source/blender/windowmanager/intern/wm_cursors.c

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