void
XFillRectangles(
Display* display, /* Display. */
Drawable d, /* Draw on this. */
GC gc, /* Use this GC. */
XRectangle *rectangles, /* Rectangle array. */
int n_rectangels) /* Number of rectangles. */
{
MacDrawable *macWin = (MacDrawable *) d;
CGrafPtr saveWorld;
GDHandle saveDevice;
GWorldPtr destPort;
Rect theRect;
int i;
destPort = TkMacGetDrawablePort(d);
display->request++;
GetGWorld(&saveWorld, &saveDevice);
SetGWorld(destPort, NULL);
TkMacSetUpClippingRgn(d);
TkMacSetUpGraphicsPort(gc);
for (i=0; i<n_rectangels; i++) {
theRect.left = (short) (macWin->xOff + rectangles[i].x);
theRect.top = (short) (macWin->yOff + rectangles[i].y);
theRect.right = (short) (theRect.left + rectangles[i].width);
theRect.bottom = (short) (theRect.top + rectangles[i].height);
FillCRect(&theRect, gPenPat);
}
SetGWorld(saveWorld, saveDevice);
}
GWorldPtr
TkMacGetDrawablePort(
Drawable drawable)
{
MacDrawable *macWin = (MacDrawable *) drawable;
GWorldPtr resultPort = NULL;
if (macWin == NULL) {
return NULL;
}
/*
* This is NULL for off-screen pixmaps. Then the portPtr
* always points to the off-screen port, and we don't
* have to worry about containment
*/
if (macWin->clipRgn == NULL) {
return macWin->portPtr;
}
/*
* If the Drawable is in an embedded window, use the Port of its container.
*
* TRICKY POINT: we can have cases when a toplevel is being destroyed
* where the winPtr for the toplevel has been freed, but the children
* are not all the way destroyed. The children will call this function
* as they are being destroyed, but Tk_IsEmbedded will return garbage.
* So we check the copy of the TK_EMBEDDED flag we put into the
* toplevel's macWin flags.
*/
if (!(macWin->toplevel->flags & TK_EMBEDDED)) {
return macWin->toplevel->portPtr;
} else {
TkWindow *contWinPtr;
contWinPtr = TkpGetOtherWindow(macWin->toplevel->winPtr);
if (contWinPtr != NULL) {
resultPort = TkMacGetDrawablePort((Drawable) contWinPtr->privatePtr);
} else if (gMacEmbedHandler != NULL) {
resultPort = gMacEmbedHandler->getPortProc(
(Tk_Window) macWin->winPtr);
}
if (resultPort == NULL) {
panic("TkMacGetDrawablePort couldn't find container");
return NULL;
}
/*
* NOTE: Here we should handle out of process embedding.
*/
}
return resultPort;
}
BitMapPtr
TkMacMakeStippleMap(
Drawable drawable, /* Window to apply stipple. */
Drawable stipple) /* The stipple pattern. */
{
MacDrawable *destDraw = (MacDrawable *) drawable;
GWorldPtr destPort;
BitMapPtr bitmapPtr;
int width, height, stippleHeight, stippleWidth;
int i, j;
char * data;
Rect bounds;
destPort = TkMacGetDrawablePort(drawable);
width = destPort->portRect.right - destPort->portRect.left;
height = destPort->portRect.bottom - destPort->portRect.top;
bitmapPtr = (BitMap *) ckalloc(sizeof(BitMap));
data = (char *) ckalloc(height * ((width / 8) + 1));
bitmapPtr->bounds.top = bitmapPtr->bounds.left = 0;
bitmapPtr->bounds.right = (short) width;
bitmapPtr->bounds.bottom = (short) height;
bitmapPtr->baseAddr = data;
bitmapPtr->rowBytes = (width / 8) + 1;
destPort = TkMacGetDrawablePort(stipple);
stippleWidth = destPort->portRect.right - destPort->portRect.left;
stippleHeight = destPort->portRect.bottom - destPort->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(&((GrafPtr) destPort)->portBits, bitmapPtr,
&((GrafPtr) destPort)->portRect, &bounds, srcCopy, NULL);
}
}
return bitmapPtr;
}
void
XMapWindow(
Display* display, /* Display. */
Window window) /* Window. */
{
MacDrawable *macWin = (MacDrawable *) window;
XEvent event;
GWorldPtr destPort;
/*
* Under certain situations it's possible for this function to be
* called before the toplevel window it's associated with has actually
* been mapped. In that case we need to create the real Macintosh
* window now as this function as well as other X functions assume that
* the portPtr is valid.
*/
if (!TkMacHostToplevelExists(macWin->toplevel->winPtr)) {
TkMacMakeRealWindowExist(macWin->toplevel->winPtr);
}
destPort = TkMacGetDrawablePort(window);
display->request++;
macWin->winPtr->flags |= TK_MAPPED;
if (Tk_IsTopLevel(macWin->winPtr)) {
if (!Tk_IsEmbedded(macWin->winPtr)) {
ShowWindow((WindowRef) destPort);
}
/*
* We only need to send the MapNotify event
* for toplevel windows.
*/
event.xany.serial = display->request;
event.xany.send_event = False;
event.xany.display = display;
event.xmap.window = window;
event.xmap.type = MapNotify;
event.xmap.event = window;
event.xmap.override_redirect = macWin->winPtr->atts.override_redirect;
Tk_QueueWindowEvent(&event, TCL_QUEUE_TAIL);
} else {
TkMacInvalClipRgns(macWin->winPtr->parentPtr);
}
/*
* Generate damage for that area of the window
*/
SetGWorld(destPort, NULL);
TkMacUpdateClipRgn(macWin->winPtr);
TkMacInvalidateWindow(macWin, TK_PARENT_WINDOW);
}
void
XFillPolygon(
Display* display, /* Display. */
Drawable d, /* Draw on this. */
GC gc, /* Use this GC. */
XPoint* points, /* Array of points. */
int npoints, /* Number of points. */
int shape, /* Shape to draw. */
int mode) /* Drawing mode. */
{
MacDrawable *macWin = (MacDrawable *) d;
PolyHandle polygon;
CGrafPtr saveWorld;
GDHandle saveDevice;
GWorldPtr destPort;
int i;
destPort = TkMacGetDrawablePort(d);
display->request++;
GetGWorld(&saveWorld, &saveDevice);
SetGWorld(destPort, NULL);
TkMacSetUpClippingRgn(d);
TkMacSetUpGraphicsPort(gc);
PenNormal();
polygon = OpenPoly();
MoveTo((short) (macWin->xOff + points[0].x),
(short) (macWin->yOff + points[0].y));
for (i = 1; i < npoints; i++) {
if (mode == CoordModePrevious) {
Line((short) (macWin->xOff + points[i].x),
(short) (macWin->yOff + points[i].y));
} else {
LineTo((short) (macWin->xOff + points[i].x),
(short) (macWin->yOff + points[i].y));
}
}
ClosePoly();
FillCPoly(polygon, gPenPat);
KillPoly(polygon);
SetGWorld(saveWorld, saveDevice);
}
void
XDrawLines(
Display* display, /* Display. */
Drawable d, /* Draw on this. */
GC gc, /* Use this GC. */
XPoint* points, /* Array of points. */
int npoints, /* Number of points. */
int mode) /* Line drawing mode. */
{
MacDrawable *macWin = (MacDrawable *) d;
CGrafPtr saveWorld;
GWorldPtr destPort;
GDHandle saveDevice;
int i;
destPort = TkMacGetDrawablePort(d);
display->request++;
if (npoints < 2) {
return; /* TODO: generate BadValue error. */
}
GetGWorld(&saveWorld, &saveDevice);
SetGWorld(destPort, NULL);
TkMacSetUpClippingRgn(d);
TkMacSetUpGraphicsPort(gc);
ShowPen();
PenPixPat(gPenPat);
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) (macWin->xOff + points[i].x),
(short) (macWin->yOff + points[i].y));
}
}
SetGWorld(saveWorld, saveDevice);
}
void
XConfigureWindow(
Display* display, /* Display. */
Window w, /* Window. */
unsigned int value_mask,
XWindowChanges* values)
{
MacDrawable *macWin = (MacDrawable *) w;
TkWindow *winPtr = macWin->winPtr;
display->request++;
/*
* Change the shape and/or position of the window.
*/
if (value_mask & (CWX|CWY|CWWidth|CWHeight)) {
XMoveResizeWindow(display, w, winPtr->changes.x, winPtr->changes.y,
winPtr->changes.width, winPtr->changes.height);
}
/*
* Change the stacking order of the window. Tk actuall keeps all
* the information we need for stacking order. All we need to do
* is make sure the clipping regions get updated and generate damage
* that will ensure things get drawn correctly.
*/
if (value_mask & CWStackMode) {
Rect bounds;
GWorldPtr destPort;
destPort = TkMacGetDrawablePort(w);
if (destPort != NULL) {
SetPort((GrafPtr) destPort);
TkMacInvalClipRgns(winPtr->parentPtr);
TkMacWinBounds(winPtr, &bounds);
InvalRect(&bounds);
}
}
/* TkGenWMMoveRequestEvent(macWin->winPtr,
macWin->winPtr->changes.x, macWin->winPtr->changes.y); */
}
void
XDrawArc(
Display* display, /* Display. */
Drawable d, /* Draw on this. */
GC gc, /* Use this GC. */
int x, /* Upper left of */
int y, /* bounding rect. */
unsigned int width, /* Width & height. */
unsigned int height,
int angle1, /* Staring angle of arc. */
int angle2) /* Ending angle of arc. */
{
MacDrawable *macWin = (MacDrawable *) d;
Rect theRect;
short start, extent;
CGrafPtr saveWorld;
GDHandle saveDevice;
GWorldPtr destPort;
destPort = TkMacGetDrawablePort(d);
display->request++;
GetGWorld(&saveWorld, &saveDevice);
SetGWorld(destPort, NULL);
TkMacSetUpClippingRgn(d);
TkMacSetUpGraphicsPort(gc);
theRect.left = (short) (macWin->xOff + x);
theRect.top = (short) (macWin->yOff + y);
theRect.right = (short) (theRect.left + width);
theRect.bottom = (short) (theRect.top + height);
start = (short) (90 - (angle1 / 64));
extent = (short) (-(angle2 / 64));
ShowPen();
PenPixPat(gPenPat);
FrameArc(&theRect, start, extent);
SetGWorld(saveWorld, saveDevice);
}
void
TkMacSetUpClippingRgn(
Drawable drawable) /* Drawable to update. */
{
MacDrawable *macDraw = (MacDrawable *) drawable;
if (macDraw->winPtr != NULL) {
if (macDraw->flags & TK_CLIP_INVALID) {
TkMacUpdateClipRgn(macDraw->winPtr);
}
/*
* When a menu is up, the Mac does not expect drawing to occur and
* does not clip out the menu. We have to do it ourselves. This
* is pretty gross.
*/
if (macDraw->clipRgn != NULL) {
if (tkUseMenuCascadeRgn == 1) {
Point scratch = {0, 0};
GDHandle saveDevice;
GWorldPtr saveWorld;
GetGWorld(&saveWorld, &saveDevice);
SetGWorld(TkMacGetDrawablePort(drawable), NULL);
LocalToGlobal(&scratch);
SetGWorld(saveWorld, saveDevice);
if (tmpRgn == NULL) {
tmpRgn = NewRgn();
}
CopyRgn(tkMenuCascadeRgn, tmpRgn);
OffsetRgn(tmpRgn, -scratch.h, -scratch.v);
DiffRgn(macDraw->clipRgn, tmpRgn, tmpRgn);
SetClip(tmpRgn);
macDraw->toplevel->flags |= TK_DRAWN_UNDER_MENU;
} else {
SetClip(macDraw->clipRgn);
}
}
}
}
void
XUnmapWindow(
Display* display, /* Display. */
Window window) /* Window. */
{
MacDrawable *macWin = (MacDrawable *) window;
XEvent event;
GWorldPtr destPort;
destPort = TkMacGetDrawablePort(window);
display->request++;
macWin->winPtr->flags &= ~TK_MAPPED;
if (Tk_IsTopLevel(macWin->winPtr)) {
if (!Tk_IsEmbedded(macWin->winPtr)) {
HideWindow((WindowRef) destPort);
}
/*
* We only need to send the UnmapNotify event
* for toplevel windows.
*/
event.xany.serial = display->request;
event.xany.send_event = False;
event.xany.display = display;
event.xunmap.type = UnmapNotify;
event.xunmap.window = window;
event.xunmap.event = window;
event.xunmap.from_configure = false;
Tk_QueueWindowEvent(&event, TCL_QUEUE_TAIL);
} else {
/*
* Generate damage for that area of the window.
*/
SetGWorld(destPort, NULL);
TkMacInvalidateWindow(macWin, TK_PARENT_WINDOW); /* TODO: may not be valid */
TkMacInvalClipRgns(macWin->winPtr->parentPtr);
}
}
void
XDrawRectangle(
Display* display, /* Display. */
Drawable d, /* Draw on this. */
GC gc, /* Use this GC. */
int x, /* Upper left corner. */
int y,
unsigned int width, /* Width & height of rect. */
unsigned int height)
{
MacDrawable *macWin = (MacDrawable *) d;
Rect theRect;
CGrafPtr saveWorld;
GDHandle saveDevice;
GWorldPtr destPort;
destPort = TkMacGetDrawablePort(d);
display->request++;
GetGWorld(&saveWorld, &saveDevice);
SetGWorld(destPort, NULL);
TkMacSetUpClippingRgn(d);
TkMacSetUpGraphicsPort(gc);
theRect.left = (short) (macWin->xOff + x);
theRect.top = (short) (macWin->yOff + y);
theRect.right = (short) (theRect.left + width);
theRect.bottom = (short) (theRect.top + height);
ShowPen();
PenPixPat(gPenPat);
FrameRect(&theRect);
SetGWorld(saveWorld, saveDevice);
}
void XDrawSegments(
Display *display,
Drawable d,
GC gc,
XSegment *segments,
int nsegments)
{
MacDrawable *macWin = (MacDrawable *) d;
CGrafPtr saveWorld;
GWorldPtr destPort;
GDHandle saveDevice;
int i;
destPort = TkMacGetDrawablePort(d);
display->request++;
GetGWorld(&saveWorld, &saveDevice);
SetGWorld(destPort, NULL);
TkMacSetUpClippingRgn(d);
TkMacSetUpGraphicsPort(gc);
ShowPen();
PenPixPat(gPenPat);
for (i = 0; i < nsegments; i++) {
MoveTo((short) (macWin->xOff + segments[i].x1),
(short) (macWin->yOff + segments[i].y1));
LineTo((short) (macWin->xOff + segments[i].x2),
(short) (macWin->yOff + segments[i].y2));
}
SetGWorld(saveWorld, saveDevice);
}
void
XCopyArea(
Display* display, /* Display. */
Drawable src, /* Source drawable. */
Drawable dest, /* Destination drawable. */
GC gc, /* GC to use. */
int src_x, /* X & Y, width & height */
int src_y, /* define the source rectangle */
unsigned int width, /* the will be copied. */
unsigned int height,
int dest_x, /* Dest X & Y on dest rect. */
int dest_y)
{
Rect srcRect, destRect;
BitMapPtr srcBit, destBit;
MacDrawable *srcDraw = (MacDrawable *) src;
MacDrawable *destDraw = (MacDrawable *) dest;
GWorldPtr srcPort, destPort;
CGrafPtr saveWorld;
GDHandle saveDevice;
short tmode;
RGBColor origForeColor, origBackColor, whiteColor, blackColor;
destPort = TkMacGetDrawablePort(dest);
srcPort = TkMacGetDrawablePort(src);
display->request++;
GetGWorld(&saveWorld, &saveDevice);
SetGWorld(destPort, NULL);
GetForeColor(&origForeColor);
GetBackColor(&origBackColor);
whiteColor.red = 0;
whiteColor.blue = 0;
whiteColor.green = 0;
RGBForeColor(&whiteColor);
blackColor.red = 0xFFFF;
blackColor.blue = 0xFFFF;
blackColor.green = 0xFFFF;
RGBBackColor(&blackColor);
TkMacSetUpClippingRgn(dest);
/*
* We will change the clip rgn in this routine, so we need to
* be able to restore it when we exit.
*/
if (tmpRgn2 == NULL) {
tmpRgn2 = NewRgn();
}
GetClip(tmpRgn2);
if (((TkpClipMask*)gc->clip_mask)->type == TKP_CLIP_REGION) {
RgnHandle clipRgn = (RgnHandle)
((TkpClipMask*)gc->clip_mask)->value.region;
int xOffset, yOffset;
if (tmpRgn == NULL) {
tmpRgn = NewRgn();
}
xOffset = destDraw->xOff + gc->clip_x_origin;
yOffset = destDraw->yOff + gc->clip_y_origin;
OffsetRgn(clipRgn, xOffset, yOffset);
GetClip(tmpRgn);
SectRgn(tmpRgn, clipRgn, tmpRgn);
SetClip(tmpRgn);
OffsetRgn(clipRgn, -xOffset, -yOffset);
}
srcBit = &((GrafPtr) srcPort)->portBits;
destBit = &((GrafPtr) destPort)->portBits;
SetRect(&srcRect, (short) (srcDraw->xOff + src_x),
(short) (srcDraw->yOff + src_y),
(short) (srcDraw->xOff + src_x + width),
(short) (srcDraw->yOff + src_y + height));
SetRect(&destRect, (short) (destDraw->xOff + dest_x),
(short) (destDraw->yOff + dest_y),
(short) (destDraw->xOff + dest_x + width),
(short) (destDraw->yOff + dest_y + height));
tmode = srcCopy;
CopyBits(srcBit, destBit, &srcRect, &destRect, tmode, NULL);
RGBForeColor(&origForeColor);
RGBBackColor(&origBackColor);
SetClip(tmpRgn2);
SetGWorld(saveWorld, saveDevice);
}
void
TkpDisplayMenuButton(
ClientData clientData) /* Information about widget. */
{
TkMenuButton *mbPtr = (TkMenuButton *) clientData;
GC gc;
Tk_3DBorder border;
int x = 0; /* Initialization needed only to stop
* compiler warning. */
int y;
Tk_Window tkwin = mbPtr->tkwin;
int width, height;
MacMenuButton * macMBPtr = (MacMenuButton *) mbPtr;
GWorldPtr destPort;
CGrafPtr saveWorld;
GDHandle saveDevice;
MacDrawable *macDraw;
mbPtr->flags &= ~REDRAW_PENDING;
if ((mbPtr->tkwin == NULL) || !Tk_IsMapped(tkwin)) {
return;
}
GetGWorld(&saveWorld, &saveDevice);
destPort = TkMacGetDrawablePort(Tk_WindowId(tkwin));
SetGWorld(destPort, NULL);
macDraw = (MacDrawable *) Tk_WindowId(tkwin);
if ((mbPtr->state == tkDisabledUid) && (mbPtr->disabledFg != NULL)) {
gc = mbPtr->disabledGC;
} else if ((mbPtr->state == tkActiveUid) && !Tk_StrictMotif(mbPtr->tkwin)) {
gc = mbPtr->activeTextGC;
} else {
gc = mbPtr->normalTextGC;
}
border = mbPtr->normalBorder;
/*
* In order to avoid screen flashes, this procedure redraws
* the menu button in a pixmap, then copies the pixmap to the
* screen in a single operation. This means that there's no
* point in time where the on-sreen image has been cleared.
*/
Tk_Fill3DRectangle(tkwin, Tk_WindowId(tkwin), border, 0, 0,
Tk_Width(tkwin), Tk_Height(tkwin), 0, TK_RELIEF_FLAT);
/*
* Display image or bitmap or text for button.
*/
if (mbPtr->image != None) {
Tk_SizeOfImage(mbPtr->image, &width, &height);
imageOrBitmap:
TkComputeAnchor(mbPtr->anchor, tkwin, 0, 0,
width + mbPtr->indicatorWidth, height, &x, &y);
if (mbPtr->image != NULL) {
Tk_RedrawImage(mbPtr->image, 0, 0, width, height,
Tk_WindowId(tkwin), x, y);
} else {
XCopyPlane(mbPtr->display, mbPtr->bitmap, Tk_WindowId(tkwin),
gc, 0, 0, (unsigned) width, (unsigned) height, x, y, 1);
}
} else if (mbPtr->bitmap != None) {
Tk_SizeOfBitmap(mbPtr->display, mbPtr->bitmap, &width, &height);
goto imageOrBitmap;
} else {
TkComputeAnchor(mbPtr->anchor, tkwin, mbPtr->padX, mbPtr->padY,
mbPtr->textWidth + mbPtr->indicatorWidth, mbPtr->textHeight,
&x, &y);
Tk_DrawTextLayout(mbPtr->display, Tk_WindowId(tkwin), gc,
mbPtr->textLayout, x, y, 0, -1);
}
/*
* If the menu button is disabled with a stipple rather than a special
* foreground color, generate the stippled effect.
*/
if ((mbPtr->state == tkDisabledUid)
&& ((mbPtr->disabledFg == NULL) || (mbPtr->image != NULL))) {
XFillRectangle(mbPtr->display, Tk_WindowId(tkwin), mbPtr->disabledGC,
mbPtr->inset, mbPtr->inset,
(unsigned) (Tk_Width(tkwin) - 2*mbPtr->inset),
(unsigned) (Tk_Height(tkwin) - 2*mbPtr->inset));
}
/*
* Draw the cascade indicator for the menu button on the
* right side of the window, if desired.
*/
if (mbPtr->indicatorOn) {
int w, h, i;
Rect r;
r.left = macDraw->xOff + Tk_Width(tkwin) - mbPtr->inset
- mbPtr->indicatorWidth;
r.top = macDraw->yOff + Tk_Height(tkwin)/2
- mbPtr->indicatorHeight/2;
r.right = macDraw->xOff + Tk_Width(tkwin) - mbPtr->inset
- kTriangleMargin;
r.bottom = macDraw->yOff + Tk_Height(tkwin)/2
+ mbPtr->indicatorHeight/2;
h = mbPtr->indicatorHeight;
w = mbPtr->indicatorWidth - 1 - kTriangleMargin;
for (i = 0; i < h; i++) {
MoveTo(r.left + i, r.top + i);
LineTo(r.left + i + w, r.top + i);
w -= 2;
}
}
/*
* Draw the border and traversal highlight last. This way, if the
* menu button's contents overflow onto the border they'll be covered
* up by the border.
*/
TkMacSetUpClippingRgn(Tk_WindowId(tkwin));
if (mbPtr->borderWidth > 0) {
Rect r;
r.left = macDraw->xOff + mbPtr->highlightWidth + mbPtr->borderWidth;
r.top = macDraw->yOff + mbPtr->highlightWidth + mbPtr->borderWidth;
r.right = macDraw->xOff + Tk_Width(tkwin) - mbPtr->highlightWidth
- mbPtr->borderWidth;
r.bottom = macDraw->yOff + Tk_Height(tkwin) - mbPtr->highlightWidth
- mbPtr->borderWidth;
FrameRect(&r);
PenSize(mbPtr->borderWidth - 1, mbPtr->borderWidth - 1);
MoveTo(r.right, r.top + kShadowOffset);
LineTo(r.right, r.bottom);
LineTo(r.left + kShadowOffset, r.bottom);
}
if (mbPtr->state == tkDisabledUid) {
}
if (mbPtr->highlightWidth != 0) {
GC gc;
if (mbPtr->flags & GOT_FOCUS) {
gc = Tk_GCForColor(mbPtr->highlightColorPtr, Tk_WindowId(tkwin));
} else {
gc = Tk_GCForColor(mbPtr->highlightBgColorPtr, Tk_WindowId(tkwin));
}
Tk_DrawFocusHighlight(tkwin, gc, mbPtr->highlightWidth,
Tk_WindowId(tkwin));
}
SetGWorld(saveWorld, saveDevice);
}
void
XFillArc(
Display* display, /* Display. */
Drawable d, /* Draw on this. */
GC gc, /* Use this GC. */
int x, /* Upper left of */
int y, /* bounding rect. */
unsigned int width, /* Width & height. */
unsigned int height,
int angle1, /* Staring angle of arc. */
int angle2) /* Ending angle of arc. */
{
MacDrawable *macWin = (MacDrawable *) d;
Rect theRect;
short start, extent;
PolyHandle polygon;
double sin1, cos1, sin2, cos2, angle;
double boxWidth, boxHeight;
double vertex[2], center1[2], center2[2];
CGrafPtr saveWorld;
GDHandle saveDevice;
GWorldPtr destPort;
destPort = TkMacGetDrawablePort(d);
display->request++;
GetGWorld(&saveWorld, &saveDevice);
SetGWorld(destPort, NULL);
TkMacSetUpClippingRgn(d);
TkMacSetUpGraphicsPort(gc);
theRect.left = (short) (macWin->xOff + x);
theRect.top = (short) (macWin->yOff + y);
theRect.right = (short) (theRect.left + width);
theRect.bottom = (short) (theRect.top + height);
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 = -(angle1/64.0)*PI/180.0;
sin1 = sin(angle);
cos1 = cos(angle);
angle -= (angle2/64.0)*PI/180.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] + 0.5), (short) (center1[1] + 0.5));
LineTo((short) (center2[0] + 0.5), (short) (center2[1] + 0.5));
ClosePoly();
ShowPen();
FillCArc(&theRect, start, extent, gPenPat);
FillCPoly(polygon, gPenPat);
KillPoly(polygon);
} else {
ShowPen();
FillCArc(&theRect, start, extent, gPenPat);
}
SetGWorld(saveWorld, saveDevice);
}
void
TkpDisplayMenuButton(
ClientData clientData) /* Information about widget. */
{
TkMenuButton *mbPtr = (TkMenuButton *) clientData;
GC gc;
Tk_3DBorder border;
int x = 0; /* Initialization needed only to stop
* compiler warning. */
int y;
Tk_Window tkwin = mbPtr->tkwin;
int width, height, fullWidth, fullHeight;
int imageXOffset, imageYOffset, textXOffset, textYOffset;
int haveImage = 0, haveText = 0;
MacMenuButton * macMBPtr = (MacMenuButton *) mbPtr;
GWorldPtr destPort;
CGrafPtr saveWorld;
GDHandle saveDevice;
MacDrawable *macDraw;
mbPtr->flags &= ~REDRAW_PENDING;
if ((mbPtr->tkwin == NULL) || !Tk_IsMapped(tkwin)) {
return;
}
GetGWorld(&saveWorld, &saveDevice);
destPort = TkMacGetDrawablePort(Tk_WindowId(tkwin));
SetGWorld(destPort, NULL);
macDraw = (MacDrawable *) Tk_WindowId(tkwin);
if ((mbPtr->state == STATE_DISABLED) && (mbPtr->disabledFg != NULL)) {
gc = mbPtr->disabledGC;
} else if ((mbPtr->state == STATE_ACTIVE)
&& !Tk_StrictMotif(mbPtr->tkwin)) {
gc = mbPtr->activeTextGC;
} else {
gc = mbPtr->normalTextGC;
}
border = mbPtr->normalBorder;
if (mbPtr->image != None) {
Tk_SizeOfImage(mbPtr->image, &width, &height);
haveImage = 1;
} else if (mbPtr->bitmap != None) {
Tk_SizeOfBitmap(mbPtr->display, mbPtr->bitmap, &width, &height);
haveImage = 1;
}
haveText = (mbPtr->textWidth != 0 && mbPtr->textHeight != 0);
/*
* In order to avoid screen flashes, this procedure redraws
* the menu button in a pixmap, then copies the pixmap to the
* screen in a single operation. This means that there's no
* point in time where the on-sreen image has been cleared.
*/
Tk_Fill3DRectangle(tkwin, Tk_WindowId(tkwin), border, 0, 0,
Tk_Width(tkwin), Tk_Height(tkwin), 0, TK_RELIEF_FLAT);
imageXOffset = 0;
imageYOffset = 0;
textXOffset = 0;
textYOffset = 0;
fullWidth = 0;
fullHeight = 0;
if (mbPtr->compound != COMPOUND_NONE && haveImage && haveText) {
switch ((enum compound) mbPtr->compound) {
case COMPOUND_TOP:
case COMPOUND_BOTTOM: {
/* Image is above or below text */
if (mbPtr->compound == COMPOUND_TOP) {
textYOffset = height + mbPtr->padY;
} else {
imageYOffset = mbPtr->textHeight + mbPtr->padY;
}
fullHeight = height + mbPtr->textHeight + mbPtr->padY;
fullWidth = (width > mbPtr->textWidth ? width :
mbPtr->textWidth);
textXOffset = (fullWidth - mbPtr->textWidth)/2;
imageXOffset = (fullWidth - width)/2;
break;
}
case COMPOUND_LEFT:
case COMPOUND_RIGHT: {
/* Image is left or right of text */
if (mbPtr->compound == COMPOUND_LEFT) {
textXOffset = width + mbPtr->padX;
} else {
imageXOffset = mbPtr->textWidth + mbPtr->padX;
}
fullWidth = mbPtr->textWidth + mbPtr->padX + width;
fullHeight = (height > mbPtr->textHeight ? height :
mbPtr->textHeight);
textYOffset = (fullHeight - mbPtr->textHeight)/2;
imageYOffset = (fullHeight - height)/2;
break;
}
case COMPOUND_CENTER: {
/* Image and text are superimposed */
fullWidth = (width > mbPtr->textWidth ? width :
mbPtr->textWidth);
fullHeight = (height > mbPtr->textHeight ? height :
mbPtr->textHeight);
textXOffset = (fullWidth - mbPtr->textWidth)/2;
imageXOffset = (fullWidth - width)/2;
textYOffset = (fullHeight - mbPtr->textHeight)/2;
imageYOffset = (fullHeight - height)/2;
break;
}
case COMPOUND_NONE: {break;}
}
TkComputeAnchor(mbPtr->anchor, tkwin, 0, 0,
mbPtr->indicatorWidth + fullWidth, fullHeight,
&x, &y);
if (mbPtr->image != NULL) {
Tk_RedrawImage(mbPtr->image, 0, 0, width, height, Tk_WindowId(tkwin),
x + imageXOffset, y + imageYOffset);
}
if (mbPtr->bitmap != None) {
XCopyPlane(mbPtr->display, mbPtr->bitmap, Tk_WindowId(tkwin),
gc, 0, 0, (unsigned) width, (unsigned) height,
x + imageXOffset, y + imageYOffset, 1);
}
if (haveText) {
Tk_DrawTextLayout(mbPtr->display, Tk_WindowId(tkwin), gc,
mbPtr->textLayout, x + textXOffset, y + textYOffset ,
0, -1);
Tk_UnderlineTextLayout(mbPtr->display, Tk_WindowId(tkwin), gc,
mbPtr->textLayout, x + textXOffset, y + textYOffset ,
mbPtr->underline);
}
} else {
if (mbPtr->image != NULL) {
TkComputeAnchor(mbPtr->anchor, tkwin, 0, 0,
width + mbPtr->indicatorWidth, height, &x, &y);
Tk_RedrawImage(mbPtr->image, 0, 0, width, height, Tk_WindowId(tkwin),
x + imageXOffset, y + imageYOffset);
} else if (mbPtr->bitmap != None) {
TkComputeAnchor(mbPtr->anchor, tkwin, 0, 0,
width + mbPtr->indicatorWidth, height, &x, &y);
XCopyPlane(mbPtr->display, mbPtr->bitmap, Tk_WindowId(tkwin),
gc, 0, 0, (unsigned) width, (unsigned) height,
x + imageXOffset, y + imageYOffset, 1);
} else {
TkComputeAnchor(mbPtr->anchor, tkwin, mbPtr->padX, mbPtr->padY,
mbPtr->textWidth + mbPtr->indicatorWidth,
mbPtr->textHeight, &x, &y);
Tk_DrawTextLayout(mbPtr->display, Tk_WindowId(tkwin), gc,
mbPtr->textLayout, x + textXOffset, y + textYOffset,
0, -1);
Tk_UnderlineTextLayout(mbPtr->display, Tk_WindowId(tkwin), gc,
mbPtr->textLayout, x + textXOffset, y + textYOffset ,
mbPtr->underline);
}
}
#if 0 /* this is the original code */
/*
* Display image or bitmap or text for button.
*/
if (mbPtr->image != None) {
Tk_SizeOfImage(mbPtr->image, &width, &height);
imageOrBitmap:
TkComputeAnchor(mbPtr->anchor, tkwin, 0, 0,
width + mbPtr->indicatorWidth, height, &x, &y);
if (mbPtr->image != NULL) {
Tk_RedrawImage(mbPtr->image, 0, 0, width, height,
Tk_WindowId(tkwin), x, y);
} else {
XCopyPlane(mbPtr->display, mbPtr->bitmap, Tk_WindowId(tkwin),
gc, 0, 0, (unsigned) width, (unsigned) height, x, y, 1);
}
} else if (mbPtr->bitmap != None) {
Tk_SizeOfBitmap(mbPtr->display, mbPtr->bitmap, &width, &height);
goto imageOrBitmap;
} else {
TkComputeAnchor(mbPtr->anchor, tkwin, mbPtr->padX, mbPtr->padY,
mbPtr->textWidth + mbPtr->indicatorWidth, mbPtr->textHeight,
&x, &y);
Tk_DrawTextLayout(mbPtr->display, Tk_WindowId(tkwin), gc,
mbPtr->textLayout, x, y, 0, -1);
}
#endif
/*
* If the menu button is disabled with a stipple rather than a special
* foreground color, generate the stippled effect.
*/
if ((mbPtr->state == STATE_DISABLED)
&& ((mbPtr->disabledFg != NULL) || (mbPtr->image != NULL))) {
XFillRectangle(mbPtr->display, Tk_WindowId(tkwin),
mbPtr->disabledGC, mbPtr->inset, mbPtr->inset,
(unsigned) (Tk_Width(tkwin) - 2*mbPtr->inset),
(unsigned) (Tk_Height(tkwin) - 2*mbPtr->inset));
}
/*
* Draw the cascade indicator for the menu button on the
* right side of the window, if desired.
*/
if (mbPtr->indicatorOn) {
int w, h, i;
Rect r;
r.left = macDraw->xOff + Tk_Width(tkwin) - mbPtr->inset
- mbPtr->indicatorWidth;
r.top = macDraw->yOff + Tk_Height(tkwin)/2
- mbPtr->indicatorHeight/2;
r.right = macDraw->xOff + Tk_Width(tkwin) - mbPtr->inset
- kTriangleMargin;
r.bottom = macDraw->yOff + Tk_Height(tkwin)/2
+ mbPtr->indicatorHeight/2;
h = mbPtr->indicatorHeight;
w = mbPtr->indicatorWidth - 1 - kTriangleMargin;
for (i = 0; i < h; i++) {
MoveTo(r.left + i, r.top + i);
LineTo(r.left + i + w, r.top + i);
w -= 2;
}
}
/*
* Draw the border and traversal highlight last. This way, if the
* menu button's contents overflow onto the border they'll be covered
* up by the border.
*/
TkMacSetUpClippingRgn(Tk_WindowId(tkwin));
if (mbPtr->borderWidth > 0) {
Rect r;
r.left = macDraw->xOff + mbPtr->highlightWidth + mbPtr->borderWidth;
r.top = macDraw->yOff + mbPtr->highlightWidth + mbPtr->borderWidth;
r.right = macDraw->xOff + Tk_Width(tkwin) - mbPtr->highlightWidth
- mbPtr->borderWidth;
r.bottom = macDraw->yOff + Tk_Height(tkwin) - mbPtr->highlightWidth
- mbPtr->borderWidth;
FrameRect(&r);
PenSize(mbPtr->borderWidth - 1, mbPtr->borderWidth - 1);
MoveTo(r.right, r.top + kShadowOffset);
LineTo(r.right, r.bottom);
LineTo(r.left + kShadowOffset, r.bottom);
}
if (mbPtr->highlightWidth != 0) {
GC fgGC, bgGC;
bgGC = Tk_GCForColor(mbPtr->highlightBgColorPtr, Tk_WindowId(tkwin));
if (mbPtr->flags & GOT_FOCUS) {
fgGC = Tk_GCForColor(mbPtr->highlightColorPtr, Tk_WindowId(tkwin));
TkpDrawHighlightBorder(tkwin, fgGC, bgGC, mbPtr->highlightWidth,
Tk_WindowId(tkwin));
} else {
TkpDrawHighlightBorder(tkwin, bgGC, bgGC, mbPtr->highlightWidth,
Tk_WindowId(tkwin));
}
}
SetGWorld(saveWorld, saveDevice);
}
void
XMoveWindow(
Display* display, /* Display. */
Window window, /* Window. */
int x,
int y)
{
MacDrawable *macWin = (MacDrawable *) window;
GWorldPtr destPort;
destPort = TkMacGetDrawablePort(window);
if (destPort == NULL) {
return;
}
SetPort((GrafPtr) destPort);
if (Tk_IsTopLevel(macWin->winPtr) && !Tk_IsEmbedded(macWin->winPtr)) {
/*
* NOTE: we are not adding the new space to the update
* region. It is currently assumed that Tk will need
* to completely redraw anway.
*/
tkMacMoveWindow((WindowRef) destPort, x, y);
/* TODO: is the following right? */
TkMacInvalidateWindow(macWin, TK_WINDOW_ONLY);
TkMacInvalClipRgns(macWin->winPtr);
} else {
int deltaX, deltaY, parentBorderwidth;
Rect bounds;
MacDrawable *macParent;
/*
* Find the Parent window -
* For an embedded window this will be its container.
*/
if (Tk_IsEmbedded(macWin->winPtr)) {
TkWindow *contWinPtr;
contWinPtr = TkpGetOtherWindow(macWin->winPtr);
if (contWinPtr == NULL) {
panic("XMoveWindow could not find container");
}
macParent = contWinPtr->privatePtr;
/*
* NOTE: Here we should handle out of process embedding.
*/
} else {
macParent = macWin->winPtr->parentPtr->privatePtr;
if (macParent == NULL) {
return; /* TODO: Probably should be a panic */
}
}
TkMacInvalClipRgns(macParent->winPtr);
TkMacInvalidateWindow(macWin, TK_PARENT_WINDOW);
deltaX = - macWin->xOff;
deltaY = - macWin->yOff;
/*
* If macWin->winPtr is an embedded window, don't offset by its
* parent's borderwidth...
*/
if (!Tk_IsEmbedded(macWin->winPtr)) {
parentBorderwidth = macWin->winPtr->parentPtr->changes.border_width;
} else {
parentBorderwidth = 0;
}
deltaX += macParent->xOff + parentBorderwidth +
macWin->winPtr->changes.x;
deltaY += macParent->yOff + parentBorderwidth +
macWin->winPtr->changes.y;
UpdateOffsets(macWin->winPtr, deltaX, deltaY);
TkMacWinBounds(macWin->winPtr, &bounds);
InvalRect(&bounds);
}
}
void
XDestroyWindow(
Display* display, /* Display. */
Window window) /* Window. */
{
MacDrawable *macWin = (MacDrawable *) window;
GWorldPtr destPort;
/*
* Remove any dangling pointers that may exist if
* the window we are deleting is being tracked by
* the grab code.
*/
TkPointerDeadWindow(macWin->winPtr);
macWin->toplevel->referenceCount--;
if (Tk_IsTopLevel(macWin->winPtr)) {
DisposeRgn(macWin->clipRgn);
DisposeRgn(macWin->aboveClipRgn);
/*
* Delete the Mac window and remove it from the windowTable.
* The window could be NULL if the window was never mapped.
* However, we don't do this for embedded windows, they don't
* go in the window list, and they do not own their portPtr's.
*/
if (!(Tk_IsEmbedded(macWin->winPtr))) {
destPort = TkMacGetDrawablePort(window);
if (destPort != NULL) {
TkMacWindowList *listPtr, *prevPtr;
TkMacUnregisterMacWindow(destPort);
DisposeWindow((WindowRef) destPort);
for (listPtr = tkMacWindowListPtr, prevPtr = NULL;
tkMacWindowListPtr != NULL;
prevPtr = listPtr, listPtr = listPtr->nextPtr) {
if (listPtr->winPtr == macWin->winPtr) {
if (prevPtr == NULL) {
tkMacWindowListPtr = listPtr->nextPtr;
} else {
prevPtr->nextPtr = listPtr->nextPtr;
}
ckfree((char *) listPtr);
break;
}
}
}
}
macWin->portPtr = NULL;
/*
* Delay deletion of a toplevel data structure untill all
* children have been deleted.
*/
if (macWin->toplevel->referenceCount == 0) {
ckfree((char *) macWin->toplevel);
}
} else {
destPort = TkMacGetDrawablePort(window);
if (destPort != NULL) {
SetGWorld(destPort, NULL);
TkMacInvalidateWindow(macWin, TK_PARENT_WINDOW);
}
if (macWin->winPtr->parentPtr != NULL) {
TkMacInvalClipRgns(macWin->winPtr->parentPtr);
}
DisposeRgn(macWin->clipRgn);
DisposeRgn(macWin->aboveClipRgn);
if (macWin->toplevel->referenceCount == 0) {
ckfree((char *) macWin->toplevel);
}
ckfree((char *) macWin);
}
}
void
XResizeWindow(
Display* display, /* Display. */
Window window, /* Window. */
unsigned int width,
unsigned int height)
{
MacDrawable *macWin = (MacDrawable *) window;
GWorldPtr destPort;
destPort = TkMacGetDrawablePort(window);
if (destPort == NULL) {
return;
}
display->request++;
SetPort((GrafPtr) destPort);
if (Tk_IsTopLevel(macWin->winPtr)) {
if (!Tk_IsEmbedded(macWin->winPtr)) {
/*
* NOTE: we are not adding the new space to the update
* region. It is currently assumed that Tk will need
* to completely redraw anway.
*/
SizeWindow((WindowRef) destPort,
(short) width, (short) height, false);
TkMacInvalidateWindow(macWin, TK_WINDOW_ONLY);
TkMacInvalClipRgns(macWin->winPtr);
} else {
int deltaX, deltaY;
/*
* Find the Parent window -
* For an embedded window this will be its container.
*/
TkWindow *contWinPtr;
contWinPtr = TkpGetOtherWindow(macWin->winPtr);
if (contWinPtr != NULL) {
MacDrawable *macParent = contWinPtr->privatePtr;
TkMacInvalClipRgns(macParent->winPtr);
TkMacInvalidateWindow(macWin, TK_PARENT_WINDOW);
deltaX = macParent->xOff +
macWin->winPtr->changes.x - macWin->xOff;
deltaY = macParent->yOff +
macWin->winPtr->changes.y - macWin->yOff;
UpdateOffsets(macWin->winPtr, deltaX, deltaY);
} else {
/*
* This is the case where we are embedded in
* another app. At this point, we are assuming that
* the changes.x,y is not maintained, if you need
* the info get it from Tk_GetRootCoords,
* and that the toplevel sits at 0,0 when it is drawn.
*/
TkMacInvalidateWindow(macWin, TK_PARENT_WINDOW);
UpdateOffsets(macWin->winPtr, 0, 0);
}
}
} else {
/* TODO: update all xOff & yOffs */
int deltaX, deltaY, parentBorderwidth;
MacDrawable *macParent = macWin->winPtr->parentPtr->privatePtr;
if (macParent == NULL) {
return; /* TODO: Probably should be a panic */
}
TkMacInvalClipRgns(macParent->winPtr);
TkMacInvalidateWindow(macWin, TK_PARENT_WINDOW);
deltaX = - macWin->xOff;
deltaY = - macWin->yOff;
parentBorderwidth = macWin->winPtr->parentPtr->changes.border_width;
deltaX += macParent->xOff + parentBorderwidth +
macWin->winPtr->changes.x;
deltaY += macParent->yOff + parentBorderwidth +
macWin->winPtr->changes.y;
UpdateOffsets(macWin->winPtr, deltaX, deltaY);
}
}
void
XCopyPlane(
Display* display, /* Display. */
Drawable src, /* Source drawable. */
Drawable dest, /* Destination drawable. */
GC gc, /* The GC to use. */
int src_x, /* X, Y, width & height */
int src_y, /* define the source rect. */
unsigned int width,
unsigned int height,
int dest_x, /* X & Y on dest where we will copy. */
int dest_y,
unsigned long plane) /* Which plane to copy. */
{
Rect srcRect, destRect;
BitMapPtr srcBit, destBit, maskBit;
MacDrawable *srcDraw = (MacDrawable *) src;
MacDrawable *destDraw = (MacDrawable *) dest;
GWorldPtr srcPort, destPort, maskPort;
CGrafPtr saveWorld;
GDHandle saveDevice;
RGBColor macColor;
TkpClipMask *clipPtr = (TkpClipMask*)gc->clip_mask;
short tmode;
destPort = TkMacGetDrawablePort(dest);
srcPort = TkMacGetDrawablePort(src);
display->request++;
GetGWorld(&saveWorld, &saveDevice);
SetGWorld(destPort, NULL);
TkMacSetUpClippingRgn(dest);
srcBit = &((GrafPtr) srcPort)->portBits;
destBit = &((GrafPtr) destPort)->portBits;
SetRect(&srcRect, (short) (srcDraw->xOff + src_x),
(short) (srcDraw->yOff + src_y),
(short) (srcDraw->xOff + src_x + width),
(short) (srcDraw->yOff + src_y + height));
SetRect(&destRect, (short) (destDraw->xOff + dest_x),
(short) (destDraw->yOff + dest_y),
(short) (destDraw->xOff + dest_x + width),
(short) (destDraw->yOff + dest_y + height));
tmode = srcOr;
tmode = srcCopy + transparent;
if (TkSetMacColor(gc->foreground, &macColor) == true) {
RGBForeColor(&macColor);
}
if (clipPtr == NULL || clipPtr->type == TKP_CLIP_REGION) {
/*
* Case 1: opaque bitmaps.
*/
TkSetMacColor(gc->background, &macColor);
RGBBackColor(&macColor);
tmode = srcCopy;
CopyBits(srcBit, destBit, &srcRect, &destRect, tmode, NULL);
} else if (clipPtr->type == TKP_CLIP_PIXMAP) {
if (clipPtr->value.pixmap == src) {
/*
* Case 2: transparent bitmaps. If it's color we ignore
* the forecolor.
*/
if ((**(srcPort->portPixMap)).pixelSize == 1) {
tmode = srcOr;
} else {
tmode = transparent;
}
CopyBits(srcBit, destBit, &srcRect, &destRect, tmode, NULL);
} else {
/*
* Case 3: two arbitrary bitmaps.
*/
tmode = srcCopy;
maskPort = TkMacGetDrawablePort(clipPtr->value.pixmap);
maskBit = &((GrafPtr) maskPort)->portBits;
CopyDeepMask(srcBit, maskBit, destBit, &srcRect, &srcRect, &destRect, tmode, NULL);
}
}
SetGWorld(saveWorld, saveDevice);
}
void
TkPutImage(
unsigned long *colors, /* Unused on Macintosh. */
int ncolors, /* Unused on Macintosh. */
Display* display, /* Display. */
Drawable d, /* Drawable to place image on. */
GC gc, /* GC to use. */
XImage* image, /* Image to place. */
int src_x, /* Source X & Y. */
int src_y,
int dest_x, /* Destination X & Y. */
int dest_y,
unsigned int width, /* Same width & height for both */
unsigned int height) /* distination and source. */
{
MacDrawable *destDraw = (MacDrawable *) d;
CGrafPtr saveWorld;
GDHandle saveDevice;
GWorldPtr destPort;
int i, j;
BitMap bitmap;
char *newData = NULL;
Rect destRect, srcRect;
destPort = TkMacGetDrawablePort(d);
SetRect(&destRect, dest_x, dest_y, dest_x + width, dest_y + height);
SetRect(&srcRect, src_x, src_y, src_x + width, src_y + height);
display->request++;
GetGWorld(&saveWorld, &saveDevice);
SetGWorld(destPort, NULL);
TkMacSetUpClippingRgn(d);
if (image->depth == 1) {
/*
* This code assumes a pixel depth of 1
*/
bitmap.bounds.top = bitmap.bounds.left = 0;
bitmap.bounds.right = (short) image->width;
bitmap.bounds.bottom = (short) image->height;
if ((image->bytes_per_line % 2) == 1) {
char *newPtr, *oldPtr;
newData = (char *) ckalloc(image->height *
(image->bytes_per_line + 1));
newPtr = newData;
oldPtr = image->data;
for (i = 0; i < image->height; i++) {
for (j = 0; j < image->bytes_per_line; j++) {
*newPtr = InvertByte((unsigned char) *oldPtr);
newPtr++, oldPtr++;
}
*newPtr = 0;
newPtr++;
}
bitmap.baseAddr = newData;
bitmap.rowBytes = image->bytes_per_line + 1;
} else {
newData = (char *) ckalloc(image->height * image->bytes_per_line);
for (i = 0; i < image->height * image->bytes_per_line; i++) {
newData[i] = InvertByte((unsigned char) image->data[i]);
}
bitmap.baseAddr = newData;
bitmap.rowBytes = image->bytes_per_line;
}
CopyBits(&bitmap, &((GrafPtr) destPort)->portBits,
&srcRect, &destRect, srcCopy, NULL);
} else {
/* Color image */
PixMap pixmap;
pixmap.bounds.left = 0;
pixmap.bounds.top = 0;
pixmap.bounds.right = (short) image->width;
pixmap.bounds.bottom = (short) image->height;
pixmap.pixelType = RGBDirect;
pixmap.pmVersion = 4; /* 32bit clean */
pixmap.packType = 0;
pixmap.packSize = 0;
pixmap.hRes = 0x00480000;
pixmap.vRes = 0x00480000;
pixmap.pixelSize = 32;
pixmap.cmpCount = 3;
pixmap.cmpSize = 8;
pixmap.planeBytes = 0;
pixmap.pmTable = NULL;
pixmap.pmReserved = 0;
pixmap.baseAddr = image->data;
if (image->bytes_per_line >= 0x4000) {
panic("TkImage too wide!");
}
pixmap.rowBytes = image->bytes_per_line | 0x8000;
CopyBits((BitMap *) &pixmap, &((GrafPtr) destPort)->portBits,
&srcRect, &destRect, srcCopy, NULL);
}
if (newData != NULL) {
ckfree(newData);
}
SetGWorld(saveWorld, saveDevice);
}
int
TkScrollWindow(
Tk_Window tkwin, /* The window to be scrolled. */
GC gc, /* GC for window to be scrolled. */
int x, /* Position rectangle to be scrolled. */
int y,
int width,
int height,
int dx, /* Distance rectangle should be moved. */
int dy,
TkRegion damageRgn) /* Region to accumulate damage in. */
{
MacDrawable *destDraw = (MacDrawable *) Tk_WindowId(tkwin);
RgnHandle rgn = (RgnHandle) damageRgn;
CGrafPtr saveWorld;
GDHandle saveDevice;
GWorldPtr destPort;
Rect srcRect, scrollRect;
destPort = TkMacGetDrawablePort(Tk_WindowId(tkwin));
GetGWorld(&saveWorld, &saveDevice);
SetGWorld(destPort, NULL);
TkMacSetUpClippingRgn(Tk_WindowId(tkwin));
/*
* 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.
*/
SetRect(&srcRect, (short) (destDraw->xOff + x),
(short) (destDraw->yOff + y),
(short) (destDraw->xOff + x + width),
(short) (destDraw->yOff + y + height));
scrollRect = srcRect;
if (dx < 0) {
scrollRect.left += dx;
} else {
scrollRect.right += dx;
}
if (dy < 0) {
scrollRect.top += dy;
} else {
scrollRect.bottom += dy;
}
/*
* Adjust clip region so that we don't copy any windows
* that may overlap us.
*/
RectRgn(rgn, &srcRect);
DiffRgn(rgn, destPort->visRgn, rgn);
OffsetRgn(rgn, dx, dy);
DiffRgn(destPort->clipRgn, rgn, destPort->clipRgn);
SetEmptyRgn(rgn);
/*
* When a menu is up, the Mac does not expect drawing to occur and
* does not clip out the menu. We have to do it ourselves. This
* is pretty gross.
*/
if (tkUseMenuCascadeRgn == 1) {
Point scratch = {0, 0};
MacDrawable *macDraw = (MacDrawable *) Tk_WindowId(tkwin);
LocalToGlobal(&scratch);
CopyRgn(tkMenuCascadeRgn, rgn);
OffsetRgn(rgn, -scratch.h, -scratch.v);
DiffRgn(destPort->clipRgn, rgn, destPort->clipRgn);
SetEmptyRgn(rgn);
macDraw->toplevel->flags |= TK_DRAWN_UNDER_MENU;
}
ScrollRect(&scrollRect, dx, dy, rgn);
SetGWorld(saveWorld, saveDevice);
/*
* Fortunantly, the region returned by ScrollRect is symanticlly
* 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.
*/
if (EmptyRgn(rgn)) {
return 0;
} else {
return 1;
}
}
void
TkpDisplayScrollbar(
ClientData clientData) /* Information about window. */
{
register TkScrollbar *scrollPtr = (TkScrollbar *) clientData;
register MacScrollbar *macScrollPtr = (MacScrollbar *) clientData;
register Tk_Window tkwin = scrollPtr->tkwin;
MacDrawable *macDraw;
CGrafPtr saveWorld;
GDHandle saveDevice;
GWorldPtr destPort;
WindowRef windowRef;
if ((scrollPtr->tkwin == NULL) || !Tk_IsMapped(tkwin)) {
goto done;
}
/*
* Draw the focus or any 3D relief we may have.
*/
if (scrollPtr->highlightWidth != 0) {
GC fgGC, bgGC;
bgGC = Tk_GCForColor(scrollPtr->highlightBgColorPtr,
Tk_WindowId(tkwin));
if (scrollPtr->flags & GOT_FOCUS) {
fgGC = Tk_GCForColor(scrollPtr->highlightColorPtr,
Tk_WindowId(tkwin));
TkpDrawHighlightBorder(tkwin, fgGC, bgGC, scrollPtr->highlightWidth,
Tk_WindowId(tkwin));
} else {
TkpDrawHighlightBorder(tkwin, bgGC, bgGC, scrollPtr->highlightWidth,
Tk_WindowId(tkwin));
}
}
Tk_Draw3DRectangle(tkwin, Tk_WindowId(tkwin), scrollPtr->bgBorder,
scrollPtr->highlightWidth, scrollPtr->highlightWidth,
Tk_Width(tkwin) - 2*scrollPtr->highlightWidth,
Tk_Height(tkwin) - 2*scrollPtr->highlightWidth,
scrollPtr->borderWidth, scrollPtr->relief);
/*
* Set up port for drawing Macintosh control.
*/
macDraw = (MacDrawable *) Tk_WindowId(tkwin);
destPort = TkMacGetDrawablePort(Tk_WindowId(tkwin));
GetGWorld(&saveWorld, &saveDevice);
SetGWorld(destPort, NULL);
TkMacSetUpClippingRgn(Tk_WindowId(tkwin));
if (macScrollPtr->sbHandle == NULL) {
Rect r;
WindowRef frontNonFloating;
r.left = r.top = 0;
r.right = r.bottom = 1;
macScrollPtr->sbHandle = NewControl((WindowRef) destPort, &r, "\p",
false, (short) 500, 0, 1000,
scrollBarProc, (SInt32) scrollPtr);
/*
* If we are foremost than make us active.
*/
if (TkMacHaveAppearance() >= 0x110) {
frontNonFloating = FrontNonFloatingWindow();
} else {
frontNonFloating = FrontWindow();
}
if ((WindowPtr) destPort == FrontWindow() || TkpIsWindowFloating((WindowPtr) destPort)) {
macScrollPtr->macFlags |= ACTIVE;
}
}
/*
* Update the control values before we draw.
*/
windowRef = (**macScrollPtr->sbHandle).contrlOwner;
UpdateControlValues(macScrollPtr);
if (macScrollPtr->macFlags & ACTIVE) {
Draw1Control(macScrollPtr->sbHandle);
if (macScrollPtr->macFlags & DRAW_GROW) {
DrawGrowIcon(windowRef);
}
} else {
(**macScrollPtr->sbHandle).contrlHilite = 255;
Draw1Control(macScrollPtr->sbHandle);
if (macScrollPtr->macFlags & DRAW_GROW) {
DrawGrowIcon(windowRef);
Tk_Fill3DRectangle(tkwin, Tk_WindowId(tkwin), scrollPtr->bgBorder,
Tk_Width(tkwin) - 13, Tk_Height(tkwin) - 13,
Tk_Width(tkwin), Tk_Height(tkwin),
0, TK_RELIEF_FLAT);
}
}
SetGWorld(saveWorld, saveDevice);
done:
scrollPtr->flags &= ~REDRAW_PENDING;
}
