8. Interfaces-utilisateur graphiques (GUI)

msg={'Message d''information', 'sur plusieurs lignes'};
msgbox(msg, 'Titre fenetre', 'none'); 

Le premier paramètre msg peut être une chaîne simple (qui sous Octave peut contenir \n pour générer un saut à la ligne) ou un vecteur cellulaire de chaînes (chaque élément étant alors affiché dans la fenêtre sur une nouvelle ligne).
Le 3e paramètre peut être 'warn', 'help' ou 'error' (=> affichage d'une icône dans la fenêtre), ou être ignoré ou valoir 'none' (=> pas d'icône).

Un 4e paramètre mode peut être passé sous MATLAB (pas encore disponible sous Octave). Il peut avoir pour valeur :

• 'non-modal' (effet identique au fait d'omettre de ce paramètre) : La fenêtre s'affiche de façon "non modale", c'est à dire que l'exécution du programme se poursuit après l'affichage de celle-ci
  
• 'modal' : L'exécution du programme est suspendue jusqu'à ce que l'utilisateur clique sur le bouton OK
  On peut parvenir au même résultat sous Octave en faisant uiwait(msgbox(...))

msg={'Message d''avertissement', 'sur plusieurs lignes'};
warndlg(msg, 'Titre fenetre'); 

Cette fonction fournit le même résultat que msgbox(msg, titre, 'warn')

Sous MATLAB on peut passer à warndlg un 3e paramètre mode (voir remarque à ce sujet concernant msgbox)

msg={'Message d''aide', 'sur plusieurs lignes'};
helpdlg(msg, 'Titre fenetre'); 

Cette fonction fournit le même résultat que msgbox(msg, titre, 'help')

Sous MATLAB on peut passer à helpdlg un 3e paramètre mode (voir remarque à ce sujet concernant msgbox)

msg={'Message d''erreur', 'sur plusieurs lignes'};
errordlg(msg, 'Titre fenetre'); 

Cette fonction fournit le même résultat que msgbox(msg, titre, 'error')

Sous MATLAB on peut passer à errordlg un 3e paramètre mode (voir remarque à ce sujet concernant msgbox)

Cette fonction suspend l'exécution du programme et affiche une fenêtre de question. L'exécution se poursuit lorsque l'on a cliqué sur l'un des 3 boutons.

msg={'Question sur', 'plusieurs lignes'};
bouton = questdlg(msg, 'Titre fenetre','Yes') 

Avec la première forme ci-dessus, affiche en-dessous du message msg les 3 boutons Cancel, No et Yes. Le 3e paramètres (facultatif, 'Yes' dans l'exemple ci-dessus) indique quel bouton est pré-sélectionné et sera activé si l'on presse enter. Retourne sur bouton la chaîne de caractère correspondant au nom du bouton pressé.
Différence de comportement entre MATLAB et Octave si on utilise la case de fermeture de la fenêtre au lieu des boutons : MATLAB retourne une chaîne vide, Octave retourne 'Cancel'

bouton = questdlg(msg, 'Titre fenetre', ...
                'Annuler', 'Non', 'Oui', 'Annuler') 

Cette fonction suspend l'exécution du programme et affiche une fenêtre de saisie multi-champs. L'exécution se poursuit lorsque l'on a cliqué sur l'un des 2 boutons.

labels  = {'Prenom', 'Nom', 'Pays', 'Commentaire'};
li_cols = [1, 15; 1, 15; 1, 12; 2, 20];
val_def = {'', '', 'Suisse', ''};

vec_cel = inputdlg(labels, 'Titre fenetre', li_cols, val_def)

Affiche les champs de saisie étiquetés par les chaînes du vecteur cellulaire labels.

Le paramètre li_cols (facultatif, mais nécessaire si on veut passer le paramètre val_def) permet de définir la taille des champs :
• scalaire : nombre de lignes de tous les champs
• vecteur à 2 éléments [lignes, colonnes] : nombre de lignes et de colonnes de tous les champs
• vecteur (avec autant d'éléments que labels) : nombre de lignes de chaque champ
• matrice (de 2 colonnes et autant de lignes que d'éléments dans labels) : nombre de lignes et de colonnes de chaque champ
Notez que sous MATLAB le paramètre colonnes affecte non seulement la largeur du champ mais aussi la largeur d'affichage des étiquettes labels !

Le vecteur cellulaire de chaînes val_def (paramètre facultatif) permet de pré-remplir les champs par des valeurs par défaut (ici le Pays Suisse).

Lorsque l'on clique Ok, la fonction retourne les données saisies dans les différents champs sur un vecteur cellulaire de chaînes vec_cel.

Cette fonction suspend l'exécution du programme et affiche une fenêtre de sélection. L'exécution se poursuit lorsque l'on a cliqué sur l'un des 2 boutons inférieurs.

valeurs={'pommes','poires','cerises','kiwis','oranges'};
    
[sel_ind, ok] = listdlg('ListString', valeurs, ...
        'Name', 'Vos fruits', ...
        'PromptString', 'Fruits preferes :', ...
        'SelectionMode', 'Multiple', ...
        'ListSize', [100 140], ...
        'InitialValue', [1, 3], ...
        'OKString', 'J''ai choisi', ...
        'CancelString', 'Annuler');
if ok
  fprintf('Fruits choisis: ')
  for ind = 1:numel(sel_ind)
    fprintf([valeurs{sel_ind(ind)} ' '])
  end
  fprintf('\n')
end

Les paramètres d'entrée de listdlg sont définis par paire : 'mot-clé', valeur

Paramètre d'entrée obligatoire :
• 'ListString' réfère le vecteur cellulaire valeurs des éléments à afficher dans la liste

Paramètres d'entrée facultatifs :
• 'Name' définit le titre de la fenêtre
• 'PromptString' définit l'invite affichés au haut de la liste
• 'SelectionMode' peut être 'Multiple' (sélection possible de plusieurs valeurs avec ctrl-clic, mode par défaut) ou 'Single'
• 'ListSize' définit en pixels la taille [dx dy] de la zone d'affichage des valeurs
• 'InitialValue' réfère un vecteur contenant les indices dans valeurs des éléments qui seront présélectionnés ;
    en l'absence de ce paramètre ou si on spécifie [] :
    sous Octave : aucun élément n'est présélectionné
    sous MATLAB : le premier élément est présélectionné ( un bug dans le cas où l'on définit explicitement [])
• 'OKString' permet de redéfinir le texte du bouton Ok
• 'CancelString' permet de redéfinir le texte du bouton Cancel

Paramètres de sortie :
• sel_ind est un vecteur ligne contenant les indices des éléments de valeurs que l'on a sélectionnés
• ok retourne 1 si on a cliqué Ok, et 0 si on a cliqué Cancel

choix = menu('Titre', 'element1','element2',...) ou

v_cel = {'element1','element2',...} puis choix = menu('Titre', v_cel)

Implémente un menu retournant dans choix le numéro d'ordre de l'élément sélectionné :

• MATLAB : ce menu apparaît sous forme d'une fenêtre dans laquelle chaque élement fait l'objet d'un bouton (voir figure de gauche ci-contre). Il suffit de cliquer sur un bouton pour refermer la fenêtre et continuer l'exécution du programme.

• Octave : Sous Octave ≥ 4.0, ce menu est implémenté par une fenêtre analogue à celle de la fonction listdlg (voir figure de droite ci-contre). Le bouton Select All est désactivé. Il faut sélectionner l'élément désiré puis cliquer sur Ok pour refermer la fenêtre et continuer l'exécution du programme.

Si vous souhaitez implémenter un choix permettant de sélectionner plusieurs éléments, utilisez la fonction listdlg présentée plus haut.

handle = waitbar(fraction {,'texte'} )

Affiche une barre de progression ("thermomètre") de longueur définie par le paramètre fraction dont la valeur doit être comprise entre 0.0 (barre vide) et 1.0 (barre pleine). On utilise par exemple cette fonction pour faire patienter l'utilisateur en lui indiquant la progression d'un traitement d'une certaine durée.
Cette barre se présente sous la forme d'une fenêtre graphique que l'on pourra refermer avec close(handle). Attention, seul le 1er appel à waitbar peut contenir le paramètre texte (qui s'affichera au-dessus de la barre), sinon autant de fenêtre seront crées que d'appels à cette fonction !

barre = waitbar(0,'Patientez...');
for k=1:50
   pause(0.1)
     % pour les besoins de l'exemple, on
     %    fait ici une pause en lieu et
     %    place d'autres instructions...
   waitbar(k/50)
end
close(barre) 

a) structure = uisetfont();
b) uisetfont(h {, 'Titre'});

a) Affiche une fenêtre modale de sélection de police de caractères. Une fois que l'utilisateur a fait sa sélection, retourne sur la variable structure ce qui a été choisi, avec les champs FontName (nom de la police), FontWeight ('normal' ou 'bold'), FontAngle ('normal' ou 'italic'), FontUnits ('points'), FontSize (taille)

b) Permet de modifier interactivement la fonte/style/taille de l'objet (de type: text, axes, uicontrol) spécifié par son handle h. On peut optionnellement changer le Titre de cette fenêtre de dialogue.

hm = uimenu({dlg,} 'label','texte' {, 'accelerator','car'} {, 'property',value ...} );

Ajoute, dans la fenêtre dlg (ou la fenêtre courante si dlg n'est pas spécifié), le menu avec le libellé texte indiqué. On pourra déplier ce menu avec la souris ou le raccourci clavier alt-car.
Inséré à l'intérieur du texte du menu, le caractère & désigne à sa droite le caractère qui sera souligné lorsque l'on frappe alt. Cela permet de mettre en évidence les raccourcis des entrées principales des menus.

uimenu(hm, 'label','article' {, 'accelerator','car'} , 'callback',callback {, 'property',value ...} )

Ajoute l'article de menu spécifié dans le menu hm. Le choix de cet article par l'utilisateur ou l'usage du raccourci clavier ctrl-car activera le callback.
Parmi les propriétés intéressantes, mentionnons :

• 'enable','off|on' : désactive (grise) ou réactive l'article de menu
• 'separator','on|off' : ajoute ou enlève une ligne de séparation au-dessus de l'article
• 'checked','on|off' : ajoute ou enlève le caractère "vu" à gauche de l'article

m1 = uimenu('label','&Fichier', 'accelerator','f'); % => alt-f
uimenu(m1, 'label','Quitter', 'accelerator','q', ...
        'callback','close');  % => ctrl-q

alt-f affiche :  

a) hcm = uicontextmenu({dlg,});
b) uimenu(hcm, 'label','article1', 'callback',callback1)
    uimenu(hcm, 'label','article2', 'callback',callback2)
c) set(dlg, 'uicontextmenu', hcm);

