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