home *** CD-ROM | disk | FTP | other *** search
/ Gold Fish 3 / goldfish_volume_3.bin / files / util / cdity / runlist3 / runlist3i / src / runlist3ni.c < prev    next >
C/C++ Source or Header  |  1995-04-24  |  22KB  |  805 lines

  1. /*
  2.  *  Source machine generated by GadToolsBox V2.0b
  3.  *  which is (c) Copyright 1991-1993 Jaba Development
  4.  *
  5.  *  GUI Designed by : -- Heinz Reinert --
  6.  */
  7.  
  8. #include <exec/types.h>
  9. #include <intuition/intuition.h>
  10. #include <intuition/classes.h>
  11. #include <intuition/classusr.h>
  12. #include <intuition/imageclass.h>
  13. #include <intuition/gadgetclass.h>
  14. #include <libraries/gadtools.h>
  15. #include <graphics/displayinfo.h>
  16. #include <graphics/gfxbase.h>
  17. #include <clib/exec_protos.h>
  18. #include <clib/intuition_protos.h>
  19. #include <clib/gadtools_protos.h>
  20. #include <clib/graphics_protos.h>
  21. #include <clib/utility_protos.h>
  22. #include <proto/intuition.h>
  23. #include <proto/graphics.h>
  24. #include <proto/exec.h>
  25. #include <proto/dos.h>
  26. #include <proto/gadtools.h>
  27. #include <exec/memory.h>
  28. #include <string.h>
  29.                                     
  30.  
  31. #define GetString( g )      ((( struct StringInfo * )g->SpecialInfo )->Buffer  )
  32. #define GetNumber( g )      ((( struct StringInfo * )g->SpecialInfo )->LongInt )
  33.  
  34. #define GD_list                                0
  35. #define GD_new                                 1
  36. #define GD_del                                 2
  37. #define GD_descr                               3
  38. #define GD_command1                            4
  39. #define GD_command2                            5
  40. #define GD_command3                            6
  41. #define GD_save                                7
  42. #define GD_runa                                8
  43. #define GD_run3                                9
  44. #define GD_run2                                10
  45. #define GD_run1                                11
  46.  
  47. #define GDX_list                               0
  48. #define GDX_new                                1
  49. #define GDX_del                                2
  50. #define GDX_descr                              3
  51. #define GDX_command1                           4
  52. #define GDX_command2                           5
  53. #define GDX_command3                           6
  54. #define GDX_save                               7
  55. #define GDX_runa                               8
  56. #define GDX_run3                               9
  57. #define GDX_run2                               10
  58. #define GDX_run1                               11
  59.  
  60. #define Project0_CNT 12
  61. UBYTE *vers = "\0$VER: RunList 3";
  62.  
  63. extern struct IntuitionBase *IntuitionBase;
  64. extern struct Library       *GadToolsBase;
  65.  
  66. extern struct Screen        *Scr;
  67. extern UBYTE                 *PubScreenName;
  68. extern APTR                  VisualInfo;
  69. extern struct Window        *Project0Wnd;
  70. extern struct Gadget        *Project0GList;
  71. extern struct Gadget        *Project0Gadgets[12];
  72. extern UWORD                 Project0Left;
  73. extern UWORD                 Project0Top;
  74. extern UWORD                 Project0Width;
  75. extern UWORD                 Project0Height;
  76. extern UBYTE                *Project0Wdt;
  77. extern struct TextAttr       topaz11;
  78. extern UWORD                 Project0GTypes[];
  79. extern struct NewGadget      Project0NGad[];
  80. extern ULONG                 Project0GTags[];
  81.  
  82. extern int SetupScreen( void );
  83. extern void CloseDownScreen( void );
  84. extern int OpenProject0Window( void );
  85. extern void CloseProject0Window( void );
  86.  
  87.  
  88. struct Screen         *Scr = NULL;
  89. UBYTE                 *PubScreenName = NULL;
  90. APTR                   VisualInfo = NULL;
  91. struct Window         *Project0Wnd = NULL;
  92. struct Gadget         *Project0GList = NULL;
  93. struct Gadget         *Project0Gadgets[12];
  94. UWORD                  Project0Left = 330;
  95. UWORD                  Project0Top = 10;
  96. UWORD                  Project0Width = 314;
  97. UWORD                  Project0Height = 0;
  98. UBYTE                 *Project0Wdt = (UBYTE *)"RunList i 3";
  99.  
  100. struct TextAttr topaz11 = {
  101.                  ( STRPTR )"topaz.font", 11, 0x00, 0x01 };
  102.  
  103. UWORD Project0GTypes[] = {
  104.         LISTVIEW_KIND,
  105.         BUTTON_KIND,
  106.         BUTTON_KIND,
  107.         STRING_KIND,
  108.         STRING_KIND,
  109.         STRING_KIND,
  110.         STRING_KIND,
  111.         BUTTON_KIND,
  112.         BUTTON_KIND,
  113.         BUTTON_KIND,
  114.         BUTTON_KIND,
  115.         BUTTON_KIND
  116. };
  117.  
  118. struct NewGadget Project0NGad[] = {
  119.         8, 10, 198, 140, NULL, NULL, GD_list, 0, NULL, NULL,
  120.         212, 10, 72, 15, (UBYTE *)"NEW", NULL, GD_new, PLACETEXT_IN, NULL, NULL,
  121.         212, 25, 72, 15, (UBYTE *)"DELETE", NULL, GD_del, PLACETEXT_IN, NULL, NULL,
  122.         8, 146, 198, 19, NULL, NULL, GD_descr, 0, NULL, NULL,
  123.         8, 172, 277, 19, NULL, NULL, GD_command1, 0, NULL, NULL,
  124.         8, 192, 277, 19, NULL, NULL, GD_command2, 0, NULL, NULL,
  125.         8, 212, 277, 19, NULL, NULL, GD_command3, 0, NULL, NULL,
  126.         212, 40, 72, 15, (UBYTE *)"SAVE", NULL, GD_save, PLACETEXT_IN, NULL, NULL,
  127.         212, 55, 72, 65, (UBYTE *)"RUN ALL", NULL, GD_runa, PLACETEXT_IN, NULL, NULL,
  128.         212, 150, 72, 15, (UBYTE *)"RUN 3", NULL, GD_run3, PLACETEXT_IN, NULL, NULL,
  129.         212, 135, 72, 15, (UBYTE *)"RUN 2", NULL, GD_run2, PLACETEXT_IN, NULL, NULL,
  130.         212, 120, 72, 15, (UBYTE *)"RUN 1", NULL, GD_run1, PLACETEXT_IN, NULL, NULL
  131. };
  132.  
  133. ULONG Project0GTags[] = {
  134.         (TAG_DONE),
  135.         (TAG_DONE),
  136.         (TAG_DONE),
  137.         (GTST_MaxChars), 256, (TAG_DONE),
  138.         (GTST_MaxChars), 256, (TAG_DONE),
  139.         (GTST_MaxChars), 256, (TAG_DONE),
  140.         (GTST_MaxChars), 256, (TAG_DONE),
  141.         (TAG_DONE),
  142.         (TAG_DONE),
  143.         (TAG_DONE),
  144.         (TAG_DONE),
  145.         (TAG_DONE)
  146. };
  147.  
  148. int SetupScreen( void )
  149. {
  150.         if ( ! ( Scr = LockPubScreen( PubScreenName )))
  151.                 return( 1L );
  152.  
  153.         if ( ! ( VisualInfo = GetVisualInfo( Scr, TAG_DONE )))
  154.                 return( 2L );
  155.  
  156.         return( 0L );
  157. }
  158.  
  159. void CloseDownScreen( void )
  160. {
  161.         if ( VisualInfo ) {
  162.                 FreeVisualInfo( VisualInfo );
  163.                 VisualInfo = NULL;
  164.         }
  165.  
  166.         if ( Scr        ) {
  167.                 UnlockPubScreen( NULL, Scr );
  168.                 Scr = NULL;
  169.         }
  170. }
  171.  
  172. int OpenProject0Window( void )
  173. {
  174.         struct NewGadget        ng;
  175.         struct Gadget   *g;
  176.         UWORD           lc, tc;
  177.         UWORD           offx = Scr->WBorLeft, offy = Scr->WBorTop + Scr->RastPort.TxHeight + 1;
  178.  
  179.         if ( ! ( g = CreateContext( &Project0GList )))
  180.                 return( 1L );
  181.  
  182.         for( lc = 0, tc = 0; lc < Project0_CNT; lc++ ) {
  183.  
  184.                 CopyMem((char * )&Project0NGad[ lc ], (char * )&ng, (long)sizeof( struct NewGadget ));
  185.  
  186.                 ng.ng_VisualInfo = VisualInfo;
  187.                 ng.ng_TextAttr   = &topaz11;
  188.                 ng.ng_LeftEdge  += offx;
  189.                 ng.ng_TopEdge   += offy;
  190.  
  191.                 Project0Gadgets[ lc ] = g = CreateGadgetA((ULONG)Project0GTypes[ lc ], g, &ng, ( struct TagItem * )&Project0GTags[ tc ] );
  192.  
  193.                 while( Project0GTags[ tc ] ) tc += 2;
  194.                 tc++;
  195.  
  196.                 if ( NOT g )
  197.                         return( 2L );
  198.         }
  199.  
  200.  
  201.         if ( ! ( Project0Wnd = OpenWindowTags( NULL,
  202.                                 WA_Left,        Project0Left,
  203.                                 WA_Top,         Project0Top,
  204.                                 WA_Width,       Project0Width,
  205.                                 WA_Height,      Project0Height + offy,
  206.                                 WA_IDCMP,       LISTVIEWIDCMP|
  207.                                                 BUTTONIDCMP|
  208.                                                 STRINGIDCMP|
  209.                                                 IDCMP_NEWSIZE|
  210.                                                 IDCMP_CLOSEWINDOW|
  211.                                                 IDCMP_CHANGEWINDOW|
  212.                                                 IDCMP_INTUITICKS |
  213.                                                 IDCMP_MOUSEBUTTONS|
  214.                                                 IDCMP_REFRESHWINDOW,
  215.                                 WA_Flags,       WFLG_SIZEGADGET|
  216.                                                 WFLG_DRAGBAR|
  217.                                                 WFLG_DEPTHGADGET|
  218.                                                 WFLG_CLOSEGADGET|
  219.                                                 WFLG_SMART_REFRESH,
  220.                                 WA_Gadgets,     Project0GList,
  221.                                 WA_Title,       Project0Wdt,
  222.                                 WA_ScreenTitle, "RunList i 3 © Heinz Reinert 1995",
  223.                                 WA_PubScreen,   Scr,
  224.                                 WA_MinWidth,    314,
  225.                                 WA_MinHeight,   252,
  226.                                 WA_MaxWidth,    314,
  227.                                 WA_MaxHeight,   252,
  228.                                 TAG_DONE )))
  229.         return( 4L );
  230.  
  231.         GT_RefreshWindow( Project0Wnd, NULL );
  232.  
  233.         return( 0L );
  234. }
  235.  
  236. void CloseProject0Window( void )
  237. {
  238.         if ( Project0Wnd        ) {
  239.                 CloseWindow( Project0Wnd );
  240.                 Project0Wnd = NULL;
  241.         }
  242.  
  243.         if ( Project0GList      ) {
  244.                 FreeGadgets( Project0GList );
  245.                 Project0GList = NULL;
  246.         }
  247. }
  248.  
  249. /*
  250.  * Struktur für einen Datenbankeintrag
  251.  */
  252.  
  253. struct VDB {
  254.     char    Name[30];
  255.     char    list[256];
  256.     USHORT  new;
  257.     USHORT  del;
  258.     char    command1[81], command2[81], command3[81];
  259.     USHORT  save;
  260.     USHORT  runa;
  261.     USHORT  run3;
  262.     USHORT  run2;
  263.     USHORT  run1;
  264.                             
  265. };
  266.  
  267.  
  268.  
  269. struct VDBnode {
  270.         struct  Node n; /*** Für Liste    ***/
  271.         struct  VDB d;  /*** VDB-Struktur ***/
  272. };
  273.  
  274. /*
  275.  * Flags
  276.  */
  277.  
  278. #define VDBF_STEREO             1
  279.  
  280. /*
  281.  *
  282.  * In dieser Liste befinden sich die VDB-Nodes
  283.  *
  284.  */
  285.  
  286. struct List vdblist;
  287.  
  288. /*
  289.  * Der aktuelle Eintrag
  290.  */
  291.  
  292. struct VDBnode *currentprj;
  293.  
  294. /*
  295.  * Die von der Gadtoolsbox erzeugten Header
  296.  */
  297.  
  298.  
  299. /*
  300.  *
  301.  * Die Hilfsroutinen
  302.  *
  303.  */
  304.  
  305. /*
  306.  * Allgemeine Gadgets
  307.  */
  308.  
  309. /*
  310.  *      Gadtools-Gadget einschalten
  311.  */
  312. void gt_OnGadget( struct Gadget         *gad,
  313.                                   struct Window         *w )
  314. {
  315.         GT_SetGadgetAttrs( gad, w, NULL, GA_DISABLED, FALSE, TAG_DONE );
  316. }
  317. /*
  318.  *      ...und wieder aus...
  319.  */
  320. void gt_OffGadget( struct Gadget        *gad,
  321.                                    struct Window        *w )
  322. {
  323.         GT_SetGadgetAttrs( gad, w, NULL, GA_DISABLED, TRUE, TAG_DONE );
  324. }
  325.  
  326.  
  327. /*
  328.  *  String-Gadgets
  329.  */
  330. void gt_SetString( struct Gadget        *gad,
  331.                                    struct Window        *w,
  332.                                    char                         *string )
  333. {
  334.         GT_SetGadgetAttrs( gad, w, NULL, GTST_String, string, TAG_DONE );
  335. }
  336.  
  337. char * gt_GetString( struct Gadget      *gad )
  338. {
  339.         struct StringInfo *si = gad->SpecialInfo;
  340.  
  341.         if( si )
  342.                 return( ( char * ) si->Buffer );
  343.         else
  344.                 return( NULL );
  345. }
  346.  
  347. /*
  348.  * Listenverwaltung für Listview-Gadgets
  349.  */
  350.  
  351. /*
  352.  * Liste anhängen
  353.  * "list" kann ~0 (-1) sein, dann ist kein Listenzugriff möglich
  354.  */
  355.  
  356. void gt_AttachList(     struct Gadget   *lv,
  357.                                         struct Window   *w,
  358.                                         struct List     *list )
  359. {
  360.         GT_SetGadgetAttrs( lv, w, NULL, GTLV_Labels, list, TAG_DONE );
  361. }
  362.  
  363. /*
  364.  *  Aktuellen Eintrag setzen
  365.  */
  366. void gt_SetLV( struct Gadget    *gad,
  367.                            struct Window        *w,
  368.                            ULONG                        value)
  369. {
  370.         GT_SetGadgetAttrs( gad, w, NULL, GTLV_Selected, value, TAG_DONE );
  371. }
  372.  
  373. /*
  374.  * x-ten Eintrag aus einer Exec-Liste holen
  375.  */
  376. struct Node * gt_GetListEntry( struct List *l,
  377.                                                            int num )
  378. {
  379.         int count = 0;
  380.         struct Node *n = l->lh_Head;
  381.  
  382.         while( n->ln_Succ )
  383.         {
  384.                 if( num==count ) return( n );
  385.                 n = n->ln_Succ;
  386.                 count++;
  387.         }
  388.         return( NULL );
  389. }
  390. /*
  391.  * Nummer einer Node aus einer Liste feststellen
  392.  * -1 falls nicht in Liste
  393.  */
  394. int gt_GetListEntryNum( struct List *l,
  395.                                                 struct Node *n )
  396. {
  397.         int count = 0;
  398.         struct Node *r = l->lh_Head;
  399.  
  400.         while( r->ln_Succ )
  401.         {
  402.                 if( r==n ) return( count );
  403.                 r = r->ln_Succ;
  404.                 count++;
  405.         }
  406.         return( -1 );
  407. }
  408. /*
  409.  * Anzahl Einträge einer Liste zählen
  410.  */
  411. int gt_GetListNumEntries( struct List *l )
  412. {
  413.         int count = 0;
  414.         struct Node *n = l->lh_Head;
  415.  
  416.         while( n->ln_Succ )
  417.         {
  418.                 n = n->ln_Succ;
  419.                 count++;
  420.         }
  421.  
  422.         return( count );
  423. }
  424.  
  425. /************************************************************************/
  426.  
  427. /*
  428.  *
  429.  *  Liste laden
  430.  *
  431.  */
  432.  
  433. void loadprjlist( void )
  434. {
  435.         struct VDB new;
  436.         struct VDBnode *n;
  437.         BPTR f;
  438.  
  439.         /*** Liste initialisieren ***/
  440.         NewList( &vdblist );
  441.         currentprj = NULL;
  442.  
  443.         /*** Datei öffnen ***/
  444.         f = Open( "S:List.DAT", MODE_OLDFILE );
  445.         if( !f )
  446.                 return;
  447.  
  448.         /*** Einträge einlesen */
  449.         while( Read( f, &new, sizeof( new ) ) == sizeof( new ) )
  450.         {
  451.                 /*** newe Node ***/
  452.                 n = AllocVec( sizeof( *n ), 0 );
  453.                 if( !n )
  454.                         break;
  455.  
  456.                 /*** Struktur kopieren und an Liste anhängen ***/
  457.                 n->d = new;
  458.                 n->n.ln_Name = n->d.Name;
  459.                 n->n.ln_Pri      = - n->d.Name[0];
  460.                 Enqueue( &vdblist, (struct Node *) n );
  461.         }
  462.  
  463.         Close( f );
  464. }
  465.  
  466. /*
  467.  *      Liste speichern und freigeben 
  468.  */
  469.  
  470. void save_and_freeprjlist(void )
  471. {
  472.         struct VDBnode *n;
  473.         BPTR f;
  474.  
  475.         f = Open( "S:List.DAT", MODE_NEWFILE );
  476.  
  477.         while( ( n = (struct VDBnode * ) RemHead( &vdblist ) ) )
  478.         {
  479.                 /*** Node speichern... ***/
  480.                 if( f )
  481.                         Write( f, &n->d, sizeof( struct VDB ) );
  482.  
  483.                 /*** ...und freigeben ***/
  484.                 FreeVec( n );
  485.         }
  486.  
  487.         if( f )
  488.                 Close( f );
  489. }
  490.  
  491.  
  492. /************************************************************************/
  493.  
  494. /*
  495.  * Schaltet die Gadgets mit Ausnahme der Liste ein oder aus
  496.  * abhängig davon, ob gerade ein Listeneintrag aktiviert ist
  497.  * oder nicht
  498.  *
  499.  */
  500.  
  501. void checkonoff( void )
  502. {
  503.         int c;
  504.  
  505.         if( currentprj )
  506.         {
  507.                 for( c = GD_del; c < Project0_CNT; c++ )
  508.                         gt_OnGadget( Project0Gadgets[c], Project0Wnd );
  509.         }
  510.         else
  511.         {
  512.                 for( c = GD_del; c < Project0_CNT; c++ )
  513.                         gt_OffGadget( Project0Gadgets[c], Project0Wnd );
  514.         }
  515.  
  516. }
  517.  
  518. /*
  519.  *
  520.  *  Trägt die Werte aus der aktuellen Struktur in die
  521.  *  Gadgets ein
  522.  *
  523.  */
  524.  
  525. void setgadvals( void )
  526. {
  527.  
  528.         if( !currentprj )
  529.                 return;
  530.  
  531.         gt_SetString(   Project0Gadgets[ GD_descr ], Project0Wnd,
  532.                                                    currentprj->d.Name );
  533.         gt_SetString(   Project0Gadgets[ GD_command1 ], Project0Wnd,
  534.                                                    currentprj->d.command1 );
  535.         gt_SetString(   Project0Gadgets[ GD_command2 ], Project0Wnd,
  536.                                                    currentprj->d.command2 );
  537.         gt_SetString(   Project0Gadgets[ GD_command3 ], Project0Wnd,
  538.                                                    currentprj->d.command3 );
  539.  
  540.  
  541. }
  542.  
  543.  
  544. /*
  545.  *
  546.  *  Erzeugt einen neuen, leeren Eintrag 
  547.  *
  548.  */
  549.  
  550. void newvdb( void )
  551. {
  552.         struct VDBnode *new;
  553.  
  554.         new = AllocVec( sizeof( *new ), MEMF_CLEAR );
  555.  
  556.         if( !new )
  557.                 return;
  558.  
  559.         currentprj = new;
  560.  
  561.         new->n.ln_Name = new->d.Name;
  562.  
  563.         strcpy( new->d.Name, "new" );
  564.  
  565.         gt_AttachList( Project0Gadgets[GD_list], Project0Wnd, (struct List *) ~0 );
  566.  
  567.         new->n.ln_Pri    = - new->d.Name[0];
  568.         Enqueue( &vdblist, (struct Node *) new );
  569.  
  570.         gt_AttachList( Project0Gadgets[GD_list], Project0Wnd, &vdblist );
  571.  
  572.         gt_SetLV( Project0Gadgets[GD_list], Project0Wnd, gt_GetListEntryNum( &vdblist, new ) );
  573.         checkonoff();
  574.         setgadvals();
  575. }
  576.  
  577.  
  578.  
  579. /*
  580.  *      Gadget-Event bearbeiten
  581.  */
  582.  
  583. void dogadup( struct IntuiMessage *im )
  584. {
  585.         struct Gadget *g = im->IAddress;
  586.  
  587.         switch( g->GadgetID )
  588.         {
  589.  
  590. /*** Ein Listeneintrag ***/
  591. case GD_list:
  592.         currentprj = (struct VDBnode *) gt_GetListEntry( &vdblist, im->Code );
  593.         checkonoff();
  594.         setgadvals();
  595.         break;
  596.  
  597. /*** new ***/
  598. case GD_new:
  599.         newvdb();
  600.         break;
  601.  
  602. /*** Löschen ***/
  603. case GD_del:
  604.         if( currentprj )
  605.         {
  606.                 gt_AttachList( Project0Gadgets[ GD_list ], Project0Wnd, (struct List *) ~0 );
  607.                 Remove( currentprj );
  608.                 FreeVec( currentprj );
  609.                 currentprj = FALSE;
  610.                 checkonoff();
  611.                 gt_AttachList( Project0Gadgets[ GD_list ], Project0Wnd, &vdblist );
  612.                 gt_SetLV( Project0Gadgets[ GD_list ], Project0Wnd, ~0 );
  613.         }
  614.         break;
  615.  
  616. /*** KassettenName ***/
  617. case GD_descr:
  618.         if( currentprj )
  619.         {
  620.                 gt_AttachList( Project0Gadgets[ GD_list ], Project0Wnd, (struct List *) ~0 );
  621.                 strcpy( currentprj->d.Name, gt_GetString( Project0Gadgets[ GD_descr ] ) );
  622.                 gt_AttachList( Project0Gadgets[ GD_list ], Project0Wnd, &vdblist );
  623.         }
  624.         checkonoff();
  625.         break;
  626.  
  627.  
  628. case GD_command1:
  629.         if( currentprj )
  630.         {
  631.                 strcpy( currentprj->d.command1, gt_GetString( Project0Gadgets[ GD_command1 ] ) );
  632.         }
  633.         checkonoff();
  634.         break;
  635.  
  636. case GD_command2:
  637.         if( currentprj )
  638.         {
  639.                 strcpy( currentprj->d.command2, gt_GetString( Project0Gadgets[ GD_command2 ] ) );
  640.         }
  641.         checkonoff();
  642.         break;
  643.  
  644. case GD_command3:
  645.         if( currentprj )
  646.         {
  647.                strcpy( currentprj->d.command3, gt_GetString( Project0Gadgets[ GD_command3 ] ) );
  648.         }
  649.         checkonoff();
  650.         break;
  651.  
  652. case GD_runa:
  653.         {
  654.             Execute(currentprj->d.command1, NULL, Output());
  655.             Execute(currentprj->d.command2, NULL, Output());
  656.             Execute(currentprj->d.command3, NULL, Output());
  657.         }
  658.         checkonoff();
  659.         break;
  660.  
  661. case GD_run1:
  662.         {
  663.             Execute(currentprj->d.command1, NULL, Output());
  664.         }
  665.         checkonoff();
  666.         break;
  667.  
  668. case GD_run2:
  669.         {
  670.             Execute(currentprj->d.command2, NULL, Output());
  671.         }
  672.         checkonoff();
  673.         break;
  674.  
  675. case GD_run3:
  676.         {
  677.             Execute(currentprj->d.command3, NULL, Output());
  678.         }
  679.         checkonoff();
  680.         break;
  681.  
  682. case GD_save:
  683.         {
  684.             save_and_freeprjlist();
  685.             loadprjlist();
  686.         }
  687.         checkonoff();
  688.         break;
  689.         }
  690. }
  691.  
  692.  
  693. /*
  694.  * Programmstart
  695.  */
  696.  
  697. int main( void )
  698. {
  699.         struct IntuiMessage     *im,imsg;
  700.         BOOL   Done = FALSE;
  701.  
  702.         USHORT code;           /* Code. */
  703.         ULONG seconds, micros; /* Time. */
  704.  
  705.         /* Declare and initialize the time stamps: */
  706.         ULONG sec1 = 0;
  707.         ULONG mic1 = 0;
  708.         ULONG sec2 = 0;
  709.         ULONG mic2 = 0;
  710.  
  711.         /*** Bildschirm und Fenster öffnen ***/
  712.         SetupScreen();
  713.         OpenProject0Window();
  714.  
  715.         /*** Liste laden ***/
  716.         loadprjlist();
  717.  
  718.         /*** Liste anzeigen ***/
  719.         gt_AttachList( Project0Gadgets[GD_list], Project0Wnd, &vdblist );
  720.  
  721.         /*** Gadgets setzen ***/
  722.         checkonoff();
  723.  
  724.         /*** Hauptschleife ***/
  725.         while( !Done )
  726.         {
  727.  
  728.                 /*** Auf IntuiMessage warten ***/
  729.                 while( !( im=GT_GetIMsg( Project0Wnd->UserPort ) ) )
  730.                         WaitPort( Project0Wnd->UserPort );
  731.  
  732.                         code    = im->Code;
  733.                         seconds = im->Seconds;
  734.                         micros  = im->Micros;
  735.  
  736.                 /*** Kopieren ***/
  737.                 imsg = *im;
  738.                 GT_ReplyIMsg( im );             
  739.  
  740.                 switch( imsg.Class )
  741.                 {
  742.  
  743.                         /*** CLOSEWINDOW: Fenster schließen? ***/
  744.                         case IDCMP_CLOSEWINDOW:
  745.                                 Done = TRUE;
  746.                                 break;
  747.  
  748.                         /*** Gadgetup; ein Gadget wurde ausgewählt ***/
  749.                         /*** Wir bearbeiten Gadget-Events in einer ***/
  750.                         /*** eigenen Routine                                       ***/
  751.                         case GADGETUP:
  752.                                 dogadup( &imsg );
  753.                                 break;
  754.  
  755.  
  756.                         case IDCMP_MOUSEBUTTONS: /* The user pressed/released a mouse button. */
  757.                                 if( code == SELECTDOWN )
  758.                                 {
  759.                                    /* Left button pressed. */
  760.  
  761.                                    /* Save the old time: */
  762.                                     sec2 = sec1;
  763.                                     mic2 = mic1;
  764.  
  765.                                    /* Get the new time: */
  766.                                     sec1 = seconds;
  767.                                     mic1 = micros;
  768.  
  769.                                    /* Check if it was a double-click or not: */
  770.                                 if( DoubleClick( sec2, mic2, sec1, mic1 ) )
  771.                                 {
  772.                                     Execute("RUN >NIL: Shellwin ", NULL, Output());
  773.                                    /* Reset the values: */
  774.                                     sec1 = 0;
  775.                                     mic1 = 0;
  776.                                     }
  777.                                 }
  778.                                 break;    
  779.  
  780.  
  781.  
  782.                         /*** REFRESH: Grafikobjekte (Boxen) neu zeichnen ***/
  783.                         case IDCMP_REFRESHWINDOW:
  784.                                 GT_BeginRefresh( Project0Wnd );
  785.                                 GT_EndRefresh( Project0Wnd, TRUE );
  786.                                 break;
  787.  
  788.  
  789.                 }
  790.  
  791.         }
  792.  
  793.         /*** Fenster und Bildschirm wieder schließen ***/       
  794.         CloseProject0Window();
  795.         CloseDownScreen();
  796.  
  797.  
  798.         return(0);
  799. }
  800.     
  801.  
  802.  
  803.   
  804.  
  805.