style cleanup: wm, mosyly adding space around ops

1 files changed, 347 insertions, 352 deletions

diff --git a/source/blender/windowmanager/intern/wm_cursors.c b/source/blender/windowmanager/intern/wm_cursors.c
index 2f0a118b54a..80a25913481 100644
--- a/source/blender/windowmanager/intern/wm_cursors.c
+++ b/source/blender/windowmanager/intern/wm_cursors.c
@@ -55,27 +55,27 @@
 /* Some simple ghost <-> blender conversions */
 static GHOST_TStandardCursor convert_cursor(int curs) 
 {
-	switch(curs) {
+	switch (curs) {
 		default:
-		case CURSOR_STD:		return GHOST_kStandardCursorDefault;
-		case CURSOR_FACESEL:	return GHOST_kStandardCursorRightArrow;
-		case CURSOR_WAIT:		return GHOST_kStandardCursorWait;
-		case CURSOR_EDIT:		return GHOST_kStandardCursorCrosshair;
+		case CURSOR_STD:        return GHOST_kStandardCursorDefault;
+		case CURSOR_FACESEL:    return GHOST_kStandardCursorRightArrow;
+		case CURSOR_WAIT:       return GHOST_kStandardCursorWait;
+		case CURSOR_EDIT:       return GHOST_kStandardCursorCrosshair;
 		case CURSOR_HELP:		
 #ifdef __APPLE__
 			return GHOST_kStandardCursorLeftRight;
 #else
 			return GHOST_kStandardCursorHelp;
 #endif
-		case CURSOR_X_MOVE:		return GHOST_kStandardCursorLeftRight;
-		case CURSOR_Y_MOVE:		return GHOST_kStandardCursorUpDown;
-		case CURSOR_PENCIL:		return GHOST_kStandardCursorPencil;
-		case CURSOR_COPY:		return GHOST_kStandardCursorCopy;
+		case CURSOR_X_MOVE:     return GHOST_kStandardCursorLeftRight;
+		case CURSOR_Y_MOVE:     return GHOST_kStandardCursorUpDown;
+		case CURSOR_PENCIL:     return GHOST_kStandardCursorPencil;
+		case CURSOR_COPY:       return GHOST_kStandardCursorCopy;
 	}
 }
 
 static void window_set_custom_cursor(wmWindow *win, unsigned char mask[16][2], 
-							  unsigned char bitmap[16][2], int hotx, int hoty) 
+                                     unsigned char bitmap[16][2], int hotx, int hoty)
 {
 	GHOST_SetCustomCursorShape(win->ghostwin, bitmap, mask, hotx, hoty);
 }
@@ -84,17 +84,17 @@ static void window_set_custom_cursor_ex(wmWindow *win, BCursor *cursor, int useB
 {
 	if (useBig) {
 		GHOST_SetCustomCursorShapeEx(win->ghostwin, 
-									 (GHOST_TUns8 *)cursor->big_bm, (GHOST_TUns8 *)cursor->big_mask, 
-									 cursor->big_sizex,cursor->big_sizey,
-									 cursor->big_hotx,cursor->big_hoty,
-									 cursor->fg_color, cursor->bg_color);
+		                             (GHOST_TUns8 *)cursor->big_bm, (GHOST_TUns8 *)cursor->big_mask,
+		                             cursor->big_sizex, cursor->big_sizey,
+		                             cursor->big_hotx, cursor->big_hoty,
+		                             cursor->fg_color, cursor->bg_color);
 	}
 	else {
 		GHOST_SetCustomCursorShapeEx(win->ghostwin, 
-									 (GHOST_TUns8 *)cursor->small_bm, (GHOST_TUns8 *)cursor->small_mask, 
-									 cursor->small_sizex,cursor->small_sizey,
-									 cursor->small_hotx,cursor->small_hoty,
-									 cursor->fg_color, cursor->bg_color);
+		                             (GHOST_TUns8 *)cursor->small_bm, (GHOST_TUns8 *)cursor->small_mask,
+		                             cursor->small_sizex, cursor->small_sizey,
+		                             cursor->small_hotx, cursor->small_hoty,
+		                             cursor->fg_color, cursor->bg_color);
 	}
 }
 
@@ -105,9 +105,9 @@ static BCursor *BlenderCursor[BC_NUMCURSORS]; /*Points to static BCursor Structs
 void WM_cursor_set(wmWindow *win, int curs)
 {
 
-	if (win==NULL) return; /* Can't set custom cursor before Window init */
+	if (win == NULL) return;  /* Can't set custom cursor before Window init */
 
