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