Obligement - L'Amiga au maximum

Samedi 21 octobre 2017 - 23:27  

Translate

En De Nl Nl
Es Pt It Nl


Rubriques

 · Accueil
 · A Propos
 · Articles
 · Galeries
 · Glossaire
 · Hit Parade
 · Liens
 · Liste jeux Amiga
 · Quizz
 · Téléchargements
 · Trucs et astuces


Articles

 · Actualité (récente)
 · Actualité (archive)
 · Comparatifs
 · Dossiers
 · Entrevues
 · Matériel (tests)
 · Matériel (bidouilles)
 · Points de vue
 · En pratique
 · Programmation
 · Reportages
 · Tests de jeux
 · Tests de logiciels
 · Tests de compilations
 · Articles divers

 · Articles in english
 · Articles in other languages


Twitter

Suivez-nous sur Twitter




Liens

 · Sites de téléchargements
 · Associations
 · Pages Personnelles
 · Moteurs de recherche
 · Pages de liens
 · Constructeurs matériels
 · Matériel
 · Autres sites de matériel
 · Réparateurs
 · Revendeurs
 · Presse et médias
 · Programmation
 · Développeurs logiciels
 · Logiciels
 · Développeurs de jeux
 · Jeux
 · Autres sites de jeux
 · Scène démo
 · Divers
 · Informatique générale


Jeux Amiga

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


Trucs et astuces

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


Glossaire

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


Partenaires

Annuaire Amiga

Amedia Computer

Relec

Hit Parade


Contact

David Brunet

Courriel

 


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.).


[Retour en haut] / [Retour aux articles] [Article précédent] / [Article suivant]