/*
|
/*
|
* tkMacSubwindows.c --
|
* tkMacSubwindows.c --
|
*
|
*
|
* Implements subwindows for the macintosh version of Tk.
|
* Implements subwindows for the macintosh version of Tk.
|
*
|
*
|
* Copyright (c) 1995-1997 Sun Microsystems, Inc.
|
* Copyright (c) 1995-1997 Sun Microsystems, Inc.
|
*
|
*
|
* See the file "license.terms" for information on usage and redistribution
|
* See the file "license.terms" for information on usage and redistribution
|
* of this file, and for a DISCLAIMER OF ALL WARRANTIES.
|
* of this file, and for a DISCLAIMER OF ALL WARRANTIES.
|
*
|
*
|
* RCS: @(#) $Id: tkMacSubwindows.c,v 1.1.1.1 2002-01-16 10:25:57 markom Exp $
|
* RCS: @(#) $Id: tkMacSubwindows.c,v 1.1.1.1 2002-01-16 10:25:57 markom Exp $
|
*/
|
*/
|
|
|
#include "tkInt.h"
|
#include "tkInt.h"
|
#include "X.h"
|
#include "X.h"
|
#include "Xlib.h"
|
#include "Xlib.h"
|
#include <stdio.h>
|
#include <stdio.h>
|
|
|
#include <Windows.h>
|
#include <Windows.h>
|
#include <QDOffscreen.h>
|
#include <QDOffscreen.h>
|
#include "tkMacInt.h"
|
#include "tkMacInt.h"
|
|
|
/*
|
/*
|
* Temporary region that can be reused.
|
* Temporary region that can be reused.
|
*/
|
*/
|
static RgnHandle tmpRgn = NULL;
|
static RgnHandle tmpRgn = NULL;
|
|
|
static void UpdateOffsets _ANSI_ARGS_((TkWindow *winPtr, int deltaX, int deltaY));
|
static void UpdateOffsets _ANSI_ARGS_((TkWindow *winPtr, int deltaX, int deltaY));
|
|
|
void tkMacMoveWindow _ANSI_ARGS_((WindowRef window, int x, int y));
|
void tkMacMoveWindow _ANSI_ARGS_((WindowRef window, int x, int y));
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* XDestroyWindow --
|
* XDestroyWindow --
|
*
|
*
|
* Dealocates the given X Window.
|
* Dealocates the given X Window.
|
*
|
*
|
* Results:
|
* Results:
|
* The window id is returned.
|
* The window id is returned.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* None.
|
* None.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
void
|
void
|
XDestroyWindow(
|
XDestroyWindow(
|
Display* display, /* Display. */
|
Display* display, /* Display. */
|
Window window) /* Window. */
|
Window window) /* Window. */
|
{
|
{
|
MacDrawable *macWin = (MacDrawable *) window;
|
MacDrawable *macWin = (MacDrawable *) window;
|
GWorldPtr destPort;
|
GWorldPtr destPort;
|
|
|
/*
|
/*
|
* Remove any dangling pointers that may exist if
|
* Remove any dangling pointers that may exist if
|
* the window we are deleting is being tracked by
|
* the window we are deleting is being tracked by
|
* the grab code.
|
* the grab code.
|
*/
|
*/
|
|
|
TkPointerDeadWindow(macWin->winPtr);
|
TkPointerDeadWindow(macWin->winPtr);
|
macWin->toplevel->referenceCount--;
|
macWin->toplevel->referenceCount--;
|
|
|
|
|
if (Tk_IsTopLevel(macWin->winPtr)) {
|
if (Tk_IsTopLevel(macWin->winPtr)) {
|
DisposeRgn(macWin->clipRgn);
|
DisposeRgn(macWin->clipRgn);
|
DisposeRgn(macWin->aboveClipRgn);
|
DisposeRgn(macWin->aboveClipRgn);
|
|
|
/*
|
/*
|
* Delete the Mac window and remove it from the windowTable.
|
* Delete the Mac window and remove it from the windowTable.
|
* The window could be NULL if the window was never mapped.
|
* The window could be NULL if the window was never mapped.
|
* However, we don't do this for embedded windows, they don't
|
* 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.
|
* go in the window list, and they do not own their portPtr's.
|
*/
|
*/
|
|
|
if (!(Tk_IsEmbedded(macWin->winPtr))) {
|
if (!(Tk_IsEmbedded(macWin->winPtr))) {
|
destPort = TkMacGetDrawablePort(window);
|
destPort = TkMacGetDrawablePort(window);
|
if (destPort != NULL) {
|
if (destPort != NULL) {
|
TkMacWindowList *listPtr, *prevPtr;
|
TkMacWindowList *listPtr, *prevPtr;
|
|
|
TkMacUnregisterMacWindow(destPort);
|
TkMacUnregisterMacWindow(destPort);
|
DisposeWindow((WindowRef) destPort);
|
DisposeWindow((WindowRef) destPort);
|
|
|
for (listPtr = tkMacWindowListPtr, prevPtr = NULL;
|
for (listPtr = tkMacWindowListPtr, prevPtr = NULL;
|
tkMacWindowListPtr != NULL;
|
tkMacWindowListPtr != NULL;
|
prevPtr = listPtr, listPtr = listPtr->nextPtr) {
|
prevPtr = listPtr, listPtr = listPtr->nextPtr) {
|
if (listPtr->winPtr == macWin->winPtr) {
|
if (listPtr->winPtr == macWin->winPtr) {
|
if (prevPtr == NULL) {
|
if (prevPtr == NULL) {
|
tkMacWindowListPtr = listPtr->nextPtr;
|
tkMacWindowListPtr = listPtr->nextPtr;
|
} else {
|
} else {
|
prevPtr->nextPtr = listPtr->nextPtr;
|
prevPtr->nextPtr = listPtr->nextPtr;
|
}
|
}
|
ckfree((char *) listPtr);
|
ckfree((char *) listPtr);
|
break;
|
break;
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
macWin->portPtr = NULL;
|
macWin->portPtr = NULL;
|
|
|
/*
|
/*
|
* Delay deletion of a toplevel data structure untill all
|
* Delay deletion of a toplevel data structure untill all
|
* children have been deleted.
|
* children have been deleted.
|
*/
|
*/
|
if (macWin->toplevel->referenceCount == 0) {
|
if (macWin->toplevel->referenceCount == 0) {
|
ckfree((char *) macWin->toplevel);
|
ckfree((char *) macWin->toplevel);
|
}
|
}
|
} else {
|
} else {
|
destPort = TkMacGetDrawablePort(window);
|
destPort = TkMacGetDrawablePort(window);
|
if (destPort != NULL) {
|
if (destPort != NULL) {
|
SetGWorld(destPort, NULL);
|
SetGWorld(destPort, NULL);
|
TkMacInvalidateWindow(macWin, TK_PARENT_WINDOW);
|
TkMacInvalidateWindow(macWin, TK_PARENT_WINDOW);
|
}
|
}
|
if (macWin->winPtr->parentPtr != NULL) {
|
if (macWin->winPtr->parentPtr != NULL) {
|
TkMacInvalClipRgns(macWin->winPtr->parentPtr);
|
TkMacInvalClipRgns(macWin->winPtr->parentPtr);
|
}
|
}
|
DisposeRgn(macWin->clipRgn);
|
DisposeRgn(macWin->clipRgn);
|
DisposeRgn(macWin->aboveClipRgn);
|
DisposeRgn(macWin->aboveClipRgn);
|
|
|
if (macWin->toplevel->referenceCount == 0) {
|
if (macWin->toplevel->referenceCount == 0) {
|
ckfree((char *) macWin->toplevel);
|
ckfree((char *) macWin->toplevel);
|
}
|
}
|
ckfree((char *) macWin);
|
ckfree((char *) macWin);
|
}
|
}
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* XMapWindow --
|
* XMapWindow --
|
*
|
*
|
* Map the given X Window to the screen. See X window documentation
|
* Map the given X Window to the screen. See X window documentation
|
* for more details.
|
* for more details.
|
*
|
*
|
* Results:
|
* Results:
|
* None.
|
* None.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* The subwindow or toplevel may appear on the screen.
|
* The subwindow or toplevel may appear on the screen.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
void
|
void
|
XMapWindow(
|
XMapWindow(
|
Display* display, /* Display. */
|
Display* display, /* Display. */
|
Window window) /* Window. */
|
Window window) /* Window. */
|
{
|
{
|
MacDrawable *macWin = (MacDrawable *) window;
|
MacDrawable *macWin = (MacDrawable *) window;
|
XEvent event;
|
XEvent event;
|
GWorldPtr destPort;
|
GWorldPtr destPort;
|
|
|
/*
|
/*
|
* Under certain situations it's possible for this function to be
|
* Under certain situations it's possible for this function to be
|
* called before the toplevel window it's associated with has actually
|
* called before the toplevel window it's associated with has actually
|
* been mapped. In that case we need to create the real Macintosh
|
* 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
|
* window now as this function as well as other X functions assume that
|
* the portPtr is valid.
|
* the portPtr is valid.
|
*/
|
*/
|
if (!TkMacHostToplevelExists(macWin->toplevel->winPtr)) {
|
if (!TkMacHostToplevelExists(macWin->toplevel->winPtr)) {
|
TkMacMakeRealWindowExist(macWin->toplevel->winPtr);
|
TkMacMakeRealWindowExist(macWin->toplevel->winPtr);
|
}
|
}
|
destPort = TkMacGetDrawablePort(window);
|
destPort = TkMacGetDrawablePort(window);
|
|
|
display->request++;
|
display->request++;
|
macWin->winPtr->flags |= TK_MAPPED;
|
macWin->winPtr->flags |= TK_MAPPED;
|
if (Tk_IsTopLevel(macWin->winPtr)) {
|
if (Tk_IsTopLevel(macWin->winPtr)) {
|
if (!Tk_IsEmbedded(macWin->winPtr)) {
|
if (!Tk_IsEmbedded(macWin->winPtr)) {
|
ShowWindow((WindowRef) destPort);
|
ShowWindow((WindowRef) destPort);
|
}
|
}
|
|
|
/*
|
/*
|
* We only need to send the MapNotify event
|
* We only need to send the MapNotify event
|
* for toplevel windows.
|
* for toplevel windows.
|
*/
|
*/
|
event.xany.serial = display->request;
|
event.xany.serial = display->request;
|
event.xany.send_event = False;
|
event.xany.send_event = False;
|
event.xany.display = display;
|
event.xany.display = display;
|
|
|
event.xmap.window = window;
|
event.xmap.window = window;
|
event.xmap.type = MapNotify;
|
event.xmap.type = MapNotify;
|
event.xmap.event = window;
|
event.xmap.event = window;
|
event.xmap.override_redirect = macWin->winPtr->atts.override_redirect;
|
event.xmap.override_redirect = macWin->winPtr->atts.override_redirect;
|
Tk_QueueWindowEvent(&event, TCL_QUEUE_TAIL);
|
Tk_QueueWindowEvent(&event, TCL_QUEUE_TAIL);
|
} else {
|
} else {
|
TkMacInvalClipRgns(macWin->winPtr->parentPtr);
|
TkMacInvalClipRgns(macWin->winPtr->parentPtr);
|
}
|
}
|
|
|
/*
|
/*
|
* Generate damage for that area of the window
|
* Generate damage for that area of the window
|
*/
|
*/
|
SetGWorld(destPort, NULL);
|
SetGWorld(destPort, NULL);
|
TkMacUpdateClipRgn(macWin->winPtr);
|
TkMacUpdateClipRgn(macWin->winPtr);
|
TkMacInvalidateWindow(macWin, TK_PARENT_WINDOW);
|
TkMacInvalidateWindow(macWin, TK_PARENT_WINDOW);
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* XUnmapWindow --
|
* XUnmapWindow --
|
*
|
*
|
* Unmap the given X Window to the screen. See X window
|
* Unmap the given X Window to the screen. See X window
|
* documentation for more details.
|
* documentation for more details.
|
*
|
*
|
* Results:
|
* Results:
|
* None.
|
* None.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* The subwindow or toplevel may be removed from the screen.
|
* The subwindow or toplevel may be removed from the screen.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
void
|
void
|
XUnmapWindow(
|
XUnmapWindow(
|
Display* display, /* Display. */
|
Display* display, /* Display. */
|
Window window) /* Window. */
|
Window window) /* Window. */
|
{
|
{
|
MacDrawable *macWin = (MacDrawable *) window;
|
MacDrawable *macWin = (MacDrawable *) window;
|
XEvent event;
|
XEvent event;
|
GWorldPtr destPort;
|
GWorldPtr destPort;
|
|
|
destPort = TkMacGetDrawablePort(window);
|
destPort = TkMacGetDrawablePort(window);
|
|
|
display->request++;
|
display->request++;
|
macWin->winPtr->flags &= ~TK_MAPPED;
|
macWin->winPtr->flags &= ~TK_MAPPED;
|
if (Tk_IsTopLevel(macWin->winPtr)) {
|
if (Tk_IsTopLevel(macWin->winPtr)) {
|
if (!Tk_IsEmbedded(macWin->winPtr)) {
|
if (!Tk_IsEmbedded(macWin->winPtr)) {
|
HideWindow((WindowRef) destPort);
|
HideWindow((WindowRef) destPort);
|
}
|
}
|
|
|
/*
|
/*
|
* We only need to send the UnmapNotify event
|
* We only need to send the UnmapNotify event
|
* for toplevel windows.
|
* for toplevel windows.
|
*/
|
*/
|
event.xany.serial = display->request;
|
event.xany.serial = display->request;
|
event.xany.send_event = False;
|
event.xany.send_event = False;
|
event.xany.display = display;
|
event.xany.display = display;
|
|
|
event.xunmap.type = UnmapNotify;
|
event.xunmap.type = UnmapNotify;
|
event.xunmap.window = window;
|
event.xunmap.window = window;
|
event.xunmap.event = window;
|
event.xunmap.event = window;
|
event.xunmap.from_configure = false;
|
event.xunmap.from_configure = false;
|
Tk_QueueWindowEvent(&event, TCL_QUEUE_TAIL);
|
Tk_QueueWindowEvent(&event, TCL_QUEUE_TAIL);
|
} else {
|
} else {
|
/*
|
/*
|
* Generate damage for that area of the window.
|
* Generate damage for that area of the window.
|
*/
|
*/
|
SetGWorld(destPort, NULL);
|
SetGWorld(destPort, NULL);
|
TkMacInvalidateWindow(macWin, TK_PARENT_WINDOW); /* TODO: may not be valid */
|
TkMacInvalidateWindow(macWin, TK_PARENT_WINDOW); /* TODO: may not be valid */
|
TkMacInvalClipRgns(macWin->winPtr->parentPtr);
|
TkMacInvalClipRgns(macWin->winPtr->parentPtr);
|
}
|
}
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* XResizeWindow --
|
* XResizeWindow --
|
*
|
*
|
* Resize a given X window. See X windows documentation for
|
* Resize a given X window. See X windows documentation for
|
* further details.
|
* further details.
|
*
|
*
|
* Results:
|
* Results:
|
* None.
|
* None.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* None.
|
* None.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
void
|
void
|
XResizeWindow(
|
XResizeWindow(
|
Display* display, /* Display. */
|
Display* display, /* Display. */
|
Window window, /* Window. */
|
Window window, /* Window. */
|
unsigned int width,
|
unsigned int width,
|
unsigned int height)
|
unsigned int height)
|
{
|
{
|
MacDrawable *macWin = (MacDrawable *) window;
|
MacDrawable *macWin = (MacDrawable *) window;
|
GWorldPtr destPort;
|
GWorldPtr destPort;
|
|
|
destPort = TkMacGetDrawablePort(window);
|
destPort = TkMacGetDrawablePort(window);
|
if (destPort == NULL) {
|
if (destPort == NULL) {
|
return;
|
return;
|
}
|
}
|
|
|
display->request++;
|
display->request++;
|
SetPort((GrafPtr) destPort);
|
SetPort((GrafPtr) destPort);
|
if (Tk_IsTopLevel(macWin->winPtr)) {
|
if (Tk_IsTopLevel(macWin->winPtr)) {
|
if (!Tk_IsEmbedded(macWin->winPtr)) {
|
if (!Tk_IsEmbedded(macWin->winPtr)) {
|
/*
|
/*
|
* NOTE: we are not adding the new space to the update
|
* NOTE: we are not adding the new space to the update
|
* region. It is currently assumed that Tk will need
|
* region. It is currently assumed that Tk will need
|
* to completely redraw anway.
|
* to completely redraw anway.
|
*/
|
*/
|
SizeWindow((WindowRef) destPort,
|
SizeWindow((WindowRef) destPort,
|
(short) width, (short) height, false);
|
(short) width, (short) height, false);
|
TkMacInvalidateWindow(macWin, TK_WINDOW_ONLY);
|
TkMacInvalidateWindow(macWin, TK_WINDOW_ONLY);
|
TkMacInvalClipRgns(macWin->winPtr);
|
TkMacInvalClipRgns(macWin->winPtr);
|
} else {
|
} else {
|
int deltaX, deltaY;
|
int deltaX, deltaY;
|
|
|
/*
|
/*
|
* Find the Parent window -
|
* Find the Parent window -
|
* For an embedded window this will be its container.
|
* For an embedded window this will be its container.
|
*/
|
*/
|
TkWindow *contWinPtr;
|
TkWindow *contWinPtr;
|
|
|
contWinPtr = TkpGetOtherWindow(macWin->winPtr);
|
contWinPtr = TkpGetOtherWindow(macWin->winPtr);
|
|
|
if (contWinPtr != NULL) {
|
if (contWinPtr != NULL) {
|
MacDrawable *macParent = contWinPtr->privatePtr;
|
MacDrawable *macParent = contWinPtr->privatePtr;
|
|
|
TkMacInvalClipRgns(macParent->winPtr);
|
TkMacInvalClipRgns(macParent->winPtr);
|
TkMacInvalidateWindow(macWin, TK_PARENT_WINDOW);
|
TkMacInvalidateWindow(macWin, TK_PARENT_WINDOW);
|
|
|
deltaX = macParent->xOff +
|
deltaX = macParent->xOff +
|
macWin->winPtr->changes.x - macWin->xOff;
|
macWin->winPtr->changes.x - macWin->xOff;
|
deltaY = macParent->yOff +
|
deltaY = macParent->yOff +
|
macWin->winPtr->changes.y - macWin->yOff;
|
macWin->winPtr->changes.y - macWin->yOff;
|
|
|
UpdateOffsets(macWin->winPtr, deltaX, deltaY);
|
UpdateOffsets(macWin->winPtr, deltaX, deltaY);
|
} else {
|
} else {
|
/*
|
/*
|
* This is the case where we are embedded in
|
* This is the case where we are embedded in
|
* another app. At this point, we are assuming that
|
* another app. At this point, we are assuming that
|
* the changes.x,y is not maintained, if you need
|
* the changes.x,y is not maintained, if you need
|
* the info get it from Tk_GetRootCoords,
|
* the info get it from Tk_GetRootCoords,
|
* and that the toplevel sits at 0,0 when it is drawn.
|
* and that the toplevel sits at 0,0 when it is drawn.
|
*/
|
*/
|
|
|
TkMacInvalidateWindow(macWin, TK_PARENT_WINDOW);
|
TkMacInvalidateWindow(macWin, TK_PARENT_WINDOW);
|
UpdateOffsets(macWin->winPtr, 0, 0);
|
UpdateOffsets(macWin->winPtr, 0, 0);
|
}
|
}
|
|
|
}
|
}
|
} else {
|
} else {
|
/* TODO: update all xOff & yOffs */
|
/* TODO: update all xOff & yOffs */
|
int deltaX, deltaY, parentBorderwidth;
|
int deltaX, deltaY, parentBorderwidth;
|
MacDrawable *macParent = macWin->winPtr->parentPtr->privatePtr;
|
MacDrawable *macParent = macWin->winPtr->parentPtr->privatePtr;
|
|
|
if (macParent == NULL) {
|
if (macParent == NULL) {
|
return; /* TODO: Probably should be a panic */
|
return; /* TODO: Probably should be a panic */
|
}
|
}
|
|
|
TkMacInvalClipRgns(macParent->winPtr);
|
TkMacInvalClipRgns(macParent->winPtr);
|
TkMacInvalidateWindow(macWin, TK_PARENT_WINDOW);
|
TkMacInvalidateWindow(macWin, TK_PARENT_WINDOW);
|
|
|
deltaX = - macWin->xOff;
|
deltaX = - macWin->xOff;
|
deltaY = - macWin->yOff;
|
deltaY = - macWin->yOff;
|
|
|
parentBorderwidth = macWin->winPtr->parentPtr->changes.border_width;
|
parentBorderwidth = macWin->winPtr->parentPtr->changes.border_width;
|
|
|
deltaX += macParent->xOff + parentBorderwidth +
|
deltaX += macParent->xOff + parentBorderwidth +
|
macWin->winPtr->changes.x;
|
macWin->winPtr->changes.x;
|
deltaY += macParent->yOff + parentBorderwidth +
|
deltaY += macParent->yOff + parentBorderwidth +
|
macWin->winPtr->changes.y;
|
macWin->winPtr->changes.y;
|
|
|
UpdateOffsets(macWin->winPtr, deltaX, deltaY);
|
UpdateOffsets(macWin->winPtr, deltaX, deltaY);
|
}
|
}
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* XMoveResizeWindow --
|
* XMoveResizeWindow --
|
*
|
*
|
* Move or resize a given X window. See X windows documentation
|
* Move or resize a given X window. See X windows documentation
|
* for further details.
|
* for further details.
|
*
|
*
|
* Results:
|
* Results:
|
* None.
|
* None.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* None.
|
* None.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
void
|
void
|
XMoveResizeWindow(
|
XMoveResizeWindow(
|
Display* display, /* Display. */
|
Display* display, /* Display. */
|
Window window, /* Window. */
|
Window window, /* Window. */
|
int x, int y,
|
int x, int y,
|
unsigned int width,
|
unsigned int width,
|
unsigned int height)
|
unsigned int height)
|
{
|
{
|
MacDrawable *macWin = (MacDrawable *) window;
|
MacDrawable *macWin = (MacDrawable *) window;
|
GWorldPtr destPort;
|
GWorldPtr destPort;
|
|
|
destPort = TkMacGetDrawablePort(window);
|
destPort = TkMacGetDrawablePort(window);
|
if (destPort == NULL) {
|
if (destPort == NULL) {
|
return;
|
return;
|
}
|
}
|
|
|
SetPort((GrafPtr) destPort);
|
SetPort((GrafPtr) destPort);
|
if (Tk_IsTopLevel(macWin->winPtr) && !Tk_IsEmbedded(macWin->winPtr)) {
|
if (Tk_IsTopLevel(macWin->winPtr) && !Tk_IsEmbedded(macWin->winPtr)) {
|
/*
|
/*
|
* NOTE: we are not adding the new space to the update
|
* NOTE: we are not adding the new space to the update
|
* region. It is currently assumed that Tk will need
|
* region. It is currently assumed that Tk will need
|
* to completely redraw anway.
|
* to completely redraw anway.
|
*/
|
*/
|
|
|
SizeWindow((WindowRef) destPort,
|
SizeWindow((WindowRef) destPort,
|
(short) width, (short) height, false);
|
(short) width, (short) height, false);
|
tkMacMoveWindow((WindowRef) destPort, x, y);
|
tkMacMoveWindow((WindowRef) destPort, x, y);
|
|
|
/* TODO: is the following right? */
|
/* TODO: is the following right? */
|
TkMacInvalidateWindow(macWin, TK_WINDOW_ONLY);
|
TkMacInvalidateWindow(macWin, TK_WINDOW_ONLY);
|
TkMacInvalClipRgns(macWin->winPtr);
|
TkMacInvalClipRgns(macWin->winPtr);
|
} else {
|
} else {
|
int deltaX, deltaY, parentBorderwidth;
|
int deltaX, deltaY, parentBorderwidth;
|
Rect bounds;
|
Rect bounds;
|
MacDrawable *macParent;
|
MacDrawable *macParent;
|
|
|
/*
|
/*
|
* Find the Parent window -
|
* Find the Parent window -
|
* For an embedded window this will be its container.
|
* For an embedded window this will be its container.
|
*/
|
*/
|
|
|
if (Tk_IsEmbedded(macWin->winPtr)) {
|
if (Tk_IsEmbedded(macWin->winPtr)) {
|
TkWindow *contWinPtr;
|
TkWindow *contWinPtr;
|
|
|
contWinPtr = TkpGetOtherWindow(macWin->winPtr);
|
contWinPtr = TkpGetOtherWindow(macWin->winPtr);
|
if (contWinPtr == NULL) {
|
if (contWinPtr == NULL) {
|
panic("XMoveResizeWindow could not find container");
|
panic("XMoveResizeWindow could not find container");
|
}
|
}
|
macParent = contWinPtr->privatePtr;
|
macParent = contWinPtr->privatePtr;
|
|
|
/*
|
/*
|
* NOTE: Here we should handle out of process embedding.
|
* NOTE: Here we should handle out of process embedding.
|
*/
|
*/
|
|
|
|
|
} else {
|
} else {
|
macParent = macWin->winPtr->parentPtr->privatePtr;
|
macParent = macWin->winPtr->parentPtr->privatePtr;
|
if (macParent == NULL) {
|
if (macParent == NULL) {
|
return; /* TODO: Probably should be a panic */
|
return; /* TODO: Probably should be a panic */
|
}
|
}
|
}
|
}
|
|
|
TkMacInvalClipRgns(macParent->winPtr);
|
TkMacInvalClipRgns(macParent->winPtr);
|
TkMacInvalidateWindow(macWin, TK_PARENT_WINDOW);
|
TkMacInvalidateWindow(macWin, TK_PARENT_WINDOW);
|
|
|
deltaX = - macWin->xOff;
|
deltaX = - macWin->xOff;
|
deltaY = - macWin->yOff;
|
deltaY = - macWin->yOff;
|
|
|
/*
|
/*
|
* If macWin->winPtr is an embedded window, don't offset by its
|
* If macWin->winPtr is an embedded window, don't offset by its
|
* parent's borderwidth...
|
* parent's borderwidth...
|
*/
|
*/
|
|
|
if (!Tk_IsEmbedded(macWin->winPtr)) {
|
if (!Tk_IsEmbedded(macWin->winPtr)) {
|
parentBorderwidth = macWin->winPtr->parentPtr->changes.border_width;
|
parentBorderwidth = macWin->winPtr->parentPtr->changes.border_width;
|
} else {
|
} else {
|
parentBorderwidth = 0;
|
parentBorderwidth = 0;
|
}
|
}
|
deltaX += macParent->xOff + parentBorderwidth +
|
deltaX += macParent->xOff + parentBorderwidth +
|
macWin->winPtr->changes.x;
|
macWin->winPtr->changes.x;
|
deltaY += macParent->yOff + parentBorderwidth +
|
deltaY += macParent->yOff + parentBorderwidth +
|
macWin->winPtr->changes.y;
|
macWin->winPtr->changes.y;
|
|
|
UpdateOffsets(macWin->winPtr, deltaX, deltaY);
|
UpdateOffsets(macWin->winPtr, deltaX, deltaY);
|
TkMacWinBounds(macWin->winPtr, &bounds);
|
TkMacWinBounds(macWin->winPtr, &bounds);
|
InvalRect(&bounds);
|
InvalRect(&bounds);
|
}
|
}
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* XMoveWindow --
|
* XMoveWindow --
|
*
|
*
|
* Move a given X window. See X windows documentation for further
|
* Move a given X window. See X windows documentation for further
|
* details.
|
* details.
|
*
|
*
|
* Results:
|
* Results:
|
* None.
|
* None.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* None.
|
* None.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
void
|
void
|
XMoveWindow(
|
XMoveWindow(
|
Display* display, /* Display. */
|
Display* display, /* Display. */
|
Window window, /* Window. */
|
Window window, /* Window. */
|
int x,
|
int x,
|
int y)
|
int y)
|
{
|
{
|
MacDrawable *macWin = (MacDrawable *) window;
|
MacDrawable *macWin = (MacDrawable *) window;
|
GWorldPtr destPort;
|
GWorldPtr destPort;
|
|
|
destPort = TkMacGetDrawablePort(window);
|
destPort = TkMacGetDrawablePort(window);
|
if (destPort == NULL) {
|
if (destPort == NULL) {
|
return;
|
return;
|
}
|
}
|
|
|
SetPort((GrafPtr) destPort);
|
SetPort((GrafPtr) destPort);
|
if (Tk_IsTopLevel(macWin->winPtr) && !Tk_IsEmbedded(macWin->winPtr)) {
|
if (Tk_IsTopLevel(macWin->winPtr) && !Tk_IsEmbedded(macWin->winPtr)) {
|
/*
|
/*
|
* NOTE: we are not adding the new space to the update
|
* NOTE: we are not adding the new space to the update
|
* region. It is currently assumed that Tk will need
|
* region. It is currently assumed that Tk will need
|
* to completely redraw anway.
|
* to completely redraw anway.
|
*/
|
*/
|
tkMacMoveWindow((WindowRef) destPort, x, y);
|
tkMacMoveWindow((WindowRef) destPort, x, y);
|
|
|
/* TODO: is the following right? */
|
/* TODO: is the following right? */
|
TkMacInvalidateWindow(macWin, TK_WINDOW_ONLY);
|
TkMacInvalidateWindow(macWin, TK_WINDOW_ONLY);
|
TkMacInvalClipRgns(macWin->winPtr);
|
TkMacInvalClipRgns(macWin->winPtr);
|
} else {
|
} else {
|
int deltaX, deltaY, parentBorderwidth;
|
int deltaX, deltaY, parentBorderwidth;
|
Rect bounds;
|
Rect bounds;
|
MacDrawable *macParent;
|
MacDrawable *macParent;
|
|
|
/*
|
/*
|
* Find the Parent window -
|
* Find the Parent window -
|
* For an embedded window this will be its container.
|
* For an embedded window this will be its container.
|
*/
|
*/
|
|
|
if (Tk_IsEmbedded(macWin->winPtr)) {
|
if (Tk_IsEmbedded(macWin->winPtr)) {
|
TkWindow *contWinPtr;
|
TkWindow *contWinPtr;
|
|
|
contWinPtr = TkpGetOtherWindow(macWin->winPtr);
|
contWinPtr = TkpGetOtherWindow(macWin->winPtr);
|
if (contWinPtr == NULL) {
|
if (contWinPtr == NULL) {
|
panic("XMoveWindow could not find container");
|
panic("XMoveWindow could not find container");
|
}
|
}
|
macParent = contWinPtr->privatePtr;
|
macParent = contWinPtr->privatePtr;
|
|
|
/*
|
/*
|
* NOTE: Here we should handle out of process embedding.
|
* NOTE: Here we should handle out of process embedding.
|
*/
|
*/
|
|
|
} else {
|
} else {
|
macParent = macWin->winPtr->parentPtr->privatePtr;
|
macParent = macWin->winPtr->parentPtr->privatePtr;
|
if (macParent == NULL) {
|
if (macParent == NULL) {
|
return; /* TODO: Probably should be a panic */
|
return; /* TODO: Probably should be a panic */
|
}
|
}
|
}
|
}
|
|
|
TkMacInvalClipRgns(macParent->winPtr);
|
TkMacInvalClipRgns(macParent->winPtr);
|
TkMacInvalidateWindow(macWin, TK_PARENT_WINDOW);
|
TkMacInvalidateWindow(macWin, TK_PARENT_WINDOW);
|
|
|
deltaX = - macWin->xOff;
|
deltaX = - macWin->xOff;
|
deltaY = - macWin->yOff;
|
deltaY = - macWin->yOff;
|
|
|
/*
|
/*
|
* If macWin->winPtr is an embedded window, don't offset by its
|
* If macWin->winPtr is an embedded window, don't offset by its
|
* parent's borderwidth...
|
* parent's borderwidth...
|
*/
|
*/
|
|
|
if (!Tk_IsEmbedded(macWin->winPtr)) {
|
if (!Tk_IsEmbedded(macWin->winPtr)) {
|
parentBorderwidth = macWin->winPtr->parentPtr->changes.border_width;
|
parentBorderwidth = macWin->winPtr->parentPtr->changes.border_width;
|
} else {
|
} else {
|
parentBorderwidth = 0;
|
parentBorderwidth = 0;
|
}
|
}
|
deltaX += macParent->xOff + parentBorderwidth +
|
deltaX += macParent->xOff + parentBorderwidth +
|
macWin->winPtr->changes.x;
|
macWin->winPtr->changes.x;
|
deltaY += macParent->yOff + parentBorderwidth +
|
deltaY += macParent->yOff + parentBorderwidth +
|
macWin->winPtr->changes.y;
|
macWin->winPtr->changes.y;
|
|
|
UpdateOffsets(macWin->winPtr, deltaX, deltaY);
|
UpdateOffsets(macWin->winPtr, deltaX, deltaY);
|
TkMacWinBounds(macWin->winPtr, &bounds);
|
TkMacWinBounds(macWin->winPtr, &bounds);
|
InvalRect(&bounds);
|
InvalRect(&bounds);
|
}
|
}
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* XRaiseWindow --
|
* XRaiseWindow --
|
*
|
*
|
* Change the stacking order of a window.
|
* Change the stacking order of a window.
|
*
|
*
|
* Results:
|
* Results:
|
* None.
|
* None.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* Changes the stacking order of the specified window.
|
* Changes the stacking order of the specified window.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
void
|
void
|
XRaiseWindow(
|
XRaiseWindow(
|
Display* display, /* Display. */
|
Display* display, /* Display. */
|
Window window) /* Window. */
|
Window window) /* Window. */
|
{
|
{
|
MacDrawable *macWin = (MacDrawable *) window;
|
MacDrawable *macWin = (MacDrawable *) window;
|
|
|
display->request++;
|
display->request++;
|
if (Tk_IsTopLevel(macWin->winPtr) && !Tk_IsEmbedded(macWin->winPtr)) {
|
if (Tk_IsTopLevel(macWin->winPtr) && !Tk_IsEmbedded(macWin->winPtr)) {
|
TkWmRestackToplevel(macWin->winPtr, Above, NULL);
|
TkWmRestackToplevel(macWin->winPtr, Above, NULL);
|
} else {
|
} else {
|
/* TODO: this should generate damage */
|
/* TODO: this should generate damage */
|
}
|
}
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* XConfigureWindow --
|
* XConfigureWindow --
|
*
|
*
|
* Change the size, position, stacking, or border of the specified
|
* Change the size, position, stacking, or border of the specified
|
* window.
|
* window.
|
*
|
*
|
* Results:
|
* Results:
|
* None.
|
* None.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* Changes the attributes of the specified window. Note that we
|
* Changes the attributes of the specified window. Note that we
|
* ignore the passed in values and use the values stored in the
|
* ignore the passed in values and use the values stored in the
|
* TkWindow data structure.
|
* TkWindow data structure.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
void
|
void
|
XConfigureWindow(
|
XConfigureWindow(
|
Display* display, /* Display. */
|
Display* display, /* Display. */
|
Window w, /* Window. */
|
Window w, /* Window. */
|
unsigned int value_mask,
|
unsigned int value_mask,
|
XWindowChanges* values)
|
XWindowChanges* values)
|
{
|
{
|
MacDrawable *macWin = (MacDrawable *) w;
|
MacDrawable *macWin = (MacDrawable *) w;
|
TkWindow *winPtr = macWin->winPtr;
|
TkWindow *winPtr = macWin->winPtr;
|
|
|
display->request++;
|
display->request++;
|
|
|
/*
|
/*
|
* Change the shape and/or position of the window.
|
* Change the shape and/or position of the window.
|
*/
|
*/
|
|
|
if (value_mask & (CWX|CWY|CWWidth|CWHeight)) {
|
if (value_mask & (CWX|CWY|CWWidth|CWHeight)) {
|
XMoveResizeWindow(display, w, winPtr->changes.x, winPtr->changes.y,
|
XMoveResizeWindow(display, w, winPtr->changes.x, winPtr->changes.y,
|
winPtr->changes.width, winPtr->changes.height);
|
winPtr->changes.width, winPtr->changes.height);
|
}
|
}
|
|
|
/*
|
/*
|
* Change the stacking order of the window. Tk actuall keeps all
|
* Change the stacking order of the window. Tk actuall keeps all
|
* the information we need for stacking order. All we need to do
|
* the information we need for stacking order. All we need to do
|
* is make sure the clipping regions get updated and generate damage
|
* is make sure the clipping regions get updated and generate damage
|
* that will ensure things get drawn correctly.
|
* that will ensure things get drawn correctly.
|
*/
|
*/
|
|
|
if (value_mask & CWStackMode) {
|
if (value_mask & CWStackMode) {
|
Rect bounds;
|
Rect bounds;
|
GWorldPtr destPort;
|
GWorldPtr destPort;
|
|
|
destPort = TkMacGetDrawablePort(w);
|
destPort = TkMacGetDrawablePort(w);
|
if (destPort != NULL) {
|
if (destPort != NULL) {
|
SetPort((GrafPtr) destPort);
|
SetPort((GrafPtr) destPort);
|
TkMacInvalClipRgns(winPtr->parentPtr);
|
TkMacInvalClipRgns(winPtr->parentPtr);
|
TkMacWinBounds(winPtr, &bounds);
|
TkMacWinBounds(winPtr, &bounds);
|
InvalRect(&bounds);
|
InvalRect(&bounds);
|
}
|
}
|
}
|
}
|
|
|
/* TkGenWMMoveRequestEvent(macWin->winPtr,
|
/* TkGenWMMoveRequestEvent(macWin->winPtr,
|
macWin->winPtr->changes.x, macWin->winPtr->changes.y); */
|
macWin->winPtr->changes.x, macWin->winPtr->changes.y); */
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* TkMacUpdateClipRgn --
|
* TkMacUpdateClipRgn --
|
*
|
*
|
* This function updates the cliping regions for a given window
|
* This function updates the cliping regions for a given window
|
* and all of its children. Once updated the TK_CLIP_INVALID flag
|
* and all of its children. Once updated the TK_CLIP_INVALID flag
|
* in the subwindow data structure is unset. The TK_CLIP_INVALID
|
* in the subwindow data structure is unset. The TK_CLIP_INVALID
|
* flag should always be unset before any drawing is attempted.
|
* flag should always be unset before any drawing is attempted.
|
*
|
*
|
* Results:
|
* Results:
|
* None.
|
* None.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* The clip regions for the window and its children are updated.
|
* The clip regions for the window and its children are updated.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
void
|
void
|
TkMacUpdateClipRgn(
|
TkMacUpdateClipRgn(
|
TkWindow *winPtr)
|
TkWindow *winPtr)
|
{
|
{
|
RgnHandle rgn;
|
RgnHandle rgn;
|
int x, y;
|
int x, y;
|
TkWindow *win2Ptr;
|
TkWindow *win2Ptr;
|
|
|
if (winPtr == NULL) {
|
if (winPtr == NULL) {
|
return;
|
return;
|
}
|
}
|
|
|
if (winPtr->privatePtr->flags & TK_CLIP_INVALID) {
|
if (winPtr->privatePtr->flags & TK_CLIP_INVALID) {
|
rgn = winPtr->privatePtr->aboveClipRgn;
|
rgn = winPtr->privatePtr->aboveClipRgn;
|
if (tmpRgn == NULL) {
|
if (tmpRgn == NULL) {
|
tmpRgn = NewRgn();
|
tmpRgn = NewRgn();
|
}
|
}
|
|
|
/*
|
/*
|
* Start with a region defined by the window bounds.
|
* Start with a region defined by the window bounds.
|
*/
|
*/
|
|
|
x = winPtr->privatePtr->xOff;
|
x = winPtr->privatePtr->xOff;
|
y = winPtr->privatePtr->yOff;
|
y = winPtr->privatePtr->yOff;
|
SetRectRgn(rgn, (short) x, (short) y,
|
SetRectRgn(rgn, (short) x, (short) y,
|
(short) (winPtr->changes.width + x),
|
(short) (winPtr->changes.width + x),
|
(short) (winPtr->changes.height + y));
|
(short) (winPtr->changes.height + y));
|
|
|
/*
|
/*
|
* Clip away the area of any windows that may obscure this
|
* Clip away the area of any windows that may obscure this
|
* window.
|
* window.
|
* For a non-toplevel window, first, clip to the parents visable
|
* For a non-toplevel window, first, clip to the parents visable
|
* clip region.
|
* clip region.
|
* Second, clip away any siblings that are higher in the
|
* Second, clip away any siblings that are higher in the
|
* stacking order.
|
* stacking order.
|
* For an embedded toplevel, just clip to the container's visible
|
* For an embedded toplevel, just clip to the container's visible
|
* clip region. Remember, we only allow one contained window
|
* clip region. Remember, we only allow one contained window
|
* in a frame, and don't support any other widgets in the frame either.
|
* in a frame, and don't support any other widgets in the frame either.
|
* This is not currently enforced, however.
|
* This is not currently enforced, however.
|
*/
|
*/
|
|
|
if (!Tk_IsTopLevel(winPtr)) {
|
if (!Tk_IsTopLevel(winPtr)) {
|
TkMacUpdateClipRgn(winPtr->parentPtr);
|
TkMacUpdateClipRgn(winPtr->parentPtr);
|
SectRgn(rgn,
|
SectRgn(rgn,
|
winPtr->parentPtr->privatePtr->aboveClipRgn, rgn);
|
winPtr->parentPtr->privatePtr->aboveClipRgn, rgn);
|
|
|
win2Ptr = winPtr->nextPtr;
|
win2Ptr = winPtr->nextPtr;
|
while (win2Ptr != NULL) {
|
while (win2Ptr != NULL) {
|
if (Tk_IsTopLevel(win2Ptr) || !Tk_IsMapped(win2Ptr)) {
|
if (Tk_IsTopLevel(win2Ptr) || !Tk_IsMapped(win2Ptr)) {
|
win2Ptr = win2Ptr->nextPtr;
|
win2Ptr = win2Ptr->nextPtr;
|
continue;
|
continue;
|
}
|
}
|
x = win2Ptr->privatePtr->xOff;
|
x = win2Ptr->privatePtr->xOff;
|
y = win2Ptr->privatePtr->yOff;
|
y = win2Ptr->privatePtr->yOff;
|
SetRectRgn(tmpRgn, (short) x, (short) y,
|
SetRectRgn(tmpRgn, (short) x, (short) y,
|
(short) (win2Ptr->changes.width + x),
|
(short) (win2Ptr->changes.width + x),
|
(short) (win2Ptr->changes.height + y));
|
(short) (win2Ptr->changes.height + y));
|
DiffRgn(rgn, tmpRgn, rgn);
|
DiffRgn(rgn, tmpRgn, rgn);
|
|
|
win2Ptr = win2Ptr->nextPtr;
|
win2Ptr = win2Ptr->nextPtr;
|
}
|
}
|
} else if (Tk_IsEmbedded(winPtr)) {
|
} else if (Tk_IsEmbedded(winPtr)) {
|
TkWindow *contWinPtr;
|
TkWindow *contWinPtr;
|
|
|
contWinPtr = TkpGetOtherWindow(winPtr);
|
contWinPtr = TkpGetOtherWindow(winPtr);
|
|
|
if (contWinPtr != NULL) {
|
if (contWinPtr != NULL) {
|
TkMacUpdateClipRgn(contWinPtr);
|
TkMacUpdateClipRgn(contWinPtr);
|
SectRgn(rgn,
|
SectRgn(rgn,
|
contWinPtr->privatePtr->aboveClipRgn, rgn);
|
contWinPtr->privatePtr->aboveClipRgn, rgn);
|
} else if (gMacEmbedHandler != NULL) {
|
} else if (gMacEmbedHandler != NULL) {
|
gMacEmbedHandler->getClipProc((Tk_Window) winPtr, tmpRgn);
|
gMacEmbedHandler->getClipProc((Tk_Window) winPtr, tmpRgn);
|
SectRgn(rgn, tmpRgn, rgn);
|
SectRgn(rgn, tmpRgn, rgn);
|
}
|
}
|
|
|
/*
|
/*
|
* NOTE: Here we should handle out of process embedding.
|
* NOTE: Here we should handle out of process embedding.
|
*/
|
*/
|
|
|
}
|
}
|
|
|
/*
|
/*
|
* The final clip region is the aboveClip region (or visable
|
* The final clip region is the aboveClip region (or visable
|
* region) minus all the children of this window.
|
* region) minus all the children of this window.
|
* Alternatively, if the window is a container, we must also
|
* Alternatively, if the window is a container, we must also
|
* subtract the region of the embedded window.
|
* subtract the region of the embedded window.
|
*/
|
*/
|
|
|
rgn = winPtr->privatePtr->clipRgn;
|
rgn = winPtr->privatePtr->clipRgn;
|
CopyRgn(winPtr->privatePtr->aboveClipRgn, rgn);
|
CopyRgn(winPtr->privatePtr->aboveClipRgn, rgn);
|
|
|
win2Ptr = winPtr->childList;
|
win2Ptr = winPtr->childList;
|
while (win2Ptr != NULL) {
|
while (win2Ptr != NULL) {
|
if (Tk_IsTopLevel(win2Ptr) || !Tk_IsMapped(win2Ptr)) {
|
if (Tk_IsTopLevel(win2Ptr) || !Tk_IsMapped(win2Ptr)) {
|
win2Ptr = win2Ptr->nextPtr;
|
win2Ptr = win2Ptr->nextPtr;
|
continue;
|
continue;
|
}
|
}
|
x = win2Ptr->privatePtr->xOff;
|
x = win2Ptr->privatePtr->xOff;
|
y = win2Ptr->privatePtr->yOff;
|
y = win2Ptr->privatePtr->yOff;
|
SetRectRgn(tmpRgn, (short) x, (short) y,
|
SetRectRgn(tmpRgn, (short) x, (short) y,
|
(short) (win2Ptr->changes.width + x),
|
(short) (win2Ptr->changes.width + x),
|
(short) (win2Ptr->changes.height + y));
|
(short) (win2Ptr->changes.height + y));
|
DiffRgn(rgn, tmpRgn, rgn);
|
DiffRgn(rgn, tmpRgn, rgn);
|
|
|
win2Ptr = win2Ptr->nextPtr;
|
win2Ptr = win2Ptr->nextPtr;
|
}
|
}
|
|
|
if (Tk_IsContainer(winPtr)) {
|
if (Tk_IsContainer(winPtr)) {
|
win2Ptr = TkpGetOtherWindow(winPtr);
|
win2Ptr = TkpGetOtherWindow(winPtr);
|
if (win2Ptr != NULL) {
|
if (win2Ptr != NULL) {
|
if (Tk_IsMapped(win2Ptr)) {
|
if (Tk_IsMapped(win2Ptr)) {
|
x = win2Ptr->privatePtr->xOff;
|
x = win2Ptr->privatePtr->xOff;
|
y = win2Ptr->privatePtr->yOff;
|
y = win2Ptr->privatePtr->yOff;
|
SetRectRgn(tmpRgn, (short) x, (short) y,
|
SetRectRgn(tmpRgn, (short) x, (short) y,
|
(short) (win2Ptr->changes.width + x),
|
(short) (win2Ptr->changes.width + x),
|
(short) (win2Ptr->changes.height + y));
|
(short) (win2Ptr->changes.height + y));
|
DiffRgn(rgn, tmpRgn, rgn);
|
DiffRgn(rgn, tmpRgn, rgn);
|
}
|
}
|
}
|
}
|
|
|
/*
|
/*
|
* NOTE: Here we should handle out of process embedding.
|
* NOTE: Here we should handle out of process embedding.
|
*/
|
*/
|
|
|
}
|
}
|
|
|
winPtr->privatePtr->flags &= ~TK_CLIP_INVALID;
|
winPtr->privatePtr->flags &= ~TK_CLIP_INVALID;
|
}
|
}
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* TkMacVisableClipRgn --
|
* TkMacVisableClipRgn --
|
*
|
*
|
* This function returnd the Macintosh cliping region for the
|
* This function returnd the Macintosh cliping region for the
|
* given window. A NULL Rgn means the window is not visable.
|
* given window. A NULL Rgn means the window is not visable.
|
*
|
*
|
* Results:
|
* Results:
|
* The region.
|
* The region.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* None.
|
* None.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
RgnHandle
|
RgnHandle
|
TkMacVisableClipRgn(
|
TkMacVisableClipRgn(
|
TkWindow *winPtr)
|
TkWindow *winPtr)
|
{
|
{
|
if (winPtr->privatePtr->flags & TK_CLIP_INVALID) {
|
if (winPtr->privatePtr->flags & TK_CLIP_INVALID) {
|
TkMacUpdateClipRgn(winPtr);
|
TkMacUpdateClipRgn(winPtr);
|
}
|
}
|
|
|
return winPtr->privatePtr->clipRgn;
|
return winPtr->privatePtr->clipRgn;
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* TkMacInvalidateWindow --
|
* TkMacInvalidateWindow --
|
*
|
*
|
* This function makes the window as invalid will generate damage
|
* This function makes the window as invalid will generate damage
|
* for the window.
|
* for the window.
|
*
|
*
|
* Results:
|
* Results:
|
* None.
|
* None.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* Damage is created.
|
* Damage is created.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
void
|
void
|
TkMacInvalidateWindow(
|
TkMacInvalidateWindow(
|
MacDrawable *macWin, /* Make window that's causing damage. */
|
MacDrawable *macWin, /* Make window that's causing damage. */
|
int flag) /* Should be TK_WINDOW_ONLY or
|
int flag) /* Should be TK_WINDOW_ONLY or
|
* TK_PARENT_WINDOW */
|
* TK_PARENT_WINDOW */
|
{
|
{
|
|
|
if (flag == TK_WINDOW_ONLY) {
|
if (flag == TK_WINDOW_ONLY) {
|
InvalRgn(macWin->clipRgn);
|
InvalRgn(macWin->clipRgn);
|
} else {
|
} else {
|
if (!EmptyRgn(macWin->aboveClipRgn)) {
|
if (!EmptyRgn(macWin->aboveClipRgn)) {
|
InvalRgn(macWin->aboveClipRgn);
|
InvalRgn(macWin->aboveClipRgn);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* TkMacGetDrawablePort --
|
* TkMacGetDrawablePort --
|
*
|
*
|
* This function returns the Graphics Port for a given X drawable.
|
* This function returns the Graphics Port for a given X drawable.
|
*
|
*
|
* Results:
|
* Results:
|
* A GWorld pointer. Either an off screen pixmap or a Window.
|
* A GWorld pointer. Either an off screen pixmap or a Window.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* None.
|
* None.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
GWorldPtr
|
GWorldPtr
|
TkMacGetDrawablePort(
|
TkMacGetDrawablePort(
|
Drawable drawable)
|
Drawable drawable)
|
{
|
{
|
MacDrawable *macWin = (MacDrawable *) drawable;
|
MacDrawable *macWin = (MacDrawable *) drawable;
|
GWorldPtr resultPort = NULL;
|
GWorldPtr resultPort = NULL;
|
|
|
if (macWin == NULL) {
|
if (macWin == NULL) {
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
/*
|
/*
|
* This is NULL for off-screen pixmaps. Then the portPtr
|
* This is NULL for off-screen pixmaps. Then the portPtr
|
* always points to the off-screen port, and we don't
|
* always points to the off-screen port, and we don't
|
* have to worry about containment
|
* have to worry about containment
|
*/
|
*/
|
|
|
if (macWin->clipRgn == NULL) {
|
if (macWin->clipRgn == NULL) {
|
return macWin->portPtr;
|
return macWin->portPtr;
|
}
|
}
|
|
|
/*
|
/*
|
* If the Drawable is in an embedded window, use the Port of its container.
|
* 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
|
* TRICKY POINT: we can have cases when a toplevel is being destroyed
|
* where the winPtr for the toplevel has been freed, but the children
|
* where the winPtr for the toplevel has been freed, but the children
|
* are not all the way destroyed. The children will call this function
|
* are not all the way destroyed. The children will call this function
|
* as they are being destroyed, but Tk_IsEmbedded will return garbage.
|
* 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
|
* So we check the copy of the TK_EMBEDDED flag we put into the
|
* toplevel's macWin flags.
|
* toplevel's macWin flags.
|
*/
|
*/
|
|
|
if (!(macWin->toplevel->flags & TK_EMBEDDED)) {
|
if (!(macWin->toplevel->flags & TK_EMBEDDED)) {
|
return macWin->toplevel->portPtr;
|
return macWin->toplevel->portPtr;
|
} else {
|
} else {
|
TkWindow *contWinPtr;
|
TkWindow *contWinPtr;
|
|
|
contWinPtr = TkpGetOtherWindow(macWin->toplevel->winPtr);
|
contWinPtr = TkpGetOtherWindow(macWin->toplevel->winPtr);
|
|
|
if (contWinPtr != NULL) {
|
if (contWinPtr != NULL) {
|
resultPort = TkMacGetDrawablePort((Drawable) contWinPtr->privatePtr);
|
resultPort = TkMacGetDrawablePort((Drawable) contWinPtr->privatePtr);
|
} else if (gMacEmbedHandler != NULL) {
|
} else if (gMacEmbedHandler != NULL) {
|
resultPort = gMacEmbedHandler->getPortProc(
|
resultPort = gMacEmbedHandler->getPortProc(
|
(Tk_Window) macWin->winPtr);
|
(Tk_Window) macWin->winPtr);
|
}
|
}
|
|
|
if (resultPort == NULL) {
|
if (resultPort == NULL) {
|
panic("TkMacGetDrawablePort couldn't find container");
|
panic("TkMacGetDrawablePort couldn't find container");
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
/*
|
/*
|
* NOTE: Here we should handle out of process embedding.
|
* NOTE: Here we should handle out of process embedding.
|
*/
|
*/
|
|
|
}
|
}
|
return resultPort;
|
return resultPort;
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* TkMacInvalClipRgns --
|
* TkMacInvalClipRgns --
|
*
|
*
|
* This function invalidates the clipping regions for a given
|
* This function invalidates the clipping regions for a given
|
* window and all of its children. This function should be
|
* window and all of its children. This function should be
|
* called whenever changes are made to subwindows that would
|
* called whenever changes are made to subwindows that would
|
* effect the size or position of windows.
|
* effect the size or position of windows.
|
*
|
*
|
* Results:
|
* Results:
|
* None.
|
* None.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* The cliping regions for the window and its children are
|
* The cliping regions for the window and its children are
|
* mark invalid. (Make sure they are valid before drawing.)
|
* mark invalid. (Make sure they are valid before drawing.)
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
void
|
void
|
TkMacInvalClipRgns(
|
TkMacInvalClipRgns(
|
TkWindow *winPtr)
|
TkWindow *winPtr)
|
{
|
{
|
TkWindow *childPtr;
|
TkWindow *childPtr;
|
|
|
/*
|
/*
|
* If already marked we can stop because all
|
* If already marked we can stop because all
|
* decendants will also already be marked.
|
* decendants will also already be marked.
|
*/
|
*/
|
if (winPtr->privatePtr->flags & TK_CLIP_INVALID) {
|
if (winPtr->privatePtr->flags & TK_CLIP_INVALID) {
|
return;
|
return;
|
}
|
}
|
|
|
winPtr->privatePtr->flags |= TK_CLIP_INVALID;
|
winPtr->privatePtr->flags |= TK_CLIP_INVALID;
|
|
|
/*
|
/*
|
* Invalidate clip regions for all children &
|
* Invalidate clip regions for all children &
|
* their decendants - unless the child is a toplevel.
|
* their decendants - unless the child is a toplevel.
|
*/
|
*/
|
childPtr = winPtr->childList;
|
childPtr = winPtr->childList;
|
while (childPtr != NULL) {
|
while (childPtr != NULL) {
|
if (!Tk_IsTopLevel(childPtr) && Tk_IsMapped(childPtr)) {
|
if (!Tk_IsTopLevel(childPtr) && Tk_IsMapped(childPtr)) {
|
TkMacInvalClipRgns(childPtr);
|
TkMacInvalClipRgns(childPtr);
|
}
|
}
|
childPtr = childPtr->nextPtr;
|
childPtr = childPtr->nextPtr;
|
}
|
}
|
|
|
/*
|
/*
|
* Also, if the window is a container, mark its embedded window
|
* Also, if the window is a container, mark its embedded window
|
*/
|
*/
|
|
|
if (Tk_IsContainer(winPtr)) {
|
if (Tk_IsContainer(winPtr)) {
|
childPtr = TkpGetOtherWindow(winPtr);
|
childPtr = TkpGetOtherWindow(winPtr);
|
|
|
if (childPtr != NULL && Tk_IsMapped(childPtr)) {
|
if (childPtr != NULL && Tk_IsMapped(childPtr)) {
|
TkMacInvalClipRgns(childPtr);
|
TkMacInvalClipRgns(childPtr);
|
}
|
}
|
|
|
/*
|
/*
|
* NOTE: Here we should handle out of process embedding.
|
* NOTE: Here we should handle out of process embedding.
|
*/
|
*/
|
|
|
}
|
}
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* TkMacWinBounds --
|
* TkMacWinBounds --
|
*
|
*
|
* Given a Tk window this function determines the windows
|
* Given a Tk window this function determines the windows
|
* bounds in relation to the Macintosh window's coordinate
|
* bounds in relation to the Macintosh window's coordinate
|
* system. This is also the same coordinate system as the
|
* system. This is also the same coordinate system as the
|
* Tk toplevel window in which this window is contained.
|
* Tk toplevel window in which this window is contained.
|
*
|
*
|
* Results:
|
* Results:
|
* None.
|
* None.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* None.
|
* None.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
void
|
void
|
TkMacWinBounds(
|
TkMacWinBounds(
|
TkWindow *winPtr,
|
TkWindow *winPtr,
|
Rect *bounds)
|
Rect *bounds)
|
{
|
{
|
bounds->left = (short) winPtr->privatePtr->xOff;
|
bounds->left = (short) winPtr->privatePtr->xOff;
|
bounds->top = (short) winPtr->privatePtr->yOff;
|
bounds->top = (short) winPtr->privatePtr->yOff;
|
bounds->right = (short) (winPtr->privatePtr->xOff +
|
bounds->right = (short) (winPtr->privatePtr->xOff +
|
winPtr->changes.width);
|
winPtr->changes.width);
|
bounds->bottom = (short) (winPtr->privatePtr->yOff +
|
bounds->bottom = (short) (winPtr->privatePtr->yOff +
|
winPtr->changes.height);
|
winPtr->changes.height);
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* tkMacMoveWindow --
|
* tkMacMoveWindow --
|
*
|
*
|
* A replacement for the Macintosh MoveWindow function. This
|
* A replacement for the Macintosh MoveWindow function. This
|
* function adjusts the inputs to MoveWindow to offset the root of
|
* function adjusts the inputs to MoveWindow to offset the root of
|
* the window system. This has the effect of making the coords
|
* the window system. This has the effect of making the coords
|
* refer to the window dressing rather than the top of the content.
|
* refer to the window dressing rather than the top of the content.
|
*
|
*
|
* Results:
|
* Results:
|
* None.
|
* None.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* Moves the Macintosh window.
|
* Moves the Macintosh window.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
void
|
void
|
tkMacMoveWindow(
|
tkMacMoveWindow(
|
WindowRef window,
|
WindowRef window,
|
int x,
|
int x,
|
int y)
|
int y)
|
{
|
{
|
int xOffset, yOffset;
|
int xOffset, yOffset;
|
|
|
TkMacWindowOffset(window, &xOffset, &yOffset);
|
TkMacWindowOffset(window, &xOffset, &yOffset);
|
MoveWindow((WindowRef) window,
|
MoveWindow((WindowRef) window,
|
(short) (x + xOffset), (short) (y + yOffset), false);
|
(short) (x + xOffset), (short) (y + yOffset), false);
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* UpdateOffsets --
|
* UpdateOffsets --
|
*
|
*
|
* Updates the X & Y offsets of the given TkWindow from the
|
* Updates the X & Y offsets of the given TkWindow from the
|
* TopLevel it is a decendant of.
|
* TopLevel it is a decendant of.
|
*
|
*
|
* Results:
|
* Results:
|
* None.
|
* None.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* The xOff & yOff fields for the Mac window datastructure
|
* The xOff & yOff fields for the Mac window datastructure
|
* is updated to the proper offset.
|
* is updated to the proper offset.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
static void
|
static void
|
UpdateOffsets(
|
UpdateOffsets(
|
TkWindow *winPtr,
|
TkWindow *winPtr,
|
int deltaX,
|
int deltaX,
|
int deltaY)
|
int deltaY)
|
{
|
{
|
TkWindow *childPtr;
|
TkWindow *childPtr;
|
|
|
if (winPtr->privatePtr == NULL) {
|
if (winPtr->privatePtr == NULL) {
|
/*
|
/*
|
* We havn't called Tk_MakeWindowExist for this window yet. The
|
* We havn't called Tk_MakeWindowExist for this window yet. The
|
* offset information will be postponed and calulated at that
|
* offset information will be postponed and calulated at that
|
* time. (This will usually only happen when a mapped parent is
|
* time. (This will usually only happen when a mapped parent is
|
* being moved but has child windows that have yet to be mapped.)
|
* being moved but has child windows that have yet to be mapped.)
|
*/
|
*/
|
return;
|
return;
|
}
|
}
|
|
|
winPtr->privatePtr->xOff += deltaX;
|
winPtr->privatePtr->xOff += deltaX;
|
winPtr->privatePtr->yOff += deltaY;
|
winPtr->privatePtr->yOff += deltaY;
|
|
|
childPtr = winPtr->childList;
|
childPtr = winPtr->childList;
|
while (childPtr != NULL) {
|
while (childPtr != NULL) {
|
if (!Tk_IsTopLevel(childPtr)) {
|
if (!Tk_IsTopLevel(childPtr)) {
|
UpdateOffsets(childPtr, deltaX, deltaY);
|
UpdateOffsets(childPtr, deltaX, deltaY);
|
}
|
}
|
childPtr = childPtr->nextPtr;
|
childPtr = childPtr->nextPtr;
|
}
|
}
|
|
|
if (Tk_IsContainer(winPtr)) {
|
if (Tk_IsContainer(winPtr)) {
|
childPtr = TkpGetOtherWindow(winPtr);
|
childPtr = TkpGetOtherWindow(winPtr);
|
if (childPtr != NULL) {
|
if (childPtr != NULL) {
|
UpdateOffsets(childPtr,deltaX,deltaY);
|
UpdateOffsets(childPtr,deltaX,deltaY);
|
}
|
}
|
|
|
/*
|
/*
|
* NOTE: Here we should handle out of process embedding.
|
* NOTE: Here we should handle out of process embedding.
|
*/
|
*/
|
|
|
}
|
}
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* Tk_GetPixmap --
|
* Tk_GetPixmap --
|
*
|
*
|
* Creates an in memory drawing surface.
|
* Creates an in memory drawing surface.
|
*
|
*
|
* Results:
|
* Results:
|
* Returns a handle to a new pixmap.
|
* Returns a handle to a new pixmap.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* Allocates a new Macintosh GWorld.
|
* Allocates a new Macintosh GWorld.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
Pixmap
|
Pixmap
|
Tk_GetPixmap(
|
Tk_GetPixmap(
|
Display *display, /* Display for new pixmap (can be null). */
|
Display *display, /* Display for new pixmap (can be null). */
|
Drawable d, /* Drawable where pixmap will be used (ignored). */
|
Drawable d, /* Drawable where pixmap will be used (ignored). */
|
int width, /* Dimensions of pixmap. */
|
int width, /* Dimensions of pixmap. */
|
int height,
|
int height,
|
int depth) /* Bits per pixel for pixmap. */
|
int depth) /* Bits per pixel for pixmap. */
|
{
|
{
|
QDErr err;
|
QDErr err;
|
GWorldPtr gWorld;
|
GWorldPtr gWorld;
|
Rect bounds;
|
Rect bounds;
|
MacDrawable *macPix;
|
MacDrawable *macPix;
|
PixMapHandle pixels;
|
PixMapHandle pixels;
|
|
|
if (display != NULL) {
|
if (display != NULL) {
|
display->request++;
|
display->request++;
|
}
|
}
|
macPix = (MacDrawable *) ckalloc(sizeof(MacDrawable));
|
macPix = (MacDrawable *) ckalloc(sizeof(MacDrawable));
|
macPix->winPtr = NULL;
|
macPix->winPtr = NULL;
|
macPix->xOff = 0;
|
macPix->xOff = 0;
|
macPix->yOff = 0;
|
macPix->yOff = 0;
|
macPix->clipRgn = NULL;
|
macPix->clipRgn = NULL;
|
macPix->aboveClipRgn = NULL;
|
macPix->aboveClipRgn = NULL;
|
macPix->referenceCount = 0;
|
macPix->referenceCount = 0;
|
macPix->toplevel = NULL;
|
macPix->toplevel = NULL;
|
macPix->flags = 0;
|
macPix->flags = 0;
|
|
|
bounds.top = bounds.left = 0;
|
bounds.top = bounds.left = 0;
|
bounds.right = (short) width;
|
bounds.right = (short) width;
|
bounds.bottom = (short) height;
|
bounds.bottom = (short) height;
|
if (depth != 1) {
|
if (depth != 1) {
|
depth = 0;
|
depth = 0;
|
}
|
}
|
|
|
/*
|
/*
|
* Allocate memory for the off screen pixmap. If we fail
|
* Allocate memory for the off screen pixmap. If we fail
|
* try again from system memory. Eventually, we may have
|
* try again from system memory. Eventually, we may have
|
* to panic.
|
* to panic.
|
*/
|
*/
|
err = NewGWorld(&gWorld, depth, &bounds, NULL, NULL, 0);
|
err = NewGWorld(&gWorld, depth, &bounds, NULL, NULL, 0);
|
if (err != noErr) {
|
if (err != noErr) {
|
err = NewGWorld(&gWorld, depth, &bounds, NULL, NULL, useTempMem);
|
err = NewGWorld(&gWorld, depth, &bounds, NULL, NULL, useTempMem);
|
}
|
}
|
if (err != noErr) {
|
if (err != noErr) {
|
panic("Out of memory: NewGWorld failed in Tk_GetPixmap");
|
panic("Out of memory: NewGWorld failed in Tk_GetPixmap");
|
}
|
}
|
|
|
/*
|
/*
|
* Lock down the pixels so they don't move out from under us.
|
* Lock down the pixels so they don't move out from under us.
|
*/
|
*/
|
pixels = GetGWorldPixMap(gWorld);
|
pixels = GetGWorldPixMap(gWorld);
|
LockPixels(pixels);
|
LockPixels(pixels);
|
macPix->portPtr = gWorld;
|
macPix->portPtr = gWorld;
|
|
|
return (Pixmap) macPix;
|
return (Pixmap) macPix;
|
}
|
}
|
|
|
/*
|
/*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*
|
*
|
* Tk_FreePixmap --
|
* Tk_FreePixmap --
|
*
|
*
|
* Release the resources associated with a pixmap.
|
* Release the resources associated with a pixmap.
|
*
|
*
|
* Results:
|
* Results:
|
* None.
|
* None.
|
*
|
*
|
* Side effects:
|
* Side effects:
|
* Deletes the Macintosh GWorld created by Tk_GetPixmap.
|
* Deletes the Macintosh GWorld created by Tk_GetPixmap.
|
*
|
*
|
*----------------------------------------------------------------------
|
*----------------------------------------------------------------------
|
*/
|
*/
|
|
|
void
|
void
|
Tk_FreePixmap(
|
Tk_FreePixmap(
|
Display *display, /* Display. */
|
Display *display, /* Display. */
|
Pixmap pixmap) /* Pixmap to destroy */
|
Pixmap pixmap) /* Pixmap to destroy */
|
{
|
{
|
MacDrawable *macPix = (MacDrawable *) pixmap;
|
MacDrawable *macPix = (MacDrawable *) pixmap;
|
PixMapHandle pixels;
|
PixMapHandle pixels;
|
|
|
display->request++;
|
display->request++;
|
pixels = GetGWorldPixMap(macPix->portPtr);
|
pixels = GetGWorldPixMap(macPix->portPtr);
|
UnlockPixels(pixels);
|
UnlockPixels(pixels);
|
DisposeGWorld(macPix->portPtr);
|
DisposeGWorld(macPix->portPtr);
|
ckfree((char *) macPix);
|
ckfree((char *) macPix);
|
}
|
}
|
|
|
|
|
