home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 22 gnu / 22-gnu.zip / gwm18a.zip / plug.c < prev    next >
C/C++ Source or Header  |  1995-07-03  |  7KB  |  254 lines
  1. /* Copyright 1989 GROUPE BULL -- See license conditions in file COPYRIGHT
  2.  * Copyright 1989 Massachusetts Institute of Technology
  3.  */
  4. /*****************************************************\
  5. *                               *
  6. *     BULL WINDOW MANAGER for X11 .              *
  7. *                               *
  8. *         MODULE defining the Plug Wob Class    *
  9. *                               *
  10. \*****************************************************/
  11.  
  12. /*  include  */
  13.  
  14. #include        "EXTERN.h"
  15. #include     "gwm.h"
  16. #include    "wl_atom.h"
  17. #include    "wl_list.h"
  18. #include    "wl_fsm.h"
  19. #include    "wl_pixmap.h"
  20. #include    "wl_cursor.h"
  21. #include    "wl_plug.h"
  22.  
  23. #ifdef SHAPE            /* compile with -I/usr/include/X11 AND
  24.                    -I/usr/include/X11/extensions to work on
  25.                    machines having shapes.h in either place */
  26. #include    <shape.h>
  27. #endif /* SHAPE */
  28.  
  29. /*  local constants  */
  30.  
  31. /*  external  */
  32.  
  33. extern Wob      NewWob();
  34. extern WOOL_METHOD WLMenu[];
  35. extern Plug PlugOpen();
  36. extern PlugClose(), PlugEventHandler(), ReconfigurePlug();
  37.  
  38. WOB_METHOD       PlugClass[] = {
  39.                    0,    /* METHODS_ARRAY */
  40.                    WobEval,
  41.                    WobPrint,
  42.                    WobRelease,
  43.                    WobExecute,
  44.                    WobSet,
  45.                    WobGetCValue,
  46.                    (WOB_METHOD) PlugOpen,
  47.                    PlugClose,
  48.                    PlugEventHandler,
  49.                                (WOB_METHOD) wool_undefined_method_1,
  50.                                WobGetDimensions,
  51.                                (WOB_METHOD) wool_undefined_method_2,
  52.                                (WOB_METHOD) wool_undefined_method_2,
  53.                                ReconfigurePlug,
  54.             (WOB_METHOD) wool_undefined_method_2,
  55.             (WOB_METHOD) wool_undefined_method_1,
  56.             (WOB_METHOD) wool_undefined_method_1,
  57.             (WOB_METHOD) wool_undefined_method_1,
  58.             (WOB_METHOD) wool_undefined_method_1,
  59.             (WOB_METHOD) wool_undefined_method_1
  60. };
  61.  
  62. /*  routines  */
  63.  
  64. /*
  65.  * Set up an icon that must be mapped onto a bar.
  66.  */
  67.  
  68. Plug
  69. PlugOpen(plug)
  70. Plug             plug;
  71. {
  72.     Pixmap mask;
  73.  
  74.     check_window_size(plug);
  75.     plug -> hook =
  76.     XCreateSimpleWindow(dpy, plug -> parent -> hook,
  77.                 plug -> box.x, plug -> box.y,
  78.                 plug -> box.width, plug -> box.height,
  79.                 plug -> box.borderwidth,
  80.                 plug -> box.borderpixel, plug -> box.background);
  81.     if (plug -> parent -> type == ScreenClass)
  82.         plug -> status |= TopLevelXWindowStatus;
  83.     WobRecordHook(plug);
  84.     plug -> curstate = (int) WOOL_send(WOOL_open, plug -> fsm, (plug -> fsm));
  85.     plug -> input_mask = WobMask 
  86.     | (plug -> graphic_mask = 
  87.        ((unsigned int) WOOL_send(WOOL_open, 
  88.                      plug -> graphic, 
  89.                      (plug -> graphic, plug))))
  90.         | ((WOOL_Fsm) plug -> fsm) -> mask;
  91.     XSelectInput(dpy, plug -> hook, plug -> input_mask);
  92.     if (plug -> cursor != NIL)
  93.     XDefineCursor(dpy, plug -> hook,
  94.               ((WOOL_Cursor) plug -> cursor) -> cursor);
  95.     if (plug -> bordertile != NIL)
  96.     XSetWindowBorderPixmap(dpy, plug -> hook,
  97.                    ((WOOL_Pixmap) plug -> bordertile) -> pixmap);
  98. #ifdef SHAPE
  99.     /* if the plug is made of a non-rectangular (shaped) pixmap, sets its
  100.      * shape to it...
  101.      */
  102.     if (plug -> graphic -> type == WLPixmap
  103.     && (mask = ((WOOL_Pixmap) (plug -> graphic))->mask)) {
  104.     XShapeCombineMask(dpy, plug -> hook, ShapeBounding, 0, 0,
  105.               mask, ShapeSet);
  106.     }
  107. #endif /* SHAPE */
  108.  
  109.     return plug;
  110. }
  111.  
  112. Plug 
  113. NewPlug(bar, wl_plug)
  114. Bar             bar;
  115. WOOL_Plug    wl_plug;
  116. {
  117.     Plug            plug;
  118.     WOOL_OBJECT     graphic;
  119.  
  120.     /* if plug = (), then it is a space and we return NULL */
  121.     if (wl_plug == (WOOL_Plug) NIL)
  122.     return NULL;
  123.     plug = (Plug) NewWob(sizeof(struct _Plug));
  124.     wl_plug = (WOOL_Plug) wool_type_or_evaluate(wl_plug, WLPlug);
  125.     plug -> type = PlugClass;
  126.     plug -> parent = (Wob) bar;
  127.     graphic = wl_plug -> graphic;
  128.     if (graphic -> type == WLAtom || graphic -> type == WLList)
  129.     graphic = WOOL_send(WOOL_eval, graphic, (graphic));
  130.     /* first, set the box info */
  131.     plug -> box.borderwidth = wl_plug -> borderwidth;
  132.     plug -> box.borderpixel = wl_plug -> borderpixel;
  133.     plug -> box.background = wl_plug -> background;
  134.     increase_reference(plug -> property = (WOOL_OBJECT) wl_plug -> property);
  135.     increase_reference(plug -> bordertile =
  136.             wool_type_or_evaluate(wl_plug -> bordertile, WLPixmap));
  137.     increase_reference(plug -> fsm =
  138.                wool_type_or_evaluate(wl_plug -> fsm, WLFsm));
  139.     increase_reference(plug -> menu =
  140.                wool_type_or_evaluate(wl_plug -> menu, WLMenu));
  141.     increase_reference(plug -> cursor =
  142.                wool_type_or_evaluate(wl_plug -> cursor, WLCursor));
  143.     increase_reference(plug -> graphic = graphic);
  144.     increase_reference(plug -> tile = (graphic -> type == WLPixmap
  145.                        ? graphic : NIL));
  146.     return plug;
  147. }
  148.  
  149. PlugClose(wob)
  150. Plug             wob;
  151. {
  152.     decrease_reference(wob -> graphic);
  153.     WobRelease(wob);
  154. }
  155.  
  156. /*
  157.  * Set here the dimensions of a plug
  158.  */
  159.  
  160. UpdatePlugGeometry(plug)
  161. Plug    plug;
  162. {
  163.     WOOL_send(WOOL_get_dimensions, plug -> graphic,
  164.           (plug -> graphic, &(plug -> box)));
  165. }
  166.  
  167. PlugEventHandler(plug, evt)
  168. Plug    plug;
  169. XEvent    *evt;
  170. {
  171.     switch (evt -> type) {
  172.     case Expose:
  173.     SetTarget(plug);
  174.     WOOL_send(WOOL_redraw, plug -> graphic,
  175.           (plug -> graphic, plug));
  176.     break;
  177.     default:
  178.     WLFsm_action(plug -> fsm, plug, evt);
  179.     }
  180. }
  181.     
  182. ReconfigurePlug(plug, culprit)
  183. Plug     plug;
  184. Wob    culprit;
  185. {
  186.     int             width, height;
  187.     Pixmap shape;
  188.     int dirty = 0;
  189.  
  190.     if (culprit == (Wob) plug -> parent) {
  191.     XMoveWindow(dpy, plug -> hook, plug -> box.x, plug -> box.y);
  192.     } else if (culprit == (Wob) plug -> graphic) {
  193.     width = plug -> box.width;
  194.     height = plug -> box.height;
  195.     shape = plug->box.shape;
  196.     UpdatePlugGeometry(plug);
  197.     if ((plug -> box.width != width) || (plug -> box.height != height)) {
  198.         XResizeWindow(dpy, plug -> hook,
  199.               plug -> box.width, plug -> box.height);
  200.         dirty = 1;
  201.     }
  202.     if (plug -> box.shape != shape) {
  203.         dirty = 1;
  204.     }
  205.     if (dirty)
  206.         WOOL_send(WOOL_reconfigure, plug -> parent,
  207.               (plug -> parent, plug));
  208.     }
  209.     WOOL_send(WOOL_redraw, plug -> graphic, (plug -> graphic, plug));
  210. }
  211.  
  212. set_plug_bitmap(plug, wl_pixmap)
  213. Plug    plug;
  214. WOOL_OBJECT    wl_pixmap;
  215. {
  216.     Pixmap mask;
  217.     unsigned int    graphic_mask;
  218.     int was_shaped = 0;
  219.  
  220.     if (wl_pixmap -> type == WLAtom || wl_pixmap -> type == WLList)
  221.     return;
  222.     if (plug -> graphic -> type == WLPixmap
  223.     && (((WOOL_Pixmap) (plug -> graphic))->mask))
  224.       was_shaped = 1;
  225.     decrease_reference(plug -> graphic);
  226.     increase_reference(plug -> graphic = wl_pixmap);
  227.     graphic_mask = ((unsigned int) WOOL_send(WOOL_open, plug -> graphic,
  228.                       (plug -> graphic, plug)));
  229.     if (graphic_mask != plug -> graphic_mask) {
  230.     plug -> input_mask &= ~plug -> graphic_mask;
  231.     plug -> input_mask |= graphic_mask;
  232.     XSelectInput(dpy, plug -> hook, plug -> input_mask);
  233.     }
  234. #ifdef SHAPE
  235.     /* if the plug is made of a non-rectangular (shaped) pixmap, sets its
  236.      * shape to it...
  237.      */
  238.     if (plug -> graphic -> type == WLPixmap
  239.     && (mask = ((WOOL_Pixmap) (plug -> graphic))->mask)) {
  240.     XShapeCombineMask(dpy, plug -> hook, ShapeBounding, 0, 0,
  241.               mask, ShapeSet);
  242.     } 
  243.     else if (was_shaped) {      /* Was shaped but is no more */
  244.     XShapeCombineMask(dpy, plug -> hook, ShapeBounding, 0, 0,
  245.               None, ShapeSet);
  246.     }
  247. #endif /* SHAPE */
  248.     ReconfigurePlug(plug, plug -> graphic);
  249.     decrease_reference(plug -> tile);
  250.     increase_reference(plug -> tile = (wl_pixmap -> type == WLPixmap
  251.                                        ? wl_pixmap : NIL));
  252. }
  253.  
  254.