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