home *** CD-ROM | disk | FTP | other *** search
/ Computer Music Interactif…cial Edition 1999 Winter / cd 3.iso / mac / Mac / Shares / Midishare™1.68 / Development Tools / Sources Examples / Skeleton_C / Skeleton.c next >
Encoding:
C/C++ Source or Header  |  1994-06-23  |  21.3 KB  |  667 lines  |  [TEXT/MPS ]
  1. /********************************************************************************/
  2. /*                        MIDI SHARE Application Skeleton                       */
  3. /*                            Version Think C 4.0                                    */
  4. /*------------------------------------------------------------------------------*/
  5. /* MIDISHARE est un module logiciel conçu spécialement pour permettre le fonc-    */
  6. /* tionnement et le développement d'applications Midi dans un contexte multi-    */
  7. /* tâches et temps réel.                                                         */
  8. /*                                                                                 */
  9. /* MIDISHARE prend en charge la plupart des problèmes spécifiques liés au déve- */
  10. /* loppement d'applications Midi: gestion des flux Midi, gestion du temps,        */
  11. /* gestion des tâches. En outre, MIDISHARE permet le fonctionnement simultané    */
  12. /* sous Multi-Finder de ces applications, ainsi que l'établissement de connec-    */
  13. /* tions Midi virtuelles entre celles-ci.                                        */
  14. /*                                                                                 */
  15. /* SKELETON est un exemple d'application MidiShare minimale qui peut être        */
  16. /* utilisée comme base de développement pour de nouvelles applications.            */
  17. /* Par défaut, l'application renvoie tous les événements qu'elle reçoit, sans    */
  18. /* aucune modification.                                                            */
  19. /*                                                                                */
  20. /* Les points qui peuvent être facilement modifiés sont les suivants :            */
  21. /*                                                                                */
  22. /* - La constante ApplName : le nom de l'application pour MidiShare                 */
  23. /*                                                                                */
  24. /* - ReceiveEvents : qui traite tous les événements reçus et qui réalise ici     */
  25. /*   un simple MidiThru.                                                        */
  26. /*                                                                                */
  27. /* - La constante wantRealTime : quand elle vaut 1, ReceiveEvents est appelée    */
  28. /*   sous interruption et fonctionne donc en temps réel, mais ne peut pas        */
  29. /*   utiliser les appels à la Toolbox; quand elle vaut 0, ReceiveEvents est     */
  30. /*   appelée dans la boucle principale et peut donc utiliser la toolbox.        */
  31. /*                                                                                */
  32. /* - La constante wantFilter : quand elle vaut 1, un filtre sur les entrées      */
  33. /*   Midi est installé, quand elle vaut 0, aucun filtre n'est installé et         */
  34. /*   l'application reçoit tous les événements.                                    */
  35. /*                                                                                */
  36. /* - InstallFilter : qui configure le filtre d'entrée                            */
  37. /*                                                                                */
  38. /* - La resource de dialogue 128 qui définit la fenêtre de l'application        */
  39. /*                                                                                */
  40. /*------------------------------------------------------------------------------*/
  41. /*        © GRAME 1987-92, Yann Orlarey et Hervé Lequay                             */
  42. /********************************************************************************/
  43.  
  44. #include "MIDIShare.h"
  45.  
  46. #include <Values.h>
  47. #include <Types.h>
  48. #include <Resources.h>
  49. #include <QuickDraw.h>
  50. #include <Fonts.h>
  51. #include <Events.h>
  52. #include <Windows.h>
  53. #include <Menus.h>
  54. #include <TextEdit.h>
  55. #include <Dialogs.h>
  56. #include <Desk.h>
  57. #include <ToolUtils.h>
  58. #include <Memory.h>
  59. #include <SegLoad.h>
  60. #include <Files.h>
  61. #include <OSUtils.h>
  62. #include <OSEvents.h>
  63. #include <DiskInit.h>
  64. #include <Packages.h>
  65. #include <Traps.h>
  66.  
  67. /* Quelques constantes Macintosh */
  68.  
  69. #define nil                        0
  70. #define osEvent                 app4Evt
  71. #define    resumeMask                1
  72. #define    suspendResumeMessage    1
  73. #define mouseMovedMessage        0xFA
  74. #define _Unimplemented            0xA89F            /* Unimplemented trap                */
  75. #define _WaitNextEvent            0xA860            /* WaitNextEvent trap                */
  76.  
  77.  
  78. /* Une barre de menus minimale */
  79.  
  80. #define mBarSize    3
  81. #define    AppleMenu    0
  82. #define    FileMenu    1
  83. #define    EditMenu    2
  84.  
  85. #define    AppleID        128
  86. #define    FileID        129
  87. #define    EditID        130
  88.  
  89.  
  90. /* Les items du menu Edit    */
  91.  
  92. #define    UndoI        1
  93. #define    CutI        3
  94. #define    CopyI        4
  95. #define    PasteI        5
  96. #define    ClearI        6
  97.  
  98.  
  99. /* La fenêtre de l'application qui est en fait un dialog */
  100.  
  101. #define WindowID    128                         
  102.  
  103.  
  104. /* Pour les erreurs et le About    */
  105.  
  106. #define    AboutID        129
  107. #define    AlertID        500
  108.  
  109.  
  110. /* Constantes pour paramétrer l'application    */
  111.  
  112. #define ApplName         "\pSkeleton"
  113. #define    wantRealTime     1
  114. #define wantFilter        0
  115.  
  116.  
  117. /* Variables globales pour MidiShare    */
  118.  
  119. short        myRefNum;                            /* numéro d'appl. Midi                */
  120. TFilter        myFilter;                            /* filtre pour les événements Midi    */
  121.  
  122.  
  123. /* Variables globales d'une application Macintosh    */
  124.  
  125. WindowPtr    myWindow;                            /* fenêtre                            */
  126.  
  127. Boolean        doneFlag;                            /* flag d'arrêt                        */
  128.     
  129. SysEnvRec    gMac;                                /* machine…                            */
  130. Boolean        hasWNE;                                /* vrai si WaitNextEvent implémenté    */
  131. Boolean        foreGround;                            /* vrai si en foreGround            */
  132.  
  133. EventRecord    myEvent;                            /* pour la main event loop            */
  134. char        theChar;                            /* pour la gestion des touches        */
  135. Rect        dragRect;                            /* rect de déplacement de fenêtre    */
  136. MenuHandle    myMenus[mBarSize];                    /* les menus                        */
  137.  
  138.  
  139.  
  140.  
  141.  
  142. /********************************************************************************/
  143. /*                                 Macintosh     utilities                            */
  144. /*------------------------------------------------------------------------------*/
  145. /*                                                                                 */
  146. /********************************************************************************/
  147.  
  148. void AlertUser (short r)                        /* Signale une erreur à l'utilisateur    */
  149. {    
  150.     Str255        msg;
  151.     
  152.     GetIndString( msg, AlertID, r);
  153.     ParamText( ApplName, msg, "\p", "\p");
  154.     Alert(AlertID,nil);
  155.     ExitToShell();                                
  156. }
  157.  
  158. Boolean        TrapAvailable(short    trapNum, short tType)
  159. {
  160.     if ( (tType == ToolTrap)  &&                        /* Toolbox trap        */
  161.          (gMac.machineType > envMachUnknown)  &&        /* …512KE, Plus, or    */
  162.          (gMac.machineType < envMacII) ) {                /* …SE                */
  163.          
  164.         trapNum &= 0x3FF;                /* Traps numbers are 10 bits long    */
  165.         
  166.         if (trapNum > 0x1FF) {            /* Traps only go up to 0x1FF on        */
  167.             return(false);                /*   these machines                    */
  168.         }
  169.     }
  170.     return NGetTrapAddress(trapNum, tType) != GetTrapAddress(_Unimplemented);
  171. }
  172.  
  173. Boolean IsAppWindow (WindowPtr wind)
  174. {
  175.     return  wind ? ((WindowPeek)wind)->windowKind >= 0 : false ;
  176. }
  177.  
  178. Boolean IsDAWindow (WindowPtr wind)
  179. {
  180.     return  wind ? ((WindowPeek)wind)->windowKind < 0 : false ;
  181. }
  182.  
  183. void CloseWind (WindowPtr wind)
  184. {
  185.     if ( IsDAWindow(wind) )
  186.         CloseDeskAcc( ((WindowPeek)wind)->windowKind );
  187.     else if ( IsAppWindow(wind) )
  188.         DisposeWindow(wind);
  189. }
  190.  
  191. void CloseAllWinds (WindowPtr wind)
  192. {
  193.     if (wind) {
  194.         CloseAllWinds( (WindowPtr) (((WindowPeek)wind)->nextWindow) );
  195.         CloseWind(wind);
  196.     }
  197. }
  198.  
  199.  
  200.  
  201. /*=============================== MidiShare Part ===============================*/
  202.  
  203.  
  204. /********************************************************************************/
  205. /*                                 ReceiveEvents                                    */
  206. /*------------------------------------------------------------------------------*/
  207. /* Cette procédure traite tous les événements reçus. Elle peut être appelée        */
  208. /* "manuellement" (wantRealTime 0) dans la boucle principale de l'application    */
  209. /* s'il n'y a pas de contraintes temps réel sur la réception.                    */
  210. /*                                                                                 */
  211. /* Dans le cas contraire (wantRealTime 1), grâce à MidiSetRcvAlarm, la routine     */
  212. /* peut être appelée automatiquement par MidiShare, sous interruptions, chaque     */ 
  213. /* fois que l'application reçoit de nouveaux événements (voir SetupMidi).         */
  214. /*                                                                                 */
  215. /* Dans le code ci dessous, ReceiveEvents réalise un simple MidiThru sans        */
  216. /* aucun traitement.                                                             */
  217. /*                                                                                 */
  218. /* ReceiveEvents doit obligatoirement comporter un paramètre, qui est le         */
  219. /* numéro de référence MidiShare de l'application.                                */
  220. /*                                                                                 */
  221. /* Les paramètres de l'appel :                                                    */
  222. /* ---------------------------                                                    */
  223. /*                                                                                 */
  224. /*        refNum:    numéro de référence MidiShare de l'application.                    */
  225. /*                                                                                 */
  226. /********************************************************************************/
  227.  
  228. pascal void ReceiveEvents (register short r)
  229. {
  230.     register MidiEvPtr    e;
  231.     register long n;
  232.  
  233.     if (n=MidiCountEvs(r))                        /* Pour chaque événement reçu :        */
  234.         do {
  235.             e = MidiGetEv(r);                        /*  récupérer l'événement            */
  236.             /* .... */                                /*  traiter l'événement                */
  237.             MidiSend(r,e);                            /*  renvoyer l'événement            */
  238.         }while (--n);
  239. }
  240.  
  241.  
  242. /****************************************************************************
  243. *                             InstallFilter                                    *
  244. *---------------------------------------------------------------------------*
  245. * Cette procédure définit les valeurs du filtre de l'application. Un filtre *
  246. * est composé de trois parties, qui sont trois tableaux de booléens :        * 
  247. *                                                                             *
  248. *        un tableau de 256 bits pour les ports Midi acceptés                    *
  249. *        un tableau de 256 bits pour les types d'événements acceptés            *
  250. *        un tableau de  16 bits pour les canaux Midi acceptés                *
  251. *                                                                             *
  252. * Dans le code ci dessous, le filtre est paramétré pour accepter n'importe    *
  253. * quel type d'événement.                                                     *
  254. *                                                                             *
  255. * Les paramètres de l'appel :                                                *
  256. * ---------------------------                                                *
  257. *                                                                             *
  258. *        aucun                                                                *
  259. *                                                                             *
  260. *****************************************************************************/
  261.  
  262. void InstallFilter ()
  263. {
  264.     register short i;
  265.  
  266.     for (i = 0; i<256; i++)
  267.     {                                         
  268.         AcceptBit(myFilter.evType,i);                /* accepte tous les types d'événements    */
  269.         AcceptBit(myFilter.port,i);                    /* en provenance de tous les ports        */
  270.     }
  271.                                             
  272.     for (i = 0; i<16; i++)
  273.         AcceptBit(myFilter.channel,i);                /* et sur tous les canaux Midi            */
  274.         
  275.     MidiSetFilter( myRefNum, &myFilter );           /* installe le filtre                    */
  276. }
  277.  
  278.  
  279. /********************************************************************************/
  280. /*                                 SETUP MIDI                                        */
  281. /*------------------------------------------------------------------------------*/
  282. /* Vérifie la présence de MidiShare, la possibilité d'ouverture Midi, et        */
  283. /* installe la procédure d'alarme qui sera appelée par MidiShare lors des chan-    */
  284. /* gements de statut des applications ou des ports.                                */
  285. /*                                                                                 */
  286. /* Les paramètres de l'appel :                                                    */
  287. /* ---------------------------                                                    */
  288. /*                                                                                 */
  289. /*        aucun                                                                    */
  290. /*                                                                                 */
  291. /********************************************************************************/
  292.  
  293. void SetUpMidi()
  294. {
  295.     if (!MidiShare())                                /* Vérifie la présence de MidiShare            */
  296.     {
  297.         AlertUser(1);
  298.     }
  299.     
  300.     myRefNum= MidiOpen(ApplName);                    /* Ouvre l'application pour MidiShare        */        
  301.     if (myRefNum == MIDIerrSpace)                    /* Vérifie que tout c'est bien passé        */
  302.     {
  303.         AlertUser(2);
  304.     } 
  305.     
  306.     if (wantRealTime)                                /* Installe la routine de réception pour    */
  307.         MidiSetRcvAlarm(myRefNum, ReceiveEvents);    /* qu'elle soit appelée sous interruptions     */
  308.         
  309.     if (wantFilter)
  310.         InstallFilter();                            /* Installe le filtre de réception            */
  311.         
  312.     MidiConnect(0,myRefNum,true);                    /* Connecte l'entrée de l'appl. aux entrées physiques    */
  313.     MidiConnect(myRefNum,0,true);                    /* Connecte la sortie de l'appl. aux sorties physiques    */
  314. }
  315.             
  316.  
  317. /********************************************************************************/
  318. /*                                 Do Idle                                            */
  319. /*------------------------------------------------------------------------------*/
  320. /* Execution des différentes tâches Midi : reception des événements Midi si        */
  321. /* cela n'est pas fait sous interruptions; Exécution des tâches différées en    */
  322. /* attente (tâches crées par MidiDTask).                                        */
  323. /*                                                                                 */
  324. /* Les paramètres de l'appel :                                                    */
  325. /* ---------------------------                                                    */
  326. /*                                                                                 */
  327. /*        aucun                                                                    */
  328. /*                                                                                 */
  329. /********************************************************************************/
  330. void DoIdle()
  331. {
  332.     register long    n;
  333.     register short     r;
  334.     
  335.     r = myRefNum;
  336.     if (!wantRealTime) ReceiveEvents(r);
  337.     for (n=MidiCountDTasks(r); n>0; --n) MidiExec1DTask(r);
  338.     /* .... */
  339. }
  340.  
  341.  
  342. /********************************************************************************/
  343. /*                                 Setup windows                                    */
  344. /*------------------------------------------------------------------------------*/
  345. /* Ouvre la fenêtre                                                                */
  346. /*                                                                                 */
  347. /* Les paramètres de l'appel :                                                    */
  348. /* ---------------------------                                                    */
  349. /*                                                                                 */
  350. /*        aucun                                                                    */
  351. /*                                                                                 */
  352. /********************************************************************************/
  353.  
  354. void SetUpWindows()
  355. {
  356.     SetRect (&dragRect, qd.screenBits.bounds.left, qd.screenBits.bounds.top, 
  357.                         qd.screenBits.bounds.right,qd.screenBits.bounds.bottom);
  358.     InsetRect (&dragRect, 4, 4);
  359.  
  360.      myWindow = GetNewDialog (WindowID, nil, (WindowPtr) -1);
  361.      SetPort(myWindow);
  362.     TextFont(monaco); TextSize(9); TextMode(srcCopy); PenNormal();
  363.     ShowWindow(myWindow);
  364.  
  365. }
  366.  
  367. /********************************************************************************
  368. *                                 TrackDialog                                        *
  369. *------------------------------------------------------------------------------    *
  370. * Procédure chargée du suivi de la souris.                                        *
  371. *                                                                                 *
  372. * Les paramètres de l'appel :                                                    *
  373. * ---------------------------                                                    *
  374. *                                                                                 *
  375. *        w    :    pointeur sur la fenêtre de dialogue.                            *
  376. *        p    :    point où la souris a été cliquée.                                *
  377. *                                                                                 *
  378. ********************************************************************************/
  379.  
  380. void TrackDialog(WindowPtr w, Point p)
  381. {
  382.     SetPort(w);
  383.     GlobalToLocal(&p);                                /* conversion du point en local    */
  384. }
  385.  
  386.         
  387. /********************************************************************************/
  388. /*                                 SET UP MENUS                                    */
  389. /*------------------------------------------------------------------------------*/
  390. /* Installation de la barre de menus                                              */
  391. /*                                                                                 */
  392. /* Les paramètres de l'appel :                                                    */
  393. /* ---------------------------                                                    */
  394. /*                                                                                 */
  395. /*        aucun                                                                    */
  396. /*                                                                                 */
  397. /********************************************************************************/
  398.  
  399. void SetUpMenus()
  400. {
  401.     short    i;
  402.         
  403.     myMenus[AppleMenu] = GetMenu(AppleID);
  404.     AddResMenu(myMenus[AppleMenu],'DRVR');
  405.     myMenus[FileMenu] = GetMenu(FileID);
  406.     myMenus[EditMenu] = GetMenu(EditID);
  407.     for (i = AppleMenu; i <= EditMenu; i++)
  408.         InsertMenu(myMenus[i], 0);
  409.     DrawMenuBar();
  410. }            
  411.  
  412. /********************************************************************************/
  413. /*                                 ADJUST MENUS                                    */
  414. /*------------------------------------------------------------------------------*/
  415. /* Ajustement de la barre de menus suivant la fenêtre de premier plan, juste    */
  416. /* lors d'un click dans la barre des menus                                        */
  417. /*                                                                                 */
  418. /* Les paramètres de l'appel :                                                    */
  419. /* ---------------------------                                                    */
  420. /*                                                                                 */
  421. /*        aucun                                                                    */
  422. /*                                                                                 */
  423. /********************************************************************************/
  424.  
  425. void AdjustMenus() 
  426. {
  427.     if ( IsAppWindow( FrontWindow() ) ) 
  428.     {
  429.         DisableItem( myMenus[EditMenu], UndoI );
  430.         DisableItem( myMenus[EditMenu], CutI );
  431.         DisableItem( myMenus[EditMenu], CopyI );
  432.         DisableItem( myMenus[EditMenu], PasteI );
  433.         DisableItem( myMenus[EditMenu], ClearI );
  434.     } 
  435.     else if ( IsDAWindow( FrontWindow() ) ) 
  436.     {
  437.         EnableItem( myMenus[EditMenu], UndoI );
  438.         EnableItem( myMenus[EditMenu], CutI );
  439.         EnableItem( myMenus[EditMenu], CopyI );
  440.         EnableItem( myMenus[EditMenu], PasteI );
  441.         EnableItem( myMenus[EditMenu], ClearI );
  442.     }
  443. }            
  444.  
  445. /********************************************************************************
  446. *                                 Show About                                        *
  447. *------------------------------------------------------------------------------    *
  448. * Affiche la fenêtre de About.                                                    *
  449. *                                                                                 *
  450. * Les paramètres de l'appel :                                                    *
  451. * ---------------------------                                                    *
  452. *                                                                                 *
  453. *        aucun                                                                    *
  454. *                                                                                 *
  455. ********************************************************************************/
  456. void ShowAbout()
  457. {                                            
  458.     DialogPtr    myDialog;                    
  459.     short        Hit;                             
  460.  
  461.     myDialog = GetNewDialog(AboutID,nil,(WindowPtr) -1);
  462.     if (myDialog) {
  463.         ModalDialog(nil,&Hit);
  464.         DisposDialog(myDialog);
  465.     } else {
  466.         SysBeep(0);
  467.     }
  468. }
  469.             
  470. /********************************************************************************
  471. *                                 DO COMMAND                                        *
  472. *------------------------------------------------------------------------------    *
  473. * Execution des commandes du menu. Ici on se contente de gérer les accessoires    *
  474. * le About et la commande Quit.                                                    *
  475. *                                                                                 *
  476. * Les paramètres de l'appel :                                                    *
  477. * ---------------------------                                                    *
  478. *                                                                                 *
  479. *        mResult     :    le menu et l'item sélectionnés                            *
  480. *                                                                                 *
  481. ********************************************************************************/
  482. void DoCommand(long mResult)
  483. {
  484.     short    theItem;
  485.     short    theMenu;
  486.     Str255    name;
  487.  
  488.     theItem = LoWord(mResult);
  489.     theMenu = HiWord(mResult);
  490.     
  491.     switch ( theMenu )
  492.     {
  493.         case AppleID:
  494.             if (theItem != 1) 
  495.             {
  496.                 GetItem(myMenus[AppleMenu], theItem, name);
  497.                 theItem = OpenDeskAcc(name);
  498.             } else {
  499.                 ShowAbout();
  500.             }
  501.             break;
  502.         case EditID:
  503.             SystemEdit( theItem-1 );
  504.             break;
  505.         case FileID: 
  506.             doneFlag = true;
  507.             break;
  508.     }
  509.     HiliteMenu(0);  
  510. }
  511.  
  512. /********************************************************************************/
  513. /*                                 DO MOUSE DOWN                                    */
  514. /*------------------------------------------------------------------------------*/
  515. /* Gère les clicks souris                                                        */
  516. /*                                                                                 */
  517. /* Les paramètres de l'appel :                                                    */
  518. /* ---------------------------                                                    */
  519. /*                                                                                 */
  520. /*        aucun                                                                    */
  521. /*                                                                                 */
  522. /********************************************************************************/
  523.  
  524. void DoMouseDown() 
  525. {
  526.     WindowPtr whichWindow;
  527.     
  528.     switch ( FindWindow( myEvent.where, &whichWindow ) )
  529.     { 
  530.         case inMenuBar:    
  531.                 AdjustMenus(); 
  532.                 DoCommand(MenuSelect(myEvent.where));
  533.                 break;
  534.         case inSysWindow: 
  535.                 SystemClick(&myEvent, whichWindow);
  536.                 break;
  537.         case inGoAway:      
  538.                 doneFlag = TrackGoAway(whichWindow, myEvent.where);
  539.                 break;
  540.         case inDrag:      
  541.                 DragWindow(whichWindow, myEvent.where, &dragRect);
  542.                 break;
  543.         case inContent:      
  544.                 if (whichWindow != FrontWindow())
  545.                     SelectWindow(whichWindow);
  546.                 else if (whichWindow == myWindow)
  547.                     TrackDialog(myWindow, myEvent.where);
  548.                 break;
  549.     }
  550. }
  551.  
  552.  
  553. /********************************************************************************/
  554. /*                                 ADJUST CURSOR                                    */
  555. /*------------------------------------------------------------------------------*/
  556. /* Ajuste le curseur suivant région et fenêtre                                    */
  557. /*                                                                                 */
  558. /********************************************************************************/
  559.  
  560. void AdjustCursor() 
  561. {
  562.     if (foreGround && IsAppWindow(FrontWindow())) 
  563.         SetCursor(&qd.arrow);
  564. }
  565.  
  566.  
  567. /********************************************************************************/
  568. /*                                 INITIALIZE                                        */
  569. /*------------------------------------------------------------------------------*/
  570. /* Initialisations générales (hasWNE, foreGround, managers, fenêtre, Midi)        */
  571. /*                                                                                 */
  572. /* Les paramètres de l'appel :                                                    */
  573. /* ---------------------------                                                    */
  574. /*                                                                                 */
  575. /*        aucun                                                                    */
  576. /*                                                                                 */
  577. /********************************************************************************/
  578.  
  579. void Initialize()
  580. {
  581.     OSErr    err;
  582.  
  583.     err = SysEnvirons(1, &gMac);
  584.     if (gMac.machineType < 0) AlertUser(3);
  585.     hasWNE = TrapAvailable(_WaitNextEvent, ToolTrap);
  586.     foreGround = true;
  587.         
  588.     InitGraf(&qd.thePort);                                /* initialise QuickDraw                    */
  589.     InitFonts();                                       /* initialise le Font Manager            */
  590.     InitWindows();                                       /* initialise le Window Manager            */
  591.     InitDialogs(nil);                                   /* initialise le Dialog Manager            */
  592.     InitMenus();                                       /* initialise le Menu Manager            */
  593.     TEInit();                                           /* initialise le Text Edit Manager        */
  594.     InitCursor();                                        /* initialise le curseur de la souris    */
  595.  
  596.     FlushEvents(everyEvent, 0);                        /* efface événements Mac en attente        */
  597.  
  598.     SetUpMenus();                                    /* mise en place menus                    */
  599.     SetUpMidi();                                    /* ouverture MidiShare                    */
  600.     SetUpWindows();                                    /* initialisations fenêtre et listes    */
  601. }
  602.  
  603. /********************************************************************************/
  604. /*                             Corps Principal                                        */
  605. /*------------------------------------------------------------------------------*/
  606. /* Initialisation des managers, ouverture fenêtre, initialisations diverses    et    */
  607. /* tutti quanti, boucle principale.                                                */
  608. /*                                                                                 */
  609. /********************************************************************************/
  610.  
  611. void main()
  612. {
  613.     Boolean b;
  614.     
  615.     MaxApplZone();
  616.     Initialize();
  617.     
  618.     doneFlag = false;                                            
  619.     while (!doneFlag) {                                            /* Main Loop                */
  620.         if (hasWNE) 
  621.             b = WaitNextEvent(everyEvent, &myEvent, 0, nil);    /* no sleep, no mouseRgn    */
  622.         else {
  623.             SystemTask();
  624.              b = GetNextEvent(everyEvent, &myEvent);
  625.         }
  626.         AdjustCursor();                                            
  627.         switch( myEvent.what ) {
  628.             case nullEvent:
  629.                     DoIdle();
  630.                     break;
  631.             case osEvent:
  632.                     switch (myEvent.message >> 24) {
  633.                         case suspendResumeMessage:
  634.                             foreGround = myEvent.message & resumeMask;
  635.                             break;
  636.                         case mouseMovedMessage:
  637.                             DoIdle();
  638.                             break;
  639.                     }
  640.                     break;
  641.             case keyDown:
  642.             case autoKey:
  643.                     theChar = myEvent.message & charCodeMask;
  644.                     if (myEvent.modifiers & cmdKey ) {
  645.                         AdjustMenus();
  646.                         DoCommand(MenuKey(theChar));
  647.                     }
  648.                     break;
  649.             case mouseDown:
  650.                     DoMouseDown();
  651.                     break;
  652.             case updateEvt:
  653.                     if ( IsAppWindow( (WindowPtr)myEvent.message ) ) {
  654.                         BeginUpdate( (WindowPtr)myEvent.message );
  655.                         if ( !EmptyRgn( ((WindowPtr)myEvent.message)->visRgn ) ) {
  656.                             SetPort( (WindowPtr)myEvent.message );
  657.                             DrawDialog( (WindowPtr)myEvent.message );
  658.                         }
  659.                         EndUpdate( (WindowPtr)myEvent.message );
  660.                     }
  661.                     break;
  662.         }
  663.     }
  664.     MidiClose(myRefNum);                        
  665.     CloseAllWinds( FrontWindow() );
  666. }
  667.