a) et c) Met en place un menu contextuel dans la fenêtre dlg (ou la fenêtre courante), c'est-à-dire le menu apparaissant avec clic-droite
b) Ajoute l'article spécifié dans ce menu. Le choix de celui-ci par l'utilisateur activera le callback.

Ce menu contextuel change la colormap de la fenêtre de figure :

dlg = dialog('name','Titre', 'windowstyle','normal');
cm = uicontextmenu(dlg);
uimenu(cm, 'label','Hot',    'callback','colormap(hot)')
uimenu(cm, 'label','Winter', 'callback','colormap(winter)')
set(dlg, 'uicontextmenu',cm);

a) dlg = figure('toolbar','none')
b) htb = uitoolbar(dlg)

a) Suppression de toutes les éventuelles toolbars existantes de la fenêtre dlg.
b) Mise en place d'une nouvelle toolbar vide dans la fenêtre dlg. Le cas échéant elle prend place en-dessous des toolbars existantes.

Avec set(htb, 'visible','off|on'), on peut après coup masquer ou faire réapparaître cette toolbar.

hb = uipushtool(htb, 'cdata',icon {, 'tooltipstring','texte'}, 'clickedcallback',callback);

Insère un bouton dans la toolbar htb, le cas échéant à la suite (à droite) des boutons existants. Survoler le bouton avec la souris fait apparaître le "tooltip" texte. Cliquer sur le bouton activera le callback.

