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