ClangFormat: apply to source, most of intern

Apply clang format as proposed in T53211.

For details on usage and instructions for migrating branches
without conflicts, see:

https://wiki.blender.org/wiki/Tools/ClangFormat

1 files changed, 809 insertions, 773 deletions

diff --git a/intern/ghost/intern/GHOST_WindowCocoa.mm b/intern/ghost/intern/GHOST_WindowCocoa.mm
index 1af39f11f08..46343e17e46 100644
--- a/intern/ghost/intern/GHOST_WindowCocoa.mm
+++ b/intern/ghost/intern/GHOST_WindowCocoa.mm
@@ -34,14 +34,14 @@
 
 #pragma mark Cocoa window delegate object
 
-@interface CocoaWindowDelegate : NSObject
-<NSWindowDelegate>
+@interface CocoaWindowDelegate : NSObject <NSWindowDelegate>
 {
-	GHOST_SystemCocoa *systemCocoa;
-	GHOST_WindowCocoa *associatedWindow;
+  GHOST_SystemCocoa *systemCocoa;
+  GHOST_WindowCocoa *associatedWindow;
 }
 
-- (void)setSystemAndWindowCocoa:(GHOST_SystemCocoa *)sysCocoa windowCocoa:(GHOST_WindowCocoa *)winCocoa;
+- (void)setSystemAndWindowCocoa:(GHOST_SystemCocoa *)sysCocoa
+                    windowCocoa:(GHOST_WindowCocoa *)winCocoa;
 - (void)windowDidBecomeKey:(NSNotification *)notification;
 - (void)windowDidResignKey:(NSNotification *)notification;
 - (void)windowDidExpose:(NSNotification *)notification;
@@ -53,183 +53,207 @@
 @end
 
 @implementation CocoaWindowDelegate : NSObject
-- (void)setSystemAndWindowCocoa:(GHOST_SystemCocoa *)sysCocoa windowCocoa:(GHOST_WindowCocoa *)winCocoa
+- (void)setSystemAndWindowCocoa:(GHOST_SystemCocoa *)sysCocoa
+                    windowCocoa:(GHOST_WindowCocoa *)winCocoa
 {
-	systemCocoa = sysCocoa;
-	associatedWindow = winCocoa;
+  systemCocoa = sysCocoa;
+  associatedWindow = winCocoa;
 }
 
 - (void)windowDidBecomeKey:(NSNotification *)notification
 {
-	systemCocoa->handleWindowEvent(GHOST_kEventWindowActivate, associatedWindow);
-	// work around for broken appswitching when combining cmd-tab and missioncontrol
-	[(NSWindow*)associatedWindow->getOSWindow() orderFrontRegardless];
+  systemCocoa->handleWindowEvent(GHOST_kEventWindowActivate, associatedWindow);
+  // work around for broken appswitching when combining cmd-tab and missioncontrol
+  [(NSWindow *)associatedWindow->getOSWindow() orderFrontRegardless];
 }
 
 - (void)windowDidResignKey:(NSNotification *)notification
 {
-	systemCocoa->handleWindowEvent(GHOST_kEventWindowDeactivate, associatedWindow);
+  systemCocoa->handleWindowEvent(GHOST_kEventWindowDeactivate, associatedWindow);
 }
 
 - (void)windowDidExpose:(NSNotification *)notification
 {
-	systemCocoa->handleWindowEvent(GHOST_kEventWindowUpdate, associatedWindow);
+  systemCocoa->handleWindowEvent(GHOST_kEventWindowUpdate, associatedWindow);
 }
 
 - (void)windowDidMove:(NSNotification *)notification
 {
-	systemCocoa->handleWindowEvent(GHOST_kEventWindowMove, associatedWindow);
+  systemCocoa->handleWindowEvent(GHOST_kEventWindowMove, associatedWindow);
 }
 
 - (void)windowWillMove:(NSNotification *)notification
 {
-	systemCocoa->handleWindowEvent(GHOST_kEventWindowMove, associatedWindow);
+  systemCocoa->handleWindowEvent(GHOST_kEventWindowMove, associatedWindow);
 }
 
 - (void)windowWillEnterFullScreen:(NSNotification *)notification
 {
-	associatedWindow->setImmediateDraw(true);
+  associatedWindow->setImmediateDraw(true);
 }
 
 - (void)windowDidEnterFullScreen:(NSNotification *)notification
 {
-	associatedWindow->setImmediateDraw(false);
+  associatedWindow->setImmediateDraw(false);
 }
 
 - (void)windowWillExitFullScreen:(NSNotification *)notification
 {
-	associatedWindow->setImmediateDraw(true);
+  associatedWindow->setImmediateDraw(true);
 }
 
 - (void)windowDidExitFullScreen:(NSNotification *)notification
 {
-	associatedWindow->setImmediateDraw(false);
+  associatedWindow->setImmediateDraw(false);
 }
 
 - (void)windowDidResize:(NSNotification *)notification
 {
-	//if (![[notification object] inLiveResize]) {
-		//Send event only once, at end of resize operation (when user has released mouse button)
-		systemCocoa->handleWindowEvent(GHOST_kEventWindowSize, associatedWindow);
-	//}
-	/* Live resize, send event, gets handled in wm_window.c. Needed because live resize runs in a modal loop, not letting main loop run */
-	 if ([[notification object] inLiveResize]) {
-		systemCocoa->dispatchEvents();
-	}
+  //if (![[notification object] inLiveResize]) {
+  //Send event only once, at end of resize operation (when user has released mouse button)
+  systemCocoa->handleWindowEvent(GHOST_kEventWindowSize, associatedWindow);
+  //}
+  /* Live resize, send event, gets handled in wm_window.c. Needed because live resize runs in a modal loop, not letting main loop run */
+  if ([[notification object] inLiveResize]) {
+    systemCocoa->dispatchEvents();
+  }
 }
 
 - (void)windowDidChangeBackingProperties:(NSNotification *)notification
 {
-	systemCocoa->handleWindowEvent(GHOST_kEventNativeResolutionChange, associatedWindow);
+  systemCocoa->handleWindowEvent(GHOST_kEventNativeResolutionChange, associatedWindow);
 }
 
 - (BOOL)windowShouldClose:(id)sender;
 {
-	//Let Blender close the window rather than closing immediately
-	systemCocoa->handleWindowEvent(GHOST_kEventWindowClose, associatedWindow);
-	return false;
+  //Let Blender close the window rather than closing immediately
+  systemCocoa->handleWindowEvent(GHOST_kEventWindowClose, associatedWindow);
+  return false;
 }
 
 @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
+@interface CocoaWindow : NSWindow
 {
-	GHOST_SystemCocoa *systemCocoa;
-	GHOST_WindowCocoa *associatedWindow;
-	GHOST_TDragnDropTypes m_draggedObjectType;
+  GHOST_SystemCocoa *systemCocoa;
+  GHOST_WindowCocoa *associatedWindow;
+  GHOST_TDragnDropTypes m_draggedObjectType;
 }
-- (void)setSystemAndWindowCocoa:(GHOST_SystemCocoa *)sysCocoa windowCocoa:(GHOST_WindowCocoa *)winCocoa;
-- (GHOST_SystemCocoa*)systemCocoa;
+- (void)setSystemAndWindowCocoa:(GHOST_SystemCocoa *)sysCocoa
+                    windowCocoa:(GHOST_WindowCocoa *)winCocoa;
+- (GHOST_SystemCocoa *)systemCocoa;
 @end
 
 @implementation CocoaWindow
-- (void)setSystemAndWindowCocoa:(GHOST_SystemCocoa *)sysCocoa windowCocoa:(GHOST_WindowCocoa *)winCocoa
+- (void)setSystemAndWindowCocoa:(GHOST_SystemCocoa *)sysCocoa
+                    windowCocoa:(GHOST_WindowCocoa *)winCocoa
 {
-	systemCocoa = sysCocoa;
-	associatedWindow = winCocoa;
+  systemCocoa = sysCocoa;
+  associatedWindow = winCocoa;
 }
-- (GHOST_SystemCocoa*)systemCocoa
+- (GHOST_SystemCocoa *)systemCocoa
 {
-	return systemCocoa;
+  return systemCocoa;
 }
 
