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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 通讯编程 > 查看源码
tkMacDraw.c
资源名称：ns-allinone-2.33.tar.gz　[点击查看]
上传用户：rrhhcc
上传日期：2015-12-11
资源大小：54129k
文件大小：31k
源码类别：

通讯编程

开发平台：

Visual C++

tkMacDraw.c：源码内容
  1. /* 
  2.  * tkMacDraw.c --
  3.  *
  4.  * This file contains functions that preform drawing to
  5.  * Xlib windows.  Most of the functions simple emulate
  6.  * Xlib functions.
  7.  *
  8.  * Copyright (c) 1995-1997 Sun Microsystems, Inc.
  9.  *
  10.  * See the file "license.terms" for information on usage and redistribution
  11.  * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
  12.  *
  13.  * RCS: @(#) $Id: tkMacDraw.c,v 1.9.2.1 2005/07/28 04:57:38 hobbs Exp $
  14.  */
  16. #include "tkInt.h"
  17. #include "X.h"
  18. #include "Xlib.h"
  19. #include <stdio.h>
  20. #include <tcl.h>
  22. #include <Windows.h>
  23. #include <Fonts.h>
  24. #include <QDOffscreen.h>
  25. #include "tkMacInt.h"
  26. #include "tkPort.h"
  28. #ifndef PI
  29. #    define PI 3.14159265358979323846
  30. #endif
  32. /*
  33.  * Temporary regions that can be reused.
  34.  */
  35. static RgnHandle tmpRgn = NULL;
  36. static RgnHandle tmpRgn2 = NULL;
  38. static PixPatHandle gPenPat = NULL;
  40. /*
  41.  * Prototypes for functions used only in this file.
  42.  */
  43. static unsigned char    InvertByte _ANSI_ARGS_((unsigned char data));
  45. /*
  46.  *----------------------------------------------------------------------
  47.  *
  48.  * XCopyArea --
  49.  *
  50.  * Copies data from one drawable to another using block transfer
  51.  * routines.
  52.  *
  53.  * Results:
  54.  * None.
  55.  *
  56.  * Side effects:
  57.  * Data is moved from a window or bitmap to a second window or
  58.  * bitmap.
  59.  *
  60.  *----------------------------------------------------------------------
  61.  */
  63. void 
  64. XCopyArea(
  65.     Display* display, /* Display. */
  66.     Drawable src, /* Source drawable. */
  67.     Drawable dest, /* Destination drawable. */
  68.     GC gc, /* GC to use. */
  69.     int src_x, /* X & Y, width & height */
  70.     int src_y, /* define the source rectangle */
  71.     unsigned int width, /* the will be copied. */
  72.     unsigned int height,
  73.     int dest_x, /* Dest X & Y on dest rect. */
  74.     int dest_y)
  75. {
  76.     Rect srcRect, destRect;
  77.     BitMapPtr srcBit, destBit;
  78.     MacDrawable *srcDraw = (MacDrawable *) src;
  79.     MacDrawable *destDraw = (MacDrawable *) dest;
  80.     GWorldPtr srcPort, destPort;
  81.     CGrafPtr saveWorld;
  82.     GDHandle saveDevice;
  83.     short tmode;
  84.     RGBColor origForeColor, origBackColor, whiteColor, blackColor;
  86.     destPort = TkMacGetDrawablePort(dest);
  87.     srcPort = TkMacGetDrawablePort(src);
  89.     display->request++;
  90.     GetGWorld(&saveWorld, &saveDevice);
  91.     SetGWorld(destPort, NULL);
  92.     GetForeColor(&origForeColor);
  93.     GetBackColor(&origBackColor);
  94.     whiteColor.red = 0;
  95.     whiteColor.blue = 0;
  96.     whiteColor.green = 0;
  97.     RGBForeColor(&whiteColor);
  98.     blackColor.red = 0xFFFF;
  99.     blackColor.blue = 0xFFFF;
  100.     blackColor.green = 0xFFFF;
  101.     RGBBackColor(&blackColor);
  102.     
  104.     TkMacSetUpClippingRgn(dest);
  105.     
  106.     /*
  107.      *  We will change the clip rgn in this routine, so we need to 
  108.      *  be able to restore it when we exit.
  109.      */
  110.      
  111.     if (tmpRgn2 == NULL) {
  112.         tmpRgn2 = NewRgn();
  113.     }
  114.     GetClip(tmpRgn2);
  116.     if (((TkpClipMask*)gc->clip_mask)->type == TKP_CLIP_REGION) {
  117. RgnHandle clipRgn = (RgnHandle)
  118.         ((TkpClipMask*)gc->clip_mask)->value.region;
  120. int xOffset, yOffset;
  122. if (tmpRgn == NULL) {
  123.     tmpRgn = NewRgn();
  124. }
  126. xOffset = destDraw->xOff + gc->clip_x_origin;
  127. yOffset = destDraw->yOff + gc->clip_y_origin;
  129. OffsetRgn(clipRgn, xOffset, yOffset);
  131. GetClip(tmpRgn);
  132. SectRgn(tmpRgn, clipRgn, tmpRgn);
  134. SetClip(tmpRgn);
  136. OffsetRgn(clipRgn, -xOffset, -yOffset);
  137.     }
  138.     
  139.     srcBit = &((GrafPtr) srcPort)->portBits;
  140.     destBit = &((GrafPtr) destPort)->portBits;
  141.     SetRect(&srcRect, (short) (srcDraw->xOff + src_x),
  142.     (short) (srcDraw->yOff + src_y),
  143.     (short) (srcDraw->xOff + src_x + width),
  144.     (short) (srcDraw->yOff + src_y + height));
  145.     SetRect(&destRect, (short) (destDraw->xOff + dest_x),
  146.     (short) (destDraw->yOff + dest_y), 
  147.     (short) (destDraw->xOff + dest_x + width),
  148.     (short) (destDraw->yOff + dest_y + height));
  149.     tmode = srcCopy;
  151.     CopyBits(srcBit, destBit, &srcRect, &destRect, tmode, NULL);
  152.     RGBForeColor(&origForeColor);
  153.     RGBBackColor(&origBackColor);
  154.     SetClip(tmpRgn2);
  155.     SetGWorld(saveWorld, saveDevice);
  156. }
  158. /*
  159.  *----------------------------------------------------------------------
  160.  *
  161.  * XCopyPlane --
  162.  *
  163.  * Copies a bitmap from a source drawable to a destination
  164.  * drawable.  The plane argument specifies which bit plane of
  165.  * the source contains the bitmap.  Note that this implementation
  166.  * ignores the gc->function.
  167.  *
  168.  * Results:
  169.  * None.
  170.  *
  171.  * Side effects:
  172.  * Changes the destination drawable.
  173.  *
  174.  *----------------------------------------------------------------------
  175.  */
  177. void
  178. XCopyPlane(
  179.     Display* display, /* Display. */
  180.     Drawable src, /* Source drawable. */
  181.     Drawable dest, /* Destination drawable. */
  182.     GC gc, /* The GC to use. */
  183.     int src_x, /* X, Y, width & height */
  184.     int src_y, /* define the source rect. */
  185.     unsigned int width,
  186.     unsigned int height,
  187.     int dest_x, /* X & Y on dest where we will copy. */
  188.     int dest_y,
  189.     unsigned long plane) /* Which plane to copy. */
  190. {
  191.     Rect srcRect, destRect;
  192.     BitMapPtr srcBit, destBit, maskBit;
  193.     MacDrawable *srcDraw = (MacDrawable *) src;
  194.     MacDrawable *destDraw = (MacDrawable *) dest;
  195.     GWorldPtr srcPort, destPort, maskPort;
  196.     CGrafPtr saveWorld;
  197.     GDHandle saveDevice;
  198.     RGBColor macColor; 
  199.     TkpClipMask *clipPtr = (TkpClipMask*)gc->clip_mask;
  200.     short tmode;
  202.     destPort = TkMacGetDrawablePort(dest);
  203.     srcPort = TkMacGetDrawablePort(src);
  204.     
  205.     display->request++;
  206.     GetGWorld(&saveWorld, &saveDevice);
  207.     SetGWorld(destPort, NULL);
  209.     TkMacSetUpClippingRgn(dest);
  211.     srcBit = &((GrafPtr) srcPort)->portBits;
  212.     destBit = &((GrafPtr) destPort)->portBits;
  213.     SetRect(&srcRect, (short) (srcDraw->xOff + src_x),
  214.     (short) (srcDraw->yOff + src_y),
  215.     (short) (srcDraw->xOff + src_x + width),
  216.     (short) (srcDraw->yOff + src_y + height));
  217.     SetRect(&destRect, (short) (destDraw->xOff + dest_x),
  218.     (short) (destDraw->yOff + dest_y), 
  219.     (short) (destDraw->xOff + dest_x + width),
  220.     (short) (destDraw->yOff + dest_y + height));
  221.     tmode = srcOr;
  222.     tmode = srcCopy + transparent;
  224.     if (TkSetMacColor(gc->foreground, &macColor) == true) {
  225. RGBForeColor(&macColor);
  226.     }
  228.     if (clipPtr == NULL || clipPtr->type == TKP_CLIP_REGION) {
  230. /*
  231.  * Case 1: opaque bitmaps.
  232.  */
  234. TkSetMacColor(gc->background, &macColor);
  235. RGBBackColor(&macColor);
  236. tmode = srcCopy;
  237. CopyBits(srcBit, destBit, &srcRect, &destRect, tmode, NULL);
  238.     } else if (clipPtr->type == TKP_CLIP_PIXMAP) {
  239. if (clipPtr->value.pixmap == src) {
  240.     /*
  241.      * Case 2: transparent bitmaps.  If it's color we ignore
  242.      * the forecolor.
  243.      */
  244.     if ((**(srcPort->portPixMap)).pixelSize == 1) {
  245. tmode = srcOr;
  246.     } else {
  247. tmode = transparent;
  248.     }
  249.     CopyBits(srcBit, destBit, &srcRect, &destRect, tmode, NULL);
  250. } else {
  251.     /*
  252.      * Case 3: two arbitrary bitmaps.  
  253.      */
  254.     tmode = srcCopy;
  255.     maskPort = TkMacGetDrawablePort(clipPtr->value.pixmap);
  256.     maskBit = &((GrafPtr) maskPort)->portBits;
  257.     CopyDeepMask(srcBit, maskBit, destBit, &srcRect, &srcRect, &destRect, tmode, NULL);
  258. }
  259.     }
  261.     SetGWorld(saveWorld, saveDevice);
  262. }
  264. /*
  265.  *----------------------------------------------------------------------
  266.  *
  267.  * TkPutImage --
  268.  *
  269.  * Copies a subimage from an in-memory image to a rectangle of
  270.  * of the specified drawable.
  271.  *
  272.  * Results:
  273.  * None.
  274.  *
  275.  * Side effects:
  276.  * Draws the image on the specified drawable.
  277.  *
  278.  *----------------------------------------------------------------------
  279.  */
  281. void 
  282. TkPutImage(
  283.     unsigned long *colors, /* Unused on Macintosh. */
  284.     int ncolors, /* Unused on Macintosh. */
  285.     Display* display, /* Display. */
  286.     Drawable d, /* Drawable to place image on. */
  287.     GC gc, /* GC to use. */
  288.     XImage* image, /* Image to place. */
  289.     int src_x, /* Source X & Y. */
  290.     int src_y,
  291.     int dest_x, /* Destination X & Y. */
  292.     int dest_y,
  293.     unsigned int width, /* Same width & height for both */
  294.     unsigned int height) /* distination and source. */
  295. {
  296.     MacDrawable *destDraw = (MacDrawable *) d;
  297.     CGrafPtr saveWorld;
  298.     GDHandle saveDevice;
  299.     GWorldPtr destPort;
  300.     int i, j;
  301.     BitMap bitmap;
  302.     char *newData = NULL;
  303.     Rect destRect, srcRect;
  305.     destPort = TkMacGetDrawablePort(d);
  306.     SetRect(&destRect, dest_x, dest_y, dest_x + width, dest_y + height);
  307.     SetRect(&srcRect, src_x, src_y, src_x + width, src_y + height);
  309.     display->request++;
  310.     GetGWorld(&saveWorld, &saveDevice);
  311.     SetGWorld(destPort, NULL);
  313.     TkMacSetUpClippingRgn(d);
  315.     if (image->depth == 1) {
  317. /* 
  318.  * This code assumes a pixel depth of 1 
  319.  */
  321. bitmap.bounds.top = bitmap.bounds.left = 0;
  322. bitmap.bounds.right = (short) image->width;
  323. bitmap.bounds.bottom = (short) image->height;
  324. if ((image->bytes_per_line % 2) == 1) {
  325.     char *newPtr, *oldPtr;
  326.     newData = (char *) ckalloc(image->height *
  327.     (image->bytes_per_line + 1));
  328.     newPtr = newData;
  329.     oldPtr = image->data;
  330.     for (i = 0; i < image->height; i++) {
  331. for (j = 0; j < image->bytes_per_line; j++) {
  332.     *newPtr = InvertByte((unsigned char) *oldPtr);
  333.     newPtr++, oldPtr++;
  334. }
  335.     *newPtr = 0;
  336.     newPtr++;
  337.     }
  338.     bitmap.baseAddr = newData;
  339.     bitmap.rowBytes = image->bytes_per_line + 1;
  340. } else {
  341.     newData = (char *) ckalloc(image->height * image->bytes_per_line);
  342.     for (i = 0; i < image->height * image->bytes_per_line; i++) {
  343. newData[i] = InvertByte((unsigned char) image->data[i]);
  344.     }
  345.     bitmap.baseAddr = newData;
  346.     bitmap.rowBytes = image->bytes_per_line;
  347. }
  349. CopyBits(&bitmap, &((GrafPtr) destPort)->portBits, 
  350. &srcRect, &destRect, srcCopy, NULL);
  352.     } else {
  353.      /* Color image */
  354.      PixMap pixmap;
  355.     
  356. pixmap.bounds.left = 0;
  357. pixmap.bounds.top = 0;
  358. pixmap.bounds.right = (short) image->width;
  359. pixmap.bounds.bottom = (short) image->height;
  360. pixmap.pixelType = RGBDirect;
  361. pixmap.pmVersion = 4; /* 32bit clean */
  362. pixmap.packType = 0;
  363. pixmap.packSize = 0;
  364. pixmap.hRes = 0x00480000;
  365. pixmap.vRes = 0x00480000;
  366. pixmap.pixelSize = 32;
  367. pixmap.cmpCount = 3;
  368. pixmap.cmpSize = 8;
  369. pixmap.planeBytes = 0;
  370. pixmap.pmTable = NULL;
  371. pixmap.pmReserved = 0;
  372. pixmap.baseAddr = image->data;
  373.     if (image->bytes_per_line >= 0x4000) {
  374.      panic("TkImage too wide!");
  375.     }
  376. pixmap.rowBytes = image->bytes_per_line | 0x8000;
  378. CopyBits((BitMap *) &pixmap, &((GrafPtr) destPort)->portBits, 
  379.     &srcRect, &destRect, srcCopy, NULL);
  380.     }
  381.     
  382.     if (newData != NULL) {
  383. ckfree(newData);
  384.     }
  385.     SetGWorld(saveWorld, saveDevice);
  386. }
  388. /*
  389.  *----------------------------------------------------------------------
  390.  *
  391.  * XFillRectangles --
  392.  *
  393.  * Fill multiple rectangular areas in the given drawable.
  394.  *
  395.  * Results:
  396.  * None.
  397.  *
  398.  * Side effects:
  399.  * Draws onto the specified drawable.
  400.  *
  401.  *----------------------------------------------------------------------
  402.  */
  404. void 
  405. XFillRectangles(
  406.     Display* display, /* Display. */
  407.     Drawable d, /* Draw on this. */
  408.     GC gc, /* Use this GC. */
  409.     XRectangle *rectangles, /* Rectangle array. */
  410.     int n_rectangels) /* Number of rectangles. */
  411. {
  412.     MacDrawable *macWin = (MacDrawable *) d;
  413.     CGrafPtr saveWorld;
  414.     GDHandle saveDevice;
  415.     GWorldPtr destPort;
  416.     Rect theRect;
  417.     int i;
  419.     destPort = TkMacGetDrawablePort(d);
  421.     display->request++;
  422.     GetGWorld(&saveWorld, &saveDevice);
  423.     SetGWorld(destPort, NULL);
  425.     TkMacSetUpClippingRgn(d);
  427.     TkMacSetUpGraphicsPort(gc);
  429.     for (i=0; i<n_rectangels; i++) {
  430. theRect.left = (short) (macWin->xOff + rectangles[i].x);
  431. theRect.top = (short) (macWin->yOff + rectangles[i].y);
  432. theRect.right = (short) (theRect.left + rectangles[i].width);
  433. theRect.bottom = (short) (theRect.top + rectangles[i].height);
  434. FillCRect(&theRect, gPenPat);
  435.     }
  437.     SetGWorld(saveWorld, saveDevice);
  438. }
  440. /*
  441.  *----------------------------------------------------------------------
  442.  *
  443.  * XDrawLines --
  444.  *
  445.  * Draw connected lines.
  446.  *
  447.  * Results:
  448.  * None.
  449.  *
  450.  * Side effects:
  451.  * Renders a series of connected lines.
  452.  *
  453.  *----------------------------------------------------------------------
  454.  */
  456. void 
  457. XDrawLines(
  458.     Display* display, /* Display. */
  459.     Drawable d, /* Draw on this. */
  460.     GC gc, /* Use this GC. */
  461.     XPoint* points, /* Array of points. */
  462.     int npoints, /* Number of points. */
  463.     int mode) /* Line drawing mode. */
  464. {
  465.     MacDrawable *macWin = (MacDrawable *) d;
  466.     CGrafPtr saveWorld;
  467.     GWorldPtr destPort;
  468.     GDHandle saveDevice;
  469.     int i;
  471.     destPort = TkMacGetDrawablePort(d);
  473.     display->request++;
  474.     if (npoints < 2) {
  475.      return;  /* TODO: generate BadValue error. */
  476.     }
  477.     GetGWorld(&saveWorld, &saveDevice);
  478.     SetGWorld(destPort, NULL);
  479.     
  480.     TkMacSetUpClippingRgn(d);
  482.     TkMacSetUpGraphicsPort(gc);
  484.     ShowPen();
  486.     PenPixPat(gPenPat);
  487.     MoveTo((short) (macWin->xOff + points[0].x),
  488.     (short) (macWin->yOff + points[0].y));
  489.     for (i = 1; i < npoints; i++) {
  490. if (mode == CoordModeOrigin) {
  491.     LineTo((short) (macWin->xOff + points[i].x),
  492.     (short) (macWin->yOff + points[i].y));
  493. } else {
  494.     Line((short) (macWin->xOff + points[i].x),
  495.     (short) (macWin->yOff + points[i].y));
  496. }
  497.     }
  499.     SetGWorld(saveWorld, saveDevice);
  500. }
  502. /*
  503.  *----------------------------------------------------------------------
  504.  *
  505.  * XDrawSegments --
  506.  *
  507.  * Draw unconnected lines.
  508.  *
  509.  * Results:
  510.  * None.
  511.  *
  512.  * Side effects:
  513.  * Renders a series of connected lines.
  514.  *
  515.  *----------------------------------------------------------------------
  516.  */
  518. void XDrawSegments(
  519.     Display *display,
  520.     Drawable  d,
  521.     GC gc,
  522.     XSegment *segments,
  523.     int  nsegments)
  524. {
  525.     MacDrawable *macWin = (MacDrawable *) d;
  526.     CGrafPtr saveWorld;
  527.     GWorldPtr destPort;
  528.     GDHandle saveDevice;
  529.     int i;
  531.     destPort = TkMacGetDrawablePort(d);
  533.     display->request++;
  535.     GetGWorld(&saveWorld, &saveDevice);
  536.     SetGWorld(destPort, NULL);
  537.     
  538.     TkMacSetUpClippingRgn(d);
  540.     TkMacSetUpGraphicsPort(gc);
  542.     ShowPen();
  544.     PenPixPat(gPenPat);
  545.     for (i = 0; i < nsegments; i++) {
  546.         MoveTo((short) (macWin->xOff + segments[i].x1),
  547.         (short) (macWin->yOff + segments[i].y1));
  548. LineTo((short) (macWin->xOff + segments[i].x2),
  549. (short) (macWin->yOff + segments[i].y2));
  550.     }
  552.     SetGWorld(saveWorld, saveDevice);
  553. }
  555. /*
  556.  *----------------------------------------------------------------------
  557.  *
  558.  * XFillPolygon --
  559.  *
  560.  * Draws a filled polygon.
  561.  *
  562.  * Results:
  563.  * None.
  564.  *
  565.  * Side effects:
  566.  * Draws a filled polygon on the specified drawable.
  567.  *
  568.  *----------------------------------------------------------------------
  569.  */
  571. void 
  572. XFillPolygon(
  573.     Display* display, /* Display. */
  574.     Drawable d, /* Draw on this. */
  575.     GC gc, /* Use this GC. */
  576.     XPoint* points, /* Array of points. */
  577.     int npoints, /* Number of points. */
  578.     int shape, /* Shape to draw. */
  579.     int mode) /* Drawing mode. */
  580. {
  581.     MacDrawable *macWin = (MacDrawable *) d;
  582.     PolyHandle polygon;
  583.     CGrafPtr saveWorld;
  584.     GDHandle saveDevice;
  585.     GWorldPtr destPort;
  586.     int i;
  588.     destPort = TkMacGetDrawablePort(d);
  590.     display->request++;
  591.     GetGWorld(&saveWorld, &saveDevice);
  592.     SetGWorld(destPort, NULL);
  594.     TkMacSetUpClippingRgn(d);
  595.     
  596.     TkMacSetUpGraphicsPort(gc);
  598.     PenNormal();
  599.     polygon = OpenPoly();
  601.     MoveTo((short) (macWin->xOff + points[0].x),
  602.     (short) (macWin->yOff + points[0].y));
  603.     for (i = 1; i < npoints; i++) {
  604. if (mode == CoordModePrevious) {
  605.     Line((short) (macWin->xOff + points[i].x),
  606.     (short) (macWin->yOff + points[i].y));
  607. } else {
  608.     LineTo((short) (macWin->xOff + points[i].x),
  609.     (short) (macWin->yOff + points[i].y));
  610. }
  611.     }
  613.     ClosePoly();
  615.     FillCPoly(polygon, gPenPat);
  617.     KillPoly(polygon);
  618.     SetGWorld(saveWorld, saveDevice);
  619. }
  621. /*
  622.  *----------------------------------------------------------------------
  623.  *
  624.  * XDrawRectangle --
  625.  *
  626.  * Draws a rectangle.
  627.  *
  628.  * Results:
  629.  * None.
  630.  *
  631.  * Side effects:
  632.  * Draws a rectangle on the specified drawable.
  633.  *
  634.  *----------------------------------------------------------------------
  635.  */
  637. void 
  638. XDrawRectangle(
  639.     Display* display, /* Display. */
  640.     Drawable d, /* Draw on this. */
  641.     GC gc, /* Use this GC. */
  642.     int x, /* Upper left corner. */
  643.     int y,
  644.     unsigned int width, /* Width & height of rect. */
  645.     unsigned int height)
  646. {
  647.     MacDrawable *macWin = (MacDrawable *) d;
  648.     Rect theRect;
  649.     CGrafPtr saveWorld;
  650.     GDHandle saveDevice;
  651.     GWorldPtr destPort;
  653.     destPort = TkMacGetDrawablePort(d);
  655.     display->request++;
  656.     GetGWorld(&saveWorld, &saveDevice);
  657.     SetGWorld(destPort, NULL);
  659.     TkMacSetUpClippingRgn(d);
  661.     TkMacSetUpGraphicsPort(gc);
  663.     theRect.left = (short) (macWin->xOff + x);
  664.     theRect.top = (short) (macWin->yOff + y);
  665.     theRect.right = (short) (theRect.left + width);
  666.     theRect.bottom = (short) (theRect.top + height);
  668.     ShowPen();
  669.     PenPixPat(gPenPat);
  670.     FrameRect(&theRect);
  672.     SetGWorld(saveWorld, saveDevice);
  673. }
  675. /*
  676.  *----------------------------------------------------------------------
  677.  *
  678.  * XDrawArc --
  679.  *
  680.  * Draw an arc.
  681.  *
  682.  * Results:
  683.  * None.
  684.  *
  685.  * Side effects:
  686.  * Draws an arc on the specified drawable.
  687.  *
  688.  *----------------------------------------------------------------------
  689.  */
  691. void 
  692. XDrawArc(
  693.     Display* display, /* Display. */
  694.     Drawable d, /* Draw on this. */
  695.     GC gc, /* Use this GC. */
  696.     int x, /* Upper left of */
  697.     int y, /* bounding rect. */
  698.     unsigned int width, /* Width & height. */
  699.     unsigned int height,
  700.     int angle1, /* Staring angle of arc. */
  701.     int angle2) /* Ending angle of arc. */
  702. {
  703.     MacDrawable *macWin = (MacDrawable *) d;
  704.     Rect theRect;
  705.     short start, extent;
  706.     CGrafPtr saveWorld;
  707.     GDHandle saveDevice;
  708.     GWorldPtr destPort;
  710.     destPort = TkMacGetDrawablePort(d);
  712.     display->request++;
  713.     GetGWorld(&saveWorld, &saveDevice);
  714.     SetGWorld(destPort, NULL);
  716.     TkMacSetUpClippingRgn(d);
  718.     TkMacSetUpGraphicsPort(gc);
  720.     theRect.left = (short) (macWin->xOff + x);
  721.     theRect.top = (short) (macWin->yOff + y);
  722.     theRect.right = (short) (theRect.left + width);
  723.     theRect.bottom = (short) (theRect.top + height);
  724.     start = (short) (90 - (angle1 / 64));
  725.     extent = (short) (-(angle2 / 64));
  727.     ShowPen();
  728.     PenPixPat(gPenPat);
  729.     FrameArc(&theRect, start, extent);
  731.     SetGWorld(saveWorld, saveDevice);
  732. }
  734. /*
  735.  *----------------------------------------------------------------------
  736.  *
  737.  * XFillArc --
  738.  *
  739.  * Draw a filled arc.
  740.  *
  741.  * Results:
  742.  * None.
  743.  *
  744.  * Side effects:
  745.  * Draws a filled arc on the specified drawable.
  746.  *
  747.  *----------------------------------------------------------------------
  748.  */
  750. void
  751. XFillArc(
  752.     Display* display, /* Display. */
  753.     Drawable d, /* Draw on this. */
  754.     GC gc, /* Use this GC. */
  755.     int x, /* Upper left of */
  756.     int y, /* bounding rect. */
  757.     unsigned int width, /* Width & height. */
  758.     unsigned int height,
  759.     int angle1, /* Staring angle of arc. */
  760.     int angle2) /* Ending angle of arc. */
  761. {
  762.     MacDrawable *macWin = (MacDrawable *) d;
  763.     Rect theRect;
  764.     short start, extent;
  765.     PolyHandle polygon;
  766.     double sin1, cos1, sin2, cos2, angle;
  767.     double boxWidth, boxHeight;
  768.     double vertex[2], center1[2], center2[2];
  769.     CGrafPtr saveWorld;
  770.     GDHandle saveDevice;
  771.     GWorldPtr destPort;
  773.     destPort = TkMacGetDrawablePort(d);
  775.     display->request++;
  776.     GetGWorld(&saveWorld, &saveDevice);
  777.     SetGWorld(destPort, NULL);
  779.     TkMacSetUpClippingRgn(d);
  781.     TkMacSetUpGraphicsPort(gc);
  783.     theRect.left = (short) (macWin->xOff + x);
  784.     theRect.top = (short) (macWin->yOff + y);
  785.     theRect.right = (short) (theRect.left + width);
  786.     theRect.bottom = (short) (theRect.top + height);
  787.     start = (short) (90 - (angle1 / 64));
  788.     extent = (short) (- (angle2 / 64));
  790.     if (gc->arc_mode == ArcChord) {
  791.      boxWidth = theRect.right - theRect.left;
  792.      boxHeight = theRect.bottom - theRect.top;
  793.      angle = -(angle1/64.0)*PI/180.0;
  794.      sin1 = sin(angle);
  795.      cos1 = cos(angle);
  796.      angle -= (angle2/64.0)*PI/180.0;
  797.      sin2 = sin(angle);
  798.      cos2 = cos(angle);
  799.      vertex[0] = (theRect.left + theRect.right)/2.0;
  800.      vertex[1] = (theRect.top + theRect.bottom)/2.0;
  801.      center1[0] = vertex[0] + cos1*boxWidth/2.0;
  802.      center1[1] = vertex[1] + sin1*boxHeight/2.0;
  803.      center2[0] = vertex[0] + cos2*boxWidth/2.0;
  804.      center2[1] = vertex[1] + sin2*boxHeight/2.0;
  806. polygon = OpenPoly();
  807. MoveTo((short) ((theRect.left + theRect.right)/2),
  808. (short) ((theRect.top + theRect.bottom)/2));
  810. LineTo((short) (center1[0] + 0.5), (short) (center1[1] + 0.5));
  811. LineTo((short) (center2[0] + 0.5), (short) (center2[1] + 0.5));
  812. ClosePoly();
  814. ShowPen();
  815. FillCArc(&theRect, start, extent, gPenPat);
  816. FillCPoly(polygon, gPenPat);
  818. KillPoly(polygon);
  819.     } else {
  820. ShowPen();
  821. FillCArc(&theRect, start, extent, gPenPat);
  822.     }
  824.     SetGWorld(saveWorld, saveDevice);
  825. }
  827. /*
  828.  *----------------------------------------------------------------------
  829.  *
  830.  * TkScrollWindow --
  831.  *
  832.  * Scroll a rectangle of the specified window and accumulate
  833.  * a damage region.
  834.  *
  835.  * Results:
  836.  * Returns 0 if the scroll genereated no additional damage.
  837.  * Otherwise, sets the region that needs to be repainted after
  838.  * scrolling and returns 1.
  839.  *
  840.  * Side effects:
  841.  * Scrolls the bits in the window.
  842.  *
  843.  *----------------------------------------------------------------------
  844.  */
  846. int
  847. TkScrollWindow(
  848.     Tk_Window tkwin, /* The window to be scrolled. */
  849.     GC gc, /* GC for window to be scrolled. */
  850.     int x, /* Position rectangle to be scrolled. */
  851.     int y,
  852.     int width,
  853.     int height,
  854.     int dx, /* Distance rectangle should be moved. */
  855.     int dy,
  856.     TkRegion damageRgn) /* Region to accumulate damage in. */
  857. {
  858.     MacDrawable *destDraw = (MacDrawable *) Tk_WindowId(tkwin);
  859.     RgnHandle rgn = (RgnHandle) damageRgn;
  860.     CGrafPtr saveWorld;
  861.     GDHandle saveDevice;
  862.     GWorldPtr destPort;
  863.     Rect srcRect, scrollRect;
  864.     
  865.     destPort = TkMacGetDrawablePort(Tk_WindowId(tkwin));
  867.     GetGWorld(&saveWorld, &saveDevice);
  868.     SetGWorld(destPort, NULL);
  870.     TkMacSetUpClippingRgn(Tk_WindowId(tkwin));
  872.     /*
  873.      * Due to the implementation below the behavior may be differnt
  874.      * than X in certain cases that should never occur in Tk.  The 
  875.      * scrollRect is the source rect extended by the offset (the union 
  876.      * of the source rect and the offset rect).  Everything
  877.      * in the extended scrollRect is scrolled.  On X, it's possible
  878.      * to "skip" over an area if the offset makes the source and
  879.      * destination rects disjoint and non-aligned.
  880.      */
  881.        
  882.     SetRect(&srcRect, (short) (destDraw->xOff + x),
  883.     (short) (destDraw->yOff + y),
  884.     (short) (destDraw->xOff + x + width),
  885.     (short) (destDraw->yOff + y + height));
  886.     scrollRect = srcRect;
  887.     if (dx < 0) {
  888. scrollRect.left += dx;
  889.     } else {
  890. scrollRect.right += dx;
  891.     }
  892.     if (dy < 0) {
  893. scrollRect.top += dy;
  894.     } else {
  895. scrollRect.bottom += dy;
  896.     }
  898.     /*
  899.      * Adjust clip region so that we don't copy any windows
  900.      * that may overlap us.
  901.      */
  902.     RectRgn(rgn, &srcRect);
  903.     DiffRgn(rgn, destPort->visRgn, rgn);
  904.     OffsetRgn(rgn, dx, dy);
  905.     DiffRgn(destPort->clipRgn, rgn, destPort->clipRgn);
  906.     SetEmptyRgn(rgn);
  907.     
  908.     /*
  909.      * When a menu is up, the Mac does not expect drawing to occur and
  910.      * does not clip out the menu. We have to do it ourselves. This
  911.      * is pretty gross.
  912.      */
  914.     if (tkUseMenuCascadeRgn == 1) {
  915.      Point scratch = {0, 0};
  916.      MacDrawable *macDraw = (MacDrawable *) Tk_WindowId(tkwin);
  918. LocalToGlobal(&scratch);
  919. CopyRgn(tkMenuCascadeRgn, rgn);
  920. OffsetRgn(rgn, -scratch.h, -scratch.v);
  921. DiffRgn(destPort->clipRgn, rgn, destPort->clipRgn);
  922. SetEmptyRgn(rgn);
  923. macDraw->toplevel->flags |= TK_DRAWN_UNDER_MENU;
  924.     }
  926.     ScrollRect(&scrollRect, dx, dy, rgn);
  927.     
  928.     SetGWorld(saveWorld, saveDevice);
  929.     
  930.     /*
  931.      * Fortunantly, the region returned by ScrollRect is symanticlly
  932.      * the same as what we need to return in this function.  If the
  933.      * region is empty we return zero to denote that no damage was
  934.      * created.
  935.      */
  936.     if (EmptyRgn(rgn)) {
  937. return 0;
  938.     } else {
  939. return 1;
  940.     }
  941. }
  943. /*
  944.  *----------------------------------------------------------------------
  945.  *
  946.  * TkMacSetUpGraphicsPort --
  947.  *
  948.  * Set up the graphics port from the given GC.
  949.  *
  950.  * Results:
  951.  * None.
  952.  *
  953.  * Side effects:
  954.  * The current port is adjusted.
  955.  *
  956.  *----------------------------------------------------------------------
  957.  */
  959. void
  960. TkMacSetUpGraphicsPort(
  961.     GC gc) /* GC to apply to current port. */
  962. {
  963.     RGBColor macColor;
  965.     if (gPenPat == NULL) {
  966. gPenPat = NewPixPat();
  967.     }
  968.     
  969.     if (TkSetMacColor(gc->foreground, &macColor) == true) {
  970.         /* TODO: cache RGBPats for preformace - measure gains...  */
  971. MakeRGBPat(gPenPat, &macColor);
  972.     }
  973.     
  974.     PenNormal();
  975.     if(gc->function == GXxor) {
  976. PenMode(patXor);
  977.     }
  978.     if (gc->line_width > 1) {
  979. PenSize(gc->line_width, gc->line_width);
  980.     }
  981.     if (gc->line_style != LineSolid) {
  982. unsigned char *p = (unsigned char *) &(gc->dashes);
  983. /*
  984.  * Here the dash pattern should be set in the drawing,
  985.  * environment, but I don't know how to do that for the Mac.
  986.  *
  987.  * p[] is an array of unsigned chars containing the dash list.
  988.  * A '' indicates the end of this list.
  989.  *
  990.  * Someone knows how to implement this? If you have a more
  991.  * complete implementation of SetUpGraphicsPort() for
  992.  * the Mac (or for Windows), please let me know.
  993.  *
  994.  * Jan Nijtmans
  995.  * CMG Arnhem, B.V.
  996.  * email: j.nijtmans@chello.nl (private)
  997.  *        jan.nijtmans@cmg.nl (work)
  998.  * url:   http://purl.oclc.org/net/nijtmans/
  999.  */
  1000.     }
  1001. }
  1003. /*
  1004.  *----------------------------------------------------------------------
  1005.  *
  1006.  * TkMacSetUpClippingRgn --
  1007.  *
  1008.  * Set up the clipping region so that drawing only occurs on the
  1009.  * specified X subwindow.
  1010.  *
  1011.  * Results:
  1012.  * None.
  1013.  *
  1014.  * Side effects:
  1015.  * The clipping region in the current port is changed.
  1016.  *
  1017.  *----------------------------------------------------------------------
  1018.  */
  1020. void
  1021. TkMacSetUpClippingRgn(
  1022.     Drawable drawable) /* Drawable to update. */
  1023. {
  1024.     MacDrawable *macDraw = (MacDrawable *) drawable;
  1026.     if (macDraw->winPtr != NULL) {
  1027. if (macDraw->flags & TK_CLIP_INVALID) {
  1028.     TkMacUpdateClipRgn(macDraw->winPtr);
  1029. }
  1031. /*
  1032.  * When a menu is up, the Mac does not expect drawing to occur and
  1033.  * does not clip out the menu. We have to do it ourselves. This
  1034.  * is pretty gross.
  1035.  */
  1037. if (macDraw->clipRgn != NULL) {
  1038.     if (tkUseMenuCascadeRgn == 1) {
  1039.      Point scratch = {0, 0};
  1040.      GDHandle saveDevice;
  1041.      GWorldPtr saveWorld;
  1042.     
  1043.      GetGWorld(&saveWorld, &saveDevice);
  1044.      SetGWorld(TkMacGetDrawablePort(drawable), NULL);
  1045.      LocalToGlobal(&scratch);
  1046.      SetGWorld(saveWorld, saveDevice);
  1047.      if (tmpRgn == NULL) {
  1048.          tmpRgn = NewRgn();
  1049.      }
  1050.      CopyRgn(tkMenuCascadeRgn, tmpRgn);
  1051.      OffsetRgn(tmpRgn, -scratch.h, -scratch.v);
  1052.      DiffRgn(macDraw->clipRgn, tmpRgn, tmpRgn);
  1053.      SetClip(tmpRgn);
  1054.      macDraw->toplevel->flags |= TK_DRAWN_UNDER_MENU;
  1055.     } else {
  1056.      SetClip(macDraw->clipRgn);
  1057.     }
  1058. }
  1059.     }
  1060. }
  1062. /*
  1063.  *----------------------------------------------------------------------
  1064.  *
  1065.  * TkMacMakeStippleMap --
  1066.  *
  1067.  * Given a drawable and a stipple pattern this function draws the
  1068.  * pattern repeatedly over the drawable.  The drawable can then
  1069.  * be used as a mask for bit-bliting a stipple pattern over an
  1070.  * object.
  1071.  *
  1072.  * Results:
  1073.  * A BitMap data structure.
  1074.  *
  1075.  * Side effects:
  1076.  * None.
  1077.  *
  1078.  *----------------------------------------------------------------------
  1079.  */
  1081. BitMapPtr
  1082. TkMacMakeStippleMap(
  1083.     Drawable drawable, /* Window to apply stipple. */
  1084.     Drawable stipple) /* The stipple pattern. */
  1085. {
  1086.     MacDrawable *destDraw = (MacDrawable *) drawable;
  1087.     GWorldPtr destPort;
  1088.     BitMapPtr bitmapPtr;
  1089.     int width, height, stippleHeight, stippleWidth;
  1090.     int i, j;
  1091.     char * data;
  1092.     Rect bounds;
  1094.     destPort = TkMacGetDrawablePort(drawable);
  1095.     width = destPort->portRect.right - destPort->portRect.left;
  1096.     height = destPort->portRect.bottom - destPort->portRect.top;
  1097.     
  1098.     bitmapPtr = (BitMap *) ckalloc(sizeof(BitMap));
  1099.     data = (char *) ckalloc(height * ((width / 8) + 1));
  1100.     bitmapPtr->bounds.top = bitmapPtr->bounds.left = 0;
  1101.     bitmapPtr->bounds.right = (short) width;
  1102.     bitmapPtr->bounds.bottom = (short) height;
  1103.     bitmapPtr->baseAddr = data;
  1104.     bitmapPtr->rowBytes = (width / 8) + 1;
  1106.     destPort = TkMacGetDrawablePort(stipple);
  1107.     stippleWidth = destPort->portRect.right - destPort->portRect.left;
  1108.     stippleHeight = destPort->portRect.bottom - destPort->portRect.top;
  1110.     for (i = 0; i < height; i += stippleHeight) {
  1111. for (j = 0; j < width; j += stippleWidth) {
  1112.     bounds.left = j;
  1113.     bounds.top = i;
  1114.     bounds.right = j + stippleWidth;
  1115.     bounds.bottom = i + stippleHeight;
  1116.     
  1117.     CopyBits(&((GrafPtr) destPort)->portBits, bitmapPtr, 
  1118. &((GrafPtr) destPort)->portRect, &bounds, srcCopy, NULL);
  1119. }
  1120.     }
  1121.     return bitmapPtr;
  1122. }
  1124. /*
  1125.  *----------------------------------------------------------------------
  1126.  *
  1127.  * InvertByte --
  1128.  *
  1129.  *      This function reverses the bits in the passed in Byte of data.
  1130.  *
  1131.  * Results:
  1132.  *      The incoming byte in reverse bit order.
  1133.  *
  1134.  * Side effects:
  1135.  *      None.
  1136.  *
  1137.  *----------------------------------------------------------------------
  1138.  */
  1140. static unsigned char
  1141. InvertByte(
  1142.     unsigned char data) /* Byte of data. */
  1143. {
  1144.     unsigned char i;
  1145.     unsigned char mask = 1, result = 0;
  1146.  
  1147.     for (i = (1 << 7); i != 0; i /= 2) {
  1148.         if (data & mask) {
  1149.             result |= i;
  1150.         }
  1151.         mask = mask << 1;
  1152.     }
  1153.     return result;
  1154. }
  1156. /*
  1157.  *----------------------------------------------------------------------
  1158.  *
  1159.  * TkpDrawHighlightBorder --
  1160.  *
  1161.  * This procedure draws a rectangular ring around the outside of
  1162.  * a widget to indicate that it has received the input focus.
  1163.  *
  1164.  *      On the Macintosh, this puts a 1 pixel border in the bgGC color
  1165.  *      between the widget and the focus ring, except in the case where 
  1166.  *      highlightWidth is 1, in which case the border is left out.
  1167.  *
  1168.  *      For proper Mac L&F, use highlightWidth of 3.
  1169.  *
  1170.  * Results:
  1171.  * None.
  1172.  *
  1173.  * Side effects:
  1174.  * A rectangle "width" pixels wide is drawn in "drawable",
  1175.  * corresponding to the outer area of "tkwin".
  1176.  *
  1177.  *----------------------------------------------------------------------
  1178.  */
  1180. void 
  1181. TkpDrawHighlightBorder (
  1182.         Tk_Window tkwin, 
  1183.         GC fgGC, 
  1184.         GC bgGC, 
  1185.         int highlightWidth,
  1186.         Drawable drawable)
  1187. {
  1188.     if (highlightWidth == 1) {
  1189.         TkDrawInsetFocusHighlight (tkwin, fgGC, highlightWidth, drawable, 0);
  1190.     } else {
  1191.         TkDrawInsetFocusHighlight (tkwin, bgGC, highlightWidth, drawable, 0);
  1192.         if (fgGC != bgGC) {
  1193.             TkDrawInsetFocusHighlight (tkwin, fgGC, highlightWidth - 1, drawable, 0);
  1194.         }
  1195.     }
  1196. }
  1198. /*
  1199.  *----------------------------------------------------------------------
  1200.  *
  1201.  * TkpDrawFrame --
  1202.  *
  1203.  * This procedure draws the rectangular frame area.
  1204.  *
  1205.  * Results:
  1206.  * None.
  1207.  *
  1208.  * Side effects:
  1209.  * Draws inside the tkwin area.
  1210.  *
  1211.  *----------------------------------------------------------------------
  1212.  */
  1214. void
  1215. TkpDrawFrame (Tk_Window tkwin, Tk_3DBorder border,
  1216. int highlightWidth, int borderWidth, int relief)
  1217. {
  1218.     Tk_Fill3DRectangle(tkwin, Tk_WindowId(tkwin),
  1219.     border, highlightWidth, highlightWidth,
  1220.     Tk_Width(tkwin) - 2 * highlightWidth,
  1221.     Tk_Height(tkwin) - 2 * highlightWidth,
  1222.     borderWidth, relief);
  1223. }