Amiga ISO Collection

home *** CD-ROM | disk | FTP | other *** search

/ Amiga ISO Collection / AmigaUtilCD1.iso / EGS / egssys71.lha / EGSClusterInc.lha / IntuiGfx.def < prev next >

Wrap

Text File | 1994-12-13 | 32.7 KB | 745 lines

|##########| |#MAGIC #|DBBCMEAF |#PROJECT #|"" |#PATHS #|"EGSProject" |#FLAGS #|xx---x--x---xxx----------------- |#USERSW #|-------------------------------- |#USERMASK#|-------------------------------- |#SWITCHES#|x--x-x---------- |##########| DEFINITION MODULE IntuiGfx; | | +---------------------------------------------------------------------+ | | |## | | egsintui.library v0.7, © '91 StoneWare |## | | EXTENDED - GRAPHICS - STANDARD |## | | support : IntuiGfx |## | | |## | +---------------------------------------------------------------------+## | ####################################################################### | | Um die Ausgabe von Grafiken in Windows, Menues und Gadgets möglichst flexibel, | effizient und Mächtig zu gestallten verfügt die egsintui.library über einen | Interpreter, mit dem Programme einer einfachen Stack-Graphik-Sprache | ausgeführt werden können. | | Porgramme in dieser Sprache werden für alle Intuition typischen Grafiken | verwendet, wie Gadgets, Menüs und "Requester". Da innerhalb dieser Programme | auch Unterprogramme mit Parametern verwendet werden können, ist diese Technik | wesentlich flexibler als die bekannte mit getrennten Border, Text und Image | Listen. | | Beispiele: | | - Werden für einen Requester oder Menü mehrmals ähnliche Textzüge mit | Schatten benötigt, muß nur eine Prozedur definiert werden, mit der | ein derartiger Text ausgegeben wird. Später muß dann nur noch diese | Prozedur mit dem Text als Parameter aufgerufen werden. | | - Werden Gadgets mit dreidimensionalen Rahmen verwendet, so genügt es | diesen Rahmen ein einziges mal zu Programmieren, da bei aufruf der | .select und .release Grafiken von Requestern und Menüs Position und | Größe des Gadgets mit übergeben wird. | | - Wird für eine Grafik mehrfach das selbe Element benötigt, z.B. in | Farbauswahlrequester, können diese mit einer Programmschleife | ausgeführt werden. | | - Häufig benötigte Grafikelemente können in einem Modul gesammelt, | und immer wieder benutzt werden. | | - Da innerhalb eines Gfx-Programmes auch auf die Standard-Farben eines | Fensters (Screens) zugegriffen werden kann, können die selben Requester | ohne Änderung bei verschiedenen Farbtiefen und Paletten benutzt werden. | | | FROM EGSGfx IMPORT RastPortPtr; | | WinColors... | | Um Requestern etc. slebst bei verschiedenen Farbtiefen eine möglichst ideale | Farbgebung zu verpassen, wird für jeden Screen (oder auch Window) eine | Struktur definiert, in der die üblichen Farben mit ihren Werten definiert | sind. Auf diese Farben kann innerhalb der Gfx-Programme zugegriffen werden. | Diese Farben werden ausserdem innerhalb von Gadgets (String-Gadgets) | verwendet. | | .light : Eine helle Farbe, für 3D-Strukturen | .normal : Die Farbe eines nicht ausgewählten Fensterrahmens | .dark : Eine dunkle Farbe für Schatteneffekte | .select : Die Farbe eines ausgewählten Fensterrahmens | .back : Die Hintergrundfarbe eines Fensters | .txtFront : Farbe, in der Text ausgegeben werden soll | .txtBack : Hintergrundfarbe für Textausgaben | TYPE WinColors = RECORD light, normal, dark, select, back, txtFront, txtBack : LONGINT; END; CONST | | Ein IntuiGfx-Programm besteht aus einer Folge von Langwörtern, die Konstanten, | Adressen oder Befehle enthalten können. Befehle und Konstanten unterscheiden | sich von Adressen dadurch, daß ihr höchstes Bit-gesetzt ist (Commo-verwendet | ebenfalls dieses oberste Bit, so daß keine Kompatibilitätsprobleme auftreten | solten). Das Ende eines Programms ist durch einen Speziellen Befehl 'RTS' | gegeben. | | Die Sprache ist Stack-orientiert, d.h. Befehle und Prozeduren beziehen sich | immer auf Parameter, die vorher auf den Stack aufgebracht wurden. Neben dem | Stackpointer (SP) ist noch ein Framepointer (FP) implementiert, über den sich | Parameter und lokale Variablen adressieren lassen. Durch den Befehl 'FRAME' | lässt sich dieser Variablenbereich vergrößern. | | Viele Befehle, die Konstante Daten benötigen, bekommen die Konstante auf ihren | Token-Wert aufaddiert. | | Der Stack arbeitet mit Predecrement (PUSH) und Postincrement (POP), so | daß ältere Elemente mit positivem Displacement adressiert werden. | | Alle Befehle, die einen Wert zurückliefern tun dies auf dem Stack, ebenso | erwarten alle Befehle und Prozeduren ihre Parameter auf dem Stack, und | deallozieren sie selbsständig. | | Alle Graphikkoordinaten in einem IntuiGfx-Programm beziehen sich auf den Punkt | als Ursprung, auf dem beim Aufruf der Cursor stand. Dem Interpreter können | Parameter mitgegeben werden, die dann für die Programme wie normale Parameter | auf dem Stack liegen. Dies geschieht auch durch Intuition, z.B. die .activate | und .release Aufrufe bei Gadgets und Menüs. | |############################################################################### | | Befehlsübersicht: | | | (1). Stack- und framespezifische Anweissungen | | | POP : Entfernt das oberste Element vom Stack | INC(SP) | | POPN : Entfernt soviele Elemente vom Stack wie SP[0] anzeigt | INC(SP,SP[0]+1) | | DUP : Verdoppelt das oberste Element auf dem Stack | SP-^:=SP[0] | | DUPN : Verdoppelt soviele Elemente wie in SP[0] angegeben | x:=SP+^;SP-^:=SP[0..x] | | DUPI : Verdoppelt soviele Elemente, wie in DUPI angegeben | x:='DUPI';SP-^:=SP[0..x] | | SWAP : Tauscht die beiden obersten Elemente auf dem Stack | PS[1] <-> SP[0]; | | ROT3 : Rotiert die obersten drei Elemente | SP[2] -> SP[0] -> SP[1] -> SP[2] | | ROTN : Roitert soviele Elemente wie in SP[0] angegeben | x:=SP+^;SP[x] -> SP[0] -> SP[1] -...-> SP[x] | | VAL : Liest ein Wort aus dem Speicher an der Adresse von SP^ | SP[0]:=IntPtr(SP[0])^ | | ADR : Liest ein Langwort aus dem Speicher, an der Adresse von SP^ | SP[0]:=LongPtr(SP[0])^ | | GET1 : Liefert das zweitoberste Element des Stacks | SP-^:=SP[1] | | GET2 : Liefert das drittoberste Element des Stacks | SP-^:=SP[2] | | GETN : Liefert das SP[0]'te Element des Stacks | SP[0]:=SP[SP[0]+1] | | GETSI : Liefert das in GETSI angegebene Element des Stacks | SP-^:=SP['GETSI'] | | GETF : Liefert das SP[0]'te Element des Frames | SP[0]:=FP[SP[0]] | | GETFI : Liefert das in GETFI angegebene Element des Frames | SP-^:=FP['GETFI'] | | PUTF : Schreibt den SP[1] in das durch SP[0] gegebene Element des Frames | FP[SP[0]]:=SP[1];INC(SP,2) | | PUTFI : Schreibt den SP[0] in das durch PUTFI gegebene Element des Frames | FP['PUTFI']:=SP[0];INC(SP) | | Const : Schreibt die Konstante in Const auf den Stack | SP-^:='Const' | | Const24:Schreibt die Konstante in Const24 um acht Bits nach links verschoben | auf den Stack (für 24Bit Farben. | SP-^:='Const24' SHL 8 | | | (2). Arithmetische und logische Anweissungen | | | ADD : Addiert die beiden obersten Stackelemente | SP[1]:=SP[1]+SP[0];INC(SP) | | ADDI : Addiert die in ADDI gegebene Konstante zum SP[0] | SP[0]:=SP[0]+'ADDI' | | SUB : Zieht das oberste Stackelement vom zweitobersten ab | SP[1]:=SP[1]-SP[0];INC(SP) | | NEG : Negiert das oberste Stackelement | SP[0]:=-SP[0] | | MUL : Multipliziert das zweitoberste Stackelement zum obersten | SP[1]:=SP[1]*SP[0];INC(SP) | | SEQ : Testet, ob SP[1] gleich SP[0] ist, liefert -1 falls wahr, sonst 0 | IF SP[1]=SP[0] THEN SP[1]:=-1 ELSE SP[1]:=0 END;INC(SP) | | SNE : Testet, ob SP[1] ungleich SP[0] ist, liefert -1 falls wahr, sonst 0 | IF SP[1]#SP[0] THEN SP[1]:=-1 ELSE SP[1]:=0 END;INC(SP) | | SGT : Testet, ob SP[1] größer als SP[0] ist, liefert -1 falls wahr, sonst 0 | IF SP[1]>SP[0] THEN SP[1]:=-1 ELSE SP[1]:=0 END;INC(SP) | | SLT : Testet, ob SP[1] kleiner als SP[0] ist | IF SP[1]<SP[0] THEN SP[1]:=-1 ELSE SP[1]:=0 END;INC(SP) | | SGE : Testet, ob SP[1] größer oder gleich SP[0] ist | IF SP[1]>=SP[0] THEN SP[1]:=-1 ELSE SP[1]:=0 END;INC(SP) | | SLE : Testet, ob SP[1] kleiner oder gleich SP[0] ist | IF SP[1]<=SP[0] THEN SP[1]:=-1 ELSE SP[1]:=0 END;INC(SP) | | SNOT : Liefert 0, falls SP[0] ungleich 0 ist, sonst -1 | IF SP[0]=0 THEN SP[0]:=-1 ELSE SP[0]:=0 END; | | SAND : Liefert -1, falls SP[0] und SP[1] ungleich 0 sind, 0 sonst | IF SP[0]#0 AND SP[1]#0 THEN SP[1]:=-1 ELSE SP[1]:=0 END;INC(SP) | | SOR : Liefert -1, falls SP[0] oder SP[1] ungleich 0 sind, 0 sonst | IF SP[0]#0 OR SP[1]#0 THEN SP[1]:=-1 ELSE SP[1]:=0 END;INC(SP) | | | (3). Programmsteueranweissungen | | | JMP : Springt an die Adresse die in SP[0] steht | PC:=SP[0];INC(SP) | | RTS : Rückkehr aus einem Unterprogramm, ohne Framedeallozierung | POP(PC) | | RTF : Rückkehr aus einem Unterprogramm, mit Framedeallozierung | SP:=FP+'RTF';POP(PC) | | JSR : Springt in ein Unterprogramm an der angegebenen Stelle | PUSH(PC);PC:=SP[0];INC(SP) | | While S1 Do S2 End : führt die Programmteile S1 und S2 solange aus, wie | nach S1 ein Wert ungleich 0 auf dem Stack liegt. | Dieser Wert wird dealloziert | | If S1 Else S2 End : führt den Programmteil S1 aus, wenn bei If ein Wert | ungleich null auf dem Stack liegt, sonst S2. Der Wert | auf dem Stack wird dealloziert. | | Repeat S1 Until : führt den Programmteil S1 solange aus, bis danach ein | Wert ungleich null auf dem Stack liegt. Dieser Wert | wird dealloziert. | | | (4). Zeichenbefehle | | | Color : Setzt die aktuelle Zeichenfarbe mit dem Wert in SP[0] | SetAPen(r,SP[0]);INC(SP) | | Back : Setzt die Hintergrundfarbe mit dem Wert in SP[0]# | SetBPen(r,SP[0]);INC(SP) | | ModeA : Setzt Zeichenmodus 'drawAPen' | SetDrMd(r,drawAPen) | | ModeAB: Setzt Zeichenmodus 'drawABPen' | SetDrMd(r,drawABPen) | | Image : Kopiert den Inhalt einer durch SP[0] gegebenen BitMap an die | aktuelle Zeichenposition | map:=BitMapPtr(SP[0]);INC(SP); | CopyBitMapRastPort(map,r,0,0,map.^width,map.^height,r^.cx,r^.cy); | | Packed: Packt ein Image aus der BitPlane Form aus, und kopiert es an | die aktuelle Cursorposition. | image:=ImagePtr(SP[0]);col:=ColorTablePtr(SP[1]);INC(SP,2); | IF UnpackImage(map,image^,r^.depth,col^) THEN | CopyBitMapRastPort(map'PTR,r,0,0,map.width,map.height... | DisposeBitMap(map) | END | | Move : Verschiebt den Graphikcursor um die Strecke in (SP[1],SP[0]) | INC(r^.cx,SP[1]);INC(r^.cy,SP[0]);INC(SP,2) | | Locate: Setzt den Graphikcursor an die Position (SP[1],SP[0]) | Move(r,SP[1],SP[0]);INC(SP,2) | | Locate00: Setzt den Graphikcursor an die Startposition zurück | Move(r,0,0) | | Draw : Zeichnet vom Graphikcursor aus die Strecke (SP[1],SP[0]) | Draw(r,r^.cx+SP[1],r^.cy+SP[0]);INC(SP,2); | | DrawAbs:Zeichnet vom Graphikcursor aus die Strecke zum Punkt (SP[1],SP[0]) | Draw(r,SP[1],SP[0]);INC(SP,2) | | Box : Zeichnet ein ausgefülltes Rechteck mit den Kanten SP[1], SP[0] | RectangleFill(r,r^.cx,r^.cy,SP[1],SP[0]);INC(SP,2) | | Write : Gibt einen Text an der aktuellen Cursorposition aus. In SP[0] | befindet sich ein Zeiger auf einen String, wobei das erste | Wort die Länge, alle weiteren Bytes die Zeichen enthalten | Text(r,SP[0]^.data'PTR,SP[0]^.len);INC(SP) | | Text : Gibt einen Text an der aktuellen Cursorposition aus. In SP[0] | befindet sich ein Zeiger auf das erste Zeichen. Die Zeichenkette | wird durch ein Null-Byte abgeschlossen. | Text(r,SP[0],Length(SP[0]^)); | | Font : Setzt den Font, der durch SP[0] gegeben ist. SP[0] muß einen | Zeiger auf eine geöffnetet EFont enthalten. | r^.font:=EFontPtr(SP[0]);INC(SP) | | | (5). Graphikfunktionen | | | GetPosX: Liefert die aktuelle X-Koordinate des Graphikcursors | INC(SP);SP[0]:=r^.cx | | GetPosY: Liefert die aktuelle Y-Koordinate des Graphikcursors | INC(SP);SP[0]:=r^.cy; | | GetColor: Liefert die aktuelle Zeichenfarbe | INC(SP);SP[0]:=r^.aPen | | GetBack : Liefert die aktuelle Hintergrundfarbe | INC(SP);SP[0]:=r^.bPen | | CLight : Liefert die helle Farbe des Fensters | CNormal : Liefert die normale Rahmenfarbe des Fensters | CDark : Liefert die dunkle Farbe des Fensters | CSelect : Liefert die Auswahlfarbe des Fensters | CBack : Liefert die Hintergrundfarbe des Fenster | CTxtFront : Liefert die Empfohlene Textvordergrundfarbe des Fensters | CTxtBack : Liefert die Empfohlene Texthintergrundfarbe des Fensters | | | | | | Programmsteueranweissungen | JMP = $80000001; | adr JMP : Sprung nach adr RTS = $80000002; | RTS : Ende der Liste JSR = $80000003; | adr JSR : Unterprogramm bei adr CALL = $80000004; | adr CALL : Proceduraufruf | | Stacksteueranweissungen | POP = $80000011; | POP : oberstes Element vom Stapel | nehmen DUP = $80000012; | DUP : oberstes Element Duplizieren SWAP = $80000013; | SWAP : oberste Elemente tauschen ROT3 = $80000014; | ROT3 : oberste drei Elemente rotieren | [2]->[0]->[1]->[2] ROTN = $80000015; | val ROTN : beliebig viele Element rotieren | [val]->[0]->[1]..->[val] VAL = $80000016; | adr VAL : Inhalt der Adresse adr holen, | und als INTEGER handhaben ADR = $80000017; | adr ADR : Inhalt der Adresse adr holen, | und als Zeiger handhaben GET1 = $80000018; | GET1 : zweitoberstes Element holen GET2 = $80000019; | GET2 : drittoberstes Element holen GETN = $8000001A; | val GETN : beliebiges Element holen POPN = $8000001B; | val POPN : beliebig viele Elemente vom | Stapel werfen DUPN = $8000001C; | val DUPN : kopiert beliegig viele Elemente | des Stapels GETF = $8000001D; | val GETF : nimmt ein Element aus dem Frame PUTF = $8000001E; | val PUTF : schreibt ein Element auf den Frame STKADR = $8000001F; | STKADR : Adresse des Stackpointers oben auf | den Stack legen. BYTE = $80000111; | adr BYTE : Inhalt der Adresse adr holen | und als Byte interpretieren POKEB = $80000113; | val adr POKEB : Schreibt das LSB von val an die | Adresse adr POKEW = $80000114; | val adr POKEB : Schreibt das LSW von val an die | Adresse adr POKE = $80000115; | val adr POKEB : Schreibt val an die Adresse adr | | Arithmetische Operationen | ADD = $80000021; | val val ADD : Summe der obersten beinen | Elemente NEG = $80000022; | val NEG : Oberstes Element negieren SUB = $80000023; | val val SUB : Oberstes Element vom | zweitobersten abziehen MUL = $80000024; | val val MUL : Produkt der beiden obersten | Elemente bilden SEQ = $80000025; | val1 val2 SEQ : -1, falls val1=val2, sonst 0 SNE = $80000026; | val1 val2 SNE : -1, falls val1#val2, sonst 0 SGT = $80000027; | val1 val2 SGT : -1, falls val1>val2, sonst 0 SLT = $80000028; | val1 val2 SLT : -1, falls val1<val2, sonst 0 SGE = $80000029; | val1 val2 SGE : -1, falls val1>=val2, sonst 0 SLE = $8000002A; | val1 val2 SLE : -1, falls val1<=val2, sonst 0 SNOT = $8000002B; | val SNOT : -1, falls val=0, sonst 0 SAND = $8000002C; | val1 val2 SAND : -1, falls val1#0 & val2#0 SOR = $8000002D; | val1 val2 SOR : -1, falls val1#0 | val2#0 IDIV = $8000002E; | val val IDIV : Integerdivision IMOD = $8000002F; | val val IMOD : Integermodulo | | Zeichenfunktionen | GetPosX = $80000031; | GetPosX : X-Koordinate des Zeichen- | Cursors holen GetPosY = $80000032; | GetPosY : Y-Koordinate des Zeichen- | Cursors holen GetColor = $80000033; | GetColor : aktuelle Zeichenfarbe holen GetBack = $80000034; | GetBack : aktuelle Hintergrundfarbe holen | | Zeichenbefehle | Color = $80000041; | val Color : aktuelle Zeichenfarbe setzen Back = $80000042; | val Color : aktuelle Hintergrundfarbe setzen ModeA = $80000043; | ModeA : Mode A setzen ModeAB = $80000044; | ModeAB : Mose AB setzen Image = $80000045; | adr Image : Image an angegebener Adresse | Zeichnen Move = $80000046; | dx dy Move : Zeichen-Cursor relativ bewegen Draw = $80000047; | dx dy Draw : Linie ziehen, bis Cursor Write = $80000048; | adr Write : Text ausgeben Text = $8000004F; | adr Text : Text ausgeben Box = $80000049; | b h Box : Ausgefülltes Rechteck ausgeben Locate = $8000004A; | x y Locate : Zeichen-Cursor absolut bewegen Locate00 = $8000004B; | Locate00 : Zeichen-Cursor nach 00 bewegen Packed = $8000004C; | col imm Packed : gepacktes Image ausgeben Font = $8000004D; | font Font : Textfont setzen DrawAbs = $8000004E; | x y Draw : Linie ziehen, bis Cursor ModeInvers = $80000112; | ModeInvers : Mode Invers setzen Box3d = $80000401; | br ul w h Box3d : 3d Box zeichnen, ersetzt routine Rect3d = $80000402; | in br ul w h Rect3d : gefüllte 3d Box zeichnen Box2d = $80000403; | w h Box2d Box3df = $80000404; Rect3df = $80000405; CLight = $80000050; | CLight : Helle Fensterfarbe CNormal = $80000051; | CNormal : Normale Farbe CDark = $80000052; | CDark : Dunkle Fensterfarbe CSelect = $80000053; | CSelect : Auswahlfarbe CBack = $80000054; | CBack : Hintergrundfarbe CTxtFront = $80000055; | CTxtFront : Text-Vordergrundfarbe CTxtBack = $80000056; | CTxtBack : Text-Hintergrundfarbe | | Skalierungs befehle | SetScale = $80000300; | w h SetScale: Setzt skalierung SetRatio = $80000301; | w h SetRatio | SMove = $80000311; | dx dy SMove SLocate = $80000312; | x y SLocate SDraw = $80000313; | dx dy SDraw SDrawAbs = $80000314; | x y SDrawAbs SCurve = $80000315; | vx1 vy1 vx2 vy2 dx dy SCurve SCurveAbs = $80000316; | vx1 vy1 vx2 vy2 x y SCurveAbs SEllipse = $80000317; | a b SEllipse SAMove = $80000321; | dx dy SAMove SALocate = $80000322; | x y SALocate SADraw = $80000323; | dx dy SADraw SADrawAbs = $80000324; | x y SADrawAbs SACurve = $80000325; | vx1 vy1 vx2 vy2 dx dy SACurve SACurveAbs = $80000326; | vx1 vy1 vx2 vy2 x y SACurveAbs SAEllipse = $80000327; | a b SAEllipse SAEnd = $8000033F; | SAEnd | | While = $80000101; | While val Do ... End Do = $80000102; | : Der Teil von While bis End | wird solange ausgeführt, bis | die Bedingung in val =0 wird If = $80000103; | val If ... Else ... End Else = $80000104; | : Der Teil zwischen If und Else End = $80000105; | wird durchgeführt, falls val#0. | sonst der Teil von Else bis End. Repeat = $80000106; | Repeat ... val Until Until = $80000107; | : Der Teil zwischen Repeat und Until | wird ausgeführt, und solange | wiederholt, bis val#0 ist. | | | Debug = $80000200; Const = $81008000; | +val Konstante Const24 = $89000000; | +val Konstante SHR 8 !!! GETFI = $82000000; | +i aus fester Frameposition holen PUTFI = $83000000; | +i an feste Frameposition schreiben GETSI = $84000000; | +i von fester Stackposition holen FRAME = $85000000; | +n Frame erzeugen RTF = $86000000; | +n Frame zerstören und Rücksprung ADDI = $87008000; | +val Direkte Summe DUPI = $88000000; | +n feste Anzahl von Elementen verdoppeln POPI = $8A000000; | +n feste Anzahl von Elementen entfernen GROUP Commands = JMP,RTS,JSR,CALL, POP,DUP,SWAP,ROT3,ROTN,VAL,ADR,GET1,GET2,GETN, POPN,DUPN,GETF,PUTF,ADD,NEG,SUB,MUL,POPI, SEQ,SNE,SGT,SLT,SGE,SLE,SNOT,SAND,SOR, GetPosX,GetPosY,GetColor,GetBack,Color, Back,ModeA,ModeAB,Image, Move,Draw,Write,Box,Locate,Locate00,Packed,Text, While,Do,If,Else,End,Repeat,Until, Const,GETFI,PUTFI,GETSI,FRAME,RTF,ADDI,DUPI; TYPE IntuiGfxPtr = POINTER TO LONGINT; IntuiGfx = ARRAY OF LONGINT; PROC = PROCEDURE(rast : RastPortPtr;tof : IntuiGfxPtr;x,y : INTEGER); CONST | | Beispiele: | | - Box3d : Zeichnen eines Rechtecks in zwei Farben. Um einen | 3D-Effekt zu erzielen werden die obere und die | linke Linie in anderen Farben dargestellt wie die | untere und die rechte. | Übergabeparameter sind also zwei Farben, | 'bottomRight' und 'topLeft' sowie die Breite 'width' | und die Höhe 'height'. | | Parameter: | | - bottomRight (FP+3) : Farbe für links und oben | - topLeft (FP+2) : Farbe für rechts und unten | - width (FP+1) : Breite | - height (FP+0) : Höhe | | (* Box3d = IntuiGfx:(ADDI-1, | Höhe um eins vermindern SWAP, | Breite und Höhe tauschen ADDI-1, | breite um eins vermindern SWAP, | wieder Rücktauschen GETFI+2,Color, | Farbe für oben und links | holen und setzten GETFI+1,Const+0,Draw, | Eine Linie um Breite nach | rechts zeichnen GETFI+3,Color, | Farbe für unten und rechts | holen und setzten Const+0,GETFI+0,Draw, | Linie um Höhe nach unten | zeichnen GETFI+1,NEG,Const+0,Draw,| Linie um Breite nach rechts | ziehen. Dazu wird die | Breite negiert. GETFI+2,Color, | Farbe für oben und links | wieder setzen Const+0,GETFI+0,NEG,Draw,| Linie um Höhe nach oben | ziehen. RTF+4); | Stack bereinigen und | Rücksprung zum Aufrufer. | | | - Border3d : Zeichnen eines doppelt umrandeten 3D-Rechtecks, mit | der Prozedur 'Box3d'. Da nicht sicher ist, ob das | Rechteck herausschauen, oder hineingedrückt sein soll, | müssen wiederum zwei Farben angegeben werden. | Die Routine 'Box3d' wird zweimal aufgerufen, einmal | mit den Parameter von Border3d, und mit vertauschten | Farben sowie einem versetzten und verkleinerten | Rechteck. | | Parameter: | | - dark (FP+3) : Erste Farbe | - light (FP+2) : Zweite Farbe | - width (FP+1) : Breite | - height (FP+0) : Höhe | | *) Border3d = IntuiGfx:(GETFI+2,GETFI+3, | Farben umgekehrt auf den | Stack ablegen. GETFI+1,ADDI-2, | Breite holen und um zwei | vermindern, damit das | innere Rechteck direkt | im äusseren liegt GETFI+0,ADDI-2, | Höhe holen un um zwei | vermindern Const+1,Const+1,Move, | Cursor einen Punkt nach | unten und links bewegen. Box3d, | 'Box3d' mit diesen | modifizierten Parametern | aufrufen. Locate00, | Cursor wieder oben links | in die Ecke setzten Box3d, | 'Box3d' mit den originalen | Parametern aufrufen, für | äussere Rechteck RTS); | Prozedur verlassen, keine | Parameter Deallozierung, | da dies bereits durch | 'Box3d' geschehen ist. | (dirty trick :-) ) | | | - Rect3d : Ausgefülltes 3D-Rechteck zeichnen. Diese Routine benutzt | ebenfalls 'Box3d', um den Rahmen um das Rechteck zu | zeichnen. Diesmal ist noch eine dritte Farbe nötig, da | auch das innere des Rechtecks eingefärbt wird. | | Parameter: | | - inner (FP+4) : Farbe des inneren | - bottomRight (FP+3) : Farbe unten und rechts | - leftTop (FP+2) : Farbe für oben und links | - width (FP+1) : Breite | - height (FP+0) : Höhe | | (* Rect3d = IntuiGfx:(GETFI+4,Color, | Innenfarbe setzten Const+1,Const+1,Move, | einen Punkt nach unten | und rechts gehen GETFI+1,ADDI-2, | Breite holen, und für | inneres Rechteck um zwei | vermindern GETFI+0,ADDI-2, | Höhe holen und um zwei | vermindern Box, | Ausgefülltes mittleres | Rechteck zeichnen Locate00, | Wieder zurück zum | Ursprung DUPI+4, | Daten für 'Box3d' holen. | Da diese die selbe | Reihenfolge haben, könnte | man auch die Parameter auf | dem Stack benutzen, dies | ist die sauber Lösung. Box3d'ADR,JSR, | 'Box3d' aufrufen RTF+5); | Rücksprung und Stack | breinigen *) | | | - BigBorder3d : Breiten ausgefüllten 3D-Rahmen Zeichnen. Die Parameter | sind die seleben wie bei 'Rect3d' | | Parameter: | | - inner (FP+4) : Farbe des Rahmeninneren | - bottomRight (FP+3) : Farbe unten und rechts | - leftTop (FP+2) : Farbe für oben und links | - width (FP+1) : Breite | - height (FP+0) : Höhe | | BigBorder3d = IntuiGfx:(DUPI+4,Box3d, | Äusseren Rahmen zeichnen GETFI+2,GETFI+3, | Inneren Rahmen zeichnen GETFI+1,ADDI-30, | GETFI+0,ADDI-30, | Const+15,Const+15,Move, | Box3d, | GETFI+4,Color, | Farbe für innen setzen Const+1,Const+1,Locate, | Balken oben zeichnen GETFI+1,ADDI-16, | Const+14,Box, | Const+0,Const-14,Move, | Balken rechts zeichnen Const+14, | GETFI+0,ADDI-16,Box, | Const+1,Const+15,Locate, | Balken links zeichnen Const+14, | GETFI+0,ADDI-16,Box, | Const+0,Const-14,Move, | Balken unten zeichnen GETFI+1,ADDI-16, | Const+14,Box, | Locate00, | aufräumen RTF+5); | | | - Write3d : Text mit Schlagschatten ausgeben. Dazu wird der Text | zuerst leicht versetzt in einem dunkleren Farbton | gezeichnet, danach in einem helleren an der gewünschten | Stelle. | | Parameter: | | - light (FP+2) : Helle Farbe | - shade (FP+1) : Schattenfarbe | - text (FP+0) : Auszugebender Text | | Write3d = IntuiGfx:(ModeA, | Auf Zeichenmodus | 'drawAPen' umschalten GETFI+1,Color, | dunkle Farbe setzen Const+1,Const+1,Move, | leichter Versatz für | Schlagschatten GETFI+0,Write, | dunklen Text ausgeben Locate00, | Zurück an gewünschte | Koordinaten GETFI+2,Color, | helle Farbe setzen GETFI+0,Write, | Text ausgeben RTF+3); | aufräumen. PROCEDURE Interpret( rast : RastPortPtr; VAR colors : WinColors; VAR toff : IntuiGfxPtr; prog : IntuiGfxPtr; x,y : INTEGER); PROCEDURE InterpretStacked( rast : RastPortPtr; VAR colors : WinColors; prog : IntuiGfxPtr; x,y : INTEGER); PROCEDURE Interpret1Param( rast : RastPortPtr; VAR colors : WinColors; prog : IntuiGfxPtr; x,y : INTEGER; para1 : LONGINT); PROCEDURE Interpret2Param( rast : RastPortPtr; VAR colors : WinColors; prog : IntuiGfxPtr; x,y : INTEGER; para1, para2 : LONGINT); END IntuiGfx.