home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / 1990 / 05 / grdlagen / hello3a.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-08-10  |  17.2 KB  |  444 lines
  1. /*****************************************************/
  2. /*                                                   */
  3. /*                 HELLO3A.c                         */
  4. /*                                                   */
  5. /*  (C) 1989 Heid                                    */
  6. /*                                                   */
  7. /*  5. Version von Hello World:                      */
  8. /*  - Ausgabe von "Hello World by PM"                */
  9. /*    in einem Standardfenster mit Resourcen fuer    */
  10. /*    - Actionbar                                    */
  11. /*    - Akzeleratortasten                            */
  12. /*    - Textzeilen.                                  */
  13. /*  - Der Actionbar bietet die Eintraege "Commands"  */
  14. /*    und "Exit" an.                                 */
  15. /*    Das Pull-down-Menu von "Commands" hat 5        */
  16. /*    Eintraege, mit denen man jeweils einen         */
  17. /*    anderen String im Client ausgibt.              */
  18. /*  - F3 beendet das Programm.                       */
  19. /*  - Jeder Klick der li. Maustaste alterniert die   */
  20. /*    Hintergrundfarbe zwischen rot und gruen.       */
  21. /*                                                   */
  22. /*  Erweiterung von hello2.c !                       */
  23. /*  - die Windowprozedur ClientWndProc behandelt     */
  24. /*    explizit die folgenden 5 Events:               */
  25. /*        WMCREATE, WM_PAINT, WM_BUTTON1DOWN,        */
  26. /*        WM_COMMAND, WM_CHAR.                       */
  27. /*  - Benutzung von Resourcen!                       */
  28. /*                                                   */
  29. /*  Unterschied zu hello2.c:                         */
  30. /*  - Da F3 nun als Akzeleratortaste definiert ist,  */
  31. /*    wird die Reaktion auf F3 nach WM_COMMAND       */
  32. /*    abgehandelt.                                   */
  33. /*  - verschiedene Hintergrund- und Vordergrund-     */
  34. /*    farben fuer GpiCharStringAt(...,szString)      */
  35. /*                                                   */
  36. /*                                                   */
  37. /*                                                   */
  38. /*                                                   */
  39. /*  Benoetigte Dateien:                              */
  40. /*  -------------------                              */
  41. /*    HELLO3A.c      - Quellcode-Datei               */
  42. /*    HELLO3A.def    - Modul-Definitions-Datei       */
  43. /*    HELLO3A.rc     - Resource-Datei                */
  44. /*    HELLO3A.h      - Header-Datei                  */
  45. /*    OS2.h          - PM-Include-File               */
  46. /*                                                   */
  47. /*  Benoetigte Libraries:                            */
  48. /*  -------------------                              */
  49. /*    OS2.lib        - PM/OS2 Library                */
  50. /*                                                   */
  51. /*****************************************************/
  52.  
  53. #include <string.h>    // fuer strlen
  54. #include "hello3a.h"   // Symbol. Konstanten fuer die
  55.                        //         Resourcen
  56.  
  57. #define INCL_WIN
  58. #define INCL_GPI
  59. #include <os2.h>     // PM-Include-Datei
  60.  
  61.  
  62. /*****************************************************/
  63. /* Konstanten-Bezeichner                             */
  64. /*****************************************************/
  65. #define STRING_LAENGE  20    // Laenge von szString
  66.  
  67.  
  68. /*****************************************************/
  69. /* Funktions-Prototypen                              */
  70. /*****************************************************/
  71. MRESULT EXPENTRY ClientWindowProc( HWND hwnd,
  72.                                    USHORT msg,
  73.                                    MPARAM mp1,
  74.                                    MPARAM mp2 );
  75. int cdecl main( VOID );
  76. BOOL WndCreate( VOID );
  77.  
  78.  
  79. /*****************************************************/
  80. /* globale Variablen                                 */
  81. /*****************************************************/
  82. HAB  hab;                  // Programmanker
  83. CHAR szClientClass[] = "KlasseHello3";
  84.                            // Name der Fensterklasse
  85. HWND hwndClient;   // Handle fuer den Client-Bereich
  86.                    //        des Fensters
  87. HWND hwndFrame;    // Handle fuer das Frame-Fenster
  88.  
  89. CHAR szText[] = "Hello World by PM";
  90. CHAR szString[STRING_LAENGE];
  91.  
  92. // Strings, die in der Fensterprozedur bei WM_CREATE
  93. // gesetzt und bei WM_COMMAND fuer die Zuweisung
  94. // an die Variable szString benutzt werden.
  95. CHAR szHallo[STRING_LAENGE];
  96. CHAR sz1[STRING_LAENGE];
  97. CHAR sz2[STRING_LAENGE];
  98. CHAR sz3[STRING_LAENGE];
  99.  
  100.  
  101.  
  102.  
  103. /*-------  Start der main-Funktion  -----------------*/
  104. /*                                                   */
  105. /* - initialisiert und terminiert                    */
  106. /* - Message-Loop                                    */
  107. /*                                                   */
  108. /* - benutzte globale Variable: hab, hwndFrame.      */
  109. /* - ruft: WndCreate()                               */
  110. /*                                                   */
  111. /*---------------------------------------------------*/
  112. int cdecl main(  )
  113. {
  114.   HMQ   hmq;          // Handle fuer die Message-Queue
  115.   QMSG  qmsg;         // Message in der Message-Queue
  116.  
  117.   hab = WinInitialize( NULL );       // Initialisiere PM
  118.   hmq = WinCreateMsgQueue( hab, 0 ); // Erzeuge Message-Queue
  119.  
  120.   if ( hmq != (HMQ)NULL )
  121.   {
  122.     if ( WndCreate() == TRUE )
  123.     {
  124.       /************************************************/
  125.       /* "Message-processing-Loop":                   */
  126.       /* Empfaengt und verteilt Messages aus der      */
  127.       /* Message-Queue der Anwendung, bis WinGetMsg   */
  128.       /* FALSE zurueckgibt: dies geschieht dann, wenn */
  129.       /* WinGetMsg eine WM_QUIT-Message erhielt.      */
  130.       /************************************************/
  131.       while( WinGetMsg( hab, (PQMSG)&qmsg,
  132.                         (HWND)NULL, 0, 0 )
  133.             )
  134.         WinDispatchMsg( hab, (PQMSG)&qmsg );
  135.  
  136.       WinDestroyWindow( hwndFrame );
  137.     }
  138.     WinDestroyMsgQueue( hmq );
  139.   }
  140.   WinTerminate( hab );
  141.  
  142.   return 0;
  143. }
  144. /*-------  Ende der main-Funktion  ------------------*/
  145.  
  146.  
  147.  
  148.  
  149. /*-------  Start der WndCreate-Funktion -------------*/
  150. /*                                                   */
  151. /* - registriert die Fensterklasse des Client        */
  152. /* - erzeugt das Standardfenster                     */
  153. /*                                                   */
  154. /* - benutzte globale Variable:                      */
  155. /*   hab, szClientClass, hwndClient, hwndFrame.      */
  156. /* - aufgerufen von: main()                          */
  157. /* - Return: - TRUE, wenn alles klappt               */
  158. /*           - FALSE, wenn etwas schiefging          */
  159. /*---------------------------------------------------*/
  160. BOOL WndCreate( VOID )
  161. {
  162.   ULONG flCreateFrame;  // Flaggen fuer die Erzeugung
  163.                         //         der Controls
  164.   BOOL  brc;            // Hilfsvariable zum Abpruefen
  165.                         //    des Rueckgabewertes von
  166.                         //    API-Funktionen
  167.  
  168.   brc = WinRegisterClass(    // Ordne die ClientWndProc
  169.                              //    einer Klasse zu
  170.           hab,
  171.           szClientClass,     // Name der Fensterklasse
  172.           ClientWindowProc,  // Adr. der Fensterprozedur
  173.           CS_SIZEREDRAW,     // Klassen-Style
  174.           0                  // keine Extra-Bytes reservieren
  175.           );
  176.  
  177.            // WinRegisterClass nicht erfolgreich
  178.   if ( brc == FALSE ) return ( FALSE );
  179.  
  180.            // nun Standardfenster auch mit Actionbar
  181.            //     und Akzeleratortabelle als Resource
  182.   flCreateFrame = FCF_STANDARD & ~FCF_ICON;
  183.  
  184.            // Erzeugen eines Standardfensters
  185.   hwndFrame = WinCreateStdWindow(
  186.  
  187.            HWND_DESKTOP,      // Handle des Vaterfensters
  188.            WS_VISIBLE,        // Style des Frame-Fensters
  189.            (PULONG)&flCreateFrame,
  190.            szClientClass,     // Client-Fenster-Klasse
  191.            "",                // Kein expliziter Titel
  192.            0L,                // Style des Client-Fensters
  193.            NULL,              // Resourcen sind in EXE-Datei
  194.            ID_RESOURCE,       // Bezeichner fuer Resourcen
  195.            (PHWND)&hwndClient // Zeiger auf den Handle des
  196.                               //    Client-Fensters
  197.            );
  198.  
  199.                // WinCreateStdWindow nicht erfolgreich
  200.   if ( hwndFrame == (HWND)NULL ) return ( FALSE );
  201.  
  202.   return ( TRUE );
  203.  
  204. }
  205. /*-------  Ende der WndCreate-Funktion --------------*/
  206.  
  207.  
  208.  
  209. /*-------  Start der Window-Prozedur des Client -----*/
  210. /*                                                   */
  211. /* - behandelt die Reaktionen des Clientfensters     */
  212. /*                                                   */
  213. /* - benutzte globale Variable:  hab, szText,        */
  214. /*       szHallo, sz1, sz2, sz3, szString.           */
  215. /*                                                   */
  216. /* - aufgerufen von: Presentation Manager            */
  217. /*---------------------------------------------------*/
  218. MRESULT EXPENTRY ClientWindowProc( HWND hwnd,
  219.                                    USHORT msg,
  220.                                    MPARAM mp1,
  221.                                    MPARAM mp2 )
  222. {
  223.   HPS    hps;       // Presentation-Space-Handle
  224.   RECTL  rectl;     // Struktur Rechteck-Koordinaten
  225.   POINTL pt;        // Koordinaten fuer den Textanfang
  226.   LONG   lCount;    // Stringlaenge ohne ASCII-Null
  227.   USHORT command;   // Command-Wert bei WM_COMMAND
  228.                     // Hintergrundfarbe des Clients
  229.   static COLOR colorClient = CLR_RED;
  230.                     // wird eraseLastLine auf TRUE
  231.                     // gesetzt, wird die letzte Zeile
  232.                     // nicht mehr angezeigt.
  233.   static BOOL eraseLastLine = FALSE;
  234.  
  235.  
  236.   switch( msg )
  237.   {
  238.  
  239.     case WM_CREATE:
  240.       /***********************************************/
  241.       /* hier werden Initialisierungen vorgenommen:  */
  242.       /* WinLoadString laedt die Strings aus der     */
  243.       /*               Resource-Datei                */
  244.       /***********************************************/
  245.       WinLoadString( hab, NULL, IDS_HALLO,
  246.                      STRING_LAENGE, szHallo );
  247.       WinLoadString( hab, NULL, IDS_1,
  248.                      STRING_LAENGE, sz1     );
  249.       WinLoadString( hab, NULL, IDS_2,
  250.                      STRING_LAENGE, sz2     );
  251.       WinLoadString( hab, NULL, IDS_3,
  252.                      STRING_LAENGE, sz3     );
  253.                     // Kopiert "Hallo !" in szString
  254.       strcpy( szString, szHallo );
  255.       break;
  256.  
  257.  
  258.     case WM_PAINT:
  259.       /***********************************************/
  260.       /* hier wird der Inhalt des Clients gezeichnet */
  261.       /***********************************************/
  262.                 // Erzeuge einen Presentation Space
  263.       hps = WinBeginPaint( hwnd, NULL, NULL );
  264.  
  265.                 // rect erhaelt Koordinaten des Client
  266.         WinQueryWindowRect( hwnd, &rectl );
  267.  
  268.                 // Hintergrundfarbe des Client schreiben
  269.         WinFillRect( hps, &rectl, colorClient );
  270.  
  271.         pt.x =  10L; // Setze die Anfangskoordinaten fuer
  272.         pt.y = 240L; //       die Ausgabe des Textes
  273.  
  274.                       // Setze Text-Farbe
  275.         GpiSetColor( hps, CLR_WHITE );
  276.  
  277.                       // Zeichne den Textstring szText
  278.         GpiCharStringAt( hps, &pt, (LONG)strlen(szText),
  279.                          (PCH)szText );
  280.  
  281.         pt.x =  30L;  // Setze Koordinaten fuer
  282.         pt.y = 190L;  //       weitere Textausgaben
  283.         GpiCharStringAt( hps, &pt, 23L,
  284.                        (PCH)"Maus-Taste 1 alterniert");
  285.         pt.y = 175L;
  286.         GpiCharStringAt( hps, &pt, 26L,
  287.                     (PCH)"die Farbe dieses Fensters!");
  288.         pt.y = 150L;
  289.         lCount = (LONG)strlen("F3 beendet das Programm!");
  290.         GpiCharStringAt( hps, &pt, lCount,
  291.                          (PCH)"F3 beendet das Programm!");
  292.         pt.x = 10L; pt.y = 110L;
  293.         GpiCharStringAt( hps, &pt, 30L,
  294.                 (PCH)"Die folgende Zeile laesst sich");
  295.         pt.y = 90L;
  296.         GpiCharStringAt( hps, &pt, 29L,
  297.                (PCH)"mit dem Menue \"Commands\" oder");
  298.         pt.y = 70L;
  299.         GpiCharStringAt( hps, &pt, 53L,
  300.                 (PCH)"mit Akzeleratortasten aendern \
  301. bzw. unsichtbar machen:");
  302.  
  303.        if ( eraseLastLine == FALSE )
  304.        {
  305.        // ab hier Fuellen der 3 variablen Ausgabefelder
  306.                       // weiss auf dem jeweiligen
  307.                       //       Fensterhintergrund
  308.         pt.x = 50; pt.y = 40;
  309.         GpiCharStringAt( hps, &pt,
  310.                     (LONG)strlen(szString), szString );
  311.  
  312.                       // Rechteckhintergrund auf weiss
  313.         pt.x = 150; pt.y = 40;
  314.                       // Setze Text-Farbe
  315.         GpiSetColor( hps, colorClient );
  316.                       // Setze Hintergrund-Farbe
  317.         GpiSetBackColor( hps, CLR_WHITE );
  318.                       // Mischung der Hintergrundfarben
  319.         GpiSetBackMix( hps, BM_OVERPAINT );
  320.         GpiCharStringAt( hps, &pt,
  321.                     (LONG)strlen(szString), szString );
  322.  
  323.                       // hier schwarz auf weiss
  324.         pt.x = 250; pt.y = 40;
  325.         GpiSetColor( hps, CLR_BLACK );
  326.         GpiSetBackColor( hps, CLR_WHITE );
  327.         GpiSetBackMix( hps, BM_OVERPAINT );
  328.         GpiCharStringAt( hps, &pt,
  329.                     (LONG)strlen(szString), szString );
  330.        }
  331.  
  332.       WinEndPaint( hps );   // Paint ist erledigt
  333.       return 0;
  334.  
  335.  
  336.     case WM_BUTTON1DOWN:
  337.       /***********************************************/
  338.       /* Maus-Taste 1 wurde geklickt:                */
  339.       /*  - Sicherstellen, dass Client den Focus hat */
  340.       /*  - Alternieren der Farbvariable colorClient */
  341.       /*    zwischen rot und gruen.                  */
  342.       /*  - Abschicken einer PAINT-Message, damit    */
  343.       /*    das Fenster neu gezeichnet wird.         */
  344.       /***********************************************/
  345.       WinSetFocus( HWND_DESKTOP, hwnd );
  346.  
  347.       colorClient = ( colorClient == CLR_RED ) ?
  348.                       ( CLR_GREEN ) : (CLR_RED );
  349.  
  350.       WinInvalidateRect( hwnd, NULL, TRUE );
  351.       return 0;
  352.  
  353.  
  354.     case WM_CHAR:
  355.       /***********************************************/
  356.       /* Bearbeiten von Tastatur-Eingaben:           */
  357.       /*  - Tastatur-Eingaben erzeugen nur dann      */
  358.       /*    eine WM_CHAR-Message, wenn sie nicht     */
  359.       /*    in der Akzelerator-Tabelle definiert     */
  360.       /*    sind.                                    */
  361.       /***********************************************/
  362.       if( CHARMSG( &msg ) -> vkey == VK_F3 )
  363.       // diese Abfrage wird nie erfüllt wegen hot keys
  364.           DosBeep( 260, 100 );
  365.  
  366.       if( CHARMSG( &msg ) -> vkey == VK_F2 )
  367.           DosBeep( 260, 100 );
  368.  
  369.       return 0;
  370.  
  371.  
  372.     case WM_COMMAND:
  373.       /***********************************************/
  374.       /* Bearbeiten der Menue-Selektion:             */
  375.       /*  - Die ersten 2 Byte des Message-Parameters */
  376.       /*    mp1 enthalten den Command-Wert, also     */
  377.       /*    den Wert des Bezeichners fuer den        */
  378.       /*    ausgewaehlten Menueeintrag.              */
  379.       /*  - Wenn im "Commands"-Submenue eine der     */
  380.       /*    Optionen 1-4 selektiert wird, erhaelt    */
  381.       /*    szString den entsprechenden Wert und     */
  382.       /*    WinInvalidateRegion schickt ein WM_PAINT.*/
  383.       /*    Die Auswahl der 5. Option dagegen        */
  384.       /*    bewirkt, dass die letzte Zeile gar       */
  385.       /*    nicht erst geschrieben wird.             */
  386.       /*  - Wenn im "Exit"-Submenue der Eintrag      */
  387.       /*    "Exit" gewaehlt wird, schickt sich die   */
  388.       /*    Anwendung eine WM_CLOSE-Message.         */
  389.       /*    Bei "Resume" tut sie gar nichts.         */
  390.       /***********************************************/
  391.  
  392.       command = COMMANDMSG(&msg)->cmd;
  393.       switch (command)
  394.       {
  395.         case IDM_OPTION1:
  396.           eraseLastLine = FALSE;
  397.           strcpy( szString, sz1 );
  398.           WinInvalidateRegion( hwnd, NULL, FALSE );
  399.           break;
  400.         case IDM_OPTION2:
  401.           eraseLastLine = FALSE;
  402.           strcpy( szString, sz2 );
  403.           WinInvalidateRegion( hwnd, NULL, FALSE );
  404.           break;
  405.         case IDM_OPTION3:
  406.           eraseLastLine = FALSE;
  407.           strcpy( szString, sz3 );
  408.           WinInvalidateRegion( hwnd, NULL, FALSE );
  409.           break;
  410.         case IDM_HALLO:
  411.           eraseLastLine = FALSE;
  412.           strcpy( szString, szHallo );
  413.           WinInvalidateRegion( hwnd, NULL, FALSE );
  414.           break;
  415.         case IDM_ERASE:
  416.           eraseLastLine = TRUE;
  417.           WinInvalidateRegion( hwnd, NULL, FALSE );
  418.           break;
  419.         case IDM_EXITPROG:
  420.           WinPostMsg( hwnd, WM_CLOSE, 0L, 0L );
  421.           break;
  422.         case IDM_RESUME:
  423.           break;
  424.         default:
  425.           return WinDefWindowProc( hwnd, msg, mp1, mp2 );
  426.       }
  427.       break;
  428.  
  429.  
  430.     default:
  431.       /***********************************************/
  432.       /* Hierher gelangen alle anderen Events, die   */
  433.       /* von der Window-Prozedur des Client-Bereiches*/
  434.       /* nicht explizit behandelt werden.            */
  435.       /* Dieser Fall ("case") muss vorhanden sein!   */
  436.       /***********************************************/
  437.  
  438.       return WinDefWindowProc( hwnd, msg, mp1, mp2 );
  439.   }
  440.  
  441.   return FALSE;
  442. }
  443. /*-------  Ende der Window-Prozedur des Client  -----*/
  444.