home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / 1990 / 03 / multi / hello2.c < prev    next >
C/C++ Source or Header  |  1990-01-23  |  11KB  |  228 lines
  1. /**********************************************************/
  2. /*                     HELLO2.c                           */
  3. /*                                                        */
  4. /*            (C) 1990 Heid & toolbox                     */
  5. /*                                                        */
  6. /*  Minimalversion von Hello World:                       */
  7. /*  - Ausgabe von "toolbox, das Fenster zum Durchblicken" */
  8. /*    in Standardfenster, ohne Actionbar, ohne Ressourcen */
  9. /*  Erweiterung von hello1.c !                            */
  10. /*  - die Windowprozedur ClientWndProc behandelt          */
  11. /*    explizit die folgenden 3 Events:                    */
  12. /*        WM_PAINT, WM_BUTTON1DOWN, WM_CHAR               */
  13. /*  - F3 beendet das Programm.                            */
  14. /*  - jeder Klick der li. Maustaste alterniert Farbe      */
  15. /*  Unterschied zu hello1.c:                              */
  16. /*  - ohne WM_CREATE und ohne WM_DESTROY                  */
  17. /*  - statt WinDrawText nun mit GpiCharStringAt           */
  18. /*  Benötigte Dateien: HELLO2.c, HELLO2.def, OS2.h        */
  19. /*  Benötigte Libraries:  OS2.lib                         */
  20. /**********************************************************/
  21.  
  22. #include <string.h>                      //      fuer strlen
  23. #define INCL_WIN
  24. #include <os2.h>                         // PM-Include-Datei
  25.  
  26. /**********************************************************/
  27. /* Funktions-Prototypen                                   */
  28. /**********************************************************/
  29.  
  30. MRESULT EXPENTRY ClientWindowProc( HWND hwnd,
  31.                                    USHORT msg,
  32.                                    MPARAM mp1,
  33.                                    MPARAM mp2 );
  34. int cdecl main( VOID );
  35. BOOL WndCreate( VOID );
  36. /**********************************************************/
  37. /* globale Variablen                                      */
  38. /**********************************************************/
  39. HAB  hab;                  //                  Programmanker
  40. CHAR szClientClass[] = "KlasseHello2";
  41.                            //         Name der Fensterklasse
  42. HWND hwndClient;           // Handle fuer den Client-Bereich
  43.                            //                   des Fensters
  44. HWND hwndFrame;            //  Handle fuer das Frame-Fenster
  45.  
  46. /*-------  Start der main-Funktion  ----------------------*/
  47. /*                                                        */
  48. /* - initialisiert und terminiert                         */
  49. /* - Message-Loop                                         */
  50. /*                                                        */
  51. /* - ruft: WndCreate()                                    */
  52. /*                                                        */
  53. /*--------------------------------------------------------*/
  54. int cdecl main(  )
  55. {
  56.   HMQ   hmq;          // Handle fuer die Message-Queue
  57.   QMSG  qmsg;         // Message in der Message-Queue
  58.   hab = WinInitialize( NULL );       // Initialisiere PM
  59.   hmq = WinCreateMsgQueue( hab, 0 );
  60.                                    // Erzeuge Message-Queue
  61.   if ( hmq != (HMQ)NULL )
  62.   {
  63.     if ( WndCreate() == TRUE )
  64.     {
  65.       /****************************************************/
  66.       /* "Message-processing-Loop":                       */
  67.       /* Empfange und verteile Messages aus der           */
  68.       /* Message-Queue der Anwendung, bis WinGetMsg       */
  69.       /* FALSE zurueckgibt: dies geschieht dann, wenn     */
  70.       /* WinGetMsg eine WM_QUIT-Message erhielt.          */
  71.       /****************************************************/
  72.       while( WinGetMsg( hab, (PQMSG)&qmsg,
  73.                         (HWND)NULL, 0, 0 )
  74.             )
  75.         WinDispatchMsg( hab, (PQMSG)&qmsg );
  76.       WinDestroyWindow( hwndFrame );
  77.     }
  78.     WinDestroyMsgQueue( hmq );
  79.   }
  80.   WinTerminate( hab );
  81.   return 0;
  82. }
  83. /*-------  Ende der main-Funktion  -----------------------*/
  84.  
  85. /*-------  Start der WndCreate-Funktion ------------------*/
  86. /*                                                        */
  87. /* - registriert Fensterklasse des Client                 */
  88. /* - erzeugt das Standardfenster                          */
  89. /*                                                        */
  90. /* - benutzte globale Variable:                           */
  91. /*   hab, szClientClass, hwndClient, hwndFrame.           */
  92. /* - aufgerufen von: main()                               */
  93. /* - Return: - TRUE, wenn alles klappt                    */
  94. /*           - FALSE, wenn etwas schiefging               */
  95. /*--------------------------------------------------------*/
  96. BOOL WndCreate( VOID )
  97. {
  98.   ULONG flCreateFrame;        //  Flaggen fuer die Erzeugung
  99.                               //                der Controls
  100.   BOOL  brc;                  // Hilfsvariable zum Abpruefen
  101.                               //     des Rueckgabewertes von
  102.                               //              API-Funktionen
  103.   brc = WinRegisterClass(     //     Ordne die ClientWndProc
  104.                               //             einer Klasse zu
  105.           hab,
  106.           szClientClass,      //      Name der Fensterklasse
  107.           ClientWindowProc,   //    Adr. der Fensterprozedur
  108.           CS_SIZEREDRAW,      //               Klassen-Style
  109.           0                   //           keine Extra-Bytes
  110.           );                  //                 reservieren
  111.                        // WinRegisterClass nicht erfolgreich
  112.   if ( brc == FALSE ) return ( FALSE );
  113.                  // welche Controls sollen eingefuegt werden
  114.   flCreateFrame = FCF_STANDARD & ~FCF_ICON
  115.                                & ~FCF_ACCELTABLE
  116.                                & ~FCF_MENU;
  117.                           // Erzeugen eines Standardfensters
  118.   hwndFrame = WinCreateStdWindow(
  119.        HWND_DESKTOP,             // Handle des Vaterfensters
  120.        WS_VISIBLE,               // Style des Frame-Fensters
  121.        (PULONG)&flCreateFrame,
  122.        szClientClass,       //         Client-Fenster-Klasse
  123.        "",                  //         Kein expliziter Titel
  124.        0L,                  //     Style des Client-Fensters
  125.        NULL,                //  Ressourcen sind in EXE-Datei
  126.        0,                   // keine Identity für Ressourcen
  127.        (PHWND)&hwndClient   //     Zeiger auf den Handle des
  128.                             //               Client-Fensters
  129.        );
  130.                      // WinCreateStdWindow nicht erfolgreich
  131.   if ( hwndFrame == (HWND)NULL ) return ( FALSE );
  132.   return ( TRUE );
  133. }
  134. /*-------  Ende der WndCreate-Funktion -------------------*/
  135.  
  136. /*-------  Start der Window-Prozedur des Client ----------*/
  137. /* - behandelt die Reaktionen des Clientfensters          */
  138. /* - erzeugt das Standardfenster                          */
  139. /* - benutzte globale Variable:  /                        */
  140. /* - aufgerufen von: Presentation Manager                 */
  141. /*--------------------------------------------------------*/
  142. MRESULT EXPENTRY ClientWindowProc( HWND hwnd,
  143.                                    USHORT msg,
  144.                                    MPARAM mp1,
  145.                                    MPARAM mp2 )
  146. {
  147.   HPS    hps;             //       Presentation-Space-Handle
  148.   RECTL  rectl;           //   Struktur Rechteck-Koordinaten
  149.   POINTL pt;              // Koordinaten fuer den Textanfang
  150.   LONG   lCount;          //    Stringlaenge ohne ASCII-Null
  151.  
  152.   static CHAR szText[] = "das toolbox-Fenster";
  153.                           //    Hintergrundfarbe des Clients
  154.   static COLOR colorClient = CLR_RED;
  155.   switch( msg )
  156.   {
  157.     case WM_PAINT:
  158.       /****************************************************/
  159.       /* hier wird der Inhalt des Clients gezeichnet      */
  160.       /****************************************************/
  161.                      //     Erzeuge einen Presentation Space
  162.       hps = WinBeginPaint( hwnd, NULL, NULL );
  163.                     //   rect erhaelt Koordinaten des Client
  164.         WinQueryWindowRect( hwnd, &rectl );
  165.                     // Hintergrundfarbe des Client schreiben
  166.         WinFillRect( hps, &rectl, colorClient );
  167.         pt.x = 10L;     // Setze die Anfangskoordinaten fuer
  168.         pt.y = 190L;    //            die Ausgabe des Textes
  169.                         //                  Setze Text-Farbe
  170.         GpiSetColor( hps, CLR_WHITE );
  171.                         //     Zeichne den Textstring szText
  172.         GpiCharStringAt( hps, &pt, (LONG)strlen(szText),
  173.                          (PCH)szText );
  174.                         //   Setze y-Koordinate fuer weitere
  175.         pt.y = 170L;    //                      Textausgaben
  176.         GpiCharStringAt( hps, &pt, 23L,
  177.                          (PCH)"Maus-Taste 1 alterniert");
  178.         pt.y = 155L;
  179.         GpiCharStringAt( hps, &pt, 26L,
  180.                     (PCH)"die Farbe dieses Fensters!xxx" );
  181.         pt.y = 130L;
  182.         lCount = (LONG)strlen("F3 beendet das Programm!");
  183.         GpiCharStringAt( hps, &pt, lCount,
  184.                          (PCH)"F3 beendet das Programm!");
  185.       WinEndPaint( hps );              // Paint ist erledigt
  186.       return 0;
  187.  
  188.     case WM_BUTTON1DOWN:
  189.       /****************************************************/
  190.       /* Maus-Taste 1 wurde geklickt:                     */
  191.       /*  - Sicherstellen, dass Client den Focus hat      */
  192.       /*  - Alternieren der Farbvariable colorClient      */
  193.       /*  - Abschicken einer PAINT-Message, damit         */
  194.       /*    das Fenster neu gezeichnet wird.              */
  195.       /****************************************************/
  196.       WinSetFocus( HWND_DESKTOP, hwnd );
  197.       colorClient = ( colorClient == CLR_RED ) ?
  198.                       ( CLR_GREEN ) : (CLR_RED );
  199.       WinInvalidateRect( hwnd, NULL, TRUE );
  200.       return 0;
  201.     case WM_CHAR:
  202.       /****************************************************/
  203.       /* Bearbeiten von Tastatur-Eingaben:                */
  204.       /*  - Die ersten 2 Byte des Message-Parameters      */
  205.       /*    mp2 enthalten den Zeichen-Code, die höheren   */
  206.       /*    2 Byte enthalten den "virtuellen" Tasten-Code */
  207.       /*  - Wenn F3 gedrueckt wurde, wird eine            */
  208.       /*    WM_QUIT-Message an die Message-Queue          */
  209.       /*    gepostet, um das Programm zu beenden.         */
  210.       /****************************************************/
  211.       if( CHARMSG( &msg ) -> vkey == VK_F3 )
  212.         // oder: if ( SHORT2FROMMP( mp2 ) == VK_F3 )
  213.         WinPostMsg( hwnd, WM_QUIT, 0L, 0L );
  214.       return 0;
  215.     default:
  216.       /****************************************************/
  217.       /* Hierher gelangen alle anderen Events, die        */
  218.       /* von der Window-Prozedur des Client-Bereiches     */
  219.       /* nicht explizit behandelt werden.                 */
  220.       /* Dieser Fall muß(!) behandelt werden!             */
  221.       /****************************************************/
  222.  
  223.       return WinDefWindowProc( hwnd, msg, mp1, mp2 );
  224.   }
  225.   return FALSE;
  226. }
  227. /*-------  Ende der Window-Prozedur des Client  ----------*/
  228.