--(BOOL)canBecomeKeyWindow
+- (BOOL)canBecomeKeyWindow
 {
-	return YES;
+  return YES;
 }
 
 //The drag'n'drop dragging destination methods
-- (NSDragOperation)draggingEntered:(id < NSDraggingInfo >)sender
-{
-	NSPoint mouseLocation = [sender draggingLocation];
-	NSPasteboard *draggingPBoard = [sender draggingPasteboard];
-
-	if ([[draggingPBoard types] containsObject:NSTIFFPboardType]) m_draggedObjectType = GHOST_kDragnDropTypeBitmap;
-	else if ([[draggingPBoard types] containsObject:NSFilenamesPboardType]) m_draggedObjectType = GHOST_kDragnDropTypeFilenames;
-	else if ([[draggingPBoard types] containsObject:NSStringPboardType]) m_draggedObjectType = GHOST_kDragnDropTypeString;
-	else return NSDragOperationNone;
-
-	associatedWindow->setAcceptDragOperation(TRUE); //Drag operation is accepted by default
-	systemCocoa->handleDraggingEvent(GHOST_kEventDraggingEntered, m_draggedObjectType, associatedWindow, mouseLocation.x, mouseLocation.y, nil);
-	return NSDragOperationCopy;
+- (NSDragOperation)draggingEntered:(id<NSDraggingInfo>)sender
+{
+  NSPoint mouseLocation = [sender draggingLocation];
+  NSPasteboard *draggingPBoard = [sender draggingPasteboard];
+
+  if ([[draggingPBoard types] containsObject:NSTIFFPboardType])
+    m_draggedObjectType = GHOST_kDragnDropTypeBitmap;
+  else if ([[draggingPBoard types] containsObject:NSFilenamesPboardType])
+    m_draggedObjectType = GHOST_kDragnDropTypeFilenames;
+  else if ([[draggingPBoard types] containsObject:NSStringPboardType])
+    m_draggedObjectType = GHOST_kDragnDropTypeString;
+  else
+    return NSDragOperationNone;
+
+  associatedWindow->setAcceptDragOperation(TRUE);  //Drag operation is accepted by default
+  systemCocoa->handleDraggingEvent(GHOST_kEventDraggingEntered,
+                                   m_draggedObjectType,
+                                   associatedWindow,
+                                   mouseLocation.x,
+                                   mouseLocation.y,
+                                   nil);
+  return NSDragOperationCopy;
 }
 
 - (BOOL)wantsPeriodicDraggingUpdates
 {
-	return NO; //No need to overflow blender event queue. Events shall be sent only on changes
+  return NO;  //No need to overflow blender event queue. Events shall be sent only on changes
 }
 
-- (NSDragOperation)draggingUpdated:(id < NSDraggingInfo >)sender
+- (NSDragOperation)draggingUpdated:(id<NSDraggingInfo>)sender
 {
-	NSPoint mouseLocation = [sender draggingLocation];
+  NSPoint mouseLocation = [sender draggingLocation];
 
-	systemCocoa->handleDraggingEvent(GHOST_kEventDraggingUpdated, m_draggedObjectType, associatedWindow, mouseLocation.x, mouseLocation.y, nil);
-	return associatedWindow->canAcceptDragOperation() ? NSDragOperationCopy : NSDragOperationNone;
+  systemCocoa->handleDraggingEvent(GHOST_kEventDraggingUpdated,
+                                   m_draggedObjectType,
+                                   associatedWindow,
+                                   mouseLocation.x,
+                                   mouseLocation.y,
+                                   nil);
+  return associatedWindow->canAcceptDragOperation() ? NSDragOperationCopy : NSDragOperationNone;
 }
 
-- (void)draggingExited:(id < NSDraggingInfo >)sender
+- (void)draggingExited:(id<NSDraggingInfo>)sender
 {
-	systemCocoa->handleDraggingEvent(GHOST_kEventDraggingExited, m_draggedObjectType, associatedWindow, 0, 0, nil);
-	m_draggedObjectType = GHOST_kDragnDropTypeUnknown;
+  systemCocoa->handleDraggingEvent(
+      GHOST_kEventDraggingExited, m_draggedObjectType, associatedWindow, 0, 0, nil);
+  m_draggedObjectType = GHOST_kDragnDropTypeUnknown;
 }
 
-- (BOOL)prepareForDragOperation:(id < NSDraggingInfo >)sender
+- (BOOL)prepareForDragOperation:(id<NSDraggingInfo>)sender
 {
-	if (associatedWindow->canAcceptDragOperation())
-		return YES;
-	else
-		return NO;
+  if (associatedWindow->canAcceptDragOperation())
+    return YES;
+  else
+    return NO;
 }
 
-- (BOOL)performDragOperation:(id < NSDraggingInfo >)sender
+- (BOOL)performDragOperation:(id<NSDraggingInfo>)sender
 {
-	NSPoint mouseLocation = [sender draggingLocation];
-	NSPasteboard *draggingPBoard = [sender draggingPasteboard];
-	NSImage *droppedImg;
-	id data;
+  NSPoint mouseLocation = [sender draggingLocation];
+  NSPasteboard *draggingPBoard = [sender draggingPasteboard];
+  NSImage *droppedImg;
+  id data;
 
-	switch (m_draggedObjectType) {
-		case GHOST_kDragnDropTypeBitmap:
-			if ([NSImage canInitWithPasteboard:draggingPBoard]) {
-				droppedImg = [[NSImage alloc]initWithPasteboard:draggingPBoard];
-				data = droppedImg; //[draggingPBoard dataForType:NSTIFFPboardType];
-			}
-			else return NO;
-			break;
-		case GHOST_kDragnDropTypeFilenames:
-			data = [draggingPBoard propertyListForType:NSFilenamesPboardType];
-			break;
-		case GHOST_kDragnDropTypeString:
-			data = [draggingPBoard stringForType:NSStringPboardType];
-			break;
-		default:
-			return NO;
-			break;
-	}
-	systemCocoa->handleDraggingEvent(GHOST_kEventDraggingDropDone, m_draggedObjectType, associatedWindow, mouseLocation.x, mouseLocation.y, (void*)data);
-	return YES;
+  switch (m_draggedObjectType) {
+    case GHOST_kDragnDropTypeBitmap:
+      if ([NSImage canInitWithPasteboard:draggingPBoard]) {
+        droppedImg = [[NSImage alloc] initWithPasteboard:draggingPBoard];
+        data = droppedImg;  //[draggingPBoard dataForType:NSTIFFPboardType];
+      }
+      else
+        return NO;
+      break;
+    case GHOST_kDragnDropTypeFilenames:
+      data = [draggingPBoard propertyListForType:NSFilenamesPboardType];
+      break;
+    case GHOST_kDragnDropTypeString:
+      data = [draggingPBoard stringForType:NSStringPboardType];
+      break;
+    default:
+      return NO;
+      break;
+  }
+  systemCocoa->handleDraggingEvent(GHOST_kEventDraggingDropDone,
+                                   m_draggedObjectType,
+                                   associatedWindow,
+                                   mouseLocation.x,
+                                   mouseLocation.y,
+                                   (void *)data);
+  return YES;
 }
 
 @end
@@ -238,204 +262,204 @@
 //We need to subclass it in order to give Cocoa the feeling key events are trapped
 @interface CocoaOpenGLView : NSOpenGLView <NSTextInput>
 {
-	GHOST_SystemCocoa *systemCocoa;
-	GHOST_WindowCocoa *associatedWindow;
+  GHOST_SystemCocoa *systemCocoa;
+  GHOST_WindowCocoa *associatedWindow;
 
-	bool composing;
-	NSString *composing_text;
+  bool composing;
+  NSString *composing_text;
 
-	bool immediate_draw;
+  bool immediate_draw;
 }
-- (void)setSystemAndWindowCocoa:(GHOST_SystemCocoa *)sysCocoa windowCocoa:(GHOST_WindowCocoa *)winCocoa;
+- (void)setSystemAndWindowCocoa:(GHOST_SystemCocoa *)sysCocoa
+                    windowCocoa:(GHOST_WindowCocoa *)winCocoa;
 @end
 
 @implementation CocoaOpenGLView
 
-- (void)setSystemAndWindowCocoa:(GHOST_SystemCocoa *)sysCocoa windowCocoa:(GHOST_WindowCocoa *)winCocoa
+- (void)setSystemAndWindowCocoa:(GHOST_SystemCocoa *)sysCocoa
+                    windowCocoa:(GHOST_WindowCocoa *)winCocoa
 {
-	systemCocoa = sysCocoa;
-	associatedWindow = winCocoa;
+  systemCocoa = sysCocoa;
+  associatedWindow = winCocoa;
 
-	composing = false;
-	composing_text = nil;
+  composing = false;
+  composing_text = nil;
 
-	immediate_draw = false;
+  immediate_draw = false;
 }
 
 - (BOOL)acceptsFirstResponder
 {
-	return YES;
+  return YES;
 }
 
 // The trick to prevent Cocoa from complaining (beeping)
 - (void)keyDown:(NSEvent *)event
 {
-	systemCocoa->handleKeyEvent(event);
+  systemCocoa->handleKeyEvent(event);
 
-	/* Start or continue composing? */
-	if ([[event characters] length] == 0  ||
-	    [[event charactersIgnoringModifiers] length] == 0 ||
-	    composing)
-	{
-		composing = YES;
+  /* Start or continue composing? */
+  if ([[event characters] length] == 0 || [[event charactersIgnoringModifiers] length] == 0 ||
+      composing) {
+    composing = YES;
 
-		// interpret event to call insertText
-		NSMutableArray *events;
-		events = [[NSMutableArray alloc] initWithCapacity:1];
-		[events addObject:event];
-		[self interpretKeyEvents:events]; // calls insertText
-		[events removeObject:event];
-		[events release];
-		return;
-	}
+    // interpret event to call insertText
+    NSMutableArray *events;
+    events = [[NSMutableArray alloc] initWithCapacity:1];
+    [events addObject:event];
+    [self interpretKeyEvents:events];  // calls insertText
+    [events removeObject:event];
+    [events release];
+    return;
+  }
 }
 
 - (void)keyUp:(NSEvent *)event
 {
-	systemCocoa->handleKeyEvent(event);
+  systemCocoa->handleKeyEvent(event);
 }
 
 - (void)flagsChanged:(NSEvent *)event
 {
-	systemCocoa->handleKeyEvent(event);
+  systemCocoa->handleKeyEvent(event);
 }
 
 - (void)mouseDown:(NSEvent *)event
 {
-	systemCocoa->handleMouseEvent(event);
+  systemCocoa->handleMouseEvent(event);
 }
 
 - (void)mouseUp:(NSEvent *)event
 {
-	systemCocoa->handleMouseEvent(event);
+  systemCocoa->handleMouseEvent(event);
 }
 
 - (void)rightMouseDown:(NSEvent *)event
 {
-	systemCocoa->handleMouseEvent(event);
+  systemCocoa->handleMouseEvent(event);
 }
 
 - (void)rightMouseUp:(NSEvent *)event
 {
-	systemCocoa->handleMouseEvent(event);
+  systemCocoa->handleMouseEvent(event);
 }
 
 - (void)mouseMoved:(NSEvent *)event
 {
-	systemCocoa->handleMouseEvent(event);
+  systemCocoa->handleMouseEvent(event);
 }
 
 - (void)mouseDragged:(NSEvent *)event
 {
-	systemCocoa->handleMouseEvent(event);
+  systemCocoa->handleMouseEvent(event);
 }
 
 - (void)rightMouseDragged:(NSEvent *)event
 {
-	systemCocoa->handleMouseEvent(event);
+  systemCocoa->handleMouseEvent(event);
 }
 
 - (void)scrollWheel:(NSEvent *)event
 {
-	systemCocoa->handleMouseEvent(event);
+  systemCocoa->handleMouseEvent(event);
 }
 
 - (void)otherMouseDown:(NSEvent *)event
 {
-	systemCocoa->handleMouseEvent(event);
+  systemCocoa->handleMouseEvent(event);
 }
 
 - (void)otherMouseUp:(NSEvent *)event
 {
-	systemCocoa->handleMouseEvent(event);
+  systemCocoa->handleMouseEvent(event);
 }
 
 - (void)otherMouseDragged:(NSEvent *)event
 {
-	systemCocoa->handleMouseEvent(event);
+  systemCocoa->handleMouseEvent(event);
 }
 
 - (void)magnifyWithEvent:(NSEvent *)event
 {
-	systemCocoa->handleMouseEvent(event);
+  systemCocoa->handleMouseEvent(event);
 }
 
 - (void)rotateWithEvent:(NSEvent *)event
 {
-	systemCocoa->handleMouseEvent(event);
+  systemCocoa->handleMouseEvent(event);
 }
 
 - (void)tabletPoint:(NSEvent *)event
 {
-	systemCocoa->handleTabletEvent(event,[event type]);
+  systemCocoa->handleTabletEvent(event, [event type]);
 }
 
 - (void)tabletProximity:(NSEvent *)event
 {
-	systemCocoa->handleTabletEvent(event,[event type]);
+  systemCocoa->handleTabletEvent(event, [event type]);
 }
 
 - (BOOL)isOpaque
 {
-	return YES;
+  return YES;
 }
 
-- (void) drawRect:(NSRect)rect
+- (void)drawRect:(NSRect)rect
 {
-	if ([self inLiveResize]) {
-		/* Don't redraw while in live resize */
-	}
-	else {
-		[super drawRect:rect];
-		systemCocoa->handleWindowEvent(GHOST_kEventWindowUpdate, associatedWindow);
+  if ([self inLiveResize]) {
+    /* Don't redraw while in live resize */
+  }
+  else {
+    [super drawRect:rect];
+    systemCocoa->handleWindowEvent(GHOST_kEventWindowUpdate, associatedWindow);
 
-		/* For some cases like entering fullscreen we need to redraw immediately
-		 * so our window does not show blank during the animation */
-		if (associatedWindow->getImmediateDraw())
-			systemCocoa->dispatchEvents();
-	}
+    /* For some cases like entering fullscreen we need to redraw immediately
+     * so our window does not show blank during the animation */
+    if (associatedWindow->getImmediateDraw())
+      systemCocoa->dispatchEvents();
+  }
 }
 
 // Text input
 
 - (void)composing_free
 {
-	composing = NO;
+  composing = NO;
 
-	if (composing_text) {
-		[composing_text release];
-		composing_text = nil;
-	}
+  if (composing_text) {
+    [composing_text release];
+    composing_text = nil;
+  }
 }
 
 - (void)insertText:(id)chars
 {
-	[self composing_free];
+  [self composing_free];
 }
 
 - (void)setMarkedText:(id)chars selectedRange:(NSRange)range
 {
-	[self composing_free];
-	if ([chars length] == 0)
-		return;
+  [self composing_free];
+  if ([chars length] == 0)
+    return;
 
-	// start composing
-	composing = YES;
-	composing_text = [chars copy];
+  // start composing
+  composing = YES;
+  composing_text = [chars copy];
 
-	// if empty, cancel
-	if ([composing_text length] == 0)
-		[self composing_free];
+  // if empty, cancel
+  if ([composing_text length] == 0)
+    [self composing_free];
 }
 
 - (void)unmarkText
 {
-	[self composing_free];
+  [self composing_free];
 }
 
 - (BOOL)hasMarkedText
 {
-	return (composing) ? YES : NO;
+  return (composing) ? YES : NO;
 }
 
 - (void)doCommandBySelector:(SEL)selector
@@ -444,457 +468,463 @@
 
 - (BOOL)isComposing
 {
-	return composing;
+  return composing;
 }
 
 - (NSInteger)conversationIdentifier
 {
-	return (NSInteger)self;
+  return (NSInteger)self;
 }
 
 - (NSAttributedString *)attributedSubstringFromRange:(NSRange)range
 {
-	return [NSAttributedString new]; // XXX does this leak?
+  return [NSAttributedString new];  // XXX does this leak?
 }
 
 - (NSRange)markedRange
 {
-	unsigned int length = (composing_text) ? [composing_text length] : 0;
+  unsigned int length = (composing_text) ? [composing_text length] : 0;
 
-	if (composing)
-		return NSMakeRange(0, length);
+  if (composing)
+    return NSMakeRange(0, length);
 
-	return NSMakeRange(NSNotFound, 0);
+  return NSMakeRange(NSNotFound, 0);
 }
 
 - (NSRange)selectedRange
 {
-	unsigned int length = (composing_text) ? [composing_text length] : 0;
-	return NSMakeRange(0, length);
+  unsigned int length = (composing_text) ? [composing_text length] : 0;
+  return NSMakeRange(0, length);
 }
 
 - (NSRect)firstRectForCharacterRange:(NSRange)range
 {
-	return NSZeroRect;
+  return NSZeroRect;
 }
 
 - (NSUInteger)characterIndexForPoint:(NSPoint)point
 {
-	return NSNotFound;
+  return NSNotFound;
 }
 
-- (NSArray*)validAttributesForMarkedText
+- (NSArray *)validAttributesForMarkedText
 {
-	return [NSArray array]; // XXX does this leak?
+  return [NSArray array];  // XXX does this leak?
 }
 
 @end
 
 #pragma mark initialization / finalization
 
-GHOST_WindowCocoa::GHOST_WindowCocoa(
-	GHOST_SystemCocoa *systemCocoa,
-	const STR_String& title,
-	GHOST_TInt32 left,
-	GHOST_TInt32 bottom,
-	GHOST_TUns32 width,
-	GHOST_TUns32 height,
-	GHOST_TWindowState state,
-	GHOST_TDrawingContextType type,
-	const bool stereoVisual, const GHOST_TUns16 numOfAASamples, bool is_debug
-) :
-	GHOST_Window(width, height, state, stereoVisual, false, numOfAASamples),
-	m_customCursor(0),
-	m_debug_context(is_debug)
+GHOST_WindowCocoa::GHOST_WindowCocoa(GHOST_SystemCocoa *systemCocoa,
+                                     const STR_String &title,
+                                     GHOST_TInt32 left,
+                                     GHOST_TInt32 bottom,
+                                     GHOST_TUns32 width,
+                                     GHOST_TUns32 height,
+                                     GHOST_TWindowState state,
+                                     GHOST_TDrawingContextType type,
+                                     const bool stereoVisual,
+                                     const GHOST_TUns16 numOfAASamples,
+                                     bool is_debug)
+    : GHOST_Window(width, height, state, stereoVisual, false, numOfAASamples),
+      m_customCursor(0),
+      m_debug_context(is_debug)
 {
-	m_systemCocoa = systemCocoa;
-	m_fullScreen = false;
-	m_immediateDraw = false;
+  m_systemCocoa = systemCocoa;
+  m_fullScreen = false;
+  m_immediateDraw = false;
 
-	NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
+  NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 
-	//Creates the window
-	NSRect rect;
-	NSSize	minSize;
+  //Creates the window
+  NSRect rect;
+  NSSize minSize;
 
-	rect.origin.x = left;
-	rect.origin.y = bottom;
-	rect.size.width = width;
-	rect.size.height = height;
+  rect.origin.x = left;
+  rect.origin.y = bottom;
+  rect.size.width = width;
+  rect.size.height = height;
 
-	m_window = [[CocoaWindow alloc] initWithContentRect:rect
-	        styleMask:NSTitledWindowMask | NSClosableWindowMask | NSResizableWindowMask | NSMiniaturizableWindowMask
-	        backing:NSBackingStoreBuffered defer:NO];
+  m_window = [[CocoaWindow alloc]
+      initWithContentRect:rect
+                styleMask:NSTitledWindowMask | NSClosableWindowMask | NSResizableWindowMask |
+                          NSMiniaturizableWindowMask
+                  backing:NSBackingStoreBuffered
+                    defer:NO];
 
-	if (m_window == nil) {
-		[pool drain];
-		return;
-	}
+  if (m_window == nil) {
+    [pool drain];
+    return;
+  }
 
-	[m_window setSystemAndWindowCocoa:systemCocoa windowCocoa:this];
+  [m_window setSystemAndWindowCocoa:systemCocoa windowCocoa:this];
 
-	//Forbid to resize the window below the blender defined minimum one
-	minSize.width = 320;
-	minSize.height = 240;
-	[m_window setContentMinSize:minSize];
+  //Forbid to resize the window below the blender defined minimum one
+  minSize.width = 320;
+  minSize.height = 240;
+  [m_window setContentMinSize:minSize];
 
-	//Creates the OpenGL View inside the window
-	m_openGLView = [[CocoaOpenGLView alloc] initWithFrame:rect];
+  //Creates the OpenGL View inside the window
+  m_openGLView = [[CocoaOpenGLView alloc] initWithFrame:rect];
 
-	if (m_systemCocoa->m_nativePixel) {
-		// Needs to happen early when building with the 10.14 SDK, otherwise
-		// has no effect until resizeing the window.
-		if ([m_openGLView respondsToSelector:@selector(setWantsBestResolutionOpenGLSurface:)]) {
-			[m_openGLView setWantsBestResolutionOpenGLSurface:YES];
-		}
-	}
+  if (m_systemCocoa->m_nativePixel) {
+    // Needs to happen early when building with the 10.14 SDK, otherwise
+    // has no effect until resizeing the window.
+    if ([m_openGLView respondsToSelector:@selector(setWantsBestResolutionOpenGLSurface:)]) {
+      [m_openGLView setWantsBestResolutionOpenGLSurface:YES];
+    }
+  }
 
-	[m_openGLView setSystemAndWindowCocoa:systemCocoa windowCocoa:this];
+  [m_openGLView setSystemAndWindowCocoa:systemCocoa windowCocoa:this];
 
-	[m_window setContentView:m_openGLView];
-	[m_window setInitialFirstResponder:m_openGLView];
+  [m_window setContentView:m_openGLView];
+  [m_window setInitialFirstResponder:m_openGLView];
 
-	[m_window makeKeyAndOrderFront:nil];
+  [m_window makeKeyAndOrderFront:nil];
 
-	setDrawingContextType(type);
-	updateDrawingContext();
-	activateDrawingContext();
+  setDrawingContextType(type);
+  updateDrawingContext();
+  activateDrawingContext();
 
-	setTitle(title);
+  setTitle(title);
 
-	m_tablet.Active = GHOST_kTabletModeNone;
+  m_tablet.Active = GHOST_kTabletModeNone;
 
-	CocoaWindowDelegate *windowDelegate = [[CocoaWindowDelegate alloc] init];
-	[windowDelegate setSystemAndWindowCocoa:systemCocoa windowCocoa:this];
-	[m_window setDelegate:windowDelegate];
+  CocoaWindowDelegate *windowDelegate = [[CocoaWindowDelegate alloc] init];
+  [windowDelegate setSystemAndWindowCocoa:systemCocoa windowCocoa:this];
+  [m_window setDelegate:windowDelegate];
 
-	[m_window setAcceptsMouseMovedEvents:YES];
+  [m_window setAcceptsMouseMovedEvents:YES];
 
-	NSView *view = [m_window contentView];
-	[view setAcceptsTouchEvents:YES];
+  NSView *view = [m_window contentView];
+  [view setAcceptsTouchEvents:YES];
 
-	[m_window registerForDraggedTypes:[NSArray arrayWithObjects:NSFilenamesPboardType,
-	                                   NSStringPboardType, NSTIFFPboardType, nil]];
+  [m_window registerForDraggedTypes:[NSArray arrayWithObjects:NSFilenamesPboardType,
+                                                              NSStringPboardType,
+                                                              NSTIFFPboardType,
+                                                              nil]];
 
-	if (state != GHOST_kWindowStateFullScreen) {
-		[m_window setCollectionBehavior:NSWindowCollectionBehaviorFullScreenPrimary];
-	}
+  if (state != GHOST_kWindowStateFullScreen) {
+    [m_window setCollectionBehavior:NSWindowCollectionBehaviorFullScreenPrimary];
+  }
 
-	if (state == GHOST_kWindowStateFullScreen)
-		setState(GHOST_kWindowStateFullScreen);
+  if (state == GHOST_kWindowStateFullScreen)
+    setState(GHOST_kWindowStateFullScreen);
 
-	setNativePixelSize();
+  setNativePixelSize();
 
-	[pool drain];
+  [pool drain];
 }
 
-
 GHOST_WindowCocoa::~GHOST_WindowCocoa()
 {
-	NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
+  NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 
-	if (m_customCursor) {
-		[m_customCursor release];
-		m_customCursor = nil;
-	}
+  if (m_customCursor) {
+    [m_customCursor release];
+    m_customCursor = nil;
+  }
 
-	releaseNativeHandles();
+  releaseNativeHandles();
 
-	[m_openGLView release];
+  [m_openGLView release];
 
-	if (m_window) {
-		[m_window close];
-	}
+  if (m_window) {
+    [m_window close];
+  }
 
-	// Check for other blender opened windows and make the frontmost key
-	// Note: for some reason the closed window is still in the list
-	NSArray *windowsList = [NSApp orderedWindows];
-	for (int a = 0; a < [windowsList count]; a++) {
-		if (m_window != (CocoaWindow *)[windowsList objectAtIndex:a]) {
-			[[windowsList objectAtIndex:a] makeKeyWindow];
-			break;
-		}
-	}
-	m_window = nil;
+  // Check for other blender opened windows and make the frontmost key
+  // Note: for some reason the closed window is still in the list
+  NSArray *windowsList = [NSApp orderedWindows];
+  for (int a = 0; a < [windowsList count]; a++) {
+    if (m_window != (CocoaWindow *)[windowsList objectAtIndex:a]) {
+      [[windowsList objectAtIndex:a] makeKeyWindow];
+      break;
+    }
+  }
+  m_window = nil;
 
-	[pool drain];
+  [pool drain];
 }
 
 #pragma mark accessors
 
 bool GHOST_WindowCocoa::getValid() const
 {
-	return GHOST_Window::getValid() && m_window != NULL && m_openGLView != NULL;
+  return GHOST_Window::getValid() && m_window != NULL && m_openGLView != NULL;
 }
 
-void* GHOST_WindowCocoa::getOSWindow() const
+void *GHOST_WindowCocoa::getOSWindow() const
 {
-	return (void*)m_window;
+  return (void *)m_window;
 }
 
-void GHOST_WindowCocoa::setTitle(const STR_String& title)
+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] initWithCString:title encoding:NSUTF8StringEncoding];
+  GHOST_ASSERT(getValid(), "GHOST_WindowCocoa::setTitle(): window invalid");
+  NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 
-	//Set associated file if applicable
-	if (windowTitle && [windowTitle hasPrefix:@"Blender"]) {
-		NSRange fileStrRange;
-		NSString *associatedFileName;
-		int len;
+  NSString *windowTitle = [[NSString alloc] initWithCString:title encoding:NSUTF8StringEncoding];
 
-		fileStrRange.location = [windowTitle rangeOfString:@"["].location+1;
-		len = [windowTitle rangeOfString:@"]"].location - fileStrRange.location;
+  //Set associated file if applicable
+  if (windowTitle && [windowTitle hasPrefix:@"Blender"]) {
+    NSRange fileStrRange;
+    NSString *associatedFileName;
+    int len;
 
-		if (len > 0) {
-			fileStrRange.length = len;
-			associatedFileName = [windowTitle substringWithRange:fileStrRange];
-			[m_window setTitle:[associatedFileName lastPathComponent]];
+    fileStrRange.location = [windowTitle rangeOfString:@"["].location + 1;
+    len = [windowTitle rangeOfString:@"]"].location - fileStrRange.location;
 
-			//Blender used file open/save functions converte file names into legal URL ones
-			associatedFileName = [associatedFileName stringByAddingPercentEscapesUsingEncoding:NSUTF8StringEncoding];
-			@try {
-				[m_window setRepresentedFilename:associatedFileName];
-			}
-			@catch (NSException * e) {
-				printf("\nInvalid file path given in window title");
-			}
-		}
-		else {
-			[m_window setTitle:windowTitle];
-			[m_window setRepresentedFilename:@""];
-		}
+    if (len > 0) {
+      fileStrRange.length = len;
+      associatedFileName = [windowTitle substringWithRange:fileStrRange];
+      [m_window setTitle:[associatedFileName lastPathComponent]];
 
-	}
-	else {
-		[m_window setTitle:windowTitle];
-		[m_window setRepresentedFilename:@""];
-	}
+      //Blender used file open/save functions converte file names into legal URL ones
+      associatedFileName = [associatedFileName
+          stringByAddingPercentEscapesUsingEncoding:NSUTF8StringEncoding];
+      @try {
+        [m_window setRepresentedFilename:associatedFileName];
+      }
+      @catch (NSException *e) {
+        printf("\nInvalid file path given in window title");
+      }
+    }
+    else {
+      [m_window setTitle:windowTitle];
+      [m_window setRepresentedFilename:@""];
+    }
+  }
+  else {
+    [m_window setTitle:windowTitle];
+    [m_window setRepresentedFilename:@""];
+  }
 
