Commit of cursor framework. Cursors now defined in source/blender/src/cursors.c and
[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 #ifdef WIN32
40 #include "BLI_winstuff.h"
41 #endif   
42
43 #include "DNA_listBase.h"
44 #include "DNA_userdef_types.h" 
45
46 #include "BIF_cursors.h"
47 #include "BIF_resources.h"
48 #include "BIF_graphics.h"
49 #include "BIF_screen.h"
50
51 #include "GHOST_C-api.h"
52 #include "winlay.h"
53
54
55 /* ****************************************************************** 
56 Cursor Description:
57
58 Each bit represents a pixel, so 1 byte = 8 pixels, 
59 the bytes go Left to Right. Top to bottom
60 the bits in a byte go right to left
61 (ie;  0x01, 0x80  represents a line of 16 pix with the first and last pix set.) 
62
63 A 0 in the bitmap = bg_color, a 1 fg_color
64 a 0 in the mask   = transparent pix.
65
66 Until 32x32 cursors are supported on all platforms, the size of the 
67 small cursors MUST be 16x16.
68
69 Large cursors have a MAXSIZE of 32x32.
70
71 Other than that, the specified size of the cursors is just a guideline, 
72 However, the char array that defines the BM and MASK must be byte aligned.
73 ie a 17x17 cursor needs 3 bytes (cols) * 17 bytes (rows) 
74 (3 bytes = 17 bits rounded up to nearest whole byte).  Pad extra bits
75 in mask with 0's.
76
77 Setting big_bm=NULL disables the large version of the cursor.
78
79 ******************************************************************* */
80
81 /* Because defining a cursor mixes declarations and executable code
82    each cursor needs it's own scoping block or it would be split up 
83    over several hundred lines of code.  To enforce/document this better
84    I define 2 pretty braindead macros so it's obvious what the extra "[]"
85    are for */
86
87 #define BEGIN_CURSOR_BLOCK {
88 #define END_CURSOR_BLOCK   }
89
90 /* Cursor Globals */
91 static BCursor *BlenderCursor[BC_NUMCURSORS]; /*Points to static BCursor Structs */
92 static short CurrentCursor=-1, LastCursor=-1;
93
94 void SetBlenderCursor(short curs){
95         Window *win;
96
97         if ((curs<LASTCURSOR)||(curs>=BC_NUMCURSORS)) return;
98
99         win=winlay_get_active_window();
100
101         if (win==NULL) return; /* Can't set custom cursor before Window init */ 
102         if (win->ghostwin==NULL) return;
103
104         LastCursor=CurrentCursor;
105         CurrentCursor=curs;
106
107         if (curs==LASTCURSOR) curs=LastCursor;
108
109         if (curs==SYSCURSOR) {  /* System default Cursor */
110                 set_cursor(CURSOR_STD);
111         }
112         else if ( (U.curssize==0) || (BlenderCursor[curs]->big_bm == NULL) ) {
113                 printf("setting small cursor\n");
114                 GHOST_SetCustomCursorShapeEx(win->ghostwin, 
115                         BlenderCursor[curs]->small_bm, BlenderCursor[curs]->small_mask, 
116                         BlenderCursor[curs]->small_sizex,BlenderCursor[curs]->small_sizey,
117                         BlenderCursor[curs]->small_hotx,BlenderCursor[curs]->small_hoty,
118                         BlenderCursor[curs]->fg_color, BlenderCursor[curs]->bg_color    
119                         );
120         }
121         else {
122                 printf("setting big cursor\n");
123                 GHOST_SetCustomCursorShapeEx(win->ghostwin, 
124                         BlenderCursor[curs]->big_bm, BlenderCursor[curs]->big_mask, 
125                         BlenderCursor[curs]->big_sizex,BlenderCursor[curs]->big_sizey,
126                         BlenderCursor[curs]->big_hotx,BlenderCursor[curs]->big_hoty,
127                         BlenderCursor[curs]->fg_color, BlenderCursor[curs]->bg_color    
128                         );
129
130         }
131 }
132
133
134 short GetCurrentCursor(void){
135         return(CurrentCursor);
136 }
137
138
139 void InitCursorData(void){
140
141         /********************** NW_ARROW Cursor **************************/
142 BEGIN_CURSOR_BLOCK
143                 static char nw_sbm[]={
144                         0x03,  0x00,  0x05,  0x00,  0x09,  0x00,  0x11,  0x00,
145                                 0x21,  0x00,  0x41,  0x00,  0x81,  0x00,  0x01,  0x01,
146                                 0x01,  0x02,  0xc1,  0x03,  0x49,  0x00,  0x8d,  0x00,
147                                 0x8b,  0x00,  0x10,  0x01,  0x90,  0x01,  0x60,  0x00,
148                 };
149
150                 static char nw_smsk[]={
151                         0x03,  0x00,  0x07,  0x00,  0x0f,  0x00,  0x1f,  0x00,
152                                 0x3f,  0x00,  0x7f,  0x00,  0xff,  0x00,  0xff,  0x01,
153                                 0xff,  0x03,  0xff,  0x03,  0x7f,  0x00,  0xff,  0x00,
154                                 0xfb,  0x00,  0xf0,  0x01,  0xf0,  0x01,  0x60,  0x00,
155                 };
156
157                 static BCursor NWArrowCursor = {
158                         /*small*/
159                         nw_sbm, nw_smsk,
160                                 16, 16, 
161                                 6,  7,
162                                 /*big*/
163                                 NULL, NULL,
164                                 32,32, 
165                                 15, 15,
166                                 /*color*/
167                                 BC_BLACK, BC_WHITE
168                 };
169
170                 BlenderCursor[BC_NW_ARROWCURSOR]=&NWArrowCursor;
171 END_CURSOR_BLOCK
172
173         ///********************** NS_ARROW Cursor *************************/
174 BEGIN_CURSOR_BLOCK
175                 static char ns_sbm[]={
176                         0x40,  0x01,  0x20,  0x02,  0x10,  0x04,  0x08,  0x08,
177                                 0x04,  0x10,  0x3c,  0x1e,  0x20,  0x02,  0x20,  0x02,
178                                 0x20,  0x02,  0x20,  0x02,  0x3c,  0x1e,  0x04,  0x10,
179                                 0x08,  0x08,  0x10,  0x04,  0x20,  0x02,  0x40,  0x01
180                 };
181
182                 static char ns_smsk[]={
183                         0xc0,  0x01,  0xe0,  0x03,  0xf0,  0x07,  0xf8,  0x0f,
184                                 0xfc,  0x1f,  0xfc,  0x1f,  0xe0,  0x03,  0xe0,  0x03,
185                                 0xe0,  0x03,  0xe0,  0x03,  0xfc,  0x1f,  0xfc,  0x1f,
186                                 0xf8,  0x0f,  0xf0,  0x07,  0xe0,  0x03,  0xc0,  0x01
187                 };
188
189                 static BCursor NSArrowCursor = {
190                         /*small*/
191                         ns_sbm, ns_smsk,
192                                 16, 16, 
193                                 6,  7,
194                                 /*big*/
195                                 NULL, NULL,
196                                 32,32, 
197                                 15, 15,
198                                 /*color*/
199                                 BC_BLACK, BC_WHITE
200                 };
201
202                 BlenderCursor[BC_NS_ARROWCURSOR]=&NSArrowCursor;
203                 
204 END_CURSOR_BLOCK
205         /********************** EW_ARROW Cursor *************************/
206 BEGIN_CURSOR_BLOCK
207         static char ew_sbm[]={
208                 0x00,  0x00,  0x00,  0x00,  0x10,  0x08,  0x38,  0x1c,
209                 0x2c,  0x34,  0xe6,  0x67,  0x03,  0xc0,  0x01,  0x80,
210                 0x03,  0xc0,  0xe6,  0x67,  0x2c,  0x34,  0x38,  0x1c,
211                 0x10,  0x08,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
212         };
213
214         static char ew_smsk[]={
215                 0x00,  0x00,  0x00,  0x00,  0x10,  0x08,  0x38,  0x1c,
216                 0x3c,  0x3c,  0xfe,  0x7f,  0xff,  0xff,  0x3f,  0xfc,
217                 0xff,  0xff,  0xfe,  0x7f,  0x3c,  0x3c,  0x38,  0x1c,
218                 0x10,  0x08,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
219         };
220
221         static BCursor EWArrowCursor = {
222                 /*small*/
223                 ew_sbm, ew_smsk,
224                 16, 16, 
225                 7,  6,
226                 /*big*/
227                 NULL, NULL,
228                 32,32, 
229                 15, 15,
230                 /*color*/
231                 BC_BLACK, BC_WHITE
232         };
233
234         BlenderCursor[BC_EW_ARROWCURSOR]=&EWArrowCursor;
235 END_CURSOR_BLOCK
236
237         /********************** Wait Cursor *****************************/
238 BEGIN_CURSOR_BLOCK
239         static char wait_sbm[]={
240                 0xfe,  0x7f,  0x02,  0x40,  0x02,  0x40,  0x84,  0x21,
241                 0xc8,  0x13,  0xd0,  0x0b,  0xa0,  0x04,  0x20,  0x05,
242                 0xa0,  0x04,  0x10,  0x09,  0x88,  0x11,  0xc4,  0x23,
243                 0xe2,  0x47,  0xfa,  0x5f,  0x02,  0x40,  0xfe,  0x7f,
244         };
245
246         static char wait_smsk[]={
247                 0xfe,  0x7f,  0xfe,  0x7f,  0x06,  0x60,  0x8c,  0x31,
248                 0xd8,  0x1b,  0xf0,  0x0f,  0xe0,  0x06,  0x60,  0x07,
249                 0xe0,  0x06,  0x30,  0x0d,  0x98,  0x19,  0xcc,  0x33,
250                 0xe6,  0x67,  0xfe,  0x7f,  0xfe,  0x7f,  0xfe,  0x7f,
251         };
252
253         static char wait_lbm[]={
254                 0xfc,  0xff,  0xff,  0x3f,  0xfc,  0xff,  0xff,  0x3f,
255                 0x0c,  0x00,  0x00,  0x30,  0x0c,  0x00,  0x00,  0x30,
256                 0x0c,  0x00,  0x00,  0x30,  0x0c,  0x00,  0x00,  0x18,
257                 0x18,  0xc0,  0x03,  0x0c,  0x30,  0x20,  0x07,  0x06,
258                 0x60,  0xf0,  0x0f,  0x03,  0xc0,  0xd0,  0x8d,  0x01,
259                 0x80,  0x79,  0xcf,  0x00,  0x00,  0xf3,  0x67,  0x00,
260                 0x00,  0x66,  0x37,  0x00,  0x00,  0x8c,  0x33,  0x00,
261                 0x00,  0x0c,  0x32,  0x00,  0x00,  0xcc,  0x33,  0x00,
262                 0x00,  0x8c,  0x30,  0x00,  0x00,  0x46,  0x61,  0x00,
263                 0x00,  0x03,  0xc3,  0x00,  0x80,  0x01,  0x83,  0x01,
264                 0xc0,  0xc0,  0x03,  0x03,  0x60,  0xa0,  0x05,  0x06,
265                 0x30,  0xf0,  0x0f,  0x0c,  0x18,  0xf8,  0x1d,  0x18,
266                 0x0c,  0x5c,  0x3f,  0x30,  0x0c,  0xff,  0x5f,  0x30,
267                 0x0c,  0xf7,  0xfe,  0x31,  0xcc,  0xfb,  0x9f,  0x33,
268                 0x0c,  0x00,  0x00,  0x30,  0x0c,  0x00,  0x00,  0x30,
269                 0xfc,  0xff,  0xff,  0x3f,  0xfc,  0xff,  0xff,  0x3f,
270         };
271
272         static char wait_lmsk[]={
273                 0xfc,  0xff,  0xff,  0x3f,  0xfc,  0xff,  0xff,  0x3f,
274                 0xfc,  0xff,  0xff,  0x3f,  0xfc,  0xff,  0xff,  0x3f,
275                 0x3c,  0x00,  0x00,  0x3c,  0x3c,  0x00,  0x00,  0x1e,
276                 0x78,  0xc0,  0x03,  0x0f,  0xf0,  0xa0,  0x87,  0x07,
277                 0xe0,  0xf1,  0xcf,  0x03,  0xc0,  0xf3,  0xef,  0x01,
278                 0x80,  0xff,  0xff,  0x00,  0x00,  0xff,  0x7f,  0x00,
279                 0x00,  0xfe,  0x3f,  0x00,  0x00,  0xfc,  0x3f,  0x00,
280                 0x00,  0x3c,  0x3f,  0x00,  0x00,  0xfc,  0x3f,  0x00,
281                 0x00,  0xbc,  0x3c,  0x00,  0x00,  0xde,  0x79,  0x00,
282                 0x00,  0x0f,  0xf3,  0x00,  0x80,  0x07,  0xe3,  0x01,
283                 0xc0,  0xc3,  0xc3,  0x03,  0xe0,  0xe1,  0x87,  0x07,
284                 0xf0,  0xf0,  0x0f,  0x0f,  0x78,  0xf8,  0x1f,  0x1e,
285                 0x3c,  0x7c,  0x3f,  0x3c,  0x3c,  0xff,  0x7f,  0x3c,
286                 0xbc,  0xff,  0xff,  0x3d,  0xfc,  0xfb,  0xbf,  0x3f,
287                 0xfc,  0xff,  0xff,  0x3f,  0xfc,  0xff,  0xff,  0x3f,
288                 0xfc,  0xff,  0xff,  0x3f,  0xfc,  0xff,  0xff,  0x3f,
289         };
290
291         static BCursor WaitCursor = {
292                 /*small*/
293         wait_sbm, wait_smsk,
294                 16, 16, 
295                 7,  7,
296                 /*big*/
297                 wait_lbm, wait_lmsk,
298                 32,32, 
299                 15, 15,
300                 /*color*/
301                 BC_BLACK, BC_WHITE
302         };
303
304         BlenderCursor[BC_WAITCURSOR]=&WaitCursor;
305 END_CURSOR_BLOCK
306
307         /********************** Cross Cursor ***************************/
308 BEGIN_CURSOR_BLOCK
309         static char cross_sbm[]={
310                 0x00,  0x00,  0x80,  0x01,  0x80,  0x01,  0x80,  0x01,
311                 0x80,  0x01,  0x80,  0x01,  0x80,  0x01,  0x7e,  0x7e,
312                 0x7e,  0x7e,  0x80,  0x01,  0x80,  0x01,  0x80,  0x01,
313                 0x80,  0x01,  0x80,  0x01,  0x80,  0x01,  0x00,  0x00,
314         };
315
316         static char cross_smsk[]={
317                 0x80,  0x01,  0x80,  0x01,  0x80,  0x01,  0x80,  0x01,
318                 0x80,  0x01,  0x80,  0x01,  0xc0,  0x03,  0x7f,  0xfe,
319                 0x7f,  0xfe,  0xc0,  0x03,  0x80,  0x01,  0x80,  0x01,
320                 0x80,  0x01,  0x80,  0x01,  0x80,  0x01,  0x80,  0x01,
321         };
322         static char cross_lbm[]={
323                 0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
324                 0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
325                 0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
326                 0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
327                 0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
328                 0x00,  0x80,  0x01,  0x00,  0x00,  0xc0,  0x03,  0x00,
329                 0x00,  0xc0,  0x03,  0x00,  0x00,  0x40,  0x02,  0x00,
330                 0x00,  0x78,  0x1e,  0x00,  0xfc,  0x1f,  0xf8,  0x3f,
331                 0xfc,  0x1f,  0xf8,  0x3f,  0x00,  0x78,  0x1e,  0x00,
332                 0x00,  0x40,  0x02,  0x00,  0x00,  0xc0,  0x03,  0x00,
333                 0x00,  0xc0,  0x03,  0x00,  0x00,  0x80,  0x01,  0x00,
334                 0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
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,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
339         };
340
341         static char cross_lmsk[]={
342                 0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
343                 0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
344                 0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
345                 0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
346                 0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
347                 0x00,  0x80,  0x01,  0x00,  0x00,  0xc0,  0x03,  0x00,
348                 0x00,  0xe0,  0x07,  0x00,  0x00,  0x70,  0x0e,  0x00,
349                 0x00,  0x78,  0x1e,  0x00,  0xff,  0x1f,  0xf8,  0xff,
350                 0xff,  0x1f,  0xf8,  0xff,  0x00,  0x78,  0x1e,  0x00,
351                 0x00,  0x70,  0x0e,  0x00,  0x00,  0xe0,  0x07,  0x00,
352                 0x00,  0xc0,  0x03,  0x00,  0x00,  0x80,  0x01,  0x00,
353                 0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
354                 0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
355                 0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
356                 0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
357                 0x00,  0x80,  0x01,  0x00,  0x00,  0x80,  0x01,  0x00,
358         };
359
360         static BCursor CrossCursor = {
361                 /*small*/
362                 cross_sbm, cross_smsk,
363                 16, 16, 
364                 7,  7,
365                 /*big*/
366                 cross_lbm, cross_lmsk,
367                 32,32, 
368                 15, 15,
369                 /*color*/
370                 BC_BLACK, BC_WHITE
371         };
372
373         BlenderCursor[BC_CROSSCURSOR]=&CrossCursor;
374 END_CURSOR_BLOCK
375
376         /********************** EditCross Cursor ***********************/       
377 BEGIN_CURSOR_BLOCK
378         static char editcross_sbm[]={
379                 0x0e,  0x00,  0x11,  0x00,  0x1d,  0x00,  0x19,  0x03,
380                 0x1d,  0x03,  0x11,  0x03,  0x0e,  0x03,  0x00,  0x03,
381                 0xf8,  0x7c,  0xf8,  0x7c,  0x00,  0x03,  0x00,  0x03,
382                 0x00,  0x03,  0x00,  0x03,  0x00,  0x03,  0x00,  0x00,
383         };
384
385         static char editcross_smsk[]={
386                 0x0e,  0x00,  0x1f,  0x00,  0x1f,  0x03,  0x1f,  0x03,
387                 0x1f,  0x03,  0x1f,  0x03,  0x0e,  0x03,  0x80,  0x07,
388                 0xfc,  0xfc,  0xfc,  0xfc,  0x80,  0x07,  0x00,  0x03,
389                 0x00,  0x03,  0x00,  0x03,  0x00,  0x03,  0x00,  0x03,
390         };
391
392         static BCursor EditCrossCursor = {
393                 /*small*/
394                 editcross_sbm, editcross_smsk,
395                 16, 16, 
396                 9,  8,
397                 /*big*/
398                 NULL, NULL,
399                 32,32, 
400                 15, 15,
401                 /*color*/
402                 BC_BLACK, BC_WHITE
403         };
404
405         BlenderCursor[BC_EDITCROSSCURSOR]=&EditCrossCursor;
406 END_CURSOR_BLOCK
407
408         /********************** Box Select *************************/
409 BEGIN_CURSOR_BLOCK
410         static char box_sbm[32]={
411         0x7f,  0x00,  0x41,  0x00,  0x41,  0x00,  0x41,  0x06,
412                 0x41,  0x06,  0x41,  0x06,  0x7f,  0x06,  0x00,  0x06,
413                 0xe0,  0x79,  0xe0,  0x79,  0x00,  0x06,  0x00,  0x06,
414                 0x00,  0x06,  0x00,  0x06,  0x00,  0x06,  0x00,  0x00,
415         };
416
417         static char box_smsk[32]={
418         0x7f,  0x00,  0x7f,  0x00,  0x63,  0x06,  0x63,  0x06,
419                 0x63,  0x06,  0x7f,  0x06,  0x7f,  0x06,  0x00,  0x0f,
420                 0xf0,  0xf9,  0xf0,  0xf9,  0x00,  0x0f,  0x00,  0x06,
421                 0x00,  0x06,  0x00,  0x06,  0x00,  0x06,  0x00,  0x06,
422
423         };
424
425         static BCursor BoxSelCursor = {
426                 /*small*/
427                 box_sbm, box_smsk,
428                 16, 16, 
429                 9,  8,
430                 /*big*/
431                 NULL, NULL,
432                 32,32, 
433                 15, 15,
434                 /*color*/
435                 BC_BLACK, BC_WHITE
436         };
437
438         BlenderCursor[BC_BOXSELCURSOR]=&BoxSelCursor;
439
440 END_CURSOR_BLOCK
441         /********************** Knife Cursor ***********************/
442 BEGIN_CURSOR_BLOCK
443         static char knife_sbm[]={
444                 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x2c,
445                 0x00, 0x5a, 0x00, 0x34, 0x00, 0x2a, 0x00, 0x17,
446                 0x80, 0x06, 0x40, 0x03, 0xa0, 0x03, 0xd0, 0x01,
447                 0x68, 0x00, 0x1c, 0x00, 0x06, 0x00, 0x00, 0x00
448         };
449
450         static char knife_smsk[]={
451                 0x00, 0x60, 0x00, 0xf0, 0x00, 0xfc, 0x00, 0xfe,
452                 0x00, 0xfe, 0x00, 0x7e, 0x00, 0x7f, 0x80, 0x3f,
453                 0xc0, 0x0e, 0x60, 0x07, 0xb0, 0x07, 0xd8, 0x03,
454                 0xec, 0x01, 0x7e, 0x00, 0x1f, 0x00, 0x07, 0x00
455         };
456
457         static char knife_lbm[]={
458                 0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
459                 0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
460                 0x00,  0x00,  0x00,  0x08,  0x00,  0x00,  0x00,  0x1c,
461                 0x00,  0x00,  0x00,  0x3e,  0x00,  0x00,  0x00,  0x7f,
462                 0x00,  0x00,  0x80,  0xbf,  0x00,  0x00,  0xc0,  0x5f,
463                 0x00,  0x00,  0xc0,  0x6f,  0x00,  0x00,  0xc0,  0x37,
464                 0x00,  0x00,  0xa8,  0x1b,  0x00,  0x00,  0x54,  0x0d,
465                 0x00,  0x00,  0xa8,  0x00,  0x00,  0x00,  0x54,  0x00,
466                 0x00,  0x00,  0xa8,  0x00,  0x00,  0x00,  0x53,  0x00,
467                 0x00,  0xc0,  0x07,  0x00,  0x00,  0xe0,  0x0f,  0x00,
468                 0x00,  0xd0,  0x0f,  0x00,  0x00,  0xe8,  0x07,  0x00,
469                 0x00,  0xf4,  0x07,  0x00,  0x00,  0xfa,  0x00,  0x00,
470                 0x00,  0x3d,  0x00,  0x00,  0x80,  0x0e,  0x00,  0x00,
471                 0xc0,  0x03,  0x00,  0x00,  0xe0,  0x00,  0x00,  0x00,
472                 0x30,  0x00,  0x00,  0x00,  0x08,  0x00,  0x00,  0x00,
473                 0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
474
475         };
476
477         static char knife_lmsk[]={
478                 0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
479                 0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x18,
480                 0x00,  0x00,  0x00,  0x3c,  0x00,  0x00,  0x00,  0x7e,
481                 0x00,  0x00,  0x00,  0xff,  0x00,  0x00,  0x80,  0xff,
482                 0x00,  0x00,  0xc0,  0xbf,  0x00,  0x00,  0xe0,  0xdf,
483                 0x00,  0x00,  0xe0,  0xef,  0x00,  0x00,  0xf8,  0x77,
484                 0x00,  0x00,  0xfc,  0x3b,  0x00,  0x00,  0xfe,  0x1d,
485                 0x00,  0x00,  0xfe,  0x0f,  0x00,  0x00,  0xfe,  0x01,
486                 0x00,  0x00,  0xff,  0x01,  0x00,  0xc0,  0xff,  0x00,
487                 0x00,  0xe0,  0x7f,  0x00,  0x00,  0xf0,  0x1f,  0x00,
488                 0x00,  0xd8,  0x1f,  0x00,  0x00,  0xec,  0x0f,  0x00,
489                 0x00,  0xf6,  0x0f,  0x00,  0x00,  0xfb,  0x06,  0x00,
490                 0x80,  0xbd,  0x01,  0x00,  0xc0,  0x6e,  0x00,  0x00,
491                 0xe0,  0x1b,  0x00,  0x00,  0xf0,  0x06,  0x00,  0x00,
492                 0xb8,  0x01,  0x00,  0x00,  0x6c,  0x00,  0x00,  0x00,
493                 0x1c,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
494
495         };
496
497         static BCursor KnifeCursor = {
498                 /*small*/
499         knife_sbm, knife_smsk,
500                 16, 16, 
501                 0,  15,
502                 /*big*/
503                 knife_lbm, knife_lmsk,
504                 32,32, 
505                 0, 31,
506                 /*color*/
507                 BC_BLACK, BC_WHITE
508         };
509
510         BlenderCursor[BC_KNIFECURSOR]=&KnifeCursor;
511
512 END_CURSOR_BLOCK
513         /********************** Put the cursors in the array ***********************/
514         
515 }
516
517
518