L'apparence du bouton est définie par un tableau 3D icon de dimension hauteur x largeur x 3 représentant une image de hauteur x largeur pixels par leurs 3 composantes RGB. Noter que largeur et hauteur semblent ne pas devoir dépasser 16 pixels. Si l'on désire utiliser une image provenant d'un fichier, il faudra la lire avec imread, puis la convertir en fichier-image RGB avec ind2rgb, puis éventuellement la resizer avec imresize[O: image].

Avec 'separator','on' on peut ajouter à gauche du bouton un séparateur vertical.
Avec set(hb, 'visible','off|on') on peut après coup masquer ou faire réapparaître le bouton hb.

ht = uitoggletool(htb, 'cdata',icon, 'clickedcallback',cback_clic, 'oncallback',cback_on, 'offcallback',cback_off);

Insère dans la toolbar htb (le cas échéant à droite des boutons existants) un bouton à bascule, c'est-à-dire qui passe à chaque clic de l'état relâché (off) à l'état pressé (on) et vice versa. Chaque clic par l'utilisateur active le callback cback_clic. En plus lorsque le bouton passe à l'état pressé le callback cback_on est activé, et lorsqu'il est relâché c'est le callback cback_off qui est activé.

Mêmes remarques que pour uipushtool concernant l'icon, et l'on peut aussi utiliser les propriétés 'tooltipstring' et 'visible'.