-
-	[windowTitle release];
-	[pool drain];
+  [windowTitle release];
+  [pool drain];
 }
 
-
-void GHOST_WindowCocoa::getTitle(STR_String& title) const
+void GHOST_WindowCocoa::getTitle(STR_String &title) const
 {
-	GHOST_ASSERT(getValid(), "GHOST_WindowCocoa::getTitle(): window invalid");
+  GHOST_ASSERT(getValid(), "GHOST_WindowCocoa::getTitle(): window invalid");
 
-	NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
+  NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 
-	NSString *windowTitle = [m_window title];
+  NSString *windowTitle = [m_window title];
 
-	if (windowTitle != nil) {
-		title = [windowTitle UTF8String];
-	}
+  if (windowTitle != nil) {
+    title = [windowTitle UTF8String];
+  }
 
-	[pool drain];
+  [pool drain];
 }
 
-
-void GHOST_WindowCocoa::getWindowBounds(GHOST_Rect& bounds) const
+void GHOST_WindowCocoa::getWindowBounds(GHOST_Rect &bounds) const
 {
-	NSRect rect;
-	GHOST_ASSERT(getValid(), "GHOST_WindowCocoa::getWindowBounds(): window invalid");
+  NSRect rect;
+  GHOST_ASSERT(getValid(), "GHOST_WindowCocoa::getWindowBounds(): window invalid");
 
-	NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
+  NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 
-	NSRect screenSize = [[m_window screen] visibleFrame];
+  NSRect screenSize = [[m_window screen] visibleFrame];
 
-	rect = [m_window frame];
+  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);
+  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];
+  [pool drain];
 }
 
