Suivez-nous sur X
|
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z,
ALL
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z
|
|
A propos d'Obligement
|
|
David Brunet
|
|
|
|
Programmation : C - programmation d'une interface MUI : les objets
(Article écrit par Eric Totel et extrait d'Amiga News - septembre 1995)
|
|
Les objets disponibles dans cette bibliothèque sont particulièrement nombreux. Je vais essayer d'en faire une description
succincte (tous les attributs de tous les objets ne seront pas décrits). Les descriptions complètes sont disponibles, d'une part
dans les autodocs de MUI, et d'autre part dans le fichier "mui.h".
Application
L'application est à la fois l'objet racine de votre interface et le point d'entrée de tous les échanges que votre programme aura
l'occasion de gérer, que ce soit avec le système (commodités, ARexx) ou avec l'utilisateur par l'intermédiaire des événements
qu'il engendre. Quelques attributs usuels peuvent être cités ici :
MUIA_Application_Title (char *) : Titre de votre application
MUIA_Application_Version (char *)
: Chaîne de version (ex : "$VER:
MonApplication (28/05/95)")
MUIA_Application_Author (char *) : Chaîne donnant le nom de l'auteur
MUIA_Application_Base (char *) : Nom de base pour le port ARexx
MUIA_Application_SingleTask (BOOL)
: impossibilité de lancer deux sessions
de ce programme
MUIA_Application_Description (char *)
: comme son nom l'indique !
|
La création de l'objet application peut être illustré par l'exemple suivant :
APTR App;
App = ApplicationObject,
MUIA_Application_Title ,"Exemple d'application",
MUIA_Application_Version ,"$VER: Exemple 1.0 (06.06.95)",
MUIA_Application_Copyright ,"Copyright AmigaNews ©1995",
MUIA_Application_Author ,"Amiga News",
MUIA_Application_Description ,"Un simple exemple",
MUIA_Application_Base ,"EXEMPLE",
MUIA_HelpFile ,"Exemple.guide",
MUIA_Application_Menustrip , MenustripObject, ... End,
SubWindow, WindowObject,
...
End,
End;
|
Fenêtre
La fenêtre est l'objet principal de l'interface, et peut prendre diverses formes, décrites grâce aux valeurs de ses attributs,
dont voici quelques exemples :
MUIA_Window_AppWindow (BOOL)
: déclare la fenêtre comme AppWindow si mis à TRUE
MUIA_Window_BackDrop (BOOL)
: colle la fenêtre en fond d'écran si mis à TRUE
MUIA_Window_Borderless (BOOL)
: pas de bord si mis à TRUE
MUIA_Window_CloseGadget (BOOL)
: pas de gadget de fermeture si mis à FALSE
MUIA_Window_DepthGadget (BOOL)
: pas de gadget de profondeur si mis à FALSE
MUIA_Window_SizeGadget (BOOL)
: pas de gadget de taille si mis à FALSE
MUIA_Window_Open (BOOL)
: si mis à TRUE, la fenêtre est ouverte
|
Exemple :
ma_fenetre = WindowObject,
MUIA_Window_SizeGadget, FALSE, /* pas de gadget de taille */
MUIA_Window_RootObject, VGroup, /* objet racine = groupe vertical */
Child, ...,
Child, ...,
End,
End;
|
Groupes
L'objet "Groupe" permet l'organisation des objets dans les fenêtres. Chaque groupe contient un ou plusieurs objets (dont des groupes)
qui sont organisés suivant les valeurs de ses attributs :
MUIA_Group_Horiz (BOOL)
: si TRUE, alors le groupe est disposé horizontalement
MUIA_Group_Columns (ULONG)
: nombre de colonnes dans le groupe (1 par défaut)
MUIA_Group_PageMode (BOOL)
: si TRUE, chaque fils est présenté sur une page différente
: à vous de créer les gadgets permettant de passer d'une
page à l'autre (en modifiant MUIA_Group_ActivePage).
|
Exemple :
mon_groupe = GroupObject, /* Groupe horizontal contenant deux boutons */
MUIA_Group_Horizontal, TRUE,
MUIA_Group_Child, SimpleButton("Bouton _1"),
MUIA_Group_Child, SimpleButton("Bouton _2"),
End;
|
Il faut noter également la présence d'un type de groupe différent : le RegisterGroup, qui se comporte exactement comme un groupe
en PageMode, mais auquel est associé un gadget permettant de passer d'un fils à l'autre. Celui-ci se présente soit comme un cycle,
soit comme de superbes onglets. Dans les deux cas, on doit lui fournir les noms des différentes pages sous forme d'un tableau
de pointeurs se terminant par la valeur NULL.
Exemple :
char * Titles[] =
{ /* Il doit y avoir autant de titres que de fils au groupe */
"Page 1",
"Page 2",
NULL
}
mon_groupe = RegisterGroup(Titles),
Child, ...,
Child, ...,
End;
|
Menus
Un menu peut être attaché soit à l'application (dans ce cas toute fenêtre ne possédant pas de menu propre se verra associer ce
dernier), soit spécifiquement à une fenêtre, et ceci en positionnant respectivement les attributs MUIA_Application_Menustrip ou
MUIA_Window_Menustrip (Object*).
Un menu se compose d'un objet MenustripObject encapsulant tous les menus principaux, ceux-ci contenant les sous-menus et les
items élémentaires.
Object *mon_menu;
mon_menu = MenustripObject, /* Création de l'encapsulation des menus */
MUIA_Family_Child, MenuitemObject, /* Menu Projet */
MUIA_Menuitem_Title, "Projet",
MUIA_Family_Child, MenuitemObject, /* Item "Ouvrir" */
MUIA_Menuitem_Title, "Ouvrir",
MUIA_Menuitem_Shortcut, 'o',
End,
MUIA_Family_Child, MenuitemObject, /* Sous-Menu */
MUIA_Menuitem_Title, "Mon Sous-Menu",
MUIA_Family_Child, MenuitemObject, /* Item du sous-menu */
MUIA_Menuitem_Title, "Element 1",
MUIA_Menuitem_Shortcut, '1',
End,
End,
End,
End;
|
Objets de types textes : Boutons, Labels
Pour créer un texte, il suffit d'utiliser les macros Label ou KeyLabel, cette deuxième assurant la visualisation d'un raccourci
clavier :
Exemple :
Label("Essai");
KeyLabel("Essai", 'e');
|
Les boutons sont des objets textes ayant la propriété d'être sélectionnables à la souris. Ils peuvent être créés à l'aide des
macros suivantes :
Exemple :
mybutton = SimpleButton("Cancel") ; /* pas de raccourci clavier */
kbutton = KeyButton("Cancel", 'c') ; /* dans tous les cas suivants raccourci = 'c' */
kbutton2 = MUI_MakeObject(MUIO_Button, "_Cancel");
kbutton3 = SimpleButton("_Cancel");
|
Il est à noter que les textes entrés dans ces objets peuvent prendre des formes diverses, et en particulier contenir des chaînes
au "style C" contenant des caractères d'échappement (tel "\033b" qui permet d'obtenir des caractères gras).
Gadget chaîne
Ce gadget permet l'entrée d'une chaîne de caractères au clavier. On peut le créer en utilisant :
Exemple :
String("Essai", 80)
; /* Chaîne de contenu initial "Essai" et de longueur maximale 80 */
KeyString("Essai", 80, 'e')
; /* Même chose, mais raccourci clavier d'activation 'e' */
|
Gadgets Cycle et Radio
Le but de ces deux objets est de proposer à l'utilisateur le choix d'une option parmi plusieurs. Dans chacun des deux cas, il faut
fournir au gadget une liste de pointeurs sur des chaînes, celles-ci apparaissant à l'écran.
Exemple :
char * Entries[] = /* définit les entrées du cycle ou radio */
{
"Choix 1",
"Choix 2",
"Choix 3",
NULL /* Le tableau DOIT se terminer par une entrée nulle */
};
|
Exemples de créations :
* mon_cycle = Cycle(Entries) ; /* Cycle Simple */
* mon_kcycle = Cycle(Entries, 'c') ; /* Cycle avec raccourci d'activation 'c' */
* mon_radio = Radio("Choix", Entries) ; /* Radio avec "Choix" en titre */
* mon_kradio = KeyRadio("Choix", Entries, 'r') ; /* Radio avec raccourci 'r' */
|
Listes
Il s'agit de l'un des objets les plus complexes, il est composé de deux parties distinctes : l'objet List (qui permet une gestion
simple de listes) et l'objet Listview (qui permet l'affichage à l'écran de l'objet List).
De nombreux attributs peuvent être positionnés, de manière à créer une liste multicolonnes, en lecture seule, autorisant la
multisélection, etc. (Cf. MUI_List.doc).
Exemple :
ma_liste = ListviewObject, /* Liste Simple */
MUIA_Listview_List, ListObject,
InputListFrame,
End,
End;
struct Hook *DisplayHook = {{NULL,NULL},(void*)DisplayFunction,NULL, NULL};
Child, lv_group = ListviewObject, /* Liste à deux colonnes */
MUIA_Listview_DefClickColumn, 2,
MUIA_Listview_List, ListObject,
InputListFrame,
MUIA_List_Format, "COL=0 P=\033C DELTA=8, COL=1 P=\033C DELTA=8",
MUIA_List_DisplayHook, &DisplayHook,
End,
End;
|
Dans ce deuxième exemple, vous remarquerez l'utilisation d'une fonction d'affichage dans la liste multicolonne. La déclaration
de cette fonction passe par la création d'un Hook (crochet en français) que je décrirai dans le prochain article.
Il existe bien d'autres objets, tels PopAsl, les objets PopUp, les images, les objets palettes... que vous découvrirez en
utilisant MUI. Mais les plus utilisés figurent ci-dessus, et devraient suffire à des besoins traditionnels.
La prochaine fois, vous aurez droit à une description des notifications et des éléments de programmation qui y sont attachés,
ce qui devrait clore cette série d'articles sur MUI.
|