hc = uicontrol({dlg|hp,} 'style','style', 'position',position {, 'units','unites'} {, 'callback',callback} {'property',value ...} );

Le contrôle graphique spécifié par son style est inséré dans la fenêtre courante, ou dans celle spécifiée par dlg, ou dans le "panel" hp spécifié.
Il est placé à la position spécifiée définie par défaut en pixels. Il est possible de travailler dans d'autres unités en spécifiant : 'units', 'normalized | pixels | points | characters | centimeters | inches'. Les "unités normalisées" (voir plus haut) sont intéressantes en ce sens qu'elles sont indépendantes de la taille de la fenêtre.
Si l'on omet de définir un style, c'est un contrôle graphique de type pushbutton qui est dessiné.

Parmi les properties communes à tous les contrôles graphiques, citons :
- 'tooltipstring','texte' : affiche le texte spécifié quand le curseur survole le contrôle graphique
- 'visible','off|on' : masque ou rend visible le contrôle graphique
- 'enable','off|on' : désactive le contrôle graphique (qui est alors grisé) ou le réactive
- 'string','texte', 'fontsize',taille : texte associé au contrôle graphique et sa taille (par défaut en "points")
  'foregroundcolor',couleur : couleur du texte du contrôle graphique
- 'backgroundcolor',couleur : couleur de fond du contrôle graphique
Les properties spécifiques à chaque style sont précisées ci-dessous.

On distingue les contrôles graphiques suivants selon la valeur de l'attribut style :

'style','pushbutton', 'string','texte', 'position',[x1 y1 dx dy] → ex 1

Affiche un bouton texte à l'emplacement x1 y1 et de taille dx dy.
Pour définir une action qui serait exécutée lorsqu'on frappe une touche clavier, typiquement un "bouton par défaut" invoqué par la touche enter, définir un callback 'KeyPressFcn' global pour la fenêtre GUI (figure ou dialog). Cela est illustré par l' ex "exemple_callback" plus haut.

