Cleanup: pass event args as const
[blender-staging.git] / source / blender / windowmanager / intern / wm_cursors.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version. 
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2005-2007 Blender Foundation
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): Matt Ebb
24  *
25  * ***** END GPL/BL DUAL LICENSE BLOCK *****
26  */
27
28 /** \file blender/windowmanager/intern/wm_cursors.c
29  *  \ingroup wm
30  *
31  * Cursor pixmap and cursor utility functions to change the cursor.
32  */
33
34 #include <stdio.h>
35 #include <string.h>
36
37 #include "GHOST_C-api.h"
38
39 #include "BLI_utildefines.h"
40
41 #include "BLI_sys_types.h"
42
43 #include "DNA_listBase.h"
44 #include "DNA_userdef_types.h" 
45
46 #include "BKE_context.h"
47 #include "BKE_global.h"
48 #include "BKE_main.h"
49
50 #include "WM_types.h"
51 #include "WM_api.h"
52 #include "wm_cursors.h"
53 #include "wm_window.h"
54
55 /* XXX this still is mess from old code */
56
57
58
59 /* Some simple ghost <-> blender conversions */
60 static GHOST_TStandardCursor convert_cursor(int curs) 
61 {
62         switch (curs) {
63                 default:
64                 case CURSOR_STD:        return GHOST_kStandardCursorDefault;
65                 case CURSOR_FACESEL:    return GHOST_kStandardCursorRightArrow;
66                 case CURSOR_WAIT:       return GHOST_kStandardCursorWait;
67                 case CURSOR_EDIT:       return GHOST_kStandardCursorCrosshair;
68                 case CURSOR_HELP:
69 #ifdef __APPLE__
70                         return GHOST_kStandardCursorLeftRight;
71 #else
72                         return GHOST_kStandardCursorHelp;
73 #endif
74                 case CURSOR_X_MOVE:     return GHOST_kStandardCursorLeftRight;
75                 case CURSOR_Y_MOVE:     return GHOST_kStandardCursorUpDown;
76                 case CURSOR_PENCIL:     return GHOST_kStandardCursorPencil;
77                 case CURSOR_COPY:       return GHOST_kStandardCursorCopy;
78         }
79 }
80
81 static void window_set_custom_cursor(wmWindow *win, unsigned char mask[16][2], 
82                                      unsigned char bitmap[16][2], int hotx, int hoty)
83 {
84         GHOST_SetCustomCursorShape(win->ghostwin, bitmap, mask, hotx, hoty);
85 }
86
87 static void window_set_custom_cursor_ex(wmWindow *win, BCursor *cursor, int useBig) 
88 {
89         if (useBig) {
90                 GHOST_SetCustomCursorShapeEx(win->ghostwin, 
91                                              (GHOST_TUns8 *)cursor->big_bm, (GHOST_TUns8 *)cursor->big_mask,
92                                              cursor->big_sizex, cursor->big_sizey,
93                                              cursor->big_hotx, cursor->big_hoty,
94                                              cursor->fg_color, cursor->bg_color);
95         }
96         else {
97                 GHOST_SetCustomCursorShapeEx(win->ghostwin, 
98                                              (GHOST_TUns8 *)cursor->small_bm, (GHOST_TUns8 *)cursor->small_mask,
99                                              cursor->small_sizex, cursor->small_sizey,
100                                              cursor->small_hotx, cursor->small_hoty,
101                                              cursor->fg_color, cursor->bg_color);
102         }
103 }
104
105
106 /* Cursor Globals */
107 static BCursor *BlenderCursor[BC_NUMCURSORS]; /*Points to static BCursor Structs */
108
109 void WM_cursor_set(wmWindow *win, int curs)
110 {
111
112         if (win == NULL || G.background) {
113                 return;  /* Can't set custom cursor before Window init */
114         }
115
116         if (curs == CURSOR_NONE) {
117                 GHOST_SetCursorVisibility(win->ghostwin, 0);
118                 return;
119         }
120
121 #ifdef _WIN32
122         /* the default win32 cross cursor is barely visible,
123          * only 1 pixel thick, use another one instead */
124         if (curs == CURSOR_EDIT)
125                 curs = BC_CROSSCURSOR;
126 #else
127         /* in case of large cursor, also use custom cursor because
128          * large cursors don't work for system cursors */
129         if (U.curssize && curs == CURSOR_EDIT)
130                 curs = BC_CROSSCURSOR;
131 #endif
132
133         GHOST_SetCursorVisibility(win->ghostwin, 1);
134         
135         if (curs == CURSOR_STD && win->modalcursor)
136                 curs = win->modalcursor;
137         
138         win->cursor = curs;
139         
140         /* detect if we use system cursor or Blender cursor */
141         if (curs >= BC_GHOST_CURSORS) {
142                 GHOST_SetCursorShape(win->ghostwin, convert_cursor(curs));
143         }
144         else {
145                 if ((curs < SYSCURSOR) || (curs >= BC_NUMCURSORS)) return;
146
147                 if (curs == SYSCURSOR) {  /* System default Cursor */
148                         GHOST_SetCursorShape(win->ghostwin, convert_cursor(CURSOR_STD));
149                 }
150                 else if ((U.curssize == 0) || (BlenderCursor[curs]->big_bm == NULL)) {
151                         window_set_custom_cursor_ex(win, BlenderCursor[curs], 0);
152                 }
153                 else {
154                         window_set_custom_cursor_ex(win, BlenderCursor[curs], 1);
155                 }
156         }
157 }
158
159 void WM_cursor_modal_set(wmWindow *win, int val)
160 {
161         if (win->lastcursor == 0)
162                 win->lastcursor = win->cursor;
163         win->modalcursor = val;
164         WM_cursor_set(win, val);
165 }
166
167 void WM_cursor_modal_restore(wmWindow *win)
168 {
169         win->modalcursor = 0;
170         if (win->lastcursor)
171                 WM_cursor_set(win, win->lastcursor);
172         win->lastcursor = 0;
173 }
174
175 /* to allow usage all over, we do entire WM */
176 void WM_cursor_wait(bool val)
177 {
178         if (!G.background) {
179                 wmWindowManager *wm = G.main->wm.first;
180                 wmWindow *win = wm ? wm->windows.first : NULL;
181                 
182                 for (; win; win = win->next) {
183                         if (val) {
184                                 WM_cursor_modal_set(win, BC_WAITCURSOR);
185                         }
186                         else {
187                                 WM_cursor_modal_restore(win);
188                         }
189                 }
190         }
191 }
192
193 /**
194  * \param bounds can be NULL
195  */
196 void WM_cursor_grab_enable(wmWindow *win, bool wrap, bool hide, int bounds[4])
197 {
198         /* Only grab cursor when not running debug.
199          * It helps not to get a stuck WM when hitting a breakpoint  
200          * */
201         GHOST_TGrabCursorMode mode = GHOST_kGrabNormal;
202
203         if (bounds) {
204                 wm_cursor_position_to_ghost(win, &bounds[0], &bounds[1]);
205                 wm_cursor_position_to_ghost(win, &bounds[2], &bounds[3]);
206         }
207         
208         if (hide) {
209                 mode = GHOST_kGrabHide;
210         }
211         else if (wrap) {
212                 mode = GHOST_kGrabWrap;
213         }
214         if ((G.debug & G_DEBUG) == 0) {
215                 if (win->ghostwin) {
216                         const GHOST_TabletData *tabletdata = GHOST_GetTabletData(win->ghostwin);
217                         
218                         /* Note: There is no tabletdata on Windows if no tablet device is connected. */
219                         if (!tabletdata)
220                                 GHOST_SetCursorGrab(win->ghostwin, mode, bounds, NULL);
221                         else if (tabletdata->Active == GHOST_kTabletModeNone)
222                                 GHOST_SetCursorGrab(win->ghostwin, mode, bounds, NULL);
223
224                         win->grabcursor = mode;
225                 }
226         }
227 }
228
229 void WM_cursor_grab_disable(wmWindow *win, const int mouse_ungrab_xy[2])
230 {
231         if ((G.debug & G_DEBUG) == 0) {
232                 if (win && win->ghostwin) {
233                         if (mouse_ungrab_xy) {
234                                 int mouse_xy[2] = {mouse_ungrab_xy[0], mouse_ungrab_xy[1]};
235                                 wm_cursor_position_to_ghost(win, &mouse_xy[0], &mouse_xy[1]);
236                                 GHOST_SetCursorGrab(win->ghostwin, GHOST_kGrabDisable, NULL, mouse_xy);
237                         }
238                         else {
239                                 GHOST_SetCursorGrab(win->ghostwin, GHOST_kGrabDisable, NULL, NULL);
240                         }
241
242                         win->grabcursor = GHOST_kGrabDisable;
243                 }
244         }
245 }
246
247 static void wm_cursor_warp_relative(wmWindow *win, int x, int y)
248 {
249         /* note: don't use wmEvent coords because of continuous grab [#36409] */
250         int cx, cy;
251         wm_get_cursor_position(win, &cx, &cy);
252         WM_cursor_warp(win, cx + x, cy + y);
253 }
254
255 /* give it a modal keymap one day? */
256 bool wm_cursor_arrow_move(wmWindow *win, const wmEvent *event)
257 {
258         if (win && event->val == KM_PRESS) {
259                 if (event->type == UPARROWKEY) {
260                         wm_cursor_warp_relative(win, 0, 1);
261                         return 1;
262                 }
263                 else if (event->type == DOWNARROWKEY) {
264                         wm_cursor_warp_relative(win, 0, -1);
265                         return 1;
266                 }
267                 else if (event->type == LEFTARROWKEY) {
268                         wm_cursor_warp_relative(win, -1, 0);
269                         return 1;
270                 }
271                 else if (event->type == RIGHTARROWKEY) {
272                         wm_cursor_warp_relative(win, 1, 0);
273                         return 1;
274                 }
275         }
276         return 0;
277 }
278
279
280 /* afer this you can call restore too */
281 void WM_cursor_time(wmWindow *win, int nr)
282 {
283         /* 10 8x8 digits */
284         const char number_bitmaps[10][8] = {
285                 {0,  56,  68,  68,  68,  68,  68,  56},
286                 {0,  24,  16,  16,  16,  16,  16,  56},
287                 {0,  60,  66,  32,  16,   8,   4, 126},
288                 {0, 124,  32,  16,  56,  64,  66,  60},
289                 {0,  32,  48,  40,  36, 126,  32,  32},
290                 {0, 124,   4,  60,  64,  64,  68,  56},
291                 {0,  56,   4,   4,  60,  68,  68,  56},
292                 {0, 124,  64,  32,  16,   8,   8,   8},
293                 {0,  60,  66,  66,  60,  66,  66,  60},
294                 {0,  56,  68,  68, 120,  64,  68,  56}
295         };
296         unsigned char mask[16][2];
297         unsigned char bitmap[16][2] = {{0}};
298         int i, idx;
299         
300         if (win->lastcursor == 0)
301                 win->lastcursor = win->cursor;
302         
303         memset(&mask, 0xFF, sizeof(mask));
304         
305         /* print number bottom right justified */
306         for (idx = 3; nr && idx >= 0; idx--) {
307                 const char *digit = number_bitmaps[nr % 10];
308                 int x = idx % 2;
309                 int y = idx / 2;
310
311                 for (i = 0; i < 8; i++)
312                         bitmap[i + y * 8][x] = digit[i];
313                 nr /= 10;
314         }
315         
316         window_set_custom_cursor(win, mask, bitmap, 7, 7);
317 }
318
319
320 /**
321  * Custom Cursor Description
322  * =========================
323  *
324  * Each bit represents a pixel, so 1 byte = 8 pixels,
325  * the bytes go Left to Right. Top to bottom
326  * the bits in a byte go right to left
327  * (ie;  0x01, 0x80  represents a line of 16 pix with the first and last pix set.)
328  *
329  * - A 0 in the bitmap = bg_color, a 1 fg_color
330  * - a 0 in the mask   = transparent pix.
331  *
332  * Until 32x32 cursors are supported on all platforms, the size of the
333  * small cursors MUST be 16x16.
334  *
335  * Large cursors have a maximum size of 32x32.
336  *
337  * Other than that, the specified size of the cursors is just a guideline,
338  * However, the char array that defines the BM and MASK must be byte aligned.
339  * ie a 17x17 cursor needs 3 bytes (cols) * 17 bytes (rows)
340  * (3 bytes = 17 bits rounded up to nearest whole byte).  Pad extra bits
341  * in mask with 0's.
342  *
343  * Setting `big_bm = NULL` disables the large version of the cursor.
344  *
345  * ----
346  *
347  * There is a nice Python GUI utility that can be used for drawing cursors in
348  * this format in the Blender source distribution, in
349  * `./source/tools/utils/make_cursor_gui.py` .
350  *
351  * Start it with the command `python3 make_cursor_gui.py`
352  * It will copy its output to the console when you press 'Do it'.
353  */
354
355 /**
356  * Because defining a cursor mixes declarations and executable code
357  * each cursor needs it's own scoping block or it would be split up
358  * over several hundred lines of code.  To enforce/document this better
359  * I define 2 pretty brain-dead macros so it's obvious what the extra "[]"
360  * are for */
361
362 #define BEGIN_CURSOR_BLOCK {
363 #define END_CURSOR_BLOCK   }
364
365 void wm_init_cursor_data(void)
366 {
367         /********************** NW_ARROW Cursor **************************/
368 BEGIN_CURSOR_BLOCK
369         static char nw_sbm[] = {
370                 0x03,  0x00,  0x05,  0x00,  0x09,  0x00,  0x11,  0x00,
371                 0x21,  0x00,  0x41,  0x00,  0x81,  0x00,  0x01,  0x01,
372                 0x01,  0x02,  0xc1,  0x03,  0x49,  0x00,  0x8d,  0x00,
373                 0x8b,  0x00,  0x10,  0x01,  0x90,  0x01,  0x60,  0x00,
374         };
375
376         static char nw_smsk[] = {
377                 0x03,  0x00,  0x07,  0x00,  0x0f,  0x00,  0x1f,  0x00,
378                 0x3f,  0x00,  0x7f,  0x00,  0xff,  0x00,  0xff,  0x01,
379                 0xff,  0x03,  0xff,  0x03,  0x7f,  0x00,  0xff,  0x00,
380                 0xfb,  0x00,  0xf0,  0x01,  0xf0,  0x01,  0x60,  0x00,
381         };
382
383         static BCursor NWArrowCursor = {
384                 /*small*/
385                 nw_sbm, nw_smsk,
386                 16, 16,
387                 6,  7,
388                 /*big*/
389                 NULL, NULL,
390                 32, 32,
391                 15, 15,
392                 /*color*/
393                 BC_BLACK, BC_WHITE
394         };
395
396         BlenderCursor[BC_NW_ARROWCURSOR] = &NWArrowCursor;
397 END_CURSOR_BLOCK
398
399         ///********************** NS_ARROW Cursor *************************/
400 BEGIN_CURSOR_BLOCK
401         static char ns_sbm[] = {
402                 0x40,  0x01,  0x20,  0x02,  0x10,  0x04,  0x08,  0x08,
403                 0x04,  0x10,  0x3c,  0x1e,  0x20,  0x02,  0x20,  0x02,
404                 0x20,  0x02,  0x20,  0x02,  0x3c,  0x1e,  0x04,  0x10,
405                 0x08,  0x08,  0x10,  0x04,  0x20,  0x02,  0x40,  0x01
406         };
407
408         static char ns_smsk[] = {
409                 0xc0,  0x01,  0xe0,  0x03,  0xf0,  0x07,  0xf8,  0x0f,
410                 0xfc,  0x1f,  0xfc,  0x1f,  0xe0,  0x03,  0xe0,  0x03,
411                 0xe0,  0x03,  0xe0,  0x03,  0xfc,  0x1f,  0xfc,  0x1f,
412                 0xf8,  0x0f,  0xf0,  0x07,  0xe0,  0x03,  0xc0,  0x01
413         };
414
415         static BCursor NSArrowCursor = {
416                 /*small*/
417                 ns_sbm, ns_smsk,
418                 16, 16,
419                 6,  7,
420                 /*big*/
421                 NULL, NULL,
422                 32, 32,
423                 15, 15,
424                 /*color*/
425                 BC_BLACK, BC_WHITE
426         };
427
428         BlenderCursor[BC_NS_ARROWCURSOR] = &NSArrowCursor;
429                 
430 END_CURSOR_BLOCK
431         /********************** EW_ARROW Cursor *************************/
432 BEGIN_CURSOR_BLOCK
433         static char ew_sbm[] = {
434                 0x00,  0x00,  0x00,  0x00,  0x10,  0x08,  0x38,  0x1c,
435                 0x2c,  0x34,  0xe6,  0x67,  0x03,  0xc0,  0x01,  0x80,
436                 0x03,  0xc0,  0xe6,  0x67,  0x2c,  0x34,  0x38,  0x1c,
437                 0x10,  0x08,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
438         };
439
440         static char ew_smsk[] = {
441                 0x00,  0x00,  0x00,  0x00,  0x10,  0x08,  0x38,  0x1c,
442                 0x3c,  0x3c,  0xfe,  0x7f,  0xff,  0xff,  0xff,  0xff,
443                 0xff,  0xff,  0xfe,  0x7f,  0x3c,  0x3c,  0x38,  0x1c,
444                 0x10,  0x08,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
445         };
446
447         static BCursor EWArrowCursor = {
448                 /*small*/
449                 ew_sbm, ew_smsk,
450                 16, 16, 
451                 7,  6,
452                 /*big*/
453                 NULL, NULL,
454                 32, 32,
455                 15, 15,
456                 /*color*/
457                 BC_BLACK, BC_WHITE
458         };
459
460         BlenderCursor[BC_EW_ARROWCURSOR] = &EWArrowCursor;
461 END_CURSOR_BLOCK
462
463         /********************** Wait Cursor *****************************/
464 BEGIN_CURSOR_BLOCK
465         static char wait_sbm[] = {
466                 0xfe,  0x7f,  0x02,  0x40,  0x02,  0x40,  0x84,  0x21,
467                 0xc8,  0x13,  0xd0,  0x0b,  0xa0,  0x04,  0x20,  0x05,
468                 0xa0,  0x04,  0x10,  0x09,  0x88,  0x11,  0xc4,  0x23,
469                 0xe2,  0x47,  0xfa,  0x5f,  0x02,  0x40,  0xfe,  0x7f,
470         };
471
472         static char wait_smsk[] = {
473                 0xfe,  0x7f,  0xfe,  0x7f,  0x06,  0x60,  0x8c,  0x31,
474                 0xd8,  0x1b,  0xf0,  0x0f,  0xe0,  0x06,  0x60,  0x07,
475                 0xe0,  0x06,  0x30,  0x0d,  0x98,  0x19,  0xcc,  0x33,
476                 0xe6,  0x67,  0xfe,  0x7f,  0xfe,  0x7f,  0xfe,  0x7f,
477         };
478
479         static char wait_lbm[] = {
480                 0xfc,  0xff,  0xff,  0x3f,  0xfc,  0xff,  0xff,  0x3f,
481                 0x0c,  0x00,  0x00,  0x30,  0x0c,  0x00,  0x00,  0x30,
482                 0x0c,  0x00,  0x00,  0x30,  0x0c,  0x00,  0x00,  0x18,
483                 0x18,  0xc0,  0x03,  0x0c,  0x30,  0x20,  0x07,  0x06,
484                 0x60,  0xf0,  0x0f,  0x03,  0xc0,  0xd0,  0x8d,  0x01,
485                 0x80,  0x79,  0xcf,  0x00,  0x00,  0xf3,  0x67,  0x00,
486                 0x00,  0x66,  0x37,  0x00,  0x00,  0x8c,  0x33,  0x00,
487                 0x00,  0x0c,  0x32,  0x00,  0x00,  0xcc,  0x33,  0x00,
488                 0x00,  0x8c,  0x30,  0x00,  0x00,  0x46,  0x61,  0x00,
489                 0x00,  0x03,  0xc3,  0x00,  0x80,  0x01,  0x83,  0x01,
490                 0xc0,  0xc0,  0x03,  0x03,  0x60,  0xa0,  0x05,  0x06,
491                 0x30,  0xf0,  0x0f,  0x0c,  0x18,  0xf8,  0x1d,  0x18,
492                 0x0c,  0x5c,  0x3f,  0x30,  0x0c,  0xff,  0x5f,  0x30,
493                 0x0c,  0xf7,  0xfe,  0x31,  0xcc,  0xfb,  0x9f,  0x33,
494                 0x0c,  0x00,  0x00,  0x30,  0x0c,  0x00,  0x00,  0x30,
495                 0xfc,  0xff,  0xff,  0x3f,  0xfc,  0xff,  0xff,  0x3f,
496         };
497
498         static char wait_lmsk[] = {
499                 0xfc,  0xff,  0xff,  0x3f,  0xfc,  0xff,  0xff,  0x3f,
500                 0xfc,  0xff,  0xff,  0x3f,  0xfc,  0xff,  0xff,  0x3f,
501                 0x3c,  0x00,  0x00,  0x3c,  0x3c,  0x00,  0x00,  0x1e,
502                 0x78,  0xc0,  0x03,  0x0f,  0xf0,  0xa0,  0x87,  0x07,
503                 0xe0,  0xf1,  0xcf,  0x03,  0xc0,  0xf3,  0xef,  0x01,
504                 0x80,  0xff,  0xff,  0x00,  0x00,  0xff,  0x7f,  0x00,
505                 0x00,  0xfe,  0x3f,  0x00,  0x00,  0xfc,  0x3f,  0x00,
506                 0x00,  0x3c,  0x3f,  0x00,  0x00,  0xfc,  0x3f,  0x00,
507                 0x00,  0xbc,  0x3c,  0x00,  0x00,  0xde,  0x79,  0x00,
508                 0x00,  0x0f,  0xf3,  0x00,  0x80,  0x07,  0xe3,  0x01,
509                 0xc0,  0xc3,  0xc3,  0x03,  0xe0,  0xe1,  0x87,  0x07,
510                 0xf0,  0xf0,  0x0f,  0x0f,  0x78,  0xf8,  0x1f,  0x1e,
511                 0x3c,  0x7c,  0x3f,  0x3c,  0x3c,  0xff,  0x7f,  0x3c,
512                 0xbc,  0xff,  0xff,  0x3d,  0xfc,  0xfb,  0xbf,  0x3f,
513                 0xfc,  0xff,  0xff,  0x3f,  0xfc,  0xff,  0xff,  0x3f,
514                 0xfc,  0xff,  0xff,  0x3f,  0xfc,  0xff,  0xff,  0x3f,
515         };
516
517         static BCursor WaitCursor = {
518                 /*small*/
519                 wait_sbm, wait_smsk,
520                 16, 16, 
521                 7,  7,
522                 /*big*/
523                 wait_lbm, wait_lmsk,
524                 32, 32,
525                 15, 15,
526                 /*color*/
527                 BC_BLACK, BC_WHITE
528         };
529
530         BlenderCursor[BC_WAITCURSOR] = &WaitCursor;
531 END_CURSOR_BLOCK
532
533         /********************** Cross Cursor ***************************/
534 BEGIN_CURSOR_BLOCK
535         static char cross_sbm[] = {
536                 0x00,  0x00,  0x80,  0x01,  0x80,  0x01,  0x80,  0x01,
537                 0x80,  0x01,  0x80,  0x01,  0x80,  0x01,  0x7e,  0x7e,
538                 0x7e,  0x7e,  0x80,  0x01,  0x80,  0x01,  0x80,  0x01,
539                 0x80,  0x01,  0x80,  0x01,  0x80,  0x01,  0x00,  0x00,
540         };
541
542         static char cross_smsk[] = {
543                 0x80,  0x01,  0x80,  0x01,  0x80,  0x01,  0x80,  0x01,
544                 0x80,  0x01,  0x80,  0x01,  0xc0,  0x03,  0x7f,  0xfe,
545                 0x7f,  0xfe,  0xc0,  0x03,  0x80,  0x01,  0x80,  0x01,
546                 0x80,  0x01,  0x80,  0x01,  0x80,  0x01,  0x80,  0x01,
547         };
548         static char cross_lbm[] = {
549                 0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
550                 0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
551                 0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
552                 0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
553                 0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
554                 0x00,  0x80,  0x01,  0x00,  0x00,  0xc0,  0x03,  0x00,
555                 0x00,  0xc0,  0x03,  0x00,  0x00,  0x40,  0x02,  0x00,
556                 0x00,  0x78,  0x1e,  0x00,  0xfc,  0x1f,  0xf8,  0x3f,
557                 0xfc,  0x1f,  0xf8,  0x3f,  0x00,  0x78,  0x1e,  0x00,
558                 0x00,  0x40,  0x02,  0x00,  0x00,  0xc0,  0x03,  0x00,
559                 0x00,  0xc0,  0x03,  0x00,  0x00,  0x80,  0x01,  0x00,
560                 0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
561                 0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
562                 0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
563                 0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
564                 0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
565         };
566
567         static char cross_lmsk[] = {
568                 0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
569                 0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
570                 0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
571                 0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
572                 0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
573                 0x00,  0x80,  0x01,  0x00,  0x00,  0xc0,  0x03,  0x00,
574                 0x00,  0xe0,  0x07,  0x00,  0x00,  0x70,  0x0e,  0x00,
575                 0x00,  0x78,  0x1e,  0x00,  0xff,  0x1f,  0xf8,  0xff,
576                 0xff,  0x1f,  0xf8,  0xff,  0x00,  0x78,  0x1e,  0x00,
577                 0x00,  0x70,  0x0e,  0x00,  0x00,  0xe0,  0x07,  0x00,
578                 0x00,  0xc0,  0x03,  0x00,  0x00,  0x80,  0x01,  0x00,
579                 0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
580                 0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
581                 0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
582                 0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
583                 0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
584         };
585
586         static BCursor CrossCursor = {
587                 /*small*/
588                 cross_sbm, cross_smsk,
589                 16, 16, 
590                 7,  7,
591                 /*big*/
592                 cross_lbm, cross_lmsk,
593                 32, 32,
594                 15, 15,
595                 /*color*/
596                 BC_BLACK, BC_WHITE
597         };
598
599         BlenderCursor[BC_CROSSCURSOR] = &CrossCursor;
600 END_CURSOR_BLOCK
601
602         /********************** EditCross Cursor ***********************/
603 BEGIN_CURSOR_BLOCK
604         static char editcross_sbm[] = {
605                 0x0e,  0x00,  0x11,  0x00,  0x1d,  0x00,  0x19,  0x03,
606                 0x1d,  0x03,  0x11,  0x03,  0x0e,  0x03,  0x00,  0x03,
607                 0xf8,  0x7c,  0xf8,  0x7c,  0x00,  0x03,  0x00,  0x03,
608                 0x00,  0x03,  0x00,  0x03,  0x00,  0x03,  0x00,  0x00,
609         };
610
611         static char editcross_smsk[] = {
612                 0x0e,  0x00,  0x1f,  0x00,  0x1f,  0x03,  0x1f,  0x03,
613                 0x1f,  0x03,  0x1f,  0x03,  0x0e,  0x03,  0x80,  0x07,
614                 0xfc,  0xfc,  0xfc,  0xfc,  0x80,  0x07,  0x00,  0x03,
615                 0x00,  0x03,  0x00,  0x03,  0x00,  0x03,  0x00,  0x03,
616         };
617
618         static BCursor EditCrossCursor = {
619                 /*small*/
620                 editcross_sbm, editcross_smsk,
621                 16, 16, 
622                 9,  8,
623                 /*big*/
624                 NULL, NULL,
625                 32, 32,
626                 15, 15,
627                 /*color*/
628                 BC_BLACK, BC_WHITE
629         };
630
631         BlenderCursor[BC_EDITCROSSCURSOR] = &EditCrossCursor;
632 END_CURSOR_BLOCK
633
634         /********************** Box Select *************************/
635 BEGIN_CURSOR_BLOCK
636         static char box_sbm[32] = {
637                 0x7f,  0x00,  0x41,  0x00,  0x41,  0x00,  0x41,  0x06,
638                 0x41,  0x06,  0x41,  0x06,  0x7f,  0x06,  0x00,  0x06,
639                 0xe0,  0x79,  0xe0,  0x79,  0x00,  0x06,  0x00,  0x06,
640                 0x00,  0x06,  0x00,  0x06,  0x00,  0x06,  0x00,  0x00,
641         };
642
643         static char box_smsk[32] = {
644                 0x7f,  0x00,  0x7f,  0x00,  0x63,  0x06,  0x63,  0x06,
645                 0x63,  0x06,  0x7f,  0x06,  0x7f,  0x06,  0x00,  0x0f,
646                 0xf0,  0xf9,  0xf0,  0xf9,  0x00,  0x0f,  0x00,  0x06,
647                 0x00,  0x06,  0x00,  0x06,  0x00,  0x06,  0x00,  0x06,
648
649         };
650
651         static BCursor BoxSelCursor = {
652                 /*small*/
653                 box_sbm, box_smsk,
654                 16, 16, 
655                 9,  8,
656                 /*big*/
657                 NULL, NULL,
658                 32, 32,
659                 15, 15,
660                 /*color*/
661                 BC_BLACK, BC_WHITE
662         };
663
664         BlenderCursor[BC_BOXSELCURSOR] = &BoxSelCursor;
665
666 END_CURSOR_BLOCK
667         /********************** Knife Cursor ***********************/
668 BEGIN_CURSOR_BLOCK
669         static char knife_sbm[] = {
670                 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x2c,
671                 0x00, 0x5a, 0x00, 0x34, 0x00, 0x2a, 0x00, 0x17,
672                 0x80, 0x06, 0x40, 0x03, 0xa0, 0x03, 0xd0, 0x01,
673                 0x68, 0x00, 0x1c, 0x00, 0x06, 0x00, 0x00, 0x00
674         };
675
676         static char knife_smsk[] = {
677                 0x00, 0x60, 0x00, 0xf0, 0x00, 0xfc, 0x00, 0xfe,
678                 0x00, 0xfe, 0x00, 0x7e, 0x00, 0x7f, 0x80, 0x3f,
679                 0xc0, 0x0e, 0x60, 0x07, 0xb0, 0x07, 0xd8, 0x03,
680                 0xec, 0x01, 0x7e, 0x00, 0x1f, 0x00, 0x07, 0x00
681         };
682
683         static char knife_lbm[] = {
684                 0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
685                 0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
686                 0x00,  0x00,  0x00,  0x08,  0x00,  0x00,  0x00,  0x1c,
687                 0x00,  0x00,  0x00,  0x3e,  0x00,  0x00,  0x00,  0x7f,
688                 0x00,  0x00,  0x80,  0xbf,  0x00,  0x00,  0xc0,  0x5f,
689                 0x00,  0x00,  0xc0,  0x6f,  0x00,  0x00,  0xc0,  0x37,
690                 0x00,  0x00,  0xa8,  0x1b,  0x00,  0x00,  0x54,  0x0d,
691                 0x00,  0x00,  0xa8,  0x00,  0x00,  0x00,  0x54,  0x00,
692                 0x00,  0x00,  0xa8,  0x00,  0x00,  0x00,  0x53,  0x00,
693                 0x00,  0xc0,  0x07,  0x00,  0x00,  0xe0,  0x0f,  0x00,
694                 0x00,  0xd0,  0x0f,  0x00,  0x00,  0xe8,  0x07,  0x00,
695                 0x00,  0xf4,  0x07,  0x00,  0x00,  0xfa,  0x00,  0x00,
696                 0x00,  0x3d,  0x00,  0x00,  0x80,  0x0e,  0x00,  0x00,
697                 0xc0,  0x03,  0x00,  0x00,  0xe0,  0x00,  0x00,  0x00,
698                 0x30,  0x00,  0x00,  0x00,  0x08,  0x00,  0x00,  0x00,
699                 0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
700
701         };
702
703         static char knife_lmsk[] = {
704                 0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
705                 0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x18,
706                 0x00,  0x00,  0x00,  0x3c,  0x00,  0x00,  0x00,  0x7e,
707                 0x00,  0x00,  0x00,  0xff,  0x00,  0x00,  0x80,  0xff,
708                 0x00,  0x00,  0xc0,  0xbf,  0x00,  0x00,  0xe0,  0xdf,
709                 0x00,  0x00,  0xe0,  0xef,  0x00,  0x00,  0xf8,  0x77,
710                 0x00,  0x00,  0xfc,  0x3b,  0x00,  0x00,  0xfe,  0x1d,
711                 0x00,  0x00,  0xfe,  0x0f,  0x00,  0x00,  0xfe,  0x01,
712                 0x00,  0x00,  0xff,  0x01,  0x00,  0xc0,  0xff,  0x00,
713                 0x00,  0xe0,  0x7f,  0x00,  0x00,  0xf0,  0x1f,  0x00,
714                 0x00,  0xd8,  0x1f,  0x00,  0x00,  0xec,  0x0f,  0x00,
715                 0x00,  0xf6,  0x0f,  0x00,  0x00,  0xfb,  0x06,  0x00,
716                 0x80,  0xbd,  0x01,  0x00,  0xc0,  0x6e,  0x00,  0x00,
717                 0xe0,  0x1b,  0x00,  0x00,  0xf0,  0x06,  0x00,  0x00,
718                 0xb8,  0x01,  0x00,  0x00,  0x6c,  0x00,  0x00,  0x00,
719                 0x1c,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
720
721         };
722
723         static BCursor KnifeCursor = {
724                 /*small*/
725                 knife_sbm, knife_smsk,
726                 16, 16, 
727                 0,  15,
728                 /*big*/
729                 knife_lbm, knife_lmsk,
730                 32, 32,
731                 0, 31,
732                 /*color*/
733                 BC_BLACK, BC_WHITE
734         };
735
736         BlenderCursor[BC_KNIFECURSOR] = &KnifeCursor;
737
738 END_CURSOR_BLOCK
739         
740         /********************** Loop Select Cursor ***********************/
741 BEGIN_CURSOR_BLOCK
742
743         static char vloop_sbm[] = {
744                 0x00,  0x00,  0x7e,  0x00,  0x3e,  0x00,  0x1e,  0x00,
745                 0x0e,  0x00,  0x66,  0x60,  0x62,  0x6f,  0x00,  0x00,
746                 0x20,  0x20,  0x20,  0x20,  0x20,  0x20,  0x20,  0x20,
747                 0x00,  0x00,  0x60,  0x60,  0x60,  0x6f,  0x00,  0x00,
748         };
749
750         static char vloop_smsk[] = {
751                 0xff,  0x01,  0xff,  0x00,  0x7f,  0x00,  0x3f,  0x00,
752                 0xff,  0xf0,  0xff,  0xff,  0xf7,  0xff,  0xf3,  0xf0,
753                 0x61,  0x60,  0x60,  0x60,  0x60,  0x60,  0x60,  0x60,
754                 0xf0,  0xf0,  0xf0,  0xff,  0xf0,  0xff,  0xf0,  0xf0,
755         };
756
757
758
759         static char vloop_lbm[] = {
760                 0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
761                 0xfc,  0x3f,  0x00,  0x00,  0xfc,  0x3f,  0x00,  0x00,
762                 0xfc,  0x0f,  0x00,  0x00,  0xfc,  0x0f,  0x00,  0x00,
763                 0xfc,  0x03,  0x00,  0x00,  0xfc,  0x03,  0x00,  0x00,
764                 0xfc,  0x00,  0x00,  0x00,  0xfc,  0x00,  0x00,  0x00,
765                 0x3c,  0x3c,  0x00,  0x3c,  0x3c,  0x3c,  0x00,  0x3c,
766                 0x0c,  0x3c,  0xff,  0x3c,  0x0c,  0x3c,  0xff,  0x3c,
767                 0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
768                 0x00,  0x0c,  0x00,  0x0c,  0x00,  0x0c,  0x00,  0x0c,
769                 0x00,  0x0c,  0x00,  0x0c,  0x00,  0x0c,  0x00,  0x0c,
770                 0x00,  0x0c,  0x00,  0x0c,  0x00,  0x0c,  0x00,  0x0c,
771                 0x00,  0x0c,  0x00,  0x0c,  0x00,  0x0c,  0x00,  0x0c,
772                 0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
773                 0x00,  0x3c,  0x00,  0x3c,  0x00,  0x3c,  0x00,  0x3c,
774                 0x00,  0x3c,  0xff,  0x3c,  0x00,  0x3c,  0xff,  0x3c,
775                 0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
776         };
777
778         static char vloop_lmsk[] = {
779                 0xff,  0xff,  0x03,  0x00,  0xff,  0xff,  0x03,  0x00,
780                 0xff,  0xff,  0x00,  0x00,  0xff,  0xff,  0x00,  0x00,
781                 0xff,  0x3f,  0x00,  0x00,  0xff,  0x3f,  0x00,  0x00,
782                 0xff,  0x0f,  0x00,  0x00,  0xff,  0x0f,  0x00,  0x00,
783                 0xff,  0xff,  0x00,  0xff,  0xff,  0xff,  0x00,  0xff,
784                 0xff,  0xff,  0xff,  0xff,  0xff,  0xff,  0xff,  0xff,
785                 0x3f,  0xff,  0xff,  0xff,  0x3f,  0xff,  0xff,  0xff,
786                 0x0f,  0xff,  0x00,  0xff,  0x0f,  0xff,  0x00,  0xff,
787                 0x03,  0x3c,  0x00,  0x3c,  0x03,  0x3c,  0x00,  0x3c,
788                 0x00,  0x3c,  0x00,  0x3c,  0x00,  0x3c,  0x00,  0x3c,
789                 0x00,  0x3c,  0x00,  0x3c,  0x00,  0x3c,  0x00,  0x3c,
790                 0x00,  0x3c,  0x00,  0x3c,  0x00,  0x3c,  0x00,  0x3c,
791                 0x00,  0xff,  0x00,  0xff,  0x00,  0xff,  0x00,  0xff,
792                 0x00,  0xff,  0xff,  0xff,  0x00,  0xff,  0xff,  0xff,
793                 0x00,  0xff,  0xff,  0xff,  0x00,  0xff,  0xff,  0xff,
794                 0x00,  0xff,  0x00,  0xff,  0x00,  0xff,  0x00,  0xff,
795         };
796
797
798
799         static BCursor VLoopCursor = {
800                 /*small*/
801                 vloop_sbm, vloop_smsk,
802                 16, 16, 
803                 0,  0,
804                 /*big*/
805                 vloop_lbm, vloop_lmsk,
806                 32, 32,
807                 0, 0,
808                 /*color*/
809                 BC_BLACK, BC_WHITE
810         };
811
812         BlenderCursor[BC_VLOOPCURSOR] = &VLoopCursor;
813
814 END_CURSOR_BLOCK
815         
816
817         /********************** TextEdit Cursor ***********************/
818 BEGIN_CURSOR_BLOCK
819         static char textedit_sbm[] = {
820                 0xe0,  0x03,  0x10,  0x04,  0x60,  0x03,  0x40,  0x01,
821                 0x40,  0x01,  0x40,  0x01,  0x40,  0x01,  0x40,  0x01,
822                 0x40,  0x01,  0x40,  0x01,  0x40,  0x01,  0x40,  0x01,
823                 0x40,  0x01,  0x60,  0x03,  0x10,  0x04,  0xe0,  0x03,
824         };
825
826         static char textedit_smsk[] = {
827                 0xe0,  0x03,  0xf0,  0x07,  0xe0,  0x03,  0xc0,  0x01,
828                 0xc0,  0x01,  0xc0,  0x01,  0xc0,  0x01,  0xc0,  0x01,
829                 0xc0,  0x01,  0xc0,  0x01,  0xc0,  0x01,  0xc0,  0x01,
830                 0xc0,  0x01,  0xe0,  0x03,  0xf0,  0x07,  0xe0,  0x03,
831         };
832
833         static BCursor TextEditCursor = {
834                 /*small*/
835                 textedit_sbm, textedit_smsk,
836                 16, 16, 
837                 9,  8,
838                 /*big*/
839                 NULL, NULL,
840                 32, 32,
841                 15, 15,
842                 /*color*/
843                 BC_BLACK, BC_WHITE
844         };
845
846         BlenderCursor[BC_TEXTEDITCURSOR] = &TextEditCursor;
847 END_CURSOR_BLOCK
848
849
850         /********************** Paintbrush Cursor ***********************/
851 BEGIN_CURSOR_BLOCK
852         static char paintbrush_sbm[] = {
853
854                 0x00,  0xe0,  0x00,  0x98,  0x00,  0x44,  0x00,  0x42,
855                 0x00,  0x21,  0x80,  0x20,  0x40,  0x13,  0x40,  0x17,
856                 0xa0,  0x0b,  0x98,  0x05,  0x04,  0x02,  0x02,  0x01,
857                 0x02,  0x01,  0x02,  0x01,  0x81,  0x00,  0x7f,  0x00,
858
859
860
861         };
862
863         static char paintbrush_smsk[] = {
864                 0x00,  0xe0,  0x00,  0xf8,  0x00,  0x7c,  0x00,  0x7e,
865                 0x00,  0x3f,  0x80,  0x3f,  0xc0,  0x1f,  0xc0,  0x1f,
866                 0xe0,  0x0f,  0xf8,  0x07,  0xfc,  0x03,  0xfe,  0x01,
867                 0xfe,  0x01,  0xfe,  0x01,  0xff,  0x00,  0x7f,  0x00,
868
869
870         };
871
872         static BCursor PaintBrushCursor = {
873                 /*small*/
874                 paintbrush_sbm, paintbrush_smsk,
875                 16, 16, 
876                 0,  15,
877                 /*big*/
878                 NULL, NULL,
879                 32, 32,
880                 15, 15,
881                 /*color*/
882                 BC_BLACK, BC_WHITE
883         };
884
885         BlenderCursor[BC_PAINTBRUSHCURSOR] = &PaintBrushCursor;
886 END_CURSOR_BLOCK
887
888
889 /********************** Hand Cursor ***********************/
890 BEGIN_CURSOR_BLOCK
891
892         static char hand_sbm[] = {
893                 0x00,  0x00,  0x00,  0x00,  0x80,  0x01,  0x80,  0x0d,
894                 0x98,  0x6d,  0x98,  0x6d,  0xb0,  0x6d,  0xb0,  0x6d,
895                 0xe0,  0x6f,  0xe6,  0x7f,  0xee,  0x7f,  0xfc,  0x3f,
896                 0xf8,  0x3f,  0xf0,  0x1f,  0xc0,  0x1f,  0xc0,  0x1f,
897         };
898
899         static char hand_smsk[] = {
900                 0x00,  0x00,  0x80,  0x01,  0xc0,  0x0f,  0xd8,  0x7f,
901                 0xfc,  0xff,  0xfc,  0xff,  0xf8,  0xff,  0xf8,  0xff,
902                 0xf6,  0xff,  0xff,  0xff,  0xff,  0xff,  0xfe,  0x7f,
903                 0xfc,  0x7f,  0xf8,  0x3f,  0xf0,  0x3f,  0xe0,  0x3f,
904         };
905
906
907         static BCursor HandCursor = {
908                 /*small*/
909                 hand_sbm, hand_smsk,
910                 16, 16,
911                 8,  8,
912                 /*big*/
913                 NULL, NULL,
914                 32, 32,
915                 15, 15,
916                 /*color*/
917                 BC_BLACK, BC_WHITE
918         };
919
920         BlenderCursor[BC_HANDCURSOR] = &HandCursor;
921
922 END_CURSOR_BLOCK
923
924 /********************** NSEW Scroll Cursor ***********************/
925 BEGIN_CURSOR_BLOCK
926
927         static char nsewscroll_sbm[] = {
928                 0x00,  0x00,  0x80,  0x01,  0xc0,  0x03,  0xc0,  0x03,
929                 0x00,  0x00,  0x00,  0x00,  0x0c,  0x30,  0x0e,  0x70,
930                 0x0e,  0x70,  0x0c,  0x30,  0x00,  0x00,  0x00,  0x00,
931                 0xc0,  0x03,  0xc0,  0x03,  0x80,  0x01,  0x00,  0x00,
932         };
933
934         static char nsewscroll_smsk[] = {
935                 0x80,  0x01,  0xc0,  0x03,  0xe0,  0x07,  0xe0,  0x07,
936                 0xc0,  0x03,  0x0c,  0x30,  0x1e,  0x78,  0x1f,  0xf8,
937                 0x1f,  0xf8,  0x1e,  0x78,  0x0c,  0x30,  0xc0,  0x03,
938                 0xe0,  0x07,  0xe0,  0x07,  0xc0,  0x03,  0x80,  0x01,
939         };
940
941
942         static BCursor NSEWScrollCursor = {
943                 /*small*/
944                 nsewscroll_sbm, nsewscroll_smsk,
945                 16, 16,
946                 8, 8,
947                 /*big*/
948                 NULL, NULL,
949                 32, 32,
950                 15, 15,
951                 /*color*/
952                 BC_BLACK, BC_WHITE
953         };
954
955         BlenderCursor[BC_NSEW_SCROLLCURSOR] = &NSEWScrollCursor;
956
957 END_CURSOR_BLOCK
958
959
960 /********************** NS Scroll Cursor ***********************/
961 BEGIN_CURSOR_BLOCK
962
963         static char nsscroll_sbm[] = {
964                 0x00,  0x00,  0x80,  0x01,  0xc0,  0x03,  0xc0,  0x03,
965                 0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
966                 0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
967                 0xc0,  0x03,  0xc0,  0x03,  0x80,  0x01,  0x00,  0x00,
968         };
969
970         static char nsscroll_smsk[] = {
971                 0x80,  0x01,  0xc0,  0x03,  0xe0,  0x07,  0xe0,  0x07,
972                 0xc0,  0x03,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
973                 0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0xc0,  0x03,
974                 0xe0,  0x07,  0xe0,  0x07,  0xc0,  0x03,  0x80,  0x01,
975         };
976
977
978         static BCursor NSScrollCursor = {
979                 /*small*/
980                 nsscroll_sbm, nsscroll_smsk,
981                 16, 16,
982                 8, 8,
983                 /*big*/
984                 NULL, NULL,
985                 32, 32,
986                 15, 15,
987                 /*color*/
988                 BC_BLACK, BC_WHITE
989         };
990
991         BlenderCursor[BC_NS_SCROLLCURSOR] = &NSScrollCursor;
992
993 END_CURSOR_BLOCK
994
995
996 /********************** EW Scroll Cursor ***********************/
997 BEGIN_CURSOR_BLOCK
998
999         static char ewscroll_sbm[] = {
1000                 0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
1001                 0x00,  0x00,  0x00,  0x00,  0x0c,  0x30,  0x0e,  0x70,
1002                 0x0e,  0x70,  0x0c,  0x30,  0x00,  0x00,  0x00,  0x00,
1003                 0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
1004         };
1005
1006         static char ewscroll_smsk[] = {
1007                 0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
1008                 0x00,  0x00,  0x0c,  0x30,  0x1e,  0x78,  0x1f,  0xf8,
1009                 0x1f,  0xf8,  0x1e,  0x78,  0x0c,  0x30,  0x00,  0x00,
1010                 0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
1011         };
1012
1013
1014         static BCursor EWScrollCursor = {
1015                 /*small*/
1016                 ewscroll_sbm, ewscroll_smsk,
1017                 16, 16,
1018                 8, 8,
1019                 /*big*/
1020                 NULL, NULL,
1021                 32, 32,
1022                 15, 15,
1023                 /*color*/
1024                 BC_BLACK, BC_WHITE
1025         };
1026
1027         BlenderCursor[BC_EW_SCROLLCURSOR] = &EWScrollCursor;
1028
1029 END_CURSOR_BLOCK
1030
1031 /********************** Eyedropper Cursor ***********************/
1032 BEGIN_CURSOR_BLOCK
1033
1034         static char eyedropper_sbm[] = {
1035                 0x00,  0x30,  0x00,  0x48,  0x00,  0x85,  0x80,  0x82,
1036                 0x40,  0x40,  0x80,  0x20,  0x40,  0x11,  0xa0,  0x23,
1037                 0xd0,  0x15,  0xe8,  0x0a,  0x74,  0x01,  0xb4,  0x00,
1038                 0x4a,  0x00,  0x35,  0x00,  0x08,  0x00,  0x04,  0x00,
1039         };
1040
1041         static char eyedropper_smsk[] = {
1042                 0x00,  0x30,  0x00,  0x78,  0x00,  0xfd,  0x80,  0xff,
1043                 0xc0,  0x7f,  0x80,  0x3f,  0xc0,  0x1f,  0xe0,  0x3f,
1044                 0xf0,  0x1f,  0xf8,  0x0b,  0xfc,  0x01,  0xfc,  0x00,
1045                 0x7e,  0x00,  0x3f,  0x00,  0x0c,  0x00,  0x04,  0x00,
1046         };
1047
1048         
1049         static BCursor EyedropperCursor = {
1050                 /*small*/
1051                 eyedropper_sbm, eyedropper_smsk,
1052                 16, 16,
1053                 1, 15,
1054                 /*big*/
1055                 NULL, NULL,
1056                 32, 32,
1057                 15, 15,
1058                 /*color*/
1059                 BC_BLACK, BC_WHITE
1060         };
1061
1062         BlenderCursor[BC_EYEDROPPER_CURSOR] = &EyedropperCursor;
1063
1064 END_CURSOR_BLOCK
1065
1066 /********************** Swap Area Cursor ***********************/
1067 BEGIN_CURSOR_BLOCK
1068         static char swap_sbm[] = {
1069                 0xc0,  0xff,  0x40,  0x80,  0x40,  0x80,  0x40,  0x9c,
1070                 0x40,  0x98,  0x40,  0x94,  0x00,  0x82,  0xfe,  0x80,
1071                 0x7e,  0xfd,  0xbe,  0x01,  0xda,  0x01,  0xe2,  0x01,
1072                 0xe2,  0x01,  0xc2,  0x01,  0xfe,  0x01,  0x00,  0x00,
1073         };
1074
1075         static char swap_smsk[] = {
1076                 0xc0,  0xff,  0xc0,  0xff,  0xc0,  0xff,  0xc0,  0xff,
1077                 0xc0,  0xff,  0xc0,  0xff,  0xff,  0xff,  0xff,  0xff,
1078                 0xff,  0xff,  0xff,  0x03,  0xff,  0x03,  0xff,  0x03,
1079                 0xff,  0x03,  0xff,  0x03,  0xff,  0x03,  0xff,  0x03,
1080         };
1081
1082         static BCursor SwapCursor = {
1083                 /*small*/
1084                 swap_sbm, swap_smsk,
1085                 16, 16,
1086                 8,  8,
1087                 /*big*/
1088                 NULL, NULL,
1089                 32, 32,
1090                 15, 15,
1091                 /*color*/
1092                 BC_YELLOW, BC_BLUE
1093         };
1094
1095         BlenderCursor[BC_SWAPAREA_CURSOR] = &SwapCursor;
1096
1097 END_CURSOR_BLOCK
1098 /********************** Put the cursors in the array ***********************/
1099
1100 }