45f56968a321c94453d8aabddeb9faf2b40b1e95
[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 #define END_CURSOR_BLOCK }
391
392 void wm_init_cursor_data(void)
393 {
394   /********************** NW_ARROW Cursor **************************/
395   BEGIN_CURSOR_BLOCK
396   static char nw_sbm[] = {
397       0x03, 0x00, 0x05, 0x00, 0x09, 0x00, 0x11, 0x00, 0x21, 0x00, 0x41,
398       0x00, 0x81, 0x00, 0x01, 0x01, 0x01, 0x02, 0xc1, 0x03, 0x49, 0x00,
399       0x8d, 0x00, 0x8b, 0x00, 0x10, 0x01, 0x90, 0x01, 0x60, 0x00,
400   };
401
402   static char nw_smsk[] = {
403       0x03, 0x00, 0x07, 0x00, 0x0f, 0x00, 0x1f, 0x00, 0x3f, 0x00, 0x7f,
404       0x00, 0xff, 0x00, 0xff, 0x01, 0xff, 0x03, 0xff, 0x03, 0x7f, 0x00,
405       0xff, 0x00, 0xfb, 0x00, 0xf0, 0x01, 0xf0, 0x01, 0x60, 0x00,
406   };
407
408   static BCursor NWArrowCursor = {
409       /*small*/
410       nw_sbm,
411       nw_smsk,
412       16,
413       16,
414       6,
415       7,
416       /*big*/
417       NULL,
418       NULL,
419       32,
420       32,
421       15,
422       15,
423       /*color*/
424       BC_BLACK,
425       BC_WHITE,
426   };
427
428   BlenderCursor[BC_NW_ARROWCURSOR] = &NWArrowCursor;
429   END_CURSOR_BLOCK
430
431   ///********************** NS_ARROW Cursor *************************/
432   BEGIN_CURSOR_BLOCK
433   static char ns_sbm[] = {
434       0x40, 0x01, 0x20, 0x02, 0x10, 0x04, 0x08, 0x08, 0x04, 0x10, 0x3c,
435       0x1e, 0x20, 0x02, 0x20, 0x02, 0x20, 0x02, 0x20, 0x02, 0x3c, 0x1e,
436       0x04, 0x10, 0x08, 0x08, 0x10, 0x04, 0x20, 0x02, 0x40, 0x01,
437   };
438
439   static char ns_smsk[] = {
440       0xc0, 0x01, 0xe0, 0x03, 0xf0, 0x07, 0xf8, 0x0f, 0xfc, 0x1f, 0xfc,
441       0x1f, 0xe0, 0x03, 0xe0, 0x03, 0xe0, 0x03, 0xe0, 0x03, 0xfc, 0x1f,
442       0xfc, 0x1f, 0xf8, 0x0f, 0xf0, 0x07, 0xe0, 0x03, 0xc0, 0x01,
443   };
444
445   static BCursor NSArrowCursor = {
446       /*small*/
447       ns_sbm,
448       ns_smsk,
449       16,
450       16,
451       6,
452       7,
453       /*big*/
454       NULL,
455       NULL,
456       32,
457       32,
458       15,
459       15,
460       /*color*/
461       BC_BLACK,
462       BC_WHITE,
463   };
464
465   BlenderCursor[BC_NS_ARROWCURSOR] = &NSArrowCursor;
466
467   END_CURSOR_BLOCK
468   /********************** EW_ARROW Cursor *************************/
469   BEGIN_CURSOR_BLOCK
470   static char ew_sbm[] = {
471       0x00, 0x00, 0x00, 0x00, 0x10, 0x08, 0x38, 0x1c, 0x2c, 0x34, 0xe6,
472       0x67, 0x03, 0xc0, 0x01, 0x80, 0x03, 0xc0, 0xe6, 0x67, 0x2c, 0x34,
473       0x38, 0x1c, 0x10, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
474   };
475
476   static char ew_smsk[] = {
477       0x00, 0x00, 0x00, 0x00, 0x10, 0x08, 0x38, 0x1c, 0x3c, 0x3c, 0xfe,
478       0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x7f, 0x3c, 0x3c,
479       0x38, 0x1c, 0x10, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
480   };
481
482   static BCursor EWArrowCursor = {
483       /*small*/
484       ew_sbm,
485       ew_smsk,
486       16,
487       16,
488       7,
489       6,
490       /*big*/
491       NULL,
492       NULL,
493       32,
494       32,
495       15,
496       15,
497       /*color*/
498       BC_BLACK,
499       BC_WHITE,
500   };
501
502   BlenderCursor[BC_EW_ARROWCURSOR] = &EWArrowCursor;
503   END_CURSOR_BLOCK
504
505   /********************** Wait Cursor *****************************/
506   BEGIN_CURSOR_BLOCK
507   static char wait_sbm[] = {
508       0xfe, 0x7f, 0x02, 0x40, 0x02, 0x40, 0x84, 0x21, 0xc8, 0x13, 0xd0,
509       0x0b, 0xa0, 0x04, 0x20, 0x05, 0xa0, 0x04, 0x10, 0x09, 0x88, 0x11,
510       0xc4, 0x23, 0xe2, 0x47, 0xfa, 0x5f, 0x02, 0x40, 0xfe, 0x7f,
511   };
512
513   static char wait_smsk[] = {
514       0xfe, 0x7f, 0xfe, 0x7f, 0x06, 0x60, 0x8c, 0x31, 0xd8, 0x1b, 0xf0,
515       0x0f, 0xe0, 0x06, 0x60, 0x07, 0xe0, 0x06, 0x30, 0x0d, 0x98, 0x19,
516       0xcc, 0x33, 0xe6, 0x67, 0xfe, 0x7f, 0xfe, 0x7f, 0xfe, 0x7f,
517   };
518
519   static char wait_lbm[] = {
520       0xfc, 0xff, 0xff, 0x3f, 0xfc, 0xff, 0xff, 0x3f, 0x0c, 0x00, 0x00, 0x30, 0x0c, 0x00, 0x00,
521       0x30, 0x0c, 0x00, 0x00, 0x30, 0x0c, 0x00, 0x00, 0x18, 0x18, 0xc0, 0x03, 0x0c, 0x30, 0x20,
522       0x07, 0x06, 0x60, 0xf0, 0x0f, 0x03, 0xc0, 0xd0, 0x8d, 0x01, 0x80, 0x79, 0xcf, 0x00, 0x00,
523       0xf3, 0x67, 0x00, 0x00, 0x66, 0x37, 0x00, 0x00, 0x8c, 0x33, 0x00, 0x00, 0x0c, 0x32, 0x00,
524       0x00, 0xcc, 0x33, 0x00, 0x00, 0x8c, 0x30, 0x00, 0x00, 0x46, 0x61, 0x00, 0x00, 0x03, 0xc3,
525       0x00, 0x80, 0x01, 0x83, 0x01, 0xc0, 0xc0, 0x03, 0x03, 0x60, 0xa0, 0x05, 0x06, 0x30, 0xf0,
526       0x0f, 0x0c, 0x18, 0xf8, 0x1d, 0x18, 0x0c, 0x5c, 0x3f, 0x30, 0x0c, 0xff, 0x5f, 0x30, 0x0c,
527       0xf7, 0xfe, 0x31, 0xcc, 0xfb, 0x9f, 0x33, 0x0c, 0x00, 0x00, 0x30, 0x0c, 0x00, 0x00, 0x30,
528       0xfc, 0xff, 0xff, 0x3f, 0xfc, 0xff, 0xff, 0x3f,
529   };
530
531   static char wait_lmsk[] = {
532       0xfc, 0xff, 0xff, 0x3f, 0xfc, 0xff, 0xff, 0x3f, 0xfc, 0xff, 0xff, 0x3f, 0xfc, 0xff, 0xff,
533       0x3f, 0x3c, 0x00, 0x00, 0x3c, 0x3c, 0x00, 0x00, 0x1e, 0x78, 0xc0, 0x03, 0x0f, 0xf0, 0xa0,
534       0x87, 0x07, 0xe0, 0xf1, 0xcf, 0x03, 0xc0, 0xf3, 0xef, 0x01, 0x80, 0xff, 0xff, 0x00, 0x00,
535       0xff, 0x7f, 0x00, 0x00, 0xfe, 0x3f, 0x00, 0x00, 0xfc, 0x3f, 0x00, 0x00, 0x3c, 0x3f, 0x00,
536       0x00, 0xfc, 0x3f, 0x00, 0x00, 0xbc, 0x3c, 0x00, 0x00, 0xde, 0x79, 0x00, 0x00, 0x0f, 0xf3,
537       0x00, 0x80, 0x07, 0xe3, 0x01, 0xc0, 0xc3, 0xc3, 0x03, 0xe0, 0xe1, 0x87, 0x07, 0xf0, 0xf0,
538       0x0f, 0x0f, 0x78, 0xf8, 0x1f, 0x1e, 0x3c, 0x7c, 0x3f, 0x3c, 0x3c, 0xff, 0x7f, 0x3c, 0xbc,
539       0xff, 0xff, 0x3d, 0xfc, 0xfb, 0xbf, 0x3f, 0xfc, 0xff, 0xff, 0x3f, 0xfc, 0xff, 0xff, 0x3f,
540       0xfc, 0xff, 0xff, 0x3f, 0xfc, 0xff, 0xff, 0x3f,
541   };
542
543   static BCursor WaitCursor = {
544       /*small*/
545       wait_sbm,
546       wait_smsk,
547       16,
548       16,
549       7,
550       7,
551       /*big*/
552       wait_lbm,
553       wait_lmsk,
554       32,
555       32,
556       15,
557       15,
558       /*color*/
559       BC_BLACK,
560       BC_WHITE,
561   };
562
563   BlenderCursor[BC_WAITCURSOR] = &WaitCursor;
564   END_CURSOR_BLOCK
565
566   /********************** Cross Cursor ***************************/
567   BEGIN_CURSOR_BLOCK
568   static char cross_sbm[] = {
569       0x00, 0x00, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80,
570       0x01, 0x80, 0x01, 0x7e, 0x7e, 0x7e, 0x7e, 0x80, 0x01, 0x80, 0x01,
571       0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x00, 0x00,
572   };
573
574   static char cross_smsk[] = {
575       0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80,
576       0x01, 0xc0, 0x03, 0x7f, 0xfe, 0x7f, 0xfe, 0xc0, 0x03, 0x80, 0x01,
577       0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01,
578   };
579   static char cross_lbm[] = {
580       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01,
581       0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80,
582       0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00,
583       0xc0, 0x03, 0x00, 0x00, 0xc0, 0x03, 0x00, 0x00, 0x40, 0x02, 0x00, 0x00, 0x78, 0x1e, 0x00,
584       0xfc, 0x1f, 0xf8, 0x3f, 0xfc, 0x1f, 0xf8, 0x3f, 0x00, 0x78, 0x1e, 0x00, 0x00, 0x40, 0x02,
585       0x00, 0x00, 0xc0, 0x03, 0x00, 0x00, 0xc0, 0x03, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80,
586       0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00,
587       0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00,
588       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
589   };
590
591   static char cross_lmsk[] = {
592       0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01,
593       0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80,
594       0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00,
595       0xc0, 0x03, 0x00, 0x00, 0xe0, 0x07, 0x00, 0x00, 0x70, 0x0e, 0x00, 0x00, 0x78, 0x1e, 0x00,
596       0xff, 0x1f, 0xf8, 0xff, 0xff, 0x1f, 0xf8, 0xff, 0x00, 0x78, 0x1e, 0x00, 0x00, 0x70, 0x0e,
597       0x00, 0x00, 0xe0, 0x07, 0x00, 0x00, 0xc0, 0x03, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80,
598       0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00,
599       0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00,
600       0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00,
601   };
602
603   static BCursor CrossCursor = {
604       /*small*/
605       cross_sbm,
606       cross_smsk,
607       16,
608       16,
609       7,
610       7,
611       /*big*/
612       cross_lbm,
613       cross_lmsk,
614       32,
615       32,
616       15,
617       15,
618       /*color*/
619       BC_BLACK,
620       BC_WHITE,
621   };
622
623   BlenderCursor[BC_CROSSCURSOR] = &CrossCursor;
624   END_CURSOR_BLOCK
625
626   /********************** EditCross Cursor ***********************/
627   BEGIN_CURSOR_BLOCK
628   static char editcross_sbm[] = {
629       0x0e, 0x00, 0x11, 0x00, 0x1d, 0x00, 0x19, 0x03, 0x1d, 0x03, 0x11,
630       0x03, 0x0e, 0x03, 0x00, 0x03, 0xf8, 0x7c, 0xf8, 0x7c, 0x00, 0x03,
631       0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x00,
632   };
633
634   static char editcross_smsk[] = {
635       0x0e, 0x00, 0x1f, 0x00, 0x1f, 0x03, 0x1f, 0x03, 0x1f, 0x03, 0x1f,
636       0x03, 0x0e, 0x03, 0x80, 0x07, 0xfc, 0xfc, 0xfc, 0xfc, 0x80, 0x07,
637       0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03,
638   };
639
640   static BCursor EditCrossCursor = {
641       /*small*/
642       editcross_sbm,
643       editcross_smsk,
644       16,
645       16,
646       9,
647       8,
648       /*big*/
649       NULL,
650       NULL,
651       32,
652       32,
653       15,
654       15,
655       /*color*/
656       BC_BLACK,
657       BC_WHITE,
658   };
659
660   BlenderCursor[BC_EDITCROSSCURSOR] = &EditCrossCursor;
661   END_CURSOR_BLOCK
662
663   /********************** Box Select *************************/
664   BEGIN_CURSOR_BLOCK
665   static char box_sbm[32] = {
666       0x7f, 0x00, 0x41, 0x00, 0x41, 0x00, 0x41, 0x06, 0x41, 0x06, 0x41,
667       0x06, 0x7f, 0x06, 0x00, 0x06, 0xe0, 0x79, 0xe0, 0x79, 0x00, 0x06,
668       0x00, 0x06, 0x00, 0x06, 0x00, 0x06, 0x00, 0x06, 0x00, 0x00,
669   };
670
671   static char box_smsk[32] = {
672       0x7f, 0x00, 0x7f, 0x00, 0x63, 0x06, 0x63, 0x06, 0x63, 0x06, 0x7f,
673       0x06, 0x7f, 0x06, 0x00, 0x0f, 0xf0, 0xf9, 0xf0, 0xf9, 0x00, 0x0f,
674       0x00, 0x06, 0x00, 0x06, 0x00, 0x06, 0x00, 0x06, 0x00, 0x06,
675   };
676
677   static BCursor BoxSelCursor = {
678       /*small*/
679       box_sbm,
680       box_smsk,
681       16,
682       16,
683       9,
684       8,
685       /*big*/
686       NULL,
687       NULL,
688       32,
689       32,
690       15,
691       15,
692       /*color*/
693       BC_BLACK,
694       BC_WHITE,
695   };
696
697   BlenderCursor[BC_BOXSELCURSOR] = &BoxSelCursor;
698
699   END_CURSOR_BLOCK
700   /********************** Knife Cursor ***********************/
701   BEGIN_CURSOR_BLOCK
702   static char knife_sbm[] = {
703       0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x2c, 0x00, 0x5a, 0x00,
704       0x34, 0x00, 0x2a, 0x00, 0x17, 0x80, 0x06, 0x40, 0x03, 0xa0, 0x03,
705       0xd0, 0x01, 0x68, 0x00, 0x1c, 0x00, 0x06, 0x00, 0x00, 0x00,
706   };
707
708   static char knife_smsk[] = {
709       0x00, 0x60, 0x00, 0xf0, 0x00, 0xfc, 0x00, 0xfe, 0x00, 0xfe, 0x00,
710       0x7e, 0x00, 0x7f, 0x80, 0x3f, 0xc0, 0x0e, 0x60, 0x07, 0xb0, 0x07,
711       0xd8, 0x03, 0xec, 0x01, 0x7e, 0x00, 0x1f, 0x00, 0x07, 0x00,
712   };
713
714   static char knife_lbm[] = {
715       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
716       0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00,
717       0x00, 0x7f, 0x00, 0x00, 0x80, 0xbf, 0x00, 0x00, 0xc0, 0x5f, 0x00, 0x00, 0xc0, 0x6f, 0x00,
718       0x00, 0xc0, 0x37, 0x00, 0x00, 0xa8, 0x1b, 0x00, 0x00, 0x54, 0x0d, 0x00, 0x00, 0xa8, 0x00,
719       0x00, 0x00, 0x54, 0x00, 0x00, 0x00, 0xa8, 0x00, 0x00, 0x00, 0x53, 0x00, 0x00, 0xc0, 0x07,
720       0x00, 0x00, 0xe0, 0x0f, 0x00, 0x00, 0xd0, 0x0f, 0x00, 0x00, 0xe8, 0x07, 0x00, 0x00, 0xf4,
721       0x07, 0x00, 0x00, 0xfa, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x00, 0x80, 0x0e, 0x00, 0x00, 0xc0,
722       0x03, 0x00, 0x00, 0xe0, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
723       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
724   };
725
726   static char knife_lmsk[] = {
727       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
728       0x18, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00, 0x7e, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00,
729       0x80, 0xff, 0x00, 0x00, 0xc0, 0xbf, 0x00, 0x00, 0xe0, 0xdf, 0x00, 0x00, 0xe0, 0xef, 0x00,
730       0x00, 0xf8, 0x77, 0x00, 0x00, 0xfc, 0x3b, 0x00, 0x00, 0xfe, 0x1d, 0x00, 0x00, 0xfe, 0x0f,
731       0x00, 0x00, 0xfe, 0x01, 0x00, 0x00, 0xff, 0x01, 0x00, 0xc0, 0xff, 0x00, 0x00, 0xe0, 0x7f,
732       0x00, 0x00, 0xf0, 0x1f, 0x00, 0x00, 0xd8, 0x1f, 0x00, 0x00, 0xec, 0x0f, 0x00, 0x00, 0xf6,
733       0x0f, 0x00, 0x00, 0xfb, 0x06, 0x00, 0x80, 0xbd, 0x01, 0x00, 0xc0, 0x6e, 0x00, 0x00, 0xe0,
734       0x1b, 0x00, 0x00, 0xf0, 0x06, 0x00, 0x00, 0xb8, 0x01, 0x00, 0x00, 0x6c, 0x00, 0x00, 0x00,
735       0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
736   };
737
738   static BCursor KnifeCursor = {
739       /*small*/
740       knife_sbm,
741       knife_smsk,
742       16,
743       16,
744       0,
745       15,
746       /*big*/
747       knife_lbm,
748       knife_lmsk,
749       32,
750       32,
751       0,
752       31,
753       /*color*/
754       BC_BLACK,
755       BC_WHITE,
756   };
757
758   BlenderCursor[BC_KNIFECURSOR] = &KnifeCursor;
759
760   END_CURSOR_BLOCK
761
762   /********************** Loop Select Cursor ***********************/
763   BEGIN_CURSOR_BLOCK
764
765   static char vloop_sbm[] = {
766       0x00, 0x00, 0x7e, 0x00, 0x3e, 0x00, 0x1e, 0x00, 0x0e, 0x00, 0x66,
767       0x60, 0x62, 0x6f, 0x00, 0x00, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
768       0x20, 0x20, 0x00, 0x00, 0x60, 0x60, 0x60, 0x6f, 0x00, 0x00,
769   };
770
771   static char vloop_smsk[] = {
772       0xff, 0x01, 0xff, 0x00, 0x7f, 0x00, 0x3f, 0x00, 0xff, 0xf0, 0xff,
773       0xff, 0xf7, 0xff, 0xf3, 0xf0, 0x61, 0x60, 0x60, 0x60, 0x60, 0x60,
774       0x60, 0x60, 0xf0, 0xf0, 0xf0, 0xff, 0xf0, 0xff, 0xf0, 0xf0,
775   };
776
777   static char vloop_lbm[] = {
778       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x3f, 0x00, 0x00, 0xfc, 0x3f, 0x00,
779       0x00, 0xfc, 0x0f, 0x00, 0x00, 0xfc, 0x0f, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0xfc, 0x03,
780       0x00, 0x00, 0xfc, 0x00, 0x00, 0x00, 0xfc, 0x00, 0x00, 0x00, 0x3c, 0x3c, 0x00, 0x3c, 0x3c,
781       0x3c, 0x00, 0x3c, 0x0c, 0x3c, 0xff, 0x3c, 0x0c, 0x3c, 0xff, 0x3c, 0x00, 0x00, 0x00, 0x00,
782       0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x0c, 0x00, 0x0c, 0x00, 0x0c, 0x00, 0x0c, 0x00,
783       0x0c, 0x00, 0x0c, 0x00, 0x0c, 0x00, 0x0c, 0x00, 0x0c, 0x00, 0x0c, 0x00, 0x0c, 0x00, 0x0c,
784       0x00, 0x0c, 0x00, 0x0c, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
785       0x3c, 0x00, 0x3c, 0x00, 0x3c, 0x00, 0x3c, 0x00, 0x3c, 0xff, 0x3c, 0x00, 0x3c, 0xff, 0x3c,
786       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
787   };
788
789   static char vloop_lmsk[] = {
790       0xff, 0xff, 0x03, 0x00, 0xff, 0xff, 0x03, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00,
791       0x00, 0xff, 0x3f, 0x00, 0x00, 0xff, 0x3f, 0x00, 0x00, 0xff, 0x0f, 0x00, 0x00, 0xff, 0x0f,
792       0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
793       0xff, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xff, 0x0f, 0xff, 0x00, 0xff,
794       0x0f, 0xff, 0x00, 0xff, 0x03, 0x3c, 0x00, 0x3c, 0x03, 0x3c, 0x00, 0x3c, 0x00, 0x3c, 0x00,
795       0x3c, 0x00, 0x3c, 0x00, 0x3c, 0x00, 0x3c, 0x00, 0x3c, 0x00, 0x3c, 0x00, 0x3c, 0x00, 0x3c,
796       0x00, 0x3c, 0x00, 0x3c, 0x00, 0x3c, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00,
797       0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff,
798       0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff,
799   };
800
801   static BCursor VLoopCursor = {
802       /*small*/
803       vloop_sbm,
804       vloop_smsk,
805       16,
806       16,
807       0,
808       0,
809       /*big*/
810       vloop_lbm,
811       vloop_lmsk,
812       32,
813       32,
814       0,
815       0,
816       /*color*/
817       BC_BLACK,
818       BC_WHITE,
819   };
820
821   BlenderCursor[BC_VLOOPCURSOR] = &VLoopCursor;
822
823   END_CURSOR_BLOCK
824
825   /********************** TextEdit Cursor ***********************/
826   BEGIN_CURSOR_BLOCK
827   static char textedit_sbm[] = {
828       0xe0, 0x03, 0x10, 0x04, 0x60, 0x03, 0x40, 0x01, 0x40, 0x01, 0x40,
829       0x01, 0x40, 0x01, 0x40, 0x01, 0x40, 0x01, 0x40, 0x01, 0x40, 0x01,
830       0x40, 0x01, 0x40, 0x01, 0x60, 0x03, 0x10, 0x04, 0xe0, 0x03,
831   };
832
833   static char textedit_smsk[] = {
834       0xe0, 0x03, 0xf0, 0x07, 0xe0, 0x03, 0xc0, 0x01, 0xc0, 0x01, 0xc0,
835       0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01,
836       0xc0, 0x01, 0xc0, 0x01, 0xe0, 0x03, 0xf0, 0x07, 0xe0, 0x03,
837   };
838
839   static BCursor TextEditCursor = {
840       /*small*/
841       textedit_sbm,
842       textedit_smsk,
843       16,
844       16,
845       9,
846       8,
847       /*big*/
848       NULL,
849       NULL,
850       32,
851       32,
852       15,
853       15,
854       /*color*/
855       BC_BLACK,
856       BC_WHITE,
857   };
858
859   BlenderCursor[BC_TEXTEDITCURSOR] = &TextEditCursor;
860   END_CURSOR_BLOCK
861
862   /********************** Paintbrush Cursor ***********************/
863   BEGIN_CURSOR_BLOCK
864   static char paintbrush_sbm[] = {
865
866       0x00, 0xe0, 0x00, 0x98, 0x00, 0x44, 0x00, 0x42, 0x00, 0x21, 0x80,
867       0x20, 0x40, 0x13, 0x40, 0x17, 0xa0, 0x0b, 0x98, 0x05, 0x04, 0x02,
868       0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x81, 0x00, 0x7f, 0x00,
869   };
870
871   static char paintbrush_smsk[] = {
872       0x00, 0xe0, 0x00, 0xf8, 0x00, 0x7c, 0x00, 0x7e, 0x00, 0x3f, 0x80,
873       0x3f, 0xc0, 0x1f, 0xc0, 0x1f, 0xe0, 0x0f, 0xf8, 0x07, 0xfc, 0x03,
874       0xfe, 0x01, 0xfe, 0x01, 0xfe, 0x01, 0xff, 0x00, 0x7f, 0x00,
875   };
876
877   static BCursor PaintBrushCursor = {
878       /*small*/
879       paintbrush_sbm,
880       paintbrush_smsk,
881       16,
882       16,
883       0,
884       15,
885       /*big*/
886       NULL,
887       NULL,
888       32,
889       32,
890       15,
891       15,
892       /*color*/
893       BC_BLACK,
894       BC_WHITE,
895   };
896
897   BlenderCursor[BC_PAINTBRUSHCURSOR] = &PaintBrushCursor;
898   END_CURSOR_BLOCK
899
900   /********************** Hand Cursor ***********************/
901   BEGIN_CURSOR_BLOCK
902
903   static char hand_sbm[] = {
904       0x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0x80, 0x0d, 0x98, 0x6d, 0x98,
905       0x6d, 0xb0, 0x6d, 0xb0, 0x6d, 0xe0, 0x6f, 0xe6, 0x7f, 0xee, 0x7f,
906       0xfc, 0x3f, 0xf8, 0x3f, 0xf0, 0x1f, 0xc0, 0x1f, 0xc0, 0x1f,
907   };
908
909   static char hand_smsk[] = {
910       0x00, 0x00, 0x80, 0x01, 0xc0, 0x0f, 0xd8, 0x7f, 0xfc, 0xff, 0xfc,
911       0xff, 0xf8, 0xff, 0xf8, 0xff, 0xf6, 0xff, 0xff, 0xff, 0xff, 0xff,
912       0xfe, 0x7f, 0xfc, 0x7f, 0xf8, 0x3f, 0xf0, 0x3f, 0xe0, 0x3f,
913   };
914
915   static BCursor HandCursor = {
916       /*small*/
917       hand_sbm,
918       hand_smsk,
919       16,
920       16,
921       8,
922       8,
923       /*big*/
924       NULL,
925       NULL,
926       32,
927       32,
928       15,
929       15,
930       /*color*/
931       BC_BLACK,
932       BC_WHITE,
933   };
934
935   BlenderCursor[BC_HANDCURSOR] = &HandCursor;
936
937   END_CURSOR_BLOCK
938
939   /********************** NSEW Scroll Cursor ***********************/
940   BEGIN_CURSOR_BLOCK
941
942   static char nsewscroll_sbm[] = {
943       0x00, 0x00, 0x80, 0x01, 0xc0, 0x03, 0xc0, 0x03, 0x00, 0x00, 0x00,
944       0x00, 0x0c, 0x30, 0x0e, 0x70, 0x0e, 0x70, 0x0c, 0x30, 0x00, 0x00,
945       0x00, 0x00, 0xc0, 0x03, 0xc0, 0x03, 0x80, 0x01, 0x00, 0x00,
946   };
947
948   static char nsewscroll_smsk[] = {
949       0x80, 0x01, 0xc0, 0x03, 0xe0, 0x07, 0xe0, 0x07, 0xc0, 0x03, 0x0c,
950       0x30, 0x1e, 0x78, 0x1f, 0xf8, 0x1f, 0xf8, 0x1e, 0x78, 0x0c, 0x30,
951       0xc0, 0x03, 0xe0, 0x07, 0xe0, 0x07, 0xc0, 0x03, 0x80, 0x01,
952   };
953
954   static BCursor NSEWScrollCursor = {
955       /*small*/
956       nsewscroll_sbm,
957       nsewscroll_smsk,
958       16,
959       16,
960       8,
961       8,
962       /*big*/
963       NULL,
964       NULL,
965       32,
966       32,
967       15,
968       15,
969       /*color*/
970       BC_BLACK,
971       BC_WHITE,
972   };
973
974   BlenderCursor[BC_NSEW_SCROLLCURSOR] = &NSEWScrollCursor;
975
976   END_CURSOR_BLOCK
977
978   /********************** NS Scroll Cursor ***********************/
979   BEGIN_CURSOR_BLOCK
980
981   static char nsscroll_sbm[] = {
982       0x00, 0x00, 0x80, 0x01, 0xc0, 0x03, 0xc0, 0x03, 0x00, 0x00, 0x00,
983       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
984       0x00, 0x00, 0xc0, 0x03, 0xc0, 0x03, 0x80, 0x01, 0x00, 0x00,
985   };
986
987   static char nsscroll_smsk[] = {
988       0x80, 0x01, 0xc0, 0x03, 0xe0, 0x07, 0xe0, 0x07, 0xc0, 0x03, 0x00,
989       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
990       0xc0, 0x03, 0xe0, 0x07, 0xe0, 0x07, 0xc0, 0x03, 0x80, 0x01,
991   };
992
993   static BCursor NSScrollCursor = {
994       /*small*/
995       nsscroll_sbm,
996       nsscroll_smsk,
997       16,
998       16,
999       8,
1000       8,
1001       /*big*/
1002       NULL,
1003       NULL,
1004       32,
1005       32,
1006       15,
1007       15,
1008       /*color*/
1009       BC_BLACK,
1010       BC_WHITE,
1011   };
1012
1013   BlenderCursor[BC_NS_SCROLLCURSOR] = &NSScrollCursor;
1014
1015   END_CURSOR_BLOCK
1016
1017   /********************** EW Scroll Cursor ***********************/
1018   BEGIN_CURSOR_BLOCK
1019
1020   static char ewscroll_sbm[] = {
1021       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1022       0x00, 0x0c, 0x30, 0x0e, 0x70, 0x0e, 0x70, 0x0c, 0x30, 0x00, 0x00,
1023       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1024   };
1025
1026   static char ewscroll_smsk[] = {
1027       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c,
1028       0x30, 0x1e, 0x78, 0x1f, 0xf8, 0x1f, 0xf8, 0x1e, 0x78, 0x0c, 0x30,
1029       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1030   };
1031
1032   static BCursor EWScrollCursor = {
1033       /*small*/
1034       ewscroll_sbm,
1035       ewscroll_smsk,
1036       16,
1037       16,
1038       8,
1039       8,
1040       /*big*/
1041       NULL,
1042       NULL,
1043       32,
1044       32,
1045       15,
1046       15,
1047       /*color*/
1048       BC_BLACK,
1049       BC_WHITE,
1050   };
1051
1052   BlenderCursor[BC_EW_SCROLLCURSOR] = &EWScrollCursor;
1053
1054   END_CURSOR_BLOCK
1055
1056   /********************** Eyedropper Cursor ***********************/
1057   BEGIN_CURSOR_BLOCK
1058
1059   static char eyedropper_sbm[] = {
1060       0x00, 0x30, 0x00, 0x48, 0x00, 0x85, 0x80, 0x82, 0x40, 0x40, 0x80,
1061       0x20, 0x40, 0x11, 0xa0, 0x23, 0xd0, 0x15, 0xe8, 0x0a, 0x74, 0x01,
1062       0xb4, 0x00, 0x4a, 0x00, 0x35, 0x00, 0x08, 0x00, 0x04, 0x00,
1063   };
1064
1065   static char eyedropper_smsk[] = {
1066       0x00, 0x30, 0x00, 0x78, 0x00, 0xfd, 0x80, 0xff, 0xc0, 0x7f, 0x80,
1067       0x3f, 0xc0, 0x1f, 0xe0, 0x3f, 0xf0, 0x1f, 0xf8, 0x0b, 0xfc, 0x01,
1068       0xfc, 0x00, 0x7e, 0x00, 0x3f, 0x00, 0x0c, 0x00, 0x04, 0x00,
1069   };
1070
1071   static BCursor EyedropperCursor = {
1072       /*small*/
1073       eyedropper_sbm,
1074       eyedropper_smsk,
1075       16,
1076       16,
1077       1,
1078       15,
1079       /*big*/
1080       NULL,
1081       NULL,
1082       32,
1083       32,
1084       15,
1085       15,
1086       /*color*/
1087       BC_BLACK,
1088       BC_WHITE,
1089   };
1090
1091   BlenderCursor[BC_EYEDROPPER_CURSOR] = &EyedropperCursor;
1092
1093   END_CURSOR_BLOCK
1094
1095   /********************** Swap Area Cursor ***********************/
1096   BEGIN_CURSOR_BLOCK
1097   static char swap_sbm[] = {
1098       0xc0, 0xff, 0x40, 0x80, 0x40, 0x80, 0x40, 0x9c, 0x40, 0x98, 0x40,
1099       0x94, 0x00, 0x82, 0xfe, 0x80, 0x7e, 0xfd, 0xbe, 0x01, 0xda, 0x01,
1100       0xe2, 0x01, 0xe2, 0x01, 0xc2, 0x01, 0xfe, 0x01, 0x00, 0x00,
1101   };
1102
1103   static char swap_smsk[] = {
1104       0xc0, 0xff, 0xc0, 0xff, 0xc0, 0xff, 0xc0, 0xff, 0xc0, 0xff, 0xc0,
1105       0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0xff, 0x03,
1106       0xff, 0x03, 0xff, 0x03, 0xff, 0x03, 0xff, 0x03, 0xff, 0x03,
1107   };
1108
1109   static BCursor SwapCursor = {
1110       /*small*/
1111       swap_sbm,
1112       swap_smsk,
1113       16,
1114       16,
1115       8,
1116       8,
1117       /*big*/
1118       NULL,
1119       NULL,
1120       32,
1121       32,
1122       15,
1123       15,
1124       /*color*/
1125       BC_YELLOW,
1126       BC_BLUE,
1127   };
1128
1129   BlenderCursor[BC_SWAPAREA_CURSOR] = &SwapCursor;
1130
1131   END_CURSOR_BLOCK
1132
1133   /********************** Horizontal Split Cursor ***********************/
1134   BEGIN_CURSOR_BLOCK
1135
1136   static char hsplit_sbm[] = {0x00, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x88,
1137                               0x08, 0x8C, 0x18, 0x8E, 0x38, 0x8C, 0x18, 0x88, 0x08, 0x80, 0x00,
1138                               0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00};
1139
1140   static char hsplit_smsk[] = {0xC0, 0x01, 0xC0, 0x01, 0xC0, 0x01, 0xD0, 0x05, 0xD8, 0x0D, 0xDC,
1141                                0x1D, 0xDE, 0x3D, 0xDF, 0x7D, 0xDE, 0x3D, 0xDC, 0x1D, 0xD8, 0x0D,
1142                                0xD0, 0x05, 0xC0, 0x01, 0xC0, 0x01, 0xC0, 0x01, 0x00, 0x00};
1143
1144   static char hsplit_lbm[] = {
1145       0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01,
1146       0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80,
1147       0x01, 0x00, 0x00, 0x84, 0x21, 0x00, 0x00, 0x86, 0x61, 0x00, 0x00, 0x87, 0xE1, 0x00, 0x80,
1148       0x87, 0xE1, 0x01, 0xC0, 0x87, 0xE1, 0x03, 0xE0, 0x87, 0xE1, 0x07, 0xF0, 0x87, 0xE1, 0x0F,
1149       0xF8, 0x87, 0xE1, 0x1F, 0xF0, 0x87, 0xE1, 0x0F, 0xE0, 0x87, 0xE1, 0x07, 0xC0, 0x87, 0xE1,
1150       0x03, 0x80, 0x87, 0xE1, 0x01, 0x00, 0x87, 0xE1, 0x00, 0x00, 0x86, 0x61, 0x00, 0x00, 0x84,
1151       0x21, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00,
1152       0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00,
1153       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
1154
1155   static char hsplit_lmsk[] = {
1156       0x00, 0xC0, 0x03, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xC0, 0x03,
1157       0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xC8, 0x13, 0x00, 0x00, 0xCC, 0x33, 0x00, 0x00, 0xCE,
1158       0x73, 0x00, 0x00, 0xCF, 0xF3, 0x00, 0x80, 0xCF, 0xF3, 0x01, 0xC0, 0xCF, 0xF3, 0x03, 0xE0,
1159       0xCF, 0xF3, 0x07, 0xF0, 0xCF, 0xF3, 0x0F, 0xF8, 0xCF, 0xF3, 0x1F, 0xFC, 0xCF, 0xF3, 0x3F,
1160       0xFE, 0xCF, 0xF3, 0x7F, 0xFC, 0xCF, 0xF3, 0x3F, 0xF8, 0xCF, 0xF3, 0x1F, 0xF0, 0xCF, 0xF3,
1161       0x0F, 0xE0, 0xCF, 0xF3, 0x07, 0xC0, 0xCF, 0xF3, 0x03, 0x80, 0xCF, 0xF3, 0x01, 0x00, 0xCF,
1162       0xF3, 0x00, 0x00, 0xCE, 0x73, 0x00, 0x00, 0xCC, 0x33, 0x00, 0x00, 0xC8, 0x13, 0x00, 0x00,
1163       0xC8, 0x03, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xC0, 0x03, 0x00,
1164       0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00};
1165
1166   static BCursor HSplitCursor = {/*small*/
1167                                  hsplit_sbm,
1168                                  hsplit_smsk,
1169                                  16,
1170                                  16,
1171                                  7,
1172                                  7,
1173                                  /*big*/
1174                                  hsplit_lbm,
1175                                  hsplit_lmsk,
1176                                  32,
1177                                  32,
1178                                  15,
1179                                  15,
1180                                  /*color*/
1181                                  BC_BLACK,
1182                                  BC_WHITE};
1183
1184   BlenderCursor[BC_H_SPLITCURSOR] = &HSplitCursor;
1185
1186   END_CURSOR_BLOCK
1187
1188   /********************** Vertical Split Cursor ***********************/
1189   BEGIN_CURSOR_BLOCK
1190
1191   static char vsplit_sbm[] = {0x00, 0x00, 0x80, 0x00, 0xC0, 0x01, 0xE0, 0x03, 0x00, 0x00, 0x00,
1192                               0x00, 0x00, 0x00, 0xFE, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1193                               0xE0, 0x03, 0xC0, 0x01, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00};
1194
1195   static char vsplit_smsk[] = {0x80, 0x00, 0xC0, 0x01, 0xE0, 0x03, 0xF0, 0x07, 0xF8, 0x0F, 0x00,
1196                                0x00, 0xFF, 0x7F, 0xFF, 0x7F, 0xFF, 0x7F, 0x00, 0x00, 0xF8, 0x0F,
1197                                0xF0, 0x07, 0xE0, 0x03, 0xC0, 0x01, 0x80, 0x00, 0x00, 0x00};
1198
1199   static char vsplit_lbm[] = {
1200       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00,
1201       0x00, 0x00, 0xC0, 0x01, 0x00, 0x00, 0xE0, 0x03, 0x00, 0x00, 0xF0, 0x07, 0x00, 0x00, 0xF8,
1202       0x0F, 0x00, 0x00, 0xFC, 0x1F, 0x00, 0x00, 0xFE, 0x3F, 0x00, 0x00, 0xFF, 0x7F, 0x00, 0x00,
1203       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1204       0xFE, 0xFF, 0xFF, 0x3F, 0xFE, 0xFF, 0xFF, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1205       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x7F, 0x00, 0x00, 0xFE,
1206       0x3F, 0x00, 0x00, 0xFC, 0x1F, 0x00, 0x00, 0xF8, 0x0F, 0x00, 0x00, 0xF0, 0x07, 0x00, 0x00,
1207       0xE0, 0x03, 0x00, 0x00, 0xC0, 0x01, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1208       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
1209
1210   static char vsplit_lmsk[] = {
1211       0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0xC0, 0x01, 0x00, 0x00, 0xE0, 0x03,
1212       0x00, 0x00, 0xF0, 0x07, 0x00, 0x00, 0xF8, 0x0F, 0x00, 0x00, 0xFC, 0x1F, 0x00, 0x00, 0xFE,
1213       0x3F, 0x00, 0x00, 0xFF, 0x7F, 0x00, 0x80, 0xFF, 0xFF, 0x00, 0xC0, 0xFF, 0xFF, 0x01, 0xE0,
1214       0xFF, 0xFF, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0x7F,
1215       0xFF, 0xFF, 0xFF, 0x7F, 0xFF, 0xFF, 0xFF, 0x7F, 0xFF, 0xFF, 0xFF, 0x7F, 0x00, 0x00, 0x00,
1216       0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0xFF, 0x03, 0xC0, 0xFF, 0xFF, 0x01, 0x80, 0xFF,
1217       0xFF, 0x00, 0x00, 0xFF, 0x7F, 0x00, 0x00, 0xFE, 0x3F, 0x00, 0x00, 0xFC, 0x1F, 0x00, 0x00,
1218       0xF8, 0x0F, 0x00, 0x00, 0xF0, 0x07, 0x00, 0x00, 0xE0, 0x03, 0x00, 0x00, 0xC0, 0x01, 0x00,
1219       0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
1220
1221   static BCursor VSplitCursor = {/*small*/
1222                                  vsplit_sbm,
1223                                  vsplit_smsk,
1224                                  16,
1225                                  16,
1226                                  7,
1227                                  7,
1228                                  /*big*/
1229                                  vsplit_lbm,
1230                                  vsplit_lmsk,
1231                                  32,
1232                                  32,
1233                                  15,
1234                                  15,
1235                                  /*color*/
1236                                  BC_BLACK,
1237                                  BC_WHITE};
1238
1239   BlenderCursor[BC_V_SPLITCURSOR] = &VSplitCursor;
1240
1241   END_CURSOR_BLOCK
1242
1243   /********************** North Arrow Cursor ***********************/
1244   BEGIN_CURSOR_BLOCK
1245
1246   static char narrow_sbm[] = {0x00, 0x00, 0x80, 0x00, 0xC0, 0x01, 0xE0, 0x03, 0xF0, 0x07, 0xF8,
1247                               0x0F, 0xFC, 0x1F, 0xE0, 0x03, 0xE0, 0x03, 0xE0, 0x03, 0xE0, 0x03,
1248                               0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
1249
1250   static char narrow_smsk[] = {0x80, 0x00, 0xC0, 0x01, 0xE0, 0x03, 0xF0, 0x07, 0xF8, 0x0F, 0xFC,
1251                                0x1F, 0xFE, 0x3F, 0xFF, 0x7F, 0xF0, 0x07, 0xF0, 0x07, 0xF0, 0x07,
1252                                0xF0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
1253
1254   static char narrow_lbm[] = {
1255       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0xC0, 0x01,
1256       0x00, 0x00, 0xE0, 0x03, 0x00, 0x00, 0xF0, 0x07, 0x00, 0x00, 0xF8, 0x0F, 0x00, 0x00, 0xFC,
1257       0x1F, 0x00, 0x00, 0xFE, 0x3F, 0x00, 0x00, 0xFF, 0x7F, 0x00, 0x80, 0xFF, 0xFF, 0x00, 0xC0,
1258       0xFF, 0xFF, 0x01, 0xE0, 0xFF, 0xFF, 0x03, 0xF0, 0xFF, 0xFF, 0x07, 0xF8, 0xFF, 0xFF, 0x0F,
1259       0x00, 0xFC, 0x1F, 0x00, 0x00, 0xFC, 0x1F, 0x00, 0x00, 0xFC, 0x1F, 0x00, 0x00, 0xFC, 0x1F,
1260       0x00, 0x00, 0xFC, 0x1F, 0x00, 0x00, 0xFC, 0x1F, 0x00, 0x00, 0xFC, 0x1F, 0x00, 0x00, 0xFC,
1261       0x1F, 0x00, 0x00, 0xFC, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1262       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1263       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
1264
1265   static char narrow_lmsk[] = {
1266       0x00, 0x80, 0x00, 0x00, 0x00, 0xC0, 0x01, 0x00, 0x00, 0xE0, 0x03, 0x00, 0x00, 0xF0, 0x07,
1267       0x00, 0x00, 0xF8, 0x0F, 0x00, 0x00, 0xFC, 0x1F, 0x00, 0x00, 0xFE, 0x3F, 0x00, 0x00, 0xFF,
1268       0x7F, 0x00, 0x80, 0xFF, 0xFF, 0x00, 0xC0, 0xFF, 0xFF, 0x01, 0xE0, 0xFF, 0xFF, 0x03, 0xF0,
1269       0xFF, 0xFF, 0x07, 0xF8, 0xFF, 0xFF, 0x0F, 0xFC, 0xFF, 0xFF, 0x1F, 0xFE, 0xFF, 0xFF, 0x3F,
1270       0xFF, 0xFF, 0xFF, 0x7F, 0x00, 0xFE, 0x3F, 0x00, 0x00, 0xFE, 0x3F, 0x00, 0x00, 0xFE, 0x3F,
1271       0x00, 0x00, 0xFE, 0x3F, 0x00, 0x00, 0xFE, 0x3F, 0x00, 0x00, 0xFE, 0x3F, 0x00, 0x00, 0xFE,
1272       0x3F, 0x00, 0x00, 0xFE, 0x3F, 0x00, 0x00, 0xFE, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1273       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1274       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
1275
1276   static BCursor NArrowCursor = {/*small*/
1277                                  narrow_sbm,
1278                                  narrow_smsk,
1279                                  16,
1280                                  16,
1281                                  7,
1282                                  4,
1283                                  /*big*/
1284                                  narrow_lbm,
1285                                  narrow_lmsk,
1286                                  32,
1287                                  32,
1288                                  15,
1289                                  10,
1290                                  /*color*/
1291                                  BC_BLACK,
1292                                  BC_WHITE};
1293
1294   BlenderCursor[BC_N_ARROWCURSOR] = &NArrowCursor;
1295
1296   END_CURSOR_BLOCK
1297
1298   /********************** South Arrow Cursor ***********************/
1299   BEGIN_CURSOR_BLOCK
1300
1301   static char sarrow_sbm[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0,
1302                               0x03, 0xE0, 0x03, 0xE0, 0x03, 0xE0, 0x03, 0xFC, 0x1F, 0xF8, 0x0F,
1303                               0xF0, 0x07, 0xE0, 0x03, 0xC0, 0x01, 0x80, 0x00, 0x00, 0x00};
1304
1305   static char sarrow_smsk[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x07, 0xF0,
1306                                0x07, 0xF0, 0x07, 0xF0, 0x07, 0xFF, 0x7F, 0xFE, 0x3F, 0xFC, 0x1F,
1307                                0xF8, 0x0F, 0xF0, 0x07, 0xE0, 0x03, 0xC0, 0x01, 0x80, 0x00};
1308
1309   static char sarrow_lbm[] = {
1310       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1311       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1312       0x00, 0x00, 0x00, 0xFC, 0x1F, 0x00, 0x00, 0xFC, 0x1F, 0x00, 0x00, 0xFC, 0x1F, 0x00, 0x00,
1313       0xFC, 0x1F, 0x00, 0x00, 0xFC, 0x1F, 0x00, 0x00, 0xFC, 0x1F, 0x00, 0x00, 0xFC, 0x1F, 0x00,
1314       0x00, 0xFC, 0x1F, 0x00, 0x00, 0xFC, 0x1F, 0x00, 0xF8, 0xFF, 0xFF, 0x0F, 0xF0, 0xFF, 0xFF,
1315       0x07, 0xE0, 0xFF, 0xFF, 0x03, 0xC0, 0xFF, 0xFF, 0x01, 0x80, 0xFF, 0xFF, 0x00, 0x00, 0xFF,
1316       0x7F, 0x00, 0x00, 0xFE, 0x3F, 0x00, 0x00, 0xFC, 0x1F, 0x00, 0x00, 0xF8, 0x0F, 0x00, 0x00,
1317       0xF0, 0x07, 0x00, 0x00, 0xE0, 0x03, 0x00, 0x00, 0xC0, 0x01, 0x00, 0x00, 0x80, 0x00, 0x00,
1318       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
1319
1320   static char sarrow_lmsk[] = {
1321       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1322       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE,
1323       0x3F, 0x00, 0x00, 0xFE, 0x3F, 0x00, 0x00, 0xFE, 0x3F, 0x00, 0x00, 0xFE, 0x3F, 0x00, 0x00,
1324       0xFE, 0x3F, 0x00, 0x00, 0xFE, 0x3F, 0x00, 0x00, 0xFE, 0x3F, 0x00, 0x00, 0xFE, 0x3F, 0x00,
1325       0x00, 0xFE, 0x3F, 0x00, 0xFF, 0xFF, 0xFF, 0x7F, 0xFE, 0xFF, 0xFF, 0x3F, 0xFC, 0xFF, 0xFF,
1326       0x1F, 0xF8, 0xFF, 0xFF, 0x0F, 0xF0, 0xFF, 0xFF, 0x07, 0xE0, 0xFF, 0xFF, 0x03, 0xC0, 0xFF,
1327       0xFF, 0x01, 0x80, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0x7F, 0x00, 0x00, 0xFE, 0x3F, 0x00, 0x00,
1328       0xFC, 0x1F, 0x00, 0x00, 0xF8, 0x0F, 0x00, 0x00, 0xF0, 0x07, 0x00, 0x00, 0xE0, 0x03, 0x00,
1329       0x00, 0xC0, 0x01, 0x00, 0x00, 0x80, 0x00, 0x00};
1330
1331   static BCursor SArrowCursor = {/*small*/
1332                                  sarrow_sbm,
1333                                  sarrow_smsk,
1334                                  16,
1335                                  16,
1336                                  7,
1337                                  11,
1338                                  /*big*/
1339                                  sarrow_lbm,
1340                                  sarrow_lmsk,
1341                                  32,
1342                                  32,
1343                                  15,
1344                                  21,
1345                                  /*color*/
1346                                  BC_BLACK,
1347                                  BC_WHITE};
1348
1349   BlenderCursor[BC_S_ARROWCURSOR] = &SArrowCursor;
1350
1351   END_CURSOR_BLOCK
1352
1353   /********************** East Arrow Cursor ***********************/
1354   BEGIN_CURSOR_BLOCK
1355
1356   static char earrow_sbm[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0E, 0xE0,
1357                               0x1F, 0xE0, 0x3F, 0xE0, 0x7F, 0xE0, 0x3F, 0xE0, 0x1F, 0x00, 0x0E,
1358                               0x00, 0x06, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
1359
1360   static char earrow_smsk[] = {0x00, 0x01, 0x00, 0x03, 0x00, 0x07, 0x00, 0x0F, 0xF0, 0x1F, 0xF0,
1361                                0x3F, 0xF0, 0x7F, 0xF0, 0xFF, 0xF0, 0x7F, 0xF0, 0x3F, 0xF0, 0x1F,
1362                                0x00, 0x0F, 0x00, 0x07, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00};
1363
1364   static char earrow_lbm[] = {
1365       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
1366       0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00,
1367       0x3E, 0x00, 0x00, 0x00, 0x7E, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0xFF, 0xFF, 0x01, 0x00,
1368       0xFF, 0xFF, 0x03, 0x00, 0xFF, 0xFF, 0x07, 0x00, 0xFF, 0xFF, 0x0F, 0x00, 0xFF, 0xFF, 0x1F,
1369       0x00, 0xFF, 0xFF, 0x3F, 0x00, 0xFF, 0xFF, 0x1F, 0x00, 0xFF, 0xFF, 0x0F, 0x00, 0xFF, 0xFF,
1370       0x07, 0x00, 0xFF, 0xFF, 0x03, 0x00, 0xFF, 0xFF, 0x01, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00,
1371       0x7E, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00,
1372       0x00, 0x06, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1373       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
1374
1375   static char earrow_lmsk[] = {
1376       0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x0F,
1377       0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x3F, 0x00, 0x00, 0x00, 0x7F, 0x00, 0x00, 0x00,
1378       0xFF, 0x00, 0x00, 0x00, 0xFF, 0x01, 0x80, 0xFF, 0xFF, 0x03, 0x80, 0xFF, 0xFF, 0x07, 0x80,
1379       0xFF, 0xFF, 0x0F, 0x80, 0xFF, 0xFF, 0x1F, 0x80, 0xFF, 0xFF, 0x3F, 0x80, 0xFF, 0xFF, 0x7F,
1380       0x80, 0xFF, 0xFF, 0xFF, 0x80, 0xFF, 0xFF, 0x7F, 0x80, 0xFF, 0xFF, 0x3F, 0x80, 0xFF, 0xFF,
1381       0x1F, 0x80, 0xFF, 0xFF, 0x0F, 0x80, 0xFF, 0xFF, 0x07, 0x80, 0xFF, 0xFF, 0x03, 0x00, 0x00,
1382       0xFF, 0x01, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x7F, 0x00, 0x00, 0x00, 0x3F, 0x00, 0x00,
1383       0x00, 0x1F, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x03, 0x00,
1384       0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00};
1385
1386   static BCursor EArrowCursor = {/*small*/
1387                                  earrow_sbm,
1388                                  earrow_smsk,
1389                                  16,
1390                                  16,
1391                                  11,
1392                                  7,
1393                                  /*big*/
1394                                  earrow_lbm,
1395                                  earrow_lmsk,
1396                                  32,
1397                                  32,
1398                                  15,
1399                                  22,
1400                                  /*color*/
1401                                  BC_BLACK,
1402                                  BC_WHITE};
1403
1404   BlenderCursor[BC_E_ARROWCURSOR] = &EArrowCursor;
1405
1406   END_CURSOR_BLOCK
1407
1408   /********************** West Arrow Cursor ***********************/
1409   BEGIN_CURSOR_BLOCK
1410
1411   static char warrow_sbm[] = {0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x60, 0x00, 0x70, 0x00, 0xF8,
1412                               0x07, 0xFC, 0x07, 0xFE, 0x07, 0xFC, 0x07, 0xF8, 0x07, 0x70, 0x00,
1413                               0x60, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
1414
1415   static char warrow_smsk[] = {0x80, 0x00, 0xC0, 0x00, 0xE0, 0x00, 0xF0, 0x00, 0xF8, 0x0F, 0xFC,
1416                                0x0F, 0xFE, 0x0F, 0xFF, 0x0F, 0xFE, 0x0F, 0xFC, 0x0F, 0xF8, 0x0F,
1417                                0xF0, 0x00, 0xE0, 0x00, 0xC0, 0x00, 0x80, 0x00, 0x00, 0x00};
1418
1419   static char warrow_lbm[] = {
1420       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00,
1421       0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x7C,
1422       0x00, 0x00, 0x00, 0x7E, 0x00, 0x00, 0x00, 0x7F, 0x00, 0x00, 0x80, 0xFF, 0xFF, 0x00, 0xC0,
1423       0xFF, 0xFF, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0xF0, 0xFF, 0xFF, 0x00, 0xF8, 0xFF, 0xFF, 0x00,
1424       0xFC, 0xFF, 0xFF, 0x00, 0xF8, 0xFF, 0xFF, 0x00, 0xF0, 0xFF, 0xFF, 0x00, 0xE0, 0xFF, 0xFF,
1425       0x00, 0xC0, 0xFF, 0xFF, 0x00, 0x80, 0xFF, 0xFF, 0x00, 0x00, 0x7F, 0x00, 0x00, 0x00, 0x7E,
1426       0x00, 0x00, 0x00, 0x7C, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00,
1427       0x60, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1428       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
1429
1430   static char warrow_lmsk[] = {
1431       0x00, 0x80, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0xF0, 0x00,
1432       0x00, 0x00, 0xF8, 0x00, 0x00, 0x00, 0xFC, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0xFF,
1433       0x00, 0x00, 0x80, 0xFF, 0x00, 0x00, 0xC0, 0xFF, 0xFF, 0x01, 0xE0, 0xFF, 0xFF, 0x01, 0xF0,
1434       0xFF, 0xFF, 0x01, 0xF8, 0xFF, 0xFF, 0x01, 0xFC, 0xFF, 0xFF, 0x01, 0xFE, 0xFF, 0xFF, 0x01,
1435       0xFF, 0xFF, 0xFF, 0x01, 0xFE, 0xFF, 0xFF, 0x01, 0xFC, 0xFF, 0xFF, 0x01, 0xF8, 0xFF, 0xFF,
1436       0x01, 0xF0, 0xFF, 0xFF, 0x01, 0xE0, 0xFF, 0xFF, 0x01, 0xC0, 0xFF, 0xFF, 0x01, 0x80, 0xFF,
1437       0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0xFC, 0x00, 0x00, 0x00,
1438       0xF8, 0x00, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00,
1439       0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
1440
1441   static BCursor WArrowCursor = {/*small*/
1442                                  warrow_sbm,
1443                                  warrow_smsk,
1444                                  16,
1445                                  16,
1446                                  4,
1447                                  7,
1448                                  /*big*/
1449                                  warrow_lbm,
1450                                  warrow_lmsk,
1451                                  32,
1452                                  32,
1453                                  15,
1454                                  15,
1455                                  /*color*/
1456                                  BC_BLACK,
1457                                  BC_WHITE};
1458
1459   BlenderCursor[BC_W_ARROWCURSOR] = &WArrowCursor;
1460
1461   END_CURSOR_BLOCK
1462
1463   /********************** Stop Sign Cursor ***********************/
1464   BEGIN_CURSOR_BLOCK
1465
1466   static char stop_sbm[] = {0x00, 0x00, 0xE0, 0x07, 0x38, 0x1C, 0x1C, 0x30, 0x3C, 0x20, 0x76,
1467                             0x60, 0xE2, 0x40, 0xC2, 0x41, 0x82, 0x43, 0x02, 0x47, 0x06, 0x6E,
1468                             0x04, 0x3C, 0x0C, 0x38, 0x38, 0x1C, 0xE0, 0x07, 0x00, 0x00};
1469
1470   static char stop_smsk[] = {0xE0, 0x07, 0xF8, 0x1F, 0xFC, 0x3F, 0x3E, 0x7C, 0x7E, 0x70, 0xFF,
1471                              0xF0, 0xF7, 0xE1, 0xE7, 0xE3, 0xC7, 0xE7, 0x87, 0xEF, 0x0F, 0xFF,
1472                              0x0E, 0x7E, 0x3E, 0x7C, 0xFC, 0x3F, 0xF8, 0x1F, 0xE0, 0x07};
1473
1474   static char stop_lbm[] = {
1475       0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x0F, 0x00, 0x00, 0xFE, 0x7F, 0x00, 0x00, 0x0F, 0xF0,
1476       0x00, 0xC0, 0x03, 0xC0, 0x03, 0xE0, 0x01, 0x00, 0x07, 0xF0, 0x01, 0x00, 0x0E, 0xF0, 0x01,
1477       0x00, 0x0C, 0xF8, 0x03, 0x00, 0x18, 0x1C, 0x07, 0x00, 0x38, 0x0C, 0x0E, 0x00, 0x30, 0x0C,
1478       0x1C, 0x00, 0x30, 0x06, 0x38, 0x00, 0x60, 0x06, 0x70, 0x00, 0x60, 0x06, 0xE0, 0x00, 0x60,
1479       0x06, 0xC0, 0x01, 0x60, 0x06, 0x80, 0x03, 0x60, 0x06, 0x00, 0x07, 0x60, 0x06, 0x00, 0x0E,
1480       0x60, 0x06, 0x00, 0x1C, 0x60, 0x0C, 0x00, 0x38, 0x30, 0x0C, 0x00, 0x70, 0x30, 0x1C, 0x00,
1481       0xE0, 0x38, 0x18, 0x00, 0xC0, 0x1F, 0x30, 0x00, 0x80, 0x0F, 0x70, 0x00, 0x80, 0x0F, 0xE0,
1482       0x00, 0x80, 0x07, 0xC0, 0x03, 0xC0, 0x03, 0x00, 0x0F, 0xF0, 0x00, 0x00, 0xFE, 0x7F, 0x00,
1483       0x00, 0xF0, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00};
1484
1485   static char stop_lmsk[] = {
1486       0x00, 0xF0, 0x0F, 0x00, 0x00, 0xFE, 0x7F, 0x00, 0x80, 0xFF, 0xFF, 0x01, 0xC0, 0xFF, 0xFF,
1487       0x03, 0xE0, 0x1F, 0xF8, 0x07, 0xF0, 0x03, 0xC0, 0x0F, 0xF8, 0x03, 0x80, 0x1F, 0xFC, 0x07,
1488       0x00, 0x3F, 0xFC, 0x0F, 0x00, 0x3E, 0xFE, 0x1F, 0x00, 0x7C, 0x9E, 0x3F, 0x00, 0x78, 0x1E,
1489       0x7F, 0x00, 0x78, 0x1F, 0xFE, 0x00, 0xF8, 0x0F, 0xFC, 0x01, 0xF0, 0x0F, 0xF8, 0x03, 0xF0,
1490       0x0F, 0xF0, 0x07, 0xF0, 0x0F, 0xE0, 0x0F, 0xF0, 0x0F, 0xC0, 0x1F, 0xF0, 0x0F, 0x80, 0x3F,
1491       0xF0, 0x1F, 0x00, 0x7F, 0xF8, 0x1E, 0x00, 0xFE, 0x78, 0x1E, 0x00, 0xFC, 0x79, 0x3E, 0x00,
1492       0xF8, 0x7F, 0x7C, 0x00, 0xF0, 0x3F, 0xFC, 0x00, 0xE0, 0x3F, 0xF8, 0x01, 0xC0, 0x1F, 0xF0,
1493       0x03, 0xC0, 0x0F, 0xE0, 0x1F, 0xF8, 0x07, 0xC0, 0xFF, 0xFF, 0x03, 0x80, 0xFF, 0xFF, 0x01,
1494       0x00, 0xFE, 0x7F, 0x00, 0x00, 0xF0, 0x0F, 0x00};
1495
1496   static BCursor StopCursor = {/*small*/
1497                                stop_sbm,
1498                                stop_smsk,
1499                                16,
1500                                16,
1501                                7,
1502                                7,
1503                                /*big*/
1504                                stop_lbm,
1505                                stop_lmsk,
1506                                32,
1507                                32,
1508                                15,
1509                                15,
1510                                /*color*/
1511                                BC_BLACK,
1512                                BC_WHITE};
1513
1514   BlenderCursor[BC_STOPCURSOR] = &StopCursor;
1515
1516   END_CURSOR_BLOCK
1517
1518   /********************** Put the cursors in the array ***********************/
1519 }