files missing from recent merge
authorJoseph Eagar <joeedh@gmail.com>
Sat, 24 Oct 2009 05:43:27 +0000 (05:43 +0000)
committerJoseph Eagar <joeedh@gmail.com>
Sat, 24 Oct 2009 05:43:27 +0000 (05:43 +0000)
21 files changed:
1  2 
intern/ghost/intern/GHOST_DisplayManagerCocoa.h
intern/ghost/intern/GHOST_DisplayManagerCocoa.mm
intern/ghost/intern/GHOST_SystemCocoa.h
intern/ghost/intern/GHOST_SystemCocoa.mm
intern/ghost/intern/GHOST_WindowCocoa.h
intern/ghost/intern/GHOST_WindowCocoa.mm
source/blender/editors/mesh/bmesh_tools.c
source/blender/gpu/gpu_buffers.h
source/blender/gpu/intern/gpu_buffers.c
source/blender/makesrna/intern/rna_image_api.c
source/blender/makesrna/intern/rna_pose_api.c
source/gameengine/Converter/BL_ArmatureActuator.cpp
source/gameengine/Converter/BL_ArmatureActuator.h
source/gameengine/Converter/BL_ArmatureChannel.cpp
source/gameengine/Converter/BL_ArmatureChannel.h
source/gameengine/Converter/BL_ArmatureConstraint.cpp
source/gameengine/Converter/BL_ArmatureConstraint.h
source/gameengine/GameLogic/SCA_BasicEventManager.cpp
source/gameengine/GameLogic/SCA_BasicEventManager.h
source/gameengine/Ketsji/KX_ArmatureSensor.cpp
source/gameengine/Ketsji/KX_ArmatureSensor.h

index 0000000000000000000000000000000000000000,153ee401011bf9a2bf0f832b069c61819635d161..0ce5e08b4f69d82246b47e911916b7a7583eb084
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,106 +1,106 @@@
 - * $Id$
+ /**
++ * $Id: GHOST_DisplayManagerCocoa.h 23603 2009-10-02 07:20:33Z damien78 $
+  * ***** BEGIN GPL LICENSE BLOCK *****
+  *
+  * This program is free software; you can redistribute it and/or
+  * modify it under the terms of the GNU General Public License
+  * as published by the Free Software Foundation; either version 2
+  * of the License, or (at your option) any later version.
+  *
+  * This program is distributed in the hope that it will be useful,
+  * but WITHOUT ANY WARRANTY; without even the implied warranty of
+  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  * GNU General Public License for more details.
+  *
+  * You should have received a copy of the GNU General Public License
+  * along with this program; if not, write to the Free Software Foundation,
+  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+  *
+  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
+  * All rights reserved.
+  *
+  * The Original Code is: all of this file.
+  *
+  * Contributor(s): none yet.
+  *
+  * ***** END GPL LICENSE BLOCK *****
+  */
+ /**
+  * @file      GHOST_DisplayManagerCocoa.h
+  * Declaration of GHOST_DisplayManagerCocoa class.
+  */
+ #ifndef _GHOST_DISPLAY_MANAGER_COCOA_H_
+ #define _GHOST_DISPLAY_MANAGER_COCOA_H_
+ #ifndef __APPLE__
+ #error Apple only!
+ #endif // __APPLE__
+ #include "GHOST_DisplayManager.h"
+ /**
+  * Manages system displays  (Mac OSX/Cocoa implementation).
+  * @see GHOST_DisplayManager
+  * @author    Maarten Gribnau
+  * @date      September 21, 2001
+  */
+ class GHOST_DisplayManagerCocoa : public GHOST_DisplayManager
+ {
+ public:
+       /**
+        * Constructor.
+        */
+       GHOST_DisplayManagerCocoa(void);
+       /**
+        * Returns the number of display devices on this system.
+        * @param numDisplays The number of displays on this system.
+        * @return Indication of success.
+        */
+       virtual GHOST_TSuccess getNumDisplays(GHOST_TUns8& numDisplays) const;
+       /**
+        * Returns the number of display settings for this display device.
+        * @param display The index of the display to query with 0 <= display < getNumDisplays().
+        * @param setting The number of settings of the display device with this index.
+        * @return Indication of success.
+        */
+       virtual GHOST_TSuccess getNumDisplaySettings(GHOST_TUns8 display, GHOST_TInt32& numSettings) const;
+       /**
+        * Returns the current setting for this display device. 
+        * @param display The index of the display to query with 0 <= display < getNumDisplays().
+        * @param index   The setting index to be returned.
+        * @param setting The setting of the display device with this index.
+        * @return Indication of success.
+        */
+       virtual GHOST_TSuccess getDisplaySetting(GHOST_TUns8 display, GHOST_TInt32 index, GHOST_DisplaySetting& setting) const;
+       /**
+        * Returns the current setting for this display device. 
+        * @param display The index of the display to query with 0 <= display < getNumDisplays().
+        * @param setting The current setting of the display device with this index.
+        * @return Indication of success.
+        */
+       virtual GHOST_TSuccess getCurrentDisplaySetting(GHOST_TUns8 display, GHOST_DisplaySetting& setting) const;
+       /**
+        * Changes the current setting for this display device. 
+        * @param display The index of the display to query with 0 <= display < getNumDisplays().
+        * @param setting The current setting of the display device with this index.
+        * @return Indication of success.
+        */
+       virtual GHOST_TSuccess setCurrentDisplaySetting(GHOST_TUns8 display, const GHOST_DisplaySetting& setting);
+ protected:    
+       //Do not cache values as OS X supports screen hot plug
+       /** Cached number of displays. */
+       //CGDisplayCount m_numDisplays;
+       /** Cached display id's for each display. */
+       //CGDirectDisplayID* m_displayIDs;
+ };
+ #endif // _GHOST_DISPLAY_MANAGER_COCOA_H_
index 0000000000000000000000000000000000000000,f105928c9a3c678fe64b6328642555a177e09882..5be49851bcb261d8aeedf2dcf43d22bbbf8258c7
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,168 +1,168 @@@
 -/**
 - * $Id$
 - * ***** BEGIN GPL LICENSE BLOCK *****
 - *
 - * This program is free software; you can redistribute it and/or
 - * modify it under the terms of the GNU General Public License
 - * as published by the Free Software Foundation; either version 2
 - * of the License, or (at your option) any later version.
 - *
 - * This program is distributed in the hope that it will be useful,
 - * but WITHOUT ANY WARRANTY; without even the implied warranty of
 - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 - * GNU General Public License for more details.
 - *
 - * You should have received a copy of the GNU General Public License
 - * along with this program; if not, write to the Free Software Foundation,
 - * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 - *
 - * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
 - * All rights reserved.
 - *
 - * The Original Code is: all of this file.
 - *
 - * Contributor(s):    Maarten Gribnau 09/2001
 -                                      Damien Plisson  10/2009
 - *
 - * ***** END GPL LICENSE BLOCK *****
 - */
 -
 -#include <Cocoa/Cocoa.h>
 -
 -#include "GHOST_DisplayManagerCocoa.h"
 -#include "GHOST_Debug.h"
 -
 -// We do not support multiple monitors at the moment
 -
 -
 -GHOST_DisplayManagerCocoa::GHOST_DisplayManagerCocoa(void)
 -{
 -}
 -
 -
 -GHOST_TSuccess GHOST_DisplayManagerCocoa::getNumDisplays(GHOST_TUns8& numDisplays) const
 -{
 -      NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 -      
 -      numDisplays = (GHOST_TUns8) [[NSScreen screens] count];
 -      
 -      [pool drain];
 -      return GHOST_kSuccess;
 -}
 -
 -
 -GHOST_TSuccess GHOST_DisplayManagerCocoa::getNumDisplaySettings(GHOST_TUns8 display, GHOST_TInt32& numSettings) const
 -{
 -      GHOST_ASSERT((display==kMainDisplay), "GHOST_DisplayManagerCocoa::getNumDisplaySettings(): only main display is supported");
 -      
 -      numSettings = (GHOST_TInt32)3; //Width, Height, BitsPerPixel
 -      
 -      return GHOST_kSuccess;
 -}
 -
 -
 -GHOST_TSuccess GHOST_DisplayManagerCocoa::getDisplaySetting(GHOST_TUns8 display, GHOST_TInt32 index, GHOST_DisplaySetting& setting) const
 -{
 -      //Note that only current display setting is available
 -      NSScreen *askedDisplay;
 -      
 -      GHOST_ASSERT((display==kMainDisplay), "GHOST_DisplayManagerCocoa::getDisplaySetting(): only main display is supported");
 -      
 -      NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 -      
 -      if (display == kMainDisplay) //Screen #0 may not be the main one
 -              askedDisplay = [NSScreen mainScreen];
 -      else
 -              askedDisplay = [[NSScreen screens] objectAtIndex:display];
 -      
 -      if(askedDisplay == nil) {
 -              [pool drain];
 -              return GHOST_kFailure;
 -      }
 -      
 -      NSRect frame = [askedDisplay visibleFrame];
 -      setting.xPixels = frame.size.width;
 -      setting.yPixels = frame.size.height;
 -      
 -      setting.bpp = NSBitsPerPixelFromDepth([askedDisplay depth]);
 -      
 -      setting.frequency = 0; //No more CRT display...
 -                              
 -#ifdef GHOST_DEBUG
 -      printf("display mode: width=%d, height=%d, bpp=%d, frequency=%d\n", setting.xPixels, setting.yPixels, setting.bpp, setting.frequency);
 -#endif // GHOST_DEBUG
 -
 -      [pool drain];
 -      return GHOST_kSuccess;
 -}
 -
 -
 -GHOST_TSuccess GHOST_DisplayManagerCocoa::getCurrentDisplaySetting(GHOST_TUns8 display, GHOST_DisplaySetting& setting) const
 -{
 -      NSScreen *askedDisplay;
 -      
 -      GHOST_ASSERT((display==kMainDisplay), "GHOST_DisplayManagerCocoa::getCurrentDisplaySetting(): only main display is supported");
 -    
 -      NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];     
 -
 -      if (display == kMainDisplay) //Screen #0 may not be the main one
 -              askedDisplay = [NSScreen mainScreen];
 -      else
 -              askedDisplay = [[NSScreen screens] objectAtIndex:display];
 -      
 -      if(askedDisplay == nil) {
 -              [pool drain];
 -              return GHOST_kFailure;
 -      }
 -      
 -      NSRect frame = [askedDisplay visibleFrame];
 -      setting.xPixels = frame.size.width;
 -      setting.yPixels = frame.size.height;
 -      
 -      setting.bpp = NSBitsPerPixelFromDepth([askedDisplay depth]);
 -      
 -      setting.frequency = 0; //No more CRT display...
 -
 -#ifdef GHOST_DEBUG
 -      printf("current display mode: width=%d, height=%d, bpp=%d, frequency=%d\n", setting.xPixels, setting.yPixels, setting.bpp, setting.frequency);
 -#endif // GHOST_DEBUG
 -
 -      [pool drain];
 -      return GHOST_kSuccess;
 -}
 -
 -
 -GHOST_TSuccess GHOST_DisplayManagerCocoa::setCurrentDisplaySetting(GHOST_TUns8 display, const GHOST_DisplaySetting& setting)
 -{
 -      GHOST_ASSERT((display==kMainDisplay), "GHOST_DisplayManagerCocoa::setCurrentDisplaySetting(): only main display is supported");
 -
 -#ifdef GHOST_DEBUG
 -      printf("GHOST_DisplayManagerCocoa::setCurrentDisplaySetting(): requested settings:\n");
 -      printf("  setting.xPixels=%d\n", setting.xPixels);
 -      printf("  setting.yPixels=%d\n", setting.yPixels);
 -      printf("  setting.bpp=%d\n", setting.bpp);
 -      printf("  setting.frequency=%d\n", setting.frequency);
 -#endif // GHOST_DEBUG
 -
 -      //Display configuration is no more available in 10.6
 -      
 -/*    CFDictionaryRef displayModeValues = ::CGDisplayBestModeForParametersAndRefreshRate(
 -              m_displayIDs[display],
 -              (size_t)setting.bpp,
 -              (size_t)setting.xPixels,
 -              (size_t)setting.yPixels,
 -              (CGRefreshRate)setting.frequency,
 -              NULL);*/
 -
 -#ifdef GHOST_DEBUG
 -      printf("GHOST_DisplayManagerCocoa::setCurrentDisplaySetting(): switching to:\n");
 -      printf("  setting.xPixels=%d\n", getValue(displayModeValues, kCGDisplayWidth));
 -      printf("  setting.yPixels=%d\n", getValue(displayModeValues, kCGDisplayHeight));
 -      printf("  setting.bpp=%d\n", getValue(displayModeValues, kCGDisplayBitsPerPixel));
 -      printf("  setting.frequency=%d\n", getValue(displayModeValues, kCGDisplayRefreshRate));
 -#endif // GHOST_DEBUG
 -
 -      //CGDisplayErr err = ::CGDisplaySwitchToMode(m_displayIDs[display], displayModeValues);
 -        
 -      return /*err == CGDisplayNoErr ? GHOST_kSuccess :*/ GHOST_kFailure;
 -}
++/**\r
++ * $Id: GHOST_DisplayManagerCocoa.mm 23603 2009-10-02 07:20:33Z damien78 $\r
++ * ***** BEGIN GPL LICENSE BLOCK *****\r
++ *\r
++ * This program is free software; you can redistribute it and/or\r
++ * modify it under the terms of the GNU General Public License\r
++ * as published by the Free Software Foundation; either version 2\r
++ * of the License, or (at your option) any later version.\r
++ *\r
++ * This program is distributed in the hope that it will be useful,\r
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of\r
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
++ * GNU General Public License for more details.\r
++ *\r
++ * You should have received a copy of the GNU General Public License\r
++ * along with this program; if not, write to the Free Software Foundation,\r
++ * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.\r
++ *\r
++ * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.\r
++ * All rights reserved.\r
++ *\r
++ * The Original Code is: all of this file.\r
++ *\r
++ * Contributor(s):    Maarten Gribnau 09/2001\r
++                                      Damien Plisson  10/2009\r
++ *\r
++ * ***** END GPL LICENSE BLOCK *****\r
++ */\r
++\r
++#include <Cocoa/Cocoa.h>\r
++\r
++#include "GHOST_DisplayManagerCocoa.h"\r
++#include "GHOST_Debug.h"\r
++\r
++// We do not support multiple monitors at the moment\r
++\r
++\r
++GHOST_DisplayManagerCocoa::GHOST_DisplayManagerCocoa(void)\r
++{\r
++}\r
++\r
++\r
++GHOST_TSuccess GHOST_DisplayManagerCocoa::getNumDisplays(GHOST_TUns8& numDisplays) const\r
++{\r
++      NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];\r
++      \r
++      numDisplays = (GHOST_TUns8) [[NSScreen screens] count];\r
++      \r
++      [pool drain];\r
++      return GHOST_kSuccess;\r
++}\r
++\r
++\r
++GHOST_TSuccess GHOST_DisplayManagerCocoa::getNumDisplaySettings(GHOST_TUns8 display, GHOST_TInt32& numSettings) const\r
++{\r
++      GHOST_ASSERT((display==kMainDisplay), "GHOST_DisplayManagerCocoa::getNumDisplaySettings(): only main display is supported");\r
++      \r
++      numSettings = (GHOST_TInt32)3; //Width, Height, BitsPerPixel\r
++      \r
++      return GHOST_kSuccess;\r
++}\r
++\r
++\r
++GHOST_TSuccess GHOST_DisplayManagerCocoa::getDisplaySetting(GHOST_TUns8 display, GHOST_TInt32 index, GHOST_DisplaySetting& setting) const\r
++{\r
++      //Note that only current display setting is available\r
++      NSScreen *askedDisplay;\r
++      \r
++      GHOST_ASSERT((display==kMainDisplay), "GHOST_DisplayManagerCocoa::getDisplaySetting(): only main display is supported");\r
++      \r
++      NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];\r
++      \r
++      if (display == kMainDisplay) //Screen #0 may not be the main one\r
++              askedDisplay = [NSScreen mainScreen];\r
++      else\r
++              askedDisplay = [[NSScreen screens] objectAtIndex:display];\r
++      \r
++      if(askedDisplay == nil) {\r
++              [pool drain];\r
++              return GHOST_kFailure;\r
++      }\r
++      \r
++      NSRect frame = [askedDisplay visibleFrame];\r
++      setting.xPixels = frame.size.width;\r
++      setting.yPixels = frame.size.height;\r
++      \r
++      setting.bpp = NSBitsPerPixelFromDepth([askedDisplay depth]);\r
++      \r
++      setting.frequency = 0; //No more CRT display...\r
++                              \r
++#ifdef GHOST_DEBUG\r
++      printf("display mode: width=%d, height=%d, bpp=%d, frequency=%d\n", setting.xPixels, setting.yPixels, setting.bpp, setting.frequency);\r
++#endif // GHOST_DEBUG\r
++\r
++      [pool drain];\r
++      return GHOST_kSuccess;\r
++}\r
++\r
++\r
++GHOST_TSuccess GHOST_DisplayManagerCocoa::getCurrentDisplaySetting(GHOST_TUns8 display, GHOST_DisplaySetting& setting) const\r
++{\r
++      NSScreen *askedDisplay;\r
++      \r
++      GHOST_ASSERT((display==kMainDisplay), "GHOST_DisplayManagerCocoa::getCurrentDisplaySetting(): only main display is supported");\r
++    \r
++      NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];     \r
++\r
++      if (display == kMainDisplay) //Screen #0 may not be the main one\r
++              askedDisplay = [NSScreen mainScreen];\r
++      else\r
++              askedDisplay = [[NSScreen screens] objectAtIndex:display];\r
++      \r
++      if(askedDisplay == nil) {\r
++              [pool drain];\r
++              return GHOST_kFailure;\r
++      }\r
++      \r
++      NSRect frame = [askedDisplay visibleFrame];\r
++      setting.xPixels = frame.size.width;\r
++      setting.yPixels = frame.size.height;\r
++      \r
++      setting.bpp = NSBitsPerPixelFromDepth([askedDisplay depth]);\r
++      \r
++      setting.frequency = 0; //No more CRT display...\r
++\r
++#ifdef GHOST_DEBUG\r
++      printf("current display mode: width=%d, height=%d, bpp=%d, frequency=%d\n", setting.xPixels, setting.yPixels, setting.bpp, setting.frequency);\r
++#endif // GHOST_DEBUG\r
++\r
++      [pool drain];\r
++      return GHOST_kSuccess;\r
++}\r
++\r
++\r
++GHOST_TSuccess GHOST_DisplayManagerCocoa::setCurrentDisplaySetting(GHOST_TUns8 display, const GHOST_DisplaySetting& setting)\r
++{\r
++      GHOST_ASSERT((display==kMainDisplay), "GHOST_DisplayManagerCocoa::setCurrentDisplaySetting(): only main display is supported");\r
++\r
++#ifdef GHOST_DEBUG\r
++      printf("GHOST_DisplayManagerCocoa::setCurrentDisplaySetting(): requested settings:\n");\r
++      printf("  setting.xPixels=%d\n", setting.xPixels);\r
++      printf("  setting.yPixels=%d\n", setting.yPixels);\r
++      printf("  setting.bpp=%d\n", setting.bpp);\r
++      printf("  setting.frequency=%d\n", setting.frequency);\r
++#endif // GHOST_DEBUG\r
++\r
++      //Display configuration is no more available in 10.6\r
++      \r
++/*    CFDictionaryRef displayModeValues = ::CGDisplayBestModeForParametersAndRefreshRate(\r
++              m_displayIDs[display],\r
++              (size_t)setting.bpp,\r
++              (size_t)setting.xPixels,\r
++              (size_t)setting.yPixels,\r
++              (CGRefreshRate)setting.frequency,\r
++              NULL);*/\r
++\r
++#ifdef GHOST_DEBUG\r
++      printf("GHOST_DisplayManagerCocoa::setCurrentDisplaySetting(): switching to:\n");\r
++      printf("  setting.xPixels=%d\n", getValue(displayModeValues, kCGDisplayWidth));\r
++      printf("  setting.yPixels=%d\n", getValue(displayModeValues, kCGDisplayHeight));\r
++      printf("  setting.bpp=%d\n", getValue(displayModeValues, kCGDisplayBitsPerPixel));\r
++      printf("  setting.frequency=%d\n", getValue(displayModeValues, kCGDisplayRefreshRate));\r
++#endif // GHOST_DEBUG\r
++\r
++      //CGDisplayErr err = ::CGDisplaySwitchToMode(m_displayIDs[display], displayModeValues);\r
++        \r
++      return /*err == CGDisplayNoErr ? GHOST_kSuccess :*/ GHOST_kFailure;\r
++}\r
index 0000000000000000000000000000000000000000,ee7f9d8ed37dbe302c48d9f981edf71b3754921d..002089e418586cd981e4005b054ca34d6552022e
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,273 +1,273 @@@
 - * $Id$
