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
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);
}
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);
}
}
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;
}
local.y = [win frame].size.height - local.y;
global.y = tkMacOSXZeroScreenHeight - global.y;
} else { /* local will be in screen coordinates. */
if (_windowWithMouse ) {
win = _windowWithMouse;
global = local;
local = [nswindow convertPointFromScreen: local];
local.y = [win frame].size.height - local.y;
global.y = tkMacOSXZeroScreenHeight - global.y;
} else { /* We have no window. Use the screen???*/
local.y = tkMacOSXZeroScreenHeight - local.y;
global = local;
}
}
Window window = TkMacOSXGetXWindow(win);
Tk_Window tkwin = window ? Tk_IdToWindow(TkGetDisplayList()->display,
window) : NULL;
if (!tkwin) {
tkwin = TkMacOSXGetCapture();
}
if (!tkwin) {
return theEvent; /* Give up. No window for this event. */
}
TkWindow *winPtr = (TkWindow *) tkwin;
local.x -= winPtr->wmInfoPtr->xInParent;
local.y -= winPtr->wmInfoPtr->yInParent;
int win_x, win_y;
tkwin = Tk_TopCoordsToWindow(tkwin, local.x, local.y,
void
TkMacOSXHandleMenuSelect(
long mResult,
int optionKeyPressed)
{
short theItem = LoWord(mResult);
short theMenu = HiWord(mResult);
Tk_Window tkwin;
Window window;
TkDisplay *dispPtr;
if (mResult == 0) {
TkMacOSXHandleTearoffMenu();
TkMacOSXClearMenubarActive();
return;
}
switch (theMenu) {
case kAppleMenu:
switch (theItem) {
case kAppleAboutItem:
{
Tcl_CmdInfo dummy;
if (optionKeyPressed || gInterp == NULL ||
Tcl_GetCommandInfo(gInterp,
"tkAboutDialog", &dummy) == 0) {
TkAboutDlg();
} else {
Tcl_Eval(gInterp, "tkAboutDialog");
}
break;
}
}
break;
case kFileMenu:
switch (theItem) {
case kSourceItem:
/* TODO: source script */
SourceDialog();
break;
case kCloseItem:
/* Send close event */
window = TkMacOSXGetXWindow(FrontNonFloatingWindow());
dispPtr = TkGetDisplayList();
tkwin = Tk_IdToWindow(dispPtr->display, window);
TkGenWMDestroyEvent(tkwin);
break;
case kQuitItem:
/* Exit */
if (optionKeyPressed || gInterp == NULL) {
Tcl_Exit(0);
} else {
Tcl_Eval(gInterp, "exit");
}
break;
}
break;
case kEditMenu:
/*
* This implementation just send keysyms
* the Tk thinks are associated with function keys that
* do Cut, Copy & Paste on a Sun keyboard.
*/
GenerateEditEvent(theItem);
break;
default:
TkMacOSXDispatchMenuEvent(theMenu, theItem);
TkMacOSXClearMenubarActive();
break;
}
/*
* Finally we unhighlight the menu.
*/
HiliteMenu(0);
}
local.y = [eventWindow frame].size.height - local.y;
global.y = tkMacOSXZeroScreenHeight - global.y;
} else { /* local will be in screen coordinates. */
if (_windowWithMouse ) {
eventWindow = _windowWithMouse;
global = local;
local = [eventWindow convertPointFromScreen: local];
local.y = [eventWindow frame].size.height - local.y;
global.y = tkMacOSXZeroScreenHeight - global.y;
} else { /* We have no window. Use the screen???*/
local.y = tkMacOSXZeroScreenHeight - local.y;
global = local;
}
}
Window window = TkMacOSXGetXWindow(eventWindow);
Tk_Window tkwin = window ? Tk_IdToWindow(TkGetDisplayList()->display,
window) : NULL;
if (!tkwin) {
tkwin = TkMacOSXGetCapture();
}
if (!tkwin) {
return theEvent; /* Give up. No window for this event. */
}
TkWindow *winPtr = (TkWindow *) tkwin;
local.x -= winPtr->wmInfoPtr->xInParent;
local.y -= winPtr->wmInfoPtr->yInParent;
int win_x, win_y;
tkwin = Tk_TopCoordsToWindow(tkwin, local.x, local.y,
void
TkMacOSXHandleMenuSelect(
MenuID theMenu,
MenuItemIndex theItem,
int optionKeyPressed)
{
Tk_Window tkwin;
Window window;
TkDisplay *dispPtr;
Tcl_CmdInfo dummy;
int code;
if (theItem == 0) {
TkMacOSXClearMenubarActive();
return;
}
switch (theMenu) {
case kAppleMenu:
switch (theItem) {
case kAppleAboutItem:
if (optionKeyPressed || gInterp == NULL ||
Tcl_GetCommandInfo(gInterp, "tkAboutDialog", &dummy) == 0) {
TkAboutDlg();
} else {
code = Tcl_EvalEx(gInterp, "tkAboutDialog", -1,
TCL_EVAL_GLOBAL);
if (code != TCL_OK) {
Tcl_BackgroundException(gInterp, code);
}
Tcl_ResetResult(gInterp);
}
break;
}
break;
case kFileMenu:
switch (theItem) {
case kSourceItem:
if (gInterp) {
if (Tcl_EvalEx(gInterp, "tk_getOpenFile -filetypes {"
"{{TCL Scripts} {.tcl} TEXT} {{Text Files} {} TEXT}}",
-1, TCL_EVAL_GLOBAL) == TCL_OK) {
Tcl_Obj *path = Tcl_GetObjResult(gInterp);
int len;
Tcl_GetStringFromObj(path, &len);
if (len) {
Tcl_IncrRefCount(path);
code = Tcl_FSEvalFile(gInterp, path);
if (code != TCL_OK) {
Tcl_BackgroundException(gInterp, code);
}
Tcl_DecrRefCount(path);
}
}
Tcl_ResetResult(gInterp);
}
break;
case kDemoItem:
if (gInterp) {
Tcl_Obj *path = GetWidgetDemoPath(gInterp);
if (path) {
Tcl_IncrRefCount(path);
code = Tcl_FSEvalFile(gInterp, path);
if (code != TCL_OK) {
Tcl_BackgroundException(gInterp, code);
}
Tcl_DecrRefCount(path);
Tcl_ResetResult(gInterp);
}
}
break;
case kCloseItem:
/* Send close event */
window = TkMacOSXGetXWindow(ActiveNonFloatingWindow());
dispPtr = TkGetDisplayList();
tkwin = Tk_IdToWindow(dispPtr->display, window);
TkGenWMDestroyEvent(tkwin);
break;
}
break;
case kEditMenu:
/*
* This implementation just send the keysyms Tk thinks are associated
* with function keys that do Cut, Copy & Paste on a Sun keyboard.
*/
GenerateEditEvent(theItem);
break;
default:
TkMacOSXDispatchMenuEvent(theMenu, theItem);
break;
}
/*
* Finally we unhighlight the menu.
*/
HiliteMenu(0);
}
