Cleanup: add trailing commas to avoid right shift
[blender.git] / source / blender / windowmanager / intern / wm_cursors.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2005-2007 Blender Foundation
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup wm
22  *
23  * Cursor pixmap and cursor utility functions to change the cursor.
24  */
25
26 #include <stdio.h>
27 #include <string.h>
28
29 #include "GHOST_C-api.h"
30
31 #include "BLI_utildefines.h"
32
33 #include "BLI_sys_types.h"
34
35 #include "DNA_listBase.h"
36 #include "DNA_userdef_types.h"
37 #include "DNA_workspace_types.h"
38
39 #include "BKE_context.h"
40 #include "BKE_global.h"
41 #include "BKE_main.h"
42
43 #include "WM_types.h"
44 #include "WM_api.h"
45 #include "wm_cursors.h"
46 #include "wm_window.h"
47
48 /* XXX this still is mess from old code */
49
50 /* Some simple ghost <-> blender conversions */
51 static GHOST_TStandardCursor convert_cursor(int curs)
52 {
53   switch (curs) {
54     default:
55     case CURSOR_STD:
56       return GHOST_kStandardCursorDefault;
57     case CURSOR_FACESEL:
58       return GHOST_kStandardCursorRightArrow;
59     case CURSOR_WAIT:
60       return GHOST_kStandardCursorWait;
61     case CURSOR_EDIT:
62       return GHOST_kStandardCursorCrosshair;
63     case CURSOR_HELP:
64 #ifdef __APPLE__
65       return GHOST_kStandardCursorLeftRight;
66 #else
67       return GHOST_kStandardCursorHelp;
68 #endif
69     case CURSOR_X_MOVE:
70       return GHOST_kStandardCursorLeftRight;
71     case CURSOR_Y_MOVE:
72       return GHOST_kStandardCursorUpDown;
73     case CURSOR_PENCIL:
74       return GHOST_kStandardCursorPencil;
75     case CURSOR_COPY:
76       return GHOST_kStandardCursorCopy;
77   }
78 }
79
80 static void window_set_custom_cursor(
81     wmWindow *win, unsigned char mask[16][2], unsigned char bitmap[16][2], int hotx, int hoty)
82 {
83   GHOST_SetCustomCursorShape(win->ghostwin, bitmap, mask, hotx, hoty);
84 }
85
86 static void window_set_custom_cursor_ex(wmWindow *win, BCursor *cursor, int useBig)
87 {
88   if (useBig) {
89     GHOST_SetCustomCursorShapeEx(win->ghostwin,
90                                  (GHOST_TUns8 *)cursor->big_bm,
91                                  (GHOST_TUns8 *)cursor->big_mask,
92                                  cursor->big_sizex,
93                                  cursor->big_sizey,
94                                  cursor->big_hotx,
95                                  cursor->big_hoty,
96                                  cursor->fg_color,
97                                  cursor->bg_color);
98   }
99   else {
100     GHOST_SetCustomCursorShapeEx(win->ghostwin,
101                                  (GHOST_TUns8 *)cursor->small_bm,
102                                  (GHOST_TUns8 *)cursor->small_mask,
103                                  cursor->small_sizex,
104                                  cursor->small_sizey,
105                                  cursor->small_hotx,
106                                  cursor->small_hoty,
107                                  cursor->fg_color,
108                                  cursor->bg_color);
109   }
110 }
111
112 /* Cursor Globals */
113 static BCursor *BlenderCursor[BC_NUMCURSORS]; /*Points to static BCursor Structs */
114
115 void WM_cursor_set(wmWindow *win, int curs)
116 {
117
118   if (win == NULL || G.background) {
119     return; /* Can't set custom cursor before Window init */
120   }
121
122   if (curs == CURSOR_NONE) {
123     GHOST_SetCursorVisibility(win->ghostwin, 0);
124     return;
125   }
126
127 #ifdef _WIN32
128   /* the default win32 cross cursor is barely visible,
129    * only 1 pixel thick, use another one instead */
130   if (curs == CURSOR_EDIT) {
131     curs = BC_CROSSCURSOR;
132   }
133 #else
134   /* in case of large cursor, also use custom cursor because
135    * large cursors don't work for system cursors */
136   if (U.curssize && curs == CURSOR_EDIT) {
137     curs = BC_CROSSCURSOR;
138   }
139 #endif
140
141   GHOST_SetCursorVisibility(win->ghostwin, 1);
142
143   if (curs == CURSOR_STD && win->modalcursor) {
144     curs = win->modalcursor;
145   }
146
147   win->cursor = curs;
148
149   /* detect if we use system cursor or Blender cursor */
150   if (curs >= BC_GHOST_CURSORS) {
151     GHOST_SetCursorShape(win->ghostwin, convert_cursor(curs));
152   }
153   else {
154     if ((curs < SYSCURSOR) || (curs >= BC_NUMCURSORS)) {
155       return;
156     }
157
158     if (curs == SYSCURSOR) { /* System default Cursor */
159       GHOST_SetCursorShape(win->ghostwin, convert_cursor(CURSOR_STD));
160     }
161     else if ((U.curssize == 0) || (BlenderCursor[curs]->big_bm == NULL)) {
162       window_set_custom_cursor_ex(win, BlenderCursor[curs], 0);
163     }
164     else {
165       window_set_custom_cursor_ex(win, BlenderCursor[curs], 1);
166     }
167   }
168 }
169
170 bool WM_cursor_set_from_tool(struct wmWindow *win, const ScrArea *sa, const ARegion *ar)
171 {
172   if (ar && (ar->regiontype != RGN_TYPE_WINDOW)) {
173     return false;
174   }
175
176   bToolRef_Runtime *tref_rt = (sa && sa->runtime.tool) ? sa->runtime.tool->runtime : NULL;
177   if (tref_rt && tref_rt->cursor != CURSOR_STD) {
178     if (win->modalcursor == 0) {
179       WM_cursor_set(win, tref_rt->cursor);
180       win->cursor = tref_rt->cursor;
181       return true;
182     }
183   }
184   return false;
185 }
186
187 void WM_cursor_modal_set(wmWindow *win, int val)
188 {
189   if (win->lastcursor == 0) {
190     win->lastcursor = win->cursor;
191   }
192   win->modalcursor = val;
193   WM_cursor_set(win, val);
194 }
195
196 void WM_cursor_modal_restore(wmWindow *win)
197 {
198   win->modalcursor = 0;
199   if (win->lastcursor) {
200     WM_cursor_set(win, win->lastcursor);
201   }
202   win->lastcursor = 0;
203 }
204
205 /* to allow usage all over, we do entire WM */
206 void WM_cursor_wait(bool val)
207 {
208   if (!G.background) {
209     wmWindowManager *wm = G_MAIN->wm.first;
210     wmWindow *win = wm ? wm->windows.first : NULL;
211
212     for (; win; win = win->next) {
213       if (val) {
214         WM_cursor_modal_set(win, BC_WAITCURSOR);
215       }
216       else {
217         WM_cursor_modal_restore(win);
218       }
219     }
220   }
221 }
222
223 /**
224  * \param bounds: can be NULL
225  */
226 void WM_cursor_grab_enable(wmWindow *win, bool wrap, bool hide, int bounds[4])
227 {
228   /* Only grab cursor when not running debug.
229    * It helps not to get a stuck WM when hitting a breakpoint
230    * */
231   GHOST_TGrabCursorMode mode = GHOST_kGrabNormal;
232
233   if (bounds) {
234     wm_cursor_position_to_ghost(win, &bounds[0], &bounds[1]);
235     wm_cursor_position_to_ghost(win, &bounds[2], &bounds[3]);
236   }
237
238   if (hide) {
239     mode = GHOST_kGrabHide;
240   }
241   else if (wrap) {
242     mode = GHOST_kGrabWrap;
243   }
244   if ((G.debug & G_DEBUG) == 0) {
245     if (win->ghostwin) {
246       /* Note: There is no tabletdata on Windows if no tablet device is connected. */
247       if (win->eventstate->is_motion_absolute == false) {
248         GHOST_SetCursorGrab(win->ghostwin, mode, bounds, NULL);
249       }
250
251       win->grabcursor = mode;
252     }
253   }
254 }
255
256 void WM_cursor_grab_disable(wmWindow *win, const int mouse_ungrab_xy[2])
257 {
258   if ((G.debug & G_DEBUG) == 0) {
259     if (win && win->ghostwin) {
260       if (mouse_ungrab_xy) {
261         int mouse_xy[2] = {mouse_ungrab_xy[0], mouse_ungrab_xy[1]};
262         wm_cursor_position_to_ghost(win, &mouse_xy[0], &mouse_xy[1]);
263         GHOST_SetCursorGrab(win->ghostwin, GHOST_kGrabDisable, NULL, mouse_xy);
264       }
265       else {
266         GHOST_SetCursorGrab(win->ghostwin, GHOST_kGrabDisable, NULL, NULL);
267       }
268
269       win->grabcursor = GHOST_kGrabDisable;
270     }
271   }
272 }
273
274 static void wm_cursor_warp_relative(wmWindow *win, int x, int y)
275 {
276   /* note: don't use wmEvent coords because of continuous grab [#36409] */
277   int cx, cy;
278   wm_get_cursor_position(win, &cx, &cy);
279   WM_cursor_warp(win, cx + x, cy + y);
280 }
281
282 /* give it a modal keymap one day? */
283 bool wm_cursor_arrow_move(wmWindow *win, const wmEvent *event)
284 {
285   if (win && event->val == KM_PRESS) {
286     if (event->type == UPARROWKEY) {
287       wm_cursor_warp_relative(win, 0, 1);
288       return 1;
289     }
290     else if (event->type == DOWNARROWKEY) {
291       wm_cursor_warp_relative(win, 0, -1);
292       return 1;
293     }
294     else if (event->type == LEFTARROWKEY) {
295       wm_cursor_warp_relative(win, -1, 0);
296       return 1;
297     }
298     else if (event->type == RIGHTARROWKEY) {
299       wm_cursor_warp_relative(win, 1, 0);
300       return 1;
301     }
302   }
303   return 0;
304 }
305
306 /* after this you can call restore too */
307 void WM_cursor_time(wmWindow *win, int nr)
308 {
309   /* 10 8x8 digits */
310   const char number_bitmaps[10][8] = {
311       {0, 56, 68, 68, 68, 68, 68, 56},
312       {0, 24, 16, 16, 16, 16, 16, 56},
313       {0, 60, 66, 32, 16, 8, 4, 126},
314       {0, 124, 32, 16, 56, 64, 66, 60},
315       {0, 32, 48, 40, 36, 126, 32, 32},
316       {0, 124, 4, 60, 64, 64, 68, 56},
317       {0, 56, 4, 4, 60, 68, 68, 56},
318       {0, 124, 64, 32, 16, 8, 8, 8},
319       {0, 60, 66, 66, 60, 66, 66, 60},
320       {0, 56, 68, 68, 120, 64, 68, 56},
321   };
322   unsigned char mask[16][2];
323   unsigned char bitmap[16][2] = {{0}};
324   int i, idx;
325
326   if (win->lastcursor == 0) {
327     win->lastcursor = win->cursor;
328   }
329
330   memset(&mask, 0xFF, sizeof(mask));
331
332   /* print number bottom right justified */
333   for (idx = 3; nr && idx >= 0; idx--) {
334     const char *digit = number_bitmaps[nr % 10];
335     int x = idx % 2;
336     int y = idx / 2;
337
338     for (i = 0; i < 8; i++) {
339       bitmap[i + y * 8][x] = digit[i];
340     }
341     nr /= 10;
342   }
343
344   window_set_custom_cursor(win, mask, bitmap, 7, 7);
345 }
346
347 /**
348  * Custom Cursor Description
349  * =========================
350  *
351  * Each bit represents a pixel, so 1 byte = 8 pixels,
352  * the bytes go Left to Right. Top to bottom
353  * the bits in a byte go right to left
354  * (ie;  0x01, 0x80  represents a line of 16 pix with the first and last pix set.)
355  *
356  * - A 0 in the bitmap = bg_color, a 1 fg_color
357  * - a 0 in the mask   = transparent pix.
358  *
359  * Until 32x32 cursors are supported on all platforms, the size of the
360  * small cursors MUST be 16x16.
361  *
362  * Large cursors have a maximum size of 32x32.
363  *
364  * Other than that, the specified size of the cursors is just a guideline,
365  * However, the char array that defines the BM and MASK must be byte aligned.
366  * ie a 17x17 cursor needs 3 bytes (cols) * 17 bytes (rows)
367  * (3 bytes = 17 bits rounded up to nearest whole byte).  Pad extra bits
368  * in mask with 0's.
369  *
370  * Setting `big_bm = NULL` disables the large version of the cursor.
371  *
372  * ----
373  *
374  * There is a nice Python GUI utility that can be used for drawing cursors in
375  * this format in the Blender source distribution, in
376  * `./source/tools/utils/make_cursor_gui.py` .
377  *
378  * Start it with the command `python3 make_cursor_gui.py`
379  * It will copy its output to the console when you press 'Do it'.
380  */
381
382 /**
383  * Because defining a cursor mixes declarations and executable code
384  * each cursor needs it's own scoping block or it would be split up
385  * over several hundred lines of code.  To enforce/document this better
386  * I define 2 pretty brain-dead macros so it's obvious what the extra "[]"
387  * are for */
388
389 #define BEGIN_CURSOR_BLOCK \
390   { \
391     ((void)0)
392 #define END_CURSOR_BLOCK \
393   } \
394   ((void)0)
395
396 void wm_init_cursor_data(void)
397 {
398   /********************** NW_ARROW Cursor **************************/
399   BEGIN_CURSOR_BLOCK;
400   static char nw_sbm[] = {
401       0x03, 0x00, 0x05, 0x00, 0x09, 0x00, 0x11, 0x00, 0x21, 0x00, 0x41,
402       0x00, 0x81, 0x00, 0x01, 0x01, 0x01, 0x02, 0xc1, 0x03, 0x49, 0x00,
403       0x8d, 0x00, 0x8b, 0x00, 0x10, 0x01, 0x90, 0x01, 0x60, 0x00,
404   };
405
406   static char nw_smsk[] = {
407       0x03, 0x00, 0x07, 0x00, 0x0f, 0x00, 0x1f, 0x00, 0x3f, 0x00, 0x7f,
408       0x00, 0xff, 0x00, 0xff, 0x01, 0xff, 0x03, 0xff, 0x03, 0x7f, 0x00,
409       0xff, 0x00, 0xfb, 0x00, 0xf0, 0x01, 0xf0, 0x01, 0x60, 0x00,
410   };
411
412   static BCursor NWArrowCursor = {
413       /*small*/
414       nw_sbm,
415       nw_smsk,
416       16,
417       16,
418       6,
419       7,
420       /*big*/
421       NULL,
422       NULL,
423       32,
424       32,
425       15,
426       15,
427       /*color*/
428       BC_BLACK,
429       BC_WHITE,
430   };
431
432   BlenderCursor[BC_NW_ARROWCURSOR] = &NWArrowCursor;
433   END_CURSOR_BLOCK;
434
435   ///********************** NS_ARROW Cursor *************************/
436   BEGIN_CURSOR_BLOCK;
437   static char ns_sbm[] = {
438       0x40, 0x01, 0x20, 0x02, 0x10, 0x04, 0x08, 0x08, 0x04, 0x10, 0x3c,
439       0x1e, 0x20, 0x02, 0x20, 0x02, 0x20, 0x02, 0x20, 0x02, 0x3c, 0x1e,
440       0x04, 0x10, 0x08, 0x08, 0x10, 0x04, 0x20, 0x02, 0x40, 0x01,
441   };
442
443   static char ns_smsk[] = {
444       0xc0, 0x01, 0xe0, 0x03, 0xf0, 0x07, 0xf8, 0x0f, 0xfc, 0x1f, 0xfc,
445       0x1f, 0xe0, 0x03, 0xe0, 0x03, 0xe0, 0x03, 0xe0, 0x03, 0xfc, 0x1f,
446       0xfc, 0x1f, 0xf8, 0x0f, 0xf0, 0x07, 0xe0, 0x03, 0xc0, 0x01,
447   };
448
449   static BCursor NSArrowCursor = {
450       /*small*/
451       ns_sbm,
452       ns_smsk,
453       16,
454       16,
455       6,
456       7,
457       /*big*/
458       NULL,
459       NULL,
460       32,
461       32,
462       15,
463       15,
464       /*color*/
465       BC_BLACK,
466       BC_WHITE,
467   };
468
469   BlenderCursor[BC_NS_ARROWCURSOR] = &NSArrowCursor;
470
471   END_CURSOR_BLOCK;
472   /********************** EW_ARROW Cursor *************************/
473   BEGIN_CURSOR_BLOCK;
474   static char ew_sbm[] = {
475       0x00, 0x00, 0x00, 0x00, 0x10, 0x08, 0x38, 0x1c, 0x2c, 0x34, 0xe6,
476       0x67, 0x03, 0xc0, 0x01, 0x80, 0x03, 0xc0, 0xe6, 0x67, 0x2c, 0x34,
477       0x38, 0x1c, 0x10, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
478   };
479
480   static char ew_smsk[] = {
481       0x00, 0x00, 0x00, 0x00, 0x10, 0x08, 0x38, 0x1c, 0x3c, 0x3c, 0xfe,
482       0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x7f, 0x3c, 0x3c,
483       0x38, 0x1c, 0x10, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
484   };
485
486   static BCursor EWArrowCursor = {
487       /*small*/
488       ew_sbm,
489       ew_smsk,
490       16,
491       16,
492       7,
493       6,
494       /*big*/
495       NULL,
496       NULL,
497       32,
498       32,
499       15,
500       15,
501       /*color*/
502       BC_BLACK,
503       BC_WHITE,
504   };
505
506   BlenderCursor[BC_EW_ARROWCURSOR] = &EWArrowCursor;
507   END_CURSOR_BLOCK;
508
509   /********************** Wait Cursor *****************************/
510   BEGIN_CURSOR_BLOCK;
511   static char wait_sbm[] = {
512       0xfe, 0x7f, 0x02, 0x40, 0x02, 0x40, 0x84, 0x21, 0xc8, 0x13, 0xd0,
513       0x0b, 0xa0, 0x04, 0x20, 0x05, 0xa0, 0x04, 0x10, 0x09, 0x88, 0x11,
514       0xc4, 0x23, 0xe2, 0x47, 0xfa, 0x5f, 0x02, 0x40, 0xfe, 0x7f,
515   };
516
517   static char wait_smsk[] = {
518       0xfe, 0x7f, 0xfe, 0x7f, 0x06, 0x60, 0x8c, 0x31, 0xd8, 0x1b, 0xf0,
519       0x0f, 0xe0, 0x06, 0x60, 0x07, 0xe0, 0x06, 0x30, 0x0d, 0x98, 0x19,
520       0xcc, 0x33, 0xe6, 0x67, 0xfe, 0x7f, 0xfe, 0x7f, 0xfe, 0x7f,
521   };
522
523   static char wait_lbm[] = {
524       0xfc, 0xff, 0xff, 0x3f, 0xfc, 0xff, 0xff, 0x3f, 0x0c, 0x00, 0x00, 0x30, 0x0c, 0x00, 0x00,
525       0x30, 0x0c, 0x00, 0x00, 0x30, 0x0c, 0x00, 0x00, 0x18, 0x18, 0xc0, 0x03, 0x0c, 0x30, 0x20,
526       0x07, 0x06, 0x60, 0xf0, 0x0f, 0x03, 0xc0, 0xd0, 0x8d, 0x01, 0x80, 0x79, 0xcf, 0x00, 0x00,
527       0xf3, 0x67, 0x00, 0x00, 0x66, 0x37, 0x00, 0x00, 0x8c, 0x33, 0x00, 0x00, 0x0c, 0x32, 0x00,
528       0x00, 0xcc, 0x33, 0x00, 0x00, 0x8c, 0x30, 0x00, 0x00, 0x46, 0x61, 0x00, 0x00, 0x03, 0xc3,
529       0x00, 0x80, 0x01, 0x83, 0x01, 0xc0, 0xc0, 0x03, 0x03, 0x60, 0xa0, 0x05, 0x06, 0x30, 0xf0,
530       0x0f, 0x0c, 0x18, 0xf8, 0x1d, 0x18, 0x0c, 0x5c, 0x3f, 0x30, 0x0c, 0xff, 0x5f, 0x30, 0x0c,
531       0xf7, 0xfe, 0x31, 0xcc, 0xfb, 0x9f, 0x33, 0x0c, 0x00, 0x00, 0x30, 0x0c, 0x00, 0x00, 0x30,
532       0xfc, 0xff, 0xff, 0x3f, 0xfc, 0xff, 0xff, 0x3f,
533   };
534
535   static char wait_lmsk[] = {
536       0xfc, 0xff, 0xff, 0x3f, 0xfc, 0xff, 0xff, 0x3f, 0xfc, 0xff, 0xff, 0x3f, 0xfc, 0xff, 0xff,
537       0x3f, 0x3c, 0x00, 0x00, 0x3c, 0x3c, 0x00, 0x00, 0x1e, 0x78, 0xc0, 0x03, 0x0f, 0xf0, 0xa0,
538       0x87, 0x07, 0xe0, 0xf1, 0xcf, 0x03, 0xc0, 0xf3, 0xef, 0x01, 0x80, 0xff, 0xff, 0x00, 0x00,
539       0xff, 0x7f, 0x00, 0x00, 0xfe, 0x3f, 0x00, 0x00, 0xfc, 0x3f, 0x00, 0x00, 0x3c, 0x3f, 0x00,
540       0x00, 0xfc, 0x3f, 0x00, 0x00, 0xbc, 0x3c, 0x00, 0x00, 0xde, 0x79, 0x00, 0x00, 0x0f, 0xf3,
541       0x00, 0x80, 0x07, 0xe3, 0x01, 0xc0, 0xc3, 0xc3, 0x03, 0xe0, 0xe1, 0x87, 0x07, 0xf0, 0xf0,
542       0x0f, 0x0f, 0x78, 0xf8, 0x1f, 0x1e, 0x3c, 0x7c, 0x3f, 0x3c, 0x3c, 0xff, 0x7f, 0x3c, 0xbc,
543       0xff, 0xff, 0x3d, 0xfc, 0xfb, 0xbf, 0x3f, 0xfc, 0xff, 0xff, 0x3f, 0xfc, 0xff, 0xff, 0x3f,
544       0xfc, 0xff, 0xff, 0x3f, 0xfc, 0xff, 0xff, 0x3f,
545   };
546
547   static BCursor WaitCursor = {
548       /*small*/
549       wait_sbm,
550       wait_smsk,
551       16,
552       16,
553       7,
554       7,
555       /*big*/
556       wait_lbm,
557       wait_lmsk,
558       32,
559       32,
560       15,
561       15,
562       /*color*/
563       BC_BLACK,
564       BC_WHITE,
565   };
566
567   BlenderCursor[BC_WAITCURSOR] = &WaitCursor;
568   END_CURSOR_BLOCK;
569
570   /********************** Cross Cursor ***************************/
571   BEGIN_CURSOR_BLOCK;
572   static char cross_sbm[] = {
573       0x00, 0x00, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80,
574       0x01, 0x80, 0x01, 0x7e, 0x7e, 0x7e, 0x7e, 0x80, 0x01, 0x80, 0x01,
575       0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x00, 0x00,
576   };
577
578   static char cross_smsk[] = {
579       0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80,
580       0x01, 0xc0, 0x03, 0x7f, 0xfe, 0x7f, 0xfe, 0xc0, 0x03, 0x80, 0x01,
581       0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01,
582   };
583   static char cross_lbm[] = {
584       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01,
585       0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80,
586       0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00,
587       0xc0, 0x03, 0x00, 0x00, 0xc0, 0x03, 0x00, 0x00, 0x40, 0x02, 0x00, 0x00, 0x78, 0x1e, 0x00,
588       0xfc, 0x1f, 0xf8, 0x3f, 0xfc, 0x1f, 0xf8, 0x3f, 0x00, 0x78, 0x1e, 0x00, 0x00, 0x40, 0x02,
589       0x00, 0x00, 0xc0, 0x03, 0x00, 0x00, 0xc0, 0x03, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80,
590       0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00,
591       0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00,
592       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
593   };
594
595   static char cross_lmsk[] = {
596       0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01,
597       0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80,
598       0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00,
599       0xc0, 0x03, 0x00, 0x00, 0xe0, 0x07, 0x00, 0x00, 0x70, 0x0e, 0x00, 0x00, 0x78, 0x1e, 0x00,
600       0xff, 0x1f, 0xf8, 0xff, 0xff, 0x1f, 0xf8, 0xff, 0x00, 0x78, 0x1e, 0x00, 0x00, 0x70, 0x0e,
601       0x00, 0x00, 0xe0, 0x07, 0x00, 0x00, 0xc0, 0x03, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80,
602       0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00,
603       0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00,
604       0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00,
605   };
606
607   static BCursor CrossCursor = {
608       /*small*/
609       cross_sbm,
610       cross_smsk,
611       16,
612       16,
613       7,
614       7,
615       /*big*/
616       cross_lbm,
617       cross_lmsk,
618       32,
619       32,
620       15,
621       15,
622       /*color*/
623       BC_BLACK,
624       BC_WHITE,
625   };
626
627   BlenderCursor[BC_CROSSCURSOR] = &CrossCursor;
628   END_CURSOR_BLOCK;
629
630   /********************** EditCross Cursor ***********************/
631   BEGIN_CURSOR_BLOCK;
632   static char editcross_sbm[] = {
633       0x0e, 0x00, 0x11, 0x00, 0x1d, 0x00, 0x19, 0x03, 0x1d, 0x03, 0x11,
634       0x03, 0x0e, 0x03, 0x00, 0x03, 0xf8, 0x7c, 0xf8, 0x7c, 0x00, 0x03,
635       0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x00,
636   };
637
638   static char editcross_smsk[] = {
639       0x0e, 0x00, 0x1f, 0x00, 0x1f, 0x03, 0x1f, 0x03, 0x1f, 0x03, 0x1f,
640       0x03, 0x0e, 0x03, 0x80, 0x07, 0xfc, 0xfc, 0xfc, 0xfc, 0x80, 0x07,
641       0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03,
642   };
643
644   static BCursor EditCrossCursor = {
645       /*small*/
646       editcross_sbm,
647       editcross_smsk,
648       16,
649       16,
650       9,
651       8,
652       /*big*/
653       NULL,
654       NULL,
655       32,
656       32,
657       15,
658       15,
659       /*color*/
660       BC_BLACK,
661       BC_WHITE,
662   };
663
664   BlenderCursor[BC_EDITCROSSCURSOR] = &EditCrossCursor;
665   END_CURSOR_BLOCK;
666
667   /********************** Box Select *************************/
668   BEGIN_CURSOR_BLOCK;
669   static char box_sbm[32] = {
670       0x7f, 0x00, 0x41, 0x00, 0x41, 0x00, 0x41, 0x06, 0x41, 0x06, 0x41,
671       0x06, 0x7f, 0x06, 0x00, 0x06, 0xe0, 0x79, 0xe0, 0x79, 0x00, 0x06,
672       0x00, 0x06, 0x00, 0x06, 0x00, 0x06, 0x00, 0x06, 0x00, 0x00,
673   };
674
675   static char box_smsk[32] = {
676       0x7f, 0x00, 0x7f, 0x00, 0x63, 0x06, 0x63, 0x06, 0x63, 0x06, 0x7f,
677       0x06, 0x7f, 0x06, 0x00, 0x0f, 0xf0, 0xf9, 0xf0, 0xf9, 0x00, 0x0f,
678       0x00, 0x06, 0x00, 0x06, 0x00, 0x06, 0x00, 0x06, 0x00, 0x06,
679   };
680
681   static BCursor BoxSelCursor = {
682       /*small*/
683       box_sbm,
684       box_smsk,
685       16,
686       16,
687       9,
688       8,
689       /*big*/
690       NULL,
691       NULL,
692       32,
693       32,
694       15,
695       15,
696       /*color*/
697       BC_BLACK,
698       BC_WHITE,
699   };
700
701   BlenderCursor[BC_BOXSELCURSOR] = &BoxSelCursor;
702
703   END_CURSOR_BLOCK;
704   /********************** Knife Cursor ***********************/
705   BEGIN_CURSOR_BLOCK;
706   static char knife_sbm[] = {
707       0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x2c, 0x00, 0x5a, 0x00,
708       0x34, 0x00, 0x2a, 0x00, 0x17, 0x80, 0x06, 0x40, 0x03, 0xa0, 0x03,
709       0xd0, 0x01, 0x68, 0x00, 0x1c, 0x00, 0x06, 0x00, 0x00, 0x00,
710   };
711
712   static char knife_smsk[] = {
713       0x00, 0x60, 0x00, 0xf0, 0x00, 0xfc, 0x00, 0xfe, 0x00, 0xfe, 0x00,
714       0x7e, 0x00, 0x7f, 0x80, 0x3f, 0xc0, 0x0e, 0x60, 0x07, 0xb0, 0x07,
715       0xd8, 0x03, 0xec, 0x01, 0x7e, 0x00, 0x1f, 0x00, 0x07, 0x00,
716   };
717
718   static char knife_lbm[] = {
719       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
720       0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00,
721       0x00, 0x7f, 0x00, 0x00, 0x80, 0xbf, 0x00, 0x00, 0xc0, 0x5f, 0x00, 0x00, 0xc0, 0x6f, 0x00,
722       0x00, 0xc0, 0x37, 0x00, 0x00, 0xa8, 0x1b, 0x00, 0x00, 0x54, 0x0d, 0x00, 0x00, 0xa8, 0x00,
723       0x00, 0x00, 0x54, 0x00, 0x00, 0x00, 0xa8, 0x00, 0x00, 0x00, 0x53, 0x00, 0x00, 0xc0, 0x07,
724       0x00, 0x00, 0xe0, 0x0f, 0x00, 0x00, 0xd0, 0x0f, 0x00, 0x00, 0xe8, 0x07, 0x00, 0x00, 0xf4,
725       0x07, 0x00, 0x00, 0xfa, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x00, 0x80, 0x0e, 0x00, 0x00, 0xc0,
726       0x03, 0x00, 0x00, 0xe0, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
727       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
728   };
729
730   static char knife_lmsk[] = {
731       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
732       0x18, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00, 0x7e, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00,
733       0x80, 0xff, 0x00, 0x00, 0xc0, 0xbf, 0x00, 0x00, 0xe0, 0xdf, 0x00, 0x00, 0xe0, 0xef, 0x00,
734       0x00, 0xf8, 0x77, 0x00, 0x00, 0xfc, 0x3b, 0x00, 0x00, 0xfe, 0x1d, 0x00, 0x00, 0xfe, 0x0f,
735       0x00, 0x00, 0xfe, 0x01, 0x00, 0x00, 0xff, 0x01, 0x00, 0xc0, 0xff, 0x00, 0x00, 0xe0, 0x7f,
736       0x00, 0x00, 0xf0, 0x1f, 0x00, 0x00, 0xd8, 0x1f, 0x00, 0x00, 0xec, 0x0f, 0x00, 0x00, 0xf6,
737       0x0f, 0x00, 0x00, 0xfb, 0x06, 0x00, 0x80, 0xbd, 0x01, 0x00, 0xc0, 0x6e, 0x00, 0x00, 0xe0,
738       0x1b, 0x00, 0x00, 0xf0, 0x06, 0x00, 0x00, 0xb8, 0x01, 0x00, 0x00, 0x6c, 0x00, 0x00, 0x00,
739       0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
740   };
741
742   static BCursor KnifeCursor = {
743       /*small*/
744       knife_sbm,
745       knife_smsk,
746       16,
747       16,
748       0,
749       15,
750       /*big*/
751       knife_lbm,
752       knife_lmsk,
753       32,
754       32,
755       0,
756       31,
757       /*color*/
758       BC_BLACK,
759       BC_WHITE,
760   };
761
762   BlenderCursor[BC_KNIFECURSOR] = &KnifeCursor;
763
764   END_CURSOR_BLOCK;
765
766   /********************** Loop Select Cursor ***********************/
767   BEGIN_CURSOR_BLOCK;
768
769   static char vloop_sbm[] = {
770       0x00, 0x00, 0x7e, 0x00, 0x3e, 0x00, 0x1e, 0x00, 0x0e, 0x00, 0x66,
771       0x60, 0x62, 0x6f, 0x00, 0x00, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
772       0x20, 0x20, 0x00, 0x00, 0x60, 0x60, 0x60, 0x6f, 0x00, 0x00,
773   };
774
775   static char vloop_smsk[] = {
776       0xff, 0x01, 0xff, 0x00, 0x7f, 0x00, 0x3f, 0x00, 0xff, 0xf0, 0xff,
777       0xff, 0xf7, 0xff, 0xf3, 0xf0, 0x61, 0x60, 0x60, 0x60, 0x60, 0x60,
778       0x60, 0x60, 0xf0, 0xf0, 0xf0, 0xff, 0xf0, 0xff, 0xf0, 0xf0,
779   };
780
781   static char vloop_lbm[] = {
782       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x3f, 0x00, 0x00, 0xfc, 0x3f, 0x00,
783       0x00, 0xfc, 0x0f, 0x00, 0x00, 0xfc, 0x0f, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0xfc, 0x03,
784       0x00, 0x00, 0xfc, 0x00, 0x00, 0x00, 0xfc, 0x00, 0x00, 0x00, 0x3c, 0x3c, 0x00, 0x3c, 0x3c,
785       0x3c, 0x00, 0x3c, 0x0c, 0x3c, 0xff, 0x3c, 0x0c, 0x3c, 0xff, 0x3c, 0x00, 0x00, 0x00, 0x00,
786       0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x0c, 0x00, 0x0c, 0x00, 0x0c, 0x00, 0x0c, 0x00,
787       0x0c, 0x00, 0x0c, 0x00, 0x0c, 0x00, 0x0c, 0x00, 0x0c, 0x00, 0x0c, 0x00, 0x0c, 0x00, 0x0c,
788       0x00, 0x0c, 0x00, 0x0c, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
789       0x3c, 0x00, 0x3c, 0x00, 0x3c, 0x00, 0x3c, 0x00, 0x3c, 0xff, 0x3c, 0x00, 0x3c, 0xff, 0x3c,
790       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
791   };
792
793   static char vloop_lmsk[] = {
794       0xff, 0xff, 0x03, 0x00, 0xff, 0xff, 0x03, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00,
795       0x00, 0xff, 0x3f, 0x00, 0x00, 0xff, 0x3f, 0x00, 0x00, 0xff, 0x0f, 0x00, 0x00, 0xff, 0x0f,
796       0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
797       0xff, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xff, 0x0f, 0xff, 0x00, 0xff,
798       0x0f, 0xff, 0x00, 0xff, 0x03, 0x3c, 0x00, 0x3c, 0x03, 0x3c, 0x00, 0x3c, 0x00, 0x3c, 0x00,
799       0x3c, 0x00, 0x3c, 0x00, 0x3c, 0x00, 0x3c, 0x00, 0x3c, 0x00, 0x3c, 0x00, 0x3c, 0x00, 0x3c,
800       0x00, 0x3c, 0x00, 0x3c, 0x00, 0x3c, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00,
801       0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff,
802       0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff,
803   };
804
805   static BCursor VLoopCursor = {
806       /*small*/
807       vloop_sbm,
808       vloop_smsk,
809       16,
810       16,
811       0,
812       0,
813       /*big*/
814       vloop_lbm,
815       vloop_lmsk,
816       32,
817       32,
818       0,
819       0,
820       /*color*/
821       BC_BLACK,
822       BC_WHITE,
823   };
824
825   BlenderCursor[BC_VLOOPCURSOR] = &VLoopCursor;
826
827   END_CURSOR_BLOCK;
828
829   /********************** TextEdit Cursor ***********************/
830   BEGIN_CURSOR_BLOCK;
831   static char textedit_sbm[] = {
832       0xe0, 0x03, 0x10, 0x04, 0x60, 0x03, 0x40, 0x01, 0x40, 0x01, 0x40,
833       0x01, 0x40, 0x01, 0x40, 0x01, 0x40, 0x01, 0x40, 0x01, 0x40, 0x01,
834       0x40, 0x01, 0x40, 0x01, 0x60, 0x03, 0x10, 0x04, 0xe0, 0x03,
835   };
836
837   static char textedit_smsk[] = {
838       0xe0, 0x03, 0xf0, 0x07, 0xe0, 0x03, 0xc0, 0x01, 0xc0, 0x01, 0xc0,
839       0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01,
840       0xc0, 0x01, 0xc0, 0x01, 0xe0, 0x03, 0xf0, 0x07, 0xe0, 0x03,
841   };
842
843   static BCursor TextEditCursor = {
844       /*small*/
845       textedit_sbm,
846       textedit_smsk,
847       16,
848       16,
849       9,
850       8,
851       /*big*/
852       NULL,
853       NULL,
854       32,
855       32,
856       15,
857       15,
858       /*color*/
859       BC_BLACK,
860       BC_WHITE,
861   };
862
863   BlenderCursor[BC_TEXTEDITCURSOR] = &TextEditCursor;
864   END_CURSOR_BLOCK;
865
866   /********************** Paintbrush Cursor ***********************/
867   BEGIN_CURSOR_BLOCK;
868   static char paintbrush_sbm[] = {
869
870       0x00, 0xe0, 0x00, 0x98, 0x00, 0x44, 0x00, 0x42, 0x00, 0x21, 0x80,
871       0x20, 0x40, 0x13, 0x40, 0x17, 0xa0, 0x0b, 0x98, 0x05, 0x04, 0x02,
872       0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x81, 0x00, 0x7f, 0x00,
873   };
874
875   static char paintbrush_smsk[] = {
876       0x00, 0xe0, 0x00, 0xf8, 0x00, 0x7c, 0x00, 0x7e, 0x00, 0x3f, 0x80,
877       0x3f, 0xc0, 0x1f, 0xc0, 0x1f, 0xe0, 0x0f, 0xf8, 0x07, 0xfc, 0x03,
878       0xfe, 0x01, 0xfe, 0x01, 0xfe, 0x01, 0xff, 0x00, 0x7f, 0x00,
879   };
880
881   static BCursor PaintBrushCursor = {
882       /*small*/
883       paintbrush_sbm,
884       paintbrush_smsk,
885       16,
886       16,
887       0,
888       15,
889       /*big*/
890       NULL,
891       NULL,
892       32,
893       32,
894       15,
895       15,
896       /*color*/
897       BC_BLACK,
898       BC_WHITE,
899   };
900
901   BlenderCursor[BC_PAINTBRUSHCURSOR] = &PaintBrushCursor;
902   END_CURSOR_BLOCK;
903
904   /********************** Hand Cursor ***********************/
905   BEGIN_CURSOR_BLOCK;
906
907   static char hand_sbm[] = {
908       0x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0x80, 0x0d, 0x98, 0x6d, 0x98,
909       0x6d, 0xb0, 0x6d, 0xb0, 0x6d, 0xe0, 0x6f, 0xe6, 0x7f, 0xee, 0x7f,
910       0xfc, 0x3f, 0xf8, 0x3f, 0xf0, 0x1f, 0xc0, 0x1f, 0xc0, 0x1f,
911   };
912
913   static char hand_smsk[] = {
914       0x00, 0x00, 0x80, 0x01, 0xc0, 0x0f, 0xd8, 0x7f, 0xfc, 0xff, 0xfc,
915       0xff, 0xf8, 0xff, 0xf8, 0xff, 0xf6, 0xff, 0xff, 0xff, 0xff, 0xff,
916       0xfe, 0x7f, 0xfc, 0x7f, 0xf8, 0x3f, 0xf0, 0x3f, 0xe0, 0x3f,
917   };
918
919   static BCursor HandCursor = {
920       /*small*/
921       hand_sbm,
922       hand_smsk,
923       16,
924       16,
925       8,
926       8,
927       /*big*/
928       NULL,
929       NULL,
930       32,
931       32,
932       15,
933       15,
934       /*color*/
935       BC_BLACK,
936       BC_WHITE,
937   };
938
939   BlenderCursor[BC_HANDCURSOR] = &HandCursor;
940
941   END_CURSOR_BLOCK;
942
943   /********************** NSEW Scroll Cursor ***********************/
944   BEGIN_CURSOR_BLOCK;
945
946   static char nsewscroll_sbm[] = {
947       0x00, 0x00, 0x80, 0x01, 0xc0, 0x03, 0xc0, 0x03, 0x00, 0x00, 0x00,
948       0x00, 0x0c, 0x30, 0x0e, 0x70, 0x0e, 0x70, 0x0c, 0x30, 0x00, 0x00,
949       0x00, 0x00, 0xc0, 0x03, 0xc0, 0x03, 0x80, 0x01, 0x00, 0x00,
950   };
951
952   static char nsewscroll_smsk[] = {
953       0x80, 0x01, 0xc0, 0x03, 0xe0, 0x07, 0xe0, 0x07, 0xc0, 0x03, 0x0c,
954       0x30, 0x1e, 0x78, 0x1f, 0xf8, 0x1f, 0xf8, 0x1e, 0x78, 0x0c, 0x30,
955       0xc0, 0x03, 0xe0, 0x07, 0xe0, 0x07, 0xc0, 0x03, 0x80, 0x01,
956   };
957
958   static BCursor NSEWScrollCursor = {
959       /*small*/
960       nsewscroll_sbm,
961       nsewscroll_smsk,
962       16,
963       16,
964       8,
965       8,
966       /*big*/
967       NULL,
968       NULL,
969       32,
970       32,
971       15,
972       15,
973       /*color*/
974       BC_BLACK,
975       BC_WHITE,
976   };
977
978   BlenderCursor[BC_NSEW_SCROLLCURSOR] = &NSEWScrollCursor;
979
980   END_CURSOR_BLOCK;
981
982   /********************** NS Scroll Cursor ***********************/
983   BEGIN_CURSOR_BLOCK;
984
985   static char nsscroll_sbm[] = {
986       0x00, 0x00, 0x80, 0x01, 0xc0, 0x03, 0xc0, 0x03, 0x00, 0x00, 0x00,
987       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
988       0x00, 0x00, 0xc0, 0x03, 0xc0, 0x03, 0x80, 0x01, 0x00, 0x00,
989   };
990
991   static char nsscroll_smsk[] = {
992       0x80, 0x01, 0xc0, 0x03, 0xe0, 0x07, 0xe0, 0x07, 0xc0, 0x03, 0x00,
993       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
994       0xc0, 0x03, 0xe0, 0x07, 0xe0, 0x07, 0xc0, 0x03, 0x80, 0x01,
995   };
996
997   static BCursor NSScrollCursor = {
998       /*small*/
999       nsscroll_sbm,
1000       nsscroll_smsk,
1001       16,
1002       16,
1003       8,
1004       8,
1005       /*big*/
1006       NULL,
1007       NULL,
1008       32,
1009       32,
1010       15,
1011       15,
1012       /*color*/
1013       BC_BLACK,
1014       BC_WHITE,
1015   };
1016
1017   BlenderCursor[BC_NS_SCROLLCURSOR] = &NSScrollCursor;
1018
1019   END_CURSOR_BLOCK;
1020
1021   /********************** EW Scroll Cursor ***********************/
1022   BEGIN_CURSOR_BLOCK;
1023
1024   static char ewscroll_sbm[] = {
1025       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1026       0x00, 0x0c, 0x30, 0x0e, 0x70, 0x0e, 0x70, 0x0c, 0x30, 0x00, 0x00,
1027       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1028   };
1029
1030   static char ewscroll_smsk[] = {
1031       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c,
1032       0x30, 0x1e, 0x78, 0x1f, 0xf8, 0x1f, 0xf8, 0x1e, 0x78, 0x0c, 0x30,
1033       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1034   };
1035
1036   static BCursor EWScrollCursor = {
1037       /*small*/
1038       ewscroll_sbm,
1039       ewscroll_smsk,
1040       16,
1041       16,
1042       8,
1043       8,
1044       /*big*/
1045       NULL,
1046       NULL,
1047       32,
1048       32,
1049       15,
1050       15,
1051       /*color*/
1052       BC_BLACK,
1053       BC_WHITE,
1054   };
1055
1056   BlenderCursor[BC_EW_SCROLLCURSOR] = &EWScrollCursor;
1057
1058   END_CURSOR_BLOCK;
1059
1060   /********************** Eyedropper Cursor ***********************/
1061   BEGIN_CURSOR_BLOCK;
1062
1063   static char eyedropper_sbm[] = {
1064       0x00, 0x30, 0x00, 0x48, 0x00, 0x85, 0x80, 0x82, 0x40, 0x40, 0x80,
1065       0x20, 0x40, 0x11, 0xa0, 0x23, 0xd0, 0x15, 0xe8, 0x0a, 0x74, 0x01,
1066       0xb4, 0x00, 0x4a, 0x00, 0x35, 0x00, 0x08, 0x00, 0x04, 0x00,
1067   };
1068
1069   static char eyedropper_smsk[] = {
1070       0x00, 0x30, 0x00, 0x78, 0x00, 0xfd, 0x80, 0xff, 0xc0, 0x7f, 0x80,
1071       0x3f, 0xc0, 0x1f, 0xe0, 0x3f, 0xf0, 0x1f, 0xf8, 0x0b, 0xfc, 0x01,
1072       0xfc, 0x00, 0x7e, 0x00, 0x3f, 0x00, 0x0c, 0x00, 0x04, 0x00,
1073   };
1074
1075   static BCursor EyedropperCursor = {
1076       /*small*/
1077       eyedropper_sbm,
1078       eyedropper_smsk,
1079       16,
1080       16,
1081       1,
1082       15,
1083       /*big*/
1084       NULL,
1085       NULL,
1086       32,
1087       32,
1088       15,
1089       15,
1090       /*color*/
1091       BC_BLACK,
1092       BC_WHITE,
1093   };
1094
1095   BlenderCursor[BC_EYEDROPPER_CURSOR] = &EyedropperCursor;
1096
1097   END_CURSOR_BLOCK;
1098
1099   /********************** Swap Area Cursor ***********************/
1100   BEGIN_CURSOR_BLOCK;
1101   static char swap_sbm[] = {
1102       0xc0, 0xff, 0x40, 0x80, 0x40, 0x80, 0x40, 0x9c, 0x40, 0x98, 0x40,
1103       0x94, 0x00, 0x82, 0xfe, 0x80, 0x7e, 0xfd, 0xbe, 0x01, 0xda, 0x01,
1104       0xe2, 0x01, 0xe2, 0x01, 0xc2, 0x01, 0xfe, 0x01, 0x00, 0x00,
1105   };
1106
1107   static char swap_smsk[] = {
1108       0xc0, 0xff, 0xc0, 0xff, 0xc0, 0xff, 0xc0, 0xff, 0xc0, 0xff, 0xc0,
1109       0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0xff, 0x03,
1110       0xff, 0x03, 0xff, 0x03, 0xff, 0x03, 0xff, 0x03, 0xff, 0x03,
1111   };
1112
1113   static BCursor SwapCursor = {
1114       /*small*/
1115       swap_sbm,
1116       swap_smsk,
1117       16,
1118       16,
1119       8,
1120       8,
1121       /*big*/
1122       NULL,
1123       NULL,
1124       32,
1125       32,
1126       15,
1127       15,
1128       /*color*/
1129       BC_YELLOW,
1130       BC_BLUE,
1131   };
1132
1133   BlenderCursor[BC_SWAPAREA_CURSOR] = &SwapCursor;
1134
1135   END_CURSOR_BLOCK;
1136
1137   /********************** Horizontal Split Cursor ***********************/
1138   BEGIN_CURSOR_BLOCK;
1139
1140   static char hsplit_sbm[] = {
1141       0x00, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x88,
1142       0x08, 0x8C, 0x18, 0x8E, 0x38, 0x8C, 0x18, 0x88, 0x08, 0x80, 0x00,
1143       0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00,
1144   };
1145
1146   static char hsplit_smsk[] = {
1147       0xC0, 0x01, 0xC0, 0x01, 0xC0, 0x01, 0xD0, 0x05, 0xD8, 0x0D, 0xDC,
1148       0x1D, 0xDE, 0x3D, 0xDF, 0x7D, 0xDE, 0x3D, 0xDC, 0x1D, 0xD8, 0x0D,
1149       0xD0, 0x05, 0xC0, 0x01, 0xC0, 0x01, 0xC0, 0x01, 0x00, 0x00,
1150   };
1151
1152   static char hsplit_lbm[] = {
1153       0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01,
1154       0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80,
1155       0x01, 0x00, 0x00, 0x84, 0x21, 0x00, 0x00, 0x86, 0x61, 0x00, 0x00, 0x87, 0xE1, 0x00, 0x80,
1156       0x87, 0xE1, 0x01, 0xC0, 0x87, 0xE1, 0x03, 0xE0, 0x87, 0xE1, 0x07, 0xF0, 0x87, 0xE1, 0x0F,
1157       0xF8, 0x87, 0xE1, 0x1F, 0xF0, 0x87, 0xE1, 0x0F, 0xE0, 0x87, 0xE1, 0x07, 0xC0, 0x87, 0xE1,
1158       0x03, 0x80, 0x87, 0xE1, 0x01, 0x00, 0x87, 0xE1, 0x00, 0x00, 0x86, 0x61, 0x00, 0x00, 0x84,
1159       0x21, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00,
1160       0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00,
1161       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
1162
1163   static char hsplit_lmsk[] = {
1164       0x00, 0xC0, 0x03, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xC0, 0x03,
1165       0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xC8, 0x13, 0x00, 0x00, 0xCC, 0x33, 0x00, 0x00, 0xCE,
1166       0x73, 0x00, 0x00, 0xCF, 0xF3, 0x00, 0x80, 0xCF, 0xF3, 0x01, 0xC0, 0xCF, 0xF3, 0x03, 0xE0,
1167       0xCF, 0xF3, 0x07, 0xF0, 0xCF, 0xF3, 0x0F, 0xF8, 0xCF, 0xF3, 0x1F, 0xFC, 0xCF, 0xF3, 0x3F,
1168       0xFE, 0xCF, 0xF3, 0x7F, 0xFC, 0xCF, 0xF3, 0x3F, 0xF8, 0xCF, 0xF3, 0x1F, 0xF0, 0xCF, 0xF3,
1169       0x0F, 0xE0, 0xCF, 0xF3, 0x07, 0xC0, 0xCF, 0xF3, 0x03, 0x80, 0xCF, 0xF3, 0x01, 0x00, 0xCF,
1170       0xF3, 0x00, 0x00, 0xCE, 0x73, 0x00, 0x00, 0xCC, 0x33, 0x00, 0x00, 0xC8, 0x13, 0x00, 0x00,
1171       0xC8, 0x03, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xC0, 0x03, 0x00,
1172       0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00};
1173
1174   static BCursor HSplitCursor = {
1175       /*small*/
1176       hsplit_sbm,
1177       hsplit_smsk,
1178       16,
1179       16,
1180       7,
1181       7,
1182       /*big*/
1183       hsplit_lbm,
1184       hsplit_lmsk,
1185       32,
1186       32,
1187       15,
1188       15,
1189       /*color*/
1190       BC_BLACK,
1191       BC_WHITE,
1192   };
1193
1194   BlenderCursor[BC_H_SPLITCURSOR] = &HSplitCursor;
1195
1196   END_CURSOR_BLOCK;
1197
1198   /********************** Vertical Split Cursor ***********************/
1199   BEGIN_CURSOR_BLOCK;
1200
1201   static char vsplit_sbm[] = {
1202       0x00, 0x00, 0x80, 0x00, 0xC0, 0x01, 0xE0, 0x03, 0x00, 0x00, 0x00,
1203       0x00, 0x00, 0x00, 0xFE, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1204       0xE0, 0x03, 0xC0, 0x01, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00,
1205   };
1206
1207   static char vsplit_smsk[] = {
1208       0x80, 0x00, 0xC0, 0x01, 0xE0, 0x03, 0xF0, 0x07, 0xF8, 0x0F, 0x00,
1209       0x00, 0xFF, 0x7F, 0xFF, 0x7F, 0xFF, 0x7F, 0x00, 0x00, 0xF8, 0x0F,
1210       0xF0, 0x07, 0xE0, 0x03, 0xC0, 0x01, 0x80, 0x00, 0x00, 0x00,
1211   };
1212
1213   static char vsplit_lbm[] = {
1214       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00,
1215       0x00, 0x00, 0xC0, 0x01, 0x00, 0x00, 0xE0, 0x03, 0x00, 0x00, 0xF0, 0x07, 0x00, 0x00, 0xF8,
1216       0x0F, 0x00, 0x00, 0xFC, 0x1F, 0x00, 0x00, 0xFE, 0x3F, 0x00, 0x00, 0xFF, 0x7F, 0x00, 0x00,
1217       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1218       0xFE, 0xFF, 0xFF, 0x3F, 0xFE, 0xFF, 0xFF, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1219       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x7F, 0x00, 0x00, 0xFE,
1220       0x3F, 0x00, 0x00, 0xFC, 0x1F, 0x00, 0x00, 0xF8, 0x0F, 0x00, 0x00, 0xF0, 0x07, 0x00, 0x00,
1221       0xE0, 0x03, 0x00, 0x00, 0xC0, 0x01, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1222       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
1223
1224   static char vsplit_lmsk[] = {
1225       0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0xC0, 0x01, 0x00, 0x00, 0xE0, 0x03,
1226       0x00, 0x00, 0xF0, 0x07, 0x00, 0x00, 0xF8, 0x0F, 0x00, 0x00, 0xFC, 0x1F, 0x00, 0x00, 0xFE,
1227       0x3F, 0x00, 0x00, 0xFF, 0x7F, 0x00, 0x80, 0xFF, 0xFF, 0x00, 0xC0, 0xFF, 0xFF, 0x01, 0xE0,
1228       0xFF, 0xFF, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0x7F,
1229       0xFF, 0xFF, 0xFF, 0x7F, 0xFF, 0xFF, 0xFF, 0x7F, 0xFF, 0xFF, 0xFF, 0x7F, 0x00, 0x00, 0x00,
1230       0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0xFF, 0x03, 0xC0, 0xFF, 0xFF, 0x01, 0x80, 0xFF,
1231       0xFF, 0x00, 0x00, 0xFF, 0x7F, 0x00, 0x00, 0xFE, 0x3F, 0x00, 0x00, 0xFC, 0x1F, 0x00, 0x00,
1232       0xF8, 0x0F, 0x00, 0x00, 0xF0, 0x07, 0x00, 0x00, 0xE0, 0x03, 0x00, 0x00, 0xC0, 0x01, 0x00,
1233       0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
1234
1235   static BCursor VSplitCursor = {
1236       /*small*/
1237       vsplit_sbm,
1238       vsplit_smsk,
1239       16,
1240       16,
1241       7,
1242       7,
1243       /*big*/
1244       vsplit_lbm,
1245       vsplit_lmsk,
1246       32,
1247       32,
1248       15,
1249       15,
1250       /*color*/
1251       BC_BLACK,
1252       BC_WHITE,
1253   };
1254
1255   BlenderCursor[BC_V_SPLITCURSOR] = &VSplitCursor;
1256
1257   END_CURSOR_BLOCK;
1258
1259   /********************** North Arrow Cursor ***********************/
1260   BEGIN_CURSOR_BLOCK;
1261
1262   static char narrow_sbm[] = {
1263       0x00, 0x00, 0x80, 0x00, 0xC0, 0x01, 0xE0, 0x03, 0xF0, 0x07, 0xF8,
1264       0x0F, 0xFC, 0x1F, 0xE0, 0x03, 0xE0, 0x03, 0xE0, 0x03, 0xE0, 0x03,
1265       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1266   };
1267
1268   static char narrow_smsk[] = {
1269       0x80, 0x00, 0xC0, 0x01, 0xE0, 0x03, 0xF0, 0x07, 0xF8, 0x0F, 0xFC,
1270       0x1F, 0xFE, 0x3F, 0xFF, 0x7F, 0xF0, 0x07, 0xF0, 0x07, 0xF0, 0x07,
1271       0xF0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1272   };
1273
1274   static char narrow_lbm[] = {
1275       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0xC0, 0x01,
1276       0x00, 0x00, 0xE0, 0x03, 0x00, 0x00, 0xF0, 0x07, 0x00, 0x00, 0xF8, 0x0F, 0x00, 0x00, 0xFC,
1277       0x1F, 0x00, 0x00, 0xFE, 0x3F, 0x00, 0x00, 0xFF, 0x7F, 0x00, 0x80, 0xFF, 0xFF, 0x00, 0xC0,
1278       0xFF, 0xFF, 0x01, 0xE0, 0xFF, 0xFF, 0x03, 0xF0, 0xFF, 0xFF, 0x07, 0xF8, 0xFF, 0xFF, 0x0F,
1279       0x00, 0xFC, 0x1F, 0x00, 0x00, 0xFC, 0x1F, 0x00, 0x00, 0xFC, 0x1F, 0x00, 0x00, 0xFC, 0x1F,
1280       0x00, 0x00, 0xFC, 0x1F, 0x00, 0x00, 0xFC, 0x1F, 0x00, 0x00, 0xFC, 0x1F, 0x00, 0x00, 0xFC,
1281       0x1F, 0x00, 0x00, 0xFC, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1282       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1283       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
1284
1285   static char narrow_lmsk[] = {
1286       0x00, 0x80, 0x00, 0x00, 0x00, 0xC0, 0x01, 0x00, 0x00, 0xE0, 0x03, 0x00, 0x00, 0xF0, 0x07,
1287       0x00, 0x00, 0xF8, 0x0F, 0x00, 0x00, 0xFC, 0x1F, 0x00, 0x00, 0xFE, 0x3F, 0x00, 0x00, 0xFF,
1288       0x7F, 0x00, 0x80, 0xFF, 0xFF, 0x00, 0xC0, 0xFF, 0xFF, 0x01, 0xE0, 0xFF, 0xFF, 0x03, 0xF0,
1289       0xFF, 0xFF, 0x07, 0xF8, 0xFF, 0xFF, 0x0F, 0xFC, 0xFF, 0xFF, 0x1F, 0xFE, 0xFF, 0xFF, 0x3F,
1290       0xFF, 0xFF, 0xFF, 0x7F, 0x00, 0xFE, 0x3F, 0x00, 0x00, 0xFE, 0x3F, 0x00, 0x00, 0xFE, 0x3F,
1291       0x00, 0x00, 0xFE, 0x3F, 0x00, 0x00, 0xFE, 0x3F, 0x00, 0x00, 0xFE, 0x3F, 0x00, 0x00, 0xFE,
1292       0x3F, 0x00, 0x00, 0xFE, 0x3F, 0x00, 0x00, 0xFE, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1293       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1294       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
1295
1296   static BCursor NArrowCursor = {
1297       /*small*/
1298       narrow_sbm,
1299       narrow_smsk,
1300       16,
1301       16,
1302       7,
1303       4,
1304       /*big*/
1305       narrow_lbm,
1306       narrow_lmsk,
1307       32,
1308       32,
1309       15,
1310       10,
1311       /*color*/
1312       BC_BLACK,
1313       BC_WHITE,
1314   };
1315
1316   BlenderCursor[BC_N_ARROWCURSOR] = &NArrowCursor;
1317
1318   END_CURSOR_BLOCK;
1319
1320   /********************** South Arrow Cursor ***********************/
1321   BEGIN_CURSOR_BLOCK;
1322
1323   static char sarrow_sbm[] = {
1324       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0,
1325       0x03, 0xE0, 0x03, 0xE0, 0x03, 0xE0, 0x03, 0xFC, 0x1F, 0xF8, 0x0F,
1326       0xF0, 0x07, 0xE0, 0x03, 0xC0, 0x01, 0x80, 0x00, 0x00, 0x00,
1327   };
1328
1329   static char sarrow_smsk[] = {
1330       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x07, 0xF0,
1331       0x07, 0xF0, 0x07, 0xF0, 0x07, 0xFF, 0x7F, 0xFE, 0x3F, 0xFC, 0x1F,
1332       0xF8, 0x0F, 0xF0, 0x07, 0xE0, 0x03, 0xC0, 0x01, 0x80, 0x00,
1333   };
1334
1335   static char sarrow_lbm[] = {
1336       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1337       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1338       0x00, 0x00, 0x00, 0xFC, 0x1F, 0x00, 0x00, 0xFC, 0x1F, 0x00, 0x00, 0xFC, 0x1F, 0x00, 0x00,
1339       0xFC, 0x1F, 0x00, 0x00, 0xFC, 0x1F, 0x00, 0x00, 0xFC, 0x1F, 0x00, 0x00, 0xFC, 0x1F, 0x00,
1340       0x00, 0xFC, 0x1F, 0x00, 0x00, 0xFC, 0x1F, 0x00, 0xF8, 0xFF, 0xFF, 0x0F, 0xF0, 0xFF, 0xFF,
1341       0x07, 0xE0, 0xFF, 0xFF, 0x03, 0xC0, 0xFF, 0xFF, 0x01, 0x80, 0xFF, 0xFF, 0x00, 0x00, 0xFF,
1342       0x7F, 0x00, 0x00, 0xFE, 0x3F, 0x00, 0x00, 0xFC, 0x1F, 0x00, 0x00, 0xF8, 0x0F, 0x00, 0x00,
1343       0xF0, 0x07, 0x00, 0x00, 0xE0, 0x03, 0x00, 0x00, 0xC0, 0x01, 0x00, 0x00, 0x80, 0x00, 0x00,
1344       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
1345
1346   static char sarrow_lmsk[] = {
1347       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1348       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE,
1349       0x3F, 0x00, 0x00, 0xFE, 0x3F, 0x00, 0x00, 0xFE, 0x3F, 0x00, 0x00, 0xFE, 0x3F, 0x00, 0x00,
1350       0xFE, 0x3F, 0x00, 0x00, 0xFE, 0x3F, 0x00, 0x00, 0xFE, 0x3F, 0x00, 0x00, 0xFE, 0x3F, 0x00,
1351       0x00, 0xFE, 0x3F, 0x00, 0xFF, 0xFF, 0xFF, 0x7F, 0xFE, 0xFF, 0xFF, 0x3F, 0xFC, 0xFF, 0xFF,
1352       0x1F, 0xF8, 0xFF, 0xFF, 0x0F, 0xF0, 0xFF, 0xFF, 0x07, 0xE0, 0xFF, 0xFF, 0x03, 0xC0, 0xFF,
1353       0xFF, 0x01, 0x80, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0x7F, 0x00, 0x00, 0xFE, 0x3F, 0x00, 0x00,
1354       0xFC, 0x1F, 0x00, 0x00, 0xF8, 0x0F, 0x00, 0x00, 0xF0, 0x07, 0x00, 0x00, 0xE0, 0x03, 0x00,
1355       0x00, 0xC0, 0x01, 0x00, 0x00, 0x80, 0x00, 0x00};
1356
1357   static BCursor SArrowCursor = {
1358       /*small*/
1359       sarrow_sbm,
1360       sarrow_smsk,
1361       16,
1362       16,
1363       7,
1364       11,
1365       /*big*/
1366       sarrow_lbm,
1367       sarrow_lmsk,
1368       32,
1369       32,
1370       15,
1371       21,
1372       /*color*/
1373       BC_BLACK,
1374       BC_WHITE,
1375   };
1376
1377   BlenderCursor[BC_S_ARROWCURSOR] = &SArrowCursor;
1378
1379   END_CURSOR_BLOCK;
1380
1381   /********************** East Arrow Cursor ***********************/
1382   BEGIN_CURSOR_BLOCK;
1383
1384   static char earrow_sbm[] = {
1385       0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0E, 0xE0,
1386       0x1F, 0xE0, 0x3F, 0xE0, 0x7F, 0xE0, 0x3F, 0xE0, 0x1F, 0x00, 0x0E,
1387       0x00, 0x06, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1388   };
1389
1390   static char earrow_smsk[] = {
1391       0x00, 0x01, 0x00, 0x03, 0x00, 0x07, 0x00, 0x0F, 0xF0, 0x1F, 0xF0,
1392       0x3F, 0xF0, 0x7F, 0xF0, 0xFF, 0xF0, 0x7F, 0xF0, 0x3F, 0xF0, 0x1F,
1393       0x00, 0x0F, 0x00, 0x07, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00,
1394   };
1395
1396   static char earrow_lbm[] = {
1397       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
1398       0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00,
1399       0x3E, 0x00, 0x00, 0x00, 0x7E, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0xFF, 0xFF, 0x01, 0x00,
1400       0xFF, 0xFF, 0x03, 0x00, 0xFF, 0xFF, 0x07, 0x00, 0xFF, 0xFF, 0x0F, 0x00, 0xFF, 0xFF, 0x1F,
1401       0x00, 0xFF, 0xFF, 0x3F, 0x00, 0xFF, 0xFF, 0x1F, 0x00, 0xFF, 0xFF, 0x0F, 0x00, 0xFF, 0xFF,
1402       0x07, 0x00, 0xFF, 0xFF, 0x03, 0x00, 0xFF, 0xFF, 0x01, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00,
1403       0x7E, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00,
1404       0x00, 0x06, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1405       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
1406
1407   static char earrow_lmsk[] = {
1408       0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x0F,
1409       0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x3F, 0x00, 0x00, 0x00, 0x7F, 0x00, 0x00, 0x00,
1410       0xFF, 0x00, 0x00, 0x00, 0xFF, 0x01, 0x80, 0xFF, 0xFF, 0x03, 0x80, 0xFF, 0xFF, 0x07, 0x80,
1411       0xFF, 0xFF, 0x0F, 0x80, 0xFF, 0xFF, 0x1F, 0x80, 0xFF, 0xFF, 0x3F, 0x80, 0xFF, 0xFF, 0x7F,
1412       0x80, 0xFF, 0xFF, 0xFF, 0x80, 0xFF, 0xFF, 0x7F, 0x80, 0xFF, 0xFF, 0x3F, 0x80, 0xFF, 0xFF,
1413       0x1F, 0x80, 0xFF, 0xFF, 0x0F, 0x80, 0xFF, 0xFF, 0x07, 0x80, 0xFF, 0xFF, 0x03, 0x00, 0x00,
1414       0xFF, 0x01, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x7F, 0x00, 0x00, 0x00, 0x3F, 0x00, 0x00,
1415       0x00, 0x1F, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x03, 0x00,
1416       0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00};
1417
1418   static BCursor EArrowCursor = {
1419       /*small*/
1420       earrow_sbm,
1421       earrow_smsk,
1422       16,
1423       16,
1424       11,
1425       7,
1426       /*big*/
1427       earrow_lbm,
1428       earrow_lmsk,
1429       32,
1430       32,
1431       15,
1432       22,
1433       /*color*/
1434       BC_BLACK,
1435       BC_WHITE,
1436   };
1437
1438   BlenderCursor[BC_E_ARROWCURSOR] = &EArrowCursor;
1439
1440   END_CURSOR_BLOCK;
1441
1442   /********************** West Arrow Cursor ***********************/
1443   BEGIN_CURSOR_BLOCK;
1444
1445   static char warrow_sbm[] = {
1446       0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x60, 0x00, 0x70, 0x00, 0xF8,
1447       0x07, 0xFC, 0x07, 0xFE, 0x07, 0xFC, 0x07, 0xF8, 0x07, 0x70, 0x00,
1448       0x60, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1449   };
1450
1451   static char warrow_smsk[] = {
1452       0x80, 0x00, 0xC0, 0x00, 0xE0, 0x00, 0xF0, 0x00, 0xF8, 0x0F, 0xFC,
1453       0x0F, 0xFE, 0x0F, 0xFF, 0x0F, 0xFE, 0x0F, 0xFC, 0x0F, 0xF8, 0x0F,
1454       0xF0, 0x00, 0xE0, 0x00, 0xC0, 0x00, 0x80, 0x00, 0x00, 0x00,
1455   };
1456
1457   static char warrow_lbm[] = {
1458       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00,
1459       0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x7C,
1460       0x00, 0x00, 0x00, 0x7E, 0x00, 0x00, 0x00, 0x7F, 0x00, 0x00, 0x80, 0xFF, 0xFF, 0x00, 0xC0,
1461       0xFF, 0xFF, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0xF0, 0xFF, 0xFF, 0x00, 0xF8, 0xFF, 0xFF, 0x00,
1462       0xFC, 0xFF, 0xFF, 0x00, 0xF8, 0xFF, 0xFF, 0x00, 0xF0, 0xFF, 0xFF, 0x00, 0xE0, 0xFF, 0xFF,
1463       0x00, 0xC0, 0xFF, 0xFF, 0x00, 0x80, 0xFF, 0xFF, 0x00, 0x00, 0x7F, 0x00, 0x00, 0x00, 0x7E,
1464       0x00, 0x00, 0x00, 0x7C, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00,
1465       0x60, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1466       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
1467
1468   static char warrow_lmsk[] = {
1469       0x00, 0x80, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0xF0, 0x00,
1470       0x00, 0x00, 0xF8, 0x00, 0x00, 0x00, 0xFC, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0xFF,
1471       0x00, 0x00, 0x80, 0xFF, 0x00, 0x00, 0xC0, 0xFF, 0xFF, 0x01, 0xE0, 0xFF, 0xFF, 0x01, 0xF0,
1472       0xFF, 0xFF, 0x01, 0xF8, 0xFF, 0xFF, 0x01, 0xFC, 0xFF, 0xFF, 0x01, 0xFE, 0xFF, 0xFF, 0x01,
1473       0xFF, 0xFF, 0xFF, 0x01, 0xFE, 0xFF, 0xFF, 0x01, 0xFC, 0xFF, 0xFF, 0x01, 0xF8, 0xFF, 0xFF,
1474       0x01, 0xF0, 0xFF, 0xFF, 0x01, 0xE0, 0xFF, 0xFF, 0x01, 0xC0, 0xFF, 0xFF, 0x01, 0x80, 0xFF,
1475       0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0xFC, 0x00, 0x00, 0x00,
1476       0xF8, 0x00, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00,
1477       0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
1478
1479   static BCursor WArrowCursor = {
1480       /*small*/
1481       warrow_sbm,
1482       warrow_smsk,
1483       16,
1484       16,
1485       4,
1486       7,
1487       /*big*/
1488       warrow_lbm,
1489       warrow_lmsk,
1490       32,
1491       32,
1492       15,
1493       15,
1494       /*color*/
1495       BC_BLACK,
1496       BC_WHITE,
1497   };
1498
1499   BlenderCursor[BC_W_ARROWCURSOR] = &WArrowCursor;
1500
1501   END_CURSOR_BLOCK;
1502
1503   /********************** Stop Sign Cursor ***********************/
1504   BEGIN_CURSOR_BLOCK;
1505
1506   static char stop_sbm[] = {
1507       0x00, 0x00, 0xE0, 0x07, 0x38, 0x1C, 0x1C, 0x30, 0x3C, 0x20, 0x76,
1508       0x60, 0xE2, 0x40, 0xC2, 0x41, 0x82, 0x43, 0x02, 0x47, 0x06, 0x6E,
1509       0x04, 0x3C, 0x0C, 0x38, 0x38, 0x1C, 0xE0, 0x07, 0x00, 0x00,
1510   };
1511
1512   static char stop_smsk[] = {
1513       0xE0, 0x07, 0xF8, 0x1F, 0xFC, 0x3F, 0x3E, 0x7C, 0x7E, 0x70, 0xFF,
1514       0xF0, 0xF7, 0xE1, 0xE7, 0xE3, 0xC7, 0xE7, 0x87, 0xEF, 0x0F, 0xFF,
1515       0x0E, 0x7E, 0x3E, 0x7C, 0xFC, 0x3F, 0xF8, 0x1F, 0xE0, 0x07,
1516   };
1517
1518   static char stop_lbm[] = {
1519       0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x0F, 0x00, 0x00, 0xFE, 0x7F, 0x00, 0x00, 0x0F, 0xF0,
1520       0x00, 0xC0, 0x03, 0xC0, 0x03, 0xE0, 0x01, 0x00, 0x07, 0xF0, 0x01, 0x00, 0x0E, 0xF0, 0x01,
1521       0x00, 0x0C, 0xF8, 0x03, 0x00, 0x18, 0x1C, 0x07, 0x00, 0x38, 0x0C, 0x0E, 0x00, 0x30, 0x0C,
1522       0x1C, 0x00, 0x30, 0x06, 0x38, 0x00, 0x60, 0x06, 0x70, 0x00, 0x60, 0x06, 0xE0, 0x00, 0x60,
1523       0x06, 0xC0, 0x01, 0x60, 0x06, 0x80, 0x03, 0x60, 0x06, 0x00, 0x07, 0x60, 0x06, 0x00, 0x0E,
1524       0x60, 0x06, 0x00, 0x1C, 0x60, 0x0C, 0x00, 0x38, 0x30, 0x0C, 0x00, 0x70, 0x30, 0x1C, 0x00,
1525       0xE0, 0x38, 0x18, 0x00, 0xC0, 0x1F, 0x30, 0x00, 0x80, 0x0F, 0x70, 0x00, 0x80, 0x0F, 0xE0,
1526       0x00, 0x80, 0x07, 0xC0, 0x03, 0xC0, 0x03, 0x00, 0x0F, 0xF0, 0x00, 0x00, 0xFE, 0x7F, 0x00,
1527       0x00, 0xF0, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00};
1528
1529   static char stop_lmsk[] = {
1530       0x00, 0xF0, 0x0F, 0x00, 0x00, 0xFE, 0x7F, 0x00, 0x80, 0xFF, 0xFF, 0x01, 0xC0, 0xFF, 0xFF,
1531       0x03, 0xE0, 0x1F, 0xF8, 0x07, 0xF0, 0x03, 0xC0, 0x0F, 0xF8, 0x03, 0x80, 0x1F, 0xFC, 0x07,
1532       0x00, 0x3F, 0xFC, 0x0F, 0x00, 0x3E, 0xFE, 0x1F, 0x00, 0x7C, 0x9E, 0x3F, 0x00, 0x78, 0x1E,
1533       0x7F, 0x00, 0x78, 0x1F, 0xFE, 0x00, 0xF8, 0x0F, 0xFC, 0x01, 0xF0, 0x0F, 0xF8, 0x03, 0xF0,
1534       0x0F, 0xF0, 0x07, 0xF0, 0x0F, 0xE0, 0x0F, 0xF0, 0x0F, 0xC0, 0x1F, 0xF0, 0x0F, 0x80, 0x3F,
1535       0xF0, 0x1F, 0x00, 0x7F, 0xF8, 0x1E, 0x00, 0xFE, 0x78, 0x1E, 0x00, 0xFC, 0x79, 0x3E, 0x00,
1536       0xF8, 0x7F, 0x7C, 0x00, 0xF0, 0x3F, 0xFC, 0x00, 0xE0, 0x3F, 0xF8, 0x01, 0xC0, 0x1F, 0xF0,
1537       0x03, 0xC0, 0x0F, 0xE0, 0x1F, 0xF8, 0x07, 0xC0, 0xFF, 0xFF, 0x03, 0x80, 0xFF, 0xFF, 0x01,
1538       0x00, 0xFE, 0x7F, 0x00, 0x00, 0xF0, 0x0F, 0x00};
1539
1540   static BCursor StopCursor = {
1541       /*small*/
1542       stop_sbm,
1543       stop_smsk,
1544       16,
1545       16,
1546       7,
1547       7,
1548       /*big*/
1549       stop_lbm,
1550       stop_lmsk,
1551       32,
1552       32,
1553       15,
1554       15,
1555       /*color*/
1556       BC_BLACK,
1557       BC_WHITE,
1558   };
1559
1560   BlenderCursor[BC_STOPCURSOR] = &StopCursor;
1561
1562   END_CURSOR_BLOCK;
1563
1564   /********************** Put the cursors in the array ***********************/
1565 }