static void DisplaySimpleWindow( void )
{
OSErr err;
WindowRef window;
WindowStorage *windowStorage;
WindowGroupRef windowGroup;
static EventHandlerUPP simpleWindowEventHandlerUPP;
const EventTypeSpec windowEvents[] =
{
{ kEventClassCommand, kEventCommandProcess },
{ kEventClassWindow, kEventWindowClickContentRgn },
{ kEventClassWindow, kEventWindowBoundsChanging },
{ kEventClassWindow, kEventWindowBoundsChanged },
{ kEventClassWindow, kEventWindowClose }
};
err = CreateWindowFromNib( g.mainNib, CFSTR("MainWindow"), &window );
if ( (err != noErr) || (window == NULL) ) goto Bail;
if ( simpleWindowEventHandlerUPP == NULL ) simpleWindowEventHandlerUPP = NewEventHandlerUPP( SimpleWindowEventHandlerProc );
err = InstallWindowEventHandler( window, simpleWindowEventHandlerUPP, GetEventTypeCount(windowEvents), windowEvents, window, NULL );
windowStorage = (WindowStorage*) NewPtrClear( sizeof(WindowStorage) );
SetWRefCon( window, (long) windowStorage );
err = CreateWindowGroup( kWindowGroupAttrMoveTogether | kWindowGroupAttrLayerTogether | kWindowGroupAttrHideOnCollapse, &windowGroup );
if ( err == noErr ) err = SetWindowGroupParent( windowGroup, g.windowGroups[1] ); // Default group
if ( err == noErr ) err = SetWindowGroup( window, windowGroup );
ShowWindow( window );
Bail:
return;
}
void Init(void)
{
Str255 winTitle;
OSErr err = noErr;
Str255 instMode;
Ptr pinstMode;
gDone = false;
InitManagers();
InitControlsObject();
CleanTemp();
ParseInstall();
gWPtr = GetNewCWindow(rRootWin, NULL, (WindowPtr) -1);
GetIndString( instMode, rTitleStrList, sNSInstTitle);
pinstMode = PascalToC(instMode);
#if MOZILLA == 0
GetResourcedString(winTitle, rInstList, sNsTitle);
#else
GetResourcedString(winTitle, rInstList, sMoTitle);
#endif
SetWTitle( gWPtr, winTitle );
SetWRefCon(gWPtr, kMIWMagic);
MakeMenus();
ParseConfig();
InitOptObject();
ShowWelcomeWin();
SetThemeWindowBackground(gWPtr, kThemeBrushDialogBackgroundActive, true);
/* Set menu */
InitNewMenu();
}
GBWindow::GBWindow(GBView * contents, short left, short top, bool vis)
: showGrowBox(false), //TODO
window(nil),
view(contents),
visible(vis)
{
Rect bounds;
bounds.left = left;
bounds.top = top;
bounds.right = left + view->PreferredWidth();
bounds.bottom = top + view->PreferredHeight();
Str255 s;
ToPascalString(view->Name(), s);
view->SetBounds(GBRect(0, 0, view->PreferredWidth(), view->PreferredHeight()));
if ( CreateNewWindow(kDocumentWindowClass,
view->Resizable() ? kWindowStandardDocumentAttributes
: (kWindowCloseBoxAttribute | kWindowCollapseBoxAttribute),
&bounds, &window) )
throw GBOutOfMemoryError();
SetWTitle(window, s);
SetWRefCon(window, (long)this);
SetWindowKind(window, kMacWindowKind);
view->SetGraphics(&graphics);
if ( vis )
ShowWindow(window);
}
bool wxTopLevelWindowMac::SetShape(const wxRegion& region)
{
wxCHECK_MSG( HasFlag(wxFRAME_SHAPED), FALSE,
_T("Shaped windows must be created with the wxFRAME_SHAPED style."));
#if TARGET_CARBON
// The empty region signifies that the shape should be removed from the
// window.
if ( region.IsEmpty() )
{
wxSize sz = GetClientSize();
wxRegion rgn(0, 0, sz.x, sz.y);
return SetShape(rgn);
}
// Make a copy of the region
RgnHandle shapeRegion = NewRgn();
CopyRgn( (RgnHandle)region.GetWXHRGN(), shapeRegion );
// Dispose of any shape region we may already have
RgnHandle oldRgn = (RgnHandle)GetWRefCon( (WindowRef)MacGetWindowRef() );
if ( oldRgn )
DisposeRgn(oldRgn);
// Save the region so we can use it later
SetWRefCon((WindowRef)MacGetWindowRef(), (SInt32)shapeRegion);
// Tell the window manager that the window has changed shape
ReshapeCustomWindow((WindowRef)MacGetWindowRef());
return TRUE;
#else
return FALSE;
#endif
}
int open_window(MacWindow* macwin, short resID)
{
macwin->ref=GetNewCWindow(resID, 0, (WindowRef)-1);
if( macwin->ref==0) mac_ErrorExit("\pCannot open Window!");
SetWRefCon(macwin->ref, (long)macwin);
return 0;
}
bool QuartzWindow::open(
uint32 /* WindowClass */ wc,
int* /* WindowAttributes */ attrs,
int left,
int top,
int right,
int bottom,
const char* title,
const char* font_name,
int font_size ) {
HIRect bounds = (HIRect) CGRectMake(left, top, right, bottom);
OSStatus err = HIWindowCreate(wc, attrs, NULL, kHICoordSpace72DPIGlobal, &bounds, &_quartz_win);
if (err != noErr)
return false;
SetWRefCon(my_window(), (int32)this);
CFStringRef cftitle = CFStringCreateWithCString(NULL, title, kCFStringEncodingMacRoman);
SetWindowTitleWithCFString(my_window(), cftitle);
CFRelease(cftitle);
WindowSet::add_window(my_window());
_is_open = true;
init_colors();
init_events();
return true;
}
void mac_openabout(void)
{
DialogItemType itemtype;
Handle item;
VersRecHndl vers;
Rect box;
StringPtr longvers;
WinInfo *wi;
if (windows.about)
SelectWindow(windows.about);
else {
windows.about =
GetDialogWindow(GetNewDialog(wAbout, NULL, (WindowPtr)-1));
wi = snew(WinInfo);
memset(wi, 0, sizeof(*wi));
wi->wtype = wAbout;
wi->update = &mac_updateabout;
wi->click = &mac_clickabout;
wi->activate = &mac_activateabout;
wi->close = &mac_closeabout;
SetWRefCon(windows.about, (long)wi);
vers = (VersRecHndl)Get1Resource('vers', 1);
if (vers != NULL && *vers != NULL) {
longvers = (*vers)->shortVersion + (*vers)->shortVersion[0] + 1;
GetDialogItem(GetDialogFromWindow(windows.about), wiAboutVersion,
&itemtype, &item, &box);
assert(itemtype & kStaticTextDialogItem);
SetDialogItemText(item, longvers);
}
ShowWindow(windows.about);
}
}
static void mac_config(int midsession)
{
Session *s;
WinInfo *wi;
Str255 mactitle;
char *str;
if (midsession) {
s = mac_windowsession(FrontWindow());
} else {
s = snew(Session);
memset(s, 0, sizeof(*s));
do_defaults(NULL, &s->cfg);
s->hasfile = FALSE;
s->session_closed = FALSE;
}
/* Copy the configuration somewhere else in case this is a *
* reconfiguration and the user cancels the operation */
s->temp_cfg = s->cfg;
if (HAVE_COLOR_QD())
s->settings_window = GetNewCWindow(wSettings, NULL, (WindowPtr)-1);
else
s->settings_window = GetNewWindow(wSettings, NULL, (WindowPtr)-1);
s->ctrlbox = ctrl_new_box();
setup_config_box(s->ctrlbox, midsession, 0, 0);
s->settings_ctrls.data = &s->temp_cfg;
if (midsession)
s->settings_ctrls.end = &mac_enddlg_reconfig;
else
s->settings_ctrls.end = &mac_enddlg_config;
macctrl_layoutbox(s->ctrlbox, s->settings_window, &s->settings_ctrls);
wi = snew(WinInfo);
memset(wi, 0, sizeof(*wi));
wi->s = s;
wi->mcs = &s->settings_ctrls;
wi->wtype = wSettings;
wi->update = &macctrl_update;
wi->click = &macctrl_click;
wi->key = &macctrl_key;
wi->activate = &macctrl_activate;
wi->adjustmenus = &macctrl_adjustmenus;
wi->close = &mac_closedlg;
SetWRefCon(s->settings_window, (long)wi);
if (midsession)
str = dupprintf("%s Reconfiguration", appname);
else
str = dupprintf("%s Configuration", appname);
c2pstrcpy(mactitle, str);
sfree(str);
SetWTitle(s->settings_window, mactitle);
ShowWindow(s->settings_window);
}
static
OSStatus InstallWindowEventHandlers( WindowRef windowRef )
{
static const EventTypeSpec inputEventSpec[] = {
{ kEventClassTextInput, kEventTextInputUnicodeForKeyEvent } };
static const EventTypeSpec windowEventSpec[] = {
{ kEventClassWindow, kEventWindowClosed },
{ kEventClassWindow, kEventWindowBoundsChanged } };
static const EventTypeSpec viewEventSpec[] = {
{ kEventClassControl, kEventControlDraw } };
OSStatus err;
DrawContextStruct *newContext;
// allocate a new draw context
newContext = calloc( 1, sizeof( DrawContextStruct ) );
require_action( newContext != NULL, InstallWindowEventHandlers_err,
err = paramErr );
HIViewFindByID(HIViewGetRoot(windowRef), myHIViewID, &newContext->viewRef);
newContext->windowRef = windowRef;
// install a key event handler
err = InstallWindowEventHandler( windowRef, NewEventHandlerUPP( HandleKeyEvent ), GetEventTypeCount( inputEventSpec ), inputEventSpec, (void *) newContext, NULL );
require_noerr( err, InstallWindowEventHandlersEvent_err );
// install a general window event handler
err = InstallWindowEventHandler( windowRef, NewEventHandlerUPP( HandleWindowEvent ), GetEventTypeCount( windowEventSpec ), windowEventSpec, (void *) newContext, NULL );
require_noerr( err, InstallWindowEventHandlersEvent_err );
// install handler for the HI view
err = HIViewInstallEventHandler( newContext->viewRef, NewEventHandlerUPP( HandleViewEvent ), GetEventTypeCount( viewEventSpec ), viewEventSpec, (void *) newContext, NULL);
require_noerr( err, InstallWindowEventHandlersEvent_err );
// also, set the context as the window refcon
SetWRefCon( windowRef, (SRefCon) newContext );
return noErr;
InstallWindowEventHandlersEvent_err:
// make sure that if we're bailing to get rid of the allocated buffer
free( newContext );
InstallWindowEventHandlers_err:
return err;
}
static void mac_openlicence(void)
{
WinInfo *wi;
if (windows.licence)
SelectWindow(windows.licence);
else {
windows.licence = GetNewWindow(wLicence, NULL, (WindowPtr)-1);
wi = snew(WinInfo);
memset(wi, 0, sizeof(*wi));
wi->wtype = wLicence;
wi->update = &mac_updatelicence;
wi->close = &mac_closelicence;
SetWRefCon(windows.licence, (long)wi);
ShowWindow(windows.licence);
}
}
void attach_new_endpoint_to_application(
struct endpoint_data *endpoint,
char *title,
NMBoolean system_time)
{
static long startLeft = 100;
static long startTop = 100;
WindowPtr wp;
char window_title[128];
if(system_time)
{
Rect boundsRect;
boundsRect.left = startLeft;
startLeft += 32;
boundsRect.right = boundsRect.left + 500;
boundsRect.top = startTop;
startTop += 32;
boundsRect.bottom = boundsRect.top + 300;
wp = NewCWindow(nil,&boundsRect,"\pWindow", true, noGrowDocProc,(WindowPtr)-1,false,0);
//wp = NewCWind(
//wp= GetNewWindow(winDOCUMENT, NULL, (WindowPtr) -1l);
op_assert(wp);
//add a close box
//FIXME: i forgot how to do this on classic =)
#ifdef OP_PLATFORM_MAC_CARBON_FLAG
ChangeWindowAttributes(wp,kWindowCloseBoxAttribute,0);
#endif
if(wp)
{
SetWRefCon(wp, (long) endpoint);
strcpy(window_title, title);
c2pstr(window_title);
SetWTitle(wp, (const unsigned char *) window_title);
ShowWindow(wp);
new_log(wp);
}
} else {
static void window_create(IMAGE *img)
{
WindowRef windowRef;
Str255 windowTitle = "\pGhostscript Image";
Rect windowRect = {20,4,580,420};//, portRect;
Rect scrollbarRect = {0,0,0,0};
#if TARGET_API_MAC_CARBON
GetAvailableWindowPositioningBounds(GetMainDevice(),&windowRect);
#endif
/* Create a new suitablty positioned window */
windowRect.top = windowRect.top * 2 + 2;
windowRect.bottom -= 10;
windowRect.left += 4;
windowRect.right = ((windowRect.bottom - windowRect.top) * 3) / 4 + windowRect.left;
if(!(windowRef = NewCWindow(NULL, &windowRect, windowTitle, true,
zoomDocProc, (WindowRef) -1, false, 0)))
ExitToShell();
img->windowRef = windowRef;
SetWRefCon(img->windowRef, (SInt32)img);
/* Create the window's scrollbars */
#if TARGET_API_MAC_CARBON
if(gRunningOnX)
ChangeWindowAttributes(windowRef,kWindowLiveResizeAttribute,0);
CreateScrollBarControl(windowRef, &scrollbarRect, 0, 0, 0, 0,
true, gActionFunctionScrollUPP, &(img->scrollbarVertRef));
CreateScrollBarControl(windowRef, &scrollbarRect, 0, 0, 0, 0,
true, gActionFunctionScrollUPP, &(img->scrollbarHorizRef));
#else
img->scrollbarVertRef = NewControl(windowRef,&scrollbarRect,"\p",false,0,0,0,scrollBarProc,0);
img->scrollbarHorizRef = NewControl(windowRef,&scrollbarRect,"\p",false,0,0,0,scrollBarProc,0);
#endif
window_adjust_scrollbars(windowRef);
}
static void mac_createeventlog(Session *s)
{
Rect view;
ListBounds bounds = { 0, 0, 0, 1 }; /* 1 column, 0 rows */
Point csize = { 0, 0 };
GrafPtr saveport;
long fondsize;
WinInfo *wi;
s->eventlog_window = GetNewWindow(wEventLog, NULL, (WindowPtr)-1);
wi = snew(WinInfo);
memset(wi, 0, sizeof(*wi));
wi->s = s;
wi->wtype = wEventLog;
wi->click = &mac_clickeventlog;
wi->activate = &mac_activateeventlog;
wi->grow = &mac_groweventlog;
wi->update = &mac_updateeventlog;
wi->close = &mac_closeeventlog;
SetWRefCon(s->eventlog_window, (long)wi);
GetPort(&saveport);
SetPort((GrafPtr)GetWindowPort(s->eventlog_window));
fondsize = GetScriptVariable(smRoman, smScriptSmallFondSize);
TextFont(HiWord(fondsize));
TextSize(LoWord(fondsize));
SetPort(saveport);
#if TARGET_API_MAC_CARBON
GetPortBounds(GetWindowPort(s->eventlog_window), &view);
#else
view = s->eventlog_window->portRect;
#endif
view.right -= 15; /* Scrollbar */
s->eventlog = LNew(&view, &bounds, csize, 0, s->eventlog_window,
TRUE, TRUE, FALSE, TRUE);
mac_adjusteventlogscrollbar(s);
#if TARGET_API_MAC_CARBON
SetListSelectionFlags(s->eventlog, lExtendDrag | lNoDisjoint | lNoExtend);
#else
(*s->eventlog)->selFlags = lExtendDrag | lNoDisjoint | lNoExtend;
#endif
}
void mac_newkey(void)
{
KeyState *ks;
WinInfo *wi;
Handle h;
short type;
Rect rect;
ks = snew(KeyState);
ks->box = GetNewDialog(wKey, NULL, (WindowPtr)-1);
GetDialogItem(ks->box, wiKeyProgress, &type, &h, &rect);
ks->progress = (ControlHandle)h;
wi = snew(WinInfo);
memset(wi, 0, sizeof(*wi));
wi->ks = ks;
wi->wtype = wKey;
wi->update = &mac_updatekey;
wi->click = &mac_clickkey;
wi->activate = &mac_activatekey;
SetWRefCon(GetDialogWindow(ks->box), (long)wi);
ShowWindow(GetDialogWindow(ks->box));
}
void WindowBase::EnableEvent()
{
OSXWindowData *windowData = new OSXWindowData;
windowData->WindowBaseOwner = this;
EventTypeSpec list[] = { { kEventClassWindow, kEventWindowShown },
{ kEventClassWindow, kEventWindowActivated },
{ kEventClassWindow, kEventWindowDeactivated },
{ kEventClassWindow, kEventWindowClose },
{ kEventClassWindow, kEventWindowDrawContent },
{ kEventClassWindow, kEventWindowBoundsChanged },
{ kEventClassKeyboard, kEventRawKeyDown },
{ kEventClassKeyboard, kEventRawKeyUp },
{ kEventClassMouse, kEventMouseMoved },
{ kEventClassMouse, kEventMouseDown },
{ kEventClassMouse, kEventMouseUp }
};
windowData->WindowEventHandler = NewEventHandlerUPP(WindowEventHandler);
PRCORE_ASSERT_EXCEPTION(
noErr != InstallWindowEventHandler (
mWindowHandle,
windowData->WindowEventHandler,
GetEventTypeCount (list), list,
(void*)windowData,
&windowData->EventHandlerReference
)
);
windowData->StartedApplicationLoop = false;
windowData->EventMainLoopReference = NULL;
SetWRefCon (mWindowHandle,(long)windowData);
mIsEventEnable=true;
}
pascal Boolean ConfirmAlertFilter(DialogPtr theDialog, EventRecord *theEvent, short *itemHit)
{
char charCode;
Boolean enterORreturn;
Boolean returnValue = false;
if (0 == GetWRefCon(theDialog))
SetWRefCon (theDialog,TickCount());
else
{
if (GetWRefCon(theDialog) + kSecondsToConfirm * 60 < TickCount())
{
returnValue = true;
theEvent->what = nullEvent;
*itemHit = 1;
}
else
{
if (theEvent->what == keyDown)
{
charCode = (char)theEvent->message & charCodeMask;
enterORreturn = (charCode == (char)char_Return) || (charCode == (char)char_Enter);
if (enterORreturn)
{
theEvent->what = nullEvent;
returnValue = true;
*itemHit = iRevertItem;
if (enterORreturn && (0 != (theEvent->modifiers & optionKey)))
{
*itemHit = iConfirmItem;
}
}
}
}
}
return (returnValue);
}
bool wxSkinWindow::SetShape(const wxRegion& region)
{
#if defined(__WXMSW__) && !defined(__WXWINCE__)
// The empty region signifies that the shape should be removed from the
// window.
if ( region.IsEmpty() )
{
if (::SetWindowRgn(GetHwnd(), NULL, TRUE) == 0)
{
wxLogLastError(_T("SetWindowRgn"));
return false;
}
return true;
}
DWORD noBytes = ::GetRegionData(GetHrgnOf(region), 0, NULL);
RGNDATA *rgnData = (RGNDATA*) new char[noBytes];
::GetRegionData(GetHrgnOf(region), noBytes, rgnData);
HRGN hrgn = ::ExtCreateRegion(NULL, noBytes, rgnData);
delete[] (char*) rgnData;
RECT rect;
DWORD dwStyle = ::GetWindowLong(GetHwnd(), GWL_STYLE);
DWORD dwExStyle = ::GetWindowLong(GetHwnd(), GWL_EXSTYLE);
::GetClientRect(GetHwnd(), &rect);
::AdjustWindowRectEx(&rect, dwStyle, FALSE, dwExStyle);
::OffsetRgn(hrgn, -rect.left, -rect.top);
if (::SetWindowRgn(GetHwnd(), hrgn, TRUE) == 0)
{
wxLogLastError(_T("SetWindowRgn"));
return false;
}
return true;
#elif defined(__WXMAC__)
if ( region.IsEmpty() )
{
wxSize sz = GetClientSize();
wxRegion rgn(0, 0, sz.x, sz.y);
return SetShape(rgn);
}
// Make a copy of the region
RgnHandle shapeRegion = NewRgn();
CopyRgn( (RgnHandle)region.GetWXHRGN(), shapeRegion );
// Dispose of any shape region we may already have
RgnHandle oldRgn = (RgnHandle)GetWRefCon( (WindowRef)GetHandle() );
if ( oldRgn )
DisposeRgn(oldRgn);
// Save the region so we can use it later
SetWRefCon((WindowRef)GetHandle(), (SInt32)shapeRegion);
// Tell the window manager that the window has changed shape
ReshapeCustomWindow((WindowRef)GetHandle());
return true;
#elif defined(__WXGTK__)
if(region.IsEmpty())
{
if(m_wxwindow && !GTK_WIDGET_NO_WINDOW(m_wxwindow))
gtk_widget_shape_combine_mask(m_wxwindow,NULL,0,0);
if(m_widget && !GTK_WIDGET_NO_WINDOW(m_widget))
gtk_widget_shape_combine_mask(m_widget,NULL,0,0);
}
else
{ wxBitmap bmp = region.ConvertToBitmap();
bmp.SetMask(new wxMask(bmp, *wxBLACK));
GdkBitmap* mask = bmp.GetMask()->GetBitmap();
if(m_wxwindow && !GTK_WIDGET_NO_WINDOW(m_wxwindow))
gtk_widget_shape_combine_mask(m_wxwindow,mask,0,0);
if(m_widget && !GTK_WIDGET_NO_WINDOW(m_widget))
gtk_widget_shape_combine_mask(m_widget,mask,0,0);
}
return true;
#else
return false;
#endif
}
// window instance management
NWindow* NCarbonWindowManager::New(const NString & sImplementationName, const NRect & rWindBounds, const NString & sWindCaption, bool bWindowVisible)
{
OSStatus err;
NWindow *aWindow = NULL;
WindowRef macWindow = NULL;
DialogRef macDialog = NULL;
NWindowImplementation *refImp = GetWindowImpByName(sImplementationName);
Rect r = rWindBounds.AsQDRect();
NUInt32 iRC;
// need an implementation
if(refImp == NULL) return NULL;
// extract info from implementation, convert to mac style class + attr
NWindowClass iWinClass = refImp->ImplementationWindowClass();
NWindowFeatures iWinFeatures = refImp->ImplementationWindowFeatures();
WindowClass iMacClass = 0;
WindowAttributes iMacAttrs = 0;
if(iWinClass == kWindowClassDialog)
{
// get dialog items
Handle h = refImp->GetInitialMacDialogItems();
if(h == NULL)
return NULL;
// create dialog
macDialog = NewFeaturesDialog(NULL, &r, "\p", bWindowVisible, kWindowDocumentProc, (WindowPtr)-1, (iWinFeatures & kWindowFeatureHasCloseBox) != 0,
0, h, kDialogFlagsUseThemeBackground | kDialogFlagsUseControlHierarchy | kDialogFlagsUseThemeControls);
if(macDialog == NULL)
return NULL;
}
else
{
// create a WindowRef
if(iWinClass == kWindowClassUtility)
{
iMacClass = kUtilityWindowClass;
}
else
{
if(iWinFeatures & kWindowFeatureHasBorder)
iMacClass = kDocumentWindowClass;
else
iMacClass = kFloatingWindowClass;
}
if((iWinFeatures & kWindowFeatureIsResizeableH) || (iWinFeatures & kWindowFeatureIsResizeableV))
iMacAttrs |= kWindowResizableAttribute;
if(iWinFeatures & kWindowFeatureHasCloseBox)
iMacAttrs |= kWindowCloseBoxAttribute;
if(iWinFeatures & kWindowFeatureIsMinimizable)
iMacAttrs |= kWindowCollapseBoxAttribute;
if(iWinFeatures & kWindowFeatureIsMaximizable)
iMacAttrs |= kWindowFullZoomAttribute;
// create mac window
err = CreateNewWindow(iMacClass, iMacAttrs, &r, &macWindow);
if(err != noErr) return NULL;
}
// determine window handle to pass as refcon for NWindow
if(iWinClass == kWindowClassDialog)
iRC = (NUInt32)GetDialogWindow(macDialog);
else
iRC = (NUInt32)macWindow;
// create NWindow, link macwindow/nwindow
aWindow = new NWindow("CarbonWindow", iWinClass, iWinFeatures, rWindBounds, refImp->Clone(), iRC);
if(iWinClass == kWindowClassDialog)
SetWRefCon(GetDialogWindow(macDialog), (NUInt32)aWindow);
else
SetWRefCon(macWindow, (NUInt32)aWindow);
// set caption, make visible
aWindow->SetCaption(sWindCaption);
aWindow->SetVisible(bWindowVisible);
if(bWindowVisible)
aWindow->BringToFront();
return aWindow;
}
static SDL_Surface *ROM_SetVideoMode(_THIS, SDL_Surface *current,
int width, int height, int bpp, Uint32 flags)
{
Rect wrect, orect;
#if TARGET_API_MAC_CARBON
Rect tmprect;
#endif
/* Free any previous video mode */
ROM_UnsetVideoMode(this, current);
/* Create the ROM window and SDL video surface */
current->flags = 0; /* Clear flags */
current->w = width;
current->h = height;
SetRect(&wrect, 0, 0, width, height);
if ( SDL_Window ) {
/* If we recreate the window, don't move it around */
#if TARGET_API_MAC_CARBON
orect = *GetWindowPortBounds(SDL_Window, &tmprect);
#else
orect = SDL_Window->portRect;
#endif
OffsetRect(&wrect, orect.left, orect.top);
} else {
/* Center the window the first time we show it */
OffsetRect(&wrect,
(SDL_modelist[0]->w-width)/2, (SDL_modelist[0]->h-height)/2);
}
#if defined(__MACOSX__) && !USE_QUICKTIME
/* Hum.. fullscreen mode is broken */
flags &= ~SDL_FULLSCREEN;
#endif
if ( (flags & SDL_FULLSCREEN) == SDL_FULLSCREEN ) {
/* Create the fullscreen window and use screen bits */
current->flags |= SDL_HWSURFACE|SDL_FULLSCREEN;
if ( SDL_Window ) {
DisposeWindow(SDL_Window);
}
#if USE_QUICKTIME
BeginFullScreen(&fullscreen_ctx, nil, 0,0, &SDL_Window, nil, 0);
#else
SDL_Window = NewCWindow(nil, &wrect, "\p", true, plainDBox,
(WindowPtr)-1, false, 0);
ROM_HideMenuBar(this);
#endif
current->pitch = (**(**SDL_Display).gdPMap).rowBytes & 0x3FFF;
current->pixels = (**(**SDL_Display).gdPMap).baseAddr;
this->UpdateRects = ROM_DirectUpdate;
} else {
GWorldPtr memworld;
PixMapHandle pixmap;
int style;
style = noGrowDocProc;
if ( flags & SDL_NOFRAME ) {
style = plainDBox;
current->flags |= SDL_NOFRAME;
} else
if ( flags & SDL_RESIZABLE ) {
style = zoomDocProc;
current->flags |= SDL_RESIZABLE;
}
if ( SDL_Window && (style == current_style) ) {
/* Resize existing window, if necessary */
if ( ((orect.right-orect.left) != width) ||
((orect.bottom-orect.top) != height) ) {
SizeWindow(SDL_Window, width, height, false);
}
} else {
/* Recreate the window in the new style */
if ( SDL_Window ) {
DisposeWindow(SDL_Window);
}
SDL_Window = NewCWindow(nil, &wrect, "\p", true,
style, (WindowPtr)-1, true, 0);
/* Set the window title, if any */
{ char *title;
SDL_WM_GetCaption(&title, NULL);
if ( title ) {
Mac_SetCaption(this, title, NULL);
}
}
}
current_style = style;
SetPalette(SDL_Window, SDL_CPal, false);
ActivatePalette(SDL_Window);
if ( NewGWorld(&memworld, 0,
#if TARGET_API_MAC_CARBON
GetWindowPortBounds(SDL_Window, &tmprect),
#else
&SDL_Window->portRect,
#endif
SDL_CTab, nil, 0) != noErr ) {
SDL_SetError("NewGWorld() failed");
return(NULL);
}
SetWRefCon(SDL_Window, (long)memworld);
pixmap = GetGWorldPixMap(memworld);
LockPixels(pixmap);
current->pitch = (**pixmap).rowBytes & 0x3FFF;
current->pixels = GetPixBaseAddr(pixmap);
this->UpdateRects = ROM_WindowUpdate;
}
SetPortWindowPort(SDL_Window);
SelectWindow(SDL_Window);
/* Handle OpenGL support */
if ( flags & SDL_OPENGL ) {
if ( Mac_GL_Init(this) == 0 ) {
current->flags |= SDL_OPENGL;
} else {
current = NULL;
}
}
if ( (flags & SDL_HWPALETTE) && (flags & SDL_FULLSCREEN) )
current->flags |= SDL_HWPALETTE;
/* We're live! */
return(current);
}
/*****************************************************
*
* Do_NewWindowFromIB(outWindow)
*
* Purpose: called to create a new window that has been constructed with Interface Builder
*
* Notes: called by Do_NewWindow()
*
* Inputs: outWindow - if not NULL, the address where to return the WindowRef
* - if not NULL, the callee will have to ShowWindow
*
* Returns: OSStatus - error code (0 == no error)
*/
static OSStatus Do_NewWindowFromIB(WindowRef * outWindow)
{
OSStatus status;
WindowRef aWindowRef = NULL;
CFStringRef theTitle = NULL;
CFMutableStringRef theNewTitle = NULL;
// Create a window. "MainWindow" is the name of the window object. This name is set in
// InterfaceBuilder when the nib is created.
status = CreateWindowFromNib(gIBNibRef, CFSTR("MainWindow"), &aWindowRef);
require_noerr(status, CreateWindowFromNib);
require(aWindowRef != NULL, CreateWindowFromNib);
WindowDataPtr wdr = (WindowDataPtr)calloc(1, sizeof(WindowDataRec));
require(wdr != NULL, CantAllocateWindowData);
SetWRefCon(aWindowRef, (long)wdr);
status = CopyWindowTitleAsCFString(aWindowRef, &theTitle);
require_noerr(status, CopyWindowTitleAsCFString);
theNewTitle = CFStringCreateMutableCopy(NULL, 0, theTitle);
require(theNewTitle != NULL, CFStringCreateMutableCopy);
CFStringAppendFormat(theNewTitle, NULL, CFSTR(" %ld"), ++gWindowCount);
status = SetWindowTitleWithCFString(aWindowRef, theNewTitle);
require_noerr(status, SetWindowTitleWithCFString);
EventTypeSpec eventTypeCP = {kEventClassCommand, kEventCommandProcess};
status = InstallWindowEventHandler(aWindowRef, Handle_WindowCommandProcess, 1, &eventTypeCP, (void *)aWindowRef, NULL);
require_noerr(status, CantInstallEventHandler);
EventTypeSpec eventTypeWC = {kEventClassWindow, kEventWindowClosed};
status = InstallWindowEventHandler(aWindowRef, Handle_WindowIsClosing, 1, &eventTypeWC, (void *)aWindowRef, NULL);
require_noerr(status, CantInstallEventHandler);
HIViewID littleArrowsId = { 'LARC', 100 };
HIViewRef littleArrows;
status = HIViewFindByID(HIViewGetRoot(aWindowRef), littleArrowsId, &littleArrows);
require_noerr(status, HIViewFindByID);
require(littleArrows != NULL, HIViewFindByID);
SetControlAction(littleArrows, LittleArrowsControlAction);
EventTypeSpec eventTypeCVFC = {kEventClassControl, kEventControlValueFieldChanged};
status = HIViewInstallEventHandler(littleArrows, Handle_PostLittleArrowsClick, 1, &eventTypeCVFC, (void *)littleArrows, NULL);
require_noerr(status, CantInstallEventHandler);
// The window was created hidden so show it if the outWindow parameter is NULL,
// if it's not, it will be the responsibility of the caller to show it.
if (outWindow == NULL)
ShowWindow(aWindowRef);
SetWindowModified(aWindowRef, false);
HIViewFindByID:
CantInstallEventHandler:
SetWindowTitleWithCFString:
CFStringCreateMutableCopy:
CopyWindowTitleAsCFString:
if (theTitle != NULL)
CFRelease(theTitle);
if (theNewTitle != NULL)
CFRelease(theNewTitle);
CantAllocateWindowData:
CreateWindowFromNib:
if (outWindow != NULL)
*outWindow = aWindowRef;
return status;
} // Do_NewWindowFromIB
/*****************************************************
*
* DisplaySimpleWindow ( void )
*
* Purpose: Called to create a new window in response to a kHICommandNew event. Here we create a window, set up the MyMPTaskInfo structure,
* and create an MP thread to monitor our specified directories.
*
*/
static void DisplaySimpleWindow( void )
{
OSStatus err;
OSStatus err1;
WindowRef window;
ControlRef control;
MPTaskID mpTaskID;
MyMPTaskInfo *mpTaskInfo;
FSRef fsRef;
char path[MAXPATHLEN];
DialogRef alertDialog;
static EventHandlerUPP mpWindowEventHandlerUPP;
SInt32 i = -1;
const EventTypeSpec windowEvents[] = {
{ kEventClassCommand, kEventCommandProcess },
{ kEventClassMP, kEventKQueue },
{ kEventClassWindow, kEventWindowClose }
};
err = CreateWindowFromNib( g.mainNib, CFSTR("MainWindow"), &window );
if ( (err != noErr) || (window == NULL) ) goto Bail;
if ( mpWindowEventHandlerUPP == NULL ) mpWindowEventHandlerUPP = NewEventHandlerUPP( MPWindowEventHandlerProc ); // MPWindowEventHandlerProc handles events for this window
err = InstallWindowEventHandler( window, mpWindowEventHandlerUPP, GetEventTypeCount(windowEvents), windowEvents, window, NULL );
// Display the directories we are going to watch in the static text fields. In this sample we hard code the values to a few specific locations
err = FSFindFolder( kUserDomain, kDesktopFolderType, kDontCreateFolder, &fsRef ); // Watch the Desktop folder
err1 = FSRefMakePath( &fsRef, (UInt8 *)path, MAXPATHLEN );
if ( (err == noErr) && (err1 == noErr) )
SetControlCString( window, 'STxt', ++i, path );
err = FSFindFolder( kUserDomain, kDocumentsFolderType, kDontCreateFolder, &fsRef ); // Watch the Documents folder
err1 = FSRefMakePath( &fsRef, (UInt8 *)path, MAXPATHLEN );
if ( (err == noErr) && (err1 == noErr) )
SetControlCString( window, 'STxt', ++i, path );
err = FSFindFolder( kUserDomain, kCurrentUserFolderType, kDontCreateFolder, &fsRef ); // Watch the Users folder
err1 = FSRefMakePath( &fsRef, (UInt8 *)path, MAXPATHLEN );
if ( (err == noErr) && (err1 == noErr) )
SetControlCString( window, 'STxt', ++i, path );
mpTaskInfo = (MyMPTaskInfo*) NewPtrClear( sizeof(MyMPTaskInfo) );
SetWRefCon( window, (long) mpTaskInfo );
for ( mpTaskInfo->count = 0 ; mpTaskInfo->count < kMaxFoldersToWatch ; mpTaskInfo->count++ )
{
GetControlCString( window, 'STxt', mpTaskInfo->count, mpTaskInfo->path[mpTaskInfo->count] ); // This code pretty much just reads back the strings we set above
if ( mpTaskInfo->path[mpTaskInfo->count][0] == '\0' ) break;
// We initialize a number of values which are not be safe to retrieve from an MP thread.
GetControlBySigAndID( window, 'Date', mpTaskInfo->count, &mpTaskInfo->mpControlInfo[mpTaskInfo->count].dateControl );
GetControlBySigAndID( window, 'STxt', mpTaskInfo->count, &control );
mpTaskInfo->mpControlInfo[mpTaskInfo->count].eventTarget = GetControlEventTarget( control );
}
if ( mpTaskInfo->count < 1 )
{
DisposePtr( (Ptr) mpTaskInfo );
goto Bail;
}
// Create our MP thread and pass in mpTaskInfo. MyMPTask is responsible for watching the passed in directories, and posting notifications of changes.
err = MPCreateTask( MyMPTask, (void *) mpTaskInfo, 0, NULL, 0, 0, kNilOptions, &mpTaskID );
if ( err != noErr ) // Alert if an error occured
{
CreateStandardAlert( kAlertStopAlert, CFSTR("MPCreateTask returned an error! Will not create window."), NULL, NULL, &alertDialog );
RunStandardAlert( alertDialog, NULL, NULL );
goto Bail;
}
ShowWindow( window );
Bail:
return;
}
/*****************************************************
*
* Do_NewWindowFromAPI(outWindow)
*
* Purpose: called to create a new window using only API calls fron MacWindows.h, Controls.h, and HIView.h
*
* Notes: called by Do_NewWindow()
*
* Inputs: outWindow - if not NULL, the address where to return the WindowRef
* - if not NULL, the callee will have to ShowWindow
*
* Returns: OSStatus - error code (0 == no error)
*/
static OSStatus Do_NewWindowFromAPI(WindowRef * outWindow)
{
WindowRef aWindowRef = NULL;
CFStringRef theTitle = NULL;
OSStatus status;
// Create a window
Rect bounds = {0, 0, 360, 480};
status = CreateNewWindow(kDocumentWindowClass, kWindowStandardFloatingAttributes | kWindowStandardHandlerAttribute | kWindowCompositingAttribute | kWindowMetalAttribute, &bounds, &aWindowRef);
require_noerr(status, CreateNewWindow);
require(aWindowRef != NULL, CreateNewWindow);
status = RepositionWindow(aWindowRef, NULL, kWindowCascadeOnMainScreen);
require_noerr(status, RepositionWindow);
HIViewRef contentView;
status = HIViewFindByID(HIViewGetRoot(aWindowRef), kHIViewWindowContentID, &contentView);
require_noerr(status, HIViewFindByID);
ControlRef aControlRef;
Rect statBounds = {113, 20, 177, 460};
ControlFontStyleRec style = {kControlUseJustMask, 0, 0, 0, 0, teJustCenter};
status = CreateStaticTextControl(NULL, &statBounds, CFSTR("Click in the LittleArrows control above."), &style, &aControlRef);
require_noerr(status, CreateStaticTextControl);
HIViewID staticTextID = { 'STTC', 100 };
HIViewSetID(aControlRef, staticTextID);
status = HIViewAddSubview(contentView, aControlRef);
require_noerr(status, HIViewAddSubview);
Rect littleArrowBounds = {51, 234, 73, 247};
status = CreateLittleArrowsControl(NULL, &littleArrowBounds, 0, 0, 10, 1, &aControlRef);
require_noerr(status, CreateLittleArrowsControl);
status = HIViewAddSubview(contentView, aControlRef);
require_noerr(status, HIViewAddSubview);
SetControlAction(aControlRef, LittleArrowsControlAction);
EventTypeSpec eventTypeCVFC = {kEventClassControl, kEventControlValueFieldChanged};
status = HIViewInstallEventHandler(aControlRef, Handle_PostLittleArrowsClick, 1, &eventTypeCVFC, (void *)aControlRef, NULL);
require_noerr(status, CantInstallEventHandler);
Rect buttonBounds = {320, 390, 340, 460};
status = CreatePushButtonControl(NULL, &buttonBounds, CFSTR("OK"), &aControlRef);
require_noerr(status, CreatePushButtonControl);
status = SetControlCommandID(aControlRef, kHICommandOK);
require_noerr(status, SetControlCommandID);
status = HIViewAddSubview(contentView, aControlRef);
require_noerr(status, HIViewAddSubview);
status = SetWindowDefaultButton(aWindowRef, aControlRef);
require_noerr(status, SetWindowDefaultButton);
WindowDataPtr wdr = (WindowDataPtr)calloc(1, sizeof(WindowDataRec));
require(wdr != NULL, CantAllocateWindowData);
SetWRefCon(aWindowRef, (long)wdr);
theTitle = CFStringCreateWithFormat(NULL, NULL, CFSTR("LittleArrowsShowcase Window From API #%ld"), ++gWindowCount);
require(theTitle != NULL, CFStringCreateWithFormat);
status = SetWindowTitleWithCFString(aWindowRef, theTitle);
require_noerr(status, SetWindowTitleWithCFString);
EventTypeSpec eventTypeCP = {kEventClassCommand, kEventCommandProcess};
status = InstallWindowEventHandler(aWindowRef, Handle_WindowCommandProcess, 1, &eventTypeCP, (void *)aWindowRef, NULL);
require_noerr(status, CantInstallEventHandler);
EventTypeSpec eventTypeWC = {kEventClassWindow, kEventWindowClosed};
status = InstallWindowEventHandler(aWindowRef, Handle_WindowIsClosing, 1, &eventTypeWC, (void *)aWindowRef, NULL);
require_noerr(status, CantInstallEventHandler);
// The window was created hidden so show it if the outWindow parameter is NULL,
// if it's not, it will be the responsibility of the caller to show it.
if (outWindow == NULL)
ShowWindow(aWindowRef);
SetWindowModified(aWindowRef, false);
CantInstallEventHandler:
SetWindowTitleWithCFString:
CFStringCreateWithFormat:
if (theTitle != NULL)
CFRelease(theTitle);
CantAllocateWindowData:
SetWindowDefaultButton:
SetControlCommandID:
CreatePushButtonControl:
CreateLittleArrowsControl:
HIViewAddSubview:
CreateStaticTextControl:
HIViewFindByID:
RepositionWindow:
CreateNewWindow:
if (outWindow != NULL)
*outWindow = aWindowRef;
return status;
} // Do_NewWindowFromAPI
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();
}