+ /**
++ * $Id: GHOST_SystemCocoa.h 23737 2009-10-09 12:48:28Z damien78 $
+  * ***** BEGIN GPL LICENSE BLOCK *****
+  *
+  * This program is free software; you can redistribute it and/or
+  * modify it under the terms of the GNU General Public License
+  * as published by the Free Software Foundation; either version 2
+  * of the License, or (at your option) any later version.
+  *
+  * This program is distributed in the hope that it will be useful,
+  * but WITHOUT ANY WARRANTY; without even the implied warranty of
+  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  * GNU General Public License for more details.
+  *
+  * You should have received a copy of the GNU General Public License
+  * along with this program; if not, write to the Free Software Foundation,
+  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+  *
+  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
+  * All rights reserved.
+  *
+  * The Original Code is: all of this file.
+  *
+  * Contributor(s):    Maarten Gribnau 05/2001
+  *                                    Damien Plisson 09/2009
+  *
+  * ***** END GPL LICENSE BLOCK *****
+  */
+ /**
+  * @file      GHOST_SystemCocoa.h
+  * Declaration of GHOST_SystemCocoa class.
+  */
+ #ifndef _GHOST_SYSTEM_COCOA_H_
+ #define _GHOST_SYSTEM_COCOA_H_
+ #ifndef __APPLE__
+ #error Apple OSX only!
+ #endif // __APPLE__
+ //#define __CARBONSOUND__
+ #include "GHOST_System.h"
+ class GHOST_EventCursor;
+ class GHOST_EventKey;
+ class GHOST_EventWindow;
+ class GHOST_WindowCocoa;
+ class GHOST_SystemCocoa : public GHOST_System {
+ public:
+     /**
+      * Constructor.
+      */
+     GHOST_SystemCocoa();
+     
+     /** 
+      * Destructor.
+      */
+     ~GHOST_SystemCocoa();
+     
+       /***************************************************************************************
+        ** Time(r) functionality
+        ***************************************************************************************/
+       /**
+        * Returns the system time.
+        * Returns the number of milliseconds since the start of the system process.
+        * Based on ANSI clock() routine.
+        * @return The number of milliseconds.
+        */
+       virtual GHOST_TUns64 getMilliSeconds() const;
+       /***************************************************************************************
+        ** Display/window management functionality
+        ***************************************************************************************/
+       /**
+        * Returns the number of displays on this system.
+        * @return The number of displays.
+        */
+       virtual GHOST_TUns8 getNumDisplays() const;
+       /**
+        * Returns the dimensions of the main display on this system.
+        * @return The dimension of the main display.
+        */
+       virtual void getMainDisplayDimensions(GHOST_TUns32& width, GHOST_TUns32& height) const;
+       
+       /**
+        * Create a new window.
+        * The new window is added to the list of windows managed. 
+        * Never explicitly delete the window, use disposeWindow() instead.
+        * @param       title   The name of the window (displayed in the title bar of the window if the OS supports it).
+        * @param       left    The coordinate of the left edge of the window.
+        * @param       top             The coordinate of the top edge of the window.
+        * @param       width   The width the window.
+        * @param       height  The height the window.
+        * @param       state   The state of the window when opened.
+        * @param       type    The type of drawing context installed in this window.
+        * @param       parentWindow    Parent (embedder) window
+        * @return      The new window (or 0 if creation failed).
+        */
+       virtual GHOST_IWindow* createWindow(
+               const STR_String& title,
+               GHOST_TInt32 left,
+               GHOST_TInt32 top,
+               GHOST_TUns32 width,
+               GHOST_TUns32 height,
+               GHOST_TWindowState state,
+               GHOST_TDrawingContextType type,
+               const bool stereoVisual,
+               const GHOST_TEmbedderWindowID parentWindow = 0 
+       );
+       
+       virtual GHOST_TSuccess beginFullScreen(
+               const GHOST_DisplaySetting& setting, 
+               GHOST_IWindow** window,
+               const bool stereoVisual
+       );
+       
+       virtual GHOST_TSuccess endFullScreen( void );
+       
+       /***************************************************************************************
+        ** Event management functionality
+        ***************************************************************************************/
+       /**
+        * Gets events from the system and stores them in the queue.
+        * @param waitForEvent Flag to wait for an event (or return immediately).
+        * @return Indication of the presence of events.
+        */
+       virtual bool processEvents(bool waitForEvent);
+       
+       /**
+        * Handle User request to quit, from Menu bar Quit, and Cmd+Q
+        * Display alert panel if changes performed since last save
+        */
+       GHOST_TUns8 handleQuitRequest();
+       
+       /***************************************************************************************
+        ** Cursor management functionality
+        ***************************************************************************************/
+       /**
+        * Returns the current location of the cursor (location in screen coordinates)
+        * @param x                     The x-coordinate of the cursor.
+        * @param y                     The y-coordinate of the cursor.
+        * @return                      Indication of success.
+        */
+       virtual GHOST_TSuccess getCursorPosition(GHOST_TInt32& x, GHOST_TInt32& y) const;
+       /**
+        * Updates the location of the cursor (location in screen coordinates).
+        * @param x                     The x-coordinate of the cursor.
+        * @param y                     The y-coordinate of the cursor.
+        * @return                      Indication of success.
+        */
+       virtual GHOST_TSuccess setCursorPosition(GHOST_TInt32 x, GHOST_TInt32 y) const;
+       /***************************************************************************************
+        ** Access to mouse button and keyboard states.
+        ***************************************************************************************/
+       /**
+        * Returns the state of all modifier keys.
+        * @param keys  The state of all modifier keys (true == pressed).
+        * @return              Indication of success.
+        */
+       virtual GHOST_TSuccess getModifierKeys(GHOST_ModifierKeys& keys) const;
+       /**
+        * Returns the state of the mouse buttons (ouside the message queue).
+        * @param buttons       The state of the buttons.
+        * @return                      Indication of success.
+        */
+       virtual GHOST_TSuccess getButtons(GHOST_Buttons& buttons) const;
+       /**
+        * Returns Clipboard data
+        * @param selection             Indicate which buffer to return
+        * @return                              Returns the selected buffer
+        */
+       virtual GHOST_TUns8* getClipboard(bool selection) const;
+       
+       /**
+        * Puts buffer to system clipboard
+        * @param buffer        The buffer to be copied
+        * @param selection     Indicates which buffer to copy too, only used on X11
+        */
+       virtual void putClipboard(GHOST_TInt8 *buffer, bool selection) const;
+       /**
+      * Handles a window event. Called by GHOST_WindowCocoa window delegate
+      * @param eventPtr        An NSEvent pointer (casted to void* to enable compilation in standard C++)
+      * @return Indication whether the event was handled. 
+      */
+     GHOST_TSuccess handleWindowEvent(GHOST_TEventType eventType, GHOST_WindowCocoa* window);
+       
+ protected:
+       /**
+        * Initializes the system.
+        * For now, it justs registers the window class (WNDCLASS).
+        * @return A success value.
+        */
+       virtual GHOST_TSuccess init();
+     /**
+      * Handles a tablet event.
+      * @param eventPtr        An NSEvent pointer (casted to void* to enable compilation in standard C++)
+        * @param eventType The type of the event. It needs to be passed separately as it can be either directly in the event type, or as a subtype if combined with a mouse button event
+      * @return Indication whether the event was handled. 
+      */
+     GHOST_TSuccess handleTabletEvent(void *eventPtr, short eventType);
+     
+       /**
+      * Handles a mouse event.
+      * @param eventPtr        An NSEvent pointer (casted to void* to enable compilation in standard C++)
+      * @return Indication whether the event was handled. 
+      */
+     GHOST_TSuccess handleMouseEvent(void *eventPtr);
+     /**
+      * Handles a key event.
+      * @param eventPtr        An NSEvent pointer (casted to void* to enable compilation in standard C++)
+      * @return Indication whether the event was handled. 
+      */
+     GHOST_TSuccess handleKeyEvent(void *eventPtr);
+     /**
+      * Handles all basic Mac application stuff for a mouse down event.
+      * @param eventPtr        An NSEvent pointer (casted to void* to enable compilation in standard C++)
+      * @return Indication whether the event was handled. 
+      */
+    // bool handleMouseDown(void *eventPtr);
+     /**
+      * Handles a Mac menu command.
+      * @param menuResult A Mac menu/item identifier.
+      * @return Indication whether the event was handled. 
+      */
+    // bool handleMenuCommand(GHOST_TInt32 menuResult);
+     
+     /* callback for blender generated events */
+ //    static OSStatus blendEventHandlerProc(EventHandlerCallRef handler, EventRef event, void* userData);
+     /**
+      * Callback for Mac Timer tasks that expire.
+      * @param tmTask Pointer to the timer task that expired.
+      */
+     //static void s_timerCallback(TMTaskPtr tmTask);
+       
+     /** Event handler reference. */
+     //EventHandlerRef m_handler;
+       
+       /** Start time at initialization. */
+       GHOST_TUns64 m_start_time;
+       
+       /** Mouse buttons state */
+       GHOST_TUns32 m_pressedMouseButtons;
+       
+     /** State of the modifiers. */
+     GHOST_TUns32 m_modifierMask;
+     /** Ignores window size messages (when window is dragged). */
+     bool m_ignoreWindowSizedMessages;    
+ };
+ #endif // _GHOST_SYSTEM_COCOA_H_
index 0000000000000000000000000000000000000000,62f0c538e7e2b62b270915151dd4e0652875eac8..b924adeebdeff4929330e243317d2e5be3cce516
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,1396 +1,1396 @@@
 -/**
 - * $Id$
 - * ***** BEGIN GPL LICENSE BLOCK *****
 - *
 - * This program is free software; you can redistribute it and/or
 - * modify it under the terms of the GNU General Public License
 - * as published by the Free Software Foundation; either version 2
 - * of the License, or (at your option) any later version.
 - *
 - * This program is distributed in the hope that it will be useful,
 - * but WITHOUT ANY WARRANTY; without even the implied warranty of
 - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 - * GNU General Public License for more details.
 - *
 - * You should have received a copy of the GNU General Public License
 - * along with this program; if not, write to the Free Software Foundation,
 - * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 - *
 - * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
 - * All rights reserved.
 - *
 - * The Original Code is: all of this file.
 - *
 - * Contributor(s):    Maarten Gribnau 05/2001
 - *                                    Damien Plisson 09/2009
 - *
 - * ***** END GPL LICENSE BLOCK *****
 - */
 -
 -#import <Cocoa/Cocoa.h>
 -
 -#include <sys/time.h>
 -#include <sys/types.h>
 -#include <sys/sysctl.h>
 -
 -#include "GHOST_SystemCocoa.h"
 -
 -#include "GHOST_DisplayManagerCocoa.h"
 -#include "GHOST_EventKey.h"
 -#include "GHOST_EventButton.h"
 -#include "GHOST_EventCursor.h"
 -#include "GHOST_EventWheel.h"
 -#include "GHOST_EventNDOF.h"
 -
 -#include "GHOST_TimerManager.h"
 -#include "GHOST_TimerTask.h"
 -#include "GHOST_WindowManager.h"
 -#include "GHOST_WindowCocoa.h"
 -#include "GHOST_NDOFManager.h"
 -#include "AssertMacros.h"
 -
 -#pragma mark KeyMap, mouse converters
 -
 -
 -/* Keycodes from Carbon include file */
 -/*  
 - *  Summary:
 - *    Virtual keycodes
 - *  
 - *  Discussion:
 - *    These constants are the virtual keycodes defined originally in
 - *    Inside Mac Volume V, pg. V-191. They identify physical keys on a
 - *    keyboard. Those constants with "ANSI" in the name are labeled
 - *    according to the key position on an ANSI-standard US keyboard.
 - *    For example, kVK_ANSI_A indicates the virtual keycode for the key
 - *    with the letter 'A' in the US keyboard layout. Other keyboard
 - *    layouts may have the 'A' key label on a different physical key;
 - *    in this case, pressing 'A' will generate a different virtual
 - *    keycode.
 - */
 -enum {
 -      kVK_ANSI_A                    = 0x00,
 -      kVK_ANSI_S                    = 0x01,
 -      kVK_ANSI_D                    = 0x02,
 -      kVK_ANSI_F                    = 0x03,
 -      kVK_ANSI_H                    = 0x04,
 -      kVK_ANSI_G                    = 0x05,
 -      kVK_ANSI_Z                    = 0x06,
 -      kVK_ANSI_X                    = 0x07,
 -      kVK_ANSI_C                    = 0x08,
 -      kVK_ANSI_V                    = 0x09,
 -      kVK_ANSI_B                    = 0x0B,
 -      kVK_ANSI_Q                    = 0x0C,
 -      kVK_ANSI_W                    = 0x0D,
 -      kVK_ANSI_E                    = 0x0E,
 -      kVK_ANSI_R                    = 0x0F,
 -      kVK_ANSI_Y                    = 0x10,
 -      kVK_ANSI_T                    = 0x11,
 -      kVK_ANSI_1                    = 0x12,
 -      kVK_ANSI_2                    = 0x13,
 -      kVK_ANSI_3                    = 0x14,
 -      kVK_ANSI_4                    = 0x15,
 -      kVK_ANSI_6                    = 0x16,
 -      kVK_ANSI_5                    = 0x17,
 -      kVK_ANSI_Equal                = 0x18,
 -      kVK_ANSI_9                    = 0x19,
 -      kVK_ANSI_7                    = 0x1A,
 -      kVK_ANSI_Minus                = 0x1B,
 -      kVK_ANSI_8                    = 0x1C,
 -      kVK_ANSI_0                    = 0x1D,
 -      kVK_ANSI_RightBracket         = 0x1E,
 -      kVK_ANSI_O                    = 0x1F,
 -      kVK_ANSI_U                    = 0x20,
 -      kVK_ANSI_LeftBracket          = 0x21,
 -      kVK_ANSI_I                    = 0x22,
 -      kVK_ANSI_P                    = 0x23,
 -      kVK_ANSI_L                    = 0x25,
 -      kVK_ANSI_J                    = 0x26,
 -      kVK_ANSI_Quote                = 0x27,
 -      kVK_ANSI_K                    = 0x28,
 -      kVK_ANSI_Semicolon            = 0x29,
 -      kVK_ANSI_Backslash            = 0x2A,
 -      kVK_ANSI_Comma                = 0x2B,
 -      kVK_ANSI_Slash                = 0x2C,
 -      kVK_ANSI_N                    = 0x2D,
 -      kVK_ANSI_M                    = 0x2E,
 -      kVK_ANSI_Period               = 0x2F,
 -      kVK_ANSI_Grave                = 0x32,
 -      kVK_ANSI_KeypadDecimal        = 0x41,
 -      kVK_ANSI_KeypadMultiply       = 0x43,
 -      kVK_ANSI_KeypadPlus           = 0x45,
 -      kVK_ANSI_KeypadClear          = 0x47,
 -      kVK_ANSI_KeypadDivide         = 0x4B,
 -      kVK_ANSI_KeypadEnter          = 0x4C,
 -      kVK_ANSI_KeypadMinus          = 0x4E,
 -      kVK_ANSI_KeypadEquals         = 0x51,
 -      kVK_ANSI_Keypad0              = 0x52,
 -      kVK_ANSI_Keypad1              = 0x53,
 -      kVK_ANSI_Keypad2              = 0x54,
 -      kVK_ANSI_Keypad3              = 0x55,
 -      kVK_ANSI_Keypad4              = 0x56,
 -      kVK_ANSI_Keypad5              = 0x57,
 -      kVK_ANSI_Keypad6              = 0x58,
 -      kVK_ANSI_Keypad7              = 0x59,
 -      kVK_ANSI_Keypad8              = 0x5B,
 -      kVK_ANSI_Keypad9              = 0x5C
 -};
 -
 -/* keycodes for keys that are independent of keyboard layout*/
 -enum {
 -      kVK_Return                    = 0x24,
 -      kVK_Tab                       = 0x30,
 -      kVK_Space                     = 0x31,
 -      kVK_Delete                    = 0x33,
 -      kVK_Escape                    = 0x35,
 -      kVK_Command                   = 0x37,
 -      kVK_Shift                     = 0x38,
 -      kVK_CapsLock                  = 0x39,
 -      kVK_Option                    = 0x3A,
 -      kVK_Control                   = 0x3B,
 -      kVK_RightShift                = 0x3C,
 -      kVK_RightOption               = 0x3D,
 -      kVK_RightControl              = 0x3E,
 -      kVK_Function                  = 0x3F,
 -      kVK_F17                       = 0x40,
 -      kVK_VolumeUp                  = 0x48,
 -      kVK_VolumeDown                = 0x49,
 -      kVK_Mute                      = 0x4A,
 -      kVK_F18                       = 0x4F,
 -      kVK_F19                       = 0x50,
 -      kVK_F20                       = 0x5A,
 -      kVK_F5                        = 0x60,
 -      kVK_F6                        = 0x61,
 -      kVK_F7                        = 0x62,
 -      kVK_F3                        = 0x63,
 -      kVK_F8                        = 0x64,
 -      kVK_F9                        = 0x65,
 -      kVK_F11                       = 0x67,
 -      kVK_F13                       = 0x69,
 -      kVK_F16                       = 0x6A,
 -      kVK_F14                       = 0x6B,
 -      kVK_F10                       = 0x6D,
 -      kVK_F12                       = 0x6F,
 -      kVK_F15                       = 0x71,
 -      kVK_Help                      = 0x72,
 -      kVK_Home                      = 0x73,
 -      kVK_PageUp                    = 0x74,
 -      kVK_ForwardDelete             = 0x75,
 -      kVK_F4                        = 0x76,
 -      kVK_End                       = 0x77,
 -      kVK_F2                        = 0x78,
 -      kVK_PageDown                  = 0x79,
 -      kVK_F1                        = 0x7A,
 -      kVK_LeftArrow                 = 0x7B,
 -      kVK_RightArrow                = 0x7C,
 -      kVK_DownArrow                 = 0x7D,
 -      kVK_UpArrow                   = 0x7E
 -};
 -
 -/* ISO keyboards only*/
 -enum {
 -      kVK_ISO_Section               = 0x0A
 -};
 -
 -/* JIS keyboards only*/
 -enum {
 -      kVK_JIS_Yen                   = 0x5D,
 -      kVK_JIS_Underscore            = 0x5E,
 -      kVK_JIS_KeypadComma           = 0x5F,
 -      kVK_JIS_Eisu                  = 0x66,
 -      kVK_JIS_Kana                  = 0x68
 -};
 -
 -
 -static GHOST_TButtonMask convertButton(int button)
 -{
 -      switch (button) {
 -              case 0:
 -                      return GHOST_kButtonMaskLeft;
 -              case 1:
 -                      return GHOST_kButtonMaskRight;
 -              case 2:
 -                      return GHOST_kButtonMaskMiddle;
 -              case 3:
 -                      return GHOST_kButtonMaskButton4;
 -              case 4:
 -                      return GHOST_kButtonMaskButton5;
 -              default:
 -                      return GHOST_kButtonMaskLeft;
 -      }
 -}
 -
 -/**
 - * Converts Mac rawkey codes (same for Cocoa & Carbon)
 - * into GHOST key codes
 - * @param rawCode The raw physical key code
 - * @param recvChar the character ignoring modifiers (except for shift)
 - * @return Ghost key code
 - */
 -static GHOST_TKey convertKey(int rawCode, unichar recvChar) 
 -{     
 -      
 -      //printf("\nrecvchar %c 0x%x",recvChar,recvChar);
 -      switch (rawCode) {
 -              /*Physical keycodes not used due to map changes in int'l keyboards
 -              case kVK_ANSI_A:        return GHOST_kKeyA;
 -              case kVK_ANSI_B:        return GHOST_kKeyB;
 -              case kVK_ANSI_C:        return GHOST_kKeyC;
 -              case kVK_ANSI_D:        return GHOST_kKeyD;
 -              case kVK_ANSI_E:        return GHOST_kKeyE;
 -              case kVK_ANSI_F:        return GHOST_kKeyF;
 -              case kVK_ANSI_G:        return GHOST_kKeyG;
 -              case kVK_ANSI_H:        return GHOST_kKeyH;
 -              case kVK_ANSI_I:        return GHOST_kKeyI;
 -              case kVK_ANSI_J:        return GHOST_kKeyJ;
 -              case kVK_ANSI_K:        return GHOST_kKeyK;
 -              case kVK_ANSI_L:        return GHOST_kKeyL;
 -              case kVK_ANSI_M:        return GHOST_kKeyM;
 -              case kVK_ANSI_N:        return GHOST_kKeyN;
 -              case kVK_ANSI_O:        return GHOST_kKeyO;
 -              case kVK_ANSI_P:        return GHOST_kKeyP;
 -              case kVK_ANSI_Q:        return GHOST_kKeyQ;
 -              case kVK_ANSI_R:        return GHOST_kKeyR;
 -              case kVK_ANSI_S:        return GHOST_kKeyS;
 -              case kVK_ANSI_T:        return GHOST_kKeyT;
 -              case kVK_ANSI_U:        return GHOST_kKeyU;
 -              case kVK_ANSI_V:        return GHOST_kKeyV;
 -              case kVK_ANSI_W:        return GHOST_kKeyW;
 -              case kVK_ANSI_X:        return GHOST_kKeyX;
 -              case kVK_ANSI_Y:        return GHOST_kKeyY;
 -              case kVK_ANSI_Z:        return GHOST_kKeyZ;*/
 -              
 -              /* Numbers keys mapped to handle some int'l keyboard (e.g. French)*/
 -              case kVK_ISO_Section: return    GHOST_kKeyUnknown;
 -              case kVK_ANSI_1:        return GHOST_kKey1;
 -              case kVK_ANSI_2:        return GHOST_kKey2;
 -              case kVK_ANSI_3:        return GHOST_kKey3;
 -              case kVK_ANSI_4:        return GHOST_kKey4;
 -              case kVK_ANSI_5:        return GHOST_kKey5;
 -              case kVK_ANSI_6:        return GHOST_kKey6;
 -              case kVK_ANSI_7:        return GHOST_kKey7;
 -              case kVK_ANSI_8:        return GHOST_kKey8;
 -              case kVK_ANSI_9:        return GHOST_kKey9;
 -              case kVK_ANSI_0:        return GHOST_kKey0;
 -      
 -              case kVK_ANSI_Keypad0:                  return GHOST_kKeyNumpad0;
 -              case kVK_ANSI_Keypad1:                  return GHOST_kKeyNumpad1;
 -              case kVK_ANSI_Keypad2:                  return GHOST_kKeyNumpad2;
 -              case kVK_ANSI_Keypad3:                  return GHOST_kKeyNumpad3;
 -              case kVK_ANSI_Keypad4:                  return GHOST_kKeyNumpad4;
 -              case kVK_ANSI_Keypad5:                  return GHOST_kKeyNumpad5;
 -              case kVK_ANSI_Keypad6:                  return GHOST_kKeyNumpad6;
 -              case kVK_ANSI_Keypad7:                  return GHOST_kKeyNumpad7;
 -              case kVK_ANSI_Keypad8:                  return GHOST_kKeyNumpad8;
 -              case kVK_ANSI_Keypad9:                  return GHOST_kKeyNumpad9;
 -              case kVK_ANSI_KeypadDecimal:    return GHOST_kKeyNumpadPeriod;
 -              case kVK_ANSI_KeypadEnter:              return GHOST_kKeyNumpadEnter;
 -              case kVK_ANSI_KeypadPlus:               return GHOST_kKeyNumpadPlus;
 -              case kVK_ANSI_KeypadMinus:              return GHOST_kKeyNumpadMinus;
 -              case kVK_ANSI_KeypadMultiply:   return GHOST_kKeyNumpadAsterisk;
 -              case kVK_ANSI_KeypadDivide:     return GHOST_kKeyNumpadSlash;
 -              case kVK_ANSI_KeypadClear:              return GHOST_kKeyUnknown;
 -
 -              case kVK_F1:                            return GHOST_kKeyF1;
 -              case kVK_F2:                            return GHOST_kKeyF2;
 -              case kVK_F3:                            return GHOST_kKeyF3;
 -              case kVK_F4:                            return GHOST_kKeyF4;
 -              case kVK_F5:                            return GHOST_kKeyF5;
 -              case kVK_F6:                            return GHOST_kKeyF6;
 -              case kVK_F7:                            return GHOST_kKeyF7;
 -              case kVK_F8:                            return GHOST_kKeyF8;
 -              case kVK_F9:                            return GHOST_kKeyF9;
 -              case kVK_F10:                           return GHOST_kKeyF10;
 -              case kVK_F11:                           return GHOST_kKeyF11;
 -              case kVK_F12:                           return GHOST_kKeyF12;
 -              case kVK_F13:                           return GHOST_kKeyF13;
 -              case kVK_F14:                           return GHOST_kKeyF14;
 -              case kVK_F15:                           return GHOST_kKeyF15;
 -              case kVK_F16:                           return GHOST_kKeyF16;
 -              case kVK_F17:                           return GHOST_kKeyF17;
 -              case kVK_F18:                           return GHOST_kKeyF18;
 -              case kVK_F19:                           return GHOST_kKeyF19;
 -              case kVK_F20:                           return GHOST_kKeyF20;
 -                      
 -              case kVK_UpArrow:                       return GHOST_kKeyUpArrow;
 -              case kVK_DownArrow:                     return GHOST_kKeyDownArrow;
 -              case kVK_LeftArrow:                     return GHOST_kKeyLeftArrow;
 -              case kVK_RightArrow:            return GHOST_kKeyRightArrow;
 -                      
 -              case kVK_Return:                        return GHOST_kKeyEnter;
 -              case kVK_Delete:                        return GHOST_kKeyBackSpace;
 -              case kVK_ForwardDelete:         return GHOST_kKeyDelete;
 -              case kVK_Escape:                        return GHOST_kKeyEsc;
 -              case kVK_Tab:                           return GHOST_kKeyTab;
 -              case kVK_Space:                         return GHOST_kKeySpace;
 -                      
 -              case kVK_Home:                          return GHOST_kKeyHome;
 -              case kVK_End:                           return GHOST_kKeyEnd;
 -              case kVK_PageUp:                        return GHOST_kKeyUpPage;
 -              case kVK_PageDown:                      return GHOST_kKeyDownPage;
 -                      
 -              /*case kVK_ANSI_Minus:          return GHOST_kKeyMinus;
 -              case kVK_ANSI_Equal:            return GHOST_kKeyEqual;
 -              case kVK_ANSI_Comma:            return GHOST_kKeyComma;
 -              case kVK_ANSI_Period:           return GHOST_kKeyPeriod;
 -              case kVK_ANSI_Slash:            return GHOST_kKeySlash;
 -              case kVK_ANSI_Semicolon:        return GHOST_kKeySemicolon;
 -              case kVK_ANSI_Quote:            return GHOST_kKeyQuote;
 -              case kVK_ANSI_Backslash:        return GHOST_kKeyBackslash;
 -              case kVK_ANSI_LeftBracket:      return GHOST_kKeyLeftBracket;
 -              case kVK_ANSI_RightBracket:     return GHOST_kKeyRightBracket;
 -              case kVK_ANSI_Grave:            return GHOST_kKeyAccentGrave;*/
 -                      
 -              case kVK_VolumeUp:
 -              case kVK_VolumeDown:
 -              case kVK_Mute:
 -                      return GHOST_kKeyUnknown;
 -                      
 -              default:
 -                      /*Then detect on character value for "remappable" keys in int'l keyboards*/
 -                      if ((recvChar >= 'A') && (recvChar <= 'Z')) {
 -                              return (GHOST_TKey) (recvChar - 'A' + GHOST_kKeyA);
 -                      } else if ((recvChar >= 'a') && (recvChar <= 'z')) {
 -                              return (GHOST_TKey) (recvChar - 'a' + GHOST_kKeyA);
 -                      } else
 -                      switch (recvChar) {
 -                              case '-':       return GHOST_kKeyMinus;
 -                              case '=':       return GHOST_kKeyEqual;
 -                              case ',':       return GHOST_kKeyComma;
 -                              case '.':       return GHOST_kKeyPeriod;
 -                              case '/':       return GHOST_kKeySlash;
 -                              case ';':       return GHOST_kKeySemicolon;
 -                              case '\'':      return GHOST_kKeyQuote;
 -                              case '\\':      return GHOST_kKeyBackslash;
 -                              case '[':       return GHOST_kKeyLeftBracket;
 -                              case ']':       return GHOST_kKeyRightBracket;
 -                              case '`':       return GHOST_kKeyAccentGrave;
 -                              default:
 -                                      return GHOST_kKeyUnknown;
 -                      }
 -      }
 -      return GHOST_kKeyUnknown;
 -}
 -
 -/* MacOSX returns a Roman charset with kEventParamKeyMacCharCodes
 - * as defined here: http://developer.apple.com/documentation/mac/Text/Text-516.html
 - * I am not sure how international this works...
 - * For cross-platform convention, we'll use the Latin ascii set instead.
 - * As defined at: http://www.ramsch.org/martin/uni/fmi-hp/iso8859-1.html
 - * 
 - */
 -static unsigned char convertRomanToLatin(unsigned char ascii)
 -{
 -
 -      if(ascii<128) return ascii;
 -      
 -      switch(ascii) {
 -      case 128:       return 142;
 -      case 129:       return 143;
 -      case 130:       return 128;
 -      case 131:       return 201;
 -      case 132:       return 209;
 -      case 133:       return 214;
 -      case 134:       return 220;
 -      case 135:       return 225;
 -      case 136:       return 224;
 -      case 137:       return 226;
 -      case 138:       return 228;
 -      case 139:       return 227;
 -      case 140:       return 229;
 -      case 141:       return 231;
 -      case 142:       return 233;
 -      case 143:       return 232;
 -      case 144:       return 234;
 -      case 145:       return 235;
 -      case 146:       return 237;
 -      case 147:       return 236;
 -      case 148:       return 238;
 -      case 149:       return 239;
 -      case 150:       return 241;
 -      case 151:       return 243;
 -      case 152:       return 242;
 -      case 153:       return 244;
 -      case 154:       return 246;
 -      case 155:       return 245;
 -      case 156:       return 250;
 -      case 157:       return 249;
 -      case 158:       return 251;
 -      case 159:       return 252;
 -      case 160:       return 0;
 -      case 161:       return 176;
 -      case 162:       return 162;
 -      case 163:       return 163;
 -      case 164:       return 167;
 -      case 165:       return 183;
 -      case 166:       return 182;
 -      case 167:       return 223;
 -      case 168:       return 174;
 -      case 169:       return 169;
 -      case 170:       return 174;
 -      case 171:       return 180;
 -      case 172:       return 168;
 -      case 173:       return 0;
 -      case 174:       return 198;
 -      case 175:       return 216;
 -      case 176:       return 0;
 -      case 177:       return 177;
 -      case 178:       return 0;
 -      case 179:       return 0;
 -      case 180:       return 165;
 -      case 181:       return 181;
 -      case 182:       return 0;
 -      case 183:       return 0;
 -      case 184:       return 215;
 -      case 185:       return 0;
 -      case 186:       return 0;
 -      case 187:       return 170;
 -      case 188:       return 186;
 -      case 189:       return 0;
 -      case 190:       return 230;
 -      case 191:       return 248;
 -      case 192:       return 191;
 -      case 193:       return 161;
 -      case 194:       return 172;
 -      case 195:       return 0;
 -      case 196:       return 0;
 -      case 197:       return 0;
 -      case 198:       return 0;
 -      case 199:       return 171;
 -      case 200:       return 187;
 -      case 201:       return 201;
 -      case 202:       return 0;
 -      case 203:       return 192;
 -      case 204:       return 195;
 -      case 205:       return 213;
 -      case 206:       return 0;
 -      case 207:       return 0;
 -      case 208:       return 0;
 -      case 209:       return 0;
 -      case 210:       return 0;
 -      
 -      case 214:       return 247;
 -
 -      case 229:       return 194;
 -      case 230:       return 202;
 -      case 231:       return 193;
 -      case 232:       return 203;
 -      case 233:       return 200;
 -      case 234:       return 205;
 -      case 235:       return 206;
 -      case 236:       return 207;
 -      case 237:       return 204;
 -      case 238:       return 211;
 -      case 239:       return 212;
 -      case 240:       return 0;
 -      case 241:       return 210;
 -      case 242:       return 218;
 -      case 243:       return 219;
 -      case 244:       return 217;
 -      case 245:       return 0;
 -      case 246:       return 0;
 -      case 247:       return 0;
 -      case 248:       return 0;
 -      case 249:       return 0;
 -      case 250:       return 0;
 -
 -      
 -              default: return 0;
 -      }
 -
 -}
 -
 -#define FIRSTFILEBUFLG 512
 -static bool g_hasFirstFile = false;
 -static char g_firstFileBuf[512];
 -
 -//TODO:Need to investigate this. Function called too early in creator.c to have g_hasFirstFile == true
 -extern "C" int GHOST_HACK_getFirstFile(char buf[FIRSTFILEBUFLG]) { 
 -      if (g_hasFirstFile) {
 -              strncpy(buf, g_firstFileBuf, FIRSTFILEBUFLG - 1);
 -              buf[FIRSTFILEBUFLG - 1] = '\0';
 -              return 1;
 -      } else {
 -              return 0; 
 -      }
 -}
 -
 -
 -#pragma mark Cocoa objects
 -
 -/**
 - * CocoaAppDelegate
 - * ObjC object to capture applicationShouldTerminate, and send quit event
 - **/
 -@interface CocoaAppDelegate : NSObject {
 -      GHOST_SystemCocoa *systemCocoa;
 -}
 --(void)setSystemCocoa:(GHOST_SystemCocoa *)sysCocoa;
 -- (NSApplicationTerminateReply)applicationShouldTerminate:(NSApplication *)sender;
 -- (void)applicationWillTerminate:(NSNotification *)aNotification;
 -@end
 -
 -@implementation CocoaAppDelegate : NSObject
 --(void)setSystemCocoa:(GHOST_SystemCocoa *)sysCocoa
 -{
 -      systemCocoa = sysCocoa;
 -}
 -
 -- (NSApplicationTerminateReply)applicationShouldTerminate:(NSApplication *)sender
 -{
 -      //TODO: implement graceful termination through Cocoa mechanism to avoid session log off to be cancelled
 -      //Note that Cmd+Q is already handled by keyhandler
 -    if (systemCocoa->handleQuitRequest() == GHOST_kExitNow)
 -              return NSTerminateCancel;//NSTerminateNow;
 -      else
 -              return NSTerminateCancel;
 -}
 -
 -// To avoid cancelling a log off process, we must use Cocoa termination process
 -// And this function is the only chance to perform clean up
 -// So WM_exit needs to be called directly, as the event loop will never run before termination
 -- (void)applicationWillTerminate:(NSNotification *)aNotification
 -{
 -      /*G.afbreek = 0; //Let Cocoa perform the termination at the end
 -      WM_exit(C);*/
 -}
 -@end
 -
 -
 -
 -#pragma mark initialization/finalization
 -
 -
 -GHOST_SystemCocoa::GHOST_SystemCocoa()
 -{
 -      m_modifierMask =0;
 -      m_pressedMouseButtons =0;
 -      m_displayManager = new GHOST_DisplayManagerCocoa ();
 -      GHOST_ASSERT(m_displayManager, "GHOST_SystemCocoa::GHOST_SystemCocoa(): m_displayManager==0\n");
 -      m_displayManager->initialize();
 -
 -      //NSEvent timeStamp is given in system uptime, state start date is boot time
 -      //FIXME : replace by Cocoa equivalent
 -      int mib[2];
 -      struct timeval boottime;
 -      size_t len;
 -      
 -      mib[0] = CTL_KERN;
 -      mib[1] = KERN_BOOTTIME;
 -      len = sizeof(struct timeval);
 -      
 -      sysctl(mib, 2, &boottime, &len, NULL, 0);
 -      m_start_time = ((boottime.tv_sec*1000)+(boottime.tv_usec/1000));
 -      
 -      m_ignoreWindowSizedMessages = false;
 -}
 -
 -GHOST_SystemCocoa::~GHOST_SystemCocoa()
 -{
 -}
 -
 -
 -GHOST_TSuccess GHOST_SystemCocoa::init()
 -{
 -      
 -    GHOST_TSuccess success = GHOST_System::init();
 -    if (success) {
 -              //ProcessSerialNumber psn;
 -              
 -              //Carbon stuff to move window & menu to foreground
 -              /*if (!GetCurrentProcess(&psn)) {
 -                      TransformProcessType(&psn, kProcessTransformToForegroundApplication);
 -                      SetFrontProcess(&psn);
 -              }*/
 -              
 -              NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 -              if (NSApp == nil) {
 -                      [NSApplication sharedApplication];
 -                      
 -                      if ([NSApp mainMenu] == nil) {
 -                              NSMenu *mainMenubar = [[NSMenu alloc] init];
 -                              NSMenuItem *menuItem;
 -                              NSMenu *windowMenu;
 -                              NSMenu *appMenu;
 -                              
 -                              //Create the application menu
 -                              appMenu = [[NSMenu alloc] initWithTitle:@"Blender"];
 -                              
 -                              [appMenu addItemWithTitle:@"About Blender" action:@selector(orderFrontStandardAboutPanel:) keyEquivalent:@""];
 -                              [appMenu addItem:[NSMenuItem separatorItem]];
 -                              
 -                              menuItem = [appMenu addItemWithTitle:@"Hide Blender" action:@selector(hide:) keyEquivalent:@"h"];
 -                              [menuItem setKeyEquivalentModifierMask:NSCommandKeyMask];
 -                               
 -                              menuItem = [appMenu addItemWithTitle:@"Hide others" action:@selector(hideOtherApplications:) keyEquivalent:@"h"];
 -                              [menuItem setKeyEquivalentModifierMask:(NSAlternateKeyMask | NSCommandKeyMask)];
 -                              
 -                              [appMenu addItemWithTitle:@"Show All" action:@selector(unhideAllApplications:) keyEquivalent:@""];
 -                              
 -                              menuItem = [appMenu addItemWithTitle:@"Quit Blender" action:@selector(terminate:) keyEquivalent:@"q"];
 -                              [menuItem setKeyEquivalentModifierMask:NSCommandKeyMask];
 -                              
 -                              menuItem = [[NSMenuItem alloc] init];
 -                              [menuItem setSubmenu:appMenu];
 -                              
 -                              [mainMenubar addItem:menuItem];
 -                              [menuItem release];
 -                              [NSApp performSelector:@selector(setAppleMenu:) withObject:appMenu]; //Needed for 10.5
 -                              [appMenu release];
 -                              
 -                              //Create the window menu
 -                              windowMenu = [[NSMenu alloc] initWithTitle:@"Window"];
 -                              
 -                              menuItem = [windowMenu addItemWithTitle:@"Minimize" action:@selector(performMiniaturize:) keyEquivalent:@"m"];
 -                              [menuItem setKeyEquivalentModifierMask:NSCommandKeyMask];
 -                              
 -                              [windowMenu addItemWithTitle:@"Zoom" action:@selector(performZoom:) keyEquivalent:@""];
 -                              
 -                              menuItem = [[NSMenuItem alloc] init];
 -                              [menuItem setSubmenu:windowMenu];
 -                              
 -                              [mainMenubar addItem:menuItem];
 -                              [menuItem release];
 -                              
 -                              [NSApp setMainMenu:mainMenubar];
 -                              [NSApp setWindowsMenu:windowMenu];
 -                              [windowMenu release];
 -                      }
 -                      [NSApp finishLaunching];
 -              }
 -              if ([NSApp delegate] == nil) {
 -                      CocoaAppDelegate *appDelegate = [[CocoaAppDelegate alloc] init];
 -                      [appDelegate setSystemCocoa:this];
 -                      [NSApp setDelegate:appDelegate];
 -              }
 -                              
 -              [pool drain];
 -    }
 -    return success;
 -}
 -
 -
 -#pragma mark window management
 -
 -GHOST_TUns64 GHOST_SystemCocoa::getMilliSeconds() const
 -{
 -      //Cocoa equivalent exists in 10.6 ([[NSProcessInfo processInfo] systemUptime])
 -      int mib[2];
 -      struct timeval boottime;
 -      size_t len;
 -      
 -      mib[0] = CTL_KERN;
 -      mib[1] = KERN_BOOTTIME;
 -      len = sizeof(struct timeval);
 -      
 -      sysctl(mib, 2, &boottime, &len, NULL, 0);
 -
 -      return ((boottime.tv_sec*1000)+(boottime.tv_usec/1000));
 -}
 -
 -
 -GHOST_TUns8 GHOST_SystemCocoa::getNumDisplays() const
 -{
 -      //Note that OS X supports monitor hot plug
 -      // We do not support multiple monitors at the moment
 -      NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 -
 -      GHOST_TUns8 count = [[NSScreen screens] count];
 -
 -      [pool drain];
 -      return count;
 -}
 -
 -
 -void GHOST_SystemCocoa::getMainDisplayDimensions(GHOST_TUns32& width, GHOST_TUns32& height) const
 -{
 -      NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 -      //Get visible frame, that is frame excluding dock and top menu bar
 -      NSRect frame = [[NSScreen mainScreen] visibleFrame];
 -      
 -      //Returns max window contents (excluding title bar...)
 -      NSRect contentRect = [NSWindow contentRectForFrameRect:frame
 -                                                                                               styleMask:(NSTitledWindowMask | NSClosableWindowMask | NSMiniaturizableWindowMask)];
 -      
 -      width = contentRect.size.width;
 -      height = contentRect.size.height;
 -
 -      [pool drain];
 -}
 -
 -
 -GHOST_IWindow* GHOST_SystemCocoa::createWindow(
 -      const STR_String& title, 
 -      GHOST_TInt32 left,
 -      GHOST_TInt32 top,
 -      GHOST_TUns32 width,
 -      GHOST_TUns32 height,
 -      GHOST_TWindowState state,
 -      GHOST_TDrawingContextType type,
 -      bool stereoVisual,
 -      const GHOST_TEmbedderWindowID parentWindow
 -)
 -{
 -    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 -      GHOST_IWindow* window = 0;
 -      
 -      //Get the available rect for including window contents
 -      NSRect frame = [[NSScreen mainScreen] visibleFrame];
 -      NSRect contentRect = [NSWindow contentRectForFrameRect:frame
 -                                                                                               styleMask:(NSTitledWindowMask | NSClosableWindowMask | NSMiniaturizableWindowMask)];
 -      
 -      //Ensures window top left is inside this available rect
 -      left = left > contentRect.origin.x ? left : contentRect.origin.x;
 -      top = top > contentRect.origin.y ? top : contentRect.origin.y;
 -      
 -      window = new GHOST_WindowCocoa (this, title, left, top, width, height, state, type);
 -
 -    if (window) {
 -        if (window->getValid()) {
 -            // Store the pointer to the window 
 -            GHOST_ASSERT(m_windowManager, "m_windowManager not initialized");
 -            m_windowManager->addWindow(window);
 -            m_windowManager->setActiveWindow(window);
 -                      //Need to tell window manager the new window is the active one (Cocoa does not send the event activate upon window creation)
 -            pushEvent(new GHOST_Event(getMilliSeconds(), GHOST_kEventWindowActivate, window));
 -                      pushEvent(new GHOST_Event(getMilliSeconds(), GHOST_kEventWindowSize, window));
 -
 -        }
 -        else {
 -                      GHOST_PRINT("GHOST_SystemCocoa::createWindow(): window invalid\n");
 -            delete window;
 -            window = 0;
 -        }
 -    }
 -      else {
 -              GHOST_PRINT("GHOST_SystemCocoa::createWindow(): could not create window\n");
 -      }
 -      [pool drain];
 -    return window;
 -}
 -
 -GHOST_TSuccess GHOST_SystemCocoa::beginFullScreen(const GHOST_DisplaySetting& setting, GHOST_IWindow** window, const bool stereoVisual)
 -{     
 -      GHOST_IWindow* currentWindow = m_windowManager->getActiveWindow();
 -
 -      *window = currentWindow;
 -      
 -      return currentWindow->setState(GHOST_kWindowStateFullScreen);
 -}
 -
 -GHOST_TSuccess GHOST_SystemCocoa::endFullScreen(void)
 -{     
 -      GHOST_IWindow* currentWindow = m_windowManager->getActiveWindow();
 -      
 -      return currentWindow->setState(GHOST_kWindowStateNormal);
 -}
 -
 -
 -      
 -
 -GHOST_TSuccess GHOST_SystemCocoa::getCursorPosition(GHOST_TInt32& x, GHOST_TInt32& y) const
 -{
 -    NSPoint mouseLoc = [NSEvent mouseLocation];
 -      
 -    // Returns the mouse location in screen coordinates
 -    x = (GHOST_TInt32)mouseLoc.x;
 -    y = (GHOST_TInt32)mouseLoc.y;
 -    return GHOST_kSuccess;
 -}
 -
 -
 -GHOST_TSuccess GHOST_SystemCocoa::setCursorPosition(GHOST_TInt32 x, GHOST_TInt32 y) const
 -{
 -      float xf=(float)x, yf=(float)y;
 -      
 -      //Quartz Display Services uses the old coordinates (top left origin)
 -      yf = [[NSScreen mainScreen] frame].size.height -yf;
 -      
 -      //CGAssociateMouseAndMouseCursorPosition(false);
 -      CGWarpMouseCursorPosition(CGPointMake(xf, yf));
 -      //CGAssociateMouseAndMouseCursorPosition(true);
 -
 -    return GHOST_kSuccess;
 -}
 -
 -
 -GHOST_TSuccess GHOST_SystemCocoa::getModifierKeys(GHOST_ModifierKeys& keys) const
 -{
 -      unsigned int modifiers = [[NSApp currentEvent] modifierFlags];
 -      //Direct query to modifierFlags can be used in 10.6
 -
 -    keys.set(GHOST_kModifierKeyCommand, (modifiers & NSCommandKeyMask) ? true : false);
 -    keys.set(GHOST_kModifierKeyLeftAlt, (modifiers & NSAlternateKeyMask) ? true : false);
 -    keys.set(GHOST_kModifierKeyLeftShift, (modifiers & NSShiftKeyMask) ? true : false);
 -    keys.set(GHOST_kModifierKeyLeftControl, (modifiers & NSControlKeyMask) ? true : false);
 -      
 -    return GHOST_kSuccess;
 -}
 -
 -GHOST_TSuccess GHOST_SystemCocoa::getButtons(GHOST_Buttons& buttons) const
 -{
 -      buttons.clear();
 -    buttons.set(GHOST_kButtonMaskLeft, m_pressedMouseButtons & GHOST_kButtonMaskLeft);
 -      buttons.set(GHOST_kButtonMaskRight, m_pressedMouseButtons & GHOST_kButtonMaskRight);
 -      buttons.set(GHOST_kButtonMaskMiddle, m_pressedMouseButtons & GHOST_kButtonMaskMiddle);
 -      buttons.set(GHOST_kButtonMaskButton4, m_pressedMouseButtons & GHOST_kButtonMaskButton4);
 -      buttons.set(GHOST_kButtonMaskButton5, m_pressedMouseButtons & GHOST_kButtonMaskButton5);
 -    return GHOST_kSuccess;
 -}
 -
 -
 -
 -#pragma mark Event handlers
 -
 -/**
 - * The event queue polling function
 - */
 -bool GHOST_SystemCocoa::processEvents(bool waitForEvent)
 -{
 -      bool anyProcessed = false;
 -      NSEvent *event;
 -      
 -      //      SetMouseCoalescingEnabled(false, NULL);
 -      //TODO : implement timer ??
 -      
 -      /*do {
 -              GHOST_TimerManager* timerMgr = getTimerManager();
 -              
 -               if (waitForEvent) {
 -               GHOST_TUns64 next = timerMgr->nextFireTime();
 -               double timeOut;
 -               
 -               if (next == GHOST_kFireTimeNever) {
 -               timeOut = kEventDurationForever;
 -               } else {
 -               timeOut = (double)(next - getMilliSeconds())/1000.0;
 -               if (timeOut < 0.0)
 -               timeOut = 0.0;
 -               }
 -               
 -               ::ReceiveNextEvent(0, NULL, timeOut, false, &event);
 -               }
 -               
 -               if (timerMgr->fireTimers(getMilliSeconds())) {
 -               anyProcessed = true;
 -               }
 -               
 -                       if (getFullScreen()) {
 -               // Check if the full-screen window is dirty
 -               GHOST_IWindow* window = m_windowManager->getFullScreenWindow();
 -               if (((GHOST_WindowCarbon*)window)->getFullScreenDirty()) {
 -               pushEvent( new GHOST_Event(getMilliSeconds(), GHOST_kEventWindowUpdate, window) );
 -               anyProcessed = true;
 -               }
 -               }*/
 -              
 -              do {
 -                      NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
 -                      event = [NSApp nextEventMatchingMask:NSAnyEventMask
 -                                                                         untilDate:[NSDate distantPast]
 -                                                                                inMode:NSDefaultRunLoopMode
 -                                                                               dequeue:YES];
 -                      if (event==nil) {
 -                              [pool drain];
 -                              break;
 -                      }
 -                      
 -                      anyProcessed = true;
 -                      
 -                      switch ([event type]) {
 -                              case NSKeyDown:
 -                              case NSKeyUp:
 -                              case NSFlagsChanged:
 -                                      handleKeyEvent(event);
 -                                      
 -                                      /* Support system-wide keyboard shortcuts, like Exposé, ...) =>included in always NSApp sendEvent */
 -                                      /*              if (([event modifierFlags] & NSCommandKeyMask) || [event type] == NSFlagsChanged) {
 -                                       [NSApp sendEvent:event];
 -                                       }*/
 -                                      break;
 -                                      
 -                              case NSLeftMouseDown:
 -                              case NSLeftMouseUp:
 -                              case NSRightMouseDown:
 -                              case NSRightMouseUp:
 -                              case NSMouseMoved:
 -                              case NSLeftMouseDragged:
 -                              case NSRightMouseDragged:
 -                              case NSScrollWheel:
 -                              case NSOtherMouseDown:
 -                              case NSOtherMouseUp:
 -                              case NSOtherMouseDragged:                               
 -                                      handleMouseEvent(event);
 -                                      break;
 -                                      
 -                              case NSTabletPoint:
 -                              case NSTabletProximity:
 -                                      handleTabletEvent(event,[event type]);
 -                                      break;
 -                                      
 -                                      /* Trackpad features, will need OS X 10.6 for implementation
 -                                       case NSEventTypeGesture:
 -                                       case NSEventTypeMagnify:
 -                                       case NSEventTypeSwipe:
 -                                       case NSEventTypeRotate:
 -                                       case NSEventTypeBeginGesture:
 -                                       case NSEventTypeEndGesture:
 -                                       break; */
 -                                      
 -                                      /*Unused events
 -                                       NSMouseEntered       = 8,
 -                                       NSMouseExited        = 9,
 -                                       NSAppKitDefined      = 13,
 -                                       NSSystemDefined      = 14,
 -                                       NSApplicationDefined = 15,
 -                                       NSPeriodic           = 16,
 -                                       NSCursorUpdate       = 17,*/
 -                                      
 -                              default:
 -                                      break;
 -                      }
 -                      //Resend event to NSApp to ensure Mac wide events are handled
 -                      [NSApp sendEvent:event];
 -                      [pool drain];
 -              } while (event!= nil);          
 -      //} while (waitForEvent && !anyProcessed); Needed only for timer implementation
 -      
 -      
 -      
 -    return anyProcessed;
 -}
 -
 -//Note: called from NSWindow delegate
 -GHOST_TSuccess GHOST_SystemCocoa::handleWindowEvent(GHOST_TEventType eventType, GHOST_WindowCocoa* window)
 -{
 -      if (!validWindow(window)) {
 -              return GHOST_kFailure;
 -      }
 -              switch(eventType) 
 -              {
 -                      case GHOST_kEventWindowClose:
 -                              pushEvent( new GHOST_Event(getMilliSeconds(), GHOST_kEventWindowClose, window) );
 -                              break;
 -                      case GHOST_kEventWindowActivate:
 -                              m_windowManager->setActiveWindow(window);
 -                              window->loadCursor(window->getCursorVisibility(), window->getCursorShape());
 -                              pushEvent( new GHOST_Event(getMilliSeconds(), GHOST_kEventWindowActivate, window) );
 -                              break;
 -                      case GHOST_kEventWindowDeactivate:
 -                              m_windowManager->setWindowInactive(window);
 -                              pushEvent( new GHOST_Event(getMilliSeconds(), GHOST_kEventWindowDeactivate, window) );
 -                              break;
 -                      case GHOST_kEventWindowUpdate:
 -                              pushEvent( new GHOST_Event(getMilliSeconds(), GHOST_kEventWindowUpdate, window) );
 -                              break;
 -                      case GHOST_kEventWindowSize:
 -                              if (!m_ignoreWindowSizedMessages)
 -                              {
 -                                      window->updateDrawingContext();
 -                                      pushEvent( new GHOST_Event(getMilliSeconds(), GHOST_kEventWindowSize, window) );
 -                              }
 -                              break;
 -                      default:
 -                              return GHOST_kFailure;
 -                              break;
 -              }
 -      return GHOST_kSuccess;
 -}
 -
 -GHOST_TUns8 GHOST_SystemCocoa::handleQuitRequest()
 -{
 -      //Check open windows if some changes are not saved
 -      if (m_windowManager->getAnyModifiedState())
 -      {
 -              int shouldQuit = NSRunAlertPanel(@"Exit Blender", @"Some changes have not been saved. Do you really want to quit ?",
 -                                                                               @"Cancel", @"Quit anyway", nil);
 -              if (shouldQuit == NSAlertAlternateReturn)
 -              {
 -                      pushEvent( new GHOST_Event(getMilliSeconds(), GHOST_kEventQuit, NULL) );
 -                      return GHOST_kExitNow;
 -              }
 -      }
 -      else {
 -              pushEvent( new GHOST_Event(getMilliSeconds(), GHOST_kEventQuit, NULL) );
 -              return GHOST_kExitNow;
 -      }
 -      
 -      return GHOST_kExitCancel;
 -}
 -
 -
 -GHOST_TSuccess GHOST_SystemCocoa::handleTabletEvent(void *eventPtr, short eventType)
 -{
 -      NSEvent *event = (NSEvent *)eventPtr;
 -      GHOST_IWindow* window = m_windowManager->getActiveWindow();
 -      GHOST_TabletData& ct=((GHOST_WindowCocoa*)window)->GetCocoaTabletData();
 -      
 -      switch (eventType) {
 -              case NSTabletPoint:
 -                      ct.Pressure = [event tangentialPressure];
 -                      ct.Xtilt = [event tilt].x;
 -                      ct.Ytilt = [event tilt].y;
 -                      break;
 -              
 -              case NSTabletProximity:
 -                      ct.Pressure = 0;
 -                      ct.Xtilt = 0;
 -                      ct.Ytilt = 0;
 -                      if ([event isEnteringProximity])
 -                      {
 -                              //pointer is entering tablet area proximity
 -                              switch ([event pointingDeviceType]) {
 -                                      case NSPenPointingDevice:
 -                                              ct.Active = GHOST_kTabletModeStylus;
 -                                              break;
 -                                      case NSEraserPointingDevice:
 -                                              ct.Active = GHOST_kTabletModeEraser;
 -                                              break;
 -                                      case NSCursorPointingDevice:
 -                                      case NSUnknownPointingDevice:
 -                                      default:
 -                                              ct.Active = GHOST_kTabletModeNone;
 -                                              break;
 -                              }
 -                      } else {
 -                              // pointer is leaving - return to mouse
 -                              ct.Active = GHOST_kTabletModeNone;
 -                      }
 -                      break;
 -              
 -              default:
 -                      GHOST_ASSERT(FALSE,"GHOST_SystemCocoa::handleTabletEvent : unknown event received");
 -                      return GHOST_kFailure;
 -                      break;
 -      }
 -      return GHOST_kSuccess;
 -}
 -
 -
 -GHOST_TSuccess GHOST_SystemCocoa::handleMouseEvent(void *eventPtr)
 -{
 -      NSEvent *event = (NSEvent *)eventPtr;
 -    GHOST_Window* window = (GHOST_Window*)m_windowManager->getActiveWindow();
 -      
 -      if (!window) {
 -              return GHOST_kFailure;
 -      }
 -      
 -      switch ([event type])
 -    {
 -              case NSLeftMouseDown:
 -              case NSRightMouseDown:
 -              case NSOtherMouseDown:
 -                      pushEvent(new GHOST_EventButton([event timestamp], GHOST_kEventButtonDown, window, convertButton([event buttonNumber])));
 -                      //Handle tablet events combined with mouse events
 -                      switch ([event subtype]) {
 -                              case NX_SUBTYPE_TABLET_POINT:
 -                                      handleTabletEvent(eventPtr, NSTabletPoint);
 -                                      break;
 -                              case NX_SUBTYPE_TABLET_PROXIMITY:
 -                                      handleTabletEvent(eventPtr, NSTabletProximity);
 -                                      break;
 -                              default:
 -                                      //No tablet event included : do nothing
 -                                      break;
 -                      }
 -                      break;
 -                                              
 -              case NSLeftMouseUp:
 -              case NSRightMouseUp:
 -              case NSOtherMouseUp:
 -                      pushEvent(new GHOST_EventButton([event timestamp], GHOST_kEventButtonUp, window, convertButton([event buttonNumber])));
 -                      //Handle tablet events combined with mouse events
 -                      switch ([event subtype]) {
 -                              case NX_SUBTYPE_TABLET_POINT:
 -                                      handleTabletEvent(eventPtr, NSTabletPoint);
 -                                      break;
 -                              case NX_SUBTYPE_TABLET_PROXIMITY:
 -                                      handleTabletEvent(eventPtr, NSTabletProximity);
 -                                      break;
 -                              default:
 -                                      //No tablet event included : do nothing
 -                                      break;
 -                      }
 -                      break;
 -                      
 -              case NSLeftMouseDragged:
 -              case NSRightMouseDragged:
 -              case NSOtherMouseDragged:                               
 -                      //Handle tablet events combined with mouse events
 -                      switch ([event subtype]) {
 -                              case NX_SUBTYPE_TABLET_POINT:
 -                                      handleTabletEvent(eventPtr, NSTabletPoint);
 -                                      break;
 -                              case NX_SUBTYPE_TABLET_PROXIMITY:
 -                                      handleTabletEvent(eventPtr, NSTabletProximity);
 -                                      break;
 -                              default:
 -                                      //No tablet event included : do nothing
 -                                      break;
 -                      }
 -              case NSMouseMoved:
 -                      {
 -                              if(window->getCursorWarp()) {
 -                                      GHOST_TInt32 x_warp, y_warp, x_accum, y_accum;
 -                                      
 -                                      window->getCursorWarpPos(x_warp, y_warp);
 -                                      
 -                                      window->getCursorWarpAccum(x_accum, y_accum);
 -                                      x_accum += [event deltaX];
 -                                      y_accum += -[event deltaY]; //Strange Apple implementation (inverted coordinates for the deltaY) ...
 -                                      window->setCursorWarpAccum(x_accum, y_accum);
 -                                      
 -                                      pushEvent(new GHOST_EventCursor([event timestamp], GHOST_kEventCursorMove, window, x_warp+x_accum, y_warp+y_accum));
 -                              } 
 -                              else { //Normal cursor operation: send mouse position in window
 -                                      NSPoint mousePos = [event locationInWindow];
 -                                      pushEvent(new GHOST_EventCursor([event timestamp], GHOST_kEventCursorMove, window, mousePos.x, mousePos.y));
 -                                      window->setCursorWarpAccum(0, 0); //Mouse motion occured between two cursor warps, so we can reset the delta counter
 -                              }
 -                              break;
 -                      }
 -                      
 -              case NSScrollWheel:
 -                      {
 -                              GHOST_TInt32 delta;
 -                              
 -                              double deltaF = [event deltaY];
 -                              if (deltaF == 0.0) break; //discard trackpad delta=0 events
 -                              
 -                              delta = deltaF > 0.0 ? 1 : -1;
 -                              pushEvent(new GHOST_EventWheel([event timestamp], window, delta));
 -                      }
 -                      break;
 -                      
 -              default:
 -                      return GHOST_kFailure;
 -                      break;
 -              }
 -      
 -      return GHOST_kSuccess;
 -}
 -
 -
 -GHOST_TSuccess GHOST_SystemCocoa::handleKeyEvent(void *eventPtr)
 -{
 -      NSEvent *event = (NSEvent *)eventPtr;
 -      GHOST_IWindow* window = m_windowManager->getActiveWindow();
 -      unsigned int modifiers;
 -      NSString *characters;
 -      GHOST_TKey keyCode;
 -      unsigned char ascii;
 -
 -      /* Can happen, very rarely - seems to only be when command-H makes
 -       * the window go away and we still get an HKey up. 
 -       */
 -      if (!window) {
 -              printf("\nW failure");
 -              return GHOST_kFailure;
 -      }
 -      
 -      switch ([event type]) {
 -              case NSKeyDown:
 -              case NSKeyUp:
 -                      characters = [event characters];
 -                      if ([characters length]) { //Check for dead keys
 -                              keyCode = convertKey([event keyCode],
 -                                                                       [[event charactersIgnoringModifiers] characterAtIndex:0]);
 -                              ascii= convertRomanToLatin((char)[characters characterAtIndex:0]);
 -                      } else {
 -                              keyCode = convertKey([event keyCode],0);
 -                              ascii= 0;
 -                      }
 -                      
 -                      
 -                      if ((keyCode == GHOST_kKeyQ) && (m_modifierMask & NSCommandKeyMask))
 -                              break; //Cmd-Q is directly handled by Cocoa
 -
 -                      if ([event type] == NSKeyDown) {
 -                              pushEvent( new GHOST_EventKey([event timestamp], GHOST_kEventKeyDown, window, keyCode, ascii) );
 -                              //printf("\nKey pressed keyCode=%u ascii=%i %c",keyCode,ascii,ascii);
 -                      } else {
 -                              pushEvent( new GHOST_EventKey([event timestamp], GHOST_kEventKeyUp, window, keyCode, ascii) );
 -                      }
 -                      break;
 -      
 -              case NSFlagsChanged: 
 -                      modifiers = [event modifierFlags];
 -                      if ((modifiers & NSShiftKeyMask) != (m_modifierMask & NSShiftKeyMask)) {
 -                              pushEvent( new GHOST_EventKey([event timestamp], (modifiers & NSShiftKeyMask)?GHOST_kEventKeyDown:GHOST_kEventKeyUp, window, GHOST_kKeyLeftShift) );
 -                      }
 -                      if ((modifiers & NSControlKeyMask) != (m_modifierMask & NSControlKeyMask)) {
 -                              pushEvent( new GHOST_EventKey([event timestamp], (modifiers & NSControlKeyMask)?GHOST_kEventKeyDown:GHOST_kEventKeyUp, window, GHOST_kKeyLeftControl) );
 -                      }
 -                      if ((modifiers & NSAlternateKeyMask) != (m_modifierMask & NSAlternateKeyMask)) {
 -                              pushEvent( new GHOST_EventKey([event timestamp], (modifiers & NSAlternateKeyMask)?GHOST_kEventKeyDown:GHOST_kEventKeyUp, window, GHOST_kKeyLeftAlt) );
 -                      }
 -                      if ((modifiers & NSCommandKeyMask) != (m_modifierMask & NSCommandKeyMask)) {
 -                              pushEvent( new GHOST_EventKey([event timestamp], (modifiers & NSCommandKeyMask)?GHOST_kEventKeyDown:GHOST_kEventKeyUp, window, GHOST_kKeyCommand) );
 -                      }
 -                      
 -                      m_modifierMask = modifiers;
 -                      break;
 -                      
 -              default:
 -                      return GHOST_kFailure;
 -                      break;
 -      }
 -      
 -      return GHOST_kSuccess;
 -}
 -
 -
 -
 -#pragma mark Clipboard get/set
 -
 -GHOST_TUns8* GHOST_SystemCocoa::getClipboard(bool selection) const
 -{
 -      GHOST_TUns8 * temp_buff;
 -      size_t pastedTextSize;  
 -      
 -      NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 -      
 -      NSPasteboard *pasteBoard = [NSPasteboard generalPasteboard];
 -      
 -      if (pasteBoard == nil) {
 -              [pool drain];
 -              return NULL;
 -      }
 -      
 -      NSArray *supportedTypes =
 -              [NSArray arrayWithObjects: @"public.utf8-plain-text", nil];
 -      
 -      NSString *bestType = [[NSPasteboard generalPasteboard]
 -                                                availableTypeFromArray:supportedTypes];
 -      
 -      if (bestType == nil) {
 -              [pool drain];
 -              return NULL;
 -      }
 -      
 -      NSString * textPasted = [pasteBoard stringForType:@"public.utf8-plain-text"];
 -
 -      if (textPasted == nil) {
 -              [pool drain];
 -              return NULL;
 -      }
 -      
 -      pastedTextSize = [textPasted lengthOfBytesUsingEncoding:NSUTF8StringEncoding];
 -      
 -      temp_buff = (GHOST_TUns8*) malloc(pastedTextSize+1); 
 -
 -      if (temp_buff == NULL) {
 -              [pool drain];
 -              return NULL;
 -      }
 -      
 -      strncpy((char*)temp_buff, [textPasted UTF8String], pastedTextSize);
 -      
 -      temp_buff[pastedTextSize] = '\0';
 -      
 -      [pool drain];
 -
 -      if(temp_buff) {
 -              return temp_buff;
 -      } else {
 -              return NULL;
 -      }
 -}
 -
 -void GHOST_SystemCocoa::putClipboard(GHOST_TInt8 *buffer, bool selection) const
 -{
 -      NSString *textToCopy;
 -      
 -      if(selection) {return;} // for copying the selection, used on X11
 -
 -      NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 -              
 -      NSPasteboard *pasteBoard = [NSPasteboard generalPasteboard];
 -      
 -      if (pasteBoard == nil) {
 -              [pool drain];
 -              return;
 -      }
 -      
 -      NSArray *supportedTypes = [NSArray arrayWithObject:@"public.utf8-plain-text"];
 -      
 -      [pasteBoard declareTypes:supportedTypes owner:nil];
 -      
 -      textToCopy = [NSString stringWithUTF8String:buffer];
 -      
 -      [pasteBoard setString:textToCopy forType:@"public.utf8-plain-text"];
 -      
 -      [pool drain];
 -}
 -
 -#pragma mark Carbon stuff to remove
 -
 -#ifdef WITH_CARBON
 -
 -
 -OSErr GHOST_SystemCarbon::sAEHandlerLaunch(const AppleEvent *event, AppleEvent *reply, SInt32 refCon)
 -{
 -      //GHOST_SystemCarbon* sys = (GHOST_SystemCarbon*) refCon;
 -      
 -      return noErr;
 -}
 -
 -OSErr GHOST_SystemCarbon::sAEHandlerOpenDocs(const AppleEvent *event, AppleEvent *reply, SInt32 refCon)
 -{
 -      //GHOST_SystemCarbon* sys = (GHOST_SystemCarbon*) refCon;
 -      AEDescList docs;
 -      SInt32 ndocs;
 -      OSErr err;
 -      
 -      err = AEGetParamDesc(event, keyDirectObject, typeAEList, &docs);
 -      if (err != noErr)  return err;
 -      
 -      err = AECountItems(&docs, &ndocs);
 -      if (err==noErr) {
 -              int i;
 -              
 -              for (i=0; i<ndocs; i++) {
 -                      FSSpec fss;
 -                      AEKeyword kwd;
 -                      DescType actType;
 -                      Size actSize;
 -                      
 -                      err = AEGetNthPtr(&docs, i+1, typeFSS, &kwd, &actType, &fss, sizeof(fss), &actSize);
 -                      if (err!=noErr)
 -                              break;
 -                      
 -                      if (i==0) {
 -                              FSRef fsref;
 -                              
 -                              if (FSpMakeFSRef(&fss, &fsref)!=noErr)
 -                                      break;
 -                              if (FSRefMakePath(&fsref, (UInt8*) g_firstFileBuf, sizeof(g_firstFileBuf))!=noErr)
 -                                      break;
 -                              
 -                              g_hasFirstFile = true;
 -                      }
 -              }
 -      }
 -      
 -      AEDisposeDesc(&docs);
 -      
 -      return err;
 -}
 -
 -OSErr GHOST_SystemCarbon::sAEHandlerPrintDocs(const AppleEvent *event, AppleEvent *reply, SInt32 refCon)
 -{
 -      //GHOST_SystemCarbon* sys = (GHOST_SystemCarbon*) refCon;
 -      
 -      return noErr;
 -}
 -
 -OSErr GHOST_SystemCarbon::sAEHandlerQuit(const AppleEvent *event, AppleEvent *reply, SInt32 refCon)
 -{
 -      GHOST_SystemCarbon* sys = (GHOST_SystemCarbon*) refCon;
 -      
 -      sys->pushEvent( new GHOST_Event(sys->getMilliSeconds(), GHOST_kEventQuit, NULL) );
 -      
 -      return noErr;
 -}
