home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 5 / FreshFish_July-August1994.bin / bbs / dev / cmanual-3.0.lha / CManual-3.0 / Intuition / Menus / Example7.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-10-12  |  10.6 KB  |  332 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: Menus                       Tulevagen 22       */
  8. /* File:    Example7.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 opens a normal window to which we connect a menu strip.  */
  21. /* The menu consists of one small action item with two images.           */
  22.  
  23.  
  24.  
  25. #include <intuition/intuition.h>
  26.  
  27.  
  28.  
  29. struct IntuitionBase *IntuitionBase;
  30.  
  31.  
  32.  
  33. /*************************************************************************/
  34. /*                        F A C E   S L E E P I N G                      */
  35. /*************************************************************************/
  36.  
  37. USHORT chip face_sleeping_data[]=
  38. {
  39.   0x7FFF,0xFC00, /* Bitplane ZERO */
  40.   0xFE10,0xFE00,
  41.   0xF9D7,0x3E00,
  42.   0xE7D7,0xCE00,
  43.   0xDFD7,0xF600,
  44.   0xDF93,0xF600,
  45.   0xC054,0x0600,
  46.   0xDFD7,0xF600,
  47.   0xC010,0x0600,
  48.   0xFFFF,0xFE00,
  49.   0x7FFF,0xFC00,
  50.     
  51.   0x7FFF,0xFC00, /* Bitplane ONE */
  52.   0xFFFF,0xFE00,
  53.   0xFFFF,0xFE00,
  54.   0xFFFF,0xFE00,
  55.   0xFFFF,0xFE00,
  56.   0xFFFF,0xFE00,
  57.   0xFFBB,0xFE00,
  58.   0xE038,0x0E00,
  59.   0xFFFF,0xFE00,
  60.   0xFFFF,0xFE00,
  61.   0x7FFF,0xFC00
  62. };
  63.  
  64. /* Image structure for the sleeping face: */
  65. struct Image face_sleeping=
  66. {
  67.   0,          /* LeftEdge, 0 pixels out. */
  68.   0,          /* TopEdge, 0 pixels down. */
  69.   23,         /* Width, 23 pixels wide. */
  70.   11,         /* Height, 11 lines heigh. */
  71.   2,          /* Depth, two Bitplanes. */
  72.   face_sleeping_data, /* ImageData, pointer to the image data. */
  73.   0x3,        /* PlanePick, affect Bitplane zero and one. */
  74.   0x0,        /* PlaneOnOff, do not bother about any Bitplanes. */
  75.   NULL        /* NextImage, no Image structure connected to this one. */
  76. };
  77.  
  78.  
  79.  
  80. /*************************************************************************/
  81. /*                          F A C E   A W A K E                          */
  82. /*************************************************************************/
  83.  
  84. USHORT chip face_awake_data[]=
  85. {
  86.   0x7FFF,0xFC00, /* Bitplane ZERO */
  87.   0xFE10,0xFE00,
  88.   0xF9D7,0x3E00,
  89.   0xE7D7,0xCE00,
  90.   0xDFD7,0xF600,
  91.   0xDE10,0xF600,
  92.   0xDC10,0x7600,
  93.   0xDC10,0x7600,
  94.   0xC010,0x0600,
  95.   0xFFFF,0xFE00,
  96.   0x7FFF,0xFC00,
  97.  
  98.   0x7FFF,0xFC00, /* Bitplane ONE */
  99.   0xFFFF,0xFE00,
  100.   0xFE38,0xFE00,
  101.   0xF838,0x3E00,
  102.   0xE038,0x0E00,
  103.   0xE1FF,0x0E00,
  104.   0xE3FF,0x8E00,
  105.   0xE3FF,0x8E00,
  106.   0xFFFF,0xFE00,
  107.   0xFFFF,0xFE00,
  108.   0x7FFF,0xFC00
  109. };
  110.  
  111. /* Image structure for the awake face: */
  112. struct Image face_awake=
  113. {
  114.   0,          /* LeftEdge, 0 pixels out. */
  115.   0,          /* TopEdge, 0 pixels down. */
  116.   23,         /* Width, 23 pixels wide. */
  117.   11,         /* Height, 11 lines heigh. */
  118.   2,          /* Depth, two Bitplanes. */
  119.   face_awake_data, /* ImageData, pointer to the image data. */
  120.   0x3,        /* PlanePick, affect Bitplane zero and one. */
  121.   0x0,        /* PlaneOnOff, do not bother about any Bitplanes. */
  122.   NULL        /* NextImage, no Image structure connected to this one. */
  123. };
  124.  
  125.  
  126.  
  127. /*************************************************************************/
  128. /*                           M E N U   I T E M                           */
  129. /*************************************************************************/
  130.  
  131. /* The one and only MenuItem structure: */
  132. struct MenuItem my_item=
  133. {
  134.   NULL,            /* NextItem, this is the one and only item. */
  135.   0,               /* LeftEdge, 0 pixels out. */
  136.   0,               /* TopEdge, 0 lines down. */
  137.   50,              /* Width, 50 pixels wide. */
  138.   11,              /* Height, 11 lines high. */
  139.   ITEMENABLED|     /* Flags, this item will be enabled. */
  140.                    /*        render this item with an Image. */
  141.                    /*        (ITEMTEXT is not set.) */
  142.                    /*        it is an action item. */
  143.                    /*        (CHECKIT is not set.) */
  144.   HIGHIMAGE,       /*        display an alternative Image when highl. */
  145.   0x00000000,      /* MutualExclude, no mutualexclude. */
  146.   (APTR) &face_sleeping, /* ItemFill, pointer to the image. */
  147.   (APTR) &face_awake,    /* SelectFill, pointer to the alternative image. */
  148.   0,               /* Command, no command-key sequence. */
  149.   NULL,            /* SubItem, no subitem list. */
  150.   MENUNULL,        /* NextSelect, no items selected. */
  151. };
  152.  
  153.  
  154.  
  155. /*************************************************************************/
  156. /*                              M E N U                                  */
  157. /*************************************************************************/
  158.  
  159. /* The Menu structure for the first (and only) menu: */
  160. struct Menu my_menu=
  161. {
  162.   NULL,        /* NextMenu, no more menu structures. */
  163.   0,           /* LeftEdge, left corner. */
  164.   0,           /* TopEdge, for the moment ignored by Intuition. */
  165.   50,          /* Width, 50 pixels wide. */
  166.   0,           /* Height, for the moment ignored by Intuition. */
  167.   MENUENABLED, /* Flags, this menu will be enabled. */
  168.   "Face",      /* MenuName, the string. */
  169.   &my_item     /* FirstItem, pointer to the first item in the list. */
  170. };
  171.  
  172.  
  173.  
  174. /* Declare a pointer to a Window structure: */ 
  175. struct Window *my_window;
  176.  
  177. /* Declare and initialize your NewWindow structure: */
  178. struct NewWindow my_new_window=
  179. {
  180.   50,            /* LeftEdge    x position of the window. */
  181.   25,            /* TopEdge     y positio of the window. */
  182.   200,           /* Width       200 pixels wide. */
  183.   100,           /* Height      100 lines high. */
  184.   0,             /* DetailPen   Text should be drawn with colour reg. 0 */
  185.   1,             /* BlockPen    Blocks should be drawn with colour reg. 1 */
  186.   CLOSEWINDOW|   /* IDCMPFlags  The window will give us a message if the */
  187.                  /*             user has selected the Close window gad. */
  188.   MENUPICK,
  189.   SMART_REFRESH| /* Flags       Intuition should refresh the window. */
  190.   WINDOWCLOSE|   /*             Close Gadget. */
  191.   WINDOWDRAG|    /*             Drag gadget. */
  192.   WINDOWDEPTH|   /*             Depth arrange Gadgets. */
  193.   WINDOWSIZING|  /*             Sizing Gadget. */
  194.   ACTIVATE,      /*             The window should be Active when opened. */
  195.   NULL,          /* FirstGadget No Custom gadgets. */
  196.   NULL,          /* CheckMark   Use Intuition's default checkmark. */
  197.   "Person",      /* Title       Title of the window. */
  198.   NULL,          /* Screen      Connected to the Workbench Screen. */
  199.   NULL,          /* BitMap      No Custom BitMap. */
  200.   80,            /* MinWidth    We will not allow the window to become */
  201.   30,            /* MinHeight   smaller than 80 x 30, and not bigger */
  202.   300,           /* MaxWidth    than 300 x 200. */
  203.   200,           /* MaxHeight */
  204.   WBENCHSCREEN   /* Type        Connected to the Workbench Screen. */
  205. };
  206.  
  207.  
  208.  
  209. main()
  210. {
  211.   /* Boolean variable used for the while loop: */
  212.   BOOL close_me;
  213.  
  214.   /* Declare a variable in which we will store the IDCMP flag: */
  215.   ULONG class;
  216.   
  217.   /* If we recieve a MENUPICK event, the Code field of the message */
  218.   /* structure will contain the menu number of the first selected item. */
  219.   /* Declare a variable to store the Code value in, and an extra menu */
  220.   /* number variable: */
  221.   USHORT code, menu_number;
  222.   
  223.   /* Declare a MenuItem pointer: */
  224.   struct MenuItem *item;
  225.   
  226.   /* Declare a pointer to an IntuiMessage structure: */
  227.   struct IntuiMessage *my_message;
  228.  
  229.  
  230.  
  231.   /* Before we can use Intuition we need to open the Intuition Library: */
  232.   IntuitionBase = (struct IntuitionBase *)
  233.     OpenLibrary( "intuition.library", 0 );
  234.   
  235.   if( IntuitionBase == NULL )
  236.     exit(); /* Could NOT open the Intuition Library! */
  237.  
  238.  
  239.  
  240.   /* We will now try to open the window: */
  241.   my_window = (struct Window *) OpenWindow( &my_new_window );
  242.   
  243.   /* Have we opened the window succesfully? */
  244.   if(my_window == NULL)
  245.   {
  246.     /* Could NOT open the Window! */
  247.     
  248.     /* Close the Intuition Library since we have opened it: */
  249.     CloseLibrary( IntuitionBase );
  250.  
  251.     exit();  
  252.   }
  253.  
  254.  
  255.  
  256.   /* We have opened the window, and everything seems to be OK. */
  257.  
  258.  
  259.  
  260.   SetMenuStrip( my_window, &my_menu );
  261.   printf("Menustrip connected to window!\n");
  262.  
  263.  
  264.   close_me = FALSE;
  265.  
  266.   /* Stay in the while loop until the user has selected the Close window */
  267.   /* gadget: */
  268.   while( close_me == FALSE )
  269.   {
  270.     /* Wait until we have recieved a message: */
  271.     Wait( 1 << my_window->UserPort->mp_SigBit );
  272.  
  273.     /* As long as we collect messages sucessfully we stay in the loop: */
  274.     while(my_message=(struct IntuiMessage *) GetMsg( my_window->UserPort ))
  275.     {
  276.       /* After we have collected the message we can read it, and save any */
  277.       /* important values which we maybe want to check later: */
  278.       class = my_message->Class;
  279.       code = my_message->Code;
  280.  
  281.  
  282.       /* After we have read it we reply as fast as possible: */
  283.       /* REMEMBER! Do never try to read a message after you have replied! */
  284.       /* Some other process has maybe changed it. */
  285.       ReplyMsg( my_message );
  286.  
  287.       /* Check which IDCMP flag was sent: */
  288.       if( class == CLOSEWINDOW )
  289.         close_me=TRUE; /* The user selected the Close window gadget! */  
  290.  
  291.       if(class == MENUPICK)
  292.       {
  293.         printf("\nMenu pick!\n");
  294.         menu_number = code;
  295.         
  296.         while( menu_number != MENUNULL )
  297.         {
  298.           /* Get the address of the item: */
  299.           item = (struct MenuItem *) ItemAddress( &my_menu, menu_number );
  300.  
  301.  
  302.           /* Print out the menu number plus etc: */
  303.           printf("menu_number= %d\n", menu_number );
  304.           printf("MENUNUM = %d\n", MENUNUM(menu_number) );
  305.           printf("ITEMNUM = %d\n", ITEMNUM(menu_number) );
  306.           printf("SUBNUM  = %d\n", SUBNUM(menu_number) );
  307.  
  308.  
  309.           /* Get the following item's menu number: */
  310.           menu_number = item->NextSelect;
  311.         }
  312.       }
  313.     }
  314.   }
  315.  
  316.  
  317.  
  318.   printf("Menustrip removed from window!\n");
  319.   ClearMenuStrip( my_window );
  320.  
  321.  
  322.  
  323.   /* Close the window: */
  324.   CloseWindow( my_window );
  325.  
  326.  
  327.  
  328.   /* Close the Intuition Library since we have opened it: */
  329.   CloseLibrary( IntuitionBase );
  330.   
  331.   /* THE END */
  332. }