(* $R- $S- $V- *)

MODULE LayerDemo;

(* Demo für einige Funktionen der "layers.library" *)
(*                 written by H.G.                 *)

FROM Arts      IMPORT Assert;
FROM SYSTEM    IMPORT ADR,LONGSET;
FROM Intuition IMPORT ScreenPtr,NewScreen,OpenScreen,CloseScreen,
                      customScreen;
FROM Graphics  IMPORT ViewModes,ViewModeSet,LayerPtr,LayerInfoPtr,SetAPen,
                      Move,Draw,Text,BitMapPtr,LayerFlags,LayerFlagSet;
FROM Hardware  IMPORT ciaa,CiaaPraFlags,CiaaPraFlagSet;
FROM Layers    IMPORT CreateUpfrontLayer,CreateBehindLayer,DeleteLayer,
                      MoveLayer,MoveLayerInFrontOf,BehindLayer,
                      UpfrontLayer;
FROM Dos       IMPORT Delay;

VAR ScreenDaten: NewScreen;
    Screen     : ScreenPtr;
    LInfo      : LayerInfoPtr;
    Upfront1   : LayerPtr;
    Upfront2   : LayerPtr;
    Backdrop1  : LayerPtr;
    Backdrop2  : LayerPtr;
    BMap       : BitMapPtr;
    i          : INTEGER;
    ok         : BOOLEAN;

BEGIN

  WITH ScreenDaten DO (* Screen initialisieren *)
    leftEdge:=0; topEdge:=0; width:=640; height:=256; depth:=2;
    detailPen:=0; blockPen:=1; viewModes:=ViewModeSet{hires};
    type:=customScreen; defaultTitle:=ADR("Screen für Layers");
    font:=NIL; gadgets:=NIL; customBitMap:=NIL;
  END;

  Screen:=OpenScreen(ScreenDaten);
  Assert(Screen#NIL,ADR("Konnte Screen nicht öffnen!"));

  LInfo:=ADR(Screen^.layerInfo);
  BMap:=ADR(Screen^.bitMap);

  (* Hier werden jetzt vier Layers erstellt: zwei Backdrops und
     zwei Upfronts. Es handelt sich ausschließlich um layerSmart-Layers. *)

  Upfront1:=CreateUpfrontLayer(LInfo,BMap,0,0,320,128,
                               LayerFlagSet{layerSmart},NIL);
  Assert(Upfront1#NIL,ADR("Upfront-Layer 1 nicht bekommen!"));

  Upfront2:=CreateUpfrontLayer(LInfo,BMap,320,0,639,128,
                               LayerFlagSet{layerSmart},NIL);
  Assert(Upfront2#NIL,ADR("Upfront-Layer 2 nicht bekommen!"));

  Backdrop1:=CreateBehindLayer(LInfo,BMap,0,128,320,255,
                               LayerFlagSet{layerSmart,layerBackdrop},NIL);
  Assert(Backdrop1#NIL,ADR("Backdrop-Layer 1 nicht bekommen!"));

  Backdrop2:=CreateBehindLayer(LInfo,BMap,320,128,639,255,
                               LayerFlagSet{layerSmart,layerBackdrop},NIL);
  Assert(Backdrop2#NIL,ADR("Backdrop-Layer 2 nicht bekommen!"));

  (* An dieser Stelle wird allen vier Layers ein Rahmen und etwas Text
     verpaßt, damit sie überhaupt zu sehen sind ... *)

  Move(Upfront1^.rp,0,0);
  Draw(Upfront1^.rp,319,0);
  Draw(Upfront1^.rp,319,127);
  Draw(Upfront1^.rp,0,127);
  Draw(Upfront1^.rp,0,0);
  Move(Upfront1^.rp,124,60);
  Text(Upfront1^.rp,ADR("Upfront 1"),9);

  Move(Upfront2^.rp,0,0);
  Draw(Upfront2^.rp,319,0);
  Draw(Upfront2^.rp,319,127);
  Draw(Upfront2^.rp,0,127);
  Draw(Upfront2^.rp,0,0);
  Move(Upfront2^.rp,124,60);
  Text(Upfront2^.rp,ADR("Upfront 2"),9);

  Move(Backdrop1^.rp,0,0);
  Draw(Backdrop1^.rp,319,0);
  Draw(Backdrop1^.rp,319,127);
  Draw(Backdrop1^.rp,0,127);
  Draw(Backdrop1^.rp,0,0);
  Move(Backdrop1^.rp,124,60);
  Text(Backdrop1^.rp,ADR("Backdrop 1"),10);

  Move(Backdrop2^.rp,0,0);
  Draw(Backdrop2^.rp,319,0);
  Draw(Backdrop2^.rp,319,127);
  Draw(Backdrop2^.rp,0,127);
  Draw(Backdrop2^.rp,0,0);
  Move(Backdrop2^.rp,124,60);
  Text(Backdrop2^.rp,ADR("Backdrop 2"),10);

  (* Hier beginnt die Show. Fangen wir mit dem Verschieben an. *)

  FOR i:=0 TO 79 DO

    ok:=MoveLayer(Upfront1,1,1);
    Assert(ok#FALSE,ADR("Konnte Upfront 1 nicht bewegen!"));

    ok:=MoveLayer(Upfront2,-1,1);
    Assert(ok#FALSE,ADR("Konnte Upfront 2 nicht bewegen!"));

    ok:=MoveLayer(Backdrop1,1,-1);
    Assert(ok#FALSE,ADR("Konnte Backdrop 1 nicht bewegen!"));

    ok:=MoveLayer(Backdrop2,-1,-1);
    Assert(ok#FALSE,ADR("Konnte Backdrop 2 nicht bewegen!"));

  END;

  (* Jetzt wird das Wechseln der visuellen Priorität demonstriert. *)

  Delay(100);

  ok:=BehindLayer(Upfront2);
  Assert(ok#FALSE,ADR("Konnte Upfront 2 nicht verschieben!"));

  ok:=BehindLayer(Backdrop1);
  Assert(ok#FALSE,ADR("Konnte Backdrop 1 nicht veschieben!"));

  Delay(100);

  ok:=UpfrontLayer(Upfront2);
  Assert(ok#FALSE,ADR("Konnte Upfront 2 nicht verschieben!"));

  ok:=UpfrontLayer(Backdrop1);
  Assert(ok#FALSE,ADR("Konnte Backdrop 1 nicht verschieben!"));

  (* Nun wird ein geregelter Zustand erstellt ... *)

  Delay(300);

  ok:=DeleteLayer(Upfront1);                    (* alle Layers löschen *)
  Assert(ok#FALSE,ADR("Konnte Upfront 1 nicht entfernen!"));

  ok:=DeleteLayer(Upfront2);
  Assert(ok#FALSE,ADR("Konnte Upfront 2 nicht entfernen!"));

  ok:=DeleteLayer(Backdrop1);
  Assert(ok#FALSE,ADR("Konnte Backdrop 1 nicht entfernen!"));

  ok:=DeleteLayer(Backdrop2);
  Assert(ok#FALSE,ADR("Konnte Backdrop 2 nicht entfernen!"));

  CloseScreen(Screen);                          (* Screen schließen *)

END LayerDemo.