++/**\r
++ * $Id: GHOST_SystemCocoa.mm 23854 2009-10-15 08:27:31Z damien78 $\r
++ * ***** BEGIN GPL LICENSE BLOCK *****\r
++ *\r
++ * This program is free software; you can redistribute it and/or\r
++ * modify it under the terms of the GNU General Public License\r
++ * as published by the Free Software Foundation; either version 2\r
++ * of the License, or (at your option) any later version.\r
++ *\r
++ * This program is distributed in the hope that it will be useful,\r
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of\r
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
++ * GNU General Public License for more details.\r
++ *\r
++ * You should have received a copy of the GNU General Public License\r
++ * along with this program; if not, write to the Free Software Foundation,\r
++ * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.\r
++ *\r
++ * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.\r
++ * All rights reserved.\r
++ *\r
++ * The Original Code is: all of this file.\r
++ *\r
++ * Contributor(s):    Maarten Gribnau 05/2001\r
++ *                                    Damien Plisson 09/2009\r
++ *\r
++ * ***** END GPL LICENSE BLOCK *****\r
++ */\r
++\r
++#import <Cocoa/Cocoa.h>\r
++\r
++#include <sys/time.h>\r
++#include <sys/types.h>\r
++#include <sys/sysctl.h>\r
++\r
++#include "GHOST_SystemCocoa.h"\r
++\r
++#include "GHOST_DisplayManagerCocoa.h"\r
++#include "GHOST_EventKey.h"\r
++#include "GHOST_EventButton.h"\r
++#include "GHOST_EventCursor.h"\r
++#include "GHOST_EventWheel.h"\r
++#include "GHOST_EventNDOF.h"\r
++\r
++#include "GHOST_TimerManager.h"\r
++#include "GHOST_TimerTask.h"\r
++#include "GHOST_WindowManager.h"\r
++#include "GHOST_WindowCocoa.h"\r
++#include "GHOST_NDOFManager.h"\r
++#include "AssertMacros.h"\r
++\r
++#pragma mark KeyMap, mouse converters\r
++\r
++\r
++/* Keycodes from Carbon include file */\r
++/*  \r
++ *  Summary:\r
++ *    Virtual keycodes\r
++ *  \r
++ *  Discussion:\r
++ *    These constants are the virtual keycodes defined originally in\r
++ *    Inside Mac Volume V, pg. V-191. They identify physical keys on a\r
++ *    keyboard. Those constants with "ANSI" in the name are labeled\r
++ *    according to the key position on an ANSI-standard US keyboard.\r
++ *    For example, kVK_ANSI_A indicates the virtual keycode for the key\r
++ *    with the letter 'A' in the US keyboard layout. Other keyboard\r
++ *    layouts may have the 'A' key label on a different physical key;\r
++ *    in this case, pressing 'A' will generate a different virtual\r
++ *    keycode.\r
++ */\r
++enum {\r
++      kVK_ANSI_A                    = 0x00,\r
++      kVK_ANSI_S                    = 0x01,\r
++      kVK_ANSI_D                    = 0x02,\r
++      kVK_ANSI_F                    = 0x03,\r
++      kVK_ANSI_H                    = 0x04,\r
++      kVK_ANSI_G                    = 0x05,\r
++      kVK_ANSI_Z                    = 0x06,\r
++      kVK_ANSI_X                    = 0x07,\r
++      kVK_ANSI_C                    = 0x08,\r
++      kVK_ANSI_V                    = 0x09,\r
++      kVK_ANSI_B                    = 0x0B,\r
++      kVK_ANSI_Q                    = 0x0C,\r
++      kVK_ANSI_W                    = 0x0D,\r
++      kVK_ANSI_E                    = 0x0E,\r
++      kVK_ANSI_R                    = 0x0F,\r
++      kVK_ANSI_Y                    = 0x10,\r
++      kVK_ANSI_T                    = 0x11,\r
++      kVK_ANSI_1                    = 0x12,\r
++      kVK_ANSI_2                    = 0x13,\r
++      kVK_ANSI_3                    = 0x14,\r
++      kVK_ANSI_4                    = 0x15,\r
++      kVK_ANSI_6                    = 0x16,\r
++      kVK_ANSI_5                    = 0x17,\r
++      kVK_ANSI_Equal                = 0x18,\r
++      kVK_ANSI_9                    = 0x19,\r
++      kVK_ANSI_7                    = 0x1A,\r
++      kVK_ANSI_Minus                = 0x1B,\r
++      kVK_ANSI_8                    = 0x1C,\r
++      kVK_ANSI_0                    = 0x1D,\r
++      kVK_ANSI_RightBracket         = 0x1E,\r
++      kVK_ANSI_O                    = 0x1F,\r
++      kVK_ANSI_U                    = 0x20,\r
++      kVK_ANSI_LeftBracket          = 0x21,\r
++      kVK_ANSI_I                    = 0x22,\r
++      kVK_ANSI_P                    = 0x23,\r
++      kVK_ANSI_L                    = 0x25,\r
++      kVK_ANSI_J                    = 0x26,\r
++      kVK_ANSI_Quote                = 0x27,\r
++      kVK_ANSI_K                    = 0x28,\r
++      kVK_ANSI_Semicolon            = 0x29,\r
++      kVK_ANSI_Backslash            = 0x2A,\r
++      kVK_ANSI_Comma                = 0x2B,\r
++      kVK_ANSI_Slash                = 0x2C,\r
++      kVK_ANSI_N                    = 0x2D,\r
++      kVK_ANSI_M                    = 0x2E,\r
++      kVK_ANSI_Period               = 0x2F,\r
++      kVK_ANSI_Grave                = 0x32,\r
++      kVK_ANSI_KeypadDecimal        = 0x41,\r
++      kVK_ANSI_KeypadMultiply       = 0x43,\r
++      kVK_ANSI_KeypadPlus           = 0x45,\r
++      kVK_ANSI_KeypadClear          = 0x47,\r
++      kVK_ANSI_KeypadDivide         = 0x4B,\r
++      kVK_ANSI_KeypadEnter          = 0x4C,\r
++      kVK_ANSI_KeypadMinus          = 0x4E,\r
++      kVK_ANSI_KeypadEquals         = 0x51,\r
++      kVK_ANSI_Keypad0              = 0x52,\r
++      kVK_ANSI_Keypad1              = 0x53,\r
++      kVK_ANSI_Keypad2              = 0x54,\r
++      kVK_ANSI_Keypad3              = 0x55,\r
++      kVK_ANSI_Keypad4              = 0x56,\r
++      kVK_ANSI_Keypad5              = 0x57,\r
++      kVK_ANSI_Keypad6              = 0x58,\r
++      kVK_ANSI_Keypad7              = 0x59,\r
++      kVK_ANSI_Keypad8              = 0x5B,\r
++      kVK_ANSI_Keypad9              = 0x5C\r
++};\r
++\r
++/* keycodes for keys that are independent of keyboard layout*/\r
++enum {\r
++      kVK_Return                    = 0x24,\r
++      kVK_Tab                       = 0x30,\r
++      kVK_Space                     = 0x31,\r
++      kVK_Delete                    = 0x33,\r
++      kVK_Escape                    = 0x35,\r
++      kVK_Command                   = 0x37,\r
++      kVK_Shift                     = 0x38,\r
++      kVK_CapsLock                  = 0x39,\r
++      kVK_Option                    = 0x3A,\r
++      kVK_Control                   = 0x3B,\r
++      kVK_RightShift                = 0x3C,\r
++      kVK_RightOption               = 0x3D,\r
++      kVK_RightControl              = 0x3E,\r
++      kVK_Function                  = 0x3F,\r
++      kVK_F17                       = 0x40,\r
++      kVK_VolumeUp                  = 0x48,\r
++      kVK_VolumeDown                = 0x49,\r
++      kVK_Mute                      = 0x4A,\r
++      kVK_F18                       = 0x4F,\r
++      kVK_F19                       = 0x50,\r
++      kVK_F20                       = 0x5A,\r
++      kVK_F5                        = 0x60,\r
++      kVK_F6                        = 0x61,\r
++      kVK_F7                        = 0x62,\r
++      kVK_F3                        = 0x63,\r
++      kVK_F8                        = 0x64,\r
++      kVK_F9                        = 0x65,\r
++      kVK_F11                       = 0x67,\r
++      kVK_F13                       = 0x69,\r
++      kVK_F16                       = 0x6A,\r
++      kVK_F14                       = 0x6B,\r
++      kVK_F10                       = 0x6D,\r
++      kVK_F12                       = 0x6F,\r
++      kVK_F15                       = 0x71,\r
++      kVK_Help                      = 0x72,\r
++      kVK_Home                      = 0x73,\r
++      kVK_PageUp                    = 0x74,\r
++      kVK_ForwardDelete             = 0x75,\r
++      kVK_F4                        = 0x76,\r
++      kVK_End                       = 0x77,\r
++      kVK_F2                        = 0x78,\r
++      kVK_PageDown                  = 0x79,\r
++      kVK_F1                        = 0x7A,\r
++      kVK_LeftArrow                 = 0x7B,\r
++      kVK_RightArrow                = 0x7C,\r
++      kVK_DownArrow                 = 0x7D,\r
++      kVK_UpArrow                   = 0x7E\r
++};\r
++\r
++/* ISO keyboards only*/\r
++enum {\r
++      kVK_ISO_Section               = 0x0A\r
++};\r
++\r
++/* JIS keyboards only*/\r
++enum {\r
++      kVK_JIS_Yen                   = 0x5D,\r
++      kVK_JIS_Underscore            = 0x5E,\r
++      kVK_JIS_KeypadComma           = 0x5F,\r
++      kVK_JIS_Eisu                  = 0x66,\r
++      kVK_JIS_Kana                  = 0x68\r
++};\r
++\r
++\r
++static GHOST_TButtonMask convertButton(int button)\r
++{\r
++      switch (button) {\r
++              case 0:\r
++                      return GHOST_kButtonMaskLeft;\r
++              case 1:\r
++                      return GHOST_kButtonMaskRight;\r
++              case 2:\r
++                      return GHOST_kButtonMaskMiddle;\r
++              case 3:\r
++                      return GHOST_kButtonMaskButton4;\r
++              case 4:\r
++                      return GHOST_kButtonMaskButton5;\r
++              default:\r
++                      return GHOST_kButtonMaskLeft;\r
++      }\r
++}\r
++\r
++/**\r
++ * Converts Mac rawkey codes (same for Cocoa & Carbon)\r
++ * into GHOST key codes\r
++ * @param rawCode The raw physical key code\r
++ * @param recvChar the character ignoring modifiers (except for shift)\r
++ * @return Ghost key code\r
++ */\r
++static GHOST_TKey convertKey(int rawCode, unichar recvChar) \r
++{     \r
++      \r
++      //printf("\nrecvchar %c 0x%x",recvChar,recvChar);\r
++      switch (rawCode) {\r
++              /*Physical keycodes not used due to map changes in int'l keyboards\r
++              case kVK_ANSI_A:        return GHOST_kKeyA;\r
++              case kVK_ANSI_B:        return GHOST_kKeyB;\r
++              case kVK_ANSI_C:        return GHOST_kKeyC;\r
++              case kVK_ANSI_D:        return GHOST_kKeyD;\r
++              case kVK_ANSI_E:        return GHOST_kKeyE;\r
++              case kVK_ANSI_F:        return GHOST_kKeyF;\r
++              case kVK_ANSI_G:        return GHOST_kKeyG;\r
++              case kVK_ANSI_H:        return GHOST_kKeyH;\r
++              case kVK_ANSI_I:        return GHOST_kKeyI;\r
++              case kVK_ANSI_J:        return GHOST_kKeyJ;\r
++              case kVK_ANSI_K:        return GHOST_kKeyK;\r
++              case kVK_ANSI_L:        return GHOST_kKeyL;\r
++              case kVK_ANSI_M:        return GHOST_kKeyM;\r
++              case kVK_ANSI_N:        return GHOST_kKeyN;\r
++              case kVK_ANSI_O:        return GHOST_kKeyO;\r
++              case kVK_ANSI_P:        return GHOST_kKeyP;\r
++              case kVK_ANSI_Q:        return GHOST_kKeyQ;\r
++              case kVK_ANSI_R:        return GHOST_kKeyR;\r
++              case kVK_ANSI_S:        return GHOST_kKeyS;\r
++              case kVK_ANSI_T:        return GHOST_kKeyT;\r
++              case kVK_ANSI_U:        return GHOST_kKeyU;\r
++              case kVK_ANSI_V:        return GHOST_kKeyV;\r
++              case kVK_ANSI_W:        return GHOST_kKeyW;\r
++              case kVK_ANSI_X:        return GHOST_kKeyX;\r
++              case kVK_ANSI_Y:        return GHOST_kKeyY;\r
++              case kVK_ANSI_Z:        return GHOST_kKeyZ;*/\r
++              \r
++              /* Numbers keys mapped to handle some int'l keyboard (e.g. French)*/\r
++              case kVK_ISO_Section: return    GHOST_kKeyUnknown;\r
++              case kVK_ANSI_1:        return GHOST_kKey1;\r
++              case kVK_ANSI_2:        return GHOST_kKey2;\r
++              case kVK_ANSI_3:        return GHOST_kKey3;\r
++              case kVK_ANSI_4:        return GHOST_kKey4;\r
++              case kVK_ANSI_5:        return GHOST_kKey5;\r
++              case kVK_ANSI_6:        return GHOST_kKey6;\r
++              case kVK_ANSI_7:        return GHOST_kKey7;\r
++              case kVK_ANSI_8:        return GHOST_kKey8;\r
++              case kVK_ANSI_9:        return GHOST_kKey9;\r
++              case kVK_ANSI_0:        return GHOST_kKey0;\r
++      \r
++              case kVK_ANSI_Keypad0:                  return GHOST_kKeyNumpad0;\r
++              case kVK_ANSI_Keypad1:                  return GHOST_kKeyNumpad1;\r
++              case kVK_ANSI_Keypad2:                  return GHOST_kKeyNumpad2;\r
++              case kVK_ANSI_Keypad3:                  return GHOST_kKeyNumpad3;\r
++              case kVK_ANSI_Keypad4:                  return GHOST_kKeyNumpad4;\r
++              case kVK_ANSI_Keypad5:                  return GHOST_kKeyNumpad5;\r
++              case kVK_ANSI_Keypad6:                  return GHOST_kKeyNumpad6;\r
++              case kVK_ANSI_Keypad7:                  return GHOST_kKeyNumpad7;\r
++              case kVK_ANSI_Keypad8:                  return GHOST_kKeyNumpad8;\r
++              case kVK_ANSI_Keypad9:                  return GHOST_kKeyNumpad9;\r
++              case kVK_ANSI_KeypadDecimal:    return GHOST_kKeyNumpadPeriod;\r
++              case kVK_ANSI_KeypadEnter:              return GHOST_kKeyNumpadEnter;\r
++              case kVK_ANSI_KeypadPlus:               return GHOST_kKeyNumpadPlus;\r
++              case kVK_ANSI_KeypadMinus:              return GHOST_kKeyNumpadMinus;\r
++              case kVK_ANSI_KeypadMultiply:   return GHOST_kKeyNumpadAsterisk;\r
++              case kVK_ANSI_KeypadDivide:     return GHOST_kKeyNumpadSlash;\r
++              case kVK_ANSI_KeypadClear:              return GHOST_kKeyUnknown;\r
++\r
++              case kVK_F1:                            return GHOST_kKeyF1;\r
++              case kVK_F2:                            return GHOST_kKeyF2;\r
++              case kVK_F3:                            return GHOST_kKeyF3;\r
++              case kVK_F4:                            return GHOST_kKeyF4;\r
++              case kVK_F5:                            return GHOST_kKeyF5;\r
++              case kVK_F6:                            return GHOST_kKeyF6;\r
++              case kVK_F7:                            return GHOST_kKeyF7;\r
++              case kVK_F8:                            return GHOST_kKeyF8;\r
++              case kVK_F9:                            return GHOST_kKeyF9;\r
++              case kVK_F10:                           return GHOST_kKeyF10;\r
++              case kVK_F11:                           return GHOST_kKeyF11;\r
++              case kVK_F12:                           return GHOST_kKeyF12;\r
++              case kVK_F13:                           return GHOST_kKeyF13;\r
++              case kVK_F14:                           return GHOST_kKeyF14;\r
++              case kVK_F15:                           return GHOST_kKeyF15;\r
++              case kVK_F16:                           return GHOST_kKeyF16;\r
++              case kVK_F17:                           return GHOST_kKeyF17;\r
++              case kVK_F18:                           return GHOST_kKeyF18;\r
++              case kVK_F19:                           return GHOST_kKeyF19;\r
++              case kVK_F20:                           return GHOST_kKeyF20;\r
++                      \r
++              case kVK_UpArrow:                       return GHOST_kKeyUpArrow;\r
++              case kVK_DownArrow:                     return GHOST_kKeyDownArrow;\r
++              case kVK_LeftArrow:                     return GHOST_kKeyLeftArrow;\r
++              case kVK_RightArrow:            return GHOST_kKeyRightArrow;\r
++                      \r
++              case kVK_Return:                        return GHOST_kKeyEnter;\r
++              case kVK_Delete:                        return GHOST_kKeyBackSpace;\r
++              case kVK_ForwardDelete:         return GHOST_kKeyDelete;\r
++              case kVK_Escape:                        return GHOST_kKeyEsc;\r
++              case kVK_Tab:                           return GHOST_kKeyTab;\r
++              case kVK_Space:                         return GHOST_kKeySpace;\r
++                      \r
++              case kVK_Home:                          return GHOST_kKeyHome;\r
++              case kVK_End:                           return GHOST_kKeyEnd;\r
++              case kVK_PageUp:                        return GHOST_kKeyUpPage;\r
++              case kVK_PageDown:                      return GHOST_kKeyDownPage;\r
++                      \r
++              /*case kVK_ANSI_Minus:          return GHOST_kKeyMinus;\r
++              case kVK_ANSI_Equal:            return GHOST_kKeyEqual;\r
++              case kVK_ANSI_Comma:            return GHOST_kKeyComma;\r
++              case kVK_ANSI_Period:           return GHOST_kKeyPeriod;\r
++              case kVK_ANSI_Slash:            return GHOST_kKeySlash;\r
++              case kVK_ANSI_Semicolon:        return GHOST_kKeySemicolon;\r
++              case kVK_ANSI_Quote:            return GHOST_kKeyQuote;\r
++              case kVK_ANSI_Backslash:        return GHOST_kKeyBackslash;\r
++              case kVK_ANSI_LeftBracket:      return GHOST_kKeyLeftBracket;\r
++              case kVK_ANSI_RightBracket:     return GHOST_kKeyRightBracket;\r
++              case kVK_ANSI_Grave:            return GHOST_kKeyAccentGrave;*/\r
++                      \r
++              case kVK_VolumeUp:\r
++              case kVK_VolumeDown:\r
++              case kVK_Mute:\r
++                      return GHOST_kKeyUnknown;\r
++                      \r
++              default:\r
++                      /*Then detect on character value for "remappable" keys in int'l keyboards*/\r
++                      if ((recvChar >= 'A') && (recvChar <= 'Z')) {\r
++                              return (GHOST_TKey) (recvChar - 'A' + GHOST_kKeyA);\r
++                      } else if ((recvChar >= 'a') && (recvChar <= 'z')) {\r
++                              return (GHOST_TKey) (recvChar - 'a' + GHOST_kKeyA);\r
++                      } else\r
++                      switch (recvChar) {\r
++                              case '-':       return GHOST_kKeyMinus;\r
++                              case '=':       return GHOST_kKeyEqual;\r
++                              case ',':       return GHOST_kKeyComma;\r
++                              case '.':       return GHOST_kKeyPeriod;\r
++                              case '/':       return GHOST_kKeySlash;\r
++                              case ';':       return GHOST_kKeySemicolon;\r
++                              case '\'':      return GHOST_kKeyQuote;\r
++                              case '\\':      return GHOST_kKeyBackslash;\r
++                              case '[':       return GHOST_kKeyLeftBracket;\r
++                              case ']':       return GHOST_kKeyRightBracket;\r
++                              case '`':       return GHOST_kKeyAccentGrave;\r
++                              default:\r
++                                      return GHOST_kKeyUnknown;\r
++                      }\r
++      }\r
++      return GHOST_kKeyUnknown;\r
++}\r
++\r
++/* MacOSX returns a Roman charset with kEventParamKeyMacCharCodes\r
++ * as defined here: http://developer.apple.com/documentation/mac/Text/Text-516.html\r
++ * I am not sure how international this works...\r
++ * For cross-platform convention, we'll use the Latin ascii set instead.\r
++ * As defined at: http://www.ramsch.org/martin/uni/fmi-hp/iso8859-1.html\r
++ * \r
++ */\r
++static unsigned char convertRomanToLatin(unsigned char ascii)\r
++{\r
++\r
++      if(ascii<128) return ascii;\r
++      \r
++      switch(ascii) {\r
++      case 128:       return 142;\r
++      case 129:       return 143;\r
++      case 130:       return 128;\r
++      case 131:       return 201;\r
++      case 132:       return 209;\r
++      case 133:       return 214;\r
++      case 134:       return 220;\r
++      case 135:       return 225;\r
++      case 136:       return 224;\r
++      case 137:       return 226;\r
++      case 138:       return 228;\r
++      case 139:       return 227;\r
++      case 140:       return 229;\r
++      case 141:       return 231;\r
++      case 142:       return 233;\r
++      case 143:       return 232;\r
++      case 144:       return 234;\r
++      case 145:       return 235;\r
++      case 146:       return 237;\r
++      case 147:       return 236;\r
++      case 148:       return 238;\r
++      case 149:       return 239;\r
++      case 150:       return 241;\r
++      case 151:       return 243;\r
++      case 152:       return 242;\r
++      case 153:       return 244;\r
++      case 154:       return 246;\r
++      case 155:       return 245;\r
++      case 156:       return 250;\r
++      case 157:       return 249;\r
++      case 158:       return 251;\r
++      case 159:       return 252;\r
++      case 160:       return 0;\r
++      case 161:       return 176;\r
++      case 162:       return 162;\r
++      case 163:       return 163;\r
++      case 164:       return 167;\r
++      case 165:       return 183;\r
++      case 166:       return 182;\r
++      case 167:       return 223;\r
++      case 168:       return 174;\r
++      case 169:       return 169;\r
++      case 170:       return 174;\r
++      case 171:       return 180;\r
++      case 172:       return 168;\r
++      case 173:       return 0;\r
++      case 174:       return 198;\r
++      case 175:       return 216;\r
++      case 176:       return 0;\r
++      case 177:       return 177;\r
++      case 178:       return 0;\r
++      case 179:       return 0;\r
++      case 180:       return 165;\r
++      case 181:       return 181;\r
++      case 182:       return 0;\r
++      case 183:       return 0;\r
++      case 184:       return 215;\r
++      case 185:       return 0;\r
++      case 186:       return 0;\r
++      case 187:       return 170;\r
++      case 188:       return 186;\r
++      case 189:       return 0;\r
++      case 190:       return 230;\r
++      case 191:       return 248;\r
++      case 192:       return 191;\r
++      case 193:       return 161;\r
++      case 194:       return 172;\r
++      case 195:       return 0;\r
++      case 196:       return 0;\r
++      case 197:       return 0;\r
++      case 198:       return 0;\r
++      case 199:       return 171;\r
++      case 200:       return 187;\r
++      case 201:       return 201;\r
++      case 202:       return 0;\r
++      case 203:       return 192;\r
++      case 204:       return 195;\r
++      case 205:       return 213;\r
++      case 206:       return 0;\r
++      case 207:       return 0;\r
++      case 208:       return 0;\r
++      case 209:       return 0;\r
++      case 210:       return 0;\r
++      \r
++      case 214:       return 247;\r
++\r
++      case 229:       return 194;\r
++      case 230:       return 202;\r
++      case 231:       return 193;\r
++      case 232:       return 203;\r
++      case 233:       return 200;\r
++      case 234:       return 205;\r
++      case 235:       return 206;\r
++      case 236:       return 207;\r
++      case 237:       return 204;\r
++      case 238:       return 211;\r
++      case 239:       return 212;\r
++      case 240:       return 0;\r
++      case 241:       return 210;\r
++      case 242:       return 218;\r
++      case 243:       return 219;\r
++      case 244:       return 217;\r
++      case 245:       return 0;\r
++      case 246:       return 0;\r
++      case 247:       return 0;\r
++      case 248:       return 0;\r
++      case 249:       return 0;\r
++      case 250:       return 0;\r
++\r
++      \r
++              default: return 0;\r
++      }\r
++\r
++}\r
++\r
++#define FIRSTFILEBUFLG 512\r
++static bool g_hasFirstFile = false;\r
++static char g_firstFileBuf[512];\r
++\r
++//TODO:Need to investigate this. Function called too early in creator.c to have g_hasFirstFile == true\r
++extern "C" int GHOST_HACK_getFirstFile(char buf[FIRSTFILEBUFLG]) { \r
++      if (g_hasFirstFile) {\r
++              strncpy(buf, g_firstFileBuf, FIRSTFILEBUFLG - 1);\r
++              buf[FIRSTFILEBUFLG - 1] = '\0';\r
++              return 1;\r
++      } else {\r
++              return 0; \r
++      }\r
++}\r
++\r
++\r
++#pragma mark Cocoa objects\r
++\r
++/**\r
++ * CocoaAppDelegate\r
++ * ObjC object to capture applicationShouldTerminate, and send quit event\r
++ **/\r
++@interface CocoaAppDelegate : NSObject {\r
++      GHOST_SystemCocoa *systemCocoa;\r
++}\r
++-(void)setSystemCocoa:(GHOST_SystemCocoa *)sysCocoa;\r
++- (NSApplicationTerminateReply)applicationShouldTerminate:(NSApplication *)sender;\r
++- (void)applicationWillTerminate:(NSNotification *)aNotification;\r
++@end\r
++\r
++@implementation CocoaAppDelegate : NSObject\r
++-(void)setSystemCocoa:(GHOST_SystemCocoa *)sysCocoa\r
++{\r
++      systemCocoa = sysCocoa;\r
++}\r
++\r
++- (NSApplicationTerminateReply)applicationShouldTerminate:(NSApplication *)sender\r
++{\r
++      //TODO: implement graceful termination through Cocoa mechanism to avoid session log off to be cancelled\r
++      //Note that Cmd+Q is already handled by keyhandler\r
++    if (systemCocoa->handleQuitRequest() == GHOST_kExitNow)\r
++              return NSTerminateCancel;//NSTerminateNow;\r
++      else\r
++              return NSTerminateCancel;\r
++}\r
++\r
++// To avoid cancelling a log off process, we must use Cocoa termination process\r
++// And this function is the only chance to perform clean up\r
++// So WM_exit needs to be called directly, as the event loop will never run before termination\r
++- (void)applicationWillTerminate:(NSNotification *)aNotification\r
++{\r
++      /*G.afbreek = 0; //Let Cocoa perform the termination at the end\r
++      WM_exit(C);*/\r
++}\r
++@end\r
++\r
++\r
++\r
++#pragma mark initialization/finalization\r
++\r
++\r
++GHOST_SystemCocoa::GHOST_SystemCocoa()\r
++{\r
++      m_modifierMask =0;\r
++      m_pressedMouseButtons =0;\r
++      m_displayManager = new GHOST_DisplayManagerCocoa ();\r
++      GHOST_ASSERT(m_displayManager, "GHOST_SystemCocoa::GHOST_SystemCocoa(): m_displayManager==0\n");\r
++      m_displayManager->initialize();\r
++\r
++      //NSEvent timeStamp is given in system uptime, state start date is boot time\r
++      //FIXME : replace by Cocoa equivalent\r
++      int mib[2];\r
++      struct timeval boottime;\r
++      size_t len;\r
++      \r
++      mib[0] = CTL_KERN;\r
++      mib[1] = KERN_BOOTTIME;\r
++      len = sizeof(struct timeval);\r
++      \r
++      sysctl(mib, 2, &boottime, &len, NULL, 0);\r
++      m_start_time = ((boottime.tv_sec*1000)+(boottime.tv_usec/1000));\r
++      \r
++      m_ignoreWindowSizedMessages = false;\r
++}\r
++\r
++GHOST_SystemCocoa::~GHOST_SystemCocoa()\r
++{\r
++}\r
++\r
++\r
++GHOST_TSuccess GHOST_SystemCocoa::init()\r
++{\r
++      \r
++    GHOST_TSuccess success = GHOST_System::init();\r
++    if (success) {\r
++              //ProcessSerialNumber psn;\r
++              \r
++              //Carbon stuff to move window & menu to foreground\r
++              /*if (!GetCurrentProcess(&psn)) {\r
++                      TransformProcessType(&psn, kProcessTransformToForegroundApplication);\r
++                      SetFrontProcess(&psn);\r
++              }*/\r
++              \r
++              NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];\r
++              if (NSApp == nil) {\r
++                      [NSApplication sharedApplication];\r
++                      \r
++                      if ([NSApp mainMenu] == nil) {\r
++                              NSMenu *mainMenubar = [[NSMenu alloc] init];\r
++                              NSMenuItem *menuItem;\r
++                              NSMenu *windowMenu;\r
++                              NSMenu *appMenu;\r
++                              \r
++                              //Create the application menu\r
++                              appMenu = [[NSMenu alloc] initWithTitle:@"Blender"];\r
++                              \r
++                              [appMenu addItemWithTitle:@"About Blender" action:@selector(orderFrontStandardAboutPanel:) keyEquivalent:@""];\r
++                              [appMenu addItem:[NSMenuItem separatorItem]];\r
++                              \r
++                              menuItem = [appMenu addItemWithTitle:@"Hide Blender" action:@selector(hide:) keyEquivalent:@"h"];\r
++                              [menuItem setKeyEquivalentModifierMask:NSCommandKeyMask];\r
++                               \r
++                              menuItem = [appMenu addItemWithTitle:@"Hide others" action:@selector(hideOtherApplications:) keyEquivalent:@"h"];\r
++                              [menuItem setKeyEquivalentModifierMask:(NSAlternateKeyMask | NSCommandKeyMask)];\r
++                              \r
++                              [appMenu addItemWithTitle:@"Show All" action:@selector(unhideAllApplications:) keyEquivalent:@""];\r
++                              \r
++                              menuItem = [appMenu addItemWithTitle:@"Quit Blender" action:@selector(terminate:) keyEquivalent:@"q"];\r
++                              [menuItem setKeyEquivalentModifierMask:NSCommandKeyMask];\r
++                              \r
++                              menuItem = [[NSMenuItem alloc] init];\r
++                              [menuItem setSubmenu:appMenu];\r
++                              \r
++                              [mainMenubar addItem:menuItem];\r
++                              [menuItem release];\r
++                              [NSApp performSelector:@selector(setAppleMenu:) withObject:appMenu]; //Needed for 10.5\r
++                              [appMenu release];\r
++                              \r
++                              //Create the window menu\r
++                              windowMenu = [[NSMenu alloc] initWithTitle:@"Window"];\r
++                              \r
++                              menuItem = [windowMenu addItemWithTitle:@"Minimize" action:@selector(performMiniaturize:) keyEquivalent:@"m"];\r
++                              [menuItem setKeyEquivalentModifierMask:NSCommandKeyMask];\r
++                              \r
++                              [windowMenu addItemWithTitle:@"Zoom" action:@selector(performZoom:) keyEquivalent:@""];\r
++                              \r
++                              menuItem = [[NSMenuItem alloc] init];\r
++                              [menuItem setSubmenu:windowMenu];\r
++                              \r
++                              [mainMenubar addItem:menuItem];\r
++                              [menuItem release];\r
++                              \r
++                              [NSApp setMainMenu:mainMenubar];\r
++                              [NSApp setWindowsMenu:windowMenu];\r
++                              [windowMenu release];\r
++                      }\r
++                      [NSApp finishLaunching];\r
++              }\r
++              if ([NSApp delegate] == nil) {\r
++                      CocoaAppDelegate *appDelegate = [[CocoaAppDelegate alloc] init];\r
++                      [appDelegate setSystemCocoa:this];\r
++                      [NSApp setDelegate:appDelegate];\r
++              }\r
++                              \r
++              [pool drain];\r
++    }\r
++    return success;\r
++}\r
++\r
++\r
++#pragma mark window management\r
++\r
++GHOST_TUns64 GHOST_SystemCocoa::getMilliSeconds() const\r
++{\r
++      //Cocoa equivalent exists in 10.6 ([[NSProcessInfo processInfo] systemUptime])\r
++      int mib[2];\r
++      struct timeval boottime;\r
++      size_t len;\r
++      \r
++      mib[0] = CTL_KERN;\r
++      mib[1] = KERN_BOOTTIME;\r
++      len = sizeof(struct timeval);\r
++      \r
++      sysctl(mib, 2, &boottime, &len, NULL, 0);\r
++\r
++      return ((boottime.tv_sec*1000)+(boottime.tv_usec/1000));\r
++}\r
++\r
++\r
++GHOST_TUns8 GHOST_SystemCocoa::getNumDisplays() const\r
++{\r
++      //Note that OS X supports monitor hot plug\r
++      // We do not support multiple monitors at the moment\r
++      NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];\r
++\r
++      GHOST_TUns8 count = [[NSScreen screens] count];\r
++\r
++      [pool drain];\r
++      return count;\r
++}\r
++\r
++\r
++void GHOST_SystemCocoa::getMainDisplayDimensions(GHOST_TUns32& width, GHOST_TUns32& height) const\r
++{\r
++      NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];\r
++      //Get visible frame, that is frame excluding dock and top menu bar\r
++      NSRect frame = [[NSScreen mainScreen] visibleFrame];\r
++      \r
++      //Returns max window contents (excluding title bar...)\r
++      NSRect contentRect = [NSWindow contentRectForFrameRect:frame\r
++                                                                                               styleMask:(NSTitledWindowMask | NSClosableWindowMask | NSMiniaturizableWindowMask)];\r
++      \r
++      width = contentRect.size.width;\r
++      height = contentRect.size.height;\r
++\r
++      [pool drain];\r
++}\r
++\r
++\r
++GHOST_IWindow* GHOST_SystemCocoa::createWindow(\r
++      const STR_String& title, \r
++      GHOST_TInt32 left,\r
++      GHOST_TInt32 top,\r
++      GHOST_TUns32 width,\r
++      GHOST_TUns32 height,\r
++      GHOST_TWindowState state,\r
++      GHOST_TDrawingContextType type,\r
++      bool stereoVisual,\r
++      const GHOST_TEmbedderWindowID parentWindow\r
++)\r
++{\r
++    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];\r
++      GHOST_IWindow* window = 0;\r
++      \r
++      //Get the available rect for including window contents\r
++      NSRect frame = [[NSScreen mainScreen] visibleFrame];\r
++      NSRect contentRect = [NSWindow contentRectForFrameRect:frame\r
++                                                                                               styleMask:(NSTitledWindowMask | NSClosableWindowMask | NSMiniaturizableWindowMask)];\r
++      \r
++      //Ensures window top left is inside this available rect\r
++      left = left > contentRect.origin.x ? left : contentRect.origin.x;\r
++      top = top > contentRect.origin.y ? top : contentRect.origin.y;\r
++      \r
++      window = new GHOST_WindowCocoa (this, title, left, top, width, height, state, type);\r
++\r
++    if (window) {\r
++        if (window->getValid()) {\r
++            // Store the pointer to the window \r
++            GHOST_ASSERT(m_windowManager, "m_windowManager not initialized");\r
++            m_windowManager->addWindow(window);\r
++            m_windowManager->setActiveWindow(window);\r
++                      //Need to tell window manager the new window is the active one (Cocoa does not send the event activate upon window creation)\r
++            pushEvent(new GHOST_Event(getMilliSeconds(), GHOST_kEventWindowActivate, window));\r
++                      pushEvent(new GHOST_Event(getMilliSeconds(), GHOST_kEventWindowSize, window));\r
++\r
++        }\r
++        else {\r
++                      GHOST_PRINT("GHOST_SystemCocoa::createWindow(): window invalid\n");\r
++            delete window;\r
++            window = 0;\r
++        }\r
++    }\r
++      else {\r
++              GHOST_PRINT("GHOST_SystemCocoa::createWindow(): could not create window\n");\r
++      }\r
++      [pool drain];\r
++    return window;\r
++}\r
++\r
++GHOST_TSuccess GHOST_SystemCocoa::beginFullScreen(const GHOST_DisplaySetting& setting, GHOST_IWindow** window, const bool stereoVisual)\r
++{     \r
++      GHOST_IWindow* currentWindow = m_windowManager->getActiveWindow();\r
++\r
++      *window = currentWindow;\r
++      \r
++      return currentWindow->setState(GHOST_kWindowStateFullScreen);\r
++}\r
++\r
++GHOST_TSuccess GHOST_SystemCocoa::endFullScreen(void)\r
++{     \r
++      GHOST_IWindow* currentWindow = m_windowManager->getActiveWindow();\r
++      \r
++      return currentWindow->setState(GHOST_kWindowStateNormal);\r
++}\r
++\r
++\r
++      \r
++\r
++GHOST_TSuccess GHOST_SystemCocoa::getCursorPosition(GHOST_TInt32& x, GHOST_TInt32& y) const\r
++{\r
++    NSPoint mouseLoc = [NSEvent mouseLocation];\r
++      \r
++    // Returns the mouse location in screen coordinates\r
++    x = (GHOST_TInt32)mouseLoc.x;\r
++    y = (GHOST_TInt32)mouseLoc.y;\r
++    return GHOST_kSuccess;\r
++}\r
++\r
++\r
++GHOST_TSuccess GHOST_SystemCocoa::setCursorPosition(GHOST_TInt32 x, GHOST_TInt32 y) const\r
++{\r
++      float xf=(float)x, yf=(float)y;\r
++      \r
++      //Quartz Display Services uses the old coordinates (top left origin)\r
++      yf = [[NSScreen mainScreen] frame].size.height -yf;\r
++      \r
++      //CGAssociateMouseAndMouseCursorPosition(false);\r
++      CGWarpMouseCursorPosition(CGPointMake(xf, yf));\r
++      //CGAssociateMouseAndMouseCursorPosition(true);\r
++\r
++    return GHOST_kSuccess;\r
++}\r
++\r
++\r
++GHOST_TSuccess GHOST_SystemCocoa::getModifierKeys(GHOST_ModifierKeys& keys) const\r
++{\r
++      unsigned int modifiers = [[NSApp currentEvent] modifierFlags];\r
++      //Direct query to modifierFlags can be used in 10.6\r
++\r
++    keys.set(GHOST_kModifierKeyCommand, (modifiers & NSCommandKeyMask) ? true : false);\r
++    keys.set(GHOST_kModifierKeyLeftAlt, (modifiers & NSAlternateKeyMask) ? true : false);\r
++    keys.set(GHOST_kModifierKeyLeftShift, (modifiers & NSShiftKeyMask) ? true : false);\r
++    keys.set(GHOST_kModifierKeyLeftControl, (modifiers & NSControlKeyMask) ? true : false);\r
++      \r
++    return GHOST_kSuccess;\r
++}\r
++\r
++GHOST_TSuccess GHOST_SystemCocoa::getButtons(GHOST_Buttons& buttons) const\r
++{\r
++      buttons.clear();\r
++    buttons.set(GHOST_kButtonMaskLeft, m_pressedMouseButtons & GHOST_kButtonMaskLeft);\r
++      buttons.set(GHOST_kButtonMaskRight, m_pressedMouseButtons & GHOST_kButtonMaskRight);\r
++      buttons.set(GHOST_kButtonMaskMiddle, m_pressedMouseButtons & GHOST_kButtonMaskMiddle);\r
++      buttons.set(GHOST_kButtonMaskButton4, m_pressedMouseButtons & GHOST_kButtonMaskButton4);\r
++      buttons.set(GHOST_kButtonMaskButton5, m_pressedMouseButtons & GHOST_kButtonMaskButton5);\r
++    return GHOST_kSuccess;\r
++}\r
++\r
++\r
++\r
++#pragma mark Event handlers\r
++\r
++/**\r
++ * The event queue polling function\r
++ */\r
++bool GHOST_SystemCocoa::processEvents(bool waitForEvent)\r
++{\r
++      bool anyProcessed = false;\r
++      NSEvent *event;\r
++      \r
++      //      SetMouseCoalescingEnabled(false, NULL);\r
++      //TODO : implement timer ??\r
++      \r
++      /*do {\r
++              GHOST_TimerManager* timerMgr = getTimerManager();\r
++              \r
++               if (waitForEvent) {\r
++               GHOST_TUns64 next = timerMgr->nextFireTime();\r
++               double timeOut;\r
++               \r
++               if (next == GHOST_kFireTimeNever) {\r
++               timeOut = kEventDurationForever;\r
++               } else {\r
++               timeOut = (double)(next - getMilliSeconds())/1000.0;\r
++               if (timeOut < 0.0)\r
++               timeOut = 0.0;\r
++               }\r
++               \r
++               ::ReceiveNextEvent(0, NULL, timeOut, false, &event);\r
++               }\r
++               \r
++               if (timerMgr->fireTimers(getMilliSeconds())) {\r
++               anyProcessed = true;\r
++               }\r
++               \r
++                       if (getFullScreen()) {\r
++               // Check if the full-screen window is dirty\r
++               GHOST_IWindow* window = m_windowManager->getFullScreenWindow();\r
++               if (((GHOST_WindowCarbon*)window)->getFullScreenDirty()) {\r
++               pushEvent( new GHOST_Event(getMilliSeconds(), GHOST_kEventWindowUpdate, window) );\r
++               anyProcessed = true;\r
++               }\r
++               }*/\r
++              \r
++              do {\r
++                      NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];\r
++                      event = [NSApp nextEventMatchingMask:NSAnyEventMask\r
++                                                                         untilDate:[NSDate distantPast]\r
++                                                                                inMode:NSDefaultRunLoopMode\r
++                                                                               dequeue:YES];\r
++                      if (event==nil) {\r
++                              [pool drain];\r
++                              break;\r
++                      }\r
++                      \r
++                      anyProcessed = true;\r
++                      \r
++                      switch ([event type]) {\r
++                              case NSKeyDown:\r
++                              case NSKeyUp:\r
++                              case NSFlagsChanged:\r
++                                      handleKeyEvent(event);\r
++                                      \r
++                                      /* Support system-wide keyboard shortcuts, like Exposé, ...) =>included in always NSApp sendEvent */\r
++                                      /*              if (([event modifierFlags] & NSCommandKeyMask) || [event type] == NSFlagsChanged) {\r
++                                       [NSApp sendEvent:event];\r
++                                       }*/\r
++                                      break;\r
++                                      \r
++                              case NSLeftMouseDown:\r
++                              case NSLeftMouseUp:\r
++                              case NSRightMouseDown:\r
++                              case NSRightMouseUp:\r
++                              case NSMouseMoved:\r
++                              case NSLeftMouseDragged:\r
++                              case NSRightMouseDragged:\r
++                              case NSScrollWheel:\r
++                              case NSOtherMouseDown:\r
++                              case NSOtherMouseUp:\r
++                              case NSOtherMouseDragged:                               \r
++                                      handleMouseEvent(event);\r
++                                      break;\r
++                                      \r
++                              case NSTabletPoint:\r
++                              case NSTabletProximity:\r
++                                      handleTabletEvent(event,[event type]);\r
++                                      break;\r
++                                      \r
++                                      /* Trackpad features, will need OS X 10.6 for implementation\r
++                                       case NSEventTypeGesture:\r
++                                       case NSEventTypeMagnify:\r
++                                       case NSEventTypeSwipe:\r
++                                       case NSEventTypeRotate:\r
++                                       case NSEventTypeBeginGesture:\r
++                                       case NSEventTypeEndGesture:\r
++                                       break; */\r
++                                      \r
++                                      /*Unused events\r
++                                       NSMouseEntered       = 8,\r
++                                       NSMouseExited        = 9,\r
++                                       NSAppKitDefined      = 13,\r
++                                       NSSystemDefined      = 14,\r
++                                       NSApplicationDefined = 15,\r
++                                       NSPeriodic           = 16,\r
++                                       NSCursorUpdate       = 17,*/\r
++                                      \r
++                              default:\r
++                                      break;\r
++                      }\r
++                      //Resend event to NSApp to ensure Mac wide events are handled\r
++                      [NSApp sendEvent:event];\r
++                      [pool drain];\r
++              } while (event!= nil);          \r
++      //} while (waitForEvent && !anyProcessed); Needed only for timer implementation\r
++      \r
++      \r
++      \r
++    return anyProcessed;\r
++}\r
++\r
++//Note: called from NSWindow delegate\r
++GHOST_TSuccess GHOST_SystemCocoa::handleWindowEvent(GHOST_TEventType eventType, GHOST_WindowCocoa* window)\r
++{\r
++      if (!validWindow(window)) {\r
++              return GHOST_kFailure;\r
++      }\r
++              switch(eventType) \r
++              {\r
++                      case GHOST_kEventWindowClose:\r
++                              pushEvent( new GHOST_Event(getMilliSeconds(), GHOST_kEventWindowClose, window) );\r
++                              break;\r
++                      case GHOST_kEventWindowActivate:\r
++                              m_windowManager->setActiveWindow(window);\r
++                              window->loadCursor(window->getCursorVisibility(), window->getCursorShape());\r
++                              pushEvent( new GHOST_Event(getMilliSeconds(), GHOST_kEventWindowActivate, window) );\r
++                              break;\r
++                      case GHOST_kEventWindowDeactivate:\r
++                              m_windowManager->setWindowInactive(window);\r
++                              pushEvent( new GHOST_Event(getMilliSeconds(), GHOST_kEventWindowDeactivate, window) );\r
++                              break;\r
++                      case GHOST_kEventWindowUpdate:\r
++                              pushEvent( new GHOST_Event(getMilliSeconds(), GHOST_kEventWindowUpdate, window) );\r
++                              break;\r
++                      case GHOST_kEventWindowSize:\r
++                              if (!m_ignoreWindowSizedMessages)\r
++                              {\r
++                                      window->updateDrawingContext();\r
++                                      pushEvent( new GHOST_Event(getMilliSeconds(), GHOST_kEventWindowSize, window) );\r
++                              }\r
++                              break;\r
++                      default:\r
++                              return GHOST_kFailure;\r
++                              break;\r
++              }\r
++      return GHOST_kSuccess;\r
++}\r
++\r
++GHOST_TUns8 GHOST_SystemCocoa::handleQuitRequest()\r
++{\r
++      //Check open windows if some changes are not saved\r
++      if (m_windowManager->getAnyModifiedState())\r
++      {\r
++              int shouldQuit = NSRunAlertPanel(@"Exit Blender", @"Some changes have not been saved. Do you really want to quit ?",\r
++                                                                               @"Cancel", @"Quit anyway", nil);\r
++              if (shouldQuit == NSAlertAlternateReturn)\r
++              {\r
++                      pushEvent( new GHOST_Event(getMilliSeconds(), GHOST_kEventQuit, NULL) );\r
++                      return GHOST_kExitNow;\r
++              }\r
++      }\r
++      else {\r
++              pushEvent( new GHOST_Event(getMilliSeconds(), GHOST_kEventQuit, NULL) );\r
++              return GHOST_kExitNow;\r
++      }\r
++      \r
++      return GHOST_kExitCancel;\r
++}\r
++\r
++\r
++GHOST_TSuccess GHOST_SystemCocoa::handleTabletEvent(void *eventPtr, short eventType)\r
++{\r
++      NSEvent *event = (NSEvent *)eventPtr;\r
++      GHOST_IWindow* window = m_windowManager->getActiveWindow();\r
++      GHOST_TabletData& ct=((GHOST_WindowCocoa*)window)->GetCocoaTabletData();\r
++      \r
++      switch (eventType) {\r
++              case NSTabletPoint:\r
++                      ct.Pressure = [event tangentialPressure];\r
++                      ct.Xtilt = [event tilt].x;\r
++                      ct.Ytilt = [event tilt].y;\r
++                      break;\r
++              \r
++              case NSTabletProximity:\r
++                      ct.Pressure = 0;\r
++                      ct.Xtilt = 0;\r
++                      ct.Ytilt = 0;\r
++                      if ([event isEnteringProximity])\r
++                      {\r
++                              //pointer is entering tablet area proximity\r
++                              switch ([event pointingDeviceType]) {\r
++                                      case NSPenPointingDevice:\r
++                                              ct.Active = GHOST_kTabletModeStylus;\r
++                                              break;\r
++                                      case NSEraserPointingDevice:\r
++                                              ct.Active = GHOST_kTabletModeEraser;\r
++                                              break;\r
++                                      case NSCursorPointingDevice:\r
++                                      case NSUnknownPointingDevice:\r
++                                      default:\r
++                                              ct.Active = GHOST_kTabletModeNone;\r
++                                              break;\r
++                              }\r
++                      } else {\r
++                              // pointer is leaving - return to mouse\r
++                              ct.Active = GHOST_kTabletModeNone;\r
++                      }\r
++                      break;\r
++              \r
++              default:\r
++                      GHOST_ASSERT(FALSE,"GHOST_SystemCocoa::handleTabletEvent : unknown event received");\r
++                      return GHOST_kFailure;\r
++                      break;\r
++      }\r
++      return GHOST_kSuccess;\r
++}\r
++\r
++\r
++GHOST_TSuccess GHOST_SystemCocoa::handleMouseEvent(void *eventPtr)\r
++{\r
++      NSEvent *event = (NSEvent *)eventPtr;\r
++    GHOST_Window* window = (GHOST_Window*)m_windowManager->getActiveWindow();\r
++      \r
++      if (!window) {\r
++              return GHOST_kFailure;\r
++      }\r
++      \r
++      switch ([event type])\r
++    {\r
++              case NSLeftMouseDown:\r
++              case NSRightMouseDown:\r
++              case NSOtherMouseDown:\r
++                      pushEvent(new GHOST_EventButton([event timestamp], GHOST_kEventButtonDown, window, convertButton([event buttonNumber])));\r
++                      //Handle tablet events combined with mouse events\r
++                      switch ([event subtype]) {\r
++                              case NX_SUBTYPE_TABLET_POINT:\r
++                                      handleTabletEvent(eventPtr, NSTabletPoint);\r
++                                      break;\r
++                              case NX_SUBTYPE_TABLET_PROXIMITY:\r
++                                      handleTabletEvent(eventPtr, NSTabletProximity);\r
++                                      break;\r
++                              default:\r
++                                      //No tablet event included : do nothing\r
++                                      break;\r
++                      }\r
++                      break;\r
++                                              \r
++              case NSLeftMouseUp:\r
++              case NSRightMouseUp:\r
++              case NSOtherMouseUp:\r
++                      pushEvent(new GHOST_EventButton([event timestamp], GHOST_kEventButtonUp, window, convertButton([event buttonNumber])));\r
++                      //Handle tablet events combined with mouse events\r
++                      switch ([event subtype]) {\r
++                              case NX_SUBTYPE_TABLET_POINT:\r
++                                      handleTabletEvent(eventPtr, NSTabletPoint);\r
++                                      break;\r
++                              case NX_SUBTYPE_TABLET_PROXIMITY:\r
++                                      handleTabletEvent(eventPtr, NSTabletProximity);\r
++                                      break;\r
++                              default:\r
++                                      //No tablet event included : do nothing\r
++                                      break;\r
++                      }\r
++                      break;\r
++                      \r
++              case NSLeftMouseDragged:\r
++              case NSRightMouseDragged:\r
++              case NSOtherMouseDragged:                               \r
++                      //Handle tablet events combined with mouse events\r
++                      switch ([event subtype]) {\r
++                              case NX_SUBTYPE_TABLET_POINT:\r
++                                      handleTabletEvent(eventPtr, NSTabletPoint);\r
++                                      break;\r
++                              case NX_SUBTYPE_TABLET_PROXIMITY:\r
++                                      handleTabletEvent(eventPtr, NSTabletProximity);\r
++                                      break;\r
++                              default:\r
++                                      //No tablet event included : do nothing\r
++                                      break;\r
++                      }\r
++              case NSMouseMoved:\r
++                      {\r
++                              if(window->getCursorWarp()) {\r
++                                      GHOST_TInt32 x_warp, y_warp, x_accum, y_accum;\r
++                                      \r
++                                      window->getCursorWarpPos(x_warp, y_warp);\r
++                                      \r
++                                      window->getCursorWarpAccum(x_accum, y_accum);\r
++                                      x_accum += [event deltaX];\r
++                                      y_accum += -[event deltaY]; //Strange Apple implementation (inverted coordinates for the deltaY) ...\r
++                                      window->setCursorWarpAccum(x_accum, y_accum);\r
++                                      \r
++                                      pushEvent(new GHOST_EventCursor([event timestamp], GHOST_kEventCursorMove, window, x_warp+x_accum, y_warp+y_accum));\r
++                              } \r
++                              else { //Normal cursor operation: send mouse position in window\r
++                                      NSPoint mousePos = [event locationInWindow];\r
++                                      pushEvent(new GHOST_EventCursor([event timestamp], GHOST_kEventCursorMove, window, mousePos.x, mousePos.y));\r
++                                      window->setCursorWarpAccum(0, 0); //Mouse motion occured between two cursor warps, so we can reset the delta counter\r
++                              }\r
++                              break;\r
++                      }\r
++                      \r
++              case NSScrollWheel:\r
++                      {\r
++                              GHOST_TInt32 delta;\r
++                              \r
++                              double deltaF = [event deltaY];\r
++                              if (deltaF == 0.0) break; //discard trackpad delta=0 events\r
++                              \r
++                              delta = deltaF > 0.0 ? 1 : -1;\r
++                              pushEvent(new GHOST_EventWheel([event timestamp], window, delta));\r
++                      }\r
++                      break;\r
++                      \r
++              default:\r
++                      return GHOST_kFailure;\r
++                      break;\r
++              }\r
++      \r
++      return GHOST_kSuccess;\r
++}\r
++\r
++\r
++GHOST_TSuccess GHOST_SystemCocoa::handleKeyEvent(void *eventPtr)\r
++{\r
++      NSEvent *event = (NSEvent *)eventPtr;\r
++      GHOST_IWindow* window = m_windowManager->getActiveWindow();\r
++      unsigned int modifiers;\r
++      NSString *characters;\r
++      GHOST_TKey keyCode;\r
++      unsigned char ascii;\r
++\r
++      /* Can happen, very rarely - seems to only be when command-H makes\r
++       * the window go away and we still get an HKey up. \r
++       */\r
++      if (!window) {\r
++              printf("\nW failure");\r
++              return GHOST_kFailure;\r
++      }\r
++      \r
++      switch ([event type]) {\r
++              case NSKeyDown:\r
++              case NSKeyUp:\r
++                      characters = [event characters];\r
++                      if ([characters length]) { //Check for dead keys\r
++                              keyCode = convertKey([event keyCode],\r
++                                                                       [[event charactersIgnoringModifiers] characterAtIndex:0]);\r
++                              ascii= convertRomanToLatin((char)[characters characterAtIndex:0]);\r
++                      } else {\r
++                              keyCode = convertKey([event keyCode],0);\r
++                              ascii= 0;\r
++                      }\r
++                      \r
++                      \r
++                      if ((keyCode == GHOST_kKeyQ) && (m_modifierMask & NSCommandKeyMask))\r
++                              break; //Cmd-Q is directly handled by Cocoa\r
++\r
++                      if ([event type] == NSKeyDown) {\r
++                              pushEvent( new GHOST_EventKey([event timestamp], GHOST_kEventKeyDown, window, keyCode, ascii) );\r
++                              //printf("\nKey pressed keyCode=%u ascii=%i %c",keyCode,ascii,ascii);\r
++                      } else {\r
++                              pushEvent( new GHOST_EventKey([event timestamp], GHOST_kEventKeyUp, window, keyCode, ascii) );\r
++                      }\r
++                      break;\r
++      \r
++              case NSFlagsChanged: \r
++                      modifiers = [event modifierFlags];\r
++                      if ((modifiers & NSShiftKeyMask) != (m_modifierMask & NSShiftKeyMask)) {\r
++                              pushEvent( new GHOST_EventKey([event timestamp], (modifiers & NSShiftKeyMask)?GHOST_kEventKeyDown:GHOST_kEventKeyUp, window, GHOST_kKeyLeftShift) );\r
++                      }\r
++                      if ((modifiers & NSControlKeyMask) != (m_modifierMask & NSControlKeyMask)) {\r
++                              pushEvent( new GHOST_EventKey([event timestamp], (modifiers & NSControlKeyMask)?GHOST_kEventKeyDown:GHOST_kEventKeyUp, window, GHOST_kKeyLeftControl) );\r
++                      }\r
++                      if ((modifiers & NSAlternateKeyMask) != (m_modifierMask & NSAlternateKeyMask)) {\r
++                              pushEvent( new GHOST_EventKey([event timestamp], (modifiers & NSAlternateKeyMask)?GHOST_kEventKeyDown:GHOST_kEventKeyUp, window, GHOST_kKeyLeftAlt) );\r
++                      }\r
++                      if ((modifiers & NSCommandKeyMask) != (m_modifierMask & NSCommandKeyMask)) {\r
++                              pushEvent( new GHOST_EventKey([event timestamp], (modifiers & NSCommandKeyMask)?GHOST_kEventKeyDown:GHOST_kEventKeyUp, window, GHOST_kKeyCommand) );\r
++                      }\r
++                      \r
++                      m_modifierMask = modifiers;\r
++                      break;\r
++                      \r
++              default:\r
++                      return GHOST_kFailure;\r
++                      break;\r
++      }\r
++      \r
++      return GHOST_kSuccess;\r
++}\r
++\r
++\r
++\r
++#pragma mark Clipboard get/set\r
++\r
++GHOST_TUns8* GHOST_SystemCocoa::getClipboard(bool selection) const\r
++{\r
++      GHOST_TUns8 * temp_buff;\r
++      size_t pastedTextSize;  \r
++      \r
++      NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];\r
++      \r
++      NSPasteboard *pasteBoard = [NSPasteboard generalPasteboard];\r
++      \r
++      if (pasteBoard == nil) {\r
++              [pool drain];\r
++              return NULL;\r
++      }\r
++      \r
++      NSArray *supportedTypes =\r
++              [NSArray arrayWithObjects: @"public.utf8-plain-text", nil];\r
++      \r
++      NSString *bestType = [[NSPasteboard generalPasteboard]\r
++                                                availableTypeFromArray:supportedTypes];\r
++      \r
++      if (bestType == nil) {\r
++              [pool drain];\r
++              return NULL;\r
++      }\r
++      \r
++      NSString * textPasted = [pasteBoard stringForType:@"public.utf8-plain-text"];\r
++\r
++      if (textPasted == nil) {\r
++              [pool drain];\r
++              return NULL;\r
++      }\r
++      \r
++      pastedTextSize = [textPasted lengthOfBytesUsingEncoding:NSUTF8StringEncoding];\r
++      \r
++      temp_buff = (GHOST_TUns8*) malloc(pastedTextSize+1); \r
++\r
++      if (temp_buff == NULL) {\r
++              [pool drain];\r
++              return NULL;\r
++      }\r
++      \r
++      strncpy((char*)temp_buff, [textPasted UTF8String], pastedTextSize);\r
++      \r
++      temp_buff[pastedTextSize] = '\0';\r
++      \r
++      [pool drain];\r
++\r
++      if(temp_buff) {\r
++              return temp_buff;\r
++      } else {\r
++              return NULL;\r
++      }\r
++}\r
++\r
++void GHOST_SystemCocoa::putClipboard(GHOST_TInt8 *buffer, bool selection) const\r
++{\r
++      NSString *textToCopy;\r
++      \r
++      if(selection) {return;} // for copying the selection, used on X11\r
++\r
++      NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];\r
++              \r
++      NSPasteboard *pasteBoard = [NSPasteboard generalPasteboard];\r
++      \r
++      if (pasteBoard == nil) {\r
++              [pool drain];\r
++              return;\r
++      }\r
++      \r
++      NSArray *supportedTypes = [NSArray arrayWithObject:@"public.utf8-plain-text"];\r
++      \r
++      [pasteBoard declareTypes:supportedTypes owner:nil];\r
++      \r
++      textToCopy = [NSString stringWithUTF8String:buffer];\r
++      \r
++      [pasteBoard setString:textToCopy forType:@"public.utf8-plain-text"];\r
++      \r
++      [pool drain];\r
++}\r
++\r
++#pragma mark Carbon stuff to remove\r
++\r
++#ifdef WITH_CARBON\r
++\r
++\r
++OSErr GHOST_SystemCarbon::sAEHandlerLaunch(const AppleEvent *event, AppleEvent *reply, SInt32 refCon)\r
++{\r
++      //GHOST_SystemCarbon* sys = (GHOST_SystemCarbon*) refCon;\r
++      \r
++      return noErr;\r
++}\r
++\r
++OSErr GHOST_SystemCarbon::sAEHandlerOpenDocs(const AppleEvent *event, AppleEvent *reply, SInt32 refCon)\r
++{\r
++      //GHOST_SystemCarbon* sys = (GHOST_SystemCarbon*) refCon;\r
++      AEDescList docs;\r
++      SInt32 ndocs;\r
++      OSErr err;\r
++      \r
++      err = AEGetParamDesc(event, keyDirectObject, typeAEList, &docs);\r
++      if (err != noErr)  return err;\r
++      \r
++      err = AECountItems(&docs, &ndocs);\r
++      if (err==noErr) {\r
++              int i;\r
++              \r
++              for (i=0; i<ndocs; i++) {\r
++                      FSSpec fss;\r
++                      AEKeyword kwd;\r
++                      DescType actType;\r
++                      Size actSize;\r
++                      \r
++                      err = AEGetNthPtr(&docs, i+1, typeFSS, &kwd, &actType, &fss, sizeof(fss), &actSize);\r
++                      if (err!=noErr)\r
++                              break;\r
++                      \r
++                      if (i==0) {\r
++                              FSRef fsref;\r
++                              \r
++                              if (FSpMakeFSRef(&fss, &fsref)!=noErr)\r
++                                      break;\r
++                              if (FSRefMakePath(&fsref, (UInt8*) g_firstFileBuf, sizeof(g_firstFileBuf))!=noErr)\r
++                                      break;\r
++                              \r
++                              g_hasFirstFile = true;\r
++                      }\r
++              }\r
++      }\r
++      \r
++      AEDisposeDesc(&docs);\r
++      \r
++      return err;\r
++}\r
++\r
++OSErr GHOST_SystemCarbon::sAEHandlerPrintDocs(const AppleEvent *event, AppleEvent *reply, SInt32 refCon)\r
++{\r
++      //GHOST_SystemCarbon* sys = (GHOST_SystemCarbon*) refCon;\r
++      \r
++      return noErr;\r
++}\r
++\r
++OSErr GHOST_SystemCarbon::sAEHandlerQuit(const AppleEvent *event, AppleEvent *reply, SInt32 refCon)\r
++{\r
++      GHOST_SystemCarbon* sys = (GHOST_SystemCarbon*) refCon;\r
++      \r
++      sys->pushEvent( new GHOST_Event(sys->getMilliSeconds(), GHOST_kEventQuit, NULL) );\r
++      \r
++      return noErr;\r
++}\r
+ #endif
index 0000000000000000000000000000000000000000,d6c154535a9f4e549c062bbd3d887c0dd42e6848..4037ebafc6460f945dd37c4a47250d1f4c764532
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,295 +1,295 @@@
 - * $Id$
