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