00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025 #ifndef _SO_QT_CURSOR_
00026 #define _SO_QT_CURSOR_
00027
00028 #include <Inventor/sys/port.h>
00029
00030 #if !defined(_WIN32) && !defined(__APPLE__)
00031
00032
00033 #define so_xt_viewing_width 16
00034 #define so_xt_viewing_height 16
00035 #define so_xt_viewing_x_hot 0
00036 #define so_xt_viewing_y_hot 0
00037 extern GCC_DLLEXPORT unsigned char so_xt_viewing_bits[];
00038
00039
00040 #define so_xt_curved_hand_width 24
00041 #define so_xt_curved_hand_height 24
00042 #define so_xt_curved_hand_x_hot 4
00043 #define so_xt_curved_hand_y_hot 2
00044 extern GCC_DLLEXPORT unsigned char so_xt_curved_hand_bits[];
00045
00046
00047 #define so_xt_flat_hand_width 24
00048 #define so_xt_flat_hand_height 28
00049 #define so_xt_flat_hand_x_hot 13
00050 #define so_xt_flat_hand_y_hot 4
00051 extern GCC_DLLEXPORT unsigned char so_xt_flat_hand_bits[];
00052
00053
00054 #define so_xt_pointing_hand_width 24
00055 #define so_xt_pointing_hand_height 24
00056 #define so_xt_pointing_hand_x_hot 9
00057 #define so_xt_pointing_hand_y_hot 4
00058 extern GCC_DLLEXPORT unsigned char so_xt_pointing_hand_bits[];
00059
00060
00061 #define so_xt_roll_width 17
00062 #define so_xt_roll_height 23
00063 #define so_xt_roll_x_hot 8
00064 #define so_xt_roll_y_hot 11
00065 extern GCC_DLLEXPORT unsigned char so_xt_roll_bits[];
00066
00067
00068 #define so_xt_target_width 21
00069 #define so_xt_target_height 21
00070 #define so_xt_target_x_hot 10
00071 #define so_xt_target_y_hot 10
00072 extern GCC_DLLEXPORT unsigned char so_xt_target_bits[];
00073
00074
00075 #define so_xt_normal_vec_width 24
00076 #define so_xt_normal_vec_height 24
00077 #define so_xt_normal_vec_x_hot 12
00078 #define so_xt_normal_vec_y_hot 18
00079 extern GCC_DLLEXPORT unsigned char so_xt_normal_vec_bits[];
00080
00081
00082
00083
00084
00085 #define so_xt_walk_width 32
00086 #define so_xt_walk_height 24
00087 #define so_xt_walk_x_hot 15
00088 #define so_xt_walk_y_hot 3
00089 extern GCC_DLLEXPORT unsigned char so_xt_walk_bits[];
00090 extern GCC_DLLEXPORT unsigned char so_xt_walk_mask_bits[];
00091
00092 #define so_xt_pan_width 20
00093 #define so_xt_pan_height 24
00094 #define so_xt_pan_x_hot 9
00095 #define so_xt_pan_y_hot 1
00096 extern GCC_DLLEXPORT unsigned char so_xt_pan_bits[];
00097
00098 #define so_xt_tilt_width 32
00099 #define so_xt_tilt_height 32
00100 #define so_xt_tilt_x_hot 7
00101 #define so_xt_tilt_y_hot 10
00102 extern GCC_DLLEXPORT unsigned char so_xt_tilt_bits[];
00103 extern GCC_DLLEXPORT unsigned char so_xt_tilt_mask_bits[];
00104 #endif
00105
00106 static const char *Classic_Dolly[]={
00107 "32 32 2 1",
00108 ". c None",
00109 "# c #ffffff",
00110 ".........##.....................",
00111 "........#..#....................",
00112 ".......#....#...................",
00113 "......#......#..................",
00114 ".....#...##...#.................",
00115 "....#...#..#...#................",
00116 "........#..#....................",
00117 "........#..#....................",
00118 "........#..###..................",
00119 "........#..#..###...............",
00120 "........#.....#..#..............",
00121 "........#........###............",
00122 "........#...........#...........",
00123 "........#...........#...........",
00124 "..####..#...........#...........",
00125 ".#....###...........#...........",
00126 "..##....##..........#...........",
00127 "....#..............#............",
00128 ".....#.............#............",
00129 "......#............#............",
00130 ".......#..........#.............",
00131 "........#.........#.............",
00132 ".........#........#.............",
00133 "..........#........#............",
00134 "................................",
00135 "................................",
00136 "................................",
00137 "................................",
00138 "................................",
00139 "................................",
00140 "................................",
00141 "................................"};
00142 static const char *Classic_Fly[]={
00143 "32 32 2 1",
00144 "# c None",
00145 ". c #ffffff",
00146 ".###############################",
00147 "..##############################",
00148 "...#############################",
00149 "....############################",
00150 ".....###########################",
00151 "......##########################",
00152 ".......#########################",
00153 "........########################",
00154 ".....###########################",
00155 "..#..###########################",
00156 ".###..##########################",
00157 "####..####.###.#################",
00158 "#####..###.###.#################",
00159 "#####..####.#.##################",
00160 "###########.#.##################",
00161 "############.###################",
00162 "################################",
00163 "################################",
00164 "################################",
00165 "################################",
00166 "################################",
00167 "################################",
00168 "################################",
00169 "################################",
00170 "################################",
00171 "################################",
00172 "################################",
00173 "################################",
00174 "################################",
00175 "################################",
00176 "################################",
00177 "################################"};
00178
00179 static const char *Classic_Pan[]={
00180 "32 32 2 1",
00181 ". c None",
00182 "# c #ffffff",
00183 "..............##................",
00184 ".............#..#...............",
00185 "...........###..###.............",
00186 "..........#..#..#.#.............",
00187 "..........#..#..#.##............",
00188 "..........#..#..#..#............",
00189 ".........#...#..#..##...........",
00190 "....##...#..#...#..#.#..........",
00191 "...#..#.#...#...#..#.#..........",
00192 "...#..#.#...#..#...#.#..........",
00193 "...#...#...#...#..#..#..........",
00194 "...#...#.......#..#..#..........",
00195 "...#...#......#...#..#..........",
00196 "..#...#...........#..#..........",
00197 "..#...#..........#..#...........",
00198 "..#.................#...........",
00199 "...#................#...........",
00200 "...#...............#............",
00201 "....#..............#............",
00202 "....#.............#.............",
00203 ".....#............#.............",
00204 "......#..........#..............",
00205 "......#.........#...............",
00206 "......#.........#...............",
00207 "................................",
00208 "................................",
00209 "................................",
00210 "................................",
00211 "................................",
00212 "................................",
00213 "................................",
00214 "................................"};
00215
00216
00217 static const char *Classic_Roll[]={
00218 "32 32 2 1",
00219 ". c None",
00220 "# c #ffffff",
00221 "................................",
00222 "................................",
00223 "......#.........................",
00224 "......##........................",
00225 "......##....########............",
00226 "......###.############..........",
00227 "......######........####........",
00228 "......#####...........###.......",
00229 "......######...........###......",
00230 "......########..........##......",
00231 ".....##########..........##.....",
00232 ".....##..................##.....",
00233 "....##....................##....",
00234 "....##....................##....",
00235 "....##....................##....",
00236 "....##.........##.........##....",
00237 "....##.........##.........##....",
00238 "....##....................##....",
00239 "....##....................##....",
00240 "....##....................##....",
00241 ".....##..................##.....",
00242 ".....##..........##########.....",
00243 "......##..........########......",
00244 "......##............######......",
00245 ".......###...........#####......",
00246 "........####........######......",
00247 "..........############.###......",
00248 "............########....##......",
00249 "........................##......",
00250 ".........................#......",
00251 "................................",
00252 "................................"};
00253
00254
00255 static const char *Classic_Seek[]={
00256 "32 32 2 1",
00257 ". c None",
00258 "# c #ffffff",
00259 "................................",
00260 "................................",
00261 "................................",
00262 "................................",
00263 "..............###...............",
00264 "..............###...............",
00265 "..............###...............",
00266 ".............#####..............",
00267 "...........#########............",
00268 "..........###.###.###...........",
00269 ".........##...###...##..........",
00270 "........##.....#.....##.........",
00271 "........##.....#.....##.........",
00272 ".......##......#......##........",
00273 "....#######.........#######.....",
00274 "....##########...##########.....",
00275 "....#######.........#######.....",
00276 ".......##......#......##........",
00277 "........##.....#.....##.........",
00278 "........##.....#.....##.........",
00279 ".........##...###...##..........",
00280 "..........###.###.###...........",
00281 "...........#########............",
00282 ".............#####..............",
00283 "..............###...............",
00284 "..............###...............",
00285 "..............###...............",
00286 "................................",
00287 "................................",
00288 "................................",
00289 "................................",
00290 "................................"};
00291
00292
00293 static const char *Classic_Spin[]={
00294 "32 32 2 1",
00295 ". c None",
00296 "# c #ffffff",
00297 "................................",
00298 ".........##.....................",
00299 "....###.#..#.##.................",
00300 "...#...##...#..#................",
00301 "...#....##..##..#...............",
00302 "....##...##..##..#..............",
00303 ".....#....#...#...#.............",
00304 "......#...##..##..#.............",
00305 ".......#...#...#...#............",
00306 "..#....#...#.......#............",
00307 ".#.##..#...........#............",
00308 ".#...#.#............#...........",
00309 ".#...#.#............#...........",
00310 "..#...#.............#...........",
00311 "...#................#...........",
00312 "...#.................#..........",
00313 "....#................#..........",
00314 ".....###.............#..........",
00315 "........##...........#..........",
00316 "..........#..........#..........",
00317 "...........#..........#.........",
00318 "............#..........#........",
00319 ".............#..................",
00320 "..............#.................",
00321 "................................",
00322 "................................",
00323 "................................",
00324 "................................",
00325 "................................",
00326 "................................",
00327 "................................",
00328 "................................"};
00329
00330
00331 static const char *Classic_Up[]={
00332 "32 32 2 1",
00333 ". c None",
00334 "# c #ffffff",
00335 "................................",
00336 "................................",
00337 "............#...................",
00338 "...........###..................",
00339 "..........#####.................",
00340 ".........##.#.##................",
00341 "............#...................",
00342 "............#...................",
00343 "............#...................",
00344 "............#...................",
00345 "............#...................",
00346 "............#...................",
00347 "............#...................",
00348 "............#...................",
00349 ".......###############..........",
00350 "......#.....#.......#...........",
00351 "......#....###......#...........",
00352 ".....#....#.#.#....#............",
00353 ".....#....#.#.#....#............",
00354 "....#.....#...#...#.............",
00355 "....#......###....#.............",
00356 "...#.............#..............",
00357 "...#.............#..............",
00358 "..###############...............",
00359 "................................",
00360 "................................",
00361 "................................",
00362 "................................",
00363 "................................",
00364 "................................",
00365 "................................",
00366 "................................"};
00367
00368
00369 static const char *Classic_Walk[]={
00370 "32 32 2 1",
00371 ". c None",
00372 "# c #ffffff",
00373 ".............##.................",
00374 "............#..#................",
00375 "...........#....#...............",
00376 "..........#......#..............",
00377 ".........##..##...#.............",
00378 "........#...#..#...#............",
00379 "............#..#................",
00380 "............#..#................",
00381 "............#..###..............",
00382 "............#..#..###...........",
00383 "............#.....#..#..........",
00384 "............#........###........",
00385 "............#...........#.......",
00386 "............#...........#.......",
00387 "......####..#...........#.......",
00388 ".....#....###...........#.......",
00389 "......##....##..........#.......",
00390 "........#..............#........",
00391 "......#..#.............#........",
00392 ".#...###..#............#........",
00393 ".##.#####..#..........#...#...#.",
00394 ".#########..#.........#..###.##.",
00395 ".##########..#........#.#######.",
00396 ".#########....#........########.",
00397 ".########...............#######.",
00398 ".#######.................######.",
00399 ".########...............#######.",
00400 ".#########.............########.",
00401 "................................",
00402 "................................",
00403 "................................",
00404 "................................"};
00405
00406
00407 static const char *Shadow_Dolly[]={
00408 "32 32 3 1",
00409 ". c None",
00410 "# c #ffffff",
00411 "? c #000000",
00412 "........?##?....................",
00413 ".......?#..#?...................",
00414 "......?#....#?..................",
00415 ".....?#......#?.................",
00416 "....?#..?##?..#?................",
00417 "...?#..?#..#?..#?...............",
00418 ".......?#..#?...................",
00419 ".......?#..#?...................",
00420 ".......?#..###?.................",
00421 ".......?#..#..###?..............",
00422 ".......?#.....#..#?.............",
00423 ".......?#........###?...........",
00424 ".......?#.........###?..........",
00425 "..??????#...........#?..........",
00426 ".?####??#...........#?..........",
00427 "?#....###...........#?..........",
00428 ".?##....##..........#?..........",
00429 "...?#..............#?...........",
00430 "....?#.............#?...........",
00431 ".....?#............#?...........",
00432 "......?#..........#?............",
00433 ".......?#.........#?............",
00434 "........?#........#?............",
00435 ".........?#........#?...........",
00436 "................................",
00437 "................................",
00438 "................................",
00439 "................................",
00440 "................................",
00441 "................................",
00442 "................................",
00443 "................................"};
00444
00445
00446 static const char *Shadow_Fly[]={
00447 "32 32 3 1",
00448 "# c None",
00449 ". c #ffffff",
00450 "? c #000000",
00451 "?.?##############################",
00452 "?..?#############################",
00453 "?...?############################",
00454 "?....?###########################",
00455 "?.....?##########################",
00456 "?......?#########################",
00457 "?.......?########################",
00458 "?........?#######################",
00459 "?......?#########################",
00460 "?.....?##########################",
00461 "?..#?..?#########################",
00462 "?.d###?..?#?.#####.?##############",
00463 "######?..?#?.###.?###############",
00464 "######?..?##?.#.?################",
00465 "#######???##?.#.?################",
00466 "#############?.?#################",
00467 "##############?##################",
00468 "#################################",
00469 "#################################",
00470 "#################################",
00471 "#################################",
00472 "#################################",
00473 "#################################",
00474 "#################################",
00475 "#################################",
00476 "#################################",
00477 "#################################",
00478 "#################################",
00479 "#################################",
00480 "#################################",
00481 "#################################",
00482 "#################################"};
00483
00484
00485 static const char *Shadow_Pan[]={
00486 "32 32 3 1",
00487 ". c None",
00488 "# c #ffffff",
00489 "? c #000000",
00490 ".............?##?...............",
00491 "............?#.?#?..............",
00492 "..........?###.?###?............",
00493 ".........?#.?#.?#.#?............",
00494 ".........?#.?#.?#?##?...........",
00495 ".........?#.?#.?#.?#?...........",
00496 "........?#..?#.?#.?##?..........",
00497 "...?##..?#.?#..?#.?#.#?.........",
00498 "..?#.?#?#..?#..?#.?#.#?.........",
00499 "..?#.?#.#..?#.?#..?#.#?.........",
00500 "..?#..?#..?#..?#.?#..#?.........",
00501 "..?#..?#......?#.?#..#?.........",
00502 "..?#..?#.....?#..?#..#?.........",
00503 ".?#..?#..........?#..#?.........",
00504 ".?#..?#.........?#.##?..........",
00505 ".?#.................#?..........",
00506 "..?#................#?..........",
00507 "..?#...............#?...........",
00508 "...?#..............#?...........",
00509 "...?#.............#?............",
00510 "....?#............#?............",
00511 ".....?#..........#?.............",
00512 ".....?#.........#?..............",
00513 ".....?#.........#?..............",
00514 "................................",
00515 "................................",
00516 "................................",
00517 "................................",
00518 "................................",
00519 "................................",
00520 "................................",
00521 "................................"};
00522
00523
00524 static const char *Shadow_Roll[]={
00525 "32 32 3 1",
00526 ". c None",
00527 "# c #ffffff",
00528 "? c #000000",
00529 "................................",
00530 ".....?..........................",
00531 "....?#?.........................",
00532 ".....?##?...????????............",
00533 ".....?##?..?########?...........",
00534 ".....?###.############?.........",
00535 ".....?######?......?####?.......",
00536 ".....?#####?.........?###?......",
00537 ".....?######?.........?###?.....",
00538 ".....?########?........?##?.....",
00539 "....?##########?........?##?....",
00540 "....?##?................?##?....",
00541 "...?##?..................?##?...",
00542 "...?##?..................?##?...",
00543 "...?##?..................?##?...",
00544 "...?##?.......?##?.......?##?...",
00545 "...?##?.......?##?.......?##?...",
00546 "...?##?..................?##?...",
00547 "...?##?..................?##?...",
00548 "...?##?..................?##?...",
00549 "....?##?.........?????????##?...",
00550 "....?##?........?##########?....",
00551 ".....?##?........?########?.....",
00552 ".....?##?..........?######?.....",
00553 "......?###?.........?#####?.....",
00554 ".......?####?......?######?.....",
00555 ".........?############?###?.....",
00556 "...........?########?..?##?.....",
00557 "............????????...?##?.....",
00558 "........................?#?.....",
00559 ".........................?......",
00560 "................................"};
00561
00562
00563 static const char *Shadow_Seek[]={
00564 "32 32 3 1",
00565 ". c None",
00566 "# c #ffffff",
00567 "? c #000000",
00568 "................................",
00569 "................................",
00570 "................................",
00571 "................................",
00572 ".............?###?..............",
00573 ".............?###?..............",
00574 ".............?###?..............",
00575 "............?#####?.............",
00576 "..........?#########?...........",
00577 ".........?###.###.###?..........",
00578 "........?##?..###..?##?.........",
00579 ".......?##?....#....?##?........",
00580 ".......?##?....#....?##?........",
00581 "......?##?.....#.....?##?.......",
00582 "...?#######?.......?#######?....",
00583 "...?##########?.?##########?....",
00584 "...?#######?.......?#######?....",
00585 "......?##?.....#.....?##?.......",
00586 ".......?##?....#....?##?........",
00587 ".......?##?....#....?##?........",
00588 "........?##?..###..?##?.........",
00589 ".........?###.###.###?..........",
00590 "..........?#########?...........",
00591 "............?#####?.............",
00592 ".............?###?..............",
00593 ".............?###?..............",
00594 ".............?###?..............",
00595 "................................",
00596 "................................",
00597 "................................",
00598 "................................",
00599 "................................"};
00600
00601
00602 static const char *Shadow_Spin[]={
00603 "32 32 3 1",
00604 ". c None",
00605 "# c #ffffff",
00606 "? c #000000",
00607 "................................",
00608 ".......?##?.....................",
00609 "...?###.#.?#?##.................",
00610 "..?#..?##?.?#.?#................",
00611 "..?#...?##.?##.?#...............",
00612 "...?##..?##.?##.?#..............",
00613 "....?#...?#..?#..?#.............",
00614 ".....?#..?##.?##.?#.............",
00615 "......?#..?#..?#..?#............",
00616 ".?#...?#..?#......?#............",
00617 "?#.##.?#..........?#............",
00618 "?#..?#?#...........?#...........",
00619 "?#..?#?d#...........?#..........",
00620 ".?#..?#............?#...........",
00621 "..?#...............?#...........",
00622 "..?#................?#..........",
00623 "...?#...............?#..........",
00624 "....?###............?#..........",
00625 ".......?##..........?#..........",
00626 ".........?#.........?#..........",
00627 "..........?#.........?#.........",
00628 "...........?#.........?#........",
00629 "............?#..................",
00630 ".............?#.................",
00631 "................................",
00632 "................................",
00633 "................................",
00634 "................................",
00635 "................................",
00636 "................................",
00637 "................................",
00638 "................................"};
00639
00640
00641 static const char *Shadow_Up[]={
00642 "32 32 3 1",
00643 ". c None",
00644 "# c #ffffff",
00645 "? c #000000",
00646 "................................",
00647 "............?...................",
00648 "...........?#...................",
00649 "..........?###...................",
00650 ".........?#####.................",
00651 "........?##.#.##................",
00652 "...........?#...................",
00653 "...........?#...................",
00654 "...........?#...................",
00655 "...........?#...................",
00656 "...........?#...................",
00657 "...........?#...................",
00658 "...........?#...................",
00659 ".......?????#?????????..........",
00660 "......?###############..........",
00661 ".....?#....?#......?#...........",
00662 ".....?#...?###.....?#...........",
00663 "....?#...?#.#.#...?#............",
00664 "....?#...?#.#.#...?#............",
00665 "...?#....?#...#..?#.............",
00666 "...?#.....?###...?#.............",
00667 "..?#........?...?#..............",
00668 "..?#............?#..............",
00669 ".?###############...............",
00670 "................................",
00671 "................................",
00672 "................................",
00673 "................................",
00674 "................................",
00675 "................................",
00676 "................................",
00677 "................................"};
00678
00679
00680 static const char *Shadow_Walk[]={
00681 "32 32 3 1",
00682 ". c None",
00683 "# c #ffffff",
00684 "? c #000000",
00685 "............?##.................",
00686 "...........?#.?#................",
00687 "..........?#...?#...............",
00688 ".........?#..??.?#..............",
00689 "........?##.?##?.?#.............",
00690 ".......?#..?#..#?.?#............",
00691 "...........?#..#?...............",
00692 "...........?#..#?...............",
00693 "...........?#..###?.............",
00694 "...........?#..#.###?...........",
00695 "...........?#....#.#?...........",
00696 "...........?#........###?.......",
00697 "...........?#...........#?......",
00698 "...........?#...........#?......",
00699 ".....?####.?#...........#?......",
00700 "....?#...?###...........#?......",
00701 ".....?##...?##..........#?......",
00702 ".......?#..............#?.......",
00703 ".....?#.?#.............#?.......",
00704 "?#..?###.?#............#?.......",
00705 "?##.#####.?#..........#?.?#..?#?",
00706 "?#########.?#.........#.?##..##?",
00707 "?##########.?#........#.#######?",
00708 "?#########?..?#.......?########?",
00709 "?########?.............?#######?",
00710 "?#######?...............?######?",
00711 "?########?.............?#######?",
00712 "?#########?...........?########?",
00713 "???????????...........??????????",
00714 "................................",
00715 "................................",
00716 "................................"};
00717
00718
00719 static const char *Xor_Dolly[]={
00720 "32 32 2 1",
00721 ". c None",
00722 "# c #ffffff",
00723 ".........##.....................",
00724 "........#..#....................",
00725 ".......#....#...................",
00726 "......#......#..................",
00727 ".....#...##...#.................",
00728 "....#...#..#...#................",
00729 "........#..#....................",
00730 "........#..#....................",
00731 "........#..###..................",
00732 "........#..#..###...............",
00733 "........#.....#..#..............",
00734 "........#........###............",
00735 "........#...........#...........",
00736 "........#...........#...........",
00737 "..####..#...........#...........",
00738 ".#....###...........#...........",
00739 "..##....##..........#...........",
00740 "....#..............#............",
00741 ".....#.............#............",
00742 "......#............#............",
00743 ".......#..........#.............",
00744 "........#.........#.............",
00745 ".........#........#.............",
00746 "..........#........#............",
00747 "................................",
00748 "................................",
00749 "................................",
00750 "................................",
00751 "................................",
00752 "................................",
00753 "................................",
00754 "................................"};
00755
00756
00757 static const char *Xor_Fly[]={
00758 "32 32 2 1",
00759 ". c None",
00760 "# c #ffffff",
00761 ".###############################",
00762 "..##############################",
00763 "...#############################",
00764 "....############################",
00765 ".....###########################",
00766 "......##########################",
00767 ".......#########################",
00768 "........########################",
00769 ".....###########################",
00770 "..#..###########################",
00771 ".###..##########################",
00772 "####..####.###.#################",
00773 "#####..###.###.#################",
00774 "#####..####.#.##################",
00775 "###########.#.##################",
00776 "############.###################",
00777 "################################",
00778 "################################",
00779 "################################",
00780 "################################",
00781 "################################",
00782 "################################",
00783 "################################",
00784 "################################",
00785 "################################",
00786 "################################",
00787 "################################",
00788 "################################",
00789 "################################",
00790 "################################",
00791 "################################",
00792 "################################"};
00793
00794
00795 static const char *Xor_Pan[]={
00796 "32 32 2 1",
00797 ". c None",
00798 "# c #ffffff",
00799 "..............##................",
00800 ".............#..#...............",
00801 "...........###..###.............",
00802 "..........#..#..#.#.............",
00803 "..........#..#..#.##............",
00804 "..........#..#..#..#............",
00805 ".........#...#..#..##...........",
00806 "....##...#..#...#..#.#..........",
00807 "...#..#.#...#...#..#.#..........",
00808 "...#..#.#...#..#...#.#..........",
00809 "...#...#...#...#..#..#..........",
00810 "...#...#.......#..#..#..........",
00811 "...#...#......#...#..#..........",
00812 "..#...#...........#..#..........",
00813 "..#...#..........#..#...........",
00814 "..#.................#...........",
00815 "...#................#...........",
00816 "...#...............#............",
00817 "....#..............#............",
00818 "....#.............#.............",
00819 ".....#............#.............",
00820 "......#..........#..............",
00821 "......#.........#...............",
00822 "......#.........#...............",
00823 "................................",
00824 "................................",
00825 "................................",
00826 "................................",
00827 "................................",
00828 "................................",
00829 "................................",
00830 "................................"};
00831
00832
00833 static const char *Xor_Roll[]={
00834 "32 32 2 1",
00835 ". c None",
00836 "# c #ffffff",
00837 "................................",
00838 "................................",
00839 "......#.........................",
00840 "......##........................",
00841 "......##....########............",
00842 "......###.############..........",
00843 "......######........####........",
00844 "......#####...........###.......",
00845 "......######...........###......",
00846 "......########..........##......",
00847 ".....##########..........##.....",
00848 ".....##..................##.....",
00849 "....##....................##....",
00850 "....##....................##....",
00851 "....##....................##....",
00852 "....##.........##.........##....",
00853 "....##.........##.........##....",
00854 "....##....................##....",
00855 "....##....................##....",
00856 "....##....................##....",
00857 ".....##..................##.....",
00858 ".....##..........##########.....",
00859 "......##..........########......",
00860 "......##............######......",
00861 ".......###...........#####......",
00862 "........####........######......",
00863 "..........############.###......",
00864 "............########....##......",
00865 "........................##......",
00866 ".........................#......",
00867 "................................",
00868 "................................"};
00869
00870
00871 static const char *Xor_Seek[]={
00872 "32 32 2 1",
00873 ". c None",
00874 "# c #ffffff",
00875 "................................",
00876 "................................",
00877 "................................",
00878 "................................",
00879 "..............###...............",
00880 "..............###...............",
00881 "..............###...............",
00882 ".............#####..............",
00883 "...........#########............",
00884 "..........###.###.###...........",
00885 ".........##...###...##..........",
00886 "........##.....#.....##.........",
00887 "........##.....#.....##.........",
00888 ".......##......#......##........",
00889 "....#######.........#######.....",
00890 "....##########...##########.....",
00891 "....#######.........#######.....",
00892 ".......##......#......##........",
00893 "........##.....#.....##.........",
00894 "........##.....#.....##.........",
00895 ".........##...###...##..........",
00896 "..........###.###.###...........",
00897 "...........#########............",
00898 ".............#####..............",
00899 "..............###...............",
00900 "..............###...............",
00901 "..............###...............",
00902 "................................",
00903 "................................",
00904 "................................",
00905 "................................",
00906 "................................"};
00907
00908
00909 static const char *Xor_Spin[]={
00910 "32 32 2 1",
00911 ". c None",
00912 "# c #ffffff",
00913 "................................",
00914 ".........##.....................",
00915 "....###.#..#.##.................",
00916 "...#...##...#..#................",
00917 "...#....##..##..#...............",
00918 "....##...##..##..#..............",
00919 ".....#....#...#...#.............",
00920 "......#...##..##..#.............",
00921 ".......#...#...#...#............",
00922 "..#....#...#.......#............",
00923 ".#.##..#...........#............",
00924 ".#...#.#............#...........",
00925 ".#...#.#............#...........",
00926 "..#...#.............#...........",
00927 "...#................#...........",
00928 "...#.................#..........",
00929 "....#................#..........",
00930 ".....###.............#..........",
00931 "........##...........#..........",
00932 "..........#..........#..........",
00933 "...........#..........#.........",
00934 "............#..........#........",
00935 ".............#..................",
00936 "..............#.................",
00937 "................................",
00938 "................................",
00939 "................................",
00940 "................................",
00941 "................................",
00942 "................................",
00943 "................................",
00944 "................................"};
00945
00946
00947 static const char *Xor_Up[]={
00948 "32 32 2 1",
00949 ". c None",
00950 "# c #ffffff",
00951 "................................",
00952 "................................",
00953 "............#...................",
00954 "...........###..................",
00955 "..........#####.................",
00956 ".........##.#.##................",
00957 "............#...................",
00958 "............#...................",
00959 "............#...................",
00960 "............#...................",
00961 "............#...................",
00962 "............#...................",
00963 "............#...................",
00964 "............#...................",
00965 ".......###############..........",
00966 "......#.....#.......#...........",
00967 "......#....###......#...........",
00968 ".....#....#.#.#....#............",
00969 ".....#....#.#.#....#............",
00970 "....#.....#...#...#.............",
00971 "....#......###....#.............",
00972 "...#.............#..............",
00973 "...#.............#..............",
00974 "..###############...............",
00975 "................................",
00976 "................................",
00977 "................................",
00978 "................................",
00979 "................................",
00980 "................................",
00981 "................................",
00982 "................................"};
00983
00984
00985 static const char *Xor_Walk[]={
00986 "32 32 2 1",
00987 ". c None",
00988 "# c #ffffff",
00989 ".............##.................",
00990 "............#..#................",
00991 "...........#....#...............",
00992 "..........#......#..............",
00993 ".........##..##...#.............",
00994 "........#...#..#...#............",
00995 "............#..#................",
00996 "............#..#................",
00997 "............#..###..............",
00998 "............#..#..###...........",
00999 "............#.....#..#..........",
01000 "............#........###........",
01001 "............#...........#.......",
01002 "............#...........#.......",
01003 "......####..#...........#.......",
01004 ".....#....###...........#.......",
01005 "......##....##..........#.......",
01006 "........#..............#........",
01007 "......#..#.............#........",
01008 ".#...###..#............#........",
01009 ".##.#####..#..........#...#...#.",
01010 ".#########..#.........#..###.##.",
01011 ".##########..#........#.#######.",
01012 ".#########....#........########.",
01013 ".########...............#######.",
01014 ".#######.................######.",
01015 ".########...............#######.",
01016 ".#########.............########.",
01017 "................................",
01018 "................................",
01019 "................................",
01020 "................................"};
01021
01022 #endif
01023
01024
01025
01026