+ /**
++ * $Id: GHOST_WindowCocoa.h 23789 2009-10-12 16:51:36Z damien78 $
+  * ***** BEGIN GPL LICENSE BLOCK *****
+  *
+  * This program is free software; you can redistribute it and/or
+  * modify it under the terms of the GNU General Public License
+  * as published by the Free Software Foundation; either version 2
+  * of the License, or (at your option) any later version.
+  *
+  * This program is distributed in the hope that it will be useful,
+  * but WITHOUT ANY WARRANTY; without even the implied warranty of
+  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  * GNU General Public License for more details.
+  *
+  * You should have received a copy of the GNU General Public License
+  * along with this program; if not, write to the Free Software Foundation,
+  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+  *
+  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
+  * All rights reserved.
+  *
+  * The Original Code is: all of this file.
+  *
+  * Contributor(s): none yet.
+  *
+  * ***** END GPL LICENSE BLOCK *****
+  */
+ /**
+  * @file      GHOST_WindowCocoa.h
+  * Declaration of GHOST_WindowCocoa class.
+  */
+ #ifndef _GHOST_WINDOW_COCOA_H_
+ #define _GHOST_WINDOW_COCOA_H_
+ #ifndef __APPLE__
+ #error Apple OSX only!
+ #endif // __APPLE__
+ #include "GHOST_Window.h"
+ #include "STR_String.h"
+ class GHOST_SystemCocoa;
+ /**
+  * Window on Mac OSX/Cocoa.
+  * Carbon windows have a size widget in the lower right corner of the window.
+  * To force it to be visible, the height of the client rectangle is reduced so
+  * that applications do not draw in that area. GHOST will manage that area
+  * which is called the gutter.
+  * When OpenGL contexts are active, GHOST will use AGL_BUFFER_RECT to prevent
+  * OpenGL drawing outside the reduced client rectangle.
+  * @author    Maarten Gribnau
+  * @date      May 23, 2001
+  */
+ class GHOST_WindowCocoa : public GHOST_Window {
+ public:
+       /**
+        * Constructor.
+        * Creates a new window and opens it.
+        * To check if the window was created properly, use the getValid() method.
+        * @param systemCocoa The associated system class to forward events to
+        * @param title         The text shown in the title bar of the window.
+        * @param left          The coordinate of the left edge of the window.
+        * @param top           The coordinate of the top edge of the window.
+        * @param width         The width the window.
+        * @param height        The height the window.
+        * @param state         The state the window is initially opened with.
+        * @param type          The type of drawing context installed in this window.
+        * @param stereoVisual  Stereo visual for quad buffered stereo.
+        */
+       GHOST_WindowCocoa(
+               GHOST_SystemCocoa *systemCocoa,
+               const STR_String& title,
+               GHOST_TInt32 left,
+               GHOST_TInt32 top,
+               GHOST_TUns32 width,
+               GHOST_TUns32 height,
+               GHOST_TWindowState state,
+               GHOST_TDrawingContextType type = GHOST_kDrawingContextTypeNone,
+               const bool stereoVisual = false
+       );
+       /**
+        * Destructor.
+        * Closes the window and disposes resources allocated.
+        */
+       virtual ~GHOST_WindowCocoa();
+       /**
+        * Returns indication as to whether the window is valid.
+        * @return The validity of the window.
+        */
+       virtual bool getValid() const;
+       /**
+        * Sets the title displayed in the title bar.
+        * @param title The title to display in the title bar.
+        */
+       virtual void setTitle(const STR_String& title);
+       /**
+        * Returns the title displayed in the title bar.
+        * @param title The title displayed in the title bar.
+        */
+       virtual void getTitle(STR_String& title) const;
+       /**
+        * Returns the window rectangle dimensions.
+        * The dimensions are given in screen coordinates that are relative to the upper-left corner of the screen. 
+        * @param bounds The bounding rectangle of the window.
+        */
+       virtual void getWindowBounds(GHOST_Rect& bounds) const;
+       
+       /**
+        * Returns the client rectangle dimensions.
+        * The left and top members of the rectangle are always zero.
+        * @param bounds The bounding rectangle of the cleient area of the window.
+        */
+       virtual void getClientBounds(GHOST_Rect& bounds) const;
+       /**
+        * Resizes client rectangle width.
+        * @param width The new width of the client area of the window.
+        */
+       virtual GHOST_TSuccess setClientWidth(GHOST_TUns32 width);
+       /**
+        * Resizes client rectangle height.
+        * @param height The new height of the client area of the window.
+        */
+       virtual GHOST_TSuccess setClientHeight(GHOST_TUns32 height);
+       /**
+        * Resizes client rectangle.
+        * @param width         The new width of the client area of the window.
+        * @param height        The new height of the client area of the window.
+        */
+       virtual GHOST_TSuccess setClientSize(GHOST_TUns32 width, GHOST_TUns32 height);
+       /**
+        * Returns the state of the window (normal, minimized, maximized).
+        * @return The state of the window.
+        */
+       virtual GHOST_TWindowState getState() const;
+       /**
+        * Sets the window "modified" status, indicating unsaved changes
+        * @param isUnsavedChanges Unsaved changes or not
+        * @return Indication of success.
+        */
+       virtual GHOST_TSuccess setModifiedState(bool isUnsavedChanges);
+       
+       /**
+        * Converts a point in screen coordinates to client rectangle coordinates
+        * @param inX   The x-coordinate on the screen.
+        * @param inY   The y-coordinate on the screen.
+        * @param outX  The x-coordinate in the client rectangle.
+        * @param outY  The y-coordinate in the client rectangle.
+        */
+       virtual void screenToClient(GHOST_TInt32 inX, GHOST_TInt32 inY, GHOST_TInt32& outX, GHOST_TInt32& outY) const;
+       /**
+        * Converts a point in screen coordinates to client rectangle coordinates
+        * @param inX   The x-coordinate in the client rectangle.
+        * @param inY   The y-coordinate in the client rectangle.
+        * @param outX  The x-coordinate on the screen.
+        * @param outY  The y-coordinate on the screen.
+        */
+       virtual void clientToScreen(GHOST_TInt32 inX, GHOST_TInt32 inY, GHOST_TInt32& outX, GHOST_TInt32& outY) const;
+       /**
+        * Sets the state of the window (normal, minimized, maximized).
+        * @param state The state of the window.
+        * @return Indication of success.
+        */
+       virtual GHOST_TSuccess setState(GHOST_TWindowState state);
+       /**
+        * Sets the order of the window (bottom, top).
+        * @param order The order of the window.
+        * @return Indication of success.
+        */
+       virtual GHOST_TSuccess setOrder(GHOST_TWindowOrder order);
+       /**
+        * Swaps front and back buffers of a window.
+        * @return      A boolean success indicator.
+        */
+       virtual GHOST_TSuccess swapBuffers();
+       /**
+        * Updates the drawing context of this window. Needed
+        * whenever the window is changed.
+        * @return Indication of success.
+        */
+       GHOST_TSuccess updateDrawingContext();
+       /**
+        * Activates the drawing context of this window.
+        * @return      A boolean success indicator.
+        */
+       virtual GHOST_TSuccess activateDrawingContext();
+       virtual void loadCursor(bool visible, GHOST_TStandardCursor cursor) const;
+     
+       const GHOST_TabletData* GetTabletData()
+       { return &m_tablet; }
+       GHOST_TabletData& GetCocoaTabletData()
+       { return m_tablet; }
+ protected:
+       /**
+        * Tries to install a rendering context in this window.
+        * @param type  The type of rendering context installed.
+        * @return Indication as to whether installation has succeeded.
+        */
+       virtual GHOST_TSuccess installDrawingContext(GHOST_TDrawingContextType type);
+       /**
+        * Removes the current drawing context.
+        * @return Indication as to whether removal has succeeded.
+        */
+       virtual GHOST_TSuccess removeDrawingContext();
+     
+       /**
+        * Invalidates the contents of this window.
+          * @return Indication of success.
+        */
+       virtual GHOST_TSuccess invalidate();
+       /**
+        * Sets the cursor visibility on the window using
+        * native window system calls.
+        */
+       virtual GHOST_TSuccess setWindowCursorVisibility(bool visible);
+       
+       /**
+        * Sets the cursor warp accumulator. Overriden for workaround due to Cocoa next event after cursor set giving delta values non zero
+        */
+       inline virtual bool setCursorWarpAccum(GHOST_TInt32 x, GHOST_TInt32 y);
+       
+       /**
+        * Sets the cursor grab on the window using
+        * native window system calls.
+        * @param warp  Only used when grab is enabled, hides the mouse and allows gragging outside the screen.
+        */
+       virtual GHOST_TSuccess setWindowCursorGrab(bool grab, bool warp, bool restore);
+       
+       /**
+        * Sets the cursor shape on the window using
+        * native window system calls.
+        */
+       virtual GHOST_TSuccess setWindowCursorShape(GHOST_TStandardCursor shape);
+       /**
+        * Sets the cursor shape on the window using
+        * native window system calls.
+        */
+       virtual GHOST_TSuccess setWindowCustomCursorShape(GHOST_TUns8 *bitmap, GHOST_TUns8 *mask,
+                                       int sizex, int sizey, int hotX, int hotY, int fg_color, int bg_color);
+                                       
+       virtual GHOST_TSuccess setWindowCustomCursorShape(GHOST_TUns8 bitmap[16][2], GHOST_TUns8 mask[16][2], int hotX, int hotY);
+     
+       /** The window containing the OpenGL view */
+     NSWindow *m_window;
+       
+       /** The openGL view */
+       NSOpenGLView *m_openGLView; 
+     
+       /** The opgnGL drawing context */
+       NSOpenGLContext *m_openGLContext;
+       
+       /** The mother SystemCocoa class to send events */
+       GHOST_SystemCocoa *m_systemCocoa;
+                       
+       /** The first created OpenGL context (for sharing display lists) */
+       static NSOpenGLContext *s_firstOpenGLcontext;
+       
+       NSCursor*       m_customCursor;
+       GHOST_TabletData m_tablet;
+     
+     /**
+      * The width/height of the size rectangle in the lower right corner of a 
+      * Mac/Carbon window. This is also the height of the gutter area.
+      */
+ #ifdef GHOST_DRAW_CARBON_GUTTER
+     static const GHOST_TInt32 s_sizeRectSize;
+ #endif // GHOST_DRAW_CARBON_GUTTER
+ };
+ #endif // _GHOST_WINDOW_COCOA_H_
index 0000000000000000000000000000000000000000,e41c773a4c3fb781a7c49a385e189e6fcf1eb17a..a2b146c1e33e4ae7866af1a181f50e48cc5ee0ee
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,1028 +1,1028 @@@
 -/**
 - * $Id$
 - * ***** BEGIN GPL LICENSE BLOCK *****
 - *
 - * This program is free software; you can redistribute it and/or
 - * modify it under the terms of the GNU General Public License
 - * as published by the Free Software Foundation; either version 2
 - * of the License, or (at your option) any later version.
 - *
 - * This program is distributed in the hope that it will be useful,
 - * but WITHOUT ANY WARRANTY; without even the implied warranty of
 - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 - * GNU General Public License for more details.
 - *
 - * You should have received a copy of the GNU General Public License
 - * along with this program; if not, write to the Free Software Foundation,
 - * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 - *
 - * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
 - * All rights reserved.
 - *
 - * The Original Code is: all of this file.
 - *
 - * Contributor(s):    Maarten Gribnau 05/2001
 -                                      Damien Plisson 10/2009
 - *
 - * ***** END GPL LICENSE BLOCK *****
 - */
 -
 -#include <Cocoa/Cocoa.h>
 -
 -#ifndef MAC_OS_X_VERSION_10_6
 -//Use of the SetSystemUIMode function (64bit compatible)
 -#include <Carbon/Carbon.h>
 -#endif
 -
 -#include "GHOST_WindowCocoa.h"
 -#include "GHOST_SystemCocoa.h"
 -#include "GHOST_Debug.h"
 -
 -
 -// Pixel Format Attributes for the windowed NSOpenGLContext
 -static NSOpenGLPixelFormatAttribute pixelFormatAttrsWindow[] =
 -{
 -      NSOpenGLPFADoubleBuffer,
 -      NSOpenGLPFAAccelerated,
 -      //NSOpenGLPFAAllowOfflineRenderers,   // Removed to allow 10.4 builds, and 2 GPUs rendering is not used anyway
 -      NSOpenGLPFADepthSize, (NSOpenGLPixelFormatAttribute) 32,
 -      (NSOpenGLPixelFormatAttribute) 0
 -};
 -
 -#pragma mark Cocoa window delegate object
 -
 -@interface CocoaWindowDelegate : NSObject
 -{
 -      GHOST_SystemCocoa *systemCocoa;
 -      GHOST_WindowCocoa *associatedWindow;
 -}
 -
 -- (void)setSystemAndWindowCocoa:(const GHOST_SystemCocoa *)sysCocoa windowCocoa:(GHOST_WindowCocoa *)winCocoa;
 -- (void)windowWillClose:(NSNotification *)notification;
 -- (void)windowDidBecomeKey:(NSNotification *)notification;
 -- (void)windowDidResignKey:(NSNotification *)notification;
 -- (void)windowDidUpdate:(NSNotification *)notification;
 -- (void)windowDidResize:(NSNotification *)notification;
 -@end
 -
 -@implementation CocoaWindowDelegate : NSObject
 -- (void)setSystemAndWindowCocoa:(GHOST_SystemCocoa *)sysCocoa windowCocoa:(GHOST_WindowCocoa *)winCocoa
 -{
 -      systemCocoa = sysCocoa;
 -      associatedWindow = winCocoa;
 -}
 -
 -- (void)windowWillClose:(NSNotification *)notification
 -{
 -      systemCocoa->handleWindowEvent(GHOST_kEventWindowClose, associatedWindow);
 -}
 -
 -- (void)windowDidBecomeKey:(NSNotification *)notification
 -{
 -      systemCocoa->handleWindowEvent(GHOST_kEventWindowActivate, associatedWindow);
 -}
 -
 -- (void)windowDidResignKey:(NSNotification *)notification
 -{
 -      //The window is no more key when its own view becomes fullscreen
 -      //but ghost doesn't know the view/window difference, so hide this fact
 -      if (associatedWindow->getState() != GHOST_kWindowStateFullScreen)
 -              systemCocoa->handleWindowEvent(GHOST_kEventWindowDeactivate, associatedWindow);
 -}
 -
 -- (void)windowDidUpdate:(NSNotification *)notification
 -{
 -      systemCocoa->handleWindowEvent(GHOST_kEventWindowUpdate, associatedWindow);
 -}
 -
 -- (void)windowDidResize:(NSNotification *)notification
 -{
 -      systemCocoa->handleWindowEvent(GHOST_kEventWindowSize, associatedWindow);
 -}
 -@end
 -
 -#pragma mark NSWindow subclass
 -//We need to subclass it to tell that even borderless (fullscreen), it can become key (receive user events)
 -@interface CocoaWindow: NSWindow
 -{
 -
 -}
 --(BOOL)canBecomeKeyWindow;
 -
 -@end
 -@implementation CocoaWindow
 -
 --(BOOL)canBecomeKeyWindow
 -{
 -      return YES;
 -}
 -
 -@end
 -
 -
 -
 -#pragma mark NSOpenGLView subclass
 -//We need to subclass it in order to give Cocoa the feeling key events are trapped
 -@interface CocoaOpenGLView : NSOpenGLView
 -{
 -      
 -}
 -@end
 -@implementation CocoaOpenGLView
 -
 -- (BOOL)acceptsFirstResponder
 -{
 -    return YES;
 -}
 -
 -//The trick to prevent Cocoa from complaining (beeping)
 -- (void)keyDown:(NSEvent *)theEvent
 -{}
 -
 -- (BOOL)isOpaque
 -{
 -    return YES;
 -}
 -
 -@end
 -
 -
 -#pragma mark initialization / finalization
 -
 -NSOpenGLContext* GHOST_WindowCocoa::s_firstOpenGLcontext = nil;
 -
 -GHOST_WindowCocoa::GHOST_WindowCocoa(
 -      GHOST_SystemCocoa *systemCocoa,
 -      const STR_String& title,
 -      GHOST_TInt32 left,
 -      GHOST_TInt32 top,
 -      GHOST_TUns32 width,
 -      GHOST_TUns32 height,
 -      GHOST_TWindowState state,
 -      GHOST_TDrawingContextType type,
 -      const bool stereoVisual
 -) :
 -      GHOST_Window(title, left, top, width, height, state, GHOST_kDrawingContextTypeNone),
 -      m_customCursor(0)
 -{
 -      m_systemCocoa = systemCocoa;
 -      m_fullScreen = false;
 -      
 -      NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 -      
 -
 -      //Creates the window
 -      NSRect rect;
 -      
 -      rect.origin.x = left;
 -      rect.origin.y = top;
 -      rect.size.width = width;
 -      rect.size.height = height;
 -      
 -      m_window = [[CocoaWindow alloc] initWithContentRect:rect
 -                                                                                 styleMask:NSTitledWindowMask | NSClosableWindowMask | NSResizableWindowMask | NSMiniaturizableWindowMask
 -                                                                                       backing:NSBackingStoreBuffered defer:NO];
 -      if (m_window == nil) {
 -              [pool drain];
 -              return;
 -      }
 -      
 -      setTitle(title);
 -      
 -                      
 -      //Creates the OpenGL View inside the window
 -      NSOpenGLPixelFormat *pixelFormat =
 -      [[NSOpenGLPixelFormat alloc] initWithAttributes:pixelFormatAttrsWindow];
 -      
 -      m_openGLView = [[CocoaOpenGLView alloc] initWithFrame:rect
 -                                                                                               pixelFormat:pixelFormat];
 -      
 -      [pixelFormat release];
 -      
 -      m_openGLContext = [m_openGLView openGLContext]; //This context will be replaced by the proper one just after
 -      
 -      [m_window setContentView:m_openGLView];
 -      [m_window setInitialFirstResponder:m_openGLView];
 -      
 -      [m_window setReleasedWhenClosed:NO]; //To avoid bad pointer exception in case of user closing the window
 -      
 -      [m_window makeKeyAndOrderFront:nil];
 -      
 -      setDrawingContextType(type);
 -      updateDrawingContext();
 -      activateDrawingContext();
 -      
 -      m_tablet.Active = GHOST_kTabletModeNone;
 -      
 -      CocoaWindowDelegate *windowDelegate = [[CocoaWindowDelegate alloc] init];
 -      [windowDelegate setSystemAndWindowCocoa:systemCocoa windowCocoa:this];
 -      [m_window setDelegate:windowDelegate];
 -      
 -      [m_window setAcceptsMouseMovedEvents:YES];
 -      
 -      if (state == GHOST_kWindowStateFullScreen)
 -              setState(GHOST_kWindowStateFullScreen);
 -              
 -      [pool drain];
 -}
 -
 -
 -GHOST_WindowCocoa::~GHOST_WindowCocoa()
 -{
 -      if (m_customCursor) delete m_customCursor;
 -
 -    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 -      [m_openGLView release];
 -      
 -      if (m_window) {
 -              [m_window close];
 -              [[m_window delegate] release];
 -              [m_window release];
 -              m_window = nil;
 -      }
 -      
 -      //Check for other blender opened windows and make the frontmost key
 -      NSArray *windowsList = [NSApp orderedWindows];
 -      if ([windowsList count]) {
 -              [[windowsList objectAtIndex:0] makeKeyAndOrderFront:nil];
 -      }
 -      [pool drain];
 -}
 -
 -#pragma mark accessors
 -
 -bool GHOST_WindowCocoa::getValid() const
 -{
 -    bool valid;
 -    if (!m_fullScreen) {
 -        valid = (m_window != 0); //&& ::IsValidWindowPtr(m_windowRef);
 -    }
 -    else {
 -        valid = true;
 -    }
 -    return valid;
 -}
 -
 -
 -void GHOST_WindowCocoa::setTitle(const STR_String& title)
 -{
 -    GHOST_ASSERT(getValid(), "GHOST_WindowCocoa::setTitle(): window invalid")
 -      NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 -
 -      NSString *windowTitle = [[NSString alloc] initWithUTF8String:title];
 -      
 -      //Set associated file if applicable
 -      if ([windowTitle hasPrefix:@"Blender"])
 -      {
 -              NSRange fileStrRange;
 -              NSString *associatedFileName;
 -              int len;
 -              
 -              fileStrRange.location = [windowTitle rangeOfString:@"["].location+1;
 -              len = [windowTitle rangeOfString:@"]"].location - fileStrRange.location;
 -      
 -              if (len >0)
 -              {
 -                      fileStrRange.length = len;
 -                      associatedFileName = [windowTitle substringWithRange:fileStrRange];
 -                      @try {
 -                              [m_window setRepresentedFilename:associatedFileName];
 -                      }
 -                      @catch (NSException * e) {
 -                              printf("\nInvalid file path given in window title");
 -                      }
 -                      [m_window setTitle:[associatedFileName lastPathComponent]];
 -              }
 -              else {
 -                      [m_window setTitle:windowTitle];
 -                      [m_window setRepresentedFilename:@""];
 -              }
 -
 -      } else {
 -              [m_window setTitle:windowTitle];
 -              [m_window setRepresentedFilename:@""];
 -      }
 -
 -      
 -      [windowTitle release];
 -      [pool drain];
 -}
 -
 -
 -void GHOST_WindowCocoa::getTitle(STR_String& title) const
 -{
 -    GHOST_ASSERT(getValid(), "GHOST_WindowCocoa::getTitle(): window invalid")
 -
 -      NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 -
 -      NSString *windowTitle = [m_window title];
 -
 -      if (windowTitle != nil) {
 -              title = [windowTitle UTF8String];               
 -      }
 -      
 -      [pool drain];
 -}
 -
 -
 -void GHOST_WindowCocoa::getWindowBounds(GHOST_Rect& bounds) const
 -{
 -      NSRect rect;
 -      GHOST_ASSERT(getValid(), "GHOST_WindowCocoa::getWindowBounds(): window invalid")
 -
 -      NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 -      
 -      NSRect screenSize = [[m_window screen] visibleFrame];
 -
 -      rect = [m_window frame];
 -
 -      bounds.m_b = screenSize.size.height - (rect.origin.y -screenSize.origin.y);
 -      bounds.m_l = rect.origin.x -screenSize.origin.x;
 -      bounds.m_r = rect.origin.x-screenSize.origin.x + rect.size.width;
 -      bounds.m_t = screenSize.size.height - (rect.origin.y + rect.size.height -screenSize.origin.y);
 -      
 -      [pool drain];
 -}
 -
 -
 -void GHOST_WindowCocoa::getClientBounds(GHOST_Rect& bounds) const
 -{
 -      NSRect rect;
 -      GHOST_ASSERT(getValid(), "GHOST_WindowCocoa::getClientBounds(): window invalid")
 -      
 -      NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 -      
 -      if (!m_fullScreen)
 -      {
 -              NSRect screenSize = [[m_window screen] visibleFrame];
 -
 -              //Max window contents as screen size (excluding title bar...)
 -              NSRect contentRect = [CocoaWindow contentRectForFrameRect:screenSize
 -                                                                                                       styleMask:(NSTitledWindowMask | NSClosableWindowMask | NSMiniaturizableWindowMask | NSResizableWindowMask)];
 -
 -              rect = [m_window contentRectForFrameRect:[m_window frame]];
 -              
 -              bounds.m_b = contentRect.size.height - (rect.origin.y -contentRect.origin.y);
 -              bounds.m_l = rect.origin.x -contentRect.origin.x;
 -              bounds.m_r = rect.origin.x-contentRect.origin.x + rect.size.width;
 -              bounds.m_t = contentRect.size.height - (rect.origin.y + rect.size.height -contentRect.origin.y);
 -      }
 -      else {
 -              NSRect screenSize = [[m_window screen] frame];
 -              
 -              bounds.m_b = screenSize.origin.y + screenSize.size.height;
 -              bounds.m_l = screenSize.origin.x;
 -              bounds.m_r = screenSize.origin.x + screenSize.size.width;
 -              bounds.m_t = screenSize.origin.y;
 -      }
 -      [pool drain];
 -}
 -
 -
 -GHOST_TSuccess GHOST_WindowCocoa::setClientWidth(GHOST_TUns32 width)
 -{
 -      GHOST_ASSERT(getValid(), "GHOST_WindowCocoa::setClientWidth(): window invalid")
 -      GHOST_Rect cBnds, wBnds;
 -      getClientBounds(cBnds);
 -      if (((GHOST_TUns32)cBnds.getWidth()) != width) {
 -              NSSize size;
 -              size.width=width;
 -              size.height=cBnds.getHeight();
 -              [m_window setContentSize:size];
 -      }
 -      return GHOST_kSuccess;
 -}
 -
 -
 -GHOST_TSuccess GHOST_WindowCocoa::setClientHeight(GHOST_TUns32 height)
 -{
 -      GHOST_ASSERT(getValid(), "GHOST_WindowCocoa::setClientHeight(): window invalid")
 -      GHOST_Rect cBnds, wBnds;
 -      getClientBounds(cBnds);
 -      if (((GHOST_TUns32)cBnds.getHeight()) != height) {
 -              NSSize size;
 -              size.width=cBnds.getWidth();
 -              size.height=height;
 -              [m_window setContentSize:size];
 -      }
 -      return GHOST_kSuccess;
 -}
 -
 -
 -GHOST_TSuccess GHOST_WindowCocoa::setClientSize(GHOST_TUns32 width, GHOST_TUns32 height)
 -{
 -      GHOST_ASSERT(getValid(), "GHOST_WindowCocoa::setClientSize(): window invalid")
 -      GHOST_Rect cBnds, wBnds;
 -      getClientBounds(cBnds);
 -      if ((((GHOST_TUns32)cBnds.getWidth()) != width) ||
 -          (((GHOST_TUns32)cBnds.getHeight()) != height)) {
 -              NSSize size;
 -              size.width=width;
 -              size.height=height;
 -              [m_window setContentSize:size];
 -      }
 -      return GHOST_kSuccess;
 -}
 -
 -
 -GHOST_TWindowState GHOST_WindowCocoa::getState() const
 -{
 -      GHOST_ASSERT(getValid(), "GHOST_WindowCocoa::getState(): window invalid")
 -      NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 -      GHOST_TWindowState state;
 -      if (m_fullScreen) {
 -              state = GHOST_kWindowStateFullScreen;
 -      } 
 -      else if ([m_window isMiniaturized]) {
 -              state = GHOST_kWindowStateMinimized;
 -      }
 -      else if ([m_window isZoomed]) {
 -              state = GHOST_kWindowStateMaximized;
 -      }
 -      else {
 -              state = GHOST_kWindowStateNormal;
 -      }
 -      [pool drain];
 -      return state;
 -}
 -
 -
 -void GHOST_WindowCocoa::screenToClient(GHOST_TInt32 inX, GHOST_TInt32 inY, GHOST_TInt32& outX, GHOST_TInt32& outY) const
 -{
 -      GHOST_ASSERT(getValid(), "GHOST_WindowCocoa::screenToClient(): window invalid")
 -      
 -      NSPoint screenCoord;
 -      NSPoint baseCoord;
 -      
 -      screenCoord.x = inX;
 -      screenCoord.y = inY;
 -      
 -      baseCoord = [m_window convertScreenToBase:screenCoord];
 -      
 -      outX = baseCoord.x;
 -      outY = baseCoord.y;
 -}
 -
 -
 -void GHOST_WindowCocoa::clientToScreen(GHOST_TInt32 inX, GHOST_TInt32 inY, GHOST_TInt32& outX, GHOST_TInt32& outY) const
 -{
 -      GHOST_ASSERT(getValid(), "GHOST_WindowCocoa::clientToScreen(): window invalid")
 -      
 -      NSPoint screenCoord;
 -      NSPoint baseCoord;
 -      
 -      baseCoord.x = inX;
 -      baseCoord.y = inY;
 -      
 -      screenCoord = [m_window convertBaseToScreen:baseCoord];
 -      
 -      outX = screenCoord.x;
 -      outY = screenCoord.y;
 -}
 -
 -/**
 - * @note Fullscreen switch is not actual fullscreen with display capture. As this capture removes all OS X window manager features.
 - * Instead, the menu bar and the dock are hidden, and the window is made borderless and enlarged.
 - * Thus, process switch, exposé, spaces, ... still work in fullscreen mode
 - */
 -GHOST_TSuccess GHOST_WindowCocoa::setState(GHOST_TWindowState state)
 -{
 -      GHOST_ASSERT(getValid(), "GHOST_WindowCocoa::setState(): window invalid")
 -    switch (state) {
 -              case GHOST_kWindowStateMinimized:
 -            [m_window miniaturize:nil];
 -            break;
 -              case GHOST_kWindowStateMaximized:
 -                      [m_window zoom:nil];
 -                      break;
 -              
 -              case GHOST_kWindowStateFullScreen:
 -                      if (!m_fullScreen)
 -                      {
 -                              NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 -                      
 -                              //This status change needs to be done before Cocoa call to enter fullscreen mode
 -                              //to give window delegate hint not to forward its deactivation to ghost wm that doesn't know view/window difference
 -                              m_fullScreen = true;
 -
 -#ifdef MAC_OS_X_VERSION_10_6
 -                              //10.6 provides Cocoa functions to autoshow menu bar, and to change a window style
 -                              //Hide menu & dock if needed
 -                              if ([[m_window screen] isEqual:[NSScreen mainScreen]])
 -                              {
 -                                      [NSApp setPresentationOptions:(NSApplicationPresentationHideDock | NSApplicationPresentationAutoHideMenuBar)];
 -                              }
 -                              //Make window borderless and enlarge it
 -                              [m_window setStyleMask:NSBorderlessWindowMask];
 -                              [m_window setFrame:[[m_window screen] frame] display:YES];
 -#else
 -                              //With 10.5, we need to create a new window to change its style to borderless
 -                              //Hide menu & dock if needed
 -                              if ([[m_window screen] isEqual:[NSScreen mainScreen]])
 -                              {
 -                                      //Cocoa function in 10.5 does not allow to set the menu bar in auto-show mode [NSMenu setMenuBarVisible:NO];
 -                                      //One of the very few 64bit compatible Carbon function
 -                                      SetSystemUIMode(kUIModeAllHidden,kUIOptionAutoShowMenuBar);
 -                              }
 -                              //Create a fullscreen borderless window
 -                              CocoaWindow *tmpWindow = [[CocoaWindow alloc]
 -                                                                                initWithContentRect:[[m_window screen] frame]
 -                                                                                styleMask:NSBorderlessWindowMask
 -                                                                                backing:NSBackingStoreBuffered
 -                                                                                defer:YES];
 -                              //Copy current window parameters
 -                              [tmpWindow setTitle:[m_window title]];
 -                              [tmpWindow setRepresentedFilename:[m_window representedFilename]];
 -                              [tmpWindow setReleasedWhenClosed:NO];
 -                              [tmpWindow setAcceptsMouseMovedEvents:YES];
 -                              [tmpWindow setDelegate:[m_window delegate]];
 -                              
 -                              //Assign the openGL view to the new window
 -                              [tmpWindow setContentView:m_openGLView];
 -                              
 -                              //Show the new window
 -                              [tmpWindow makeKeyAndOrderFront:nil];
 -                              //Close and release old window
 -                              [m_window setDelegate:nil]; // To avoid the notification of "window closed" event
 -                              [m_window close];
 -                              [m_window release];
 -                              m_window = tmpWindow;
 -#endif
 -                      
 -                              //Tell WM of view new size
 -                              m_systemCocoa->handleWindowEvent(GHOST_kEventWindowSize, this);
 -                              
 -                              [pool drain];
 -                              }
 -                      break;
 -              case GHOST_kWindowStateNormal:
 -        default:
 -                      if (m_fullScreen)
 -                      {
 -                              NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 -                              m_fullScreen = false;
 -
 -                              //Exit fullscreen
 -#ifdef MAC_OS_X_VERSION_10_6
 -                              //Show again menu & dock if needed
 -                              if ([[m_window screen] isEqual:[NSScreen mainScreen]])
 -                              {
 -                                      [NSApp setPresentationOptions:NSApplicationPresentationDefault];
 -                              }
 -                              //Make window normal and resize it
 -                              [m_window setStyleMask:(NSTitledWindowMask | NSClosableWindowMask | NSMiniaturizableWindowMask | NSResizableWindowMask)];
 -                              [m_window setFrame:[[m_window screen] visibleFrame] display:YES];
 -#else
 -                              //With 10.5, we need to create a new window to change its style to borderless
 -                              //Show menu & dock if needed
 -                              if ([[m_window screen] isEqual:[NSScreen mainScreen]])
 -                              {
 -                                      //Cocoa function in 10.5 does not allow to set the menu bar in auto-show mode [NSMenu setMenuBarVisible:YES];
 -                                      SetSystemUIMode(kUIModeNormal, 0); //One of the very few 64bit compatible Carbon function
 -                              }
 -                              //Create a fullscreen borderless window
 -                              CocoaWindow *tmpWindow = [[CocoaWindow alloc]
 -                                                                                initWithContentRect:[[m_window screen] frame]
 -                                                                                                      styleMask:(NSTitledWindowMask | NSClosableWindowMask | NSMiniaturizableWindowMask | NSResizableWindowMask)
 -                                                                                                        backing:NSBackingStoreBuffered
 -                                                                                                              defer:YES];
 -                              //Copy current window parameters
 -                              [tmpWindow setTitle:[m_window title]];
 -                              [tmpWindow setRepresentedFilename:[m_window representedFilename]];
 -                              [tmpWindow setReleasedWhenClosed:NO];
 -                              [tmpWindow setAcceptsMouseMovedEvents:YES];
 -                              [tmpWindow setDelegate:[m_window delegate]];
 -                              
 -                              //Assign the openGL view to the new window
 -                              [tmpWindow setContentView:m_openGLView];
 -                              
 -                              //Show the new window
 -                              [tmpWindow makeKeyAndOrderFront:nil];
 -                              //Close and release old window
 -                              [m_window setDelegate:nil]; // To avoid the notification of "window closed" event
 -                              [m_window close];
 -                              [m_window release];
 -                              m_window = tmpWindow;
 -#endif
 -                      
 -                              //Tell WM of view new size
 -                              m_systemCocoa->handleWindowEvent(GHOST_kEventWindowSize, this);
 -                              
 -                              [pool drain];
 -                      }
 -            else if ([m_window isMiniaturized])
 -                              [m_window deminiaturize:nil];
 -                      else if ([m_window isZoomed])
 -                              [m_window zoom:nil];
 -            break;
 -    }
 -    return GHOST_kSuccess;
 -}
 -
 -GHOST_TSuccess GHOST_WindowCocoa::setModifiedState(bool isUnsavedChanges)
 -{
 -      NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 -      
 -      [m_window setDocumentEdited:isUnsavedChanges];
 -      
 -      [pool drain];
 -      return GHOST_Window::setModifiedState(isUnsavedChanges);
 -}
 -
 -
 -
 -GHOST_TSuccess GHOST_WindowCocoa::setOrder(GHOST_TWindowOrder order)
 -{
 -      GHOST_ASSERT(getValid(), "GHOST_WindowCocoa::setOrder(): window invalid")
 -    if (order == GHOST_kWindowOrderTop) {
 -              [m_window orderFront:nil];
 -    }
 -    else {
 -              [m_window orderBack:nil];
 -    }
 -    return GHOST_kSuccess;
 -}
 -
 -#pragma mark Drawing context
 -
 -/*#define  WAIT_FOR_VSYNC 1*/
 -
 -GHOST_TSuccess GHOST_WindowCocoa::swapBuffers()
 -{
 -    if (m_drawingContextType == GHOST_kDrawingContextTypeOpenGL) {
 -        if (m_openGLContext != nil) {
 -                      NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 -                      [m_openGLContext flushBuffer];
 -                      [pool drain];
 -            return GHOST_kSuccess;
 -        }
 -    }
 -    return GHOST_kFailure;
 -}
 -
 -GHOST_TSuccess GHOST_WindowCocoa::updateDrawingContext()
 -{
 -      if (m_drawingContextType == GHOST_kDrawingContextTypeOpenGL) {
 -              if (m_openGLContext != nil) {
 -                      NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 -                      [m_openGLContext update];
 -                      [pool drain];
 -                      return GHOST_kSuccess;
 -              }
 -      }
 -      return GHOST_kFailure;
 -}
 -
 -GHOST_TSuccess GHOST_WindowCocoa::activateDrawingContext()
 -{
 -      if (m_drawingContextType == GHOST_kDrawingContextTypeOpenGL) {
 -              if (m_openGLContext != nil) {
 -                      NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 -                      [m_openGLContext makeCurrentContext];
 -                      [pool drain];
 -                      return GHOST_kSuccess;
 -              }
 -      }
 -      return GHOST_kFailure;
 -}
 -
 -
 -GHOST_TSuccess GHOST_WindowCocoa::installDrawingContext(GHOST_TDrawingContextType type)
 -{
 -      GHOST_TSuccess success = GHOST_kFailure;
 -      
 -      NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 -      
 -      NSOpenGLPixelFormat *pixelFormat;
 -      NSOpenGLContext *tmpOpenGLContext;
 -      
 -      switch (type) {
 -              case GHOST_kDrawingContextTypeOpenGL:
 -                      if (!getValid()) break;
 -                                      
 -                      pixelFormat = [m_openGLView pixelFormat];
 -                      tmpOpenGLContext = [[NSOpenGLContext alloc] initWithFormat:pixelFormat
 -                                                                                                                        shareContext:s_firstOpenGLcontext];
 -                      if (tmpOpenGLContext == nil) {
 -                              success = GHOST_kFailure;
 -                              break;
 -                      }
 -                      
 -                      if (!s_firstOpenGLcontext) s_firstOpenGLcontext = tmpOpenGLContext;
 -#ifdef WAIT_FOR_VSYNC
 -                              /* wait for vsync, to avoid tearing artifacts */
 -                              [tmpOpenGLContext setValues:1 forParameter:NSOpenGLCPSwapInterval];
 -#endif
 -                              [m_openGLView setOpenGLContext:tmpOpenGLContext];
 -                              [tmpOpenGLContext setView:m_openGLView];
 -                              
 -                              m_openGLContext = tmpOpenGLContext;
 -                      break;
 -              
 -              case GHOST_kDrawingContextTypeNone:
 -                      success = GHOST_kSuccess;
 -                      break;
 -              
 -              default:
 -                      break;
 -      }
 -      [pool drain];
 -      return success;
 -}
 -
 -
 -GHOST_TSuccess GHOST_WindowCocoa::removeDrawingContext()
 -{
 -      NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 -      switch (m_drawingContextType) {
 -              case GHOST_kDrawingContextTypeOpenGL:
 -                      if (m_openGLContext)
 -                      {
 -                              [m_openGLView clearGLContext];
 -                              if (s_firstOpenGLcontext == m_openGLContext) s_firstOpenGLcontext = nil;
 -                              m_openGLContext = nil;
 -                      }
 -                      [pool drain];
 -                      return GHOST_kSuccess;
 -              case GHOST_kDrawingContextTypeNone:
 -                      [pool drain];
 -                      return GHOST_kSuccess;
 -                      break;
 -              default:
 -                      [pool drain];
 -                      return GHOST_kFailure;
 -      }
 -}
 -
 -
 -GHOST_TSuccess GHOST_WindowCocoa::invalidate()
 -{
 -      GHOST_ASSERT(getValid(), "GHOST_WindowCocoa::invalidate(): window invalid")
 -      NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 -      [m_openGLView setNeedsDisplay:YES];
 -      [pool drain];
 -      return GHOST_kSuccess;
 -}
 -
 -#pragma mark Cursor handling
 -
 -void GHOST_WindowCocoa::loadCursor(bool visible, GHOST_TStandardCursor cursor) const
 -{
 -      static bool systemCursorVisible = true;
 -      
 -      NSAutoreleasePool *pool =[[NSAutoreleasePool alloc] init];
 -
 -      NSCursor *tmpCursor =nil;
 -      
 -      if (visible != systemCursorVisible) {
 -              if (visible) {
 -                      [NSCursor unhide];
 -                      systemCursorVisible = true;
 -              }
 -              else {
 -                      [NSCursor hide];
 -                      systemCursorVisible = false;
 -              }
 -      }
 -
 -      if (cursor == GHOST_kStandardCursorCustom && m_customCursor) {
 -              tmpCursor = m_customCursor;
 -      } else {
 -              switch (cursor) {
 -                      case GHOST_kStandardCursorDestroy:
 -                              tmpCursor = [NSCursor disappearingItemCursor];
 -                              break;
 -                      case GHOST_kStandardCursorText:
 -                              tmpCursor = [NSCursor IBeamCursor];
 -                              break;
 -                      case GHOST_kStandardCursorCrosshair:
 -                              tmpCursor = [NSCursor crosshairCursor];
 -                              break;
 -                      case GHOST_kStandardCursorUpDown:
 -                              tmpCursor = [NSCursor resizeUpDownCursor];
 -                              break;
 -                      case GHOST_kStandardCursorLeftRight:
 -                              tmpCursor = [NSCursor resizeLeftRightCursor];
 -                              break;
 -                      case GHOST_kStandardCursorTopSide:
 -                              tmpCursor = [NSCursor resizeUpCursor];
 -                              break;
 -                      case GHOST_kStandardCursorBottomSide:
 -                              tmpCursor = [NSCursor resizeDownCursor];
 -                              break;
 -                      case GHOST_kStandardCursorLeftSide:
 -                              tmpCursor = [NSCursor resizeLeftCursor];
 -                              break;
 -                      case GHOST_kStandardCursorRightSide:
 -                              tmpCursor = [NSCursor resizeRightCursor];
 -                              break;
 -                      case GHOST_kStandardCursorRightArrow:
 -                      case GHOST_kStandardCursorInfo:
 -                      case GHOST_kStandardCursorLeftArrow:
 -                      case GHOST_kStandardCursorHelp:
 -                      case GHOST_kStandardCursorCycle:
 -                      case GHOST_kStandardCursorSpray:
 -                      case GHOST_kStandardCursorWait:
 -                      case GHOST_kStandardCursorTopLeftCorner:
 -                      case GHOST_kStandardCursorTopRightCorner:
 -                      case GHOST_kStandardCursorBottomRightCorner:
 -                      case GHOST_kStandardCursorBottomLeftCorner:
 -                      case GHOST_kStandardCursorDefault:
 -                      default:
 -                              tmpCursor = [NSCursor arrowCursor];
 -                              break;
 -              };
 -      }
 -      [tmpCursor set];
 -      [pool drain];
 -}
 -
 -
 -
 -GHOST_TSuccess GHOST_WindowCocoa::setWindowCursorVisibility(bool visible)
 -{
 -      if ([m_window isVisible]) {
 -              loadCursor(visible, getCursorShape());
 -      }
 -      
 -      return GHOST_kSuccess;
 -}
 -
 -
 -//Override this method to provide set feature even if not in warp
 -inline bool GHOST_WindowCocoa::setCursorWarpAccum(GHOST_TInt32 x, GHOST_TInt32 y)
 -{
 -      m_cursorWarpAccumPos[0]= x;
 -      m_cursorWarpAccumPos[1]= y;
 -      
 -      return GHOST_kSuccess;
 -}
 -
 -
 -GHOST_TSuccess GHOST_WindowCocoa::setWindowCursorGrab(bool grab, bool warp, bool restore)
 -{
 -      if (grab)
 -      {
 -              //No need to perform grab without warp as it is always on in OS X
 -              if(warp) {
 -                      GHOST_TInt32 x_old,y_old;
 -
 -                      m_cursorWarp= true;
 -                      m_systemCocoa->getCursorPosition(x_old,y_old);
 -                      screenToClient(x_old, y_old, m_cursorWarpInitPos[0], m_cursorWarpInitPos[1]);
 -                      //Warp position is stored in client (window base) coordinates
 -                      setWindowCursorVisibility(false);
 -                      return CGAssociateMouseAndMouseCursorPosition(false) == kCGErrorSuccess ? GHOST_kSuccess : GHOST_kFailure;
 -              }
 -      }
 -      else {
 -              if(m_cursorWarp)
 -              {/* are we exiting warp */
 -                      setWindowCursorVisibility(true);
 -                      /* Almost works without but important otherwise the mouse GHOST location can be incorrect on exit */
 -                      if(restore) {
 -                              GHOST_Rect bounds;
 -                              GHOST_TInt32 x_new, y_new, x_cur, y_cur;
 -                              
 -                              getClientBounds(bounds);
 -                              x_new= m_cursorWarpInitPos[0]+m_cursorWarpAccumPos[0];
 -                              y_new= m_cursorWarpInitPos[1]+m_cursorWarpAccumPos[1];
 -                              
 -                              if(x_new < 0)           x_new = 0;
 -                              if(y_new < 0)           y_new = 0;
 -                              if(x_new > bounds.getWidth())   x_new = bounds.getWidth();
 -                              if(y_new > bounds.getHeight())  y_new = bounds.getHeight();
 -                              
 -                              //get/set cursor position works in screen coordinates
 -                              clientToScreen(x_new, y_new, x_cur, y_cur);
 -                              m_systemCocoa->setCursorPosition(x_cur, y_cur);
 -                              
 -                              //As Cocoa will give as first deltaX,deltaY this change in cursor position, we need to compensate for it
 -                              //Issue appearing in case of two transform operations conducted w/o mouse motion in between
 -                              x_new=m_cursorWarpAccumPos[0];
 -                              y_new=m_cursorWarpAccumPos[1];
 -                              setCursorWarpAccum(-x_new, -y_new);
 -                      }
 -                      else {
 -                              GHOST_TInt32 x_new, y_new;
 -                              //get/set cursor position works in screen coordinates
 -                              clientToScreen(m_cursorWarpInitPos[0], m_cursorWarpInitPos[1], x_new, y_new);
 -                              m_systemCocoa->setCursorPosition(x_new, y_new);
 -                              setCursorWarpAccum(0, 0);
 -                      }
 -                      
 -                      m_cursorWarp= false;
 -                      return CGAssociateMouseAndMouseCursorPosition(true) == kCGErrorSuccess ? GHOST_kSuccess : GHOST_kFailure;
 -              }
 -      }
 -      return GHOST_kSuccess;
 -}
 -      
 -GHOST_TSuccess GHOST_WindowCocoa::setWindowCursorShape(GHOST_TStandardCursor shape)
 -{
 -      if (m_customCursor) {
 -              [m_customCursor release];
 -              m_customCursor = nil;
 -      }
 -
 -      if ([m_window isVisible]) {
 -              loadCursor(getCursorVisibility(), shape);
 -      }
 -      
 -      return GHOST_kSuccess;
 -}
 -
 -/** Reverse the bits in a GHOST_TUns8
 -static GHOST_TUns8 uns8ReverseBits(GHOST_TUns8 ch)
 -{
 -      ch= ((ch>>1)&0x55) | ((ch<<1)&0xAA);
 -      ch= ((ch>>2)&0x33) | ((ch<<2)&0xCC);
 -      ch= ((ch>>4)&0x0F) | ((ch<<4)&0xF0);
 -      return ch;
 -}
 -*/
 -
 -
 -/** Reverse the bits in a GHOST_TUns16 */
 -static GHOST_TUns16 uns16ReverseBits(GHOST_TUns16 shrt)
 -{
 -      shrt= ((shrt>>1)&0x5555) | ((shrt<<1)&0xAAAA);
 -      shrt= ((shrt>>2)&0x3333) | ((shrt<<2)&0xCCCC);
 -      shrt= ((shrt>>4)&0x0F0F) | ((shrt<<4)&0xF0F0);
 -      shrt= ((shrt>>8)&0x00FF) | ((shrt<<8)&0xFF00);
 -      return shrt;
 -}
 -
 -GHOST_TSuccess GHOST_WindowCocoa::setWindowCustomCursorShape(GHOST_TUns8 *bitmap, GHOST_TUns8 *mask,
 -                                      int sizex, int sizey, int hotX, int hotY, int fg_color, int bg_color)
 -{
 -      int y,nbUns16;
 -      NSPoint hotSpotPoint;
 -      NSBitmapImageRep *cursorImageRep;
 -      NSImage *cursorImage;
 -      NSSize imSize;
 -      GHOST_TUns16 *cursorBitmap;
 -      
 -      
 -      NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 -      
 -      if (m_customCursor) {
 -              [m_customCursor release];
 -              m_customCursor = nil;
 -      }
 -      
 -
 -      cursorImageRep = [[NSBitmapImageRep alloc] initWithBitmapDataPlanes:nil
 -                                                                                                                       pixelsWide:sizex
 -                                                                                                                       pixelsHigh:sizey
 -                                                                                                                bitsPerSample:1 
 -                                                                                                              samplesPerPixel:2
 -                                                                                                                         hasAlpha:YES
 -                                                                                                                         isPlanar:YES
 -                                                                                                               colorSpaceName:NSDeviceBlackColorSpace
 -                                                                                                                      bytesPerRow:(sizex/8 + (sizex%8 >0 ?1:0))
 -                                                                                                                 bitsPerPixel:1];
 -      
 -      
 -      cursorBitmap = (GHOST_TUns16*)[cursorImageRep bitmapData];
 -      nbUns16 = [cursorImageRep bytesPerPlane]/2;
 -      
 -      for (y=0; y<nbUns16; y++) {
 -#if !defined(__LITTLE_ENDIAN__)
 -              cursorBitmap[y] = uns16ReverseBits((bitmap[2*y]<<0) | (bitmap[2*y+1]<<8));
 -              cursorBitmap[nbUns16+y] = uns16ReverseBits((mask[2*y]<<0) | (mask[2*y+1]<<8));
 -#else
 -              cursorBitmap[y] = uns16ReverseBits((bitmap[2*y+1]<<0) | (bitmap[2*y]<<8));
 -              cursorBitmap[nbUns16+y] = uns16ReverseBits((mask[2*y+1]<<0) | (mask[2*y]<<8));
 -#endif
 -              
 -      }
 -      
 -      
 -      imSize.width = sizex;
 -      imSize.height= sizey;
 -      cursorImage = [[NSImage alloc] initWithSize:imSize];
 -      [cursorImage addRepresentation:cursorImageRep];
 -      
 -      hotSpotPoint.x = hotX;
 -      hotSpotPoint.y = hotY;
 -      
 -      //foreground and background color parameter is not handled for now (10.6)
 -      m_customCursor = [[NSCursor alloc] initWithImage:cursorImage
 -                                                                                       hotSpot:hotSpotPoint];
 -      
 -      [cursorImageRep release];
 -      [cursorImage release];
 -      
 -      if ([m_window isVisible]) {
 -              loadCursor(getCursorVisibility(), GHOST_kStandardCursorCustom);
 -      }
 -      [pool drain];
 -      return GHOST_kSuccess;
 -}
 -
 -GHOST_TSuccess GHOST_WindowCocoa::setWindowCustomCursorShape(GHOST_TUns8 bitmap[16][2], 
 -                                                                                              GHOST_TUns8 mask[16][2], int hotX, int hotY)
 -{
 -      return setWindowCustomCursorShape((GHOST_TUns8*)bitmap, (GHOST_TUns8*) mask, 16, 16, hotX, hotY, 0, 1);
 -}
