home *** CD-ROM | disk | FTP | other *** search
/ Vectronix 2 / VECTRONIX2.iso / FILES_01 / PC_V11_B.LZH / DEMO_PC / PCGEM4.C < prev    next >
Text File  |  1992-05-09  |  18KB  |  378 lines
  1. /************************************************************************/
  2. /*                                                                      */
  3. /*       Beispielprogramm:                             EVNT_MULTI( )    */
  4. /*                                            diverse WIND_-Routinen    */
  5. /*                                                                      */
  6. /*       Copyright (c) 1989 Borland International                       */
  7. /*       All rights reserved.                                           */
  8. /*                                                                      */
  9. /************************************************************************/
  10.  
  11. /* -------------------------------------------------------------------- */
  12. /*       Include-Files einbinden.                                       */
  13. /* -------------------------------------------------------------------- */
  14.  
  15. #include <aes.h>
  16. #include <vdi.h>
  17. #include <stdio.h>
  18.  
  19. #include "scancode.h"
  20.  
  21. /* -------------------------------------------------------------------- */
  22. /*       Konstantendefinitionen.                                        */
  23. /* -------------------------------------------------------------------- */
  24.  
  25. #define DESK                  0
  26.  
  27. #define W_KIND                NAME|CLOSER|FULLER|MOVER|SIZER
  28. #define EV_KIND               MU_MESAG|MU_TIMER|MU_KEYBD
  29.  
  30. #define WINDOW_NAME           "Pure C - Beispielprogramm"
  31.  
  32. #define min(a, b)             ((a) < (b) ? (a) : (b))
  33. #define max(a, b)             ((a) > (b) ? (a) : (b))
  34.  
  35. /* -------------------------------------------------------------------- */
  36. /*    Typendefinition.                                                  */
  37. /* -------------------------------------------------------------------- */
  38.  
  39. typedef enum
  40. {
  41.     FALSE,
  42.     TRUE
  43. }
  44. boolean;
  45.  
  46. /* -------------------------------------------------------------------- */
  47. /*    Funktionsprototypen.                                              */
  48. /* -------------------------------------------------------------------- */
  49.  
  50. void    gem_prg( void );
  51. void    hndl_window( void );
  52. void    do_redraw( int w_handle, int x, int y, int w, int h );
  53. void    new_size( int w_handle, int x, int y, int w, int h );
  54. void    close_window( int w_handle );
  55. void    clipping( int x, int y, int w, int h, int mode );
  56. boolean rc_intersect( GRECT *r1, GRECT *r2 );
  57. boolean open_window( void );
  58.  
  59. /* -------------------------------------------------------------------- */
  60. /*       Globale Variablen.                                             */
  61. /* -------------------------------------------------------------------- */
  62.  
  63. int     Msgbuff[8];                 /* Buffer für Mitteilungen.         */
  64.  
  65. int     W_handle,                   /* Variablen zum Arbeiten mit einem */
  66.         Wx, Wy, Ww, Wh;             /* Fenster - bei mehreren Fenstern  */
  67. boolean W_fulled;                   /* ist ein Feld mit diesen Variabl. */
  68.                                     /* zu vereinbaren.                  */
  69. int     pxarray[128];               /* Feld für Clipkoordinaten etc.    */
  70. boolean Done = FALSE;               /* 'Mach weiter'-Flag.              */
  71.  
  72. /* -------------------------------------------------------------------- */
  73. /*       Extern definierte globale Variable.                            */
  74. /* -------------------------------------------------------------------- */
  75.  
  76. extern int handle;
  77. extern int gl_wbox,
  78.            gl_hbox;
  79.  
  80. /* -------------------------------------------------------------------- */
  81. /*       void gem_prg( void );                                          */
  82. /*                                                                      */
  83. /*       Beispiel für die Verwendung der Funktion evnt_multi( ), sowie  */
  84. /*       diverser Funktionen der wind-Bibliothek in einem GEM-Programm. */
  85. /*                                                                      */
  86. /*       ->                      Nichts.                                */
  87. /*                                                                      */
  88. /*       <-                      Nichts.                                */
  89. /* -------------------------------------------------------------------- */
  90.  
  91. void gem_prg( void )
  92. {
  93.    int      style = 0;              /* Füllmuster für Fenster.          */
  94.    int      event,                  /* Ergebnis mit Ereignissen.        */
  95.             mx, my,                 /* Mauskoordinaten.                 */
  96.             mbutton,                /* Mausknopf.                       */
  97.             mstate,                 /* Status des Mausknopfs.           */
  98.             keycode,                /* Scancode einer Tastatureingabe.  */
  99.             mclicks;                /* Anzahl Mausklicks.               */
  100.  
  101.    vsf_color( handle, 1 );          /* Farbindex setzen.                */
  102.    vsf_interior( handle, 3 );       /* Schraffierte Muster zeichnen.    */
  103.  
  104.    if ( open_window( ) == TRUE )    /* Ein Fenster zu Beginn öffnen.    */
  105.    {
  106.       do
  107.       {
  108.          event = evnt_multi( EV_KIND,
  109.                              1, 1, 1,
  110.                              0, 0, 0, 0, 0,
  111.                              0, 0, 0, 0, 0,
  112.                              Msgbuff,
  113.                              1000, 0,  /* 1 s warten.                   */
  114.                              &mx, &my,
  115.                              &mbutton, &mstate,
  116.                              &keycode, &mclicks);
  117.  
  118.          wind_update( BEG_UPDATE ); /* Jetzt darf GEM nicht mehr        */
  119.                                     /* alleine zeichnen.                */
  120.          if ( event & MU_MESAG )    /* Auswertung der Ereignisse.       */
  121.          {
  122.             if ( Msgbuff[0] >= WM_REDRAW && WM_NEWTOP >= Msgbuff[0] )
  123.                hndl_window( );      /* Fensteraktion.                   */
  124.          }
  125.          else if ( event & MU_TIMER ) /* Nach 1 Sekunden anderen        */
  126.          {                            /* Fensterinhalt zeichnen.        */
  127.             style++;                  /* Füllmuster ändern.             */
  128.             if ( style == 13 )
  129.                style = 1;
  130.             vsf_style( handle, style );
  131.             do_redraw( W_handle, Wx, Wy, Ww, Wh );
  132.  
  133.          }
  134.          else if( event & MU_KEYBD )
  135.          {
  136.             if ( keycode == CNTRL_C ) /* Mit Control-C kann beendet     */
  137.             {                         /* werden.                        */
  138.                if ( W_handle != -1 )
  139.                   close_window( W_handle );
  140.                Done = TRUE;
  141.             }
  142.          }
  143.          wind_update( END_UPDATE );
  144.       }
  145.       while ( !Done );
  146.    }
  147. }
  148.  
  149. /* -------------------------------------------------------------------- */
  150. /*       void hndl_window( void )                     handle windows    */
  151. /*                                                                      */
  152. /*       Behandlen der Windowaktionen.                                  */
  153. /*                                                                      */
  154. /*       ->                      Nichts.                                */
  155. /*                                                                      */
  156. /*       <-                      Nichts.                                */
  157. /* -------------------------------------------------------------------- */
  158.  
  159. void hndl_window( void )
  160. {
  161.  
  162.    switch( Msgbuff[0] )
  163.    {
  164.       case WM_REDRAW:               /* Fensterinhalt neu zeichen.       */
  165.          do_redraw( Msgbuff[3], Msgbuff[4], Msgbuff[5], Msgbuff[6], Msgbuff[7] );
  166.       break;
  167.  
  168.       case WM_CLOSED:               /* Fenster wurde geschlossen.       */
  169.          close_window( Msgbuff[3] );  /* Programm beendet.                */
  170.          Done = TRUE;
  171.       break;
  172.  
  173.       case WM_MOVED:                /* Fenster wurde bewegt oder in     */
  174.       case WM_SIZED:                /* seiner Grö₧e verändert.          */
  175.          if ( Msgbuff[6] < 10 * gl_wbox )  /* Mindestgrö₧e für Fenster. */
  176.             Msgbuff[6] = 10 * gl_wbox;
  177.          if ( Msgbuff[7] < 5 * gl_hbox )
  178.             Msgbuff[7] = 5 * gl_hbox;
  179.          new_size( Msgbuff[3], Msgbuff[4], Msgbuff[5], Msgbuff[6], Msgbuff[7] );
  180.       break;
  181.  
  182.       case WM_TOPPED:               /* Fenster (wurde) aktiviert.       */
  183.       case WM_NEWTOP:
  184.          wind_set( Msgbuff[3], WF_TOP, 0, 0, 0, 0 );
  185.          wind_get( Msgbuff[3], WF_WORKXYWH, &Wx, &Wy, &Ww, &Wh );
  186.       break;
  187.  
  188.       case WM_FULLED:               /* Fenster zoomen.                  */
  189.          if (( W_fulled ^= TRUE ))
  190.             wind_get( Msgbuff[3], WF_FULLXYWH, &Msgbuff[4], &Msgbuff[5], &Msgbuff[6], &Msgbuff[7] );
  191.          else
  192.             wind_get( Msgbuff[3], WF_PREVXYWH, &Msgbuff[4], &Msgbuff[5], &Msgbuff[6], &Msgbuff[7] );
  193.          wind_get( Msgbuff[3], WF_WORKXYWH, &Wx, &Wy, &Ww, &Wh );
  194.          new_size( Msgbuff[3], Msgbuff[4], Msgbuff[5], Msgbuff[6], Msgbuff[7] );
  195.       break;
  196.    }
  197. }
  198.  
  199. /* -------------------------------------------------------------------- */
  200. /*       boolean open_window( void );                                   */
  201. /*                                                                      */
  202. /*       Öffnen eines Fensters. Bei erfolgreichem Öffnen wird TRUE zu-  */
  203. /*       rückgeliefert.                                                 */
  204. /*                                                                      */
  205. /*       ->                      Nichts.                                */
  206. /*                                                                      */
  207. /*       <-                      TRUE  falls ein Fenster geöffnet wer-  */
  208. /*                                     konnte (dann wurden auch dessen  */
  209. /*                                     globale Parameter gesetzt),      */
  210. /*                               FALSE sonst.                           */
  211. /* -------------------------------------------------------------------- */
  212.  
  213. boolean open_window( void )
  214. {
  215.    int new,
  216.        xdesk, ydesk, wdesk, hdesk;
  217.                                     /* Grö₧e Arbeitsfläche des Desktop. */
  218.    wind_get( DESK, WF_WORKXYWH, &xdesk, &ydesk, &wdesk, &hdesk );
  219.    if (( new = wind_create( W_KIND, xdesk, ydesk, wdesk, hdesk )) < 0 )
  220.    {
  221.       form_alert( 1, "[3][Kann kein Fenster öffnen.][Abbruch]" );
  222.       return ( FALSE );
  223.    }
  224.    graf_mouse( M_OFF, 0 );          /* Maus aus.                        */
  225.    wind_set( new, WF_NAME, WINDOW_NAME, 0, 0 ); /* Fenstername setzen.        */
  226.                                     /* Öffnendes Rechteck zeichnen.     */
  227.    graf_growbox( 0, 0, 0, 0, wdesk / 10, hdesk / 10, wdesk / 3, hdesk / 3 );
  228.    wind_open( new, wdesk / 10, hdesk / 10, wdesk / 3, hdesk / 3 );
  229.                                     /* Fenster öffnen.                  */
  230.                                     /* Arbeitsfläche des Fensters best. */
  231.    wind_get( new, WF_WORKXYWH, &Wx, &Wy, &Ww, &Wh );
  232.    W_handle = new;
  233.    W_fulled = FALSE;
  234.    graf_mouse( M_ON, 0 );           /* Maus an.                         */
  235.    graf_mouse( ARROW, 0 );
  236.  
  237.    return ( TRUE );                 /* ERFOLG!                          */
  238. }
  239.  
  240. /* -------------------------------------------------------------------- */
  241. /*       void do_redraw( int w_handle, int x, int y, int w, int h );    */
  242. /*                                                                      */
  243. /*       Neu zeichnen des Inhalts eines Fensters.                       */
  244. /*                                                                      */
  245. /*       -> w_handle             Handle des zu schlie₧enden Fensters.   */
  246. /*          x, y          x-,y-Koordinate des Zeichenbereichs.          */
  247. /*          w, h          Höhe und Breite des Zeichenbereichs.          */
  248. /*                                                                      */
  249. /*       <-                      Nichts.                                */
  250. /* -------------------------------------------------------------------- */
  251.  
  252. void do_redraw( int w_handle, int x, int y, int w, int h )
  253. {
  254.    GRECT t1, t2;
  255.  
  256.    t2.g_x     = pxarray[0] = x;     /* Zeichenkoordinaten setzen.       */
  257.    t2.g_y     = pxarray[1] = y;
  258.    t2.g_w     = w;
  259.    t2.g_h     = h;
  260.    pxarray[2] = x + w - 1;
  261.    pxarray[3] = y + h - 1;
  262.  
  263.    graf_mouse( M_OFF, 0 );
  264.    wind_get( w_handle, WF_FIRSTXYWH, &t1.g_x, &t1.g_y, &t1.g_w, &t1.g_h );
  265.    while ( t1.g_w && t1.g_h )
  266.    {
  267.       if ( rc_intersect( &t2, &t1 ) == TRUE )
  268.       {                             /* Nur berechnetes Rechteck         */
  269.                                     /* neu zeichen, sonst könnten       */
  270.                                     /* andere Bildschirminhalte         */
  271.                                     /* zerstört werden.                 */
  272.          clipping( t1.g_x, t1.g_y, t1.g_w, t1.g_h, TRUE );
  273.          v_bar( handle, pxarray );
  274.       }
  275.       wind_get( w_handle, WF_NEXTXYWH, &t1.g_x, &t1.g_y, &t1.g_w, &t1.g_h );
  276.    }
  277.    clipping( t1.g_x, t1.g_y, t1.g_w, t1.g_h, FALSE );
  278.  
  279.    graf_mouse( M_ON, 0 );
  280. }
  281.  
  282. /* -------------------------------------------------------------------- */
  283. /*       void new_size( int w_handle, int x, int y, int w, int h );     */
  284. /*                                                                      */
  285. /*       Fenster an neue Grö₧e anpassen.                                */
  286. /*                                                                      */
  287. /*       -> w_handle             Fensterhandle.                         */
  288. /*          x, y, w, h           Au₧enkoordinaten des Fensters.         */
  289. /*                                                                      */
  290. /*       <-                      Die globalen Variablen, die die Koor-  */
  291. /*                               dinaten der Fensterarbeitsfläche ent-  */
  292. /*                               halten, werden updated.                */
  293. /* -------------------------------------------------------------------- */
  294.  
  295. void new_size( int w_handle, int x, int y, int w, int h )
  296. {
  297.    wind_set( w_handle, WF_CURRXYWH, x, y, w, h );
  298.    wind_get( w_handle, WF_WORKXYWH, &Wx, &Wy, &Ww, &Wh );
  299. }
  300.  
  301. /* -------------------------------------------------------------------- */
  302. /*       void close_window( int w_handle );                             */
  303. /*                                                                      */
  304. /*       Schlie₧en eines Fensters.                                      */
  305. /*                                                                      */
  306. /*       -> w_handle             Handle des zu schlie₧enden Fensters.   */
  307. /*                                                                      */
  308. /*       <-                      Nichts.                                */
  309. /* -------------------------------------------------------------------- */
  310.  
  311. void close_window( int w_handle )
  312. {
  313.    int x, y, w, h;
  314.  
  315.    wind_get( w_handle, WF_CURRXYWH, &x, &y, &w, &h );
  316.    graf_shrinkbox( 0, 0, 0, 0, x, y, w, h );
  317.    wind_close( w_handle );
  318.    wind_delete( w_handle );
  319. }
  320.  
  321. /* -------------------------------------------------------------------- */
  322. /*       boolean rc_intersect( GRECT *r1, GRECT *r2 );                  */
  323. /*                                                                      */
  324. /*       Berechnung der Schnittfläche zweier Rechtecke.                 */
  325. /*                                                                      */
  326. /*       -> r1, r2               Pointer auf Rechteckstruktur.          */
  327. /*                                                                      */
  328. /*       <-                      TRUE  falls sich die Rechtecke         */
  329. /*                                     schneiden,                       */
  330. /*                               FALSE sonst.                           */
  331. /* -------------------------------------------------------------------- */
  332.  
  333. boolean rc_intersect( GRECT *r1, GRECT *r2 )
  334. {
  335.    int x, y, w, h;
  336.  
  337.    x = max( r2->g_x, r1->g_x );
  338.    y = max( r2->g_y, r1->g_y );
  339.    w = min( r2->g_x + r2->g_w, r1->g_x + r1->g_w );
  340.    h = min( r2->g_y + r2->g_h, r1->g_y + r1->g_h );
  341.  
  342.    r2->g_x = x;
  343.    r2->g_y = y;
  344.    r2->g_w = w - x;
  345.    r2->g_h = h - y;
  346.  
  347.    return ( (boolean) ((w > x) && (h > y) ) );
  348. }
  349.  
  350. /* -------------------------------------------------------------------- */
  351. /*       void clipping( int x, int y, int w, int h, int mode );         */
  352. /*                                                                      */
  353. /*       Last but not least: (Re-)Set Clipping Rectangle ...            */
  354. /*                                                                      */
  355. /*       -> x                    x-Koordinate der Clipp' Begrenzung.    */
  356. /*          y                    y-Koordinate       - " -          .    */
  357. /*          w                    Breite des begrenzten Rechtecks.       */
  358. /*          h                    Höhe         - " -             .       */
  359. /*          mode                 TRUE  - clipping on,                   */
  360. /*                               FALSE - clipping off.                  */
  361. /*                                                                      */
  362. /*       <-                      Nichts.                                */
  363. /* -------------------------------------------------------------------- */
  364.  
  365. void clipping( int x, int y, int w, int h, int mode )
  366. {
  367.    pxarray[0] = x;
  368.    pxarray[1] = y;
  369.    pxarray[2] = x + w - 1;
  370.    pxarray[3] = y + h - 1;
  371.  
  372.    vs_clip( handle, mode, pxarray );
  373. }
  374.  
  375. /* -------------------------------------------------------------------- */
  376. /*       Ende der Beispielprogramms für EVNT_MULTI( ).                  */
  377. /* -------------------------------------------------------------------- */
  378.