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