'style','togglebutton', 'string','texte', 'position',[x1 y1 dx dy], 'value','0|1' → ex 2

Affiche un bouton à bascule texte qui passe à chaque clic de l'état enfoncé ("On", où la propriété 'value' est à 1) à l'état relâché ("Off", où celle-ci est à 0) et vice versa.

'style','text', 'string','texte', 'position',[x1 y1 dx dy], ...
    'horizontalalignment','center|left|right', 'verticalalignment','middle|top|bottom' → ex 3

Affiche le texte spécifié à la position x1 y1, positionné par défaut de façon centrée sur la largeur dx et la hauteur dy.
Voir par ailleurs les propriétés 'fontsize', 'foregroundcolor', 'backgroundcolor' ci-dessus.

'style','edit', {'string','texte',}, 'position',[x1 y1 dx dy], 'horizontalalignment','center|left|right' → ex 3

Affiche un champ de saisie de texte à l'emplacement x1 y1 et de taille dx dy. Le contenu initial peut être défini avec la propriété 'string'

'style','popupmenu', 'string',cell_text, 'position',[x1 y1 dx dy] → ex 4

Affiche un menu déroulant à l'emplacement x1 y1 et de taille dx dy. Le libellé des articles du menu est défini par un tableau cellulaire de chaînes cell_text. Avec le callback, on récupère sur la propriété 'value' le numéro de l'article de menu qui a été choisi par l'utilisateur.

'style','listbox', 'string',cell_text, 'max',max, 'position',[x1 y1 dx dy] → ex 5

Affiche une boîte de sélection dans une liste. Analogue au popupmenu ci-dessus, sauf que la liste est ici dépliée et que l'on peut faire une sélection multiple (discontinue par ctrl-clic, ou continue par maj-clic) si max est supérieur à 1. Avec le callback, on récupère sur la propriété 'value' un vecteur contenant les numéros des éléments qui ont été sélectionnés par l'utilisateur.

'style','checkbox', 'string','texte', 'value','0|1', 'position',[x1 y1 dx dy] → ex 6

Affiche une boîte à cocher suivie du texte spécifié, à l'emplacement x1 y1 et dans un espace de taille dx dy. L'état initial de la boîte est défini par la propriété 'value' : décochée avec 0, et cochée avec 1.

'style','radiobutton', 'string','texte', 'value','0|1', 'position',[x1 y1 dx dy] → ex 8

Affiche un bouton radio. Pour le reste, strictement identique à la checkbox ci-dessus. Pour faire en sorte que, dans un groupe de boutons radio, le clic de l'un désactive les autres, voir la fonction uibuttongroup plus bas.

'style','slider', 'min',vmin, 'max',vmax, 'value',val, 'position',[x1 y1 dx dy] → ex 7

Affiche un curseur à l'emplacement x1 y1 et de taille dx dy. La position de gauche du bouton du curseur correspond à la valeur vmin, celle de droite à la valeur vmax. La position initiale du bouton est définie par val, et c'est donc sur la propriété 'value' que le callback récupère la position choisie par l'utilisateur.

'style','frame'

Analogue aux fonctions uipanel ou uibuttongroup présentées ci-dessous et qu'il est préférable d'utiliser → ex 9

uicontrol('style','pushbutton', 'string','Oui', ...
    'position',[10  10  50 30], 'callback','disp(''oui'')');
uicontrol('style','pushbutton', 'string','Non', ...
    'position',[70  10  50 30], 'callback','disp(''non'')');
uicontrol('style','pushbutton', 'string','Quitter', ...
    'position',[150 10 100 30], 'callback','close', ...
    'tooltipstring','Fermer la fenetre');

Remarquez le tooltip associé au bouton Quitter

function test_togglebutton
  dialog('name','Togglebutton', 'windowstyle','normal')
  uicontrol('style','togglebutton', 'string','Off', ...
    'position',[10 380 100 30], 'value',0, ...
    'callback',@cbk_togglebutton);
