From e12f860f1bdc63d5f4835b568cb4023f7d72e15c Mon Sep 17 00:00:00 2001 From: "alexey.lysiuk" Date: Sun, 3 Aug 2014 12:36:02 +0300 Subject: [PATCH] Added native Cocoa back-end implementation --- src/cocoa/i_backend_cocoa.mm | 1744 ++++++++++++++++++++++++++++++++++ src/cocoa/i_joystick.cpp | 776 +++++++++++++++ src/cocoa/i_timer.cpp | 191 ++++ src/cocoa/zdoom-info.plist | 47 + src/cocoa/zdoom.icns | Bin 0 -> 196176 bytes src/cocoa/zdoom.xib | 874 +++++++++++++++++ 6 files changed, 3632 insertions(+) create mode 100644 src/cocoa/i_backend_cocoa.mm create mode 100644 src/cocoa/i_joystick.cpp create mode 100644 src/cocoa/i_timer.cpp create mode 100644 src/cocoa/zdoom-info.plist create mode 100644 src/cocoa/zdoom.icns create mode 100644 src/cocoa/zdoom.xib diff --git a/src/cocoa/i_backend_cocoa.mm b/src/cocoa/i_backend_cocoa.mm new file mode 100644 index 0000000000..d4c353edd6 --- /dev/null +++ b/src/cocoa/i_backend_cocoa.mm @@ -0,0 +1,1744 @@ +/* + ** i_backend_cocoa.mm + ** + **--------------------------------------------------------------------------- + ** Copyright 2012-2014 Alexey Lysiuk + ** All rights reserved. + ** + ** Redistribution and use in source and binary forms, with or without + ** modification, are permitted provided that the following conditions + ** are met: + ** + ** 1. Redistributions of source code must retain the above copyright + ** notice, this list of conditions and the following disclaimer. + ** 2. Redistributions in binary form must reproduce the above copyright + ** notice, this list of conditions and the following disclaimer in the + ** documentation and/or other materials provided with the distribution. + ** 3. The name of the author may not be used to endorse or promote products + ** derived from this software without specific prior written permission. + ** + ** THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + ** IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + ** OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + ** IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + ** INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + ** NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + ** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + ** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + ** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + ** THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + **--------------------------------------------------------------------------- + ** + */ + +#include +#include + +#include +#include +#include +#include + +#include +#include +#include + +#include + +// Avoid collision between DObject class and Objective-C +#define Class ObjectClass + +#include "basictypes.h" +#include "basicinlines.h" +#include "bitmap.h" +#include "c_console.h" +#include "c_dispatch.h" +#include "cmdlib.h" +#include "d_event.h" +#include "d_gui.h" +#include "dikeys.h" +#include "doomdef.h" +#include "doomstat.h" +#include "s_sound.h" +#include "textures.h" +#include "v_video.h" +#include "version.h" + +#undef Class + + +#define ZD_UNUSED(VARIABLE) ((void)(VARIABLE)) + + +// --------------------------------------------------------------------------- + + +#ifndef NSAppKitVersionNumber10_7 + +@interface NSView(HiDPIStubs) +- (NSPoint)convertPointToBacking:(NSPoint)aPoint; +- (NSSize)convertSizeToBacking:(NSSize)aSize; +- (NSSize)convertSizeFromBacking:(NSSize)aSize; + +- (void)setWantsBestResolutionOpenGLSurface:(BOOL)flag; +@end + +@interface NSScreen(HiDPIStubs) +- (NSRect)convertRectToBacking:(NSRect)aRect; +@end + +#endif // NSAppKitVersionNumber10_7 + + +// --------------------------------------------------------------------------- + + +CVAR(Bool, use_mouse, true, CVAR_ARCHIVE | CVAR_GLOBALCONFIG) +CVAR(Bool, m_noprescale, false, CVAR_ARCHIVE | CVAR_GLOBALCONFIG) +CVAR(Bool, m_filter, false, CVAR_ARCHIVE | CVAR_GLOBALCONFIG) + +CUSTOM_CVAR(Int, mouse_capturemode, 1, CVAR_GLOBALCONFIG | CVAR_ARCHIVE) +{ + if (self < 0) + { + self = 0; + } + else if (self > 2) + { + self = 2; + } +} + +bool GUICapture; + + +extern int paused, chatmodeon; +extern constate_e ConsoleState; + +EXTERN_CVAR(Int, m_use_mouse); + +void I_ShutdownJoysticks(); + + +namespace +{ + +struct FrameBufferParameters +{ + float pixelScale; + + float shiftX; + float shiftY; + + float width; + float height; +}; + +FrameBufferParameters s_frameBufferParameters; + + +const int ARGC_MAX = 64; + +int s_argc; +char* s_argv[ARGC_MAX]; + +TArray s_argvStorage; + + +bool s_nativeMouse = true; + +// TODO: remove this magic! +size_t s_skipMouseMoves; + +NSCursor* s_cursor; + + +void CheckGUICapture() +{ + const bool wantCapture = (MENU_Off == menuactive) + ? (c_down == ConsoleState || c_falling == ConsoleState || chatmodeon) + : (menuactive == MENU_On || menuactive == MENU_OnNoPause); + + if (wantCapture != GUICapture) + { + GUICapture = wantCapture; + + ResetButtonStates(); + } +} + +void CenterCursor() +{ + NSWindow* window = [NSApp keyWindow]; + if (nil == window) + { + return; + } + + const NSRect displayRect = [[window screen] frame]; + const NSRect windowRect = [window frame]; + const CGPoint centerPoint = CGPointMake(NSMidX(windowRect), displayRect.size.height - NSMidY(windowRect)); + + CGEventSourceRef eventSource = CGEventSourceCreate(kCGEventSourceStateCombinedSessionState); + + if (NULL != eventSource) + { + CGEventRef mouseMoveEvent = CGEventCreateMouseEvent(eventSource, + kCGEventMouseMoved, centerPoint, kCGMouseButtonLeft); + + if (NULL != mouseMoveEvent) + { + CGEventPost(kCGHIDEventTap, mouseMoveEvent); + CFRelease(mouseMoveEvent); + } + + CFRelease(eventSource); + } + + // TODO: remove this magic! + s_skipMouseMoves = 2; +} + + +bool IsInGame() +{ + switch (mouse_capturemode) + { + default: + case 0: + return gamestate == GS_LEVEL; + + case 1: + return gamestate == GS_LEVEL || gamestate == GS_INTERMISSION || gamestate == GS_FINALE; + + case 2: + return true; + } +} + +void SetNativeMouse(bool wantNative) +{ + if (wantNative != s_nativeMouse) + { + s_nativeMouse = wantNative; + + if (!wantNative) + { + CenterCursor(); + } + + CGAssociateMouseAndMouseCursorPosition(wantNative); + + if (wantNative) + { + [NSCursor unhide]; + } + else + { + [NSCursor hide]; + } + } +} + +void CheckNativeMouse() +{ + bool windowed = (NULL == screen) || !screen->IsFullscreen(); + bool wantNative; + + if (windowed) + { + if (![NSApp isActive] || !use_mouse) + { + wantNative = true; + } + else if (MENU_WaitKey == menuactive) + { + wantNative = false; + } + else + { + wantNative = (!m_use_mouse || MENU_WaitKey != menuactive) + && (!IsInGame() || GUICapture || paused || demoplayback); + } + } + else + { + // ungrab mouse when in the menu with mouse control on. + wantNative = m_use_mouse + && (MENU_On == menuactive || MENU_OnNoPause == menuactive); + } + + SetNativeMouse(wantNative); +} + +} // unnamed namespace + + +// from iokit_joystick.cpp +void I_ProcessJoysticks(); + + +void I_GetEvent() +{ + [[NSRunLoop mainRunLoop] limitDateForMode:NSDefaultRunLoopMode]; +} + +void I_StartTic() +{ + CheckGUICapture(); + CheckNativeMouse(); + + I_ProcessJoysticks(); + I_GetEvent(); +} + +void I_StartFrame() +{ + +} + + +void I_SetMouseCapture() +{ + +} + +void I_ReleaseMouseCapture() +{ + +} + + +// --------------------------------------------------------------------------- + + +namespace +{ + +const size_t KEY_COUNT = 128; + + +// See Carbon -> HIToolbox -> Events.h for kVK_ constants + +const uint8_t KEYCODE_TO_DIK[KEY_COUNT] = +{ + DIK_A, DIK_S, DIK_D, DIK_F, DIK_H, DIK_G, DIK_Z, DIK_X, // 0x00 - 0x07 + DIK_C, DIK_V, 0, DIK_B, DIK_Q, DIK_W, DIK_E, DIK_R, // 0x08 - 0x0F + DIK_Y, DIK_T, DIK_1, DIK_2, DIK_3, DIK_4, DIK_6, DIK_5, // 0x10 - 0x17 + DIK_EQUALS, DIK_9, DIK_7, DIK_MINUS, DIK_8, DIK_0, DIK_RBRACKET, DIK_O, // 0x18 - 0x1F + DIK_U, DIK_LBRACKET, DIK_I, DIK_P, DIK_RETURN, DIK_L, DIK_J, DIK_APOSTROPHE, // 0x20 - 0x27 + DIK_K, DIK_SEMICOLON, DIK_BACKSLASH, DIK_COMMA, DIK_SLASH, DIK_N, DIK_M, DIK_PERIOD, // 0x28 - 0x2F + DIK_TAB, DIK_SPACE, DIK_GRAVE, DIK_BACK, 0, DIK_ESCAPE, 0, DIK_LWIN, // 0x30 - 0x37 + DIK_LSHIFT, DIK_CAPITAL, DIK_LMENU, DIK_LCONTROL, DIK_RSHIFT, DIK_RMENU, DIK_RCONTROL, 0, // 0x38 - 0x3F + 0, DIK_DECIMAL, 0, DIK_MULTIPLY, 0, DIK_ADD, 0, 0, // 0x40 - 0x47 + DIK_VOLUMEUP, DIK_VOLUMEDOWN, DIK_MUTE, DIK_SLASH, DIK_NUMPADENTER, 0, DIK_SUBTRACT, 0, // 0x48 - 0x4F + 0, DIK_NUMPAD_EQUALS, DIK_NUMPAD0, DIK_NUMPAD1, DIK_NUMPAD2, DIK_NUMPAD3, DIK_NUMPAD4, DIK_NUMPAD5, // 0x50 - 0x57 + DIK_NUMPAD6, DIK_NUMPAD7, 0, DIK_NUMPAD8, DIK_NUMPAD9, 0, 0, 0, // 0x58 - 0x5F + DIK_F5, DIK_F6, DIK_F7, DIK_F3, DIK_F8, DIK_F9, 0, DIK_F11, // 0x60 - 0x67 + 0, DIK_F13, 0, DIK_F14, 0, DIK_F10, 0, DIK_F12, // 0x68 - 0x6F + 0, DIK_F15, 0, DIK_HOME, 0, DIK_DELETE, DIK_F4, DIK_END, // 0x70 - 0x77 + DIK_F2, 0, DIK_F1, DIK_LEFT, DIK_RIGHT, DIK_DOWN, DIK_UP, 0, // 0x78 - 0x7F +}; + +const uint8_t KEYCODE_TO_ASCII[KEY_COUNT] = +{ + 'a', 's', 'd', 'f', 'h', 'g', 'z', 'x', // 0x00 - 0x07 + 'c', 'v', 0, 'b', 'q', 'w', 'e', 'r', // 0x08 - 0x0F + 'y', 't', '1', '2', '3', '4', '6', '5', // 0x10 - 0x17 + '=', '9', '7', '-', '8', '0', ']', 'o', // 0x18 - 0x1F + 'u', '[', 'i', 'p', 13, 'l', 'j', '\'', // 0x20 - 0x27 + 'k', ';', '\\', ',', '/', 'n', 'm', '.', // 0x28 - 0x2F + 9, ' ', '`', 12, 0, 27, 0, 0, // 0x30 - 0x37 + 0, 0, 0, 0, 0, 0, 0, 0, // 0x38 - 0x3F + 0, 0, 0, 0, 0, 0, 0, 0, // 0x40 - 0x47 + 0, 0, 0, 0, 0, 0, 0, 0, // 0x48 - 0x4F + 0, 0, 0, 0, 0, 0, 0, 0, // 0x50 - 0x57 + 0, 0, 0, 0, 0, 0, 0, 0, // 0x58 - 0x5F + 0, 0, 0, 0, 0, 0, 0, 0, // 0x60 - 0x67 + 0, 0, 0, 0, 0, 0, 0, 0, // 0x68 - 0x6F + 0, 0, 0, 0, 0, 0, 0, 0, // 0x70 - 0x77 + 0, 0, 0, 0, 0, 0, 0, 0, // 0x78 - 0x7F +}; + + +uint8_t ModifierToDIK(const uint32_t modifier) +{ + switch (modifier) + { + case NSAlphaShiftKeyMask: return DIK_CAPITAL; + case NSShiftKeyMask: return DIK_LSHIFT; + case NSControlKeyMask: return DIK_LCONTROL; + case NSAlternateKeyMask: return DIK_LMENU; + case NSCommandKeyMask: return DIK_LWIN; + } + + return 0; +} + +SWORD ModifierFlagsToGUIKeyModifiers(NSEvent* theEvent) +{ + const NSUInteger modifiers([theEvent modifierFlags] & NSDeviceIndependentModifierFlagsMask); + return ((modifiers & NSShiftKeyMask ) ? GKM_SHIFT : 0) + | ((modifiers & NSControlKeyMask ) ? GKM_CTRL : 0) + | ((modifiers & NSAlternateKeyMask) ? GKM_ALT : 0) + | ((modifiers & NSCommandKeyMask ) ? GKM_META : 0); +} + +bool ShouldGenerateGUICharEvent(NSEvent* theEvent) +{ + const NSUInteger modifiers([theEvent modifierFlags] & NSDeviceIndependentModifierFlagsMask); + return !(modifiers & NSControlKeyMask) + && !(modifiers & NSAlternateKeyMask) + && !(modifiers & NSCommandKeyMask) + && !(modifiers & NSFunctionKeyMask); +} + +void ProcessKeyboardFlagsEvent(NSEvent* theEvent) +{ + static const uint32_t FLAGS_MASK = + NSDeviceIndependentModifierFlagsMask & ~NSNumericPadKeyMask; + + const uint32_t modifiers = [theEvent modifierFlags] & FLAGS_MASK; + static uint32_t oldModifiers = 0; + const uint32_t deltaModifiers = modifiers ^ oldModifiers; + + if (0 == deltaModifiers) + { + return; + } + + event_t event = {}; + + event.type = modifiers > oldModifiers ? EV_KeyDown : EV_KeyUp; + event.data1 = ModifierToDIK(deltaModifiers); + + oldModifiers = modifiers; + + // Caps Lock is a modifier key which generates one event per state change + // but not per actual key press or release. So treat any event as key down + // Also its event should be not be posted in menu and console + + if (DIK_CAPITAL == event.data1) + { + if (GUICapture) + { + return; + } + + event.type = EV_KeyDown; + } + + D_PostEvent(&event); +} + +NSStringEncoding GetEncodingForUnicodeCharacter(const unichar character) +{ + if (character >= L'\u0100' && character <= L'\u024F') + { + return NSWindowsCP1250StringEncoding; // Central and Eastern Europe + } + else if (character >= L'\u0370' && character <= L'\u03FF') + { + return NSWindowsCP1253StringEncoding; // Greek + } + else if (character >= L'\u0400' && character <= L'\u04FF') + { + return NSWindowsCP1251StringEncoding; // Cyrillic + } + + // TODO: add handling for other characters + // TODO: Turkish should use NSWindowsCP1254StringEncoding + + return NSWindowsCP1252StringEncoding; +} + +unsigned char GetCharacterFromNSEvent(NSEvent* theEvent) +{ + const NSString* unicodeCharacters = [theEvent characters]; + + if (0 == [unicodeCharacters length]) + { + return '\0'; + } + + const unichar unicodeCharacter = [unicodeCharacters characterAtIndex:0]; + const NSStringEncoding encoding = GetEncodingForUnicodeCharacter(unicodeCharacter); + + unsigned char character = '\0'; + + if (NSWindowsCP1252StringEncoding == encoding) + { + // TODO: make sure that the following is always correct + character = unicodeCharacter & 0xFF; + } + else + { + const NSData* const characters = + [[theEvent characters] dataUsingEncoding:encoding]; + + character = [characters length] > 0 + ? *static_cast([characters bytes]) + : '\0'; + } + + return character; +} + +void ProcessKeyboardEventInMenu(NSEvent* theEvent) +{ + event_t event = {}; + + event.type = EV_GUI_Event; + event.subtype = NSKeyDown == [theEvent type] ? EV_GUI_KeyDown : EV_GUI_KeyUp; + event.data2 = GetCharacterFromNSEvent(theEvent); + event.data3 = ModifierFlagsToGUIKeyModifiers(theEvent); + + if (EV_GUI_KeyDown == event.subtype && [theEvent isARepeat]) + { + event.subtype = EV_GUI_KeyRepeat; + } + + const unsigned short keyCode = [theEvent keyCode]; + + switch (keyCode) + { + case kVK_Return: event.data1 = GK_RETURN; break; + case kVK_PageUp: event.data1 = GK_PGUP; break; + case kVK_PageDown: event.data1 = GK_PGDN; break; + case kVK_End: event.data1 = GK_END; break; + case kVK_Home: event.data1 = GK_HOME; break; + case kVK_LeftArrow: event.data1 = GK_LEFT; break; + case kVK_RightArrow: event.data1 = GK_RIGHT; break; + case kVK_UpArrow: event.data1 = GK_UP; break; + case kVK_DownArrow: event.data1 = GK_DOWN; break; + case kVK_Delete: event.data1 = GK_BACKSPACE; break; + case kVK_ForwardDelete: event.data1 = GK_DEL; break; + case kVK_Escape: event.data1 = GK_ESCAPE; break; + case kVK_F1: event.data1 = GK_F1; break; + case kVK_F2: event.data1 = GK_F2; break; + case kVK_F3: event.data1 = GK_F3; break; + case kVK_F4: event.data1 = GK_F4; break; + case kVK_F5: event.data1 = GK_F5; break; + case kVK_F6: event.data1 = GK_F6; break; + case kVK_F7: event.data1 = GK_F7; break; + case kVK_F8: event.data1 = GK_F8; break; + case kVK_F9: event.data1 = GK_F9; break; + case kVK_F10: event.data1 = GK_F10; break; + case kVK_F11: event.data1 = GK_F11; break; + case kVK_F12: event.data1 = GK_F12; break; + default: + event.data1 = KEYCODE_TO_ASCII[keyCode]; + break; + } + + if (event.data1 < 128) + { + event.data1 = toupper(event.data1); + + D_PostEvent(&event); + } + + if (!iscntrl(event.data2) + && EV_GUI_KeyUp != event.subtype + && ShouldGenerateGUICharEvent(theEvent)) + { + event.subtype = EV_GUI_Char; + event.data1 = event.data2; + event.data2 = event.data3 & GKM_ALT; + + D_PostEvent(&event); + } +} + +void ProcessKeyboardEvent(NSEvent* theEvent) +{ + const unsigned short keyCode = [theEvent keyCode]; + if (keyCode >= KEY_COUNT) + { + assert(!"Unknown keycode"); + return; + } + + if (GUICapture) + { + ProcessKeyboardEventInMenu(theEvent); + } + else + { + event_t event = {}; + + event.type = NSKeyDown == [theEvent type] ? EV_KeyDown : EV_KeyUp; + event.data1 = KEYCODE_TO_DIK[ keyCode ]; + + if (0 != event.data1) + { + event.data2 = KEYCODE_TO_ASCII[ keyCode ]; + + D_PostEvent(&event); + } + } +} + + +bool IsHiDPISupported() +{ +#ifdef NSAppKitVersionNumber10_7 + return NSAppKitVersionNumber >= NSAppKitVersionNumber10_7; +#else // !NSAppKitVersionNumber10_7 + return false; +#endif // NSAppKitVersionNumber10_7 +} + +NSSize GetRealContentViewSize(const NSWindow* const window) +{ + const NSView* view = [window contentView]; + const NSSize frameSize = [view frame].size; + + // TODO: figure out why [NSView frame] returns different values in "fullscreen" and in window + // In "fullscreen" the result is multiplied by [NSScreen backingScaleFactor], but not in window + + return (IsHiDPISupported() && NSNormalWindowLevel == [window level]) + ? [view convertSizeToBacking:frameSize] + : frameSize; +} + + +void NSEventToGameMousePosition(NSEvent* inEvent, event_t* outEvent) +{ + const NSWindow* window = [inEvent window]; + const NSView* view = [window contentView]; + + const NSPoint screenPos = [NSEvent mouseLocation]; + const NSPoint windowPos = [window convertScreenToBase:screenPos]; + + const NSPoint viewPos = IsHiDPISupported() + ? [view convertPointToBacking:windowPos] + : [view convertPointFromBase:windowPos]; + + const CGFloat frameHeight = GetRealContentViewSize(window).height; + + const CGFloat posX = ( viewPos.x - s_frameBufferParameters.shiftX) / s_frameBufferParameters.pixelScale; + const CGFloat posY = (frameHeight - viewPos.y - s_frameBufferParameters.shiftY) / s_frameBufferParameters.pixelScale; + + outEvent->data1 = static_cast< int >(posX); + outEvent->data2 = static_cast< int >(posY); +} + +void ProcessMouseButtonEvent(NSEvent* theEvent) +{ + event_t event = {}; + + const NSEventType cocoaEventType = [theEvent type]; + + if (GUICapture) + { + event.type = EV_GUI_Event; + + switch (cocoaEventType) + { + case NSLeftMouseDown: event.subtype = EV_GUI_LButtonDown; break; + case NSRightMouseDown: event.subtype = EV_GUI_RButtonDown; break; + case NSOtherMouseDown: event.subtype = EV_GUI_MButtonDown; break; + case NSLeftMouseUp: event.subtype = EV_GUI_LButtonUp; break; + case NSRightMouseUp: event.subtype = EV_GUI_RButtonUp; break; + case NSOtherMouseUp: event.subtype = EV_GUI_MButtonUp; break; + } + + NSEventToGameMousePosition(theEvent, &event); + + D_PostEvent(&event); + } + else + { + switch (cocoaEventType) + { + case NSLeftMouseDown: + case NSRightMouseDown: + case NSOtherMouseDown: + event.type = EV_KeyDown; + break; + + case NSLeftMouseUp: + case NSRightMouseUp: + case NSOtherMouseUp: + event.type = EV_KeyUp; + break; + } + + event.data1 = std::min(KEY_MOUSE1 + [theEvent buttonNumber], NSInteger(KEY_MOUSE8)); + + D_PostEvent(&event); + } +} + + +void ProcessMouseMoveInMenu(NSEvent* theEvent) +{ + event_t event = {}; + + event.type = EV_GUI_Event; + event.subtype = EV_GUI_MouseMove; + + NSEventToGameMousePosition(theEvent, &event); + + D_PostEvent(&event); +} + +void ProcessMouseMoveInGame(NSEvent* theEvent) +{ + if (!use_mouse) + { + return; + } + + // TODO: remove this magic! + + if (s_skipMouseMoves > 0) + { + --s_skipMouseMoves; + return; + } + + int x([theEvent deltaX]); + int y(-[theEvent deltaY]); + + if (0 == x && 0 == y) + { + return; + } + + if (!m_noprescale) + { + x *= 3; + y *= 2; + } + + event_t event = {}; + + static int lastX = 0, lastY = 0; + + if (m_filter) + { + event.x = (x + lastX) / 2; + event.y = (y + lastY) / 2; + } + else + { + event.x = x; + event.y = y; + } + + lastX = x; + lastY = y; + + if (0 != event.x | 0 != event.y) + { + event.type = EV_Mouse; + + D_PostEvent(&event); + } +} + +void ProcessMouseMoveEvent(NSEvent* theEvent) +{ + if (GUICapture) + { + ProcessMouseMoveInMenu(theEvent); + } + else + { + ProcessMouseMoveInGame(theEvent); + } +} + + +void ProcessMouseWheelEvent(NSEvent* theEvent) +{ + const CGFloat delta = [theEvent deltaY]; + const bool isZeroDelta = fabs(delta) < 1.0E-5; + + if (isZeroDelta && GUICapture) + { + return; + } + + event_t event = {}; + + if (GUICapture) + { + event.type = EV_GUI_Event; + event.subtype = delta > 0.0f ? EV_GUI_WheelUp : EV_GUI_WheelDown; + event.data3 = delta; + event.data3 = ModifierFlagsToGUIKeyModifiers(theEvent); + } + else + { + event.type = isZeroDelta ? EV_KeyUp : EV_KeyDown; + event.data1 = delta > 0.0f ? KEY_MWHEELUP : KEY_MWHEELDOWN; + } + + D_PostEvent(&event); +} + +} // unnamed namespace + + +// --------------------------------------------------------------------------- + + +@interface FullscreenWindow : NSWindow +{ + +} + +- (bool)canBecomeKeyWindow; + +- (void)close; + +@end + + +@implementation FullscreenWindow + +- (bool)canBecomeKeyWindow +{ + return true; +} + + +- (void)close +{ + [super close]; + + I_ShutdownJoysticks(); + + [NSApp terminate:self]; +} + +@end + + +// --------------------------------------------------------------------------- + + +@interface FullscreenView : NSOpenGLView +{ + +} + +- (void)resetCursorRects; + +@end + + +@implementation FullscreenView + +- (void)resetCursorRects +{ + [super resetCursorRects]; + [self addCursorRect: [self bounds] + cursor: s_cursor]; +} + +@end + + +// --------------------------------------------------------------------------- + + +@interface ApplicationDelegate : NSResponder +#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1070 + +#endif +{ +@private + FullscreenWindow* m_window; + + bool m_openGLInitialized; + int m_multisample; +} + +- (id)init; +- (void)dealloc; + +- (void)keyDown:(NSEvent*)theEvent; +- (void)keyUp:(NSEvent*)theEvent; + +- (void)applicationDidBecomeActive:(NSNotification*)aNotification; +- (void)applicationWillResignActive:(NSNotification*)aNotification; + +- (void)applicationDidFinishLaunching:(NSNotification*)aNotification; + +- (void)applicationWillTerminate:(NSNotification*)aNotification; + +- (BOOL)application:(NSApplication*)theApplication openFile:(NSString*)filename; + +- (int)multisample; +- (void)setMultisample:(int)multisample; + +- (void)initializeOpenGL; +- (void)changeVideoResolution:(bool)fullscreen width:(int)width height:(int)height; + +- (void)processEvents:(NSTimer*)timer; + +- (void)invalidateCursorRects; + +- (void)setMainWindowVisible:(bool)visible; + +@end + + +static ApplicationDelegate* s_applicationDelegate; + + +@implementation ApplicationDelegate + +- (id)init +{ + self = [super init]; + + m_openGLInitialized = false; + m_multisample = 0; + + return self; +} + +- (void)dealloc +{ + [m_window release]; + + [super dealloc]; +} + + +- (void)keyDown:(NSEvent*)theEvent +{ + // Empty but present to avoid playing of 'beep' alert sound + + ZD_UNUSED(theEvent); +} + +- (void)keyUp:(NSEvent*)theEvent +{ + // Empty but present to avoid playing of 'beep' alert sound + + ZD_UNUSED(theEvent); +} + + +- (void)applicationDidBecomeActive:(NSNotification*)aNotification +{ + ZD_UNUSED(aNotification); + + S_SetSoundPaused(1); +} + +- (void)applicationWillResignActive:(NSNotification*)aNotification +{ + ZD_UNUSED(aNotification); + + S_SetSoundPaused(0); +} + + +- (void)applicationDidFinishLaunching:(NSNotification*)aNotification +{ + // When starting from command line with real executable path, e.g. ZDoom.app/Contents/MacOS/ZDoom + // application remains deactivated for an unknown reason. + // The following call resolves this issue + [NSApp activateIgnoringOtherApps:YES]; + + // Setup timer for custom event loop + + NSTimer* timer = [NSTimer timerWithTimeInterval:0 + target:self + selector:@selector(processEvents:) + userInfo:nil + repeats:YES]; + [[NSRunLoop mainRunLoop] addTimer:timer + forMode:NSDefaultRunLoopMode]; + + exit(SDL_main(s_argc, s_argv)); +} + + +- (BOOL)application:(NSApplication*)theApplication openFile:(NSString*)filename +{ + ZD_UNUSED(theApplication); + + if (0 == [filename length] || s_argc + 2 >= ARGC_MAX) + { + return FALSE; + } + + // Some parameters from command line are passed to this function + // These parameters need to be skipped to avoid duplication + // Note: SDL has different approach to fix this issue, see the same method in SDLMain.m + + const char* const charFileName = [filename UTF8String]; + + for (int i = 0; i < s_argc; ++i) + { + if (0 == strcmp(s_argv[i], charFileName)) + { + return FALSE; + } + } + + s_argvStorage.Push("-file"); + s_argv[s_argc++] = s_argvStorage.Last().LockBuffer(); + + s_argvStorage.Push([filename UTF8String]); + s_argv[s_argc++] = s_argvStorage.Last().LockBuffer(); + + return TRUE; +} + + +- (void)applicationWillTerminate:(NSNotification*)aNotification +{ + ZD_UNUSED(aNotification); + + // Hide window as nothing will be rendered at this point + [m_window orderOut:nil]; +} + + +- (int)multisample +{ + return m_multisample; +} + +- (void)setMultisample:(int)multisample +{ + m_multisample = multisample; +} + + +- (void)initializeOpenGL +{ + if (m_openGLInitialized) + { + return; + } + + // Create window + + m_window = [[FullscreenWindow alloc] initWithContentRect:NSMakeRect(0, 0, 640, 480) + styleMask:NSTitledWindowMask | NSClosableWindowMask | NSMiniaturizableWindowMask + backing:NSBackingStoreBuffered + defer:NO]; + [m_window setOpaque:YES]; + [m_window makeFirstResponder:self]; + [m_window setAcceptsMouseMovedEvents:YES]; + + // Create OpenGL context and view + + NSOpenGLPixelFormatAttribute attributes[16]; + size_t i = 0; + + attributes[i++] = NSOpenGLPFADoubleBuffer; + attributes[i++] = NSOpenGLPFAColorSize; + attributes[i++] = 32; + attributes[i++] = NSOpenGLPFADepthSize; + attributes[i++] = 24; + attributes[i++] = NSOpenGLPFAStencilSize; + attributes[i++] = 8; + + if (m_multisample) + { + attributes[i++] = NSOpenGLPFAMultisample; + attributes[i++] = NSOpenGLPFASampleBuffers; + attributes[i++] = 1; + attributes[i++] = NSOpenGLPFASamples; + attributes[i++] = m_multisample; + } + + attributes[i] = 0; + + NSOpenGLPixelFormat *pixelFormat = [[NSOpenGLPixelFormat alloc] initWithAttributes:attributes]; + + const NSRect contentRect = [m_window contentRectForFrameRect:[m_window frame]]; + NSOpenGLView* glView = [[FullscreenView alloc] initWithFrame:contentRect + pixelFormat:pixelFormat]; + [[glView openGLContext] makeCurrentContext]; + + if (IsHiDPISupported()) + { + [glView setWantsBestResolutionOpenGLSurface:YES]; + } + + [m_window setContentView:glView]; + + m_openGLInitialized = true; +} + +- (void)changeVideoResolution:(bool)fullscreen width:(int)width height:(int)height +{ + [self initializeOpenGL]; + + CGLContextObj context = CGLGetCurrentContext(); + NSView* view = [m_window contentView]; + + if (fullscreen) + { + NSScreen* screen = [m_window screen]; + const NSRect screenFrame = [screen frame]; + const NSRect displayRect = IsHiDPISupported() + ? [screen convertRectToBacking:screenFrame] + : screenFrame; + + const float displayWidth = displayRect.size.width; + const float displayHeight = displayRect.size.height; + + const float pixelScaleFactorX = displayWidth / static_cast< float >(width ); + const float pixelScaleFactorY = displayHeight / static_cast< float >(height); + + s_frameBufferParameters.pixelScale = std::min(pixelScaleFactorX, pixelScaleFactorY); + + s_frameBufferParameters.width = width * s_frameBufferParameters.pixelScale; + s_frameBufferParameters.height = height * s_frameBufferParameters.pixelScale; + + s_frameBufferParameters.shiftX = (displayWidth - s_frameBufferParameters.width ) / 2.0f; + s_frameBufferParameters.shiftY = (displayHeight - s_frameBufferParameters.height) / 2.0f; + + [m_window setLevel:NSMainMenuWindowLevel + 1]; + [m_window setStyleMask:NSBorderlessWindowMask]; + [m_window setHidesOnDeactivate:YES]; + [m_window setFrame:displayRect display:YES]; + [m_window setFrameOrigin:NSMakePoint(0.0f, 0.0f)]; + } + else + { + s_frameBufferParameters.pixelScale = 1.0f; + + s_frameBufferParameters.width = static_cast< float >(width ); + s_frameBufferParameters.height = static_cast< float >(height); + + s_frameBufferParameters.shiftX = 0.0f; + s_frameBufferParameters.shiftY = 0.0f; + + const NSSize windowPixelSize = NSMakeSize(width, height); + const NSSize windowSize = IsHiDPISupported() + ? [view convertSizeFromBacking:windowPixelSize] + : windowPixelSize; + + [m_window setLevel:NSNormalWindowLevel]; + [m_window setStyleMask:NSTitledWindowMask | NSClosableWindowMask | NSMiniaturizableWindowMask]; + [m_window setHidesOnDeactivate:NO]; + [m_window setContentSize:windowSize]; + [m_window center]; + } + + const NSSize viewSize = GetRealContentViewSize(m_window); + + glViewport(0, 0, viewSize.width, viewSize.height); + glClearColor(0.0f, 0.0f, 0.0f, 0.0f); + glClear(GL_COLOR_BUFFER_BIT); + + CGLFlushDrawable(context); + + static NSString* const TITLE_STRING = + [NSString stringWithFormat:@"%s %s", GAMESIG, GetVersionString()]; + [m_window setTitle:TITLE_STRING]; + + if (![m_window isKeyWindow]) + { + [m_window makeKeyAndOrderFront:nil]; + } +} + + +- (void)processEvents:(NSTimer*)timer +{ + ZD_UNUSED(timer); + + while (true) + { + NSEvent* event = [NSApp nextEventMatchingMask:NSAnyEventMask + untilDate:[NSDate dateWithTimeIntervalSinceNow:0] + inMode:NSDefaultRunLoopMode + dequeue:YES]; + if (nil == event) + { + break; + } + + const NSEventType eventType = [event type]; + + switch (eventType) + { + case NSMouseMoved: + ProcessMouseMoveEvent(event); + break; + + case NSLeftMouseDown: + case NSLeftMouseUp: + case NSRightMouseDown: + case NSRightMouseUp: + case NSOtherMouseDown: + case NSOtherMouseUp: + ProcessMouseButtonEvent(event); + break; + + case NSLeftMouseDragged: + case NSRightMouseDragged: + case NSOtherMouseDragged: + ProcessMouseButtonEvent(event); + ProcessMouseMoveEvent(event); + break; + + case NSScrollWheel: + ProcessMouseWheelEvent(event); + break; + + case NSKeyDown: + case NSKeyUp: + ProcessKeyboardEvent(event); + break; + + case NSFlagsChanged: + ProcessKeyboardFlagsEvent(event); + break; + } + + [NSApp sendEvent:event]; + } + + [NSApp updateWindows]; +} + + +- (void)invalidateCursorRects +{ + [m_window invalidateCursorRectsForView:[m_window contentView]]; +} + + +- (void)setMainWindowVisible:(bool)visible +{ + if (visible) + { + [m_window orderFront:nil]; + } + else + { + [m_window orderOut:nil]; + } +} + +@end + + +// --------------------------------------------------------------------------- + + +void I_SetMainWindowVisible(bool visible) +{ + [s_applicationDelegate setMainWindowVisible:visible]; + + SetNativeMouse(!visible); +} + + +// --------------------------------------------------------------------------- + + +bool I_SetCursor(FTexture* cursorpic) +{ + if (NULL == cursorpic || FTexture::TEX_Null == cursorpic->UseType) + { + s_cursor = [NSCursor arrowCursor]; + } + else + { + // Create bitmap image representation + + const NSInteger imageWidth = cursorpic->GetWidth(); + const NSInteger imageHeight = cursorpic->GetHeight(); + const NSInteger imagePitch = imageWidth * 4; + + NSBitmapImageRep* bitmapImageRep = [NSBitmapImageRep alloc]; + [bitmapImageRep initWithBitmapDataPlanes:NULL + pixelsWide:imageWidth + pixelsHigh:imageHeight + bitsPerSample:8 + samplesPerPixel:4 + hasAlpha:YES + isPlanar:NO + colorSpaceName:NSDeviceRGBColorSpace + bytesPerRow:imagePitch + bitsPerPixel:0]; + + // Load bitmap data to representation + + BYTE* buffer = [bitmapImageRep bitmapData]; + FBitmap bitmap(buffer, imagePitch, imageWidth, imageHeight); + cursorpic->CopyTrueColorPixels(&bitmap, 0, 0); + + // Swap red and blue components in each pixel + + for (size_t i = 0; i < size_t(imageWidth * imageHeight); ++i) + { + const size_t offset = i * 4; + + const BYTE temp = buffer[offset ]; + buffer[offset ] = buffer[offset + 2]; + buffer[offset + 2] = temp; + } + + // Create image from representation and set it as cursor + + NSData* imageData = [bitmapImageRep representationUsingType:NSPNGFileType + properties:nil]; + NSImage* cursorImage = [[NSImage alloc] initWithData:imageData]; + + s_cursor = [[NSCursor alloc] initWithImage:cursorImage + hotSpot:NSMakePoint(0.0f, 0.0f)]; + } + + [s_applicationDelegate invalidateCursorRects]; + + return true; +} + + +// --------------------------------------------------------------------------- + + +extern "C" +{ + +struct SDL_mutex +{ + pthread_mutex_t mutex; +}; + + +SDL_mutex* SDL_CreateMutex() +{ + pthread_mutexattr_t attributes; + pthread_mutexattr_init(&attributes); + pthread_mutexattr_settype(&attributes, PTHREAD_MUTEX_RECURSIVE); + + SDL_mutex* result = new SDL_mutex; + + if (0 != pthread_mutex_init(&result->mutex, &attributes)) + { + delete result; + result = NULL; + } + + pthread_mutexattr_destroy(&attributes); + + return result; +} + +int SDL_mutexP(SDL_mutex* mutex) +{ + return pthread_mutex_lock(&mutex->mutex); +} + +int SDL_mutexV(SDL_mutex* mutex) +{ + return pthread_mutex_unlock(&mutex->mutex); +} + +void SDL_DestroyMutex(SDL_mutex* mutex) +{ + pthread_mutex_destroy(&mutex->mutex); + delete mutex; +} + + +static timeval s_startTicks; + +uint32_t SDL_GetTicks() +{ + timeval now; + gettimeofday(&now, NULL); + + const uint32_t ticks = + (now.tv_sec - s_startTicks.tv_sec ) * 1000 + + (now.tv_usec - s_startTicks.tv_usec) / 1000; + + return ticks; +} + + +int SDL_Init(Uint32 flags) +{ + ZD_UNUSED(flags); + + return 0; +} + +void SDL_Quit() +{ + if (NULL != s_applicationDelegate) + { + [NSApp setDelegate:nil]; + [NSApp deactivate]; + + [s_applicationDelegate release]; + s_applicationDelegate = NULL; + } +} + + +char* SDL_GetError() +{ + static char empty[] = {0}; + return empty; +} + + +char* SDL_VideoDriverName(char* namebuf, int maxlen) +{ + return strncpy(namebuf, "Native OpenGL", maxlen); +} + +const SDL_VideoInfo* SDL_GetVideoInfo() +{ + // NOTE: Only required fields are assigned + + static SDL_PixelFormat pixelFormat; + memset(&pixelFormat, 0, sizeof(pixelFormat)); + + pixelFormat.BitsPerPixel = 32; + + static SDL_VideoInfo videoInfo; + memset(&videoInfo, 0, sizeof(videoInfo)); + + const NSRect displayRect = [[NSScreen mainScreen] frame]; + + videoInfo.current_w = displayRect.size.width; + videoInfo.current_h = displayRect.size.height; + videoInfo.vfmt = &pixelFormat; + + return &videoInfo; +} + +SDL_Rect** SDL_ListModes(SDL_PixelFormat* format, Uint32 flags) +{ + ZD_UNUSED(format); + ZD_UNUSED(flags); + + static std::vector< SDL_Rect* > resolutions; + + if (resolutions.empty()) + { +#define DEFINE_RESOLUTION(WIDTH, HEIGHT) \ + static SDL_Rect resolution_##WIDTH##_##HEIGHT = { 0, 0, WIDTH, HEIGHT }; \ + resolutions.push_back(&resolution_##WIDTH##_##HEIGHT); + + DEFINE_RESOLUTION(640, 480); + DEFINE_RESOLUTION(720, 480); + DEFINE_RESOLUTION(800, 600); + DEFINE_RESOLUTION(1024, 640); + DEFINE_RESOLUTION(1024, 768); + DEFINE_RESOLUTION(1152, 720); + DEFINE_RESOLUTION(1280, 720); + DEFINE_RESOLUTION(1280, 800); + DEFINE_RESOLUTION(1280, 960); + DEFINE_RESOLUTION(1280, 1024); + DEFINE_RESOLUTION(1366, 768); + DEFINE_RESOLUTION(1400, 1050); + DEFINE_RESOLUTION(1440, 900); + DEFINE_RESOLUTION(1600, 900); + DEFINE_RESOLUTION(1600, 1200); + DEFINE_RESOLUTION(1680, 1050); + DEFINE_RESOLUTION(1920, 1080); + DEFINE_RESOLUTION(1920, 1200); + DEFINE_RESOLUTION(2048, 1536); + DEFINE_RESOLUTION(2560, 1440); + DEFINE_RESOLUTION(2560, 1600); + DEFINE_RESOLUTION(2880, 1800); + +#undef DEFINE_RESOLUTION + + resolutions.push_back(NULL); + } + + return &resolutions[0]; +} + + +//static GLAuxilium::Texture2D* s_softwareTexture; +static GLuint s_frameBufferTexture = 0; + +static const Uint16 BYTES_PER_PIXEL = 4; + +static SDL_PixelFormat* GetPixelFormat() +{ + static SDL_PixelFormat result; + + result.palette = NULL; + result.BitsPerPixel = BYTES_PER_PIXEL * 8; + result.BytesPerPixel = BYTES_PER_PIXEL; + result.Rloss = 0; + result.Gloss = 0; + result.Bloss = 0; + result.Aloss = 8; + result.Rshift = 8; + result.Gshift = 16; + result.Bshift = 24; + result.Ashift = 0; + result.Rmask = 0x000000FF; + result.Gmask = 0x0000FF00; + result.Bmask = 0x00FF0000; + result.Amask = 0xFF000000; + result.colorkey = 0; + result.alpha = 0xFF; + + return &result; +} + + +SDL_Surface* SDL_SetVideoMode(int width, int height, int, Uint32 flags) +{ + [s_applicationDelegate changeVideoResolution:(SDL_FULLSCREEN & flags) width:width height:height]; + + static SDL_Surface result; + + const bool isSoftwareRenderer = !(SDL_OPENGL & flags); + + if (isSoftwareRenderer) + { + if (NULL != result.pixels) + { + free(result.pixels); + } + + if (0 != s_frameBufferTexture) + { + glBindTexture(GL_TEXTURE_2D, 0); + glDeleteTextures(1, &s_frameBufferTexture); + s_frameBufferTexture = 0; + } + } + + result.flags = flags; + result.format = GetPixelFormat(); + result.w = width; + result.h = height; + result.pitch = width * BYTES_PER_PIXEL; + result.pixels = isSoftwareRenderer ? malloc(width * height * BYTES_PER_PIXEL) : NULL; + result.refcount = 1; + + result.clip_rect.x = 0; + result.clip_rect.y = 0; + result.clip_rect.w = width; + result.clip_rect.h = height; + + return &result; +} + + +void SDL_WM_SetCaption(const char* title, const char* icon) +{ + ZD_UNUSED(title); + ZD_UNUSED(icon); + + // Window title is set in SDL_SetVideoMode() +} + +static void ResetSoftwareViewport() +{ + // For an unknown reason the following call to glClear() is needed + // to avoid drawing of garbage in fullscreen mode + // when game video resolution's aspect ratio is different from display one + + GLint viewport[2]; + glGetIntegerv(GL_MAX_VIEWPORT_DIMS, viewport); + + glViewport(0, 0, viewport[0], viewport[1]); + glClear(GL_COLOR_BUFFER_BIT); + + glViewport(s_frameBufferParameters.shiftX, s_frameBufferParameters.shiftY, + s_frameBufferParameters.width, s_frameBufferParameters.height); +} + +int SDL_WM_ToggleFullScreen(SDL_Surface* surface) +{ + if (surface->flags & SDL_FULLSCREEN) + { + surface->flags &= ~SDL_FULLSCREEN; + } + else + { + surface->flags |= SDL_FULLSCREEN; + } + + [s_applicationDelegate changeVideoResolution:(SDL_FULLSCREEN & surface->flags) + width:surface->w + height:surface->h]; + ResetSoftwareViewport(); + + return 1; +} + + +void SDL_GL_SwapBuffers() +{ + [[NSOpenGLContext currentContext] flushBuffer]; +} + +int SDL_LockSurface(SDL_Surface* surface) +{ + ZD_UNUSED(surface); + + return 0; +} + +void SDL_UnlockSurface(SDL_Surface* surface) +{ + ZD_UNUSED(surface); +} + +int SDL_BlitSurface(SDL_Surface* src, SDL_Rect* srcrect, SDL_Surface* dst, SDL_Rect* dstrect) +{ + ZD_UNUSED(src); + ZD_UNUSED(srcrect); + ZD_UNUSED(dst); + ZD_UNUSED(dstrect); + + return 0; +} + + +static void SetupSoftwareRendering(SDL_Surface* screen) +{ + glMatrixMode(GL_MODELVIEW); + glLoadIdentity(); + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + glOrtho(0.0, screen->w, screen->h, 0.0, -1.0, 1.0); + + ResetSoftwareViewport(); + + glEnable(GL_TEXTURE_2D); + + glGenTextures(1, &s_frameBufferTexture); + glBindTexture(GL_TEXTURE_2D, s_frameBufferTexture); + + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); +} + +int SDL_Flip(SDL_Surface* screen) +{ + assert(NULL != screen); + + if (0 == s_frameBufferTexture) + { + SetupSoftwareRendering(screen); + } + + const int width = screen->w; + const int height = screen->h; + + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, + width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, screen->pixels); + + glBegin(GL_QUADS); + glColor4f(1.0f, 1.0f, 1.0f, 1.0f); + glTexCoord2f(0.0f, 0.0f); + glVertex2f(0.0f, 0.0f); + glTexCoord2f(1.0f, 0.0f); + glVertex2f(width, 0.0f); + glTexCoord2f(1.0f, 1.0f); + glVertex2f(width, height); + glTexCoord2f(0.0f, 1.0f); + glVertex2f(0.0f, height); + glEnd(); + + glFlush(); + + SDL_GL_SwapBuffers(); + + return 0; +} + +int SDL_SetPalette(SDL_Surface* surface, int flags, SDL_Color* colors, int firstcolor, int ncolors) +{ + ZD_UNUSED(surface); + ZD_UNUSED(flags); + ZD_UNUSED(colors); + ZD_UNUSED(firstcolor); + ZD_UNUSED(ncolors); + + return 0; +} + +} // extern "C" + +#ifdef main +#undef main +#endif // main + +static void CheckOSVersion() +{ + static const char* const PARAMETER_NAME = "kern.osrelease"; + + size_t size = 0; + + if (-1 == sysctlbyname(PARAMETER_NAME, NULL, &size, NULL, 0)) + { + return; + } + + char* version = static_cast(alloca(size)); + + if (-1 == sysctlbyname(PARAMETER_NAME, version, &size, NULL, 0)) + { + return; + } + + if (strcmp(version, "10.0") < 0) + { + CFOptionFlags responseFlags; + CFUserNotificationDisplayAlert(0, kCFUserNotificationStopAlertLevel, NULL, NULL, NULL, + CFSTR("Unsupported version of OS X"), CFSTR("You need OS X 10.6 or higher running on Intel platform in order to play."), + NULL, NULL, NULL, &responseFlags); + + exit(EXIT_FAILURE); + } +} + +int main(int argc, char** argv) +{ + CheckOSVersion(); + + gettimeofday(&s_startTicks, NULL); + + for (int i = 0; i <= argc; ++i) + { + const char* const argument = argv[i]; + + if (NULL == argument || '\0' == argument[0]) + { + continue; + } + + s_argvStorage.Push(argument); + s_argv[s_argc++] = s_argvStorage.Last().LockBuffer(); + } + + NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init]; + + [NSApplication sharedApplication]; + [NSBundle loadNibNamed:@"zdoom" owner:NSApp]; + + s_applicationDelegate = [ApplicationDelegate new]; + [NSApp setDelegate:s_applicationDelegate]; + + [NSApp run]; + + [pool release]; + + return EXIT_SUCCESS; +} diff --git a/src/cocoa/i_joystick.cpp b/src/cocoa/i_joystick.cpp new file mode 100644 index 0000000000..add1b1bd76 --- /dev/null +++ b/src/cocoa/i_joystick.cpp @@ -0,0 +1,776 @@ +/* + ** i_joystick.cpp + ** + **--------------------------------------------------------------------------- + ** Copyright 2012-2014 Alexey Lysiuk + ** All rights reserved. + ** + ** Redistribution and use in source and binary forms, with or without + ** modification, are permitted provided that the following conditions + ** are met: + ** + ** 1. Redistributions of source code must retain the above copyright + ** notice, this list of conditions and the following disclaimer. + ** 2. Redistributions in binary form must reproduce the above copyright + ** notice, this list of conditions and the following disclaimer in the + ** documentation and/or other materials provided with the distribution. + ** 3. The name of the author may not be used to endorse or promote products + ** derived from this software without specific prior written permission. + ** + ** THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + ** IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + ** OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + ** IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + ** INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + ** NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + ** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + ** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + ** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + ** THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + **--------------------------------------------------------------------------- + ** + */ + +#include "m_joy.h" + +#include "HID_Utilities_External.h" + +#include "d_event.h" +#include "doomdef.h" +#include "templates.h" + + +namespace +{ + +FString ToFString( const CFStringRef string ) +{ + if ( NULL == string ) + { + return FString(); + } + + const CFIndex stringLength = CFStringGetLength( string ); + + if ( 0 == stringLength ) + { + return FString(); + } + + const size_t bufferSize = CFStringGetMaximumSizeForEncoding( stringLength, kCFStringEncodingUTF8 ) + 1; + + char buffer[ bufferSize ]; + memset( buffer, 0, bufferSize ); + + CFStringGetCString( string, buffer, bufferSize, kCFStringEncodingUTF8 ); + + return FString( buffer ); +} + + +class IOKitJoystick : public IJoystickConfig +{ +public: + explicit IOKitJoystick( IOHIDDeviceRef device ); + virtual ~IOKitJoystick(); + + virtual FString GetName(); + virtual float GetSensitivity(); + virtual void SetSensitivity( float scale ); + + virtual int GetNumAxes(); + virtual float GetAxisDeadZone( int axis ); + virtual EJoyAxis GetAxisMap( int axis ); + virtual const char* GetAxisName( int axis ); + virtual float GetAxisScale( int axis ); + + virtual void SetAxisDeadZone( int axis, float deadZone ); + virtual void SetAxisMap( int axis, EJoyAxis gameAxis ); + virtual void SetAxisScale( int axis, float scale ); + + virtual bool IsSensitivityDefault(); + virtual bool IsAxisDeadZoneDefault( int axis ); + virtual bool IsAxisMapDefault( int axis ); + virtual bool IsAxisScaleDefault( int axis ); + + virtual void SetDefaultConfig(); + virtual FString GetIdentifier(); + + void AddAxes( float axes[ NUM_JOYAXIS ] ) const; + + void Update(); + +private: + IOHIDDeviceRef m_device; + + float m_sensitivity; + + struct AxisInfo + { + char name[ 64 ]; + + float value; + + float deadZone; + float defaultDeadZone; + float sensitivity; + float defaultSensitivity; + + EJoyAxis gameAxis; + EJoyAxis defaultGameAxis; + + IOHIDElementRef element; + }; + + TArray< AxisInfo > m_axes; + + TArray< IOHIDElementRef > m_buttons; + TArray< IOHIDElementRef > m_POVs; + + + static const float DEFAULT_DEADZONE; + static const float DEFAULT_SENSITIVITY; + + + bool ProcessAxis ( const IOHIDValueRef value ); + bool ProcessButton( const IOHIDValueRef value ); + bool ProcessPOV ( const IOHIDValueRef value ); + +}; + + +const float IOKitJoystick::DEFAULT_DEADZONE = 0.25f; +const float IOKitJoystick::DEFAULT_SENSITIVITY = 1.0f; + + +IOKitJoystick::IOKitJoystick( IOHIDDeviceRef device ) +: m_device( device ) +, m_sensitivity( DEFAULT_SENSITIVITY ) +{ + IOHIDElementRef element = HIDGetFirstDeviceElement( device, kHIDElementTypeInput ); + + while ( NULL != element ) + { + const uint32_t usagePage = IOHIDElementGetUsagePage( element ); + + if ( kHIDPage_GenericDesktop == usagePage ) + { + const uint32_t usage = IOHIDElementGetUsage( element ); + + if ( kHIDUsage_GD_Slider == usage + || kHIDUsage_GD_X == usage || kHIDUsage_GD_Y == usage || kHIDUsage_GD_Z == usage + || kHIDUsage_GD_Rx == usage || kHIDUsage_GD_Ry == usage || kHIDUsage_GD_Rz == usage ) + { + AxisInfo axis; + memset( &axis, 0, sizeof( axis ) ); + + if ( const CFStringRef name = IOHIDElementGetName( element ) ) + { + CFStringGetCString( name, axis.name, sizeof( axis.name ) - 1, kCFStringEncodingUTF8 ); + } + else + { + snprintf( axis.name, sizeof( axis.name ), "Axis %i", m_axes.Size() + 1 ); + } + + axis.element = element; + + m_axes.Push( axis ); + + IOHIDElement_SetCalibrationMin( element, -1 ); + IOHIDElement_SetCalibrationMax( element, 1 ); + + HIDQueueElement( m_device, element ); + } + else if ( kHIDUsage_GD_Hatswitch == usage && m_POVs.Size() < 4 ) + { + m_POVs.Push( element ); + + HIDQueueElement( m_device, element ); + } + } + else if ( kHIDPage_Button == usagePage ) + { + m_buttons.Push( element ); + + HIDQueueElement( m_device, element ); + } + + element = HIDGetNextDeviceElement( element, kHIDElementTypeInput ); + } + + SetDefaultConfig(); +} + +IOKitJoystick::~IOKitJoystick() +{ + M_SaveJoystickConfig( this ); +} + + +FString IOKitJoystick::GetName() +{ + FString result; + + result += ToFString( IOHIDDevice_GetManufacturer( m_device ) ); + result += " "; + result += ToFString( IOHIDDevice_GetProduct( m_device ) ); + + return result; +} + + +float IOKitJoystick::GetSensitivity() +{ + return m_sensitivity; +} + +void IOKitJoystick::SetSensitivity( float scale ) +{ + m_sensitivity = scale; +} + + +int IOKitJoystick::GetNumAxes() +{ + return static_cast< int >( m_axes.Size() ); +} + +#define IS_AXIS_VALID ( static_cast< unsigned int >( axis ) < m_axes.Size() ) + +float IOKitJoystick::GetAxisDeadZone( int axis ) +{ + return IS_AXIS_VALID ? m_axes[ axis ].deadZone : 0.0f; +} + +EJoyAxis IOKitJoystick::GetAxisMap( int axis ) +{ + return IS_AXIS_VALID ? m_axes[ axis ].gameAxis : JOYAXIS_None; +} + +const char* IOKitJoystick::GetAxisName( int axis ) +{ + return IS_AXIS_VALID ? m_axes[ axis ].name : "Invalid"; +} + +float IOKitJoystick::GetAxisScale( int axis ) +{ + return IS_AXIS_VALID ? m_axes[ axis ].sensitivity : 0.0f; +} + +void IOKitJoystick::SetAxisDeadZone( int axis, float deadZone ) +{ + if ( IS_AXIS_VALID ) + { + m_axes[ axis ].deadZone = clamp( deadZone, 0.0f, 1.0f ); + } +} + +void IOKitJoystick::SetAxisMap( int axis, EJoyAxis gameAxis ) +{ + if ( IS_AXIS_VALID ) + { + m_axes[ axis ].gameAxis = ( gameAxis > JOYAXIS_None && gameAxis < NUM_JOYAXIS ) + ? gameAxis + : JOYAXIS_None; + } +} + +void IOKitJoystick::SetAxisScale( int axis, float scale ) +{ + if ( IS_AXIS_VALID ) + { + m_axes[ axis ].sensitivity = scale; + } +} + + +bool IOKitJoystick::IsSensitivityDefault() +{ + return DEFAULT_SENSITIVITY == m_sensitivity; +} + +bool IOKitJoystick::IsAxisDeadZoneDefault( int axis ) +{ + return IS_AXIS_VALID + ? ( m_axes[ axis ].deadZone == m_axes[ axis ].defaultDeadZone ) + : true; +} + +bool IOKitJoystick::IsAxisMapDefault( int axis ) +{ + return IS_AXIS_VALID + ? ( m_axes[ axis ].gameAxis == m_axes[ axis ].defaultGameAxis ) + : true; +} + +bool IOKitJoystick::IsAxisScaleDefault( int axis ) +{ + return IS_AXIS_VALID + ? ( m_axes[ axis ].sensitivity == m_axes[ axis ].defaultSensitivity ) + : true; +} + +#undef IS_AXIS_VALID + +void IOKitJoystick::SetDefaultConfig() +{ + m_sensitivity = DEFAULT_SENSITIVITY; + + const size_t axisCount = m_axes.Size(); + + for ( size_t i = 0; i < axisCount; ++i ) + { + m_axes[i].deadZone = DEFAULT_DEADZONE; + m_axes[i].sensitivity = DEFAULT_SENSITIVITY; + m_axes[i].gameAxis = JOYAXIS_None; + } + + // Two axes? Horizontal is yaw and vertical is forward. + + if ( 2 == axisCount) + { + m_axes[0].gameAxis = JOYAXIS_Yaw; + m_axes[1].gameAxis = JOYAXIS_Forward; + } + + // Three axes? First two are movement, third is yaw. + + else if ( axisCount >= 3 ) + { + m_axes[0].gameAxis = JOYAXIS_Side; + m_axes[1].gameAxis = JOYAXIS_Forward; + m_axes[2].gameAxis = JOYAXIS_Yaw; + + // Four axes? First two are movement, last two are looking around. + + if ( axisCount >= 4 ) + { + m_axes[3].gameAxis = JOYAXIS_Pitch; +// ??? m_axes[3].sensitivity = 0.75f; + + // Five axes? Use the fifth one for moving up and down. + + if ( axisCount >= 5 ) + { + m_axes[4].gameAxis = JOYAXIS_Up; + } + } + } + + // If there is only one axis, then we make no assumptions about how + // the user might want to use it. + + // Preserve defaults for config saving. + + for ( size_t i = 0; i < axisCount; ++i ) + { + m_axes[i].defaultDeadZone = m_axes[i].deadZone; + m_axes[i].defaultSensitivity = m_axes[i].sensitivity; + m_axes[i].defaultGameAxis = m_axes[i].gameAxis; + } +} + + +FString IOKitJoystick::GetIdentifier() +{ + char identifier[ 32 ] = {0}; + + snprintf( identifier, sizeof( identifier ), "VID_%04lx_PID_%04lx", + IOHIDDevice_GetVendorID( m_device ), IOHIDDevice_GetProductID( m_device ) ); + + return FString( identifier ); +} + + +void IOKitJoystick::AddAxes( float axes[ NUM_JOYAXIS ] ) const +{ + for ( size_t i = 0, count = m_axes.Size(); i < count; ++i ) + { + const EJoyAxis axis = m_axes[i].gameAxis; + + if ( JOYAXIS_None == axis ) + { + continue; + } + + axes[ axis ] -= m_axes[i].value; + } +} + + +void IOKitJoystick::Update() +{ + IOHIDValueRef value = NULL; + + while ( HIDGetEvent( m_device, &value ) && NULL != value ) + { + ProcessAxis( value ) || ProcessButton( value ) || ProcessPOV( value ); + + CFRelease( value ); + } +} + + +bool IOKitJoystick::ProcessAxis( const IOHIDValueRef value ) +{ + const IOHIDElementRef element = IOHIDValueGetElement( value ); + + if ( NULL == element ) + { + return false; + } + + for ( size_t i = 0, count = m_axes.Size(); i < count; ++i ) + { + if ( element != m_axes[i].element ) + { + continue; + } + + AxisInfo& axis = m_axes[i]; + + const double scaledValue = IOHIDValueGetScaledValue( value, kIOHIDValueScaleTypeCalibrated ); + const double filteredValue = Joy_RemoveDeadZone( scaledValue, axis.deadZone, NULL ); + + axis.value = static_cast< float >( filteredValue * m_sensitivity * axis.sensitivity ); + + return true; + } + + return false; +} + +bool IOKitJoystick::ProcessButton( const IOHIDValueRef value ) +{ + const IOHIDElementRef element = IOHIDValueGetElement( value ); + + if ( NULL == element ) + { + return false; + } + + for ( size_t i = 0, count = m_buttons.Size(); i < count; ++i ) + { + if ( element != m_buttons[i] ) + { + continue; + } + + const int newButton = IOHIDValueGetIntegerValue( value ) & 1; + const int oldButton = ~newButton; + + Joy_GenerateButtonEvents( oldButton, newButton, 1, + static_cast< int >( KEY_FIRSTJOYBUTTON + i ) ); + + return true; + } + + return false; +} + +bool IOKitJoystick::ProcessPOV( const IOHIDValueRef value ) +{ + const IOHIDElementRef element = IOHIDValueGetElement( value ); + + if ( NULL == element ) + { + return false; + } + + for ( size_t i = 0, count = m_POVs.Size(); i < count; ++i ) + { + if ( element != m_POVs[i] ) + { + continue; + } + + const CFIndex direction = IOHIDValueGetIntegerValue( value ); + + // Default values is for Up/North + int oldButtons = 0; + int newButtons = 1; + int numButtons = 1; + int baseButton = KEY_JOYPOV1_UP; + + switch ( direction ) + { + case 0: // N + break; + + case 1: // NE + newButtons = 3; + numButtons = 2; + break; + + case 2: // E + baseButton = KEY_JOYPOV1_RIGHT; + break; + + case 3: // SE + newButtons = 3; + numButtons = 2; + baseButton = KEY_JOYPOV1_RIGHT; + break; + + case 4: // S + baseButton = KEY_JOYPOV1_DOWN; + break; + + case 5: // SW + newButtons = 3; + numButtons = 2; + baseButton = KEY_JOYPOV1_DOWN; + break; + + case 6: // W + baseButton = KEY_JOYPOV1_LEFT; + break; + + case 7: // NW + newButtons = 9; // UP and LEFT + numButtons = 4; + break; + + default: + // release all four directions + oldButtons = 15; + newButtons = 0; + numButtons = 4; + break; + } + + Joy_GenerateButtonEvents( oldButtons, newButtons, numButtons, + static_cast< int >( baseButton + i * 4 ) ); + } + + return false; +} + + +// --------------------------------------------------------------------------- + + +class IOKitJoystickManager +{ +public: + IOKitJoystickManager(); + ~IOKitJoystickManager(); + + void GetJoysticks( TArray< IJoystickConfig* >& joysticks ) const; + + void AddAxes( float axes[ NUM_JOYAXIS ] ) const; + + // Updates axes/buttons states + void Update(); + + // Rebuilds device list + void Rescan(); + +private: + TArray< IOKitJoystick* > m_joysticks; + + static void OnDeviceChanged( void* context, IOReturn result, void* sender, IOHIDDeviceRef device ); + + void ReleaseJoysticks(); + + void EnableCallbacks(); + void DisableCallbacks(); + +}; + + +IOKitJoystickManager::IOKitJoystickManager() +{ + Rescan(); +} + +IOKitJoystickManager::~IOKitJoystickManager() +{ + ReleaseJoysticks(); + DisableCallbacks(); + + HIDReleaseDeviceList(); +} + + +void IOKitJoystickManager::GetJoysticks( TArray< IJoystickConfig* >& joysticks ) const +{ + const size_t joystickCount = m_joysticks.Size(); + + joysticks.Resize( joystickCount ); + + for ( size_t i = 0; i < joystickCount; ++i ) + { + M_LoadJoystickConfig( m_joysticks[i] ); + + joysticks[i] = m_joysticks[i]; + } +} + +void IOKitJoystickManager::AddAxes( float axes[ NUM_JOYAXIS ] ) const +{ + for ( size_t i = 0, count = m_joysticks.Size(); i < count; ++i ) + { + m_joysticks[i]->AddAxes( axes ); + } +} + + +void IOKitJoystickManager::Update() +{ + for ( size_t i = 0, count = m_joysticks.Size(); i < count; ++i ) + { + m_joysticks[i]->Update(); + } +} + + +void IOKitJoystickManager::Rescan() +{ + ReleaseJoysticks(); + DisableCallbacks(); + + const int usageCount = 2; + + const UInt32 usagePages[ usageCount ] = + { + kHIDPage_GenericDesktop, + kHIDPage_GenericDesktop + }; + + const UInt32 usages[ usageCount ] = + { + kHIDUsage_GD_Joystick, + kHIDUsage_GD_GamePad + }; + + if ( HIDUpdateDeviceList( usagePages, usages, usageCount ) ) + { + IOHIDDeviceRef device = HIDGetFirstDevice(); + + while ( NULL != device ) + { + IOKitJoystick* joystick = new IOKitJoystick( device ); + m_joysticks.Push( joystick ); + + device = HIDGetNextDevice( device ); + } + } + else + { + Printf( "IOKitJoystickManager: Failed to build gamepad/joystick device list.\n" ); + } + + EnableCallbacks(); +} + + +void IOKitJoystickManager::OnDeviceChanged( void* context, IOReturn result, void* sender, IOHIDDeviceRef device ) +{ + event_t event; + + memset( &event, 0, sizeof( event ) ); + event.type = EV_DeviceChange; + + D_PostEvent( &event ); +} + + +void IOKitJoystickManager::ReleaseJoysticks() +{ + for ( size_t i = 0, count = m_joysticks.Size(); i < count; ++i ) + { + delete m_joysticks[i]; + } + + m_joysticks.Clear(); +} + + +void IOKitJoystickManager::EnableCallbacks() +{ + if ( NULL == gIOHIDManagerRef ) + { + return; + } + + IOHIDManagerRegisterDeviceMatchingCallback( gIOHIDManagerRef, OnDeviceChanged, this ); + IOHIDManagerRegisterDeviceRemovalCallback ( gIOHIDManagerRef, OnDeviceChanged, this ); + IOHIDManagerScheduleWithRunLoop( gIOHIDManagerRef, CFRunLoopGetCurrent(), kCFRunLoopDefaultMode ); +} + +void IOKitJoystickManager::DisableCallbacks() +{ + if ( NULL == gIOHIDManagerRef ) + { + return; + } + + IOHIDManagerUnscheduleFromRunLoop( gIOHIDManagerRef, CFRunLoopGetCurrent(), kCFRunLoopDefaultMode ); + IOHIDManagerRegisterDeviceMatchingCallback( gIOHIDManagerRef, NULL, NULL ); + IOHIDManagerRegisterDeviceRemovalCallback ( gIOHIDManagerRef, NULL, NULL ); +} + + +IOKitJoystickManager* s_joystickManager; + + +} // unnamed namespace + + +// --------------------------------------------------------------------------- + + +void I_StartupJoysticks() +{ + s_joystickManager = new IOKitJoystickManager; +} + +void I_ShutdownJoysticks() +{ + delete s_joystickManager; +} + +void I_GetJoysticks( TArray< IJoystickConfig* >& sticks ) +{ + if ( NULL != s_joystickManager ) + { + s_joystickManager->GetJoysticks( sticks ); + } +} + +void I_GetAxes( float axes[ NUM_JOYAXIS ] ) +{ + for ( size_t i = 0; i < NUM_JOYAXIS; ++i ) + { + axes[i] = 0.0f; + } + + if ( use_joystick && NULL != s_joystickManager ) + { + s_joystickManager->AddAxes( axes ); + } +} + +IJoystickConfig* I_UpdateDeviceList() +{ + if ( use_joystick && NULL != s_joystickManager ) + { + s_joystickManager->Rescan(); + } + + return NULL; +} + + +// --------------------------------------------------------------------------- + + +void I_ProcessJoysticks() +{ + if ( use_joystick && NULL != s_joystickManager ) + { + s_joystickManager->Update(); + } +} diff --git a/src/cocoa/i_timer.cpp b/src/cocoa/i_timer.cpp new file mode 100644 index 0000000000..29d3f8865a --- /dev/null +++ b/src/cocoa/i_timer.cpp @@ -0,0 +1,191 @@ + +#include +#include +#include + +#include + +#include "basictypes.h" +#include "basicinlines.h" +#include "doomdef.h" +#include "i_system.h" +#include "templates.h" + + +unsigned int I_MSTime() +{ + return SDL_GetTicks(); +} + +unsigned int I_FPSTime() +{ + return SDL_GetTicks(); +} + + +bool g_isTicFrozen; + + +namespace +{ + +timespec GetNextTickTime() +{ + static const long MILLISECONDS_IN_SECOND = 1000; + static const long MICROSECONDS_IN_SECOND = 1000 * MILLISECONDS_IN_SECOND; + static const long NANOSECONDS_IN_SECOND = 1000 * MICROSECONDS_IN_SECOND; + + static timespec ts = {}; + + if (__builtin_expect((0 == ts.tv_sec), 0)) + { + timeval tv; + gettimeofday(&tv, NULL); + + ts.tv_sec = tv.tv_sec; + ts.tv_nsec = (tv.tv_usec + MICROSECONDS_IN_SECOND / TICRATE) * MILLISECONDS_IN_SECOND; + } + else + { + ts.tv_nsec += (MICROSECONDS_IN_SECOND / TICRATE) * MILLISECONDS_IN_SECOND; + } + + if (ts.tv_nsec >= NANOSECONDS_IN_SECOND) + { + ts.tv_sec++; + ts.tv_nsec -= NANOSECONDS_IN_SECOND; + } + + return ts; +} + + +pthread_cond_t s_timerEvent; +pthread_mutex_t s_timerMutex; +pthread_t s_timerThread; + +bool s_timerInitialized; +bool s_timerExitRequested; + +uint32_t s_ticStart; +uint32_t s_ticNext; + +uint32_t s_timerStart; +uint32_t s_timerNext; + +int s_tics; + + +void* TimerThreadFunc(void*) +{ + assert(s_timerInitialized); + assert(!s_timerExitRequested); + + while (true) + { + if (s_timerExitRequested) + { + break; + } + + const timespec timeToNextTick = GetNextTickTime(); + + pthread_mutex_lock(&s_timerMutex); + pthread_cond_timedwait(&s_timerEvent, &s_timerMutex, &timeToNextTick); + + if (!g_isTicFrozen) + { + __sync_add_and_fetch(&s_tics, 1); + } + + s_timerStart = SDL_GetTicks(); + s_timerNext = Scale(Scale(s_timerStart, TICRATE, 1000) + 1, 1000, TICRATE); + + pthread_cond_broadcast(&s_timerEvent); + pthread_mutex_unlock(&s_timerMutex); + } + + return NULL; +} + +int GetTimeThreaded(bool saveMS) +{ + if (saveMS) + { + s_ticStart = s_timerStart; + s_ticNext = s_timerNext; + } + + return s_tics; +} + +int WaitForTicThreaded(int prevTic) +{ + assert(!g_isTicFrozen); + + while (s_tics <= prevTic) + { + pthread_mutex_lock(&s_timerMutex); + pthread_cond_wait(&s_timerEvent, &s_timerMutex); + pthread_mutex_unlock(&s_timerMutex); + } + + return s_tics; +} + +void FreezeTimeThreaded(bool frozen) +{ + g_isTicFrozen = frozen; +} + +} // unnamed namespace + + +fixed_t I_GetTimeFrac(uint32* ms) +{ + const uint32_t now = SDL_GetTicks(); + + if (NULL != ms) + { + *ms = s_ticNext; + } + + const uint32_t step = s_ticNext - s_ticStart; + + return 0 == step + ? FRACUNIT + : clamp( (now - s_ticStart) * FRACUNIT / step, 0, FRACUNIT); +} + + +void I_InitTimer () +{ + assert(!s_timerInitialized); + s_timerInitialized = true; + + pthread_cond_init (&s_timerEvent, NULL); + pthread_mutex_init(&s_timerMutex, NULL); + + pthread_create(&s_timerThread, NULL, TimerThreadFunc, NULL); + + I_GetTime = GetTimeThreaded; + I_WaitForTic = WaitForTicThreaded; + I_FreezeTime = FreezeTimeThreaded; +} + +void I_ShutdownTimer () +{ + if (!s_timerInitialized) + { + // This might happen if Cancel button was pressed + // in the IWAD selector window + return; + } + + s_timerExitRequested = true; + + pthread_join(s_timerThread, NULL); + + pthread_mutex_destroy(&s_timerMutex); + pthread_cond_destroy (&s_timerEvent); +} diff --git a/src/cocoa/zdoom-info.plist b/src/cocoa/zdoom-info.plist new file mode 100644 index 0000000000..8371b0555b --- /dev/null +++ b/src/cocoa/zdoom-info.plist @@ -0,0 +1,47 @@ + + + + + CFBundleDevelopmentRegion + English + CFBundleExecutable + ${EXECUTABLE_NAME} + CFBundleIconFile + zdoom.icns + CFBundleIdentifier + org.zdoom.zdoom + CFBundleInfoDictionaryVersion + 6.0 + CFBundleName + ZDoom + CFBundlePackageType + APPL + CFBundleShortVersionString + Version 2.8.0 + CFBundleSignature + ???? + LSApplicationCategoryType + public.app-category.action-games + LSMinimumSystemVersion + ${MACOSX_DEPLOYMENT_TARGET} + CFBundleDocumentTypes + + + CFBundleTypeName + Doom Resource File + CFBundleTypeRole + Viewer + CFBundleTypeExtensions + + wad + pk3 + zip + pk7 + 7z + + + + NSPrincipalClass + NSApplication + + diff --git a/src/cocoa/zdoom.icns b/src/cocoa/zdoom.icns new file mode 100644 index 0000000000000000000000000000000000000000..decb4c5ab4054a1ec0a67990d88f8dd89bc982d9 GIT binary patch literal 196176 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 ^mYw-ZTq{;6VDK=D6 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

