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