home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 125.lha / Menucure / Menucure.c < prev    next >
Encoding:
C/C++ Source or Header  |  1986-11-20  |  19.9 KB  |  750 lines
  1. /*********************************************************************
  2. ***********************************************************************
  3. **                                                                   **
  4. **  Menucure.c                                                       **
  5. **                                                                   **
  6. **  Historique    Nom            Description                         **
  7. **  ----------    ------------   ----------------------------------  **
  8. **   06-05-88     Eric Le Saux   Version originale                   **
  9. **                Jean Pepin                                         **
  10. **                                                                   **
  11. ***********************************************************************
  12.  *********************************************************************/
  13.  
  14. /*********************************************************************
  15. ***********************************************************************
  16. **                                                                   **
  17. **       Club Amiga Montréal (CAM)                                   **
  18. **       C.P. 195 STATION "N"                                        **
  19. **       Montréal (Québec)                                           **
  20. **       H2X 3M2, CANADA                                             **
  21. **                                                                   **
  22. **       Je veux être propagé comme un virus !                       **
  23. **                                                                   **
  24. **       DOMAINE PUBLIC - Distribution non-commerciale               **
  25. **       PUBLIC DOMAIN  - Freely redistributable                     **
  26. **                                                                   **
  27. ***********************************************************************
  28.  *********************************************************************/
  29.  
  30. #include <Menucure.h>
  31.  
  32. /*********************************************************************
  33. ***********************************************************************
  34. **
  35. **  Comparaisons de chaînes de caractères avec wildcards.
  36. **
  37. **  Certains titres d'écrans et de fenêtres ont des parties variantes,
  38. **  pour les reconnaître, on permet l'usage de certaines wildcards.
  39. **
  40. **  '?' pour empecher la comparaison
  41. **  '#' pour arreter la comparaison
  42. **
  43. **  Retourne TRUE quand les chaînes sont identiques.
  44. */
  45.  
  46. BOOL StrCmp (S1, S2)
  47. STRPTR S1, S2;
  48. {
  49.     FOREVER
  50.     {
  51.        if ( (*S1 != '\0') && (*S1 != '\0') )
  52.        {
  53.           if ( (*S1 != '?') && (*S2 != '?') )
  54.           {
  55.              if ( (*S1 == '#') || (*S2 == '#') ) return (TRUE);
  56.  
  57.              if (*S1 != *S2) return (FALSE);
  58.           }
  59.        }
  60.        else return (*S1 == *S2);
  61.  
  62.        S1++;
  63.        S2++;
  64.     }
  65.  
  66.     return (*(S1-1) == *(S2-1));
  67. }
  68.  
  69.  
  70. /*********************************************************************
  71. ***********************************************************************
  72. **
  73. **  Copie d'une chaîne de caractères dans une autre.
  74. **
  75. **  N est la taille du buffer S1, incluant le terminateur '\0'.
  76. **  On copie jusqu'à N-1 caractères de S2 vers S1.
  77. **
  78. **  Si S2 est trop grande, l'avant-dernier caractère a être mis dans S1
  79. **  est celui de troncation : '#'.
  80. **
  81. */
  82.  
  83. void StrNCpy (S1, S2, N)
  84. UBYTE *S1, *S2;
  85. SHORT N;
  86. {
  87.     while ( --N && (*S1++ = *S2++) );
  88.  
  89.     if (!N)
  90.     {
  91.        *S1 = '\0';
  92.        *(S1-1)='#';
  93.     }
  94. }
  95.  
  96.  
  97. /*********************************************************************
  98. ***********************************************************************
  99. **
  100. **  Calcule le nombre d'occurences d'un caractère dans un fichier
  101. **
  102. */
  103.  
  104. SHORT Occurences (Fichier, Car)
  105. FILE *Fichier;
  106. UBYTE Car;
  107. {
  108.     LONG  Pos;
  109.     SHORT C;
  110.     SHORT N = 0;
  111.  
  112.     Pos = ftell (Fichier);
  113.  
  114.     while ( (C=getc(Fichier)) != EOF ) if ( C == SEP ) N++;
  115.  
  116.     fseek (Fichier, Pos, 0);
  117.  
  118.     return (N);
  119. }
  120.  
  121.  
  122. /*********************************************************************
  123. ***********************************************************************
  124. **
  125. **  Modification de la largeur d'un menu et de ses items.
  126. **
  127. */
  128.  
  129. void ChangeLargeur(Item, LargeurFonte, LargeurEcran)
  130. struct MenuItem * Item;
  131. SHORT  LargeurFonte;
  132. SHORT  LargeurEcran;
  133. {
  134.     struct MenuItem * Ptr = Item;
  135.     SHORT  Max = 0, L;
  136.     SHORT  LargeurTotale;
  137.     SHORT  CoteGauche = Item->LeftEdge;
  138.     BOOL   Commandes  = FALSE;
  139.     BOOL   CheckMarks = FALSE;
  140.  
  141.     while (Ptr)
  142.     {
  143.        if ( (L=strlen(((IT *)Ptr->ItemFill)->IText)) > Max )
  144.           Max = L;
  145.        if (Ptr->Flags & COMMSEQ) Commandes  = TRUE;
  146.        if (Ptr->Flags & CHECKIT) CheckMarks = TRUE;
  147.        Ptr = Ptr->NextItem;
  148.     }
  149.  
  150.     LargeurTotale = LargeurFonte * Max;
  151.     if (Commandes)  LargeurTotale += COMWIDTH;
  152.     if (CheckMarks) LargeurTotale += COMWIDTH/2;
  153.  
  154.     if ( (L=CoteGauche+LargeurTotale+20) > LargeurEcran )
  155.        CoteGauche -= (L-LargeurEcran);
  156.  
  157.     Ptr = Item;
  158.  
  159.     while (Ptr)
  160.     {
  161.        Ptr->LeftEdge = CoteGauche;
  162.        Ptr->Width    = LargeurTotale;
  163.        Ptr = Ptr->NextItem;
  164.     }
  165. }
  166.  
  167.  
  168. /*********************************************************************
  169. ***********************************************************************
  170. **
  171. **  Modification de menus
  172. **
  173. */
  174.  
  175. void ChangeMenus (Table, N)
  176.  
  177. struct TableCom *Table;
  178. SHORT N;
  179.  
  180. {
  181.     struct Screen *        Ecran;
  182.     struct Window *        Fenetre;
  183.     struct Menu *        Menu;
  184.     struct Menu *        BandeMenu;
  185.     struct MenuItem *    Item;
  186.     struct MenuItem *    SubItem;
  187.     ULONG            Lock;
  188.  
  189.  
  190.     Lock = LockIBase (0L);
  191.  
  192.     Ecran = PREMIER_ECRAN;
  193.  
  194.     while (Ecran)
  195.     {
  196.        if (StrCmp(Ecran->Title,Table->NomEcran))
  197.        {
  198.           Fenetre = Ecran->FirstWindow;
  199.  
  200.           while (Fenetre)
  201.           {
  202.              if (StrCmp(Fenetre->Title,Table->NomFenetre))
  203.              {
  204.                 BandeMenu = Menu = Fenetre->MenuStrip;
  205.  
  206.                 ClearMenuStrip (Fenetre);
  207.  
  208.                 while (Menu)
  209.                 {
  210.                    if (StrCmp(Menu->MenuName,Table->NomMenu))
  211.                    {
  212.                       Item = Menu->FirstItem;
  213.  
  214.                       while (Item && ( (Item->Flags & ITEMTEXT) || (Item->SubItem) ) )
  215.                       {
  216.                          if (StrCmp (((IT *)Item->ItemFill)->IText,Table->NomItem))
  217.                          {
  218.                             if (Table->NomSubItem[0])  /* s'il y a un sous-item */
  219.                             {
  220.                                SubItem = Item->SubItem;
  221.  
  222.                                while (SubItem && (SubItem->Flags & ITEMTEXT) )
  223.                                {
  224.                                   if (StrCmp (((IT *)SubItem->ItemFill)->IText,Table->NomSubItem))
  225.                                   {
  226.                                      SubItem->Command = Table->Commande;
  227.  
  228.                                      if (Table->Commande != NOCOM)
  229.                                      {
  230.                                         if ( ! (SubItem->Flags & COMMSEQ) )
  231.                                         {
  232.                                            SubItem->Flags  |= COMMSEQ;
  233.                                            ChangeLargeur (Item->SubItem,
  234.                                                           Fenetre->RPort->Font->tf_XSize,
  235.                                                           Ecran->Width);
  236.                                         }
  237.                                      }
  238.                                      else if (SubItem->Flags & COMMSEQ)
  239.                                      {
  240.                                         SubItem->Flags &= ~COMMSEQ;
  241.                                         ChangeLargeur (Item->SubItem,
  242.                                         Fenetre->RPort->Font->tf_XSize,
  243.                                         Ecran->Width);
  244.                                      }
  245.  
  246.                                      Table->Modifie = TRUE;
  247.                                   }
  248.  
  249.                                   SubItem = SubItem->NextItem;
  250.                                   Table++;
  251.                                }
  252.                             }
  253.                             else /* Item */
  254.                             {
  255.                                Item->Command = Table->Commande;
  256.  
  257.                                if (Table->Commande != NOCOM)
  258.                                {
  259.                                   if ( ! (Item->Flags & COMMSEQ) )
  260.                                   {
  261.                                      Item->Flags  |= COMMSEQ;
  262.                                      ChangeLargeur (Menu->FirstItem,
  263.                                      Fenetre->RPort->Font->tf_XSize,
  264.                                      Ecran->Width);
  265.                                   }
  266.                                }
  267.                                else if (Item->Flags & COMMSEQ)
  268.                                {
  269.                                   Item->Flags &= ~COMMSEQ;
  270.                                   ChangeLargeur (Menu->FirstItem,
  271.                                   Fenetre->RPort->Font->tf_XSize,
  272.                                   Ecran->Width);
  273.                                }
  274.  
  275.                                Table->Modifie = TRUE;
  276.                                Table++;
  277.                             }
  278.                          }
  279.  
  280.                          Item = Item->NextItem;
  281.                       }
  282.                    }
  283.  
  284.                    Menu = Menu->NextMenu;
  285.                 }
  286.  
  287.                 SetMenuStrip (Fenetre, BandeMenu);
  288.              }
  289.  
  290.              Fenetre = Fenetre->NextWindow;
  291.           }
  292.        }
  293.  
  294.        Ecran = Ecran->NextScreen;
  295.     }
  296.  
  297.     UnlockIBase (Lock);
  298. }
  299.  
  300.  
  301. /*********************************************************************
  302. ***********************************************************************
  303. **
  304. **  Lecture de la prochaine string dans le fichier
  305. **
  306. **  TRUE si le séparateur attendu est rencontré.
  307. */
  308.  
  309. BOOL LectureString (Fichier, StrPtr)
  310. FILE *Fichier;
  311. STRPTR StrPtr;
  312. {
  313.     STRPTR Ptr = StrPtr;
  314.     SHORT  Car;
  315.     SHORT  N = 0;
  316.  
  317.     while ( ((Car=getc(Fichier)) != EOF) && (Car != SEP) && (N<(MAX-1)) )
  318.     {
  319.        *Ptr++ = Car;
  320.        N++;
  321.     }
  322.  
  323.     if (Car == EOF) return (FALSE);
  324.     if ( (Car == SEP) || (N == (MAX-1)) ) *Ptr = '\0';
  325.  
  326.     return (TRUE);
  327. }
  328.  
  329.  
  330. /*********************************************************************
  331. ***********************************************************************
  332. **
  333. **  Allocation de la table des menus
  334. **
  335. */
  336.  
  337. LONG AlloueTable (Table, NbMenus)
  338. struct TableCom **Table;
  339. SHORT NbMenus;
  340. {
  341.     LONG BytesRequises;
  342.  
  343.     BytesRequises = NbMenus * sizeof (struct TableCom);
  344.  
  345.     *Table = AllocMem (BytesRequises, MEMF_PUBLIC|MEMF_CLEAR);
  346.     
  347.     return (BytesRequises);
  348. }
  349.  
  350.  
  351. /*********************************************************************
  352. ***********************************************************************
  353. **
  354. **  Lecture des menus à partir du fichier passé en paramètre
  355. **
  356. */
  357.  
  358. void LectureMenus (Fichier, CLI)
  359. FILE *Fichier;
  360. BOOL CLI;
  361. {
  362.     struct TableCom *Table;
  363.     SHORT  Car;
  364.     SHORT  NbMenus;
  365.     LONG   Taille;
  366.     SHORT  N, M;
  367.  
  368.      /*** Allocation de la table des menus ***/
  369.  
  370.     if ( ! (NbMenus = Occurences (Fichier,SEP) / 6 ) ) return;
  371.  
  372.     if ( ! (Taille = AlloueTable (&Table,NbMenus)) )
  373.     {
  374.        if (CLI) printf (ERRMEM);
  375.            else DisplayBeep (NULL);
  376.  
  377.            return;
  378.     }
  379.  
  380.      /*** Lecture du fichier ***/
  381.  
  382.     for (N=0; N<NbMenus; N++)
  383.     {
  384.        while ( ((Car=getc(Fichier)) != EOF) && (Car != SEP) );
  385.  
  386.        if (Car == EOF) break;
  387.  
  388.        if (!LectureString(Fichier,Table[N].NomEcran))   break;
  389.        if (!LectureString(Fichier,Table[N].NomFenetre)) break;
  390.        if (!LectureString(Fichier,Table[N].NomMenu))    break;
  391.        if (!LectureString(Fichier,Table[N].NomItem))    break;
  392.        if (!LectureString(Fichier,Table[N].NomSubItem)) break;
  393.  
  394.        Table[N].Commande = getc(Fichier);
  395.  
  396.        Table[N].Modifie  = FALSE;
  397.     }
  398.  
  399.      /*** Application de la table ***/
  400.  
  401.     ChangeMenus (Table, N);
  402.  
  403.      /*** Messages d'erreurs pour les menus non-modifiés ***/
  404.  
  405.     for (M=0; M<N; M++)
  406.        if (!Table[M].Modifie)
  407.           if (CLI)
  408.           {
  409.              printf ("%s->%s->%s->%s->%s  non-modifié pour '%c'\n",
  410.                      Table[M].NomEcran,   Table[M].NomFenetre,
  411.                      Table[M].NomMenu,    Table[M].NomItem,
  412.                      Table[M].NomSubItem, Table[M].Commande);
  413.           }
  414.           else
  415.           {
  416.              DisplayBeep (NULL);
  417.           }
  418.  
  419.      /*** Déallocation de la table des menus ***/
  420.  
  421.     FreeMem (Table, Taille);
  422.  
  423. }
  424.  
  425.  
  426. /*********************************************************************
  427. ***********************************************************************
  428. **
  429. **  Affichage des menus
  430. **
  431. **  Deux passes : la première pour compter le nb de menus à enregistrer,
  432. **                la deuxième pour les enregistrer.
  433. **
  434. **  Retourne FALSE s'il a manqué de mémoire pour la table.
  435. */
  436.  
  437. BOOL AfficheMenus (Fichier, CLI)
  438. FILE * Fichier;
  439. BOOL CLI;
  440. {
  441.     struct Screen *        Ecran;
  442.     struct Window *        Fenetre;
  443.     struct Menu *        Menu;
  444.     struct MenuItem *    Item;
  445.     struct MenuItem *    SubItem;
  446.     ULONG            Lock;
  447.     SHORT            Passe;
  448.     SHORT            NbMenus = 0;
  449.     struct TableCom *    Table;
  450.     struct TableCom *    Ptr;
  451.     struct TableCom *    Ptr2;
  452.     LONG            Taille;
  453.  
  454.  
  455.      /*** Création de la table de menus ***/
  456.  
  457.     Lock = LockIBase (0L); /* Accès sécuritaire à IntuitionBase */
  458.  
  459.     for (Passe=0; Passe<2; Passe++)
  460.     {
  461.  
  462.        if (Passe==1)
  463.        {
  464.           if (!NbMenus) /* Impossible à partir du WB */
  465.           {
  466.              printf (ERRNBMENUS);
  467.  
  468.              UnlockIBase (Lock);
  469.              return (FALSE);
  470.           }
  471.  
  472.           if ( ! (Taille = AlloueTable (&Table,NbMenus)) )
  473.           {
  474.              if (CLI) printf (ERRMEM);
  475.                  else DisplayBeep (NULL);
  476.  
  477.              UnlockIBase (Lock);
  478.                  return (FALSE);
  479.           }
  480.  
  481.           Ptr2 = Ptr = Table;
  482.        }
  483.  
  484.        Ecran = PREMIER_ECRAN;
  485.  
  486.        while (Ecran)
  487.        {
  488.           Fenetre = Ecran->FirstWindow;
  489.  
  490.           while (Fenetre)
  491.           {
  492.              Menu = Fenetre->MenuStrip;
  493.  
  494.              while (Menu)
  495.              {
  496.                 Item = Menu->FirstItem;
  497.  
  498.                 while (Item)
  499.                 {
  500.                    SubItem = Item->SubItem;
  501.  
  502.                    if (SubItem) while (SubItem)
  503.                    {
  504.                       if (SubItem->Flags & ITEMTEXT)
  505.                       {
  506.                          if (Passe==1)
  507.                          {
  508.                             StrNCpy (Ptr->NomEcran,Ecran->Title,MAX);
  509.                             StrNCpy (Ptr->NomFenetre,Fenetre->Title,MAX);
  510.                             StrNCpy (Ptr->NomMenu,Menu->MenuName,MAX);
  511.                             StrNCpy (Ptr->NomItem,((IT *)Item->ItemFill)->IText,MAX);
  512.                             StrNCpy (Ptr->NomSubItem,((IT *)SubItem->ItemFill)->IText,MAX);
  513.                             Ptr->Commande = (SubItem->Flags & COMMSEQ)?SubItem->Command:NOCOM;
  514.                             Ptr++;
  515.                          }
  516.                          else NbMenus++;
  517.                       }
  518.  
  519.                       SubItem = SubItem->NextItem;
  520.                    }
  521.                    else
  522.                    {
  523.                       if (Item->Flags & ITEMTEXT)
  524.                       {
  525.                          if (Passe==1)
  526.                          {
  527.                             StrNCpy (Ptr->NomEcran,Ecran->Title,MAX);
  528.                             StrNCpy (Ptr->NomFenetre,Fenetre->Title,MAX);
  529.                             StrNCpy (Ptr->NomMenu,Menu->MenuName,MAX);
  530.                             StrNCpy (Ptr->NomItem,((IT *)Item->ItemFill)->IText,MAX);
  531.                             Ptr->NomSubItem[0] = '\0';
  532.                             Ptr->Commande = (Item->Flags & COMMSEQ)?Item->Command:NOCOM;
  533.                             Ptr++;
  534.                          }
  535.  
  536.                          else NbMenus++;
  537.                       }
  538.                    }
  539.  
  540.                    Item = Item->NextItem;
  541.                 }
  542.  
  543.                 Menu = Menu->NextMenu;
  544.              }
  545.  
  546.              Fenetre = Fenetre->NextWindow;
  547.           }
  548.  
  549.           Ecran = Ecran->NextScreen;
  550.        }
  551.         }
  552.  
  553.     UnlockIBase (Lock); /* On repermet l'accès à IntuitionBase */
  554.  
  555.  
  556.      /*** Envoi de la table dans le fichier ***/
  557.  
  558.     while (Ptr2 < Ptr)
  559.     {
  560.        fprintf (Fichier, "¹%s¹%s¹%s¹%s¹%s¹%c\n",
  561.                 Ptr2->NomEcran,
  562.                 Ptr2->NomFenetre,
  563.                 Ptr2->NomMenu,
  564.                 Ptr2->NomItem,
  565.                 Ptr2->NomSubItem,
  566.                 Ptr2->Commande
  567.                );
  568.        Ptr2++;
  569.     }
  570.  
  571.  
  572.      /*** Déallocation de la table des menus ***/
  573.  
  574.     FreeMem (Table, Taille);
  575.  
  576.     return (TRUE);
  577. }
  578.  
  579.  
  580. /*********************************************************************
  581. ***********************************************************************
  582. **
  583. **  Création d'une liste de menus exécutable du WB
  584. **
  585. */
  586.  
  587. void CreeWBListe (NomOutil)
  588. UBYTE *NomOutil;
  589. {
  590.     FILE * Fichier;
  591.     SHORT  NbBytes;
  592.     BOOL   Resultat;
  593.  
  594.      /*** On écrit le fichier de données ***/
  595.  
  596.     Fichier = fopen (NOM_DATA, "w");
  597.     if (!Fichier) return;
  598.     Resultat = AfficheMenus (Fichier, FALSE);
  599.     fclose (Fichier);
  600.     if (!Resultat) unlink (NOM_DATA);
  601.  
  602.      /*** On crée son .info ***/
  603.  
  604.     Fichier = fopen (NOM_DATA_INFO, "w");
  605.     if (!Fichier) return;
  606.  
  607.     for (NbBytes=0; NbBytes<LONGUEUR_INFO; NbBytes++)
  608.        putc (DataInfo[NbBytes], Fichier);
  609.  
  610.     fprintf (Fichier, "%c%s", (UBYTE)strlen(NomOutil), NomOutil);
  611.  
  612.     fclose (Fichier);
  613. }
  614.  
  615.  
  616. /*********************************************************************
  617. ***********************************************************************
  618. **
  619. **  Lectures des menus passés en paramètres du WB
  620. **
  621. **  S'il n'y a pas d'argument, l'usager veut que l'on crée une liste
  622. **  des menus des fenêtres actuellement ouvertes.
  623. */
  624.  
  625. void WBArguments (WBMsg)
  626. struct WBStartup *WBMsg;
  627. {
  628.     struct WBArg    *Arg = WBMsg->sm_ArgList;
  629.     SHORT          NbArgs;
  630.     FILE        *Fichier;
  631.     UBYTE        *NomOutil = (UBYTE *) Arg->wa_Name;
  632.  
  633.     Arg++;  /* On saute l'outil lui-même */
  634.  
  635.     if (WBMsg->sm_NumArgs==1)
  636.        CreeWBListe (NomOutil);
  637.     else
  638.        for (NbArgs=1; NbArgs<WBMsg->sm_NumArgs; NbArgs++)
  639.        {
  640.           Fichier = fopen (Arg->wa_Name, "r");
  641.           if (Fichier)
  642.           {
  643.              LectureMenus (Fichier, FALSE);
  644.              fclose (Fichier);
  645.           }
  646.           Arg++;
  647.        }
  648. }
  649.  
  650.  
  651. /*********************************************************************
  652. ***********************************************************************
  653. **
  654. **  Programme principal                                            
  655. **
  656. **  Workbench:
  657. **     Outil     : crée un fichier de menus NOM_DATA avec icône.
  658. **     Projet(s) : applique les menus du(des) projet(s).
  659. **  CLI:
  660. **     1> Menucure            ; crée un fichier de menus NOM_DATA.
  661. **     1> Menucure Fichier    ; applique les menus du Fichier.
  662. **     1> Menucure -f Fichier ; crée un fichier de menus Fichier.
  663. */
  664.  
  665. main (argc, argv)
  666. SHORT  argc;
  667. STRPTR argv[];
  668. {
  669.     FILE *Fichier;
  670.     BOOL Resultat;
  671.  
  672.     IntuitionBase = (struct IntuitionBase *) OpenLibrary ("intuition.library", 33L);
  673.     if (!IntuitionBase)
  674.     {
  675.        if (argc) printf ("Nécessite intuition.library v33 et +\n");
  676.        exit (0);
  677.     }
  678.  
  679.     if (argv[1] == '?') argc = 10;    /* force l'aide */
  680.  
  681.     switch (argc)
  682.     {
  683.        case 0 : WBArguments (WBenchMsg);
  684.                 break;
  685.  
  686.        case 1 : Fichier = fopen (NOM_DATA, "w");
  687.                 if (Fichier)
  688.                 {
  689.                    Resultat = AfficheMenus (Fichier, TRUE);
  690.                    fclose (Fichier);
  691.                    if (Resultat)
  692.                       printf ("Fichier %s créé par défaut\n", NOM_DATA);
  693.                    else
  694.                       unlink (NOM_DATA);
  695.                 }
  696.                 else
  697.                 {
  698.                    printf ("Ne peut ouvrir le fichier de sortie\n");
  699.                 }
  700.                 break;
  701.  
  702.        case 3 : if ( *(argv[1]+1) == 'f' )
  703.                 {
  704.                    Fichier = fopen (argv[2], "w");
  705.                    if (Fichier)
  706.                    {
  707.                       Resultat = AfficheMenus (Fichier, TRUE);
  708.                       fclose (Fichier);
  709.                       if (!Resultat) unlink (argv[2]);
  710.                    }
  711.                    else
  712.                    {
  713.                       printf ("Ne peut ouvrir '%s'\n", argv[2]);
  714.                    }
  715.                    break;
  716.                 }
  717.                 else
  718.                 {
  719.                    printf ("Option inconnue.\n");
  720.                 }
  721.  
  722.        /** L'option 2 après 3, sinon on exécute le else de ce dernier ***/
  723.  
  724.        case 2 : if ( *argv[1] != '?' )
  725.                 {
  726.                    Fichier = fopen (argv[1], "r");
  727.                    if (!Fichier)
  728.                    {
  729.                       printf ("Fichier '%s' introuvable\n", argv[1]);
  730.                       break;
  731.                    }
  732.                    LectureMenus (Fichier, TRUE);
  733.                    fclose (Fichier);
  734.                    break;
  735.                 }
  736.                 /* Sinon il va aboutir dans le default: */
  737.  
  738.        default:
  739.                 printf ("\n== Club Amiga Montréal ==\n");
  740.                 printf ("Eric Le Saux & Jean Pepin\n");
  741.                 printf ("\nUSAGE\n\n");
  742.                 printf (" %s            ; crée le fichier de menus '%s'\n", argv[0], NOM_DATA);
  743.                 printf (" %s Fichier    ; applique les menus de 'Fichier'\n", argv[0]);
  744.                 printf (" %s -f Fichier ; crée un fichier de menus 'Fichier'\n\n", argv[0]);
  745.                 break;
  746.     }
  747.  
  748.     CloseLibrary (IntuitionBase);
  749. }
  750.