end

function cbk_togglebutton(h,e)
  if get(h,'value')   % égal à 1 => true
    set(h,'string','On');  disp('on');
  else
    set(h,'string','Off'); disp('off');
  end
end

Dans cet exemple, on change le libellé du bouton selon qu'il est enfoncé (On) ou relâché (Off)

uicontrol('style','text', 'string','Nom / prenom', ...
    'position',[10 380 100 30], ...
    'foregroundcolor', 'b', 'backgroundcolor','w', ...
    'fontangle','italic', 'horizontalalignment','left');

uicontrol('style','edit', 'string','...', ...
    'position',[120 380 180 30], 'horizontalalignment','left');

function test_popupmenu
  liste={'Suisse','France','Italie','Allemagne','Espagne', ...
    'Belgique','Luxembourg','Portugal'};
  uicontrol('style','popupmenu', 'string',liste, ...
    'position',[10 380 100 30], 'callback', @cbk_popupmenu);
end

function cbk_popupmenu(h,e)
  menu_itemms = get(h,'string');
  disp(menu_itemms{get(h,'value')})
end

function test_listbox
  liste={'Suisse','France','Italie','Allemagne','Espagne', ...
    'Belgique','Luxembourg','Portugal'};
  uicontrol('style', 'listbox', 'string',liste, 'max',2, ...
    'position',[10 250 100 160], 'callback', @cbk_listbox);
end

function cbk_listbox(h,e)
  disp(get(h,'value'))
end

function test_checkbox
  for k=1:5; 
    hcb(k)=uicontrol('style','checkbox', ...
    'string',['Article ' num2str(k)], 'value',0, ...
    'position',[10 400-20*k 100 20], 'callback',{@cbk_checkbox k});
  end
  uicontrol('style','pushbutton', 'string','Commander', ...
    'position',[10 260 100 30], 'callback',{@cbk_commande hcb});
end

function cbk_checkbox(h,e, k)
  if get(h,'value')
    status = 'on';
  else
    status = 'off';
  end
  fprintf(' article %d %s \n', k, status)
end

function cbk_commande(h,e, hcb)
  fprintf('commande articles: ')
  for k=1:5
    if get(hcb(k),'value')  % égal à 1 => true
      fprintf('%s ',num2str(k))
    end
  end
  fprintf('\n')
end

Dans cet exemple, chaque clic active le callback "cbk_checkbox". De plus le bouton Commander active le callback "cbk_commande" qui relève l'état de toutes les boîtes à cocher.

function test_slider
  uicontrol('style','text', 'string','Température', ...
    'position',[10 370 100 30]);
  uicontrol('style','slider', 'position', [130 375 250 15], ...
    'min',-10, 'max',30, 'value',0, ...
    'callback', @cbk_slider); 
end

function cbk_slider(h,e)
  disp(get(h,'value'))
end

hbg = uibuttongroup('title','texte', 'position',[x1 y1 dx dy]);

Crée un "panel" spécifique permettant de grouper et lier des boutons radios, c'est-à-dire faire en sorte que le clic de l'un désactive automatiquement les autres. Ce panel est placé en x1 y1 et a une taille dx dy, mais il faut noter que ces valeurs sont définies par défaut en "unités normalisées" (comme pour uipanel) et non pas en pixels (comme pour uicontrol) ! Un cadre est automatiquement dessiné autour de ce panel avec le titre title.

function test_uibuttongroup
  hbg = uibuttongroup('title','Sexe', ...
    'position',[.05 .65 .25 .3]);  % unités normalisées !!!
  uicontrol(hbg, 'style','radiobutton', 'string','Femme', ...
    'value',0, 'position',[10 80 100 20], 'callback',{@cbk_radio 'femme'});
  uicontrol(hbg, 'style','radiobutton', 'string','Homme', ...
    'value',0, 'position',[10 50 100 20], 'callback',{@cbk_radio 'homme'});
  uicontrol(hbg, 'style','radiobutton', 'string','N/A', ...
    'value',1, 'position',[10 20 100 20], 'callback',{@cbk_radio 'n/a'});
