*
* Eine bunte Copperlist.
*
* created on 21/10/89  15:27:26  by Holger Gzella
*

                incdir "asm:"
                include "exec/exec_lib.i"
                include "graphics/graphics_lib.i"
                include "intuition/intuition_lib.i"

*
* Libraries, Window und Screen öffnen
*
                lea     GfxName,a1              * Graphics öffnen
                moveq.l #0,d0
                CALLEXEC OpenLibrary
                move.l  d0,GfxBase

                lea     IntuiName,a1            * Intuition öffnen
                moveq.l #0,d0
                CALLEXEC OpenLibrary
                move.l  d0,IntuiBase

                move.l  d0,a6
                lea     ScreenDefs,a0           * Screen öffnen
                jsr     _LVOOpenScreen(a6)
                tst.l   d0
                beq     Fault
                move.l  d0,ScreenPtr

                lea     WindowDefs,a0
                jsr     _LVOOpenWindow(a6)
                tst.l   d0
                beq     Fault2
                move.l  d0,WindowPtr
                move.l  d0,a0
                move.l  $32(a0),RastPort

*
* Hier wird Speicher für die Copperlist geholt.
*

                move.l  #$10002,d1              * CHIP u. memClear
                moveq.l #12,d0                  * 12 Bytes
                CALLEXEC AllocMem               * allokieren!
                tst.l   d0                      * alles klar?
                beq     MemFault                * nö!
                move.l  d0,CList                * Zeiger retten

*
* An dieser Stelle wird die Copperliste aufgebaut.
*

                move.l  #1,a2                   * bei Zeile 1 starten
                move.l  #255,d4                 * 256 Zeilen

CopLoop:        move.l  a2,d2                   * auf Zeile warten
                move.l  #20,d3                  * x-Position: 20
                bsr     CopWait

                move.l  #$180,d2                * Hintergrund setzen
                move.l  a2,d3                   * Zeilennummer als Farbe
                bsr     CopMove                 * und MOVE!

                move.l  #$182,d2                * Vordergrund setzen
                move.l  a2,d3                   * 4096
                move.l  #4096,d5                * minus
                sub.l   d3,d5                   * Zeilennummer
                move.l  d5,d3                   * als Farbe
                bsr     CopMove                 * setzen

                add     #1,a2                   * Zähler erhöhen
                dbra    d4,CopLoop              * bis zum Ende!

*
* Die Instruktionsliste muß natürlich auch noch aktiviert werden.
*

                move.l  #10000,d2               * auf (256;10000) warten:
                move.l  #256,d3                 * unmögliche Position, heißt
                bsr     CopWait                 * Ende der Liste!

                move.l  WindowPtr,a0            * ViewPort des
                move.l  IntuiBase,a6            * Screens holen
                jsr     _LVOViewPortAddress(a6)
                move.l  d0,a0                   * und die
                move.l  CList,a1                * Copperlist
                move.l  a1,20(a0)               * einbinden

                jsr     _LVORethinkDisplay(a6)  * Display erneuern!

*
* Jetzt wird etwas gezeichnet, damit man von der Liste
* auch ordentlich was sieht!
*

                move.l  GfxBase,a6              * Vordergrundfarbe
                move.l  RastPort,a1             * auf 1 setzen, damit
                moveq.l #1,d0                   * man die schöne Copperlist,
                jsr     _LVOSetAPen(a6)         * die das Register 1
                                                * betrifft, sieht ...

                move.l  RastPort,a1             * Recheck von
                moveq.l #50,d0                  * (50;50) bis
                moveq.l #50,d1                  * (590;206)
                move.l  #590,d2                 * zeichnen -
                move.l  #206,d3                 * tierischer
                jsr     _LVORectFill(a6)        * Effekt!

*
* Nun wird gewartet, bis der verehrte Benutzer unser
* Close-Gadget angeklickt hat. Ohne Zweifel ein recht gutes
* Beispiel für die Handhabung von IDCMPs.
*

MessageLoop:    move.l  WindowPtr,a0            * WindowPtr holen
                move.l  $56(a0),a0              * UserPort holen
                move.l  a0,a5                   * und retten
                move.b  $f(a0),d1               * SigBit holen
                moveq   #0,d0                   * und in
                bset    d1,d0                   * Bitmaske wandeln
                CALLEXEC Wait                   * warten

                move.l  a5,a0                   * UserPort holen
                CALLEXEC GetMsg                 * Nachricht holen
                move.l  d0,a1                   * Message nach A1
                move.l  $14(a1),d4              * Art der Message holen
                CALLEXEC ReplyMsg               * und beantworten

                cmpi.l  #$200,d4                * Schließsymbol betätigt?
                beq     MemFault                * ja!

                bra     MessageLoop             * Schleife

*
* Ende - alles schließen
*

MemFault:       move.l  WindowPtr,a0
                jsr     _LVOCloseWindow(a6)

Fault2:         move.l  ScreenPtr,a0
                move.l  IntuiBase,a6
                jsr     _LVOCloseScreen(a6)

Fault:          move.l  IntuiBase,a1
                CALLEXEC CloseLibrary

                move.l  GfxBase,a1
                CALLEXEC CloseLibrary

                moveq.l #0,d0
                rts

*
* Unterprogramme ...
*

*
* Diese Routine entspricht etwa CWAIT aus GfxMacros.
* Übergeben werden müssen:
*
* D2 - y-Koordinate der Position, auf die gewartet werden soll.
* D3 - x-Koordinate der Position, auf die gewartet werden soll.
*

CopWait:        move.l  d2,d0                   * y-Koordinate und
                move.l  d3,d1                   * x-Koordinate sowie
                move.l  CList,a1                * Copperlist-Zeiger setzen!
                move.l  GfxBase,a6              * CWait
                jsr     _LVOCWait(a6)           * aufrufen!
                move.l  CList,a1                * CBump
                move.l  GfxBase,a6              * auf-
                jsr     _LVOCBump(a6)           * rufen
                rts                             * und zurück!

*
* Hier steht eine Art Äquivalent zu CMOVE.
* Diese Parameter werden benötigt:
*
* D0 - Offset des Hardware-Registers von $DFF000.
* D1 - Wert, den das Register erhalten soll.
*

CopMove:        move.l  d2,d0                   * Offset,
                move.l  d3,d1                   * Wert und
                move.l  CList,a1                * Zeiger setzen,
                move.l  GfxBase,a6              * dann
                jsr     _LVOCMove(a6)           * CMove und
                move.l  CList,a1                * darauf
                move.l  GfxBase,a6              * CBump
                jsr     _LVOCBump(a6)           * aufrufen!
                rts                             * zurück!

*
* Datenteil ...
*

GfxName:        dc.b    "graphics.library",0
 even
IntuiName:      dc.b    "intuition.library",0
 even

 even
WindowDefs:     dc.w    0,11,640,245,1
                dc.l    $200,$E,0,0,Titel
ScreenPtr:      dc.l    0,0,0,0
                dc.w    $F

 even
ScreenDefs:     dc.w    0,0,640,256,2,1,$8000,$F,0,0
                dc.l    0,0,0

Titel:          dc.b    "Ein Copper-Demoprogramm",0
 even

GfxBase:        dc.l    0
IntuiBase:      dc.l    0
WindowPtr:      dc.l    0
RastPort:       dc.l    0
CList:          dc.l    0

                END