void redraw_windows(void)
{
// center
select_clear();
main_wind_center_position_in_map();
// some defaults
magnify_factor=magnify_factor_default;
main_wind_set_view(vw_3_panel);
main_wind_set_perspective(ps_perspective);
// redraw
main_wind_tool_default();
menu_fix_enable();
main_wind_tool_fix_enable();
SelectWindow(mainwind);
main_wind_draw();
texture_palette_reset();
}
void doMouseDown(EventRecord *eventStrucPtr)
{
WindowRef windowRef;
WindowPartCode partCode, zoomPart;
BitMap screenBits;
Rect constraintRect, mainScreenRect;
Point standardStateHeightAndWidth;
long newSize;
partCode = FindWindow(eventStrucPtr->where,&windowRef);
switch(partCode)
{
case inMenuBar:
break;
case inContent:
if(windowRef != FrontWindow())
SelectWindow(windowRef);
else
doInContent(eventStrucPtr,windowRef);
break;
case inDrag:
DragWindow(windowRef,eventStrucPtr->where,NULL);
break;
case inGoAway:
break;
case inGrow:
constraintRect.top = 75;
constraintRect.left = 250;
constraintRect.bottom = constraintRect.right = 32767;
newSize = GrowWindow(windowRef,eventStrucPtr->where,&constraintRect);
if (newSize != 0)
SizeWindow(windowRef,LoWord(newSize),HiWord(newSize),true);
window_adjust_scrollbars(windowRef);
window_invalidate(windowRef);
break;
case inZoomIn:
case inZoomOut:
mainScreenRect = GetQDGlobalsScreenBits(&screenBits)->bounds;
standardStateHeightAndWidth.v = mainScreenRect.bottom;
standardStateHeightAndWidth.h = mainScreenRect.right;
if(IsWindowInStandardState(windowRef,&standardStateHeightAndWidth,NULL))
zoomPart = inZoomIn;
else
zoomPart = inZoomOut;
if(TrackBox(windowRef,eventStrucPtr->where,partCode))
{
ZoomWindowIdeal(windowRef,zoomPart,&standardStateHeightAndWidth);
window_adjust_scrollbars(windowRef);
}
break;
}
}
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 INT GraphOpen (GRAPH_WINDOW *gw, const char *title, short h, short v, short dh, short dv)
{
WindowPtr MacWin;
GrafPtr myPort;
PaletteHandle myPalette;
Str255 pstr;
MacWin = MAC_WIN(gw);
/* read in resources */
if (GetNewCWindow(GRAPH_RSRC_ID,(Ptr) MacWin,(WindowPtr) -1)==NULL)
return (1);
myPalette = GetNewPalette(PALETTE_RSRC_ID);
SetPalette(MacWin,myPalette,FALSE);
/* move and size window */
myPort = (GrafPtr) MacWin;
SetPort(myPort);
MoveWindow(MacWin,h,v,false);
SizeWindow(MacWin,dh,dv,false);
CopyCStringToPascal(title,pstr);
SetWTitle(MacWin,pstr);
ShowWindow(MacWin);
SelectWindow(MacWin);
DrawGrowIcon(MacWin);
return (0);
}
StateLayer::StateLayer(ViewLayer& view)
{
mappings[&view] = this;
_view = &view;
_project = new Project();
assembly::Assembly& assembly = _project->getAssembly();
_selectionModel = new SelectionModel();
_view->constructShots(assembly);
_view->populateConceptSelectCombo(assembly.getOntology());
_view->rendererBoundsChanged();
scenegraph::Shot& shot = view.getRootShot();
_renderingState = new RenderingState(shot);
_defaultPerspective = new SearchPerspective();
_currentPerspective = _defaultPerspective;
_currentInteractionState = new SelectState(*_renderingState);
_currentPerspective->activate(*_view);
WindowRef window = _view->getWindow();
ActivateWindow(window, true);
SetPortWindowPort(window);
ShowWindow(window);
SelectWindow(window);
ActivateWindow(window, true);
_selectedLayer = 0;
_creationType = 0;
}
void PreferencesDialog::show()
{
backupDataBase();
initDialog();
ShowWindow(preferencesWindow);
SelectWindow(preferencesWindow);
}
void App_Prefs::show()
{
if ( !prefs_window )
prefs_window.reset( new Prefs_Window );
ShowWindow( prefs_window->window() );
SelectWindow( prefs_window->window() );
}
void MacIdle(void)
{
extern logical anywarns;
static long time = 0;
EventRecord myEvent;
WindowPtr whichWindow;
#if TARGET_API_MAC_CARBON
Rect tempRect;
#endif
char theChar;
if (TickCount()<time) return;
if (mac_quit_now) {
anywarns = FALSE; /* kludge so that window doesn't sit around */
my_exit(1);
}
#if !TARGET_API_MAC_CARBON
SystemTask();
#endif
if (WaitNextEvent(everyEvent, &myEvent, 1, nil)) {
if (!SIOUXHandleOneEvent(&myEvent)) switch (myEvent.what) {
case mouseDown:
switch (FindWindow(myEvent.where,&whichWindow)) {
case inMenuBar:
MenuSelect(myEvent.where);
break;
#if !TARGET_API_MAC_CARBON
case inSysWindow:
SystemClick(&myEvent,whichWindow);
break;
#endif
case inContent:
SelectWindow(whichWindow);
break;
case inDrag:
#if TARGET_API_MAC_CARBON
GetRegionBounds(GetGrayRgn(),&tempRect);
DragWindow(whichWindow,myEvent.where,&tempRect);
#else
DragWindow(whichWindow,myEvent.where,&qd.screenBits.bounds);
#endif
break;
}
break;
case keyDown:
theChar = myEvent.message & charCodeMask;
break;
case updateEvt:
BeginUpdate((WindowPtr) myEvent.message);
EndUpdate((WindowPtr) myEvent.message);
break;
}
}
time=TickCount()+20;
}
void NCarbonWindowManager::BringWindowToFront(NWindow* window)
{
WindowRef macWindow = GetMacWindowFromNWindow(window);
// mac activate events handle the rest
BringToFront(macWindow);
SelectWindow(macWindow);
}
void doEventLoop()
{
EventRecord event;
WindowPtr window;
short clickArea;
Rect screenRect;
RgnHandle rgnHandle = NewRgn();
for (;;)
{
if (WaitNextEvent( everyEvent, &event, 0, nil ))
{
if (event.what == mouseDown)
{
clickArea = FindWindow( event.where, &window );
if (clickArea == inDrag)
{
//screenRect = (**GetGrayRgn ()).rgnBBox;
GetRegionBounds(GetGrayRgn(), &screenRect);
DragWindow( window, event.where, &screenRect );
}
else if (clickArea == inContent)
{
if (window != FrontWindow())
SelectWindow( window );
}
else if (clickArea == inGoAway)
if (TrackGoAway( window, event.where ))
return;
}
else if (event.what == updateEvt)
{
window = (WindowPtr)event.message;
//SetPort( window );
SetPortWindowPort( window );
BeginUpdate( window );
drawPixelImageData();
EndUpdate( window );
QDFlushPortBuffer(GetWindowPort(window), GetPortVisibleRegion(GetWindowPort(window), rgnHandle));
}
else if (event.what == activateEvt)
{
/*if (event.modifiers & activeFlag) {
window = (WindowPtr)event.message;
SetPortWindowPort(window);
drawPixelImageData();
QDFlushPortBuffer(GetWindowPort(window), GetPortVisibleRegion(GetWindowPort(window), rgnHandle));
}*/
/*if (event.modifiers & activeFlag)
PostEvent(updateEvt, (unsigned long)gWindow);*/
}
}
}
DisposeRgn(rgnHandle);
}
static void ProcessEvent ()
{
EventRecord myEvent;
WindowPtr whichWindow;
/* do system tasks */
SystemTask();
/* get event */
if (GetNextEvent(everyEvent,&myEvent))
{
switch (myEvent.what)
{
case mouseDown :
switch (FindWindow(myEvent.where,&whichWindow))
{
case inSysWindow :
SystemClick(&myEvent,whichWindow);
break;
case inMenuBar :
DoCommand(MenuSelect(myEvent.where));
break;
case inDrag :
DragWindow(whichWindow,myEvent.where,&dragRect);
break;
case inContent :
if (whichWindow!=FrontWindow())
SelectWindow(whichWindow);
else
{
/*DoContentClick(whichWindow,&myEvent);*/
}
break;
case inGrow :
/*DoGrowWindow(whichWindow,&myEvent);*/
break;
case inGoAway :
/*DoGoAway(whichWindow,&myEvent);*/
break;
}
break; /* mouseDown */
case keyDown :
case autoKey :
DoKey(&myEvent);
break;
case activateEvt :
/*DoActivate(&myEvent);*/
break;
case updateEvt :
whichWindow = (WindowPtr) myEvent.message;
/*DoUpdate(whichWindow,&myEvent);*/
break;
}
}
} /* ProcessEvent */
OSStatus OpenFileDialog(
OSType applicationSignature,
short numTypes,
OSType typeList[],
NavDialogRef *outDialog )
{
OSStatus theErr = noErr;
if ( gOpenFileDialog == NULL )
{
NavDialogCreationOptions dialogOptions;
NavTypeListHandle openList = NULL;
NavGetDefaultDialogCreationOptions( &dialogOptions );
dialogOptions.modality = kWindowModalityNone;
dialogOptions.clientName = CFStringCreateWithPascalString( NULL, LMGetCurApName(), GetApplicationTextEncoding());
openList = (NavTypeListHandle)NewOpenHandle( applicationSignature, numTypes, typeList );
theErr = NavCreateGetFileDialog( &dialogOptions, openList, GetPrivateEventUPP(), NULL, NULL, NULL, &gOpenFileDialog );
if ( theErr == noErr )
{
theErr = NavDialogRun( gOpenFileDialog );
if ( theErr != noErr )
{
NavDialogDispose( gOpenFileDialog );
gOpenFileDialog = NULL;
}
}
if (openList != NULL)
{
DisposeHandle((Handle)openList);
}
if ( dialogOptions.clientName != NULL )
{
CFRelease( dialogOptions.clientName );
}
}
else
{
if ( NavDialogGetWindow( gOpenFileDialog ) != NULL )
{
SelectWindow( NavDialogGetWindow( gOpenFileDialog ));
}
}
if ( outDialog != NULL )
{
*outDialog = gOpenFileDialog;
}
return NULL;
}
void doEventLoop()
{
EventRecord anEvent;
WindowPtr evtWind;
short clickArea;
Rect screenRect;
Point thePoint;
Rect zoomFrom, zoomTo;
zoomFrom.top = zoomTo.top = -1;
while (!gDone)
{
if (WaitNextEvent( everyEvent, &anEvent, 0, nil ))
{
if (anEvent.what == mouseDown)
{
clickArea = FindWindow( anEvent.where, &evtWind );
if (clickArea == inDrag)
{
GetRegionBounds( GetGrayRgn(), &screenRect );
DragWindow( evtWind, anEvent.where, &screenRect );
}
else if (clickArea == inContent)
{
if (evtWind != FrontWindow())
SelectWindow( evtWind );
else
{
thePoint = anEvent.where;
GlobalToLocal( &thePoint );
//Handle click in window content here
GetRect(&zoomFrom, &zoomTo);
}
}
else if (clickArea == inGoAway)
if (TrackGoAway( evtWind, anEvent.where ))
gDone = true;
}
else if (anEvent.what == updateEvt)
{
evtWind = (WindowPtr)anEvent.message;
SetPortWindowPort( evtWind );
BeginUpdate( evtWind );
//Call Draw Function here....
if (zoomFrom.top != -1)
FrameRect(&zoomFrom);
if (zoomTo.top != -1)
FrameRect(&zoomTo);
EndUpdate (evtWind);
}
}
}
}
static int CreateApplicationWindow (AWindowRecord *wr, char *fname, short h, short v, short dh, short dv)
{
Rect r;
GrafPtr myPort;
PaletteHandle myPalette;
char name[80];
/* init AWindowRecord */
wr->theWindow = (WindowPtr) wr;
/* read in resources */
if (GetNewCWindow(appWinId,(Ptr)wr,(WindowPtr) -1)==NULL)
{
return(1);
}
myPalette = GetNewPalette(defaultPaletteId);
SetPalette(wr->theWindow,myPalette,false);
/* move and size window */
myPort = (GrafPtr) wr->theWindow;
SetPort(myPort);
MoveWindow(wr->theWindow,h,v,false);
SizeWindow(wr->theWindow,dh+15,dv+15,false);
strcpy(name,fname);
SetWTitle(wr->theWindow,c2pstr(name));
ShowWindow(wr->theWindow);
SelectWindow(wr->theWindow);
DrawGrowIcon(wr->theWindow);
r = myPort->portRect;
TextFont(kFontIDMonaco);
/* get the scroll bars */
wr->vScrollBar = GetNewControl(vScrollBarId,wr->theWindow);
wr->hScrollBar = GetNewControl(hScrollBarId,wr->theWindow);
/* set correct size of the scroll bars */
MoveControl(wr->vScrollBar,r.right-15,-1);
SizeControl(wr->vScrollBar,16,r.bottom-13);
SetControlMinimum(wr->vScrollBar,0);
SetControlMaximum(wr->vScrollBar,0);
SetControlValue(wr->vScrollBar,0);
ShowControl(wr->vScrollBar);
MoveControl(wr->hScrollBar,-1,r.bottom-15);
SizeControl(wr->hScrollBar,r.right-13,16);
SetControlMinimum(wr->hScrollBar,0);
SetControlMaximum(wr->hScrollBar,0);
SetControlValue(wr->hScrollBar,0);
ShowControl(wr->hScrollBar);
DrawControls(wr->theWindow);
SetRect(&(wr->usableRect),0,0,dh,dv);
return(0);
}
void QuartzWindow::activate() {
WindowPtr wp = my_window();
if (!IsWindowVisible(wp))
ShowWindow(wp);
SelectWindow(wp);
OSStatus e = SetUserFocusWindow(wp);
if (e) lprintf("SetUserFocus %d\n", e);
e = ActivateWindow(wp, true);
if (e) lprintf("ActivateWindow %d\n", e);
}
void GBWindow::Show() {
if ( ! visible && view->NeedsResize() )
ResizeSelf();
#if MAC
ShowWindow(window);
SelectWindow(window);
#elif WINDOWS
ShowWindow(win, SW_SHOWNORMAL);
#endif
visible = true;
}
bool Sys_CreateWindow(const char *title, unsigned int w, unsigned int h, bool fs) {
OSErr result;
ProcessSerialNumber psn;
windowRect.top = 100;
windowRect.left = 100;
windowRect.bottom = windowRect.top + h;
windowRect.right = windowRect.left + w;
g_Window.height = h;
g_Window.width = w;
g_Window.fs = fs;
result = CreateNewWindow(kDocumentWindowClass,
(kWindowStandardDocumentAttributes |
kWindowInWindowMenuAttribute |
kWindowStandardHandlerAttribute) &
~kWindowResizableAttribute,
&windowRect, &g_Window.window);
if (result != noErr)
return false;
SetWindowTitleWithCFString(
g_Window.window,
CFStringCreateWithCString(0, title, CFStringGetSystemEncoding())
);
result = GetCurrentProcess(&psn);
if (result == noErr) {
TransformProcessType(&psn, kProcessTransformToForegroundApplication);
SetFrontProcess(&psn);
}
ShowWindow(g_Window.window);
SelectWindow(g_Window.window);
g_Window.glctx = createContext(g_Window.window);
if (!g_Window.glctx)
return false;
/*
static EventTypeSpec suspendResume[2] = {{kEventClassApplication, kEventAppActivated},
{kEventClassApplication, kEventAppDeactivated}};
InstallApplicationEventHandler(NewEventHandlerUPP(suspendResumeHandler), 2,
suspendResume, &g_Window.window, NULL);
*/
AEInstallEventHandler(kCoreEventClass, kAEQuitApplication,
NewAEEventHandlerUPP(quitEventHandler), 0, false);
return true;
}
/*
* Bring all windows in main windowgroup to frontmost layer
* we have to handle this explicitly because of Quartz behaviour
* when layering windowgroups
*/
void CARBON_GUI::bringToFront() {
bool anyChannel=false;
for ( int i = 0;i < MAX_CHANNELS;i++) {
if(channel[i]) {
anyChannel=true;
SendWindowGroupBehind(channel[i]->faderGroup,mainGroup);
}
}
if(!anyChannel) BringToFront(window);
SelectWindow(window);
OSStatus err = SetRootMenu(mainMenu);
if(err != noErr) msg->error("Can't set MenuBar!!");
}
void HandleMouseDown(EventRecord *event)
{
short part;
WindowRef window;
MacWindow *macwin;
Rect growRect={100,100,32000,32000};
long size;
part=FindWindow(event->where, &window);
macwin = (MacWindow*)GetWRefCon(window);
switch(part)
{
case inMenuBar:
mac_AdjustMenus(event->modifiers);
mac_HandleMenuSelect(MenuSelect(event->where), event->modifiers);
HiliteMenu(0);
break;
case inContent:
SetPortWindowPort(window);
SelectWindow(window);
GlobalToLocal(&event->where);
if(macwin) macwin->click(event->where, event->modifiers);
break;
case inDrag:
DragWindow(window, event->where, &qd.screenBits.bounds);
break;
case inGrow:
SetPortWindowPort(window);
size=GrowWindow(window, event->where, &growRect);
if( size )
{
SizeWindow(window, size&0x0000FFFF, size>>16, 0);
EraseRect(&GetWindowPort(window)->portRect);
InvalRect(&GetWindowPort(window)->portRect);
if( macwin ) macwin->message(MW_GROW, size);
}
break;
case inGoAway:
if( TrackGoAway(window, event->where) ){
if( macwin ){
macwin->goaway(macwin);
}
}
break;
//case inZoomIn:
//case inZoomOut:
// break;
}
}
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 doEventLoop()
{
EventRecord anEvent;
WindowPtr evtWind;
short clickArea;
Rect screenRect;
while (!gDone)
{
if (WaitNextEvent( everyEvent, &anEvent, 0, nil ))
{
if (anEvent.what == mouseDown)
{
clickArea = FindWindow( anEvent.where, &evtWind );
if (clickArea == inMenuBar)
handleMenuSelection(MenuSelect(anEvent.where));
else if (clickArea == inDrag)
{
//screenRect = (**GetGrayRgn ()).rgnBBox;
GetRegionBounds(GetGrayRgn(), &screenRect);
DragWindow( evtWind, anEvent.where, &screenRect );
}
else if (clickArea == inContent)
{
if (evtWind != FrontWindow())
SelectWindow( evtWind );
}
else if (clickArea == inGoAway)
if (TrackGoAway( evtWind, anEvent.where ))
gDone = true;
}
else if (anEvent.what == updateEvt)
{
evtWind = (WindowPtr)anEvent.message;
//SetPort( evtWind );
SetPortWindowPort( evtWind );
BeginUpdate( evtWind );
drawImage( evtWind );
EndUpdate (evtWind);
}
else if (anEvent.what == autoKey || anEvent.what == keyDown)
handleKeyPress(&anEvent);
}
}
}
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);
}
}
P2(PUBLIC pascal trap, void, SystemClick, EventRecord *, evp, WindowPtr, wp)
{
Point p;
LONGINT pointaslong, val;
Rect bounds;
LONGINT templ;
if (wp) {
p.h = CW(evp->where.h);
p.v = CW(evp->where.v);
if (PtInRgn (p, WINDOW_STRUCT_REGION (wp)))
{
pointaslong = ((LONGINT)p.v << 16)|(unsigned short)p.h;
val = WINDCALL((WindowPtr) wp, wHit, pointaslong);
switch (val) {
case wInContent:
if (WINDOW_HILITED_X (wp))
{
templ = (LONGINT) (long) RM(evp);
Control (WINDOW_KIND (wp), accEvent, (Ptr) &templ);
} else
SelectWindow(wp);
break;
case wInDrag:
bounds.top = CW (CW (MBarHeight) + 4);
bounds.left = CW (CW (GD_BOUNDS (MR (TheGDevice)).left) + 4);
bounds.bottom = CW (CW (GD_BOUNDS (MR (TheGDevice)).bottom) - 4);
bounds.right = CW (CW (GD_BOUNDS (MR (TheGDevice)).right) - 4);
DragWindow(wp, p, &bounds);
break;
case wInGoAway:
if (TrackGoAway(wp, p))
CloseDeskAcc (WINDOW_KIND (wp));
break;
}
} else {
if (DeskHook) {
ROMlib_hook(desk_deskhooknumber);
EM_D0 = -1;
EM_A0 = (LONGINT) (long) US_TO_SYN68K(evp);
CALL_EMULATOR((syn68k_addr_t) (long) CL((long) DeskHook));
}
}
}
}
static void handlemouse (EventRecord *ev) {
short part;
WindowPtr w;
part = FindWindow ((*ev).where, &w);
if (w != nil)
if (w != FrontWindow ()) { /*just like all other Mac programs*/
SelectWindow (w);
return; /*the mouse click is consumed by the bringtofront operation*/
}
switch (part) {
case inMenuBar:
handlemenu (MenuSelect ((*ev).where));
break;
case inSysWindow:
SystemClick (ev, w);
break;
case inDrag:
handledrag (ev, w);
break;
case inContent:
EnableSharedMenus (false);
while (StillDown ())
;
EnableSharedMenus (true);
break;
} /*switch*/
} /*handlemouse*/
void doEvents(EventRecord *eventStrucPtr)
{
WindowRef windowRef;
if (eventStrucPtr->what == mouseDown &&
FindWindow(eventStrucPtr->where,&windowRef) == inMenuBar)
SelectWindow(SIOUXTextWindow->window);
SIOUXSettings.standalone = true;
if (SIOUXHandleOneEvent(eventStrucPtr))
{
if (SIOUXQuitting)
gDone = true;
SIOUXSettings.standalone = false;
return;
}
SIOUXSettings.standalone = false;
switch(eventStrucPtr->what)
{
case kHighLevelEvent:
AEProcessAppleEvent(eventStrucPtr);
break;
case mouseDown:
doMouseDown(eventStrucPtr);
break;
case keyDown:
case autoKey:
break;
case updateEvt:
doUpdate(eventStrucPtr);
break;
case activateEvt:
DrawGrowIcon(windowRef);
break;
case osEvt:
doOSEvent(eventStrucPtr);
break;
}
}
void Macros( void)
{
DialogPtr dtemp;
short dItem;
short i;
Rect dBox;
Str255 temp;
Handle MacString[10], rubbish;
setLastCursor(theCursors[normcurs]);
if (TelInfo->macrosModeless) {
SelectWindow(TelInfo->macrosModeless);
return;
}
dtemp=GetNewMyDialog( MacroDLOG, NULL, kInFront, (void *)ThirdCenterDialog);
SetDialogDefaultItem(dtemp, 1);
SetDialogCancelItem(dtemp, 2);
SetDialogTracksCursor(dtemp, 1);
dialogPane = 0; // start with Command-[0-9]
// RAB BetterTelnet 2.0b5 - fix cancel button so it works again
oldMacros = TelInfo->newMacros.handle;
HandToHand(&oldMacros);
oldMacroIndexes = TelInfo->newMacros;
// now fix the strings
for (i=0; i<10; i++) {
GetIndString(temp, 7100, i + (10 * dialogPane) + 1);
GetDialogItem(dtemp, i+3, &dItem, &rubbish, &dBox);
if (!temp[0]) { HideDialogItem(dtemp, i+13); HideDialogItem(dtemp, i+3); }
else { ShowDialogItem(dtemp, i+13); ShowDialogItem(dtemp, i+3); }
SetDialogItemText(rubbish, temp);
}
for (i=0; i<10; i++) {
getmacro(&TelInfo->newMacros, i, (char *) &temp, 256); /* BYU LSC */
c2pstr((char *)temp); /* BYU LSC */
GetDialogItem( dtemp, i+13, &dItem, &MacString[i], &dBox);
SetDialogItemText( MacString[i], temp );
}
TelInfo->macrosModeless = dtemp;
}
bool AquaGui::run()
{
double interval = _interval / 1000.0;
OSStatus ret = InstallEventLoopTimer (GetMainEventLoop(), 0, interval,
DoAdvanceMovie, this, _advance_timer);
if (ret != noErr) {
return false;
}
RepositionWindow(myWindow, NULL, kWindowCascadeOnMainScreen);
SelectWindow(myWindow);
ShowWindow(myWindow);
SetWindowModified(myWindow, false);
RunApplicationEventLoop();
return true;
}
long wait ()
{
EventRecord event;
WindowPtr window;
MenuInfo **m;
long r;
Str255 tmp;
/* wait for an event */
WaitNextEvent (everyEvent,&event,(long) 6,NIL);
switch (event.what) { /* got one -- what is it? */
case mouseDown: /* mouse clicked */
switch (FindWindow (event.where,&window)) {
case inMenuBar: /* menu bar item? */
/* yes, interesting event? */
if (r = MenuSelect (event.where)) {
/* round-about test for Apple menu */
if ((*(m = GetMHandle (HiWord (r))))->menuData[1] == appleMark) {
/* get desk accessory name */
GetItem (m,LoWord (r),tmp);
OpenDeskAcc (tmp); /* fire it up */
SetPort (window); /* put us back at our window */
}
else SysBeep (60); /* the fool forgot to disable it! */
}
HiliteMenu (0); /* unhighlight it */
break;
case inContent: /* some window was selected */
if (window != FrontWindow ()) SelectWindow (window);
break;
default: /* ignore all others */
break;
}
break;
case keyDown: /* key hit - if COMMAND/. then punt */
if ((event.modifiers & cmdKey) && (event.message & charCodeMask) == '.')
return NIL;
break;
default: /* ignore all others */
break;
}
return T; /* try wait test again */
}
/*****************************************************************************
* Function
* DESCRIPTION:
* Redraws or clears the colon.
*****************************************************************************/
bool DataPointTime::RedrawColon()
{
if (mVisible)
{
int x = 0;
int minutes = mTime.GetTime(MINUTES);
char sz_time[10];
if (mFormat == DATETIME_FORMAT_MDY_AMPM)// timeformat using am/pm
{
bool isAm;
int hoursOffset;
GetAs12HourClock(&isAm, &hoursOffset);
sprintf(sz_time, ":%02d %s", minutes, isAm ? "am" : "pm");
}
else
{
sprintf(sz_time, ":%02d", minutes);
}
SelectWindow();
GUI_SetColor(mColour);
GUI_SetBkColor(mBackgroundColour);
GUI_SetFont(GetFont());
x = GetWidth() - GUI_GetStringDistX(sz_time);
if (mShowColon)
{
GUI_DispStringAt(":", x, 2);
mLastColonPosition = x;
}
else if (mLastColonPosition == x)
{
GUI_ClearRect(x, 0, x + 1, GetHeight() - 1);
}
Validate();
}
return true;
}
P1(PUBLIC pascal trap, INTEGER, OpenDeskAcc, Str255, acc) /* IMI-440 */
{
INTEGER retval;
DCtlHandle dctlh;
WindowPtr wp;
if (EqualString (acc, about_box_menu_name_pstr, TRUE, TRUE))
{
do_about_box ();
retval = 0;
goto done;
}
if (OpenDriver(acc, &retval) == noErr) {
retval = CW(retval);
dctlh = GetDCtlEntry(retval);
if (dctlh)
{
wp = HxP(dctlh, dCtlWindow);
if (wp)
{
ShowWindow(wp);
SelectWindow(wp);
}
}
}
done:
SEvtEnb = TRUE;
return retval;
}