-
-void GHOST_WindowCocoa::getClientBounds(GHOST_Rect& bounds) const
+void GHOST_WindowCocoa::getClientBounds(GHOST_Rect &bounds) const
 {
-	NSRect rect;
-	GHOST_ASSERT(getValid(), "GHOST_WindowCocoa::getClientBounds(): window invalid");
+  NSRect rect;
+  GHOST_ASSERT(getValid(), "GHOST_WindowCocoa::getClientBounds(): window invalid");
 
-	NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
+  NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 
-	NSRect screenSize = [[m_window screen] visibleFrame];
+  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)];
+  //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]];
+  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);
-	[pool drain];
+  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);
+  [pool drain];
 }
 
-
 GHOST_TSuccess GHOST_WindowCocoa::setClientWidth(GHOST_TUns32 width)
 {
-	GHOST_ASSERT(getValid(), "GHOST_WindowCocoa::setClientWidth(): window invalid");
-	NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
-	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];
-	}
-	[pool drain];
-	return GHOST_kSuccess;
+  GHOST_ASSERT(getValid(), "GHOST_WindowCocoa::setClientWidth(): window invalid");
+  NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
+  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];
+  }
+  [pool drain];
+  return GHOST_kSuccess;
 }
 
-
 GHOST_TSuccess GHOST_WindowCocoa::setClientHeight(GHOST_TUns32 height)
 {
-	GHOST_ASSERT(getValid(), "GHOST_WindowCocoa::setClientHeight(): window invalid");
-	NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
-	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];
-	}
-	[pool drain];
-	return GHOST_kSuccess;
+  GHOST_ASSERT(getValid(), "GHOST_WindowCocoa::setClientHeight(): window invalid");
+  NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
+  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];
+  }
+  [pool drain];
+  return GHOST_kSuccess;
 }
 
