void
XMoveResizeWindow(
Display *display, /* Display. */
Window window, /* Window. */
int x, int y,
unsigned int width,
unsigned int height)
{
MacDrawable *macWin = (MacDrawable *) window;
display->request++;
if (Tk_IsTopLevel(macWin->winPtr) && !Tk_IsEmbedded(macWin->winPtr)) {
WindowRef w = TkMacOSXDrawableWindow(window);
if (w) {
Rect bounds;
bounds.left = x + macWin->winPtr->wmInfoPtr->xInParent;
bounds.right = bounds.left + width;
bounds.top = y + macWin->winPtr->wmInfoPtr->yInParent;
bounds.bottom = bounds.top + height;
ChkErr(SetWindowBounds, w, kWindowContentRgn, &bounds);
}
} else {
MoveResizeWindow(macWin);
}
}
void
XUnmapWindow(
Display *display, /* Display. */
Window window) /* Window. */
{
MacDrawable *macWin = (MacDrawable *) window;
XEvent event;
display->request++;
macWin->winPtr->flags &= ~TK_MAPPED;
if (Tk_IsTopLevel(macWin->winPtr)) {
if (!Tk_IsEmbedded(macWin->winPtr) &&
macWin->winPtr->wmInfoPtr->hints.initial_state!=IconicState) {
/*
* XXX This should be HideSheetWindow for kSheetWindowClass
* XXX windows that have a wmPtr->master parent set.
*/
WindowRef wref = TkMacOSXDrawableWindow(window);
if ((macWin->winPtr->wmInfoPtr->macClass == kSheetWindowClass)
&& (macWin->winPtr->wmInfoPtr->master != None)) {
HideSheetWindow(wref);
} else {
HideWindow(wref);
}
}
TkMacOSXInvalClipRgns((Tk_Window) macWin->winPtr);
/*
* 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.
*/
TkMacOSXInvalidateWindow(macWin, TK_PARENT_WINDOW);
TkMacOSXInvalClipRgns((Tk_Window) macWin->winPtr->parentPtr);
}
}
void
TkMacOSXBringWindowForward(
WindowRef wRef)
{
TkDisplay *dispPtr = TkGetDisplayList();
Tk_Window tkwin = Tk_IdToWindow(dispPtr->display,TkMacOSXGetXWindow(wRef));
Tk_Window grabWin = GetGrabWindowForWindow(tkwin);
if (grabWin && grabWin != tkwin) {
wRef = TkMacOSXDrawableWindow(((TkWindow*)grabWin)->window);
}
TkMacOSXSetEatButtonUp(true);
BringWindowForward(wRef, Tk_MacOSXIsAppInFront(), !grabWin);
}
static void
BringWindowForward(
WindowRef wRef,
int isFrontProcess,
int frontWindowOnly)
{
if (wRef && !TkpIsWindowFloating(wRef) && IsValidWindowPtr(wRef)) {
WindowRef frontWindow = FrontNonFloatingWindow();
WindowModality frontWindowModality = kWindowModalityNone;
if (frontWindow && frontWindow != wRef) {
ChkErr(GetWindowModality, frontWindow, &frontWindowModality, NULL);
}
if (frontWindowModality != kWindowModalityAppModal) {
Window window = TkMacOSXGetXWindow(wRef);
if (window != None) {
TkDisplay *dispPtr = TkGetDisplayList();
TkWindow * winPtr = (TkWindow *)Tk_IdToWindow(dispPtr->display,
window);
if (winPtr && winPtr->wmInfoPtr &&
winPtr->wmInfoPtr->master != None) {
TkWindow *masterWinPtr = (TkWindow *)Tk_IdToWindow(
dispPtr->display, winPtr->wmInfoPtr->master);
if (masterWinPtr && masterWinPtr->window != None &&
TkMacOSXHostToplevelExists(masterWinPtr)) {
WindowRef masterMacWin =
TkMacOSXDrawableWindow(masterWinPtr->window);
if (masterMacWin) {
BringToFront(masterMacWin);
}
}
}
}
SelectWindow(wRef);
} else {
frontWindowOnly = 0;
}
}
if (!isFrontProcess) {
ProcessSerialNumber ourPsn = {0, kCurrentProcess};
ChkErr(SetFrontProcessWithOptions, &ourPsn, frontWindowOnly ?
kSetFrontProcessFrontWindowOnly : 0);
}
}
void
XMoveWindow(
Display *display, /* Display. */
Window window, /* Window. */
int x, int y)
{
MacDrawable *macWin = (MacDrawable *) window;
display->request++;
if (Tk_IsTopLevel(macWin->winPtr) && !Tk_IsEmbedded(macWin->winPtr)) {
WindowRef w = TkMacOSXDrawableWindow(window);
if (w) {
ChkErr(MoveWindowStructure, w, x, y);
}
} else {
MoveResizeWindow(macWin);
}
}
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 actually 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;
WindowRef wRef = TkMacOSXDrawableWindow(w);
if (wRef) {
TkMacOSXInvalClipRgns((Tk_Window) winPtr->parentPtr);
TkMacOSXWinBounds(winPtr, &bounds);
InvalWindowRect(wRef, &bounds);
}
}
/* TkGenWMMoveRequestEvent(macWin->winPtr,
macWin->winPtr->changes.x, macWin->winPtr->changes.y); */
}
void
TkMacOSXInvalidateWindow(
MacDrawable *macWin, /* Make window that's causing damage. */
int flag) /* Should be TK_WINDOW_ONLY or
* TK_PARENT_WINDOW */
{
WindowRef windowRef;
HIShapeRef rgn;
windowRef = TkMacOSXDrawableWindow((Drawable)macWin);
if (macWin->flags & TK_CLIP_INVALID) {
TkMacOSXUpdateClipRgn(macWin->winPtr);
}
rgn = (flag == TK_WINDOW_ONLY) ? macWin->visRgn : macWin->aboveVisRgn;
if (!HIShapeIsEmpty(rgn)) {
TkMacOSXCheckTmpQdRgnEmpty();
ChkErr(HIShapeGetAsQDRgn, rgn, tkMacOSXtmpQdRgn);
InvalWindowRgn(windowRef, tkMacOSXtmpQdRgn);
SetEmptyRgn(tkMacOSXtmpQdRgn);
}
#ifdef TK_MAC_DEBUG_CLIP_REGIONS
TkMacOSXDebugFlashRegion((Drawable) macWin, rgn);
#endif /* TK_MAC_DEBUG_CLIP_REGIONS */
}
void
TkMacOSXUpdateClipRgn(
TkWindow *winPtr)
{
MacDrawable *macWin;
if (winPtr == NULL) {
return;
}
macWin = winPtr->privatePtr;
if (macWin && macWin->flags & TK_CLIP_INVALID) {
TkWindow *win2Ptr;
if (Tk_IsMapped(winPtr)) {
int rgnChanged = 0;
CGRect bounds;
HIMutableShapeRef rgn;
/*
* Start with a region defined by the window bounds.
*/
TkMacOSXWinCGBounds(winPtr, &bounds);
rgn = TkMacOSXHIShapeCreateMutableWithRect(&bounds);
/*
* Clip away the area of any windows that may obscure this window.
* For a non-toplevel window, first, clip to the parents visible
* clip region. Second, clip away any siblings that are higher in
* the stacking order. For an embedded toplevel, just clip to the
* container's visible clip region. Remember, we only allow one
* contained window in a frame, and don't support any other widgets
* in the frame either. This is not currently enforced, however.
*/
if (!Tk_IsTopLevel(winPtr)) {
TkMacOSXUpdateClipRgn(winPtr->parentPtr);
if (winPtr->parentPtr) {
ChkErr(HIShapeIntersect,
winPtr->parentPtr->privatePtr->aboveVisRgn,
rgn, rgn);
}
win2Ptr = winPtr;
while ((win2Ptr = win2Ptr->nextPtr)) {
if (Tk_IsTopLevel(win2Ptr) || !Tk_IsMapped(win2Ptr)) {
continue;
}
TkMacOSXWinCGBounds(win2Ptr, &bounds);
ChkErr(TkMacOSHIShapeDifferenceWithRect, rgn, &bounds);
}
} else if (Tk_IsEmbedded(winPtr)) {
win2Ptr = TkpGetOtherWindow(winPtr);
if (win2Ptr) {
TkMacOSXUpdateClipRgn(win2Ptr);
ChkErr(HIShapeIntersect,
win2Ptr->privatePtr->aboveVisRgn, rgn, rgn);
} else if (tkMacOSXEmbedHandler != NULL) {
HIShapeRef visRgn;
TkMacOSXCheckTmpQdRgnEmpty();
tkMacOSXEmbedHandler->getClipProc((Tk_Window) winPtr,
tkMacOSXtmpQdRgn);
visRgn = HIShapeCreateWithQDRgn(tkMacOSXtmpQdRgn);
SetEmptyRgn(tkMacOSXtmpQdRgn);
ChkErr(HIShapeIntersect, visRgn, rgn, rgn);
}
/*
* TODO: Here we should handle out of process embedding.
*/
} else if (winPtr->wmInfoPtr->attributes &
kWindowResizableAttribute) {
HIViewRef growBoxView;
OSErr err = HIViewFindByID(HIViewGetRoot(
TkMacOSXDrawableWindow(winPtr->window)),
kHIViewWindowGrowBoxID, &growBoxView);
if (err == noErr) {
ChkErr(HIViewGetFrame, growBoxView, &bounds);
bounds = CGRectOffset(bounds,
-winPtr->wmInfoPtr->xInParent,
-winPtr->wmInfoPtr->yInParent);
ChkErr(TkMacOSHIShapeDifferenceWithRect, rgn, &bounds);
}
}
macWin->aboveVisRgn = HIShapeCreateCopy(rgn);
/*
* The final clip region is the aboveVis region (or visible region)
* minus all the children of this window. If the window is a
* container, we must also subtract the region of the embedded
* window.
*/
win2Ptr = winPtr->childList;
while (win2Ptr) {
if (Tk_IsTopLevel(win2Ptr) || !Tk_IsMapped(win2Ptr)) {
win2Ptr = win2Ptr->nextPtr;
continue;
}
TkMacOSXWinCGBounds(win2Ptr, &bounds);
ChkErr(TkMacOSHIShapeDifferenceWithRect, rgn, &bounds);
rgnChanged = 1;
win2Ptr = win2Ptr->nextPtr;
}
if (Tk_IsContainer(winPtr)) {
win2Ptr = TkpGetOtherWindow(winPtr);
if (win2Ptr) {
if (Tk_IsMapped(win2Ptr)) {
TkMacOSXWinCGBounds(win2Ptr, &bounds);
ChkErr(TkMacOSHIShapeDifferenceWithRect, rgn, &bounds);
rgnChanged = 1;
}
}
/*
* TODO: Here we should handle out of process embedding.
*/
}
if (rgnChanged) {
HIShapeRef diffRgn = HIShapeCreateDifference(
macWin->aboveVisRgn, rgn);
if (!HIShapeIsEmpty(diffRgn)) {
macWin->visRgn = HIShapeCreateCopy(rgn);
}
CFRelease(diffRgn);
}
CFRelease(rgn);
} else {
/*
* An unmapped window has empty clip regions to prevent any
* (erroneous) drawing into it or its children from becoming
* visible. [Bug 940117]
*/
if (!Tk_IsTopLevel(winPtr)) {
TkMacOSXUpdateClipRgn(winPtr->parentPtr);
} else if (Tk_IsEmbedded(winPtr)) {
win2Ptr = TkpGetOtherWindow(winPtr);
if (win2Ptr) {
TkMacOSXUpdateClipRgn(win2Ptr);
}
}
macWin->aboveVisRgn = TkMacOSXHIShapeCreateEmpty();
}
if (!macWin->visRgn) {
macWin->visRgn = HIShapeCreateCopy(macWin->aboveVisRgn);
}
macWin->flags &= ~TK_CLIP_INVALID;
#ifdef TK_MAC_DEBUG_CLIP_REGIONS
TkMacOSXDebugFlashRegion((Drawable) macWin, macWin->visRgn);
#endif /* TK_MAC_DEBUG_CLIP_REGIONS */
}
}
void
XDestroyWindow(
Display *display, /* Display. */
Window window) /* Window. */
{
MacDrawable *macWin = (MacDrawable *) window;
WindowRef winRef;
/*
* 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)) {
TkMacOSXInvalidateWindow(macWin, TK_PARENT_WINDOW);
if (macWin->winPtr->parentPtr != NULL) {
TkMacOSXInvalClipRgns((Tk_Window) macWin->winPtr->parentPtr);
}
if (macWin->visRgn) {
CFRelease(macWin->visRgn);
}
if (macWin->aboveVisRgn) {
CFRelease(macWin->aboveVisRgn);
}
if (macWin->toplevel->referenceCount == 0) {
ckfree((char *) macWin->toplevel);
}
ckfree((char *) macWin);
return;
}
/*
* We are relying on the Activate Mac OS event to pass the focus away from
* a window that is getting Destroyed to the Front non-floating window. BUT
* we don't get activate events when a floating window is destroyed, since
* the front non-floating window doesn't in fact get activated... So maybe
* we can check here and if we are destroying a floating window, we can
* pass the focus back to the front non-floating window...
*/
if (macWin->grafPtr != NULL) {
TkWindow *focusPtr = TkGetFocusWin(macWin->winPtr);
if (focusPtr == NULL
|| (focusPtr->mainPtr->winPtr == macWin->winPtr)) {
winRef = TkMacOSXDrawableWindow(window);
if (TkpIsWindowFloating (winRef)) {
Window window = TkMacOSXGetXWindow(ActiveNonFloatingWindow());
if (window != None) {
TkMacOSXGenerateFocusEvent(window, 1);
}
}
}
}
if (macWin->visRgn) {
CFRelease(macWin->visRgn);
}
if (macWin->aboveVisRgn) {
CFRelease(macWin->aboveVisRgn);
}
/*
* 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)) {
WindowRef winRef = TkMacOSXDrawableWindow(window);
if (winRef) {
TkMacOSXWindowList *listPtr, *prevPtr;
WindowGroupRef group;
if (GetWindowProperty(winRef, 'Tk ', 'TsGp', sizeof(group), NULL,
&group) == noErr) {
TkDisplay *dispPtr = TkGetDisplayList();
ItemCount i = CountWindowGroupContents(group,
kWindowGroupContentsReturnWindows);
WindowRef macWin;
WindowGroupRef newGroup;
Window window;
while (i > 0) {
ChkErr(GetIndexedWindow, group, i--, 0, &macWin);
if (!macWin) {
continue;
}
window = TkMacOSXGetXWindow(macWin);
newGroup = NULL;
if (window != None) {
TkWindow *winPtr = (TkWindow *)
Tk_IdToWindow(dispPtr->display, window);
if (winPtr && winPtr->wmInfoPtr) {
newGroup = GetWindowGroupOfClass(
winPtr->wmInfoPtr->macClass);
}
}
if (!newGroup) {
newGroup =
GetWindowGroupOfClass(kDocumentWindowClass);
}
ChkErr(SetWindowGroup, macWin, newGroup);
}
ChkErr(SetWindowGroupOwner, group, NULL);
ChkErr(ReleaseWindowGroup, group);
}
TkMacOSXUnregisterMacWindow(winRef);
DisposeWindow(winRef);
for (listPtr=tkMacOSXWindowListPtr, prevPtr=NULL;
tkMacOSXWindowListPtr != NULL;
prevPtr=listPtr, listPtr=listPtr->nextPtr) {
if (listPtr->winPtr == macWin->winPtr) {
if (prevPtr == NULL) {
tkMacOSXWindowListPtr = listPtr->nextPtr;
} else {
prevPtr->nextPtr = listPtr->nextPtr;
}
ckfree((char *) listPtr);
break;
}
}
}
}
macWin->grafPtr = NULL;
/*
* Delay deletion of a toplevel data structure untill all children have
* been deleted.
*/
if (macWin->toplevel->referenceCount == 0) {
ckfree((char *) macWin->toplevel);
}
}
void
XMapWindow(
Display *display, /* Display. */
Window window) /* Window. */
{
MacDrawable *macWin = (MacDrawable *) window;
XEvent event;
/*
* 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 (!TkMacOSXHostToplevelExists(macWin->toplevel->winPtr)) {
TkMacOSXMakeRealWindowExist(macWin->toplevel->winPtr);
}
display->request++;
macWin->winPtr->flags |= TK_MAPPED;
if (Tk_IsTopLevel(macWin->winPtr)) {
if (!Tk_IsEmbedded(macWin->winPtr)) {
/*
* XXX This should be ShowSheetWindow for kSheetWindowClass
* XXX windows that have a wmPtr->master parent set.
*/
WindowRef wRef = TkMacOSXDrawableWindow(window);
if ((macWin->winPtr->wmInfoPtr->macClass == kSheetWindowClass)
&& (macWin->winPtr->wmInfoPtr->master != None)) {
ShowSheetWindow(wRef, TkMacOSXDrawableWindow(
macWin->winPtr->wmInfoPtr->master));
} else {
ShowWindow(wRef);
}
}
TkMacOSXInvalClipRgns((Tk_Window) macWin->winPtr);
/*
* 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 {
/*
* Generate damage for that area of the window.
*/
TkMacOSXInvalClipRgns((Tk_Window) macWin->winPtr->parentPtr);
TkMacOSXInvalidateWindow(macWin, TK_PARENT_WINDOW);
}
/*
* Generate VisibilityNotify events for window and all mapped children.
*/
event.xany.send_event = False;
event.xany.display = display;
event.xvisibility.type = VisibilityNotify;
event.xvisibility.state = VisibilityUnobscured;
NotifyVisibility(macWin->winPtr, &event);
}
MODULE_SCOPE int
TkMacOSXProcessMouseEvent(TkMacOSXEvent *eventPtr, MacEventStatus * statusPtr)
{
Tk_Window tkwin;
Point where, where2;
int result;
TkDisplay * dispPtr;
OSStatus err;
MouseEventData mouseEventData, * medPtr = &mouseEventData;
int isFrontProcess;
switch (eventPtr->eKind) {
case kEventMouseDown:
case kEventMouseUp:
case kEventMouseMoved:
case kEventMouseDragged:
case kEventMouseWheelMoved:
break;
default:
return false;
break;
}
err = ChkErr(GetEventParameter, eventPtr->eventRef,
kEventParamMouseLocation,
typeQDPoint, NULL,
sizeof(where), NULL,
&where);
if (err != noErr) {
GetGlobalMouse(&where);
}
err = ChkErr(GetEventParameter, eventPtr->eventRef,
kEventParamWindowRef,
typeWindowRef, NULL,
sizeof(WindowRef), NULL,
&medPtr->whichWin);
if (err == noErr) {
err = ChkErr(GetEventParameter, eventPtr->eventRef,
kEventParamWindowPartCode,
typeWindowPartCode, NULL,
sizeof(WindowPartCode), NULL,
&medPtr->windowPart);
}
if (err != noErr) {
medPtr->windowPart = FindWindow(where, &medPtr->whichWin);
}
medPtr->window = TkMacOSXGetXWindow(medPtr->whichWin);
if (medPtr->whichWin != NULL && medPtr->window == None) {
return false;
}
if (eventPtr->eKind == kEventMouseDown) {
if (IsWindowActive(medPtr->whichWin) && IsWindowPathSelectEvent(
medPtr->whichWin, eventPtr->eventRef)) {
ChkErr(WindowPathSelect, medPtr->whichWin, NULL, NULL);
return false;
}
if (medPtr->windowPart == inProxyIcon) {
TkMacOSXTrackingLoop(1);
err = ChkErr(TrackWindowProxyDrag, medPtr->whichWin, where);
TkMacOSXTrackingLoop(0);
if (err == errUserWantsToDragWindow) {
medPtr->windowPart = inDrag;
} else {
return false;
}
}
}
isFrontProcess = Tk_MacOSXIsAppInFront();
if (isFrontProcess) {
medPtr->state = ButtonModifiers2State(GetCurrentEventButtonState(),
GetCurrentEventKeyModifiers());
} else {
medPtr->state = ButtonModifiers2State(GetCurrentButtonState(),
GetCurrentKeyModifiers());
}
medPtr->global = where;
err = ChkErr(GetEventParameter, eventPtr->eventRef,
kEventParamWindowMouseLocation,
typeQDPoint, NULL,
sizeof(Point), NULL,
&medPtr->local);
if (err == noErr) {
if (medPtr->whichWin) {
Rect widths;
GetWindowStructureWidths(medPtr->whichWin, &widths);
medPtr->local.h -= widths.left;
medPtr->local.v -= widths.top;
}
} else {
medPtr->local = where;
if (medPtr->whichWin) {
QDGlobalToLocalPoint(GetWindowPort(medPtr->whichWin),
&medPtr->local);
}
}
medPtr->activeNonFloating = ActiveNonFloatingWindow();
dispPtr = TkGetDisplayList();
tkwin = Tk_IdToWindow(dispPtr->display, medPtr->window);
if (eventPtr->eKind != kEventMouseDown) {
int res = false;
switch (eventPtr->eKind) {
case kEventMouseUp:
/*
* The window manager only needs to know about mouse down
* events and sometimes we need to "eat" the mouse up.
* Otherwise, we just pass the event to Tk.
*/
if (TkMacOSXGetEatButtonUp()) {
TkMacOSXSetEatButtonUp(false);
} else {
res = GenerateButtonEvent(medPtr);
}
break;
case kEventMouseWheelMoved:
err = ChkErr(GetEventParameter, eventPtr->eventRef,
kEventParamMouseWheelDelta, typeLongInteger, NULL,
sizeof(long), NULL, &medPtr->delta);
if (err != noErr ) {
statusPtr->err = 1;
} else {
EventMouseWheelAxis axis;
err = ChkErr(GetEventParameter, eventPtr->eventRef,
kEventParamMouseWheelAxis, typeMouseWheelAxis,
NULL, sizeof(EventMouseWheelAxis), NULL, &axis);
if (err == noErr && axis == kEventMouseWheelAxisX) {
medPtr->state |= ShiftMask;
}
res = GenerateMouseWheelEvent(medPtr);
}
break;
case kEventMouseMoved:
case kEventMouseDragged:
res = GeneratePollingEvents(medPtr);
break;
default:
Tcl_Panic("Unknown mouse event !");
}
if (res) {
statusPtr->stopProcessing = 1;
}
return res;
}
TkMacOSXSetEatButtonUp(false);
if (medPtr->whichWin) {
/*
* We got a mouse down in a window
* See if this is the activate click
* This click moves the window forward. We don't want
* the corresponding mouse-up to be reported to the application
* or else it will mess up some Tk scripts.
*/
if (!(TkpIsWindowFloating(medPtr->whichWin))
&& (medPtr->whichWin != medPtr->activeNonFloating
|| !isFrontProcess)) {
int frontWindowOnly = 1;
int cmdDragGrow = ((medPtr->windowPart == inDrag ||
medPtr->windowPart == inGrow) && medPtr->state & Mod1Mask);
if (!cmdDragGrow) {
Tk_Window grabWin = GetGrabWindowForWindow(tkwin);
frontWindowOnly = !grabWin;
if (grabWin && grabWin != tkwin) {
TkMacOSXSetEatButtonUp(true);
BringWindowForward(TkMacOSXDrawableWindow(
((TkWindow*)grabWin)->window), isFrontProcess,
frontWindowOnly);
return false;
}
}
/*
* Clicks in the titlebar widgets are handled without bringing the
* window forward.
*/
if ((result = HandleWindowTitlebarMouseDown(medPtr, tkwin)) != -1) {
statusPtr->stopProcessing = 1;
return result;
} else {
/*
* Only windows with the kWindowNoActivatesAttribute can
* receive mouse events in the background.
*/
if (!(((TkWindow *)tkwin)->wmInfoPtr->attributes &
kWindowNoActivatesAttribute)) {
/*
* Allow background window dragging & growing with Command
* down.
*/
if (!cmdDragGrow) {
TkMacOSXSetEatButtonUp(true);
BringWindowForward(medPtr->whichWin, isFrontProcess,
frontWindowOnly);
}
/*
* Allow dragging & growing of windows that were/are in the
* background.
*/
if (!(medPtr->windowPart == inDrag ||
medPtr->windowPart == inGrow)) {
return false;
}
}
}
} else {
if ((result = HandleWindowTitlebarMouseDown(medPtr, tkwin)) != -1) {
statusPtr->stopProcessing = 1;
return result;
}
}
switch (medPtr->windowPart) {
case inDrag: {
WindowAttributes attributes;
GetWindowAttributes(medPtr->whichWin, &attributes);
if (!(attributes & kWindowAsyncDragAttribute)) {
TkMacOSXTrackingLoop(1);
DragWindow(medPtr->whichWin, where, NULL);
TkMacOSXTrackingLoop(0);
where2.h = where2.v = 0;
QDLocalToGlobalPoint(GetWindowPort(medPtr->whichWin),
&where2);
if (EqualPt(where, where2)) {
return false;
}
return true;
}
break;
}
case inGrow:
/*
* Generally the content region is the domain of Tk
* sub-windows. However, one exception is the grow
* region. A button down in this area will be handled
* by the window manager. Note: this means that Tk
* may not get button down events in this area!
*/
if (TkMacOSXGrowToplevel(medPtr->whichWin, where) == true) {
statusPtr->stopProcessing = 1;
return true;
} else {
return GenerateButtonEvent(medPtr);
}
break;
case inContent:
return GenerateButtonEvent(medPtr);
break;
default:
return false;
break;
}
}
return false;
}
void
TkpDisplayScale(
ClientData clientData) /* Widget record for scale. */
{
TkScale *scalePtr = (TkScale *) clientData;
Tk_Window tkwin = scalePtr->tkwin;
Tcl_Interp *interp = scalePtr->interp;
int result;
char string[TCL_DOUBLE_SPACE];
MacScale *macScalePtr = (MacScale *) clientData;
Rect r;
WindowRef windowRef;
CGrafPtr destPort, savePort;
Boolean portChanged;
MacDrawable *macDraw;
SInt32 initialValue, minValue, maxValue;
UInt16 numTicks;
#ifdef TK_MAC_DEBUG_SCALE
TkMacOSXDbgMsg("TkpDisplayScale");
#endif
scalePtr->flags &= ~REDRAW_PENDING;
if ((scalePtr->tkwin == NULL) || !Tk_IsMapped(scalePtr->tkwin)) {
goto done;
}
/*
* Invoke the scale's command if needed.
*/
Tcl_Preserve((ClientData) scalePtr);
if ((scalePtr->flags & INVOKE_COMMAND) && (scalePtr->command != NULL)) {
Tcl_Preserve((ClientData) interp);
sprintf(string, scalePtr->format, scalePtr->value);
result = Tcl_VarEval(interp, scalePtr->command, " ", string, NULL);
if (result != TCL_OK) {
Tcl_AddErrorInfo(interp, "\n (command executed by scale)");
Tcl_BackgroundError(interp);
}
Tcl_Release((ClientData) interp);
}
scalePtr->flags &= ~INVOKE_COMMAND;
if (scalePtr->flags & SCALE_DELETED) {
Tcl_Release((ClientData) scalePtr);
return;
}
Tcl_Release((ClientData) scalePtr);
/*
* Now handle the part of redisplay that is the same for
* horizontal and vertical scales: border and traversal
* highlight.
*/
if (scalePtr->highlightWidth != 0) {
GC gc = Tk_GCForColor(scalePtr->highlightColorPtr, Tk_WindowId(tkwin));
Tk_DrawFocusHighlight(tkwin, gc, scalePtr->highlightWidth,
Tk_WindowId(tkwin));
}
Tk_Draw3DRectangle(tkwin, Tk_WindowId(tkwin), scalePtr->bgBorder,
scalePtr->highlightWidth, scalePtr->highlightWidth,
Tk_Width(tkwin) - 2*scalePtr->highlightWidth,
Tk_Height(tkwin) - 2*scalePtr->highlightWidth,
scalePtr->borderWidth, scalePtr->relief);
/*
* Set up port for drawing Macintosh control.
*/
macDraw = (MacDrawable *) Tk_WindowId(tkwin);
destPort = TkMacOSXGetDrawablePort(Tk_WindowId(tkwin));
windowRef = TkMacOSXDrawableWindow(Tk_WindowId(tkwin));
portChanged = QDSwapPort(destPort, &savePort);
TkMacOSXSetUpClippingRgn(Tk_WindowId(tkwin));
/*
* Create Macintosh control.
*/
#define MAC_OSX_SCROLL_WIDTH 10
if (scalePtr->orient == ORIENT_HORIZONTAL) {
int offset = (Tk_Height(tkwin) - MAC_OSX_SCROLL_WIDTH)/2;
if (offset < 0) {
offset = 0;
}
r.left = macDraw->xOff + scalePtr->inset;
r.top = macDraw->yOff + offset;
r.right = macDraw->xOff+Tk_Width(tkwin) - scalePtr->inset;
r.bottom = macDraw->yOff + offset + MAC_OSX_SCROLL_WIDTH/2;
} else {
int offset = (Tk_Width(tkwin) - MAC_OSX_SCROLL_WIDTH)/2;
if (offset < 0) {
offset = 0;
}
r.left = macDraw->xOff + offset;
r.top = macDraw->yOff + scalePtr->inset;
r.right = macDraw->xOff + offset + MAC_OSX_SCROLL_WIDTH/2;
r.bottom = macDraw->yOff+Tk_Height(tkwin) - scalePtr->inset;
}
if (macScalePtr->scaleHandle == NULL) {
#ifdef TK_MAC_DEBUG_SCALE
TkMacOSXDbgMsg("Initialising scale");
#endif
initialValue = scalePtr->value;
if (scalePtr->orient == ORIENT_HORIZONTAL) {
minValue = scalePtr->fromValue;
maxValue = scalePtr->toValue;
} else {
minValue = scalePtr->fromValue;
maxValue = scalePtr->toValue;
}
if (scalePtr->tickInterval == 0) {
numTicks = 0;
} else {
numTicks = (maxValue - minValue)/scalePtr->tickInterval;
}
CreateSliderControl(windowRef, &r, initialValue, minValue, maxValue,
kControlSliderPointsDownOrRight, numTicks, 1, scaleActionProc,
&(macScalePtr->scaleHandle));
SetControlReference(macScalePtr->scaleHandle, (UInt32) scalePtr);
if (IsWindowActive(windowRef)) {
macScalePtr->flags |= ACTIVE;
}
} else {
SetControlBounds(macScalePtr->scaleHandle, &r);
SetControl32BitValue(macScalePtr->scaleHandle, scalePtr->value);
SetControl32BitMinimum(macScalePtr->scaleHandle, scalePtr->fromValue);
SetControl32BitMaximum(macScalePtr->scaleHandle, scalePtr->toValue);
}
/*
* Finally draw the control.
*/
SetControlVisibility(macScalePtr->scaleHandle,true,true);
HiliteControl(macScalePtr->scaleHandle,0);
Draw1Control(macScalePtr->scaleHandle);
if (portChanged) {
QDSwapPort(savePort, NULL);
}
done:
scalePtr->flags &= ~REDRAW_ALL;
}
void
TkpDisplayScrollbar(
ClientData clientData) /* Information about window. */
{
TkScrollbar *scrollPtr = (TkScrollbar *) clientData;
MacScrollbar *macScrollPtr = (MacScrollbar *) clientData;
Tk_Window tkwin = scrollPtr->tkwin;
CGrafPtr destPort, savePort;
Boolean portChanged;
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);
if (macScrollPtr->sbHandle == NULL) {
Rect r = {0, 0, 1, 1};
windowRef = TkMacOSXDrawableWindow(Tk_WindowId(tkwin));
CreateScrollBarControl(windowRef, &r, 0, 0, 0, 0, true, NULL,
&(macScrollPtr->sbHandle));
SetControlReference(macScrollPtr->sbHandle, (SInt32) scrollPtr);
if (IsWindowActive(windowRef)) {
macScrollPtr->macFlags |= ACTIVE;
}
}
/*
* Update the control values before we draw.
*/
UpdateControlValues(macScrollPtr);
/*
* Set up port for drawing Macintosh control.
*/
destPort = TkMacOSXGetDrawablePort(Tk_WindowId(tkwin));
portChanged = QDSwapPort(destPort, &savePort);
TkMacOSXSetUpClippingRgn(Tk_WindowId(tkwin));
/*
* Scrollbars do not erase the complete control bounds if they are wider
* than the standard width, so manually erase the extra space.
*/
if (!EmptyRect(&macScrollPtr->eraseRect)) {
EraseRect(&macScrollPtr->eraseRect);
}
Draw1Control(macScrollPtr->sbHandle);
if (portChanged) {
QDSwapPort(savePort, NULL);
}
done:
scrollPtr->flags &= ~REDRAW_PENDING;
}
static int
TkMacOSXInitControl(
MacButton *mbPtr, /* Mac button. */
GWorldPtr destPort,
GC gc,
Pixmap pixmap,
Rect *paneRect,
Rect *cntrRect)
{
TkButton *butPtr = (TkButton *) mbPtr;
ControlRef rootControl;
SInt16 procID, initialValue, minValue, maxValue;
Boolean initiallyVisible;
SInt32 controlReference;
rootControl = TkMacOSXGetRootControl(Tk_WindowId(butPtr->tkwin));
mbPtr->windowRef = TkMacOSXDrawableWindow(Tk_WindowId(butPtr->tkwin));
/*
* Set up the user pane.
*/
initiallyVisible = false;
initialValue = kControlSupportsEmbedding|kControlHasSpecialBackground;
minValue = 0;
maxValue = 1;
procID = kControlUserPaneProc;
controlReference = (SInt32)mbPtr;
mbPtr->userPane = NewControl(mbPtr->windowRef, paneRect, "\p",
initiallyVisible, initialValue, minValue, maxValue, procID,
controlReference);
if (!mbPtr->userPane) {
TkMacOSXDbgMsg("Failed to create user pane control");
return 1;
}
if (ChkErr(EmbedControl, mbPtr->userPane,rootControl) != noErr) {
return 1;
}
SetUserPaneSetUpSpecialBackgroundProc(mbPtr->userPane,
UserPaneBackgroundProc);
SetUserPaneDrawProc(mbPtr->userPane,UserPaneDraw);
initiallyVisible = false;
TkMacOSXComputeControlParams(butPtr,&mbPtr->params);
mbPtr->control = NewControl(mbPtr->windowRef, cntrRect, "\p",
initiallyVisible, mbPtr->params.initialValue,
mbPtr->params.minValue, mbPtr->params.maxValue,
mbPtr->params.procID, controlReference);
if (!mbPtr->control) {
TkMacOSXDbgMsg("Failed to create control of type %d\n", procID);
return 1;
}
if (ChkErr(EmbedControl, mbPtr->control,mbPtr->userPane) != noErr ) {
return 1;
}
mbPtr->flags |= (CONTROL_INITIALIZED | FIRST_DRAW);
if (IsWindowActive(mbPtr->windowRef)) {
mbPtr->flags |= ACTIVE;
}
return 0;
}
