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