-	if (curs==CURSOR_NONE) {
+	if (curs == CURSOR_NONE) {
 		GHOST_SetCursorVisibility(win->ghostwin, 0);
 		return;
 	}
@@ -115,28 +115,28 @@ void WM_cursor_set(wmWindow *win, int curs)
 #ifdef _WIN32
 	/* the default win32 cross cursor is barely visible,
 	 * only 1 pixel thick, use another one instead */
-	if (curs==CURSOR_EDIT)
-		curs= BC_CROSSCURSOR;
+	if (curs == CURSOR_EDIT)
+		curs = BC_CROSSCURSOR;
 #endif
 
 	GHOST_SetCursorVisibility(win->ghostwin, 1);
 	
 	if (curs == CURSOR_STD && win->modalcursor)
-		curs= win->modalcursor;
+		curs = win->modalcursor;
 	
-	win->cursor= curs;
+	win->cursor = curs;
 	
 	/* detect if we use system cursor or Blender cursor */
-	if (curs>=BC_GHOST_CURSORS) {
+	if (curs >= BC_GHOST_CURSORS) {
 		GHOST_SetCursorShape(win->ghostwin, convert_cursor(curs));
 	}
 	else {
-		if ((curs<SYSCURSOR) || (curs>=BC_NUMCURSORS)) return;	
+		if ((curs < SYSCURSOR) || (curs >= BC_NUMCURSORS)) return;
 
-		if (curs==SYSCURSOR) {  /* System default Cursor */
+		if (curs == SYSCURSOR) {  /* System default Cursor */
 			GHOST_SetCursorShape(win->ghostwin, convert_cursor(CURSOR_STD));
 		}
-		else if ( (U.curssize==0) || (BlenderCursor[curs]->big_bm == NULL) ) {
+		else if ( (U.curssize == 0) || (BlenderCursor[curs]->big_bm == NULL) ) {
 			window_set_custom_cursor_ex(win, BlenderCursor[curs], 0);
 		}
 		else {
@@ -165,10 +165,10 @@ void WM_cursor_restore(wmWindow *win)
 void WM_cursor_wait(int val)
 {
 	if (!G.background) {
-		wmWindowManager *wm= G.main->wm.first;
-		wmWindow *win= wm?wm->windows.first:NULL; 
+		wmWindowManager *wm = G.main->wm.first;
+		wmWindow *win = wm ? wm->windows.first : NULL;
 		
-		for (; win; win= win->next) {
+		for (; win; win = win->next) {
 			if (val) {
 				WM_cursor_modal(win, BC_WAITCURSOR);
 			}
@@ -186,11 +186,11 @@ void WM_cursor_grab(wmWindow *win, int wrap, int hide, int *bounds)
 	 * */
 	GHOST_TGrabCursorMode mode = GHOST_kGrabNormal;
 
-	if (hide)		mode = GHOST_kGrabHide;
-	else if (wrap)	mode = GHOST_kGrabWrap;
+	if (hide) mode = GHOST_kGrabHide;
+	else if (wrap) mode = GHOST_kGrabWrap;
 	if ((G.f & G_DEBUG) == 0) {
 		if (win && win->ghostwin) {
-			const GHOST_TabletData *tabletdata= GHOST_GetTabletData(win->ghostwin);
+			const GHOST_TabletData *tabletdata = GHOST_GetTabletData(win->ghostwin);
 			// Note: There is no tabletdata on Windows if no tablet device is connected.
 			if (!tabletdata)
 				GHOST_SetCursorGrab(win->ghostwin, mode, bounds);
@@ -215,22 +215,22 @@ void WM_cursor_ungrab(wmWindow *win)
 /* give it a modal keymap one day? */
 int wm_cursor_arrow_move(wmWindow *win, wmEvent *event)
 {
-	if (win && event->val==KM_PRESS) {
+	if (win && event->val == KM_PRESS) {
 		
-		if (event->type==UPARROWKEY) {
-			WM_cursor_warp(win, event->x, event->y+1);
+		if (event->type == UPARROWKEY) {
+			WM_cursor_warp(win, event->x, event->y + 1);
 			return 1;
 		}
-		else if (event->type==DOWNARROWKEY) {
-			WM_cursor_warp(win, event->x, event->y-1);
+		else if (event->type == DOWNARROWKEY) {
+			WM_cursor_warp(win, event->x, event->y - 1);
 			return 1;
 		}
-		else if (event->type==LEFTARROWKEY) {
-			WM_cursor_warp(win, event->x-1, event->y);
+		else if (event->type == LEFTARROWKEY) {
+			WM_cursor_warp(win, event->x - 1, event->y);
 			return 1;
 		}
-		else if (event->type==RIGHTARROWKEY) {
-			WM_cursor_warp(win, event->x+1, event->y);
+		else if (event->type == RIGHTARROWKEY) {
+			WM_cursor_warp(win, event->x + 1, event->y);
 			return 1;
 		}
 	}
@@ -242,36 +242,36 @@ int wm_cursor_arrow_move(wmWindow *win, wmEvent *event)
 void WM_timecursor(wmWindow *win, int nr)
 {
 	/* 10 8x8 digits */
-	static char number_bitmaps[10][8]= {
-	{0,  56,  68,  68,  68,  68,  68,  56}, 
-	{0,  24,  16,  16,  16,  16,  16,  56}, 
-	{0,  60,  66,  32,  16,   8,   4, 126}, 
-	{0, 124,  32,  16,  56,  64,  66,  60}, 
-	{0,  32,  48,  40,  36, 126,  32,  32}, 
-	{0, 124,   4,  60,  64,  64,  68,  56}, 
-	{0,  56,   4,   4,  60,  68,  68,  56}, 
-	{0, 124,  64,  32,  16,   8,   8,   8}, 
-	{0,  60,  66,  66,  60,  66,  66,  60}, 
-	{0,  56,  68,  68, 120,  64,  68,  56} 
+	static char number_bitmaps[10][8] = {
+		{0,  56,  68,  68,  68,  68,  68,  56},
+		{0,  24,  16,  16,  16,  16,  16,  56},
+		{0,  60,  66,  32,  16,   8,   4, 126},
+		{0, 124,  32,  16,  56,  64,  66,  60},
+		{0,  32,  48,  40,  36, 126,  32,  32},
+		{0, 124,   4,  60,  64,  64,  68,  56},
+		{0,  56,   4,   4,  60,  68,  68,  56},
+		{0, 124,  64,  32,  16,   8,   8,   8},
+		{0,  60,  66,  66,  60,  66,  66,  60},
+		{0,  56,  68,  68, 120,  64,  68,  56}
 	};
 	unsigned char mask[16][2];
-	unsigned char bitmap[16][2]= {{0}};
+	unsigned char bitmap[16][2] = {{0}};
 	int i, idx;
 	
 	if (win->lastcursor == 0)
-		win->lastcursor= win->cursor; 
+		win->lastcursor = win->cursor;
 	
 	memset(&mask, 0xFF, sizeof(mask));
 	
 	/* print number bottom right justified */
-	for (idx= 3; nr && idx>=0; idx--) {
-		char *digit= number_bitmaps[nr%10];
-		int x = idx%2;
-		int y = idx/2;
-		
-		for (i=0; i<8; i++)
-			bitmap[i + y*8][x]= digit[i];
-		nr/= 10;
+	for (idx = 3; nr && idx >= 0; idx--) {
+		char *digit = number_bitmaps[nr % 10];
+		int x = idx % 2;
+		int y = idx / 2;
+
+		for (i = 0; i < 8; i++)
+			bitmap[i + y * 8][x] = digit[i];
+		nr /= 10;
 	}
 	
 	window_set_custom_cursor(win, mask, bitmap, 7, 7);
@@ -324,78 +324,78 @@ void wm_init_cursor_data(void)
 {
 	/********************** NW_ARROW Cursor **************************/
 BEGIN_CURSOR_BLOCK
-		static char nw_sbm[]={
-			0x03,  0x00,  0x05,  0x00,  0x09,  0x00,  0x11,  0x00,
-				0x21,  0x00,  0x41,  0x00,  0x81,  0x00,  0x01,  0x01,
-				0x01,  0x02,  0xc1,  0x03,  0x49,  0x00,  0x8d,  0x00,
-				0x8b,  0x00,  0x10,  0x01,  0x90,  0x01,  0x60,  0x00,
-		};
-
-		static char nw_smsk[]={
-			0x03,  0x00,  0x07,  0x00,  0x0f,  0x00,  0x1f,  0x00,
-				0x3f,  0x00,  0x7f,  0x00,  0xff,  0x00,  0xff,  0x01,
-				0xff,  0x03,  0xff,  0x03,  0x7f,  0x00,  0xff,  0x00,
-				0xfb,  0x00,  0xf0,  0x01,  0xf0,  0x01,  0x60,  0x00,
-		};
-
-		static BCursor NWArrowCursor = {
-			/*small*/
-			nw_sbm, nw_smsk,
-				16, 16, 
-				6,  7,
-				/*big*/
-				NULL, NULL,
-				32,32, 
-				15, 15,
-				/*color*/
-				BC_BLACK, BC_WHITE
-		};
-
-		BlenderCursor[BC_NW_ARROWCURSOR]=&NWArrowCursor;
+	static char nw_sbm[] = {
+		0x03,  0x00,  0x05,  0x00,  0x09,  0x00,  0x11,  0x00,
+		0x21,  0x00,  0x41,  0x00,  0x81,  0x00,  0x01,  0x01,
+		0x01,  0x02,  0xc1,  0x03,  0x49,  0x00,  0x8d,  0x00,
+		0x8b,  0x00,  0x10,  0x01,  0x90,  0x01,  0x60,  0x00,
+	};
+
+	static char nw_smsk[] = {
+		0x03,  0x00,  0x07,  0x00,  0x0f,  0x00,  0x1f,  0x00,
+		0x3f,  0x00,  0x7f,  0x00,  0xff,  0x00,  0xff,  0x01,
+		0xff,  0x03,  0xff,  0x03,  0x7f,  0x00,  0xff,  0x00,
+		0xfb,  0x00,  0xf0,  0x01,  0xf0,  0x01,  0x60,  0x00,
+	};
+
+	static BCursor NWArrowCursor = {
+		/*small*/
+		nw_sbm, nw_smsk,
+		16, 16,
+		6,  7,
+		/*big*/
+		NULL, NULL,
+		32, 32,
+		15, 15,
+		/*color*/
+		BC_BLACK, BC_WHITE
+	};
+
+	BlenderCursor[BC_NW_ARROWCURSOR] = &NWArrowCursor;
 END_CURSOR_BLOCK
 
 	///********************** NS_ARROW Cursor *************************/
 BEGIN_CURSOR_BLOCK
-		static char ns_sbm[]={
-			0x40,  0x01,  0x20,  0x02,  0x10,  0x04,  0x08,  0x08,
-				0x04,  0x10,  0x3c,  0x1e,  0x20,  0x02,  0x20,  0x02,
-				0x20,  0x02,  0x20,  0x02,  0x3c,  0x1e,  0x04,  0x10,
-				0x08,  0x08,  0x10,  0x04,  0x20,  0x02,  0x40,  0x01
-		};
-
-		static char ns_smsk[]={
-			0xc0,  0x01,  0xe0,  0x03,  0xf0,  0x07,  0xf8,  0x0f,
-				0xfc,  0x1f,  0xfc,  0x1f,  0xe0,  0x03,  0xe0,  0x03,
-				0xe0,  0x03,  0xe0,  0x03,  0xfc,  0x1f,  0xfc,  0x1f,
-				0xf8,  0x0f,  0xf0,  0x07,  0xe0,  0x03,  0xc0,  0x01
-		};
-
-		static BCursor NSArrowCursor = {
-			/*small*/
-			ns_sbm, ns_smsk,
-				16, 16, 
-				6,  7,
-				/*big*/
-				NULL, NULL,
-				32,32, 
-				15, 15,
-				/*color*/
-				BC_BLACK, BC_WHITE
-		};
-
-		BlenderCursor[BC_NS_ARROWCURSOR]=&NSArrowCursor;
+	static char ns_sbm[] = {
+		0x40,  0x01,  0x20,  0x02,  0x10,  0x04,  0x08,  0x08,
+		0x04,  0x10,  0x3c,  0x1e,  0x20,  0x02,  0x20,  0x02,
+		0x20,  0x02,  0x20,  0x02,  0x3c,  0x1e,  0x04,  0x10,
+		0x08,  0x08,  0x10,  0x04,  0x20,  0x02,  0x40,  0x01
+	};
+
+	static char ns_smsk[] = {
+		0xc0,  0x01,  0xe0,  0x03,  0xf0,  0x07,  0xf8,  0x0f,
+		0xfc,  0x1f,  0xfc,  0x1f,  0xe0,  0x03,  0xe0,  0x03,
+		0xe0,  0x03,  0xe0,  0x03,  0xfc,  0x1f,  0xfc,  0x1f,
+		0xf8,  0x0f,  0xf0,  0x07,  0xe0,  0x03,  0xc0,  0x01
+	};
+
+	static BCursor NSArrowCursor = {
+		/*small*/
+		ns_sbm, ns_smsk,
+		16, 16,
+		6,  7,
+		/*big*/
+		NULL, NULL,
+		32, 32,
+		15, 15,
+		/*color*/
+		BC_BLACK, BC_WHITE
+	};
+
+	BlenderCursor[BC_NS_ARROWCURSOR] = &NSArrowCursor;
 		
 END_CURSOR_BLOCK
 	/********************** EW_ARROW Cursor *************************/
 BEGIN_CURSOR_BLOCK
-	static char ew_sbm[]={
+	static char ew_sbm[] = {
 		0x00,  0x00,  0x00,  0x00,  0x10,  0x08,  0x38,  0x1c,
 		0x2c,  0x34,  0xe6,  0x67,  0x03,  0xc0,  0x01,  0x80,
 		0x03,  0xc0,  0xe6,  0x67,  0x2c,  0x34,  0x38,  0x1c,
 		0x10,  0x08,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
 	};
 
-	static char ew_smsk[]={
+	static char ew_smsk[] = {
 		0x00,  0x00,  0x00,  0x00,  0x10,  0x08,  0x38,  0x1c,
 		0x3c,  0x3c,  0xfe,  0x7f,  0xff,  0xff,  0xff,  0xff,
 		0xff,  0xff,  0xfe,  0x7f,  0x3c,  0x3c,  0x38,  0x1c,
@@ -409,32 +409,32 @@ BEGIN_CURSOR_BLOCK
 		7,  6,
 		/*big*/
 		NULL, NULL,
-		32,32, 
+		32, 32,
 		15, 15,
 		/*color*/
 		BC_BLACK, BC_WHITE
 	};
 
-	BlenderCursor[BC_EW_ARROWCURSOR]=&EWArrowCursor;
+	BlenderCursor[BC_EW_ARROWCURSOR] = &EWArrowCursor;
 END_CURSOR_BLOCK
 
 	/********************** Wait Cursor *****************************/
 BEGIN_CURSOR_BLOCK
-	static char wait_sbm[]={
+	static char wait_sbm[] = {
 		0xfe,  0x7f,  0x02,  0x40,  0x02,  0x40,  0x84,  0x21,
 		0xc8,  0x13,  0xd0,  0x0b,  0xa0,  0x04,  0x20,  0x05,
 		0xa0,  0x04,  0x10,  0x09,  0x88,  0x11,  0xc4,  0x23,
 		0xe2,  0x47,  0xfa,  0x5f,  0x02,  0x40,  0xfe,  0x7f,
 	};
 
-	static char wait_smsk[]={
+	static char wait_smsk[] = {
 		0xfe,  0x7f,  0xfe,  0x7f,  0x06,  0x60,  0x8c,  0x31,
 		0xd8,  0x1b,  0xf0,  0x0f,  0xe0,  0x06,  0x60,  0x07,
 		0xe0,  0x06,  0x30,  0x0d,  0x98,  0x19,  0xcc,  0x33,
 		0xe6,  0x67,  0xfe,  0x7f,  0xfe,  0x7f,  0xfe,  0x7f,
 	};
 
-	static char wait_lbm[]={
+	static char wait_lbm[] = {
 		0xfc,  0xff,  0xff,  0x3f,  0xfc,  0xff,  0xff,  0x3f,
 		0x0c,  0x00,  0x00,  0x30,  0x0c,  0x00,  0x00,  0x30,
 		0x0c,  0x00,  0x00,  0x30,  0x0c,  0x00,  0x00,  0x18,
@@ -453,7 +453,7 @@ BEGIN_CURSOR_BLOCK
 		0xfc,  0xff,  0xff,  0x3f,  0xfc,  0xff,  0xff,  0x3f,
 	};
 
-	static char wait_lmsk[]={
+	static char wait_lmsk[] = {
 		0xfc,  0xff,  0xff,  0x3f,  0xfc,  0xff,  0xff,  0x3f,
 		0xfc,  0xff,  0xff,  0x3f,  0xfc,  0xff,  0xff,  0x3f,
 		0x3c,  0x00,  0x00,  0x3c,  0x3c,  0x00,  0x00,  0x1e,
@@ -474,36 +474,36 @@ BEGIN_CURSOR_BLOCK
 
 	static BCursor WaitCursor = {
 		/*small*/
-	wait_sbm, wait_smsk,
+		wait_sbm, wait_smsk,
 		16, 16, 
 		7,  7,
 		/*big*/
 		wait_lbm, wait_lmsk,
-		32,32, 
+		32, 32,
 		15, 15,
 		/*color*/
 		BC_BLACK, BC_WHITE
 	};
 
-	BlenderCursor[BC_WAITCURSOR]=&WaitCursor;
+	BlenderCursor[BC_WAITCURSOR] = &WaitCursor;
 END_CURSOR_BLOCK
 
 	/********************** Cross Cursor ***************************/
 BEGIN_CURSOR_BLOCK
-	static char cross_sbm[]={
+	static char cross_sbm[] = {
 		0x00,  0x00,  0x80,  0x01,  0x80,  0x01,  0x80,  0x01,
 		0x80,  0x01,  0x80,  0x01,  0x80,  0x01,  0x7e,  0x7e,
 		0x7e,  0x7e,  0x80,  0x01,  0x80,  0x01,  0x80,  0x01,
 		0x80,  0x01,  0x80,  0x01,  0x80,  0x01,  0x00,  0x00,
 	};
 
-	static char cross_smsk[]={
+	static char cross_smsk[] = {
 		0x80,  0x01,  0x80,  0x01,  0x80,  0x01,  0x80,  0x01,
 		0x80,  0x01,  0x80,  0x01,  0xc0,  0x03,  0x7f,  0xfe,
 		0x7f,  0xfe,  0xc0,  0x03,  0x80,  0x01,  0x80,  0x01,
 		0x80,  0x01,  0x80,  0x01,  0x80,  0x01,  0x80,  0x01,
 	};
-	static char cross_lbm[]={
+	static char cross_lbm[] = {
 		0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
 		0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
 		0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
@@ -522,7 +522,7 @@ BEGIN_CURSOR_BLOCK
 		0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
 	};
 
-	static char cross_lmsk[]={
+	static char cross_lmsk[] = {
 		0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
 		0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
 		0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
@@ -548,25 +548,25 @@ BEGIN_CURSOR_BLOCK
 		7,  7,
 		/*big*/
 		cross_lbm, cross_lmsk,
-		32,32, 
+		32, 32,
 		15, 15,
 		/*color*/
 		BC_BLACK, BC_WHITE
 	};
 
-	BlenderCursor[BC_CROSSCURSOR]=&CrossCursor;
+	BlenderCursor[BC_CROSSCURSOR] = &CrossCursor;
 END_CURSOR_BLOCK
 
 	/********************** EditCross Cursor ***********************/	
 BEGIN_CURSOR_BLOCK
-	static char editcross_sbm[]={
+	static char editcross_sbm[] = {
 		0x0e,  0x00,  0x11,  0x00,  0x1d,  0x00,  0x19,  0x03,
 		0x1d,  0x03,  0x11,  0x03,  0x0e,  0x03,  0x00,  0x03,
 		0xf8,  0x7c,  0xf8,  0x7c,  0x00,  0x03,  0x00,  0x03,
 		0x00,  0x03,  0x00,  0x03,  0x00,  0x03,  0x00,  0x00,
 	};
 
-	static char editcross_smsk[]={
+	static char editcross_smsk[] = {
 		0x0e,  0x00,  0x1f,  0x00,  0x1f,  0x03,  0x1f,  0x03,
 		0x1f,  0x03,  0x1f,  0x03,  0x0e,  0x03,  0x80,  0x07,
 		0xfc,  0xfc,  0xfc,  0xfc,  0x80,  0x07,  0x00,  0x03,
@@ -580,26 +580,26 @@ BEGIN_CURSOR_BLOCK
 		9,  8,
 		/*big*/
 		NULL, NULL,
-		32,32, 
+		32, 32,
 		15, 15,
 		/*color*/
 		BC_BLACK, BC_WHITE
 	};
 
-	BlenderCursor[BC_EDITCROSSCURSOR]=&EditCrossCursor;
+	BlenderCursor[BC_EDITCROSSCURSOR] = &EditCrossCursor;
 END_CURSOR_BLOCK
 
 	/********************** Box Select *************************/
 BEGIN_CURSOR_BLOCK
-	static char box_sbm[32]={
-	0x7f,  0x00,  0x41,  0x00,  0x41,  0x00,  0x41,  0x06,
+	static char box_sbm[32] = {
+		0x7f,  0x00,  0x41,  0x00,  0x41,  0x00,  0x41,  0x06,
 		0x41,  0x06,  0x41,  0x06,  0x7f,  0x06,  0x00,  0x06,
 		0xe0,  0x79,  0xe0,  0x79,  0x00,  0x06,  0x00,  0x06,
 		0x00,  0x06,  0x00,  0x06,  0x00,  0x06,  0x00,  0x00,
 	};
 
-	static char box_smsk[32]={
-	0x7f,  0x00,  0x7f,  0x00,  0x63,  0x06,  0x63,  0x06,
+	static char box_smsk[32] = {
+		0x7f,  0x00,  0x7f,  0x00,  0x63,  0x06,  0x63,  0x06,
 		0x63,  0x06,  0x7f,  0x06,  0x7f,  0x06,  0x00,  0x0f,
 		0xf0,  0xf9,  0xf0,  0xf9,  0x00,  0x0f,  0x00,  0x06,
 		0x00,  0x06,  0x00,  0x06,  0x00,  0x06,  0x00,  0x06,
@@ -613,32 +613,32 @@ BEGIN_CURSOR_BLOCK
 		9,  8,
 		/*big*/
 		NULL, NULL,
-		32,32, 
+		32, 32,
 		15, 15,
 		/*color*/
 		BC_BLACK, BC_WHITE
 	};
 
-	BlenderCursor[BC_BOXSELCURSOR]=&BoxSelCursor;
+	BlenderCursor[BC_BOXSELCURSOR] = &BoxSelCursor;
 
 END_CURSOR_BLOCK
 	/********************** Knife Cursor ***********************/
 BEGIN_CURSOR_BLOCK
-	static char knife_sbm[]={
+	static char knife_sbm[] = {
 		0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x2c,
 		0x00, 0x5a, 0x00, 0x34, 0x00, 0x2a, 0x00, 0x17,
 		0x80, 0x06, 0x40, 0x03, 0xa0, 0x03, 0xd0, 0x01,
 		0x68, 0x00, 0x1c, 0x00, 0x06, 0x00, 0x00, 0x00
 	};
 
-	static char knife_smsk[]={
+	static char knife_smsk[] = {
 		0x00, 0x60, 0x00, 0xf0, 0x00, 0xfc, 0x00, 0xfe,
 		0x00, 0xfe, 0x00, 0x7e, 0x00, 0x7f, 0x80, 0x3f,
 		0xc0, 0x0e, 0x60, 0x07, 0xb0, 0x07, 0xd8, 0x03,
 		0xec, 0x01, 0x7e, 0x00, 0x1f, 0x00, 0x07, 0x00
 	};
 
-	static char knife_lbm[]={
+	static char knife_lbm[] = {
 		0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
 		0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
 		0x00,  0x00,  0x00,  0x08,  0x00,  0x00,  0x00,  0x1c,
@@ -658,7 +658,7 @@ BEGIN_CURSOR_BLOCK
 
 	};
 
-	static char knife_lmsk[]={
+	static char knife_lmsk[] = {
 		0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
 		0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x18,
 		0x00,  0x00,  0x00,  0x3c,  0x00,  0x00,  0x00,  0x7e,
@@ -680,41 +680,41 @@ BEGIN_CURSOR_BLOCK
 
 	static BCursor KnifeCursor = {
 		/*small*/
-	knife_sbm, knife_smsk,
+		knife_sbm, knife_smsk,
 		16, 16, 
 		0,  15,
 		/*big*/
 		knife_lbm, knife_lmsk,
-		32,32, 
+		32, 32,
 		0, 31,
 		/*color*/
 		BC_BLACK, BC_WHITE
 	};
 
-	BlenderCursor[BC_KNIFECURSOR]=&KnifeCursor;
+	BlenderCursor[BC_KNIFECURSOR] = &KnifeCursor;
 
 END_CURSOR_BLOCK
 	
 	/********************** Loop Select Cursor ***********************/
 BEGIN_CURSOR_BLOCK
 
-static char vloop_sbm[]={
+	static char vloop_sbm[] = {
 		0x00,  0x00,  0x7e,  0x00,  0x3e,  0x00,  0x1e,  0x00,
 		0x0e,  0x00,  0x66,  0x60,  0x62,  0x6f,  0x00,  0x00,
 		0x20,  0x20,  0x20,  0x20,  0x20,  0x20,  0x20,  0x20,
 		0x00,  0x00,  0x60,  0x60,  0x60,  0x6f,  0x00,  0x00,
-};
+	};
 
-static char vloop_smsk[]={
+	static char vloop_smsk[] = {
 		0xff,  0x01,  0xff,  0x00,  0x7f,  0x00,  0x3f,  0x00,
 		0xff,  0xf0,  0xff,  0xff,  0xf7,  0xff,  0xf3,  0xf0,
 		0x61,  0x60,  0x60,  0x60,  0x60,  0x60,  0x60,  0x60,
 		0xf0,  0xf0,  0xf0,  0xff,  0xf0,  0xff,  0xf0,  0xf0,
-};
+	};
 
 
 
-static char vloop_lbm[]={
+	static char vloop_lbm[] = {
 		0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
 		0xfc,  0x3f,  0x00,  0x00,  0xfc,  0x3f,  0x00,  0x00,
 		0xfc,  0x0f,  0x00,  0x00,  0xfc,  0x0f,  0x00,  0x00,
@@ -731,9 +731,9 @@ static char vloop_lbm[]={
 		0x00,  0x3c,  0x00,  0x3c,  0x00,  0x3c,  0x00,  0x3c,
 		0x00,  0x3c,  0xff,  0x3c,  0x00,  0x3c,  0xff,  0x3c,
 		0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
-};
+	};
 
-static char vloop_lmsk[]={
+	static char vloop_lmsk[] = {
 		0xff,  0xff,  0x03,  0x00,  0xff,  0xff,  0x03,  0x00,
 		0xff,  0xff,  0x00,  0x00,  0xff,  0xff,  0x00,  0x00,
 		0xff,  0x3f,  0x00,  0x00,  0xff,  0x3f,  0x00,  0x00,
@@ -750,38 +750,38 @@ static char vloop_lmsk[]={
 		0x00,  0xff,  0xff,  0xff,  0x00,  0xff,  0xff,  0xff,
 		0x00,  0xff,  0xff,  0xff,  0x00,  0xff,  0xff,  0xff,
 		0x00,  0xff,  0x00,  0xff,  0x00,  0xff,  0x00,  0xff,
-};
+	};
 
 
 
 	static BCursor VLoopCursor = {
 		/*small*/
-	vloop_sbm, vloop_smsk,
+		vloop_sbm, vloop_smsk,
 		16, 16, 
 		0,  0,
 		/*big*/
 		vloop_lbm, vloop_lmsk,
-		32,32, 
+		32, 32,
 		0, 0,
 		/*color*/
 		BC_BLACK, BC_WHITE
 	};
 
-	BlenderCursor[BC_VLOOPCURSOR]=&VLoopCursor;
+	BlenderCursor[BC_VLOOPCURSOR] = &VLoopCursor;
 
-END_CURSOR_BLOCK	
+END_CURSOR_BLOCK
 	
 
 	/********************** TextEdit Cursor ***********************/	
 BEGIN_CURSOR_BLOCK
-	static char textedit_sbm[]={
+	static char textedit_sbm[] = {
 		0xe0,  0x03,  0x10,  0x04,  0x60,  0x03,  0x40,  0x01,
 		0x40,  0x01,  0x40,  0x01,  0x40,  0x01,  0x40,  0x01,
 		0x40,  0x01,  0x40,  0x01,  0x40,  0x01,  0x40,  0x01,
 		0x40,  0x01,  0x60,  0x03,  0x10,  0x04,  0xe0,  0x03,
 	};
 
-	static char textedit_smsk[]={
+	static char textedit_smsk[] = {
 		0xe0,  0x03,  0xf0,  0x07,  0xe0,  0x03,  0xc0,  0x01,
 		0xc0,  0x01,  0xc0,  0x01,  0xc0,  0x01,  0xc0,  0x01,
 		0xc0,  0x01,  0xc0,  0x01,  0xc0,  0x01,  0xc0,  0x01,
@@ -795,19 +795,19 @@ BEGIN_CURSOR_BLOCK
 		9,  8,
 		/*big*/
 		NULL, NULL,
-		32,32, 
+		32, 32,
 		15, 15,
 		/*color*/
 		BC_BLACK, BC_WHITE
 	};
 
-	BlenderCursor[BC_TEXTEDITCURSOR]=&TextEditCursor;
+	BlenderCursor[BC_TEXTEDITCURSOR] = &TextEditCursor;
 END_CURSOR_BLOCK
 
 
 	/********************** Paintbrush Cursor ***********************/	
 BEGIN_CURSOR_BLOCK
-	static char paintbrush_sbm[]={
+	static char paintbrush_sbm[] = {
 
 		0x00,  0xe0,  0x00,  0x98,  0x00,  0x44,  0x00,  0x42,
 		0x00,  0x21,  0x80,  0x20,  0x40,  0x13,  0x40,  0x17,
@@ -818,7 +818,7 @@ BEGIN_CURSOR_BLOCK
 
 	};
 
-	static char paintbrush_smsk[]={
+	static char paintbrush_smsk[] = {
 		0x00,  0xe0,  0x00,  0xf8,  0x00,  0x7c,  0x00,  0x7e,
 		0x00,  0x3f,  0x80,  0x3f,  0xc0,  0x1f,  0xc0,  0x1f,
 		0xe0,  0x0f,  0xf8,  0x07,  0xfc,  0x03,  0xfe,  0x01,
@@ -834,83 +834,83 @@ BEGIN_CURSOR_BLOCK
 		0,  15,
 		/*big*/
 		NULL, NULL,
-		32,32, 
+		32, 32,
 		15, 15,
 		/*color*/
 		BC_BLACK, BC_WHITE
 	};
 
-	BlenderCursor[BC_PAINTBRUSHCURSOR]=&PaintBrushCursor;
+	BlenderCursor[BC_PAINTBRUSHCURSOR] = &PaintBrushCursor;
 END_CURSOR_BLOCK
 
 
 /********************** Hand Cursor ***********************/
 BEGIN_CURSOR_BLOCK
 
-static char hand_sbm[]={ 
-	0x00,  0x00,  0x00,  0x00,  0x80,  0x01,  0x80,  0x0d,  
-	0x98,  0x6d,  0x98,  0x6d,  0xb0,  0x6d,  0xb0,  0x6d,  
-	0xe0,  0x6f,  0xe6,  0x7f,  0xee,  0x7f,  0xfc,  0x3f,  
-	0xf8,  0x3f,  0xf0,  0x1f,  0xc0,  0x1f,  0xc0,  0x1f,  
-};
-
-static char hand_smsk[]={ 
-	0x00,  0x00,  0x80,  0x01,  0xc0,  0x0f,  0xd8,  0x7f,  
-	0xfc,  0xff,  0xfc,  0xff,  0xf8,  0xff,  0xf8,  0xff,  
-	0xf6,  0xff,  0xff,  0xff,  0xff,  0xff,  0xfe,  0x7f,  
-	0xfc,  0x7f,  0xf8,  0x3f,  0xf0,  0x3f,  0xe0,  0x3f,  
-};
-
-
-static BCursor HandCursor = {
-	/*small*/
-	hand_sbm, hand_smsk,
-	16, 16, 
-	8,  8,
-	/*big*/
-	NULL, NULL,
-	32,32, 
-	15, 15,
-	/*color*/
-	BC_BLACK, BC_WHITE
-};
-
-BlenderCursor[BC_HANDCURSOR]=&HandCursor;
+	static char hand_sbm[] = {
+		0x00,  0x00,  0x00,  0x00,  0x80,  0x01,  0x80,  0x0d,
+		0x98,  0x6d,  0x98,  0x6d,  0xb0,  0x6d,  0xb0,  0x6d,
+		0xe0,  0x6f,  0xe6,  0x7f,  0xee,  0x7f,  0xfc,  0x3f,
+		0xf8,  0x3f,  0xf0,  0x1f,  0xc0,  0x1f,  0xc0,  0x1f,
+	};
+
+	static char hand_smsk[] = {
+		0x00,  0x00,  0x80,  0x01,  0xc0,  0x0f,  0xd8,  0x7f,
+		0xfc,  0xff,  0xfc,  0xff,  0xf8,  0xff,  0xf8,  0xff,
+		0xf6,  0xff,  0xff,  0xff,  0xff,  0xff,  0xfe,  0x7f,
+		0xfc,  0x7f,  0xf8,  0x3f,  0xf0,  0x3f,  0xe0,  0x3f,
+	};
+
+
+	static BCursor HandCursor = {
+		/*small*/
+		hand_sbm, hand_smsk,
+		16, 16,
+		8,  8,
+		/*big*/
+		NULL, NULL,
+		32, 32,
+		15, 15,
+		/*color*/
+		BC_BLACK, BC_WHITE
+	};
+
+	BlenderCursor[BC_HANDCURSOR] = &HandCursor;
 
 END_CURSOR_BLOCK
 
 /********************** NSEW Scroll Cursor ***********************/
 BEGIN_CURSOR_BLOCK
 
-static char nsewscroll_sbm[]={ 
-	0x00,  0x00,  0x80,  0x01,  0xc0,  0x03,  0xc0,  0x03,  
-	0x00,  0x00,  0x00,  0x00,  0x0c,  0x30,  0x0e,  0x70,  
-	0x0e,  0x70,  0x0c,  0x30,  0x00,  0x00,  0x00,  0x00,  
-	0xc0,  0x03,  0xc0,  0x03,  0x80,  0x01,  0x00,  0x00, 
-};
-
-static char nsewscroll_smsk[]={ 
-	0x80,  0x01,  0xc0,  0x03,  0xe0,  0x07,  0xe0,  0x07,  
-	0xc0,  0x03,  0x0c,  0x30,  0x1e,  0x78,  0x1f,  0xf8,  
-	0x1f,  0xf8,  0x1e,  0x78,  0x0c,  0x30,  0xc0,  0x03,  
-	0xe0,  0x07,  0xe0,  0x07,  0xc0,  0x03,  0x80,  0x01, 
-};
-
-
-static BCursor NSEWScrollCursor = {
-	/*small*/
-	nsewscroll_sbm, nsewscroll_smsk,
-	16, 16, 
-	8, 8,
-	/*big*/
-	NULL, NULL,
-	32,32, 
-	15, 15,
-	/*color*/
-	BC_BLACK, BC_WHITE
-};
-
-BlenderCursor[BC_NSEW_SCROLLCURSOR]=&NSEWScrollCursor;
+	static char nsewscroll_sbm[] = {
+		0x00,  0x00,  0x80,  0x01,  0xc0,  0x03,  0xc0,  0x03,
+		0x00,  0x00,  0x00,  0x00,  0x0c,  0x30,  0x0e,  0x70,
+		0x0e,  0x70,  0x0c,  0x30,  0x00,  0x00,  0x00,  0x00,
+		0xc0,  0x03,  0xc0,  0x03,  0x80,  0x01,  0x00,  0x00,
+	};
+
+	static char nsewscroll_smsk[] = {
+		0x80,  0x01,  0xc0,  0x03,  0xe0,  0x07,  0xe0,  0x07,
+		0xc0,  0x03,  0x0c,  0x30,  0x1e,  0x78,  0x1f,  0xf8,
+		0x1f,  0xf8,  0x1e,  0x78,  0x0c,  0x30,  0xc0,  0x03,
+		0xe0,  0x07,  0xe0,  0x07,  0xc0,  0x03,  0x80,  0x01,
+	};
+
+
+	static BCursor NSEWScrollCursor = {
+		/*small*/
+		nsewscroll_sbm, nsewscroll_smsk,
+		16, 16,
+		8, 8,
+		/*big*/
+		NULL, NULL,
+		32, 32,
+		15, 15,
+		/*color*/
+		BC_BLACK, BC_WHITE
+	};
+
+	BlenderCursor[BC_NSEW_SCROLLCURSOR] = &NSEWScrollCursor;
 
 END_CURSOR_BLOCK
 
@@ -918,35 +918,35 @@ END_CURSOR_BLOCK
 /********************** NS Scroll Cursor ***********************/
 BEGIN_CURSOR_BLOCK
 
-static char nsscroll_sbm[]={ 
-	0x00,  0x00,  0x80,  0x01,  0xc0,  0x03,  0xc0,  0x03,  
-	0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  
-	0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  
-	0xc0,  0x03,  0xc0,  0x03,  0x80,  0x01,  0x00,  0x00,
-};
-
-static char nsscroll_smsk[]={ 
-	0x80,  0x01,  0xc0,  0x03,  0xe0,  0x07,  0xe0,  0x07,  
-	0xc0,  0x03,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  
-	0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0xc0,  0x03,  
-	0xe0,  0x07,  0xe0,  0x07,  0xc0,  0x03,  0x80,  0x01,
-};
-
-
-static BCursor NSScrollCursor = {
-	/*small*/
-	nsscroll_sbm, nsscroll_smsk,
-	16, 16, 
-	8, 8,
-	/*big*/
-	NULL, NULL,
-	32,32, 
-	15, 15,
-	/*color*/
-	BC_BLACK, BC_WHITE
-};
-
-BlenderCursor[BC_NS_SCROLLCURSOR]=&NSScrollCursor;
+	static char nsscroll_sbm[] = {
+		0x00,  0x00,  0x80,  0x01,  0xc0,  0x03,  0xc0,  0x03,
+		0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
+		0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
+		0xc0,  0x03,  0xc0,  0x03,  0x80,  0x01,  0x00,  0x00,
+	};
+
+	static char nsscroll_smsk[] = {
+		0x80,  0x01,  0xc0,  0x03,  0xe0,  0x07,  0xe0,  0x07,
+		0xc0,  0x03,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
+		0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0xc0,  0x03,
+		0xe0,  0x07,  0xe0,  0x07,  0xc0,  0x03,  0x80,  0x01,
+	};
+
+
+	static BCursor NSScrollCursor = {
+		/*small*/
+		nsscroll_sbm, nsscroll_smsk,
+		16, 16,
+		8, 8,
+		/*big*/
+		NULL, NULL,
+		32, 32,
+		15, 15,
+		/*color*/
+		BC_BLACK, BC_WHITE
+	};
+
+	BlenderCursor[BC_NS_SCROLLCURSOR] = &NSScrollCursor;
 
 END_CURSOR_BLOCK
 
@@ -954,110 +954,105 @@ END_CURSOR_BLOCK
 /********************** EW Scroll Cursor ***********************/
 BEGIN_CURSOR_BLOCK
 
-static char ewscroll_sbm[]={ 
-	0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  
-	0x00,  0x00,  0x00,  0x00,  0x0c,  0x30,  0x0e,  0x70,  
-	0x0e,  0x70,  0x0c,  0x30,  0x00,  0x00,  0x00,  0x00,  
-	0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
-};
-
-static char ewscroll_smsk[]={ 
-	0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  
-	0x00,  0x00,  0x0c,  0x30,  0x1e,  0x78,  0x1f,  0xf8,  
-	0x1f,  0xf8,  0x1e,  0x78,  0x0c,  0x30,  0x00,  0x00,  
-	0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
-};
-
-
-static BCursor EWScrollCursor = {
-	/*small*/
-	ewscroll_sbm, ewscroll_smsk,
-	16, 16, 
-	8, 8,
-	/*big*/
-	NULL, NULL,
-	32,32, 
-	15, 15,
-	/*color*/
-	BC_BLACK, BC_WHITE
-};
-
-BlenderCursor[BC_EW_SCROLLCURSOR]=&EWScrollCursor;
+	static char ewscroll_sbm[] = {
+		0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
+		0x00,  0x00,  0x00,  0x00,  0x0c,  0x30,  0x0e,  0x70,
+		0x0e,  0x70,  0x0c,  0x30,  0x00,  0x00,  0x00,  0x00,
+		0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
+	};
+
+	static char ewscroll_smsk[] = {
+		0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
+		0x00,  0x00,  0x0c,  0x30,  0x1e,  0x78,  0x1f,  0xf8,
+		0x1f,  0xf8,  0x1e,  0x78,  0x0c,  0x30,  0x00,  0x00,
+		0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
+	};
+
+
+	static BCursor EWScrollCursor = {
+		/*small*/
+		ewscroll_sbm, ewscroll_smsk,
+		16, 16,
+		8, 8,
+		/*big*/
+		NULL, NULL,
+		32, 32,
+		15, 15,
+		/*color*/
+		BC_BLACK, BC_WHITE
+	};
+
+	BlenderCursor[BC_EW_SCROLLCURSOR] = &EWScrollCursor;
 
 END_CURSOR_BLOCK
 
 /********************** Eyedropper Cursor ***********************/
 BEGIN_CURSOR_BLOCK
 
-static char eyedropper_sbm[]={ 
-	0x00,  0x30,  0x00,  0x48,  0x00,  0x85,  0x80,  0x82,  
-	0x40,  0x40,  0x80,  0x20,  0x40,  0x11,  0xa0,  0x23,  
-	0xd0,  0x15,  0xe8,  0x0a,  0x74,  0x01,  0xb4,  0x00,  
-	0x4a,  0x00,  0x35,  0x00,  0x08,  0x00,  0x04,  0x00,
-};
-
-static char eyedropper_smsk[]={ 
-	0x00,  0x30,  0x00,  0x78,  0x00,  0xfd,  0x80,  0xff,  
-	0xc0,  0x7f,  0x80,  0x3f,  0xc0,  0x1f,  0xe0,  0x3f,  
-	0xf0,  0x1f,  0xf8,  0x0b,  0xfc,  0x01,  0xfc,  0x00,  
-	0x7e,  0x00,  0x3f,  0x00,  0x0c,  0x00,  0x04,  0x00, 
-};
-
-
-static BCursor EyedropperCursor = {
-	/*small*/
-	eyedropper_sbm, eyedropper_smsk,
-	16, 16, 
-	1, 15,
-	/*big*/
-	NULL, NULL,
-	32,32, 
-	15, 15,
-	/*color*/
-	BC_BLACK, BC_WHITE
-};
-
-BlenderCursor[BC_EYEDROPPER_CURSOR]=&EyedropperCursor;
+	static char eyedropper_sbm[] = {
+		0x00,  0x30,  0x00,  0x48,  0x00,  0x85,  0x80,  0x82,
+		0x40,  0x40,  0x80,  0x20,  0x40,  0x11,  0xa0,  0x23,
+		0xd0,  0x15,  0xe8,  0x0a,  0x74,  0x01,  0xb4,  0x00,
+		0x4a,  0x00,  0x35,  0x00,  0x08,  0x00,  0x04,  0x00,
+	};
+
+	static char eyedropper_smsk[] = {
+		0x00,  0x30,  0x00,  0x78,  0x00,  0xfd,  0x80,  0xff,
+		0xc0,  0x7f,  0x80,  0x3f,  0xc0,  0x1f,  0xe0,  0x3f,
+		0xf0,  0x1f,  0xf8,  0x0b,  0xfc,  0x01,  0xfc,  0x00,
+		0x7e,  0x00,  0x3f,  0x00,  0x0c,  0x00,  0x04,  0x00,
+	};
+
+	
+	static BCursor EyedropperCursor = {
+		/*small*/
+		eyedropper_sbm, eyedropper_smsk,
+		16, 16,
+		1, 15,
+		/*big*/
+		NULL, NULL,
+		32, 32,
+		15, 15,
+		/*color*/
+		BC_BLACK, BC_WHITE
+	};
+
+	BlenderCursor[BC_EYEDROPPER_CURSOR] = &EyedropperCursor;
 
 END_CURSOR_BLOCK
 
 /********************** Swap Area Cursor ***********************/
 BEGIN_CURSOR_BLOCK
-static char swap_sbm[]={
-	0xc0,  0xff,  0x40,  0x80,  0x40,  0x80,  0x40,  0x9c,
-	0x40,  0x98,  0x40,  0x94,  0x00,  0x82,  0xfe,  0x80,
-	0x7e,  0xfd,  0xbe,  0x01,  0xda,  0x01,  0xe2,  0x01,
-	0xe2,  0x01,  0xc2,  0x01,  0xfe,  0x01,  0x00,  0x00,
-};
-
-static char swap_smsk[]={
-	0xc0,  0xff,  0xc0,  0xff,  0xc0,  0xff,  0xc0,  0xff,
-	0xc0,  0xff,  0xc0,  0xff,  0xff,  0xff,  0xff,  0xff,
-	0xff,  0xff,  0xff,  0x03,  0xff,  0x03,  0xff,  0x03,
-	0xff,  0x03,  0xff,  0x03,  0xff,  0x03,  0xff,  0x03,
-};
-
-static BCursor SwapCursor = {
-	/*small*/
-	swap_sbm, swap_smsk,
-	16, 16, 
-	8,  8,
-	/*big*/
-	NULL, NULL,
-	32,32, 
-	15, 15,
-	/*color*/
-	BC_YELLOW, BC_BLUE
-};
-
-BlenderCursor[BC_SWAPAREA_CURSOR]=&SwapCursor;
-
-END_CURSOR_BLOCK
-/********************** Put the cursors in the array ***********************/
-	
+	static char swap_sbm[] = {
+		0xc0,  0xff,  0x40,  0x80,  0x40,  0x80,  0x40,  0x9c,
+		0x40,  0x98,  0x40,  0x94,  0x00,  0x82,  0xfe,  0x80,
+		0x7e,  0xfd,  0xbe,  0x01,  0xda,  0x01,  0xe2,  0x01,
+		0xe2,  0x01,  0xc2,  0x01,  0xfe,  0x01,  0x00,  0x00,
+	};
 
+	static char swap_smsk[] = {
+		0xc0,  0xff,  0xc0,  0xff,  0xc0,  0xff,  0xc0,  0xff,
+		0xc0,  0xff,  0xc0,  0xff,  0xff,  0xff,  0xff,  0xff,
+		0xff,  0xff,  0xff,  0x03,  0xff,  0x03,  0xff,  0x03,
+		0xff,  0x03,  0xff,  0x03,  0xff,  0x03,  0xff,  0x03,
+	};
 
-}
+	static BCursor SwapCursor = {
+		/*small*/
+		swap_sbm, swap_smsk,
+		16, 16,
+		8,  8,
+		/*big*/
+		NULL, NULL,
+		32, 32,
+		15, 15,
+		/*color*/
+		BC_YELLOW, BC_BLUE
+	};
 
+	BlenderCursor[BC_SWAPAREA_CURSOR] = &SwapCursor;
 
+END_CURSOR_BLOCK
+/********************** Put the cursors in the array ***********************/
 
+}