// --------------------------------------------------------------------------------------
static void initialize(void)
{
OSStatus status;
IBNibRef nib;
OSErr error;
RegisterAppearanceClient();
status = CreateNibReference(CFSTR("ExamplePrefs"), &nib);
if (status != noErr)
ExitToShell();
status = SetMenuBarFromNib(nib, CFSTR("MenuBar"));
if (status != noErr)
ExitToShell();
DisposeNibReference(nib);
DrawMenuBar();
// do non time sensitive initialization after we get the application event loop going
gOpenAppAEHandler = NewAEEventHandlerUPP(openApplicationAEHandler);
error = AEInstallEventHandler(kCoreEventClass, kAEOpenApplication, gOpenAppAEHandler, 0,
false);
if (error != noErr)
ExitToShell();
/* If we supported them, we would install open documents and print documents
handlers here and we would do most of the same initialization stuff that we
do in the open application handler */
}
/* destructor for the CARBON_GUI class
* here we destroy all other used objects and
*/
CARBON_GUI::~CARBON_GUI()
{
/* Destroy used objects */
delete streamHandler;
delete playlistManager;
delete aboutWindow;
pthread_mutex_destroy(&_statusLock);
if(msgList) {
while(msgList->len()) {
Entry *e = msgList->begin();
void *val = e->get_value();
if(val)
free(val);
delete e;
}
delete msgList;
}
/* delete all input channels */
for (int i=0;i<MAX_CHANNELS;i++)
if(channel[i]) delete channel[i];
DisposeWindow(statusWindow);
DisposeWindow(vumeterWindow);
DisposeMenu(mainMenu);
// We don't need the nib reference anymore.
DisposeNibReference(nibRef);
}
TabbedWindow::TabbedWindow( void )
{
OSStatus status;
IBNibRef nibRef;
fWindowRef = NULL;
static const ControlID tabControlID =
{ kMasterTabControlSignature, kMasterTabControlID };
// Create a Nib reference passing the name of the nib file (without the .nib
// extension) CreateNibReference only searches into the application bundle.
status = CreateNibReference( CFSTR("main"), &nibRef );
require_noerr( status, TabbedWindow_err );
// Then create a window & set menubar based on Nib.
status = CreateWindowFromNib( nibRef, CFSTR("MainWindow"), &fWindowRef );
require_noerr( status, TabbedWindow_err );
status = SetMenuBarFromNib( nibRef, CFSTR( "MenuBar" ) );
require_noerr( status, TabbedWindow_err );
// finsihed with the nib reference
DisposeNibReference(nibRef);
// what events will this window handle?
status = this->RegisterWindowCarbonEventhandler();
require_noerr( status, TabbedWindow_err );
// start with current tab pane set to NULL.
fCurrentTabPane = NULL;
// start with all panes disabled
this->DisableAllPanes();
// Get a reference to the tab control in the window
status = GetControlByID( fWindowRef, &tabControlID, &fTabControlRef );
//check_noerr( status );
// put event handlers on it
status = InstallStandardEventHandler( GetControlEventTarget( fTabControlRef ) );
check_noerr( status );
// Switch to the tab content indicated by current value of the tab control
if( status == noErr )
status = this->SwitchTabPane( fTabControlRef );
// show the new window
ShowWindow( fWindowRef );
TabbedWindow_err:
#if DEBUG_ERROR_LOGS
if( status != noErr )
{
SysBeep(10);
std::cout << "Error in TabbedWindow constructor:" << status << std::endl;
}
#endif
return;
}
for_each(BumpTopCommand* option, ordered_context_menu_items) {
err = InsertMenuItemTextWithCFString(carbon_context_menu,
CFStringFromQString(option->name()),
menu_size, // MenuItemIndex inAfterItem
option->isSeparator() ? kMenuItemAttrSeparator : 0, // MenuItemAttributes inAttributes
0); // MenuCommand inCommandID
if (option->has_subcommands()) {
QStringList subcommand_names = option->subcommand_names(actors);
err = CreateNibReference(CFSTR("ContextMenu"), &nib_ref);
MenuRef carbon_context_sub_menu;
err = CreateMenuFromNib(nib_ref, CFSTR("ItemContextMenu"), &carbon_context_sub_menu);
err = ChangeMenuAttributes(carbon_context_sub_menu, kMenuAttrCondenseSeparators, NULL);
DisposeNibReference(nib_ref);
int sub_menu_size = 0;
for_each(QString subcommand, subcommand_names) {
err = InsertMenuItemTextWithCFString(carbon_context_sub_menu,
CFStringFromQString(subcommand),
sub_menu_size, // MenuItemIndex inAfterItem
subcommand == "" ? kMenuItemAttrSeparator : 0, // MenuItemAttributes inAttributes
0); // MenuCommand inCommandID
CGImageRef icon = option->iconForSubcommand(actors, sub_menu_size);
if (icon) {
err = SetMenuItemIconHandle (carbon_context_sub_menu,
sub_menu_size+1,
kMenuCGImageRefType,
(Handle) icon);
CGImageRelease(icon);
}
sub_menu_size++;
}
bool8 NPServerDialog (void)
{
OSStatus err;
IBNibRef nibRef;
npserver.dialogcancel = true;
err = CreateNibReference(kMacS9XCFString, &nibRef);
if (err == noErr)
{
WindowRef tWindowRef;
err = CreateWindowFromNib(nibRef, CFSTR("ClientList"), &tWindowRef);
if (err == noErr)
{
EventHandlerRef eref;
EventLoopTimerRef tref;
EventHandlerUPP eventUPP;
EventLoopTimerUPP timerUPP;
EventTypeSpec windowEvents[] = { { kEventClassCommand, kEventCommandProcess },
{ kEventClassCommand, kEventCommandUpdateStatus } };
HIViewRef ctl;
HIViewID cid = { 'Chse', 0 };
npserver.dialogprocess = kNPSDialogInit;
eventUPP = NewEventHandlerUPP(NPServerDialogEventHandler);
err = InstallWindowEventHandler(tWindowRef, eventUPP, GetEventTypeCount(windowEvents), windowEvents, (void *) tWindowRef, &eref);
timerUPP = NewEventLoopTimerUPP(NPServerDialogTimerHandler);
err = InstallEventLoopTimer(GetCurrentEventLoop(), 0.0f, 0.1f, timerUPP, (void *) tWindowRef, &tref);
HIViewFindByID(HIViewGetRoot(tWindowRef), cid, &ctl);
HIViewSetVisible(ctl, false);
MoveWindowPosition(tWindowRef, kWindowServer, false);
ShowWindow(tWindowRef);
err = RunAppModalLoopForWindow(tWindowRef);
HideWindow(tWindowRef);
SaveWindowPosition(tWindowRef, kWindowServer);
err = RemoveEventLoopTimer(tref);
DisposeEventLoopTimerUPP(timerUPP);
err = RemoveEventHandler(eref);
DisposeEventHandlerUPP(eventUPP);
CFRelease(tWindowRef);
}
DisposeNibReference(nibRef);
}
return (!npserver.dialogcancel);
}
int main(int argc, char* argv[])
{
IBNibRef nibRef;
WindowRef window;
HIViewRef textView;
OSStatus err;
// Create a Nib reference passing the name of the nib file (without the .nib extension)
// CreateNibReference only searches into the application bundle.
err = CreateNibReference(CFSTR("main"), &nibRef);
require_noerr( err, CantGetNibRef );
// Once the nib reference is created, set the menu bar. "MainMenu" is the name of the menu bar
// object. This name is set in InterfaceBuilder when the nib is created.
err = SetMenuBarFromNib(nibRef, CFSTR("MenuBar"));
require_noerr( err, CantSetMenuBar );
// Then create a window. "MainDocumentWindow" is the name of the window object. This name is set in
// InterfaceBuilder when the nib is created.
err = CreateWindowFromNib(nibRef, CFSTR("MainDocumentWindow"), &window);
require_noerr( err, CantCreateWindow );
// We don't need the nib reference anymore.
DisposeNibReference(nibRef);
// Make the window's content area transparent
err = MakeWindowTransparent(window);
require_noerr( err, CantMakeWindowTransparent );
// Get a reference to the TextView in the main window
err = HIViewFindByID(HIViewGetRoot(window), gTextViewID, &textView);
require_noerr( err, CantGetTextView );
// Install our default options in the TextView
err = MySetTextViewOptions(textView);
require_noerr( err, CantSetTextViewOptions );
// Make the TextView partially transparent
err = TextViewSetAlpha(textView, 0.25);
require_noerr( err, CantSetTextViewOptions );
// The window was created hidden so show it.
ShowWindow( window );
// Call the event loop
RunApplicationEventLoop();
CantSetTextViewOptions:
CantGetTextView:
CantMakeWindowTransparent:
CantCreateWindow:
CantSetMenuBar:
CantGetNibRef:
return err;
}
/*****************************************************
*
* main (argc, argv)
*
* Purpose: main program entry point
*
* Inputs: argc - the number of elements in the argv array
* argv - an array of pointers to the parameters to this application
*
* Returns: int - error code (0 == no error)
*/
int main(int argc, char* argv[])
{
OSStatus status;
// Can we run this particular demo application?
long response;
status = Gestalt(gestaltSystemVersion, &response);
Boolean ok = ((status == noErr) && (response >= 0x00001040));
if (!ok)
{
DialogRef theAlert;
CreateStandardAlert(kAlertStopAlert, CFSTR("Mac OS X 10.4 (minimum) is required for this application"), NULL, NULL, &theAlert);
RunStandardAlert(theAlert, NULL, NULL);
ExitToShell();
}
// Create a Nib reference passing the name of the nib file (without the .nib extension)
// CreateNibReference only searches into the application bundle.
IBNibRef nibRef;
status = CreateNibReference(CFSTR("main"), &nibRef);
require_noerr(status, CreateNibReference);
// Once the nib reference is created, set the menu bar. "MainMenu" is the name of the menu bar
// object. This name is set in InterfaceBuilder when the nib is created.
status = SetMenuBarFromNib(nibRef, CFSTR("MenuBar"));
require_noerr(status, SetMenuBarFromNib);
// We no longer need this Nib reference
DisposeNibReference(nibRef);
// Enabling Preferences menu item
EnableMenuCommand(NULL, kHICommandPreferences);
// Let's react to User's commands.
Install_AppleEventHandlers();
EventTypeSpec eventTypeCP = {kEventClassCommand, kEventCommandProcess};
status = InstallEventHandler(GetApplicationEventTarget(), Handle_CommandProcess, 1, &eventTypeCP, NULL, NULL);
require_noerr(status, InstallEventHandler);
EventTypeSpec eventTypeCUS = {kEventClassCommand, kEventCommandUpdateStatus};
status = InstallEventHandler(GetApplicationEventTarget(), Handle_CommandUpdateStatus, 1, &eventTypeCUS, NULL, NULL);
require_noerr(status, InstallEventHandler);
// Call the event loop
RunApplicationEventLoop();
InstallEventHandler:
SetMenuBarFromNib:
CreateNibReference:
return status;
} // main
void initSoundOpt( void ) {
OSStatus err;
err = CreateNibReference(CFSTR("np2"), &nibRef);
if (err ==noErr ) {
makeNibWindow (nibRef);
DisposeNibReference ( nibRef);
}
else {
return;
}
}
bool loadAboutWin()
{
IBNibRef nibFile;
OSStatus iResult;
EventTypeSpec pEvent;
g_lpfnAboutProc = NewEventHandlerUPP(aboutEvtHandler);
if (noErr != (iResult = CreateNibReference(CFSTR("AboutWin"), &nibFile)))
{
DisposeEventHandlerUPP(g_lpfnAboutProc);
fprintf(stderr, "loadAboutWin() - CreateNibReference(AboutWin) failed, returning %lu!\n", (unsigned long) iResult);
return false;
}
if (noErr != (iResult = CreateWindowFromNib(nibFile, CFSTR("FroggAboutWindow"), &g_refAboutWin)))
{
DisposeNibReference(nibFile);
DisposeEventHandlerUPP(g_lpfnAboutProc);
fprintf(stderr, "loadAboutWin() - CreateWindowFromNib(FroggAboutWindow) failed, returning %lu!\n", (unsigned long) iResult);
return false;
}
DisposeNibReference(nibFile);
pEvent.eventClass = kEventClassWindow;
pEvent.eventKind = kEventWindowClose;
if (noErr != (iResult = InstallWindowEventHandler(g_refAboutWin, g_lpfnAboutProc, 1, &pEvent, NULL, &g_refAboutHdlr)))
{
DisposeWindow(g_refAboutWin);
DisposeEventHandlerUPP(g_lpfnAboutProc);
fprintf(stderr, "loadAboutWin() - InstallWindowEventHandler() failed, returning %lu!\n", (unsigned long) iResult);
return false;
}
g_bLoaded = true;
return true;
}
int main(int argc, char* argv[])
{
IBNibRef nibRef;
OSStatus err;
InitCursor();
// check the correct BASS was loaded
if (HIWORD(BASS_GetVersion())!=BASSVERSION) {
Error("An incorrect version of BASS.DLL was loaded (2.4 is required)");
return 0;
}
// check the correct BASS_FX was loaded
if (HIWORD(BASS_FX_GetVersion())!=BASSVERSION) {
Error("An incorrect version of BASS_FX.DLL was loaded (2.4 is required)");
return 0;
}
// initialize default output device
if(!BASS_Init(-1,44100,0,NULL,NULL)) {
Error("Can't initialize device");
return 0;
}
// Create Window and Stuff
err = CreateNibReference(CFSTR("reverse"), &nibRef);
if (err) return err;
err = CreateWindowFromNib(nibRef, CFSTR("MainWindow"), &win);
if (err) return err;
DisposeNibReference(nibRef);
SetupControlHandler(10,kEventControlHit,OpenEventHandler);
SetControlAction(GetControl(11),NewControlActionUPP(VolEventHandler));
SetControlAction(GetControl(13),NewControlActionUPP(TempoEventHandler));
SetControlAction(GetControl(15),NewControlActionUPP(PosEventHandler));
SetupControlHandler(16,kEventControlHit,DirEventHandler);
EventLoopTimerRef timer;
InstallEventLoopTimer(GetCurrentEventLoop(),kEventDurationNoWait,kEventDurationSecond/2,TimerProc,0,&timer);
// The window was created hidden so show it.
ShowWindow(win);
// Call the event loop
RunApplicationEventLoop();
// Close output
BASS_Free();
return 0;
}
//-------------------------------------------------------------------------------------
// Prompt
//-------------------------------------------------------------------------------------
// Put up a modal panel and request some text.
//
CFStringRef
Prompt( CFStringRef inPrompt, CFStringRef inDefaultText )
{
IBNibRef nibRef;
OSStatus err;
WindowRef window;
EventTypeSpec kEvents[] = { { kEventClassCommand, kEventCommandProcess } };
PanelInfo info;
HIViewRef view;
info.window = window;
info.string = NULL;
err = CreateNibReference( CFSTR( "main" ), &nibRef );
require_noerr( err, CantGetNibRef );
err = CreateWindowFromNib( nibRef, CFSTR( "Prompt" ), &window );
require_noerr( err, CantCreateWindow );
DisposeNibReference( nibRef );
if ( inPrompt )
{
HIViewFindByID( HIViewGetRoot( window ), kPromptLabelID, &view );
SetControlData( view, 0, kControlStaticTextCFStringTag, sizeof( CFStringRef ), &inPrompt );
}
HIViewFindByID( HIViewGetRoot( window ), kTextFieldID, &view );
if ( inDefaultText )
SetControlData( view, 0, kControlEditTextCFStringTag, sizeof( CFStringRef ), &inDefaultText );
SetKeyboardFocus( window, view, kControlFocusNextPart );
InstallWindowEventHandler( window, InputPanelHandler, GetEventTypeCount( kEvents ),
kEvents, &info, NULL );
ShowWindow( window );
info.window = window;
RunAppModalLoopForWindow( window );
DisposeWindow( window );
CantCreateWindow:
CantGetNibRef:
return info.string;
}
int main( void )
{
OSErr err;
err = InitializeApplication();
if ( err != noErr ) goto Bail;
SendCommandProcessEvent( kHICommandNew ); // Send a kHICommandNew to ourselves to create a default new window
RunApplicationEventLoop();
Bail:
if ( g.mainNib != NULL ) DisposeNibReference( g.mainNib );
if ( g.mainBundle != NULL ) CFRelease( g.mainBundle );
return( noErr );
}
// Create a new demo window
OSStatus
NewWindow()
{
IBNibRef nibRef;
WindowRef window;
EventTypeSpec commandEventType = {kEventClassWindow, kEventWindowFocusAcquired};
OSStatus status = noErr;
// Create a Nib reference passing the name of the nib file (without the .nib extension)
// CreateNibReference only searches into the application bundle.
status = CreateNibReference(CFSTR("main"), &nibRef);
require_noerr( status, CantGetNibRef );
// Then create a window. "MainWindow" is the name of the window object. This name is set in
// InterfaceBuilder when the nib is created.
status = CreateWindowFromNib(nibRef, CFSTR("MainWindow"), &window);
require_noerr( status, CantCreateWindow );
// We don't need the nib reference anymore.
DisposeNibReference(nibRef);
// Let's customize the HITextView in that window
status = SetUpTheTextView( window );
check_noerr( status );
// The window was created hidden so show it.
ShowWindow( window );
// by default, focus the HITextView at start
status = TextViewFocusInWindow( window );
require_noerr( status, CantFocusTextView );
// set up the control state from the state of the text view
status = UpdateControlsFromTextViewWindow( window );
require_noerr( status, CantSetControlState );
// Install a handler to update the UI when this window comes to the front
status = InstallEventHandler(GetWindowEventTarget(window), NewEventHandlerUPP(WindowFocusAcquired), 1, &commandEventType, NULL, NULL);
require_noerr( status, CantInstallWindowEventHandler );
CantFocusTextView:
CantSetControlState:
CantInstallWindowEventHandler:
CantCreateWindow:
CantGetNibRef:
return status;
}
int main(int argc, char* argv[])
{
IBNibRef nibRef;
OSStatus err;
// check the correct BASS was loaded
if (HIWORD(BASS_GetVersion())!=BASSVERSION) {
Error("An incorrect version of BASS was loaded");
return 0;
}
// initialize default output device
if (!BASS_Init(-1,44100,0,NULL,NULL)) {
Error("Can't initialize device");
return 0;
}
BASS_SetConfig(BASS_CONFIG_NET_PLAYLIST,1); // enable playlist processing
BASS_SetConfig(BASS_CONFIG_NET_PREBUF,0); // minimize automatic pre-buffering, so we can do it (and display it) instead
BASS_SetConfigPtr(BASS_CONFIG_NET_PROXY,proxy); // setup proxy server location
// Create Window and stuff
err = CreateNibReference(CFSTR("netradio"), &nibRef);
if (err) return err;
err = CreateWindowFromNib(nibRef, CFSTR("Window"), &win);
if (err) return err;
DisposeNibReference(nibRef);
int a;
for (a=10;a<20;a++)
SetupControlHandler(a,kEventControlHit,RadioEventHandler);
SetupControlHandler(41,kEventControlHit,DirectEventHandler);
{
EventTypeSpec etype={'blah','blah'};
InstallApplicationEventHandler(NewEventHandlerUPP(CustomEventHandler),1,&etype,NULL,NULL);
}
ShowWindow(win);
RunApplicationEventLoop();
BASS_Free();
return 0;
}
//---------------------------------------------------------------------
// Creates one of our simple document windows and returns a ref to it.
//
WindowRef MyCreateNewDocumentWindow(void)
{
IBNibRef nib;
WindowRef window = NULL;
OSStatus status;
// Create one of our special main document windows
status = CreateNibReference(CFSTR("main"), &nib);
require_noerr( status, CantGetNIBRef );
status = CreateWindowFromNib(nib, CFSTR("MainDocumentWindow"), &window);
require_noerr( status, CantCreateWindow );
// Set its default options
status = MySetTextViewOptions(GetTextViewFromWindow(window));
check_noerr( status );
// Make the window transparent
status = MakeWindowTransparent(window);
check_noerr( status );
// Make the TextView partially transparent
status = TextViewSetAlpha(GetTextViewFromWindow(window), 0.25);
check_noerr( status );
// Initialize the window title and proxy icon
status = SetWindowTitleWithCFString(window, CFSTR("Untitled"));
check_noerr( status );
status = SetWindowProxyCreatorAndType(window, kUnknownType, kUnknownType, kOnSystemDisk);
check_noerr( status );
// Show the window
ShowWindow(window);
// Cleanup
CantGetViewRef:
CantCreateWindow:
DisposeNibReference(nib);
CantGetNIBRef:
return window;
}
// Create, show and run modally our dialog window
OSStatus CreateDialogWindow()
{
IBNibRef nibRef;
EventTypeSpec dialogSpec = {kEventClassCommand, kEventCommandProcess };
WindowRef dialogWindow;
EventHandlerUPP dialogUPP;
OSStatus err = noErr;
// Find the dialog nib
err = CreateNibReference(CFSTR("dialog"), &nibRef);
require_noerr( err, CantFindDialogNib );
// Load the window inside it
err = CreateWindowFromNib(nibRef, CFSTR("dialog"), &dialogWindow);
require_noerr( err, CantCreateDialogWindow );
// We don't need the nib reference anymore.
DisposeNibReference(nibRef);
// Install our event handler
dialogUPP = NewEventHandlerUPP (DialogWindowEventHandler);
err = InstallWindowEventHandler (dialogWindow, dialogUPP, 1, &dialogSpec, (void *) dialogWindow, NULL);
require_noerr( err, CantInstallDialogHandler );
// Show the window
ShowWindow( dialogWindow );
// Run modally
RunAppModalLoopForWindow(dialogWindow);
HideWindow(dialogWindow);
DisposeWindow(dialogWindow);
DisposeEventHandlerUPP(dialogUPP);
CantFindDialogNib:
CantCreateDialogWindow:
CantInstallDialogHandler:
return err;
}
int main(int argc, char* argv[])
{
IBNibRef nibRef;
WindowRef window;
OSStatus err;
// Create a Nib reference passing the name of the nib file (without the .nib extension)
// CreateNibReference only searches into the application bundle.
err = CreateNibReference(CFSTR("main"), &nibRef);
require_noerr( err, CantGetNibRef );
// Once the nib reference is created, set the menu bar. "MainMenu" is the name of the menu bar
// object. This name is set in InterfaceBuilder when the nib is created.
err = SetMenuBarFromNib(nibRef, CFSTR("MenuBar"));
require_noerr( err, CantSetMenuBar );
// Then create a window. "MainWindow" is the name of the window object. This name is set in
// InterfaceBuilder when the nib is created.
err = CreateWindowFromNib(nibRef, CFSTR("MainWindow"), &window);
require_noerr( err, CantCreateWindow );
// We don't need the nib reference anymore.
DisposeNibReference(nibRef);
// The window was created hidden so show it.
ShowWindow( window );
// Run the sample code
err = RunRoundTripFlatteningSample( window );
check_noerr( err );
// Call the event loop
RunApplicationEventLoop();
CantCreateWindow:
CantSetMenuBar:
CantGetNibRef:
return err;
}
int main(int argc, char* argv[])
{
IBNibRef nibRef;
OSStatus err;
// Create a Nib reference passing the name of the nib file (without the .nib extension)
// CreateNibReference only searches into the application bundle.
err = CreateNibReference(CFSTR("main"), &nibRef);
require_noerr( err, CantGetNibRef );
// Once the nib reference is created, set the menu bar. "MainMenu" is the name of the menu bar
// object. This name is set in InterfaceBuilder when the nib is created.
err = SetMenuBarFromNib(nibRef, CFSTR("MenuBar"));
require_noerr( err, CantSetMenuBar );
MakeWindow(nibRef);
// don't need the nib reference anymore.
DisposeNibReference(nibRef);
const EventTypeSpec commandProcessEvents[] = { { kEventClassCommand, kEventCommandProcess } };
InstallAppleEventHandlers();
InstallApplicationEventHandler( NewEventHandlerUPP(CommandProcessEventHandler),
GetEventTypeCount(commandProcessEvents),
commandProcessEvents, NULL, NULL );
// Must initialize QuickTime first
InitializeQuickTime ();
// Call the event loop
RunApplicationEventLoop();
CantCreateWindow:
CantSetMenuBar:
CantGetNibRef:
return err;
}
//---------------------------------------------------------------------------------------------
int main()
{
static const EventTypeSpec sApplicationEvents[] = {{ kEventClassCommand, kEventCommandProcess }};
OSErr err;
if (!SystemVersionRequired(0x1020))
{
DialogRef theAlert;
CreateStandardAlert(kAlertStopAlert, CFSTR("Need 10.2 or later!"), NULL, NULL, &theAlert);
RunStandardAlert(theAlert, NULL, NULL);
return 0;
}
ProcessSerialNumber psn = {0, kCurrentProcess};
err = GetProcessBundleLocation(&psn, &gApplicationBundleFSRef);
err = CreateNibReference(CFSTR("CarbonSketch"), &gOurNibRef );
require_noerr( err, CantGetNibRef );
err = SetMenuBarFromNib( gOurNibRef, CFSTR("MenuBar") );
require_noerr( err, SetMenuBarFromNib_FAILED );
AEInstallEventHandler(kCoreEventClass, kAEOpenApplication, DoOpenApp, 0, false);
AEInstallEventHandler(kCoreEventClass, kAEOpenDocuments, DoOpenDocuments, 0, false);
// AEInstallEventHandler(kCoreEventClass, kAEPrintDocuments, DoPrintDocuments, 0, false);
InstallApplicationEventHandler( NewEventHandlerUPP(AppEventHandlerProc),
GetEventTypeCount(sApplicationEvents),
sApplicationEvents, 0, NULL );
RunApplicationEventLoop();
SetMenuBarFromNib_FAILED:
DisposeNibReference(gOurNibRef);
CantGetNibRef:
return err;
}
int main(int argc, char* argv[])
{
IBNibRef nibRef;
WindowRef window;
OSStatus err;
EventTypeSpec cmdEvent = {kEventClassCommand, kEventCommandProcess};
// Create a Nib reference passing the name of the nib file (without the .nib extension)
// CreateNibReference only searches into the application bundle.
err = CreateNibReference(CFSTR("main"), &nibRef);
require_noerr( err, CantGetNibRef );
// Once the nib reference is created, set the menu bar. "MainMenu" is the name of the menu bar
// object. This name is set in InterfaceBuilder when the nib is created.
err = SetMenuBarFromNib(nibRef, CFSTR("MenuBar"));
require_noerr( err, CantSetMenuBar );
// Then create a window. "MainWindow" is the name of the window object. This name is set in
// InterfaceBuilder when the nib is created.
err = CreateWindowFromNib(nibRef, CFSTR("MainWindow"), &window);
require_noerr( err, CantCreateWindow );
// We don't need the nib reference anymore.
DisposeNibReference(nibRef);
// The window was created hidden so show it.
ShowWindow( window );
InstallApplicationEventHandler(NewEventHandlerUPP(appCommandHandler), GetEventTypeCount(cmdEvent), &cmdEvent, 0, NULL);
// Call the event loop
RunApplicationEventLoop();
CantCreateWindow:
CantSetMenuBar:
CantGetNibRef:
return err;
}
bool LLCrashLoggerMac::mainLoop()
{
OSStatus err = noErr;
if(err == noErr && mCrashBehavior == CRASH_BEHAVIOR_ASK)
{
RunAppModalLoopForWindow(gWindow);
}
else if (mCrashBehavior == CRASH_BEHAVIOR_ALWAYS_SEND)
{
gSendReport = true;
}
if(gRememberChoice)
{
if(gSendReport) saveCrashBehaviorSetting(CRASH_BEHAVIOR_ALWAYS_SEND);
else saveCrashBehaviorSetting(CRASH_BEHAVIOR_NEVER_SEND);
}
if(gSendReport)
{
setUserText(gUserNotes);
sendCrashLogs();
}
if(gWindow != NULL)
{
DisposeWindow(gWindow);
}
if(nib != NULL)
{
DisposeNibReference(nib);
}
return true;
}
/*****************************************************
*
* Routine: main (argc, argv)*
* Purpose: main program entry point
*
* Inputs: argc - the number of elements in the argv array
* argv - an array of pointers to the parameters to this application
*
* Returns: int - error code (0 == no error)
*/
int main(int argc, char* argv[])
{
IBNibRef nibRef;
OSStatus err;
// Create a Nib reference passing the name of the nib file (without the .nib extension)
// CreateNibReference only searches into the application bundle.
err = CreateNibReference(CFSTR("main"), &nibRef);
require_noerr(err, CantGetNibRef);
// Once the nib reference is created, set the menu bar. "MainMenu" is the name of the menu bar
// object. This name is set in InterfaceBuilder when the nib is created.
err = SetMenuBarFromNib(nibRef, CFSTR("MenuBar"));
require_noerr(err, CantSetMenuBar);
// A bit of an explanation...
WindowRef window;
CreateWindowFromNib(nibRef, CFSTR("Explain"), &window);
ShowWindow(window);
// We don't need the nib reference anymore.
DisposeNibReference(nibRef);
// Let's react to User's commands.
EventTypeSpec eventTypeCP = {kEventClassCommand, kEventCommandProcess};
InstallEventHandler(GetApplicationEventTarget(), CommandProcess, 1, &eventTypeCP, NULL, NULL);
// And start our dialogs
StartTheDialogs();
// Call the event loop
RunApplicationEventLoop();
CantSetMenuBar:
CantGetNibRef:
return err;
}
int
main(int argc, char* argv[])
{
#pragma unused(argc)
#pragma unused(argv)
IBNibRef nibRef;
OSStatus err;
err = CreateNibReference(CFSTR("main"), &nibRef);
assert(err == noErr);
err = SetMenuBarFromNib(nibRef, CFSTR("MenuBar"));
assert(err == noErr);
DisposeNibReference(nibRef);
err = MyChooseFolder();
if (err == noErr) {
RunApplicationEventLoop();
}
return err;
}
void init_apple_menu(const char* product)
{
// Load up a proper menu bar.
{
OSStatus err;
IBNibRef nib = NULL;
// NOTE: DO NOT translate or brand this string. It's an internal name in the .nib file, and MUST match exactly.
err = CreateNibReference(CFSTR("SecondLife"), &nib);
if(err == noErr)
{
// NOTE: DO NOT translate or brand this string. It's an internal name in the .nib file, and MUST match exactly.
SetMenuBarFromNib(nib, CFSTR("MenuBar"));
}
if(nib != NULL)
{
DisposeNibReference(nib);
}
}
// Install a handler for 'gurl' AppleEvents. This is how secondlife:// URLs get passed to the viewer.
if(AEInstallEventHandler('GURL', 'GURL', NewAEEventHandlerUPP(AEGURLHandler),0, false) != noErr)
{
// Couldn't install AppleEvent handler. This error shouldn't be fatal.
llinfos << "Couldn't install 'GURL' AppleEvent handler. Continuing..." << llendl;
}
// Install a handler for 'quit' AppleEvents. This makes quitting the application from the dock work.
if(AEInstallEventHandler(kCoreEventClass, kAEQuitApplication, NewAEEventHandlerUPP(AEQuitHandler),0, false) != noErr)
{
// Couldn't install AppleEvent handler. This error shouldn't be fatal.
llinfos << "Couldn't install Quit AppleEvent handler. Continuing..." << llendl;
}
}
//----------------------------------------------------------------------------//
void MacCEGuiRendererSelector::loadDialogWindow()
{
// get our framework bundle from the app
CFBundleRef helperFwk =
CFBundleGetBundleWithIdentifier(
CFSTR("net.sourceforge.crayzedsgui.CEGUISampleHelper"));
if (helperFwk)
{
IBNibRef nib;
if (!CreateNibReferenceWithCFBundle(helperFwk,
CFSTR("RendererSelector"), &nib))
{
CreateWindowFromNib(nib, CFSTR("RendererSelector"), &d_dialog);
DisposeNibReference (nib);
// find popup button in the window
const HIViewID rendererPopupID = {'PBTN', 0};
HIViewFindByID(HIViewGetRoot(d_dialog),
rendererPopupID,
&d_rendererPopup);
}
}
}
void
create_login (HWND hwnd,
LPCSTR username,
LPCSTR password,
LPCSTR dsn,
TLOGIN * log_t)
{
EventTypeSpec controlSpec = { kEventClassControl, kEventControlHit };
RgnHandle cursorRgn = NULL;
WindowRef wlogin;
ControlRef control;
ControlID controlID;
EventRecord event;
IBNibRef nibRef;
OSStatus err;
char msg[1024];
if (hwnd == NULL)
return;
/* Search the bundle for a .nib file named 'odbcadmin'. */
err =
CreateNibReferenceWithCFBundle (CFBundleGetBundleWithIdentifier (CFSTR
("org.iodbc.drvproxy")), CFSTR ("login"), &nibRef);
if (err == noErr)
{
/* Nib found ... so create the window */
CreateWindowFromNib (nibRef, CFSTR ("Dialog"), &wlogin);
DisposeNibReference (nibRef);
/* Set the title with the DSN */
if (dsn)
{
msg[0] = STRLEN ("Login for ") + STRLEN(dsn);
sprintf (msg+1, "Login for %s", (char*)dsn);
SetWTitle (wlogin, msg);
}
/* Set the control into the structure */
GETCONTROLBYID (controlID, CNTL_SIGNATURE, LBUSER_CNTL, wlogin,
log_t->username);
GETCONTROLBYID (controlID, CNTL_SIGNATURE, LBPASS_CNTL, wlogin,
log_t->password);
log_t->user = log_t->pwd = NULL;
log_t->mainwnd = wlogin;
/* Install handlers for the finish button, the cancel */
GETCONTROLBYID (controlID, CNTL_SIGNATURE, LBOK_CNTL, wlogin, control);
InstallEventHandler (GetControlEventTarget (control),
NewEventHandlerUPP (login_ok_clicked), 1, &controlSpec, log_t,
NULL);
GETCONTROLBYID (controlID, CNTL_SIGNATURE, LBCANCEL_CNTL, wlogin,
control);
InstallEventHandler (GetControlEventTarget (control),
NewEventHandlerUPP (login_cancel_clicked), 1, &controlSpec, log_t,
NULL);
SetControlData (log_t->username, 0, kControlEditTextTextTag,
username ? STRLEN (username) : STRLEN(""),
(UInt8 *) username ? username : "");
SetControlData (log_t->password, 0, kControlEditTextPasswordTag,
password ? STRLEN (password) : STRLEN(""),
(UInt8 *) password ? password : "");
/* Show the window and run the loop */
AdvanceKeyboardFocus (wlogin);
ShowWindow (wlogin);
/* The main loop */
while (log_t->mainwnd)
{
switch (WaitNextEvent (everyEvent, &event, 60L, cursorRgn))
{
};
}
}
else
goto error;
return;
error:
fprintf (stderr, "Can't load Window. Err: %d\n", (int) err);
return;
}
OSStatus _Growl_ShowUpdatePromptForVersion(CFStringRef updateVersion) {
OSStatus err = noErr;
if (_checkOSXVersion()) {
CFBundleRef bundle = CFBundleGetBundleWithIdentifier(GROWL_WITHINSTALLER_FRAMEWORK_IDENTIFIER);
if (!bundle)
NSLog(CFSTR("GrowlInstallationPrompt: could not locate framework bundle (forget about installing Growl); had looked for bundle with identifier '%@'"), GROWL_WITHINSTALLER_FRAMEWORK_IDENTIFIER);
else {
IBNibRef nib = NULL;
err = CreateNibReferenceWithCFBundle(bundle, CFSTR("GrowlInstallationPrompt-Carbon"), &nib);
if (err != noErr) {
NSLog(CFSTR("GrowlInstallationPrompt: could not obtain nib: CreateNibReferenceWithCFBundle(%@, %@) returned %li"), bundle, CFSTR("GrowlInstallationPrompt-Carbon"), (long)err);
} else {
WindowRef window = NULL;
err = CreateWindowFromNib(nib, CFSTR("Installation prompt"), &window);
DisposeNibReference(nib);
if (err != noErr) {
NSLog(CFSTR("GrowlInstallationPrompt: could not obtain window from nib: CreateWindowFromNib(%p, %@) returned %li"), nib, CFSTR("Installation prompt"), (long)err);
} else {
OSStatus fillOutTextErr = _fillOutTextInWindow(window, (updateVersion != nil));
OSStatus fillOutIconErr = _fillOutIconInWindow(window);
err = (fillOutTextErr != noErr) ? fillOutTextErr : (fillOutIconErr != noErr) ? fillOutIconErr : noErr;
if (err == noErr) {
if (updateVersion) {
//store the update version on the window.
updateVersion = CFRetain(updateVersion);
err = SetWindowProperty(window,
GROWL_SIGNATURE,
GIPC_UPDATE_VERSION,
sizeof(updateVersion),
&updateVersion);
if (err != noErr)
NSLog(CFSTR("GrowlInstallationPrompt: SetWindowProperty returned %li"), (long)err);
}
EventHandlerUPP handlerUPP = NewEventHandlerUPP(_handleCommandInWindow);
struct EventTypeSpec types[] = {
{ .eventClass = kEventClassCommand, .eventKind = kEventCommandProcess },
};
EventHandlerRef handler = NULL;
err = InstallWindowEventHandler(window,
handlerUPP,
GetEventTypeCount(types),
types,
/*refcon*/ window,
&handler);
if (err != noErr)
NSLog(CFSTR("GrowlInstallationPrompt: InstallWindowEventHandler returned %li"), (long)err);
else {
HIViewID chasingArrowsID = { GROWL_SIGNATURE, chasingArrowsIDNumber };
HIViewRef chasingArrows = NULL;
//stop and hide the chasing arrows, until the user clicks Install.
OSStatus chasingArrowsErr = HIViewFindByID(HIViewGetRoot(window), chasingArrowsID, &chasingArrows);
if (chasingArrowsErr == noErr) {
Boolean truth = false;
SetControlData(chasingArrows,
kControlEntireControl,
kControlChasingArrowsAnimatingTag,
sizeof(truth),
&truth);
HIViewSetVisible(chasingArrows, false);
}
SelectWindow(window);
ShowWindow(window);
err = RunAppModalLoopForWindow(window);
if (err != noErr)
NSLog(CFSTR("GrowlInstallationPrompt: RunAppModalLoopForWindow(%p) returned %li"), window, (long)err);
RemoveEventHandler(handler);
}
DisposeEventHandlerUPP(handlerUPP);
}
ReleaseWindow(window);
}
}
}
}
int main(int argc, char **argv)
{
// We assume that all the logs we're looking for reside on the current drive
gDirUtilp->initAppDirs("SecondLife");
LLError::initForApplication( gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, ""));
// Rename current log file to ".old"
std::string old_log_file = gDirUtilp->getExpandedFilename(LL_PATH_LOGS, "updater.log.old");
std::string log_file = gDirUtilp->getExpandedFilename(LL_PATH_LOGS, "updater.log");
LLFile::rename(log_file.c_str(), old_log_file.c_str());
// Set the log file to updater.log
LLError::logToFile(log_file);
/////////////////////////////////////////
//
// Process command line arguments
//
gUpdateURL = NULL;
gProductName = NULL;
gBundleID = NULL;
gDmgFile = NULL;
gMarkerPath = NULL;
parse_args(argc, argv);
if ((gUpdateURL == NULL) && (gDmgFile == NULL))
{
llinfos << "Usage: mac_updater -url <url> | -dmg <dmg file> [-name <product_name>] [-program <program_name>]" << llendl;
exit(1);
}
else
{
llinfos << "Update url is: " << gUpdateURL << llendl;
if (gProductName)
{
llinfos << "Product name is: " << gProductName << llendl;
}
else
{
gProductName = "Second Life";
}
if (gBundleID)
{
llinfos << "Bundle ID is: " << gBundleID << llendl;
}
else
{
gBundleID = "com.secondlife.indra.viewer";
}
}
llinfos << "Starting " << gProductName << " Updater" << llendl;
// Real UI...
OSStatus err;
IBNibRef nib = NULL;
err = CreateNibReference(CFSTR("AutoUpdater"), &nib);
char windowTitle[MAX_PATH]; /* Flawfinder: ignore */
snprintf(windowTitle, sizeof(windowTitle), "%s Updater", gProductName);
CFStringRef windowTitleRef = NULL;
windowTitleRef = CFStringCreateWithCString(NULL, windowTitle, kCFStringEncodingUTF8);
if(err == noErr)
{
err = CreateWindowFromNib(nib, CFSTR("Updater"), &gWindow);
}
if (err == noErr)
{
err = SetWindowTitleWithCFString(gWindow, windowTitleRef);
}
CFRelease(windowTitleRef);
if(err == noErr)
{
// Set up an event handler for the window.
EventTypeSpec handlerEvents[] =
{
{ kEventClassCommand, kEventCommandProcess },
{ kEventClassCustom, kEventCustomProgress },
{ kEventClassCustom, kEventCustomDone }
};
InstallStandardEventHandler(GetWindowEventTarget(gWindow));
InstallWindowEventHandler(
gWindow,
NewEventHandlerUPP(dialogHandler),
GetEventTypeCount (handlerEvents),
handlerEvents,
0,
&gEventHandler);
}
if(err == noErr)
{
ShowWindow(gWindow);
SelectWindow(gWindow);
}
if(err == noErr)
{
pthread_create(&updatethread,
NULL,
&updatethreadproc,
NULL);
}
if(err == noErr)
{
RunAppModalLoopForWindow(gWindow);
}
void *threadresult;
pthread_join(updatethread, &threadresult);
if(!gCancelled && (gFailure != noErr))
{
// Something went wrong. Since we always just tell the user to download a new version, we don't really care what.
AlertStdCFStringAlertParamRec params;
SInt16 retval_mac = 1;
DialogRef alert = NULL;
OSStatus err;
params.version = kStdCFStringAlertVersionOne;
params.movable = false;
params.helpButton = false;
params.defaultText = (CFStringRef)kAlertDefaultOKText;
params.cancelText = 0;
params.otherText = 0;
params.defaultButton = 1;
params.cancelButton = 0;
params.position = kWindowDefaultPosition;
params.flags = 0;
err = CreateStandardAlert(
kAlertStopAlert,
CFSTR("Error"),
CFSTR("An error occurred while updating Second Life. Please download the latest version from www.secondlife.com."),
¶ms,
&alert);
if(err == noErr)
{
err = RunStandardAlert(
alert,
NULL,
&retval_mac);
}
if(gMarkerPath != 0)
{
// Create a install fail marker that can be used by the viewer to
// detect install problems.
std::ofstream stream(gMarkerPath);
if(stream) stream << -1;
}
exit(-1);
} else {
exit(0);
}
if(gWindow != NULL)
{
DisposeWindow(gWindow);
}
if(nib != NULL)
{
DisposeNibReference(nib);
}
return 0;
}
void MusicBoxDialog(void)
{
OSStatus err;
IBNibRef nibRef;
if (!cartOpen)
return;
err = CreateNibReference(kMacS9XCFString, &nibRef);
if (err == noErr)
{
CFURLRef iconURL;
FSRef iconFSRef;
IconRef actIcon;
WindowRef tWindowRef;
actIcon = nil;
if (musicboxmode == kMBXSoundEmulation)
iconURL = CFBundleCopyResourceURL(CFBundleGetMainBundle(), CFSTR("musicbox_ledoff"), CFSTR("icns"), nil);
else
iconURL = CFBundleCopyResourceURL(CFBundleGetMainBundle(), CFSTR("musicbox_ledon" ), CFSTR("icns"), nil);
if (iconURL)
{
if (CFURLGetFSRef(iconURL, &iconFSRef))
err = RegisterIconRefFromFSRef('~9X~', 'micn', &iconFSRef, &actIcon);
CFRelease(iconURL);
}
err = CreateWindowFromNib(nibRef, CFSTR("MusicBox"), &tWindowRef);
if (err == noErr)
{
EventHandlerRef mboxRef, paneRef;
EventHandlerUPP mboxUPP, paneUPP;
EventLoopTimerRef timeRef;
EventLoopTimerUPP timeUPP;
EventTypeSpec mboxEvents[] = { { kEventClassCommand, kEventCommandProcess },
{ kEventClassCommand, kEventCommandUpdateStatus } },
paneEvents[] = { { kEventClassControl, kEventControlDraw } };
CFStringRef sref;
CGDataProviderRef prov;
CGImageRef ipng;
CFURLRef iurl;
HIViewRef ctl, root, paneView, imageView, contentView;
HIViewID cid;
HIRect bounds;
Rect windowRect, barRect;
char drive[_MAX_DRIVE], dir[_MAX_DIR], fname[_MAX_FNAME], ext[_MAX_EXT];
mboxPause = false;
mbxFinished = false;
showIndicator = false;
so.stereo_switch = ~0;
for (int i = 0; i < MAC_MAX_PLAYERS; i++)
controlPad[i] = 0;
switch (drawingMethod)
{
case kDrawingOpenGL:
Settings.OpenGLEnable = true;
break;
case kDrawingDirect:
case kDrawingBlitGL:
Settings.OpenGLEnable = false;
}
// 107's enhanced SPC player
root = HIViewGetRoot(tWindowRef);
cid.id = 0;
if (musicboxmode == kMBXSoundEmulation)
{
cid.signature = 'HEAD';
HIViewFindByID(root, cid, &ctl);
EnableControl(ctl);
StoredAPU = new SAPU;
StoredAPURegisters = new SAPURegisters;
StoredSoundData = new SSoundData;
StoredIAPURAM = new uint8 [0x10000];
SPCPlayFreeze();
}
else
MusicBoxForceFreeze();
cid.signature = 'Kart';
HIViewFindByID(root, cid, &ctl);
SetStaticTextTrunc(ctl, truncEnd, false);
_splitpath(Memory.ROMFilename, drive, dir, fname, ext);
sref = CFStringCreateWithCString(kCFAllocatorDefault, fname, MAC_PATH_ENCODING);
if (sref)
{
SetStaticTextCFString(ctl, sref, false);
CFRelease(sref);
}
ipng = nil;
iurl = CFBundleCopyResourceURL(CFBundleGetMainBundle(), CFSTR("musicbox_indicator"), CFSTR("png"), nil);
if (iurl)
{
prov = CGDataProviderCreateWithURL(iurl);
if (prov)
{
ipng = CGImageCreateWithPNGDataProvider(prov, nil, false, kCGRenderingIntentDefault);
CGDataProviderRelease(prov);
}
CFRelease(iurl);
}
imageView = nil;
if (ipng)
{
HIViewFindByID(root, kHIViewWindowContentID, &contentView);
err = HIImageViewCreate(ipng, &imageView);
if (err == noErr)
{
bounds = CGRectMake(30, 64, CGImageGetWidth(ipng), CGImageGetHeight(ipng));
HIViewSetFrame(imageView, &bounds);
HIImageViewSetOpaque(imageView, false);
HIViewSetVisible(imageView, true);
HIViewAddSubview(contentView, imageView);
cid.signature = 'iMaG';
SetControlID(imageView, &cid);
}
CGImageRelease(ipng);
}
cid.signature = 'Pane';
HIViewFindByID(root, cid, &paneView);
HIViewGetBounds(paneView, &bounds);
mbxViewWidth = bounds.size.width;
mbxViewHeight = bounds.size.height;
mbxMarginY = (mbxViewHeight - mbxBarHeight) / 2.0;
mbxMarginX = (mbxViewWidth - ((mbxBarWidth * 8.0 + mbxBarSpace * 7.0) * 2.0 + mbxLRSpace)) / 2.0;
if (imageView)
{
HIViewSetZOrder(imageView, kHIViewZOrderBelow, paneView);
HIViewAddSubview(imageView, paneView);
}
cid.signature = 'Tr_i';
HIViewFindByID(root, cid, &ctl);
HIViewGetFrame(ctl, &bounds);
GetWindowBounds(tWindowRef, kWindowTitleBarRgn, &barRect);
mbxClosedHeight = (short) (bounds.origin.y + bounds.size.height + 7.0) + (barRect.bottom - barRect.top);
GetWindowBounds(tWindowRef, kWindowStructureRgn, &windowRect);
mbxOpenedHeight = windowRect.bottom - windowRect.top;
windowRect.bottom = windowRect.top + mbxClosedHeight;
SetWindowBounds(tWindowRef, kWindowStructureRgn, &windowRect);
paneUPP = NewEventHandlerUPP(IndicatorEventHandler);
err = InstallControlEventHandler(paneView, paneUPP, GetEventTypeCount(paneEvents), paneEvents, (void *) paneView, &paneRef);
mboxUPP = NewEventHandlerUPP(MusicBoxEventHandler);
err = InstallWindowEventHandler(tWindowRef, mboxUPP, GetEventTypeCount(mboxEvents), mboxEvents, (void *) tWindowRef, &mboxRef);
timeUPP = NewEventLoopTimerUPP(MusicBoxTimerHandler);
err = InstallEventLoopTimer(GetCurrentEventLoop(), kEventDurationNoWait, kEventDurationSecond * 2.0 / (double) Memory.ROMFramesPerSecond, timeUPP, (void *) paneView, &timeRef);
MusicBoxInitIndicator();
stopNow = false;
MacStartSound();
pthread_create(&mbxThread, nil, SoundTask, nil);
MoveWindowPosition(tWindowRef, kWindowMusicBox, true);
GetWindowBounds(tWindowRef, kWindowStructureRgn, &windowRect);
if (windowRect.bottom - windowRect.top > mbxClosedHeight)
{
showIndicator = true;
SetControl32BitValue(ctl, 1); // Tr_i
}
ShowWindow(tWindowRef);
err = RunAppModalLoopForWindow(tWindowRef);
HideWindow(tWindowRef);
SaveWindowPosition(tWindowRef, kWindowMusicBox);
stopNow = true;
pthread_join(mbxThread, nil);
MacStopSound();
err = RemoveEventLoopTimer(timeRef);
DisposeEventLoopTimerUPP(timeUPP);
err = RemoveEventHandler(mboxRef);
DisposeEventHandlerUPP(mboxUPP);
err = RemoveEventHandler(paneRef);
DisposeEventHandlerUPP(paneUPP);
ReleaseWindow(tWindowRef);
so.stereo_switch = ~0;
mbxFinished = true;
if (musicboxmode == kMBXSoundEmulation)
{
SPCPlayDefrost();
delete StoredAPU;
delete StoredAPURegisters;
delete StoredSoundData;
delete [] StoredIAPURAM;
}
else
MusicBoxForceDefrost();
Settings.OpenGLEnable = false;
}
if (actIcon)
err = UnregisterIconRef('~9X~', 'micn');
DisposeNibReference(nibRef);
}
}
Boolean MultiCartDialog (void)
{
OSStatus err;
IBNibRef nibRef;
multiCartDragHilite = -1;
multiCartDialogResult = false;
err = CreateNibReference(kMacS9XCFString, &nibRef);
if (err == noErr)
{
WindowRef window;
err = CreateWindowFromNib(nibRef, CFSTR("MultiCart"), &window);
if (err == noErr)
{
static int index[2] = { 0, 1 };
EventHandlerRef wRef, cRef[2];
EventHandlerUPP wUPP, cUPP[2];
EventTypeSpec wEvent[] = { { kEventClassCommand, kEventCommandProcess },
{ kEventClassCommand, kEventCommandUpdateStatus } },
cEvent[] = { { kEventClassControl, kEventControlDraw },
{ kEventClassControl, kEventControlDragEnter },
{ kEventClassControl, kEventControlDragWithin },
{ kEventClassControl, kEventControlDragLeave },
{ kEventClassControl, kEventControlDragReceive } };
HIViewRef ctl, root, pane[2];
HIViewID cid;
root = HIViewGetRoot(window);
wUPP = NewEventHandlerUPP(MultiCartEventHandler);
err = InstallWindowEventHandler(window, wUPP, GetEventTypeCount(wEvent), wEvent, (void *) window, &wRef);
err = SetAutomaticControlDragTrackingEnabledForWindow(window, true);
for (int i = 0; i < 2; i++)
{
cid.id = i;
cid.signature = 'MPan';
HIViewFindByID(root, cid, &pane[i]);
cUPP[i] = NewEventHandlerUPP(MultiCartPaneEventHandler);
err = InstallControlEventHandler(pane[i], cUPP[i], GetEventTypeCount(cEvent), cEvent, (void *) &index[i], &cRef[i]);
err = SetControlDragTrackingEnabled(pane[i], true);
cid.signature = 'MNAM';
HIViewFindByID(root, cid, &ctl);
SetStaticTextTrunc(ctl, truncEnd, false);
if (multiCartPath[i])
{
CFStringRef str;
CFURLRef url;
url = CFURLCreateWithFileSystemPath(kCFAllocatorDefault, multiCartPath[i], kCFURLPOSIXPathStyle, false);
str = CFURLCopyLastPathComponent(url);
SetStaticTextCFString(ctl, str, false);
CFRelease(str);
CFRelease(url);
}
else
SetStaticTextCFString(ctl, CFSTR(""), false);
}
MoveWindowPosition(window, kWindowMultiCart, false);
ShowWindow(window);
err = RunAppModalLoopForWindow(window);
HideWindow(window);
SaveWindowPosition(window, kWindowMultiCart);
for (int i = 0; i < 2; i++)
{
err = RemoveEventHandler(cRef[i]);
DisposeEventHandlerUPP(cUPP[i]);
}
err = RemoveEventHandler(wRef);
DisposeEventHandlerUPP(wUPP);
CFRelease(window);
}
DisposeNibReference(nibRef);
}
return (multiCartDialogResult);
}