-
 GHOST_TSuccess GHOST_WindowCocoa::setClientSize(GHOST_TUns32 width, GHOST_TUns32 height)
 {
-	GHOST_ASSERT(getValid(), "GHOST_WindowCocoa::setClientSize(): window invalid");
-	NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
-	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];
-	}
-	[pool drain];
-	return GHOST_kSuccess;
+  GHOST_ASSERT(getValid(), "GHOST_WindowCocoa::setClientSize(): window invalid");
+  NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
+  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];
+  }
+  [pool drain];
+  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;
+  GHOST_ASSERT(getValid(), "GHOST_WindowCocoa::getState(): window invalid");
+  NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
+  GHOST_TWindowState state;
 
-	NSUInteger masks = [m_window styleMask];
+  NSUInteger masks = [m_window styleMask];
 
-	if (masks & NSFullScreenWindowMask) {
-		// Lion style fullscreen
-		if (!m_immediateDraw) {
-			state = GHOST_kWindowStateFullScreen;
-		}
-		else {
-			state = GHOST_kWindowStateNormal;
-		}
-	}
-	else if ([m_window isMiniaturized]) {
-		state = GHOST_kWindowStateMinimized;
-	}
-	else if ([m_window isZoomed]) {
-		state = GHOST_kWindowStateMaximized;
-	}
-	else {
-		if (m_immediateDraw) {
-			state = GHOST_kWindowStateFullScreen;
-		}
-		else {
-			state = GHOST_kWindowStateNormal;
-		}
-	}
-	[pool drain];
-	return state;
+  if (masks & NSFullScreenWindowMask) {
+    // Lion style fullscreen
+    if (!m_immediateDraw) {
+      state = GHOST_kWindowStateFullScreen;
+    }
+    else {
+      state = GHOST_kWindowStateNormal;
+    }
+  }
+  else if ([m_window isMiniaturized]) {
+    state = GHOST_kWindowStateMinimized;
+  }
+  else if ([m_window isZoomed]) {
+    state = GHOST_kWindowStateMaximized;
+  }
+  else {
+    if (m_immediateDraw) {
+      state = GHOST_kWindowStateFullScreen;
+    }
+    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
+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");
+  GHOST_ASSERT(getValid(), "GHOST_WindowCocoa::screenToClient(): window invalid");
 
-	screenToClientIntern(inX, inY, outX, outY);
+  screenToClientIntern(inX, inY, outX, outY);
 
-	/* switch y to match ghost convention */
-	GHOST_Rect cBnds;
-	getClientBounds(cBnds);
-	outY = (cBnds.getHeight() - 1) - outY;
+  /* switch y to match ghost convention */
+  GHOST_Rect cBnds;
+  getClientBounds(cBnds);
+  outY = (cBnds.getHeight() - 1) - outY;
 }
 
