开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 查看源码
_doswin.c
资源名称：leda.tar.gz　[点击查看]
上传用户：gzelex
上传日期：2007-01-07
资源大小：707k
文件大小：21k
源码类别：

数值算法/人工智能

开发平台：

MultiPlatform

_doswin.c：源码内容
  1. /*******************************************************************************
  2. +
  3. +  LEDA-R  3.2.3
  4. +
  5. +  _doswin.c
  6. +
  7. +  Copyright (c) 1995  by  Max-Planck-Institut fuer Informatik
  8. +  Im Stadtwald, 66123 Saarbruecken, Germany     
  9. +  All rights reserved.
  10. + 
  11. *******************************************************************************/
  13. #include <LEDA/impl/doswin.h>
  14. #include <LEDA/bitmaps/leda_icon.xbm>
  16. //------------------------------------------------------------------------------
  17. // event handling, window manager, etc ...                                    
  18. //------------------------------------------------------------------------------
  20. static char read_kbd()
  21. {
  22. #if defined(__EMX__)
  23.    return _read_kbd(0,0,0); 
  24. #else
  25.    return (kbhit()) ? getch() : 0; 
  26. #endif
  27.  }
  30. const int root_color = blue2; 
  31. const int label_col0 = grey2;
  32. const int label_col1 = grey2; 
  34. const int  win_max = 16;
  35. DosWindow  win_stack[win_max];
  36. int        win_top = 0;
  39. #define BORDER_W 5
  40. #define HEADER_W 20 
  42. static int display = 0;
  43. static int mouse_installed=0;
  44. static int mouse_two_buttons=0;
  46. static DosWindow root_win = 0;
  47. static DosWindow active_win = 0;
  49. static int pointer_shape = 0;
  50. static int pointer_visible = 0;
  51. static int mouse_x = 320;
  52. static int mouse_y = 240;
  54. static int event_buffer_e = -1;
  55. static int event_buffer_val;
  56. static DosWindow event_buffer_win;
  58. static int last_event_e;
  59. static int last_event_val;
  60. static DosWindow last_event_win;
  62. static int save_mode;
  63. static int save_lw;
  64. static int save_ls;
  67. static void show_pointer()
  68. { if (!pointer_visible) 
  69.      draw_pointer(mouse_x,mouse_y,pointer_shape); 
  70.   pointer_visible = 1;
  71.  }
  73. static void hide_pointer()
  74. { if (pointer_visible) 
  75.      draw_pointer(mouse_x,mouse_y,pointer_shape); 
  76.   pointer_visible = 0;
  77.  }
  80. static void set_pointer_shape(int shape)
  81. { if (pointer_shape != shape) 
  82.   { hide_pointer();
  83.     pointer_shape = shape;
  84.     show_pointer();
  85.   }
  86.  }
  89. static void put_header(DosWindow win)
  90. { char str[80];
  91.   int n = (win->width - 40)/text_width("H");
  92.   strncpy(str,win->header,n);
  93.   str[n] = 0;
  94.   put_ctext(root_win->id,win->x0 + win->width/2 + 20, win->y0 + 10 ,str,0);
  95.  }
  97. static void set_header(DosWindow win, const char* s)
  98. { int save_co = set_color(win->label_col);
  99.   int save_mo = set_mode(0);
  100.   put_header(win);
  101.   if (s != win->header) strcpy(win->header,s);
  102.   set_color(1);
  103.   put_header(win);
  104.   set_color(save_co);
  105.   set_mode(save_mo);
  106.  }
  108. void set_header(Window win, const char* s) { set_header(win_stack[win],s); }
  111. void draw_window(DosWindow win, int clear_win = 1)
  112. {
  113.   int bw  = win->xpos - win->x0 - 2;
  114.   int lw  = win->ypos - win->y0 - 2;
  115.   int bw1 = 2*(bw+1);
  117.   int x0 = win->x0;
  118.   int y0 = win->y0;
  120.   int x1 = win->x1;
  121.   int y1 = win->y1;
  123.   int save_mode = set_mode(0);
  125.   if (clear_win)
  126.   { set_color(win->bg_col);
  127.     box(root_win->id,x0,y0,x1,y1);
  128.    }
  130.   set_color(win->label_col);
  131.   box(root_win->id,x0+bw,y0+bw,x1-bw,y0+lw);
  132.   box(root_win->id,x0,y0+bw1,x0+bw,y1-bw1);
  133.   box(root_win->id,x1-bw,y0+bw1,x1,y1-bw1);
  134.   box(root_win->id,x0+bw1,y1-bw,x1-bw1,y1);
  135.   box(root_win->id,x0+bw1,y0,x1-bw1,y0+bw);
  136.   set_color(1);
  138.   rectangle(root_win->id,x0,y0,x1,y1);
  140.   line(root_win->id,x0+bw,y0+bw,x0+bw1,y0+bw);
  141.   line(root_win->id,x0+bw1,y0+bw,x0+bw1,y0+1);
  142.   line(root_win->id,x0+bw1,y0+1,x1-bw1,y0+1);
  143.   line(root_win->id,x1-bw1,y0+1,x1-bw1,y0+bw);
  144.   line(root_win->id,x1-bw1,y0+bw,x1-bw,y0+bw);
  145.   line(root_win->id,x1-bw,y0+bw,x1-bw,y0+bw1);
  146.   line(root_win->id,x1-bw,y0+bw1,x1-1,y0+bw1);
  147.   line(root_win->id,x1-1,y0+bw1,x1-1,y1-bw1);
  148.   line(root_win->id,x1-1,y1-bw1,x1-bw,y1-bw1);
  149.   line(root_win->id,x1-bw,y1-bw1,x1-bw,y1-bw);
  150.   line(root_win->id,x1-bw,y1-bw,x1-bw1,y1-bw);
  151.   line(root_win->id,x1-bw1,y1-bw,x1-bw1,y1-1);
  152.   line(root_win->id,x1-bw1,y1-1,x0+bw1,y1-1);
  153.   line(root_win->id,x0+bw1,y1-1,x0+bw1,y1-bw);
  154.   line(root_win->id,x0+bw1,y1-bw,x0+bw,y1-bw);
  155.   line(root_win->id,x0+bw,y1-bw,x0+bw,y1-bw1);
  156.   line(root_win->id,x0+bw,y1-bw1,x0+1,y1-bw1);
  157.   line(root_win->id,x0+1,y1-bw1,x0+1,y0+bw1);
  158.   line(root_win->id,x0+1,y0+bw1,x0+bw,y0+bw1);
  159.   line(root_win->id,x0+bw,y0+bw1,x0+bw,y0+bw);
  161.   rectangle(root_win->id, win->xpos-1, win->ypos-1,
  162.                       win->xpos+win->width, win->ypos+win->height);
  164.   // iconize-button
  165.   set_color(0);
  166.   box(root_win->id,x0+13,y0+3,x0+27,y0+15);
  167.   set_color(1);
  168.   rectangle(root_win->id,x0+13,y0+3,x0+27,y0+15);
  169.   line(root_win->id,x0+14,y0+16,x0+28,y0+16);
  170.   line(root_win->id,x0+28,y0+4,x0+28,y0+15);
  171.   line(root_win->id,x0+17,y0+6,x0+23,y0+6);
  172.   line(root_win->id,x0+16,y0+6,x0+20,y0+13);
  173.   line(root_win->id,x0+17,y0+6,x0+20,y0+13);
  174.   line(root_win->id,x0+24,y0+6,x0+20,y0+13);
  175.   line(root_win->id,x0+23,y0+6,x0+20,y0+13);
  177.   set_header(win->id,win->header);
  179.   set_mode(save_mode);
  181. }
  184. Window open_window(int x,int y,int width,int height,int bg,
  185.                    const char* header, const char* label)
  186. { 
  187.   if (win_top > 0)  // deactivate top window
  188.   { DosWindow w = win_stack[win_top];
  189.     w->label_col = label_col0;
  190.     draw_window(w,0);
  191.    }
  193.   DosWindow win = new dos_window;
  194.   win_stack[++win_top] = win;
  195.   win->id = win_top;
  197.   strcpy(win->header," ");
  198.   strcpy(win->label,label);
  200.   win->bg_col = bg;
  201.   win->label_col = label_col0;
  203.   width  += 2*BORDER_W;
  204.   height += HEADER_W+BORDER_W;
  206.   win->x0 = x;
  207.   win->y0 = y;
  208.   win->x1 = x+width-1;
  209.   win->y1 = y+height-1;
  210.   win->xpos = x+BORDER_W;
  211.   win->ypos = y+HEADER_W;
  212.   win->width = width - 2*BORDER_W; 
  213.   win->height = height - HEADER_W - BORDER_W;
  215.   win->iconized = 0;
  216.   win->save_x0 = 3;
  217.   win->save_y0 = 3 + 150*(win_top-1);
  218.   win->save_x1 = win->save_x0 + 128 + 2*BORDER_W;
  219.   win->save_y1 = win->save_y0 + 128 + HEADER_W + BORDER_W;
  220.   win->save_bg_col = white;
  221.   win->redraw = 0;
  223.   win->image_buf = create_pixrect(root_win->id,win->x0,win->y0,win->x1,win->y1);
  224.   draw_window(win);
  225.   set_header(win->id,header);
  226.   return win->id;
  227. }
  230. void clear_window(Window w)
  231. { DosWindow win = win_stack[w];
  232.   int save_col  = set_color(win->bg_col);
  233.   int save_mode = set_mode(0);
  234.   box(w,0,0,win->width-1,win->height-1);
  235.   set_color(save_col);
  236.   set_mode(save_mode);
  237.   
  238.   while (w < win_top) 
  239.   { w++;
  240.     DosWindow win = win_stack[w]; 
  241.     draw_window(win);
  242.     if (win->redraw) (*(win->redraw))();
  243.    }
  244.  }
  247. void close_window(Window w)
  248. { if (w != win_top) return;  /* can close top window only */
  249.   DosWindow win = win_stack[w];
  250.   insert_pixrect(root_win->id,win->x0,win->y0,win->image_buf);
  251.   delete_pixrect(win->image_buf);
  252.   win_top--;
  253.   delete win;
  254.  }
  257. void set_read_gc()
  258. { save_mode = set_mode(1);
  259.   save_ls   = set_line_style(0);
  260.   save_lw   = set_line_width(1);
  261.   set_color(1);
  262.   show_pointer();
  263.  }
  265. void reset_gc()
  266. { hide_pointer();
  267.   set_mode(save_mode);
  268.   set_line_style(save_ls);
  269.   set_line_width(save_lw);
  270.  }
  274. #define UP  72
  275. #define DO  80
  276. #define LE  75
  277. #define RI  77
  279. static int handle_next_event(Window* win, int *val, int *x, int *y)
  280. {
  281.   int  e =  no_event;
  282.   int  i;
  283.   DosWindow w;
  285.   union REGISTERS key_regs;
  286.   union REGISTERS mouse_regs;
  288.   if (event_buffer_e != -1)
  289.   { *val = event_buffer_val;
  290.     w = event_buffer_win;
  291.     *win = w->id;
  292.     *x = mouse_x - w->xpos;
  293.     *y = mouse_y - w->ypos;
  294.     last_event_e = event_buffer_e;
  295.     last_event_val = event_buffer_val;
  296.     last_event_win = event_buffer_win;
  297.     event_buffer_e = -1;
  298.     return last_event_e;
  299.    }
  301.   mouse_regs.x.cx = 8*mouse_x;
  302.   mouse_regs.x.dx = 8*mouse_y;
  304.   char c;
  306.   if ((c = read_kbd()) > 0)
  307.   { 
  308.     int step = 16;
  310.     if (c==27) 
  311.     { close_display();
  312.       exit(0);
  313.      }
  315.     if (c != 0)   /* ascii char */
  316.        { *val = c;
  317.          e = key_press_event;
  318.         }
  319.     else          /* cursor or function key  */
  320.        { 
  321.          c = getch();
  323.          switch(c) {
  325.          case  LE: mouse_regs.x.cx -= step;
  326.                    e = motion_event;
  327.                    break;
  329.          case  RI: mouse_regs.x.cx += step;
  330.                    e = motion_event;
  331.                    break;
  333.          case  UP: mouse_regs.x.dx -= step;
  334.                    e = motion_event;
  335.                    break;
  337.          case  DO: mouse_regs.x.dx += step;
  338.                    e = motion_event;
  339.                    break;
  341.         }
  343.         /* set cursor position */
  344.         mouse_regs.x.ax=04;
  345.         int_86(0x33,&mouse_regs,&mouse_regs);
  346.       }
  348.    } /* kbhit */
  350.  else
  352.   if (mouse_installed)
  353.   { 
  354.     int but;
  356.     /* check for button press and release events */
  358. //INT 33 - MS MOUSE - RETURN BUTTON PRESS DATA
  359. // AX = 0005h
  360. // BX = button
  361. //     0000h left
  362. //     0001h right
  363. //     0002h middle (Mouse Systems/Logitech mouse)
  364. //Return: AX = 1 if button pressed
  365. //   BX = number of times specified button has been pressed since last call
  366. //   CX = column at time specified button was last pressed
  367. //   DX = row at time specified button was last pressed
  369. //INT 33 - MS MOUSE - RETURN BUTTON RELEASE DATA
  370. // AX = 0006h
  371. // BX = button
  372. //     0000h left
  373. //     0001h right
  374. //     0002h middle (Mouse Systems/Logitech mouse)
  375. //Return: AX = 1 if button released
  376. //   BX = # of times specified button has been released since last call
  377. //   CX = column at time specified button was last released
  378. //   DX = row at time specified button was last released
  380.     for(but=0; but < 3; but++)
  381.     { 
  382.       mouse_regs.x.ax=5;
  383.       mouse_regs.x.bx=but;
  384.       int_86(0x33,&mouse_regs,&mouse_regs);
  386.       if (mouse_regs.x.bx)
  387.       { e = button_press_event;
  388.         break;
  389.        }
  391.       mouse_regs.x.ax=6;
  392.       mouse_regs.x.bx=but;
  393.       int_86(0x33,&mouse_regs,&mouse_regs);
  395.       if (mouse_regs.x.bx)
  396.       { e = button_release_event;
  397.         break;
  398.        }
  400.      }
  403.     if (but < 3) 
  404.     { 
  405.       if (but == 0) *val = 1;   // left
  406.       if (but == 1) *val = 3;   // right
  407.       if (but == 2) *val = 2;   // middle
  409.       //INT 16 - GET KEYBOARD SHIFT KEY STATES
  410.       //          AH = 0002h
  411.       //  OUTPUT: AL  bit 0    right shift
  412.       //              bit 1    left shift
  413.       //              bit 2    ctrl
  414.       //              bit 3    alt
  416.       key_regs.h.ah=0x02;
  417.       int_86(0x16,&key_regs,&key_regs);
  419.       // ALT key simulates middle button  (two-button mouse)
  420.       if (key_regs.h.al & 8) *val = 2;       // alt
  421.       if (key_regs.h.al & 3) *val = -*val;   // shift
  422.       if (key_regs.h.al & 4) *val += 3;      // ctrl
  423.      }
  425.    // INT 33 MS-MOUSE GET CURSOR POSITION
  426.    mouse_regs.x.ax=03;
  427.    int_86(0x33,&mouse_regs,&mouse_regs);
  428.   }
  430.   if (mouse_regs.x.cx/8 != mouse_x || mouse_regs.x.dx/8 != mouse_y)
  431.   { if (e==no_event) e = motion_event;
  432.     hide_pointer();
  433.     mouse_y = mouse_regs.x.dx/8;
  434.     mouse_x = mouse_regs.x.cx/8;
  435.     show_pointer();
  436.    }
  438.   for(i = win_top; i >= 0; i--)
  439.   { w = win_stack[i];
  440.     if (mouse_x >= w->x0  && mouse_x <= w->x1 &&
  441.         mouse_y >= w->y0  && mouse_y <= w->y1 )  break;
  442.    }
  444.   *win = w->id;
  445.   *x = mouse_x - w->xpos;
  446.   *y = mouse_y - w->ypos;
  448.   if (e != no_event)
  449.   { last_event_e   = e;
  450.     last_event_val = *val;
  451.     last_event_win = w;
  452.    }
  454.   return e;
  455.  }
  458. void put_back_event() 
  459. { event_buffer_e   = last_event_e;  
  460.   event_buffer_val = last_event_val; 
  461.   event_buffer_win = last_event_win; 
  462.  }
  464. static void change_geometry(DosWindow win, int x0, int y0, int x1, int y1)
  465. {
  466.   if (x0==win->x0 && y0==win->y0 && x1==win->x1 && y1==win->y1) return;
  468.   int w = x1-x0+1;
  469.   int h = y1-y0+1;
  471.   hide_pointer();
  472.   insert_pixrect(root_win->id,win->x0,win->y0,win->image_buf);
  473.   delete_pixrect(win->image_buf);
  475.   win->x0 = x0;
  476.   win->y0 = y0;
  477.   win->x1 = x1;
  478.   win->y1 = y1;
  479.   win->xpos = x0+BORDER_W;
  480.   win->ypos = y0+HEADER_W;
  481.   win->width = w - 2*BORDER_W; 
  482.   win->height = h - HEADER_W - BORDER_W;
  484.   win->image_buf = create_pixrect(root_win->id,win->x0,win->y0,win->x1,win->y1);
  485.   draw_window(win);
  486.   show_pointer();
  487. }
  490. static void iconize(DosWindow win)
  491. { Window w;
  492.   int val,x,y;
  493.   box(root_win->id,win->x0+14,win->y0+4,win->x0+26,win->y0+14);
  494.   while (handle_next_event(&w,&val,&x,&y) != button_release_event);
  495.   box(root_win->id,win->x0+14,win->y0+4,win->x0+26,win->y0+14);
  497.   int x0 = win->save_x0;
  498.   int y0 = win->save_y0;
  499.   int x1 = win->save_x1;
  500.   int y1 = win->save_y1;
  501.   int bg = win->save_bg_col;
  502.   win->save_x0 = win->x0;
  503.   win->save_y0 = win->y0;
  504.   win->save_x1 = win->x1;
  505.   win->save_y1 = win->y1;
  506.   win->save_bg_col = win->bg_col;
  507.   win->bg_col =  bg;
  508.   change_geometry(win,x0,y0,x1,y1);
  509.   win->iconized = 1-win->iconized;
  511.   if (win->iconized) 
  512.      insert_bitmap(win->id, leda_icon_width, leda_icon_height,
  513.                    (char*)leda_icon_bits);
  514.  }
  516. static void move_win(DosWindow win, int *x, int *y)
  517. { int xp0 = win->x0;
  518.   int yp0 = win->y0;
  519.   int xp1 = win->x1;
  520.   int yp1 = win->y1;
  521.   int wi  = xp1-xp0+1;
  522.   int he  = yp1-yp0+1;
  523.   int xb  = win->xpos - xp0;
  524.   int yb  = win->ypos - yp0;
  525.   int xc = mouse_x; /* absolute cursor coordinates */
  526.   int yc = mouse_y; 
  527.   int dx = xc-xp0;  /* relative to upper left corner */
  528.   int dy = yc-yp0;
  530.   Window w;
  531.   int e,val;
  533.   rectangle(root_win->id,xp0-1,yp0-1,xp1+1,yp1+1);
  535.   do { e = handle_next_event(&w,&val,x,y);
  536.       if (mouse_x != xc || mouse_y != yc)
  537.        { int rx0 = mouse_x-dx-1;
  538.          int ry0 = mouse_y-dy-1;
  539.          int rx1 = mouse_x-dx+wi;
  540.          int ry1 = mouse_y-dy+he;
  541.          rectangle(root_win->id,rx0,ry0,rx1,ry1);
  542.          rectangle(root_win->id,xc-dx-1,yc-dy-1,xc-dx+wi,yc-dy+he);
  543.          xc = mouse_x;
  544.          yc = mouse_y;
  545.        }
  546.      } while (e != button_release_event);
  548.   xc -= dx;
  549.   yc -= dy;
  551.   rectangle(root_win->id,xc-1,yc-1,xc+wi,yc+he);
  553.   if (win_top > 1)  /* move panel */
  554.   { change_geometry(win,xc,yc,xc+wi-1,yc+he-1);
  555.     if (win->iconized) 
  556.        insert_bitmap(win->id, leda_icon_width, leda_icon_height,
  557.                      (char*)leda_icon_bits);
  558.     return;
  559.    }
  561.   if (xc < 0) xc = 0;
  562.   if (yc < 0) yc = 0;
  563.   if (xc + wi > DISP_MAX_X) xc = DISP_MAX_X - wi;
  564.   if (yc + he > DISP_MAX_Y) yc = DISP_MAX_Y - he;
  566.   xc -= xc % 8;
  567.   xc += xp0 % 8;
  569.   hide_pointer();
  570.   copy_pixrect(root_win->id,xp0,yp0+1,xp0+wi,yp0+he-1,xc,yc+1);
  571.   show_pointer();
  573.   set_mode(0);
  574.   set_color(root_color);
  576.   if (xc > xp0) 
  577.      box(root_win->id,xp0,yp0,xc-1,yp1);
  578.   else
  579.      box(root_win->id,xc+wi,yp0,xp1,yp1);
  581.   if (yc > yp0) 
  582.      box(root_win->id,xp0,yp0,xp1,yc-1);
  583.   else
  584.      box(root_win->id,xp0,yc+he,xp1,yp1);
  586.   set_color(1);
  587.   rectangle(root_win->id,xc,yc,xc+wi-1,yc+he-1);
  589.   set_mode(1);
  591.   win->x0 = xc; 
  592.   win->y0 = yc; 
  593.   win->x1 = xc+wi-1; 
  594.   win->y1 = yc+he-1; 
  595.   win->xpos = xc+xb; 
  596.   win->ypos = yc+yb; 
  598. }
  601. static void resize_win(DosWindow win, int* x, int* y, int pos)
  602. { int xp0 = win->x0;
  603.   int yp0 = win->y0;
  604.   int xp1 = win->x1;
  605.   int yp1 = win->y1;
  606.   int xb  = win->xpos - xp0;
  607.   int yb  = win->ypos - yp0;
  608.   
  609.   int xc  = mouse_x; /* absolute cursor coordinates */
  610.   int yc  = mouse_y;
  612.   Window w;
  613.   int e,val,dx,dy;
  615.   rectangle(root_win->id,xp0-1,yp0-1,xp1+1,yp1+1);
  617.   switch(pos) {
  618.   
  619.    case 0: dx = xp0-xc;          /* upper left */
  620.            dy = yp0-yc;
  621.            break;
  623.    case 1: dx = xp1-xc;          /* upper right */
  624.            dy = yp0-yc;
  625.            break;
  627.    case 2: dx = xp1-xc;          /* lower right */
  628.            dy = yp1-yc;
  629.            break;
  631.    case 3: dx = xp0-xc;          /* lower left */
  632.            dy = yp1-yc;
  633.            break;
  635.    }
  637.   do { e = handle_next_event(&w,&val,x,y);
  638.        if (mouse_x != xc || mouse_y != yc)
  639.         { 
  640.           switch(pos) {
  642.           case 0: rectangle(root_win->id,mouse_x+dx-1,mouse_y+dy-1,xp1+1,yp1+1);
  643.                   rectangle(root_win->id,xc+dx-1,yc+dy-1,xp1+1,yp1+1);
  644.                   break;
  645.           
  646.           case 1: rectangle(root_win->id,xp0-1,mouse_y+dy-1,mouse_x+dx+1,yp1+1);
  647.                   rectangle(root_win->id,xp0-1,yc+dy-1,xc+dx+1,yp1+1);
  648.                   break;
  650.           case 2: rectangle(root_win->id,xp0-1,yp0-1,mouse_x+dx+1,mouse_y+dy+1);
  651.                   rectangle(root_win->id,xp0-1,yp0-1,xc+dx+1,yc+dy+1);
  652.                   break;
  653.              
  654.           case 3: rectangle(root_win->id,mouse_x+dx-1,yp0-1,xp1+1,mouse_y+dy+1);
  655.                   rectangle(root_win->id,xc+dx-1,yp0-1,xp1+1,yc+dy+1);
  656.                   break;
  657.           
  658.            }
  660.           xc = mouse_x;
  661.           yc = mouse_y;
  662.         }
  663.      } while (e != button_release_event);
  665.    xc += dx;
  666.    yc += dy;
  668.    switch(pos) {
  670.    case 0: win->x0 = xc; 
  671.            win->y0 = yc; 
  672.            break;
  673.                 
  674.    case 1: win->x1 = xc; 
  675.            win->y0 = yc; 
  676.            break;
  677.               
  678.    case 2: win->x1 = xc; 
  679.            win->y1 = yc; 
  680.            break;
  682.    case 3: win->x0 = xc; 
  683.            win->y1 = yc; 
  684.            break;
  685.            
  686.    }
  688.   win->xpos = win->x0 + xb;
  689.   win->ypos = win->y0 + yb;
  690.   win->width  = win->x1 - win->x0 - 2*xb + 1; 
  691.   win->height = win->y1 - win->y0 - xb - yb + 1; 
  693.   rectangle(root_win->id,win->x0-1,win->y0-1,win->x1+1,win->y1+1);
  695.   hide_pointer();
  696.   insert_pixrect(root_win->id,xp0,yp0,win->image_buf);
  697.   delete_pixrect(win->image_buf);
  698.   win->image_buf = create_pixrect(root_win->id,win->x0,win->y0,win->x1,win->y1);
  699.   draw_window(win);
  700.   show_pointer();
  702.   *x = win->width;
  703.   *y = win->height;
  705. }
  708. int check_next_event(Window* w, int* val, int* x, int *y, unsigned long* t)
  709. {
  710.   // non-blocking
  711.   
  712.   // a primitive window manager active while searching for next event
  714.   int cx[4];
  715.   int cy[4];
  716.   int bw = BORDER_W;
  717.   int lw = HEADER_W;
  719.   int e = handle_next_event(w,val,x,y);
  722.   if (*w != active_win->id)
  723.   {  hide_pointer();
  724.      active_win->label_col = label_col0;
  725.      if (active_win->id == win_top) draw_window(active_win,0);
  726.      active_win = win_stack[*w];
  727.      active_win->label_col = label_col1;
  728.      if (active_win->id == win_top) draw_window(active_win,0);
  729.      show_pointer();
  730.    }
  733.   DosWindow win = win_stack[*w];
  735.   int x0 = win->x0;
  736.   int y0 = win->y0;
  737.   int x1 = win->x1;
  738.   int y1 = win->y1;
  741.   cx[0] = x0;
  742.   cy[0] = y0;
  743.   cx[1] = x1-6;
  744.   cy[1] = y0;
  745.   cx[2] = x1-6;
  746.   cy[2] = y1-6;
  747.   cx[3] = x0;
  748.   cy[3] = y1-6;
  750.   if ( (x0 <= mouse_x && mouse_x <= x0+bw) 
  751.     || (x1 >= mouse_x && mouse_x >= x1-bw)
  752.     || (y0 <= mouse_y && mouse_y <= y0+lw)
  753.     || (y1 >= mouse_y && mouse_y >= y1-bw))
  754.     {
  755.       // pointer on window boundary: move or resize window
  757.      if (win != win_stack[win_top])  /* only top window can be changed  */
  758.      { set_pointer_shape(0);
  759.        return no_event;
  760.       }
  762.      for(int i=0; i<4; i++)
  763.        if ( cy[i] <= mouse_y && mouse_y <= cy[i]+6 &&
  764.             cx[i] <= mouse_x && mouse_x <= cx[i]+6 )
  765.        { set_pointer_shape(1);
  766.          if (e == button_press_event && ! win->iconized) 
  767.          { if (win->iconized)
  768.              e = no_event;
  769.            else
  770.              resize_win(win,x,y,i);
  771.            e = configure_event;
  772.           }
  773.           return e;
  774.         }
  776.     set_pointer_shape(0);
  777.    
  778.     if (x0+13 <= mouse_x && mouse_x <= x0+27 &&
  779.         y0+3  <= mouse_y && mouse_y <= y0+15 && e == button_press_event)
  780.     { iconize(win);
  781.       return (win->iconized) ? no_event : configure_event;
  782.      }
  785.     if (e== button_press_event) 
  786.     { move_win(win,x,y);
  787.       if (win_top==1 || win->iconized)  
  788.          return handle_next_event(w,val,x,y);  
  789.       else
  790.          return configure_event;
  791.      }
  793.     e = no_event;
  795.   }  // if pointer on window boundary
  797.   set_pointer_shape(0);
  798.  
  799.   return e;
  800. }
  803. int get_next_event(Window* win, int* val, int* x, int *y, unsigned long* t)
  804. { // blocking
  805.   int e = no_event;
  806.   while (e == no_event) e = check_next_event(win,val,x,y,t);
  807.   return e;
  808.  }
  812. void open_display()
  813. { REGISTERS regs;
  815.   if (display) return;
  817.   display = 1;
  819.   init_graphics(1,root_color);
  821.   //INT 33 - MS MOUSE - RESET DRIVER AND READ STATUS
  822.   //    AX = 0000h
  823.   //Return: AX = status
  824.   //     0000h hardware/driver not installed
  825.   //     FFFFh hardware/driver installed
  826.   //     BX = number of buttons
  827.   //     FFFFh two buttons
  828.   //     0000h other than two
  829.   //     0003h Mouse Systems/Logitech mouse
  830.   regs.x.ax=0x00;
  831.   int_86(0x33,&regs,&regs);
  832.   mouse_installed = (regs.x.ax == 0x0ffff);
  833.   mouse_two_buttons = (regs.x.bx == 0x0ffff);
  835.   //INT 33 - MS MOUSE - DEFINE HORIZONTAL CURSOR RANGE = 0..DISP_MAX_X
  836.   regs.x.ax=0x07;
  837.   regs.x.cx=0;
  838.   regs.x.dx=8*DISP_MAX_X;
  839.   int_86(0x33,&regs,&regs);
  841.   //INT 33 - MS MOUSE - DEFINE VERTICAL CURSOR RANGE = 0..DISP_MAX_Y
  842.   regs.x.ax=0x08;
  843.   regs.x.cx=0;
  844.   regs.x.dx=8*DISP_MAX_Y;
  845.   int_86(0x33,&regs,&regs);
  847.   //INT 33 - MS MOUSE - DEFINE MICKEY/PIXEL RATIO = 1
  848.   regs.x.ax=0x0F;
  849.   regs.x.cx=1;
  850.   regs.x.dx=1;
  851.   int_86(0x33,&regs,&regs);
  853.   //INT 33 - MS MOUSE - SET CURSOR POSITION
  854.   mouse_x = DISP_MAX_X/2;
  855.   mouse_y = DISP_MAX_Y/2;
  856.   regs.x.cx = 8*mouse_x;
  857.   regs.x.dx = 8*mouse_y;
  858.   regs.x.ax=04;
  859.   int_86(0x33,&regs,&regs);
  861.   root_win = new dos_window;
  862.   active_win = root_win;
  863.   root_win->id = 0;
  864.   win_stack[0] = root_win;
  865.   win_top = 0;
  867.   root_win->x0 = -1000;
  868.   root_win->y0 = -1000;
  869.   root_win->x1 =  1000;
  870.   root_win->y1 =  1000;
  871.   root_win->xpos = 0;
  872.   root_win->ypos = 0;
  873.   root_win->width  = display_width();
  874.   root_win->height = display_height();
  875.   root_win->bg_col = root_color;
  877.   set_color(root_color);
  878.   box(root_win->id,0,0,DISP_MAX_X,DISP_MAX_Y);
  879.   set_color(black);
  880. }
  883. void close_display()
  884. { init_graphics(0,0);
  885.   delete root_win;
  886.  }
  889. int  window_width(Window win)  { return win_stack[win]->width; }
  890. int  window_height(Window win) { return win_stack[win]->height; }
  892. void window_position(Window win,int* x,int* y) 
  893. { *x = win_stack[win]->x0; 
  894.   *y = win_stack[win]->y0; 
  895.  }