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