OSStatus AUCarbonViewBase::EmbedControl(ControlRef ctl) { Rect r; ::GetControlBounds(ctl, &r); if (r.right > mBottomRight.h) mBottomRight.h = r.right; if (r.bottom > mBottomRight.v) mBottomRight.v = r.bottom; WindowAttributes attributes; verify_noerr(GetWindowAttributes(mCarbonWindow, &attributes)); if (attributes & kWindowCompositingAttribute) return ::HIViewAddSubview(mCarbonPane, ctl); else return ::EmbedControl(ctl, mCarbonPane); }
static OSStatus UpdateTextControlView (HIViewRef control) { OSStatus err; WindowAttributes attr; err = GetWindowAttributes(GetControlOwner(control), &attr); if (err == noErr) { if (attr & kWindowCompositingAttribute) err = HIViewSetNeedsDisplay(control, true); else Draw1Control(control); } return (err); }
SInt32 myWindowDraw(WindowRef window,SInt32 param) { /*------------------------------------------------------ Use this method to draw the window based on the value of param. wNoHit: draw the frame and attributes wInGoAway: hilite or unhilite GoAway box wInZoomIn: hilite or unhilite ZoomIn Box wInZoomOut: hilite or unhilite ZoomOut Box wInCollapseBox: hilite or unhilite Collapse Box --------------------------------------------------------*/ static Boolean hilite=FALSE; WindowAttributes attributes; if(IsWindowVisible(window)) { switch(param){ case wNoHit: hilite=FALSE;//redrawn so no box hiliteing drawWindowFrame(window); GetWindowAttributes(window,&attributes); if(attributes & kWindowCloseBoxAttribute)//is there a close box? drawWindowCloseBox(window,hilite); if(attributes & kWindowFullZoomAttribute)//is there a zoom box? drawWindowZoomBox(window,hilite); if(attributes & kWindowCollapseBoxAttribute)//is there a collapse box? drawWindowCollapseBox(window,hilite); break; case wInGoAway: hilite=drawWindowCloseBox(window,!hilite); break; case wInZoomIn: case wInZoomOut: hilite=drawWindowZoomBox(window,!hilite); break; case wInCollapseBox: hilite=drawWindowCollapseBox(window,!hilite); break; } } return 0; }
OSStatus AUCarbonViewBase::CreateCarbonView(AudioUnit inAudioUnit, WindowRef inWindow, ControlRef inParentControl, const Float32Point &inLocation, const Float32Point &inSize, ControlRef &outParentControl) { #if !__LP64__ mEditAudioUnit = inAudioUnit; mCarbonWindow = inWindow; WindowAttributes attributes; verify_noerr(GetWindowAttributes(mCarbonWindow, &attributes)); mCompositWindow = (attributes & kWindowCompositingAttribute) != 0; Rect area; area.left = short(inLocation.x); area.top = short(inLocation.y); area.right = short(area.left + inSize.x); area.bottom = short(area.top + inSize.y); OSStatus err = ::CreateUserPaneControl(inWindow, &area, kControlSupportsEmbedding, &mCarbonPane); // subclass can resize mCarbonPane to taste verify_noerr(err); if (err) return err; outParentControl = mCarbonPane; // register for mouse-down in our pane -- we want to clear focus EventTypeSpec paneEvents[] = { { kEventClassControl, kEventControlClick } }; WantEventTypes(GetControlEventTarget(mCarbonPane), GetEventTypeCount(paneEvents), paneEvents); if (IsCompositWindow()) { verify_noerr(::HIViewAddSubview(inParentControl, mCarbonPane)); mXOffset = 0; mYOffset = 0; } else { verify_noerr(::EmbedControl(mCarbonPane, inParentControl)); mXOffset = inLocation.x; mYOffset = inLocation.y; } mBottomRight.h = mBottomRight.v = 0; SizeControl(mCarbonPane, 0, 0); if (err = CreateUI(mXOffset, mYOffset)) return err; // we should only resize the control if a subclass has embedded // controls in this AND this is done with the EmbedControl call below // if mBottomRight is STILL equal to zero, then that wasn't done // so don't size the control Rect paneBounds; GetControlBounds(mCarbonPane, &paneBounds); // only resize mCarbonPane if it has not already been resized during CreateUI if ((paneBounds.top == paneBounds.bottom) && (paneBounds.left == paneBounds.right)) { if (mBottomRight.h != 0 && mBottomRight.v != 0) SizeControl(mCarbonPane, (short) (mBottomRight.h - mXOffset), (short) (mBottomRight.v - mYOffset)); } if (IsCompositWindow()) { // prepare for handling scroll-events EventTypeSpec scrollEvents[] = { { kEventClassScrollable, kEventScrollableGetInfo }, { kEventClassScrollable, kEventScrollableScrollTo } }; WantEventTypes(GetControlEventTarget(mCarbonPane), GetEventTypeCount(scrollEvents), scrollEvents); mCurrentScrollPoint.x = mCurrentScrollPoint.y = 0.0f; } return err; #else return noErr; #endif }
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; }
IGraphicsCarbon::IGraphicsCarbon(IGraphicsMac* pGraphicsMac, WindowRef pWindow, ControlRef pParentControl, short leftOffset, short topOffset) : mGraphicsMac(pGraphicsMac) , mWindow(pWindow) , mView(0) , mTimer(0) , mControlHandler(0) , mWindowHandler(0) , mCGC(0) , mTextEntryView(0) , mTextEntryHandler(0) , mEdControl(0) , mEdParam(0) , mPrevX(0) , mPrevY(0) //, mRgn(NewRgn()) , mLeftOffset(leftOffset) , mTopOffset(topOffset) { TRACE; Rect r; // Client. r.left = r.top = 0; r.right = pGraphicsMac->Width(); r.bottom = pGraphicsMac->Height(); WindowAttributes winAttrs = 0; GetWindowAttributes(pWindow, &winAttrs); mIsComposited = (winAttrs & kWindowCompositingAttribute); UInt32 features = kControlSupportsFocus | kControlHandlesTracking | kControlSupportsEmbedding; if (mIsComposited) { features |= kHIViewIsOpaque | kHIViewFeatureDoesNotUseSpecialParts; } CreateUserPaneControl(pWindow, &r, features, &mView); const EventTypeSpec controlEvents[] = { { kEventClassControl, kEventControlDraw }, }; InstallControlEventHandler(mView, MainEventHandler, GetEventTypeCount(controlEvents), controlEvents, this, &mControlHandler); const EventTypeSpec windowEvents[] = { { kEventClassMouse, kEventMouseDown }, { kEventClassMouse, kEventMouseUp }, { kEventClassMouse, kEventMouseMoved }, { kEventClassMouse, kEventMouseDragged }, { kEventClassMouse, kEventMouseWheelMoved }, { kEventClassKeyboard, kEventRawKeyDown }, { kEventClassWindow, kEventWindowDeactivated } }; InstallWindowEventHandler(mWindow, MainEventHandler, GetEventTypeCount(windowEvents), windowEvents, this, &mWindowHandler); double t = kEventDurationSecond / (double) pGraphicsMac->FPS(); OSStatus s = InstallEventLoopTimer(GetMainEventLoop(), 0., t, TimerHandler, this, &mTimer); if (mIsComposited) { if (!pParentControl) { HIViewRef hvRoot = HIViewGetRoot(pWindow); s = HIViewFindByID(hvRoot, kHIViewWindowContentID, &pParentControl); } s = HIViewAddSubview(pParentControl, mView); } else { if (!pParentControl) { if (GetRootControl(pWindow, &pParentControl) != noErr) { CreateRootControl(pWindow, &pParentControl); } } s = EmbedControl(mView, pParentControl); } if (s == noErr) { SizeControl(mView, r.right, r.bottom); // offset? } }
OSStatus MakeWindowTransparent(WindowRef aWindowRef) { OSStatus status = paramErr; require(aWindowRef != NULL, paramErr); // is the window compositing or not? WindowAttributes attributes; status = GetWindowAttributes(aWindowRef, &attributes); require_noerr(status, GetWindowAttributes); /* if (attributes & kWindowCompositingAttribute) { // it is compositing so we intercept the kEventWindowGetRegion event to be able to specify an empty opaque region EventTypeSpec wCompositingEvents = { kEventClassWindow, kEventWindowGetRegion }; status = InstallWindowEventHandler(aWindowRef, TransparentWindowHandler, 1, &wCompositingEvents, aWindowRef, NULL); require_noerr(status, InstallWindowEventHandler); HIViewRef contentView; status = HIViewFindByID(HIViewGetRoot(aWindowRef), kHIViewWindowContentID, &contentView); require_noerr(status, HIViewFindByID); // and we intercept the kEventControlDraw event of our content view so that we can make it transparent EventTypeSpec cCompositingEvents = { kEventClassControl, kEventControlDraw }; status = InstallControlEventHandler(contentView, TransparentWindowHandler, 1, &cCompositingEvents, contentView, NULL); require_noerr(status, InstallControlEventHandler); } else*/ { // it is non-compositing so we intercept the kEventWindowGetRegion event to be able to specify an empty opaque region // and we intercept the kEventWindowDrawContent event of our window so that we can make it transparent EventTypeSpec wNonCompositingEvents[] = { { kEventClassWindow, kEventWindowGetRegion }, { kEventClassWindow, kEventWindowDrawContent } }; status = InstallWindowEventHandler(aWindowRef, TransparentWindowHandler, GetEventTypeCount(wNonCompositingEvents), wNonCompositingEvents, aWindowRef, NULL); require_noerr(status, InstallWindowEventHandler); } // telling the HIToolbox that our window is not opaque so that we will be asked for the opaque region UInt32 features; status = GetWindowFeatures(aWindowRef, &features); require_noerr(status, GetWindowFeatures); if ( ( features & kWindowIsOpaque ) != 0 ) { status = HIWindowChangeFeatures(aWindowRef, 0, kWindowIsOpaque); require_noerr(status, HIWindowChangeFeatures); } // force opaque shape to be recalculated status = ReshapeCustomWindow(aWindowRef); require_noerr(status, ReshapeCustomWindow); // ensure that HIToolbox doesn't use standard shadow style, which defeats custom opaque shape status = SetWindowAlpha(aWindowRef, 0.999); require_noerr(status, SetWindowAlpha); SetWindowAlpha: ReshapeCustomWindow: HIWindowChangeFeatures: GetWindowFeatures: InstallControlEventHandler: HIViewFindByID: InstallWindowEventHandler: GetWindowAttributes: paramErr: return status; }
void MCStack::realize() { //create window if (!MCnoui && MCModeMakeLocalWindows()) { if ( getextendedstate(ECS_FULLSCREEN) ) { //TS-2008-08-01 : [[Bug 5703 - fullscreen stack prop interacts badly with HideMenuBar]] if (!((MCScreenDC*)MCscreen)->getmenubarhidden()) SetSystemUIMode(kUIModeAllHidden, kUIOptionAutoShowMenuBar); const MCDisplay *t_display; t_display = MCscreen -> getnearestdisplay(rect); MCRectangle t_workarea, t_viewport; t_workarea = t_display -> workarea; t_viewport = t_display -> viewport ; setrect(t_viewport); } else { if (!((MCScreenDC*)MCscreen)->getmenubarhidden()) SetSystemUIMode(kUIModeNormal, NULL); } Rect wrect; MCScreenDC *psdc = (MCScreenDC *)MCscreen; psdc->MCRect2MacRect(rect, wrect); window = new _Drawable; window->type = DC_WINDOW; window->handle.window = 0; char *tmpname = NULL; const unsigned char *namePascal; if (!isunnamed()) { //set window title to name of stack temporarily. tmpname = strclone(getname_cstring()); //it will be changed by setname() later. namePascal = c2pstr(tmpname); } else namePascal = (unsigned char*)"\p"; loadwindowshape(); window->handle.window = NULL; uint32_t wclass; uint32_t wattributes; getWinstyle(wattributes,wclass); wattributes |= kWindowCompositingAttribute; long testdecorations = WD_TITLE | WD_MENU | WD_CLOSE | WD_MINIMIZE | WD_MAXIMIZE; if (m_window_shape != NULL) { static WindowDefUPP s_window_mask_proc = NULL; if (s_window_mask_proc == NULL) s_window_mask_proc = NewWindowDefUPP(WindowMaskProc); WindowDefSpec t_spec; t_spec . defType = kWindowDefProcPtr; t_spec . u . defProc = s_window_mask_proc; CreateCustomWindow(&t_spec, wclass, wattributes, &wrect, (WindowPtr *)&window -> handle . window); HIWindowChangeFeatures((WindowPtr)window -> handle . window, 0, kWindowIsOpaque); } else if (((flags & F_DECORATIONS && !(decorations & testdecorations)) || wclass == kPlainWindowClass)) { static WindowDefUPP s_borderless_proc = NULL; if (s_borderless_proc == NULL) s_borderless_proc = NewWindowDefUPP(BorderlessWindowProc); WindowDefSpec t_spec; t_spec . defType = kWindowDefProcPtr; t_spec . u . defProc = s_borderless_proc; if (wclass == kPlainWindowClass) wclass = kUtilityWindowClass; CreateCustomWindow(&t_spec, wclass, wattributes, &wrect, (WindowPtr *)&window->handle.window); } else CreateNewWindow(wclass, wattributes,&wrect, (WindowPtr *)&window->handle.window); if (wclass == kFloatingWindowClass) ChangeWindowAttributes((WindowPtr)window -> handle . window, kWindowNoAttributes, kWindowHideOnSuspendAttribute); // MW-2009-10-31: Make sure we can collapse any rev window HIWindowChangeFeatures((WindowPtr)window -> handle . window, kWindowCanCollapse, 0); if (window->handle.window == NULL) SetWTitle((WindowPtr)window->handle.window, namePascal); SetWTitle((WindowPtr)window->handle.window, namePascal); setopacity(blendlevel * 255 / 100); SetWRefCon((WindowPtr)window->handle.window, mode); ControlRef t_control; MCRevolutionStackViewCreate(this, &t_control); ControlRef t_root_control; GetRootControl((WindowPtr)window -> handle . window, &t_root_control); HIViewAddSubview(t_root_control, t_control); ShowControl(t_control); if (wclass == kDrawerWindowClass) { Window pwindow = NULL; if (parentwindow != DNULL) pwindow = parentwindow; else if (MCdefaultstackptr && MCdefaultstackptr->getw() != DNULL ) pwindow = MCdefaultstackptr->getw(); if (pwindow && GetWRefCon((WindowPtr)pwindow->handle.window) != WM_DRAWER) { SetDrawerParent((WindowPtr)window->handle.window, (WindowPtr)pwindow->handle.window); WindowAttributes watt; GetWindowAttributes((WindowPtr)pwindow->handle.window,&watt); if (wattributes & kWindowResizableAttribute) ChangeWindowAttributes((WindowPtr)pwindow->handle.window, kWindowLiveResizeAttribute, 0); OptionBits draweredge; switch (wposition) { case WP_PARENTTOP: draweredge = kWindowEdgeTop; break; case WP_PARENTRIGHT: draweredge = kWindowEdgeRight; break; case WP_PARENTBOTTOM: draweredge = kWindowEdgeBottom; break; case WP_PARENTLEFT: draweredge = kWindowEdgeLeft; break; default: draweredge = kWindowEdgeDefault; break; } SetDrawerPreferredEdge((WindowPtr)window->handle.window, draweredge); if (walignment) { MCRectangle parentwindowrect; MCscreen->getwindowgeometry(pwindow, parentwindowrect); int2 wspace = 0; RgnHandle r = NewRgn(); GetWindowRegion((WindowPtr)window->handle.window, kWindowStructureRgn, r); Rect tRect; GetRegionBounds(r, &tRect); DisposeRgn(r); MCRectangle drawerwindowrect; psdc->MacRect2MCRect(tRect, drawerwindowrect); if (wposition == WP_PARENTTOP || wposition == WP_PARENTBOTTOM) { wspace = parentwindowrect.width - drawerwindowrect.width; if (watt & kWindowMetalAttribute) if (wspace) wspace += 10; //for metal } else { wspace = parentwindowrect.height - drawerwindowrect.height; if (watt & kWindowMetalAttribute) if (wspace) wspace += 5; //for metal } if (wspace > 0) switch (walignment) { case OP_CENTER: SetDrawerOffsets ((WindowPtr)window->handle.window,ceil(wspace/2) -1,floor(wspace/2) + 1); break; case OP_RIGHT: case OP_BOTTOM: SetDrawerOffsets ((WindowPtr)window->handle.window,wspace,0); break; case OP_TOP: case OP_LEFT: SetDrawerOffsets ((WindowPtr)window->handle.window,0,wspace); break; } } } } delete tmpname; // MW-2005-11-06: We also need to catch window constraining events so we can flush // the screen geometry cache. EventTypeSpec list[] = { {kEventClassWindow, kEventWindowCollapsed}, {kEventClassWindow, kEventWindowExpanded}, {kEventClassMouse, kEventMouseWheelMoved}, {kEventClassWindow, kEventWindowBoundsChanging}, {kEventClassWindow, kEventWindowBoundsChanged}, {kEventClassWindow, kEventWindowConstrain}, {kEventClassWindow, kEventWindowFocusAcquired}, {kEventClassWindow, kEventWindowFocusRelinquish}, {kEventClassWindow, kEventWindowActivated}, {kEventClassWindow, kEventWindowDeactivated}, {kEventClassWindow, kEventWindowClose}, }; EventHandlerRef ref; // MW-2005-09-07: Pass the window handle as user data, otherwise 'takewindow' causes problems InstallWindowEventHandler((WindowPtr)window->handle.window, MCS_weh, sizeof(list) / sizeof(EventTypeSpec), list, (WindowPtr)window -> handle . window, &ref); ChangeWindowAttributes((WindowPtr)window->handle.window, 0, kWindowHideOnFullScreenAttribute); updatemodifiedmark(); } start_externals(); }