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