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