Merged from trunk with revision range 36835-37865,
[blender.git] / intern / ghost / intern / GHOST_SystemCocoa.mm
1 /**
2  * $Id$
3  * ***** BEGIN GPL LICENSE BLOCK *****
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License
7  * as published by the Free Software Foundation; either version 2
8  * of the License, or (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software Foundation,
17  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18  *
19  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
20  * All rights reserved.
21  *
22  * The Original Code is: all of this file.
23  *
24  * Contributor(s):      Maarten Gribnau 05/2001
25  *                                      Damien Plisson 09/2009
26  *
27  * ***** END GPL LICENSE BLOCK *****
28  */
29
30 #import <Cocoa/Cocoa.h>
31
32 /*For the currently not ported to Cocoa keyboard layout functions (64bit & 10.6 compatible)*/
33 #include <Carbon/Carbon.h>
34
35 #include <sys/time.h>
36 #include <sys/types.h>
37 #include <sys/sysctl.h>
38
39 #include "GHOST_SystemCocoa.h"
40
41 #include "GHOST_DisplayManagerCocoa.h"
42 #include "GHOST_EventKey.h"
43 #include "GHOST_EventButton.h"
44 #include "GHOST_EventCursor.h"
45 #include "GHOST_EventWheel.h"
46 #include "GHOST_EventNDOF.h"
47 #include "GHOST_EventTrackpad.h"
48 #include "GHOST_EventDragnDrop.h"
49 #include "GHOST_EventString.h"
50
51 #include "GHOST_TimerManager.h"
52 #include "GHOST_TimerTask.h"
53 #include "GHOST_WindowManager.h"
54 #include "GHOST_WindowCocoa.h"
55 #include "GHOST_NDOFManager.h"
56 #include "AssertMacros.h"
57
58 #pragma mark KeyMap, mouse converters
59 #if MAC_OS_X_VERSION_MIN_REQUIRED <= MAC_OS_X_VERSION_10_4
60 /* Keycodes not defined in Tiger */
61 /*  
62  *  Summary:
63  *    Virtual keycodes
64  *  
65  *  Discussion:
66  *    These constants are the virtual keycodes defined originally in
67  *    Inside Mac Volume V, pg. V-191. They identify physical keys on a
68  *    keyboard. Those constants with "ANSI" in the name are labeled
69  *    according to the key position on an ANSI-standard US keyboard.
70  *    For example, kVK_ANSI_A indicates the virtual keycode for the key
71  *    with the letter 'A' in the US keyboard layout. Other keyboard
72  *    layouts may have the 'A' key label on a different physical key;
73  *    in this case, pressing 'A' will generate a different virtual
74  *    keycode.
75  */
76 enum {
77         kVK_ANSI_A                    = 0x00,
78         kVK_ANSI_S                    = 0x01,
79         kVK_ANSI_D                    = 0x02,
80         kVK_ANSI_F                    = 0x03,
81         kVK_ANSI_H                    = 0x04,
82         kVK_ANSI_G                    = 0x05,
83         kVK_ANSI_Z                    = 0x06,
84         kVK_ANSI_X                    = 0x07,
85         kVK_ANSI_C                    = 0x08,
86         kVK_ANSI_V                    = 0x09,
87         kVK_ANSI_B                    = 0x0B,
88         kVK_ANSI_Q                    = 0x0C,
89         kVK_ANSI_W                    = 0x0D,
90         kVK_ANSI_E                    = 0x0E,
91         kVK_ANSI_R                    = 0x0F,
92         kVK_ANSI_Y                    = 0x10,
93         kVK_ANSI_T                    = 0x11,
94         kVK_ANSI_1                    = 0x12,
95         kVK_ANSI_2                    = 0x13,
96         kVK_ANSI_3                    = 0x14,
97         kVK_ANSI_4                    = 0x15,
98         kVK_ANSI_6                    = 0x16,
99         kVK_ANSI_5                    = 0x17,
100         kVK_ANSI_Equal                = 0x18,
101         kVK_ANSI_9                    = 0x19,
102         kVK_ANSI_7                    = 0x1A,
103         kVK_ANSI_Minus                = 0x1B,
104         kVK_ANSI_8                    = 0x1C,
105         kVK_ANSI_0                    = 0x1D,
106         kVK_ANSI_RightBracket         = 0x1E,
107         kVK_ANSI_O                    = 0x1F,
108         kVK_ANSI_U                    = 0x20,
109         kVK_ANSI_LeftBracket          = 0x21,
110         kVK_ANSI_I                    = 0x22,
111         kVK_ANSI_P                    = 0x23,
112         kVK_ANSI_L                    = 0x25,
113         kVK_ANSI_J                    = 0x26,
114         kVK_ANSI_Quote                = 0x27,
115         kVK_ANSI_K                    = 0x28,
116         kVK_ANSI_Semicolon            = 0x29,
117         kVK_ANSI_Backslash            = 0x2A,
118         kVK_ANSI_Comma                = 0x2B,
119         kVK_ANSI_Slash                = 0x2C,
120         kVK_ANSI_N                    = 0x2D,
121         kVK_ANSI_M                    = 0x2E,
122         kVK_ANSI_Period               = 0x2F,
123         kVK_ANSI_Grave                = 0x32,
124         kVK_ANSI_KeypadDecimal        = 0x41,
125         kVK_ANSI_KeypadMultiply       = 0x43,
126         kVK_ANSI_KeypadPlus           = 0x45,
127         kVK_ANSI_KeypadClear          = 0x47,
128         kVK_ANSI_KeypadDivide         = 0x4B,
129         kVK_ANSI_KeypadEnter          = 0x4C,
130         kVK_ANSI_KeypadMinus          = 0x4E,
131         kVK_ANSI_KeypadEquals         = 0x51,
132         kVK_ANSI_Keypad0              = 0x52,
133         kVK_ANSI_Keypad1              = 0x53,
134         kVK_ANSI_Keypad2              = 0x54,
135         kVK_ANSI_Keypad3              = 0x55,
136         kVK_ANSI_Keypad4              = 0x56,
137         kVK_ANSI_Keypad5              = 0x57,
138         kVK_ANSI_Keypad6              = 0x58,
139         kVK_ANSI_Keypad7              = 0x59,
140         kVK_ANSI_Keypad8              = 0x5B,
141         kVK_ANSI_Keypad9              = 0x5C
142 };
143
144 /* keycodes for keys that are independent of keyboard layout*/
145 enum {
146         kVK_Return                    = 0x24,
147         kVK_Tab                       = 0x30,
148         kVK_Space                     = 0x31,
149         kVK_Delete                    = 0x33,
150         kVK_Escape                    = 0x35,
151         kVK_Command                   = 0x37,
152         kVK_Shift                     = 0x38,
153         kVK_CapsLock                  = 0x39,
154         kVK_Option                    = 0x3A,
155         kVK_Control                   = 0x3B,
156         kVK_RightShift                = 0x3C,
157         kVK_RightOption               = 0x3D,
158         kVK_RightControl              = 0x3E,
159         kVK_Function                  = 0x3F,
160         kVK_F17                       = 0x40,
161         kVK_VolumeUp                  = 0x48,
162         kVK_VolumeDown                = 0x49,
163         kVK_Mute                      = 0x4A,
164         kVK_F18                       = 0x4F,
165         kVK_F19                       = 0x50,
166         kVK_F20                       = 0x5A,
167         kVK_F5                        = 0x60,
168         kVK_F6                        = 0x61,
169         kVK_F7                        = 0x62,
170         kVK_F3                        = 0x63,
171         kVK_F8                        = 0x64,
172         kVK_F9                        = 0x65,
173         kVK_F11                       = 0x67,
174         kVK_F13                       = 0x69,
175         kVK_F16                       = 0x6A,
176         kVK_F14                       = 0x6B,
177         kVK_F10                       = 0x6D,
178         kVK_F12                       = 0x6F,
179         kVK_F15                       = 0x71,
180         kVK_Help                      = 0x72,
181         kVK_Home                      = 0x73,
182         kVK_PageUp                    = 0x74,
183         kVK_ForwardDelete             = 0x75,
184         kVK_F4                        = 0x76,
185         kVK_End                       = 0x77,
186         kVK_F2                        = 0x78,
187         kVK_PageDown                  = 0x79,
188         kVK_F1                        = 0x7A,
189         kVK_LeftArrow                 = 0x7B,
190         kVK_RightArrow                = 0x7C,
191         kVK_DownArrow                 = 0x7D,
192         kVK_UpArrow                   = 0x7E
193 };
194
195 /* ISO keyboards only*/
196 enum {
197         kVK_ISO_Section               = 0x0A
198 };
199
200 /* JIS keyboards only*/
201 enum {
202         kVK_JIS_Yen                   = 0x5D,
203         kVK_JIS_Underscore            = 0x5E,
204         kVK_JIS_KeypadComma           = 0x5F,
205         kVK_JIS_Eisu                  = 0x66,
206         kVK_JIS_Kana                  = 0x68
207 };
208 #endif
209
210 static GHOST_TButtonMask convertButton(int button)
211 {
212         switch (button) {
213                 case 0:
214                         return GHOST_kButtonMaskLeft;
215                 case 1:
216                         return GHOST_kButtonMaskRight;
217                 case 2:
218                         return GHOST_kButtonMaskMiddle;
219                 case 3:
220                         return GHOST_kButtonMaskButton4;
221                 case 4:
222                         return GHOST_kButtonMaskButton5;
223                 default:
224                         return GHOST_kButtonMaskLeft;
225         }
226 }
227
228 /**
229  * Converts Mac rawkey codes (same for Cocoa & Carbon)
230  * into GHOST key codes
231  * @param rawCode The raw physical key code
232  * @param recvChar the character ignoring modifiers (except for shift)
233  * @return Ghost key code
234  */
235 static GHOST_TKey convertKey(int rawCode, unichar recvChar, UInt16 keyAction) 
236 {       
237         
238         //printf("\nrecvchar %c 0x%x",recvChar,recvChar);
239         switch (rawCode) {
240                 /*Physical keycodes not used due to map changes in int'l keyboards
241                 case kVK_ANSI_A:        return GHOST_kKeyA;
242                 case kVK_ANSI_B:        return GHOST_kKeyB;
243                 case kVK_ANSI_C:        return GHOST_kKeyC;
244                 case kVK_ANSI_D:        return GHOST_kKeyD;
245                 case kVK_ANSI_E:        return GHOST_kKeyE;
246                 case kVK_ANSI_F:        return GHOST_kKeyF;
247                 case kVK_ANSI_G:        return GHOST_kKeyG;
248                 case kVK_ANSI_H:        return GHOST_kKeyH;
249                 case kVK_ANSI_I:        return GHOST_kKeyI;
250                 case kVK_ANSI_J:        return GHOST_kKeyJ;
251                 case kVK_ANSI_K:        return GHOST_kKeyK;
252                 case kVK_ANSI_L:        return GHOST_kKeyL;
253                 case kVK_ANSI_M:        return GHOST_kKeyM;
254                 case kVK_ANSI_N:        return GHOST_kKeyN;
255                 case kVK_ANSI_O:        return GHOST_kKeyO;
256                 case kVK_ANSI_P:        return GHOST_kKeyP;
257                 case kVK_ANSI_Q:        return GHOST_kKeyQ;
258                 case kVK_ANSI_R:        return GHOST_kKeyR;
259                 case kVK_ANSI_S:        return GHOST_kKeyS;
260                 case kVK_ANSI_T:        return GHOST_kKeyT;
261                 case kVK_ANSI_U:        return GHOST_kKeyU;
262                 case kVK_ANSI_V:        return GHOST_kKeyV;
263                 case kVK_ANSI_W:        return GHOST_kKeyW;
264                 case kVK_ANSI_X:        return GHOST_kKeyX;
265                 case kVK_ANSI_Y:        return GHOST_kKeyY;
266                 case kVK_ANSI_Z:        return GHOST_kKeyZ;*/
267                 
268                 /* Numbers keys mapped to handle some int'l keyboard (e.g. French)*/
269                 case kVK_ISO_Section: return    GHOST_kKeyUnknown;
270                 case kVK_ANSI_1:        return GHOST_kKey1;
271                 case kVK_ANSI_2:        return GHOST_kKey2;
272                 case kVK_ANSI_3:        return GHOST_kKey3;
273                 case kVK_ANSI_4:        return GHOST_kKey4;
274                 case kVK_ANSI_5:        return GHOST_kKey5;
275                 case kVK_ANSI_6:        return GHOST_kKey6;
276                 case kVK_ANSI_7:        return GHOST_kKey7;
277                 case kVK_ANSI_8:        return GHOST_kKey8;
278                 case kVK_ANSI_9:        return GHOST_kKey9;
279                 case kVK_ANSI_0:        return GHOST_kKey0;
280         
281                 case kVK_ANSI_Keypad0:                  return GHOST_kKeyNumpad0;
282                 case kVK_ANSI_Keypad1:                  return GHOST_kKeyNumpad1;
283                 case kVK_ANSI_Keypad2:                  return GHOST_kKeyNumpad2;
284                 case kVK_ANSI_Keypad3:                  return GHOST_kKeyNumpad3;
285                 case kVK_ANSI_Keypad4:                  return GHOST_kKeyNumpad4;
286                 case kVK_ANSI_Keypad5:                  return GHOST_kKeyNumpad5;
287                 case kVK_ANSI_Keypad6:                  return GHOST_kKeyNumpad6;
288                 case kVK_ANSI_Keypad7:                  return GHOST_kKeyNumpad7;
289                 case kVK_ANSI_Keypad8:                  return GHOST_kKeyNumpad8;
290                 case kVK_ANSI_Keypad9:                  return GHOST_kKeyNumpad9;
291                 case kVK_ANSI_KeypadDecimal:    return GHOST_kKeyNumpadPeriod;
292                 case kVK_ANSI_KeypadEnter:              return GHOST_kKeyNumpadEnter;
293                 case kVK_ANSI_KeypadPlus:               return GHOST_kKeyNumpadPlus;
294                 case kVK_ANSI_KeypadMinus:              return GHOST_kKeyNumpadMinus;
295                 case kVK_ANSI_KeypadMultiply:   return GHOST_kKeyNumpadAsterisk;
296                 case kVK_ANSI_KeypadDivide:     return GHOST_kKeyNumpadSlash;
297                 case kVK_ANSI_KeypadClear:              return GHOST_kKeyUnknown;
298
299                 case kVK_F1:                            return GHOST_kKeyF1;
300                 case kVK_F2:                            return GHOST_kKeyF2;
301                 case kVK_F3:                            return GHOST_kKeyF3;
302                 case kVK_F4:                            return GHOST_kKeyF4;
303                 case kVK_F5:                            return GHOST_kKeyF5;
304                 case kVK_F6:                            return GHOST_kKeyF6;
305                 case kVK_F7:                            return GHOST_kKeyF7;
306                 case kVK_F8:                            return GHOST_kKeyF8;
307                 case kVK_F9:                            return GHOST_kKeyF9;
308                 case kVK_F10:                           return GHOST_kKeyF10;
309                 case kVK_F11:                           return GHOST_kKeyF11;
310                 case kVK_F12:                           return GHOST_kKeyF12;
311                 case kVK_F13:                           return GHOST_kKeyF13;
312                 case kVK_F14:                           return GHOST_kKeyF14;
313                 case kVK_F15:                           return GHOST_kKeyF15;
314                 case kVK_F16:                           return GHOST_kKeyF16;
315                 case kVK_F17:                           return GHOST_kKeyF17;
316                 case kVK_F18:                           return GHOST_kKeyF18;
317                 case kVK_F19:                           return GHOST_kKeyF19;
318                 case kVK_F20:                           return GHOST_kKeyF20;
319                         
320                 case kVK_UpArrow:                       return GHOST_kKeyUpArrow;
321                 case kVK_DownArrow:                     return GHOST_kKeyDownArrow;
322                 case kVK_LeftArrow:                     return GHOST_kKeyLeftArrow;
323                 case kVK_RightArrow:            return GHOST_kKeyRightArrow;
324                         
325                 case kVK_Return:                        return GHOST_kKeyEnter;
326                 case kVK_Delete:                        return GHOST_kKeyBackSpace;
327                 case kVK_ForwardDelete:         return GHOST_kKeyDelete;
328                 case kVK_Escape:                        return GHOST_kKeyEsc;
329                 case kVK_Tab:                           return GHOST_kKeyTab;
330                 case kVK_Space:                         return GHOST_kKeySpace;
331                         
332                 case kVK_Home:                          return GHOST_kKeyHome;
333                 case kVK_End:                           return GHOST_kKeyEnd;
334                 case kVK_PageUp:                        return GHOST_kKeyUpPage;
335                 case kVK_PageDown:                      return GHOST_kKeyDownPage;
336                         
337                 /*case kVK_ANSI_Minus:          return GHOST_kKeyMinus;
338                 case kVK_ANSI_Equal:            return GHOST_kKeyEqual;
339                 case kVK_ANSI_Comma:            return GHOST_kKeyComma;
340                 case kVK_ANSI_Period:           return GHOST_kKeyPeriod;
341                 case kVK_ANSI_Slash:            return GHOST_kKeySlash;
342                 case kVK_ANSI_Semicolon:        return GHOST_kKeySemicolon;
343                 case kVK_ANSI_Quote:            return GHOST_kKeyQuote;
344                 case kVK_ANSI_Backslash:        return GHOST_kKeyBackslash;
345                 case kVK_ANSI_LeftBracket:      return GHOST_kKeyLeftBracket;
346                 case kVK_ANSI_RightBracket:     return GHOST_kKeyRightBracket;
347                 case kVK_ANSI_Grave:            return GHOST_kKeyAccentGrave;*/
348                         
349                 case kVK_VolumeUp:
350                 case kVK_VolumeDown:
351                 case kVK_Mute:
352                         return GHOST_kKeyUnknown;
353                         
354                 default:
355                         /* alphanumerical or punctuation key that is remappable in int'l keyboards */
356                         if ((recvChar >= 'A') && (recvChar <= 'Z')) {
357                                 return (GHOST_TKey) (recvChar - 'A' + GHOST_kKeyA);
358                         } else if ((recvChar >= 'a') && (recvChar <= 'z')) {
359                                 return (GHOST_TKey) (recvChar - 'a' + GHOST_kKeyA);
360                         } else {
361 #if MAC_OS_X_VERSION_MIN_REQUIRED <= MAC_OS_X_VERSION_10_4
362                                 KeyboardLayoutRef keyLayout;
363                                 UCKeyboardLayout *uchrData;
364                                 
365                                 KLGetCurrentKeyboardLayout(&keyLayout);
366                                 KLGetKeyboardLayoutProperty(keyLayout, kKLuchrData, (const void **)
367                                                                                         &uchrData);
368                                 /*get actual character value of the "remappable" keys in int'l keyboards,
369                                  if keyboard layout is not correctly reported (e.g. some non Apple keyboards in Tiger),
370                                  then fallback on using the received charactersIgnoringModifiers */
371                                 if (uchrData)
372                                 {
373                                         UInt32 deadKeyState=0;
374                                         UniCharCount actualStrLength=0;
375                                         
376                                         UCKeyTranslate(uchrData, rawCode, keyAction, 0,
377                                                                    LMGetKbdType(), kUCKeyTranslateNoDeadKeysBit, &deadKeyState, 1, &actualStrLength, &recvChar);
378                                         
379                                 }                               
380 #else
381                                 /* Leopard and Snow Leopard 64bit compatible API*/
382                                 CFDataRef uchrHandle; /*the keyboard layout*/
383                                 TISInputSourceRef kbdTISHandle;
384                                 
385                                 kbdTISHandle = TISCopyCurrentKeyboardLayoutInputSource();
386                                 uchrHandle = (CFDataRef)TISGetInputSourceProperty(kbdTISHandle,kTISPropertyUnicodeKeyLayoutData);
387                                 CFRelease(kbdTISHandle);
388                                 
389                                 /*get actual character value of the "remappable" keys in int'l keyboards,
390                                  if keyboard layout is not correctly reported (e.g. some non Apple keyboards in Tiger),
391                                  then fallback on using the received charactersIgnoringModifiers */
392                                 if (uchrHandle)
393                                 {
394                                         UInt32 deadKeyState=0;
395                                         UniCharCount actualStrLength=0;
396                                         
397                                         UCKeyTranslate((UCKeyboardLayout*)CFDataGetBytePtr(uchrHandle), rawCode, keyAction, 0,
398                                                                    LMGetKbdType(), kUCKeyTranslateNoDeadKeysBit, &deadKeyState, 1, &actualStrLength, &recvChar);
399                                         
400                                 }
401 #endif
402                                 switch (recvChar) {
403                                         case '-':       return GHOST_kKeyMinus;
404                                         case '=':       return GHOST_kKeyEqual;
405                                         case ',':       return GHOST_kKeyComma;
406                                         case '.':       return GHOST_kKeyPeriod;
407                                         case '/':       return GHOST_kKeySlash;
408                                         case ';':       return GHOST_kKeySemicolon;
409                                         case '\'':      return GHOST_kKeyQuote;
410                                         case '\\':      return GHOST_kKeyBackslash;
411                                         case '[':       return GHOST_kKeyLeftBracket;
412                                         case ']':       return GHOST_kKeyRightBracket;
413                                         case '`':       return GHOST_kKeyAccentGrave;
414                                         default:
415                                                 return GHOST_kKeyUnknown;
416                                 }
417                         }
418         }
419         return GHOST_kKeyUnknown;
420 }
421
422
423 #pragma mark defines for 10.6 api not documented in 10.5
424 #ifndef MAC_OS_X_VERSION_10_6
425 enum {
426         /* The following event types are available on some hardware on 10.5.2 and later */
427         NSEventTypeGesture          = 29,
428         NSEventTypeMagnify          = 30,
429         NSEventTypeSwipe            = 31,
430         NSEventTypeRotate           = 18,
431         NSEventTypeBeginGesture     = 19,
432         NSEventTypeEndGesture       = 20
433 };
434
435 @interface NSEvent(GestureEvents)
436 /* This message is valid for events of type NSEventTypeMagnify, on 10.5.2 or later */
437 #if MAC_OS_X_VERSION_MIN_REQUIRED <= MAC_OS_X_VERSION_10_4
438 - (float)magnification;       // change in magnification.
439 #else
440 - (CGFloat)magnification;       // change in magnification.
441 #endif
442 @end 
443
444 #endif
445
446
447 #pragma mark Utility functions
448
449 #define FIRSTFILEBUFLG 512
450 static bool g_hasFirstFile = false;
451 static char g_firstFileBuf[512];
452
453 //TODO:Need to investigate this. Function called too early in creator.c to have g_hasFirstFile == true
454 extern "C" int GHOST_HACK_getFirstFile(char buf[FIRSTFILEBUFLG]) { 
455         if (g_hasFirstFile) {
456                 strncpy(buf, g_firstFileBuf, FIRSTFILEBUFLG - 1);
457                 buf[FIRSTFILEBUFLG - 1] = '\0';
458                 return 1;
459         } else {
460                 return 0; 
461         }
462 }
463
464 #if defined(WITH_QUICKTIME) && !defined(USE_QTKIT)
465 //Need to place this quicktime function in an ObjC file
466 //It is used to avoid memory leak when raising the quicktime "compression settings" standard dialog
467 extern "C" {
468         struct bContext;
469         struct wmOperator;
470         extern int fromcocoa_request_qtcodec_settings(bContext *C, wmOperator *op);
471
472
473 int cocoa_request_qtcodec_settings(bContext *C, wmOperator *op)
474 {
475         int result;
476         NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
477         
478         result = fromcocoa_request_qtcodec_settings(C, op);
479         
480         [pool drain];
481         return result;
482 }
483 };
484 #endif
485
486
487 #pragma mark Cocoa objects
488
489 /**
490  * CocoaAppDelegate
491  * ObjC object to capture applicationShouldTerminate, and send quit event
492  **/
493 @interface CocoaAppDelegate : NSObject {
494         GHOST_SystemCocoa *systemCocoa;
495 }
496 - (void)setSystemCocoa:(GHOST_SystemCocoa *)sysCocoa;
497 - (BOOL)application:(NSApplication *)theApplication openFile:(NSString *)filename;
498 - (NSApplicationTerminateReply)applicationShouldTerminate:(NSApplication *)sender;
499 - (void)applicationWillTerminate:(NSNotification *)aNotification;
500 - (void)applicationWillBecomeActive:(NSNotification *)aNotification;
501 @end
502
503 @implementation CocoaAppDelegate : NSObject
504 -(void)setSystemCocoa:(GHOST_SystemCocoa *)sysCocoa
505 {
506         systemCocoa = sysCocoa;
507 }
508
509 - (BOOL)application:(NSApplication *)theApplication openFile:(NSString *)filename
510 {
511         return systemCocoa->handleOpenDocumentRequest(filename);
512 }
513
514 - (NSApplicationTerminateReply)applicationShouldTerminate:(NSApplication *)sender
515 {
516         //TODO: implement graceful termination through Cocoa mechanism to avoid session log off to be cancelled
517         //Note that Cmd+Q is already handled by keyhandler
518     if (systemCocoa->handleQuitRequest() == GHOST_kExitNow)
519                 return NSTerminateCancel;//NSTerminateNow;
520         else
521                 return NSTerminateCancel;
522 }
523
524 // To avoid cancelling a log off process, we must use Cocoa termination process
525 // And this function is the only chance to perform clean up
526 // So WM_exit needs to be called directly, as the event loop will never run before termination
527 - (void)applicationWillTerminate:(NSNotification *)aNotification
528 {
529         /*G.afbreek = 0; //Let Cocoa perform the termination at the end
530         WM_exit(C);*/
531 }
532
533 - (void)applicationWillBecomeActive:(NSNotification *)aNotification
534 {
535         systemCocoa->handleApplicationBecomeActiveEvent();
536 }
537 @end
538
539
540
541 #pragma mark initialization/finalization
542
543
544 GHOST_SystemCocoa::GHOST_SystemCocoa()
545 {
546         int mib[2];
547         struct timeval boottime;
548         size_t len;
549         char *rstring = NULL;
550         
551         m_modifierMask =0;
552         m_pressedMouseButtons =0;
553         m_isGestureInProgress = false;
554         m_cursorDelta_x=0;
555         m_cursorDelta_y=0;
556         m_outsideLoopEventProcessed = false;
557         m_needDelayedApplicationBecomeActiveEventProcessing = false;
558         m_displayManager = new GHOST_DisplayManagerCocoa ();
559         GHOST_ASSERT(m_displayManager, "GHOST_SystemCocoa::GHOST_SystemCocoa(): m_displayManager==0\n");
560         m_displayManager->initialize();
561
562         //NSEvent timeStamp is given in system uptime, state start date is boot time
563         mib[0] = CTL_KERN;
564         mib[1] = KERN_BOOTTIME;
565         len = sizeof(struct timeval);
566         
567         sysctl(mib, 2, &boottime, &len, NULL, 0);
568         m_start_time = ((boottime.tv_sec*1000)+(boottime.tv_usec/1000));
569         
570         //Detect multitouch trackpad
571         mib[0] = CTL_HW;
572         mib[1] = HW_MODEL;
573         sysctl( mib, 2, NULL, &len, NULL, 0 );
574         rstring = (char*)malloc( len );
575         sysctl( mib, 2, rstring, &len, NULL, 0 );
576         
577         //Hack on MacBook revision, as multitouch avail. function missing
578         if (strstr(rstring,"MacBookAir") ||
579                 (strstr(rstring,"MacBook") && (rstring[strlen(rstring)-3]>='5') && (rstring[strlen(rstring)-3]<='9')))
580                 m_hasMultiTouchTrackpad = true;
581         else m_hasMultiTouchTrackpad = false;
582         
583         free( rstring );
584         rstring = NULL;
585         
586         m_ignoreWindowSizedMessages = false;
587 }
588
589 GHOST_SystemCocoa::~GHOST_SystemCocoa()
590 {
591 }
592
593
594 GHOST_TSuccess GHOST_SystemCocoa::init()
595 {
596         
597     GHOST_TSuccess success = GHOST_System::init();
598     if (success) {
599                 //ProcessSerialNumber psn;
600                 
601                 //Carbon stuff to move window & menu to foreground
602                 /*if (!GetCurrentProcess(&psn)) {
603                         TransformProcessType(&psn, kProcessTransformToForegroundApplication);
604                         SetFrontProcess(&psn);
605                 }*/
606                 
607                 NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
608                 if (NSApp == nil) {
609                         [NSApplication sharedApplication];
610                         
611                         if ([NSApp mainMenu] == nil) {
612                                 NSMenu *mainMenubar = [[NSMenu alloc] init];
613                                 NSMenuItem *menuItem;
614                                 NSMenu *windowMenu;
615                                 NSMenu *appMenu;
616                                 
617                                 //Create the application menu
618                                 appMenu = [[NSMenu alloc] initWithTitle:@"Blender"];
619                                 
620                                 [appMenu addItemWithTitle:@"About Blender" action:@selector(orderFrontStandardAboutPanel:) keyEquivalent:@""];
621                                 [appMenu addItem:[NSMenuItem separatorItem]];
622                                 
623                                 menuItem = [appMenu addItemWithTitle:@"Hide Blender" action:@selector(hide:) keyEquivalent:@"h"];
624                                 [menuItem setKeyEquivalentModifierMask:NSCommandKeyMask];
625                                  
626                                 menuItem = [appMenu addItemWithTitle:@"Hide others" action:@selector(hideOtherApplications:) keyEquivalent:@"h"];
627                                 [menuItem setKeyEquivalentModifierMask:(NSAlternateKeyMask | NSCommandKeyMask)];
628                                 
629                                 [appMenu addItemWithTitle:@"Show All" action:@selector(unhideAllApplications:) keyEquivalent:@""];
630                                 
631                                 menuItem = [appMenu addItemWithTitle:@"Quit Blender" action:@selector(terminate:) keyEquivalent:@"q"];
632                                 [menuItem setKeyEquivalentModifierMask:NSCommandKeyMask];
633                                 
634                                 menuItem = [[NSMenuItem alloc] init];
635                                 [menuItem setSubmenu:appMenu];
636                                 
637                                 [mainMenubar addItem:menuItem];
638                                 [menuItem release];
639                                 [NSApp performSelector:@selector(setAppleMenu:) withObject:appMenu]; //Needed for 10.5
640                                 [appMenu release];
641                                 
642                                 //Create the window menu
643                                 windowMenu = [[NSMenu alloc] initWithTitle:@"Window"];
644                                 
645                                 menuItem = [windowMenu addItemWithTitle:@"Minimize" action:@selector(performMiniaturize:) keyEquivalent:@"m"];
646                                 [menuItem setKeyEquivalentModifierMask:NSCommandKeyMask];
647                                 
648                                 [windowMenu addItemWithTitle:@"Zoom" action:@selector(performZoom:) keyEquivalent:@""];
649                                 
650                                 menuItem = [windowMenu addItemWithTitle:@"Close" action:@selector(performClose:) keyEquivalent:@"w"];
651                                 [menuItem setKeyEquivalentModifierMask:NSCommandKeyMask];
652                                 
653                                 menuItem = [[NSMenuItem alloc] init];
654                                 [menuItem setSubmenu:windowMenu];
655                                 
656                                 [mainMenubar addItem:menuItem];
657                                 [menuItem release];
658                                 
659                                 [NSApp setMainMenu:mainMenubar];
660                                 [NSApp setWindowsMenu:windowMenu];
661                                 [windowMenu release];
662                         }
663                 }
664                 if ([NSApp delegate] == nil) {
665                         CocoaAppDelegate *appDelegate = [[CocoaAppDelegate alloc] init];
666                         [appDelegate setSystemCocoa:this];
667                         [NSApp setDelegate:appDelegate];
668                 }
669                 
670                 [NSApp finishLaunching];
671                 
672                 [pool drain];
673     }
674     return success;
675 }
676
677
678 #pragma mark window management
679
680 GHOST_TUns64 GHOST_SystemCocoa::getMilliSeconds() const
681 {
682         //Cocoa equivalent exists in 10.6 ([[NSProcessInfo processInfo] systemUptime])
683         struct timeval currentTime;
684         
685         gettimeofday(&currentTime, NULL);
686         
687         //Return timestamp of system uptime
688         
689         return ((currentTime.tv_sec*1000)+(currentTime.tv_usec/1000)-m_start_time);
690 }
691
692
693 GHOST_TUns8 GHOST_SystemCocoa::getNumDisplays() const
694 {
695         //Note that OS X supports monitor hot plug
696         // We do not support multiple monitors at the moment
697         NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
698
699         GHOST_TUns8 count = [[NSScreen screens] count];
700
701         [pool drain];
702         return count;
703 }
704
705
706 void GHOST_SystemCocoa::getMainDisplayDimensions(GHOST_TUns32& width, GHOST_TUns32& height) const
707 {
708         NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
709         //Get visible frame, that is frame excluding dock and top menu bar
710         NSRect frame = [[NSScreen mainScreen] visibleFrame];
711         
712         //Returns max window contents (excluding title bar...)
713         NSRect contentRect = [NSWindow contentRectForFrameRect:frame
714                                                                                                  styleMask:(NSTitledWindowMask | NSClosableWindowMask | NSMiniaturizableWindowMask)];
715         
716         width = contentRect.size.width;
717         height = contentRect.size.height;
718
719         [pool drain];
720 }
721
722
723 GHOST_IWindow* GHOST_SystemCocoa::createWindow(
724         const STR_String& title, 
725         GHOST_TInt32 left,
726         GHOST_TInt32 top,
727         GHOST_TUns32 width,
728         GHOST_TUns32 height,
729         GHOST_TWindowState state,
730         GHOST_TDrawingContextType type,
731         bool stereoVisual,
732         const GHOST_TUns16 numOfAASamples,
733         const GHOST_TEmbedderWindowID parentWindow
734 )
735 {
736     NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
737         GHOST_IWindow* window = 0;
738         
739         //Get the available rect for including window contents
740         NSRect frame = [[NSScreen mainScreen] visibleFrame];
741         NSRect contentRect = [NSWindow contentRectForFrameRect:frame
742                                                                                                  styleMask:(NSTitledWindowMask | NSClosableWindowMask | NSMiniaturizableWindowMask)];
743         
744         GHOST_TInt32 bottom = (contentRect.size.height - 1) - height - top;
745
746         //Ensures window top left is inside this available rect
747         left = left > contentRect.origin.x ? left : contentRect.origin.x;
748         bottom = bottom > contentRect.origin.y ? bottom : contentRect.origin.y;
749
750         window = new GHOST_WindowCocoa (this, title, left, bottom, width, height, state, type, stereoVisual, numOfAASamples);
751
752     if (window) {
753         if (window->getValid()) {
754             // Store the pointer to the window 
755             GHOST_ASSERT(m_windowManager, "m_windowManager not initialized");
756             m_windowManager->addWindow(window);
757             m_windowManager->setActiveWindow(window);
758                         //Need to tell window manager the new window is the active one (Cocoa does not send the event activate upon window creation)
759             pushEvent(new GHOST_Event(getMilliSeconds(), GHOST_kEventWindowActivate, window));
760                         pushEvent(new GHOST_Event(getMilliSeconds(), GHOST_kEventWindowSize, window));
761
762         }
763         else {
764                         GHOST_PRINT("GHOST_SystemCocoa::createWindow(): window invalid\n");
765             delete window;
766             window = 0;
767         }
768     }
769         else {
770                 GHOST_PRINT("GHOST_SystemCocoa::createWindow(): could not create window\n");
771         }
772         [pool drain];
773     return window;
774 }
775
776 GHOST_TSuccess GHOST_SystemCocoa::beginFullScreen(const GHOST_DisplaySetting& setting, GHOST_IWindow** window, const bool stereoVisual)
777 {       
778         GHOST_IWindow* currentWindow = m_windowManager->getActiveWindow();
779         *window = currentWindow;
780         
781         if(!currentWindow) return GHOST_kFailure;
782         
783         return currentWindow->setState(GHOST_kWindowStateFullScreen);
784 }
785
786 GHOST_TSuccess GHOST_SystemCocoa::endFullScreen(void)
787 {       
788         GHOST_IWindow* currentWindow = m_windowManager->getActiveWindow();
789         if(!currentWindow) return GHOST_kFailure;
790         
791         return currentWindow->setState(GHOST_kWindowStateNormal);
792 }
793
794
795         
796 /**
797  * @note : returns coordinates in Cocoa screen coordinates
798  */
799 GHOST_TSuccess GHOST_SystemCocoa::getCursorPosition(GHOST_TInt32& x, GHOST_TInt32& y) const
800 {
801     NSPoint mouseLoc = [NSEvent mouseLocation];
802         
803     // Returns the mouse location in screen coordinates
804     x = (GHOST_TInt32)mouseLoc.x;
805     y = (GHOST_TInt32)mouseLoc.y;
806     return GHOST_kSuccess;
807 }
808
809 void GHOST_SystemCocoa::pushEventCursor(GHOST_TUns64 msec, GHOST_TEventType type, GHOST_IWindow* window, GHOST_TInt32 x, GHOST_TInt32 y)
810 {
811         GHOST_Rect cBnds;
812         window->getClientBounds(cBnds);
813         y = (cBnds.getHeight() - 1) - y;
814
815         GHOST_TInt32 screen_x, screen_y;
816         window->clientToScreen(x, y, screen_x, screen_y);
817
818         pushEvent(new GHOST_EventCursor(msec, type, window, screen_x, screen_y));
819 }
820
821 void GHOST_SystemCocoa::pushEventTrackpad(GHOST_TUns64 msec, GHOST_IWindow* window, GHOST_TTrackpadEventSubTypes subtype, GHOST_TInt32 x, GHOST_TInt32 y, GHOST_TInt32 deltaX, GHOST_TInt32 deltaY)
822 {
823         GHOST_Rect cBnds;
824         window->getClientBounds(cBnds);
825         y = (cBnds.getHeight() - 1) - y;
826         deltaY = -deltaY;
827
828         GHOST_TInt32 screen_x, screen_y;
829         window->clientToScreen(x, y, screen_x, screen_y);
830
831         pushEvent(new GHOST_EventTrackpad(msec, window, subtype, screen_x, screen_y, deltaX, deltaY));
832 }
833
834 /**
835  * @note : expect Cocoa screen coordinates
836  */
837 GHOST_TSuccess GHOST_SystemCocoa::setCursorPosition(GHOST_TInt32 x, GHOST_TInt32 y)
838 {
839         GHOST_TInt32 wx,wy;
840         GHOST_WindowCocoa* window = (GHOST_WindowCocoa*)m_windowManager->getActiveWindow();
841         if (!window) return GHOST_kFailure;
842
843         //Cursor and mouse dissociation placed here not to interfere with continuous grab
844         // (in cont. grab setMouseCursorPosition is directly called)
845         CGAssociateMouseAndMouseCursorPosition(false);
846         setMouseCursorPosition(x, y);
847         CGAssociateMouseAndMouseCursorPosition(true);
848         
849         //Force mouse move event (not pushed by Cocoa)
850         window->screenToClient(x, y, wx, wy);
851         pushEventCursor(getMilliSeconds(), GHOST_kEventCursorMove, window, wx,wy);
852         m_outsideLoopEventProcessed = true;
853         
854         return GHOST_kSuccess;
855 }
856
857 GHOST_TSuccess GHOST_SystemCocoa::setMouseCursorPosition(GHOST_TInt32 x, GHOST_TInt32 y)
858 {
859         float xf=(float)x, yf=(float)y;
860         GHOST_WindowCocoa* window = (GHOST_WindowCocoa*)m_windowManager->getActiveWindow();
861         if (!window) return GHOST_kFailure;
862
863         NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
864         NSScreen *windowScreen = window->getScreen();
865         NSRect screenRect = [windowScreen frame];
866         
867         //Set position relative to current screen
868         xf -= screenRect.origin.x;
869         yf -= screenRect.origin.y;
870         
871         //Quartz Display Services uses the old coordinates (top left origin)
872         yf = screenRect.size.height -yf;
873
874         CGDisplayMoveCursorToPoint((CGDirectDisplayID)[[[windowScreen deviceDescription] objectForKey:@"NSScreenNumber"] unsignedIntValue], CGPointMake(xf, yf));
875
876         [pool drain];
877     return GHOST_kSuccess;
878 }
879
880
881 GHOST_TSuccess GHOST_SystemCocoa::getModifierKeys(GHOST_ModifierKeys& keys) const
882 {
883         keys.set(GHOST_kModifierKeyOS, (m_modifierMask & NSCommandKeyMask) ? true : false);
884         keys.set(GHOST_kModifierKeyLeftAlt, (m_modifierMask & NSAlternateKeyMask) ? true : false);
885         keys.set(GHOST_kModifierKeyLeftShift, (m_modifierMask & NSShiftKeyMask) ? true : false);
886         keys.set(GHOST_kModifierKeyLeftControl, (m_modifierMask & NSControlKeyMask) ? true : false);
887         
888     return GHOST_kSuccess;
889 }
890
891 GHOST_TSuccess GHOST_SystemCocoa::getButtons(GHOST_Buttons& buttons) const
892 {
893         buttons.clear();
894     buttons.set(GHOST_kButtonMaskLeft, m_pressedMouseButtons & GHOST_kButtonMaskLeft);
895         buttons.set(GHOST_kButtonMaskRight, m_pressedMouseButtons & GHOST_kButtonMaskRight);
896         buttons.set(GHOST_kButtonMaskMiddle, m_pressedMouseButtons & GHOST_kButtonMaskMiddle);
897         buttons.set(GHOST_kButtonMaskButton4, m_pressedMouseButtons & GHOST_kButtonMaskButton4);
898         buttons.set(GHOST_kButtonMaskButton5, m_pressedMouseButtons & GHOST_kButtonMaskButton5);
899     return GHOST_kSuccess;
900 }
901
902
903
904 #pragma mark Event handlers
905
906 /**
907  * The event queue polling function
908  */
909 bool GHOST_SystemCocoa::processEvents(bool waitForEvent)
910 {
911         bool anyProcessed = false;
912         NSEvent *event;
913         
914         //      SetMouseCoalescingEnabled(false, NULL);
915         //TODO : implement timer ??
916         
917         /*do {
918                 GHOST_TimerManager* timerMgr = getTimerManager();
919                 
920                  if (waitForEvent) {
921                  GHOST_TUns64 next = timerMgr->nextFireTime();
922                  double timeOut;
923                  
924                  if (next == GHOST_kFireTimeNever) {
925                  timeOut = kEventDurationForever;
926                  } else {
927                  timeOut = (double)(next - getMilliSeconds())/1000.0;
928                  if (timeOut < 0.0)
929                  timeOut = 0.0;
930                  }
931                  
932                  ::ReceiveNextEvent(0, NULL, timeOut, false, &event);
933                  }
934                  
935                  if (timerMgr->fireTimers(getMilliSeconds())) {
936                  anyProcessed = true;
937                  }*/
938                 
939                 do {
940                         NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
941                         event = [NSApp nextEventMatchingMask:NSAnyEventMask
942                                                                            untilDate:[NSDate distantPast]
943                                                                                   inMode:NSDefaultRunLoopMode
944                                                                                  dequeue:YES];
945                         if (event==nil) {
946                                 [pool drain];
947                                 break;
948                         }
949                         
950                         anyProcessed = true;
951                         
952                         switch ([event type]) {
953                                 case NSKeyDown:
954                                 case NSKeyUp:
955                                 case NSFlagsChanged:
956                                         handleKeyEvent(event);
957                                         
958                                         /* Support system-wide keyboard shortcuts, like Expos√©, ...) =>included in always NSApp sendEvent */
959                                         /*              if (([event modifierFlags] & NSCommandKeyMask) || [event type] == NSFlagsChanged) {
960                                          [NSApp sendEvent:event];
961                                          }*/
962                                         break;
963                                         
964                                 case NSLeftMouseDown:
965                                 case NSLeftMouseUp:
966                                 case NSRightMouseDown:
967                                 case NSRightMouseUp:
968                                 case NSMouseMoved:
969                                 case NSLeftMouseDragged:
970                                 case NSRightMouseDragged:
971                                 case NSScrollWheel:
972                                 case NSOtherMouseDown:
973                                 case NSOtherMouseUp:
974                                 case NSOtherMouseDragged:
975                                 case NSEventTypeMagnify:
976                                 case NSEventTypeRotate:
977                                 case NSEventTypeBeginGesture:
978                                 case NSEventTypeEndGesture:
979                                         handleMouseEvent(event);
980                                         break;
981                                         
982                                 case NSTabletPoint:
983                                 case NSTabletProximity:
984                                         handleTabletEvent(event,[event type]);
985                                         break;
986                                         
987                                         /* Trackpad features, fired only from OS X 10.5.2
988                                          case NSEventTypeGesture:
989                                          case NSEventTypeSwipe:
990                                          break; */
991                                         
992                                         /*Unused events
993                                          NSMouseEntered       = 8,
994                                          NSMouseExited        = 9,
995                                          NSAppKitDefined      = 13,
996                                          NSSystemDefined      = 14,
997                                          NSApplicationDefined = 15,
998                                          NSPeriodic           = 16,
999                                          NSCursorUpdate       = 17,*/
1000                                         
1001                                 default:
1002                                         break;
1003                         }
1004                         //Resend event to NSApp to ensure Mac wide events are handled
1005                         [NSApp sendEvent:event];
1006                         [pool drain];
1007                 } while (event!= nil);          
1008         //} while (waitForEvent && !anyProcessed); Needed only for timer implementation
1009         
1010         if (m_needDelayedApplicationBecomeActiveEventProcessing) handleApplicationBecomeActiveEvent();
1011         
1012         if (m_outsideLoopEventProcessed) {
1013                 m_outsideLoopEventProcessed = false;
1014                 return true;
1015         }
1016         
1017         m_ignoreWindowSizedMessages = false;
1018         
1019     return anyProcessed;
1020 }
1021
1022 //Note: called from NSApplication delegate
1023 GHOST_TSuccess GHOST_SystemCocoa::handleApplicationBecomeActiveEvent()
1024 {
1025         //Update the modifiers key mask, as its status may have changed when the application was not active
1026         //(that is when update events are sent to another application)
1027         unsigned int modifiers;
1028         GHOST_IWindow* window = m_windowManager->getActiveWindow();
1029         
1030         if (!window) {
1031                 m_needDelayedApplicationBecomeActiveEventProcessing = true;
1032                 return GHOST_kFailure;
1033         }
1034         else m_needDelayedApplicationBecomeActiveEventProcessing = false;
1035
1036         modifiers = [[[NSApplication sharedApplication] currentEvent] modifierFlags];
1037         
1038         if ((modifiers & NSShiftKeyMask) != (m_modifierMask & NSShiftKeyMask)) {
1039                 pushEvent( new GHOST_EventKey(getMilliSeconds(), (modifiers & NSShiftKeyMask)?GHOST_kEventKeyDown:GHOST_kEventKeyUp, window, GHOST_kKeyLeftShift) );
1040         }
1041         if ((modifiers & NSControlKeyMask) != (m_modifierMask & NSControlKeyMask)) {
1042                 pushEvent( new GHOST_EventKey(getMilliSeconds(), (modifiers & NSControlKeyMask)?GHOST_kEventKeyDown:GHOST_kEventKeyUp, window, GHOST_kKeyLeftControl) );
1043         }
1044         if ((modifiers & NSAlternateKeyMask) != (m_modifierMask & NSAlternateKeyMask)) {
1045                 pushEvent( new GHOST_EventKey(getMilliSeconds(), (modifiers & NSAlternateKeyMask)?GHOST_kEventKeyDown:GHOST_kEventKeyUp, window, GHOST_kKeyLeftAlt) );
1046         }
1047         if ((modifiers & NSCommandKeyMask) != (m_modifierMask & NSCommandKeyMask)) {
1048                 pushEvent( new GHOST_EventKey(getMilliSeconds(), (modifiers & NSCommandKeyMask)?GHOST_kEventKeyDown:GHOST_kEventKeyUp, window, GHOST_kKeyOS) );
1049         }
1050         
1051         m_modifierMask = modifiers;
1052         
1053         m_outsideLoopEventProcessed = true;
1054         return GHOST_kSuccess;
1055 }
1056
1057 //Note: called from NSWindow delegate
1058 GHOST_TSuccess GHOST_SystemCocoa::handleWindowEvent(GHOST_TEventType eventType, GHOST_WindowCocoa* window)
1059 {
1060         if (!validWindow(window)) {
1061                 return GHOST_kFailure;
1062         }
1063                 switch(eventType) 
1064                 {
1065                         case GHOST_kEventWindowClose:
1066                                 pushEvent( new GHOST_Event(getMilliSeconds(), GHOST_kEventWindowClose, window) );
1067                                 break;
1068                         case GHOST_kEventWindowActivate:
1069                                 m_windowManager->setActiveWindow(window);
1070                                 window->loadCursor(window->getCursorVisibility(), window->getCursorShape());
1071                                 pushEvent( new GHOST_Event(getMilliSeconds(), GHOST_kEventWindowActivate, window) );
1072                                 break;
1073                         case GHOST_kEventWindowDeactivate:
1074                                 m_windowManager->setWindowInactive(window);
1075                                 pushEvent( new GHOST_Event(getMilliSeconds(), GHOST_kEventWindowDeactivate, window) );
1076                                 break;
1077                         case GHOST_kEventWindowUpdate:
1078                                 pushEvent( new GHOST_Event(getMilliSeconds(), GHOST_kEventWindowUpdate, window) );
1079                                 break;
1080                         case GHOST_kEventWindowMove:
1081                                 pushEvent( new GHOST_Event(getMilliSeconds(), GHOST_kEventWindowMove, window) );
1082                                 break;
1083                         case GHOST_kEventWindowSize:
1084                                 if (!m_ignoreWindowSizedMessages)
1085                                 {
1086                                         //Enforce only one resize message per event loop (coalescing all the live resize messages)                                      
1087                                         window->updateDrawingContext();
1088                                         pushEvent( new GHOST_Event(getMilliSeconds(), GHOST_kEventWindowSize, window) );
1089                                         //Mouse up event is trapped by the resizing event loop, so send it anyway to the window manager
1090                                         pushEvent(new GHOST_EventButton(getMilliSeconds(), GHOST_kEventButtonUp, window, convertButton(0)));
1091                                         m_ignoreWindowSizedMessages = true;
1092                                 }
1093                                 break;
1094                         default:
1095                                 return GHOST_kFailure;
1096                                 break;
1097                 }
1098         
1099         m_outsideLoopEventProcessed = true;
1100         return GHOST_kSuccess;
1101 }
1102
1103 //Note: called from NSWindow subclass
1104 GHOST_TSuccess GHOST_SystemCocoa::handleDraggingEvent(GHOST_TEventType eventType, GHOST_TDragnDropTypes draggedObjectType,
1105                                                                    GHOST_WindowCocoa* window, int mouseX, int mouseY, void* data)
1106 {
1107         if (!validWindow(window)) {
1108                 return GHOST_kFailure;
1109         }
1110         switch(eventType) 
1111         {
1112                 case GHOST_kEventDraggingEntered:
1113                 case GHOST_kEventDraggingUpdated:
1114                 case GHOST_kEventDraggingExited:
1115                         pushEvent(new GHOST_EventDragnDrop(getMilliSeconds(),eventType,draggedObjectType,window,mouseX,mouseY,NULL));
1116                         break;
1117                         
1118                 case GHOST_kEventDraggingDropDone:
1119                 {
1120                         GHOST_TUns8 * temp_buff;
1121                         GHOST_TStringArray *strArray;
1122                         NSArray *droppedArray;
1123                         size_t pastedTextSize;  
1124                         NSString *droppedStr;
1125                         GHOST_TEventDataPtr eventData;
1126                         int i;
1127
1128                         if (!data) return GHOST_kFailure;
1129                         
1130                         switch (draggedObjectType) {
1131                                 case GHOST_kDragnDropTypeFilenames:
1132                                         droppedArray = (NSArray*)data;
1133                                         
1134                                         strArray = (GHOST_TStringArray*)malloc(sizeof(GHOST_TStringArray));
1135                                         if (!strArray) return GHOST_kFailure;
1136                                         
1137                                         strArray->count = [droppedArray count];
1138                                         if (strArray->count == 0) return GHOST_kFailure;
1139                                         
1140                                         strArray->strings = (GHOST_TUns8**) malloc(strArray->count*sizeof(GHOST_TUns8*));
1141                                         
1142                                         for (i=0;i<strArray->count;i++)
1143                                         {
1144                                                 droppedStr = [droppedArray objectAtIndex:i];
1145                                                 
1146                                                 pastedTextSize = [droppedStr lengthOfBytesUsingEncoding:NSUTF8StringEncoding];
1147                                                 temp_buff = (GHOST_TUns8*) malloc(pastedTextSize+1); 
1148                                         
1149                                                 if (!temp_buff) {
1150                                                         strArray->count = i;
1151                                                         break;
1152                                                 }
1153                                         
1154                                                 strncpy((char*)temp_buff, [droppedStr cStringUsingEncoding:NSUTF8StringEncoding], pastedTextSize);
1155                                                 temp_buff[pastedTextSize] = '\0';
1156                                                 
1157                                                 strArray->strings[i] = temp_buff;
1158                                         }
1159
1160                                         eventData = (GHOST_TEventDataPtr) strArray;     
1161                                         break;
1162                                         
1163                                 case GHOST_kDragnDropTypeString:
1164                                         droppedStr = (NSString*)data;
1165                                         pastedTextSize = [droppedStr lengthOfBytesUsingEncoding:NSUTF8StringEncoding];
1166                                         
1167                                         temp_buff = (GHOST_TUns8*) malloc(pastedTextSize+1); 
1168                                         
1169                                         if (temp_buff == NULL) {
1170                                                 return GHOST_kFailure;
1171                                         }
1172                                         
1173                                         strncpy((char*)temp_buff, [droppedStr cStringUsingEncoding:NSUTF8StringEncoding], pastedTextSize);
1174                                         
1175                                         temp_buff[pastedTextSize] = '\0';
1176                                         
1177                                         eventData = (GHOST_TEventDataPtr) temp_buff;
1178                                         break;
1179                                 
1180                                 case GHOST_kDragnDropTypeBitmap:
1181                                 {
1182                                         NSImage *droppedImg = (NSImage*)data;
1183                                         NSSize imgSize = [droppedImg size];
1184                                         ImBuf *ibuf = NULL;
1185                                         GHOST_TUns8 *rasterRGB = NULL;
1186                                         GHOST_TUns8 *rasterRGBA = NULL;
1187                                         GHOST_TUns8 *toIBuf = NULL;
1188                                         int x, y, to_i, from_i;
1189                                         NSBitmapImageRep *blBitmapFormatImageRGB,*blBitmapFormatImageRGBA,*bitmapImage=nil;
1190                                         NSEnumerator *enumerator;
1191                                         NSImageRep *representation;
1192                                         
1193                                         ibuf = IMB_allocImBuf (imgSize.width , imgSize.height, 32, IB_rect);
1194                                         if (!ibuf) {
1195                                                 [droppedImg release];
1196                                                 return GHOST_kFailure;
1197                                         }
1198                                         
1199                                         /*Get the bitmap of the image*/
1200                                         enumerator = [[droppedImg representations] objectEnumerator];
1201                                         while ((representation = [enumerator nextObject])) {
1202                                                 if ([representation isKindOfClass:[NSBitmapImageRep class]]) {
1203                                                         bitmapImage = (NSBitmapImageRep *)representation;
1204                                                         break;
1205                                                 }
1206                                         }
1207                                         if (bitmapImage == nil) return GHOST_kFailure;
1208                                         
1209                                         if (([bitmapImage bitsPerPixel] == 32) && (([bitmapImage bitmapFormat] & 0x5) == 0)
1210                                                 && ![bitmapImage isPlanar]) {
1211                                                 /* Try a fast copy if the image is a meshed RGBA 32bit bitmap*/
1212                                                 toIBuf = (GHOST_TUns8*)ibuf->rect;
1213                                                 rasterRGB = (GHOST_TUns8*)[bitmapImage bitmapData];
1214                                                 for (y = 0; y < imgSize.height; y++) {
1215                                                         to_i = (imgSize.height-y-1)*imgSize.width;
1216                                                         from_i = y*imgSize.width;
1217                                                         memcpy(toIBuf+4*to_i, rasterRGB+4*from_i, 4*imgSize.width);
1218                                                 }
1219                                         }
1220                                         else {
1221                                                 /* Tell cocoa image resolution is same as current system one */
1222                                                 [bitmapImage setSize:imgSize];
1223                                                 
1224                                                 /* Convert the image in a RGBA 32bit format */
1225                                                 /* As Core Graphics does not support contextes with non premutliplied alpha,
1226                                                  we need to get alpha key values in a separate batch */
1227                                                 
1228                                                 /* First get RGB values w/o Alpha to avoid pre-multiplication, 32bit but last byte is unused */
1229                                                 blBitmapFormatImageRGB = [[NSBitmapImageRep alloc] initWithBitmapDataPlanes:NULL
1230                                                                                                                                                                                  pixelsWide:imgSize.width 
1231                                                                                                                                                                                  pixelsHigh:imgSize.height
1232                                                                                                                                                                           bitsPerSample:8 samplesPerPixel:3 hasAlpha:NO isPlanar:NO
1233                                                                                                                                                                          colorSpaceName:NSDeviceRGBColorSpace 
1234                                                                                                                                                                            bitmapFormat:(NSBitmapFormat)0
1235                                                                                                                                                                                 bytesPerRow:4*imgSize.width
1236                                                                                                                                                                            bitsPerPixel:32/*RGB format padded to 32bits*/];
1237                                                 
1238                                                 [NSGraphicsContext saveGraphicsState];
1239                                                 [NSGraphicsContext setCurrentContext:[NSGraphicsContext graphicsContextWithBitmapImageRep:blBitmapFormatImageRGB]];
1240                                                 [bitmapImage draw];
1241                                                 [NSGraphicsContext restoreGraphicsState];
1242                                                 
1243                                                 rasterRGB = (GHOST_TUns8*)[blBitmapFormatImageRGB bitmapData];
1244                                                 if (rasterRGB == NULL) {
1245                                                         [bitmapImage release];
1246                                                         [blBitmapFormatImageRGB release];
1247                                                         [droppedImg release];
1248                                                         return GHOST_kFailure;
1249                                                 }
1250                                                 
1251                                                 /* Then get Alpha values by getting the RGBA image (that is premultiplied btw) */
1252                                                 blBitmapFormatImageRGBA = [[NSBitmapImageRep alloc] initWithBitmapDataPlanes:NULL
1253                                                                                                                                                                                   pixelsWide:imgSize.width
1254                                                                                                                                                                                   pixelsHigh:imgSize.height
1255                                                                                                                                                                            bitsPerSample:8 samplesPerPixel:4 hasAlpha:YES isPlanar:NO
1256                                                                                                                                                                           colorSpaceName:NSDeviceRGBColorSpace
1257                                                                                                                                                                                 bitmapFormat:(NSBitmapFormat)0
1258                                                                                                                                                                                  bytesPerRow:4*imgSize.width
1259                                                                                                                                                                                 bitsPerPixel:32/* RGBA */];
1260                                                 
1261                                                 [NSGraphicsContext saveGraphicsState];
1262                                                 [NSGraphicsContext setCurrentContext:[NSGraphicsContext graphicsContextWithBitmapImageRep:blBitmapFormatImageRGBA]];
1263                                                 [bitmapImage draw];
1264                                                 [NSGraphicsContext restoreGraphicsState];
1265                                                 
1266                                                 rasterRGBA = (GHOST_TUns8*)[blBitmapFormatImageRGBA bitmapData];
1267                                                 if (rasterRGBA == NULL) {
1268                                                         [bitmapImage release];
1269                                                         [blBitmapFormatImageRGB release];
1270                                                         [blBitmapFormatImageRGBA release];
1271                                                         [droppedImg release];
1272                                                         return GHOST_kFailure;
1273                                                 }
1274                                                 
1275                                                 /*Copy the image to ibuf, flipping it vertically*/
1276                                                 toIBuf = (GHOST_TUns8*)ibuf->rect;
1277                                                 for (y = 0; y < imgSize.height; y++) {
1278                                                         for (x = 0; x < imgSize.width; x++) {
1279                                                                 to_i = (imgSize.height-y-1)*imgSize.width + x;
1280                                                                 from_i = y*imgSize.width + x;
1281                                                                 
1282                                                                 toIBuf[4*to_i] = rasterRGB[4*from_i]; /* R */
1283                                                                 toIBuf[4*to_i+1] = rasterRGB[4*from_i+1]; /* G */
1284                                                                 toIBuf[4*to_i+2] = rasterRGB[4*from_i+2]; /* B */
1285                                                                 toIBuf[4*to_i+3] = rasterRGBA[4*from_i+3]; /* A */
1286                                                         }
1287                                                 }
1288                                                 
1289                                                 [blBitmapFormatImageRGB release];
1290                                                 [blBitmapFormatImageRGBA release];
1291                                                 [droppedImg release];
1292                                         }
1293                                         
1294                                         eventData = (GHOST_TEventDataPtr) ibuf;
1295                                 }
1296                                         break;
1297                                         
1298                                 default:
1299                                         return GHOST_kFailure;
1300                                         break;
1301                         }
1302                         pushEvent(new GHOST_EventDragnDrop(getMilliSeconds(),eventType,draggedObjectType,window,mouseX,mouseY,eventData));
1303                 }
1304                         break;
1305                 default:
1306                         return GHOST_kFailure;
1307         }
1308         m_outsideLoopEventProcessed = true;
1309         return GHOST_kSuccess;
1310 }
1311
1312
1313 GHOST_TUns8 GHOST_SystemCocoa::handleQuitRequest()
1314 {
1315         GHOST_Window* window = (GHOST_Window*)m_windowManager->getActiveWindow();
1316         
1317         //Discard quit event if we are in cursor grab sequence
1318         if (window && (window->getCursorGrabMode() != GHOST_kGrabDisable) && (window->getCursorGrabMode() != GHOST_kGrabNormal))
1319                 return GHOST_kExitCancel;
1320         
1321         //Check open windows if some changes are not saved
1322         if (m_windowManager->getAnyModifiedState())
1323         {
1324                 int shouldQuit = NSRunAlertPanel(@"Exit Blender", @"Some changes have not been saved.\nDo you really want to quit ?",
1325                                                                                  @"Cancel", @"Quit Anyway", nil);
1326                 if (shouldQuit == NSAlertAlternateReturn)
1327                 {
1328                         pushEvent( new GHOST_Event(getMilliSeconds(), GHOST_kEventQuit, NULL) );
1329                         return GHOST_kExitNow;
1330                 } else {
1331                         //Give back focus to the blender window if user selected cancel quit
1332                         NSArray *windowsList = [NSApp orderedWindows];
1333                         if ([windowsList count]) {
1334                                 [[windowsList objectAtIndex:0] makeKeyAndOrderFront:nil];
1335                                 //Handle the modifiers keyes changed state issue
1336                                 //as recovering from the quit dialog is like application
1337                                 //gaining focus back.
1338                                 //Main issue fixed is Cmd modifier not being cleared
1339                                 handleApplicationBecomeActiveEvent();
1340                         }
1341                 }
1342
1343         }
1344         else {
1345                 pushEvent( new GHOST_Event(getMilliSeconds(), GHOST_kEventQuit, NULL) );
1346                 m_outsideLoopEventProcessed = true;
1347                 return GHOST_kExitNow;
1348         }
1349         
1350         return GHOST_kExitCancel;
1351 }
1352
1353 bool GHOST_SystemCocoa::handleOpenDocumentRequest(void *filepathStr)
1354 {
1355         NSString *filepath = (NSString*)filepathStr;
1356         int confirmOpen = NSAlertAlternateReturn;
1357         NSArray *windowsList;
1358         char * temp_buff;
1359         size_t filenameTextSize;        
1360         GHOST_Window* window= (GHOST_Window*)m_windowManager->getActiveWindow();
1361         
1362         if (!window) {
1363                 return NO;
1364         }       
1365         
1366         //Discard event if we are in cursor grab sequence, it'll lead to "stuck cursor" situation if the alert panel is raised
1367         if (window && (window->getCursorGrabMode() != GHOST_kGrabDisable) && (window->getCursorGrabMode() != GHOST_kGrabNormal))
1368                 return GHOST_kExitCancel;
1369
1370         //Check open windows if some changes are not saved
1371         if (m_windowManager->getAnyModifiedState())
1372         {
1373                 confirmOpen = NSRunAlertPanel([NSString stringWithFormat:@"Opening %@",[filepath lastPathComponent]],
1374                                                                                  @"Current document has not been saved.\nDo you really want to proceed?",
1375                                                                                  @"Cancel", @"Open", nil);
1376         }
1377
1378         //Give back focus to the blender window
1379         windowsList = [NSApp orderedWindows];
1380         if ([windowsList count]) {
1381                 [[windowsList objectAtIndex:0] makeKeyAndOrderFront:nil];
1382         }
1383
1384         if (confirmOpen == NSAlertAlternateReturn)
1385         {
1386                 filenameTextSize = [filepath lengthOfBytesUsingEncoding:NSUTF8StringEncoding];
1387                 
1388                 temp_buff = (char*) malloc(filenameTextSize+1); 
1389                 
1390                 if (temp_buff == NULL) {
1391                         return GHOST_kFailure;
1392                 }
1393                 
1394                 strncpy(temp_buff, [filepath cStringUsingEncoding:NSUTF8StringEncoding], filenameTextSize);
1395                 
1396                 temp_buff[filenameTextSize] = '\0';
1397
1398                 pushEvent(new GHOST_EventString(getMilliSeconds(),GHOST_kEventOpenMainFile,window,(GHOST_TEventDataPtr) temp_buff));
1399
1400                 return YES;
1401         }
1402         else return NO;
1403 }
1404
1405 GHOST_TSuccess GHOST_SystemCocoa::handleTabletEvent(void *eventPtr, short eventType)
1406 {
1407         NSEvent *event = (NSEvent *)eventPtr;
1408         GHOST_IWindow* window;
1409         
1410         window = m_windowManager->getWindowAssociatedWithOSWindow((void*)[event window]);
1411         if (!window) {
1412                 //printf("\nW failure for event 0x%x",[event type]);
1413                 return GHOST_kFailure;
1414         }
1415         
1416         GHOST_TabletData& ct=((GHOST_WindowCocoa*)window)->GetCocoaTabletData();
1417         
1418         switch (eventType) {
1419                 case NSTabletPoint:
1420                         ct.Pressure = [event pressure];
1421                         ct.Xtilt = [event tilt].x;
1422                         ct.Ytilt = [event tilt].y;
1423                         break;
1424                 
1425                 case NSTabletProximity:
1426                         ct.Pressure = 0;
1427                         ct.Xtilt = 0;
1428                         ct.Ytilt = 0;
1429                         if ([event isEnteringProximity])
1430                         {
1431                                 //pointer is entering tablet area proximity
1432                                 switch ([event pointingDeviceType]) {
1433                                         case NSPenPointingDevice:
1434                                                 ct.Active = GHOST_kTabletModeStylus;
1435                                                 break;
1436                                         case NSEraserPointingDevice:
1437                                                 ct.Active = GHOST_kTabletModeEraser;
1438                                                 break;
1439                                         case NSCursorPointingDevice:
1440                                         case NSUnknownPointingDevice:
1441                                         default:
1442                                                 ct.Active = GHOST_kTabletModeNone;
1443                                                 break;
1444                                 }
1445                         } else {
1446                                 // pointer is leaving - return to mouse
1447                                 ct.Active = GHOST_kTabletModeNone;
1448                         }
1449                         break;
1450                 
1451                 default:
1452                         GHOST_ASSERT(FALSE,"GHOST_SystemCocoa::handleTabletEvent : unknown event received");
1453                         return GHOST_kFailure;
1454                         break;
1455         }
1456         return GHOST_kSuccess;
1457 }
1458
1459
1460 GHOST_TSuccess GHOST_SystemCocoa::handleMouseEvent(void *eventPtr)
1461 {
1462         NSEvent *event = (NSEvent *)eventPtr;
1463     GHOST_Window* window;
1464         
1465         window = (GHOST_Window*)m_windowManager->getWindowAssociatedWithOSWindow((void*)[event window]);
1466         if (!window) {
1467                 //printf("\nW failure for event 0x%x",[event type]);
1468                 return GHOST_kFailure;
1469         }
1470         
1471         switch ([event type])
1472     {
1473                 case NSLeftMouseDown:
1474                 case NSRightMouseDown:
1475                 case NSOtherMouseDown:
1476                         pushEvent(new GHOST_EventButton([event timestamp]*1000, GHOST_kEventButtonDown, window, convertButton([event buttonNumber])));
1477                         //Handle tablet events combined with mouse events
1478                         switch ([event subtype]) {
1479                                 case NX_SUBTYPE_TABLET_POINT:
1480                                         handleTabletEvent(eventPtr, NSTabletPoint);
1481                                         break;
1482                                 case NX_SUBTYPE_TABLET_PROXIMITY:
1483                                         handleTabletEvent(eventPtr, NSTabletProximity);
1484                                         break;
1485                                 default:
1486                                         //No tablet event included : do nothing
1487                                         break;
1488                         }
1489                         break;
1490                                                 
1491                 case NSLeftMouseUp:
1492                 case NSRightMouseUp:
1493                 case NSOtherMouseUp:
1494                         pushEvent(new GHOST_EventButton([event timestamp]*1000, GHOST_kEventButtonUp, window, convertButton([event buttonNumber])));
1495                         //Handle tablet events combined with mouse events
1496                         switch ([event subtype]) {
1497                                 case NX_SUBTYPE_TABLET_POINT:
1498                                         handleTabletEvent(eventPtr, NSTabletPoint);
1499                                         break;
1500                                 case NX_SUBTYPE_TABLET_PROXIMITY:
1501                                         handleTabletEvent(eventPtr, NSTabletProximity);
1502                                         break;
1503                                 default:
1504                                         //No tablet event included : do nothing
1505                                         break;
1506                         }
1507                         break;
1508                         
1509                 case NSLeftMouseDragged:
1510                 case NSRightMouseDragged:
1511                 case NSOtherMouseDragged:                               
1512                         //Handle tablet events combined with mouse events
1513                         switch ([event subtype]) {
1514                                 case NX_SUBTYPE_TABLET_POINT:
1515                                         handleTabletEvent(eventPtr, NSTabletPoint);
1516                                         break;
1517                                 case NX_SUBTYPE_TABLET_PROXIMITY:
1518                                         handleTabletEvent(eventPtr, NSTabletProximity);
1519                                         break;
1520                                 default:
1521                                         //No tablet event included : do nothing
1522                                         break;
1523                         }
1524                         
1525                 case NSMouseMoved:
1526                                 switch (window->getCursorGrabMode()) {
1527                                         case GHOST_kGrabHide: //Cursor hidden grab operation : no cursor move
1528                                         {
1529                                                 GHOST_TInt32 x_warp, y_warp, x_accum, y_accum;
1530                                                 
1531                                                 window->getCursorGrabInitPos(x_warp, y_warp);
1532                                                 
1533                                                 window->getCursorGrabAccum(x_accum, y_accum);
1534                                                 x_accum += [event deltaX];
1535                                                 y_accum += -[event deltaY]; //Strange Apple implementation (inverted coordinates for the deltaY) ...
1536                                                 window->setCursorGrabAccum(x_accum, y_accum);
1537                                                 
1538                                                 pushEventCursor([event timestamp]*1000, GHOST_kEventCursorMove, window, x_warp+x_accum, y_warp+y_accum);
1539                                         }
1540                                                 break;
1541                                         case GHOST_kGrabWrap: //Wrap cursor at area/window boundaries
1542                                         {
1543                                                 NSPoint mousePos = [event locationInWindow];
1544                                                 GHOST_TInt32 x_mouse= mousePos.x;
1545                                                 GHOST_TInt32 y_mouse= mousePos.y;
1546                                                 GHOST_TInt32 x_accum, y_accum, x_cur, y_cur;
1547                                                 GHOST_Rect bounds, windowBounds, correctedBounds;
1548                                                 
1549                                                 /* fallback to window bounds */
1550                                                 if(window->getCursorGrabBounds(bounds)==GHOST_kFailure)
1551                                                         window->getClientBounds(bounds);
1552                                                 
1553                                                 //Switch back to Cocoa coordinates orientation (y=0 at botton,the same as blender internal btw!), and to client coordinates
1554                                                 window->getClientBounds(windowBounds);
1555                                                 window->screenToClient(bounds.m_l,bounds.m_b, correctedBounds.m_l, correctedBounds.m_t);
1556                                                 window->screenToClient(bounds.m_r, bounds.m_t, correctedBounds.m_r, correctedBounds.m_b);
1557                                                 correctedBounds.m_b = (windowBounds.m_b - windowBounds.m_t) - correctedBounds.m_b;
1558                                                 correctedBounds.m_t = (windowBounds.m_b - windowBounds.m_t) - correctedBounds.m_t;
1559                                                 
1560                                                 //Update accumulation counts
1561                                                 window->getCursorGrabAccum(x_accum, y_accum);
1562                                                 x_accum += [event deltaX]-m_cursorDelta_x;
1563                                                 y_accum += -[event deltaY]-m_cursorDelta_y; //Strange Apple implementation (inverted coordinates for the deltaY) ...
1564                                                 window->setCursorGrabAccum(x_accum, y_accum);
1565                                                 
1566                                                 
1567                                                 //Warp mouse cursor if needed
1568                                                 x_mouse += [event deltaX]-m_cursorDelta_x;
1569                                                 y_mouse += -[event deltaY]-m_cursorDelta_y;
1570                                                 correctedBounds.wrapPoint(x_mouse, y_mouse, 2);
1571                                                 
1572                                                 //Compensate for mouse moved event taking cursor position set into account
1573                                                 m_cursorDelta_x = x_mouse-mousePos.x;
1574                                                 m_cursorDelta_y = y_mouse-mousePos.y;
1575                                                 
1576                                                 //Set new cursor position
1577                                                 window->clientToScreen(x_mouse, y_mouse, x_cur, y_cur);
1578                                                 setMouseCursorPosition(x_cur, y_cur); /* wrap */
1579                                                 
1580                                                 //Post event
1581                                                 window->getCursorGrabInitPos(x_cur, y_cur);
1582                                                 pushEventCursor([event timestamp]*1000, GHOST_kEventCursorMove, window, x_cur + x_accum, y_cur + y_accum);
1583                                         }
1584                                                 break;
1585                                         default:
1586                                         {
1587                                                 //Normal cursor operation: send mouse position in window
1588                                                 NSPoint mousePos = [event locationInWindow];
1589                                                 pushEventCursor([event timestamp]*1000, GHOST_kEventCursorMove, window, mousePos.x, mousePos.y);
1590                                                 m_cursorDelta_x=0;
1591                                                 m_cursorDelta_y=0; //Mouse motion occurred between two cursor warps, so we can reset the delta counter
1592                                         }
1593                                                 break;
1594                                 }
1595                                 break;
1596                         
1597                 case NSScrollWheel:
1598                         {
1599                                 /* Send trackpad event if inside a trackpad gesture, send wheel event otherwise */
1600                                 if (!m_hasMultiTouchTrackpad || !m_isGestureInProgress) {
1601                                         GHOST_TInt32 delta;
1602                                         
1603                                         double deltaF = [event deltaY];
1604                                         if (deltaF == 0.0) break; //discard trackpad delta=0 events
1605                                         
1606                                         delta = deltaF > 0.0 ? 1 : -1;
1607                                         pushEvent(new GHOST_EventWheel([event timestamp]*1000, window, delta));
1608                                 }
1609                                 else {
1610                                         NSPoint mousePos = [event locationInWindow];
1611                                         double dx = [event deltaX];
1612                                         double dy = -[event deltaY];
1613                                         
1614                                         const double deltaMax = 50.0;
1615                                         
1616                                         if ((dx == 0) && (dy == 0)) break;
1617                                         
1618                                         /* Quadratic acceleration */
1619                                         dx = dx*(fabs(dx)+0.5);
1620                                         if (dx<0.0) dx-=0.5; else dx+=0.5;
1621                                         if (dx< -deltaMax) dx= -deltaMax; else if (dx>deltaMax) dx=deltaMax;
1622                                         
1623                                         dy = dy*(fabs(dy)+0.5);
1624                                         if (dy<0.0) dy-=0.5; else dy+=0.5;
1625                                         if (dy< -deltaMax) dy= -deltaMax; else if (dy>deltaMax) dy=deltaMax;
1626
1627                                         pushEventTrackpad([event timestamp]*1000, window, GHOST_kTrackpadEventScroll, mousePos.x, mousePos.y, dx, dy);
1628                                 }
1629                         }
1630                         break;
1631                         
1632                 case NSEventTypeMagnify:
1633                         {
1634                                 NSPoint mousePos = [event locationInWindow];
1635                                 pushEventTrackpad([event timestamp]*1000, window, GHOST_kTrackpadEventMagnify, mousePos.x, mousePos.y,
1636                                                                                                   [event magnification]*250.0 + 0.1, 0);
1637                         }
1638                         break;
1639
1640                 case NSEventTypeRotate:
1641                         {
1642                                 NSPoint mousePos = [event locationInWindow];
1643                                 pushEventTrackpad([event timestamp]*1000, window, GHOST_kTrackpadEventRotate, mousePos.x, mousePos.y,
1644                                                                                                   -[event rotation] * 5.0, 0);
1645                         }
1646                 case NSEventTypeBeginGesture:
1647                         m_isGestureInProgress = true;
1648                         break;
1649                 case NSEventTypeEndGesture:
1650                         m_isGestureInProgress = false;
1651                         break;
1652                 default:
1653                         return GHOST_kFailure;
1654                         break;
1655                 }
1656         
1657         return GHOST_kSuccess;
1658 }
1659
1660
1661 GHOST_TSuccess GHOST_SystemCocoa::handleKeyEvent(void *eventPtr)
1662 {
1663         NSEvent *event = (NSEvent *)eventPtr;
1664         GHOST_IWindow* window;
1665         unsigned int modifiers;
1666         NSString *characters;
1667         NSData *convertedCharacters;
1668         GHOST_TKey keyCode;
1669         unsigned char ascii;
1670         NSString* charsIgnoringModifiers;
1671
1672         window = m_windowManager->getWindowAssociatedWithOSWindow((void*)[event window]);
1673         if (!window) {
1674                 //printf("\nW failure for event 0x%x",[event type]);
1675                 return GHOST_kFailure;
1676         }
1677         
1678         switch ([event type]) {
1679                 case NSKeyDown:
1680                 case NSKeyUp:
1681                         charsIgnoringModifiers = [event charactersIgnoringModifiers];
1682                         if ([charsIgnoringModifiers length]>0)
1683                                 keyCode = convertKey([event keyCode],
1684                                                                          [charsIgnoringModifiers characterAtIndex:0],
1685                                                                          [event type] == NSKeyDown?kUCKeyActionDown:kUCKeyActionUp);
1686                         else
1687                                 keyCode = convertKey([event keyCode],0,
1688                                                                          [event type] == NSKeyDown?kUCKeyActionDown:kUCKeyActionUp);
1689
1690                                 
1691                         characters = [event characters];
1692                         if ([characters length]>0) { //Check for dead keys
1693                                 //Convert characters to iso latin 1 encoding
1694                                 convertedCharacters = [characters dataUsingEncoding:NSISOLatin1StringEncoding];
1695                                 if ([convertedCharacters length]>0)
1696                                         ascii =((char*)[convertedCharacters bytes])[0];
1697                                 else
1698                                         ascii = 0; //Character not available in iso latin 1 encoding
1699                         }
1700                         else
1701                                 ascii= 0;
1702                         
1703                         if ((keyCode == GHOST_kKeyQ) && (m_modifierMask & NSCommandKeyMask))
1704                                 break; //Cmd-Q is directly handled by Cocoa
1705
1706                         if ([event type] == NSKeyDown) {
1707                                 pushEvent( new GHOST_EventKey([event timestamp]*1000, GHOST_kEventKeyDown, window, keyCode, ascii) );
1708                                 //printf("\nKey down rawCode=0x%x charsIgnoringModifiers=%c keyCode=%u ascii=%i %c",[event keyCode],[charsIgnoringModifiers length]>0?[charsIgnoringModifiers characterAtIndex:0]:' ',keyCode,ascii,ascii);
1709                         } else {
1710                                 pushEvent( new GHOST_EventKey([event timestamp]*1000, GHOST_kEventKeyUp, window, keyCode, ascii) );
1711                                 //printf("\nKey up rawCode=0x%x charsIgnoringModifiers=%c keyCode=%u ascii=%i %c",[event keyCode],[charsIgnoringModifiers length]>0?[charsIgnoringModifiers characterAtIndex:0]:' ',keyCode,ascii,ascii);
1712                         }
1713                         break;
1714         
1715                 case NSFlagsChanged: 
1716                         modifiers = [event modifierFlags];
1717                         
1718                         if ((modifiers & NSShiftKeyMask) != (m_modifierMask & NSShiftKeyMask)) {
1719                                 pushEvent( new GHOST_EventKey([event timestamp]*1000, (modifiers & NSShiftKeyMask)?GHOST_kEventKeyDown:GHOST_kEventKeyUp, window, GHOST_kKeyLeftShift) );
1720                         }
1721                         if ((modifiers & NSControlKeyMask) != (m_modifierMask & NSControlKeyMask)) {
1722                                 pushEvent( new GHOST_EventKey([event timestamp]*1000, (modifiers & NSControlKeyMask)?GHOST_kEventKeyDown:GHOST_kEventKeyUp, window, GHOST_kKeyLeftControl) );
1723                         }
1724                         if ((modifiers & NSAlternateKeyMask) != (m_modifierMask & NSAlternateKeyMask)) {
1725                                 pushEvent( new GHOST_EventKey([event timestamp]*1000, (modifiers & NSAlternateKeyMask)?GHOST_kEventKeyDown:GHOST_kEventKeyUp, window, GHOST_kKeyLeftAlt) );
1726                         }
1727                         if ((modifiers & NSCommandKeyMask) != (m_modifierMask & NSCommandKeyMask)) {
1728                                 pushEvent( new GHOST_EventKey([event timestamp]*1000, (modifiers & NSCommandKeyMask)?GHOST_kEventKeyDown:GHOST_kEventKeyUp, window, GHOST_kKeyOS) );
1729                         }
1730                         
1731                         m_modifierMask = modifiers;
1732                         break;
1733                         
1734                 default:
1735                         return GHOST_kFailure;
1736                         break;
1737         }
1738         
1739         return GHOST_kSuccess;
1740 }
1741
1742
1743
1744 #pragma mark Clipboard get/set
1745
1746 GHOST_TUns8* GHOST_SystemCocoa::getClipboard(bool selection) const
1747 {
1748         GHOST_TUns8 * temp_buff;
1749         size_t pastedTextSize;  
1750         
1751         NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
1752         
1753         NSPasteboard *pasteBoard = [NSPasteboard generalPasteboard];
1754         
1755         if (pasteBoard == nil) {
1756                 [pool drain];
1757                 return NULL;
1758         }
1759         
1760         NSArray *supportedTypes =
1761                 [NSArray arrayWithObjects: NSStringPboardType, nil];
1762         
1763         NSString *bestType = [[NSPasteboard generalPasteboard]
1764                                                   availableTypeFromArray:supportedTypes];
1765         
1766         if (bestType == nil) {
1767                 [pool drain];
1768                 return NULL;
1769         }
1770         
1771         NSString * textPasted = [pasteBoard stringForType:NSStringPboardType];
1772
1773         if (textPasted == nil) {
1774                 [pool drain];
1775                 return NULL;
1776         }
1777         
1778         pastedTextSize = [textPasted lengthOfBytesUsingEncoding:NSISOLatin1StringEncoding];
1779         
1780         temp_buff = (GHOST_TUns8*) malloc(pastedTextSize+1); 
1781
1782         if (temp_buff == NULL) {
1783                 [pool drain];
1784                 return NULL;
1785         }
1786         
1787         strncpy((char*)temp_buff, [textPasted cStringUsingEncoding:NSISOLatin1StringEncoding], pastedTextSize);
1788         
1789         temp_buff[pastedTextSize] = '\0';
1790         
1791         [pool drain];
1792
1793         if(temp_buff) {
1794                 return temp_buff;
1795         } else {
1796                 return NULL;
1797         }
1798 }
1799
1800 void GHOST_SystemCocoa::putClipboard(GHOST_TInt8 *buffer, bool selection) const
1801 {
1802         NSString *textToCopy;
1803         
1804         if(selection) {return;} // for copying the selection, used on X11
1805
1806         NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
1807                 
1808         NSPasteboard *pasteBoard = [NSPasteboard generalPasteboard];
1809         
1810         if (pasteBoard == nil) {
1811                 [pool drain];
1812                 return;
1813         }
1814         
1815         NSArray *supportedTypes = [NSArray arrayWithObject:NSStringPboardType];
1816         
1817         [pasteBoard declareTypes:supportedTypes owner:nil];
1818         
1819         textToCopy = [NSString stringWithCString:buffer encoding:NSISOLatin1StringEncoding];
1820         
1821         [pasteBoard setString:textToCopy forType:NSStringPboardType];
1822         
1823         [pool drain];
1824 }
1825