home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / evbl0627.zip / everblue_20010627.zip / x11 / Xlib_CreateGC.c < prev    next >
C/C++ Source or Header  |  2001-05-21  |  9KB  |  255 lines
  1.  
  2. #include "Xlib_private.h"
  3.  
  4. int Xlib_SetFont(Pixmap, Font);
  5. int Xlib_SetStipple(Pixmap, Pixmap);
  6.  
  7. GC XCreateGC(Display* display, Drawable d, unsigned long valuemask, XGCValues* values)
  8. {
  9.         DBUG_ENTER("XCreateGC")
  10.         WinAttribData *attrib = WinQueryWindowPtr(d, QWP_WINATTRIB);
  11.         Xlib_GC *xgc;
  12.         Pixmap atom_pixmap = None;
  13.         int i;
  14.  
  15.         if (!(xgc = calloc(1,sizeof(Xlib_GC))))
  16.                 DBUG_RETURN((GC)0L);
  17.  
  18.         if (attrib) {
  19.                 (HPS)xgc->gid = attrib->hps;
  20.                 xgc->winattrib = attrib;
  21.                 atom_pixmap = (Pixmap)attrib;
  22.         } else
  23.         if ((HWND)d == hwndDesktop)
  24.             (HPS)xgc->gid = WinGetScreenPS(hwndDesktop);
  25.         else
  26.         if (d) {
  27.                 xgc->pixmap = (Xlib_Pixmap *)d;
  28.                 (HPS)xgc->gid = xgc->pixmap->hps;
  29.                 atom_pixmap = (Pixmap)d;
  30.         } else {
  31.                 free(xgc);
  32.                 DBUG_RETURN((GC)0L);
  33.         }
  34.  
  35.         xgc->values.function = GXcopy;
  36.         xgc->values.plane_mask = (unsigned long)0xffffffffL;
  37.         xgc->values.foreground = 0;
  38.         xgc->values.background = 0x00FFFFFF;
  39.         xgc->values.line_width = 1;
  40.         xgc->values.line_style = LineSolid;
  41.         xgc->values.cap_style = CapButt;
  42.         xgc->values.join_style = JoinMiter;
  43.         xgc->values.fill_style = FillSolid;
  44.         xgc->values.fill_rule = EvenOddRule;
  45.         xgc->values.arc_mode = ArcPieSlice;
  46.         xgc->values.subwindow_mode = ClipByChildren;
  47.         xgc->values.graphics_exposures = TRUE;
  48.  
  49.         /*GpiSetPattern(hps, PATSYM_SOLID);*/
  50.  
  51.         if (values && valuemask) {
  52.                 if (valuemask & GCFunction) xgc->values.function = values->function;
  53.                 if (valuemask & GCForeground) xgc->values.foreground = values->foreground;
  54.                 if (valuemask & GCBackground) xgc->values.background = values->background;
  55.                 if (valuemask & GCLineWidth) xgc->values.line_width = values->line_width;
  56.                 if (valuemask & GCLineStyle) xgc->values.line_style = values->line_style;
  57.                 if (valuemask & GCCapStyle)  xgc->values.cap_style  = values->cap_style;
  58.                 if (valuemask & GCJoinStyle) xgc->values.join_style = values->join_style;
  59.                 if (valuemask & GCFillStyle) xgc->values.fill_style = values->fill_style;
  60.                 if (valuemask & GCFillRule)  xgc->values.fill_rule  = values->fill_rule;
  61.                 if (valuemask & GCFont)      xgc->values.font       = values->font;
  62.                 if (valuemask & GCArcMode)   xgc->values.arc_mode   = values->arc_mode;
  63.                 if (valuemask & GCStipple)   xgc->values.stipple    = values->stipple;
  64.         }
  65.  
  66.         if (xgc->values.font) {
  67.                 Xlib_MonitorResource((XID *)&xgc->values.font);
  68.                 if (atom_pixmap) Xlib_SetFont(atom_pixmap, xgc->values.font);
  69.         }
  70.         if (xgc->values.stipple) {
  71.                 Xlib_MonitorResource((XID *)&xgc->values.stipple);
  72.                 if (atom_pixmap) Xlib_SetStipple(atom_pixmap, xgc->values.stipple);
  73.         }
  74.  
  75.         for (i=0; (i<1024) && GCList[i]; i++);
  76.         GCList[i] = (GC) xgc;
  77.  
  78.         DBUG_RETURN((GC) xgc);
  79. }
  80.  
  81.  
  82. int XFlush(Display* display)
  83. {
  84.         DBUG_ENTER("XFlush")
  85.         int i;
  86.         for (i=0; i<1024; i++) XFlushGC(display, GCList[i]);
  87.         DBUG_RETURN(True);
  88. }
  89.  
  90. void _XPurgeGC(Display* display, GC gc)
  91. {
  92.         DBUG_ENTER("_XPurgeGC")
  93.         Xlib_GC *xgc = (Xlib_GC *)gc;
  94.         if (xgc && xgc->path != GC_NOPATH) {
  95.                 GpiEndPath((HPS)xgc->gid);
  96.                 xgc->path = GC_NOPATH;
  97.         }
  98.         DBUG_VOID_RETURN;
  99. }
  100.  
  101. void XFlushGC(Display* display, GC gc)
  102. {
  103.         DBUG_ENTER("XFlushGC")
  104.         Xlib_GC *xgc = (Xlib_GC *)gc;
  105.         if (!xgc) DBUG_VOID_RETURN;
  106.         switch (xgc->path) {
  107.         case GC_FILLPATH:
  108.                 GpiEndPath((HPS)xgc->gid);
  109.                 GpiFillPath((HPS)xgc->gid, 1L, xgc->values.fill_rule == WindingRule ?
  110.                         FPATH_WINDING : FPATH_ALTERNATE );
  111.                 break;
  112.         case GC_STROKEPATH:
  113.                 GpiEndPath((HPS)xgc->gid);
  114.                 GpiStrokePath((HPS)xgc->gid, 1L, 0);
  115.                 break;
  116.         case GC_AREAFILL:
  117.                 GpiEndArea((HPS)xgc->gid);
  118.                 break;
  119.         }
  120.         xgc->path = GC_NOPATH;
  121.         DBUG_VOID_RETURN;
  122. }
  123.  
  124. int XFreeGC(Display* dpy, GC gc)
  125. {
  126.         DBUG_ENTER("XFreeGC")
  127.         Xlib_GC *xgc = (Xlib_GC *)gc;
  128.         _XExtension *ext;
  129.         int i;
  130.         if (!gc) DBUG_RETURN(False);
  131.         LockDisplay(dpy);
  132.         /* call out to any extensions interested */
  133.         for (ext = dpy->ext_procs; ext; ext = ext->next)
  134.                 if (ext->free_GC) (*ext->free_GC)(dpy, gc, &ext->codes);
  135.         XFlushGC(dpy, gc);
  136.         for (i=0; (i<1024) && GCList[i] != gc; i++);
  137.         GCList[i] = (GC)0L;
  138.         if (xgc->winattrib && xgc->winattrib->currentGC==gc)
  139.                 xgc->winattrib->currentGC = (GC)0L;
  140.         if (xgc->pixmap && xgc->pixmap->currentGC==gc)
  141.                 xgc->pixmap->currentGC = (GC)0L;
  142.         UnlockDisplay(dpy);
  143.         SyncHandle();
  144.         _XFreeExtData(gc->ext_data);
  145.         Xlib_UnmonitorResource((XID *)&xgc->values.font);
  146.         Xlib_UnmonitorResource((XID *)&xgc->values.stipple);
  147.         Xfree((char *) gc);
  148.         DBUG_RETURN(1);
  149. }
  150.  
  151. int XSetForeground(Display* display, GC gc, unsigned long foreground)
  152. {
  153.         DBUG_ENTER("XSetForeground")
  154.         HPS hps;
  155.         Xlib_GC *xgc = (Xlib_GC *)gc;
  156.         if (!xgc) DBUG_RETURN(False);
  157.         xgc->values.foreground = foreground;
  158.         if (!GetDrawableHeight(0, gc, &hps, GC_NOPATH)) return FALSE;
  159.         GpiSetColor(hps, foreground);
  160.         DBUG_RETURN(True);
  161. }
  162.  
  163. int XSetBackground(Display* display, GC gc, unsigned long background)
  164. {
  165.         DBUG_ENTER("XSetBackground")
  166.         HPS hps;
  167.         Xlib_GC *xgc = (Xlib_GC *)gc;
  168.         if (!xgc) DBUG_RETURN(False);
  169.         xgc->values.background = background;
  170.         if (!GetDrawableHeight(0, gc, &hps, GC_NOPATH)) return FALSE;
  171.         GpiSetBackColor(hps, background);
  172.         DBUG_RETURN(True);
  173. }
  174.  
  175. int XClearWindow(Display* display, Window w)
  176. {
  177.         DBUG_ENTER("XClearWindow")
  178.         WinAttribData *attrib = WinQueryWindowPtr(w, QWP_WINATTRIB);
  179.         RECTL rectl;
  180.         if (attrib) {
  181.                 if (attrib->currentGC) _XPurgeGC(display, attrib->currentGC);
  182.                 rectl.xLeft = 0; rectl.yBottom = 0;
  183.                 rectl.xRight = attrib->winattrib.width;
  184.                 rectl.yTop = attrib->winattrib.height;
  185.                 WinFillRect(attrib->hps, &rectl, attrib->background_pixel);
  186.                 DBUG_RETURN(True);
  187.         }
  188.         DBUG_RETURN(False);
  189. }
  190.  
  191. int XClearArea(Display* display, Window w, int x, int y,
  192.                 unsigned int width, unsigned int height, Bool exposures)
  193. {
  194.         DBUG_ENTER("XClearArea")
  195.         WinAttribData *attrib = WinQueryWindowPtr(w, QWP_WINATTRIB);
  196.         RECTL rectl;
  197.         if (attrib) {
  198.                 if (attrib->currentGC) XFlushGC(display, attrib->currentGC);
  199.                 if (!width) width = attrib->winattrib.width - x;
  200.                 if (!height) height = attrib->winattrib.height - y;
  201.                 rectl.xLeft = x;
  202.                 rectl.xRight = x + width;
  203.                 rectl.yTop = attrib->winattrib.height - y;
  204.                 rectl.yBottom = rectl.yTop - height;
  205.                 WinFillRect(attrib->hps, &rectl, attrib->background_pixel);
  206.                 DBUG_RETURN(True);
  207.         }
  208.         DBUG_RETURN(False);
  209. }
  210.  
  211. int XFillRectangle(Display* display, Drawable d, GC gc, int x, int y,
  212.                 unsigned int width, unsigned int height)
  213. {
  214.         DBUG_ENTER("XFillRectangle")
  215.         HPS hps;
  216.         POINTL ptl;
  217.         Xlib_GC *xgc = (Xlib_GC *)gc;
  218.         int rc;
  219.         int viewheight = GetDrawableHeight(d, gc, &hps, GC_NOPATH);
  220.         if (!viewheight) DBUG_RETURN(False);
  221.         Xlib_SetGC(hps, xgc);
  222.         ptl.x = x; ptl.y = viewheight - y;
  223.         rc = GpiMove(hps, &ptl);
  224.         ptl.x += width; ptl.y -= height;
  225.         rc |= GpiBox(hps, DRO_FILL, &ptl, 0, 0);
  226.         if(rc == GPI_OK)
  227.                 DBUG_RETURN(True);
  228.         DBUG_RETURN(False);
  229. }
  230.  
  231. int XFillRectangles(Display* display, Drawable d, GC gc, XRectangle* rectangles, int nrectangles)
  232. {
  233.         DBUG_ENTER("XFillRectangles")
  234.         HPS hps;
  235.         POINTL ptl;
  236.         Xlib_GC *xgc = (Xlib_GC *)gc;
  237.         int rc = 0;
  238.         int i = 0, viewheight = GetDrawableHeight(d, gc, &hps, GC_NOPATH);
  239.         if (!viewheight || !nrectangles || !rectangles) DBUG_RETURN(False);
  240.         Xlib_SetGC(hps, xgc);
  241. /*      GpiCreateLogColorTable(hps, LCOL_RESET, LCOLF_RGB, 0, 0, NULL); */
  242.         while (i < nrectangles) {
  243.                 ptl.x = rectangles->x; ptl.y = viewheight - rectangles->y;
  244.                 rc |= GpiMove(hps, &ptl);
  245.                 ptl.x += rectangles->width; ptl.y -= rectangles->height;
  246.                 rc |= GpiBox(hps, DRO_FILL, &ptl, 0, 0);
  247.                 i++; rectangles++;
  248.         }
  249.         if(rc == GPI_OK)
  250.                 DBUG_RETURN(True);
  251.         DBUG_RETURN(False);
  252. }
  253.  
  254.  
  255.