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