source/blender/windowmanager/intern/wm_cursors.c

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