>gRkX`I67s zUs`$tjb2jot5l4K1hj|lyP%oI=sNK2%lp&`17W{=irWV3{W@LiKHJ+Wc9S+8KUBxH zG{N|MV&7Tz{k!ek&3kJ-IqG$-$<&AD&o8E3O)K~)TErYEbjN@EuuZiRNprqy)2O7V zXYk5S^DozF`Zn*RcDP*qjE-`1;f0v=x$5(>8qF?`I~Mizjq$HZSBaNu$mF~ zrE&7ZDEpQ-?D!R`WiiqH+{yGq%jM+}UD-wo?A6B{jqx=Kr(9iz`{YPsHssRS@3{SD zv3)K*NxO)f}9Zs#si;N-mb1C`I5GBCC!s|?1v9Muz(2DzW?SaJ{OvO-`RlS5@b(eeyW{ zlL0xILEL`zWuw&V!dy+Qf)2}tmEvqwdwe~17p7)Dd2}p?=irC+TlEk2UrA;<7Bknv zYaMEL{SAkTY9xPMYoo)*yP*UV7W6u{2Tsd;whX(cGHI-+S-mMO>e$p}iO9PfEgmuo zPRdOUE-leLSl`o^`i*;EEdIHy!ox|%*&1xr&bC?uNdl4a69MIw-v|W>UKer^?2B&6 ztz6I=`D7Nm)mww=kxhBLcwSO=twv&a(JN60-8X~8hDmylTVM0A8hnwe_Plv=pTaHw zXG)BH<9E&8o!c@xw62!Q=V=~A`eQ)xa0yK zwq8FSvuWeLakeFa}%L*$*_qmR4GkQ^z^Qy-wJw}_u=tyo+N^UZj zm)$Pr#ZcAix`o58qdl6H29J+4M)0N{dwlxxhmwq<83((UB(o=dovZU65(!+kV}Crg z@rl<->Wh0+-rr4qICbyNoJR_~o&4-^vZLiiuT5XL`{oXd z_Ur6+;47m#pJ`OtH+fz0~<=h^o*bL}Dz=cl52p8P!OLrBT<$J&%vR8>4&vg$r@Y4B$V$yT)& zH@pzy;$OFUeHzT$}t@!89`xh6~=WQn?}o;S2T{Bq~3q#W{P*OWtcr$Yv; zt+VUr7u$!ne%*D~p^lOAlYg)}(~AJJ%61xd(Jn6j-z*!pHT<|P-H5;re_|Iy-fGmuPB=8t#!7k5CI<9k)h2L zuAy@EQ`bK;u1~KtoQ^H<%RhFYt<%AnAg?WYi(Ynzb$kVNVmY~~@ZATUXFhz`tI&F& z+-3(&`rTKD4!cE}>Z)C1aW1eBx1`>_m0y#*=}IFUR@LwSN*ax%+^d>|^ErFD|N84F;lL`6@|{ z`)~Bn+2}}?pXD2CuXCf3Mu~OiWB!u?w;4Ux1;U5q8c%ZqrW}qC^1OPoi8kDn_x0_M zM=BVkGUvJ6s?Q%g>&r4GR*`MyCuB{$r{+^2Rp6BB+{7EPT8GA&%4@MD+D}aKjf$;^ zHCgmu%h&CRcT2mjUViH3(*_xD`cS%}gJI#EV#@ZNLuNW&n^NL;jPw^zM7i9jxm-}k zSWvjLu`oV<=EXu^FT-bwNykL#l-;}{8}`|%)t#oGf9W~5B|WLW_Xe+{-_yqp0jX|y za#yIQZpwIfKa%CK+wT+*s2{cB^~v|@de)9C$=X*Tws^*tS`MtE*CT|V@* zjMO#Hfs-Fjv>Xl5V6-S!8xPVhn7p){q33Al$?B+P(3*C|Y~KjYE{l4kWwi^_cwIu7JPlaXOGkfu+Xj_R_ zQpV2A6Zg|eRj)1;&uGh*JT6~Mi`AEl7WUgbr>H=nClzvtkJw$sd4ecku1EGp;^6o zq;AetDy(KlYucw8jqZf15AD6M%jrpk!ZruL7jczG&+94GP!Mg@p&#z3_rD(MrAVtE zZf3!K1eLvI_OX>?=~haNV)yS z1CCbbNe0b(_ztNq%MO+c7POcAZP*UsTLn&h^6a##O#hZiBe~Vbr0Y>eHiwk_iHe)< zqZVgdyd^|GM?EY(bM>avytrZaR_1mSYq{2*&rcJc#Iq2SZ#k%ZRVv`k&BTMjseU@7 zwnaB1j1^uH5vy5qSB$B@Vs|7yd5QP!txcbddJausJZh z0AIP;{T?UowDRva)k#zIJ!x&;@A(qHXL62$G>1DmS(o-}j3JRVBk$?NTW$M`MK~3` z8??LqpYKh&C>DCxo#Vl6wFT~m@LnH=(#7pvhO~pj4{W7GH#GRHc!_XaGatF!`02{V zy*&ioXQpqqss?sW6g`_^R?1K5R+t|?Y0w;Z@wEEZ<1z#F9>yoEX^wGBd$*VN_4n5%gYt|cWRet`H&zvsNaefnD8?Pl+M;x^JSQRTONF3J z?LDTWDzBJKTneQ-nmReVsuno=ZqV+(_Czs`ZOin#&W6tG3by&5srkZPj^oA3K0SqZ z(#$LJ{2`f0fwLwO9oJ*y7Z&SZ6fT`ElKZ?jegl3B=MwQ}SBBf{yY5V9X};TUB6(Rr zk=SHxKzBjf^Ho^;=CH)d_g7-XlKFOIZ(~qW?fO7ocYmh}fvIpC`5}JYxzMP(qy7gs zoV}m0VItz;S^WDvL>D{5E;eoqyB@YDeKhIa!wm;#Y!i8Em>%^;W>-}))P*aH&t2FC8|5v^(Hx6# zeCP2olcBn%p538Ls3ul<{&~Wej+x_kzh$?TFivRqi4Eo`HMTo^v3)?ucVs#Bk;TQ* z!Y%6pTDmt!oO}?^Ldx}mC_x^F#T*l#cWCPt^$FD;5J#Ht$Cqvk%GHqMijl4-` z2G3cfxbWujkSsB?z1z;l{fSLAC};;ijmN%xaX%gRil#f9E#c{e9RoT=KCRmd&5rZv zi^*u!CA~j1xO7=`lWx^?{-$FGFJ3kuF6`1iIX^zbqW_kSiDFW&^Kz)mal#aiii4NM z6kjM5Zu2K;v<`21qxNTcM39_5-gjs+G*xNBREBTQwZQvfqYd#D>ii$1`iu`S zyC&q)$DJJyl&#oG7$=#v(GJf$WNu2U^~S>JzAbmI-dX0isl9VOpv&-pt~BST_u;~E zMP%()N%?Q-iwc$2YipLg2yeVEqxHajaOhbJ<9#o$89)=mSjC1gY!qH4;`2MLj7E}i?KuK{(a3s>#b&en{#B3*Et98ExpsICfjxI zsB7k_imgx6G&CYhyV(|ZHo6{+Pw9H;?dA0R1d*HbCaV{(^VQ23Z1DA(kXxtEq{*9KI{u-jm(lUGuqUs^hVn`;d(WE{TL)D% z6q5EW%~bX~YaC$|dc7@-HKfcqnZ$m)BEq+^RqD=zJ(l<;V>KpMxp?+blI_@DkTtaJ zK9ziZ!ZgoW68-lFo}QSM)7?-+cc$cHjlj_G*p;}5J%vS4dk?l;a`4hC{-S?=tKbgh zfXRI;M&Y&E8WxB34U~0!m*mskOrHePO)JHD-Fg13?B?gtNa}$1_%3zY-)`KdkUvbL z@qlL=W9#;&X&(db2ew-U$%aPU`R(*LS`J;68Wxn(V=HQ+DR(#e{{R_4=D%R5zXrk- zw2t=#l+(fHgiP$cXuTjiP7Ua4qon)bi&y%aFK@{|w-{=Fsq>GT&zOq@^#qBA!6>Uq z;x=4C-~frhsyJ_~F6tR`xqp$oSBNc}vy!K7oQ!kYNC579kT9r-rITn;CmQZM1`F^K zrhd#w%0i2}DJ&UC9?0)I1<#H>@V6@i_F4D+Otu3qiFmw~Qn|pz-73o1k7XYtJTM(x z;tk>98`{uZOEvN$XHR`ZJEUuatsacL%^3Xi;%cJT#vdad+{@9qTp+{Snp5&h1#v%) zSHLHyLkhoW9=}xFL!*Q~v>4EmPhxY-1S%?;|1PLgImY@f-$f7^irDd}gMelR66)~e zkP#^vBA1T2gqV*!Xi`{n#@fR$pylWipNCicN`j znPwBG>r-uo=PQ4dgRU<@N4o-1f@cukgg2t?|3nKsy^e*A8WswE439yAT2A0b1ZYS`P9r|wuk4UHJ$}ZNxxk$qno`V=mNqP zb$vl&Adjlj>bDl&?>hdQTiIRJ@DiV#Eni5w>-dn~pQt*U^i@yJ(B!u)6j7sH*KKko z#d6;@Z3xgETFrwQ+x93@m)V7gs`M3TQdX z+#U*Z`JJ4OB!phY5gki{wM2UZb9x|q2ua77!L zs;|Q)|3ITvksk8~C_ScptWO|xKUO;rDB!+CG5!_5>{8{^7CQhQ6g$6vN4GLopsKyY zIaZGsN;b}_=m(17uoR82e(S}rD%fzaF`fv}i#v({G~@u#sesDuetECoZ65mpqAy7Q$J&%tVRyO}cCo^M0VhK_co6#P@Gk zjH)*WyeCXr&6jUr$^$}n0X(Fu>wIvsQw<(l{R)^w2Y{u69ckz^V6%s`s;@!rh7cTX z+Q<0Y8`>iH=)kEo$~%=gk!7nbG0EP(*b9n2xr*@&$fV)<=0|4`eTmOOD_k=R8yo&$ zdzQfyE0e4MyzjqvIxYbDoWDgZFh)v{VZdlnn5i2d0Y2bA5zIEu^txGs^f`s+4>nxN z3At4M0`Ehb724lhy0xp42!A2>ncymqDp{W63e023CA*50O`)cOZ1dYfws?9F#O|Mp zkFhUvhY&qJ8Tq_@+$_5Yk<)vw4pC9!HMl3f;QH^3vyUnx0VyiIsnMTrwfi+d+YYBgkIn zP5KjNBxP;Z@p*bA^wbViDY>8l1`!5V9cLh{7>Ph-V0|6`KhFoK6Py~~_4!od8;0rR z*+#9emHu%7b1u^}P$_Dvk~_4sS~^n-7wCg&DzN1T=;d949G<{e>rZ`0RH}vwOZ)@O7NnnCAcnyb#)ByAT&h7 zOY<^+VeeyepoQe;4QHb_@GR(qX~>t=-dTqE*=z4vLz}#YII>9VONf`uO2hurxZCnT z-|9W!1vWXycN7Fom4hISw|Luy-D2b=e`HYdgz`c5=F-8fH4iHiuDx=w?ohVoKoVZi&c(dtSJ<_sWr?nhB-Le^A z%RUraLh=7oRCW!`FPr@w8>FE3$7)ejVvKe>qIu{snU{#*?HqnO@F-+GL{c?t>Po4# zB*j zQ5zzB)lqiP)su)52(i|i1Qi4x;1@Ur>32|nEu{1;IhSKpt6mts!6ox_T6?OPW8TEZ z=LHj>UTzWC?-i%)g|nFyu(rDMr_)ODS$Zrdq;LT5>ie5=rONls;os{k2+mmRM? ztCs*9k)~DvoYw+`{hoVk});HR^nX^3>X)h@{#%iel zTP7P0js)gEZ|Web1P$NSQQ_bMG@iLO>}1u|(=3x<%4HDgJ`?>^(*B(1D0!Mo0iwcA zZq(V3F@&<6nOb>(k90}uSSkFr#^7mI5Ul2e#-q^oey2#oE25zymsy#4M3d;rjyS97 zGQ${}!8*`C7$@cAvvq-Vfc{@DbCI(xY2vnl6A{7;R5#-fN;ePqAc619>ps`LK<42iv%TQ#Xpq(cdrRh~kjtc1I6a?o+UQZk_xUo8M_ zneRX3G>G9V6dTroLHHpya%hNwk`_M1S^l@@R_T=7J=zX7XcD*%DjoJ*pAXZ0$+h*h zlTDuww*2AEB9)Rw$0!m*bT*?Qk*zY?jaF6lXG-DNkZtwvs%99PL6$g`-Dkx69|&~d^R&@;aIVXVhD%;-)H?9=;CBhv9Q;ItTQJw}aV%;;@O%s1 zX7kgJ)B*a&pICXjJIeNUrn-DhpFTO$@)#S<&iz~@q?YTB{@J7kjO^@=zmtAqG8`z7)b-tInP-xT0j-QM_B)5cQMnT zdqQ8Kd63}8k@v9moSL&Vz=`gXjGCz)O>{(J7KNbg$uCaWX(@-<`e0j91R=0j5l=}d zu{wMU{{za2iCr1Djx(L4I9N$oWv}Ltb`@dFrfh4)>vgLF6zpxq6sqAAS+#T=xfU}o zY;rGa!V@sPf?~+a;lUpWP@wur-S-Dj{sh8x(C@G=h&sPojwM?tY~d&(5(uyT7?)+T zPCNS(^*4to!PeT$F(C6JofSvCWj+Z{NL1G)Kk}sG@g?C=1i)?XmQn51ydSOI*Ai*VT5(Y03*Y zbO!Y&!RsZh`vJwLJNz0q`ILy+9X#_#NpnW?!~2GB{K%-~x@K?!@3A2DC96CFuemC(6%&wg@x;J;+tyt3Vp#z83A)3>P+P_kzAY1t)cC;Q^av!)(F zH=ZK1rE|d6K6!KB-@of$lcoK8-JVocCKYfq5bHP?Rsu4B#XRS@q7rl-4iGA9U|4on ztxk0Tq0YjNc$k8|wTe1Y^Po76tvfnOVm5zxo(FOKFMVnjbb#Iw96R7gHQr(eDT>PO zMjmXA;Wj%!G8YcLZnEsyGpDBgUGQvrsjc|+$M6Yro}0n-c3}tA)!YxC(ty9Hu?tS~ zVpSWu9xFs_S7=80n6$`*xWAy{Yok2zvKg}~O0Hz3Re>*Y zX$pCQoKBtdVZ#Suupf0u#Yt8e8f^>@06I~&3_x-LhWh5QaeR=KR8#}cs@!`@ppBwf zOZP8`izoXM!TFL;jN99^qAFaJ-_Z(MraXM!iPo=`Kx@IAdNs#WfT?;UXy2JYQ>` zjHP0IgTgcXr=*yH3*%-SzsI^>HsGxgXT7P>;;jDyER6*IOGK6y?hUtT6|}hEdAuEc zVHZ?bI<%AVN^L4Pw<_LbI;Z@Er_)UFGHyL+IL6KZh#kwM7&mzfrwQ9aOv&^f^Flx# zv&8=uv4wl2(L+f4`CtlGd=58pZNhR8och$~R3cbCp#J=~;C1Z;rHeA8+khjzUBVz+ zz3~I7p#p-m+nuR~$iP`QQlu?q#zg5+z8#coZR;pf$j~As303<$JT&&mr~5B!XU}Dq zp7EP*1PyZ}L3I>HkM5xxL=H1SIdHrZN|GvMd~MfZ4DnF^G#~Un&+D7aOJ)CgY#_=t z_liJS0BkOO_VFQAKmMPiN$gL?0g+{0{Iyz`sT`;f04uA*UNBu0^bz8zY$tZe@Oo#-QY#mQVCOlq&vE@nsI)NalJYr!lwf&=FVUok5h25!ts8;T`|xMukVD-XxCCs>mR4mGv8#Tn09wJy*lW$3&x zr^fg8F)96cSjjRUDH#5jK(MHhsIq9hfarA>TK_>8k5V~)tCi(L+&ry?^GHAw$i~5ZMVu+bv2;0 zc%6phFN$1B4T;dpLeQ69wE_32Cly+PV?4a#L1w~gg!y$Ftg9B8Xh_18=|AZ&XbqDKnngT-(S15fGN7mfsXLUzyi!)0xxU_;(@PDc z4e2pvodZ>(QE0TC#DwAvq=>hogqpcQJI@=KjqOiM5lFAisLYRmag|9`Aa*c^1-bJW zDh(!%5-590l#&`RNrO+|r0jF8Ke&k!7Ol{E^HyuSpQkd@!l~i2&K!nT%c0+J%twVF z%z--TdYqAT4d0l+mgKFA#5fmK0v#jVH?&UrvND~EU+f}%O`uBj59g1abfn)ihE4^O z;c;7dvIX)e_nRT((^q-td~?XaFspFRw|rC)&g(fyc^UA4(Q^H?ctl0_)98|77yo(7 zI$mW`bP{}=DFY9(Pk_-mqC9nk%J zH&qU4o4Lbf9ZfiVI1OALI7+|N)a*vwhd>pYUdFUHtJ?VcMF7>F?*5nX8Ko1id3)D$ z{n3(2ho|KTZv-6~w~v)%DJQL+UX%w~zb-YG`N&kp&KI*)f~!%1pISSC;-Dhdl?JOT zl$#7bTo7XZ(a%(WryJ0E@_F4U*7PqUDohp6h4Tl}7hGu6Y4a0>W68jW)_=UW)~L;y zIriX&?*q^G8ew;DjN+G2vQFsXGU*)>VRWxxEwvOA6yNMs+?EnvQ{a7QH2?txrY*)g+&j=Cu8?;;RfJ%R7q^ZQV-WE2~Gb@z{Q9USjpQ z?5OamjkO|EL{1Yl4tO=a9@pJxe`g5D#R7W{GXQz9}S?b?bqoF^Z_-ikvy25 zUy)dKsF-hy=fq8oHw)+8Mr45DX;0mSjkuFWvA@csG$`*h!kAwD4+*@rfnxIC6Gr0+ z!uy|(YunFgCzd`0y5^3|5Fjs&;N$l9efxWCzOJ4BH(#;)dzbya#ZRBnr|r?qKW}Vb zx3p{O=@<6tFqIUDML%B^60+TtEzzTo^}hLbD95v6Jq&6z11B<`oT-;AFOiZ58-6v8 zm#-%!@BEhEsJlDj-+N$b@ojA8!M0aTlQkitV_S5GQl!3vUBcmRR#`RDe`m)1Mx<-@X`YCUs0#zD<-BAK zp~2L=38N6M1&)APDi%9T4R(7WQ@DxL^|iLn2<_$qB5$Z=vtfbL@5Z6e?8}>S z^);FLT4SJM0{$t#Ib7>Hbtn5*F=gVEQ)eKO1BLRA9Rq2@Gr;D+OHKe@zTm_q9pW|Ce&=DEE;FN~0YTF4D z3B`)Mt<&V&_D7vQl%E~4LSvViCWFo0H z<-&bLTCj4~=cPVQx0ea7RoE58CpxhJ3ZB_qjN-F#i z9}GS@<;Bl+7cAE=v!5>R15RN+K3NjzV%L+Y5MvS)NpF29=Jfo8u%;;yFao1a1~eMz zsOe;&#$ujQsQq)(u({d_#PPoTWLUVf{}Uu(i+g8=5zrZ;n2gp#8|1*NGImjm^i+aQ z=IF#LESg5$BM=F#%Z=V%pYo`Uoc)ftu)m0q@x?zelQj{-tX|S2035b`YN}B!$c`Bo zs|Y(-!&p3uDLd(TEQ^~jhq9g%>#1HuF4H6CCrSl+yVrR1!}Kv+>gC~XU^J>s-lrF_ zxw9+m7tYZcT;hu|RS(8Mrs25f!*j~^O3UJ28FCt!CSsXc z5)O`>a&RVkF&))=NW<8Qr?9-BoT6C}Hb0dE zKbqFT6nGyMlRsvUk=7T27}Kze*#f*zV@K|}T@U^_{iUGOykLd4yzTO{J%^$6M(S8e zu=z!SY`9F1(UD04o>}Z7jkNfd_w$%vAIr6hAX-_^t`Gt^aM3VE-G(4#!SU?mvG*^b z81Piqd}F9XyWtPHfvHEQj?ql28l+dqYdVJ22GH!n7)lsVTRyXl`(N_n8Gvz-38Vjgtp3~XC}q2$o4Wyx*VX(RB0 zqrpd6?ox8=Nz0=d0t|;9Q`#I_R;m5q*2-hq_Fn?Eu5`rgsZXftqw}xk#SQ9}9mU_xs|3Isin=O6T zpc3M>abC-tuT8jnej3$7m1iq9=$s+bFyr;sBqbt~@oOFv;=o_Bp$$QuL%S(=yG$cPA8yh~ry2 zn4V>C@YsaHy9WJ<0WKLCJJJ6hK}Jp6&cG}GJ=xgi!fd-Dm}?9oxPbmZ$mmKLMtd0D z=3@03*eKA*8UIy}LOgt0g|+5wZ@K+QLROm3R^*sBt(J>R7wKEqk`yedix6X@6+z-Q zj%QlfZ!AK0?@b)0sIL*UbTK0t7QA*!*K!sq$N&|=CcU}5OLz#RZ{!+!@N#0jASBkc zPm(t{f%%)m<JuQj??p z%ed?22`ayxf5^g8UK=sZW$9_p@!?=5G!+qNl+ILYm?|>0a#N_Jt8=cKxqiI;sFl2t z{s{c$)_)^Y=ISy&PYb-l|5M1A=r+jzBxtnNFKKH>psnnwqnS@1j$2gkS!mP9x0-m^ zcN7gnqP#vf8UVeID4%^s)#-`e_!Kwu8IiEe8x(M&a{RT?oX+OeSH$3z7i(r1Tpz4l zp22u%(-A#n4JtDCAdY)3MSp$|n?C)Oedx558b3o5Ye8S;cs`gL6GBU3Bebx20SgRK z@@sym3sEakl>qc@zgP%9zHN!wPAvyU8JU;~DIb68Du($T=8oza!hbqBqqjhiex$2N4g zk9q@(>^*}#Wpog5sJ>KJc;${AR59viL-Mgrr;$geBRRUVyS~5}HejVOa~m1;wY-ag z24>sY9ouD^cp6k&t1pm{MT@Wj`09zV1=p{hZoO986U1(_*yZc$4Odzpb0HsYPCqB{-_5 zbsXMX0RG$o_dsA>rdJ^;Cy>ha9(Lj@iwp!Du)Jw1KnVB+{;Uw4(jjBuBguHvB5wPD zQTwS-=eK+9{zl@e6S{NcvyBR~pP%F7Xu=~X^}GWpF+>8#?3aN-@{E`BZE~RZAua$z zhI58^WKd;twEd_{@Bo7MaE={q$L}aB2Rj{u-|E0QakX(N?M{kgzHPfRlD0OZflC}b z8JjRIZuX^^&T=C3HtBUhkuH*g_Wptf_Jljlfza?YJVhd(B!RbDoyxA0nv(=+&CI0_ z2Tj}hzRW_!fHIf@@W=Z+m5(J}P0w2J$&%FVvAL(qE1Q1rVG(!r9HB&>$io624P;J5lMq81eQOu;a7daJvbkrA%E$x-?tsI{$?vOhL zsaJ`5QcmnxC{J7)D-VgJ@$9My0Bkx;O2F>+I5t(F( zNd-Gr%ijkjx2?eyhkBrcS7J)z@amfi>?+K;y++)Ob9ZZ%oaUiKfgh{ ztjej_xOPGnyJ(KFRk4ywH?q6QVXAvsG#C(FVlKpaacBb$M3~ilPtywx^u@ktm5LRT zsV>N@>hz3mahsqj7Wk13L8~mqI#=q~;$27#<2Od~WU>aU{o+oCNYQuZ(iX*c<*j69 z5NGA-=JCWW0o!$bRK?nF)Rp(osw~>VxdAaxTl7>b4J0S~sXZNHa>glIPIo-)mzN0C zi7<~aE_LOF&8$u@;!mYzcvtDdB6AgsExyl}6n)ThJ}KKaPUUB&@kf@`W%PNu-(fpo zfp*15Khi$1`=Jh27mqJVwO(ZKB^qGvR`v&kK^V%AbUtR@Jt^m7*G*q>^VxThAAJeH zlJY`MVfaq+p=p{JY+FkAiSuWC5Is2UQ$@rvr4N+z%K`drxfj*0L=Z|^;RQ8KW&`6w zf1#Iu6e@T9mVZ1a8WzX@b?0iRwjGj4tIV@^#nO!V{|yCvf}yCmq(G-Ds?8L6hBJ}_ z=Z|!kqFygl9o4Hu%A^{x-8=^WesS$<<~Zmb7BozQIK{fo6Z^lOR{t9eD`F6uo)2(L z;$}E9>qvq~u820)cONs-&|*SG;VJmiM#Z?Gvk9FKcGTuDm zL0tnsZbTe(7iRfaTE)h24b|U-iiMcn2LV9h9mcd;P>j(gy_&C^sRQG*cxEc8H4O%A z4wZQq=uKhY$;xC!aZ?)|_1>DsIh@>sw~JCCgQp*%9QK?RN<*|6Ck#vCKY@#L|1h=F z92iafDu;md8DmL;I({IY36@`>jv7`bKsaopVCPRnq$g7*(i<2*K|{;pn<08vdshqG zdvpb9?qk^GJ{$plhG?E@sq!sbCOzI+{39@_HcR9uL#{tl=(zdphrv>b02|VDEvSyTO@mxXk!C(%9v9i2V%oy3+ z$4pg@@tpLe>|3hMoIF;q0M(=tVYNf7S$Eb&e#l5oFzm_s#OB7P{*fR3gwF7SOn0UH z*#w3{%T_|OQsMqKgNV4vYpDn3su^n?$5@s!Wd9~?g2+?qt~%S#ZdJSo`Q3Sz<;6Gn zsk!SrD@Ka~$CBXqNy%mwHlIYjQfo_n16&>g4kHZ7ff9lze%Nk%RUu0iDUV9tKA0?N z9o$AP=LJLe2;U{fq4vIX=p*j3tCk{&`5kuyr+>+XpH%uWb$v~+Q20M zKn{bok;IEJ#d($SZIB@73m`l?p0tuCQT%X)q;yCU|5i)(Mkq>HD@3X~1+&*_q%$3x zqauXmW~HMBF=!EAW1;j6IH(V+(rI&lDXcdTnEn+Itj8P@$8IZ2X;E01OXkjZ^~7Rm%>9*F{wd5 zYR{zq9_e1g0qAv)FaYNIpS}&X1qmyceehYEf~B=c#s5|b5CI&7&>-Gh@Zy&k)l9Q? zj8&saSVt%+rR2C!YMTxiWMH${2?D(2K=Eg@4w&8XV^M1;elxx|Jzwgw5>d^6^I&_@ znW{oWMkm1m#n1WGV6FB0YqLKWchSZ4ygVv8=YISJLl>)lzvN;WTB8vK6J|hh7MIOv zXo?LzIRvg?piW$>qvtu{_?I}>j~P|3NKCJdQvnu2%-rG+QlVtP8r3H$8%5BtWN&@> zhw`=cEku~18eo$eff(6@wiVQGWD7Xtaw|PfMV)KY6VMgZ94AI{nPu$?vl5Y$YRi$F z$I?$npk8sGO}x@>N(un)G~Jax9xmJ-djX(tWV?9{^Q$!^4h~x7D)ch~*~k6J?2$$< z1IMRb91pb0Z5`lSN}Q5xA_@j_T1DgU$-nW40^-i`h8GvZ6C^)z>bc@%JAFRn|4T~$2((!H zZJ#jv(boT4y?!`NA|oALMvd9Td{#PD^%dn~K2esOQN#APUI@Qeqa_~E91%%$9%^Q9l)rZsnFj*IMIAqPECx2b9 z_oO*NQND;|!$pO#yg?JwK#5+uZAdpM3Ns;mAR+tjLewXFpONjbK3gG;yg}kx(Bu(y zvLEtjNQmolYopHco-2$%>jzKByuuJO|6H3Uzv3`-ucSJV!lb#;W0OP~-@ycn7wpf~ zpfK=HLBpnJA8-< zt~?Rwvkq1of=QpLc@ElrAKZv-QB?ZdM$sv^wCMfN-VEe>hxV%@ixu!Ug z2I}kYmyp!t&Lv;}Zh#LMLJmi&wD`2|e<)w?g+fD=EfErj#e~>K{ltqqY4AADKW^#y z6*bGeW>QpaY=GimU!vts`;3SaHt#yRH%2mfz^pU{dw7U5)T&|!7LTrO(b#IyNK(h*#UI{v0ky_XgJ(ZhJ_3Y-EUK*ti3)x+p6@5 zZ#l&N*U4a_;=(;%4=TDXwxt^sOR&in<^XC&9!1f-nuK31sN%%q>h&Q=0i-cQ3m1_H zu#@vL>9$t=%S3Bs`4V3=2dTaUX=Wzf;)o-o#};LRM&?L`Dc&Y_x5yx*n-iz*P9HrR zg)uR~N0pz5wic1bwyMrTlxvzV0k(XyScFVVa?!<#kPi$M(IHpT>=rwT9_+0*$;APNkCuz-Z!6Ilg6z>_jk z{SP?E+{p*ANsGcXS;A`hO|K)TfP$XAgYebtk}n=8IMGb@?@!?ZC@w0|CqBKMSgL4l zch{4bu0;uzAvwx7I|8!YaxGQ+8HEd@W%n=|gudcf&I?Q{oWLOEnL+%Sd)NX1bEc9u zA5kd`v>QIjP(jm#;iEa;Tl5=<0yjbG|wWpWY32&)(z4I@$0BzyM zTmv=%?Qv|$1JO={1n3r2fQcx|fz1=ME?*R*v+4D6C$<$Ym@k3Jc$5}_4I72VmF6c( zQI}RcXa*Cqw`PzgKl&oIc3nQWuy^O-gFgZ&677Na62Hqm+5K10WU(r;;N(mlrW0&WHe-kC@=(9IQ~}{G}-1xkld; zEz8u9yIcbzsAXoax!!9dR}$1BT{n(nJr78?u?XjeBZUsJQj)WhaubG zl(LwqkKb+<_%}5f6f_~HsA7nkG_@|Pe*E){mt-uaHP_KLo&CL)cLFKDgns&j!5VL_ zH`n-GIfosCN%g^@V~jkGDImh<0<($Aok8mBpXisvQam>$H1-Wvy_)57IH(iU{N4Y8 zpG$Hg^%Jpw;JUo&MkzZ&#s3dx)DSWXC z!~5(g8Bnn_c)C0iURRdRBGP$rDA7JXzTBDs-uj&AuYX`Meb}KHPI~6IqQ8_cwac=3 zm&*>G;jIWFTh#V;i#0X4!YbCydH9f}3+gEdeeblqaKUm)Ygv7R8PB0V;Lz69+_PTW z1m->vDxf^cqN%tpW*}{LNKb$$H__+N$>sBB3?N{~*{{@=>t@J+0O>~&Q8MNaqUV+v zT`&*1b}DWChs0SM*mif;CTU|y@VZi{8jshU>@Q&hP||#9yx>qdZp)e)_%OjBzSso> zWPn9b5`lha8jfo>vtjtzB$Qh{FAL<^HV18^cpYbSQ7z&uecr-+* z`sT^{lKfFv{<|}6qjRdG@`#BAyRM*wpiZE|9Yw;q>zuVycTg`zgv~4ibThOa!HZd< zTzvPKE-O`sPN0wLBuhPCNrnWbcQUHc5>Ze%uf=uX}*zHp^uSgZ%h8Iu(m>6EGH{%W;iqn7nhwxO$jS%2bz0 z6IVZKFXbhw4eShrd!OG^$k}gOHFM%)E-^@$5{ewv9N@L@uj8Dg z^>DZ*naV6YkMh^A{M8exWHRbwuO5YL{X-a6kJ6Q4hovy<*JrvT5vxKM<=##=LJGc< zh=_eMY4abT6CDse!e*+xXy0NnHDlv$Gi#h1j}_;c{S93bczcBgCE8xmK|aq_vqR z<#83oDzjY8u}0LXkYrW<3il<~=;?0S{|#C6b5w2gCjvvBnEDG94)RP-+uOCzxrMyK zxh@r^DI}hJ_a;35eYs>F2(xx&wtzACaTuLe?pyq?A%bnf(FzoxSxWq>NP})tz#ZW< zx+ZIBKc)Xmizd%V_9Oig4Pf8)GFQ|UzsP;Ux$)>qU609Vm{G_(r>A_(C{gtyMk;y0 zUP_+Y6C{c6D_SEVjx&wULcqMCHyRs8V8h2h@p!>YI>Z0Q5Gywx21nmTa#43eyW=CRuO3bvwD?pP+rP&m}$)a`|08Ntm zVId0VBYu{tU$T&oJl!guyNiJP|0_^w2_&&{z$yvh3Ge#$^L|E}pNs{=>DD!0`PUC4 zY5z<-dV%Rz5C`4Y*=0Q5!GE0r4*9PCckFM=Dmx}mBi13S^PlaVyw+_!<+XENb$IXBQUF_gvuHj!Jz@*Xv< z9nXKR0^VT?0rT+D)Tn3j+}-n0$mwf}QFogG`PU(NnkvO!FP8{7agS-6YkGdcUV8H* z>kEtMihL$CLyJ8gA<66sO{09Rp7}JMS5{RK=dMxSWK6jIWvl7yIj3v1rHUsD9yVxH zX=d>&*!k1|IM!9XXEzvJ^OlyzO8D$s{aM`c4PZ`fWEDp{k9;LDpTayk6+_oQQ2LuXyU7z z#bM%)ADIM5Zpy|e<~LQ@ddS0AnU zNvbss3N2QzBu{OB_7ZyD^^)!M1vkI5D=LoLg6BIob(mS5%?5fXDscJp)(+vklyp$Z ztevUw;JWTNlSp;+mxcB?tId}N5k(H2%q%@wH2J0sY@da|{I#O~nPtf>E*Ess#T1^Z za(#BpkrjeNZ0;6*ahtI}Af9@{S{F0$Fn^*jw1W^-1Sw6g@B`X}CzRI6rcRO5xhH>3 zA_sW$uSB?*T3X7@&ZN@`{tg-!p6jT58{CwS^KH25exCT5moyk*EIdeB%A+^N6TO54 zntrl>q7c0Mu6KhnWwHtVLF6$e!1D^Y#FUjO-tq7GoE&}g4dZG#KsZ^8T5x(j;!;$h z*T&>G&rXlY_k(8W<@X>zdsn`*q5siLvTVec>R6kTAiIVl}qZp-!< zh0+Du@9gcT9RlKoo-BzCQe3c!((rq(sYU*%oxJWpdMkC(KAhL@MZD@}lAuD5 z1Laz^&Pn~`wZ7ehDhk2?*BWM9jYI>MjASxhSVx7&I!9k%$u@S(9bff=a*>gPPe_r< z391sd2Lxg^jwr4*YwE7?LDcPD8AU~Zmou2WUYA65o=B#SdFgPrb6!QU<>lEh;+_n= zaJLv3MR;M>XrW z_Vz%hbLOcs7x^z((jBwX;tD6?tKUS+VWL$h&~I@0!RT`bf36dq);+Y!aw^L5IkmSY zJ?uKxgYfMnLH)CPIT7FHBeDkfIi-pZy;GwY55k2wsvSBn~FPj1Fl59c;nm`B#y)c4NU@wh&1Wq7T~LhgO&IE=MaCqC=F62 zWD;uvd-hKU%}DVs_4eI&;{uc`DJBTvRzifq7Ay{4-dyK#frjT{gSv%*w*OpR;)l9Im@LSyV50D^uv!6T3QEXvS5`; z2A*{0SRL)(*2Nc9zI0(jkUV9EcJFQ$T%u+j9c^#ySlj3#bfdggZ-9-Vw6i3~iLiqX^>Ziy{LqK}FE7Nw)D76tWRR_T!0!hZb6v zdii~xv|s-)w$1f9H#er!v!nB6o-ENMC6Umss>H+>$q%F34?+_EYYL2w>KD3N2U7KS z>+*oAP9nM)E=%-a_eT%wT$-ae?!eIV2L3f0B{Gf7Y-3yKkUyHN=;xVmPA z5F1sT6Qq#KbfM(BN_oBKPOr1Aq0c zkd$X#)h!f$;}S?F*Vls7OvC7r``lja0mAq+7rh>GN|cCx2#P$}f2bn0>TaBEr<+<( z2|t^(DPSH4Tjf7X@UE7j_@?7_o#hHFAQ7BNzSxB8DoFCspjjHzv7!HaAB81BboBuMzpBZ|*P^N67S|{IS+FkTMwUxCfQp;W_c0|&u|`U| zr?(R@E~q6qzsb&CHY5C}kR^&ZFw`jLeS~cy9i4I>HboIpIxXUh_244lq1{iXV>e1y zz>z9yK{1HY^6sTAU|0LWpxA zC}q8Ok+rK6LLGXbu2l3yxY44K4fc5=^7q9o2=R&l>V7-$7`Am?vvE7i-zmk7u(M)l z^^E%*&oC_xXQ5;&cNt7=in!7m-SC{se12~UFy$gX`60BDS$piN2n+dB4qjWo=-7QM zhB4RicF2-hF0@->hRko_=^|geJbV4c`iSw1fZofa9dcrHaYr2{2f-_gA2Wptv^vl3-#?p_ zUH^K5Lk1}voz>Be>wMN!Q8iMVpp4Y{Ob1rxjoY{&fx9ufqc46j)2}6(vxNA6d@6Nt zBv=}`#7Lw1-Aw%Ekk)vrgWTsjK>WtOK-vWN=}{MmC(ZO4_!t;eJvPMbW#A#=DjztL zZR>q>M~}KB7&+A$)J1g|1a{#tY2_X>7GAQ!iDceLFoWjeumXrRAHFCry^tP)a2w2T zGA%UR*WvR<#$NTM7|IMWH-%Q8OQnu-II7<`?k6&xzB|oEFutzQX2#L@xQJM zyl&}_-@dn|gku*ZI9WW^A(0!K{4u1ekv*4@S&v(KbI*Simu)4L$)V99$uLXG9g=<) zx11_hjk0p<#NI!%ew=PdVgu@jB;q+-ePfI$P0;Szwr$(CZQHhO+qP}nw$9pncF)?l z`+oWE{c$Htv4{Z<|1Nxfv;qIg;O8spij*tOG;Q;4L+E59C$b1vepNr*e(F0oUYh8s^lvTIrB!6p;@}k zEYED%zJ?Lmaruoa%y7IZnR*4>qm&;sIS;Qj@48I{w#Z`rZ&lx{SLLglA(4R*3uRxi zPsDbpS~Ef4h4^mJRx1?IQA5gA5y2XZ$AZAr#taUE=ECb_8@1N}{n$-U@~^5fjJ>-q38Qi@pcvSGh^wV|xRY@0f4ufBs@%CFYvanq-Z& z?;=nRN?nq9q(bbIK$Y!OoVh3Hm!hWzfp%K!U3`wwwqx}^e}*h;GhW}A4yV{?K!RKL zcoJM-d!am+PHD6Uj?u1i)-gHw`JWbpSn;ezH&lH$>?k6Lk_;HTcaR!Ajn^QgJ~RLQ z69U+YzN3lQ70emV4V)4nBI>wkVwn+E|Ef(Sjje5!#F+taFD1@t<>y^|uuOm3@lx;X z)cbWM=p^5pHwX9BIH*CzL8_V%t*iOuAecmLGShSBwe2FiCBjojiwC!7bOn5&6B!u~ z?D;H!49k)LXR!f;u#iqX7)APSsrQtC6iF{zSZe?Qx9iw@-OjkRox2RjOvpguAcK4} zKxuT%E4~RV0o#8$GfjQv?eDF7w)`65DNPs%bMd?>yIv~H?4JO$ZB~I9VUFu=vc^)5 z+0ft0D^WcJC^%0E`HOXGwu22yTQ(k^5#zhpvQa{sBW z@G{RVr0uwoFyJ{S6ohtXUnDSJIZWZY^*XbqnS70-AaUOye3BjlnRj&53+(k(QpVnd z!9T$a*s%MIN3uECJf}btsA9SqD>}GZ=)qC;TzWr2SokFbHxX<3P;|tk z$vbyn_!>!&I7;60VI@(6xD^Rt(M03cUno99q3ZjsGz7?jRB?|t{z@8sM=y-XYhic@ zp^?#5zeN|u=KoEPJ`a^5P`XiR-^mA%W|tbPa=kNAL`FrF4N&1t>^XUV)z)L}O9pa>qM-fs=_0B@T&Q&wnGXJQCA zcGV{d9=Ho3#xMm8(y$2p*v|b4G0f19bkLj$1xvjmUWfRV(%e*j-}|BB1kf5cWe1yR zHa03+Rz_V3)1{6uV4;wZW$9J;_^%IW4@QTZNf~`<*GdSxD@E-WTXz&*Gye zG|C)rnL@!^&au8XkRbSM*^B3|^a*D%C-&-yTVV;^V~Gf|R%2BTI@BKCDd6e~U~F$8 z<2pLtD#g~9sS`5r_jZMr>%=*?9yY)pO>YJ=sw#@tJXYbp9QT152e*5U2G#glnp4>p z)!MjPWz^KS@3_fhRX+ZGJ#XjUo>%W+O(nq&3FH1H;f6EGZgUqGFC&5?F_SA}$%UZ% z)Ht|IQLFL~z@}EkrxkE4*%WZtt32pj7rs2-%wRQXXKW?@Q{{P+RWV7t!Kau{BB)PwKhAT%z>r2=#AHZS@3a^EkufD+$S>| zG|esr614V9KMn@y!@6M#^f|2g5^(en#*j8lKcaQ?65K+j9Kb3|8?D{tz{e#h{0e*P z_M+0>c#)xZnQLWpaF=V;F{X3hT<4to%F$Lfim_D(s~yio z=EAmVmR;5=CwwsZ%-XAaSRLtbKZv#lPZ~N4*Of0-VN0u`vQaV-8y=S-{0ai%$8dAo zvd!>u2vdaOuI#2SF&pjFHR(GU1##_O^!utJ8l;(&rJ+tVsx_zNCgLh^Maw#&>ou_e zub;IuzPlS&KwH}7Bo2Q<)0ftgNvyt(itAm6v^*#>S}q`;tszl%KfvLJZtgeo(2MR*b!h5>OcIwZ1 zqc$dKm@~&b~9Dg!Hm6( zs9ar@o>o>E8@{7Ycd5LJ~_4$ww3AEiFMRj2$N)<6sxh92nI9d$*FJ#k`zm8@*#X{{2>~EiLJ)skG0H z5QY!CHi-60cZ3DpV+a93-A>`09o3m~#J=<9&Xq;;FoF&Qt2z+CN#RZ3i5j^7SL@rvDS`{#j=GV3g*`kupQhzp|Mn;^oO?lG*F9 z5|JI-viffURbsvOgBwyi+~NK25$Vc3)YA3=d3!^z(@}GEcC5IaZT^BNe+k}YeuZGk z#>hlcvY;j`T(;ZorE(gN1M3yH=hyZy#$R!9{@n5gy$+8i+qK-ioQ0afFKRfbraI-E zz%U&m3Yf9h+H2jBeHp+L@{q+y@?~yW0FJU1wsZAth}VlN}-@cAcr+eX`Yp_6YL2#dA2ff1ATHDbQ>Q$per ziZ`TEcW=2jgegqc(jGRvHdedrK4O_(X9MK0`4`6i8tK;P2J%as-h7`Bwy&nzi4Lcv zxyl$=?@Mk5%*uLZ&;|C=N5aoALKX4Cx~#{8n`Ee6*i5w7`<@JQF4n)y&+amsdlxFc%N{=9G%q80kda?=m zkT^Y_=@+`2zrg;Oi5*$tQ`V8sz%O*`G7_4K>aSwN_vwdTQo)3I_U`8!NQgji(+b=o zxyD2-pvSu6Qazn{gpSHn?WAV7``?yF)|y`5l=;Lv;3acg-$8H|0Gvm(ah=di`wQRr zlmUeqvN$Y(m{?&LRuZ66bw1(S5i^FTe}*mzT1(Jc%TRKkNO9|HaG3`5EP{zUsyqrmPS)jzHTEi3L03-`SMA*XJzdy*O(#x<{7m zGs0XbQQ&b`P96D}Gr)BSOqXeqMh_?hG`)5{3ZQyzGc8BcduPBxGPY0P&{o+3r&na7 zDeC{6R4aRfnK1RG2ylh*@48aZ$9f4(d#fx~m|DY(LdY7Ug$An!Aamvh;yB~_t>6>( z)g>CA>>)m0!T9Q(_S;P@ynSKu$s&i}-Z8(vu;Y^p8r)4-eW=va#M|E7ZPIj=gm$3u zH2UjhTCvPtpZ7kL&xKvxoDVE~=Rq9vntj=BB1z<=cY&CL(JULi@N8+tCLuU>OF-%OJ0N2amUfkC{NJ`yV#FBp4`W={O0t zJT(NODz6UnbUKIkJ>c@3j;&j#T+Zwj)Uvx;4HhKil|EeH(smlZk(scPCC3?fCGA8s z=~wXb$~tI9=BFqZ)Z%;GL+RhrzMwj@6~8KVPO4^mfsIG1AS&U0P-tj+z4K0;47IvR z_wu`5tvUmq2PEW<-y=LBwK5BlE~JPbcK-H$XViYsx18%DJWW6U%p!`xG9j@P^)Y?Ctp}l|(_SD115YZT#W* zdCeFFbQ`kXDjdh4f3F~Hvn2p(nD`>p%8lvCF3(gMD7uG9;B=k;H54@Hxyg^{@04*E zny_3$CasdS4meo4U3_*21A@xK#_&`7q*cLE9N|LVNTM3pco)Qq)EIt+pUJY*{(0IJ zP_$MUj^AmHSh{`O#Lzrf@&{=Cfx7;gr%L0$69vj=2^5gkI*Tbh3gjw3ASN7xS z<&jP*UR= zh!L=Wqe0Pmsnd#XKx2`Nu8>j!in8_j=y}0FSfq0ShQX^V(QsuC=0#=;STt3}S8pCM z_~w!xH4}U9Mlv1aXuz{H3T;&ff@AoqeI6#^A1Hc5GSCSes}>Z}kcAe#7t>B~7o;4U zKCYjUN7aKm*Xqo-9ZI&<(l$qN1;M%qV)eq7u%*v%Q8adE5N*rw^xV;8RXOS#D};(% z_EoBn@Khg9s={Y*M}Av13NI2|2=bBFObc6pp@2qa*17cJ43(zEFNC^r#8rSD@a6Rf zpS%>%fv9bftHdS5)#1%jhUx}55rUrLu#*5j5hN94ref8t{;CHWVF`D#&1dGZ;=nG^ z`Go9*6=_d7dazV#ic4XBG-iPG;y#K!TWzITcb~1-svm$Tzjt#-y=A@7-Zz$H#Zvb+ zk;g5Fy=iwN0wQn6ho8tP6c!qF!&6nvrBGBNjKoyAtq#9(E$l~ZlW3$Hdl}#Exsp*> zi(~6y0WFX}`Xz{L8O(WJYE|*@roX6FOW}L7U0WT>VVFAM*KJVsrq%RpmyTEai(yJ0 zr2U-@2X(Y$Y~NarJNaczOTk=q1BV7V;gN`nPa&*^|J?MMFvx4V9D(QbejBC{gV3FD zLoGk1#f@928;K-m}&wiqCr(k!3sR*mybIQ64?-ng9ZfhU*=1;-QERLZ1HI2 zOlo)xlLt1|O<5z{I`Po84vLnoh%`D@)io%r2B9+F8mOQ&e1XDO72n!GuW&xdP?2D7 z`&&EJcuhn*t@a7srnA!;ft$e@d@wz!f`eMVGiopQX8@jZ-!vTk=t~`p^d>o$w2`9 zcpcXjk%@3~C@u>LvKL>3G<`7W-)jz!0pM3|J&+16SHzP1(5z_`lsq9p$?4f`%lctE z4npF^0*t(BK_j%m^g;bsJnVsf_~FlbLYii878Gwh$6 zWE35$qU`4bBwNC7f;cqv9?qSdc|l*W%^+yLRVY={^7v^tEx24f%o#S`uPc8pWJKTb zI8q-Y5#&QT6V{{}+y>mS6gI_xp+JBXh~~A|RE09^j}VW-%vtW2X6WJy{2(z`}Sc zzrbro%!;|!I(%%8{sG(_iGd*QQ>f7`-tUSE?~h#?AeZiht4%~+FzX4Fs-$2fccZ0Y zW%g^7i5Zq2ezf4QEA4b9Gc@UthVHf9JsE>{z(}&P56++r=lgW?{<#OJ61c-yXDqCG zAWJTZ(AN0zmtVb2_Rq9xZn=9<_$EGJhA9J@V?zxFa5JAlUe@cac&IlWxJfqc(cM6; zbJv-_5c7R5V29Z)j$JPwMVs#6CwlAt{p!Yyf8KljyBHKo`2OQ=-c6nR8LwY9Im%OB zJ=;*TFCRE(cW+mt*9(nDvgUQ=7u?!)H@R8lNFW6;h(E8A%>J-Wb5x~ry1vw0Q;4r^ zKk0{XwoIPzVeqN?Nc8;HXcH^JR8@V+sFkb%-V7b-mYz|u59`oSMvUo=(t`GHILlMB z{eGi{59`c>FT(w7Bno5(hg#NmvkRFq%F$ zBU^0441%+^UZ$YMWz3HZ3o;Ih?;)m7o{ZsmKV4Ns>bj7{VnqxWx3OKVd4mIV4nMVs zPDP%RD=_`C>{6fTm3n*-K3t|VKF;iK42dasmR zq};|}u+@moHi)TbyN3Mz$QNDwBZRVkvD9%vSpKQlp(m`&?i~Vg z6L;|G8JPm(%uuWcY9P;Rr{xHtS&6G$?$K!{lyMPuM#-3@iHlERdyKsF9-B?RF};0if5p!U5yHUrs@IXTBQ8K*b~9uc~e$Kwx-LUn=#Q*soP zJUoO(WjHwdXnpP!;%w1>R{U|wq@#${kKG=>D;m>0mKn9C<+w9s@GrMh+?C)e9iAga z5(|Yhh}`75;gru4RLAb9vd^D2cu_S&mb}3!D-qwIy(R(&n0Q~HxaCE}_m{CPX60`2 zY$iCdYrkVh}KcY@C@9p5r7on7SCyjCCED(5wxSLrYsp(cSwi@ zm^5YQ;Zc4rslC~AR@=c|M^UqJBP}Sz(||m-w6v6TfzW?PZHEAQe*Zbw z^PkS~N6ufjJJu=1hI5%RgaFhz5a2akmu|FGbF=~{m%ja~kuSe)O%@%a$R0#$@^5EcU5hd#YF8b%C39! z1VPy>9O3h#MNB`vTFo;R6Y9$1W#U{b#o-~KFDxMT`@GyYEMh+6k#Bk%i_W?>?6q(1 zWjj@NpN7_BrX`q2gExh;CQmXCeY?w?3lXThjtBFphm17F_FKj1qER*{K!6~ zNO>hS5xFuZbQt)^%S!TutrvR|bl(M$+0oDgp5UYlqb5hWrbS+>h!3=Jzm#~_c}Twi zZ0MXyhxZz_hVqXQ0%}=sHW3XUpQ!Z~ag`2G8GmS(Ny4xL_Rdh;bpUfOL&S!${5azvug%Ws>ImBF zk6VslQ197<&|4@5_5?4-x6;RZM%|f0&)WDf9wU8Z!E$3S)L{af)>Bt^N2!vDxVNAnqQ!Ip@kF1=03N znpXzV@P1sd)aD$+pj;}kEqM6aOb?8?wD~7_B{k#YeSUERe`XzlvX#`+tPA2-Zf*dS;S4D}E(8Bw$6^@tGa+ApcYnXEr zN`MiIHCe@|CR?AdXl_nu8;R8w0Z^sW&0`VYkKRU^5o$;689&T*StI|TN$P+2S`>a+ z)*V-_d1DzIED`aqYMZ!Fid~}xF*t}tAtJKG|8o&^fsFw6IT=<-5@U4ZL?q~Ekf)=| z8|eJ}EEl>J9YY_xj^w*aU6;~VsRt;wCog5nM$Hm*ZH&#}YjM;CyZ|XV;`G|jSmB2M zAhha`sswObtexTgn`OPp+vt7}<5CqPl#$S1xDA5ft-_7j_P{q%DXt_6VA=08K69*L ziTPuat3pXzUyH-mB`h5tP5resLGu<~UP&q(nZNi#)uECpfU@hi?k zF6YM(IRSlKw`adF6g=|pmPL$b!E-vXl`g=)Lk5-2JUud;^jQ|B)6OO0=>E^TLlp9= zy1&QJPUjJesWRAie6*j{s{c&mG$MBgIqVwahyTGay4)qIQp4`xUvMu%M)w){W~CkF z3I=4(I2DD0&_*;clP?zF65zk)t9EDCcT=ULiehR(A3cZKrtZ@{09WlE@p%b7Y$z}; z3T2#t)f3yR3I{#O64kdpT5d*VurRZN>GN87dYsX``s>$l@GHq@5-@FP*~NGu`_c7w zU4S+_oj2Y4H#s|!t(FY6Se=a0{_iregzOG==gHYtBYOXZ>-psXo8O_y@#!+qJXk%0JXKaB zc(hfJW~<5~SBT^k=8V_?B9+sW;DHb&TXh=8z#AEMgoL$?K?fgd@XdZ`i*Y=}%@Nh#5s~)GZx~)JcPbe%tP}<#8EP?jX4`_3~QEd}W|+ z(LS;~Q%7t(_$&qg(6!(`sl$dlhoTcbS=c%0H^5^MBE9M%%(UoNrR}cw@-4n33~rsg42AsM(Dfjl7^M!Yg$D<=$+qcR znau)7%gSw@YOX~4LgwSgk6bX#AI?n=+;^Iie{dgA>PxUV=kCaz5E$wXe~cB^j4Dz``Q zSF(TPfLu4_7(gb}2jOrC>*bPVhe(7}krQVVJ1FF1@AS7IOC~{iTd>oJM4}rpcP+(=@=vM&0?4{$8A2e8eYNOWRB1t^~-!jkcF8zhC^9k#p zH$hv_IoS;P3l*4siPgdw@!l}qjK#y`!ru(L!75WiSrr<`z|gYgPNHpH9uT6mssb%3 z1Hcml3h@}6rf>0mfOWVdpJB*|#|cdV>MkohM!LbU zbMcih{gm*L1gM6?Gf`_&F6-0GoFr7apu$P9Yer|=u=BJ`q%?D zdb!;O6U))Ji@>Jj!@;lO5N}fHpG2NM1s_7E4|v+E@+$LpL9q*gu*V9GU->%1l;<5u zn!@4(o{=vX>1PrD@hx!f*ko|1aST_<_Wo){{iXC&urT%mwrs>xT&4N@o0^Q&Iir#J zm%$!1$1w*bnRNUN;FJ+aJ75%5KEjY2=(FN!>`Q2&`8PhN-Z@SzTCc8g*oed>=Jl}e} zymCdwjiMJ@J63V@CSBf{k@Py@r(4Id+I4}|;@w9k3V|K4-w_z$C02U9^zE+ud3}aR zwk36drRM#NTCP|UQR))xiduZ=5yTpesb5}a<6`Jec!URfp6T5Z`>zu zT!KEl!~uTzTK({~_~DCJ-3{4n;}UVYuh4VWB$UldEJu{dLzRD2_rBGWG$O7faP1Gc z{o6CPM1^SE{+_8x+bzuVA2rA*;uooQ(Z=IEYkRYKCbxMD99H8_J1RFju_d8?e?s~V z&}eO+-s3sxZmT8XmR#d6i4tZ3CP>Lm3}FNTIpmy~dsaP0MK=I@1?0F_)RLf0i;Z1^ z#Nou?#a9oLc1o2?ci-i$_N}FH&ytxxW->G>!@0Me*7$Bj%gz$@NuSWqq?_$nx++=% zKskNv+H46bAj2T)(Al+8VQ5n|*g22H#I21|69iqsBPCQn_O#q2tjdpj^LsVON_)sx z$U|Cm6xQJ$*~P+_G~`bhwf{I350|myXkT7{c@A$ig0UqUTwx82(+A(2Fd?E(ZPDot zG|hU>DE73{jd8I;)RAuwedRSZ?|Y7i1R2GV|H#)={{#0L7FE+}HLpdDa97BBjt!=5 z&Oag*bk*8tVuwZIS0O!Mx{n@)S>cC>UM*M9{OJ1vAHhu2#Lv`W##$9CLl>$)&ygdB zmy7_T%s=in{UQ@tFkP#X1~Tg+tx_+2Q1gqr@rilWo(Iy9y-|i_pIc%D*@lwj`Rg+Q zLWBh|S-BtnT#*mbU{u|ul~w=epU~`v#O~3`oI#6|HMk@iNE5el^4(tm=j8oSQY}cS za3_)_eo9iIAXZniC89HjX6M1Pr;3)PmZpu}$=>n5;YP5kar#>^7fk9i+ISds#^MmO z!8XDq9x}1_#yLj}m)(X>J39`;g>Z=(%!fCyok|6t396IaUNLxQ|3HBiDHg3WU7jbN ziSvuY^|D}(gPB)fhrsZWlWpI(mO0YQuUx@94Q=B&a{I;cXkwYYVz%tx1w+7bMS%-0oP*1l9maG;!D8>1gz#b6&JkQ|gxt1b$L#G>}vK~9!uy@0~ z>L;FJ?^f#LRaNLlE%cJI)*>Hbj=ef$uHqn9M7TEErKolgR&+J9BB!ka_i zD}Oc|u$Q=1VXQ8VVtD-iIHO|eXO*48r5B&8Kb4V;NI_-xF(55K$mrUW#I?V7h0{^> zFl8j+!Vh`if-I^TsteNGd)zC^>jj(ofMj7&z57o&KrIhwkmRs%e6=BhQ^S+@_H_QL z4YtC0Xtn@JZc!6#{B^)nsOK%Z-4f2^JzQgd#9KEWuZD6bAdv90+M}__-;nV!NpBGgQX9K4_b8r52S6}RZ6}3Eep9v?h+w%>xGBp z?iT?5tb7=JLL9U~Hm#>SX+R|a3ivyi4rw~?a~A)Qkq1y`6l9de$zQN67=#8Hk&pm! zORN!PVY7a&D@L1Szi!eO3xwoRw>&OW!&)$t`c#|D@6k2HD%g6D_38Z3BCp=fN{0+? zcOWpq%avvTcr^YZ^}`4LH3wTyVR!Tjsfb~wNI{W-{MOBvu}^gQL18`pQu0JbrH~id z`W1!rB!f~Llmexf0O2nkV`L&i@)y~DF+;!A&6P4Zhg);dG~yd!eg?{TnUSB#S%4li1U-a{X%S2Zg$mySx+8rM&d^;@^ z2l7$)0i=ELdc9h3b9}}>jjw=mOI*`nG+YM9tU5Cl87Q~&Z`&g#yN1YmCa4LU>oKE( zY^);0PWE%3eZ*!aI;>d-ZV7RSJrFd$nL1gX@FVS-NAWgEWBe$>yoEAKs3?s)Y|S*6 z)vVS&9^EGWm1dCn>Rn?W_XLyL7Hmk9ff4qRo{d5aY9xSLuIK*h$5vL=$*9YdHn{7w zFM9PWt5X2NUNfg$o+B_XqEQ`m{W6fNlopkYBYv(bUZ;68J0yi5mMj~{Cy%0tv>Q3b z{SR-j2K4zaj!aUlyl=*GfDYg_MB+H@4M<$0Tr<@&)T z?8uLWYDKWvMiQPTxg3#VYXsON5VIM~Z43n}iV`eabMLF=fPmaiV)$oGnKoyY^>TOH za%b5K920a+1fE9(4~=8nh{$WUcVrQrRGELOl*1RYrz;xwcDTO-j=9FVHHdAK?xvDB zAc4a812OB zks<;fEou70zs`_L>+Jle{QVE9p{iB2cY!$?@t>NUGcZ4TE0nPc_|~>A8SYok24jfg z8Mxe_#m&FLyVzzjEY9ry2G3bZ8i`1i*?iBABN zRF)3EQl6~NozwI$k5-K`#9&N>zeg&_)$nA+1lCLQr~pqZb&i{^toP3e65Xlb75LUU zo(LbhES|D$0p7znmT2fi5Kvl{mCp_0lpMZYOyE>Ia>k+zh-f$%ozQ8&<$LQI$ugh9 z0mf930f6qtD<*ef{%2(ys8e2FP92tUUgxq2G_z|MMO&1i`245SyLq5q%0A1(#TI3w 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 literal 0 HcmV?d00001 diff --git a/src/cocoa/zdoom.xib b/src/cocoa/zdoom.xib new file mode 100644 index 0000000000..56099dc4b4 --- /dev/null +++ b/src/cocoa/zdoom.xib @@ -0,0 +1,874 @@ + + + + 1060 + 11C74 + 851 + 1138.23 + 567.00 + + com.apple.InterfaceBuilder.CocoaPlugin + 851 + + + YES + + + + YES + com.apple.InterfaceBuilder.CocoaPlugin + + + PluginDependencyRecalculationVersion + + + + YES + + NSApplication + + + FirstResponder + + + NSApplication + + + NSFontManager + + + Main Menu + + YES + + + ZDoom + + 2147483647 + + NSImage + NSMenuCheckmark + + + NSImage + NSMenuMixedState + + submenuAction: + + ZDoom + + YES + + + About ZDoom + + 2147483647 + + + + + + YES + YES + + + 2147483647 + + + + + + Preferences… + , + 1048576 + 2147483647 + + + + + + YES + YES + + + 2147483647 + + + + + + Services + + 2147483647 + + + submenuAction: + + Services + + YES + + _NSServicesMenu + + + + + YES + YES + + + 2147483647 + + + + + + Hide ZDoom + h + 1048576 + 2147483647 + + + + + + Hide Others + h + 1572864 + 2147483647 + + + + + + Show All + + 2147483647 + + + + + + YES + YES + + + 2147483647 + + + + + + Quit ZDoom + q + 1048576 + 2147483647 + + + + + _NSAppleMenu + + + + + Edit + + 2147483647 + + + submenuAction: + + Edit + + YES + + + Undo + z + 1048576 + 2147483647 + + + + + + Redo + Z + 1048576 + 2147483647 + + + + + + YES + YES + + + 2147483647 + + + + + + Cut + x + 1048576 + 2147483647 + + + + + + Copy + c + 1048576 + 2147483647 + + + + + + Paste + v + 1048576 + 2147483647 + + + + + + Delete + + 2147483647 + + + + + + Select All + a + 1048576 + 2147483647 + + + + + + + + + Window + + 2147483647 + + + submenuAction: + + Window + + YES + + + Minimize + m + 1048576 + 2147483647 + + + + + + Zoom + + 2147483647 + + + + + + YES + YES + + + 2147483647 + + + + + + Bring All to Front + + 2147483647 + + + + + _NSWindowsMenu + + + + _NSMainMenu + + + + + YES + + + performMiniaturize: + + + + 37 + + + + arrangeInFront: + + + + 39 + + + + orderFrontStandardAboutPanel: + + + + 142 + + + + performZoom: + + + + 240 + + + + hide: + + + + 367 + + + + hideOtherApplications: + + + + 368 + + + + terminate: + + + + 369 + + + + unhideAllApplications: + + + + 370 + + + + cut: + + + + 738 + + + + paste: + + + + 739 + + + + redo: + + + + 742 + + + + undo: + + + + 746 + + + + copy: + + + + 752 + + + + delete: + + + + 753 + + + + selectAll: + + + + 755 + + + + + YES + + 0 + + YES + + + + + + -2 + + + File's Owner + + + -1 + + + First Responder + + + -3 + + + Application + + + 29 + + + YES + + + + + + + + 19 + + + YES + + + + + + 56 + + + YES + + + + + + 57 + + + YES + + + + + + + + + + + + + + + + 58 + + + + + 134 + + + + + 150 + + + + + 136 + + + + + 144 + + + + + 129 + + + + + 143 + + + + + 236 + + + + + 131 + + + YES + + + + + + 149 + + + + + 145 + + + + + 130 + + + + + 24 + + + YES + + + + + + + + + 92 + + + + + 5 + + + + + 239 + + + + + 23 + + + + + 371 + + + + + 681 + + + YES + + + + + + 682 + + + YES + + + + + + + + + + + + + 683 + + + + + 684 + + + + + 685 + + + + + 686 + + + + + 687 + + + + + 688 + + + + + 690 + + + + + 691 + + + + + + + YES + + YES + -3.IBPluginDependency + 129.IBPluginDependency + 129.ImportedFromIB2 + 130.IBPluginDependency + 130.ImportedFromIB2 + 130.editorWindowContentRectSynchronizationRect + 131.IBPluginDependency + 131.ImportedFromIB2 + 134.IBPluginDependency + 134.ImportedFromIB2 + 136.IBPluginDependency + 136.ImportedFromIB2 + 143.IBPluginDependency + 143.ImportedFromIB2 + 144.IBPluginDependency + 144.ImportedFromIB2 + 145.IBPluginDependency + 145.ImportedFromIB2 + 149.IBPluginDependency + 149.ImportedFromIB2 + 150.IBPluginDependency + 150.ImportedFromIB2 + 19.IBPluginDependency + 19.ImportedFromIB2 + 23.IBPluginDependency + 23.ImportedFromIB2 + 236.IBPluginDependency + 236.ImportedFromIB2 + 239.IBPluginDependency + 239.ImportedFromIB2 + 24.IBEditorWindowLastContentRect + 24.IBPluginDependency + 24.ImportedFromIB2 + 24.editorWindowContentRectSynchronizationRect + 29.IBEditorWindowLastContentRect + 29.IBPluginDependency + 29.ImportedFromIB2 + 29.WindowOrigin + 29.editorWindowContentRectSynchronizationRect + 5.IBPluginDependency + 5.ImportedFromIB2 + 56.IBPluginDependency + 56.ImportedFromIB2 + 57.IBEditorWindowLastContentRect + 57.IBPluginDependency + 57.ImportedFromIB2 + 57.editorWindowContentRectSynchronizationRect + 58.IBPluginDependency + 58.ImportedFromIB2 + 681.IBPluginDependency + 682.IBEditorWindowLastContentRect + 682.IBPluginDependency + 683.IBPluginDependency + 684.IBPluginDependency + 685.IBPluginDependency + 686.IBPluginDependency + 687.IBPluginDependency + 688.IBPluginDependency + 690.IBPluginDependency + 691.IBPluginDependency + 92.IBPluginDependency + 92.ImportedFromIB2 + + + YES + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + + com.apple.InterfaceBuilder.CocoaPlugin + + {{436, 809}, {64, 6}} + com.apple.InterfaceBuilder.CocoaPlugin + + com.apple.InterfaceBuilder.CocoaPlugin + + com.apple.InterfaceBuilder.CocoaPlugin + + com.apple.InterfaceBuilder.CocoaPlugin + + com.apple.InterfaceBuilder.CocoaPlugin + + com.apple.InterfaceBuilder.CocoaPlugin + + com.apple.InterfaceBuilder.CocoaPlugin + + com.apple.InterfaceBuilder.CocoaPlugin + + com.apple.InterfaceBuilder.CocoaPlugin + + com.apple.InterfaceBuilder.CocoaPlugin + + com.apple.InterfaceBuilder.CocoaPlugin + + com.apple.InterfaceBuilder.CocoaPlugin + + {{651, 262}, {194, 73}} + com.apple.InterfaceBuilder.CocoaPlugin + + {{525, 802}, {197, 73}} + {{514, 335}, {220, 20}} + com.apple.InterfaceBuilder.CocoaPlugin + + {74, 862} + {{11, 977}, {478, 20}} + com.apple.InterfaceBuilder.CocoaPlugin + + com.apple.InterfaceBuilder.CocoaPlugin + + {{487, 217}, {195, 183}} + com.apple.InterfaceBuilder.CocoaPlugin + + {{23, 794}, {245, 183}} + com.apple.InterfaceBuilder.CocoaPlugin + + com.apple.InterfaceBuilder.CocoaPlugin + {{607, 182}, {151, 153}} + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + + + + + YES + + + YES + + + + + YES + + + YES + + + + 842 + + + + YES + + NSObject + + IBFrameworkSource + Print.framework/Headers/PDEPluginInterface.h + + + + + 0 + IBCocoaFramework + + com.apple.InterfaceBuilder.CocoaPlugin.macosx + + + + com.apple.InterfaceBuilder.CocoaPlugin.InterfaceBuilder3 + + + YES + ZDoom.xcodeproj + 3 + + YES + + YES + NSMenuCheckmark + NSMenuMixedState + + + YES + {9, 8} + {7, 2} + + + +