summaryrefslogtreecommitdiffstats
path: root/macosx/tkMacOSXDraw.c
diff options
context:
space:
mode:
Diffstat (limited to 'macosx/tkMacOSXDraw.c')
-rw-r--r--macosx/tkMacOSXDraw.c1481
1 files changed, 682 insertions, 799 deletions
diff --git a/macosx/tkMacOSXDraw.c b/macosx/tkMacOSXDraw.c
index c1fe8c5..59df566 100644
--- a/macosx/tkMacOSXDraw.c
+++ b/macosx/tkMacOSXDraw.c
@@ -6,13 +6,13 @@
* Xlib functions.
*
* Copyright (c) 1995-1997 Sun Microsystems, Inc.
- * Copyright 2001, Apple Computer, Inc.
- * Copyright (c) 2006-2007 Daniel A. Steffen <das@users.sourceforge.net>
+ * Copyright 2001-2009, Apple Inc.
+ * Copyright (c) 2006-2009 Daniel A. Steffen <das@users.sourceforge.net>
*
* See the file "license.terms" for information on usage and redistribution
* of this file, and for a DISCLAIMER OF ALL WARRANTIES.
*
- * RCS: @(#) $Id: tkMacOSXDraw.c,v 1.33 2008/02/27 00:12:33 das Exp $
+ * RCS: @(#) $Id: tkMacOSXDraw.c,v 1.34 2009/06/29 14:35:01 das Exp $
*/
#include "tkMacOSXPrivate.h"
@@ -22,6 +22,7 @@
/*
#ifdef TK_MAC_DEBUG
#define TK_MAC_DEBUG_DRAWING
+#define TK_MAC_DEBUG_IMAGE_DRAWING
#endif
*/
@@ -33,18 +34,6 @@
*/
#define NON_AA_CG_OFFSET .999
-/*
- * Temporary region that can be reused.
- */
-
-RgnHandle tkMacOSXtmpQdRgn = NULL;
-
-int tkMacOSXUseCGDrawing = 1;
-
-int tkPictureIsOpen;
-
-static PixPatHandle penPat = NULL, tmpPixPat = NULL;
-
static int cgAntiAliasLimit = 0;
#define notAA(w) ((w) < cgAntiAliasLimit)
@@ -56,7 +45,11 @@ static int useThemedFrame = 0;
*/
static void ClipToGC(Drawable d, GC gc, HIShapeRef *clipRgnPtr);
-static void NoQDClip(CGrafPtr port);
+static CGImageRef CreateCGImageWithXImage(XImage *ximage);
+static CGContextRef GetCGContextForDrawable(Drawable d);
+static void DrawCGImage(Drawable d, GC gc, CGContextRef context, CGImageRef image,
+ unsigned long imageForeground, unsigned long imageBackground,
+ CGRect imageBounds, CGRect srcBounds, CGRect dstBounds);
/*
@@ -89,11 +82,6 @@ TkMacOSXInitCGDrawing(
if (Tcl_CreateNamespace(interp, "::tk::mac", NULL, NULL) == NULL) {
Tcl_ResetResult(interp);
}
- if (Tcl_LinkVar(interp, "::tk::mac::useCGDrawing",
- (char *) &tkMacOSXUseCGDrawing, TCL_LINK_BOOLEAN) != TCL_OK) {
- Tcl_ResetResult(interp);
- }
- tkMacOSXUseCGDrawing = enable;
if (Tcl_LinkVar(interp, "::tk::mac::CGAntialiasLimit",
(char *) &cgAntiAliasLimit, TCL_LINK_INT) != TCL_OK) {
@@ -113,17 +101,14 @@ TkMacOSXInitCGDrawing(
(char *) &useThemedFrame, TCL_LINK_BOOLEAN) != TCL_OK) {
Tcl_ResetResult(interp);
}
-
- if (tkMacOSXtmpQdRgn == NULL) {
- tkMacOSXtmpQdRgn = NewRgn();
+#if TK_MAC_BUTTON_USE_COMPATIBILITY_METRICS
+ if (Tcl_LinkVar(interp, "::tk::mac::useCompatibilityMetrics",
+ (char *) &tkMacOSXUseCompatibilityMetrics, TCL_LINK_BOOLEAN)
+ != TCL_OK) {
+ Tcl_ResetResult(interp);
}
+#endif
}
-#ifdef TK_MAC_DEBUG_DRAWING
- TkMacOSXInitNamedDebugSymbol(QD, void, QD_DebugPrint, char*);
- if (QD_DebugPrint) {
- ; /* gdb: b *QD_DebugPrint */
- }
-#endif /* TK_MAC_DEBUG_WINDOWS */
return TCL_OK;
}
@@ -159,53 +144,75 @@ XCopyArea(
int dest_y)
{
TkMacOSXDrawingContext dc;
- MacDrawable *srcDraw = (MacDrawable *) src, *dstDraw = (MacDrawable *) dst;
+ MacDrawable *srcDraw = (MacDrawable *) src;
display->request++;
if (!width || !height) {
/* TkMacOSXDbgMsg("Drawing of emtpy area requested"); */
return;
}
- {
- CGrafPtr srcPort;
-
- srcPort = TkMacOSXGetDrawablePort(src);
- if (srcPort) {
- Rect srcRect, dstRect, *srcPtr = &srcRect, *dstPtr = &dstRect;
- const BitMap *srcBit, *dstBit;
- RGBColor black = {0, 0, 0}, white = {0xffff, 0xffff, 0xffff};
-
- if (!TkMacOSXSetupDrawingContext(dst, gc, 0, &dc)) {
- return;
+ if (srcDraw->flags & TK_IS_PIXMAP) {
+ if (!TkMacOSXSetupDrawingContext(dst, gc, 1, &dc)) {
+ return;
+ }
+ if (dc.context) {
+ CGImageRef img = TkMacOSXCreateCGImageWithDrawable(src);
+
+ if (img) {
+ DrawCGImage(dst, gc, dc.context, img, gc->foreground,
+ gc->background, CGRectMake(0, 0,
+ srcDraw->size.width, srcDraw->size.height),
+ CGRectMake(src_x, src_y, width, height),
+ CGRectMake(dest_x, dest_y, width, height));
+ CFRelease(img);
+ } else {
+ TkMacOSXDbgMsg("Invalid source drawable");
}
- if (dc.context) {
- TkMacOSXDbgMsg("Ignored CG drawing of QD drawable");
- goto end;
+ } else {
+ TkMacOSXDbgMsg("Invalid destination drawable");
+ }
+ TkMacOSXRestoreDrawingContext(&dc);
+ } else if (TkMacOSXDrawableWindow(src)) {
+ NSView *view = TkMacOSXDrawableView(srcDraw);
+ NSInteger gs = [[view window] gState];
+ /* // alternative using per-view gState:
+ NSInteger gs = [view gState];
+ if (!gs) {
+ [view allocateGState];
+ if ([view lockFocusIfCanDraw]) {
+ [view unlockFocus];
}
- if (!dc.port) {
- TkMacOSXDbgMsg("Invalid destination drawable");
- goto end;
+ gs = [view gState];
+ }
+ */
+ if (!gs || !TkMacOSXSetupDrawingContext(dst, gc, 1, &dc)) {
+ return;
+ }
+ if (dc.context) {
+ NSGraphicsContext *gc = nil;
+ CGFloat boundsH = [view bounds].size.height;
+ NSRect srcRect = NSMakeRect(srcDraw->xOff + src_x, boundsH -
+ height - (srcDraw->yOff + src_y), width, height);
+
+ if (((MacDrawable *) dst)->flags & TK_IS_PIXMAP) {
+ gc = [NSGraphicsContext graphicsContextWithGraphicsPort:
+ dc.context flipped:NO];
+ if (gc) {
+ [NSGraphicsContext saveGraphicsState];
+ [NSGraphicsContext setCurrentContext:gc];
+ }
}
- srcBit = GetPortBitMapForCopyBits(srcPort);
- dstBit = GetPortBitMapForCopyBits(dc.port);
- SetRect(srcPtr, srcDraw->xOff + src_x, srcDraw->yOff + src_y,
- srcDraw->xOff + src_x + width,
- srcDraw->yOff + src_y + height);
- if (tkPictureIsOpen) {
- dstPtr = srcPtr;
- } else {
- SetRect(dstPtr, dstDraw->xOff + dest_x, dstDraw->yOff + dest_y,
- dstDraw->xOff + dest_x + width,
- dstDraw->yOff + dest_y + height);
+ NSCopyBits(gs, srcRect, NSMakePoint(dest_x,
+ dc.portBounds.size.height - dest_y));
+ if (gc) {
+ [NSGraphicsContext restoreGraphicsState];
}
- RGBForeColor(&black);
- RGBBackColor(&white);
- CopyBits(srcBit, dstBit, srcPtr, dstPtr, srcCopy, NULL);
-end:
- TkMacOSXRestoreDrawingContext(&dc);
} else {
- TkMacOSXDbgMsg("Invalid source drawable");
+ TkMacOSXDbgMsg("Invalid destination drawable");
}
+ TkMacOSXRestoreDrawingContext(&dc);
+ } else {
+ TkMacOSXDbgMsg("Invalid source drawable");
}
}
@@ -243,7 +250,7 @@ XCopyPlane(
unsigned long plane) /* Which plane to copy. */
{
TkMacOSXDrawingContext dc;
- MacDrawable *srcDraw = (MacDrawable *) src, *dstDraw = (MacDrawable *) dst;
+ MacDrawable *srcDraw = (MacDrawable *) src;
display->request++;
if (!width || !height) {
@@ -253,73 +260,37 @@ XCopyPlane(
if (plane != 1) {
Tcl_Panic("Unexpected plane specified for XCopyPlane");
}
- {
- CGrafPtr srcPort;
+ if (srcDraw->flags & TK_IS_PIXMAP) {
+ if (!TkMacOSXSetupDrawingContext(dst, gc, 1, &dc)) {
+ return;
+ }
+ if (dc.context) {
+ CGImageRef img = TkMacOSXCreateCGImageWithDrawable(src);
- srcPort = TkMacOSXGetDrawablePort(src);
- if (srcPort) {
- Rect srcRect, dstRect, *srcPtr = &srcRect, *dstPtr = &dstRect;
- const BitMap *srcBit, *dstBit;
- TkpClipMask *clipPtr = (TkpClipMask *) gc->clip_mask;
+ if (img) {
+ TkpClipMask *clipPtr = (TkpClipMask *) gc->clip_mask;
+ unsigned long imageBackground = gc->background;
- if (!TkMacOSXSetupDrawingContext(dst, gc, 0, &dc)) {
- return;
- }
- if (dc.context) {
- TkMacOSXDbgMsg("Ignored CG drawing of QD drawable");
- goto end;
- }
- if (!dc.port) {
- TkMacOSXDbgMsg("Invalid destination drawable");
- goto end;
- }
- srcBit = GetPortBitMapForCopyBits(srcPort);
- dstBit = GetPortBitMapForCopyBits(dc.port);
- SetRect(srcPtr, srcDraw->xOff + src_x, srcDraw->yOff + src_y,
- srcDraw->xOff + src_x + width,
- srcDraw->yOff + src_y + height);
- if (tkPictureIsOpen) {
- dstPtr = srcPtr;
- } else {
- SetRect(dstPtr, dstDraw->xOff + dest_x, dstDraw->yOff + dest_y,
- dstDraw->xOff + dest_x + width,
- dstDraw->yOff + dest_y + height);
- }
- TkMacOSXSetColorInPort(gc->foreground, 1, NULL, dc.port);
- if (!clipPtr || clipPtr->type == TKP_CLIP_REGION) {
- /*
- * Opaque bitmaps.
- */
-
- TkMacOSXSetColorInPort(gc->background, 0, NULL, dc.port);
- CopyBits(srcBit, dstBit, srcPtr, dstPtr, srcCopy, NULL);
- } else if (clipPtr->type == TKP_CLIP_PIXMAP) {
- if (clipPtr->value.pixmap == src) {
- /*
- * Transparent bitmaps. If it's color ignore the forecolor.
- */
- short tmode = GetPixDepth(GetPortPixMap(srcPort)) == 1 ?
- srcOr : transparent;
-
- CopyBits(srcBit, dstBit, srcPtr, dstPtr, tmode, NULL);
- } else {
- /*
- * Two arbitrary bitmaps.
- */
-
- CGrafPtr mskPort = TkMacOSXGetDrawablePort(
- clipPtr->value.pixmap);
- const BitMap *mskBit = GetPortBitMapForCopyBits(mskPort);
-
- CopyDeepMask(srcBit, mskBit, dstBit, srcPtr, srcPtr,
- dstPtr, srcCopy, NULL);
+ if (clipPtr && clipPtr->type == TKP_CLIP_PIXMAP &&
+ clipPtr->value.pixmap == src) {
+ imageBackground = TRANSPARENT_PIXEL << 24;
}
+ DrawCGImage(dst, gc, dc.context, img, gc->foreground,
+ imageBackground, CGRectMake(0, 0,
+ srcDraw->size.width, srcDraw->size.height),
+ CGRectMake(src_x, src_y, width, height),
+ CGRectMake(dest_x, dest_y, width, height));
+ CFRelease(img);
+ } else {
+ TkMacOSXDbgMsg("Invalid source drawable");
}
-end:
- TkMacOSXRestoreDrawingContext(&dc);
} else {
- TkMacOSXDbgMsg("Invalid source drawable");
+ TkMacOSXDbgMsg("Invalid destination drawable");
}
+ TkMacOSXRestoreDrawingContext(&dc);
+ } else {
+ XCopyArea(display, src, dst, gc, src_x, src_y, width, height, dest_x,
+ dest_y);
}
}
@@ -356,182 +327,424 @@ TkPutImage(
unsigned int height) /* distination and source. */
{
TkMacOSXDrawingContext dc;
- MacDrawable *dstDraw = (MacDrawable *) d;
display->request++;
- if (!TkMacOSXSetupDrawingContext(d, gc, 0, &dc)) {
+ if (!TkMacOSXSetupDrawingContext(d, gc, 1, &dc)) {
return;
}
if (dc.context) {
- TkMacOSXDbgMsg("Ignored CG drawing of XImage");
- } else {
- Rect srcRect, dstRect, *srcPtr = &srcRect, *dstPtr = &dstRect;
- const BitMap *dstBit;
- RGBColor black = {0, 0, 0}, white = {0xffff, 0xffff, 0xffff};
- int i, j;
- char *newData = NULL;
- char *dataPtr, *newPtr, *oldPtr;
- int rowBytes = image->bytes_per_line, sliceRowBytes, lastSliceRowBytes;
- int slices, sliceWidth, lastSliceWidth;
-
- dstBit = GetPortBitMapForCopyBits(dc.port);
- SetRect(srcPtr, src_x, src_y, src_x + width, src_y + height);
- if (tkPictureIsOpen) {
- dstPtr = srcPtr;
+ CGImageRef img = CreateCGImageWithXImage(image);
+
+ if (img) {
+ DrawCGImage(d, gc, dc.context, img, gc->foreground, gc->background,
+ CGRectMake(0, 0, image->width, image->height),
+ CGRectMake(src_x, src_y, width, height),
+ CGRectMake(dest_x, dest_y, width, height));
+ CFRelease(img);
} else {
- SetRect(dstPtr, dstDraw->xOff + dest_x, dstDraw->yOff + dest_y,
- dstDraw->xOff + dest_x + width,
- dstDraw->yOff + dest_y + height);
+ TkMacOSXDbgMsg("Invalid source drawable");
}
- RGBForeColor(&black);
- RGBBackColor(&white);
- if (image->obdata) {
- /*
- * Image from XGetImage, copy from containing GWorld directly.
- */
+ } else {
+ TkMacOSXDbgMsg("Invalid destination drawable");
+ }
+ TkMacOSXRestoreDrawingContext(&dc);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * CreateCGImageWithXImage --
+ *
+ * Create CGImage from XImage, copying the image data.
+ *
+ * Results:
+ * CGImage, release after use.
+ *
+ * Side effects:
+ * None.
+ *
+ *----------------------------------------------------------------------
+ */
- CopyBits(GetPortBitMapForCopyBits(TkMacOSXGetDrawablePort(
- (Drawable)image->obdata)), dstBit,
- srcPtr, dstPtr, srcCopy, NULL);
- } else if (image->depth == 1) {
- /*
- * BW image
- */
-
- const int maxRowBytes = 0x3ffe;
- BitMap bitmap;
- int odd;
-
- if (rowBytes > maxRowBytes) {
- slices = rowBytes / maxRowBytes;
- sliceRowBytes = maxRowBytes;
- lastSliceRowBytes = rowBytes - (slices * maxRowBytes);
- if (!lastSliceRowBytes) {
- slices--;
- lastSliceRowBytes = maxRowBytes;
- }
- sliceWidth = (long) image->width * maxRowBytes / rowBytes;
- lastSliceWidth = image->width - (sliceWidth * slices);
- } else {
- slices = 0;
- sliceRowBytes = lastSliceRowBytes = rowBytes;
- sliceWidth = lastSliceWidth = image->width;
+static void ReleaseData(void *info, const void *data, size_t size) {
+ ckfree(info);
+}
+
+CGImageRef
+CreateCGImageWithXImage(
+ XImage *image)
+{
+ CGImageRef img = NULL;
+ size_t bitsPerComponent, bitsPerPixel;
+ size_t len = image->bytes_per_line * image->height;
+ const CGFloat *decode = NULL;
+ CGBitmapInfo bitmapInfo;
+ CGDataProviderRef provider = NULL;
+ char *data = NULL;
+ CGDataProviderReleaseDataCallback releaseData = ReleaseData;
+
+ if (image->obdata) {
+ /*
+ * Image from XGetImage
+ */
+
+ img = TkMacOSXCreateCGImageWithDrawable((Pixmap) image->obdata);
+ } else if (image->bits_per_pixel == 1) {
+ /*
+ * BW image
+ */
+
+ static const CGFloat decodeWB[2] = {1, 0};
+
+ bitsPerComponent = 1;
+ bitsPerPixel = 1;
+ decode = decodeWB;
+ if (image->bitmap_bit_order != MSBFirst) {
+ char *srcPtr = image->data + image->xoffset;
+ char *endPtr = srcPtr + len;
+ char *destPtr = (data = ckalloc(len));
+
+ while (srcPtr < endPtr) {
+ *destPtr++ = xBitReverseTable[(unsigned char)(*(srcPtr++))];
}
- bitmap.bounds.top = bitmap.bounds.left = 0;
- bitmap.bounds.bottom = (short) image->height;
- dataPtr = image->data + image->xoffset;
- do {
- if (slices) {
- bitmap.bounds.right = bitmap.bounds.left + sliceWidth;
- } else {
- sliceRowBytes = lastSliceRowBytes;
- bitmap.bounds.right = bitmap.bounds.left + lastSliceWidth;
- }
- oldPtr = dataPtr;
- odd = sliceRowBytes % 2;
- if (!newData) {
- newData = ckalloc(image->height * (sliceRowBytes+odd));
- }
- newPtr = newData;
- if (image->bitmap_bit_order != MSBFirst) {
- for (i = 0; i < image->height; i++) {
- for (j = 0; j < sliceRowBytes; j++) {
- *newPtr = xBitReverseTable[(unsigned char)*oldPtr];
- newPtr++; oldPtr++;
- }
- if (odd) {
- *newPtr++ = 0;
- }
- oldPtr += rowBytes - sliceRowBytes;
- }
- } else {
- for (i = 0; i < image->height; i++) {
- memcpy(newPtr, oldPtr, sliceRowBytes);
- newPtr += sliceRowBytes;
- if (odd) {
- *newPtr++ = 0;
- }
- oldPtr += rowBytes;
- }
- }
- bitmap.baseAddr = newData;
- bitmap.rowBytes = sliceRowBytes + odd;
- CopyBits(&bitmap, dstBit, srcPtr, dstPtr, srcCopy, NULL);
- if (slices) {
- bitmap.bounds.left = bitmap.bounds.right;
- dataPtr += sliceRowBytes;
- }
- } while (slices--);
- ckfree(newData);
} else {
- /*
- * Color image
- */
-
- const int maxRowBytes = 0x3ffc;
- PixMap pixmap;
-
- pixmap.bounds.left = 0;
- pixmap.bounds.top = 0;
- pixmap.bounds.bottom = (short) image->height;
- pixmap.pixelType = RGBDirect;
- pixmap.pmVersion = baseAddr32; /* 32bit clean */
- pixmap.packType = 0;
- pixmap.packSize = 0;
- pixmap.hRes = 0x00480000;
- pixmap.vRes = 0x00480000;
- pixmap.pixelSize = 32;
- pixmap.cmpCount = 3;
- pixmap.cmpSize = 8;
- pixmap.pixelFormat = image->byte_order == MSBFirst ?
- k32ARGBPixelFormat : k32BGRAPixelFormat;
- pixmap.pmTable = NULL;
- pixmap.pmExt = 0;
- if (rowBytes > maxRowBytes) {
- slices = rowBytes / maxRowBytes;
- sliceRowBytes = maxRowBytes;
- lastSliceRowBytes = rowBytes - (slices * maxRowBytes);
- if (!lastSliceRowBytes) {
- slices--;
- lastSliceRowBytes = maxRowBytes;
+ data = memcpy(ckalloc(len), image->data + image->xoffset,
+ len);
+ }
+ if (data) {
+ provider = CGDataProviderCreateWithData(data, data, len, releaseData);
+ }
+ if (provider) {
+ img = CGImageMaskCreate(image->width, image->height, bitsPerComponent,
+ bitsPerPixel, image->bytes_per_line,
+ provider, decode, 0);
+ }
+ } else if (image->format == ZPixmap && image->bits_per_pixel == 32) {
+ /*
+ * Color image
+ */
+
+ CGColorSpaceRef colorspace = CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB);
+
+ bitsPerComponent = 8;
+ bitsPerPixel = 32;
+ bitmapInfo = (image->byte_order == MSBFirst ?
+ kCGBitmapByteOrder32Big : kCGBitmapByteOrder32Little) |
+ kCGImageAlphaNoneSkipFirst;
+ data = memcpy(ckalloc(len), image->data + image->xoffset, len);
+ if (data) {
+ provider = CGDataProviderCreateWithData(data, data, len, releaseData);
+ }
+ if (provider) {
+ img = CGImageCreate(image->width, image->height, bitsPerComponent,
+ bitsPerPixel, image->bytes_per_line, colorspace, bitmapInfo,
+ provider, decode, 0, kCGRenderingIntentDefault);
+ }
+ if (colorspace) {
+ CFRelease(colorspace);
+ }
+ } else {
+ TkMacOSXDbgMsg("Unsupported image type");
+ }
+ if (provider) {
+ CFRelease(provider);
+ }
+
+ return img;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * TkMacOSXCreateCGImageWithDrawable --
+ *
+ * Create a CGImage from the given Drawable.
+ *
+ * Results:
+ * CGImage, release after use.
+ *
+ * Side effects:
+ * None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+CGImageRef
+TkMacOSXCreateCGImageWithDrawable(
+ Drawable drawable)
+{
+ CGImageRef img = NULL;
+ CGContextRef context = GetCGContextForDrawable(drawable);
+
+ if (context) {
+ img = CGBitmapContextCreateImage(context);
+ }
+ return img;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * CreateNSImageWithPixmap --
+ *
+ * Create NSImage for Pixmap.
+ *
+ * Results:
+ * NSImage.
+ *
+ * Side effects:
+ * None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static NSImage*
+CreateNSImageWithPixmap(
+ Pixmap pixmap,
+ int width,
+ int height)
+{
+ CGImageRef cgImage;
+ NSImage *nsImage;
+ NSBitmapImageRep *bitmapImageRep;
+
+ cgImage = TkMacOSXCreateCGImageWithDrawable(pixmap);
+ nsImage = [[NSImage alloc] initWithSize:NSMakeSize(width, height)];
+ bitmapImageRep = [[NSBitmapImageRep alloc] initWithCGImage:cgImage];
+ [nsImage addRepresentation:bitmapImageRep];
+ [bitmapImageRep release];
+ CFRelease(cgImage);
+
+ return nsImage;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * TkMacOSXGetNSImageWithTkImage --
+ *
+ * Get autoreleased NSImage for Tk_Image.
+ *
+ * Results:
+ * NSImage.
+ *
+ * Side effects:
+ * None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+NSImage*
+TkMacOSXGetNSImageWithTkImage(
+ Display *display,
+ Tk_Image image,
+ int width,
+ int height)
+{
+ Pixmap pixmap = Tk_GetPixmap(display, None, width, height, 0);
+ NSImage *nsImage;
+
+ Tk_RedrawImage(image, 0, 0, width, height, pixmap, 0, 0);
+ nsImage = CreateNSImageWithPixmap(pixmap, width, height);
+ Tk_FreePixmap(display, pixmap);
+
+ return [nsImage autorelease];
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * TkMacOSXGetNSImageWithBitmap --
+ *
+ * Get autoreleased NSImage for Bitmap.
+ *
+ * Results:
+ * NSImage.
+ *
+ * Side effects:
+ * None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+NSImage*
+TkMacOSXGetNSImageWithBitmap(
+ Display *display,
+ Pixmap bitmap,
+ GC gc,
+ int width,
+ int height)
+{
+ Pixmap pixmap = Tk_GetPixmap(display, None, width, height, 0);
+ NSImage *nsImage;
+
+ unsigned long origBackground = gc->background;
+
+ gc->background = TRANSPARENT_PIXEL << 24;
+ XSetClipOrigin(display, gc, 0, 0);
+ XCopyPlane(display, bitmap, pixmap, gc, 0, 0, width, height, 0, 0, 1);
+ gc->background = origBackground;
+ nsImage = CreateNSImageWithPixmap(pixmap, width, height);
+ Tk_FreePixmap(display, pixmap);
+
+ return [nsImage autorelease];
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * GetCGContextForDrawable --
+ *
+ * Get CGContext for given Drawable, creating one if necessary.
+ *
+ * Results:
+ * CGContext.
+ *
+ * Side effects:
+ * None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+CGContextRef
+GetCGContextForDrawable(
+ Drawable d)
+{
+ MacDrawable *macDraw = (MacDrawable *) d;
+
+ if (macDraw && (macDraw->flags & TK_IS_PIXMAP) && !macDraw->context) {
+ const size_t bitsPerComponent = 8;
+ size_t bitsPerPixel, bytesPerRow, len;
+ CGColorSpaceRef colorspace = NULL;
+ CGBitmapInfo bitmapInfo =
+#ifdef __LITTLE_ENDIAN__
+ kCGBitmapByteOrder32Host;
+#else
+ kCGBitmapByteOrderDefault;
+#endif
+ char *data;
+ CGRect bounds = CGRectMake(0, 0, macDraw->size.width,
+ macDraw->size.height);
+
+ if (macDraw->flags & TK_IS_BW_PIXMAP) {
+ bitsPerPixel = 8;
+ bitmapInfo = kCGImageAlphaOnly;
+ } else {
+ colorspace = CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB);
+ bitsPerPixel = 32;
+ bitmapInfo |= kCGImageAlphaPremultipliedFirst;
+ }
+ bytesPerRow = ((size_t) macDraw->size.width * bitsPerPixel + 127) >> 3
+ & ~15;
+ len = macDraw->size.height * bytesPerRow;
+ data = ckalloc(len);
+ bzero(data, len);
+ macDraw->context = CGBitmapContextCreate(data, macDraw->size.width,
+ macDraw->size.height, bitsPerComponent, bytesPerRow,
+ colorspace, bitmapInfo);
+ if (macDraw->context) {
+ CGContextClearRect(macDraw->context, bounds);
+ }
+ if (colorspace) {
+ CFRelease(colorspace);
+ }
+ }
+
+ return (macDraw ? macDraw->context : NULL);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * DrawCGImage --
+ *
+ * Draw CG image into drawable.
+ *
+ * Results:
+ * None.
+ *
+ * Side effects:
+ * None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+DrawCGImage(
+ Drawable d,
+ GC gc,
+ CGContextRef context,
+ CGImageRef image,
+ unsigned long imageForeground,
+ unsigned long imageBackground,
+ CGRect imageBounds,
+ CGRect srcBounds,
+ CGRect dstBounds)
+{
+ MacDrawable *macDraw = (MacDrawable *) d;
+
+ if (macDraw && context && image) {
+ CGImageRef subImage = NULL;
+
+ if (!CGRectEqualToRect(imageBounds, srcBounds)) {
+ if (!CGRectContainsRect(imageBounds, srcBounds)) {
+ TkMacOSXDbgMsg("Mismatch of sub CGImage bounds");
+ }
+ subImage = CGImageCreateWithImageInRect(image, CGRectOffset(
+ srcBounds, -imageBounds.origin.x, -imageBounds.origin.y));
+ if (subImage) {
+ image = subImage;
+ }
+ }
+ dstBounds = CGRectOffset(dstBounds, macDraw->xOff, macDraw->yOff);
+ if (CGImageIsMask(image)) {
+ /*CGContextSaveGState(context);*/
+ if (macDraw->flags & TK_IS_BW_PIXMAP) {
+ if (imageBackground != TRANSPARENT_PIXEL << 24) {
+ CGContextClearRect(context, dstBounds);
}
- sliceWidth = (long) image->width * maxRowBytes / rowBytes;
- lastSliceWidth = image->width - (sliceWidth * slices);
- dataPtr = image->data + image->xoffset;
- newData = (char *) ckalloc(image->height * sliceRowBytes);
- do {
- if (slices) {
- pixmap.bounds.right = pixmap.bounds.left + sliceWidth;
- } else {
- sliceRowBytes = lastSliceRowBytes;
- pixmap.bounds.right = pixmap.bounds.left + lastSliceWidth;
- }
- oldPtr = dataPtr;
- newPtr = newData;
- for (i = 0; i < image->height; i++) {
- memcpy(newPtr, oldPtr, sliceRowBytes);
- oldPtr += rowBytes;
- newPtr += sliceRowBytes;
- }
- pixmap.baseAddr = newData;
- pixmap.rowBytes = sliceRowBytes | 0x8000;
- CopyBits((BitMap*) &pixmap, dstBit, srcPtr, dstPtr, srcCopy,
- NULL);
- if (slices) {
- pixmap.bounds.left = pixmap.bounds.right;
- dataPtr += sliceRowBytes;
- }
- } while (slices--);
- ckfree(newData);
+ CGContextSetRGBFillColor(context, 0.0, 0.0, 0.0, 1.0);
} else {
- pixmap.bounds.right = (short) image->width;
- pixmap.baseAddr = image->data + image->xoffset;
- pixmap.rowBytes = rowBytes | 0x8000;
- CopyBits((BitMap*) &pixmap, dstBit, srcPtr, dstPtr, srcCopy, NULL);
+ if (imageBackground != TRANSPARENT_PIXEL << 24) {
+ TkMacOSXSetColorInContext(gc, imageBackground, context);
+ CGContextFillRect(context, dstBounds);
+ }
+ TkMacOSXSetColorInContext(gc, imageForeground, context);
}
}
+#ifdef TK_MAC_DEBUG_IMAGE_DRAWING
+ CGContextSaveGState(context);
+ CGContextSetLineWidth(context, 1.0);
+ CGContextSetRGBStrokeColor(context, 0, 0, 0, 0.1);
+ CGContextSetRGBFillColor(context, 0, 1, 0, 0.1);
+ CGContextFillRect(context, dstBounds);
+ CGContextStrokeRect(context, dstBounds);
+ CGPoint p[4] = {dstBounds.origin,
+ CGPointMake(CGRectGetMaxX(dstBounds), CGRectGetMaxY(dstBounds)),
+ CGPointMake(CGRectGetMinX(dstBounds), CGRectGetMaxY(dstBounds)),
+ CGPointMake(CGRectGetMaxX(dstBounds), CGRectGetMinY(dstBounds))
+ };
+ CGContextStrokeLineSegments(context, p, 4);
+ CGContextRestoreGState(context);
+ TkMacOSXDbgMsg("Drawing CGImage at (x=%f, y=%f), (w=%f, h=%f)",
+ dstBounds.origin.x, dstBounds.origin.y,
+ dstBounds.size.width, dstBounds.size.height);
+#else /* TK_MAC_DEBUG_IMAGE_DRAWING */
+ CGContextSaveGState(context);
+ CGContextTranslateCTM(context, 0, dstBounds.origin.y + CGRectGetMaxY(dstBounds));
+ CGContextScaleCTM(context, 1, -1);
+ CGContextDrawImage(context, dstBounds, image);
+ CGContextRestoreGState(context);
+#endif /* TK_MAC_DEBUG_IMAGE_DRAWING */
+ /*if (CGImageIsMask(image)) {
+ CGContextRestoreGState(context);
+ }*/
+ if (subImage) {
+ CFRelease(subImage);
+ }
+ } else {
+ TkMacOSXDbgMsg("Drawing of empty CGImage requested");
}
- TkMacOSXRestoreDrawingContext(&dc);
}
/*
@@ -572,7 +785,7 @@ XDrawLines(
}
display->request++;
- if (!TkMacOSXSetupDrawingContext(d, gc, tkMacOSXUseCGDrawing, &dc)) {
+ if (!TkMacOSXSetupDrawingContext(d, gc, 1, &dc)) {
return;
}
if (dc.context) {
@@ -595,23 +808,6 @@ XDrawLines(
}
}
CGContextStrokePath(dc.context);
- } else {
- int o = -lw/2;
-
- /* This is broken for fat lines, it is not possible to correctly
- * imitate X11 drawing of oblique fat lines with QD line drawing,
- * we should draw a filled polygon instead. */
-
- MoveTo((short) (macWin->xOff + points[0].x + o),
- (short) (macWin->yOff + points[0].y + o));
- for (i = 1; i < npoints; i++) {
- if (mode == CoordModeOrigin) {
- LineTo((short) (macWin->xOff + points[i].x + o),
- (short) (macWin->yOff + points[i].y + o));
- } else {
- Line((short) points[i].x, (short) points[i].y);
- }
- }
}
TkMacOSXRestoreDrawingContext(&dc);
}
@@ -645,7 +841,7 @@ XDrawSegments(
int i, lw = gc->line_width;
display->request++;
- if (!TkMacOSXSetupDrawingContext(d, gc, tkMacOSXUseCGDrawing, &dc)) {
+ if (!TkMacOSXSetupDrawingContext(d, gc, 1, &dc)) {
return;
}
if (dc.context) {
@@ -661,19 +857,6 @@ XDrawSegments(
macWin->yOff + segments[i].y2 + o);
CGContextStrokePath(dc.context);
}
- } else {
- int o = -lw/2;
-
- /* This is broken for fat lines, it is not possible to correctly
- * imitate X11 drawing of oblique fat lines with QD line drawing,
- * we should draw a filled polygon instead. */
-
- for (i = 0; i < nsegments; i++) {
- MoveTo((short) (macWin->xOff + segments[i].x1 + o),
- (short) (macWin->yOff + segments[i].y1 + o));
- LineTo((short) (macWin->xOff + segments[i].x2 + o),
- (short) (macWin->yOff + segments[i].y2 + o));
- }
}
TkMacOSXRestoreDrawingContext(&dc);
}
@@ -709,7 +892,7 @@ XFillPolygon(
int i;
display->request++;
- if (!TkMacOSXSetupDrawingContext(d, gc, tkMacOSXUseCGDrawing, &dc)) {
+ if (!TkMacOSXSetupDrawingContext(d, gc, 1, &dc)) {
return;
}
if (dc.context) {
@@ -732,23 +915,6 @@ XFillPolygon(
}
}
CGContextEOFillPath(dc.context);
- } else {
- PolyHandle polygon;
-
- polygon = OpenPoly();
- MoveTo((short) (macWin->xOff + points[0].x),
- (short) (macWin->yOff + points[0].y));
- for (i = 1; i < npoints; i++) {
- if (mode == CoordModeOrigin) {
- LineTo((short) (macWin->xOff + points[i].x),
- (short) (macWin->yOff + points[i].y));
- } else {
- Line((short) points[i].x, (short) points[i].y);
- }
- }
- ClosePoly();
- FillCPoly(polygon, dc.penPat);
- KillPoly(polygon);
}
TkMacOSXRestoreDrawingContext(&dc);
}
@@ -787,7 +953,7 @@ XDrawRectangle(
}
display->request++;
- if (!TkMacOSXSetupDrawingContext(d, gc, tkMacOSXUseCGDrawing, &dc)) {
+ if (!TkMacOSXSetupDrawingContext(d, gc, 1, &dc)) {
return;
}
if (dc.context) {
@@ -799,15 +965,6 @@ XDrawRectangle(
macWin->yOff + y + o,
width, height);
CGContextStrokeRect(dc.context, rect);
- } else {
- Rect theRect;
- int o = -lw/2;
-
- theRect.left = (short) (macWin->xOff + x + o);
- theRect.top = (short) (macWin->yOff + y + o);
- theRect.right = (short) (theRect.left + width + lw);
- theRect.bottom = (short) (theRect.top + height + lw);
- FrameRect(&theRect);
}
TkMacOSXRestoreDrawingContext(&dc);
}
@@ -853,7 +1010,7 @@ XDrawRectangles(
int i, lw = gc->line_width;
display->request++;
- if (!TkMacOSXSetupDrawingContext(d, gc, tkMacOSXUseCGDrawing, &dc)) {
+ if (!TkMacOSXSetupDrawingContext(d, gc, 1, &dc)) {
return;
}
if (dc.context) {
@@ -870,17 +1027,6 @@ XDrawRectangles(
rectPtr->width, rectPtr->height);
CGContextStrokeRect(dc.context, rect);
}
- } else {
- Rect theRect;
- int o = -lw/2;
-
- for (i = 0, rectPtr = rectArr; i < nRects;i++, rectPtr++) {
- theRect.left = (short) (macWin->xOff + rectPtr->x + o);
- theRect.top = (short) (macWin->yOff + rectPtr->y + o);
- theRect.right = (short) (theRect.left + rectPtr->width + lw);
- theRect.bottom = (short) (theRect.top + rectPtr->height + lw);
- FrameRect(&theRect);
- }
}
TkMacOSXRestoreDrawingContext(&dc);
}
@@ -916,7 +1062,7 @@ XFillRectangles(
int i;
display->request++;
- if (!TkMacOSXSetupDrawingContext(d, gc, tkMacOSXUseCGDrawing, &dc)) {
+ if (!TkMacOSXSetupDrawingContext(d, gc, 1, &dc)) {
return;
}
if (dc.context) {
@@ -932,16 +1078,6 @@ XFillRectangles(
rectPtr->width, rectPtr->height);
CGContextFillRect(dc.context, rect);
}
- } else {
- Rect theRect;
-
- for (i = 0, rectPtr = rectangles; i < n_rectangles; i++, rectPtr++) {
- theRect.left = (short) (macWin->xOff + rectPtr->x);
- theRect.top = (short) (macWin->yOff + rectPtr->y);
- theRect.right = (short) (theRect.left + rectPtr->width);
- theRect.bottom = (short) (theRect.top + rectPtr->height);
- FillCRect(&theRect, dc.penPat);
- }
}
TkMacOSXRestoreDrawingContext(&dc);
}
@@ -982,7 +1118,7 @@ XDrawArc(
}
display->request++;
- if (!TkMacOSXSetupDrawingContext(d, gc, tkMacOSXUseCGDrawing, &dc)) {
+ if (!TkMacOSXSetupDrawingContext(d, gc, 1, &dc)) {
return;
}
if (dc.context) {
@@ -993,10 +1129,9 @@ XDrawArc(
macWin->xOff + x + o,
macWin->yOff + y + o,
width, height);
- TK_IF_MAC_OS_X_API_COND (4, CGContextStrokeEllipseInRect,
- angle1 == 0 && angle2 == 23040,
+ if (angle1 == 0 && angle2 == 23040) {
CGContextStrokeEllipseInRect(dc.context, rect);
- ) TK_ELSE (
+ } else {
CGMutablePathRef p = CGPathCreateMutable();
CGAffineTransform t = CGAffineTransformIdentity;
CGPoint c = CGPointMake(CGRectGetMidX(rect), CGRectGetMidY(rect));
@@ -1011,19 +1146,7 @@ XDrawArc(
CGContextAddPath(dc.context, p);
CGPathRelease(p);
CGContextStrokePath(dc.context);
- ) TK_ENDIF
- } else {
- Rect theRect;
- short start, extent;
- int o = -lw/2;
-
- theRect.left = (short) (macWin->xOff + x + o);
- theRect.top = (short) (macWin->yOff + y + o);
- theRect.right = (short) (theRect.left + width + lw);
- theRect.bottom = (short) (theRect.top + height + lw);
- start = (short) (90 - (angle1/64));
- extent = (short) (-(angle2/64));
- FrameArc(&theRect, start, extent);
+ }
}
TkMacOSXRestoreDrawingContext(&dc);
}
@@ -1067,7 +1190,7 @@ XDrawArcs(
int i, lw = gc->line_width;
display->request++;
- if (!TkMacOSXSetupDrawingContext(d, gc, tkMacOSXUseCGDrawing, &dc)) {
+ if (!TkMacOSXSetupDrawingContext(d, gc, 1, &dc)) {
return;
}
if (dc.context) {
@@ -1084,10 +1207,9 @@ XDrawArcs(
macWin->yOff + arcPtr->y + o,
arcPtr->width, arcPtr->height);
- TK_IF_MAC_OS_X_API_COND (4, CGContextStrokeEllipseInRect,
- arcPtr->angle1 == 0 && arcPtr->angle2 == 23040,
+ if (arcPtr->angle1 == 0 && arcPtr->angle2 == 23040) {
CGContextStrokeEllipseInRect(dc.context, rect);
- ) TK_ELSE (
+ } else {
CGMutablePathRef p = CGPathCreateMutable();
CGAffineTransform t = CGAffineTransformIdentity;
CGPoint c = CGPointMake(CGRectGetMidX(rect),
@@ -1106,21 +1228,7 @@ XDrawArcs(
CGContextAddPath(dc.context, p);
CGPathRelease(p);
CGContextStrokePath(dc.context);
- ) TK_ENDIF
- }
- } else {
- Rect theRect;
- short start, extent;
- int o = -lw/2;
-
- for (i = 0, arcPtr = arcArr;i < nArcs;i++, arcPtr++) {
- theRect.left = (short) (macWin->xOff + arcPtr->x + o);
- theRect.top = (short) (macWin->yOff + arcPtr->y + o);
- theRect.right = (short) (theRect.left + arcPtr->width + lw);
- theRect.bottom = (short) (theRect.top + arcPtr->height + lw);
- start = (short) (90 - (arcPtr->angle1/64));
- extent = (short) (-(arcPtr->angle2/64));
- FrameArc(&theRect, start, extent);
+ }
}
}
TkMacOSXRestoreDrawingContext(&dc);
@@ -1163,7 +1271,7 @@ XFillArc(
}
display->request++;
- if (!TkMacOSXSetupDrawingContext(d, gc, tkMacOSXUseCGDrawing, &dc)) {
+ if (!TkMacOSXSetupDrawingContext(d, gc, 1, &dc)) {
return;
}
if (dc.context) {
@@ -1179,10 +1287,9 @@ XFillArc(
macWin->yOff + y + o,
width - u, height - u);
- TK_IF_MAC_OS_X_API_COND (4, CGContextFillEllipseInRect,
- angle1 == 0 && angle2 == 23040,
+ if (angle1 == 0 && angle2 == 23040) {
CGContextFillEllipseInRect(dc.context, rect);
- ) TK_ELSE (
+ } else {
CGMutablePathRef p = CGPathCreateMutable();
CGAffineTransform t = CGAffineTransformIdentity;
CGPoint c = CGPointMake(CGRectGetMidX(rect), CGRectGetMidY(rect));
@@ -1201,49 +1308,6 @@ XFillArc(
CGContextAddPath(dc.context, p);
CGPathRelease(p);
CGContextFillPath(dc.context);
- ) TK_ENDIF
- } else {
- Rect theRect;
- short start, extent;
- int o = -lw/2;
- PolyHandle polygon;
- double sin1, cos1, sin2, cos2, angle;
- double boxWidth, boxHeight;
- double vertex[2], center1[2], center2[2];
-
- theRect.left = (short) (macWin->xOff + x + o);
- theRect.top = (short) (macWin->yOff + y + o);
- theRect.right = (short) (theRect.left + width + lw);
- theRect.bottom = (short) (theRect.top + height + lw);
- start = (short) (90 - (angle1/64));
- extent = (short) (-(angle2/64));
- if (gc->arc_mode == ArcChord) {
- boxWidth = theRect.right - theRect.left;
- boxHeight = theRect.bottom - theRect.top;
- angle = radians(-angle1/64.0);
- sin1 = sin(angle);
- cos1 = cos(angle);
- angle -= radians(angle2/64.0);
- sin2 = sin(angle);
- cos2 = cos(angle);
- vertex[0] = (theRect.left + theRect.right)/2.0;
- vertex[1] = (theRect.top + theRect.bottom)/2.0;
- center1[0] = vertex[0] + cos1*boxWidth/2.0;
- center1[1] = vertex[1] + sin1*boxHeight/2.0;
- center2[0] = vertex[0] + cos2*boxWidth/2.0;
- center2[1] = vertex[1] + sin2*boxHeight/2.0;
-
- polygon = OpenPoly();
- MoveTo((short) ((theRect.left + theRect.right)/2),
- (short) ((theRect.top + theRect.bottom)/2));
- LineTo((short) (center1[0] + .5), (short) (center1[1] + .5));
- LineTo((short) (center2[0] + .5), (short) (center2[1] + .5));
- ClosePoly();
- FillCArc(&theRect, start, extent, dc.penPat);
- FillCPoly(polygon, dc.penPat);
- KillPoly(polygon);
- } else {
- FillCArc(&theRect, start, extent, dc.penPat);
}
}
TkMacOSXRestoreDrawingContext(&dc);
@@ -1280,7 +1344,7 @@ XFillArcs(
int i, lw = gc->line_width;
display->request++;
- if (!TkMacOSXSetupDrawingContext(d, gc, tkMacOSXUseCGDrawing, &dc)) {
+ if (!TkMacOSXSetupDrawingContext(d, gc, 1, &dc)) {
return;
}
if (dc.context) {
@@ -1300,10 +1364,9 @@ XFillArcs(
macWin->xOff + arcPtr->x + o,
macWin->yOff + arcPtr->y + o,
arcPtr->width - u, arcPtr->height - u);
- TK_IF_MAC_OS_X_API_COND (4, CGContextFillEllipseInRect,
- arcPtr->angle1 == 0 && arcPtr->angle2 == 23040,
+ if (arcPtr->angle1 == 0 && arcPtr->angle2 == 23040) {
CGContextFillEllipseInRect(dc.context, rect);
- ) TK_ELSE (
+ } else {
CGMutablePathRef p = CGPathCreateMutable();
CGAffineTransform t = CGAffineTransformIdentity;
CGPoint c = CGPointMake(CGRectGetMidX(rect),
@@ -1326,52 +1389,6 @@ XFillArcs(
CGContextAddPath(dc.context, p);
CGPathRelease(p);
CGContextFillPath(dc.context);
- ) TK_ENDIF
- }
- } else {
- Rect theRect;
- short start, extent;
- int o = -lw/2;
- PolyHandle polygon;
- double sin1, cos1, sin2, cos2, angle;
- double boxWidth, boxHeight;
- double vertex[2], center1[2], center2[2];
-
- for (i = 0, arcPtr = arcArr;i<nArcs;i++, arcPtr++) {
- theRect.left = (short) (macWin->xOff + arcPtr->x + o);
- theRect.top = (short) (macWin->yOff + arcPtr->y + o);
- theRect.right = (short) (theRect.left + arcPtr->width + lw);
- theRect.bottom = (short) (theRect.top + arcPtr->height + lw);
- start = (short) (90 - (arcPtr->angle1/64));
- extent = (short) (- (arcPtr->angle2/64));
-
- if (gc->arc_mode == ArcChord) {
- boxWidth = theRect.right - theRect.left;
- boxHeight = theRect.bottom - theRect.top;
- angle = radians(-arcPtr->angle1/64.0);
- sin1 = sin(angle);
- cos1 = cos(angle);
- angle -= radians(arcPtr->angle2/64.0);
- sin2 = sin(angle);
- cos2 = cos(angle);
- vertex[0] = (theRect.left + theRect.right)/2.0;
- vertex[1] = (theRect.top + theRect.bottom)/2.0;
- center1[0] = vertex[0] + cos1*boxWidth/2.0;
- center1[1] = vertex[1] + sin1*boxHeight/2.0;
- center2[0] = vertex[0] + cos2*boxWidth/2.0;
- center2[1] = vertex[1] + sin2*boxHeight/2.0;
-
- polygon = OpenPoly();
- MoveTo((short) ((theRect.left + theRect.right)/2),
- (short) ((theRect.top + theRect.bottom)/2));
- LineTo((short) (center1[0] + .5), (short) (center1[1] + .5));
- LineTo((short) (center2[0] + .5), (short) (center2[1] + .5));
- ClosePoly();
- FillCArc(&theRect, start, extent, dc.penPat);
- FillCPoly(polygon, dc.penPat);
- KillPoly(polygon);
- } else {
- FillCArc(&theRect, start, extent, dc.penPat);
}
}
}
@@ -1424,56 +1441,39 @@ TkScrollWindow(
int dx, int dy, /* Distance rectangle should be moved. */
TkRegion damageRgn) /* Region to accumulate damage in. */
{
- MacDrawable *destDraw = (MacDrawable *) Tk_WindowId(tkwin);
- CGrafPtr destPort, savePort;
- Boolean portChanged;
- Rect scrollRect;
+ MacDrawable *macDraw = (MacDrawable *) Tk_WindowId(tkwin);
+ NSView *view = TkMacOSXDrawableView(macDraw);
+ CGRect visRect, srcRect, dstRect;
+ CGFloat boundsH;
+ HIShapeRef dmgRgn, dstRgn;
int result;
- HIShapeRef dmgRgn;
-
- /*
- * Due to the implementation below the behavior may be differnt
- * than X in certain cases that should never occur in Tk. The
- * scrollRect is the source rect extended by the offset (the union
- * of the source rect and the offset rect). Everything
- * in the extended scrollRect is scrolled. On X, it's possible
- * to "skip" over an area if the offset makes the source and
- * destination rects disjoint and non-aligned.
- */
-
- scrollRect.left = destDraw->xOff + x;
- scrollRect.top = destDraw->yOff + y;
- scrollRect.right = scrollRect.left + width;
- scrollRect.bottom = scrollRect.top + height;
- if (dx < 0) {
- scrollRect.left += dx;
- } else {
- scrollRect.right += dx;
- }
- if (dy < 0) {
- scrollRect.top += dy;
- } else {
- scrollRect.bottom += dy;
- }
- destPort = TkMacOSXGetDrawablePort(Tk_WindowId(tkwin));
- TkMacOSXSetUpClippingRgn(Tk_WindowId(tkwin));
- TkMacOSXCheckTmpQdRgnEmpty();
- portChanged = QDSwapPort(destPort, &savePort);
- ScrollRect(&scrollRect, dx, dy, tkMacOSXtmpQdRgn);
- if (portChanged) {
- QDSwapPort(savePort, NULL);
+ if (view && !CGRectIsEmpty(visRect = NSRectToCGRect([view visibleRect]))) {
+ boundsH = [view bounds].size.height;
+ srcRect = CGRectMake(macDraw->xOff + x, boundsH - height -
+ (macDraw->yOff + y), width, height);
+ dstRect = CGRectIntersection(CGRectOffset(srcRect, dx, -dy), visRect);
+ srcRect = CGRectIntersection(srcRect, visRect);
+ if (!CGRectIsEmpty(srcRect) && !CGRectIsEmpty(dstRect)) {
+ /*
+ CGRect sRect = CGRectIntersection(CGRectOffset(dstRect, -dx, dy),
+ srcRect);
+ NSCopyBits(0, NSRectFromCGRect(sRect),
+ NSPointFromCGPoint(CGRectOffset(sRect, dx, -dy).origin));
+ */
+ [view scrollRect:NSRectFromCGRect(srcRect) by:NSMakeSize(dx, -dy)];
+ }
+ srcRect.origin.y = boundsH - srcRect.size.height - srcRect.origin.y;
+ dstRect.origin.y = boundsH - dstRect.size.height - dstRect.origin.y;
+ srcRect = CGRectUnion(srcRect, dstRect);
+ dmgRgn = HIShapeCreateMutableWithRect(&srcRect);
+ dstRgn = HIShapeCreateWithRect(&dstRect);
+ ChkErr(HIShapeDifference, dmgRgn, dstRgn, (HIMutableShapeRef) dmgRgn);
+ CFRelease(dstRgn);
+ TkMacOSXInvalidateViewRegion(view, dmgRgn);
+ } else {
+ dmgRgn = HIShapeCreateEmpty();
}
-
- /*
- * Fortunately, the region returned by ScrollRect is semantically
- * the same as what we need to return in this function. If the
- * region is empty we return zero to denote that no damage was
- * created.
- */
-
- dmgRgn = HIShapeCreateWithQDRgn(tkMacOSXtmpQdRgn);
- SetEmptyRgn(tkMacOSXtmpQdRgn);
TkMacOSXSetWithNativeRegion(damageRgn, dmgRgn);
result = HIShapeIsEmpty(dmgRgn) ? 0 : 1;
CFRelease(dmgRgn);
@@ -1492,7 +1492,7 @@ TkScrollWindow(
* None.
*
* Side effects:
- * The current port is adjusted.
+ * None.
*
*----------------------------------------------------------------------
*/
@@ -1500,42 +1500,12 @@ TkScrollWindow(
void
TkMacOSXSetUpGraphicsPort(
GC gc, /* GC to apply to current port. */
- GWorldPtr destPort)
+ void *destPort)
{
- CGrafPtr savePort;
- Boolean portChanged;
-
- portChanged = QDSwapPort(destPort, &savePort);
- PenNormal();
- if (gc) {
- if (!penPat) {
- if (!tmpPixPat) {
- penPat = NewPixPat();
- } else {
- penPat = tmpPixPat;
- tmpPixPat = NULL;
- }
- }
- TkMacOSXSetColorInPort(gc->foreground, 1, penPat, destPort);
- PenPixPat(penPat);
- if(gc->function == GXxor) {
- PenMode(patXor);
- }
- if (gc->line_width > 1) {
- PenSize(gc->line_width, gc->line_width);
- }
- if (gc->line_style != LineSolid) {
- /*
- * FIXME: Here the dash pattern should be set in the drawing
- * environment. This is not possible with QuickDraw line drawing.
- */
- }
- }
- if (portChanged) {
- QDSwapPort(savePort, NULL);
- }
+ Tcl_Panic("TkMacOSXSetUpGraphicsPort: Obsolete, no more QD!");
}
+
/*
*----------------------------------------------------------------------
*
@@ -1562,101 +1532,97 @@ TkMacOSXSetupDrawingContext(
TkMacOSXDrawingContext *dcPtr)
{
MacDrawable *macDraw = ((MacDrawable*)d);
- int dontDraw = 0;
- TkMacOSXDrawingContext dc = {NULL, NULL, NULL, NULL, NULL, NULL, NULL,
- {SHRT_MIN, SHRT_MIN, SHRT_MAX, SHRT_MAX}, false};
-
- if (tkPictureIsOpen) {
- if (useCG) {
- TkMacOSXDbgMsg("Ignored CG Drawing with QD Picture open");
- dontDraw = 1;
- }
- } else {
- dc.clipRgn = TkMacOSXGetClipRgn(d);
- }
+ int dontDraw = 0, isWin = 0;
+ TkMacOSXDrawingContext dc = {};
+ CGRect clipBounds;
+
+ dc.clipRgn = TkMacOSXGetClipRgn(d);
if (!dontDraw) {
ClipToGC(d, gc, &dc.clipRgn);
dontDraw = dc.clipRgn ? HIShapeIsEmpty(dc.clipRgn) : 0;
}
if (dontDraw) {
- if (dc.clipRgn) {
- CFRelease(dc.clipRgn);
- dc.clipRgn = NULL;
- }
goto end;
}
if (useCG) {
- dc.context = macDraw->context;
+ dc.context = GetCGContextForDrawable(d);
}
if (!dc.context || !(macDraw->flags & TK_IS_PIXMAP)) {
- dc.port = TkMacOSXGetDrawablePort(d);
- if (dc.port) {
- GetPortBounds(dc.port, &dc.portBounds);
- }
+ isWin = (TkMacOSXDrawableWindow(d) != nil);
}
if (dc.context) {
- if (!dc.port) {
- CGRect r;
-
- TK_IF_MAC_OS_X_API (3, CGContextGetClipBoundingBox,
- r = CGContextGetClipBoundingBox(dc.context);
- ) TK_ELSE_MAC_OS_X (3,
- r.origin = CGPointZero;
- r.size = macDraw->size;
- ) TK_ENDIF
- SetRect(&dc.portBounds, r.origin.x + macDraw->xOff,
- r.origin.y + macDraw->yOff,
- r.origin.x + r.size.width + macDraw->xOff,
- r.origin.y + r.size.height + macDraw->yOff);
- }
- CGContextSaveGState(dc.context);
- dc.saveState = (void*)1;
- dc.port = NULL;
- } else if (dc.port) {
- dc.portChanged = QDSwapPort(dc.port, &dc.savePort);
- if (useCG && ChkErr(QDBeginCGContext, dc.port, &dc.context) == noErr) {
- SyncCGContextOriginWithPort(dc.context, dc.port);
+ dc.portBounds = clipBounds = CGContextGetClipBoundingBox(dc.context);
+ } else if (isWin) {
+ NSView *view = TkMacOSXDrawableView(macDraw);
+ if (view) {
+ if (view != [NSView focusView]) {
+ dc.focusLocked = [view lockFocusIfCanDraw];
+ dontDraw = !dc.focusLocked;
+ } else {
+ dontDraw = ![view canDraw];
+ }
+ if (dontDraw) {
+ goto end;
+ }
+ dc.view = view;
+ dc.context = [[NSGraphicsContext currentContext] graphicsPort];
+ dc.portBounds = NSRectToCGRect([view bounds]);
+ if (dc.clipRgn) {
+ clipBounds = CGContextGetClipBoundingBox(dc.context);
+ }
} else {
- dc.context = NULL;
+ Tcl_Panic("TkMacOSXSetupDrawingContext(): "
+ "no NSView to draw into !");
}
} else {
Tcl_Panic("TkMacOSXSetupDrawingContext(): "
- "no port or context to draw into !");
+ "no context to draw into !");
}
if (dc.context) {
- CGContextConcatCTM(dc.context, CGAffineTransformMake(1.0, 0.0, 0.0,
- -1.0, 0.0, dc.portBounds.bottom - dc.portBounds.top));
+ CGAffineTransform t = { .a = 1, .b = 0, .c = 0, .d = -1, .tx = 0,
+ .ty = dc.portBounds.size.height};
+ dc.portBounds.origin.x += macDraw->xOff;
+ dc.portBounds.origin.y += macDraw->yOff;
+ if (!dc.focusLocked) {
+ CGContextSaveGState(dc.context);
+ }
+ CGContextSetTextDrawingMode(dc.context, kCGTextFill);
+ CGContextConcatCTM(dc.context, t);
if (dc.clipRgn) {
#ifdef TK_MAC_DEBUG_DRAWING
CGContextSaveGState(dc.context);
ChkErr(HIShapeReplacePathInCGContext, dc.clipRgn, dc.context);
- CGContextSetRGBFillColor(dc.context, 1.0, 0.0, 0.0, 0.2);
+ CGContextSetRGBFillColor(dc.context, 1.0, 0.0, 0.0, 0.1);
CGContextEOFillPath(dc.context);
CGContextRestoreGState(dc.context);
#endif /* TK_MAC_DEBUG_DRAWING */
- ChkErr(HIShapeReplacePathInCGContext, dc.clipRgn, dc.context);
- CGContextEOClip(dc.context);
+ CGRect r;
+ if (!HIShapeIsRectangular(dc.clipRgn) || !CGRectContainsRect(
+ *HIShapeGetBounds(dc.clipRgn, &r),
+ CGRectApplyAffineTransform(clipBounds, t))) {
+ ChkErr(HIShapeReplacePathInCGContext, dc.clipRgn, dc.context);
+ CGContextEOClip(dc.context);
+ }
}
if (gc) {
static const CGLineCap cgCap[] = {
- [CapNotLast] = kCGLineCapButt,
- [CapButt] = kCGLineCapButt,
- [CapRound] = kCGLineCapRound,
- [CapProjecting] = kCGLineCapSquare,
+ [CapNotLast] = kCGLineCapButt,
+ [CapButt] = kCGLineCapButt,
+ [CapRound] = kCGLineCapRound,
+ [CapProjecting] = kCGLineCapSquare,
};
static const CGLineJoin cgJoin[] = {
- [JoinMiter] = kCGLineJoinMiter,
- [JoinRound] = kCGLineJoinRound,
- [JoinBevel] = kCGLineJoinBevel,
+ [JoinMiter] = kCGLineJoinMiter,
+ [JoinRound] = kCGLineJoinRound,
+ [JoinBevel] = kCGLineJoinBevel,
};
bool shouldAntialias;
double w = gc->line_width;
- TkMacOSXSetColorInContext(gc->foreground, dc.context);
- if (dc.port) {
+ TkMacOSXSetColorInContext(gc, gc->foreground, dc.context);
+ if (isWin) {
CGContextSetPatternPhase(dc.context, CGSizeMake(
- dc.portBounds.right - dc.portBounds.left,
- dc.portBounds.bottom - dc.portBounds.top));
+ dc.portBounds.size.width, dc.portBounds.size.height));
}
if(gc->function != GXcopy) {
TkMacOSXDbgMsg("Logical functions other than GXcopy are "
@@ -1673,8 +1639,8 @@ TkMacOSXSetupDrawingContext(
if (gc->line_style != LineSolid) {
int num = 0;
char *p = &(gc->dashes);
- double dashOffset = gc->dash_offset;
- float lengths[10];
+ CGFloat dashOffset = gc->dash_offset;
+ CGFloat lengths[10];
while (p[num] != '\0' && num < 10) {
lengths[num] = p[num];
@@ -1691,26 +1657,12 @@ TkMacOSXSetupDrawingContext(
cgJoin[(unsigned)gc->join_style]);
}
}
- } else if (dc.port) {
- PixPatHandle savePat = penPat;
-
- ChkErr(GetThemeDrawingState, &dc.saveState);
- penPat = NULL;
- TkMacOSXSetUpGraphicsPort(gc, dc.port);
- dc.penPat = penPat;
- penPat = savePat;
- dc.saveClip = NewRgn();
- GetPortClipRegion(dc.port, dc.saveClip);
- if (dc.clipRgn) {
- ChkErr(HIShapeSetQDClip, dc.clipRgn, dc.port);
- } else {
- NoQDClip(dc.port);
- }
- if (!tkPictureIsOpen) {
- ShowPen();
- }
}
end:
+ if (dontDraw && dc.clipRgn) {
+ CFRelease(dc.clipRgn);
+ dc.clipRgn = NULL;
+ }
*dcPtr = dc;
return !dontDraw;
}
@@ -1737,38 +1689,15 @@ TkMacOSXRestoreDrawingContext(
{
if (dcPtr->context) {
CGContextSynchronize(dcPtr->context);
- if (dcPtr->saveState) {
+ if (dcPtr->focusLocked) {
+ [dcPtr->view unlockFocus];
+ } else {
CGContextRestoreGState(dcPtr->context);
}
- if (dcPtr->port) {
- ChkErr(QDEndCGContext, dcPtr->port, &(dcPtr->context));
- }
- } else if (dcPtr->port) {
- if (!tkPictureIsOpen) {
- HidePen();
- }
- PenNormal();
- if (dcPtr->saveClip) {
- SetPortClipRegion(dcPtr->port, dcPtr->saveClip);
- DisposeRgn(dcPtr->saveClip);
- }
- if (dcPtr->penPat) {
- if (!tmpPixPat) {
- tmpPixPat = dcPtr->penPat;
- } else {
- DisposePixPat(dcPtr->penPat);
- }
- }
- if (dcPtr->saveState) {
- ChkErr(SetThemeDrawingState, dcPtr->saveState, true);
- }
}
if (dcPtr->clipRgn) {
CFRelease(dcPtr->clipRgn);
}
- if (dcPtr->portChanged) {
- QDSwapPort(dcPtr->savePort, NULL);
- }
#ifdef TK_MAC_DEBUG
bzero(dcPtr, sizeof(TkMacOSXDrawingContext));
#endif /* TK_MAC_DEBUG */
@@ -1797,35 +1726,31 @@ TkMacOSXGetClipRgn(
{
MacDrawable *macDraw = (MacDrawable *) drawable;
HIShapeRef clipRgn = NULL;
- CGRect r;
if (macDraw->winPtr && macDraw->flags & TK_CLIP_INVALID) {
TkMacOSXUpdateClipRgn(macDraw->winPtr);
#ifdef TK_MAC_DEBUG_DRAWING
- TkMacOSXDbgMsg("%s visRgn ", macDraw->winPtr->pathName);
- TkMacOSXDebugFlashRegion(drawable, macDraw->visRgn);
+ TkMacOSXDbgMsg("%s", macDraw->winPtr->pathName);
+ NSView *view = TkMacOSXDrawableView(macDraw);
+ if ([view lockFocusIfCanDraw]) {
+ CGContextRef context = [[NSGraphicsContext currentContext] graphicsPort];
+ CGContextSaveGState(context);
+ CGContextConcatCTM(context, CGAffineTransformMake(1.0, 0.0, 0.0,
+ -1.0, 0.0, [view bounds].size.height));
+ ChkErr(HIShapeReplacePathInCGContext, macDraw->visRgn, context);
+ CGContextSetRGBFillColor(context, 0.0, 1.0, 0.0, 0.1);
+ CGContextEOFillPath(context);
+ CGContextRestoreGState(context);
+ [view unlockFocus];
+ }
#endif /* TK_MAC_DEBUG_DRAWING */
}
- if (macDraw->flags & TK_CLIPPED_DRAW) {
- r = CGRectOffset(macDraw->drawRect, macDraw->xOff, macDraw->yOff);
- }
- if (macDraw->visRgn) {
- if (macDraw->flags & TK_CLIPPED_DRAW) {
- HIShapeRef rgn = HIShapeCreateWithRect(&r);
-
- clipRgn = HIShapeCreateIntersection(macDraw->visRgn, rgn);
- CFRelease(rgn);
- } else {
- clipRgn = HIShapeCreateCopy(macDraw->visRgn);
- }
- } else if (macDraw->flags & TK_CLIPPED_DRAW) {
- clipRgn = HIShapeCreateWithRect(&r);
+ if (macDraw->drawRgn) {
+ clipRgn = HIShapeCreateCopy(macDraw->drawRgn);
+ } else if (macDraw->visRgn) {
+ clipRgn = HIShapeCreateCopy(macDraw->visRgn);
}
-#ifdef TK_MAC_DEBUG_DRAWING
- TkMacOSXDbgMsg("%s clipRgn ", macDraw->winPtr->pathName);
- TkMacOSXDebugFlashRegion(drawable, clipRgn);
-#endif /* TK_MAC_DEBUG_DRAWING */
return clipRgn;
}
@@ -1842,7 +1767,7 @@ TkMacOSXGetClipRgn(
* None.
*
* Side effects:
- * The clipping region in the current port is changed.
+ * None.
*
*----------------------------------------------------------------------
*/
@@ -1851,16 +1776,6 @@ void
TkMacOSXSetUpClippingRgn(
Drawable drawable) /* Drawable to update. */
{
- CGrafPtr port = TkMacOSXGetDrawablePort(drawable);
-
- if (port) {
- HIShapeRef clipRgn = TkMacOSXGetClipRgn(drawable);
-
- if (clipRgn) {
- ChkErr(HIShapeSetQDClip, clipRgn, port);
- CFRelease(clipRgn);
- }
- }
}
/*
@@ -1869,7 +1784,7 @@ TkMacOSXSetUpClippingRgn(
* TkpClipDrawableToRect --
*
* Clip all drawing into the drawable d to the given rectangle.
- * If width and height are negative, reset to no clipping.
+ * If width or height are negative, reset to no clipping.
*
* Results:
* None.
@@ -1888,13 +1803,38 @@ TkpClipDrawableToRect(
int width, int height)
{
MacDrawable *macDraw = (MacDrawable *) d;
+ NSView *view = TkMacOSXDrawableView(macDraw);
- if (width < 0 && height < 0) {
- macDraw->drawRect = CGRectNull;
- macDraw->flags &= ~TK_CLIPPED_DRAW;
+ if (macDraw->drawRgn) {
+ CFRelease(macDraw->drawRgn);
+ macDraw->drawRgn = NULL;
+ }
+ if (width >= 0 && height >= 0) {
+ CGRect drawRect = CGRectMake(x + macDraw->xOff, y + macDraw->yOff,
+ width, height);
+ HIShapeRef drawRgn = HIShapeCreateWithRect(&drawRect);
+
+ if (macDraw->winPtr && macDraw->flags & TK_CLIP_INVALID) {
+ TkMacOSXUpdateClipRgn(macDraw->winPtr);
+ }
+ if (macDraw->visRgn) {
+ macDraw->drawRgn = HIShapeCreateIntersection(macDraw->visRgn,
+ drawRgn);
+ CFRelease(drawRgn);
+ } else {
+ macDraw->drawRgn = drawRgn;
+ }
+ if (view && view != [NSView focusView] && [view lockFocusIfCanDraw]) {
+ drawRect.origin.y = [view bounds].size.height -
+ (drawRect.origin.y + drawRect.size.height);
+ NSRectClip(NSRectFromCGRect(drawRect));
+ macDraw->flags |= TK_FOCUSED_VIEW;
+ }
} else {
- macDraw->drawRect = CGRectMake(x, y, width, height);
- macDraw->flags |= TK_CLIPPED_DRAW;
+ if (view && (macDraw->flags & TK_FOCUSED_VIEW)) {
+ [view unlockFocus];
+ macDraw->flags &= ~TK_FOCUSED_VIEW;
+ }
}
}
@@ -1927,9 +1867,7 @@ ClipToGC(
int yOffset = ((MacDrawable *) d)->yOff + gc->clip_y_origin;
HIShapeRef clipRgn = *clipRgnPtr, gcClipRgn;
- if (!tkPictureIsOpen) {
- TkMacOSXOffsetRegion(gcClip, xOffset, yOffset);
- }
+ TkMacOSXOffsetRegion(gcClip, xOffset, yOffset);
gcClipRgn = TkMacOSXGetNativeRegion(gcClip);
if (clipRgn) {
*clipRgnPtr = HIShapeCreateIntersection(gcClipRgn, clipRgn);
@@ -1938,39 +1876,8 @@ ClipToGC(
*clipRgnPtr = HIShapeCreateCopy(gcClipRgn);
}
CFRelease(gcClipRgn);
- if (!tkPictureIsOpen) {
- TkMacOSXOffsetRegion(gcClip, -xOffset, -yOffset);
- }
- }
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * NoQDClip --
- *
- * Helper function to setup a QD port to not clip anything.
- *
- * Results:
- * None.
- *
- * Side effects:
- * None.
- *
- *----------------------------------------------------------------------
- */
-
-static void
-NoQDClip(
- CGrafPtr port)
-{
- static RgnHandle noClipRgn = NULL;
-
- if (!noClipRgn) {
- noClipRgn = NewRgn();
- SetRectRgn(noClipRgn, SHRT_MIN, SHRT_MIN, SHRT_MAX, SHRT_MAX);
+ TkMacOSXOffsetRegion(gcClip, -xOffset, -yOffset);
}
- SetPortClipRegion(port, noClipRgn);
}
/*
@@ -1992,45 +1899,12 @@ NoQDClip(
*----------------------------------------------------------------------
*/
-BitMapPtr
+void *
TkMacOSXMakeStippleMap(
Drawable drawable, /* Window to apply stipple. */
Drawable stipple) /* The stipple pattern. */
{
- CGrafPtr stipplePort;
- BitMapPtr bitmapPtr;
- const BitMap *stippleBitmap;
- Rect portRect;
- int width, height, stippleHeight, stippleWidth, i, j;
- Rect bounds;
-
- GetPortBounds(TkMacOSXGetDrawablePort(drawable), &portRect);
- width = portRect.right - portRect.left;
- height = portRect.bottom - portRect.top;
- bitmapPtr = (BitMap *) ckalloc(sizeof(BitMap));
- bitmapPtr->bounds.top = bitmapPtr->bounds.left = 0;
- bitmapPtr->bounds.right = (short) width;
- bitmapPtr->bounds.bottom = (short) height;
- bitmapPtr->rowBytes = (width / 8) + 1;
- bitmapPtr->baseAddr = ckalloc(height * bitmapPtr->rowBytes);
-
- stipplePort = TkMacOSXGetDrawablePort(stipple);
- stippleBitmap = GetPortBitMapForCopyBits(stipplePort);
- GetPortBounds(stipplePort, &portRect);
- stippleWidth = portRect.right - portRect.left;
- stippleHeight = portRect.bottom - portRect.top;
-
- for (i = 0; i < height; i += stippleHeight) {
- for (j = 0; j < width; j += stippleWidth) {
- bounds.left = j;
- bounds.top = i;
- bounds.right = j + stippleWidth;
- bounds.bottom = i + stippleHeight;
- CopyBits(stippleBitmap, bitmapPtr, &portRect, &bounds, srcCopy,
- NULL);
- }
- }
- return bitmapPtr;
+ return NULL;
}
/*
@@ -2118,3 +1992,12 @@ TkpDrawFrame(
Tk_Height(tkwin) - 2 * highlightWidth,
borderWidth, relief);
}
+
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 4
+ * fill-column: 79
+ * coding: utf-8
+ * End:
+ */