home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 5 / FreshFish_July-August1994.bin / bbs / dev / cmanual-3.0.lha / CManual-3.0 / Intuition / Gadgets / Example6.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-10-12  |  11.3 KB  |  343 lines
  1. /***********************************************************/
  2. /*                                                         */
  3. /* Amiga C Encyclopedia (ACE) V3.0      Amiga C Club (ACC) */
  4. /* -------------------------------      ------------------ */
  5. /*                                                         */
  6. /* Book:    ACM Intuition               Amiga C Club       */
  7. /* Chapter: Gadgets                     Tulevagen 22       */
  8. /* File:    Example6.c                  181 41  LIDINGO    */
  9. /* Author:  Anders Bjerin               SWEDEN             */
  10. /* Date:    92-05-01                                       */
  11. /* Version: 1.10                                           */
  12. /*                                                         */
  13. /*   Copyright 1992, Anders Bjerin - Amiga C Club (ACC)    */
  14. /*                                                         */
  15. /* Registered members may use this program freely in their */
  16. /*     own commercial/noncommercial programs/articles.     */
  17. /*                                                         */
  18. /***********************************************************/
  19.  
  20. /* This program will open a normal window which is connected to the   */
  21. /* Workbench Screen. The window will use all System Gadgets, and will */
  22. /* close first when the user has selected the System gadget Close     */
  23. /* window. Inside the window we have put a Boolean gadget with a      */
  24. /* connecting mask. The gadget will only be highlighted when the user */
  25. /* selects this gadget while pointing inside the specified (masked)   */
  26. /* area.                                                              */
  27.  
  28.  
  29.  
  30. /* If your program is using Intuition you should include intuition.h: */
  31. #include <intuition/intuition.h>
  32.  
  33.  
  34.  
  35. struct IntuitionBase *IntuitionBase;
  36.  
  37.  
  38.  
  39. /* Image data for the gadget: */
  40. USHORT chip my_image_data[32]=
  41. {
  42.    0xFFFF,0xFFFF, /* Bitplane ZERO */
  43.    0xFFF8,0x1FFF,
  44.    0xFFE0,0x07FF,
  45.    0xFF80,0x01FF,
  46.    0xFE00,0x007F,
  47.    0xF800,0x001F,
  48.    0xE000,0x0007,
  49.    0x8000,0x0001,
  50.    0x8000,0x0001,
  51.    0xE000,0x0007,
  52.    0xF800,0x001F,
  53.    0xFE00,0x007F,
  54.    0xFF80,0x01FF,
  55.    0xFFE0,0x07FF,
  56.    0xFFF8,0x1FFF,
  57.    0xFFFF,0xFFFF
  58. };
  59.  
  60. /* Image structure for the gadget: */
  61. struct Image my_image=
  62. {
  63.   0, 0,          /* LeftEdge, TopEdge */
  64.   32, 16,        /* Width, Height */
  65.   1,             /* Depth */
  66.   my_image_data, /* ImageData */
  67.   0x01, 0x00,    /* PlanePick, PlaneOnOff */
  68.   NULL           /* NextImage */
  69. };
  70.  
  71.  
  72.      UWORD chip my_mask[32]=
  73. {
  74.    0x0000,0x0000, /* Bitplane ZERO */
  75.    0x0007,0xE000,
  76.    0x001F,0xF800,
  77.    0x007F,0xFE00,
  78.    0x01FF,0xFF80,
  79.    0x07FF,0xFFE0,
  80.    0x1FFF,0xFFF8,
  81.    0x7FFF,0xFFFE,
  82.    0x7FFF,0xFFFE,
  83.    0x1FFF,0xFFF8,
  84.    0x07FF,0xFFE0,
  85.    0x01FF,0xFF80,
  86.    0x007F,0xFE00,
  87.    0x001F,0xF800,
  88.    0x0007,0xE000,
  89.    0x0000,0x0000
  90. };
  91.  
  92. /* The BoolInfo structure fot the gadget: */
  93. struct BoolInfo my_bool_info=
  94. {
  95.     BOOLMASK,  /* Flags, for the moment this is the only flag you may use. */
  96.     my_mask,   /* Mask, pointer to our bit mask. Only when the user clicks */
  97.                /* inside the small area of the gadget it will be selected, */
  98.                          /* and only that area will be highlighted. */
  99.                          /* Remember! The width and height of the mask data must */
  100.                          /* be the same as the width and height of the gadget. */
  101.   0          /* Reserved, set this variable to 0 for the moment. */
  102. };
  103.  
  104. /* The Gadget structure: */
  105. struct Gadget my_gadget=
  106. {
  107.   NULL,          /* NextGadget, no more gadgets in the list. */
  108.   40,            /* LeftEdge, 40 pixels out. */
  109.   20,            /* TopEdge, 20 lines down. */
  110.   32,            /* Width, 32 pixels wide. */
  111.   16,            /* Height, 16 pixels lines heigh. */
  112.   GADGHCOMP|     /* Flags, complement the colours when selected. */
  113.   GADGIMAGE,     /* Render the gadget with an Image structure. */
  114.   GADGIMMEDIATE| /* Activation, our program will recieve a message when */
  115.   RELVERIFY|     /* the user has selected this gadget, and when the user */
  116.                  /* has released it. */ 
  117.   BOOLEXTEND,    /* This gadget has an BoolInfo connected to it. */ 
  118.   BOOLGADGET,    /* GadgetType, a Boolean gadget. */
  119.   (APTR) &my_image, /* GadgetRender, a pointer to our Image structure. */
  120.   NULL,          /* SelectRender, NULL since we do not supply the gadget */
  121.                  /* with an alternative image. (We complement the */
  122.                  /* colours instead) */
  123.   NULL,          /* GadgetText, no text connected to the gadget. */
  124.                  /* (See chapter 3 GRAPHICS for more information) */
  125.   NULL,          /* MutualExclude, no mutual exclude. */
  126.   (APTR) &my_bool_info, /* SpecialInfo, pointer to the BoolInfo str. */
  127.   0,             /* GadgetID, no id. */
  128.   NULL           /* UserData, no user data connected to the gadget. */
  129. };
  130.  
  131.  
  132.  
  133. /* Declare a pointer to a Window structure: */ 
  134. struct Window *my_window;
  135.  
  136. /* Declare and initialize your NewWindow structure: */
  137. struct NewWindow my_new_window=
  138. {
  139.   50,            /* LeftEdge    x position of the window. */
  140.   25,            /* TopEdge     y positio of the window. */
  141.   200,           /* Width       200 pixels wide. */
  142.   100,           /* Height      100 lines high. */
  143.   0,             /* DetailPen   Text should be drawn with colour reg. 0 */
  144.   1,             /* BlockPen    Blocks should be drawn with colour reg. 1 */
  145.   CLOSEWINDOW|   /* IDCMPFlags  The window will give us a message if the */
  146.                  /*             user has selected the Close window gad, */
  147.   GADGETDOWN|    /*             or a gadget has been pressed on, or */
  148.   GADGETUP,      /*             a gadge has been released. */
  149.   SMART_REFRESH| /* Flags       Intuition should refresh the window. */
  150.   WINDOWCLOSE|   /*             Close Gadget. */
  151.   WINDOWDRAG|    /*             Drag gadget. */
  152.   WINDOWDEPTH|   /*             Depth arrange Gadgets. */
  153.   WINDOWSIZING|  /*             Sizing Gadget. */
  154.   ACTIVATE,      /*             The window should be Active when opened. */
  155.   &my_gadget,    /* FirstGadget A pointer to my_gadget structure. */
  156.   NULL,          /* CheckMark   Use Intuition's default CheckMark. */
  157.   "TOUCH ME",    /* Title       Title of the window. */
  158.   NULL,          /* Screen      Connected to the Workbench Screen. */
  159.   NULL,          /* BitMap      No Custom BitMap. */
  160.   140,           /* MinWidth    We will not allow the window to become */
  161.   50,            /* MinHeight   smaller than 140 x 50, and not bigger */
  162.   300,           /* MaxWidth    than 300 x 200. */
  163.   200,           /* MaxHeight */
  164.   WBENCHSCREEN   /* Type        Connected to the Workbench Screen. */
  165. };
  166.  
  167.  
  168.  
  169. main()
  170. {
  171.   /* Boolean variable used for the while loop: */
  172.   BOOL close_me;
  173.  
  174.   /* Declare a variable in which we will store the IDCMP flag: */
  175.   ULONG class;
  176.   
  177.   /* Declare a pointer to an IntuiMessage structure: */
  178.   struct IntuiMessage *my_message;
  179.  
  180.  
  181.  
  182.   /* Before we can use Intuition we need to open the Intuition Library: */
  183.   IntuitionBase = (struct IntuitionBase *)
  184.     OpenLibrary( "intuition.library", 0 );
  185.   
  186.   if( IntuitionBase == NULL )
  187.     exit(); /* Could NOT open the Intuition Library! */
  188.  
  189.  
  190.  
  191.   /* We will now try to open the window: */
  192.   my_window = (struct Window *) OpenWindow( &my_new_window );
  193.   
  194.   /* Have we opened the window succesfully? */
  195.   if(my_window == NULL)
  196.   {
  197.     /* Could NOT open the Window! */
  198.     
  199.     /* Close the Intuition Library since we have opened it: */
  200.     CloseLibrary( IntuitionBase );
  201.  
  202.     exit();  
  203.   }
  204.  
  205.  
  206.  
  207.   /* We have opened the window, and everything seems to be OK. */
  208.  
  209.  
  210.  
  211.   close_me = FALSE;
  212.  
  213.   /* Stay in the while loop until the user has selected the Close window */
  214.   /* gadget: */
  215.   while( close_me == FALSE )
  216.   {
  217.     /* Wait until we have recieved a message: */
  218.     Wait( 1 << my_window->UserPort->mp_SigBit );
  219.  
  220.     /* Collect the message: */
  221.     my_message = (struct IntuiMessage *) GetMsg( my_window->UserPort );
  222.  
  223.     /* Have we collected the message sucessfully? */
  224.     if(my_message)
  225.     {
  226.       /* After we have collected the message we can read it, and save any */
  227.       /* important values which we maybe want to check later: */
  228.       class = my_message->Class;
  229.  
  230.       /* After we have read it we reply as fast as possible: */
  231.       /* REMEMBER! Never try to read a message after you have replied! */
  232.       /* Some other process has maybe changed it. */
  233.       ReplyMsg( my_message );
  234.  
  235.       /* Check which IDCMP flag was sent: */
  236.       switch( class )
  237.       {
  238.         case CLOSEWINDOW:  /* The user selected the Close window gadget! */
  239.                close_me=TRUE;
  240.                break;
  241.              
  242.         case GADGETDOWN:   /* The user has pressed on the Boolean gadget. */
  243.                printf("Down\n");
  244.                break;
  245.              
  246.         case GADGETUP:     /* The user has released the Boolean gadget. */
  247.                printf("Up\n");
  248.                break;
  249.       }
  250.     }
  251.   }
  252.  
  253.  
  254.  
  255.   /* We should always close the windows we have opened before we leave: */
  256.   CloseWindow( my_window );
  257.  
  258.  
  259.  
  260.   /* Close the Intuition Library since we have opened it: */
  261.   CloseLibrary( IntuitionBase );
  262.   
  263.   /* THE END */
  264. }
  265.  
  266.  
  267.  
  268. /*******************************************/
  269. /* Extra Information about masked gadgets: */
  270. /*******************************************/
  271.  
  272. /*
  273.  
  274. What is special about this example is that we have connected a mask to the
  275. Boolean gadget. The gadget will therefore only be highlighted when the user
  276. clicks inside the "masked" area, and only that area will be highlighted.
  277.  
  278. Only Boolean gadgets may have a connecting mask, and if you would want to
  279. use one you need to:
  280.  
  281.   1. Set the BOOLEXTEND flag in the Activation field.
  282.  
  283.   2. Declare and initialize the bit mask data. Important, the mask must be
  284.      exactly as high and wide as the gadget itself. Only the selected parts
  285.      (masked = 1's) will be sensetive, and highlighted when selected.
  286.  
  287.   3. Declare and initialize a BoolInfo structure which look like this:
  288.      struct BoolInfo
  289.      {
  290.        USHORT Flags;
  291.        UWORD *Mask;
  292.        ULONG Reserved;
  293.      };
  294.      
  295.      Flags:    There exist for the moment only one flag, BOOLMASK. Set it.
  296.      Mask:     Pointer to the bit mask data.
  297.      Reserved: Reserved field. Set it to 0.
  298.  
  299.   4. Set the SpecialInfo pointer in the Gadget structure to point at a
  300.      BoolInfo structure.
  301.  
  302.  
  303.  
  304. In this example the gadget look like this:              
  305.                                              
  306. 1111111111111111 1111111111111111    0: blue 
  307. 1111111111111000 0001111111111111    1: white
  308. 1111111111100000 0000011111111111
  309. 1111111110000000 0000000111111111
  310. 1111111000000000 0000000001111111
  311. 1111100000000000 0000000000011111
  312. 1110000000000000 0000000000000111
  313. 1000000000000000 0000000000000001
  314. 1000000000000000 0000000000000001
  315. 1110000000000000 0000000000000111
  316. 1111100000000000 0000000000011111
  317. 1111111000000000 0000000001111111
  318. 1111111110000000 0000000111111111
  319. 1111111111100000 0000011111111111
  320. 1111111111111000 0001111111111111
  321. 1111111111111111 1111111111111111
  322.  
  323. And the mask look like this:
  324.  
  325. 0000000000000000 0000000000000000    0: Unselected (unmasked) area.
  326. 0000000000000111 1110000000000000    1: Selected (masked) area.
  327. 0000000000011111 1111100000000000
  328. 0000000001111111 1111111000000000
  329. 0000000111111111 1111111110000000
  330. 0000011111111111 1111111111100000
  331. 0001111111111111 1111111111111000
  332. 0111111111111111 1111111111111110
  333. 0111111111111111 1111111111111110
  334. 0001111111111111 1111111111111000
  335. 0000011111111111 1111111111100000
  336. 0000000111111111 1111111110000000
  337. 0000000001111111 1111111000000000
  338. 0000000000011111 1111100000000000
  339. 0000000000000111 1110000000000000
  340. 0000000000000000 0000000000000000
  341.  
  342. */
  343.