Obligement - L'Amiga au maximum

Mercredi 20 septembre 2017 - 03:54  

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 : C - programmation d'une interface MUI
(Article écrit par Eric Totel et extrait d'Amiga News - juillet 1995)


MUI (Magic User Interface) est une bibliothèque qui devrait combler tous les amateurs d'interface graphique. En effet, son utilisation dans un programme permet l'élaboration rapide d'interfaces intuitives. D'autres alternatives à cette bibliothèque sont également disponibles dans le domaine public, et j'essaierai de vous en présenter quelques-unes dans de prochains articles.

Le gros avantage d'une telle bibliothèque est la possibilité de programmer très rapidement des interfaces possédant de très nombreuses caractéristiques : iconifiables, reconnues comme commodités, possédant un port ARexx. Programmer des AppWindows ou autres AppIcons devient également enfantin, même pour le débutant. La réalisation d'une interface s'appuie sur la création des objets graphiques. Ces objets sont organisés sous la forme d'un arbre. L'objet Application constitue la racine de l'arbre : ses fils immédiats sont les fenêtres, qui contiennent à leur tour des groupes et autres objets. MUI s'appuie sur une notion d'encapsulation hiérarchique des objets : tout objet est contenu dans un groupe d'objets dont l'orientation est soit horizontale, soit verticale.

Ainsi, pour créer une rangée de boutons sous une chaîne, on utilisera le schéma suivant :

            Application
                Fenêtre
                    Groupe Vertical
                            Chaîne
                            Groupe Horizontal
                                Bouton1
                                Bouton2
                        Fin Groupe Horizontal
                    Fin Groupe Vertical
                Fin Fenetre
            Fin Application

Maintenant, mettons en oeuvre tout ceci. La création d'une application telle que celle présentée ci-dessus se présente sous la forme :

        /* Déclaration des objets */
        APTR App, MyWindow, BT_Hide, BT_Quit, STR_String;
        App = ApplicationObject,
            MUIA_Application_Title, "Essai",
            MUIA_Application_Author, "Amiga News",
            MUIA_Application_Base, "ESSAI",
            MUIA_Application_Copyright, "Amiga News",
            MUIA_Application_Description, "Un exemple d'application MUI",
            MUIA_Application_Version, "$VER: ExempleV1.0 (24/05/95)",  
                SubWindow, MyWindow = WindowObject,
                    MUIA_Window_Title, "Essai",
                    WindowContents, VGroup,
                        Child, STR_String = String("Texte", 80),
                        Child, HGroup,
                            Child, BT_Hide = SimpleButton("_Cacher"),
                            Child, BT_Quit = SimpleButton("_Quitter"),
                    End,
                End,
            End,
        End;

Ici, un certain nombre d'explications s'imposent. Les constantes MUIA_xxx correspondent à des attributs que l'on désire modifier, et dont la liste est présente dans les autodocs de MUI et dans le fichier "mui.h". ApplicationObject, WindowObject, Text() et KeyButton() sont des macros permettant la création des objets. A la création d'un objet, tous ses attributs possèdent des valeurs par défaut : on ne les modifie que si cela s'avère nécessaire.

Avant de continuer dans le déroulement du programme, il est nécessaire de vérifier que la création de l'interface s'est correctement déroulée. Pour cela, un simple test suivi d'un message d'erreur pour prévenir l'utilisateur fera parfaitement l'affaire :

        if (!App)
            {
            printf("Impossible de créer l'application");
            exit(20);
        }

Une application réalisée avec MUI, au même titre d'ailleurs que la plupart des interfaces graphiques actuelles, est fondée sur l'échange de messages, et l'appel de fonctions attachées à des événements. Ces messages sont de deux types : soit ils sont dirigés vers l'application, soit ils le sont vers un objet de l'interface. Je vous propose de créer un message de chaque type, de manière à illustrer cette phrase légèrement obscure. La création des messages s'effectue par l'intermédiaire de la fonction DoMethod() :

/*
* Création d'une notification:
* Lorsque le bouton 'Hide' est relaché, le gadget chaîne est caché
*/
DoMethod(BT_Hide,               /* Objet responsable de l'evenement*/           MUIM_Notify, MUIA_Pressed, FALSE,  
                                /* Description de l'evenement              */
          STR_String,           /* Objet destination                       */
          2,                    /* Nombre de parametres decrivant l'action */
          MUIM_Show, FALSE      /* Action executee sur l'objet destination */
          );
/*
 * Creation d'une notification
 * Lorsque le bouton 'Quitter' est relaché, on dit a l'application 
* de quitter en lui renvoyant
 * L'identificateur MUIV_Application_ReturnID_Quit
 */
DoMethod(BT_Quit, MUIM_Notify, MUIA_Pressed, FALSE, App, 2, MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit);

La première notification relie deux objets de l'interface : MUI se charge donc de traiter l'événement et l'action décrits. Par contre, dans le deuxième cas, on renvoie un identificateur à notre application : il nous incombe donc de capter ce retour, et de le gérer. Ceci se réalise à l'intérieur d'une boucle, que vous devez écrire dans votre programme :

while(running)
{
    switch (DoMethod(App->App,MUIM_Application_Input,&signal))
    {
            case MUIV_Application_ReturnID_Quit:
            running = FALSE; /* On sort de la boucle : fin de l'application */
            break;
    }
      if (running && signal) Wait(signal);
}

Cette boucle doit normalement reconnaître tous les identificateurs qui lui sont renvoyés (ici, un seul) et traiter l'événement.

Avant de quitter l'application, nous devons libérer la mémoire en détruisant les éléments de l'interface graphique. Ceci se réalise en une seule instruction :

    MUI_DisposeObject(App);

Nous avons donc écrit une application MUI ! Je vous laisse cogiter, et examiner le source complet. La prochaine fois, vous aurez droit à une description d'un certain nombre d'objets disponibles.

/**********************************
 * Exemple Simple d'interface MUI *
 **********************************/

/* Includes necessaires à la compilation */
#include 
#include 
#include 

#include 
#include 

#include 
#include 

/* Structure pour l'ouverture de la bibliotheque MUI */
struct Library * MUIMasterBase = NULL;

/***********************
 * Fonction Principale *
 * Interface MUI       *
 ***********************/
int main(void)
{
  BOOL running = TRUE;
  ULONG signal;
  /* Declaration des objets */
  APTR App, MyWindow, BT_Hide, BT_Quit, STR_String;

  /* Ouverture de la bibliothèque MUI */
  if (!(MUIMasterBase = OpenLibrary(MUIMASTER_NAME,MUIMASTER_VMIN)))
    {
      printf("Impossible d'ouvrir la muimaster.library V%d\n", MUIMASTER_VMIN);
      exit(20);
    }
  
  /* Creation de l'interface */
  App = ApplicationObject,
    MUIA_Application_Title, "Essai",
    MUIA_Application_Author, "Amiga News",
    MUIA_Application_Base, "ESSAI",
    MUIA_Application_Copyright, "Amiga News",
    MUIA_Application_Description, "Un exemple d'application MUI",
    MUIA_Application_Version, "$VER: ExempleV1.0 (24/05/95)",  
      SubWindow, MyWindow = WindowObject,
    MUIA_Window_Title, "Essai",
        WindowContents, VGroup,
          Child, STR_String = String("Texte", 80),
          Child, HGroup,
            Child, BT_Hide = SimpleButton("_Cacher"),
            Child, BT_Quit = SimpleButton("_Quitter"),
        End,
      End,
    End,
  End;
  
  /* Tout s'est bien passe a la creation de l'interface ? */
  if (!App)
    {
      printf("Impossible de créer l'application\n");
      CloseLibrary(MUIMasterBase);
      exit(20);
    }
  
  /*
   * Création d'une notification :
   * Lorsque le bouton 'Hide' est relaché, le gadget chaîne est caché
   */
  DoMethod(BT_Hide,                           /* Objet responsable de l'evenement        */
       MUIM_Notify, MUIA_Pressed, FALSE,  /* Description de l'evenement              */
       STR_String,                        /* Objet destination                       */
       3,                                 /* Nombre de parametres decrivant l'action */
       MUIM_Set, MUIA_ShowMe, FALSE       /* Action executee sur l'objet destination */
       );
  
  /*
   * Création d'une notification
   * Lorsque le bouton 'Quitter' est relaché, on dit a l'application de quitter en lui renvoyant
   * L'identificateur MUIV_Application_ReturnID_Quit
   */
  DoMethod(BT_Quit, MUIM_Notify, MUIA_Pressed, FALSE, App, 2, MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit);
  
  /* Ouverture de la fenetre */
  set(MyWindow, MUIA_Window_Open, TRUE);

  /* Boucle IDCMP                                            */
  /* On récupère les évènements on provenance de l'interface */
  while(running)
    {
      switch (DoMethod(App,MUIM_Application_Input,&signal))
    {
    case MUIV_Application_ReturnID_Quit:
      running = FALSE; /* On sort de la boucle : fin de l'application */
      break;
    }
      if (running && signal) Wait(signal);
    }
  
  /* Liberation de la memoire */
  MUI_DisposeObject(App);
  /* Fermeture de la bibliotheque */
  CloseLibrary(MUIMasterBase);
  exit(0);
}


[Retour en haut] / [Retour aux articles] [Article suivant]