-
-void GHOST_WindowCocoa::clientToScreen(GHOST_TInt32 inX, GHOST_TInt32 inY, GHOST_TInt32& outX, GHOST_TInt32& outY) const
+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");
+  GHOST_ASSERT(getValid(), "GHOST_WindowCocoa::clientToScreen(): window invalid");
 
-	/* switch y to match ghost convention */
-	GHOST_Rect cBnds;
-	getClientBounds(cBnds);
-	inY = (cBnds.getHeight() - 1) - inY;
+  /* switch y to match ghost convention */
+  GHOST_Rect cBnds;
+  getClientBounds(cBnds);
+  inY = (cBnds.getHeight() - 1) - inY;
 
-	clientToScreenIntern(inX, inY, outX, outY);
+  clientToScreenIntern(inX, inY, outX, outY);
 }
 
-void GHOST_WindowCocoa::screenToClientIntern(GHOST_TInt32 inX, GHOST_TInt32 inY, GHOST_TInt32& outX, GHOST_TInt32& outY) const
+void GHOST_WindowCocoa::screenToClientIntern(GHOST_TInt32 inX,
+                                             GHOST_TInt32 inY,
+                                             GHOST_TInt32 &outX,
+                                             GHOST_TInt32 &outY) const
 {
-	NSRect screenCoord;
-	NSRect baseCoord;
+  NSRect screenCoord;
+  NSRect baseCoord;
 
-	screenCoord.origin.x = inX;
-	screenCoord.origin.y = inY;
+  screenCoord.origin.x = inX;
+  screenCoord.origin.y = inY;
 
-	baseCoord = [m_window convertRectFromScreen:screenCoord];
+  baseCoord = [m_window convertRectFromScreen:screenCoord];
 
-	outX = baseCoord.origin.x;
-	outY = baseCoord.origin.y;
+  outX = baseCoord.origin.x;
+  outY = baseCoord.origin.y;
 }
 
-void GHOST_WindowCocoa::clientToScreenIntern(GHOST_TInt32 inX, GHOST_TInt32 inY, GHOST_TInt32& outX, GHOST_TInt32& outY) const
+void GHOST_WindowCocoa::clientToScreenIntern(GHOST_TInt32 inX,
+                                             GHOST_TInt32 inY,
+                                             GHOST_TInt32 &outX,
+                                             GHOST_TInt32 &outY) const
 {
-	NSRect screenCoord;
-	NSRect baseCoord;
+  NSRect screenCoord;
+  NSRect baseCoord;
 
-	baseCoord.origin.x = inX;
-	baseCoord.origin.y = inY;
+  baseCoord.origin.x = inX;
+  baseCoord.origin.y = inY;
 
-	screenCoord = [m_window convertRectToScreen:baseCoord];
+  screenCoord = [m_window convertRectToScreen:baseCoord];
 
-	outX = screenCoord.origin.x;
-	outY = screenCoord.origin.y;
+  outX = screenCoord.origin.x;
+  outY = screenCoord.origin.y;
 }
 
-
-NSScreen* GHOST_WindowCocoa::getScreen()
+NSScreen *GHOST_WindowCocoa::getScreen()
 {
-	return [m_window screen];
+  return [m_window screen];
 }
 
 /* called for event, when window leaves monitor to another */
 void GHOST_WindowCocoa::setNativePixelSize(void)
 {
-	NSRect backingBounds = [m_openGLView convertRectToBacking:[m_openGLView bounds]];
+  NSRect backingBounds = [m_openGLView convertRectToBacking:[m_openGLView bounds]];
 
-	GHOST_Rect rect;
-	getClientBounds(rect);
+  GHOST_Rect rect;
+  getClientBounds(rect);
 
-	m_nativePixelSize = (float)backingBounds.size.width / (float)rect.getWidth();
+  m_nativePixelSize = (float)backingBounds.size.width / (float)rect.getWidth();
 }
 
 /**
@@ -906,430 +936,436 @@ void GHOST_WindowCocoa::setNativePixelSize(void)
  */
 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:
