Category

Development Platform
Home > SourceCode/Document > Mathimatics-Numerical algorithms > View Code
_os2.c
Package: leda.tar.gz　[view]
Upload User: gzelex
Upload Date: 2007-01-07
Package Size: 707k
Code Size: 27k
Category:

Mathimatics-Numerical algorithms

Development Platform:

MultiPlatform

_os2.c：Code Content
  1. /*******************************************************************************
  2. +
  3. +  LEDA-R  3.2.2
  4. +
  5. +  _os2.c
  6. +
  7. +  Copyright (c) 1995  by  Max-Planck-Institut fuer Informatik
  8. +  Im Stadtwald, 66123 Saarbruecken, Germany     
  9. +  All rights reserved.
  10. + 
  11. *******************************************************************************/
  14. //-----------------------------------------------------------------------------
  15. // basic graphics routines for OS/2  (PM)
  16. //
  17. // s.n. (May & April 1995)
  18. //-----------------------------------------------------------------------------
  20. #include <LEDA/impl/x_basic.h>
  22. #include <string.h>
  23. #include <stdio.h>
  24. #include <stdlib.h>
  25. #include <math.h>
  27. #define INCL_WIN
  28. #define INCL_GPI
  29. #include <os2.h>
  31. #define LEDA_ID         1
  32. #define TEXT_FONT_ID    1
  33. #define BOLD_FONT_ID    2
  35. #define IDM_FILE        1
  36. #define IDM_EXIT        2
  37. #define IDM_FONT        3
  40. typedef void (*redraw_fct)();
  42. struct OS2_Window {
  43. HWND hwndFrame;
  44. HWND hwnd;
  45. HPS  hps_mem;
  46. HPS  hps_scr;
  47. int  bg_col;
  48. int  xmax;
  49. int  ymax;
  50. int  refresh;
  51. int  iconized;
  52. redraw_fct redraw;
  53. };
  56. #define YCOORD(w,ypix)  (wlist[w].ymax - ypix)
  59. // global data
  61. static HAB hab;
  62. static HMQ hmq;
  65. static FATTRS TextFattrs;
  66. static FATTRS BoldFattrs;
  67. static FATTRS MesgFattrs;
  69. static FONTMETRICS FontMetrics;
  71. struct event {
  72. int win;
  73. int kind;
  74. int val;
  75. int x;
  76. int y;
  77. unsigned long t;
  78. };
  80. static event cur_event;
  82. #define  MAX_WIN 32
  84. static OS2_Window wlist[MAX_WIN+1];
  85. static Window wcount = 0;
  87. static LONG   rgb_table[32];
  89. static ULONG* color_table;
  90. static ULONG  color_table_src[16];
  91. static ULONG  color_table_xor[16];
  93. static long mode_table[4];
  94. static long lstyle_table[4];
  96. static int GCOLOR;
  97. static int MODE;
  98. static int LSTYLE;
  99. static int LWIDTH;
  102. static int shift_key_down = 0;
  103. static int ctrl_key_down = 0;
  104. static int alt_key_down = 0;
  107. /* display */
  109. static void message(char* s)
  110. { WinAlarm( HWND_DESKTOP, WA_ERROR );
  111.   WinMessageBox(HWND_DESKTOP, HWND_DESKTOP, (PSZ) s, 
  112.                  (PSZ)"LEDA WINDOW MESSAGE", 256, MB_OK);
  113. } 
  115. static void message(char* s, int i)
  116. { WinAlarm( HWND_DESKTOP, WA_ERROR );
  117.   char msg[256];
  118.   sprintf(msg,s,i);
  119.   WinMessageBox(HWND_DESKTOP, HWND_DESKTOP, (PSZ) msg, 
  120.                 (PSZ)"LEDA WINDOW MESSAGE", 256, MB_OK);
  121. } 
  123. static void message(char* s, int i, int j)
  124. { WinAlarm( HWND_DESKTOP, WA_ERROR );
  125.   char msg[256];
  126.   sprintf(msg,s,i,j);
  127.   WinMessageBox(HWND_DESKTOP, HWND_DESKTOP, (PSZ) msg, 
  128.                 (PSZ)"LEDA WINDOW MESSAGE", 256, MB_OK);
  129. } 
  132. static void init_palette(HWND hwnd,HPS hps)
  133. {
  135. #define LONGFromRGB(R,G,B) (LONG)(((LONG)R<<16)+((LONG)G<<8)+(LONG)B)
  137.              // wi bl  re  gr  bl  ye  vi  or  cy  br  pi  gr  bl  g1  g2  g3
  138. unsigned char 
  139.       R[16] = {255, 0,255, 32,  0,255,160,255,  0,192,255,  0,  0,212,180,116};
  140. unsigned char 
  141.       G[16] = {255, 0,  0,255,  0,255,  0,160,192,112,  0,160,128,212,180,116};
  142. unsigned char 
  143.       B[16] = {255, 0,  0,  0,213,  0,208,  0,192, 56,255,100,255,212,180,116};
  145.   for (int i=0; i < 16; i++) 
  146.   { rgb_table[2*i] = i;
  147.     rgb_table[2*i+1] = LONGFromRGB(R[i],G[i],B[i]);
  148.    }
  150.   if (!GpiCreateLogColorTable(hps,LCOL_PURECOLOR,LCOLF_INDRGB,0,32,rgb_table))
  151.      message("cannot create color table");
  153. /*
  154.    ULONG   cclr;
  155.    int i;
  156.    for (i=0; i < 16; i++) 
  157.       rgb_table[i] = LONGFromRGB(R[i],G[i],B[i]);
  159.    HPAL hPal = GpiCreatePalette( hab,
  160.              (ULONG) LCOL_PURECOLOR,
  161.          (ULONG) LCOLF_CONSECRGB,
  162.          32,
  163.          rgb_table );
  165.    if( hPal == NULLHANDLE || hPal == GPI_ERROR)
  166.       message("GpiCreatePalette Error");
  167.    else 
  168.       if (GpiSelectPalette(hps, hPal ) == PAL_ERROR)
  169.         message("GpiSelectPalette Error");
  170.       else 
  171.         if (WinRealizePalette(hwnd,hps,&cclr) == PAL_ERROR)
  172.           message("WinRealizePalette Error");
  173. */
  175. }
  178. void open_display(void)
  179. { hab = WinInitialize (0);
  180.   hmq = WinCreateMsgQueue (hab, 0);
  181.   int i;
  182.   for(i=0; i < 16; i++) color_table_src[i] = color_table_xor[i] = i;
  184.   color_table_xor[white] = black;
  185.   color_table_xor[black] = white;
  186.   color_table_xor[red]   = cyan;
  187.   color_table_xor[green] = violet;
  188.   color_table_xor[blue]  = yellow;
  189.   color_table_xor[yellow]= blue;
  190.   color_table_xor[violet]= green;
  191.   color_table_xor[orange]= blue2;
  192.   color_table_xor[blue2] = orange;
  193.   color_table_xor[pink]  = green;
  195.   color_table = color_table_src;
  197.   GCOLOR = black;
  199.   mode_table[src_mode] = FM_OVERPAINT;
  200.   mode_table[or_mode]  = FM_OR;
  201.   mode_table[xor_mode] = FM_XOR;
  202.   mode_table[and_mode] = FM_AND;
  203.   MODE = src_mode;
  205.   lstyle_table[dotted] = LINETYPE_DOT;
  206.   lstyle_table[dashed] = LINETYPE_LONGDASH;
  207.   lstyle_table[solid]  = LINETYPE_SOLID;
  208.   LSTYLE = solid;
  209.   LWIDTH = 1;
  211.   HPS hps = WinGetPS(HWND_DESKTOP);
  213.   TextFattrs.usRecordLength  = sizeof(FATTRS);
  214.   TextFattrs.fsSelection     = 0;
  215.   TextFattrs.lMatch          = 0L;
  216.   TextFattrs.idRegistry      = 0;
  217.   TextFattrs.lMaxBaselineExt = 14L;
  218.   TextFattrs.lAveCharWidth   = 6L;
  219.   TextFattrs.fsType          = 0;
  220.   strcpy(TextFattrs.szFacename,"System VIO");
  222.   GpiCreateLogFont(hps,(PSTR8)NULL,TEXT_FONT_ID,&TextFattrs);
  223.   GpiSetCharSet(hps,TEXT_FONT_ID);
  224.   GpiQueryFontMetrics(hps,sizeof(FONTMETRICS),(PFONTMETRICS)&FontMetrics);
  226.   BoldFattrs.usRecordLength  = sizeof(FATTRS);
  227.   BoldFattrs.fsSelection     = 0;
  228.   BoldFattrs.lMatch          = 0L;
  229.   BoldFattrs.idRegistry      = 0;
  230.   BoldFattrs.lMaxBaselineExt = 14L;
  231.   BoldFattrs.lAveCharWidth   = 8L;
  232.   BoldFattrs.fsType          = 0;
  233.   strcpy(BoldFattrs.szFacename,"System VIO");
  235.   WinReleasePS(hps);
  236. }
  239. void close_display(void)
  240. { WinDestroyMsgQueue (hmq);
  241.   WinTerminate (hab);
  242.  }
  245. void flush_display(void)
  246. { //QMSG qmsg;
  247.   //if (WinPeekMsg(hab,&qmsg,0L,0,0,PM_REMOVE)) WinDispatchMsg (hab, &qmsg);
  248.  }
  251. static void refresh_win(Window w, int x0=0, int y0=0, int x1=0, int y1=0)
  252. { 
  253.   if (wlist[w].refresh) 
  254.   { if (x0 == 0 && x1 == 0) x1 = wlist[w].xmax;
  255.     if (y0 == 0 && y1 == 0) y1 = wlist[w].ymax;
  256.     if (x0 > x1) { int tmp = x0; x0 = x1; x1 = tmp; }
  257.     if (y0 > y1) { int tmp = y0; y0 = y1; y1 = tmp; }
  258.     int d = LWIDTH;
  259.     POINTL aptl[4];
  260.     aptl[0].x = x0-d;
  261.     aptl[0].y = y0-d;
  262.     aptl[1].x = x1+d;
  263.     aptl[1].y = y1+d;
  264.     aptl[2].x = x0-d;
  265.     aptl[2].y = y0-d;
  266.     aptl[3].x = x1+d;
  267.     aptl[3].y = y1+d;
  268.     GpiBitBlt(wlist[w].hps_scr,wlist[w].hps_mem,4,aptl,ROP_SRCCOPY,BBO_IGNORE);
  269.   }
  270. }
  274. void start_batch(Window w) {  wlist[w].refresh = 0; }
  276. void end_batch(Window w) 
  277. {  wlist[w].refresh = 1; 
  278.    refresh_win(w);
  279. }
  280.    
  282. int  display_width(void)
  283. { return WinQuerySysValue(HWND_DESKTOP, SV_CXSCREEN); }
  285. int  display_height(void)
  286. { return WinQuerySysValue(HWND_DESKTOP, SV_CYSCREEN); }
  288. /*
  289. int  mouse_buttons(void)
  290. { return WinQuerySysValue(HWND_DESKTOP, SV_CMOUSEBUTTONS); }
  291. */
  294. int  display_depth(void) { return 16; }
  297. /* windows */
  299. static void font_dialog(HWND hwnd)
  300. { 
  301.   FONTDLG FontDlg;
  302.   char szFamilyname[FACESIZE];
  303.   szFamilyname[0] = 0;
  304.   memset((PCH)&FontDlg,0,sizeof(FONTDLG));
  305.   FontDlg.cbSize         = sizeof(FONTDLG);
  306.   FontDlg.hpsScreen      = WinGetPS(hwnd);
  307.   FontDlg.pszFamilyname  = (PSZ)szFamilyname;
  308.   FontDlg.usFamilyBufLen = FACESIZE;
  309.   FontDlg.pszPreview     = (PSZ)"Sample Text";
  310.   FontDlg.fl             = FNTS_RESETBUTTON | FNTS_CENTER |
  311.                            FNTS_INITFROMFATTRS | FNTS_BITMAPONLY;
  312.   FontDlg.flStyle        = FATTR_SEL_ITALIC;
  313.   FontDlg.clrFore        = CLR_BLACK;
  314.   FontDlg.clrBack        = CLR_PALEGRAY;
  315.   FontDlg.fAttrs         = TextFattrs;
  316.   FontDlg.pszTitle       = (PSZ)"FONT SELECTION";
  317.   
  318.   WinFontDlg(HWND_DESKTOP,hwnd,(PFONTDLG)&FontDlg);
  319.   if (FontDlg.lReturn == DID_OK)
  320.   {  char msg[256];
  321.      TextFattrs = FontDlg.fAttrs;
  322.      sprintf(msg,"Facename = %s  MaxBaseLinExt = %d CharWidth = %d", 
  323.              TextFattrs.szFacename,
  324.              TextFattrs.lMaxBaselineExt,
  325.              TextFattrs.lAveCharWidth);
  326.      message(msg);
  327.      GpiCreateLogFont(FontDlg.hpsScreen,(PSTR8)NULL,TEXT_FONT_ID,&TextFattrs);
  328.      GpiSetCharSet(FontDlg.hpsScreen,TEXT_FONT_ID);
  329.      GpiQueryFontMetrics(FontDlg.hpsScreen,sizeof(FONTMETRICS),(PFONTMETRICS)&FontMetrics);
  330.    }
  332.   WinReleasePS(FontDlg.hpsScreen);
  333. }
  336. static MRESULT EXPENTRY ClientWndProc (HWND hwnd, ULONG msg,
  337.                                        MPARAM mp1, MPARAM mp2)
  338. {
  339.   for(int w = 1; w<=wcount; w++)
  340.      if (wlist[w].hwnd == hwnd) break;
  342.   cur_event.win = w;
  344.   switch (msg) {
  346.   case WM_SIZE: 
  347.         { RECTL rcl;
  348.           WinQueryWindowRect(hwnd, &rcl);
  349.           wlist[w].xmax = rcl.xRight;
  350.           wlist[w].ymax = rcl.yTop;
  351.           if (rcl.xRight != 0  && !wlist[w].iconized) 
  352.           { cur_event.kind = configure_event;
  353.             cur_event.x = rcl.xRight;
  354.             cur_event.y = rcl.yTop;
  355.             if (wlist[w].redraw) clear_window(w);
  356.            }
  357.            wlist[w].iconized = (rcl.xRight == 0);
  359. /*
  360.           // have to adjust bitmap (how is it done ?)
  361.           HPS hps = wlist[w].hps_scr;
  362.           BITMAPINFOHEADER2 bmp = {16, 0, 0, 4, 1}; 
  363.           bmp.cx = cur_event.x;
  364.           bmp.cy = cur_event.y;
  365.           HBITMAP hbm = GpiCreateBitmap(hps, &bmp, 0L, NULL, NULL);
  366.           if (hbm == 0) message("cannot create bitmap");
  367.           HBITMAP hbm_prev = GpiSetBitmap(hps, hbm);
  368.           GpiDeleteBitmap(hbm_prev);
  369. */
  370.           break;
  371.          }
  373.   case WM_PAINT: 
  374.         { HPS hps = WinBeginPaint(hwnd,wlist[w].hps_scr,0); 
  375.           refresh_win(w);
  376.           WinEndPaint(hps);
  377.           return ((MRESULT)0);
  378.          }
  380.   case WM_QUIT: 
  381.   case WM_CLOSE: 
  382.          cur_event.kind = destroy_event;
  383.          close_display();
  384.          exit(0);
  386.   case WM_BUTTON1DBLCLK: 
  387.   case WM_BUTTON1DOWN: 
  388.          cur_event.kind = button_press_event;
  389.          cur_event.val = 1;
  390.          cur_event.x = SHORT1FROMMP(mp1);
  391.          cur_event.y = YCOORD(w,SHORT2FROMMP(mp1));
  392.          if (shift_key_down) cur_event.val = -cur_event.val;
  393.          if (ctrl_key_down)  cur_event.val += 3;
  394.          break;
  396.   case WM_BUTTON2DBLCLK: 
  397.   case WM_BUTTON2DOWN: 
  398.          cur_event.kind = button_press_event;
  399.          cur_event.val = 3;
  400.          cur_event.x = SHORT1FROMMP(mp1);
  401.          cur_event.y = YCOORD(w,SHORT2FROMMP(mp1));
  402.          if (shift_key_down) cur_event.val = -cur_event.val;
  403.          if (ctrl_key_down)  cur_event.val += 3;
  404.          break;
  406. /*
  407.   case WM_BUTTON3DOWN: 
  408. */
  410.   case WM_BUTTON1UP: 
  411.          cur_event.kind = button_release_event;
  412.          cur_event.val = 1;
  413.          cur_event.x = SHORT1FROMMP(mp1);
  414.          cur_event.y = YCOORD(w,SHORT2FROMMP(mp1));
  415.          if (shift_key_down) cur_event.val = -cur_event.val;
  416.          if (ctrl_key_down)  cur_event.val += 3;
  417.          break;
  419.   case WM_BUTTON2UP: 
  420.          cur_event.kind = button_release_event;
  421.          cur_event.val = 3;
  422.          cur_event.x = SHORT1FROMMP(mp1);
  423.          cur_event.y = YCOORD(w,SHORT2FROMMP(mp1));
  424.          if (shift_key_down) cur_event.val = -cur_event.val;
  425.          if (ctrl_key_down)  cur_event.val += 3;
  426.          break;
  428. /*
  429.   case WM_BUTTON3UP: 
  430. */
  432.   case WM_MOUSEMOVE: 
  433.          cur_event.kind = motion_event;
  434.          cur_event.x = SHORT1FROMMP(mp1);
  435.          cur_event.y = YCOORD(w,SHORT2FROMMP(mp1));
  436.          break;
  438.   case WM_CHAR: 
  439.         { USHORT fsKeyFlags = (USHORT) SHORT1FROMMP(mp1);
  440.           if (fsKeyFlags & KC_KEYUP) 
  441.              { //key up
  442.                shift_key_down = 0;
  443.                ctrl_key_down = 0;
  444.                alt_key_down = 0;
  445.               }
  446.           else // key down
  447.              { if (fsKeyFlags & KC_SHIFT) shift_key_down = 1;
  448.                if (fsKeyFlags & KC_CTRL)  ctrl_key_down = 1;
  449.                if (fsKeyFlags & KC_ALT)   alt_key_down = 1;
  450.                if (fsKeyFlags & KC_CHAR )
  451.                { cur_event.val = SHORT1FROMMP(mp2);
  452.                  cur_event.kind = key_press_event;
  453.                 }
  454.               }
  455.            break;
  456.          }
  459.     case WM_ERASEBACKGROUND:
  460.           return (MRFROMLONG(1L));
  461.      
  463.     case WM_COMMAND:
  464.       switch (SHORT1FROMMP (mp1))
  465.       { 
  466.         case IDM_FONT:
  467.            font_dialog(hwnd);
  468.            return ((MRESULT)0);
  470.         case IDM_EXIT:
  471.            WinSendMsg (hwnd, WM_CLOSE, NULL, NULL);
  472.            return ((MRESULT)0);
  473.         }
  475.     }
  477.    return WinDefWindowProc (hwnd, msg, mp1, mp2);
  480. }
  484. Window open_window(int x,int y,int width,int height,int bg_col, 
  485.                    const char* header, const char* label)
  486. {
  487.   ULONG flFrameFlags;
  488.   HWND hwndFrame;
  489.   HWND hwnd;
  491.   if (wcount == MAX_WIN) 
  492.       message("Maximal number of windows (%d) exceeded",MAX_WIN);
  494.   WinRegisterClass (hab,(PSZ)"LEDA-WINDOW", ClientWndProc, CS_SAVEBITS, 0L);
  496.   //WinRegisterClass (hab,(PSZ)"LEDA-WINDOW", ClientWndProc, 0, 0L);
  498.   flFrameFlags = (FCF_TITLEBAR      | 
  499.                   FCF_SYSMENU       |
  500.                   FCF_SIZEBORDER    | 
  501.                   FCF_MINMAX        |
  502.                   FCF_ACCELTABLE    |
  503. //                FCF_MENU          | 
  504. //                FCF_SHELLPOSITION | 
  505.                   FCF_ICON          | 
  506.                   FCF_TASKLIST);
  508.   FRAMECDATA FrameData;
  509.   FrameData.cb = sizeof(FRAMECDATA);
  510.   FrameData.flCreateFlags = flFrameFlags;
  511.   FrameData.hmodResources = 0;
  512.   FrameData.idResources = LEDA_ID;
  514.   hwndFrame = WinCreateWindow (HWND_DESKTOP, WC_FRAME, (PSZ)header,
  515.                                0L, 0, 0, 0, 0, 0, HWND_TOP, LEDA_ID,
  516.                                (PVOID)(PFRAMECDATA)&FrameData, NULL);
  519.   hwnd = WinCreateWindow(hwndFrame,(PSZ)"LEDA-WINDOW", NULL, 
  520.                                0L, 0, 0, 0, 0, hwndFrame, HWND_TOP, FID_CLIENT,
  521.                                NULL, NULL);
  523.   WinShowWindow(hwndFrame,TRUE);
  525.   //height += WinQuerySysValue(HWND_DESKTOP, SV_CYMENU); 
  527.   height += WinQuerySysValue(HWND_DESKTOP, SV_CYTITLEBAR); 
  528.   height += WinQuerySysValue(HWND_DESKTOP, SV_CYSIZEBORDER);
  529.   width  += 2*WinQuerySysValue(HWND_DESKTOP, SV_CXSIZEBORDER);
  531.   y = WinQuerySysValue(HWND_DESKTOP, SV_CYSCREEN) - height - y; 
  533.   WinSetWindowPos(hwndFrame, 0L, x, y, width, height, SWP_MOVE | SWP_SIZE );
  536.   // create screen presentation space
  538.   SIZEL sizel = {0,0};
  540.   HDC hdc = WinOpenWindowDC(hwnd);
  541.   HPS hps_scr = GpiCreatePS(hab,hdc,&sizel,PU_PELS | GPIF_DEFAULT | 
  542.                                               GPIT_NORMAL | GPIA_ASSOC);
  544.   if (hps_scr == 0) message("cannot create client hps");
  546.  
  547.  // create memory device context and presentation space, 
  549.   DEVOPENSTRUC dop = {NULL,(PSZ)"DISPLAY",NULL,NULL,NULL,NULL,NULL,NULL,NULL};
  551.   HDC hdc_mem = DevOpenDC(hab, OD_MEMORY, (PSZ)"*", 5L,(PDEVOPENDATA)&dop, 
  552.                                                                 NULLHANDLE);
  554.   HPS hps_mem = GpiCreatePS(hab,hdc_mem,&sizel, GPIA_ASSOC | GPIT_NORMAL | PU_PELS);
  555.   if (hps_mem == 0) message("cannot create memory hps");
  557.   BITMAPINFOHEADER2 bmp = {16, 0, 0, 4, 1}; 
  558.   bmp.cx =  width;
  559.   bmp.cy =  height;
  560.   HBITMAP hbm = GpiCreateBitmap(hps_mem, &bmp, 0L, NULL, NULL);
  561.   if (hbm == 0) message("cannot create bitmap");
  562.   GpiSetBitmap(hps_mem, hbm);
  563.  
  565.   // create and set font
  567.   if (GpiCreateLogFont(hps_mem,(PSTR8)NULL,TEXT_FONT_ID,&TextFattrs) == FALSE)
  568.      message("cannot create font");
  570.   GpiSetCharSet(hps_mem,TEXT_FONT_ID);
  571.   GpiQueryFontMetrics(hps_mem,sizeof(FONTMETRICS),(PFONTMETRICS)&FontMetrics);
  574.   QMSG qmsg;
  575.   while (WinPeekMsg(hab,&qmsg,0L,0,0,PM_REMOVE)) WinDispatchMsg (hab, &qmsg);
  577.   // initialize color table
  579.   init_palette(hwnd,hps_mem);
  582.   // set default values for drawing parameters
  584.   GpiSetMix(hps_mem,mode_table[MODE]);
  585.   GpiSetColor(hps_mem,color_table[GCOLOR]);
  586.   GpiSetBackColor(hps_mem,color_table[bg_col]);
  587.   GpiSetLineType(hps_mem,lstyle_table[LSTYLE]);
  590.   // get window dimensions
  592.   SWP swp;
  593.   WinQueryWindowPos(hwnd, &swp);
  595.   wcount++;
  596.   wlist[wcount].hwndFrame = hwndFrame;
  597.   wlist[wcount].hwnd = hwnd;
  598.   wlist[wcount].hps_mem = hps_mem;
  599.   wlist[wcount].hps_scr = hps_scr;
  600.   wlist[wcount].bg_col = bg_col;
  601.   wlist[wcount].refresh = 1;
  602.   wlist[wcount].iconized = 0;
  603.   wlist[wcount].redraw = 0;
  604.   wlist[wcount].xmax = swp.cx-1;
  605.   wlist[wcount].ymax = swp.cy-1;
  607.   WinSetActiveWindow(HWND_DESKTOP,hwndFrame);
  609.   clear_window(wcount);
  610.   return wcount;
  611. }
  616. void close_window(Window win) 
  617. { GpiAssociate(wlist[win].hps_mem, NULLHANDLE); 
  618.   GpiDestroyPS(wlist[win].hps_mem); 
  619.   GpiAssociate(wlist[win].hps_scr, NULLHANDLE); 
  620.   GpiDestroyPS(wlist[win].hps_scr); 
  621.   WinDestroyWindow(wlist[win].hwndFrame); 
  622.  }
  624. void set_header(Window win, const char *s)
  625. { WinSetWindowText(wlist[win].hwndFrame, (PSZ)s);
  626.   WinInvalidateRect(WinWindowFromID(wlist[win].hwndFrame, FID_TITLEBAR),
  627.                                                      (PRECTL)NULL, FALSE);
  628.  }
  631. void set_redraw(Window w, void (*f)()) 
  632. { wlist[w].redraw = f; }
  635. int window_width(Window win)
  636. { SWP swp;
  637.   WinQueryWindowPos(wlist[win].hwnd, &swp);
  638.   return swp.cx;
  639.  }
  641. int window_height(Window win)
  642. { SWP swp;
  643.   WinQueryWindowPos(wlist[win].hwnd, &swp);
  644.   return swp.cy;
  645.  }
  648. void window_position(Window win, int* x, int* y)
  649. { SWP swp;
  650.   WinQueryWindowPos(wlist[win].hwnd, &swp);
  651.   *x = swp.x;
  652.   *y = swp.y;
  653.  }
  656. void clear_window(Window win)
  657. { // dispatch all pending messages first
  658.   QMSG qmsg;
  659.   while (WinPeekMsg(hab,&qmsg,0L,0,0,PM_REMOVE)) WinDispatchMsg (hab, &qmsg);
  660.   RECTL rcl;
  661.   WinQueryWindowRect(wlist[win].hwnd, &rcl);
  662.   int save_mode = set_mode(src_mode);
  663.   WinFillRect(wlist[win].hps_mem,&rcl,color_table[wlist[win].bg_col]);
  664.   set_mode(save_mode);
  665.   refresh_win(win);
  666. }
  671. /* drawing */
  673. void line(Window win, int x1, int y1, int x2, int y2)
  674. { POINTL pos;
  675.   HPS hps = wlist[win].hps_mem;
  676.   y1 = YCOORD(win,y1);
  677.   y2 = YCOORD(win,y2);
  678.   GpiBeginPath(hps,1L);
  679.   pos.x = x1;
  680.   pos.y = y1;
  681.   GpiMove(hps,&pos);
  682.   pos.x = x2;
  683.   pos.y = y2;
  684.   GpiLine(hps,&pos);
  685.   GpiEndPath(hps);
  686.   GpiStrokePath(hps,1L,0L);
  687.   refresh_win(win,x1,y1,x2,y2);
  688.  }
  690. void rectangle(Window win, int x1, int y1, int x2, int y2)
  691. { POINTL pos;
  692.   HPS hps = wlist[win].hps_mem;
  693.   y1 = YCOORD(win,y1);
  694.   y2 = YCOORD(win,y2);
  695.   pos.x = x1;
  696.   pos.y = y1;
  697.   GpiMove(hps,&pos);
  698.   pos.x = x2;
  699.   pos.y = y2;
  700.   GpiBox(hps,DRO_OUTLINE,&pos,0,0);
  701.   refresh_win(win,x1,y1,x2,y2);
  702.  }
  704. void box(Window win, int x1, int y1, int x2, int y2)
  705. { POINTL pos;
  706.   HPS hps = wlist[win].hps_mem;
  707.   y1 = YCOORD(win,y1);
  708.   y2 = YCOORD(win,y2);
  709.   pos.x = x1;
  710.   pos.y = y1;
  711.   GpiMove(hps,&pos);
  712.   pos.x = x2;
  713.   pos.y = y2;
  714.   GpiBox(hps,DRO_OUTLINEFILL,&pos,0,0);
  715.   refresh_win(win,x1,y1,x2,y2);
  716.  }
  718. void circle(Window win, int x, int y, int r)
  719. { HPS hps = wlist[win].hps_mem;
  720.   ARCPARAMS  arcparams; 
  721.   POINTL     center;
  722.   y = YCOORD(win,y);
  723.   arcparams.lP = r;
  724.   arcparams.lQ = r;
  725.   arcparams.lR = 0;
  726.   arcparams.lS = 0;
  727.   GpiSetArcParams(hps, (PARCPARAMS)&arcparams);
  728.   center.x = x;
  729.   center.y = y;
  730.   GpiBeginPath(hps,1L);
  731.   GpiMove (hps,&center);
  732.   GpiFullArc(hps,DRO_OUTLINE,MAKEFIXED(1,0));
  733.   GpiEndPath(hps);
  734.   GpiStrokePath(hps,1L,0L);
  735.   int d= int(0.7 * r + 1);
  736.   refresh_win(win,x-r,y-d,x-d,y+d);
  737.   refresh_win(win,x+d,y-d,x+r,y+d);
  738.   refresh_win(win,x-d,y-r,x+d,y-d);
  739.   refresh_win(win,x-d,y+d,x+d,y+r);
  740. }
  743. void fill_circle(Window win, int x, int y, int r)
  744. { HPS hps = wlist[win].hps_mem;
  745.   ARCPARAMS  arcparams; 
  746.   POINTL     center;
  747.   y = YCOORD(win,y);
  748.   arcparams.lP = r;
  749.   arcparams.lQ = r;
  750.   arcparams.lR = 0;
  751.   arcparams.lS = 0;
  752.   GpiSetArcParams(hps, (PARCPARAMS)&arcparams);
  753.   center.x = x;
  754.   center.y = y;
  755.   GpiMove (hps,&center);
  756.   GpiFullArc(hps,DRO_OUTLINEFILL,MAKEFIXED(1,0));
  757.   refresh_win(win,x-r,y-r,x+r,y+r);
  758. }
  761. void pixel(Window win, int x, int y)
  762. { line(win,x,y,x,y); }
  764. void pixels(Window win, int n, int* x, int* y)
  765. { int save = wlist[win].refresh;
  766.   wlist[win].refresh = 0;
  767.   while (n--) pixel(win,x[n],y[n]);
  768.   wlist[win].refresh = 1;
  769.   refresh_win(win);
  770. }
  772. void point(Window win, int x, int y)
  773. { HPS hps = wlist[win].hps_mem;
  774.   y = YCOORD(win,y);
  775.   POINTL pos;
  776.   pos.x = x-2;
  777.   pos.y = y-2;
  778.   GpiMove(hps,&pos);
  779.   pos.x = x+2;
  780.   pos.y = y+2;
  781.   GpiLine(hps,&pos);
  782.   pos.x = x-2;
  783.   pos.y = y+2;
  784.   GpiMove(hps,&pos);
  785.   pos.x = x-1;
  786.   pos.y = y+1;
  787.   GpiLine(hps,&pos);
  788.   pos.x = x+1;
  789.   pos.y = y-1;
  790.   GpiMove(hps,&pos);
  791.   pos.x = x+2;
  792.   pos.y = y-2;
  793.   GpiLine(hps,&pos);
  794.   refresh_win(win,x-2,y-2,x+2,y+2);
  795.  }
  798. void arc(Window win,int mx,int my,int r1,int r2,double start,double angle)
  799. { HPS hps = wlist[win].hps_mem;
  800.   POINTL p[3];
  801.   p[0].x = mx + int(r1*cos(start));
  802.   p[0].y = YCOORD(win,my + int(r1*sin(start)));
  803.   p[1].x = mx + int(r1*cos(start+angle/2));
  804.   p[1].y = YCOORD(win,my + int(r1*sin(start+angle/2)));
  805.   p[2].x = mx + int(r1*cos(start+angle));
  806.   p[2].y = YCOORD(win,my + int(r1*sin(start+angle)));
  807.   GpiBeginPath(hps,1L);
  808.   GpiMove(hps,p);
  809.   GpiPointArc(hps,p+1);
  810.   GpiEndPath(hps);
  811.   GpiStrokePath(hps,1L,0L);
  812.   refresh_win(win,mx-r1,YCOORD(win,my-r2),mx+r1,YCOORD(win,my+r2));
  813. }
  816. void fill_arc(Window win,int x0,int y0,int r1,int r2,double start,double angle)
  817. {}
  820. void ellipse(Window win, int x, int y, int r1, int r2)
  821. { HPS hps = wlist[win].hps_mem;
  822.   ARCPARAMS  arcparams; 
  823.   POINTL     center;
  824.   y = YCOORD(win,y);
  825.   arcparams.lP = r1;
  826.   arcparams.lQ = r2;
  827.   arcparams.lR = 0;
  828.   arcparams.lS = 0;
  829.   GpiSetArcParams(hps, (PARCPARAMS)&arcparams);
  830.   center.x = x;
  831.   center.y = y;
  832.   GpiMove (hps,&center);
  833.   GpiFullArc(hps,DRO_OUTLINE,MAKEFIXED(1,0));
  834.   refresh_win(win,x-r1,y-r2,x+r1,y+r2);
  835. }
  838. void fill_ellipse(Window win, int x, int y, int r1, int r2)
  839. { HPS hps = wlist[win].hps_mem;
  840.   ARCPARAMS  arcparams; 
  841.   POINTL     center;
  842.   y = YCOORD(win,y);
  843.   arcparams.lP = r1;
  844.   arcparams.lQ = r2;
  845.   arcparams.lR = 0;
  846.   arcparams.lS = 0;
  847.   GpiSetArcParams(hps, (PARCPARAMS)&arcparams);
  848.   center.x = x;
  849.   center.y = y;
  850.   GpiMove (hps,&center);
  851.   GpiFullArc(hps,DRO_OUTLINEFILL,MAKEFIXED(1,0));
  852.   refresh_win(win,x-r1,y-r2,x+r1,y+r2);
  853. }
  856. void fill_polygon(Window win, int n, int* xcoord, int* ycoord)
  857. { HPS hps = wlist[win].hps_mem;
  858.   POINTL*  p = new POINTL[n];
  859.   for(int i=0; i < n; i++) 
  860.   { p[i].x = xcoord[i];
  861.     p[i].y = YCOORD(win,ycoord[i]);
  862.    }
  863.   GpiMove(hps,p);
  864.   GpiBeginArea(hps,BA_BOUNDARY | BA_ALTERNATE);
  865.   GpiPolyLine(hps,n,p);
  866.   GpiEndArea(hps);
  868.   int xmin = 10000;
  869.   int ymin = 10000;
  870.   int xmax = 0;
  871.   int ymax = 0;
  873.   for(i=0; i < n; i++) 
  874.   { if (xmin > p[i].x) xmin = p[i].x;
  875.     if (xmax < p[i].x) xmax = p[i].x;
  876.     if (ymin > p[i].y) ymin = p[i].y;
  877.     if (ymax < p[i].y) ymax = p[i].y;
  878.    }
  879.   refresh_win(win,xmin,ymin,xmax,ymax);
  880.  }
  883. void put_text(Window win, int x, int y, const char* s, int l, int opaque)
  884. { int h = text_height(s);
  885.   int w = text_width(s);
  887.   if (opaque)
  888.   { int save_col = set_color(white);
  889.     int save_mode = set_mode(src_mode);
  890.     box(win,x,y,x+w,y+h);
  891.     set_color(save_col);
  892.     set_mode(save_mode);
  893.    }
  895.   y = YCOORD(win,y);
  897.   POINTL pos;
  898.   pos.x = x;
  899.   pos.y = y - FontMetrics.lMaxAscender;
  900.   int len = strlen(s);
  901.   if (len > 512) len = 512;
  902.   if (len > l) len = l;
  903.   GpiCharStringAt(wlist[win].hps_mem,&pos,len, (PSZ)s);
  904.   refresh_win(win,x,y,x+w,y-h);
  905.  }
  906.   
  907. void put_text(Window win, int x, int y, const char* s, int opaque)
  908. { put_text(win, x, y, s, 512, opaque); }
  911. void put_ctext(Window win, int x, int y, const char* s, int opaque)
  912. { int h = text_height(s);
  913.   int w = text_width(s);
  914.   put_text(win,x-w/2,y-h/2,s,opaque);
  915. }
  918. char* create_pixrect(Window win, int x1, int y1, int x2, int y2)
  919. { return 0; }
  921. void insert_pixrect(Window win, int x, int y, char* rect)
  922. {}
  924. void delete_pixrect(char* rect)
  925. {}
  927. void copy_pixrect(Window win, int x1, int y1, int x2, int y2, int x, int y)
  928. {}
  930. void insert_bitmap(Window win, int width, int height, char* data)
  931. {}
  933. void show_coordinates(Window win, const char* s)
  934. { int col = set_color(black);
  935.   int mode = set_mode(src_mode);
  936.   put_text(win,window_width(win)-120,0,s,1); 
  937.   set_mode(mode);
  938.   set_color(col);
  939.  }
  942. /* fonts and text */
  944. int  load_text_font(const char* font_name) { return 0; }
  945. int  load_bold_font(const char* font_name) { return 0; }
  946. int  load_message_font(const char* font_name) { return 0; }
  948. int  set_font(const char* fname) { return 0; }
  950. void set_text_font(void)
  951. { for(int win=1; win <=wcount; win++)
  952.   { HPS hps = wlist[win].hps_mem;
  953.     GpiCreateLogFont(hps,(PSTR8)NULL,TEXT_FONT_ID,&TextFattrs);
  954.     GpiSetCharSet(hps,TEXT_FONT_ID);
  955.     GpiQueryFontMetrics(hps,sizeof(FONTMETRICS),(PFONTMETRICS)&FontMetrics);
  956.    }
  957. }
  959. void set_bold_font(void)
  960. { for(int win=1; win <=wcount; win++)
  961.   { HPS hps = wlist[win].hps_mem;
  962.     GpiCreateLogFont(hps,(PSTR8)NULL,TEXT_FONT_ID,&TextFattrs);
  963.     GpiSetCharSet(hps,TEXT_FONT_ID);
  964.     GpiQueryFontMetrics(hps,sizeof(FONTMETRICS),(PFONTMETRICS)&FontMetrics);
  965.    }
  966. }
  968. void set_message_font(void)
  969. { for(int win=1; win <=wcount; win++)
  970.   { HPS hps = wlist[win].hps_mem;
  971.     GpiCreateLogFont(hps,(PSTR8)NULL,BOLD_FONT_ID,&BoldFattrs);
  972.     GpiSetCharSet(hps,BOLD_FONT_ID);
  973.     GpiQueryFontMetrics(hps,sizeof(FONTMETRICS),(PFONTMETRICS)&FontMetrics);
  974.    }
  975. }
  978. int text_width(const char* s)
  979. { return  strlen(s) * FontMetrics.lAveCharWidth; }
  981. int text_height(const char* s) 
  982. { return  FontMetrics.lMaxBaselineExt; }
  985. /* drawing parameters */
  987. int set_color(int col) 
  988. { int c = GCOLOR;
  989.   for(int win=1; win <=wcount; win++)
  990.   GpiSetColor(wlist[win].hps_mem,color_table[col]); 
  991.   GCOLOR = col;
  992.   return c;
  993.  }
  995. int set_mode(int mod) 
  996. { int m = MODE;
  997.   for(int win=1; win <=wcount; win++)
  998.      GpiSetMix(wlist[win].hps_mem,mode_table[mod]); 
  1000.   if (mod == xor_mode) // switch to complementary colors
  1001.   { 
  1002.     color_table = color_table_xor;
  1003.    }
  1004.   else
  1005.     color_table = color_table_src;
  1007.   MODE = mod;
  1009.   return m;
  1010.  }
  1012. int set_line_width(int w) 
  1013. { int lw = LWIDTH;
  1014.   for(int win=1; win <=wcount; win++)
  1015.      GpiSetLineWidthGeom(wlist[win].hps_mem,w); 
  1016.   LWIDTH = w;
  1017.   return lw;
  1018.  }
  1020. int set_line_style(int s)
  1021. { int ls = LSTYLE;
  1022.   for(int win=1; win <=wcount; win++)
  1023.   GpiSetLineType(wlist[win].hps_mem,lstyle_table[s]);
  1024.   LSTYLE = s;
  1025.   return ls;
  1026.  }
  1028. void set_read_gc()
  1029. { for(int win=1; win <=wcount; win++)
  1030.   { HPS hps = wlist[win].hps_mem;
  1031.     GpiSetMix(hps,FM_XOR);
  1032.     GpiSetColor(hps,color_table[black]);
  1033.     GpiSetLineType(hps,LINETYPE_SOLID);
  1034.     GpiSetLineWidthGeom(hps,1);
  1035.    }
  1036.  }
  1038. void reset_gc()
  1039. { for(int win=1; win <=wcount; win++)
  1040.   { HPS hps = wlist[win].hps_mem;
  1041.     GpiSetMix(hps,mode_table[MODE]);
  1042.     GpiSetColor(hps,color_table[black]);
  1043.     GpiSetLineType(hps,lstyle_table[LSTYLE]);
  1044.     GpiSetLineWidthGeom(hps,LWIDTH);
  1045.   }
  1046. }
  1051. /* colors */
  1053. void set_palette(int i, int r, int g, int b)
  1054. { unsigned char R = (unsigned char)r;
  1055.   unsigned char G = (unsigned char)g;
  1056.   unsigned char B = (unsigned char)b;
  1057.   rgb_table[2*i+1] = LONGFromRGB(R,G,B);
  1058.   for(int win=1; win<=wcount; win++)
  1059.     GpiCreateLogColorTable(wlist[win].hps_mem,LCOL_PURECOLOR,
  1060.                                               LCOLF_INDRGB,0L,32L,rgb_table);
  1061. }
  1063. int  new_color(const char*) { return black; }
  1066. /* events */
  1068. static QMSG qmsg;
  1069. static int putback = 0;
  1070. static event old_event;
  1073. int  get_next_event(Window* win, int* val, int* x, int* y, unsigned long *t)
  1074. { 
  1075.   if (putback) 
  1076.    { cur_event = old_event;
  1077.      putback = 0;
  1078.     }
  1079.   else
  1080.     { WinGetMsg (hab, &qmsg, 0L, 0, 0);
  1081.       cur_event.kind = -1;
  1082.       WinDispatchMsg (hab, &qmsg);
  1083.       cur_event.t = qmsg.time;
  1084.       if (cur_event.kind != -1) old_event = cur_event;
  1085.      } 
  1087.   *win = cur_event.win;
  1088.   *val = cur_event.val;
  1089.   *x   = cur_event.x;
  1090.   *y   = cur_event.y;
  1091.   *t   = cur_event.t;
  1092.   return cur_event.kind;
  1093.  }
  1096. int  check_next_event(Window* win, int* val, int* x, int* y, unsigned long *t)
  1097. { 
  1098.   if (putback || WinPeekMsg(hab, &qmsg, 0L, 0, 0, PM_NOREMOVE))
  1099.      return get_next_event(win,val,x,y,t); 
  1100.   else
  1101.      return no_event;
  1102.  }
  1104. void put_back_event(void) {  putback = 1; }