test/layers/layerstest.c

   1 /*
   2     Copyright © 1995-2014, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #include <stdio.h>
   7 #include <string.h>
   8 #include <exec/types.h>
   9 #include <aros/asmcall.h>
  10 #include <graphics/rastport.h>
  11 #include <graphics/regions.h>
  12 #include <graphics/layers.h>
  13 #include <graphics/clip.h>
  14 #include <intuition/intuition.h>
  15 #include <proto/dos.h>
  16 #include <proto/exec.h>
  17 #include <proto/graphics.h>
  18 #include <proto/intuition.h>
  19 #include <proto/layers.h>
  20
  21 #define GFX_SYSTEM X11  /* ord HIDD */
  22
  23 struct IntuitionBase *IntuitionBase;
  24 struct GfxBase *GfxBase;
  25 struct Library *LayersBase;
  26 struct DosLibrary *DOSBase;
  27 struct Screen *screen;
  28 struct Window * window;
  29
  30 void doall(void);
  31 struct Screen * openscreen(void);
  32 void closescreen(struct Screen * screen);
  33
  34 APTR BltBitMapPtr;
  35
  36 int main(int argc, char **argv)
  37 {
  38     if ((IntuitionBase = (struct IntuitionBase *) OpenLibrary("intuition.library", 0)))
  39     {
  40         if ((GfxBase = (struct GfxBase *)OpenLibrary("graphics.library", 0)))
  41         {
  42           if ((LayersBase = OpenLibrary("layers.library", 0)))
  43           {
  44             if ((DOSBase = (struct DosLibrary *) OpenLibrary("dos.library",0)))
  45             {
  46               if ((screen = openscreen()))
  47               {
  48                 doall();
  49                 closescreen(screen);
  50               }
  51               CloseLibrary((struct Library *)DOSBase);
  52             }
  53             CloseLibrary(LayersBase);
  54           }
  55           CloseLibrary((struct Library *)GfxBase);
  56         }
  57         CloseLibrary((struct Library *) IntuitionBase);
  58     }
  59     return 0;
  60 } /* main */
  61
  62
  63 struct Screen * openscreen(void)
  64 {
  65   struct Screen * screen;
  66
  67   screen = OpenScreenTags(NULL,
  68                           SA_Height, 200,
  69                           SA_Width, 300,
  70                           TAG_END);
  71
  72   Draw(&screen->RastPort, 100, 100);
  73
  74   return screen;
  75 }
  76
  77 void closescreen(struct Screen * screen)
  78 {
  79   CloseScreen(screen);
  80 }
  81
  82 struct Layer *layers[10];
  83
  84 void freelayers(void)
  85 {
  86   int i;
  87   for (i=0; i < 10; i++)
  88   {
  89     if (NULL != layers[i])
  90     {
  91       DeleteLayer(0, layers[i]);
  92       if (layers[i]->SuperBitMap)
  93         FreeBitMap(layers[i]->SuperBitMap);
  94     }
  95   }
  96 }
  97
  98 int unusedlayer(void)
  99 {
 100   int i;
 101   for (i =0; i < 10; i++)
 102   {
 103     if (NULL == layers[i])
 104       return i;
 105   }
 106   return -1;
 107 }
 108
 109 void createupfrontlayer(void)
 110 {
 111   int x0,y0,x1,y1;
 112   int i;
 113   char c,s;
 114   LONG flags = 0;
 115   struct BitMap * sb = NULL;
 116   for (i = 0; i < 10; i++)
 117   {
 118     if (layers[i] == NULL)
 119       break;
 120   }
 121   if (i < 10)
 122   {
 123       printf("Backdroplayer [y/N]: ");
 124       scanf("%c", &c);
 125       printf("SuperBitMap [y/N]: ");
 126       scanf("%c", &s);
 127       printf("x0: ");
 128       scanf("%d", &x0);
 129       printf("y0: ");
 130       scanf("%d", &y0);
 131       printf("x1: ");
 132       scanf("%d", &x1);
 133       printf("y1: ");
 134       scanf("%d", &y1);
 135
 136       if (c=='y' || c=='Y')
 137       {
 138         printf("Generating a backdrop layer.\n");
 139         flags |= LAYERBACKDROP;
 140       }
 141       if (s=='y' || s=='Y')
 142       {
 143         printf("Generating a superbitmap layer.\n");
 144         flags |= LAYERSUPER;
 145         sb = AllocBitMap(x1-x0+1,y1-y0+1,1,BMF_CLEAR,NULL);
 146       }
 147
 148       flags |= LAYERSMART;
 149
 150       layers[i] = CreateUpfrontLayer(&screen->LayerInfo,
 151                                      screen->RastPort.BitMap,
 152                                      x0,
 153                                      y0,
 154                                      x1,
 155                                      y1,
 156                                      flags,
 157                                      sb);
 158       if (layers[i])
 159         printf("Created layer with ID %d\n",i);
 160       else
 161         printf("Couldn't create layer. No more memory (?).\n");
 162   }
 163   else
 164     printf("No more layers possible!\n");
 165 }
 166
 167 void createbehindlayer(void)
 168 {
 169   int x0,y0,x1,y1;
 170   int i;
 171   char c, s;
 172   LONG flags = 0;
 173   struct BitMap * sb = NULL;
 174   for (i = 0; i < 10; i++)
 175   {
 176     if (layers[i] == NULL)
 177       break;
 178   }
 179   if (i < 10)
 180   {
 181       printf("Backdroplayer [y/N]: ");
 182       scanf("%c", &c);
 183       printf("SuperBitMap [y/N]: ");
 184       scanf("%c", &s);
 185       printf("x0: ");
 186       scanf("%d", &x0);
 187       printf("y0: ");
 188       scanf("%d", &y0);
 189       printf("x1: ");
 190       scanf("%d", &x1);
 191       printf("y1: ");
 192       scanf("%d", &y1);
 193
 194       if (c=='y' || c=='Y')
 195       {
 196         printf("Generating a backdrop layer.\n");
 197         flags |= LAYERBACKDROP;
 198       }
 199       if (s=='y' || s=='Y')
 200       {
 201         printf("Generating a superbitmap layer.\n");
 202         flags |= LAYERSUPER;
 203         sb = AllocBitMap(x1-x0+1,y1-y0+1,1,BMF_CLEAR,NULL);
 204       }
 205
 206       flags |= LAYERSMART;
 207
 208       layers[i] = CreateBehindLayer(&screen->LayerInfo,
 209                                      screen->RastPort.BitMap,
 210                                      x0,
 211                                      y0,
 212                                      x1,
 213                                      y1,
 214                                      flags,
 215                                      sb);
 216       if (layers[i])
 217          printf("Created layer with ID %d\n",i);
 218       else
 219         printf("Couldn't create layer. No more memory (?).\n");
 220   }
 221   else
 222     printf("No more layers possible!\n");
 223 }
 224
 225 void deletelayer(void)
 226 {
 227   int i;
 228   printf("Delete layer with id: ");
 229   scanf("%d", &i);
 230   if (layers[i])
 231   {
 232     DeleteLayer(0, layers[i]);
 233     if (layers[i]->SuperBitMap)
 234       FreeBitMap(layers[i]->SuperBitMap);
 235     printf("Deleted layer with id %d\n",i);
 236     layers[i] = NULL;
 237   }
 238   else
 239   {
 240     printf("No layer with id %d\n",i);
 241   }
 242 }
 243
 244 void upfrontlayer(void)
 245 {
 246   int i;
 247   printf("Upfront layer with id: ");
 248   scanf("%d", &i);
 249   if (layers[i]) {
 250     UpfrontLayer(0, layers[i]);
 251     printf("Moved layer with id %d upfront\n",i);
 252   }
 253   else
 254   {
 255     printf("No layer with id %d\n",i);
 256   }
 257 }
 258
 259 void behindlayer(void)
 260 {
 261   int i;
 262   printf("Behind layer with id: ");
 263   scanf("%d", &i);
 264   if (layers[i]) {
 265     BehindLayer(0, layers[i]);
 266     printf("Moved layer with id %d behind\n",i);
 267   }
 268   else
 269   {
 270     printf("No layer with id %d\n",i);
 271   }
 272 }
 273
 274 void movelayerinfrontof(void)
 275 {
 276   int i1,i2;
 277   printf("Move layer with id: ");
 278   scanf("%d", &i1);
 279   printf("in front of layer with id: ");
 280   scanf("%d", &i2);
 281   if (layers[i1] && layers[i2]) {
 282     MoveLayerInFrontOf(layers[i1], layers[i2]);
 283     printf("Moved layer with id %d in front of layer with id %d\n",i1,i2);
 284   }
 285   else
 286   {
 287     printf("No layer with id %d or id %d\n",i1,i2);
 288   }
 289 }
 290
 291 void movelayer(void)
 292 {
 293   int i,dx,dy;
 294   printf("Move layer with id: ");
 295   scanf("%d",&i);
 296   printf("delta x: ");
 297   scanf("%d",&dx);
 298   printf("delta y: ");
 299   scanf("%d",&dy);
 300   if (layers[i])
 301   {
 302     MoveLayer(0, layers[i], dx, dy);
 303     printf("Moved layer with id %d to new position.\n",i);
 304   }
 305   else
 306   {
 307     printf("No layer with id %d\n",i);
 308   }
 309 }
 310
 311 void movesizelayer(void)
 312 {
 313   int i,dx,dy,dw,dh;
 314   printf("Move and size layer with id: ");
 315   scanf("%d",&i);
 316   printf("delta x: ");
 317   scanf("%d",&dx);
 318   printf("delta y: ");
 319   scanf("%d",&dy);
 320   printf("delta width: ");
 321   scanf("%d",&dw);
 322   printf("delta height: ");
 323   scanf("%d",&dh);
 324   if (layers[i])
 325   {
 326     MoveSizeLayer(layers[i], dx, dy, dw, dh);
 327     printf("Moved and sized layer with id %d.\n",i);
 328   }
 329   else
 330   {
 331     printf("No layer with id %d\n",i);
 332   }
 333 }
 334
 335 void sizelayer(void)
 336 {
 337   int i,dx,dy;
 338   printf("Resize layer with id: ");
 339   scanf("%d",&i);
 340   printf("delta width: ");
 341   scanf("%d",&dx);
 342   printf("delta height: ");
 343   scanf("%d",&dy);
 344   if (layers[i])
 345   {
 346     SizeLayer(0, layers[i], dx, dy);
 347     printf("Resized layer with id %d.\n",i);
 348   }
 349   else
 350   {
 351     printf("No layer with id %d\n",i);
 352   }
 353 }
 354
 355 void scrolllayer(void)
 356 {
 357   int i,dx,dy;
 358   printf("Scroll layer with id: ");
 359   scanf("%d",&i);
 360   if (NULL == layers[i])
 361   {
 362     printf("No layer with id %d\n",i);
 363   }
 364
 365   printf("delta x: ");
 366   scanf("%d",&dx);
 367   printf("delta y: ");
 368   scanf("%d",&dy);
 369
 370   if (0 == (layers[i]->Flags & LAYERSUPER))
 371     printf("This is a non-superbitmapped layer.\n");
 372   else
 373     printf("This is a superbitmapped layer.\n");
 374
 375   ScrollLayer(0, layers[i], dx, dy);
 376   printf("Scrolled layer with id %d.\n",i);
 377
 378 }
 379
 380 void motion(void)
 381 {
 382   int i,dx,dy,iter;
 383   printf("Move layer with id: ");
 384   scanf("%d",&i);
 385   printf("delta x: ");
 386   scanf("%d",&dx);
 387   printf("delta y: ");
 388   scanf("%d",&dy);
 389   printf("iterations: ");
 390   scanf("%d",&iter);
 391   if (layers[i])
 392   {
 393     while (iter > 0 && (TRUE == MoveLayer(0, layers[i],dx,dy)))
 394       iter--;
 395     printf("Moved layer with id %d to new position.\n",i);
 396   }
 397   else
 398   {
 399     printf("No layer with id %d\n",i);
 400   }
 401 }
 402
 403 /* Draw a simple frame around a layer */
 404 void frame(struct Layer * layer)
 405 {
 406     int c, width = layer->bounds.MaxX-layer->bounds.MinX,i=0;
 407     SetAPen(layer->rp, 1);
 408     Move(layer->rp, 0,0);
 409     Draw(layer->rp, layer->bounds.MaxX - layer->bounds.MinX, 0);
 410     Draw(layer->rp, layer->bounds.MaxX - layer->bounds.MinX,
 411                     layer->bounds.MaxY - layer->bounds.MinY);
 412     Draw(layer->rp, 0, layer->bounds.MaxY - layer->bounds.MinY);
 413     Draw(layer->rp, 0, 0);
 414     Draw(layer->rp, layer->bounds.MaxX - layer->bounds.MinX,
 415                     layer->bounds.MaxY - layer->bounds.MinY);
 416
 417     for (c=0; c <= width; c= c+(width&0x0f)+i )
 418     {
 419       i+=2;
 420       Move(layer->rp,c,0);
 421       Draw(layer->rp,c,layer->bounds.MaxY - layer->bounds.MinY);
 422     }
 423 }
 424
 425 void Frame(void)
 426 {
 427   int i;
 428   printf("Framing layer with id: ");
 429   scanf("%d", &i);
 430   if (layers[i])
 431   {
 432     /* Draw a Frame */
 433     frame(layers[i]);
 434   }
 435   else
 436   {
 437     printf("No layer with id %d\n",i);
 438   }
 439 }
 440
 441 void GenerateLayers1(void)
 442 {
 443   int i;
 444   i = unusedlayer();
 445   if (i==-1) return;
 446   layers[i] = CreateUpfrontLayer(&screen->LayerInfo,
 447                                  screen->RastPort.BitMap,
 448                                  10,
 449                                  10,
 450                                  100,
 451                                  100,
 452                                  LAYERSMART,
 453                                  NULL);
 454
 455   frame(layers[i]);
 456
 457   i = unusedlayer();
 458   if (i==-1) return;
 459   layers[i] = CreateUpfrontLayer(&screen->LayerInfo,
 460                                  screen->RastPort.BitMap,
 461                                  50,
 462                                  50,
 463                                  150,
 464                                  150,
 465                                  LAYERSMART,
 466                                  NULL);
 467
 468   frame(layers[i]);
 469
 470   i = unusedlayer();
 471   if (i==-1) return;
 472   layers[i] = CreateUpfrontLayer(&screen->LayerInfo,
 473                                  screen->RastPort.BitMap,
 474                                  20,
 475                                  20,
 476                                  120,
 477                                  70,
 478                                  LAYERSMART,
 479                                  NULL);
 480
 481   frame(layers[i]);
 482 }
 483
 484 void GenerateLayers2(void)
 485 {
 486   int i;
 487   i = unusedlayer();
 488   layers[i] = CreateBehindLayer(&screen->LayerInfo,
 489                                  screen->RastPort.BitMap,
 490                                  10,
 491                                  10,
 492                                  100,
 493                                  95,
 494                                  LAYERSMART,
 495                                  NULL);
 496
 497   frame(layers[i]);
 498
 499   i = unusedlayer();
 500   layers[i] = CreateBehindLayer(&screen->LayerInfo,
 501                                  screen->RastPort.BitMap,
 502                                  50,
 503                                  50,
 504                                  150,
 505                                  150,
 506                                  LAYERSMART,
 507                                  NULL);
 508
 509   frame(layers[i]);
 510
 511   i = unusedlayer();
 512   layers[i] = CreateBehindLayer(&screen->LayerInfo,
 513                                  screen->RastPort.BitMap,
 514                                  70,
 515                                  130,
 516                                  140,
 517                                  190,
 518                                  LAYERSMART,
 519                                  NULL);
 520
 521   frame(layers[i]);
 522
 523   i = unusedlayer();
 524   layers[i] = CreateBehindLayer(&screen->LayerInfo,
 525                                  screen->RastPort.BitMap,
 526                                  120,
 527                                  120,
 528                                  150,
 529                                  160,
 530                                  LAYERSMART,
 531                                  NULL);
 532
 533   frame(layers[i]);
 534 }
 535
 536 void GenerateLayers3(void)
 537 {
 538   int i;
 539   i = unusedlayer();
 540   layers[i] = CreateBehindLayer(&screen->LayerInfo,
 541                                  screen->RastPort.BitMap,
 542                                  110,
 543                                  110,
 544                                  200,
 545                                  195,
 546                                  LAYERSMART,
 547                                  NULL);
 548
 549   frame(layers[i]);
 550
 551   i = unusedlayer();
 552   layers[i] = CreateBehindLayer(&screen->LayerInfo,
 553                                  screen->RastPort.BitMap,
 554                                  150,
 555                                  150,
 556                                  190,
 557                                  190,
 558                                  LAYERSMART,
 559                                  NULL);
 560
 561   frame(layers[i]);
 562
 563   i = unusedlayer();
 564   layers[i] = CreateBehindLayer(&screen->LayerInfo,
 565                                  screen->RastPort.BitMap,
 566                                  70,
 567                                  130,
 568                                  140,
 569                                  190,
 570                                  LAYERSMART,
 571                                  NULL);
 572   frame(layers[i]);
 573
 574   i = unusedlayer();
 575   layers[i] = CreateBehindLayer(&screen->LayerInfo,
 576                                  screen->RastPort.BitMap,
 577                                  120,
 578                                  120,
 579                                  150,
 580                                  160,
 581                                  LAYERSMART,
 582                                  NULL);
 583
 584   frame(layers[i]);
 585 }
 586
 587 void GenerateLayers4(void)
 588 {
 589   int i;
 590   int c = 0;
 591   while (c < 5)
 592   {
 593     i = unusedlayer();
 594     if (-1 == i)
 595       return;
 596     layers[i] = CreateBehindLayer(&screen->LayerInfo,
 597                                    screen->RastPort.BitMap,
 598                                    10+c*10,
 599                                    10+c*10,
 600                                    100+c*10,
 601                                    100+c*10,
 602                                    LAYERSMART,
 603                                    NULL);
 604     frame(layers[i]);
 605     c++;
 606   }
 607 }
 608
 609 void DemoA(void)
 610 {
 611 #define DELAYTIME 50
 612   int i;
 613   printf("Deleting all previously generated layers...\n");
 614   for (i = 0; i < 10; i++)
 615   {
 616     if (layers[i])
 617     {
 618       DeleteLayer(0, layers[i]);
 619       layers[i] = NULL;
 620     }
 621   }
 622   i = 0;
 623
 624   printf("After each step there will be a short delay.\n");
 625   printf("Activate other X-window (Amiga Screen) and always press a key\nto see what is going on\n");
 626   printf("Creating layer %i.\n",i);
 627   Delay(DELAYTIME);
 628   layers[i] = CreateUpfrontLayer(&screen->LayerInfo,
 629                                  screen->RastPort.BitMap,
 630                                  10,
 631                                  10,
 632                                  100,
 633                                  100,
 634                                  LAYERSMART,
 635                                  NULL);
 636
 637   frame(layers[i]);
 638
 639   printf("Creating layer %i.\n",++i);
 640   Delay(DELAYTIME);
 641   layers[i] = CreateUpfrontLayer(&screen->LayerInfo,
 642                                  screen->RastPort.BitMap,
 643                                  20,
 644                                  5,
 645                                  30,
 646                                  150,
 647                                  LAYERSMART,
 648                                  NULL);
 649   frame(layers[i]);
 650
 651   printf("Creating layer %i.\n",++i);
 652   Delay(DELAYTIME);
 653   layers[i] = CreateUpfrontLayer(&screen->LayerInfo,
 654                                  screen->RastPort.BitMap,
 655                                  5,
 656                                  50,
 657                                  150,
 658                                  70,
 659                                  LAYERSMART,
 660                                  NULL);
 661   frame(layers[i]);
 662
 663   printf("Creating layer %i.\n",++i);
 664   Delay(DELAYTIME);
 665   layers[i] = CreateUpfrontLayer(&screen->LayerInfo,
 666                                  screen->RastPort.BitMap,
 667                                  80,
 668                                  5,
 669                                  180,
 670                                  200,
 671                                  LAYERSMART,
 672                                  NULL);
 673   frame(layers[i]);
 674
 675   i = 0;
 676   printf("Moving layer %i in front of all other layers.\n",i);
 677   Delay(DELAYTIME);
 678   UpfrontLayer(0, layers[i]);
 679
 680   i = 1;
 681   printf("Moving layer %i in front of all other layers.\n",i);
 682   Delay(DELAYTIME);
 683   UpfrontLayer(0, layers[i]);
 684
 685   i = 2;
 686   printf("Moving layer %i in front of all other layers.\n",i);
 687   Delay(DELAYTIME);
 688   UpfrontLayer(0, layers[i]);
 689
 690   i = 3;
 691   printf("Moving layer %i in front of all other layers.\n",i);
 692   Delay(DELAYTIME);
 693   UpfrontLayer(0, layers[i]);
 694
 695
 696   i = 0;
 697   printf("Moving layer %i in front of all other layers.\n",i);
 698   Delay(DELAYTIME);
 699   UpfrontLayer(0, layers[i]);
 700
 701   i = 2;
 702   printf("Moving layer %i in front of all other layers.\n",i);
 703   Delay(DELAYTIME);
 704   UpfrontLayer(0, layers[i]);
 705
 706   i = 2;
 707   printf("Moving layer %i in front of all other layers.\n",i);
 708   Delay(DELAYTIME);
 709   UpfrontLayer(0, layers[i]);
 710
 711   i = 1;
 712   printf("Moving layer %i in front of all other layers.\n",i);
 713   Delay(DELAYTIME);
 714   UpfrontLayer(0, layers[i]);
 715
 716   i = 2;
 717   printf("Moving layer %i in front of all other layers.\n",i);
 718   Delay(DELAYTIME);
 719   UpfrontLayer(0, layers[i]);
 720
 721   for (i = 0; i < 10; i++)
 722     if (NULL != layers[i])
 723     {
 724       printf("Destroying layer %i.\n",i);
 725       Delay(DELAYTIME);
 726       DeleteLayer(0, layers[i]);
 727       layers[i] = NULL;
 728     }
 729
 730   printf("End of demo .\n");
 731 }
 732
 733 void DemoB(void)
 734 {
 735 #undef DELAYTIME
 736 #define DELAYTIME 100
 737   int i;
 738   printf("Deleting all previously generated layers...\n");
 739   for (i = 0; i < 10; i++)
 740   {
 741     if (layers[i])
 742     {
 743       DeleteLayer(0, layers[i]);
 744       layers[i] = NULL;
 745     }
 746   }
 747   i = 0;
 748
 749   printf("After each step there will be a short delay.\n");
 750   printf("Activate other X-window (Amiga Screen) and always press a key\nto see what is going on\n");
 751   printf("Creating behind-layer %i.\n",i);
 752   Delay(DELAYTIME);
 753   layers[i] = CreateBehindLayer(&screen->LayerInfo,
 754                                  screen->RastPort.BitMap,
 755                                  10,
 756                                  10,
 757                                  100,
 758                                  100,
 759                                  LAYERSMART,
 760                                  NULL);
 761
 762   frame(layers[i]);
 763
 764   printf("Creating behind-layer %i.\n",++i);
 765   Delay(DELAYTIME);
 766   layers[i] = CreateBehindLayer(&screen->LayerInfo,
 767                                  screen->RastPort.BitMap,
 768                                  50,
 769                                  50,
 770                                  120,
 771                                  120,
 772                                  LAYERSMART,
 773                                  NULL);
 774
 775   frame(layers[i]);
 776
 777   printf("Creating behind-layer %i.\n",++i);
 778   Delay(DELAYTIME);
 779   layers[i] = CreateBehindLayer(&screen->LayerInfo,
 780                                  screen->RastPort.BitMap,
 781                                  70,
 782                                  30,
 783                                  140,
 784                                  90,
 785                                  LAYERSMART,
 786                                  NULL);
 787   frame(layers[i]);
 788
 789
 790   printf("Creating behind-layer %i.\n",++i);
 791   Delay(DELAYTIME);
 792   layers[i] = CreateBehindLayer(&screen->LayerInfo,
 793                                  screen->RastPort.BitMap,
 794                                  20,
 795                                  20,
 796                                  150,
 797                                  60,
 798                                  LAYERSMART,
 799                                  NULL);
 800
 801   frame(layers[i]);
 802
 803   i = 2;
 804   printf("Moving layer %i in front of all other layers.\n",i);
 805   Delay(DELAYTIME);
 806   UpfrontLayer(0, layers[i]);
 807
 808   printf("Moving layer %i in front of layer %i\n",3,0);
 809   Delay(DELAYTIME);
 810   MoveLayerInFrontOf(layers[3], layers[0]);
 811
 812   printf("Moving layer %i in front of layer %i\n",0,3);
 813   Delay(DELAYTIME);
 814   MoveLayerInFrontOf(layers[0], layers[3]);
 815
 816   i = 1;
 817   printf("Moving layer %i in front of all other layers.\n",i);
 818   Delay(DELAYTIME);
 819   UpfrontLayer(0, layers[i]);
 820
 821   i = 0;
 822   printf("Moving layer %i in front of all other layers.\n",i);
 823   Delay(DELAYTIME);
 824   UpfrontLayer(0, layers[i]);
 825
 826   i = 1;
 827   printf("Moving layer %i behind all other layers.\n",i);
 828   Delay(DELAYTIME);
 829   BehindLayer(0, layers[i]);
 830
 831   for (i = 0; i < 10; i++)
 832     if (NULL != layers[i])
 833     {
 834       printf("Destroying layer %i.\n",i);
 835       Delay(DELAYTIME);
 836       DeleteLayer(0, layers[i]);
 837       layers[i] = NULL;
 838     }
 839
 840   printf("End of demo .\n");
 841
 842 }
 843
 844 void DemoC()
 845 {
 846   int i;
 847   printf("Generating a few layers\n");
 848   GenerateLayers2();
 849   if (layers[1])
 850   {
 851     printf("Moving layer 1...\n");
 852     Delay(30);
 853     i = 50;
 854     while (i>0 && (TRUE == MoveLayer(0, layers[1], 1,1)))
 855         i--;
 856   }
 857   if (layers[2])
 858   {
 859     printf("Moving layer 2...\n");
 860     Delay(30);
 861     i = 50;
 862     while (i>0 && (TRUE == MoveLayer(0, layers[2], 2, -1)))
 863       i--;
 864   }
 865   if (layers[3])
 866   {
 867     printf("Moving layer 3...\n");
 868     Delay(30);
 869     i = 50;
 870     while (i>0 && TRUE == MoveLayer(0, layers[3], 1, 3))
 871       i--;
 872   }
 873   if (layers[0])
 874   {
 875     printf("Moving layer 0...\n");
 876     Delay(30);
 877     i = 150;
 878     while (i>0 && TRUE == MoveLayer(0, layers[0], 0 ,1))
 879       i--;
 880   }
 881   printf("Deleting all visible layers!\n");
 882   i = 0;
 883   while (i < 10)
 884   {
 885     if (layers[i])
 886       DeleteLayer(0, layers[i]);
 887     layers[i] = NULL;
 888     i++;
 889   }
 890 }
 891
 892
 893 void DemoD()
 894 {
 895   int i;
 896   int c;
 897   struct BitMap * sb;
 898   printf("Deleting all previously generated layers...\n");
 899   for (i = 0; i < 10; i++)
 900   {
 901     if (layers[i])
 902     {
 903       DeleteLayer(0, layers[i]);
 904       layers[i] = NULL;
 905     }
 906   }
 907   i = 0;
 908
 909   printf("Creating 4 superbitmap layers\n");
 910
 911   sb = AllocBitMap(91,91,1,BMF_CLEAR,NULL);
 912
 913   layers[0] = CreateUpfrontLayer(&screen->LayerInfo,
 914                                  screen->RastPort.BitMap,
 915                                  10,
 916                                  10,
 917                                  100,
 918                                  100,
 919                                  LAYERSMART|LAYERSUPER,
 920                                  sb);
 921
 922   frame(layers[0]);
 923
 924   sb = AllocBitMap(71,71,1,BMF_CLEAR,NULL);
 925   layers[1] = CreateUpfrontLayer(&screen->LayerInfo,
 926                                  screen->RastPort.BitMap,
 927                                  50,
 928                                  50,
 929                                  120,
 930                                  120,
 931                                  LAYERSMART|LAYERSUPER,
 932                                  sb);
 933
 934   frame(layers[1]);
 935
 936   sb = AllocBitMap(71,61,1,BMF_CLEAR,NULL);
 937   layers[2] = CreateUpfrontLayer(&screen->LayerInfo,
 938                                  screen->RastPort.BitMap,
 939                                  70,
 940                                  30,
 941                                  140,
 942                                  90,
 943                                  LAYERSMART|LAYERSUPER,
 944                                  sb);
 945   frame(layers[2]);
 946
 947   sb = AllocBitMap(131,41,1,BMF_CLEAR,NULL);
 948   layers[3] = CreateUpfrontLayer(&screen->LayerInfo,
 949                                  screen->RastPort.BitMap,
 950                                  20,
 951                                  20,
 952                                  150,
 953                                  60,
 954                                  LAYERSMART|LAYERSUPER,
 955                                  sb);
 956
 957   frame(layers[3]);
 958
 959   printf("Resizing layer 4\n");
 960   Delay(30);
 961   SizeLayer(0, layers[3], -80, -10);
 962   /* this leaves width = 51, height = 31 */
 963   printf("Scrolling layer 4\n");
 964   Delay(30);
 965   c = 0;
 966   while (c < 80)
 967   {
 968     c++;
 969     Delay(5);
 970     ScrollLayer(0, layers[3], 1, 0);
 971   }
 972
 973   c = 0;
 974   while (c < 10)
 975   {
 976     c++;
 977     Delay(5);
 978     ScrollLayer(0, layers[3], 0 ,1);
 979   }
 980
 981   c = 0;
 982   while (c < 10)
 983   {
 984     c++;
 985     Delay(5);
 986     ScrollLayer(0, layers[3], -8 ,-1);
 987   }
 988
 989   printf("Resizing layer 4 to its full size\n");
 990   Delay(30);
 991   SizeLayer(0, layers[3], 80, 10);
 992
 993   printf("Resizing layer 1\n");
 994   SizeLayer(0, layers[0], -50, -50);
 995
 996   /* this leaves width = 41, height = 41 */
 997   printf("Scrolling layer 1\n");
 998   Delay(30);
 999   c = 0;
1000   while (c < 41)
1001   {
1002     c++;
1003     Delay(5);
1004     ScrollLayer(0, layers[0], 1, 0);
1005   }
1006
1007   c = 0;
1008   while (c < 41)
1009   {
1010     c++;
1011     Delay(5);
1012     ScrollLayer(0, layers[0], 0 ,1);
1013   }
1014
1015   c = 0;
1016   while (c < 41)
1017   {
1018     c++;
1019     Delay(5);
1020     ScrollLayer(0, layers[0], -1 ,-1);
1021   }
1022
1023   printf("Resizing layer 1 to its full size\n");
1024   Delay(30);
1025   SizeLayer(0, layers[0], 50, 50);
1026
1027   printf("Shuffling layers...\n");
1028   UpfrontLayer(0, layers[0]);
1029   Delay(20);
1030   UpfrontLayer(0, layers[1]);
1031   Delay(20);
1032   UpfrontLayer(0, layers[2]);
1033   Delay(20);
1034   UpfrontLayer(0, layers[3]);
1035   Delay(20);
1036   BehindLayer(0, layers[2]);
1037   Delay(20);
1038   BehindLayer(0,layers[1]);
1039   Delay(20);
1040   BehindLayer(0,layers[0]);
1041   printf("Inviting a few smart friends...\n");
1042   GenerateLayers3();
1043   printf("Moving the layers...\n");
1044   c = 0;
1045   while (c < 40)
1046   {
1047     MoveLayer(0, layers[4], -1, -1);
1048     MoveLayer(0, layers[0], 1,2);
1049     MoveLayer(0, layers[2], 2,1);
1050     MoveLayer(0, layers[5], -2, 0);
1051     c++;
1052   }
1053
1054   c = 0;
1055   while (c < 30)
1056   {
1057     MoveLayer(0, layers[4], -1, -1);
1058     MoveLayer(0, layers[5], -1, 0);
1059     MoveLayer(0, layers[3], 3, 2);
1060     MoveSizeLayer(layers[2], 2, -1, -1, -1);
1061     c++;
1062   }
1063
1064   c = 0;
1065   while (c < 30)
1066   {
1067     MoveSizeLayer(layers[2], -2, 1, 1 ,1);
1068     MoveSizeLayer(layers[1],  2, 0, -1 ,-1);
1069     MoveLayer(0, layers[5], 2, 1);
1070     c++;
1071   }
1072
1073   c = 0;
1074   while (c < 30)
1075   {
1076     MoveSizeLayer(layers[1], -1, -1 ,1 , 1);
1077     c++;
1078   }
1079
1080   printf("Deleting the layers...\n");
1081   i = 0;
1082   while (i < 8)
1083   {
1084     while ((layers[i]->bounds.MaxX - layers[i]->bounds.MinX) >= 1 &&
1085            (layers[i]->bounds.MaxY - layers[i]->bounds.MinY) >= 1)
1086     {
1087       MoveSizeLayer(layers[i], 2, 0, -1, -1);
1088     }
1089     DeleteLayer(0, layers[i]);
1090     layers[i] = NULL;
1091     i++;
1092   }
1093 }
1094
1095 void DumpCliprects(void)
1096 {
1097   int i;
1098   struct ClipRect * CR;
1099   int c;
1100
1101   printf("Dump ClipRects of which layer? ");
1102   scanf("%i",&i);
1103   if (i < 0 || i > 10 || NULL == layers[i])
1104   {
1105     printf("No such layer!\n");
1106     return;
1107   }
1108
1109   printf("Layer at %px is a ",layers[i]);
1110   if (0 != (layers[i]->Flags & LAYERSIMPLE))
1111     printf("simple layer\n");
1112   else if (0 != (layers[i]->Flags & LAYERSUPER))
1113     printf("superbitmap layer\n");
1114   else
1115     printf("smart layer\n");
1116
1117   c = 1;
1118   CR = layers[i]->ClipRect;
1119   while (NULL != CR)
1120   {
1121     printf("CR #%i\n",c);
1122
1123     printf("Bounds: (%i,%i)-(%i,%i)\n",CR->bounds.MinX,CR->bounds.MinY,CR->bounds.MaxX,CR->bounds.MaxY);
1124     if (NULL != CR->lobs)
1125       printf("This cliprect is hidden by layer %px !\n",CR->lobs);
1126     else
1127       printf("This cliprect is visible!\n");
1128     c++;
1129     CR=CR->Next;
1130   }
1131
1132   printf("-------------------------------------\n");
1133 }
1134
1135 void doall(void)
1136 {
1137   char buf[80];
1138   int i;
1139   for (i = 0; i < 10; i++)
1140     layers[i] = NULL;
1141
1142   for (;;)
1143   {
1144     printf("> ");
1145     fflush(stdout);
1146     scanf("%s", buf);
1147
1148     if (!strcmp(buf,"quit"))
1149     {
1150        freelayers();
1151        return;
1152     }
1153     else if (!strcmp(buf, "help"))
1154     {
1155         printf("quit help createupfrontlayer [cul] createbehindlayer [cbl] deletelayer [dl]\n");
1156         printf("behindlayerupfrontlayer [ul] movelayerinfrontof [mlio]\n");
1157         printf("movelayer [ml] movesizelayer [msl] sizelayer [sl] scrollayer [scl]\n");
1158         printf("motion [mot] DumpCliprects [dc] \n");
1159         printf("Frame [F]  DemoA DemoB DemoC DemoD\n");
1160         printf("Generate a few layers: [gl1,gl2,gl3,gl4]\n");
1161     }
1162     else if (!strcmp(buf, "createupfrontlayer") || !strcmp(buf, "cul"))
1163     {
1164       createupfrontlayer();
1165     }
1166     else if (!strcmp(buf, "createbehindlayer") || !strcmp(buf, "cbl"))
1167     {
1168       createbehindlayer();
1169     }
1170     else if (!strcmp(buf, "deletelayer") || !strcmp(buf, "dl"))
1171     {
1172       deletelayer();
1173     }
1174     else if (!strcmp(buf, "behindlayer") || !strcmp(buf, "bl"))
1175     {
1176       behindlayer();
1177     }
1178     else if (!strcmp(buf, "upfrontlayer") || !strcmp(buf, "ul"))
1179     {
1180       upfrontlayer();
1181     }
1182     else if (!strcmp(buf, "movelayerinfrontof") || !strcmp(buf, "mlio"))
1183     {
1184       movelayerinfrontof();
1185     }
1186     else if (!strcmp(buf, "movelayer") || !strcmp(buf, "ml"))
1187     {
1188       movelayer();
1189     }
1190     else if (!strcmp(buf, "movesizelayer") || !strcmp(buf, "msl"))
1191     {
1192       movesizelayer();
1193     }
1194     else if (!strcmp(buf, "sizelayer") || !strcmp(buf, "sl"))
1195     {
1196       sizelayer();
1197     }
1198     else if (!strcmp(buf, "scrolllayer") || !strcmp(buf, "scl"))
1199     {
1200       scrolllayer();
1201     }
1202     else if (!strcmp(buf, "motion") || !strcmp(buf, "mot"))
1203     {
1204       motion();
1205     }
1206     else if (!strcmp(buf, "Frame")  || !strcmp(buf, "F"))
1207     {
1208       Frame();
1209     }
1210     else if (!strcmp(buf, "DemoA"))
1211     {
1212       DemoA();
1213     }
1214     else if (!strcmp(buf, "DemoB"))
1215     {
1216       DemoB();
1217     }
1218     else if (!strcmp(buf, "DemoC"))
1219     {
1220       DemoC();
1221     }
1222     else if (!strcmp(buf, "DemoD"))
1223     {
1224       DemoD();
1225     }
1226     else if (!strcmp(buf, "gl1"))
1227     {
1228       GenerateLayers1();
1229     }
1230     else if (!strcmp(buf, "gl2"))
1231     {
1232       GenerateLayers2();
1233     }
1234     else if (!strcmp(buf, "gl3"))
1235     {
1236       GenerateLayers3();
1237     }
1238     else if (!strcmp(buf, "gl4"))
1239     {
1240       GenerateLayers4();
1241     }
1242     else if (!strcmp(buf, "dc"))
1243     {
1244       DumpCliprects();
1245     }
1246     else
1247       printf("Unknown command. Try 'help'.\n");
1248   }
1249 }