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 : Mon premier programme MUI
(Article écrit par Mathias Parnaudeau - juillet 2004)
|
|
Chapitre 1
Comme il faut évidemment commencer par des choses simples, notre premier programme ne ressemblera pas à un lecteur
de CD. Cela vous demanderait trop de connaissances d'un seul coup ! Nous commencerons donc par voir l'organisation
du programme puis nous reviendrons sur les éléments techniques qui le composent.
Voilà les objectifs de ce chapitre :
- Découverte de la composition d'un programme MUI.
- Description de l'interface avec l'approche "macros".
- Manipulation des méthodes et attributs des objets.
Organisation du programme
Pour ce premier programme, nous allons au plus simple, aussi, en plus du traditionnel main(), nous avons une
fonction d'ouverture des bibliothèques nécessaires et une autre fonction pour leur fermeture. Sans oublier
la fonction qui nous intéresse le plus : Create_Gui(), qui gère l'interface de sa création à sa disparition.
Dans le chapitre suivant, cette organisation changera pour plus de flexibilité.
Cette fonction principale peut être découpée en plusieurs parties :
- Description hiérarchique de l'application et des composants de la fenêtre suivant le principe immuable :
déclaration d'un objet, détail de son contenu, fin de la description avec End.
- Affectation des propriétés et appel de méthodes : ajout d'une action liée au bouton de fermeture, affichage de la fenêtre.
- Boucle d'attente de fin par clic sur le bouton de fermeture ou par Ctrl-C.
- Fermeture de la fenêtre et destruction de l'interface.
Indispensable pour concrétiser tout ça... voici le source :
/*
* DisKo1.c (05/06/04)
*
*/
#include <stdio.h>
#include <libraries/mui.h>
#include <proto/intuition.h>
#include <proto/exec.h>
#include <proto/muimaster.h>
#include <clib/alib_protos.h>
struct IntuitionBase *IntuitionBase;
struct Library *MUIMasterBase;
#ifdef __amigaos4__
struct IntuitionIFace *IIntuition;
struct MUIMasterIFace *IMUIMaster;
#endif
#define MAKE_ID(a,b,c,d) ((ULONG) (a)<<24 | (ULONG) (b)<<16 | (ULONG) (c)<<8 | (ULONG) (d))
int Initialize(void)
{
int res = 1;
IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library", 39L);
MUIMasterBase = OpenLibrary(MUIMASTER_NAME, 19);
#ifdef __amigaos4__
IMUIMaster = (struct MUIMasterIFace *)GetInterface(MUIMasterBase, "main", 1, NULL);
IIntuition = (struct IntuitionIFace *)GetInterface((struct Library *)IntuitionBase, "main", 1, NULL);
res = IMUIMaster && IIntuition;
#endif
return (IntuitionBase && MUIMasterBase && res);
}
void DeInitialize(void)
{
#ifdef __amigaos4__
if (IMUIMaster) DropInterface((struct Interface *)IMUIMaster);
if (IIntuition) DropInterface((struct Interface *)IIntuition);
#endif
if (IntuitionBase)
CloseLibrary((struct Library *)IntuitionBase);
if (MUIMasterBase)
CloseLibrary(MUIMasterBase);
}
int CreateGui(void)
{
Object *app, *window;
/* Description de l'interface graphique */
app = ApplicationObject,
MUIA_Application_Title , "Titre",
MUIA_Application_Version , "$VER: 0.0.1 (05/06/04)",
MUIA_Application_Copyright , "©2004, copyright et célébrité",
MUIA_Application_Author , "L'auteur, c'est vous !",
MUIA_Application_Description, "Description libre",
MUIA_Application_Base , "DISKO",
SubWindow, window = WindowObject,
MUIA_Window_Title, "Projet DisKo : Premier programme MUI",
MUIA_Window_ID , MAKE_ID('W','I','N','1'),
WindowContents, VGroup,
Child, TextObject, TextFrame,
MUIA_Background, MUII_TextBack,
MUIA_Text_Contents, "\33c Il affiche ici du texte multiligne
dans un TextObject\navec une frame \33bTextFrame\33n",
End,
Child, TextObject, ButtonFrame,
MUIA_Background, MUII_TextBack,
MUIA_Text_Contents, "\33c Et ici un TextObject avec une frame
d'aspect \33iButtonFrame\33n\nce qui lui donne son aspect de bouton",
End,
Child, TextObject, StringFrame,
MUIA_Background, MUII_TextBack,
MUIA_Text_Contents, "\33c Et un dernier avec \33uStringFrame\33n\n
(Escape pour quitter l'application)",
End,
Child, SimpleButton("Bouton sans action"),
End,
End,
End;
if (!app){
printf("Impossible de créer l'application.\n");
return 0;
}
DoMethod(window,MUIM_Notify,MUIA_Window_CloseRequest,TRUE,
app,2,MUIM_Application_ReturnID,MUIV_Application_ReturnID_Quit);
/* Commande l'ouverture, donc l'affichage, de la fenêtre */
set(window,MUIA_Window_Open,TRUE);
/* Boucle de gestion des événements qui permet de savoir quand la fermeture
* a été demandée
*/
{
ULONG sigs = 0;
while (DoMethod(app,MUIM_Application_NewInput,&sigs) != MUIV_Application_ReturnID_Quit)
{
if (sigs)
{
sigs = Wait(sigs | SIGBREAKF_CTRL_C);
if (sigs & SIGBREAKF_CTRL_C) break;
}
}
}
set(window,MUIA_Window_Open,FALSE);
// Fermeture de la fenêtre, désallocation des ressources
MUI_DisposeObject(app);
return 1;
}
int main(int argc,char *argv[])
{
if ( Initialize() ){
CreateGui();
}else{
printf("Impossible d'ouvrir toutes les bibliothèques\n");
}
DeInitialize();
return 0;
}
|
Pour l'instant, nous ne gérons aucune communication avec les composants. Par exemple, aucun clic de souris n'a d'effet,
sauf sur le gadget de fermeture qui est un cas particulier et requiert à lui tout seul une boucle de gestion des
événements. A cette occasion, on voit apparaître par deux fois des appels à DoMethod qui permet d'appeler une
méthode (terme en programmation objet pour désigner une fonction) d'un objet donné. Son usage va vite devenir
très fréquent !
La fonction set(), quant à elle, change un attribut d'un objet. Elle représente un cas particulier de la fonction
SetAttrs() qui permet de modifier plusieurs attributs grâce aux tags système. Pour lire un attribut, il existe
bien entendu un équivalent nommé get().
Nous savons désormais comment communiquer de façon simple avec les composants MUI. La lecture du chapitre 2
permettra d'aller plus loin en se basant sur ces notions ; on pourra par exemple signifier à un bouton "appelle
telle méthode de tel objet lorsque tu es cliqué".
Description de l'interface
Maintenant que l'on a compris le fonctionnement basique d'une application MUI, nous pouvons nous intéresser
au détail des composants : leur type, leurs propriétés et la manière de les décrire pour obtenir une interface
conforme à ce que l'on attendait.
Pour ce premier projet, seuls des objets simples interviennent, de type Bouton et Texte, avec une déclinaison
en plusieurs nuances pour ce dernier. Aucun de ces objets ne propose d'interaction, cela nécessiterait des
appels à DoMethod() (souvenez-vous !).
Nous l'avons vu, chaque application se doit d'avoir une fenêtre principale qui commence elle-même par un groupe,
vertical ou horizontal, qui sert de conteneur de composants. Vous essaierez d'ailleurs de changer VGroup
en HGroup. L'ajout d'un composant repose toujours sur le même principe : déclaration d'un objet, détail de son
contenu, fin de la description avec End. MUI fonctionne massivement à base de macros. Ça explique par exemple
pourquoi le bouton créé avec SimpleButton() ne laisse pas apparaître de mot-clé End. Sinon, pour les objets de
type texte, on crée un enfant (Child) TextObjet avec son lot de couples attribut/valeur.
Le concept délicat vient de la Frame (le cadre), qui représente le support de l'objet et définit aussi son pourtour.
C'est pourquoi l'exemple fait varier le type de frame pour chacun des trois objets texte. A l'exécution du programme,
on constate l'effet du changement de frame ! Un autre aspect que l'on peut modifier, c'est l'apparence des
chaînes de caractères grâce à des balises de type \33x avec "x" déterminant la commande : gras, centré, normal,
etc. Les codes sont référencés dans <libraries/mui.h>. Au lieu de ces codes, il est possible d'utiliser
une constante équivalente : MUIX_B, MUIX_C, MUIX_N...
Remarque à propos de MAKE_ID : ce define permet de construire un entier à partir de quatre caractères (on le trouve présent
dans <libraries/iffparse.h>). Ce nombre représente un indentifiant qui servira pour la gestion des réglages
(préférences). Pour une fenêtre, on pourra ainsi affecter et conserver la disposition, la couleur de fond,
etc. Cet ensemble est sauvé dans ENVARC: dans un fichier dont le nom est la chaîne que l'on a affectée à
MUIA_Application_Base.
Un dernier conseil à propos de l'arborescence : respectez l'indentation ! C'est encore plus important ici
qu'ailleurs. Comme les macros sont omniprésentes, la négligeance dans l'écriture entraînera imanquablement
une erreur concernant une macro non terminée. Un minimum de rigueur est préférable à un maximum de prise de tête.
Appliquez donc le principe de précaution. :)
Compilation
Voici le moment tant attendu : la création de l'exécutable ! Nous rappelons ici les lignes de commandes pour
chaque compilateur. Un makefile étant préférable...
SAS/C :
sc exemple.c LINK TO exemple
GCC :
gcc -O2 -c exemple.c
gcc -noixemul -o exemple exemple.o
vbcc :
vc -c99 -c exemple.c
vc -o exemple exemple.o -lamiga
Notions acquises dans ce chapitre
- Composition d'un programme MUI.
- VGroup : les composants qu'il contient seront ajoutés verticalement, de haut en bas.
- Utilisation de la classe TextObjet et affichage d'un bouton, sans interaction.
- Fonctions set() et SetAttrs() (qui, comme GetAttrs(), proviennent de BOOPSI).
- Fonction DoMethod() pour communiquer avec les composants.
- Boucle d'attente de fermeture : c'est le seul ID qui doit être utilisé, les événements des
autres composants seront gérés d'une autre manière.
- Usage intensif des macros : SimpleButton ou TextFrame cachent en réalité un contenu plus complexe.
- Possibilité de mise en forme avec la frame et les profils d'écriture (centrage, gras, etc.).
|