== interface ==
[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 /* Because defining a cursor mixes declarations and executable code
77    each cursor needs it's own scoping block or it would be split up 
78    over several hundred lines of code.  To enforce/document this better
79    I define 2 pretty braindead macros so it's obvious what the extra "[]"
80    are for */
81
82 #define BEGIN_CURSOR_BLOCK {
83 #define END_CURSOR_BLOCK   }
84
85 /* Cursor Globals */
86 static BCursor *BlenderCursor[BC_NUMCURSORS]; /*Points to static BCursor Structs */
87 static short CurrentCursor=-1, LastCursor=-1;
88
89 short GetBlenderCursor(void) {
90         return CurrentCursor;
91 }
92
93 void SetBlenderCursor(short curs){
94         Window *win;
95
96         if ((curs<LASTCURSOR)||(curs>=BC_NUMCURSORS)) return;
97
98         win=winlay_get_active_window();
99
100         if (win==NULL) return; /* Can't set custom cursor before Window init */ 
101
102         LastCursor=CurrentCursor;
103         CurrentCursor=curs;
104
105         if (curs==LASTCURSOR) curs=LastCursor;
106
107         if (curs==SYSCURSOR) {  /* System default Cursor */
108                 window_set_cursor(win, CURSOR_STD);
109                 //set_cursor(CURSOR_STD);
110         }
111         else if ( (U.curssize==0) || (BlenderCursor[curs]->big_bm == NULL) ) {
112                 window_set_custom_cursor_ex(win, BlenderCursor[curs], 0);
113         }
114         else {
115                 window_set_custom_cursor_ex(win, BlenderCursor[curs], 1);
116         }
117 }
118
119 /* unused no prototypes 
120 short GetCurrentCursor(void){
121         return(CurrentCursor);
122 }
123 */
124
125 void InitCursorData(void){
126
127         /********************** NW_ARROW Cursor **************************/
128 BEGIN_CURSOR_BLOCK
129                 static char nw_sbm[]={
130                         0x03,  0x00,  0x05,  0x00,  0x09,  0x00,  0x11,  0x00,
131                                 0x21,  0x00,  0x41,  0x00,  0x81,  0x00,  0x01,  0x01,
132                                 0x01,  0x02,  0xc1,  0x03,  0x49,  0x00,  0x8d,  0x00,
133                                 0x8b,  0x00,  0x10,  0x01,  0x90,  0x01,  0x60,  0x00,
134                 };
135
136                 static char nw_smsk[]={
137                         0x03,  0x00,  0x07,  0x00,  0x0f,  0x00,  0x1f,  0x00,
138                                 0x3f,  0x00,  0x7f,  0x00,  0xff,  0x00,  0xff,  0x01,
139                                 0xff,  0x03,  0xff,  0x03,  0x7f,  0x00,  0xff,  0x00,
140                                 0xfb,  0x00,  0xf0,  0x01,  0xf0,  0x01,  0x60,  0x00,
141                 };
142
143                 static BCursor NWArrowCursor = {
144                         /*small*/
145                         nw_sbm, nw_smsk,
146                                 16, 16, 
147                                 6,  7,
148                                 /*big*/
149                                 NULL, NULL,
150                                 32,32, 
151                                 15, 15,
152                                 /*color*/
153                                 BC_BLACK, BC_WHITE
154                 };
155
156                 BlenderCursor[BC_NW_ARROWCURSOR]=&NWArrowCursor;
157 END_CURSOR_BLOCK
158
159         ///********************** NS_ARROW Cursor *************************/
160 BEGIN_CURSOR_BLOCK
161                 static char ns_sbm[]={
162                         0x40,  0x01,  0x20,  0x02,  0x10,  0x04,  0x08,  0x08,
163                                 0x04,  0x10,  0x3c,  0x1e,  0x20,  0x02,  0x20,  0x02,
164                                 0x20,  0x02,  0x20,  0x02,  0x3c,  0x1e,  0x04,  0x10,
165                                 0x08,  0x08,  0x10,  0x04,  0x20,  0x02,  0x40,  0x01
166                 };
167
168                 static char ns_smsk[]={
169                         0xc0,  0x01,  0xe0,  0x03,  0xf0,  0x07,  0xf8,  0x0f,
170                                 0xfc,  0x1f,  0xfc,  0x1f,  0xe0,  0x03,  0xe0,  0x03,
171                                 0xe0,  0x03,  0xe0,  0x03,  0xfc,  0x1f,  0xfc,  0x1f,
172                                 0xf8,  0x0f,  0xf0,  0x07,  0xe0,  0x03,  0xc0,  0x01
173                 };
174
175                 static BCursor NSArrowCursor = {
176                         /*small*/
177                         ns_sbm, ns_smsk,
178                                 16, 16, 
179                                 6,  7,
180                                 /*big*/
181                                 NULL, NULL,
182                                 32,32, 
183                                 15, 15,
184                                 /*color*/
185                                 BC_BLACK, BC_WHITE
186                 };
187
188                 BlenderCursor[BC_NS_ARROWCURSOR]=&NSArrowCursor;
189                 
190 END_CURSOR_BLOCK
191         /********************** EW_ARROW Cursor *************************/
192 BEGIN_CURSOR_BLOCK
193         static char ew_sbm[]={
194                 0x00,  0x00,  0x00,  0x00,  0x10,  0x08,  0x38,  0x1c,
195                 0x2c,  0x34,  0xe6,  0x67,  0x03,  0xc0,  0x01,  0x80,
196                 0x03,  0xc0,  0xe6,  0x67,  0x2c,  0x34,  0x38,  0x1c,
197                 0x10,  0x08,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
198         };
199
200         static char ew_smsk[]={
201                 0x00,  0x00,  0x00,  0x00,  0x10,  0x08,  0x38,  0x1c,
202                 0x3c,  0x3c,  0xfe,  0x7f,  0xff,  0xff,  0x3f,  0xfc,
203                 0xff,  0xff,  0xfe,  0x7f,  0x3c,  0x3c,  0x38,  0x1c,
204                 0x10,  0x08,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
205         };
206
207         static BCursor EWArrowCursor = {
208                 /*small*/
209                 ew_sbm, ew_smsk,
210                 16, 16, 
211                 7,  6,
212                 /*big*/
213                 NULL, NULL,
214                 32,32, 
215                 15, 15,
216                 /*color*/
217                 BC_BLACK, BC_WHITE
218         };
219
220         BlenderCursor[BC_EW_ARROWCURSOR]=&EWArrowCursor;
221 END_CURSOR_BLOCK
222
223         /********************** Wait Cursor *****************************/
224 BEGIN_CURSOR_BLOCK
225         static char wait_sbm[]={
226                 0xfe,  0x7f,  0x02,  0x40,  0x02,  0x40,  0x84,  0x21,
227                 0xc8,  0x13,  0xd0,  0x0b,  0xa0,  0x04,  0x20,  0x05,
228                 0xa0,  0x04,  0x10,  0x09,  0x88,  0x11,  0xc4,  0x23,
229                 0xe2,  0x47,  0xfa,  0x5f,  0x02,  0x40,  0xfe,  0x7f,
230         };
231
232         static char wait_smsk[]={
233                 0xfe,  0x7f,  0xfe,  0x7f,  0x06,  0x60,  0x8c,  0x31,
234                 0xd8,  0x1b,  0xf0,  0x0f,  0xe0,  0x06,  0x60,  0x07,
235                 0xe0,  0x06,  0x30,  0x0d,  0x98,  0x19,  0xcc,  0x33,
236                 0xe6,  0x67,  0xfe,  0x7f,  0xfe,  0x7f,  0xfe,  0x7f,
237         };
238
239         static char wait_lbm[]={
240                 0xfc,  0xff,  0xff,  0x3f,  0xfc,  0xff,  0xff,  0x3f,
241                 0x0c,  0x00,  0x00,  0x30,  0x0c,  0x00,  0x00,  0x30,
242                 0x0c,  0x00,  0x00,  0x30,  0x0c,  0x00,  0x00,  0x18,
243                 0x18,  0xc0,  0x03,  0x0c,  0x30,  0x20,  0x07,  0x06,
244                 0x60,  0xf0,  0x0f,  0x03,  0xc0,  0xd0,  0x8d,  0x01,
245                 0x80,  0x79,  0xcf,  0x00,  0x00,  0xf3,  0x67,  0x00,
246                 0x00,  0x66,  0x37,  0x00,  0x00,  0x8c,  0x33,  0x00,
247                 0x00,  0x0c,  0x32,  0x00,  0x00,  0xcc,  0x33,  0x00,
248                 0x00,  0x8c,  0x30,  0x00,  0x00,  0x46,  0x61,  0x00,
249                 0x00,  0x03,  0xc3,  0x00,  0x80,  0x01,  0x83,  0x01,
250                 0xc0,  0xc0,  0x03,  0x03,  0x60,  0xa0,  0x05,  0x06,
251                 0x30,  0xf0,  0x0f,  0x0c,  0x18,  0xf8,  0x1d,  0x18,
252                 0x0c,  0x5c,  0x3f,  0x30,  0x0c,  0xff,  0x5f,  0x30,
253                 0x0c,  0xf7,  0xfe,  0x31,  0xcc,  0xfb,  0x9f,  0x33,
254                 0x0c,  0x00,  0x00,  0x30,  0x0c,  0x00,  0x00,  0x30,
255                 0xfc,  0xff,  0xff,  0x3f,  0xfc,  0xff,  0xff,  0x3f,
256         };
257
258         static char wait_lmsk[]={
259                 0xfc,  0xff,  0xff,  0x3f,  0xfc,  0xff,  0xff,  0x3f,
260                 0xfc,  0xff,  0xff,  0x3f,  0xfc,  0xff,  0xff,  0x3f,
261                 0x3c,  0x00,  0x00,  0x3c,  0x3c,  0x00,  0x00,  0x1e,
262                 0x78,  0xc0,  0x03,  0x0f,  0xf0,  0xa0,  0x87,  0x07,
263                 0xe0,  0xf1,  0xcf,  0x03,  0xc0,  0xf3,  0xef,  0x01,
264                 0x80,  0xff,  0xff,  0x00,  0x00,  0xff,  0x7f,  0x00,
265                 0x00,  0xfe,  0x3f,  0x00,  0x00,  0xfc,  0x3f,  0x00,
266                 0x00,  0x3c,  0x3f,  0x00,  0x00,  0xfc,  0x3f,  0x00,
267                 0x00,  0xbc,  0x3c,  0x00,  0x00,  0xde,  0x79,  0x00,
268                 0x00,  0x0f,  0xf3,  0x00,  0x80,  0x07,  0xe3,  0x01,
269                 0xc0,  0xc3,  0xc3,  0x03,  0xe0,  0xe1,  0x87,  0x07,
270                 0xf0,  0xf0,  0x0f,  0x0f,  0x78,  0xf8,  0x1f,  0x1e,
271                 0x3c,  0x7c,  0x3f,  0x3c,  0x3c,  0xff,  0x7f,  0x3c,
272                 0xbc,  0xff,  0xff,  0x3d,  0xfc,  0xfb,  0xbf,  0x3f,
273                 0xfc,  0xff,  0xff,  0x3f,  0xfc,  0xff,  0xff,  0x3f,
274                 0xfc,  0xff,  0xff,  0x3f,  0xfc,  0xff,  0xff,  0x3f,
275         };
276
277         static BCursor WaitCursor = {
278                 /*small*/
279         wait_sbm, wait_smsk,
280                 16, 16, 
281                 7,  7,
282                 /*big*/
283                 wait_lbm, wait_lmsk,
284                 32,32, 
285                 15, 15,
286                 /*color*/
287                 BC_BLACK, BC_WHITE
288         };
289
290         BlenderCursor[BC_WAITCURSOR]=&WaitCursor;
291 END_CURSOR_BLOCK
292
293         /********************** Cross Cursor ***************************/
294 BEGIN_CURSOR_BLOCK
295         static char cross_sbm[]={
296                 0x00,  0x00,  0x80,  0x01,  0x80,  0x01,  0x80,  0x01,
297                 0x80,  0x01,  0x80,  0x01,  0x80,  0x01,  0x7e,  0x7e,
298                 0x7e,  0x7e,  0x80,  0x01,  0x80,  0x01,  0x80,  0x01,
299                 0x80,  0x01,  0x80,  0x01,  0x80,  0x01,  0x00,  0x00,
300         };
301
302         static char cross_smsk[]={
303                 0x80,  0x01,  0x80,  0x01,  0x80,  0x01,  0x80,  0x01,
304                 0x80,  0x01,  0x80,  0x01,  0xc0,  0x03,  0x7f,  0xfe,
305                 0x7f,  0xfe,  0xc0,  0x03,  0x80,  0x01,  0x80,  0x01,
306                 0x80,  0x01,  0x80,  0x01,  0x80,  0x01,  0x80,  0x01,
307         };
308         static char cross_lbm[]={
309                 0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
310                 0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
311                 0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
312                 0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
313                 0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
314                 0x00,  0x80,  0x01,  0x00,  0x00,  0xc0,  0x03,  0x00,
315                 0x00,  0xc0,  0x03,  0x00,  0x00,  0x40,  0x02,  0x00,
316                 0x00,  0x78,  0x1e,  0x00,  0xfc,  0x1f,  0xf8,  0x3f,
317                 0xfc,  0x1f,  0xf8,  0x3f,  0x00,  0x78,  0x1e,  0x00,
318                 0x00,  0x40,  0x02,  0x00,  0x00,  0xc0,  0x03,  0x00,
319                 0x00,  0xc0,  0x03,  0x00,  0x00,  0x80,  0x01,  0x00,
320                 0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
321                 0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
322                 0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
323                 0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
324                 0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
325         };
326
327         static char cross_lmsk[]={
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,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
332                 0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
333                 0x00,  0x80,  0x01,  0x00,  0x00,  0xc0,  0x03,  0x00,
334                 0x00,  0xe0,  0x07,  0x00,  0x00,  0x70,  0x0e,  0x00,
335                 0x00,  0x78,  0x1e,  0x00,  0xff,  0x1f,  0xf8,  0xff,
336                 0xff,  0x1f,  0xf8,  0xff,  0x00,  0x78,  0x1e,  0x00,
337                 0x00,  0x70,  0x0e,  0x00,  0x00,  0xe0,  0x07,  0x00,
338                 0x00,  0xc0,  0x03,  0x00,  0x00,  0x80,  0x01,  0x00,
339                 0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
340                 0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
341                 0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
342                 0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
343                 0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
344         };
345
346         static BCursor CrossCursor = {
347                 /*small*/
348                 cross_sbm, cross_smsk,
349                 16, 16, 
350                 7,  7,
351                 /*big*/
352                 cross_lbm, cross_lmsk,
353                 32,32, 
354                 15, 15,
355                 /*color*/
356                 BC_BLACK, BC_WHITE
357         };
358
359         BlenderCursor[BC_CROSSCURSOR]=&CrossCursor;
360 END_CURSOR_BLOCK
361
362         /********************** EditCross Cursor ***********************/       
363 BEGIN_CURSOR_BLOCK
364         static char editcross_sbm[]={
365                 0x0e,  0x00,  0x11,  0x00,  0x1d,  0x00,  0x19,  0x03,
366                 0x1d,  0x03,  0x11,  0x03,  0x0e,  0x03,  0x00,  0x03,
367                 0xf8,  0x7c,  0xf8,  0x7c,  0x00,  0x03,  0x00,  0x03,
368                 0x00,  0x03,  0x00,  0x03,  0x00,  0x03,  0x00,  0x00,
369         };
370
371         static char editcross_smsk[]={
372                 0x0e,  0x00,  0x1f,  0x00,  0x1f,  0x03,  0x1f,  0x03,
373                 0x1f,  0x03,  0x1f,  0x03,  0x0e,  0x03,  0x80,  0x07,
374                 0xfc,  0xfc,  0xfc,  0xfc,  0x80,  0x07,  0x00,  0x03,
375                 0x00,  0x03,  0x00,  0x03,  0x00,  0x03,  0x00,  0x03,
376         };
377
378         static BCursor EditCrossCursor = {
379                 /*small*/
380                 editcross_sbm, editcross_smsk,
381                 16, 16, 
382                 9,  8,
383                 /*big*/
384                 NULL, NULL,
385                 32,32, 
386                 15, 15,
387                 /*color*/
388                 BC_BLACK, BC_WHITE
389         };
390
391         BlenderCursor[BC_EDITCROSSCURSOR]=&EditCrossCursor;
392 END_CURSOR_BLOCK
393
394         /********************** Box Select *************************/
395 BEGIN_CURSOR_BLOCK
396         static char box_sbm[32]={
397         0x7f,  0x00,  0x41,  0x00,  0x41,  0x00,  0x41,  0x06,
398                 0x41,  0x06,  0x41,  0x06,  0x7f,  0x06,  0x00,  0x06,
399                 0xe0,  0x79,  0xe0,  0x79,  0x00,  0x06,  0x00,  0x06,
400                 0x00,  0x06,  0x00,  0x06,  0x00,  0x06,  0x00,  0x00,
401         };
402
403         static char box_smsk[32]={
404         0x7f,  0x00,  0x7f,  0x00,  0x63,  0x06,  0x63,  0x06,
405                 0x63,  0x06,  0x7f,  0x06,  0x7f,  0x06,  0x00,  0x0f,
406                 0xf0,  0xf9,  0xf0,  0xf9,  0x00,  0x0f,  0x00,  0x06,
407                 0x00,  0x06,  0x00,  0x06,  0x00,  0x06,  0x00,  0x06,
408
409         };
410
411         static BCursor BoxSelCursor = {
412                 /*small*/
413                 box_sbm, box_smsk,
414                 16, 16, 
415                 9,  8,
416                 /*big*/
417                 NULL, NULL,
418                 32,32, 
419                 15, 15,
420                 /*color*/
421                 BC_BLACK, BC_WHITE
422         };
423
424         BlenderCursor[BC_BOXSELCURSOR]=&BoxSelCursor;
425
426 END_CURSOR_BLOCK
427         /********************** Knife Cursor ***********************/
428 BEGIN_CURSOR_BLOCK
429         static char knife_sbm[]={
430                 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x2c,
431                 0x00, 0x5a, 0x00, 0x34, 0x00, 0x2a, 0x00, 0x17,
432                 0x80, 0x06, 0x40, 0x03, 0xa0, 0x03, 0xd0, 0x01,
433                 0x68, 0x00, 0x1c, 0x00, 0x06, 0x00, 0x00, 0x00
434         };
435
436         static char knife_smsk[]={
437                 0x00, 0x60, 0x00, 0xf0, 0x00, 0xfc, 0x00, 0xfe,
438                 0x00, 0xfe, 0x00, 0x7e, 0x00, 0x7f, 0x80, 0x3f,
439                 0xc0, 0x0e, 0x60, 0x07, 0xb0, 0x07, 0xd8, 0x03,
440                 0xec, 0x01, 0x7e, 0x00, 0x1f, 0x00, 0x07, 0x00
441         };
442
443         static char knife_lbm[]={
444                 0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
445                 0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
446                 0x00,  0x00,  0x00,  0x08,  0x00,  0x00,  0x00,  0x1c,
447                 0x00,  0x00,  0x00,  0x3e,  0x00,  0x00,  0x00,  0x7f,
448                 0x00,  0x00,  0x80,  0xbf,  0x00,  0x00,  0xc0,  0x5f,
449                 0x00,  0x00,  0xc0,  0x6f,  0x00,  0x00,  0xc0,  0x37,
450                 0x00,  0x00,  0xa8,  0x1b,  0x00,  0x00,  0x54,  0x0d,
451                 0x00,  0x00,  0xa8,  0x00,  0x00,  0x00,  0x54,  0x00,
452                 0x00,  0x00,  0xa8,  0x00,  0x00,  0x00,  0x53,  0x00,
453                 0x00,  0xc0,  0x07,  0x00,  0x00,  0xe0,  0x0f,  0x00,
454                 0x00,  0xd0,  0x0f,  0x00,  0x00,  0xe8,  0x07,  0x00,
455                 0x00,  0xf4,  0x07,  0x00,  0x00,  0xfa,  0x00,  0x00,
456                 0x00,  0x3d,  0x00,  0x00,  0x80,  0x0e,  0x00,  0x00,
457                 0xc0,  0x03,  0x00,  0x00,  0xe0,  0x00,  0x00,  0x00,
458                 0x30,  0x00,  0x00,  0x00,  0x08,  0x00,  0x00,  0x00,
459                 0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
460
461         };
462
463         static char knife_lmsk[]={
464                 0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
465                 0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x18,
466                 0x00,  0x00,  0x00,  0x3c,  0x00,  0x00,  0x00,  0x7e,
467                 0x00,  0x00,  0x00,  0xff,  0x00,  0x00,  0x80,  0xff,
468                 0x00,  0x00,  0xc0,  0xbf,  0x00,  0x00,  0xe0,  0xdf,
469                 0x00,  0x00,  0xe0,  0xef,  0x00,  0x00,  0xf8,  0x77,
470                 0x00,  0x00,  0xfc,  0x3b,  0x00,  0x00,  0xfe,  0x1d,
471                 0x00,  0x00,  0xfe,  0x0f,  0x00,  0x00,  0xfe,  0x01,
472                 0x00,  0x00,  0xff,  0x01,  0x00,  0xc0,  0xff,  0x00,
473                 0x00,  0xe0,  0x7f,  0x00,  0x00,  0xf0,  0x1f,  0x00,
474                 0x00,  0xd8,  0x1f,  0x00,  0x00,  0xec,  0x0f,  0x00,
475                 0x00,  0xf6,  0x0f,  0x00,  0x00,  0xfb,  0x06,  0x00,
476                 0x80,  0xbd,  0x01,  0x00,  0xc0,  0x6e,  0x00,  0x00,
477                 0xe0,  0x1b,  0x00,  0x00,  0xf0,  0x06,  0x00,  0x00,
478                 0xb8,  0x01,  0x00,  0x00,  0x6c,  0x00,  0x00,  0x00,
479                 0x1c,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
480
481         };
482
483         static BCursor KnifeCursor = {
484                 /*small*/
485         knife_sbm, knife_smsk,
486                 16, 16, 
487                 0,  15,
488                 /*big*/
489                 knife_lbm, knife_lmsk,
490                 32,32, 
491                 0, 31,
492                 /*color*/
493                 BC_BLACK, BC_WHITE
494         };
495
496         BlenderCursor[BC_KNIFECURSOR]=&KnifeCursor;
497
498 END_CURSOR_BLOCK
499         
500         /********************** Loop Select Cursor ***********************/
501 BEGIN_CURSOR_BLOCK
502
503 static char vloop_sbm[]={
504         0x00,  0x00,  0x7e,  0x00,  0x3e,  0x00,  0x1e,  0x00,
505         0x0e,  0x00,  0x66,  0x60,  0x62,  0x6f,  0x00,  0x00,
506         0x20,  0x20,  0x20,  0x20,  0x20,  0x20,  0x20,  0x20,
507         0x00,  0x00,  0x60,  0x60,  0x60,  0x6f,  0x00,  0x00,
508 };
509
510 static char vloop_smsk[]={
511         0xff,  0x01,  0xff,  0x00,  0x7f,  0x00,  0x3f,  0x00,
512         0xff,  0xf0,  0xff,  0xff,  0xf7,  0xff,  0xf3,  0xf0,
513         0x61,  0x60,  0x60,  0x60,  0x60,  0x60,  0x60,  0x60,
514         0xf0,  0xf0,  0xf0,  0xff,  0xf0,  0xff,  0xf0,  0xf0,
515 };
516
517
518
519 static char vloop_lbm[]={
520         0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
521         0xfc,  0x3f,  0x00,  0x00,  0xfc,  0x3f,  0x00,  0x00,
522         0xfc,  0x0f,  0x00,  0x00,  0xfc,  0x0f,  0x00,  0x00,
523         0xfc,  0x03,  0x00,  0x00,  0xfc,  0x03,  0x00,  0x00,
524         0xfc,  0x00,  0x00,  0x00,  0xfc,  0x00,  0x00,  0x00,
525         0x3c,  0x3c,  0x00,  0x3c,  0x3c,  0x3c,  0x00,  0x3c,
526         0x0c,  0x3c,  0xff,  0x3c,  0x0c,  0x3c,  0xff,  0x3c,
527         0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
528         0x00,  0x0c,  0x00,  0x0c,  0x00,  0x0c,  0x00,  0x0c,
529         0x00,  0x0c,  0x00,  0x0c,  0x00,  0x0c,  0x00,  0x0c,
530         0x00,  0x0c,  0x00,  0x0c,  0x00,  0x0c,  0x00,  0x0c,
531         0x00,  0x0c,  0x00,  0x0c,  0x00,  0x0c,  0x00,  0x0c,
532         0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
533         0x00,  0x3c,  0x00,  0x3c,  0x00,  0x3c,  0x00,  0x3c,
534         0x00,  0x3c,  0xff,  0x3c,  0x00,  0x3c,  0xff,  0x3c,
535         0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
536 };
537
538 static char vloop_lmsk[]={
539         0xff,  0xff,  0x03,  0x00,  0xff,  0xff,  0x03,  0x00,
540         0xff,  0xff,  0x00,  0x00,  0xff,  0xff,  0x00,  0x00,
541         0xff,  0x3f,  0x00,  0x00,  0xff,  0x3f,  0x00,  0x00,
542         0xff,  0x0f,  0x00,  0x00,  0xff,  0x0f,  0x00,  0x00,
543         0xff,  0xff,  0x00,  0xff,  0xff,  0xff,  0x00,  0xff,
544         0xff,  0xff,  0xff,  0xff,  0xff,  0xff,  0xff,  0xff,
545         0x3f,  0xff,  0xff,  0xff,  0x3f,  0xff,  0xff,  0xff,
546         0x0f,  0xff,  0x00,  0xff,  0x0f,  0xff,  0x00,  0xff,
547         0x03,  0x3c,  0x00,  0x3c,  0x03,  0x3c,  0x00,  0x3c,
548         0x00,  0x3c,  0x00,  0x3c,  0x00,  0x3c,  0x00,  0x3c,
549         0x00,  0x3c,  0x00,  0x3c,  0x00,  0x3c,  0x00,  0x3c,
550         0x00,  0x3c,  0x00,  0x3c,  0x00,  0x3c,  0x00,  0x3c,
551         0x00,  0xff,  0x00,  0xff,  0x00,  0xff,  0x00,  0xff,
552         0x00,  0xff,  0xff,  0xff,  0x00,  0xff,  0xff,  0xff,
553         0x00,  0xff,  0xff,  0xff,  0x00,  0xff,  0xff,  0xff,
554         0x00,  0xff,  0x00,  0xff,  0x00,  0xff,  0x00,  0xff,
555 };
556
557
558
559         static BCursor VLoopCursor = {
560                 /*small*/
561         vloop_sbm, vloop_smsk,
562                 16, 16, 
563                 0,  0,
564                 /*big*/
565                 vloop_lbm, vloop_lmsk,
566                 32,32, 
567                 0, 0,
568                 /*color*/
569                 BC_BLACK, BC_WHITE
570         };
571
572         BlenderCursor[BC_VLOOPCURSOR]=&VLoopCursor;
573
574 END_CURSOR_BLOCK        
575         
576
577         /********************** EditCross Cursor ***********************/       
578 BEGIN_CURSOR_BLOCK
579         static char textedit_sbm[]={
580                 0xe0,  0x03,  0x10,  0x04,  0x60,  0x03,  0x40,  0x01,
581                 0x40,  0x01,  0x40,  0x01,  0x40,  0x01,  0x40,  0x01,
582                 0x40,  0x01,  0x40,  0x01,  0x40,  0x01,  0x40,  0x01,
583                 0x40,  0x01,  0x60,  0x03,  0x10,  0x04,  0xe0,  0x03,
584         };
585
586         static char textedit_smsk[]={
587                 0xe0,  0x03,  0xf0,  0x07,  0xe0,  0x03,  0xc0,  0x01,
588                 0xc0,  0x01,  0xc0,  0x01,  0xc0,  0x01,  0xc0,  0x01,
589                 0xc0,  0x01,  0xc0,  0x01,  0xc0,  0x01,  0xc0,  0x01,
590                 0xc0,  0x01,  0xe0,  0x03,  0xf0,  0x07,  0xe0,  0x03,
591         };
592
593         static BCursor TextEditCursor = {
594                 /*small*/
595                 textedit_sbm, textedit_smsk,
596                 16, 16, 
597                 9,  8,
598                 /*big*/
599                 NULL, NULL,
600                 32,32, 
601                 15, 15,
602                 /*color*/
603                 BC_BLACK, BC_WHITE
604         };
605
606         BlenderCursor[BC_TEXTEDITCURSOR]=&TextEditCursor;
607 END_CURSOR_BLOCK
608
609
610         /********************** EditCross Cursor ***********************/       
611 BEGIN_CURSOR_BLOCK
612         static char paintbrush_sbm[]={
613
614                 0x00,  0xe0,  0x00,  0x98,  0x00,  0x44,  0x00,  0x42,
615                 0x00,  0x21,  0x80,  0x20,  0x40,  0x13,  0x40,  0x17,
616                 0xa0,  0x0b,  0x98,  0x05,  0x04,  0x02,  0x02,  0x01,
617                 0x02,  0x01,  0x02,  0x01,  0x81,  0x00,  0x7f,  0x00,
618
619
620
621         };
622
623         static char paintbrush_smsk[]={
624                 0x00,  0xe0,  0x00,  0xf8,  0x00,  0x7c,  0x00,  0x7e,
625                 0x00,  0x3f,  0x80,  0x3f,  0xc0,  0x1f,  0xc0,  0x1f,
626                 0xe0,  0x0f,  0xf8,  0x07,  0xfc,  0x03,  0xfe,  0x01,
627                 0xfe,  0x01,  0xfe,  0x01,  0xff,  0x00,  0x7f,  0x00,
628
629
630         };
631
632         static BCursor PaintBrushCursor = {
633                 /*small*/
634                 paintbrush_sbm, paintbrush_smsk,
635                 16, 16, 
636                 9,  8,
637                 /*big*/
638                 NULL, NULL,
639                 32,32, 
640                 15, 15,
641                 /*color*/
642                 BC_BLACK, BC_WHITE
643         };
644
645         BlenderCursor[BC_PAINTBRUSHCURSOR]=&PaintBrushCursor;
646 END_CURSOR_BLOCK
647
648         /********************** Put the cursors in the array ***********************/
649         
650 }
651
652
653