home *** CD-ROM | disk | FTP | other *** search
/ World of A1200 / World_Of_A1200.iso / datafiles / text / c_manual / intuition / requesters / example10.c < prev    next >
C/C++ Source or Header  |  1995-02-27  |  17KB  |  470 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: Requesters                  Tulevagen 22       */
  8. /* File:    Example10.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 example demonstrates how you use a requester with a */
  21. /* predrawn bitmap. This is very useful when you want       */
  22. /* colourful and eye catching requesters. The advantage     */
  23. /* with a special bitmap is that if the window which the    */
  24. /* requester is tied to is resized, the drawing will not be */
  25. /* destroied.                                               */
  26. /*                                                          */
  27. /* The graphics data is stored in a separate file called    */
  28. /* "Example10Graphics.c". Both this and the graphical file  */
  29. /* should be compiled separately, then linked together. If  */
  30. /* you have a SAS (Lattice) C Compiler you would do like    */
  31. /* this:                                                    */
  32. /*   lc Example10.c                                         */
  33. /*   lc Example10Graphics.c                                 */
  34. /*   blink with Example10.lnk                               */ 
  35. /*                                                          */
  36. /* This program will NOT try to erase the disk! It is ony a */
  37. /* demonstration how to use a requester.                    */
  38.  
  39.  
  40.  
  41. #include <intuition/intuition.h>
  42.  
  43.  
  44.  
  45. /* The size of the requester: */
  46. #define WIDTH      310
  47. #define HEIGHT     180
  48. #define DEPTH        4
  49. #define COLOURS     16
  50.  
  51.  
  52.  
  53. struct IntuitionBase *IntuitionBase;
  54. struct GfxBase *GfxBase;
  55.  
  56.  
  57.  
  58.  
  59. /* The graphics for the requester: */
  60. extern UWORD chip YesNoData[];
  61.  
  62. /* The sixteen colours: (RGB) */
  63. UWORD colour[COLOURS]=
  64. {
  65.   0x000, 0xFFF, 0x500, 0x900, 0xE00, 0xE60, 0xFE0, 0x06F,
  66.   0x0AF, 0x04C, 0x666, 0x888, 0xBBB, 0x555, 0x028, 0x0CF
  67. };
  68.  
  69. /* The YesNo image structure: */
  70. struct Image YesNoImage=
  71. {
  72.   0, 0,            /* LeftEdge, TopEdge */
  73.   285, 154, DEPTH, /* Width, Height, Depth */
  74.   YesNoData,       /* ImageData */
  75.   0x0F, 0x00,      /* PlanePick, PlaneOnOff */
  76.   NULL             /* NextImage */
  77. };
  78.  
  79. /* The BitMap structure: */
  80. struct BitMap my_bitmap;
  81.  
  82. /* The RastPort: */
  83. struct RastPort my_rast_port;
  84.  
  85.  
  86.  
  87. /* The YES gadget (the left one): */
  88. struct Gadget yes_gadget=
  89. {
  90.   NULL,          /* NextGadget, no more gadgets in the list. */
  91.   44,            /* LeftEdge, 44 pixels out. */
  92.   108,           /* TopEdge, 108 lines down. */
  93.   80,            /* Width, 80 pixels wide. */
  94.   30,            /* Height, 30 pixels lines heigh. */
  95.   GADGHCOMP,     /* Flags, when this gadget is highlighted, the gadget */
  96.                  /* will be rendered in the complement colours. */
  97.   GADGIMMEDIATE| /* Activation, our program will recieve a message when */
  98.   RELVERIFY|     /* the user has selected this gadget, and when the user */
  99.                  /* has released it. */
  100.   ENDGADGET,     /* When the user has selected this gadget, the */
  101.                  /* requester is satisfied, and is deactivated. */
  102.                  /* IMPORTANT! At least one gadget per requester */
  103.                  /* must have the flag ENDGADGET set. If not, the */
  104.                  /* requester would never be deactivated! */
  105.  
  106.   BOOLGADGET|    /* GadgetType, a Boolean gadget which is connected to */
  107.   REQGADGET,     /* a requester. IMPORTANT! Every gadget which is */
  108.                  /* connectd to a requester must have the REQGADGET flsg */
  109.                  /* set in the GadgetType field. */
  110.   NULL,          /* GadgetRender, no rendering. */
  111.   NULL,          /* SelectRender, no alternative rendering. */
  112.   NULL,          /* GadgetText, no text. */
  113.   NULL,          /* MutualExclude, no mutual exclude. */
  114.   NULL,          /* SpecialInfo, NULL since this is a Boolean gadget. */
  115.                  /* (It is not a Proportional/String or Integer gdget) */
  116.   0,             /* GadgetID, no id. */
  117.   NULL           /* UserData, no user data connected to the gadget. */
  118. };
  119.  
  120. /* The NO gadget (the right one): */
  121. struct Gadget no_gadget=
  122. {
  123.   &yes_gadget,   /* NextGadget, pointer to the yes gadget. */
  124.   200,           /* LeftEdge, 200 pixels out. */
  125.   108,           /* TopEdge, 108 lines down. */
  126.   75,            /* Width, 75 pixels wide. */
  127.   30,            /* Height, 30 pixels lines heigh. */
  128.   GADGHCOMP,     /* Flags, when this gadget is highlighted, the gadget */
  129.                  /* will be rendered in the complement colours. */
  130.   GADGIMMEDIATE| /* Activation, our program will recieve a message when */
  131.   RELVERIFY,     /* the user has selected this gadget, and when the user */
  132.                  /* has released it. */
  133.   BOOLGADGET|    /* GadgetType, a Boolean gadget which is connected to */
  134.   REQGADGET,     /* a requester. IMPORTANT! Every gadget which is */
  135.                  /* connectd to a requester must have the REQGADGET flsg */
  136.                  /* set in the GadgetType field. */
  137.   NULL,          /* GadgetRender, no rendering. */
  138.   NULL,          /* SelectRender, no alternative rendering. */
  139.   NULL,          /* GadgetText, no text. */
  140.   NULL,          /* MutualExclude, no mutual exclude. */
  141.   NULL,          /* SpecialInfo, NULL since this is a Boolean gadget. */
  142.                  /* (It is not a Proportional/String or Integer gdget) */
  143.   0,             /* GadgetID, no id. */
  144.   NULL           /* UserData, no user data connected to the gadget. */
  145. };
  146.  
  147. /***********************************************************************/
  148. /* Important notice:                                                   */
  149. /* Remember that every gadget which is connected to a requester must   */
  150. /* have the flag REQGADGET set in the GadgetType field. Remember also  */
  151. /* that at least one gadget per requester must have the ENDGADGET flag */
  152. /* set in the Activation field.                                        */
  153. /***********************************************************************/
  154.  
  155.  
  156.  
  157. /* The request structure: */
  158. struct Requester my_requester=
  159. {
  160.   NULL,              /* OlderRequester, used by Intuition. */
  161.   5, 15,             /* LeftEdge, TopEdge, 0 pixels out, 0 lines down. */
  162.   WIDTH, HEIGHT,     /* Width, Height, 285 pixels wide, 154 lines high. */
  163.   0, 0,              /* RelLeft, RelTop, Since POINTREL flag is not set, */
  164.                      /* Intuition ignores these values. */
  165.   &no_gadget,        /* ReqGadget, pointer to the first gadget. */
  166.   NULL,              /* ReqBorder, no rendering. */
  167.   NULL,              /* ReqText, no text. */
  168.   PREDRAWN,          /* Flags, we use our own predrawn BitMap. */
  169.   0,                 /* BackFill, no backfill. */
  170.   NULL,              /* ReqLayer, used by Intuition. Set to NULL. */
  171.   NULL,              /* ReqPad1, used by Intuition. Set to NULL. */
  172.   NULL,              /* ImageBMap, will later be changed. */
  173.   NULL,              /* RWindow, used by Intuition. Set to NULL. */
  174.   NULL               /* ReqPad2, used by Intuition. Set to NULL. */
  175. };
  176.  
  177.  
  178.  
  179.  
  180. /* A pinter to a Screen structure: */ 
  181. struct Screen *my_screen;
  182.  
  183. /* The NewScreen structure: */
  184. struct NewScreen my_new_screen=
  185. {
  186.   0,            /* LeftEdge  Should always be 0. */
  187.   0,            /* TopEdge   Top of the display.*/
  188.   320,          /* Width     We are using a high-resolution screen. */
  189.   200,          /* Height    Non-Interlaced NTSC (American) display. */
  190.   DEPTH,        /* Depth     4 - 16 colours. */
  191.   0,            /* DetailPen Text should be drawn with colour reg. 0 */
  192.   1,            /* BlockPen  Blocks should be drawn with colour reg. 1 */
  193.   NULL,         /* ViewModes Low-resolution, non-Interlaced. */
  194.   CUSTOMSCREEN, /* Type      Your own customized screen. */
  195.   NULL,         /* Font      Default font. */
  196.   "MY SCREEN",  /* Title     The screen' title. */
  197.   NULL,         /* Gadget    Must for the moment be NULL. */
  198.   NULL          /* BitMap    No special CustomBitMap. */
  199. };
  200.  
  201.  
  202.  
  203. /* A pointer to a Window structure: */ 
  204. struct Window *my_window;
  205.  
  206. /* The NewWindow structure: */
  207. struct NewWindow my_new_window=
  208. {
  209.   0,             /* LeftEdge    x position of the window. */
  210.   0,             /* TopEdge     y positio of the window. */
  211.   320,           /* Width       320 pixels wide. */
  212.   200,           /* Height      200 lines high. */
  213.   0,             /* DetailPen   Text should be drawn with colour reg. 0 */
  214.   1,             /* BlockPen    Blocks should be drawn with colour reg. 1 */
  215.   CLOSEWINDOW|   /* IDCMPFlags  The window will give us a message if the */
  216.                  /*             user has selected the Close window gad, */
  217.   GADGETDOWN|    /*             or a gadget has been pressed on, or */
  218.   GADGETUP,      /*             a gadge has been released. */
  219.   SMART_REFRESH| /* Flags       Intuition should refresh the window. */
  220.   WINDOWCLOSE|   /*             Close Gadget. */
  221.   WINDOWDRAG|    /*             Drag gadget. */
  222.   WINDOWDEPTH|   /*             Depth arrange Gadgets. */
  223.   WINDOWSIZING|  /*             Sizing Gadget. */
  224.   ACTIVATE,      /*             The window should be Active when opened. */
  225.   NULL,          /* FirstGadget No gadget connected to this window. */
  226.   NULL,          /* CheckMark   Use Intuition's default CheckMark. */
  227.   "The Window",  /* Title       Title of the window. */
  228.   NULL,          /* Screen      Connected to the Workbench Screen. */
  229.   NULL,          /* BitMap      No Custom BitMap. */
  230.   140,           /* MinWidth    We will not allow the window to become */
  231.   50,            /* MinHeight   smaller than 140 x 50, and not bigger */
  232.   300,           /* MaxWidth    than 300 x 200. */
  233.   200,           /* MaxHeight */
  234.   CUSTOMSCREEN   /* Type        Connected to a Custom Screen. */
  235. };
  236.  
  237.  
  238.  
  239. /* Declare our functions: */
  240. void main();
  241. void clean_up( STRPTR message );
  242.  
  243.  
  244.  
  245. void main()
  246. {
  247.   /* Boolean variable used for the while loop: */
  248.   BOOL close_me;
  249.  
  250.   /* Declare a variable in which we will store the IDCMP flag: */
  251.   ULONG class;
  252.   
  253.   /* Declare a pointer to an IntuiMessage structure: */
  254.   struct IntuiMessage *my_message;
  255.  
  256.   /* We use this variable to check if the requester has ben activated */
  257.   /* or not: */
  258.   BOOL result;
  259.   
  260.   /* Used in the loops: */
  261.   int loop;
  262.  
  263.  
  264.  
  265.   /* Before we can use Intuition we need to open the Intuition Library: */
  266.   IntuitionBase = (struct IntuitionBase *)
  267.     OpenLibrary( "intuition.library", 0 );
  268.   
  269.   if( IntuitionBase == NULL )
  270.     clean_up( "Could NOT open the Intuition Library!" );
  271.  
  272.  
  273.   /* Before we can use the function AllocRaster() etc we need to open */
  274.   /* the graphics Library:                                            */
  275.   GfxBase = (struct GfxBase *)
  276.     OpenLibrary( "graphics.library", 0);
  277.  
  278.   if( GfxBase == NULL )
  279.     clean_up( "Could NOT open the Graphics Library!" );
  280.  
  281.  
  282.  
  283.   /* Initialize the BitMap by calling the function: */
  284.   InitBitMap( &my_bitmap, DEPTH, WIDTH, HEIGHT );
  285.   /* &my_bitmap: A pointer to the my_bitmap structure. */
  286.   /* DEPTH:      Number of bitplanes to use. */
  287.   /* WIDTH:      The width of the BitMap. */
  288.   /* HEIGHT:     The height of the BitMap. */
  289.  
  290.  
  291.  
  292.   /* Allocate display memory for the BitMap: */
  293.   for( loop=0; loop < DEPTH; loop++)
  294.   {
  295.     if((my_bitmap.Planes[loop] = (PLANEPTR)
  296.       AllocRaster( WIDTH, HEIGHT )) == NULL )
  297.         clean_up( "Not enough memory for the BitMap!" );
  298.     
  299.     /* Clear the Bitplane: */
  300.     BltClear( my_bitmap.Planes[loop], RASSIZE( WIDTH, HEIGHT ), 0);
  301.   }
  302.  
  303.  
  304.  
  305.   /* Initialize the RastPort structure: */
  306.   InitRastPort( &my_rast_port );
  307.  
  308.   /* Tie the bitmap to the rastport: */
  309.   my_rast_port.BitMap = &my_bitmap;
  310.  
  311.   /* Set the front pen to colour 13: */
  312.   SetAPen( &my_rast_port, 13 );
  313.  
  314.   /* Fill the request: */
  315.   RectFill( &my_rast_port, 0, 0, WIDTH-1, HEIGHT-1 );
  316.  
  317.   /* Draw the image into our own bitmap: */
  318.   DrawImage( &my_rast_port, &YesNoImage, 10, 8 );
  319.  
  320.   /* Give our requester a pointer to our prepared bitmap: */
  321.   my_requester.ImageBMap = &my_bitmap;
  322.  
  323.  
  324.  
  325.   /* We will now try to open the screen: */
  326.   my_screen = (struct Screen *) OpenScreen( &my_new_screen );
  327.   
  328.   /* Have we opened the screen succesfully? */
  329.   if(my_screen == NULL)
  330.     clean_up( "Could not open the Screen!" );
  331.  
  332.  
  333.  
  334.   /* Change colour registers: */
  335.   for( loop = 0; loop < COLOURS; loop++ )
  336.     SetRGB4( &my_screen->ViewPort, loop,
  337.       (colour[ loop ] & 0xF00) >> 8, /* Red   */
  338.       (colour[ loop ] & 0x0F0) >> 4, /* Green */
  339.       (colour[ loop ] & 0x00F)       /* Blue  */
  340.     );
  341.  
  342.  
  343.  
  344.   /* Before we can open the window we need to give the NewWindow */
  345.   /* structure a pointer to the opened Custom Screen: */
  346.   my_new_window.Screen = my_screen;
  347.  
  348.   /* We will now try to open the window: */
  349.   my_window = (struct Window *) OpenWindow( &my_new_window );
  350.   
  351.   /* Have we opened the window succesfully? */
  352.   if(my_window == NULL)
  353.     clean_up( "Could not open the window!" );
  354.  
  355.  
  356.  
  357.   /* We will now try to activate the requester: */
  358.   result=Request( &my_requester, my_window );
  359.  
  360.   if( !result )  /* !result is the same thing as result==FALSE */
  361.   {
  362.     /* Intuition could not activate the requester! */
  363.     /* In this case we do not need to quit since it does not matter if */
  364.     /* the requester was activated or not. I just wanted to show how   */
  365.     /* you can check if you have successfully opened requester or not. */
  366.   
  367.     printf("Could not activate the requester!\n");
  368.   }
  369.   else
  370.  
  371.  
  372.  
  373.   close_me = FALSE;
  374.   /* Stay in the while loop until the user has selected the Close window */
  375.   /* gadget. However, in this example the user first need to deactivate */
  376.   /* the requester before he can select the Close window gadget: */
  377.   while( !close_me )
  378.   {
  379.     /* Wait until we have recieved a message: */
  380.     Wait( 1 << my_window->UserPort->mp_SigBit );
  381.  
  382.     /* As long as we collect messages sucessfully: */
  383.     while(my_message=(struct IntuiMessage *) GetMsg(my_window->UserPort))
  384.     {
  385.       /* After we have collected the message we can read it, and save any */
  386.       /* important values which we maybe want to check later: */
  387.       class = my_message->Class;
  388.  
  389.       /* After we have read it we reply as fast as possible: */
  390.       /* REMEMBER! Do never try to read a message after you have replied! */
  391.       /* Some other process has maybe changed it. */
  392.       ReplyMsg( my_message );
  393.  
  394.       /* Check which IDCMP flag was sent: */
  395.       switch( class )
  396.       {
  397.         case CLOSEWINDOW:  /* The user selected the Close window gadget! */
  398.                
  399.                /* It is first when the requester has been satisfied, the */
  400.                /* user can close the window. Remember, do never close a */
  401.                /* window if there are any active requester in it. */
  402.                
  403.                close_me=TRUE;
  404.                break;
  405.              
  406.         case GADGETDOWN:   /* The user has pressed on a gadget. */
  407.                /* Since there exist only one "nomal" gadget, we do not */
  408.                /* need to check which gadget was selected. */
  409.                
  410.                printf("Down\n");
  411.                break;
  412.              
  413.         case GADGETUP:     /* The user has released a gadget. */
  414.                /* Since there exist only one "nomal" gadget, we do not */
  415.                /* need to check which gadget was released. */
  416.                
  417.                printf("Up\n");
  418.  
  419.                /* Once the user releases this gadget the requester will */
  420.                /* be satisfied and deactivated. The user can from now on */
  421.                /* select the Close window gadget. */
  422.                
  423.                printf("Requester satisfied!\n");
  424.                printf("You may now close the window!\n");
  425.                break;
  426.       }
  427.     }
  428.   }
  429.  
  430.  
  431.  
  432.   /* Clean up and quit: */
  433.   clean_up( "THE END" );
  434. }
  435.  
  436.  
  437. void clean_up( STRPTR message )
  438. {
  439.   int loop;
  440.   
  441.  
  442.   /* Close the window: */
  443.   if( my_window )
  444.     CloseWindow( my_window );
  445.  
  446.   /* Close the screen: */
  447.   if( my_screen )
  448.     CloseScreen( my_screen );
  449.  
  450.   /* Deallocate the display memory, Bitplan by Bitplan. */ 
  451.   for( loop=0; loop < DEPTH; loop++)
  452.     if( my_bitmap.Planes[loop] ) /* Deallocate this Bitplan? */
  453.       FreeRaster( my_bitmap.Planes[loop], WIDTH, HEIGHT );
  454.  
  455.   /* Close the Graphics Library: */
  456.   if( GfxBase )
  457.     CloseLibrary( GfxBase );
  458.  
  459.   /* Close the Intuition Library since we have opened it: */
  460.   if( IntuitionBase )
  461.     CloseLibrary( IntuitionBase );
  462.   
  463.   
  464.   /* Tell the user what has happened: */
  465.   printf( "%s\n", message );
  466.   
  467.   /* Quit: */
  468.   exit( 0 );
  469. }
  470.