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