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