home *** CD-ROM | disk | FTP | other *** search
/ Amiga Elysian Archive / AmigaElysianArchive.iso / prog / source / cxercise.lha / SIMPLEW3.C < prev   
Encoding:
C/C++ Source or Header  |  1987-04-20  |  5.8 KB  |  128 lines
  1. /***********************************************\
  2. *                                               *
  3. *  Sample Intuition Screen & Window program #3  *
  4. *                                               *
  5. *  Written for ATUG's 'C SIG' by Dave Brittain  *
  6. *                                               *
  7. \***********************************************/
  8.  
  9. #include <exec/types.h>
  10. #include <intuition/intuition.h>
  11.  
  12. struct IntuitionBase *IntuitionBase;
  13.  
  14. #define INTUITION_REV 0
  15.  
  16. struct IntuiText IntuiText =
  17. { 2, 0,   /* FrontPen, BackPen */
  18.   JAM1,   /* DrawMode, JAM1 = draw foreground but not background */
  19.   10, 20, /* LeftEdge, TopEdge */
  20. };        /* TextAttr, IText & Text become NULL when not specified. */
  21.  
  22. struct NewScreen NS =
  23. { 0, 0, 640, 200, 2, /* LeftEdge, TopEdge, Width, Height, Depth */
  24.   0, 1,              /* DetailPen, BlockPen */
  25.   HIRES,             /* ViewModes */
  26.   CUSTOMSCREEN,      /* Type */
  27.   NULL,              /* Font */
  28.  "A Sample Screen",  /* DefaultTitle */
  29. };                   /* Gadgets & CustomBitMap = NULL */
  30.  
  31. /*****************************************************************************\
  32. *                                                                             *
  33. *  A  static initialization of a NewWindow data structure.  This is used  by  *
  34. *  Intuition to create a window structure, which is a dynamically allocated,  *
  35. *  and used structure.  The other way of initializing a structure,  would be  *
  36. *  to  write a list of simple assignment statements that assign a  value  to  *
  37. *  each  member of (field within) the structure.  I prefer  static  initial-  *
  38. *  ization whenever possible,  since it is much quicker to type in,  and  it  *
  39. *  doesn't generate any executable code.  See page 12 of the Intuition  Ref-  *
  40. *  erence  manual for the string of 18 assignment statements that  does  the  *
  41. *  same thing as the static initialization below.  See page B-12 & 13 of the  *
  42. *  Intuition manual for the definition of the NewWindow structure.            *
  43. *                                                                             *
  44. \*****************************************************************************/
  45.  
  46. struct NewWindow SampleWindow =
  47. { 20, 20, 400, 100, /* LeftEdge, TopEdge, Width, Height */
  48.    0, 1,            /* DetailPen, BlockPen */
  49.  CLOSEWINDOW,       /* IDCMPFlags - Tells Intuition what events we want to
  50.                        hear about. */
  51.  ( WINDOWCLOSE | SMART_REFRESH | ACTIVATE | WINDOWSIZING | WINDOWDRAG |
  52.    WINDOWDRAG  | WINDOWDEPTH   | NOCAREREFRESH ), /* Flags */
  53.  NULL,              /* FirstGadget - points to YOUR gadget list. */
  54.  NULL,              /* CheckMark - points to YOUR checkmark image */
  55. "A Simple Window #3", /* Title-points to the text "A Simple Window #2", which is
  56.                        actually stored somewhere in an initialized data area */
  57.  NULL, NULL,        /* Screen, BitMap */
  58.  100, 25, 640, 200, /* MinWidth, MinHeight, MaxWidth, MaxHeight */
  59.  CUSTOMSCREEN       /* Type */
  60. };
  61.  
  62. /* Temporary storage of IntuiMessages before they are replied to. */
  63. struct IntuiMessage MyIM; 
  64.  
  65. void main()  /* a void function has no return value. */
  66. {
  67.   struct Window       *Window;
  68.   struct Screen       *Screen;
  69.   struct IntuiMessage *IntuiMessage; /* The actual IntuiMessage. */
  70.  
  71.   /***********************************************************\
  72.   *  The following statements open the Intuition library for  *
  73.   *  programatic use.                                         *
  74.   \***********************************************************/
  75.  
  76.   if (((IntuitionBase = (struct IntuitionBase *)
  77.      OpenLibrary("intuition.library", INTUITION_REV)) != NULL)
  78.   && ((Screen = (struct Screen *) OpenScreen(&NS)) != NULL))
  79.   {
  80.     /* Intuition & our screen are open, now write something into the screen: */
  81.  
  82.     IntuiText.IText = "Sample text written to a sample screen";
  83.     IntuiText.LeftEdge = 150; /* start 150 pixels from left of screen. */
  84.     IntuiText.TopEdge  = 150; /* 3/4 of the way down from the top. */
  85.     PrintIText(&Screen->RastPort, &IntuiText, 0, 0);
  86.  
  87.     /* Now open the window, but first initialize the 'Screen' member of
  88.        the NewWindow (ours is called 'SampleWindow') structure, so
  89.        Intuition will know which custom screen to open our window on: */
  90.  
  91.     SampleWindow.Screen = Screen; 
  92.  
  93.     if ((Window = (struct Window *) OpenWindow(&SampleWindow)) != NULL)
  94.     { /* our window is now open, now write the pre-initialized text. */
  95.  
  96.       IntuiText.LeftEdge = 30;
  97.       IntuiText.TopEdge  = 30;
  98.       IntuiText.FrontPen =  3;
  99.       IntuiText.IText    = "Sample text written to a simple window.";
  100.       PrintIText(Window->RPort, &IntuiText, 0, 0);
  101.  
  102.       /* Now wait for Intuition to send us a CLOSEWINDOW message. */
  103.  
  104.       do
  105.       { WaitPort(Window->UserPort);
  106.         IntuiMessage = (struct IntuiMessage *) GetMsg(Window->UserPort);
  107.         MyIM = *IntuiMessage; /* Copy the message and reply right away */
  108.         ReplyMsg(IntuiMessage);
  109.  
  110.       /**********************************************************************\
  111.       *                                                                      *
  112.       * ALL messages should be processed here, using the copy of the message *
  113.       * that we placed into 'MyIM'.  This allows Intuition to deallocate the *
  114.       * memory it allocated for the message, while we figure out what to  do *
  115.       * with the message.  Since we are only going to get a CLOSEWINDOW mes- *
  116.       * sage and quit, this is a bit overly cautious.                        *
  117.       *                                                                      *
  118.       \**********************************************************************/
  119.  
  120.       } while (MyIM.Class != CLOSEWINDOW);
  121.       
  122.       if (Window != NULL)      CloseWindow(Window);
  123.     };
  124.     if (Screen != NULL)        CloseScreen(Screen);
  125.     if (IntuitionBase != NULL) CloseLibrary(IntuitionBase);
  126.   };
  127. } /* End of program */
  128.