end

function cbk_radio(h,e, sexe)
  if get(h,'value')
    disp(sexe)
  end
end

Notez que le choix initial du bouton pressé est défini par celui qui a la propriété 'value',1, donc ici "N/A". Notez aussi que les 3 boutons étant liés (exclusifs), le clic sur l'un génère exactement 2 appels au callback : pour le passage à On de celui que l'on clique, et pour le passage automatique à Off de celui qui était à On.

hp = uipanel('title','texte', 'position',[x1 y1 dx dy], ...
    'fontsize',taille, 'foregroundcolor',coul1, 'backgroundcolor',coul2)

Dessine un "panel" en x1 y1 et de taille dx dy, ces valeurs étant par défaut exprimées en "unités normalisées" et non pas en pixels (comme pour uicontrol) ! Un cadre est dessiné autour de ce panel avec le titre texte dans la taille spécifiée. On peut optionnellement spécifier les couleurs coul1 du texte et coul2 du fond.

Un "panel" n'est donc rien d'autre qu'un élément décoratif de GUI permettant de regrouper esthétiquement les contrôles graphiques. On peut imbriquer des panels les uns dans les autres de façon hiérarchiquee.

uicontrol('parent',hp, 'style','style', 'position',[x1 y1 dx dy] ...)   ou plus simplement :
uicontrol(hp,          'style','style', 'position',[x1 y1 dx dy] ...)

Place un contrôle graphique dans un (sous-)panel.
Attention : il faut noter que dans ce cas les coordonnées x1 y1 se réfèrent à l'angle inférieur gauche du panel et non pas de la figure !

dialog('name','Exemple de uipanel', 'windowstyle','normal')

hp  = uipanel('title','Panel principal', 'position',[.1 .1 .8 .66], ...
    'fontsize',16, 'backgroundcolor','white');

hsp1= uipanel(hp,'title','Sous-panel 1', 'position',[.1 .1 .4 .4], ...
    'fontsize',12, 'backgroundcolor','y');  % sous-panel du panel hp
hsp2= uipanel(hp,'title','Sous-panel 2', 'position',[.6 .1 .3 .4], ...
    'fontsize',12, 'backgroundcolor','c');  % sous-panel du panel hp

uicontrol(hsp1,'string','Fermer', 'position',[15 15 80 30], ...
    'callback','close');   % bouton dans le sous-panel 1
uicontrol('style','text', 'string','Exemple uipanel', ...
    'units','normalized', 'position', [.1 .85 .8 .1], ...
  'foregroundcolor', 'w', 'backgroundcolor',[.4 .4 .4], ...
  'horizontalalignment','center', 'fontangle','italic', ...
  'fontsize',20);          % texte en-dehors des panels

htab = uitable({dlg,} 'Data', tableau {,'property',value ...} )

Affiche, dans la fenêtre dlg et sous forme de table, les données de tableau, et récupère le handle htab de cet objet.

La variable tableau doit être de type numérique ou cellulaire, et de dimension 1D (vecteur) ou 2D (matrice).
Si l'on omet dlg, le tableau est affiché dans la fenêtre de figure courante. Si aucune fenêtre de figure n'existe, une fenêtre est créée.

