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