home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 199.lha / GimmeLib / test.c < prev    next >
Encoding:
C/C++ Source or Header  |  1988-12-28  |  20.7 KB  |  780 lines
  1. #include <stdio.h>
  2. #include "gimmelib/gimmeall.h"
  3. #define GIM_BUILTIN
  4. #include "gimmelib/macros.h"
  5.  
  6. /***
  7.  *  NOTE: graphing from a subtask does not work
  8.  *  unfortunately I haven't figured out why yet!!
  9.  *
  10.  *
  11.  *  this looks more complicated than it is --
  12.  *  it's just that there are a lot of options for different features to demo
  13.  *  just think of all the left-aligned if-statements, like this:
  14.  *    if( COLOR ) {
  15.  *        ...
  16.  *    } comment COLOR comment
  17.  *  as equivalent to
  18.  *    #ifdef COLOR
  19.  *        ...
  20.  *    #endif COLOR
  21.  *
  22.  *  As a matter of fact, that's what they were but I hated recompiling
  23.  *  all the time for different options, so I changed them.
  24.  */
  25.  
  26.  
  27. #define SBMDEPTH    3
  28.  
  29. #define IDCMP_FLAGS    (CLOSEWINDOW | GADGETUP | GADGETDOWN | MENUPICK)
  30. #define WIN_FLAGS    (ACTIVATE | BACKDROP | BORDERLESS | WINDOWCLOSE \
  31.                 | SMART_REFRESH | NOCAREREFRESH | RMBTRAP)
  32.  
  33. #define STDSTUFF    (GSS_INTUITION | GSS_GFX | GSS_DISKFONT | GSS_TIMER \
  34.                 | GSS_SUBTASK | GSS_MEMCHAIN | GSS_DISABLEABORT)
  35.  
  36. #define SYS_GADG    0    /* system gadget -- do not use for my IDs */
  37. #define BOOL_GADG    1
  38. #define CLEAR_GADG    2
  39. #define BOOL_TOG_GADG    3
  40. #define BOOL_IMAG_GADG    4
  41. #define STRING_GADG    5
  42. #define STRING_INT_GADG 6
  43. #define PROP_H_GADG    7
  44. #define PROP_V_GADG    8
  45. #define H_SCROLLBAR    9
  46. #define V_SCROLLBAR    10
  47. #define ONESCROLL1    100    /* secondary gadgets */
  48. #define ONESCROLL2    101
  49.  
  50. #define MAX_GADG    10
  51. #define FIRST_GADG    BOOL_GADG-1
  52.  
  53. #define DI_Z        2    /* size of image data below */
  54. #define DI_X        64
  55. #define DI_Y        5
  56.  
  57. USHORT firstImageData[] = {        /* garbage image */
  58.     0x0110, 0x3420, 0x7862, 0xefca,
  59.     0x0110, 0x3420, 0x7862, 0xefca,
  60.     0x0110, 0x3420, 0x7862, 0xefca,
  61.     0x0110, 0x3420, 0x7862, 0xefca,
  62.     0x0110, 0x3420, 0x7862, 0xefca,
  63.  
  64.     0x0435, 0x3428, 0x7092, 0xe97a,
  65.     0x0110, 0x3440, 0x7062, 0xef34,
  66.     0x2340, 0x3445, 0x7060, 0xef4a,
  67.     0x0150, 0x3420, 0x7862, 0xe4ca,
  68.     0x0140, 0x6520, 0x7782, 0xef56
  69.   };
  70.  
  71. struct TextAttr ta = {
  72.     (STRPTR) "topaz.font",
  73.     9,
  74.     FS_NORMAL,
  75.     FPF_DISKFONT
  76.   };
  77.  
  78. NEWGRAPH newgraph = {
  79.     (UBYTE *) "GIMME GRAPH", (UBYTE *) "howdy! any luck?",
  80.     (UBYTE *) "MONEY $$$",
  81.     NULL, NULL, &ta,
  82.     GIM_RED, GIM_BLACK, GIM_CYAN, GIM_YELLOW,
  83.     GGR_FILLTOX | GGR_BLACKTOX | GGR_X_SPACING | GGR_Y_MAX,
  84.     GGR_INITORIGIN | GGR_HIRES | GGR_NOCLEARSTART,
  85.     {70, 200,  0, 2,  0,  0, 1, 1},
  86.     {100, 60,  0, 100,    0,  0, 2, 1},
  87.     NULL
  88.   };
  89.  
  90. #define NUM_COORDS1    5
  91. SHORT graphData[NUM_COORDS1][2] = {
  92.     03, 10,
  93.     16, 25,
  94.     29, 40,
  95.     48, 90,
  96.     82, 30
  97.   };
  98.  
  99. struct Screen *Screen = NULL;
  100. struct Window *BackWindow = NULL;
  101. struct Window *MyWindow = NULL;
  102. struct Window *SubWindow = NULL;
  103. struct BitMap *secbm = NULL;
  104. SHORT SWidth = 0, SHeight = 0;
  105. ULONG winflags = WIN_FLAGS;
  106.  
  107. struct Gadget *gadg[MAX_GADG];        /* initialize later */
  108. struct Requester *request = NULL;
  109.  
  110. struct TextFont *tf = NULL;
  111.  
  112. struct IOStdReq *inputIOreq = NULL;
  113.  
  114. GRAPH *mygraph = NULL;
  115. struct Task *mysubtask = NULL;
  116. struct Menu *menustrip = NULL;
  117.  
  118.  
  119. BYTE COLOR = 0, FONT = 0, GADGET = 0, MENU = 0, MYGRAPH = 0, POSTEXT = 0;
  120. BYTE REQUESTER = 0, SUBTASK = 0, TIMER = 0, WINDOW = 0;
  121. BYTE DBUF = 0, INPHAND = 0;
  122.  
  123.  
  124. /* forward declarations */
  125. struct Screen *initscreen();
  126. HandlerInterface();
  127. subtaskRoutine();
  128.  
  129.  
  130. main( argc, argv )
  131.     int argc;
  132.     char **argv;
  133. {
  134.     register char   *temp;
  135.     char        *fontname = NULL;
  136.     SHORT        fontsize = 0;
  137.     register SHORT  i;
  138.  
  139.     if( argc < 2 ) {
  140.     help( argc, argv );
  141.     } else {
  142.     for( i = 1; i < argc; ++i ) {
  143.         temp = argv[i];
  144.         if( *temp == '-' ) {
  145.         ++temp;
  146. next_flag: {}
  147.         switch( tolower(*temp) ) {
  148.           case 'c':
  149.             COLOR = 1; break;
  150.           case 'd':
  151.             DBUF = 1; break;
  152.           case 'f':
  153.             FONT = 1; break;
  154.           case 'g':
  155.             GADGET = 1; break;
  156.           case 'h':
  157.           case '?':
  158.             help(); break;
  159.           case 'i':
  160.             INPHAND = 1; break;
  161.           case 'j':
  162.             MYGRAPH = 1; break;
  163.           case 'm':
  164.             MENU = 1; break;
  165.           case 'p':
  166.             POSTEXT = 1; break;
  167.           case 'r':
  168.             REQUESTER = 1; break;
  169.           case 's':
  170.             SUBTASK = 1; break;
  171.           case 't':
  172.             TIMER = 1; break;
  173.           case 'w':
  174.             WINDOW = 1; break;
  175.           default:
  176.             printf("unknown option '%c' ignored\n", *temp);
  177.             break;
  178.         } /* switch */
  179.         if( *(++temp) ) {
  180.             goto next_flag;
  181.         }
  182.         } else if( !fontname ) {
  183.         fontname = temp;
  184.         if( argv[i+1][0] != '-' ) {
  185.             fontsize = atoi( argv[++i] );
  186.         }
  187.         } else {
  188.         help( argc, argv );
  189.         }
  190.     } /* for */
  191.     }
  192.     if( fontname ) {
  193.     ta.ta_Name = (STRPTR) fontname;
  194.     if( fontsize ) {
  195.         ta.ta_YSize = fontsize;
  196.     }
  197.     }
  198.     if( !openStuff() ) {
  199.     runIt( argc, argv, BackWindow );
  200.     }
  201.     cleanUp();
  202. } /* main */
  203.  
  204.  
  205. help( argc, argv )
  206.     int argc;
  207.     char **argv;
  208. {
  209.     printf( "Usage: %s -cdfgihjmprstw? [name.font [size]]\n"
  210.         "     -c    : color (use gimme.lib palette)\n"
  211.         "     -d    : double buffer screen (not too pretty w/ Intuition)\n"
  212.         "     -f    : font (use another font)\n"
  213.         "     -g    : gadget\n"
  214.         "     -h    : help -- this info (also -?)\n"
  215.         "     -i    : input handler (make RMB work like LMB)\n"
  216.         "     -j    : graph Jan Sven\n"
  217.         "     -m    : menu\n"
  218.         "     -p    : postext (position text routine demo)\n"
  219.         "     -r    : requester\n"
  220.         "     -s    : subtask\n"
  221.         "     -t    : timer\n"
  222.         "     -w    : window\n"
  223.         "  note: mix&match options to demo features of gimme.lib\n",
  224.         argv[0]);
  225.     exit( 0 );
  226. } /* help */
  227.  
  228.  
  229. openStuff()
  230. {
  231.     struct NewWindow    *nw;
  232.     struct Gadget    *gp;
  233.     struct Image    *ip;
  234.     struct Window    *tempw;
  235.     struct MenuItem    *menuitem;
  236.     ULONG        flag;
  237.     SHORT        x, y;
  238.     register SHORT    i;
  239.  
  240.     flag = gimmeStdStuff( STDSTUFF, GSS_REVISION );
  241.     if( flag ) {
  242.     printf("openStuff: can't open standard thing for flag 0x0%lx\n", flag);
  243.     return( -1 );
  244.     }
  245. if( FONT ) {
  246.     if( !(tf = gimmeFont(&ta)) ) {      /* note: this updates ta.ta_YSize */
  247.     printf("openStuff: can't open font '%s' size %d\n",
  248.             ta.ta_Name, ta.ta_YSize);
  249.     return( -1 );
  250.     }
  251. } /* FONT */
  252.  
  253. if( MENU ) {
  254.     winflags &= ~RMBTRAP;
  255. } /* MENU */
  256.     if( !(Screen = initscreen(&BackWindow)) ) {
  257.     SystemError("can't open screen/window\n");
  258.     }
  259. if( COLOR ) {
  260.     setColors( Screen, NULL, 1 << SBMDEPTH );
  261. } /* COLOR */
  262.  
  263. if( MENU ) {
  264.     menustrip = gimmeMenu( &gimChainMem, 0, -1, "Options", MENUENABLED );
  265.     menuitem = gimmeMenuItem( &gimChainMem, 0, -1, -1, 'Q',
  266.             "Quit", tf ? &ta : NULL,
  267.             ITEMTEXT | COMMSEQ | ITEMENABLED | HIGHCOMP );
  268.     if( addMenuItem(menustrip, menuitem, 0, 0, 1, GMI_DEFAULT) == MENUNULL ) {
  269.     SystemError("can't setup menu strip\n");
  270.     }
  271.     SetMenuStrip( BackWindow, menustrip );
  272. } /* MENU */
  273.  
  274. if( WINDOW ) {
  275.     nw = gimmeNewWindow( "howdy", Screen, 310, 100,
  276.                 IDCMP_VSMART, FLAGS_VSMART );
  277.     if( !nw ) {
  278.     SystemError("can't get new window\n");
  279.     }
  280.     nw->Width = 300;
  281.     nw->Height = 100;
  282.     if( !(MyWindow = gimmeWindow(nw, 0, 0, 0)) ) {
  283.     getRidOfNewWindow( nw );
  284.     SystemError("can't open window\n");
  285.     }
  286.     getRidOfNewWindow( nw );
  287. } /* WINDOW */
  288.  
  289. if( SUBTASK ) {
  290.     /* give it a 5K stack and 1K data area */
  291.     if( !(mysubtask = gimmeSubTask(&gimSubTasks, &gimMainPort, 5000L,
  292.                     1000L, NULL)) ) {
  293.     SystemError("can't setup for subtask\n");
  294.     }
  295.     strcpy( mysubtask->tc_UserData, "guess what? I am a subtask!" );
  296. } /* SUBTASK */
  297.  
  298. if( DBUF ) {
  299.     /* double-buffering isn't the greatest thing with Intuition trying to
  300.      * display things too
  301.      */
  302.     if( makeDBuf(Screen, &secbm) ) {
  303.     printf("can't make second buffer\n");
  304.     }
  305.     swapDBuf( Screen, GIM_MINTERM_COPY );   /* so Intuition draws up front */
  306.     swapDBuf( Screen, GIM_MINTERM_DEST );
  307. } /* DBUF */
  308.  
  309.  
  310.     /* always initialize gadg[] array */
  311.     for( i = FIRST_GADG; i < MAX_GADG; ++i ) {
  312.     gadg[i] = NULL;
  313.     } /* for */
  314.  
  315. if( REQUESTER ) {
  316.     SetBPen( BackWindow->RPort, (ULONG) GIM_RED );
  317.     SetDrMd( BackWindow->RPort, (ULONG) JAM2 );
  318. } /* REQUESTER */
  319.  
  320.     /* always create these two gadgets */
  321.     gadg[BOOL_GADG-1] = gimmeBoolGadget( BackWindow, BOOL_GADG, 20, 20,
  322.                 150, -1, "end", NULL, tf ? &ta : NULL,
  323.                 GPT_DEFAULT | GPT_FULLWIDTH );
  324.     if( !gadg[BOOL_GADG-1] ) {
  325.     SystemError("can't make start gadget\n");
  326.     }
  327.     gadg[CLEAR_GADG-1] = gimmeBoolGadget( BackWindow, CLEAR_GADG, 20, 40,
  328.             -1, -1, "clear", NULL, tf ? &ta : NULL, GPT_DEFAULT );
  329.     if( !gadg[CLEAR_GADG-1] ) {
  330.     SystemError("can't make clear gadget\n");
  331.     }
  332. if( REQUESTER ) {
  333.     gadg[BOOL_GADG-1]->Activation |= ENDGADGET;
  334.     gadg[BOOL_GADG-1]->GadgetType |= REQGADGET;
  335. } /* REQUESTER */
  336.  
  337. if( GADGET ) {
  338.     SetAPen( BackWindow->RPort, (ULONG) GIM_YELLOW );
  339.     gadg[BOOL_TOG_GADG-1] = gimmeBoolGadget( BackWindow, BOOL_TOG_GADG, 200, 20,
  340.         -1, -1, "toggle", "boolean", tf ? &ta : NULL, GPT_DEFAULT );
  341.     SetAPen( BackWindow->RPort, (ULONG) GIM_WHITE );
  342.  
  343.     gadg[BOOL_IMAG_GADG-1] = gimmeBoolImageGadget( BackWindow, BOOL_IMAG_GADG,
  344.                 290, 20, GOS_BITDEPTH, GOS_BITWIDTH, GOS_BITHEIGHT,
  345.                 GPT_DEFAULT, DI_Z, DI_X, DI_Y );
  346.     if( gadg[BOOL_IMAG_GADG-1] ) {
  347.     gadg[BOOL_IMAG_GADG-1]->Flags = GADGIMAGE | GADGHNONE;
  348.     gadg[BOOL_IMAG_GADG-1]->Activation = GADGIMMEDIATE;
  349.     if( gadg[BOOL_IMAG_GADG-1]->GadgetRender ) {
  350.         copyDataImage( gimDataOneScrollLeft,
  351.             (struct Image *) gadg[BOOL_IMAG_GADG-1]->GadgetRender );
  352.     }
  353.     if( gadg[BOOL_IMAG_GADG-1]->SelectRender ) {
  354.         copyDataImage( firstImageData,
  355.             (struct Image *) gadg[BOOL_IMAG_GADG-1]->SelectRender );
  356.     }
  357.     }
  358.  
  359.     gadg[STRING_GADG-1] = gimmeStringGadget( BackWindow, STRING_GADG, 20, 70,
  360.                 150, 20, "string", NULL, tf ? &ta : NULL,
  361.                 GADGIMMEDIATE | RELVERIFY );
  362.     gadg[STRING_INT_GADG-1] = gimmeStringGadget( BackWindow, STRING_INT_GADG,
  363.             20, 110, 150, 20, "12345", "int gadg:", tf ? &ta : NULL,
  364.             GADGIMMEDIATE | RELVERIFY | LONGINT );
  365.  
  366.     SetDrMd( BackWindow->RPort, (ULONG) JAM1 );
  367.     gadg[PROP_H_GADG-1] = gimmePropGadget( BackWindow, PROP_H_GADG, 250, 50,
  368.             60, GOS_BITHEIGHT + 4, "horiz prop", tf ? &ta : NULL,
  369.             GADGIMMEDIATE | RELVERIFY, FREEHORIZ );
  370.     if( ip = gimmeImage(&gadg[PROP_H_GADG-1]->UserData,
  371.                 GOS_BITDEPTH, GOS_BITWIDTH, GOS_BITHEIGHT) ) {
  372.     copyDataImage( gimDataOneScrollLeft, ip );
  373.     gadg[PROP_H_GADG-1]->GadgetRender = (APTR) ip;
  374.     ((struct PropInfo *)gadg[PROP_H_GADG-1]->SpecialInfo)->Flags
  375.                 &= ~AUTOKNOB;
  376.     }
  377.     SetDrMd( BackWindow->RPort, (ULONG) JAM2 );
  378.  
  379.     gadg[PROP_V_GADG-1] = gimmePropGadget( BackWindow, PROP_V_GADG, 250, 70,
  380.                 10, 50, "vert prop", tf ? &ta : NULL,
  381.                 GADGIMMEDIATE | RELVERIFY,
  382.                 FREEVERT | PROPBORDERLESS );
  383.  
  384.     /* note fullscrollbar returns a linked list of 3 gadgets */
  385.     gadg[H_SCROLLBAR-1] = gimmeFullScrollBar( BackWindow, H_SCROLLBAR,
  386.                         FREEHORIZ | KNOBHIT, GSB_DEFAULT,
  387.                         ONESCROLL1+500, ONESCROLL2+500 );
  388.  
  389.     gadg[V_SCROLLBAR-1] = gimmeFullScrollBar( BackWindow, V_SCROLLBAR,
  390.                         FREEVERT | KNOBHIT, GSB_DEFAULT,
  391.                         ONESCROLL1, ONESCROLL2 );
  392.     ((struct PropInfo *)gadg[V_SCROLLBAR-1]->SpecialInfo)->VertBody = 0x0fff;
  393. } /* GADGET */
  394.  
  395.     /* link the gadgets */
  396.     if( (gp = gadg[FIRST_GADG]) ) {
  397.     for( i = FIRST_GADG + 1; i < MAX_GADG; ++i ) {
  398.         if( gadg[i] ) {
  399.         gp->NextGadget = gadg[i];
  400.         for( gp = gadg[i]; gp->NextGadget; gp = gp->NextGadget ) {
  401. if( REQUESTER ) {
  402.             gp->GadgetType |= REQGADGET;
  403. } /* REQUESTER */
  404.         } /* for */
  405. if( REQUESTER ) {
  406.         gp->GadgetType |= REQGADGET;
  407. } /* REQUESTER */
  408.         }
  409.     } /* for */
  410.     }
  411.  
  412. if( REQUESTER ) {
  413.     SetBPen( BackWindow->RPort, (ULONG) GIM_BACKGROUND );
  414.     SetDrMd( BackWindow->RPort, (ULONG) JAM1 );
  415. } /* REQUESTER */
  416.  
  417.  
  418. if( POSTEXT ) {
  419.     tempw = MyWindow ? MyWindow : BackWindow;
  420.     x = tempw->Width >> 1;
  421.     y = tempw->Height >> 1;
  422.     /* some weird horizontal text cropped on the borders */
  423.     SetAPen( tempw->RPort, (long) GIM_RED );
  424.     positionText( tempw->RPort, GPT_XLEFT | GPT_YCENTREBASE,
  425.             "left centbas", 0L, x, 0 );
  426.     SetAPen( tempw->RPort, (long) GIM_BLUE );
  427.     positionText( tempw->RPort, GPT_XCENTRE | GPT_YCENTRE,
  428.             "centre centre", 0L, x - 40, 0 );
  429.     SetAPen( tempw->RPort, (long) GIM_GREEN );
  430.     positionText( tempw->RPort, GPT_XRIGHT | GPT_YBOTTOM,
  431.             "right bot", 0L, x + 60, tempw->Height + 4 );
  432.     /* some vertical text */
  433.     SetAPen( tempw->RPort, (long) GIM_YELLOW );
  434.     positionText( tempw->RPort, GPT_YTOP | GPT_YUPWARDS | GPT_XTHICKEN,
  435.             "dflt top", 0L, x, y );
  436.     SetAPen( tempw->RPort, (long) GIM_CYAN );
  437.     positionText( tempw->RPort, GPT_YCENTRE | GPT_YDOWNWARDS | GPT_XTHICKEN,
  438.             "dflt centre", 0L, x, y );
  439.     SetAPen( tempw->RPort, (long) GIM_WHITE );
  440.     positionText( tempw->RPort, GPT_YBOTTOM | GPT_YUPWARDS,
  441.             "dflt bot", 0L, x, y );
  442.     SetAPen( tempw->RPort, (long) GIM_MAGENTA );
  443.     Move( tempw->RPort, (long) x - 20, (long) y );
  444.     Draw( tempw->RPort, (long) x + 20, (long) y );
  445.     Move( tempw->RPort, (long) x, (long) y - 20 );
  446.     Draw( tempw->RPort, (long) x, (long) y + 20 );
  447.     SetAPen( tempw->RPort, (long) GIM_WHITE );
  448. } /* POSTEXT */
  449.  
  450. if( MYGRAPH ) {
  451. if( !SUBTASK ) {
  452.     newgraph.rp = BackWindow->RPort;
  453.     if( !(mygraph = gimmeGraph(&newgraph, NULL, NULL, NULL)) ) {
  454.     printf("OpenStuff: couldn't open graph\n");
  455.     MYGRAPH = 0;
  456.     }
  457. } /* !SUBTASK */
  458. } /* MYGRAPH */
  459.  
  460. if( REQUESTER ) {
  461.     request = gimmeRequester( &gimChainMem, 0, 0, -1, -1, GIM_RED,
  462.             gadg[FIRST_GADG], "sample requester", &gimMyFont, 0L );
  463.     if( !request ) {
  464.     SystemError("can't get requester\n");
  465.     }
  466.     Request( request, BackWindow );
  467. } else {
  468.     if( gadg[FIRST_GADG] ) {
  469.     AddGList( BackWindow, gadg[FIRST_GADG], -1L, -1L, NULL );
  470.     }
  471.     RefreshGadgets( gadg[FIRST_GADG], BackWindow, NULL );
  472. } /* else !REQUESTER */
  473.  
  474. if( INPHAND ) {
  475.     if( !(inputIOreq = addInputHandler(HandlerInterface, NULL, 51, NULL)) ) {
  476.     printf("can't get input handler\n");
  477.     }
  478. } /* INPHAND */
  479.  
  480.     return( 0 );
  481. } /* openStuff */
  482.  
  483.  
  484. cleanUp()
  485. {
  486.     struct Gadget   *gp = NULL;
  487.     ULONG        flag;
  488.  
  489.     if( inputIOreq ) removeInputHandler( inputIOreq );
  490.     if( mygraph ) getRidOfGraph( mygraph );
  491.     if( BackWindow ) {
  492.     gp = findMyFirstGadget( BackWindow->FirstGadget, SYS_GADG );
  493.     }
  494.     if( gp ) {
  495.     RemoveGList( BackWindow, gp, -1L );
  496.     getRidOfGadgets( gp );
  497.     } else {
  498.     if( gadg[FIRST_GADG] ) getRidOfGadgets( gadg[FIRST_GADG] );
  499.     }
  500.     if( MyWindow ) getRidOfWindow( MyWindow );
  501.     if( Screen ) {
  502.     if( secbm ) unmakeDBuf( Screen, &secbm, secbm );
  503.     getRidOfScreen( Screen, BackWindow );
  504.     }
  505.     if( tf ) getRidOfFont( tf );
  506.     if( flag = getRidOfStdStuff(GSS_CLOSEALL) ) {
  507.     printf("cleanUp: can't close standard thing for flag 0x%0lx\n", flag);
  508.     getRidOfStdStuff( GSS_KILLALL );
  509.     }
  510. #ifdef MEMTRACE
  511.     freeall();
  512. #endif
  513. } /* cleanUp */
  514.  
  515.  
  516. SystemError( string )
  517.     char *string;
  518. {
  519.     if( Output() ) {
  520.     Write( Output(), string, (ULONG)strlen(string) );
  521.     }
  522.     cleanUp();
  523.     exit( 1 );
  524. } /* SystemError */
  525.  
  526.  
  527. int processMessage( window, class, code, iaddr )
  528.     struct Window *window;
  529.     ULONG   class;
  530.     USHORT  code;
  531.     APTR    iaddr;
  532. {
  533.     struct MenuItem *MenuItem;
  534.  
  535.     switch( class ) {
  536.       case CLOSEWINDOW:
  537.     return( -1 );
  538.     break;
  539.       case GADGETDOWN:
  540.     toggleBoolGadget( window, (struct Gadget *) iaddr, request );
  541.     break;
  542.       case GADGETUP:
  543. if( !INPHAND ) {
  544.     if( ((struct Gadget *)iaddr)->GadgetID == CLEAR_GADG ) {
  545.         clearGadgets( gadg[FIRST_GADG]->NextGadget, window, request, -1 );
  546.     }
  547. } /* !INPHAND */
  548.     break;
  549.       case MENUPICK:
  550.     while( code != MENUNULL ) {
  551.         MenuItem = ItemAddress( window->MenuStrip, (long) code );
  552.         if( MenuItem->Command == 'Q' ) {
  553.         return( -1 );
  554.         }
  555.         code = MenuItem->NextSelect;
  556.     } /* while */
  557.     break;
  558.       default:
  559.     break;
  560.     } /* switch */
  561.     return( 0 );
  562. } /* processMessage */
  563.  
  564.  
  565. runIt( argc, argv, window )
  566.     int argc;
  567.     char **argv;
  568.     struct Window *window;
  569. {
  570.     struct IntuiMessage *imsg;
  571.     ULONG   class;
  572.     USHORT  code;
  573.     APTR    iaddr;
  574.     ULONG   waitmask;
  575.     SHORT   quitflag = 0;
  576.     SHORT   i;
  577.  
  578.     waitmask = 1L << window->UserPort->mp_SigBit;
  579.     if( MyWindow ) {
  580.     waitmask |= 1L << MyWindow->UserPort->mp_SigBit;
  581.     }
  582. if( SUBTASK ) {
  583.     if( mysubtask ) {
  584.     startSubTask( mysubtask, "DEMO SUBTASK", 0, subtaskRoutine, NULL );
  585.     waitmask |= 1L << gimMainPort->mp_SigBit;
  586.     }
  587. } else {
  588. if( MYGRAPH ) {
  589.     for( i = 0; i < NUM_COORDS1; ++i ) {
  590.     addToGraph( mygraph, graphData[i][0], graphData[i][1] );
  591.     } /* for */
  592. } /* MYGRAPH */
  593.     if( gimTimerPort ) {
  594.     waitmask |= 1L << gimTimerPort->mp_SigBit;
  595.     }
  596. }/* else SUBTASK */
  597.     while( !quitflag && !Chk_Abort() ) {
  598.     Wait( waitmask );
  599.     SetWindowTitles( BackWindow, "", -1L );
  600.     while( imsg = (struct IntuiMessage *) GetMsg(window->UserPort) ) {
  601.         class = imsg->Class;
  602.         code = imsg->Code;
  603.         iaddr = imsg->IAddress;
  604.         ReplyMsg( imsg );
  605.         if( processMessage(window, class, code, iaddr) ) {
  606.         quitflag = -1;
  607.         }
  608.     } /* while */
  609.     if( MyWindow ) {
  610.         while( imsg = (struct IntuiMessage *) GetMsg(MyWindow->UserPort) ) {
  611.         class = imsg->Class;
  612.         code = imsg->Code;
  613.         iaddr = imsg->IAddress;
  614.         ReplyMsg( imsg );
  615.         if( processMessage(MyWindow, class, code, iaddr) ) {
  616.             waitmask &= ~(1L << MyWindow->UserPort->mp_SigBit);
  617.             getRidOfWindow( MyWindow );
  618.             MyWindow = NULL;
  619.             break;
  620.         }
  621.         } /* while */
  622.     }
  623.     if( gimMainPort ) {
  624.         handleSpecialSubTaskMsg( &gimSubTasks, &gimMainPort );
  625.     }
  626.     if( quitflag && gimSubTasks ) {
  627.         SetWindowTitles( BackWindow, "hey! kill subtask first", -1L );
  628.         quitflag = 0;
  629.     }
  630.     } /* while */
  631. } /* runIt */
  632.  
  633.  
  634. struct Screen *initscreen( winptr )
  635.     struct Window   **winptr;
  636. {
  637.     struct NewScreen    *ns;
  638.     struct Screen    *screen = NULL;
  639.  
  640.     ns = gimmeNewScreen( HIRES, CUSTOMSCREEN, SBMDEPTH,
  641.                 "Gimme.lib V1.2 testing", tf ? &ta : &gimMyFont );
  642.     if( ns ) {
  643.     screen = gimmeScreen( ns, winptr, SBMDEPTH, IDCMP_FLAGS, winflags );
  644.     if( screen ) {
  645.         SWidth = screen->Width;
  646.         SHeight = screen->Height;
  647. /***
  648.         ShowTitle( screen, TRUE );
  649. ***/
  650.     }
  651.     getRidOfNewScreen( ns );
  652.     }
  653.     return( screen );
  654. } /* initscreen */
  655.  
  656.  
  657. /*  example of a handler which makes the right mouse button
  658.  *  behave like the left mouse button
  659.  *  note: it's priority must be >50 (to be ahead of Intuition)
  660.  */
  661. struct InputEvent *myhandler( events, data )
  662.     struct InputEvent    *events;
  663.     APTR        data;
  664. {
  665.     register struct InputEvent    *ev;
  666.  
  667.     geta4();        /* is this really necessary ??? */
  668.     for( ev = events; ev; ev = ev->ie_NextEvent ) {
  669.     if( ev->ie_Class == IECLASS_RAWMOUSE ) {
  670.         if( (ev->ie_Code & ~IECODE_UP_PREFIX) == IECODE_RBUTTON ) {
  671.         ev->ie_Code = (ev->ie_Code & ~IECODE_RBUTTON) | IECODE_LBUTTON;
  672.         }
  673.     }
  674.     } /* for */
  675.     return( events );
  676. } /* myhandler */
  677.  
  678.  
  679. #asm
  680.         ; events pointer in A0
  681.         ; data pointer in A1
  682.         ; return events pointer in D0
  683. _HandlerInterface:
  684.     MOVEM.L    D2/D3/A4/A6,-(sp)       ; save some registers
  685.     MOVEM.L    A0/A1,-(sp)             ; set up parms for C
  686.     JSR     _myhandler
  687.     LEA     8(sp),sp                ; pop parms
  688.     MOVEM.L    (sp)+,D2/D3/A4/A6       ; restore registers
  689.     RTS
  690. #endasm
  691.  
  692.  
  693. subtaskRoutine( data )
  694.     UBYTE   *data;
  695. {
  696.     struct NewWindow    *nw;
  697.     struct IntuiMessage *imsg;
  698.     struct timerequest    *mytr = NULL, *tr;
  699.     struct MsgPort    *myport = NULL;
  700.     ULONG   class;
  701.     USHORT  code;
  702.     APTR    iaddr;
  703.     ULONG   waitmask;
  704.     SHORT   quitflag = 0;
  705.     SHORT   i;
  706.     BYTE    subtimer;
  707.  
  708.     subtimer = TIMER;
  709.     doPrintf( gimMainPort, NULL, "message from subtask: %s\n", data);
  710.     nw = gimmeNewWindow( "subtask'd window", Screen, 50, 50,
  711.                 IDCMP_VSMART, FLAGS_VSMART );
  712.     if( !nw ) {
  713.     doPrintf(gimMainPort, NULL, "can't get new window\n");
  714.     return;
  715.     }
  716.     nw->Width = 400;
  717.     nw->Height = 150;
  718.     if( !(SubWindow = gimmeWindow(nw, 0, 0, 0)) ) {
  719.     getRidOfNewWindow( nw );
  720.     doPrintf( gimMainPort, NULL, "can't open subtask window\n");
  721.     return;
  722.     }
  723.     getRidOfNewWindow( nw );
  724.  
  725. /** this appears to be flaky -- but I don't know why!
  726. if( MYGRAPH ) {
  727.     newgraph.rp = SubWindow->RPort;
  728.     if( !(mygraph = gimmeGraph(&newgraph, NULL, NULL, NULL)) ) {
  729.     doPrintf(gimMainPort, NULL, "subtask: couldn't open graph\n");
  730.     MYGRAPH = 0;
  731.     }
  732. }
  733. **/
  734.  
  735.     waitmask = 1L << SubWindow->UserPort->mp_SigBit;
  736. if( TIMER ) {
  737.     if( gimTimerPort ) {
  738.     /* access Timer to get my own port and signal */
  739.     if( !(mytr = accessTimer(UNIT_VBLANK, &myport)) ) {
  740.         subtimer = 0;
  741.     } else {        /* asynchronous 10 second delay */
  742.         timeDelayAsync( 10L, 0L, UNIT_VBLANK, mytr );
  743.     }
  744.     SetWindowTitles( SubWindow, "I'll go away in 10 seconds", -1L );
  745.     waitmask |= 1L << myport->mp_SigBit;
  746.     }
  747. } /* TIMER */
  748.  
  749. /** this appears to be flaky -- but I don't know why!
  750. if( MYGRAPH ) {
  751.     for( i = 0; i < NUM_COORDS1; ++i ) {
  752.     addToGraph( mygraph, graphData[i][0], graphData[i][1] );
  753.     }
  754. }
  755. ****/
  756.  
  757.     while( !quitflag ) {
  758.     Wait( waitmask );
  759.     while( imsg = (struct IntuiMessage *) GetMsg(SubWindow->UserPort) ) {
  760.         class = imsg->Class;
  761.         code = imsg->Code;
  762.         iaddr = imsg->IAddress;
  763.         ReplyMsg( imsg );
  764.         if( processMessage(SubWindow, class, code, iaddr) ) {
  765.         quitflag = -1;
  766.         }
  767.     } /* while */
  768.     if( subtimer ) {
  769.         while( tr = (struct timerequest *) GetMsg(myport) ) {
  770.         quitflag = -1;
  771.         } /* while */
  772.     }
  773.     } /* while */
  774.     getRidOfWindow( SubWindow );
  775.     if( mytr ) {
  776.     releaseTimer( mytr, NULL );     /* will abort it if necessary */
  777.     }
  778.     SubWindow = NULL;
  779. } /* subtaskRoutine */
  780.