Parmi les properties disponibles, on peut mentionner :
- 'ColumnName', 'numbered'|vec_cel : en-têtes de colonnes numérotées incrémentalement (défaut), ou selon les données spécifiées dans vecteur cellulaire vec_cel
- 'RowName', 'numbered'|vec_cel : en-tête de lignes numérotées incrémentalement (défaut), ou selon les données spécifiées dans vecteur cellulaire vec_cel
- 'ColumnWidth', 'auto'|vec_cel : largeur des colonnes automatique (défaut), ou selon les données spécifiées dans vecteur cellulaire vec_cel en pixels
- 'ForegroundColor',couleur : couleur du texte, spécifiés sous forme de nom de couleur (tel que 'r') ou de triplet RGB (tel que [1 0 0]), par défaut noire
- 'BackgroundColor',mat2x3 : couleur de l'arrière plan des cellules en alternance lignes impaires (mat2x3(1,:)) et lignes paires (mat2x3(2,:)) ; par défaut [1 1 1;.94 .94 .94]
- 'Position',[x1 y1 dx dy] : en pixels : dimension (largeur dx, hauteur dy), et position de la table (x1 et y1) par rapport à angle inférieur gauche de la fenêtre

Faire get(htab) pour découvrir les autres propriétés disponibles, notamment celles permettant l'interaction avec le tableau.

personnes={
  'Jules','Dupond',24
  'Albertine','Durand',30
  'Robert','Muller',28
} ;
entete_col={'Prenom', 'Nom', 'Age'} ;
coul_alternee=[1  1  1 ; 1  1 .8] ;

dlg = figure('name','Utilisateurs', 'menubar','none', ...
  'numbertitle','off', 'position',[10 10 350 200]) ;
movegui(dlg,'west')

htab=uitable(dlg, 'Data',personnes, ...
  'ColumnName',entete_col, ...
  'ColumnWidth',{120 120 30}, ...
  'ForegroundColor','b', ...
  'BackgroundColor',coul_alternee, ...
  'Position',[20 20 300 150] ...
) ;

a) annotation('line', [x1 x2], [y1 y2] {, 'property',value ...} )
b) annotation('arrow', [x1 x2], [y1 y2] ...)
c) annotation('doublearrow', [x1 x2], [y1 y2] ...)
d) annotation('textarrow', [x1 x2], [y1 y2] ...)

e) annotation('textbox', [x1 y1 dx dy] ...)
f) annotation('rectangle', [x1 y1 dx dy] ...)
g) annotation('ellipse', [x1 y1 dx dy] ...)

Habille une fenêtre de dialogue (ou figure) avec un élément graphique de type :
a) ligne
b) flèche
c) double flèche
d) texte associé à une flèche
e) boîte avec du texte
f) rectangle
g) ellipse

L'annotation est positionnée aux coordonnées figure x1 et y1. Elle s'étend jusqu'à x2 et y2, ou a la dimension dx et dy. Ces valeurs sont exprimées par défaut en "unités normalisées" (voir plus haut) et non pas en pixels. On peut changer d'unités avec la property 'units', 'pixels | normalized | points | characters | centimeters | inches'.
Attention : notez que si vous placez une annotation dans un graphique, celle-ci est fixe par rapport à la fenêtre et ne "bouge" donc pas si l'on fait un pan/zoom/rotation du graphique.

dialog('name', 'Exemple d''annotations', ...
    'WindowStyle', 'normal') % dialogue non "modal"
% ou commande "figure"

annotation('line', [.5 .9], [.1 .6], 'color','b', ...
    'linewidth',4, 'linestyle',':')
annotation('arrow', [.2 .4], [.9 .6], 'color',[0 .5 0], ...
    'linewidth',3, 'linestyle','--')
annotation('doublearrow', [.35 .6], [.45 .45], ...
    'color','g', 'linewidth',3, 'linestyle','-')
annotation('textarrow', [.7 .6], [.8 .6], ...
    'string','annotation')
annotation('textbox', [.5 .5 0 0], 'string', 'Hello !', ...
    'fontsize',30, 'horizontalalignment','center', ...
    'color','r', 'edgecolor','none', 'backgroundcolor','none')
annotation('rectangle', [.15 .1 .25 .2],'facecolor',[1 1 0], ...
    'edgecolor',[.5 .5 0],'linewidth',6, 'linestyle','-')
annotation('ellipse', [.8 .1 .1 .3], ...
    'facecolor',[.8 .8 1],'edgecolor','none')