bool CARBON_GUI::init_controls() {
int i;
for(i=0;i<MAIN_CONTROLS_NUM;i++) {
err = GetControlByID(window,&mainControlsID[i],&mainControls[i]);
if(err != noErr) {
// printf("%d - %d - %d \n",i,mainControlsID[i].id,err);
msg->error("Can't get control for button %d (%d)",i,err);
}
}
/* By default start with live output enabled */
jmix->set_lineout(true);
SetControlValue(mainControls[SNDOUT_BUT],1);
/* install main event handler+ */
err = InstallWindowEventHandler (window,
NewEventHandlerUPP (MainWindowEventHandler),
GetEventTypeCount(events), events,
this, NULL);
if(err != noErr) msg->error("Can't install main eventHandler");
/* install main command handler */
err = InstallWindowEventHandler (window,
NewEventHandlerUPP (MainWindowCommandHandler),
GetEventTypeCount(commands), commands,
this, NULL);
if(err != noErr) msg->error("Can't install main commandHandler");
}
void Shell::EventLoop(ShellIdleFunction idle_function)
{
OSStatus error;
error = InstallApplicationEventHandler(NewEventHandlerUPP(InputMacOSX::EventHandler),
GetEventTypeCount(INPUT_EVENTS),
INPUT_EVENTS,
NULL,
NULL);
if (error != noErr)
DisplayError("Unable to install handler for input events, error: %d.", error);
error = InstallWindowEventHandler(window,
NewEventHandlerUPP(EventHandler),
GetEventTypeCount(WINDOW_EVENTS),
WINDOW_EVENTS,
NULL,
NULL);
if (error != noErr)
DisplayError("Unable to install handler for window events, error: %d.", error);
EventLoopTimerRef timer;
error = InstallEventLoopIdleTimer(GetMainEventLoop(), // inEventLoop
0, // inFireDelay
5 * kEventDurationMillisecond, // inInterval (200 Hz)
NewEventLoopIdleTimerUPP(IdleTimerCallback), // inTimerProc
(void*) idle_function, // inTimerData,
&timer // outTimer
);
if (error != noErr)
DisplayError("Unable to install Carbon event loop timer, error: %d.", error);
RunApplicationEventLoop();
}
MODULE_SCOPE void
TkMacOSXInitCarbonEvents(
Tcl_Interp *interp)
{
const EventTypeSpec dispatcherEventTypes[] = {
{kEventClassKeyboard, kEventRawKeyDown},
{kEventClassKeyboard, kEventRawKeyRepeat},
{kEventClassKeyboard, kEventRawKeyUp},
{kEventClassKeyboard, kEventRawKeyModifiersChanged},
{kEventClassKeyboard, kEventRawKeyRepeat},
};
const EventTypeSpec applicationEventTypes[] = {
{kEventClassMenu, kEventMenuBeginTracking},
{kEventClassMenu, kEventMenuEndTracking},
{kEventClassMenu, kEventMenuOpening},
{kEventClassMenu, kEventMenuTargetItem},
{kEventClassCommand, kEventCommandProcess},
{kEventClassCommand, kEventCommandUpdateStatus},
{kEventClassApplication, kEventAppActivated},
{kEventClassApplication, kEventAppDeactivated},
{kEventClassApplication, kEventAppQuit},
{kEventClassApplication, kEventAppHidden},
{kEventClassApplication, kEventAppShown},
{kEventClassApplication, kEventAppAvailableWindowBoundsChanged},
{kEventClassAppearance, kEventAppearanceScrollBarVariantChanged},
{kEventClassFont, kEventFontPanelClosed},
{kEventClassFont, kEventFontSelection},
};
carbonEventHandlerUPP = NewEventHandlerUPP(CarbonEventHandlerProc);
carbonEventInterp = interp;
ChkErr(InstallStandardApplicationEventHandler);
ChkErr(InstallEventHandler, GetEventDispatcherTarget(),
carbonEventHandlerUPP, GetEventTypeCount(dispatcherEventTypes),
dispatcherEventTypes, (void *) carbonEventInterp, NULL);
ChkErr(InstallEventHandler, GetApplicationEventTarget(),
carbonEventHandlerUPP, GetEventTypeCount(applicationEventTypes),
applicationEventTypes, (void *) carbonEventInterp, NULL);
#ifdef TK_MAC_DEBUG_CARBON_EVENTS
TkMacOSXInitNamedSymbol(HIToolbox, void, DebugTraceEvent, OSType, UInt32,
Boolean);
if (DebugTraceEvent) {
unsigned int i;
const EventTypeSpec *e;
for (i = 0, e = dispatcherEventTypes;
i < GetEventTypeCount(dispatcherEventTypes); i++, e++) {
DebugTraceEvent(e->eventClass, e->eventKind, 1);
}
for (i = 0, e = applicationEventTypes;
i < GetEventTypeCount(applicationEventTypes); i++, e++) {
DebugTraceEvent(e->eventClass, e->eventKind, 1);
}
DebugTraceEvent = NULL; /* Only enable tracing once. */
}
#endif /* TK_MAC_DEBUG_CARBON_EVENTS */
}
/* initialize the status window (used to show console messages in the graphic environment */
void CARBON_GUI::setupStatusWindow()
{
OSStatus err=CreateWindowFromNib(nibRef,CFSTR("StatusWindow"),&statusWindow);
if(err!=noErr) msg->error("Can't create status window (%d)!!",err);
//SetDrawerParent(statusWindow,window);
//SetDrawerPreferredEdge(statusWindow,kWindowEdgeBottom);
//SetDrawerOffsets(statusWindow,20,20);
/* install an eventHandler to intercept close requests */
err = InstallWindowEventHandler (statusWindow,
NewEventHandlerUPP (StatusWindowEventHandler),
GetEventTypeCount(statusEvents), statusEvents, this, NULL);
if(err != noErr) msg->error("Can't install status window eventHandler");
/* and then install a command handler (to handle "clear" requests) */
err=InstallWindowEventHandler(statusWindow,NewEventHandlerUPP(StatusWindowCommandHandler),
GetEventTypeCount(commands),commands,this,NULL);
/* obtain an HIViewRef for the status text box ... we have to use it
* to setup various properties and to obain a TXNObject needed to manage its content */
const ControlID txtid={ CARBON_GUI_APP_SIGNATURE, STATUS_TEXT_ID };
err= HIViewFindByID(HIViewGetRoot(statusWindow), txtid, &statusTextView);
if(err!=noErr) return;// msg->warning("Can't get textView for status window (%d)!!",err);
statusText = HITextViewGetTXNObject(statusTextView);
if(!statusText) {
msg->error("Can't get statusText object from status window!!");
}
// TXNControlTag iControlTags[1] = { kTXNAutoScrollBehaviorTag };
// TXNControlData iControlData[1] = { kTXNAutoScrollNever }; //kTXNAutoScrollWhenInsertionVisible };
// err = TXNSetTXNObjectControls(statusText,false,1,iControlTags,iControlData);
//TextViewSetObjectControlData
//TextViewSetObjectControlData(statusText,kTXNAutoScrollBehaviorTag,kUn kTXNAutoScrollWhenInsertionVisible)
/* setup status text font size and color */
// Create type attribute data structure
UInt32 fontSize = 10 << 16; // needs to be in Fixed format
TXNAttributeData fsData,fcData;
fsData.dataValue=fontSize;
fcData.dataPtr=(void *)&black;
TXNTypeAttributes attributes[] = {
//{ kTXNQDFontStyleAttribute, kTXNQDFontStyleAttributeSize, bold },
{ kTXNQDFontColorAttribute, kTXNQDFontColorAttributeSize,fcData}, //&lgrey },
{ kTXNQDFontSizeAttribute, kTXNFontSizeAttributeSize,fsData }
};
err= TXNSetTypeAttributes( statusText, 2, attributes,
kTXNStartOffset,kTXNEndOffset );
/* block user input in the statusText box */
TXNControlTag tags[] = { kTXNNoUserIOTag };
TXNControlData vals[] = { kTXNReadOnly };
err=TXNSetTXNObjectControls(statusText,false,1,tags,vals);
if(err!=noErr) msg->error("Can't set statusText properties (%d)!!",err);
// TXNSetScrollbarState(statusText,kScrollBarsAlwaysActive);
//struct TXNBackground bg = { kTXNBackgroundTypeRGB, black };
//TXNSetBackground(statusText,&bg);
}
void* CContextOSX::CreateMainWindow(SSize /*Size*/, tint32 /*iWindowsOnly_MenuResourceID = -1*/, tint32 /*iWindowsOnly_IconResourceID = -1*/)
{
gpMainContext = this;
IBNibRef sNibRef;
OSStatus err;
static const EventTypeSpec kAppEvents[] =
{
{ kEventClassCommand, kEventCommandProcess },
{ kCoreEventClass, kAEOpenDocuments }
};
// 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"), &sNibRef );
// 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( sNibRef, CFSTR("MenuBar") );
// require_noerr( err, CantSetMenuBar );
// Install our handler for common commands on the application target
// InstallApplicationEventHandler( NewEventHandlerUPP( AppEventHandler ),
// GetEventTypeCount( kAppEvents ), kAppEvents,
// 0, NULL );
WindowRef gpWindow;
err = CreateWindowFromNib( sNibRef, CFSTR("MainWindow"), &gpWindow );
// Position new windows in a staggered arrangement on the main screen
RepositionWindow( gpWindow, NULL, kWindowCascadeOnMainScreen );
// The window was created hidden, so show it
// ShowWindow( gpWindow );
::InvalMenuBar();
::DrawMenuBar();
// Install application event handler
InstallApplicationEventHandler( NewEventHandlerUPP( AppEventHandler ),
GetEventTypeCount( kAppEvents ),
kAppEvents,
this,
NULL );
InstallWindowEventHandler(gpWindow, GetWindowEventHandlerUPP(),
GetEventTypeCount(kWindowEvents), kWindowEvents,
gpWindow, NULL);
return (void*)gpWindow;
}
int _glfwInstallEventHandlers( void )
{
OSStatus error;
_glfwWin.MouseUPP = NewEventHandlerUPP( _glfwMouseEventHandler );
error = InstallEventHandler( GetApplicationEventTarget(),
_glfwWin.MouseUPP,
GetEventTypeCount( GLFW_MOUSE_EVENT_TYPES ),
GLFW_MOUSE_EVENT_TYPES,
NULL,
NULL );
if( error != noErr )
{
fprintf( stderr, "glfwOpenWindow failing because it can't install mouse event handler\n" );
return GL_FALSE;
}
_glfwWin.CommandUPP = NewEventHandlerUPP( _glfwCommandHandler );
error = InstallEventHandler( GetApplicationEventTarget(),
_glfwWin.CommandUPP,
GetEventTypeCount( GLFW_COMMAND_EVENT_TYPES ),
GLFW_COMMAND_EVENT_TYPES,
NULL,
NULL );
if( error != noErr )
{
fprintf( stderr, "glfwOpenWindow failing because it can't install command event handler\n" );
return GL_FALSE;
}
_glfwWin.KeyboardUPP = NewEventHandlerUPP( _glfwKeyEventHandler );
error = InstallEventHandler( GetApplicationEventTarget(),
_glfwWin.KeyboardUPP,
GetEventTypeCount( GLFW_KEY_EVENT_TYPES ),
GLFW_KEY_EVENT_TYPES,
NULL,
NULL );
if( error != noErr )
{
fprintf( stderr, "glfwOpenWindow failing because it can't install key event handler\n" );
return GL_FALSE;
}
return GL_TRUE;
}
static int installEventHandlers( void )
{
OSStatus error;
_glfwWin.mouseUPP = NewEventHandlerUPP( mouseEventHandler );
error = InstallEventHandler( GetApplicationEventTarget(),
_glfwWin.mouseUPP,
GetEventTypeCount( GLFW_MOUSE_EVENT_TYPES ),
GLFW_MOUSE_EVENT_TYPES,
NULL,
NULL );
if( error != noErr )
{
fprintf( stderr, "Failed to install Carbon application mouse event handler\n" );
return GL_FALSE;
}
_glfwWin.commandUPP = NewEventHandlerUPP( commandHandler );
error = InstallEventHandler( GetApplicationEventTarget(),
_glfwWin.commandUPP,
GetEventTypeCount( GLFW_COMMAND_EVENT_TYPES ),
GLFW_COMMAND_EVENT_TYPES,
NULL,
NULL );
if( error != noErr )
{
fprintf( stderr, "Failed to install Carbon application command event handler\n" );
return GL_FALSE;
}
_glfwWin.keyboardUPP = NewEventHandlerUPP( keyEventHandler );
error = InstallEventHandler( GetApplicationEventTarget(),
_glfwWin.keyboardUPP,
GetEventTypeCount( GLFW_KEY_EVENT_TYPES ),
GLFW_KEY_EVENT_TYPES,
NULL,
NULL );
if( error != noErr )
{
fprintf( stderr, "Failed to install Carbon application key event handler\n" );
return GL_FALSE;
}
return GL_TRUE;
}
OPL_Dialog::OPL_Dialog(CFStringRef resname):
m_window(0), m_status(true)
{
OSStatus err;
static EventTypeSpec dialog_events[] = {
{ kEventClassCommand, kEventCommandProcess },
{ kEventClassWindow, kEventWindowClose },
{ kEventClassControl, kEventControlHit },
};
// create and show preferences dialog
err = CreateWindowFromNib(g_main_nib, resname, &m_window);
require_noerr(err, error);
static EventHandlerUPP g_eventHandlerUPP = NULL;
if (g_eventHandlerUPP == NULL)
g_eventHandlerUPP = NewEventHandlerUPP(eventHandler);
// install control event handler
err = InstallWindowEventHandler(getWindow(), g_eventHandlerUPP,
GetEventTypeCount(dialog_events), dialog_events, this, NULL);
require_noerr(err, error);
error:
/* do nothing */;
}
static void HandleStartEvent(NavCBRecPtr callBackParms, CustomData *data)
{
data->context = callBackParms->context;
CreateUserPaneControl(callBackParms->window, &data->bounds, kControlSupportsEmbedding, &data->userpane);
InstallControlEventHandler(data->userpane,
GetHandlePaneEventsUPP(),
GetEventTypeCount(namedAttrsList),
namedAttrsList,
data,
NULL);
EmbedControl(data->choice, data->userpane);
EmbedControl(data->button, data->userpane);
NavCustomControl(callBackParms->context, kNavCtlAddControl, data->userpane);
HandleAdjustRect(callBackParms, data);
if (data && !(data->defaultLocation).IsEmpty())
{
// Set default location for the modern Navigation APIs
// Apple Technical Q&A 1151
FSSpec theFSSpec;
wxMacFilename2FSSpec(data->defaultLocation, &theFSSpec);
AEDesc theLocation = {typeNull, NULL};
if (noErr == ::AECreateDesc(typeFSS, &theFSSpec, sizeof(FSSpec), &theLocation))
::NavCustomControl(callBackParms->context, kNavCtlSetLocation, (void *) &theLocation);
}
}
wxMacSearchFieldControl::wxMacSearchFieldControl( wxTextCtrl *wxPeer,
const wxString& str,
const wxPoint& pos,
const wxSize& size, long style ) : wxMacUnicodeTextControl( wxPeer )
{
m_font = wxPeer->GetFont() ;
m_windowStyle = style ;
m_selection.selStart = m_selection.selEnd = 0;
Rect bounds = wxMacGetBoundsForControl( wxPeer , pos , size ) ;
wxString st = str ;
wxMacConvertNewlines10To13( &st ) ;
wxCFStringRef cf(st , m_font.GetEncoding()) ;
m_valueTag = kControlEditTextCFStringTag ;
OptionBits attributes = kHISearchFieldAttributesSearchIcon;
HIRect hibounds = { { bounds.left, bounds.top }, { bounds.right-bounds.left, bounds.bottom-bounds.top } };
verify_noerr( HISearchFieldCreate(
&hibounds,
attributes,
0, // MenuRef
CFSTR(""),
&m_controlRef
) );
HIViewSetVisible (m_controlRef, true);
verify_noerr( SetData<CFStringRef>( 0, kControlEditTextCFStringTag , cf ) ) ;
::InstallControlEventHandler( m_controlRef, GetwxMacSearchControlEventHandlerUPP(),
GetEventTypeCount(eventList), eventList, wxPeer, NULL);
SetNeedsFrame(false);
wxMacUnicodeTextControl::InstallEventHandlers();
}
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;
}
GHOST_TSuccess GHOST_SystemCarbon::init()
{
GHOST_TSuccess success = GHOST_System::init();
if (success) {
/*
* Initialize the cursor to the standard arrow shape (so that we can change it later on).
* This initializes the cursor's visibility counter to 0.
*/
::InitCursor();
MenuRef windMenu;
::CreateStandardWindowMenu(0, &windMenu);
::InsertMenu(windMenu, 0);
::DrawMenuBar();
::InstallApplicationEventHandler(sEventHandlerProc, GetEventTypeCount(kEvents), kEvents, this, &m_handler);
::AEInstallEventHandler(kCoreEventClass, kAEOpenApplication, sAEHandlerLaunch, (SInt32) this, false);
::AEInstallEventHandler(kCoreEventClass, kAEOpenDocuments, sAEHandlerOpenDocs, (SInt32) this, false);
::AEInstallEventHandler(kCoreEventClass, kAEPrintDocuments, sAEHandlerPrintDocs, (SInt32) this, false);
::AEInstallEventHandler(kCoreEventClass, kAEQuitApplication, sAEHandlerQuit, (SInt32) this, false);
}
return success;
}
static OSStatus MyMTViewRegister(CFStringRef myClassID)
{
OSStatus err = noErr;
static HIObjectClassRef sMyViewClassRef = NULL;
if ( sMyViewClassRef == NULL )
{
EventTypeSpec eventList[] = {
{ kEventClassHIObject, kEventHIObjectConstruct },
{ kEventClassHIObject, kEventHIObjectInitialize },
{ kEventClassHIObject, kEventHIObjectDestruct },
{ kEventClassControl, kEventControlDraw },
{ kEventClassControl, kEventControlHitTest },
{ kEventClassControl, kEventControlTrack },
};
err = HIObjectRegisterSubclass( myClassID,
kHIViewClassID, // base class ID
0, // option bits
MTViewHandler, // construct proc
GetEventTypeCount( eventList ),
eventList,
NULL, // construct data
&sMyViewClassRef );
}
return err;
}
OSStatus
TabbedWindow::RegisterWindowCarbonEventhandler()
{
OSStatus status = paramErr;
WindowRef window = this->GetWindow();
static const EventTypeSpec windowEvents[] =
{
{ kEventClassWindow, kEventWindowActivated },
{ kEventClassWindow, kEventWindowDeactivated },
{ kEventClassWindow, kEventWindowClose },
{ kEventClassWindow, kEventControlHit },
{ kEventClassControl, kEventControlHit },
{ kEventClassCommand, kEventProcessCommand },
{ kEventClassMenu, kEventMenuOpening }
};
// install the window event handler
if( window != NULL )
{
status = InstallWindowEventHandler( window, NewEventHandlerUPP(EventHandlerProc),
GetEventTypeCount( windowEvents ), windowEvents,
this, &fHandler );
}
return status;
}
void MakeWindow(IBNibRef nibRef)
{
WindowRef window;
OSStatus err;
EventHandlerRef ref;
EventTypeSpec winEvents[] = { { kEventClassCommand, kEventCommandProcess },
{ kEventClassWindow, kEventWindowClose },
{ kEventClassWindow, kEventWindowDrawContent },
{ kEventClassWindow, kEventWindowBoundsChanged },
{ kEventClassMovieExtractState, kEventKQueue } };
err = CreateWindowFromNib(nibRef, CFSTR("Window"), &window);
mWindow = window;
mWinEventHandler = NewEventHandlerUPP(WindowEventHandler);
err = InstallWindowEventHandler(window, mWinEventHandler, GetEventTypeCount( winEvents ), winEvents, 0, &ref);
ControlRef control;
err = GetControlByID( window, &kPlayBtnID, &control );
mButtonRef = control;
err = GetControlByID( window, &kMovNameTxtID, &control );
mMovNameRef = control;
ShowWindow(window);
}
void palette_scenery_open(int x,int y)
{
ControlID ctrl_id;
EventHandlerUPP tab_event_upp;
EventTypeSpec tab_event_list[]={{kEventClassControl,kEventControlHit},
{kEventClassKeyboard,kEventRawKeyUp}};
// open the window
dialog_open(&palette_scenery_wind,"SceneryPalette");
MoveWindow(palette_scenery_wind,x,y,FALSE);
// setup the tabs
dialog_set_tab(palette_scenery_wind,kSceneryTab,0,0,kSceneryTabCount);
ctrl_id.signature=kSceneryTab;
ctrl_id.id=0;
GetControlByID(palette_scenery_wind,&ctrl_id,&palette_scenery_tab);
tab_event_upp=NewEventHandlerUPP(palette_scenery_tab_proc);
InstallControlEventHandler(palette_scenery_tab,tab_event_upp,GetEventTypeCount(tab_event_list),tab_event_list,palette_scenery_wind,NULL);
// show palette
ShowWindow(palette_scenery_wind);
}
static OSErr InitializeApplication( void )
{
OSErr err;
static const EventTypeSpec sApplicationEvents[] = { { kEventClassCommand, kEventCommandProcess } };
BlockZero( &g, sizeof(g) );
g.mainBundle = CFBundleGetMainBundle();
if ( g.mainBundle == NULL ) { err = -1; goto Bail; }
err = CreateNibReferenceWithCFBundle( g.mainBundle, CFSTR("WindowFun"), &g.mainNib );
if ( err != noErr ) goto Bail;
if ( g.mainNib == NULL ) { err = -1; goto Bail; }
err = SetMenuBarFromNib( g.mainNib, CFSTR("MenuBar") );
if ( err != noErr ) goto Bail;
InstallApplicationEventHandler( NewEventHandlerUPP(AppEventEventHandlerProc), GetEventTypeCount(sApplicationEvents), sApplicationEvents, 0, NULL );
// Force the document group to be created first, so we can position our groups between the floating and document groups
(void) GetWindowGroupOfClass( kDocumentWindowClass );
// Create our default WindowGroups and set their z-order
err = CreateWindowGroup( 0, &g.windowGroups[0] );
err = CreateWindowGroup( 0, &g.windowGroups[1] );
err = CreateWindowGroup( 0, &g.windowGroups[2] );
// Position our groups behind the floating group and in front of the document group
SendWindowGroupBehind( g.windowGroups[2], GetWindowGroupOfClass( kDocumentWindowClass ) );
SendWindowGroupBehind( g.windowGroups[1], g.windowGroups[2] );
SendWindowGroupBehind( g.windowGroups[0], g.windowGroups[1] );
Bail:
return( err );
}
static void
setup_menu_event_handler (void)
{
static gboolean is_setup = FALSE;
EventHandlerUPP menu_event_handler_upp;
EventHandlerRef menu_event_handler_ref;
const EventTypeSpec menu_events[] = {
{ kEventClassCommand, kEventCommandProcess },
{ kEventClassMenu, kEventMenuTargetItem },
{ kEventClassMenu, kEventMenuOpening },
{ kEventClassMenu, kEventMenuClosed }
};
if (is_setup)
return;
/* FIXME: We might have to install one per window? */
menu_event_handler_upp = NewEventHandlerUPP (menu_event_handler_func);
InstallEventHandler (GetApplicationEventTarget (), menu_event_handler_upp,
GetEventTypeCount (menu_events), menu_events, 0,
&menu_event_handler_ref);
#if 0
/* FIXME: Remove the handler with: */
RemoveEventHandler(menu_event_handler_ref);
DisposeEventHandlerUPP(menu_event_handler_upp);
#endif
is_setup = TRUE;
}
static void makeNibWindow (IBNibRef nibRef) {
OSStatus err;
short i,j,l,k;
EventHandlerRef ref;
ControlRef targetCon[11], cref[3];
err = CreateWindowFromNib(nibRef, CFSTR("SoundDialog"), &soundWin);
if (err == noErr) {
initSoundWindow();
SetInitialTabState(soundWin, lastPaneSelected, kMaxNumTabs);
EventTypeSpec tabControlEvents[] ={ { kEventClassControl, kEventControlHit }};
InstallControlEventHandler( getControlRefByID(kTabMasterSig,kTabMasterID,soundWin), PrefsTabEventHandlerProc , GetEventTypeCount(tabControlEvents), tabControlEvents, soundWin, NULL );
EventTypeSpec sliderControlEvents[] ={
{ kEventClassControl, kEventControlDraw },
{ kEventClassControl, kEventControlValueFieldChanged }
};
for (i=0;i<5;i++) {
targetCon[i] = getControlRefByID('vMix',i,soundWin);
}
for (j=0;j<6;j++) {
targetCon[j+5] = getControlRefByID('vMix',10+j,soundWin);
}
for (l=0;l<11;l++) {
InstallControlEventHandler( targetCon[l], sliderEventHandlerProc , GetEventTypeCount(sliderControlEvents), sliderControlEvents, (void *)targetCon[l], NULL );
}
EventTypeSpec list[]={ { kEventClassCommand, kEventCommandProcess },};
InstallWindowEventHandler (soundWin, NewEventHandlerUPP(cfWinproc), GetEventTypeCount(list), list, (void *)soundWin, &ref);
EventTypeSpec ctrllist[]={ { kEventClassControl, kEventControlClick } };
for (k=0;k<3;k++) {
cref[k] = getControlRefByID('BMP ', k, soundWin);
}
InstallControlEventHandler(cref[0], NewEventHandlerUPP(s26proc), GetEventTypeCount(ctrllist), ctrllist, (void *)cref[0], NULL);
InstallControlEventHandler(cref[1], NewEventHandlerUPP(s86proc), GetEventTypeCount(ctrllist), ctrllist, (void *)cref[1], NULL);
InstallControlEventHandler(cref[2], NewEventHandlerUPP(spbproc), GetEventTypeCount(ctrllist), ctrllist, (void *)cref[2], NULL);
ShowSheetWindow(soundWin, hWndMain);
err=RunAppModalLoopForWindow(soundWin);
}
return;
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// AURenderQualityPopup::RegisterEvents
//
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
void AURenderQualityPopup::RegisterEvents ()
{
EventTypeSpec events[] = {
{ kEventClassCommand, kEventCommandProcess}
};
WantEventTypes(GetWindowEventTarget(mView->GetCarbonWindow()), GetEventTypeCount(events), events);
}
MODULE_SCOPE void
TkMacOSXInstallWindowCarbonEventHandler(
Tcl_Interp *interp, WindowRef window)
{
const EventTypeSpec windowEventTypes[] = {
{kEventClassMouse, kEventMouseDown},
{kEventClassMouse, kEventMouseUp},
{kEventClassMouse, kEventMouseMoved},
{kEventClassMouse, kEventMouseDragged},
{kEventClassMouse, kEventMouseWheelMoved},
{kEventClassWindow, kEventWindowActivated},
{kEventClassWindow, kEventWindowDeactivated},
{kEventClassWindow, kEventWindowUpdate},
{kEventClassWindow, kEventWindowExpanding},
{kEventClassWindow, kEventWindowBoundsChanged},
{kEventClassWindow, kEventWindowDragStarted},
{kEventClassWindow, kEventWindowDragCompleted},
{kEventClassWindow, kEventWindowConstrain},
{kEventClassWindow, kEventWindowGetRegion},
{kEventClassWindow, kEventWindowDrawContent},
};
ChkErr(InstallEventHandler, GetWindowEventTarget(window),
carbonEventHandlerUPP, GetEventTypeCount(windowEventTypes),
windowEventTypes, (void *) (interp ? interp : carbonEventInterp),
NULL);
#ifdef TK_MAC_DEBUG_CARBON_EVENTS
TkMacOSXInitNamedSymbol(HIToolbox, void, DebugTraceEvent, OSType, UInt32,
Boolean);
if (DebugTraceEvent) {
unsigned int i;
const EventTypeSpec *e;
for (i = 0, e = windowEventTypes;
i < GetEventTypeCount(windowEventTypes); i++, e++) {
if (!(e->eventClass == kEventClassMouse && (
e->eventKind == kEventMouseMoved ||
e->eventKind == kEventMouseDragged))) {
DebugTraceEvent(e->eventClass, e->eventKind, 1);
}
}
}
#endif /* TK_MAC_DEBUG_CARBON_EVENTS */
}
int _glfwInstallEventHandlers( void )
{
OSStatus error;
_glfwWin.MouseUPP = NewEventHandlerUPP( _glfwMouseEventHandler );
error = InstallEventHandler( GetApplicationEventTarget(),
_glfwWin.MouseUPP,
GetEventTypeCount( GLFW_MOUSE_EVENT_TYPES ),
GLFW_MOUSE_EVENT_TYPES,
NULL,
NULL );
if ( error != noErr )
{
return GL_FALSE;
}
_glfwWin.CommandUPP = NewEventHandlerUPP( _glfwCommandHandler );
error = InstallEventHandler( GetApplicationEventTarget(),
_glfwWin.CommandUPP,
GetEventTypeCount( GLFW_COMMAND_EVENT_TYPES ),
GLFW_COMMAND_EVENT_TYPES,
NULL,
NULL );
if ( error != noErr )
{
return GL_FALSE;
}
_glfwWin.KeyboardUPP = NewEventHandlerUPP( _glfwKeyEventHandler );
error = InstallEventHandler( GetApplicationEventTarget(),
_glfwWin.KeyboardUPP,
GetEventTypeCount( GLFW_KEY_EVENT_TYPES ),
GLFW_KEY_EVENT_TYPES,
NULL,
NULL );
if ( error != noErr )
{
return GL_FALSE;
}
return GL_TRUE;
}
static void installAcessibilityEventHandler(HIObjectRef hiObject)
{
if (!accessibilityEventHandlerUPP)
accessibilityEventHandlerUPP = NewEventHandlerUPP(accessibilityEventHandler);
InstallHIObjectEventHandler(hiObject, accessibilityEventHandlerUPP,
GetEventTypeCount(accessibilityEvents),
accessibilityEvents, 0, 0);
}
void AUPropertyControl::RegisterEvents ()
{
#if !__LP64__
EventTypeSpec events[] = {
{ kEventClassControl, kEventControlValueFieldChanged } // N.B. OS X only
};
WantEventTypes(GetControlEventTarget(mControl), GetEventTypeCount(events), events);
#endif
}
void
QMacInputContext::initialize()
{
if(!input_proc_handler) {
input_proc_handlerUPP = NewEventHandlerUPP(QMacInputContext::globalEventProcessor);
InstallEventHandler(GetApplicationEventTarget(), input_proc_handlerUPP,
GetEventTypeCount(input_events), input_events,
0, &input_proc_handler);
}
}
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);
}
void dialog_preference_run(void)
{
EventHandlerUPP event_upp;
EventTypeSpec event_list[]={{kEventClassCommand,kEventProcessCommand}};
// open the dialog
dialog_open(&dialog_preference_wind,"Preferences");
// set controls
dialog_set_text(dialog_preference_wind,kPrefEngineName,0,setup.engine_name);
dialog_set_combo(dialog_preference_wind,kPrefMipMapMode,0,setup.mipmap_mode);
dialog_set_boolean(dialog_preference_wind,kPrefAutoTexture,0,setup.auto_texture);
dialog_set_int(dialog_preference_wind,kPrefDuplicateOffset,0,setup.duplicate_offset);
dialog_set_color(dialog_preference_wind,kPrefBackgroundColor,0,&setup.col.background);
dialog_set_color(dialog_preference_wind,kPrefLineColor,0,&setup.col.mesh_line);
dialog_set_color(dialog_preference_wind,kPrefMeshSelColor,0,&setup.col.mesh_sel);
dialog_set_color(dialog_preference_wind,kPrefPolySelColor,0,&setup.col.poly_sel);
// show window
ShowWindow(dialog_preference_wind);
// install event handler
event_upp=NewEventHandlerUPP(preference_event_proc);
InstallWindowEventHandler(dialog_preference_wind,event_upp,GetEventTypeCount(event_list),event_list,NULL,NULL);
// modal window
dialog_preference_cancel=FALSE;
RunAppModalLoopForWindow(dialog_preference_wind);
// dialog to data
if (!dialog_preference_cancel) {
dialog_get_text(dialog_preference_wind,kPrefEngineName,0,setup.engine_name,256);
setup.mipmap_mode=dialog_get_combo(dialog_preference_wind,kPrefMipMapMode,0);
setup.auto_texture=dialog_get_boolean(dialog_preference_wind,kPrefAutoTexture,0);
setup.duplicate_offset=dialog_get_int(dialog_preference_wind,kPrefDuplicateOffset,0);
dialog_get_color(dialog_preference_wind,kPrefBackgroundColor,0,&setup.col.background);
dialog_get_color(dialog_preference_wind,kPrefLineColor,0,&setup.col.mesh_line);
dialog_get_color(dialog_preference_wind,kPrefMeshSelColor,0,&setup.col.mesh_sel);
dialog_get_color(dialog_preference_wind,kPrefPolySelColor,0,&setup.col.poly_sel);
setup_xml_write();
}
// close window
DisposeWindow(dialog_preference_wind);
}
bool LLCrashLoggerMac::init(void)
{
bool ok = LLCrashLogger::init();
if(!ok) return false;
if(mCrashBehavior != CRASH_BEHAVIOR_ASK) return true;
// Real UI...
OSStatus err;
err = CreateNibReference(CFSTR("CrashReporter"), &nib);
if(err == noErr)
{
err = CreateWindowFromNib(nib, CFSTR("CrashReporter"), &gWindow);
}
if(err == noErr)
{
// Set focus to the edit text area
ControlRef textField = NULL;
ControlID id;
id.signature = 'text';
id.id = 0;
// Don't set err if any of this fails, since it's non-critical.
if(GetControlByID(gWindow, &id, &textField) == noErr)
{
SetKeyboardFocus(gWindow, textField, kControlFocusNextPart);
}
}
if(err == noErr)
{
ShowWindow(gWindow);
}
if(err == noErr)
{
// Set up an event handler for the window.
EventTypeSpec handlerEvents[] =
{
{ kEventClassCommand, kEventCommandProcess }
};
InstallWindowEventHandler(
gWindow,
NewEventHandlerUPP(dialogHandler),
GetEventTypeCount (handlerEvents),
handlerEvents,
0,
&gEventHandler);
}
return true;
}
void MacOSXLoop::registerWindow( GenericWindow &rGenWin, WindowRef win )
{
// Create the event handler
EventTypeSpec evList[] = {
{ kEventClassWindow, kEventWindowUpdate },
{ kEventClassMouse, kEventMouseMoved }
};
EventHandlerUPP handler = NewEventHandlerUPP( WinEventHandler );
InstallWindowEventHandler( win, handler, GetEventTypeCount( evList ),
evList, &rGenWin, NULL );
}
OP_STATUS MacOpMessageLoop::Init()
{
static EventTypeSpec appEventList[] =
{
{kEventClassOperaPlatformIndependent, kEventOperaMessage}
};
mHandlerUPP = NewEventHandlerUPP(sMacMessageLoopHandler);
InstallEventHandler(GetApplicationEventTarget(), mHandlerUPP, GetEventTypeCount(appEventList), appEventList, this, &mHandlerRef);
return OpStatus::OK;
}
