/*****************************************************
*
* main (argc, argv)
*
* Purpose: main program entry point
*
* Notes: You might want to change this to something more verbose
*
* 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 = ((noErr == status) && (response >= 0x00001030));
if (!ok)
{
DialogRef theAlert;
CreateStandardAlert(kAlertStopAlert, CFSTR("Mac OS X 10.3 (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.
status = CreateNibReference(CFSTR("main"), &gIBNibRef);
require_noerr(status, 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.
status = SetMenuBarFromNib(gIBNibRef, CFSTR("MenuBar"));
require_noerr(status, CantSetMenuBar);
// Adding a Font menu
MenuRef fontMenu = GetMenuRef(3);
require(fontMenu != NULL, CantSetMenuBar);
status = CreateStandardFontMenu(fontMenu, 0, 0, 0, NULL);
require_noerr(status, CantSetMenuBar);
// Enabling Preferences menu item
EnableMenuCommand(NULL, kHICommandPreferences);
// Let's react to User's commands.
Install_AppleEventHandlers();
EventTypeSpec eventTypeCP = {kEventClassCommand, kEventCommandProcess};
InstallEventHandler(GetApplicationEventTarget(), Handle_CommandProcess, 1, &eventTypeCP, NULL, NULL);
EventTypeSpec eventTypeCUS = {kEventClassCommand, kEventCommandUpdateStatus};
InstallEventHandler(GetApplicationEventTarget(), Handle_CommandUpdateStatus, 1, &eventTypeCUS, NULL, NULL);
EventTypeSpec eventTypeAA = {kEventClassApplication, kEventAppActivated};
InstallEventHandler(GetApplicationEventTarget(), Handle_AppActivated, 1, &eventTypeAA, NULL, NULL);
// Call the event loop
RunApplicationEventLoop();
CantSetMenuBar:
CantGetNibRef:
return status;
} // main
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;
}
static OSStatus
InstallStandardApplicationEventHandler(void)
{
OSStatus err = memFullErr;
TK_IF_HI_TOOLBOX(5,
/*
* The approach below does not work correctly in Leopard, it leads to
* crashes in [NSView unlockFocus] whenever HIToolbox uses Cocoa (Help
* menu, Nav Services, Color Picker). While it is now possible to
* install the standard app handler with InstallStandardEventHandler(),
* to fully replicate RAEL the standard menubar event handler also needs
* to be installed. Unfortunately there appears to be no public API to
* obtain the menubar event target. As a workaround, for now we resort
* to calling the HIToolbox-internal GetMenuBarEventTarget() directly
* (symbol acquired via TkMacOSXInitNamedSymbol() from HIToolbox
* version 343, may not exist in later versions).
*/
err = ChkErr(InstallStandardEventHandler, GetApplicationEventTarget());
TkMacOSXInitNamedSymbol(HIToolbox, EventTargetRef,
GetMenuBarEventTarget, void);
if (GetMenuBarEventTarget) {
ChkErr(InstallStandardEventHandler, GetMenuBarEventTarget());
} else {
TkMacOSXDbgMsg("Unable to install standard menubar event handler");
}
) TK_ELSE_HI_TOOLBOX (5,
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;
}
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 */
}
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;
}
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);
}
}
UInt32
COSXScreen::registerHotKey(KeyID key, KeyModifierMask mask)
{
// get mac virtual key and modifier mask matching synergy key and mask
UInt32 macKey, macMask;
if (!m_keyState->mapSynergyHotKeyToMac(key, mask, macKey, macMask)) {
LOG((CLOG_DEBUG "could not map hotkey id=%04x mask=%04x", key, mask));
return 0;
}
// choose hotkey id
UInt32 id;
if (!m_oldHotKeyIDs.empty()) {
id = m_oldHotKeyIDs.back();
m_oldHotKeyIDs.pop_back();
}
else {
id = m_hotKeys.size() + 1;
}
// if this hot key has modifiers only then we'll handle it specially
EventHotKeyRef ref = NULL;
bool okay;
if (key == kKeyNone) {
if (m_modifierHotKeys.count(mask) > 0) {
// already registered
okay = false;
}
else {
m_modifierHotKeys[mask] = id;
okay = true;
}
}
else {
EventHotKeyID hkid = { 'SNRG', (UInt32)id };
OSStatus status = RegisterEventHotKey(macKey, macMask, hkid,
GetApplicationEventTarget(), 0,
&ref);
okay = (status == noErr);
m_hotKeyToIDMap[CHotKeyItem(macKey, macMask)] = id;
}
if (!okay) {
m_oldHotKeyIDs.push_back(id);
m_hotKeyToIDMap.erase(CHotKeyItem(macKey, macMask));
LOG((CLOG_WARN "failed to register hotkey %s (id=%04x mask=%04x)", CKeyMap::formatKey(key, mask).c_str(), key, mask));
return 0;
}
m_hotKeys.insert(std::make_pair(id, CHotKeyItem(ref, macKey, macMask)));
LOG((CLOG_DEBUG "registered hotkey %s (id=%04x mask=%04x) as id=%d", CKeyMap::formatKey(key, mask).c_str(), key, mask, id));
return id;
}
// Set up application-wide event handlers
OSStatus
InstallApplicationEventHandlers( void )
{
EventTypeSpec commandEventType = {kEventClassCommand, kEventCommandProcess};
OSStatus status;
status = InstallEventHandler(GetApplicationEventTarget(), NewEventHandlerUPP(CommandProcess), 1, &commandEventType, NULL, NULL);
require_noerr( status, CantInstallHICommandHandler );
CantInstallHICommandHandler:
return status;
}
OP_STATUS MacOpMessageLoop::Init()
{
static EventTypeSpec appEventList[] =
{
{kEventClassOperaPlatformIndependent, kEventOperaMessage}
};
mHandlerUPP = NewEventHandlerUPP(sMacMessageLoopHandler);
InstallEventHandler(GetApplicationEventTarget(), mHandlerUPP, GetEventTypeCount(appEventList), appEventList, this, &mHandlerRef);
return OpStatus::OK;
}
void doloop(void)
{
EventHandlerRef menu_event;
EventHandlerUPP menu_upp;
EventTypeSpec app_menu_events[]={{kEventClassCommand,kEventProcessCommand}};
menu_upp=NewEventHandlerUPP(app_event_menu);
InstallEventHandler(GetApplicationEventTarget(),menu_upp,GetEventTypeCount(app_menu_events),app_menu_events,NULL,&menu_event);
RunApplicationEventLoop();
RemoveEventHandler(menu_event);
DisposeEventHandlerUPP(menu_upp);
}
//
// Register global hotkey
//
bool AutoTypePlatformMac::registerGlobalShortcut(Qt::Key key, Qt::KeyboardModifiers modifiers)
{
uint16 nativeKeyCode = qtToNativeKeyCode(key);
if (nativeKeyCode == INVALID_KEYCODE) {
qWarning("Invalid key code");
return false;
}
uint16 nativeModifiers = qtToNativeModifiers(modifiers);
if (::RegisterEventHotKey(nativeKeyCode, nativeModifiers, m_hotkeyId, GetApplicationEventTarget(), 0, &m_hotkeyRef) != noErr) {
qWarning("Register hotkey failed");
return false;
}
return true;
}
KGlobalAccelImpl::KGlobalAccelImpl(GlobalShortcutsRegistry* owner)
: m_owner(owner)
, m_eventTarget(GetApplicationEventTarget())
, m_eventHandler(NewEventHandlerUPP(hotKeyEventHandler))
{
m_eventType[0].eventClass = kEventClassKeyboard;
m_eventType[0].eventKind = kEventHotKeyPressed;
m_eventType[1].eventClass = kEventClassKeyboard; // only useful for testing, is not used because count passed in call to InstallEventHandler is 1
m_eventType[1].eventKind = kEventRawKeyDown;
refs = new QMap<int, QList<EventHotKeyRef> >();
CFStringRef str = CFStringCreateWithCString(NULL, "AppleKeyboardPreferencesChangedNotification", kCFStringEncodingASCII);
if (str) {
CFNotificationCenterAddObserver(CFNotificationCenterGetDistributedCenter(), this, layoutChanged, str, NULL, CFNotificationSuspensionBehaviorHold);
CFRelease(str);
} else {
kWarning(125) << "Couldn't create CFString to register for keyboard notifications";
}
}
void CL_DisplayWindow_OpenGL::set_fullscreen(int width, int height, int bpp, int refresh_rate)
{
if(fullscreen)
return;
CGCaptureAllDisplays();
aglSetCurrentContext(fs_context);
aglSetFullScreen(fs_context, width, height, refresh_rate, 0);
context = fs_context;
install_event_handler(GetApplicationEventTarget());
fullscreen = true;
focus = true;
//After toggling to the fullscreen context, nothing is going draw unless
//we reapply the GL states/properties -mrfun 6-2-2006
CL_GLStateChecker::from_gc(get_gc())->reinitialize_asap();
}
void ui_main() {
if( data.init_done )
return;
data.init_done = 1;
# if defined(NEKO_WINDOWS)
{
WNDCLASSEX wcl;
HINSTANCE hinst = GetModuleHandle(NULL);
memset(&wcl,0,sizeof(wcl));
wcl.cbSize = sizeof(WNDCLASSEX);
wcl.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
wcl.lpfnWndProc = WindowProc;
wcl.cbClsExtra = 0;
wcl.cbWndExtra = 0;
wcl.hInstance = hinst;
wcl.hIcon = NULL;
wcl.hCursor = LoadCursor(NULL, IDC_ARROW);
wcl.hbrBackground = (HBRUSH)(COLOR_BTNFACE+1);
wcl.lpszMenuName = "";
wcl.lpszClassName = CLASS_NAME;
wcl.hIconSm = 0;
RegisterClassEx(&wcl);
}
data.tid = GetCurrentThreadId();
data.wnd = CreateWindow(CLASS_NAME,"",0,0,0,0,0,NULL,NULL,NULL,NULL);
# elif defined(NEKO_MAC)
MPCreateTask(nothing,NULL,0,0,0,0,0,NULL); // creates a MPTask that will enable Carbon MT
data.tid = pthread_self();
EventTypeSpec ets = { UIEvent, eCall };
InstallEventHandler(GetApplicationEventTarget(),NewEventHandlerUPP(handleEvents),1,&ets,0,0);
# elif defined(NEKO_LINUX)
g_thread_init(NULL);
gdk_threads_init();
gtk_init(NULL,NULL);
setlocale(LC_NUMERIC,"POSIX"); // prevent broking atof()
data.tid = pthread_self();
pthread_mutex_init(&data.lock,NULL);
# endif
}
bool wxApp::OnInitGui()
{
if ( !wxAppBase::OnInitGui() )
return false ;
InstallStandardEventHandler( GetApplicationEventTarget() ) ;
if (!sm_isEmbedded)
{
InstallApplicationEventHandler(
GetwxMacAppEventHandlerUPP(),
GetEventTypeCount(eventList), eventList, wxTheApp, (EventHandlerRef *)&(wxTheApp->m_macEventHandler));
}
if (!sm_isEmbedded)
{
sODocHandler = NewAEEventHandlerUPP(AEHandleODoc) ;
sOAppHandler = NewAEEventHandlerUPP(AEHandleOApp) ;
sPDocHandler = NewAEEventHandlerUPP(AEHandlePDoc) ;
sRAppHandler = NewAEEventHandlerUPP(AEHandleRApp) ;
sQuitHandler = NewAEEventHandlerUPP(AEHandleQuit) ;
AEInstallEventHandler( kCoreEventClass , kAEOpenDocuments ,
sODocHandler , 0 , FALSE ) ;
AEInstallEventHandler( kCoreEventClass , kAEOpenApplication ,
sOAppHandler , 0 , FALSE ) ;
AEInstallEventHandler( kCoreEventClass , kAEPrintDocuments ,
sPDocHandler , 0 , FALSE ) ;
AEInstallEventHandler( kCoreEventClass , kAEReopenApplication ,
sRAppHandler , 0 , FALSE ) ;
AEInstallEventHandler( kCoreEventClass , kAEQuitApplication ,
sQuitHandler , 0 , FALSE ) ;
}
if ( !wxMacInitCocoa() )
return false;
return true ;
}
bool QxtGlobalShortcutPrivate::registerShortcut(quint32 nativeKey,
quint32 nativeMods) {
if (!qxt_mac_handler_installed) {
EventTypeSpec t;
t.eventClass = kEventClassKeyboard;
t.eventKind = kEventHotKeyPressed;
InstallApplicationEventHandler(&qxt_mac_handle_hot_key, 1, &t, NULL, NULL);
}
EventHotKeyID keyID;
keyID.signature = 'cute';
keyID.id = ++hotKeySerial;
EventHotKeyRef ref = 0;
bool rv = !RegisterEventHotKey(nativeKey, nativeMods, keyID,
GetApplicationEventTarget(), 0, &ref);
if (rv) {
keyIDs.insert(Identifier(nativeMods, nativeKey), keyID.id);
keyRefs.insert(keyID.id, ref);
}
return rv;
}
/*****************************************************
*
* 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;
}
Boolean MCScreenDC::open()
{
owndnd = False;
mouseMoveRgn = NewRgn();
SetRectRgn(mouseMoveRgn, 0, 0, 1, 1);
//create a invisible window, and set port to this window
//so that later on at the very first time MC select and set font
//will only affect in this invisible window, not other apps on the desk top,
// when MC is first started. The size of the window is random.
// Rect invisibleWinRect;
Rect invisibleWinRect;
SetRect(&invisibleWinRect, 0, 0, 20, 20);
invisibleWin = NewCWindow(nil, &invisibleWinRect, "\p", False,
kUtilityWindowClass, (WindowRef)(-1L), False, 0);
long response;
if (Gestalt(gestaltSystemVersion, &response) == noErr)
{
if (response >= 0x1030 && response < 0x1040)
MCantialiasedtextworkaround = True;
else
MCantialiasedtextworkaround = False;
}
SetGWorld(GetWindowPort(invisibleWin), GetMainDevice());
vis = new MCVisualInfo;
devdepth = 32;
black_pixel.red = black_pixel.green = black_pixel.blue = 0; //black pixel
white_pixel.red = white_pixel.green = white_pixel.blue = 0xFFFF; //white pixel
black_pixel.pixel = 0;
white_pixel.pixel = 0xFFFFFF;
redbits = greenbits = bluebits = 8;
redshift = 16;
greenshift = 8;
blueshift = 0;
vis->red_mask = 0x00FF0000;
vis->green_mask = 0x0000FF00;
vis->blue_mask = 0x000000FF;
MCzerocolor = MCbrushcolor = white_pixel;
alloccolor(MCbrushcolor);
MCselectioncolor = MCpencolor = black_pixel;
alloccolor(MCselectioncolor);
alloccolor(MCpencolor);
gray_pixel.red = gray_pixel.green = gray_pixel.blue = 0x8888;
alloccolor(gray_pixel);
background_pixel.red = background_pixel.green = background_pixel.blue = 0xffff;
alloccolor(background_pixel);
//query the system for the hilited text color, and set ours
RGBColor hiliteRGB;
LMGetHiliteRGB(&hiliteRGB);
MChilitecolor.red = hiliteRGB.red;
MChilitecolor.green = hiliteRGB.green;
MChilitecolor.blue = hiliteRGB.blue;
alloccolor(MChilitecolor);
MCColor *syscolors = getaccentcolors();
if (syscolors != NULL)
MCaccentcolor = syscolors[4];
else
{
MCaccentcolor.red = MCaccentcolor.green = 0x0000;
MCaccentcolor.blue = 0x8080;
}
alloccolor(MCaccentcolor);
grabbed = False;
tripleclick = doubleclick = False;
MCdoubletime = GetDblTime() * 1000 / 60;
opened = True;
mousewindow = new _Drawable;
activewindow = new _Drawable;
lastactivewindow = new _Drawable;
mousewindow->type = activewindow->type = lastactivewindow->type = DC_WINDOW;
mousewindow->handle.window = activewindow->handle.window
= lastactivewindow->handle.window = 0;
//get handle of application menu bar
menuBar = GetMenuBar();
SetMenuBar(menuBar); //set menu bar as current menulist
//create Apple menu
appleMenu = NewMenu(mApple, "\p\024"); //menu title is an apple icon
InsertMenuItem(appleMenu, "\pAbout...", 0);
InsertMenu(appleMenu, 0);
DrawMenuBar(); //draw the menu bar with the Apple menu
usetemp = False;
Handle tmem = Get1IndResource('TMEM', 1);
if (tmem != NULL)
{
char *ptr = *tmem;
if (*(ptr + 1))
usetemp = True;
}
MCtemplatescrollbar->alloccolors();
if (IsMacEmulatedLF()) // no AM
MCtemplatebutton->allocicons();
// preallocate these because GetItemMark can't distinguish them
submenuIDs[0] = 1;
submenuIDs[checkMark] = 1;
submenuIDs[diamondMark] = 1;
MCcursors[PI_NONE] = nil;
MCblinkrate = GetCaretTime() * 1000 / 60;
MCDisplay const *t_displays;
getdisplays(t_displays, false);
MCwbr = t_displays[0] . workarea;
//TSM - INIT TSM APPLICATION AND INSTALL REQUIRED APPLEVENT HANDLERS
TSMPositionToOffsetUPP = NewAEEventHandlerUPP(TSMPositionToOffset);
TSMOffsetToPositionUPP = NewAEEventHandlerUPP(TSMOffsetToPosition);
TSMUpdateHandlerUPP = NewAEEventHandlerUPP(TSMUpdateHandler);
TSMUnicodeNotFromInputUPP
= NewAEEventHandlerUPP(TSMUnicodeNotFromInputHandler);
AEInstallEventHandler(kTextServiceClass, kPos2Offset,
TSMPositionToOffsetUPP, 0L , False);
AEInstallEventHandler(kTextServiceClass, kOffset2Pos,
TSMOffsetToPositionUPP, 0L , False);
AEInstallEventHandler(kTextServiceClass, kUpdateActiveInputArea,
TSMUpdateHandlerUPP, 0L , False);
AEInstallEventHandler(kTextServiceClass, kUnicodeNotFromInputMethod,
TSMUnicodeNotFromInputUPP, 0L , False);
openIME();
dragdropUPP = NewDragReceiveHandlerUPP(DragReceiveHandler);
InstallReceiveHandler(dragdropUPP, NULL, NULL);
dragmoveUPP = NewDragTrackingHandlerUPP(DragTrackingHandler);
InstallTrackingHandler(dragmoveUPP, NULL, NULL);
s_animation_current_time = s_animation_start_time = CFAbsoluteTimeGetCurrent();
//// Dock Menu Initialization
EventTypeSpec t_menu_event_specs[1];
t_menu_event_specs[0] . eventClass = kEventClassMenu;
t_menu_event_specs[0] . eventKind = kEventMenuPopulate;
CreateNewMenu(0, 0, &f_icon_menu);
s_icon_menu_event_handler_upp = NewEventHandlerUPP((EventHandlerProcPtr)handleiconmenuevent);
InstallEventHandler(GetMenuEventTarget(f_icon_menu), s_icon_menu_event_handler_upp, 1, t_menu_event_specs, NULL, NULL);
t_menu_event_specs[0] . eventClass = kEventClassCommand;
t_menu_event_specs[0] . eventKind = kEventCommandProcess;
InstallEventHandler(GetApplicationEventTarget(), s_icon_menu_event_handler_upp, 1, t_menu_event_specs, NULL, NULL);
SetApplicationDockTileMenu(f_icon_menu);
//// Color Profile Initialization
CMGetDefaultProfileBySpace(cmRGBData, &m_dst_profile);
CMProfileLocation t_location;
t_location . locType = cmPathBasedProfile;
strcpy(t_location . u . pathLoc . path, "/System/Library/ColorSync/Profiles/sRGB Profile.icc");
CMOpenProfile(&m_srgb_profile, &t_location);
////
return True;
}
// Note that this function has to be called once. To recreate textures, call the renewTex() member function.
int appleMultiContext::init(struct sageDisplayConfig &cfg)
{
// Make this a "faceful app" that can receive input events:
ProcessSerialNumber psn;
OSStatus s;
s = GetCurrentProcess(&psn); assert(s == noErr);
s = TransformProcessType(&psn,kProcessTransformToForegroundApplication); assert(s == noErr);
s = SetFrontProcess(&psn); assert(s == noErr);
singleContext = false;
configStruct = cfg;
tileNum = cfg.dimX * cfg.dimY;
if (tileNum > MAX_TILES_PER_NODE) {
sage::printLog("displayContext::init() : The tile number exceeds the maximum");
return -1;
}
if (!winCreatFlag) {
//
// Set up us the OpenGL:
// Choose global pixel format:
static GLint agl_fmt_list[] = { AGL_RGBA,
AGL_RED_SIZE, 8,
AGL_GREEN_SIZE, 8,
AGL_BLUE_SIZE, 8,
AGL_ALPHA_SIZE, 8,
AGL_DEPTH_SIZE, 24,
AGL_DOUBLEBUFFER,
AGL_NONE };
agl_fmt = aglChoosePixelFormat(0,0,agl_fmt_list);
if (agl_fmt == 0) {
fprintf(stderr,"failed to choose OpenGL pixel format\n");
abort();
}
// The critical region object
MPCreateCriticalRegion(&cr);
// Install event handlers
//
EventTargetRef target = GetApplicationEventTarget();
EventTypeSpec eventTypes[] = {
{ kEventClassKeyboard, kEventRawKeyDown }
};
InstallEventHandler(target,NewEventHandlerUPP(keyboard_handler),
sizeof(eventTypes) / sizeof(EventTypeSpec),eventTypes,
0,0);
// Create Windows
for (int k = 0; k < tileNum; k++) {
int tileX = (k % cfg.dimX) * cfg.tileRect[k].width;
int tileY = (k / cfg.dimX) * cfg.tileRect[k].height;
Rect wrect;
wrect.left = tileX; // cfg.tileRect[k].x;
wrect.top = tileY; // cfg.tileRect[k].y;
wrect.right = wrect.left + cfg.tileRect[k].width;
wrect.bottom = wrect.top + cfg.tileRect[k].height;
//fprintf(stderr,"Create window %d at %i,%i,%i,%i\n",k, wrect.left,wrect.top,wrect.right,wrect.bottom);
windows[k] = new Window(wrect, configStruct.fullScreenFlag);
windows[k]->beginGL();
glEnable(GL_DEPTH_TEST);
glEnable(GL_TEXTURE_2D);
}
winCreatFlag = true;
}
return 0;
} // End of appleMultiContext::init()
