Fix build error on Windows 32 bit.
[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                         /* Note: There is no tabletdata on Windows if no tablet device is connected. */
217                         if (win->eventstate->is_motion_absolute == false) {
218                                 GHOST_SetCursorGrab(win->ghostwin, mode, bounds, NULL);
219                         }
220
221                         win->grabcursor = mode;
222                 }
223         }
224 }
225
226 void WM_cursor_grab_disable(wmWindow *win, const int mouse_ungrab_xy[2])
227 {
228         if ((G.debug & G_DEBUG) == 0) {
229                 if (win && win->ghostwin) {
230                         if (mouse_ungrab_xy) {
231                                 int mouse_xy[2] = {mouse_ungrab_xy[0], mouse_ungrab_xy[1]};
232                                 wm_cursor_position_to_ghost(win, &mouse_xy[0], &mouse_xy[1]);
233                                 GHOST_SetCursorGrab(win->ghostwin, GHOST_kGrabDisable, NULL, mouse_xy);
234                         }
235                         else {
236                                 GHOST_SetCursorGrab(win->ghostwin, GHOST_kGrabDisable, NULL, NULL);
237                         }
238
239                         win->grabcursor = GHOST_kGrabDisable;
240                 }
241         }
242 }
243
244 static void wm_cursor_warp_relative(wmWindow *win, int x, int y)
245 {
246         /* note: don't use wmEvent coords because of continuous grab [#36409] */
247         int cx, cy;
248         wm_get_cursor_position(win, &cx, &cy);
249         WM_cursor_warp(win, cx + x, cy + y);
250 }
251
252 /* give it a modal keymap one day? */
253 bool wm_cursor_arrow_move(wmWindow *win, const wmEvent *event)
254 {
255         if (win && event->val == KM_PRESS) {
256                 if (event->type == UPARROWKEY) {
257                         wm_cursor_warp_relative(win, 0, 1);
258                         return 1;
259                 }
260                 else if (event->type == DOWNARROWKEY) {
261                         wm_cursor_warp_relative(win, 0, -1);
262                         return 1;
263                 }
264                 else if (event->type == LEFTARROWKEY) {
265                         wm_cursor_warp_relative(win, -1, 0);
266                         return 1;
267                 }
268                 else if (event->type == RIGHTARROWKEY) {
269                         wm_cursor_warp_relative(win, 1, 0);
270                         return 1;
271                 }
272         }
273         return 0;
274 }
275
276
277 /* afer this you can call restore too */
278 void WM_cursor_time(wmWindow *win, int nr)
279 {
280         /* 10 8x8 digits */
281         const char number_bitmaps[10][8] = {
282                 {0,  56,  68,  68,  68,  68,  68,  56},
283                 {0,  24,  16,  16,  16,  16,  16,  56},
284                 {0,  60,  66,  32,  16,   8,   4, 126},
285                 {0, 124,  32,  16,  56,  64,  66,  60},
286                 {0,  32,  48,  40,  36, 126,  32,  32},
287                 {0, 124,   4,  60,  64,  64,  68,  56},
288                 {0,  56,   4,   4,  60,  68,  68,  56},
289                 {0, 124,  64,  32,  16,   8,   8,   8},
290                 {0,  60,  66,  66,  60,  66,  66,  60},
291                 {0,  56,  68,  68, 120,  64,  68,  56}
292         };
293         unsigned char mask[16][2];
294         unsigned char bitmap[16][2] = {{0}};
295         int i, idx;
296         
297         if (win->lastcursor == 0)
298                 win->lastcursor = win->cursor;
299         
300         memset(&mask, 0xFF, sizeof(mask));
301         
302         /* print number bottom right justified */
303         for (idx = 3; nr && idx >= 0; idx--) {
304                 const char *digit = number_bitmaps[nr % 10];
305                 int x = idx % 2;
306                 int y = idx / 2;
307
308                 for (i = 0; i < 8; i++)
309                         bitmap[i + y * 8][x] = digit[i];
310                 nr /= 10;
311         }
312         
313         window_set_custom_cursor(win, mask, bitmap, 7, 7);
314 }
315
316
317 /**
318  * Custom Cursor Description
319  * =========================
320  *
321  * Each bit represents a pixel, so 1 byte = 8 pixels,
322  * the bytes go Left to Right. Top to bottom
323  * the bits in a byte go right to left
324  * (ie;  0x01, 0x80  represents a line of 16 pix with the first and last pix set.)
325  *
326  * - A 0 in the bitmap = bg_color, a 1 fg_color
327  * - a 0 in the mask   = transparent pix.
328  *
329  * Until 32x32 cursors are supported on all platforms, the size of the
330  * small cursors MUST be 16x16.
331  *
332  * Large cursors have a maximum size of 32x32.
333  *
334  * Other than that, the specified size of the cursors is just a guideline,
335  * However, the char array that defines the BM and MASK must be byte aligned.
336  * ie a 17x17 cursor needs 3 bytes (cols) * 17 bytes (rows)
337  * (3 bytes = 17 bits rounded up to nearest whole byte).  Pad extra bits
338  * in mask with 0's.
339  *
340  * Setting `big_bm = NULL` disables the large version of the cursor.
341  *
342  * ----
343  *
344  * There is a nice Python GUI utility that can be used for drawing cursors in
345  * this format in the Blender source distribution, in
346  * `./source/tools/utils/make_cursor_gui.py` .
347  *
348  * Start it with the command `python3 make_cursor_gui.py`
349  * It will copy its output to the console when you press 'Do it'.
350  */
351
352 /**
353  * Because defining a cursor mixes declarations and executable code
354  * each cursor needs it's own scoping block or it would be split up
355  * over several hundred lines of code.  To enforce/document this better
356  * I define 2 pretty brain-dead macros so it's obvious what the extra "[]"
357  * are for */
358
359 #define BEGIN_CURSOR_BLOCK {
360 #define END_CURSOR_BLOCK   }
361
362 void wm_init_cursor_data(void)
363 {
364         /********************** NW_ARROW Cursor **************************/
365 BEGIN_CURSOR_BLOCK
366         static char nw_sbm[] = {
367                 0x03,  0x00,  0x05,  0x00,  0x09,  0x00,  0x11,  0x00,
368                 0x21,  0x00,  0x41,  0x00,  0x81,  0x00,  0x01,  0x01,
369                 0x01,  0x02,  0xc1,  0x03,  0x49,  0x00,  0x8d,  0x00,
370                 0x8b,  0x00,  0x10,  0x01,  0x90,  0x01,  0x60,  0x00,
371         };
372
373         static char nw_smsk[] = {
374                 0x03,  0x00,  0x07,  0x00,  0x0f,  0x00,  0x1f,  0x00,
375                 0x3f,  0x00,  0x7f,  0x00,  0xff,  0x00,  0xff,  0x01,
376                 0xff,  0x03,  0xff,  0x03,  0x7f,  0x00,  0xff,  0x00,
377                 0xfb,  0x00,  0xf0,  0x01,  0xf0,  0x01,  0x60,  0x00,
378         };
379
380         static BCursor NWArrowCursor = {
381                 /*small*/
382                 nw_sbm, nw_smsk,
383                 16, 16,
384                 6,  7,
385                 /*big*/
386                 NULL, NULL,
387                 32, 32,
388                 15, 15,
389                 /*color*/
390                 BC_BLACK, BC_WHITE
391         };
392
393         BlenderCursor[BC_NW_ARROWCURSOR] = &NWArrowCursor;
394 END_CURSOR_BLOCK
395
396         ///********************** NS_ARROW Cursor *************************/
397 BEGIN_CURSOR_BLOCK
398         static char ns_sbm[] = {
399                 0x40,  0x01,  0x20,  0x02,  0x10,  0x04,  0x08,  0x08,
400                 0x04,  0x10,  0x3c,  0x1e,  0x20,  0x02,  0x20,  0x02,
401                 0x20,  0x02,  0x20,  0x02,  0x3c,  0x1e,  0x04,  0x10,
402                 0x08,  0x08,  0x10,  0x04,  0x20,  0x02,  0x40,  0x01
403         };
404
405         static char ns_smsk[] = {
406                 0xc0,  0x01,  0xe0,  0x03,  0xf0,  0x07,  0xf8,  0x0f,
407                 0xfc,  0x1f,  0xfc,  0x1f,  0xe0,  0x03,  0xe0,  0x03,
408                 0xe0,  0x03,  0xe0,  0x03,  0xfc,  0x1f,  0xfc,  0x1f,
409                 0xf8,  0x0f,  0xf0,  0x07,  0xe0,  0x03,  0xc0,  0x01
410         };
411
412         static BCursor NSArrowCursor = {
413                 /*small*/
414                 ns_sbm, ns_smsk,
415                 16, 16,
416                 6,  7,
417                 /*big*/
418                 NULL, NULL,
419                 32, 32,
420                 15, 15,
421                 /*color*/
422                 BC_BLACK, BC_WHITE
423         };
424
425         BlenderCursor[BC_NS_ARROWCURSOR] = &NSArrowCursor;
426                 
427 END_CURSOR_BLOCK
428         /********************** EW_ARROW Cursor *************************/
429 BEGIN_CURSOR_BLOCK
430         static char ew_sbm[] = {
431                 0x00,  0x00,  0x00,  0x00,  0x10,  0x08,  0x38,  0x1c,
432                 0x2c,  0x34,  0xe6,  0x67,  0x03,  0xc0,  0x01,  0x80,
433                 0x03,  0xc0,  0xe6,  0x67,  0x2c,  0x34,  0x38,  0x1c,
434                 0x10,  0x08,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
435         };
436
437         static char ew_smsk[] = {
438                 0x00,  0x00,  0x00,  0x00,  0x10,  0x08,  0x38,  0x1c,
439                 0x3c,  0x3c,  0xfe,  0x7f,  0xff,  0xff,  0xff,  0xff,
440                 0xff,  0xff,  0xfe,  0x7f,  0x3c,  0x3c,  0x38,  0x1c,
441                 0x10,  0x08,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
442         };
443
444         static BCursor EWArrowCursor = {
445                 /*small*/
446                 ew_sbm, ew_smsk,
447                 16, 16, 
448                 7,  6,
449                 /*big*/
450                 NULL, NULL,
451                 32, 32,
452                 15, 15,
453                 /*color*/
454                 BC_BLACK, BC_WHITE
455         };
456
457         BlenderCursor[BC_EW_ARROWCURSOR] = &EWArrowCursor;
458 END_CURSOR_BLOCK
459
460         /********************** Wait Cursor *****************************/
461 BEGIN_CURSOR_BLOCK
462         static char wait_sbm[] = {
463                 0xfe,  0x7f,  0x02,  0x40,  0x02,  0x40,  0x84,  0x21,
464                 0xc8,  0x13,  0xd0,  0x0b,  0xa0,  0x04,  0x20,  0x05,
465                 0xa0,  0x04,  0x10,  0x09,  0x88,  0x11,  0xc4,  0x23,
466                 0xe2,  0x47,  0xfa,  0x5f,  0x02,  0x40,  0xfe,  0x7f,
467         };
468
469         static char wait_smsk[] = {
470                 0xfe,  0x7f,  0xfe,  0x7f,  0x06,  0x60,  0x8c,  0x31,
471                 0xd8,  0x1b,  0xf0,  0x0f,  0xe0,  0x06,  0x60,  0x07,
472                 0xe0,  0x06,  0x30,  0x0d,  0x98,  0x19,  0xcc,  0x33,
473                 0xe6,  0x67,  0xfe,  0x7f,  0xfe,  0x7f,  0xfe,  0x7f,
474         };
475
476         static char wait_lbm[] = {
477                 0xfc,  0xff,  0xff,  0x3f,  0xfc,  0xff,  0xff,  0x3f,
478                 0x0c,  0x00,  0x00,  0x30,  0x0c,  0x00,  0x00,  0x30,
479                 0x0c,  0x00,  0x00,  0x30,  0x0c,  0x00,  0x00,  0x18,
480                 0x18,  0xc0,  0x03,  0x0c,  0x30,  0x20,  0x07,  0x06,
481                 0x60,  0xf0,  0x0f,  0x03,  0xc0,  0xd0,  0x8d,  0x01,
482                 0x80,  0x79,  0xcf,  0x00,  0x00,  0xf3,  0x67,  0x00,
483                 0x00,  0x66,  0x37,  0x00,  0x00,  0x8c,  0x33,  0x00,
484                 0x00,  0x0c,  0x32,  0x00,  0x00,  0xcc,  0x33,  0x00,
485                 0x00,  0x8c,  0x30,  0x00,  0x00,  0x46,  0x61,  0x00,
486                 0x00,  0x03,  0xc3,  0x00,  0x80,  0x01,  0x83,  0x01,
487                 0xc0,  0xc0,  0x03,  0x03,  0x60,  0xa0,  0x05,  0x06,
488                 0x30,  0xf0,  0x0f,  0x0c,  0x18,  0xf8,  0x1d,  0x18,
489                 0x0c,  0x5c,  0x3f,  0x30,  0x0c,  0xff,  0x5f,  0x30,
490                 0x0c,  0xf7,  0xfe,  0x31,  0xcc,  0xfb,  0x9f,  0x33,
491                 0x0c,  0x00,  0x00,  0x30,  0x0c,  0x00,  0x00,  0x30,
492                 0xfc,  0xff,  0xff,  0x3f,  0xfc,  0xff,  0xff,  0x3f,
493         };
494
495         static char wait_lmsk[] = {
496                 0xfc,  0xff,  0xff,  0x3f,  0xfc,  0xff,  0xff,  0x3f,
497                 0xfc,  0xff,  0xff,  0x3f,  0xfc,  0xff,  0xff,  0x3f,
498                 0x3c,  0x00,  0x00,  0x3c,  0x3c,  0x00,  0x00,  0x1e,
499                 0x78,  0xc0,  0x03,  0x0f,  0xf0,  0xa0,  0x87,  0x07,
500                 0xe0,  0xf1,  0xcf,  0x03,  0xc0,  0xf3,  0xef,  0x01,
501                 0x80,  0xff,  0xff,  0x00,  0x00,  0xff,  0x7f,  0x00,
502                 0x00,  0xfe,  0x3f,  0x00,  0x00,  0xfc,  0x3f,  0x00,
503                 0x00,  0x3c,  0x3f,  0x00,  0x00,  0xfc,  0x3f,  0x00,
504                 0x00,  0xbc,  0x3c,  0x00,  0x00,  0xde,  0x79,  0x00,
505                 0x00,  0x0f,  0xf3,  0x00,  0x80,  0x07,  0xe3,  0x01,
506                 0xc0,  0xc3,  0xc3,  0x03,  0xe0,  0xe1,  0x87,  0x07,
507                 0xf0,  0xf0,  0x0f,  0x0f,  0x78,  0xf8,  0x1f,  0x1e,
508                 0x3c,  0x7c,  0x3f,  0x3c,  0x3c,  0xff,  0x7f,  0x3c,
509                 0xbc,  0xff,  0xff,  0x3d,  0xfc,  0xfb,  0xbf,  0x3f,
510                 0xfc,  0xff,  0xff,  0x3f,  0xfc,  0xff,  0xff,  0x3f,
511                 0xfc,  0xff,  0xff,  0x3f,  0xfc,  0xff,  0xff,  0x3f,
512         };
513
514         static BCursor WaitCursor = {
515                 /*small*/
516                 wait_sbm, wait_smsk,
517                 16, 16, 
518                 7,  7,
519                 /*big*/
520                 wait_lbm, wait_lmsk,
521                 32, 32,
522                 15, 15,
523                 /*color*/
524                 BC_BLACK, BC_WHITE
525         };
526
527         BlenderCursor[BC_WAITCURSOR] = &WaitCursor;
528 END_CURSOR_BLOCK
529
530         /********************** Cross Cursor ***************************/
531 BEGIN_CURSOR_BLOCK
532         static char cross_sbm[] = {
533                 0x00,  0x00,  0x80,  0x01,  0x80,  0x01,  0x80,  0x01,
534                 0x80,  0x01,  0x80,  0x01,  0x80,  0x01,  0x7e,  0x7e,
535                 0x7e,  0x7e,  0x80,  0x01,  0x80,  0x01,  0x80,  0x01,
536                 0x80,  0x01,  0x80,  0x01,  0x80,  0x01,  0x00,  0x00,
537         };
538
539         static char cross_smsk[] = {
540                 0x80,  0x01,  0x80,  0x01,  0x80,  0x01,  0x80,  0x01,
541                 0x80,  0x01,  0x80,  0x01,  0xc0,  0x03,  0x7f,  0xfe,
542                 0x7f,  0xfe,  0xc0,  0x03,  0x80,  0x01,  0x80,  0x01,
543                 0x80,  0x01,  0x80,  0x01,  0x80,  0x01,  0x80,  0x01,
544         };
545         static char cross_lbm[] = {
546                 0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
547                 0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
548                 0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
549                 0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
550                 0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
551                 0x00,  0x80,  0x01,  0x00,  0x00,  0xc0,  0x03,  0x00,
552                 0x00,  0xc0,  0x03,  0x00,  0x00,  0x40,  0x02,  0x00,
553                 0x00,  0x78,  0x1e,  0x00,  0xfc,  0x1f,  0xf8,  0x3f,
554                 0xfc,  0x1f,  0xf8,  0x3f,  0x00,  0x78,  0x1e,  0x00,
555                 0x00,  0x40,  0x02,  0x00,  0x00,  0xc0,  0x03,  0x00,
556                 0x00,  0xc0,  0x03,  0x00,  0x00,  0x80,  0x01,  0x00,
557                 0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
558                 0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
559                 0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
560                 0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
561                 0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
562         };
563
564         static char cross_lmsk[] = {
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,  0x80,  0x01,  0x00,
570                 0x00,  0x80,  0x01,  0x00,  0x00,  0xc0,  0x03,  0x00,
571                 0x00,  0xe0,  0x07,  0x00,  0x00,  0x70,  0x0e,  0x00,
572                 0x00,  0x78,  0x1e,  0x00,  0xff,  0x1f,  0xf8,  0xff,
573                 0xff,  0x1f,  0xf8,  0xff,  0x00,  0x78,  0x1e,  0x00,
574                 0x00,  0x70,  0x0e,  0x00,  0x00,  0xe0,  0x07,  0x00,
575                 0x00,  0xc0,  0x03,  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,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
580                 0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
581         };
582
583         static BCursor CrossCursor = {
584                 /*small*/
585                 cross_sbm, cross_smsk,
586                 16, 16, 
587                 7,  7,
588                 /*big*/
589                 cross_lbm, cross_lmsk,
590                 32, 32,
591                 15, 15,
592                 /*color*/
593                 BC_BLACK, BC_WHITE
594         };
595
596         BlenderCursor[BC_CROSSCURSOR] = &CrossCursor;
597 END_CURSOR_BLOCK
598
599         /********************** EditCross Cursor ***********************/
600 BEGIN_CURSOR_BLOCK
601         static char editcross_sbm[] = {
602                 0x0e,  0x00,  0x11,  0x00,  0x1d,  0x00,  0x19,  0x03,
603                 0x1d,  0x03,  0x11,  0x03,  0x0e,  0x03,  0x00,  0x03,
604                 0xf8,  0x7c,  0xf8,  0x7c,  0x00,  0x03,  0x00,  0x03,
605                 0x00,  0x03,  0x00,  0x03,  0x00,  0x03,  0x00,  0x00,
606         };
607
608         static char editcross_smsk[] = {
609                 0x0e,  0x00,  0x1f,  0x00,  0x1f,  0x03,  0x1f,  0x03,
610                 0x1f,  0x03,  0x1f,  0x03,  0x0e,  0x03,  0x80,  0x07,
611                 0xfc,  0xfc,  0xfc,  0xfc,  0x80,  0x07,  0x00,  0x03,
612                 0x00,  0x03,  0x00,  0x03,  0x00,  0x03,  0x00,  0x03,
613         };
614
615         static BCursor EditCrossCursor = {
616                 /*small*/
617                 editcross_sbm, editcross_smsk,
618                 16, 16, 
619                 9,  8,
620                 /*big*/
621                 NULL, NULL,
622                 32, 32,
623                 15, 15,
624                 /*color*/
625                 BC_BLACK, BC_WHITE
626         };
627
628         BlenderCursor[BC_EDITCROSSCURSOR] = &EditCrossCursor;
629 END_CURSOR_BLOCK
630
631         /********************** Box Select *************************/
632 BEGIN_CURSOR_BLOCK
633         static char box_sbm[32] = {
634                 0x7f,  0x00,  0x41,  0x00,  0x41,  0x00,  0x41,  0x06,
635                 0x41,  0x06,  0x41,  0x06,  0x7f,  0x06,  0x00,  0x06,
636                 0xe0,  0x79,  0xe0,  0x79,  0x00,  0x06,  0x00,  0x06,
637                 0x00,  0x06,  0x00,  0x06,  0x00,  0x06,  0x00,  0x00,
638         };
639
640         static char box_smsk[32] = {
641                 0x7f,  0x00,  0x7f,  0x00,  0x63,  0x06,  0x63,  0x06,
642                 0x63,  0x06,  0x7f,  0x06,  0x7f,  0x06,  0x00,  0x0f,
643                 0xf0,  0xf9,  0xf0,  0xf9,  0x00,  0x0f,  0x00,  0x06,
644                 0x00,  0x06,  0x00,  0x06,  0x00,  0x06,  0x00,  0x06,
645
646         };
647
648         static BCursor BoxSelCursor = {
649                 /*small*/
650                 box_sbm, box_smsk,
651                 16, 16, 
652                 9,  8,
653                 /*big*/
654                 NULL, NULL,
655                 32, 32,
656                 15, 15,
657                 /*color*/
658                 BC_BLACK, BC_WHITE
659         };
660
661         BlenderCursor[BC_BOXSELCURSOR] = &BoxSelCursor;
662
663 END_CURSOR_BLOCK
664         /********************** Knife Cursor ***********************/
665 BEGIN_CURSOR_BLOCK
666         static char knife_sbm[] = {
667                 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x2c,
668                 0x00, 0x5a, 0x00, 0x34, 0x00, 0x2a, 0x00, 0x17,
669                 0x80, 0x06, 0x40, 0x03, 0xa0, 0x03, 0xd0, 0x01,
670                 0x68, 0x00, 0x1c, 0x00, 0x06, 0x00, 0x00, 0x00
671         };
672
673         static char knife_smsk[] = {
674                 0x00, 0x60, 0x00, 0xf0, 0x00, 0xfc, 0x00, 0xfe,
675                 0x00, 0xfe, 0x00, 0x7e, 0x00, 0x7f, 0x80, 0x3f,
676                 0xc0, 0x0e, 0x60, 0x07, 0xb0, 0x07, 0xd8, 0x03,
677                 0xec, 0x01, 0x7e, 0x00, 0x1f, 0x00, 0x07, 0x00
678         };
679
680         static char knife_lbm[] = {
681                 0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
682                 0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
683                 0x00,  0x00,  0x00,  0x08,  0x00,  0x00,  0x00,  0x1c,
684                 0x00,  0x00,  0x00,  0x3e,  0x00,  0x00,  0x00,  0x7f,
685                 0x00,  0x00,  0x80,  0xbf,  0x00,  0x00,  0xc0,  0x5f,
686                 0x00,  0x00,  0xc0,  0x6f,  0x00,  0x00,  0xc0,  0x37,
687                 0x00,  0x00,  0xa8,  0x1b,  0x00,  0x00,  0x54,  0x0d,
688                 0x00,  0x00,  0xa8,  0x00,  0x00,  0x00,  0x54,  0x00,
689                 0x00,  0x00,  0xa8,  0x00,  0x00,  0x00,  0x53,  0x00,
690                 0x00,  0xc0,  0x07,  0x00,  0x00,  0xe0,  0x0f,  0x00,
691                 0x00,  0xd0,  0x0f,  0x00,  0x00,  0xe8,  0x07,  0x00,
692                 0x00,  0xf4,  0x07,  0x00,  0x00,  0xfa,  0x00,  0x00,
693                 0x00,  0x3d,  0x00,  0x00,  0x80,  0x0e,  0x00,  0x00,
694                 0xc0,  0x03,  0x00,  0x00,  0xe0,  0x00,  0x00,  0x00,
695                 0x30,  0x00,  0x00,  0x00,  0x08,  0x00,  0x00,  0x00,
696                 0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
697
698         };
699
700         static char knife_lmsk[] = {
701                 0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
702                 0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x18,
703                 0x00,  0x00,  0x00,  0x3c,  0x00,  0x00,  0x00,  0x7e,
704                 0x00,  0x00,  0x00,  0xff,  0x00,  0x00,  0x80,  0xff,
705                 0x00,  0x00,  0xc0,  0xbf,  0x00,  0x00,  0xe0,  0xdf,
706                 0x00,  0x00,  0xe0,  0xef,  0x00,  0x00,  0xf8,  0x77,
707                 0x00,  0x00,  0xfc,  0x3b,  0x00,  0x00,  0xfe,  0x1d,
708                 0x00,  0x00,  0xfe,  0x0f,  0x00,  0x00,  0xfe,  0x01,
709                 0x00,  0x00,  0xff,  0x01,  0x00,  0xc0,  0xff,  0x00,
710                 0x00,  0xe0,  0x7f,  0x00,  0x00,  0xf0,  0x1f,  0x00,
711                 0x00,  0xd8,  0x1f,  0x00,  0x00,  0xec,  0x0f,  0x00,
712                 0x00,  0xf6,  0x0f,  0x00,  0x00,  0xfb,  0x06,  0x00,
713                 0x80,  0xbd,  0x01,  0x00,  0xc0,  0x6e,  0x00,  0x00,
714                 0xe0,  0x1b,  0x00,  0x00,  0xf0,  0x06,  0x00,  0x00,
715                 0xb8,  0x01,  0x00,  0x00,  0x6c,  0x00,  0x00,  0x00,
716                 0x1c,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
717
718         };
719
720         static BCursor KnifeCursor = {
721                 /*small*/
722                 knife_sbm, knife_smsk,
723                 16, 16, 
724                 0,  15,
725                 /*big*/
726                 knife_lbm, knife_lmsk,
727                 32, 32,
728                 0, 31,
729                 /*color*/
730                 BC_BLACK, BC_WHITE
731         };
732
733         BlenderCursor[BC_KNIFECURSOR] = &KnifeCursor;
734
735 END_CURSOR_BLOCK
736         
737         /********************** Loop Select Cursor ***********************/
738 BEGIN_CURSOR_BLOCK
739
740         static char vloop_sbm[] = {
741                 0x00,  0x00,  0x7e,  0x00,  0x3e,  0x00,  0x1e,  0x00,
742                 0x0e,  0x00,  0x66,  0x60,  0x62,  0x6f,  0x00,  0x00,
743                 0x20,  0x20,  0x20,  0x20,  0x20,  0x20,  0x20,  0x20,
744                 0x00,  0x00,  0x60,  0x60,  0x60,  0x6f,  0x00,  0x00,
745         };
746
747         static char vloop_smsk[] = {
748                 0xff,  0x01,  0xff,  0x00,  0x7f,  0x00,  0x3f,  0x00,
749                 0xff,  0xf0,  0xff,  0xff,  0xf7,  0xff,  0xf3,  0xf0,
750                 0x61,  0x60,  0x60,  0x60,  0x60,  0x60,  0x60,  0x60,
751                 0xf0,  0xf0,  0xf0,  0xff,  0xf0,  0xff,  0xf0,  0xf0,
752         };
753
754
755
756         static char vloop_lbm[] = {
757                 0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
758                 0xfc,  0x3f,  0x00,  0x00,  0xfc,  0x3f,  0x00,  0x00,
759                 0xfc,  0x0f,  0x00,  0x00,  0xfc,  0x0f,  0x00,  0x00,
760                 0xfc,  0x03,  0x00,  0x00,  0xfc,  0x03,  0x00,  0x00,
761                 0xfc,  0x00,  0x00,  0x00,  0xfc,  0x00,  0x00,  0x00,
762                 0x3c,  0x3c,  0x00,  0x3c,  0x3c,  0x3c,  0x00,  0x3c,
763                 0x0c,  0x3c,  0xff,  0x3c,  0x0c,  0x3c,  0xff,  0x3c,
764                 0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
765                 0x00,  0x0c,  0x00,  0x0c,  0x00,  0x0c,  0x00,  0x0c,
766                 0x00,  0x0c,  0x00,  0x0c,  0x00,  0x0c,  0x00,  0x0c,
767                 0x00,  0x0c,  0x00,  0x0c,  0x00,  0x0c,  0x00,  0x0c,
768                 0x00,  0x0c,  0x00,  0x0c,  0x00,  0x0c,  0x00,  0x0c,
769                 0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
770                 0x00,  0x3c,  0x00,  0x3c,  0x00,  0x3c,  0x00,  0x3c,
771                 0x00,  0x3c,  0xff,  0x3c,  0x00,  0x3c,  0xff,  0x3c,
772                 0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
773         };
774
775         static char vloop_lmsk[] = {
776                 0xff,  0xff,  0x03,  0x00,  0xff,  0xff,  0x03,  0x00,
777                 0xff,  0xff,  0x00,  0x00,  0xff,  0xff,  0x00,  0x00,
778                 0xff,  0x3f,  0x00,  0x00,  0xff,  0x3f,  0x00,  0x00,
779                 0xff,  0x0f,  0x00,  0x00,  0xff,  0x0f,  0x00,  0x00,
780                 0xff,  0xff,  0x00,  0xff,  0xff,  0xff,  0x00,  0xff,
781                 0xff,  0xff,  0xff,  0xff,  0xff,  0xff,  0xff,  0xff,
782                 0x3f,  0xff,  0xff,  0xff,  0x3f,  0xff,  0xff,  0xff,
783                 0x0f,  0xff,  0x00,  0xff,  0x0f,  0xff,  0x00,  0xff,
784                 0x03,  0x3c,  0x00,  0x3c,  0x03,  0x3c,  0x00,  0x3c,
785                 0x00,  0x3c,  0x00,  0x3c,  0x00,  0x3c,  0x00,  0x3c,
786                 0x00,  0x3c,  0x00,  0x3c,  0x00,  0x3c,  0x00,  0x3c,
787                 0x00,  0x3c,  0x00,  0x3c,  0x00,  0x3c,  0x00,  0x3c,
788                 0x00,  0xff,  0x00,  0xff,  0x00,  0xff,  0x00,  0xff,
789                 0x00,  0xff,  0xff,  0xff,  0x00,  0xff,  0xff,  0xff,
790                 0x00,  0xff,  0xff,  0xff,  0x00,  0xff,  0xff,  0xff,
791                 0x00,  0xff,  0x00,  0xff,  0x00,  0xff,  0x00,  0xff,
792         };
793
794
795
796         static BCursor VLoopCursor = {
797                 /*small*/
798                 vloop_sbm, vloop_smsk,
799                 16, 16, 
800                 0,  0,
801                 /*big*/
802                 vloop_lbm, vloop_lmsk,
803                 32, 32,
804                 0, 0,
805                 /*color*/
806                 BC_BLACK, BC_WHITE
807         };
808
809         BlenderCursor[BC_VLOOPCURSOR] = &VLoopCursor;
810
811 END_CURSOR_BLOCK
812         
813
814         /********************** TextEdit Cursor ***********************/
815 BEGIN_CURSOR_BLOCK
816         static char textedit_sbm[] = {
817                 0xe0,  0x03,  0x10,  0x04,  0x60,  0x03,  0x40,  0x01,
818                 0x40,  0x01,  0x40,  0x01,  0x40,  0x01,  0x40,  0x01,
819                 0x40,  0x01,  0x40,  0x01,  0x40,  0x01,  0x40,  0x01,
820                 0x40,  0x01,  0x60,  0x03,  0x10,  0x04,  0xe0,  0x03,
821         };
822
823         static char textedit_smsk[] = {
824                 0xe0,  0x03,  0xf0,  0x07,  0xe0,  0x03,  0xc0,  0x01,
825                 0xc0,  0x01,  0xc0,  0x01,  0xc0,  0x01,  0xc0,  0x01,
826                 0xc0,  0x01,  0xc0,  0x01,  0xc0,  0x01,  0xc0,  0x01,
827                 0xc0,  0x01,  0xe0,  0x03,  0xf0,  0x07,  0xe0,  0x03,
828         };
829
830         static BCursor TextEditCursor = {
831                 /*small*/
832                 textedit_sbm, textedit_smsk,
833                 16, 16, 
834                 9,  8,
835                 /*big*/
836                 NULL, NULL,
837                 32, 32,
838                 15, 15,
839                 /*color*/
840                 BC_BLACK, BC_WHITE
841         };
842
843         BlenderCursor[BC_TEXTEDITCURSOR] = &TextEditCursor;
844 END_CURSOR_BLOCK
845
846
847         /********************** Paintbrush Cursor ***********************/
848 BEGIN_CURSOR_BLOCK
849         static char paintbrush_sbm[] = {
850
851                 0x00,  0xe0,  0x00,  0x98,  0x00,  0x44,  0x00,  0x42,
852                 0x00,  0x21,  0x80,  0x20,  0x40,  0x13,  0x40,  0x17,
853                 0xa0,  0x0b,  0x98,  0x05,  0x04,  0x02,  0x02,  0x01,
854                 0x02,  0x01,  0x02,  0x01,  0x81,  0x00,  0x7f,  0x00,
855
856
857
858         };
859
860         static char paintbrush_smsk[] = {
861                 0x00,  0xe0,  0x00,  0xf8,  0x00,  0x7c,  0x00,  0x7e,
862                 0x00,  0x3f,  0x80,  0x3f,  0xc0,  0x1f,  0xc0,  0x1f,
863                 0xe0,  0x0f,  0xf8,  0x07,  0xfc,  0x03,  0xfe,  0x01,
864                 0xfe,  0x01,  0xfe,  0x01,  0xff,  0x00,  0x7f,  0x00,
865
866
867         };
868
869         static BCursor PaintBrushCursor = {
870                 /*small*/
871                 paintbrush_sbm, paintbrush_smsk,
872                 16, 16, 
873                 0,  15,
874                 /*big*/
875                 NULL, NULL,
876                 32, 32,
877                 15, 15,
878                 /*color*/
879                 BC_BLACK, BC_WHITE
880         };
881
882         BlenderCursor[BC_PAINTBRUSHCURSOR] = &PaintBrushCursor;
883 END_CURSOR_BLOCK
884
885
886 /********************** Hand Cursor ***********************/
887 BEGIN_CURSOR_BLOCK
888
889         static char hand_sbm[] = {
890                 0x00,  0x00,  0x00,  0x00,  0x80,  0x01,  0x80,  0x0d,
891                 0x98,  0x6d,  0x98,  0x6d,  0xb0,  0x6d,  0xb0,  0x6d,
892                 0xe0,  0x6f,  0xe6,  0x7f,  0xee,  0x7f,  0xfc,  0x3f,
893                 0xf8,  0x3f,  0xf0,  0x1f,  0xc0,  0x1f,  0xc0,  0x1f,
894         };
895
896         static char hand_smsk[] = {
897                 0x00,  0x00,  0x80,  0x01,  0xc0,  0x0f,  0xd8,  0x7f,
898                 0xfc,  0xff,  0xfc,  0xff,  0xf8,  0xff,  0xf8,  0xff,
899                 0xf6,  0xff,  0xff,  0xff,  0xff,  0xff,  0xfe,  0x7f,
900                 0xfc,  0x7f,  0xf8,  0x3f,  0xf0,  0x3f,  0xe0,  0x3f,
901         };
902
903
904         static BCursor HandCursor = {
905                 /*small*/
906                 hand_sbm, hand_smsk,
907                 16, 16,
908                 8,  8,
909                 /*big*/
910                 NULL, NULL,
911                 32, 32,
912                 15, 15,
913                 /*color*/
914                 BC_BLACK, BC_WHITE
915         };
916
917         BlenderCursor[BC_HANDCURSOR] = &HandCursor;
918
919 END_CURSOR_BLOCK
920
921 /********************** NSEW Scroll Cursor ***********************/
922 BEGIN_CURSOR_BLOCK
923
924         static char nsewscroll_sbm[] = {
925                 0x00,  0x00,  0x80,  0x01,  0xc0,  0x03,  0xc0,  0x03,
926                 0x00,  0x00,  0x00,  0x00,  0x0c,  0x30,  0x0e,  0x70,
927                 0x0e,  0x70,  0x0c,  0x30,  0x00,  0x00,  0x00,  0x00,
928                 0xc0,  0x03,  0xc0,  0x03,  0x80,  0x01,  0x00,  0x00,
929         };
930
931         static char nsewscroll_smsk[] = {
932                 0x80,  0x01,  0xc0,  0x03,  0xe0,  0x07,  0xe0,  0x07,
933                 0xc0,  0x03,  0x0c,  0x30,  0x1e,  0x78,  0x1f,  0xf8,
934                 0x1f,  0xf8,  0x1e,  0x78,  0x0c,  0x30,  0xc0,  0x03,
935                 0xe0,  0x07,  0xe0,  0x07,  0xc0,  0x03,  0x80,  0x01,
936         };
937
938
939         static BCursor NSEWScrollCursor = {
940                 /*small*/
941                 nsewscroll_sbm, nsewscroll_smsk,
942                 16, 16,
943                 8, 8,
944                 /*big*/
945                 NULL, NULL,
946                 32, 32,
947                 15, 15,
948                 /*color*/
949                 BC_BLACK, BC_WHITE
950         };
951
952         BlenderCursor[BC_NSEW_SCROLLCURSOR] = &NSEWScrollCursor;
953
954 END_CURSOR_BLOCK
955
956
957 /********************** NS Scroll Cursor ***********************/
958 BEGIN_CURSOR_BLOCK
959
960         static char nsscroll_sbm[] = {
961                 0x00,  0x00,  0x80,  0x01,  0xc0,  0x03,  0xc0,  0x03,
962                 0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
963                 0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
964                 0xc0,  0x03,  0xc0,  0x03,  0x80,  0x01,  0x00,  0x00,
965         };
966
967         static char nsscroll_smsk[] = {
968                 0x80,  0x01,  0xc0,  0x03,  0xe0,  0x07,  0xe0,  0x07,
969                 0xc0,  0x03,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
970                 0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0xc0,  0x03,
971                 0xe0,  0x07,  0xe0,  0x07,  0xc0,  0x03,  0x80,  0x01,
972         };
973
974
975         static BCursor NSScrollCursor = {
976                 /*small*/
977                 nsscroll_sbm, nsscroll_smsk,
978                 16, 16,
979                 8, 8,
980                 /*big*/
981                 NULL, NULL,
982                 32, 32,
983                 15, 15,
984                 /*color*/
985                 BC_BLACK, BC_WHITE
986         };
987
988         BlenderCursor[BC_NS_SCROLLCURSOR] = &NSScrollCursor;
989
990 END_CURSOR_BLOCK
991
992
993 /********************** EW Scroll Cursor ***********************/
994 BEGIN_CURSOR_BLOCK
995
996         static char ewscroll_sbm[] = {
997                 0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
998                 0x00,  0x00,  0x00,  0x00,  0x0c,  0x30,  0x0e,  0x70,
999                 0x0e,  0x70,  0x0c,  0x30,  0x00,  0x00,  0x00,  0x00,
1000                 0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
1001         };
1002
1003         static char ewscroll_smsk[] = {
1004                 0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
1005                 0x00,  0x00,  0x0c,  0x30,  0x1e,  0x78,  0x1f,  0xf8,
1006                 0x1f,  0xf8,  0x1e,  0x78,  0x0c,  0x30,  0x00,  0x00,
1007                 0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
1008         };
1009
1010
1011         static BCursor EWScrollCursor = {
1012                 /*small*/
1013                 ewscroll_sbm, ewscroll_smsk,
1014                 16, 16,
1015                 8, 8,
1016                 /*big*/
1017                 NULL, NULL,
1018                 32, 32,
1019                 15, 15,
1020                 /*color*/
1021                 BC_BLACK, BC_WHITE
1022         };
1023
1024         BlenderCursor[BC_EW_SCROLLCURSOR] = &EWScrollCursor;
1025
1026 END_CURSOR_BLOCK
1027
1028 /********************** Eyedropper Cursor ***********************/
1029 BEGIN_CURSOR_BLOCK
1030
1031         static char eyedropper_sbm[] = {
1032                 0x00,  0x30,  0x00,  0x48,  0x00,  0x85,  0x80,  0x82,
1033                 0x40,  0x40,  0x80,  0x20,  0x40,  0x11,  0xa0,  0x23,
1034                 0xd0,  0x15,  0xe8,  0x0a,  0x74,  0x01,  0xb4,  0x00,
1035                 0x4a,  0x00,  0x35,  0x00,  0x08,  0x00,  0x04,  0x00,
1036         };
1037
1038         static char eyedropper_smsk[] = {
1039                 0x00,  0x30,  0x00,  0x78,  0x00,  0xfd,  0x80,  0xff,
1040                 0xc0,  0x7f,  0x80,  0x3f,  0xc0,  0x1f,  0xe0,  0x3f,
1041                 0xf0,  0x1f,  0xf8,  0x0b,  0xfc,  0x01,  0xfc,  0x00,
1042                 0x7e,  0x00,  0x3f,  0x00,  0x0c,  0x00,  0x04,  0x00,
1043         };
1044
1045         
1046         static BCursor EyedropperCursor = {
1047                 /*small*/
1048                 eyedropper_sbm, eyedropper_smsk,
1049                 16, 16,
1050                 1, 15,
1051                 /*big*/
1052                 NULL, NULL,
1053                 32, 32,
1054                 15, 15,
1055                 /*color*/
1056                 BC_BLACK, BC_WHITE
1057         };
1058
1059         BlenderCursor[BC_EYEDROPPER_CURSOR] = &EyedropperCursor;
1060
1061 END_CURSOR_BLOCK
1062
1063 /********************** Swap Area Cursor ***********************/
1064 BEGIN_CURSOR_BLOCK
1065         static char swap_sbm[] = {
1066                 0xc0,  0xff,  0x40,  0x80,  0x40,  0x80,  0x40,  0x9c,
1067                 0x40,  0x98,  0x40,  0x94,  0x00,  0x82,  0xfe,  0x80,
1068                 0x7e,  0xfd,  0xbe,  0x01,  0xda,  0x01,  0xe2,  0x01,
1069                 0xe2,  0x01,  0xc2,  0x01,  0xfe,  0x01,  0x00,  0x00,
1070         };
1071
1072         static char swap_smsk[] = {
1073                 0xc0,  0xff,  0xc0,  0xff,  0xc0,  0xff,  0xc0,  0xff,
1074                 0xc0,  0xff,  0xc0,  0xff,  0xff,  0xff,  0xff,  0xff,
1075                 0xff,  0xff,  0xff,  0x03,  0xff,  0x03,  0xff,  0x03,
1076                 0xff,  0x03,  0xff,  0x03,  0xff,  0x03,  0xff,  0x03,
1077         };
1078
1079         static BCursor SwapCursor = {
1080                 /*small*/
1081                 swap_sbm, swap_smsk,
1082                 16, 16,
1083                 8,  8,
1084                 /*big*/
1085                 NULL, NULL,
1086                 32, 32,
1087                 15, 15,
1088                 /*color*/
1089                 BC_YELLOW, BC_BLUE
1090         };
1091
1092         BlenderCursor[BC_SWAPAREA_CURSOR] = &SwapCursor;
1093
1094 END_CURSOR_BLOCK
1095 /********************** Put the cursors in the array ***********************/
1096
1097 }