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