-		{
-			NSUInteger masks = [m_window styleMask];
-
-			if (!(masks & NSFullScreenWindowMask)) {
-				[m_window toggleFullScreen:nil];
-			}
-			break;
-		}
-		case GHOST_kWindowStateNormal:
-		default:
-			NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
-			NSUInteger masks = [m_window styleMask];
-
-			if (masks & NSFullScreenWindowMask) {
-				// Lion style fullscreen
-				[m_window toggleFullScreen:nil];
-			}
-			else if ([m_window isMiniaturized])
-				[m_window deminiaturize:nil];
-			else if ([m_window isZoomed])
-				[m_window zoom:nil];
-			[pool drain];
-			break;
-	}
-
-	return GHOST_kSuccess;
+  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: {
+      NSUInteger masks = [m_window styleMask];
+
+      if (!(masks & NSFullScreenWindowMask)) {
+        [m_window toggleFullScreen:nil];
+      }
+      break;
+    }
+    case GHOST_kWindowStateNormal:
+    default:
+      NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
+      NSUInteger masks = [m_window styleMask];
+
+      if (masks & NSFullScreenWindowMask) {
+        // Lion style fullscreen
+        [m_window toggleFullScreen:nil];
+      }
+      else if ([m_window isMiniaturized])
+        [m_window deminiaturize:nil];
+      else if ([m_window isZoomed])
+        [m_window zoom:nil];
+      [pool drain];
+      break;
+  }
+
+  return GHOST_kSuccess;
 }
 
 GHOST_TSuccess GHOST_WindowCocoa::setModifiedState(bool isUnsavedChanges)
 {
-	NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
+  NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 
-	[m_window setDocumentEdited:isUnsavedChanges];
+  [m_window setDocumentEdited:isUnsavedChanges];
 
-	[pool drain];
-	return GHOST_Window::setModifiedState(isUnsavedChanges);
+  [pool drain];
+  return GHOST_Window::setModifiedState(isUnsavedChanges);
 }
 
-
-
 GHOST_TSuccess GHOST_WindowCocoa::setOrder(GHOST_TWindowOrder order)
 {
-	NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
+  NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 
-	GHOST_ASSERT(getValid(), "GHOST_WindowCocoa::setOrder(): window invalid");
-	if (order == GHOST_kWindowOrderTop) {
-		[m_window makeKeyAndOrderFront:nil];
-	}
-	else {
-		NSArray *windowsList;
+  GHOST_ASSERT(getValid(), "GHOST_WindowCocoa::setOrder(): window invalid");
+  if (order == GHOST_kWindowOrderTop) {
+    [m_window makeKeyAndOrderFront:nil];
+  }
+  else {
+    NSArray *windowsList;
 
-		[m_window orderBack:nil];
+    [m_window orderBack:nil];
 
-		//Check for other blender opened windows and make the frontmost key
-		windowsList = [NSApp orderedWindows];
-		if ([windowsList count]) {
-			[[windowsList objectAtIndex:0] makeKeyAndOrderFront:nil];
-		}
-	}
+    //Check for other blender opened windows and make the frontmost key
+    windowsList = [NSApp orderedWindows];
+    if ([windowsList count]) {
+      [[windowsList objectAtIndex:0] makeKeyAndOrderFront:nil];
+    }
+  }
 
-	[pool drain];
-	return GHOST_kSuccess;
+  [pool drain];
+  return GHOST_kSuccess;
 }
 
 #pragma mark Drawing context
 
 GHOST_Context *GHOST_WindowCocoa::newDrawingContext(GHOST_TDrawingContextType type)
 {
-	if (type == GHOST_kDrawingContextTypeOpenGL) {
+  if (type == GHOST_kDrawingContextTypeOpenGL) {
 
-		GHOST_Context *context = new GHOST_ContextCGL(
-			m_wantStereoVisual,
-			m_wantNumOfAASamples,
-			m_window,
-			m_openGLView,
+    GHOST_Context *context = new GHOST_ContextCGL(m_wantStereoVisual,
+                                                  m_wantNumOfAASamples,
+                                                  m_window,
+                                                  m_openGLView,
 
 #if defined(WITH_GL_PROFILE_CORE)
-			GL_CONTEXT_CORE_PROFILE_BIT,
-			3, 3,
+                                                  GL_CONTEXT_CORE_PROFILE_BIT,
+                                                  3,
+                                                  3,
 #else
-			0, // no profile bit
-			2, 1,
+                                                  0,  // no profile bit
+                                                  2,
+                                                  1,
 #endif
-			GHOST_OPENGL_CGL_CONTEXT_FLAGS,
-			GHOST_OPENGL_CGL_RESET_NOTIFICATION_STRATEGY);
+                                                  GHOST_OPENGL_CGL_CONTEXT_FLAGS,
+                                                  GHOST_OPENGL_CGL_RESET_NOTIFICATION_STRATEGY);
 
-		if (context->initializeDrawingContext())
-			return context;
-		else
-			delete context;
-	}
+    if (context->initializeDrawingContext())
+      return context;
+    else
+      delete context;
+  }
 
-	return NULL;
+  return NULL;
 }
 
 #pragma mark invalidate
 
 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;
+  GHOST_ASSERT(getValid(), "GHOST_WindowCocoa::invalidate(): window invalid");
+  NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
+  [m_openGLView setNeedsDisplay:YES];
+  [pool drain];
+  return GHOST_kSuccess;
 }
 
 #pragma mark Progress bar
 
 GHOST_TSuccess GHOST_WindowCocoa::setProgressBar(float progress)
 {
-	NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
+  NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 
-	if ((progress >=0.0) && (progress <=1.0)) {
-		NSImage* dockIcon = [[NSImage alloc] initWithSize:NSMakeSize(128,128)];
+  if ((progress >= 0.0) && (progress <= 1.0)) {
+    NSImage *dockIcon = [[NSImage alloc] initWithSize:NSMakeSize(128, 128)];
 
-		[dockIcon lockFocus];
-		NSRect progressBox = {{4, 4}, {120, 16}};
+    [dockIcon lockFocus];
+    NSRect progressBox = {{4, 4}, {120, 16}};
 
-		[[NSImage imageNamed:@"NSApplicationIcon"] drawAtPoint:NSZeroPoint fromRect:NSZeroRect operation:NSCompositeSourceOver fraction:1.0];
+    [[NSImage imageNamed:@"NSApplicationIcon"] drawAtPoint:NSZeroPoint
+                                                  fromRect:NSZeroRect
+                                                 operation:NSCompositeSourceOver
+                                                  fraction:1.0];
 
-		// Track & Outline
-		[[NSColor blackColor] setFill];
-		NSRectFill(progressBox);
+    // Track & Outline
+    [[NSColor blackColor] setFill];
+    NSRectFill(progressBox);
 
-		[[NSColor whiteColor] set];
-		NSFrameRect(progressBox);
+    [[NSColor whiteColor] set];
+    NSFrameRect(progressBox);
 
-		// Progress fill
-		progressBox = NSInsetRect(progressBox, 1, 1);
+    // Progress fill
+    progressBox = NSInsetRect(progressBox, 1, 1);
 
-		progressBox.size.width = progressBox.size.width * progress;
-		NSGradient *gradient = [[NSGradient alloc] initWithStartingColor:[NSColor darkGrayColor] endingColor:[NSColor lightGrayColor]];
-		[gradient drawInRect:progressBox angle:90];
-		[gradient release];
+    progressBox.size.width = progressBox.size.width * progress;
+    NSGradient *gradient = [[NSGradient alloc] initWithStartingColor:[NSColor darkGrayColor]
+                                                         endingColor:[NSColor lightGrayColor]];
+    [gradient drawInRect:progressBox angle:90];
+    [gradient release];
 
-		[dockIcon unlockFocus];
+    [dockIcon unlockFocus];
 
-		[NSApp setApplicationIconImage:dockIcon];
-		[dockIcon release];
+    [NSApp setApplicationIconImage:dockIcon];
+    [dockIcon release];
 
-		m_progressBarVisible = true;
-	}
+    m_progressBarVisible = true;
+  }
 
-	[pool drain];
-	return GHOST_kSuccess;
+  [pool drain];
+  return GHOST_kSuccess;
 }
 
 static void postNotification()
 {
-	NSUserNotification *notification = [[NSUserNotification alloc] init];
-	notification.title = @"Blender progress notification";
-	notification.informativeText = @"Calculation is finished";
-	notification.soundName = NSUserNotificationDefaultSoundName;
-	[[NSUserNotificationCenter defaultUserNotificationCenter] deliverNotification:notification];
-	[notification release];
+  NSUserNotification *notification = [[NSUserNotification alloc] init];
+  notification.title = @"Blender progress notification";
+  notification.informativeText = @"Calculation is finished";
+  notification.soundName = NSUserNotificationDefaultSoundName;
+  [[NSUserNotificationCenter defaultUserNotificationCenter] deliverNotification:notification];
+  [notification release];
 }
 
 GHOST_TSuccess GHOST_WindowCocoa::endProgressBar()
 {
-	if (!m_progressBarVisible) return GHOST_kFailure;
-	m_progressBarVisible = false;
+  if (!m_progressBarVisible)
+    return GHOST_kFailure;
+  m_progressBarVisible = false;
 
-	NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
+  NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 
-	NSImage* dockIcon = [[NSImage alloc] initWithSize:NSMakeSize(128,128)];
-	[dockIcon lockFocus];
-	[[NSImage imageNamed:@"NSApplicationIcon"] drawAtPoint:NSZeroPoint fromRect:NSZeroRect operation:NSCompositeSourceOver fraction:1.0];
-	[dockIcon unlockFocus];
-	[NSApp setApplicationIconImage:dockIcon];
+  NSImage *dockIcon = [[NSImage alloc] initWithSize:NSMakeSize(128, 128)];
+  [dockIcon lockFocus];
+  [[NSImage imageNamed:@"NSApplicationIcon"] drawAtPoint:NSZeroPoint
+                                                fromRect:NSZeroRect
+                                               operation:NSCompositeSourceOver
+                                                fraction:1.0];
+  [dockIcon unlockFocus];
+  [NSApp setApplicationIconImage:dockIcon];
 
-	// We use notifications to inform the user when the progress reached 100%
-	// Atm. just fire this when the progressbar ends, the behavior is controlled
-	// in the NotificationCenter If Blender is not frontmost window, a message
-	// pops up with sound, in any case an entry in notifications
-	if ([NSUserNotificationCenter respondsToSelector:@selector(defaultUserNotificationCenter)]) {
-		postNotification();
-	}
+  // We use notifications to inform the user when the progress reached 100%
+  // Atm. just fire this when the progressbar ends, the behavior is controlled
+  // in the NotificationCenter If Blender is not frontmost window, a message
+  // pops up with sound, in any case an entry in notifications
+  if ([NSUserNotificationCenter respondsToSelector:@selector(defaultUserNotificationCenter)]) {
+    postNotification();
+  }
 
-	[dockIcon release];
+  [dockIcon release];
 
-	[pool drain];
-	return GHOST_kSuccess;
+  [pool drain];
+  return GHOST_kSuccess;
 }
 
 #pragma mark Cursor handling
 
 void GHOST_WindowCocoa::loadCursor(bool visible, GHOST_TStandardCursor cursor) const
 {
-	static bool systemCursorVisible = true;
-
-	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_kStandardCursorCopy:
-			case GHOST_kStandardCursorDefault:
-			default:
-				tmpCursor = [NSCursor arrowCursor];
-				break;
-		};
-	}
-	[tmpCursor set];
+  static bool systemCursorVisible = true;
+
+  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_kStandardCursorCopy:
+      case GHOST_kStandardCursorDefault:
+      default:
+        tmpCursor = [NSCursor arrowCursor];
+        break;
+    };
+  }
+  [tmpCursor set];
 }
 
