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