home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / evbl0627.zip / everblue_20010627.zip / x11 / Xlib_DrawLine.c < prev    next >
C/C++ Source or Header  |  2001-04-04  |  5KB  |  176 lines
  1.  
  2. #include "Xlib_private.h"
  3. #include <alloca.h>
  4.  
  5. int XSetLineAttributes(Display* display, GC gc, unsigned int line_width,
  6.     int line_style, int cap_style, int join_style)
  7. {
  8.     DBUG_ENTER("XSetLineAttributes")
  9.     HPS hps;
  10.     Xlib_GC *xgc = (Xlib_GC *)gc;
  11.     if (!xgc) DBUG_RETURN(False);
  12.     xgc->values.join_style = join_style;
  13.     xgc->values.cap_style = cap_style;
  14.     xgc->values.line_style = line_style;
  15.     xgc->values.line_width = line_width;
  16.     if (GetDrawableHeight(0, gc, &hps, GC_NOPATH)) {
  17.         GpiSetLineJoin(hps, JoinStyletoLineJoin[join_style]);
  18.         GpiSetLineEnd(hps, CapStyletoLineEnd[cap_style]);
  19.         GpiSetLineType(hps, LineStyletoLineType[line_style]);
  20.         GpiSetLineWidthGeom(hps, line_width);
  21.     }
  22.     DBUG_RETURN(True);
  23. }
  24.  
  25. int XSetFunction (dpy, gc, function)
  26. register Display *dpy;
  27. GC gc;
  28. int function;
  29. {
  30.     DBUG_ENTER("XSetFunction")
  31.     HPS hps;
  32.     Xlib_GC *xgc = (Xlib_GC *)gc;
  33.     if (!xgc) DBUG_RETURN(False);
  34.     LockDisplay(dpy);
  35.     if (xgc->values.function != function) {
  36.         xgc->values.function = function;
  37.         if (GetDrawableHeight(0, gc, &hps, GC_NOPATH)) {
  38.             GpiSetMix(hps, GXtoMixMode[function]);
  39.             GpiSetBackMix(hps, GXtoMixMode[function]);
  40.         }
  41.     }
  42.     UnlockDisplay(dpy);
  43.     SyncHandle();
  44.     DBUG_RETURN(1);
  45. }
  46.  
  47. int XDrawLine(Display* display, Drawable d, GC gc, int x1, int y1, int x2, int y2)
  48. {
  49.     DBUG_ENTER("XDrawLine")
  50.     HPS hps;
  51.     POINTL ptl;
  52.     Xlib_GC *xgc = (Xlib_GC *)gc;
  53.     int viewheight = GetDrawableHeight(d, gc, &hps, GC_STROKEPATH);
  54.     if (!viewheight) DBUG_RETURN(False);
  55.     Xlib_SetGC(hps, xgc);
  56.     ptl.x = x1; ptl.y = viewheight - y1;
  57.     GpiMove(hps, &ptl);
  58.     ptl.x = x2; ptl.y = viewheight - y2;
  59.     GpiLine(hps, &ptl);
  60.     DBUG_RETURN(True);
  61. }
  62.  
  63. int XDrawLines(Display* display, Drawable d, GC gc, XPoint* points, int npoints, int mode)
  64. {
  65.     DBUG_ENTER("XDrawLines")
  66.     HPS hps;
  67.     POINTL *pptl;
  68.     Xlib_GC *xgc = (Xlib_GC *)gc;
  69.     int i = 1;
  70.     int viewheight;
  71.     if (!npoints || !points || !(pptl = alloca(sizeof(POINTL) * npoints)) ||
  72.         !(viewheight = GetDrawableHeight(d, gc, &hps, GC_STROKEPATH))) DBUG_RETURN(False);
  73.     Xlib_SetGC(hps, xgc);
  74.     for (i = 0; i<npoints; i++) {
  75.         pptl[i].x = points[i].x;
  76.         pptl[i].y = viewheight - points[i].y;
  77.     }
  78.     GpiMove(hps, pptl);
  79.     GpiPolyLine(hps, npoints, pptl);
  80.     DBUG_RETURN(True);
  81. }
  82.  
  83. int XDrawSegments(Display* display, Drawable d, GC gc, XSegment* segments, int nsegments)
  84. {
  85.     DBUG_ENTER("XDrawSegments")
  86.     HPS hps;
  87.     POINTL ptl;
  88.     Xlib_GC *xgc = (Xlib_GC *)gc;
  89.     int i = 0;
  90.     int viewheight = GetDrawableHeight(d, gc, &hps, GC_STROKEPATH);
  91.     if (!viewheight || !nsegments || !segments) DBUG_RETURN(False);
  92.     Xlib_SetGC(hps, xgc);
  93.     while (i < nsegments) {
  94.         ptl.x = segments->x1; ptl.y = viewheight - segments->y1;
  95.         GpiMove(hps, &ptl);
  96.         ptl.x = segments->x2; ptl.y = viewheight - segments->y2;
  97.         GpiLine(hps, &ptl);
  98.         i++; segments++;
  99.     }
  100.     DBUG_RETURN(True);
  101. }
  102.  
  103. int XDrawRectangle(Display* display, Drawable d, GC gc, int x, int y, 
  104.         unsigned int width, unsigned int height)
  105. {
  106.     DBUG_ENTER("XDrawRectangle")
  107.     HPS hps;
  108.     POINTL ptl;
  109.     Xlib_GC *xgc = (Xlib_GC *)gc;
  110.     int viewheight = GetDrawableHeight(d, gc, &hps, GC_STROKEPATH);
  111.     if (!viewheight) DBUG_RETURN(False);
  112.     Xlib_SetGC(hps, xgc);
  113.     ptl.x = x; 
  114.     ptl.y = viewheight - y;
  115.     GpiMove(hps, &ptl);
  116.     ptl.x += width; 
  117.     ptl.y -= height;
  118.     GpiBox(hps, DRO_OUTLINE, &ptl, 0, 0);
  119.     DBUG_RETURN(True);
  120. }
  121.  
  122. int XDrawRectangles(Display* display, Drawable d, GC gc, XRectangle* rectangles, int nrectangles)
  123. {
  124.     DBUG_ENTER("XDrawRectangles")
  125.     HPS hps;
  126.     POINTL ptl;
  127.     Xlib_GC *xgc = (Xlib_GC *)gc;
  128.     int i = 0;
  129.     int viewheight = GetDrawableHeight(d, gc, &hps, GC_STROKEPATH);
  130.     if (!viewheight || !nrectangles || !rectangles) DBUG_RETURN(False);
  131.     Xlib_SetGC(hps, xgc);
  132.     while (i < nrectangles) {
  133.         ptl.x = rectangles->x; 
  134.         ptl.y = viewheight - rectangles->y;
  135.         GpiMove(hps, &ptl);
  136.         ptl.x += rectangles->width; 
  137.         ptl.y -= rectangles->height;
  138.         GpiBox(hps, DRO_OUTLINE, &ptl, 0, 0);
  139.         i++; rectangles++;
  140.     }
  141.     DBUG_RETURN(True);
  142. }
  143.  
  144. int XDrawPoint(Display* display, Drawable d, GC gc, int x, int y)
  145. {
  146.     DBUG_ENTER("XDrawPoint")
  147.     HPS hps;
  148.     POINTL ptl;
  149.     Xlib_GC *xgc = (Xlib_GC *)gc;
  150.     int viewheight = GetDrawableHeight(d, gc, &hps, GC_NOPATH);
  151.     if (!viewheight) DBUG_RETURN(False);
  152.     Xlib_SetGC(hps, xgc);
  153.     ptl.x = x; ptl.y = viewheight - y;
  154.     GpiSetPel(hps, &ptl);
  155.     DBUG_RETURN(True);
  156. }
  157.  
  158. int XDrawPoints(Display* display, Drawable d, GC gc, XPoint* points, int npoints, int mode)
  159. {
  160.     DBUG_ENTER("XDrawPoints")
  161.     HPS hps;
  162.     POINTL ptl;
  163.     Xlib_GC *xgc = (Xlib_GC *)gc;
  164.     int i = 0;
  165.     int viewheight = GetDrawableHeight(d, gc, &hps, GC_NOPATH);
  166.     if (!viewheight || !npoints || !points) DBUG_RETURN(False);
  167.     Xlib_SetGC(hps, xgc);
  168.     while (i < npoints) {
  169.         ptl.x = points->x; 
  170.         ptl.y = viewheight - points->y;
  171.         GpiSetPel(hps, &ptl);
  172.         i++; points++;
  173.     }
  174.     DBUG_RETURN(True);
  175. }
  176.