-
-
 GHOST_TSuccess GHOST_WindowCocoa::setWindowCursorVisibility(bool visible)
 {
-	NSAutoreleasePool *pool = [[NSAutoreleasePool alloc]init];
+  NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 
-	if ([m_window isVisible]) {
-		loadCursor(visible, getCursorShape());
-	}
+  if ([m_window isVisible]) {
+    loadCursor(visible, getCursorShape());
+  }
 
-	[pool drain];
-	return GHOST_kSuccess;
+  [pool drain];
+  return GHOST_kSuccess;
 }
 
-
 GHOST_TSuccess GHOST_WindowCocoa::setWindowCursorGrab(GHOST_TGrabCursorMode mode)
 {
-	GHOST_TSuccess err = GHOST_kSuccess;
+  GHOST_TSuccess err = GHOST_kSuccess;
 
-	if (mode != GHOST_kGrabDisable) {
-		//No need to perform grab without warp as it is always on in OS X
-		if (mode != GHOST_kGrabNormal) {
-			NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
+  if (mode != GHOST_kGrabDisable) {
+    //No need to perform grab without warp as it is always on in OS X
+    if (mode != GHOST_kGrabNormal) {
+      NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 
-			m_systemCocoa->getCursorPosition(m_cursorGrabInitPos[0], m_cursorGrabInitPos[1]);
-			setCursorGrabAccum(0, 0);
+      m_systemCocoa->getCursorPosition(m_cursorGrabInitPos[0], m_cursorGrabInitPos[1]);
+      setCursorGrabAccum(0, 0);
 
-			if (mode == GHOST_kGrabHide) {
-				setWindowCursorVisibility(false);
-			}
+      if (mode == GHOST_kGrabHide) {
+        setWindowCursorVisibility(false);
+      }
 
-			//Make window key if it wasn't to get the mouse move events
-			[m_window makeKeyWindow];
+      //Make window key if it wasn't to get the mouse move events
+      [m_window makeKeyWindow];
 
-			[pool drain];
-		}
-	}
-	else {
-		if (m_cursorGrab==GHOST_kGrabHide) {
-			m_systemCocoa->setCursorPosition(m_cursorGrabInitPos[0], m_cursorGrabInitPos[1]);
-			setWindowCursorVisibility(true);
-		}
+      [pool drain];
+    }
+  }
+  else {
+    if (m_cursorGrab == GHOST_kGrabHide) {
+      m_systemCocoa->setCursorPosition(m_cursorGrabInitPos[0], m_cursorGrabInitPos[1]);
+      setWindowCursorVisibility(true);
+    }
 
-		/* Almost works without but important otherwise the mouse GHOST location can be incorrect on exit */
-		setCursorGrabAccum(0, 0);
-		m_cursorGrabBounds.m_l= m_cursorGrabBounds.m_r= -1; /* disable */
-	}
-	return err;
+    /* Almost works without but important otherwise the mouse GHOST location can be incorrect on exit */
+    setCursorGrabAccum(0, 0);
+    m_cursorGrabBounds.m_l = m_cursorGrabBounds.m_r = -1; /* disable */
+  }
+  return err;
 }
 
 GHOST_TSuccess GHOST_WindowCocoa::setWindowCursorShape(GHOST_TStandardCursor shape)
 {
-	NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
+  NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 
-	if (m_customCursor) {
-		[m_customCursor release];
-		m_customCursor = nil;
-	}
+  if (m_customCursor) {
+    [m_customCursor release];
+    m_customCursor = nil;
+  }
 
-	if ([m_window isVisible]) {
-		loadCursor(getCursorVisibility(), shape);
-	}
+  if ([m_window isVisible]) {
+    loadCursor(getCursorVisibility(), shape);
+  }
 
-	[pool drain];
-	return GHOST_kSuccess;
+  [pool drain];
+  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;
+  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:NSDeviceWhiteColorSpace
-															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++) {
+  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:NSDeviceWhiteColorSpace
+                   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));
+    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));
+    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];
+  imSize.width = sizex;
+  imSize.height = sizey;
+  cursorImage = [[NSImage alloc] initWithSize:imSize];
+  [cursorImage addRepresentation:cursorImageRep];
 
-	hotSpotPoint.x = hotX;
-	hotSpotPoint.y = hotY;
+  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];
+  //foreground and background color parameter is not handled for now (10.6)
+  m_customCursor = [[NSCursor alloc] initWithImage:cursorImage hotSpot:hotSpotPoint];
 
-	[cursorImageRep release];
-	[cursorImage release];
+  [cursorImageRep release];
+  [cursorImage release];
 
-	if ([m_window isVisible]) {
-		loadCursor(getCursorVisibility(), GHOST_kStandardCursorCustom);
-	}
-	[pool drain];
-	return GHOST_kSuccess;
+  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)
+                                                             GHOST_TUns8 mask[16][2],
+                                                             int hotX,
+                                                             int hotY)
 {
-	return setWindowCustomCursorShape((GHOST_TUns8*)bitmap, (GHOST_TUns8*) mask, 16, 16, hotX, hotY, 0, 1);
+  return setWindowCustomCursorShape(
+      (GHOST_TUns8 *)bitmap, (GHOST_TUns8 *)mask, 16, 16, hotX, hotY, 0, 1);
 }