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