++/**\r
++ * $Id: GHOST_WindowCocoa.mm 23873 2009-10-15 20:09:50Z damien78 $\r
++ * ***** BEGIN GPL LICENSE BLOCK *****\r
++ *\r
++ * This program is free software; you can redistribute it and/or\r
++ * modify it under the terms of the GNU General Public License\r
++ * as published by the Free Software Foundation; either version 2\r
++ * of the License, or (at your option) any later version.\r
++ *\r
++ * This program is distributed in the hope that it will be useful,\r
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of\r
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
++ * GNU General Public License for more details.\r
++ *\r
++ * You should have received a copy of the GNU General Public License\r
++ * along with this program; if not, write to the Free Software Foundation,\r
++ * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.\r
++ *\r
++ * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.\r
++ * All rights reserved.\r
++ *\r
++ * The Original Code is: all of this file.\r
++ *\r
++ * Contributor(s):    Maarten Gribnau 05/2001\r
++                                      Damien Plisson 10/2009\r
++ *\r
++ * ***** END GPL LICENSE BLOCK *****\r
++ */\r
++\r
++#include <Cocoa/Cocoa.h>\r
++\r
++#ifndef MAC_OS_X_VERSION_10_6\r
++//Use of the SetSystemUIMode function (64bit compatible)\r
++#include <Carbon/Carbon.h>\r
++#endif\r
++\r
++#include "GHOST_WindowCocoa.h"\r
++#include "GHOST_SystemCocoa.h"\r
++#include "GHOST_Debug.h"\r
++\r
++\r
++// Pixel Format Attributes for the windowed NSOpenGLContext\r
++static NSOpenGLPixelFormatAttribute pixelFormatAttrsWindow[] =\r
++{\r
++      NSOpenGLPFADoubleBuffer,\r
++      NSOpenGLPFAAccelerated,\r
++      //NSOpenGLPFAAllowOfflineRenderers,   // Removed to allow 10.4 builds, and 2 GPUs rendering is not used anyway\r
++      NSOpenGLPFADepthSize, (NSOpenGLPixelFormatAttribute) 32,\r
++      (NSOpenGLPixelFormatAttribute) 0\r
++};\r
++\r
++#pragma mark Cocoa window delegate object\r
++\r
++@interface CocoaWindowDelegate : NSObject\r
++{\r
++      GHOST_SystemCocoa *systemCocoa;\r
++      GHOST_WindowCocoa *associatedWindow;\r
++}\r
++\r
++- (void)setSystemAndWindowCocoa:(const GHOST_SystemCocoa *)sysCocoa windowCocoa:(GHOST_WindowCocoa *)winCocoa;\r
++- (void)windowWillClose:(NSNotification *)notification;\r
++- (void)windowDidBecomeKey:(NSNotification *)notification;\r
++- (void)windowDidResignKey:(NSNotification *)notification;\r
++- (void)windowDidUpdate:(NSNotification *)notification;\r
++- (void)windowDidResize:(NSNotification *)notification;\r
++@end\r
++\r
++@implementation CocoaWindowDelegate : NSObject\r
++- (void)setSystemAndWindowCocoa:(GHOST_SystemCocoa *)sysCocoa windowCocoa:(GHOST_WindowCocoa *)winCocoa\r
++{\r
++      systemCocoa = sysCocoa;\r
++      associatedWindow = winCocoa;\r
++}\r
++\r
++- (void)windowWillClose:(NSNotification *)notification\r
++{\r
++      systemCocoa->handleWindowEvent(GHOST_kEventWindowClose, associatedWindow);\r
++}\r
++\r
++- (void)windowDidBecomeKey:(NSNotification *)notification\r
++{\r
++      systemCocoa->handleWindowEvent(GHOST_kEventWindowActivate, associatedWindow);\r
++}\r
++\r
++- (void)windowDidResignKey:(NSNotification *)notification\r
++{\r
++      //The window is no more key when its own view becomes fullscreen\r
++      //but ghost doesn't know the view/window difference, so hide this fact\r
++      if (associatedWindow->getState() != GHOST_kWindowStateFullScreen)\r
++              systemCocoa->handleWindowEvent(GHOST_kEventWindowDeactivate, associatedWindow);\r
++}\r
++\r
++- (void)windowDidUpdate:(NSNotification *)notification\r
++{\r
++      systemCocoa->handleWindowEvent(GHOST_kEventWindowUpdate, associatedWindow);\r
++}\r
++\r
++- (void)windowDidResize:(NSNotification *)notification\r
++{\r
++      systemCocoa->handleWindowEvent(GHOST_kEventWindowSize, associatedWindow);\r
++}\r
++@end\r
++\r
++#pragma mark NSWindow subclass\r
++//We need to subclass it to tell that even borderless (fullscreen), it can become key (receive user events)\r
++@interface CocoaWindow: NSWindow\r
++{\r
++\r
++}\r
++-(BOOL)canBecomeKeyWindow;\r
++\r
++@end\r
++@implementation CocoaWindow\r
++\r
++-(BOOL)canBecomeKeyWindow\r
++{\r
++      return YES;\r
++}\r
++\r
++@end\r
++\r
++\r
++\r
++#pragma mark NSOpenGLView subclass\r
++//We need to subclass it in order to give Cocoa the feeling key events are trapped\r
++@interface CocoaOpenGLView : NSOpenGLView\r
++{\r
++      \r
++}\r
++@end\r
++@implementation CocoaOpenGLView\r
++\r
++- (BOOL)acceptsFirstResponder\r
++{\r
++    return YES;\r
++}\r
++\r
++//The trick to prevent Cocoa from complaining (beeping)\r
++- (void)keyDown:(NSEvent *)theEvent\r
++{}\r
++\r
++- (BOOL)isOpaque\r
++{\r
++    return YES;\r
++}\r
++\r
++@end\r
++\r
++\r
++#pragma mark initialization / finalization\r
++\r
++NSOpenGLContext* GHOST_WindowCocoa::s_firstOpenGLcontext = nil;\r
++\r
++GHOST_WindowCocoa::GHOST_WindowCocoa(\r
++      GHOST_SystemCocoa *systemCocoa,\r
++      const STR_String& title,\r
++      GHOST_TInt32 left,\r
++      GHOST_TInt32 top,\r
++      GHOST_TUns32 width,\r
++      GHOST_TUns32 height,\r
++      GHOST_TWindowState state,\r
++      GHOST_TDrawingContextType type,\r
++      const bool stereoVisual\r
++) :\r
++      GHOST_Window(title, left, top, width, height, state, GHOST_kDrawingContextTypeNone),\r
++      m_customCursor(0)\r
++{\r
++      m_systemCocoa = systemCocoa;\r
++      m_fullScreen = false;\r
++      \r
++      NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];\r
++      \r
++\r
++      //Creates the window\r
++      NSRect rect;\r
++      \r
++      rect.origin.x = left;\r
++      rect.origin.y = top;\r
++      rect.size.width = width;\r
++      rect.size.height = height;\r
++      \r
++      m_window = [[CocoaWindow alloc] initWithContentRect:rect\r
++                                                                                 styleMask:NSTitledWindowMask | NSClosableWindowMask | NSResizableWindowMask | NSMiniaturizableWindowMask\r
++                                                                                       backing:NSBackingStoreBuffered defer:NO];\r
++      if (m_window == nil) {\r
++              [pool drain];\r
++              return;\r
++      }\r
++      \r
++      setTitle(title);\r
++      \r
++                      \r
++      //Creates the OpenGL View inside the window\r
++      NSOpenGLPixelFormat *pixelFormat =\r
++      [[NSOpenGLPixelFormat alloc] initWithAttributes:pixelFormatAttrsWindow];\r
++      \r
++      m_openGLView = [[CocoaOpenGLView alloc] initWithFrame:rect\r
++                                                                                               pixelFormat:pixelFormat];\r
++      \r
++      [pixelFormat release];\r
++      \r
++      m_openGLContext = [m_openGLView openGLContext]; //This context will be replaced by the proper one just after\r
++      \r
++      [m_window setContentView:m_openGLView];\r
++      [m_window setInitialFirstResponder:m_openGLView];\r
++      \r
++      [m_window setReleasedWhenClosed:NO]; //To avoid bad pointer exception in case of user closing the window\r
++      \r
++      [m_window makeKeyAndOrderFront:nil];\r
++      \r
++      setDrawingContextType(type);\r
++      updateDrawingContext();\r
++      activateDrawingContext();\r
++      \r
++      m_tablet.Active = GHOST_kTabletModeNone;\r
++      \r
++      CocoaWindowDelegate *windowDelegate = [[CocoaWindowDelegate alloc] init];\r
++      [windowDelegate setSystemAndWindowCocoa:systemCocoa windowCocoa:this];\r
++      [m_window setDelegate:windowDelegate];\r
++      \r
++      [m_window setAcceptsMouseMovedEvents:YES];\r
++      \r
++      if (state == GHOST_kWindowStateFullScreen)\r
++              setState(GHOST_kWindowStateFullScreen);\r
++              \r
++      [pool drain];\r
++}\r
++\r
++\r
++GHOST_WindowCocoa::~GHOST_WindowCocoa()\r
++{\r
++      if (m_customCursor) delete m_customCursor;\r
++\r
++    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];\r
++      [m_openGLView release];\r
++      \r
++      if (m_window) {\r
++              [m_window close];\r
++              [[m_window delegate] release];\r
++              [m_window release];\r
++              m_window = nil;\r
++      }\r
++      \r
++      //Check for other blender opened windows and make the frontmost key\r
++      NSArray *windowsList = [NSApp orderedWindows];\r
++      if ([windowsList count]) {\r
++              [[windowsList objectAtIndex:0] makeKeyAndOrderFront:nil];\r
++      }\r
++      [pool drain];\r
++}\r
++\r
++#pragma mark accessors\r
++\r
++bool GHOST_WindowCocoa::getValid() const\r
++{\r
++    bool valid;\r
++    if (!m_fullScreen) {\r
++        valid = (m_window != 0); //&& ::IsValidWindowPtr(m_windowRef);\r
++    }\r
++    else {\r
++        valid = true;\r
++    }\r
++    return valid;\r
++}\r
++\r
++\r
++void GHOST_WindowCocoa::setTitle(const STR_String& title)\r
++{\r
++    GHOST_ASSERT(getValid(), "GHOST_WindowCocoa::setTitle(): window invalid")\r
++      NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];\r
++\r
++      NSString *windowTitle = [[NSString alloc] initWithUTF8String:title];\r
++      \r
++      //Set associated file if applicable\r
++      if ([windowTitle hasPrefix:@"Blender"])\r
++      {\r
++              NSRange fileStrRange;\r
++              NSString *associatedFileName;\r
++              int len;\r
++              \r
++              fileStrRange.location = [windowTitle rangeOfString:@"["].location+1;\r
++              len = [windowTitle rangeOfString:@"]"].location - fileStrRange.location;\r
++      \r
++              if (len >0)\r
++              {\r
++                      fileStrRange.length = len;\r
++                      associatedFileName = [windowTitle substringWithRange:fileStrRange];\r
++                      @try {\r
++                              [m_window setRepresentedFilename:associatedFileName];\r
++                      }\r
++                      @catch (NSException * e) {\r
++                              printf("\nInvalid file path given in window title");\r
++                      }\r
++                      [m_window setTitle:[associatedFileName lastPathComponent]];\r
++              }\r
++              else {\r
++                      [m_window setTitle:windowTitle];\r
++                      [m_window setRepresentedFilename:@""];\r
++              }\r
++\r
++      } else {\r
++              [m_window setTitle:windowTitle];\r
++              [m_window setRepresentedFilename:@""];\r
++      }\r
++\r
++      \r
++      [windowTitle release];\r
++      [pool drain];\r
++}\r
++\r
++\r
++void GHOST_WindowCocoa::getTitle(STR_String& title) const\r
++{\r
++    GHOST_ASSERT(getValid(), "GHOST_WindowCocoa::getTitle(): window invalid")\r
++\r
++      NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];\r
++\r
++      NSString *windowTitle = [m_window title];\r
++\r
++      if (windowTitle != nil) {\r
++              title = [windowTitle UTF8String];               \r
++      }\r
++      \r
++      [pool drain];\r
++}\r
++\r
++\r
++void GHOST_WindowCocoa::getWindowBounds(GHOST_Rect& bounds) const\r
++{\r
++      NSRect rect;\r
++      GHOST_ASSERT(getValid(), "GHOST_WindowCocoa::getWindowBounds(): window invalid")\r
++\r
++      NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];\r
++      \r
++      NSRect screenSize = [[m_window screen] visibleFrame];\r
++\r
++      rect = [m_window frame];\r
++\r
++      bounds.m_b = screenSize.size.height - (rect.origin.y -screenSize.origin.y);\r
++      bounds.m_l = rect.origin.x -screenSize.origin.x;\r
++      bounds.m_r = rect.origin.x-screenSize.origin.x + rect.size.width;\r
++      bounds.m_t = screenSize.size.height - (rect.origin.y + rect.size.height -screenSize.origin.y);\r
++      \r
++      [pool drain];\r
++}\r
++\r
++\r
++void GHOST_WindowCocoa::getClientBounds(GHOST_Rect& bounds) const\r
++{\r
++      NSRect rect;\r
++      GHOST_ASSERT(getValid(), "GHOST_WindowCocoa::getClientBounds(): window invalid")\r
++      \r
++      NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];\r
++      \r
++      if (!m_fullScreen)\r
++      {\r
++              NSRect screenSize = [[m_window screen] visibleFrame];\r
++\r
++              //Max window contents as screen size (excluding title bar...)\r
++              NSRect contentRect = [CocoaWindow contentRectForFrameRect:screenSize\r
++                                                                                                       styleMask:(NSTitledWindowMask | NSClosableWindowMask | NSMiniaturizableWindowMask | NSResizableWindowMask)];\r
++\r
++              rect = [m_window contentRectForFrameRect:[m_window frame]];\r
++              \r
++              bounds.m_b = contentRect.size.height - (rect.origin.y -contentRect.origin.y);\r
++              bounds.m_l = rect.origin.x -contentRect.origin.x;\r
++              bounds.m_r = rect.origin.x-contentRect.origin.x + rect.size.width;\r
++              bounds.m_t = contentRect.size.height - (rect.origin.y + rect.size.height -contentRect.origin.y);\r
++      }\r
++      else {\r
++              NSRect screenSize = [[m_window screen] frame];\r
++              \r
++              bounds.m_b = screenSize.origin.y + screenSize.size.height;\r
++              bounds.m_l = screenSize.origin.x;\r
++              bounds.m_r = screenSize.origin.x + screenSize.size.width;\r
++              bounds.m_t = screenSize.origin.y;\r
++      }\r
++      [pool drain];\r
++}\r
++\r
++\r
++GHOST_TSuccess GHOST_WindowCocoa::setClientWidth(GHOST_TUns32 width)\r
++{\r
++      GHOST_ASSERT(getValid(), "GHOST_WindowCocoa::setClientWidth(): window invalid")\r
++      GHOST_Rect cBnds, wBnds;\r
++      getClientBounds(cBnds);\r
++      if (((GHOST_TUns32)cBnds.getWidth()) != width) {\r
++              NSSize size;\r
++              size.width=width;\r
++              size.height=cBnds.getHeight();\r
++              [m_window setContentSize:size];\r
++      }\r
++      return GHOST_kSuccess;\r
++}\r
++\r
++\r
++GHOST_TSuccess GHOST_WindowCocoa::setClientHeight(GHOST_TUns32 height)\r
++{\r
++      GHOST_ASSERT(getValid(), "GHOST_WindowCocoa::setClientHeight(): window invalid")\r
++      GHOST_Rect cBnds, wBnds;\r
++      getClientBounds(cBnds);\r
++      if (((GHOST_TUns32)cBnds.getHeight()) != height) {\r
++              NSSize size;\r
++              size.width=cBnds.getWidth();\r
++              size.height=height;\r
++              [m_window setContentSize:size];\r
++      }\r
++      return GHOST_kSuccess;\r
++}\r
++\r
++\r
++GHOST_TSuccess GHOST_WindowCocoa::setClientSize(GHOST_TUns32 width, GHOST_TUns32 height)\r
++{\r
++      GHOST_ASSERT(getValid(), "GHOST_WindowCocoa::setClientSize(): window invalid")\r
++      GHOST_Rect cBnds, wBnds;\r
++      getClientBounds(cBnds);\r
++      if ((((GHOST_TUns32)cBnds.getWidth()) != width) ||\r
++          (((GHOST_TUns32)cBnds.getHeight()) != height)) {\r
++              NSSize size;\r
++              size.width=width;\r
++              size.height=height;\r
++              [m_window setContentSize:size];\r
++      }\r
++      return GHOST_kSuccess;\r
++}\r
++\r
++\r
++GHOST_TWindowState GHOST_WindowCocoa::getState() const\r
++{\r
++      GHOST_ASSERT(getValid(), "GHOST_WindowCocoa::getState(): window invalid")\r
++      NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];\r
++      GHOST_TWindowState state;\r
++      if (m_fullScreen) {\r
++              state = GHOST_kWindowStateFullScreen;\r
++      } \r
++      else if ([m_window isMiniaturized]) {\r
++              state = GHOST_kWindowStateMinimized;\r
++      }\r
++      else if ([m_window isZoomed]) {\r
++              state = GHOST_kWindowStateMaximized;\r
++      }\r
++      else {\r
++              state = GHOST_kWindowStateNormal;\r
++      }\r
++      [pool drain];\r
++      return state;\r
++}\r
++\r
++\r
++void GHOST_WindowCocoa::screenToClient(GHOST_TInt32 inX, GHOST_TInt32 inY, GHOST_TInt32& outX, GHOST_TInt32& outY) const\r
++{\r
++      GHOST_ASSERT(getValid(), "GHOST_WindowCocoa::screenToClient(): window invalid")\r
++      \r
++      NSPoint screenCoord;\r
++      NSPoint baseCoord;\r
++      \r
++      screenCoord.x = inX;\r
++      screenCoord.y = inY;\r
++      \r
++      baseCoord = [m_window convertScreenToBase:screenCoord];\r
++      \r
++      outX = baseCoord.x;\r
++      outY = baseCoord.y;\r
++}\r
++\r
++\r
++void GHOST_WindowCocoa::clientToScreen(GHOST_TInt32 inX, GHOST_TInt32 inY, GHOST_TInt32& outX, GHOST_TInt32& outY) const\r
++{\r
++      GHOST_ASSERT(getValid(), "GHOST_WindowCocoa::clientToScreen(): window invalid")\r
++      \r
++      NSPoint screenCoord;\r
++      NSPoint baseCoord;\r
++      \r
++      baseCoord.x = inX;\r
++      baseCoord.y = inY;\r
++      \r
++      screenCoord = [m_window convertBaseToScreen:baseCoord];\r
++      \r
++      outX = screenCoord.x;\r
++      outY = screenCoord.y;\r
++}\r
++\r
++/**\r
++ * @note Fullscreen switch is not actual fullscreen with display capture. As this capture removes all OS X window manager features.\r
++ * Instead, the menu bar and the dock are hidden, and the window is made borderless and enlarged.\r
++ * Thus, process switch, exposé, spaces, ... still work in fullscreen mode\r
++ */\r
++GHOST_TSuccess GHOST_WindowCocoa::setState(GHOST_TWindowState state)\r
++{\r
++      GHOST_ASSERT(getValid(), "GHOST_WindowCocoa::setState(): window invalid")\r
++    switch (state) {\r
++              case GHOST_kWindowStateMinimized:\r
++            [m_window miniaturize:nil];\r
++            break;\r
++              case GHOST_kWindowStateMaximized:\r
++                      [m_window zoom:nil];\r
++                      break;\r
++              \r
++              case GHOST_kWindowStateFullScreen:\r
++                      if (!m_fullScreen)\r
++                      {\r
++                              NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];\r
++                      \r
++                              //This status change needs to be done before Cocoa call to enter fullscreen mode\r
++                              //to give window delegate hint not to forward its deactivation to ghost wm that doesn't know view/window difference\r
++                              m_fullScreen = true;\r
++\r
++#ifdef MAC_OS_X_VERSION_10_6\r
++                              //10.6 provides Cocoa functions to autoshow menu bar, and to change a window style\r
++                              //Hide menu & dock if needed\r
++                              if ([[m_window screen] isEqual:[NSScreen mainScreen]])\r
++                              {\r
++                                      [NSApp setPresentationOptions:(NSApplicationPresentationHideDock | NSApplicationPresentationAutoHideMenuBar)];\r
++                              }\r
++                              //Make window borderless and enlarge it\r
++                              [m_window setStyleMask:NSBorderlessWindowMask];\r
++                              [m_window setFrame:[[m_window screen] frame] display:YES];\r
++#else\r
++                              //With 10.5, we need to create a new window to change its style to borderless\r
++                              //Hide menu & dock if needed\r
++                              if ([[m_window screen] isEqual:[NSScreen mainScreen]])\r
++                              {\r
++                                      //Cocoa function in 10.5 does not allow to set the menu bar in auto-show mode [NSMenu setMenuBarVisible:NO];\r
++                                      //One of the very few 64bit compatible Carbon function\r
++                                      SetSystemUIMode(kUIModeAllHidden,kUIOptionAutoShowMenuBar);\r
++                              }\r
++                              //Create a fullscreen borderless window\r
++                              CocoaWindow *tmpWindow = [[CocoaWindow alloc]\r
++                                                                                initWithContentRect:[[m_window screen] frame]\r
++                                                                                styleMask:NSBorderlessWindowMask\r
++                                                                                backing:NSBackingStoreBuffered\r
++                                                                                defer:YES];\r
++                              //Copy current window parameters\r
++                              [tmpWindow setTitle:[m_window title]];\r
++                              [tmpWindow setRepresentedFilename:[m_window representedFilename]];\r
++                              [tmpWindow setReleasedWhenClosed:NO];\r
++                              [tmpWindow setAcceptsMouseMovedEvents:YES];\r
++                              [tmpWindow setDelegate:[m_window delegate]];\r
++                              \r
++                              //Assign the openGL view to the new window\r
++                              [tmpWindow setContentView:m_openGLView];\r
++                              \r
++                              //Show the new window\r
++                              [tmpWindow makeKeyAndOrderFront:nil];\r
++                              //Close and release old window\r
++                              [m_window setDelegate:nil]; // To avoid the notification of "window closed" event\r
++                              [m_window close];\r
++                              [m_window release];\r
++                              m_window = tmpWindow;\r
++#endif\r
++                      \r
++                              //Tell WM of view new size\r
++                              m_systemCocoa->handleWindowEvent(GHOST_kEventWindowSize, this);\r
++                              \r
++                              [pool drain];\r
++                              }\r
++                      break;\r
++              case GHOST_kWindowStateNormal:\r
++        default:\r
++                      if (m_fullScreen)\r
++                      {\r
++                              NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];\r
++                              m_fullScreen = false;\r
++\r
++                              //Exit fullscreen\r
++#ifdef MAC_OS_X_VERSION_10_6\r
++                              //Show again menu & dock if needed\r
++                              if ([[m_window screen] isEqual:[NSScreen mainScreen]])\r
++                              {\r
++                                      [NSApp setPresentationOptions:NSApplicationPresentationDefault];\r
++                              }\r
++                              //Make window normal and resize it\r
++                              [m_window setStyleMask:(NSTitledWindowMask | NSClosableWindowMask | NSMiniaturizableWindowMask | NSResizableWindowMask)];\r
++                              [m_window setFrame:[[m_window screen] visibleFrame] display:YES];\r
++#else\r
++                              //With 10.5, we need to create a new window to change its style to borderless\r
++                              //Show menu & dock if needed\r
++                              if ([[m_window screen] isEqual:[NSScreen mainScreen]])\r
++                              {\r
++                                      //Cocoa function in 10.5 does not allow to set the menu bar in auto-show mode [NSMenu setMenuBarVisible:YES];\r
++                                      SetSystemUIMode(kUIModeNormal, 0); //One of the very few 64bit compatible Carbon function\r
++                              }\r
++                              //Create a fullscreen borderless window\r
++                              CocoaWindow *tmpWindow = [[CocoaWindow alloc]\r
++                                                                                initWithContentRect:[[m_window screen] frame]\r
++                                                                                                      styleMask:(NSTitledWindowMask | NSClosableWindowMask | NSMiniaturizableWindowMask | NSResizableWindowMask)\r
++                                                                                                        backing:NSBackingStoreBuffered\r
++                                                                                                              defer:YES];\r
++                              //Copy current window parameters\r
++                              [tmpWindow setTitle:[m_window title]];\r
++                              [tmpWindow setRepresentedFilename:[m_window representedFilename]];\r
++                              [tmpWindow setReleasedWhenClosed:NO];\r
++                              [tmpWindow setAcceptsMouseMovedEvents:YES];\r
++                              [tmpWindow setDelegate:[m_window delegate]];\r
++                              \r
++                              //Assign the openGL view to the new window\r
++                              [tmpWindow setContentView:m_openGLView];\r
++                              \r
++                              //Show the new window\r
++                              [tmpWindow makeKeyAndOrderFront:nil];\r
++                              //Close and release old window\r
++                              [m_window setDelegate:nil]; // To avoid the notification of "window closed" event\r
++                              [m_window close];\r
++                              [m_window release];\r
++                              m_window = tmpWindow;\r
++#endif\r
++                      \r
++                              //Tell WM of view new size\r
++                              m_systemCocoa->handleWindowEvent(GHOST_kEventWindowSize, this);\r
++                              \r
++                              [pool drain];\r
++                      }\r
++            else if ([m_window isMiniaturized])\r
++                              [m_window deminiaturize:nil];\r
++                      else if ([m_window isZoomed])\r
++                              [m_window zoom:nil];\r
++            break;\r
++    }\r
++    return GHOST_kSuccess;\r
++}\r
++\r
++GHOST_TSuccess GHOST_WindowCocoa::setModifiedState(bool isUnsavedChanges)\r
++{\r
++      NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];\r
++      \r
++      [m_window setDocumentEdited:isUnsavedChanges];\r
++      \r
++      [pool drain];\r
++      return GHOST_Window::setModifiedState(isUnsavedChanges);\r
++}\r
++\r
++\r
++\r
++GHOST_TSuccess GHOST_WindowCocoa::setOrder(GHOST_TWindowOrder order)\r
++{\r
++      GHOST_ASSERT(getValid(), "GHOST_WindowCocoa::setOrder(): window invalid")\r
++    if (order == GHOST_kWindowOrderTop) {\r
++              [m_window orderFront:nil];\r
++    }\r
++    else {\r
++              [m_window orderBack:nil];\r
++    }\r
++    return GHOST_kSuccess;\r
++}\r
++\r
++#pragma mark Drawing context\r
++\r
++/*#define  WAIT_FOR_VSYNC 1*/\r
++\r
++GHOST_TSuccess GHOST_WindowCocoa::swapBuffers()\r
++{\r
++    if (m_drawingContextType == GHOST_kDrawingContextTypeOpenGL) {\r
++        if (m_openGLContext != nil) {\r
++                      NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];\r
++                      [m_openGLContext flushBuffer];\r
++                      [pool drain];\r
++            return GHOST_kSuccess;\r
++        }\r
++    }\r
++    return GHOST_kFailure;\r
++}\r
++\r
++GHOST_TSuccess GHOST_WindowCocoa::updateDrawingContext()\r
++{\r
++      if (m_drawingContextType == GHOST_kDrawingContextTypeOpenGL) {\r
++              if (m_openGLContext != nil) {\r
++                      NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];\r
++                      [m_openGLContext update];\r
++                      [pool drain];\r
++                      return GHOST_kSuccess;\r
++              }\r
++      }\r
++      return GHOST_kFailure;\r
++}\r
++\r
++GHOST_TSuccess GHOST_WindowCocoa::activateDrawingContext()\r
++{\r
++      if (m_drawingContextType == GHOST_kDrawingContextTypeOpenGL) {\r
++              if (m_openGLContext != nil) {\r
++                      NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];\r
++                      [m_openGLContext makeCurrentContext];\r
++                      [pool drain];\r
++                      return GHOST_kSuccess;\r
++              }\r
++      }\r
++      return GHOST_kFailure;\r
++}\r
++\r
++\r
++GHOST_TSuccess GHOST_WindowCocoa::installDrawingContext(GHOST_TDrawingContextType type)\r
++{\r
++      GHOST_TSuccess success = GHOST_kFailure;\r
++      \r
++      NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];\r
++      \r
++      NSOpenGLPixelFormat *pixelFormat;\r
++      NSOpenGLContext *tmpOpenGLContext;\r
++      \r
++      switch (type) {\r
++              case GHOST_kDrawingContextTypeOpenGL:\r
++                      if (!getValid()) break;\r
++                                      \r
++                      pixelFormat = [m_openGLView pixelFormat];\r
++                      tmpOpenGLContext = [[NSOpenGLContext alloc] initWithFormat:pixelFormat\r
++                                                                                                                        shareContext:s_firstOpenGLcontext];\r
++                      if (tmpOpenGLContext == nil) {\r
++                              success = GHOST_kFailure;\r
++                              break;\r
++                      }\r
++                      \r
++                      if (!s_firstOpenGLcontext) s_firstOpenGLcontext = tmpOpenGLContext;\r
++#ifdef WAIT_FOR_VSYNC\r
++                              /* wait for vsync, to avoid tearing artifacts */\r
++                              [tmpOpenGLContext setValues:1 forParameter:NSOpenGLCPSwapInterval];\r
++#endif\r
++                              [m_openGLView setOpenGLContext:tmpOpenGLContext];\r
++                              [tmpOpenGLContext setView:m_openGLView];\r
++                              \r
++                              m_openGLContext = tmpOpenGLContext;\r
++                      break;\r
++              \r
++              case GHOST_kDrawingContextTypeNone:\r
++                      success = GHOST_kSuccess;\r
++                      break;\r
++              \r
++              default:\r
++                      break;\r
++      }\r
++      [pool drain];\r
++      return success;\r
++}\r
++\r
++\r
++GHOST_TSuccess GHOST_WindowCocoa::removeDrawingContext()\r
++{\r
++      NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];\r
++      switch (m_drawingContextType) {\r
++              case GHOST_kDrawingContextTypeOpenGL:\r
++                      if (m_openGLContext)\r
++                      {\r
++                              [m_openGLView clearGLContext];\r
++                              if (s_firstOpenGLcontext == m_openGLContext) s_firstOpenGLcontext = nil;\r
++                              m_openGLContext = nil;\r
++                      }\r
++                      [pool drain];\r
++                      return GHOST_kSuccess;\r
++              case GHOST_kDrawingContextTypeNone:\r
++                      [pool drain];\r
++                      return GHOST_kSuccess;\r
++                      break;\r
++              default:\r
++                      [pool drain];\r
++                      return GHOST_kFailure;\r
++      }\r
++}\r
++\r
++\r
++GHOST_TSuccess GHOST_WindowCocoa::invalidate()\r
++{\r
++      GHOST_ASSERT(getValid(), "GHOST_WindowCocoa::invalidate(): window invalid")\r
++      NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];\r
++      [m_openGLView setNeedsDisplay:YES];\r
++      [pool drain];\r
++      return GHOST_kSuccess;\r
++}\r
++\r
++#pragma mark Cursor handling\r
++\r
++void GHOST_WindowCocoa::loadCursor(bool visible, GHOST_TStandardCursor cursor) const\r
++{\r
++      static bool systemCursorVisible = true;\r
++      \r
++      NSAutoreleasePool *pool =[[NSAutoreleasePool alloc] init];\r
++\r
++      NSCursor *tmpCursor =nil;\r
++      \r
++      if (visible != systemCursorVisible) {\r
++              if (visible) {\r
++                      [NSCursor unhide];\r
++                      systemCursorVisible = true;\r
++              }\r
++              else {\r
++                      [NSCursor hide];\r
++                      systemCursorVisible = false;\r
++              }\r
++      }\r
++\r
++      if (cursor == GHOST_kStandardCursorCustom && m_customCursor) {\r
++              tmpCursor = m_customCursor;\r
++      } else {\r
++              switch (cursor) {\r
++                      case GHOST_kStandardCursorDestroy:\r
++                              tmpCursor = [NSCursor disappearingItemCursor];\r
++                              break;\r
++                      case GHOST_kStandardCursorText:\r
++                              tmpCursor = [NSCursor IBeamCursor];\r
++                              break;\r
++                      case GHOST_kStandardCursorCrosshair:\r
++                              tmpCursor = [NSCursor crosshairCursor];\r
++                              break;\r
++                      case GHOST_kStandardCursorUpDown:\r
++                              tmpCursor = [NSCursor resizeUpDownCursor];\r
++                              break;\r
++                      case GHOST_kStandardCursorLeftRight:\r
++                              tmpCursor = [NSCursor resizeLeftRightCursor];\r
++                              break;\r
++                      case GHOST_kStandardCursorTopSide:\r
++                              tmpCursor = [NSCursor resizeUpCursor];\r
++                              break;\r
++                      case GHOST_kStandardCursorBottomSide:\r
++                              tmpCursor = [NSCursor resizeDownCursor];\r
++                              break;\r
++                      case GHOST_kStandardCursorLeftSide:\r
++                              tmpCursor = [NSCursor resizeLeftCursor];\r
++                              break;\r
++                      case GHOST_kStandardCursorRightSide:\r
++                              tmpCursor = [NSCursor resizeRightCursor];\r
++                              break;\r
++                      case GHOST_kStandardCursorRightArrow:\r
++                      case GHOST_kStandardCursorInfo:\r
++                      case GHOST_kStandardCursorLeftArrow:\r
++                      case GHOST_kStandardCursorHelp:\r
++                      case GHOST_kStandardCursorCycle:\r
++                      case GHOST_kStandardCursorSpray:\r
++                      case GHOST_kStandardCursorWait:\r
++                      case GHOST_kStandardCursorTopLeftCorner:\r
++                      case GHOST_kStandardCursorTopRightCorner:\r
++                      case GHOST_kStandardCursorBottomRightCorner:\r
++                      case GHOST_kStandardCursorBottomLeftCorner:\r
++                      case GHOST_kStandardCursorDefault:\r
++                      default:\r
++                              tmpCursor = [NSCursor arrowCursor];\r
++                              break;\r
++              };\r
++      }\r
++      [tmpCursor set];\r
++      [pool drain];\r
++}\r
++\r
++\r
++\r
++GHOST_TSuccess GHOST_WindowCocoa::setWindowCursorVisibility(bool visible)\r
++{\r
++      if ([m_window isVisible]) {\r
++              loadCursor(visible, getCursorShape());\r
++      }\r
++      \r
++      return GHOST_kSuccess;\r
++}\r
++\r
++\r
++//Override this method to provide set feature even if not in warp\r
++inline bool GHOST_WindowCocoa::setCursorWarpAccum(GHOST_TInt32 x, GHOST_TInt32 y)\r
++{\r
++      m_cursorWarpAccumPos[0]= x;\r
++      m_cursorWarpAccumPos[1]= y;\r
++      \r
++      return GHOST_kSuccess;\r
++}\r
++\r
++\r
++GHOST_TSuccess GHOST_WindowCocoa::setWindowCursorGrab(bool grab, bool warp, bool restore)\r
++{\r
++      if (grab)\r
++      {\r
++              //No need to perform grab without warp as it is always on in OS X\r
++              if(warp) {\r
++                      GHOST_TInt32 x_old,y_old;\r
++\r
++                      m_cursorWarp= true;\r
++                      m_systemCocoa->getCursorPosition(x_old,y_old);\r
++                      screenToClient(x_old, y_old, m_cursorWarpInitPos[0], m_cursorWarpInitPos[1]);\r
++                      //Warp position is stored in client (window base) coordinates\r
++                      setWindowCursorVisibility(false);\r
++                      return CGAssociateMouseAndMouseCursorPosition(false) == kCGErrorSuccess ? GHOST_kSuccess : GHOST_kFailure;\r
++              }\r
++      }\r
++      else {\r
++              if(m_cursorWarp)\r
++              {/* are we exiting warp */\r
++                      setWindowCursorVisibility(true);\r
++                      /* Almost works without but important otherwise the mouse GHOST location can be incorrect on exit */\r
++                      if(restore) {\r
++                              GHOST_Rect bounds;\r
++                              GHOST_TInt32 x_new, y_new, x_cur, y_cur;\r
++                              \r
++                              getClientBounds(bounds);\r
++                              x_new= m_cursorWarpInitPos[0]+m_cursorWarpAccumPos[0];\r
++                              y_new= m_cursorWarpInitPos[1]+m_cursorWarpAccumPos[1];\r
++                              \r
++                              if(x_new < 0)           x_new = 0;\r
++                              if(y_new < 0)           y_new = 0;\r
++                              if(x_new > bounds.getWidth())   x_new = bounds.getWidth();\r
++                              if(y_new > bounds.getHeight())  y_new = bounds.getHeight();\r
++                              \r
++                              //get/set cursor position works in screen coordinates\r
++                              clientToScreen(x_new, y_new, x_cur, y_cur);\r
++                              m_systemCocoa->setCursorPosition(x_cur, y_cur);\r
++                              \r
++                              //As Cocoa will give as first deltaX,deltaY this change in cursor position, we need to compensate for it\r
++                              //Issue appearing in case of two transform operations conducted w/o mouse motion in between\r
++                              x_new=m_cursorWarpAccumPos[0];\r
++                              y_new=m_cursorWarpAccumPos[1];\r
++                              setCursorWarpAccum(-x_new, -y_new);\r
++                      }\r
++                      else {\r
++                              GHOST_TInt32 x_new, y_new;\r
++                              //get/set cursor position works in screen coordinates\r
++                              clientToScreen(m_cursorWarpInitPos[0], m_cursorWarpInitPos[1], x_new, y_new);\r
++                              m_systemCocoa->setCursorPosition(x_new, y_new);\r
++                              setCursorWarpAccum(0, 0);\r
++                      }\r
++                      \r
++                      m_cursorWarp= false;\r
++                      return CGAssociateMouseAndMouseCursorPosition(true) == kCGErrorSuccess ? GHOST_kSuccess : GHOST_kFailure;\r
++              }\r
++      }\r
++      return GHOST_kSuccess;\r
++}\r
++      \r
++GHOST_TSuccess GHOST_WindowCocoa::setWindowCursorShape(GHOST_TStandardCursor shape)\r
++{\r
++      if (m_customCursor) {\r
++              [m_customCursor release];\r
++              m_customCursor = nil;\r
++      }\r
++\r
++      if ([m_window isVisible]) {\r
++              loadCursor(getCursorVisibility(), shape);\r
++      }\r
++      \r
++      return GHOST_kSuccess;\r
++}\r
++\r
++/** Reverse the bits in a GHOST_TUns8\r
++static GHOST_TUns8 uns8ReverseBits(GHOST_TUns8 ch)\r
++{\r
++      ch= ((ch>>1)&0x55) | ((ch<<1)&0xAA);\r
++      ch= ((ch>>2)&0x33) | ((ch<<2)&0xCC);\r
++      ch= ((ch>>4)&0x0F) | ((ch<<4)&0xF0);\r
++      return ch;\r
++}\r
++*/\r
++\r
++\r
++/** Reverse the bits in a GHOST_TUns16 */\r
++static GHOST_TUns16 uns16ReverseBits(GHOST_TUns16 shrt)\r
++{\r
++      shrt= ((shrt>>1)&0x5555) | ((shrt<<1)&0xAAAA);\r
++      shrt= ((shrt>>2)&0x3333) | ((shrt<<2)&0xCCCC);\r
++      shrt= ((shrt>>4)&0x0F0F) | ((shrt<<4)&0xF0F0);\r
++      shrt= ((shrt>>8)&0x00FF) | ((shrt<<8)&0xFF00);\r
++      return shrt;\r
++}\r
++\r
++GHOST_TSuccess GHOST_WindowCocoa::setWindowCustomCursorShape(GHOST_TUns8 *bitmap, GHOST_TUns8 *mask,\r
++                                      int sizex, int sizey, int hotX, int hotY, int fg_color, int bg_color)\r
++{\r
++      int y,nbUns16;\r
++      NSPoint hotSpotPoint;\r
++      NSBitmapImageRep *cursorImageRep;\r
++      NSImage *cursorImage;\r
++      NSSize imSize;\r
++      GHOST_TUns16 *cursorBitmap;\r
++      \r
++      \r
++      NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];\r
++      \r
++      if (m_customCursor) {\r
++              [m_customCursor release];\r
++              m_customCursor = nil;\r
++      }\r
++      \r
++\r
++      cursorImageRep = [[NSBitmapImageRep alloc] initWithBitmapDataPlanes:nil\r
++                                                                                                                       pixelsWide:sizex\r
++                                                                                                                       pixelsHigh:sizey\r
++                                                                                                                bitsPerSample:1 \r
++                                                                                                              samplesPerPixel:2\r
++                                                                                                                         hasAlpha:YES\r
++                                                                                                                         isPlanar:YES\r
++                                                                                                               colorSpaceName:NSDeviceBlackColorSpace\r
++                                                                                                                      bytesPerRow:(sizex/8 + (sizex%8 >0 ?1:0))\r
++                                                                                                                 bitsPerPixel:1];\r
++      \r
++      \r
++      cursorBitmap = (GHOST_TUns16*)[cursorImageRep bitmapData];\r
++      nbUns16 = [cursorImageRep bytesPerPlane]/2;\r
++      \r
++      for (y=0; y<nbUns16; y++) {\r
++#if !defined(__LITTLE_ENDIAN__)\r
++              cursorBitmap[y] = uns16ReverseBits((bitmap[2*y]<<0) | (bitmap[2*y+1]<<8));\r
++              cursorBitmap[nbUns16+y] = uns16ReverseBits((mask[2*y]<<0) | (mask[2*y+1]<<8));\r
++#else\r
++              cursorBitmap[y] = uns16ReverseBits((bitmap[2*y+1]<<0) | (bitmap[2*y]<<8));\r
++              cursorBitmap[nbUns16+y] = uns16ReverseBits((mask[2*y+1]<<0) | (mask[2*y]<<8));\r
++#endif\r
++              \r
++      }\r
++      \r
++      \r
++      imSize.width = sizex;\r
++      imSize.height= sizey;\r
++      cursorImage = [[NSImage alloc] initWithSize:imSize];\r
++      [cursorImage addRepresentation:cursorImageRep];\r
++      \r
++      hotSpotPoint.x = hotX;\r
++      hotSpotPoint.y = hotY;\r
++      \r
++      //foreground and background color parameter is not handled for now (10.6)\r
++      m_customCursor = [[NSCursor alloc] initWithImage:cursorImage\r
++                                                                                       hotSpot:hotSpotPoint];\r
++      \r
++      [cursorImageRep release];\r
++      [cursorImage release];\r
++      \r
++      if ([m_window isVisible]) {\r
++              loadCursor(getCursorVisibility(), GHOST_kStandardCursorCustom);\r
++      }\r
++      [pool drain];\r
++      return GHOST_kSuccess;\r
++}\r
++\r
++GHOST_TSuccess GHOST_WindowCocoa::setWindowCustomCursorShape(GHOST_TUns8 bitmap[16][2], \r
++                                                                                              GHOST_TUns8 mask[16][2], int hotX, int hotY)\r
++{\r
++      return setWindowCustomCursorShape((GHOST_TUns8*)bitmap, (GHOST_TUns8*) mask, 16, 16, hotX, hotY, 0, 1);\r
++}\r
index 9b31a06edb3edf3e4c0801e78d0d8a1eb122202b,0000000000000000000000000000000000000000..ad1654d2f3afa3113de76717f4632de2c68db061
mode 100644,000000..100644
--- /dev/null
@@@ -1,3363 -1,0 +1,3364 @@@
-               BM_ITER(v, &iter, em->bm, BM_VERTS_OF_MESH, NULL)
 + /* $Id: bmesh_tools.c
 + *
 + * ***** BEGIN GPL LICENSE BLOCK *****
 + *
 + * This program is free software; you can redistribute it and/or
 + * modify it under the terms of the GNU General Public License
 + * as published by the Free Software Foundation; either version 2
 + * of the License, or (at your option) any later version.
 + *
 + * This program is distributed in the hope that it will be useful,
 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 + * GNU General Public License for more details.
 + *
 + * You should have received a copy of the GNU General Public License
 + * along with this program; if not, write to the Free Software Foundation,
 + * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 + *
 + * The Original Code is Copyright (C) 2004 by Blender Foundation.
 + * All rights reserved.
 + *
 + * The Original Code is: all of this file.
 + *
 + * Contributor(s): Joseph Eagar
 + *
 + * ***** END GPL LICENSE BLOCK *****
 + */
 +#include <stdlib.h>
 +#include <stdarg.h>
 +#include <string.h>
 +#include <math.h>
 +#include <float.h>
 +
 +#include "MEM_guardedalloc.h"
 +#include "PIL_time.h"
 +
 +#include "BLO_sys_types.h" // for intptr_t support
 +
 +#include "DNA_mesh_types.h"
 +#include "DNA_material_types.h"
 +#include "DNA_meshdata_types.h"
 +#include "DNA_modifier_types.h"
 +#include "DNA_object_types.h"
 +#include "DNA_scene_types.h"
 +#include "DNA_screen_types.h"
 +#include "DNA_view3d_types.h"
 +#include "DNA_key_types.h"
 +#include "DNA_windowmanager_types.h"
 +
 +#include "RNA_types.h"
 +#include "RNA_define.h"
 +#include "RNA_access.h"
 +
 +#include "BLI_blenlib.h"
 +#include "BLI_arithb.h"
 +#include "BLI_editVert.h"
 +#include "BLI_rand.h"
 +#include "BLI_ghash.h"
 +#include "BLI_linklist.h"
 +#include "BLI_heap.h"
 +#include "BLI_array.h"
 +
 +#include "BKE_context.h"
 +#include "BKE_customdata.h"
 +#include "BKE_depsgraph.h"
 +#include "BKE_global.h"
 +#include "BKE_library.h"
 +#include "BKE_mesh.h"
 +#include "BKE_object.h"
 +#include "BKE_utildefines.h"
 +#include "BKE_bmesh.h"
 +#include "BKE_report.h"
 +#include "BKE_tessmesh.h"
 +
 +#include "BIF_gl.h"
 +#include "BIF_glutil.h"
 +
 +#include "WM_api.h"
 +#include "WM_types.h"
 +
 +#include "ED_mesh.h"
 +#include "ED_view3d.h"
 +#include "ED_util.h"
 +#include "ED_screen.h"
 +#include "ED_transform.h"
 +
 +#include "UI_interface.h"
 +
 +#include "mesh_intern.h"
 +#include "bmesh.h"
 +
 +#include "editbmesh_bvh.h"
 +
 +static void add_normal_aligned(float *nor, float *add)
 +{
 +      if( INPR(nor, add) < -0.9999f)
 +              VecSubf(nor, nor, add);
 +      else
 +              VecAddf(nor, nor, add);
 +}
 +
 +
 +static int subdivide_exec(bContext *C, wmOperator *op)
 +{
 +      ToolSettings *ts = CTX_data_tool_settings(C);
 +      Object *obedit= CTX_data_edit_object(C);
 +      BMEditMesh *em= ((Mesh *)obedit->data)->edit_btmesh;
 +      int cuts= RNA_int_get(op->ptr,"number_cuts");
 +      float smooth= 0.292f*RNA_float_get(op->ptr, "smoothness");
 +      float fractal= RNA_float_get(op->ptr, "fractal")/100;
 +      int flag= 0;
 +
 +      if(smooth != 0.0f)
 +              flag |= B_SMOOTH;
 +      if(fractal != 0.0f)
 +              flag |= B_FRACTAL;
 +
 +      BM_esubdivideflag(obedit, em->bm, BM_SELECT, 
 +                        smooth, fractal, 
 +                        ts->editbutflag|flag, 
 +                        cuts, 0, RNA_enum_get(op->ptr, "quadcorner"), 
 +                        RNA_boolean_get(op->ptr, "tess_single_edge"),
 +                        RNA_boolean_get(op->ptr, "gridfill"));
 +
 +      DAG_id_flush_update(obedit->data, OB_RECALC_DATA);
 +      WM_event_add_notifier(C, NC_GEOM|ND_DATA, obedit->data);
 +
 +      return OPERATOR_FINISHED;
 +}
 +
 +/* Note, these values must match delete_mesh() event values */
 +static EnumPropertyItem prop_mesh_cornervert_types[] = {
 +      {SUBD_INNERVERT,     "INNERVERT", 0,      "Inner Vert", ""},
 +      {SUBD_PATH,          "PATH", 0,           "Path", ""},
 +      {SUBD_STRAIGHT_CUT,  "STRAIGHT_CUT", 0,   "Straight Cut", ""},
 +      {SUBD_FAN,           "FAN", 0,            "Fan", ""},
 +      {0, NULL, 0, NULL, NULL}
 +};
 +
 +void MESH_OT_subdivide(wmOperatorType *ot)
 +{
 +      /* identifiers */
 +      ot->name= "Subdivide";
 +      ot->description= "Subdivide selected edges.";
 +      ot->idname= "MESH_OT_subdivide";
 +
 +      /* api callbacks */
 +      ot->exec= subdivide_exec;
 +      ot->poll= ED_operator_editmesh;
 +
 +      /* flags */
 +      ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
 +
 +      /* properties */
 +      RNA_def_int(ot->srna, "number_cuts", 1, 1, 20, "Number of Cuts", "", 1, INT_MAX);
 +      RNA_def_float(ot->srna, "fractal", 0.0, 0.0f, FLT_MAX, "Fractal", "Fractal randomness factor.", 0.0f, 1000.0f);
 +      RNA_def_float(ot->srna, "smoothness", 0.0f, 0.0f, 1000.0f, "Smoothness", "Smoothness factor.", 0.0f, FLT_MAX);
 +
 +      /*props */
 +      RNA_def_enum(ot->srna, "quadcorner", prop_mesh_cornervert_types, SUBD_STRAIGHT_CUT, "Quad Corner Type", "Method used for subdividing two adjacent edges in a quad");
 +      RNA_def_boolean(ot->srna, "tess_single_edge", 0, "Tesselate Single Edge", "Adds triangles to single edges belonging to triangles or quads");
 +      RNA_def_boolean(ot->srna, "gridfill", 1, "Grid Fill", "Fill Fully Selected Triangles and Quads With A Grid");
 +}
 +
 +/* individual face extrude */
 +/* will use vertex normals for extrusion directions, so *nor is unaffected */
 +short EDBM_Extrude_face_indiv(BMEditMesh *em, wmOperator *op, short flag, float *nor) 
 +{
 +      BMOIter siter;
 +      BMIter liter;
 +      BMFace *f;
 +      BMLoop *l;
 +      BMOperator bmop;
 +
 +      EDBM_InitOpf(em, &bmop, op, "extrude_face_indiv faces=%hf", flag);
 +
 +      /*deselect original verts*/
 +      EDBM_clear_flag_all(em, BM_SELECT);
 +
 +      BMO_Exec_Op(em->bm, &bmop);
 +      
 +      BMO_ITER(f, &siter, em->bm, &bmop, "faceout", BM_FACE) {
 +              BM_Select(em->bm, f, 1);
 +
 +              /*set face vertex normals to face normal*/
 +              BM_ITER(l, &liter, em->bm, BM_LOOPS_OF_FACE, f) {
 +                      VECCOPY(l->v->no, f->no);
 +              }
 +      }
 +
 +      if (!EDBM_FinishOp(em, &bmop, op, 1)) return 0;
 +
 +      return 's'; // s is shrink/fatten
 +}
 +
 +#if 0
 +short EDBM_Extrude_face_indiv(BMEditMesh *em, wmOperator *op, short flag, float *nor) 
 +      EditVert *eve, *v1, *v2, *v3, *v4;
 +      EditEdge *eed;
 +      EditFace *efa, *nextfa;
 +      
 +      if(em==NULL) return 0;
 +      
 +      /* selected edges with 1 or more selected face become faces */
 +      /* selected faces each makes new faces */
 +      /* always remove old faces, keeps volumes manifold */
 +      /* select the new extrusion, deselect old */
 +      
 +      /* step 1; init, count faces in edges */
 +      recalc_editnormals(em);
 +      
 +      for(eve= em->verts.first; eve; eve= eve->next) eve->f1= 0;      // new select flag
 +
 +      for(eed= em->edges.first; eed; eed= eed->next) {
 +              eed->f2= 0; // amount of unselected faces
 +      }
 +      for(efa= em->faces.first; efa; efa= efa->next) {
 +              if(efa->f & SELECT);
 +              else {
 +                      efa->e1->f2++;
 +                      efa->e2->f2++;
 +                      efa->e3->f2++;
 +                      if(efa->e4) efa->e4->f2++;
 +              }
 +      }
 +
 +      /* step 2: make new faces from faces */
 +      for(efa= em->faces.last; efa; efa= efa->prev) {
 +              if(efa->f & SELECT) {
 +                      v1= addvertlist(em, efa->v1->co, efa->v1);
 +                      v2= addvertlist(em, efa->v2->co, efa->v2);
 +                      v3= addvertlist(em, efa->v3->co, efa->v3);
 +                      
 +                      v1->f1= v2->f1= v3->f1= 1;
 +                      VECCOPY(v1->no, efa->n);
 +                      VECCOPY(v2->no, efa->n);
 +                      VECCOPY(v3->no, efa->n);
 +                      if(efa->v4) {
 +                              v4= addvertlist(em, efa->v4->co, efa->v4); 
 +                              v4->f1= 1;
 +                              VECCOPY(v4->no, efa->n);
 +                      }
 +                      else v4= NULL;
 +                      
 +                      /* side faces, clockwise */
 +                      addfacelist(em, efa->v2, v2, v1, efa->v1, efa, NULL);
 +                      addfacelist(em, efa->v3, v3, v2, efa->v2, efa, NULL);
 +                      if(efa->v4) {
 +                              addfacelist(em, efa->v4, v4, v3, efa->v3, efa, NULL);
 +                              addfacelist(em, efa->v1, v1, v4, efa->v4, efa, NULL);
 +                      }
 +                      else {
 +                              addfacelist(em, efa->v1, v1, v3, efa->v3, efa, NULL);
 +                      }
 +                      /* top face */
 +                      addfacelist(em, v1, v2, v3, v4, efa, NULL);
 +              }
 +      }
 +      
 +      /* step 3: remove old faces */
 +      efa= em->faces.first;
 +      while(efa) {
 +              nextfa= efa->next;
 +              if(efa->f & SELECT) {
 +                      BLI_remlink(&em->faces, efa);
 +                      free_editface(em, efa);
 +              }
 +              efa= nextfa;
 +      }
 +
 +      /* step 4: redo selection */
 +      EM_clear_flag_all(em, SELECT);
 +      
 +      for(eve= em->verts.first; eve; eve= eve->next) {
 +              if(eve->f1)  eve->f |= SELECT;
 +      }
 +      
 +      EM_select_flush(em);
 +      
 +      return 'n';
 +}
 +#endif
 +
 +/* extrudes individual edges */
 +short EDBM_Extrude_edges_indiv(BMEditMesh *em, wmOperator *op, short flag, float *nor) 
 +{
 +      BMOperator bmop;
 +
 +      EDBM_InitOpf(em, &bmop, op, "extrude_edge_only edges=%he", flag);
 +
 +      /*deselect original verts*/
 +      EDBM_clear_flag_all(em, BM_SELECT);
 +
 +      BMO_Exec_Op(em->bm, &bmop);
 +      BMO_HeaderFlag_Buffer(em->bm, &bmop, "geomout", BM_SELECT, BM_VERT|BM_EDGE);
 +
 +      if (!EDBM_FinishOp(em, &bmop, op, 1)) return 0;
 +
 +      return 'n'; // n is normal grab
 +}
 +
 +#if 0
 +/* nor is filled with constraint vector */
 +short EDBM_Extrude_edges_indiv(BMEditMesh *em, short flag, float *nor) 
 +{
 +      EditVert *eve;
 +      EditEdge *eed;
 +      EditFace *efa;
 +      
 +      for(eve= em->verts.first; eve; eve= eve->next) eve->tmp.v = NULL;
 +      for(eed= em->edges.first; eed; eed= eed->next) {
 +              eed->tmp.f = NULL;
 +              eed->f2= ((eed->f & flag)!=0);
 +      }
 +      
 +      set_edge_directions_f2(em, 2);
 +
 +      /* sample for next loop */
 +      for(efa= em->faces.first; efa; efa= efa->next) {
 +              efa->e1->tmp.f = efa;
 +              efa->e2->tmp.f = efa;
 +              efa->e3->tmp.f = efa;
 +              if(efa->e4) efa->e4->tmp.f = efa;
 +      }
 +      /* make the faces */
 +      for(eed= em->edges.first; eed; eed= eed->next) {
 +              if(eed->f & flag) {
 +                      if(eed->v1->tmp.v == NULL)
 +                              eed->v1->tmp.v = addvertlist(em, eed->v1->co, eed->v1);
 +                      if(eed->v2->tmp.v == NULL)
 +                              eed->v2->tmp.v = addvertlist(em, eed->v2->co, eed->v2);
 +
 +                      if(eed->dir==1) 
 +                              addfacelist(em, eed->v1, eed->v2, 
 +                                                      eed->v2->tmp.v, eed->v1->tmp.v, 
 +                                                      eed->tmp.f, NULL);
 +                      else 
 +                              addfacelist(em, eed->v2, eed->v1, 
 +                                                      eed->v1->tmp.v, eed->v2->tmp.v, 
 +                                                      eed->tmp.f, NULL);
 +
 +                      /* for transform */
 +                      if(eed->tmp.f) {
 +                              efa = eed->tmp.f;
 +                              if (efa->f & SELECT) add_normal_aligned(nor, efa->n);
 +                      }
 +              }
 +      }
 +      Normalize(nor);
 +      
 +      /* set correct selection */
 +      EM_clear_flag_all(em, SELECT);
 +      for(eve= em->verts.last; eve; eve= eve->prev) {
 +              if(eve->tmp.v) {
 +                      eve->tmp.v->f |= flag;
 +              }
 +      }
 +
 +      for(eed= em->edges.first; eed; eed= eed->next) {
 +              if(eed->v1->f & eed->v2->f & flag) eed->f |= flag;
 +      }
 +      
 +      if(nor[0]==0.0 && nor[1]==0.0 && nor[2]==0.0) return 'g'; // g is grab
 +      return 'n';  // n is for normal constraint
 +}
 +#endif
 +
 +/* extrudes individual vertices */
 +short EDBM_Extrude_verts_indiv(BMEditMesh *em, wmOperator *op, short flag, float *nor) 
 +{
 +      BMOperator bmop;
 +
 +      EDBM_InitOpf(em, &bmop, op, "extrude_vert_indiv verts=%hv", flag);
 +
 +      /*deselect original verts*/
 +      BMO_UnHeaderFlag_Buffer(em->bm, &bmop, "verts", BM_SELECT, BM_VERT);
 +
 +      BMO_Exec_Op(em->bm, &bmop);
 +      BMO_HeaderFlag_Buffer(em->bm, &bmop, "vertout", BM_SELECT, BM_VERT);
 +
 +      if (!EDBM_FinishOp(em, &bmop, op, 1)) return 0;
 +
 +      return 'g'; // g is grab
 +}
 +
 +short EDBM_Extrude_edge(Object *obedit, BMEditMesh *em, int flag, float *nor)
 +{
 +      BMesh *bm = em->bm;
 +      BMIter iter;
 +      BMOIter siter;
 +      BMOperator extop;
 +      BMVert *vert;
 +      BMEdge *edge;
 +      BMFace *f;
 +      ModifierData *md;
 +      BMHeader *el;
 +      
 +      BMO_Init_Op(&extop, "extrudefaceregion");
 +      BMO_HeaderFlag_To_Slot(bm, &extop, "edgefacein",
 +                             flag, BM_VERT|BM_EDGE|BM_FACE);
 +
 +      BM_ITER(vert, &iter, bm, BM_VERTS_OF_MESH, NULL) {
 +              BM_Select(bm, vert, 0);
 +      }
 +
 +      BM_ITER(edge, &iter, bm, BM_EDGES_OF_MESH, NULL) {
 +              BM_Select(bm, edge, 0);
 +      }
 +
 +      BM_ITER(f, &iter, bm, BM_FACES_OF_MESH, NULL) {
 +              BM_Select(bm, f, 0);
 +      }
 +
 +      /* If a mirror modifier with clipping is on, we need to adjust some 
 +       * of the cases above to handle edges on the line of symmetry.
 +       */
 +      md = obedit->modifiers.first;
 +      for (; md; md=md->next) {
 +              if (md->type==eModifierType_Mirror) {
 +                      MirrorModifierData *mmd = (MirrorModifierData*) md;     
 +              
 +                      if(mmd->flag & MOD_MIR_CLIPPING) {
 +                              float mtx[4][4];
 +                              if (mmd->mirror_ob) {
 +                                      float imtx[4][4];
 +                                      Mat4Invert(imtx, mmd->mirror_ob->obmat);
 +                                      Mat4MulMat4(mtx, obedit->obmat, imtx);
 +                              }
 +
 +                              for (edge=BMIter_New(&iter,bm,BM_EDGES_OF_MESH,NULL);
 +                                   edge; edge=BMIter_Step(&iter))
 +                              {
 +                                      if(edge->head.flag & flag) {
 +                                              float co1[3], co2[3];
 +
 +                                              VecCopyf(co1, edge->v1->co);
 +                                              VecCopyf(co2, edge->v2->co);
 +
 +                                              if (mmd->mirror_ob) {
 +                                                      VecMat4MulVecfl(co1, mtx, co1);
 +                                                      VecMat4MulVecfl(co2, mtx, co2);
 +                                              }
 +
 +                                              if (mmd->flag & MOD_MIR_AXIS_X)
 +                                                      if ( (fabs(co1[0]) < mmd->tolerance) &&
 +                                                               (fabs(co2[0]) < mmd->tolerance) )
 +                                                              BMO_Insert_MapPointer(bm, &extop, "exclude", edge, NULL);
 +
 +                                              if (mmd->flag & MOD_MIR_AXIS_Y)
 +                                                      if ( (fabs(co1[1]) < mmd->tolerance) &&
 +                                                               (fabs(co2[1]) < mmd->tolerance) )
 +                                                              BMO_Insert_MapPointer(bm, &extop, "exclude", edge, NULL);
 +
 +                                              if (mmd->flag & MOD_MIR_AXIS_Z)
 +                                                      if ( (fabs(co1[2]) < mmd->tolerance) &&
 +                                                               (fabs(co2[2]) < mmd->tolerance) )
 +                                                              BMO_Insert_MapPointer(bm, &extop, "exclude", edge, NULL);
 +                                      }
 +                              }
 +                      }
 +              }
 +      }
 +
 +      BMO_Exec_Op(bm, &extop);
 +
 +      nor[0] = nor[1] = nor[2] = 0.0f;
 +      
 +      BMO_ITER(el, &siter, bm, &extop, "geomout", BM_ALL) {
 +              BM_Select(bm, el, 1);
 +
 +              if (el->type == BM_FACE) {
 +                      f = (BMFace*)el;
 +                      add_normal_aligned(nor, f->no);
 +              };
 +      }
 +
 +      Normalize(nor);
 +
 +      BMO_Finish_Op(bm, &extop);
 +
 +      if(nor[0]==0.0 && nor[1]==0.0 && nor[2]==0.0) return 'g'; // grab
 +      return 'n'; // normal constraint 
 +
 +}
 +short EDBM_Extrude_vert(Object *obedit, BMEditMesh *em, short flag, float *nor)
 +{
 +              BMIter iter;
 +              BMEdge *eed;
 +              
 +              /*ensure vert flags are consistent for edge selections*/
 +              eed = BMIter_New(&iter, em->bm, BM_EDGES_OF_MESH, NULL);
 +              for ( ; eed; eed=BMIter_Step(&iter)) {
 +                      if (BM_TestHFlag(eed, flag)) {
 +                              if (flag != BM_SELECT) {
 +                                      BM_SetHFlag(eed->v1, flag);
 +                                      BM_SetHFlag(eed->v2, flag);
 +                              } else {
 +                                      BM_Select(em->bm, eed->v1, 1);
 +                                      BM_Select(em->bm, eed->v2, 1);
 +                              }
 +                      } else {
 +                              if (BM_TestHFlag(eed->v1, flag) && BM_TestHFlag(eed->v2, flag)) {
 +                                      if (flag != BM_SELECT)
 +                                              BM_SetHFlag(eed, flag);
 +                                      else BM_Select(em->bm, eed, 1);
 +                              }
 +                      }
 +              }
 +
 +              return EDBM_Extrude_edge(obedit, em, flag, nor);
 +
 +}
 +
 +static int extrude_repeat_mesh(bContext *C, wmOperator *op)
 +{
 +      Object *obedit= CTX_data_edit_object(C);
 +      Scene *scene = CTX_data_scene(C);
 +      BMEditMesh *em = ((Mesh *)obedit->data)->edit_btmesh;
 +      RegionView3D *rv3d = CTX_wm_region_view3d(C);           
 +              
 +      int steps = RNA_int_get(op->ptr,"steps");
 +      
 +      float offs = RNA_float_get(op->ptr,"offset");
 +      float dvec[3], tmat[3][3], bmat[3][3], nor[3]= {0.0, 0.0, 0.0};
 +      short a;
 +
 +      /* dvec */
 +      dvec[0]= rv3d->persinv[2][0];
 +      dvec[1]= rv3d->persinv[2][1];
 +      dvec[2]= rv3d->persinv[2][2];
 +      Normalize(dvec);
 +      dvec[0]*= offs;