opt l-,d+,s-,n+
	plen 72
	llen 80
	ttl "Wertetabelle"
	
* INCLUDE-Files laden

	include df0:include/exec/exec_lib.i
	include df0:include/math/mathffp_lib.i
	include df0:include/intuition/intuition_lib.i
	include df0:include/math/mathtrans_lib.i
	include df0:include/graphics/graphics_lib.i
	include df0:include/libraries/dos_lib.i

* MACRO-Definitionen		
	
* Intuition-Text ausgeben

PRINTOUT    	macro
		lea \1,a1
		move.l #\2,d0
		move.l #\3,d1
		move.l windowpointer,a0
		move.l 50(a0),a0
		CALLINT PrintIText
		endm

*Struktur für Ausgabe-Text

TEXTOUT		macro
		dc.b 3,0 	 ;Farben
		dc.b  0      	 ;Farbmodus
		even
		dc.w  0     	 ;x-Koordinate 
		dc.w  0		 ;y-Koordinate
		dc.l  0      	 ;Zeichensatz
		dc.l  \1   	 ;Textpointer
		dc.l  0      	 ;Weiterer Text      
		endm

TEXTOUT1	macro
		dc.b 0,0 	 ;Farben
		dc.b  0      	 ;Farbmodus
		even
		dc.w \1      	 ;x-Koordinate 
		dc.w \2		 ;y-Koordinate
		dc.l  0      	 ;Zeichensatz
		dc.l \3   	 ;Textpointer
		dc.l  0      	 ;Weiterer Text      
		endm

*Struktur für Menü

MENUE           macro
		dc.l \1		;naechstes Menue
		dc.w \2,\3	;x,y des Menuetitels
		dc.w 70,10	;Breite,Höhe des Menuetitels
		dc.w 1		;Menue wählbar
		dc.l \4		;Menütitel
		dc.l \5		;Menüeinträge
		dc.w 0,0,0,0
		endm

*Struktur für Menüpunkte

MENUPUNKT       macro
		dc.l  \1	;naechster Menupunkt
		dc.w  \2,\3     ;x,y-Position
		dc.w  \4        ;Breite
		dc.w  10	;Höhe
		dc.w  \5        ;Flag
		dc.l  \6        ;kein Ausschluß
		dc.l  \7	;Zeiger auf Textstruktur
		dc.l  0		;keine Zeichnung
		dc.b  \8        ;Amiga-Taste
		even
		dc.l  \9	;Zeiger auf Untermenü
		dc.l  0
		endm

* Struktur für Windows

WINDOW       macro							
             dc.w       \1      ;Linke Ecke
             dc.w       \2	;Obere Ecke
             dc.w       \3	;Breite
             dc.w       \4	;Hoehe
             dc.b       0,1	;Farben
             dc.l       \5	;Flags für Events
             dc.l       \9 	;Window Flags
             dc.l       \6      ;Zeiger auf erstes Gadget
             dc.l       0       ;Check Mark
             dc.l       \7      ;Windowname						
\8           dc.l       0	;Screenpointer
             dc.l       0	;Bit Map
             dc.w      \3	;Mindest-Breite
             dc.w      \4 	;Mindest-Hoehe
             dc.w      \3	;Maximale Breite
             dc.w      \4	;Maximale Hoehe
             dc.w      15	;Window-Typ
	     endm

* Struktur für Screens

SCREEN		macro  
	   dc.w       0		;linke Ecke
	   dc.w       0		;obere Ecke
	   dc.w       \1	;Breite
	   dc.w       \2	;Höhe
	   dc.w       2		;Tiefe (Bitplanes)
	   dc.b       2,3	;Farben
	   dc.w       \3	;Modus
	   dc.w      15		;Screentyp
	   dc.l       0		;Zeichensatz
	   dc.l       \4	;Screentitel
	   dc.l       0		;Gadgets
	   dc.l       0		;Bitmap
		endm

* Struktur für Gadgets

GADGET   macro 
	 dc.l       \1   ;naechstes Gadget
	 dc.w       \2   ;obere Ecke x
	 dc.w       \3   ;obere Ecke y
	 dc.w      122   ;Breite
	 dc.w       10   ;Hoehe
	 dc.w        0   ;Flags
	 dc.w        2   ;Activation-Flags
	 dc.w       \4   ;Gadget-Typ:String
	 dc.l       \5   ;Gadget-Boarder
	 dc.l        0   ;kein Select-Gadget
	 dc.l       \6   ;Gadget-Text
	 dc.l        0   ;kein Exclude
	 dc.l       \7   ;Special-Info
	 dc.w       \8   ;Gadget-ID
	 dc.l        0   ;User-Data
	 endm

* Struktur für Eingaben bei Stringgadgets

STRINF          macro 
	        dc.l  \1	;Textpuffer
	        dc.l  undo 	;Undo-Puffer
	        dc.w  0		;Cursor-Position
	        dc.w  15	;Anzahl Zeichen (max)
		dc.w  0		;Ausgabeposition Cursor
		dc.w  0		;Position Undo-Puffer
		dc.w  0		;Anzahl Zeichen im Textpuffer
		dc.w  0		;Anzahl sichtbare Zeichen
		dc.w  0         ;horizontaler Offset	
		dc.w  0		;vertikaler Offset
		dc.l  0		;Zeiger auf Rastport
		dc.l  0         ;Integer-Wert					                       
		dc.l  0		;Tastatur-Belegung
		endm

* Textstruktur für Gadgets

STRING         macro
               dc.b  1,0	;Farben
               dc.b  1		;Farbmodus
	even
               dc.w  \1,\2	;Positionen
               dc.l  0		;Zeichensatz
               dc.l  \3		;Textpointer
               dc.l  \4		;naechster Text
	       endm

* Strings für Eingaben

ZAHLENSTRINGS 	macro
  		dc.b  \1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
		even
                dc.b  \2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
		even
		dc.b  \3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
		even
  		dc.b  \4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
		even
                dc.b  \5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
		even
		dc.b  \6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
		even
		dc.b  \7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
		even
  		dc.b  \8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
		even
		endm
		
* Fliesskommazahlen

ZAHLENFLOAT     macro
	        dc.b   \1,0,0,\2
		dc.b   $80,0,0,$41
		dc.b   $80,0,0,\6
		dc.b   \3,0,0,\6
		dc.b   $80,0,0,\7
		dc.b   \4,0,0,\7
		dc.b   \3,0,0,\7
		dc.b   \5,0,0,\7
		endm		

	include df0:include/startup	;Startup-Code laden

undo		dc.l  0,0,0,0		;Undo-Puffer für Stringgadets

begin	lea ffpname,a1		;Math-Library öffnen
	clr.l d0
	CALLEXEC OpenLibrary
	tst.l d0
	beq fini1
	move.l d0,_MathBase

	lea intname,a1		;Intuition-Library öffnen
	clr.l d0
	CALLEXEC OpenLibrary
	tst.l d0			
	beq fini2
	move.l d0,_IntuitionBase

	lea mathtransname,a1	;Mathtrans-Library öffnen
	clr.l d0
	CALLEXEC OpenLibrary
	tst.l d0
	beq fini3
	move.l d0,_MathTransBase
	
	lea grafname,a1		;Grafik-Library öffnen
	clr.l d0
	CALLEXEC OpenLibrary
	tst.l d0
	beq fini4
	move.l d0,_GfxBase

	lea dosname,a1		;DOS-Library öffnen
	clr.l d0
	CALLEXEC OpenLibrary
	tst.l d0
	beq fini5
	move.l d0,_DOSBase

	lea screen_defs,a0		;Screen öffnen
	CALLINT OpenScreen
	move.l d0,screenpointer		;Pointer für
	move.l d0,point1
	move.l d0,point2		;Windows setzen
	move.l d0,point3
	move.l d0,point4
	move.l d0,point5

* menueaufbau, abfrage

	lea startwindow,a0		;Startwindow öffnen
	CALLINT OpenWindow
	move.l d0,windowpointer
	bsr  print    		  	;Text ausgeben
	move.l windowpointer,a0
	lea menu,a1
	CALLINT SetMenuStrip		;Menü setzen
	bra  wait

start	clr.l d4			;Menü
einl	clr.l d3			;Menüpunkt
einl1	clr.l d5			;Untermenüpunkt
	move.l d3,d2			;Menüpunkt nach Bit 5-10
	lsl.l #5,d2			
einl2	move.l d5,d0			;Untermenüpunkt nach Bit 
	lsl.l #7,d0			;11-15
	lsl.l #4,d0
	add.l d2,d0			;Menüpunkt einblenden
	add.l d4,d0			;Menü einblenden
	move.l windowpointer,a0		;Menüpunkt
	CALLINT OnMenu			;wählbar machen
	addq.l #1,d5
	cmpi.l #3,d5
	bne einl2			;max. Untermenüpunkte+1
	addq.l #1,d3			;(prinzipiell beliebig)
	cmpi.l #4,d3
	bne einl1			;max. Menüpunkte+1
	addq.l #1,d4			;(prinzipiell beliebig)
	cmpi.l #3,d4
	bne einl			;Menüs
					;(tatsächliche Anzahl)
wait	move.l windowpointer,a0
	move.l 86(a0),a0		;User-Port holen
  	move.l a0,a5			;Adresse retten
	move.b 15(a0),d1		;Signal-Bit holen
	moveq #0,d0			;Nummer in Maske
	bset d1,d0			;wandeln
	CALLEXEC Wait			;Auf Wiedersehen !
	move.l a5,a0	
	CALLEXEC GetMsg			;Message holen
	move.l d0,a1
	clr.l d7
	move.w $18(a1),d7    		;Menüpunkt holen
	CALLEXEC ReplyMsg		;Message quittieren
	cmpi.w #$ffff,d7			;Kein Menüpunkt gewählt
	beq wait
	move.w d7,d6
	lsr #7,d7
	lsr #4,d7			
	lsl #2,d7			;Untermenü*4 in D7
	move.w d6,d5				
	andi.l #%00000000000000000000011111100000,d6
	lsr #3,d6			;Menüpunkt*4 in D6
	andi.l #%00000000000000000000000000011111,d5	
	lsl #2,d5			;Menü*4 in D5
	move.l d5,a5
	clr.l d4
ausl	clr.l d3			;Alle Menüpunkt unwählbar
ausl1	clr.l d5
	move.l d3,d2			;machen (s.o.)
	lsl.l #5,d2
ausl2	move.l d5,d0
	lsl.l #7,d0
	lsl.l #4,d0
	add.l d2,d0
	add.l d4,d0
	move.l windowpointer,a0
	CALLINT OffMenu
	addq.l #1,d5
	cmpi.l #3,d5
	bne ausl2
	addq.l #1,d3
	cmpi.l #4,d3
	bne ausl1
	addq.l #1,d4
	cmpi.l #3,d4
	bne ausl
	move.l a5,d5			;Menü feststellen
	move.l #tab,a4
	adda.l d5,a4
	move.l (a4),a4			;Menüpunkt feststellen
	adda.l d6,a4
	move.l (a4),a4
	jmp (a4)			;und anspringen

tabmenu1	 dc.l zaehler,nenner,parameter	;Menüpunkte Menü1
tabmenu2         dc.l ausgabe,plotten,endof	;Menüpunkte Menü2
tabmenu3	 dc.l ZAEHLER,NENNER,FUNKTION	;Menüpunkte Menü3

tab		 dc.l tabmenu1,tabmenu2,tabmenu3 ;Menüs 1 bis 3


* ERSTES MENÜ (EINGABE)

* Menüpunkt Zaehler eingeben

zaehler		move.b #32,d7		;Strings für Eingabefelder
		lea fakzaehler,a3	;Zähler vorbereiten
		lea fakx1,a4
		lea expzaehler,a5
		lea expx1,a6
zloop1		move.l (a3)+,(a4)+
		move.l (a5)+,(a6)+
		subq #1,d7
		bne zloop1
		lea zaehlwindow,a0	;Window für Zählereingabe
		bsr  mainwindow		;öffnen
		move.b #32,d7
		lea fakzaehler,a3
		lea fakx1,a4	;Eingabestrings sichern
		lea expzaehler,a5
		lea expx1,a6
zloop2		move.l (a4)+,(a3)+
		move.l (a6)+,(a5)+
		subq #1,d7
		bne zloop2
		lea floatfakz,a3	;Faktoren in Fliesskomma 
		bsr  wandelfak		;umwandeln
		lea floatexpz,a3	;Exponenten in Fliesskomma
		bsr  wandelexp		;umwandeln
		bra  exit		;fertig

* Menüpunkt Nenner eingeben

nenner		move.b #32,d7		;s.o.
		lea faknenner,a3
		lea fakx1,a4
		lea expnenner,a5
		lea expx1,a6
nloop1		move.l (a3)+,(a4)+
		move.l (a5)+,(a6)+
		subq #1,d7
		bne nloop1
		lea nennwindow,a0
		bsr  mainwindow
		move.b #32,d7
		lea faknenner,a3
		lea fakx1,a4
		lea expnenner,a5
		lea expx1,a6
nloop2		move.l (a4)+,(a3)+
		move.l (a6)+,(a5)+
		subq #1,d7
		bne nloop2
		lea floatfakn,a3
		bsr  wandelfak
		lea floatexpn,a3
		bsr  wandelexp
		bra  exit
		
* Menüpunkt Parameter eingeben

parameter	move.b #12,d7		;Strings für Eingabe
		lea Unterex1,a3	;vorbereiten
		lea Untere,a4
ploop1		move.l (a3)+,(a4)+
		subq #1,d7
		bne ploop1
		lea parawindow,a0	;Window für Eingabe öffnen
		bsr  mainwindow
		move.b #12,d7		;Eingabestrings sichern
		lea Unterex1,a3
		lea Untere,a4
ploop2		move.l (a4)+,(a3)+
		subq #1,d7
		bne ploop2
		lea floatuntere,a3	;und in Fliesskomma
		bsr  wandelpar		;umwandeln
		lea propinfo,a0	;Proportionalwert 
		clr.l d0		;holen
		move.w 2(a0),d0
		cmpi.l #$C000,d0		
		bls notdrei
		move.b #3,stellen	;3 Nachkommastellen
		bra  parend		;bei 75-100 %
notdrei		cmpi.l #$4000,d0		;2 Nachkommastellen
		bls notzwei		;bei 25-75 %
		move.b #2,stellen
		bra  parend		;1 Nachkommastelle
notzwei		move.b #1,stellen	;bei 0-25 %
parend		bra  exit

stellen		dc.b 1
		even
		
* ZWEITES MENÜ (OPTION)

* Menüpunkt Ausgabe

ausgabe		move.l #subtab,a4	;Untermenü holen
		adda.l d7,a4
		move.l (a4),a4
		jmp (a4)

subtab		dc.l  schirm,printer

* Untermenüpunkt Bildschirmausgabe

schirm		bsr  berechnung		;Polynom berechnen
		lea auswindow,a0	;Window für Ausgabe öffnen
		CALLINT OpenWindow
		move.l d0,iwindowpointer
		clr.w startpos	;Nummer erstes Wertepaar
schleife1	move.l iwindowpointer,a0
		move.l 50(a0),a1	;Rastport holen
		clr.l d0		;Modus löschen:
		CALLGRAF SetAPen	;Zeichen=Hintergrundfarbe
		move.l #2,d0		;Ausgabebereich löschen:
		move.l #15,d1
		move.l #315,d2		;von (x,y)=(2,15) 
		move.l #130,d3		;nach (315,130)
		CALLGRAF RectFill
		move.w startpos,position ;Positiom in Wertetabelle
		move.b #20,zeilen	;y-Startkoordinate 
		clr.b zähler	;Zähler Wertepaare
schleife	clr.l d0
		move.w position,d0	;Position*4
		lsl.w #2,d0		;(Fliesskomma=Langwort)
		lea xwert,a0	;Start Wertetabelle x
		move.l (a0,d0),d3	;plus Position=Wert holen
		lea ywert,a0	;das gleiche mit y
		move.l (a0,d0),d4
		move.b zeilen,zeile	;aktuelle y-Koordinate
		bsr  xout		;x-Wert ausgeben
		move.l d4,d3		
		bsr  yout		;y-Wert ausgeben
		addi.b #1,zähler		;Schon 9 Wertepaare ?
		cmpi.b #9,zähler		;(Dann Bildschirm voll) 
		bhi schlende		;Ja, Ausgabe Stop
		addq.w #1,position
		move.w position,d0	;Alle Wertepaare ausgeben ?
		move.w paarzahl,d1
		cmp.w d0,d1		
		beq schlende		;Ja, Ausgabe Stop
		addi.b #10,zeilen	;y-Koordinate erhöhen
		bra  schleife		;Nächste Werte ausgeben
		
schlende	bsr  iloop		;Auf Message warten
		
		cmpi.w #113,d2		;Scroll abwärts ?
		bne sch1
		move.w startpos,d3	;Ja, aber wenn alle Werte
		addi.w #10,d3		;ausgegeben, kein Scrollen
		move.w paarzahl,d4	;mehr möglich
		cmp.w d4,d3
		bge schlende
		addi.w #10,startpos
		bra  schleife1
sch1		cmpi.w #112,d2		;Scrollen aufwärts ?
		bne sch2
		move.w startpos,d3	;Ja, aber wenn erste Werte
		beq schlende		;auf Bildschirm, kein 
		subi.w #10,startpos	;Scrollen mehr möglich
		bra  schleife1
sch2		bra  exit		;Ausgabe beenden

position	dc.w 0
startpos	dc.w 0
zeilen		dc.b 0
		even
zähler		dc.b 0
		even

* Untermenüpunkt Druckerausgabe

printer		bsr  berechnung		;Werte berechnen
		move.l #printername,d1
		move.l #1006,d2		;Druckerkanal öffnen
		CALLDOS Open
		tst.l d0
		beq perror		;Fehler aufgetreten
		move.l d0,printerpointer
		bsr  über		;Überschrift ausgeben
		clr.w position
pschleife	clr.l d0
		move.w position,d0	;Werte aus Tabelle holen
		lsl.w #2,d0
		lea xwert,a0
		move.l (a0,d0),d3
		lea ywert,a0	;(s.o.)
		move.l (a0,d0),d4
		bsr  xdruck		;x für Druck aufbereiten
		move.l d4,d3
		bsr  ydruck		;y für Druck aufbereiten
		bsr  druck		;Wertepaar ausdrucken
		addq.w #1,position
		move.w position,d1	;Alle Werte ausgedruckt ?
		move.w paarzahl,d2
		cmp.w d2,d1		;Nein, weiterdrucken
		blt pschleife
		
		move.l printerpointer,d1 ;Druckerkanal schliessen
		CALLDOS Close
		bra  exit1		;fertig

* Fehlerbehandlung

perror		bsr  requester		;Requester ausgeben
		cmpi.l #1,d0		;Nochmal versuchen ?
		beq printer		;Ja, bitte schön !
		bra  exit1		;Nein, Drucker kaputt 

printername	dc.b "PRT:",0
		even

printerpointer	dc.l 0
		even

* Menüpunkt Masstab

plotten		move.l #subtab1,a4	;Untermenü
		adda.l d7,a4
		move.l (a4),a4
		jmp (a4)

subtab1		dc.l  M1zu1,anpassung

* Untermenüpunkt Masstab 1:1

M1zu1		move.b #1,masstab	;Flag setzen
		bra  exit1
 
* Untermenüpunkt Masstab Anpassung

anpassung	clr.b masstab	;Flag setzen
		bra  exit1

masstab		dc.b 1
		even

* Menüpunkt Ende

endof		bra  ende

* DRITTES MENÜ (PLOTTEN)

* Menüpunkt Zähler 

ZAEHLER		bsr  plotscreen		;Plotscreen öffnen
		move.l #zaehlwert,d7
		bsr  xmasstab		;Masstab festlegen
		lea zaehlwert,a3
		bsr  zeichnen		;Plotten
		bsr  iloop		;Auf Message warten
		bra  exit2

* Menüpunkt Nenner

NENNER  	bsr  plotscreen		;s.o.
		move.l #nennwert,d7
		bsr  xmasstab
		lea nennwert,a3
		bsr  zeichnen
		bsr  iloop
		bra  exit2

* Menüpunkt Funktion

FUNKTION	bsr  plotscreen		;s.o.
		move.l #ywert,d7
		bsr  xmasstab
		lea ywert,a3
		bsr  zeichnen
		bsr  iloop
		bra  exit2

* Plotscreen öffnen

plotscreen	lea plot_defs,a0	;Screen öffnen
	 	CALLINT OpenScreen
		move.l d0,plotpointer	;Pointer sichern
		move.l d0,point6
		lea plotwindow,a0	;Window öffnen
		CALLINT OpenWindow	
		move.l d0,iwindowpointer ;Pointer sichern
		rts
	
* Schrittweite für 1 Pixel festlegen

xmasstab	move.l floatobere,d0		;Obere Grenze
		move.l floatuntere,d1		;minus
		CALLFFP SPSub
		move.l d0,d2			;Untere Grenze
		move.l #640,d0
		CALLFFP SPFlt
		move.l d0,d1
		move.l d0,xmax
		move.l d2,d0
		CALLFFP SPDiv			;Ergebnis/640
		move.l floatschritt,sicher	;Schrittweite retten
		move.l d0,floatschritt
		move.l d0,floatxschritt
		move.l d0,floatyschritt
		move.l d7,sicher1
		bsr  berechnung			;Daten berechnen
		move.l sicher1,d7
		move.l #10,d0
		CALLFFP SPFlt			;ymin = 10
		move.l d0,ymin
		move.l #256,d0
		CALLFFP SPFlt			;ymax = 256
		move.l d0,ymax
		move.l #133,d0
		CALLFFP SPFlt			;Nullinie (x-Achse):
		move.l d0,null
		move.b masstab,d0		;y = 133
		cmpi.b #1,d0			;1:1, dann fertig
		beq massfertig
		bsr  minimax			;Anpassung
massfertig	rts
		
sicher		dc.l 0
sicher1		dc.l 0
xmax		dc.l 0
ymin		dc.l 0
ymax		dc.l 0
null		dc.l 0

* Maximum und Minimum feststellen, daraus Masstab berechnen

minimax		move.l d7,a5
		move.w #639,d3			;Zähler
		move.l (a5),max
		move.l (a5)+,min		;Anfangswerte als
minimaxloop	move.l (a5)+,d1			;Minimum und
		move.l d1,d2			;Maximum setzen
		move.l max,d0			;Nächsten Wert
		CALLFFP SPCmp			;vergleichen
		cmpi.l #-1,d0			;kleiner gleich, 
		beq nomax			;kein neues Maximum
		move.l d2,max			;neues Maximum
		bra  minimaxend
nomax		move.l d2,d1			;wieder vergleichen
		move.l min,d0			;grösser gleich,
		CALLFFP SPCmp			;kein neues Minimum
		cmpi.l #1,d0
		beq minimaxend
		move.l d2,min			;neues Minimum
minimaxend	subq.w #1,d3			;Nächsten Wert
		bne minimaxloop			;untersuchen
		move.l max,d0
		move.l min,d1			;Schrittweite=
		CALLFFP SPSub
		move.l d0,d7			;(Max-Min)\
		move.l ymax,d0			;(ymax-ymin)
		move.l ymin,d1
		CALLFFP SPSub
		move.l d0,d1
		move.l d7,d0
		CALLFFP SPDiv
		move.l d0,floatyschritt
		rts

min		dc.l 0
max		dc.l 0


*Daten in Window plotten

zeichnen	move.l iwindowpointer,a0
		move.l 50(a0),d6		;Rastport holen
		move.b masstab,d0
		cmpi.b #1,d0			;Masstab 1:1 ?
		beq noverzerr			;Ja, ok
		move.l min,d0			;Bei Anpassung:
		move.l floatyschritt,d1		;y-Nullinie=
		CALLFFP SPDiv
		move.l ymax,d1			;(Min\Schrittweite)
		CALLFFP SPAdd			;+ymax
		move.l d0,null

noverzerr	move.l null,d0			;Keine x-Achse 
		CALLFFP SPFix			;zeichen, wenn:
		cmpi.l #256,d0
		bge noxlinie			;y grösser 256
		cmpi.l #10,d0
		bls noxlinie			;oder y kleiner 10
		move.l d0,d4
		move.l d6,a1
		clr.l d0
		move.l d4,d1			;x-Achse zeichnen
		CALLGRAF Move			;von (0,200) nach
		move.l d6,a1			;(639,200)
		move.l #639,d0
		move.l d4,d1
		CALLGRAF Draw
noxlinie	move.l floatuntere,d0		;Startzahl negieren
		CALLFFP SPNeg
		move.l floatxschritt,d1		;durch Masstab
		CALLFFP SPDiv
		move.l d0,d2			;=x-Offset
		clr.l d1
		CALLFFP SPCmp			;für y-Achse:
		cmpi.l #1,d0
		beq noylinie			;nicht zeichnen,
		move.l d2,d0
		move.l xmax,d1			;wenn x kleiner 0
		CALLFFP SPCmp
		cmpi.l #-1,d0			;oder x grösser 639
		beq noylinie
		move.l d2,d0
		CALLFFP SPFix			;in Integer wandeln
		move.l d0,d2
		move.l ymax,d0
		CALLFFP SPFix
		move.l d6,a1
		move.l d0,d1			;y-Achse zeichnen
		move.l d2,d0
		CALLGRAF Move
		move.l ymin,d0			;von (x,390) nach 
		CALLFFP SPFix
		move.l d0,d1
		move.l d6,a1			;(x,10)
		move.l d2,d0
		CALLGRAF Draw

noylinie	clr.l d2			;x-Koordinate
		move.l #640,d3			;Zaehler
		clr.l d7
		move.b masstab,d5
plotloop	move.l (a3)+,d0			;Wert holen
		move.l floatyschritt,d1		;Masstab
		CALLFFP SPDiv			;dividieren
		tst.b d5			;Anpassung ?
		beq nofaktor			;nicht quetschen !
		move.l #$A0000040,d1
		CALLFFP SPMul
nofaktor	move.l d0,d1
		move.l null,d0			;Nullinie
		CALLFFP SPSub
		move.l d0,d4			;hinzuaddieren=Koordinate
		move.l ymax,d1			;Maximum
		CALLFFP SPCmp			;vergleichen
		cmpi.l #-1,d0			;groesser ?
		bne plot1			;Ja, kein Punkt
		move.l #255,d0
		bra  plot2
plot1		move.l d4,d0
		move.l ymin,d1			;Minimum
		CALLFFP SPCmp			;vergleichen
		cmpi.l #1,d0			;kleiner
		bne okplot			;Ja, kein Punkt
		move.l #10,d0
plot2		move.l d7,d4
		clr.l d7
		bra  plot3
okplot		move.l d4,d0
		CALLFFP SPFix
		move.l d7,d4
		move.l #1,d7
plot3		move.l d6,a1	  		;Rastport holen
		move.l d0,d1			;x-Koordinate
		move.l d2,d0			;y-Koordinate
		tst.l d4
		beq punkt			;Linie vom letzten
		CALLGRAF Draw			;Punkt zeichnen
		bra  noplot1
punkt		CALLGRAF Move			;Punkt zeichnen
noplot1		addq #1,d2
		subq #1,d3
		bne plotloop
		move.l sicher,floatschritt
		rts
		
floatxschritt	dc.l 0
floatyschritt	dc.l 0

* Window öffnenund Message auswerten

mainwindow	CALLINT OpenWindow
		move.l d0,iwindowpointer	
         
iloop   	move.l iwindowpointer,a0
		move.l 86(a0),a0
		CALLEXEC GetMsg
		tst.l d0		;keine Message
		beq iloop
		move.l d0,a2
		move.l $14(a2),d2	;Wert holen:
		cmpi.l #$200,d2		;Close-Gadget
		beq close
		move.l d0,a2
		move.l $1C(a2),a2	;Adresse User-Gadget
		move.w $26(a2),d2	;Gadget-ID aus Gadget
		cmpi.w #111,d2		;Struktur holen
		beq close
		cmpi.w #112,d2
		beq close
		cmpi.w #113,d2
		bne iloop

close		rts

* Umwandlung String - Fliesskomma

stringfloat     clr.l float
		clr.w EXP
		clr.l d0
		clr.l d3
		move.l (a1),a5		;Start Stringstruktur   
		adda.l #16,a5
		clr.l d5
		move.w (a5),d5          ;Länge Text holen
		move.b (a2),d0          ;erstes Zeichen
		cmpi.b #"-",d0		;Minuszeichen ?
		bne plus
* Negative Zahl

		move.b #128,EXP		;Negativ-Flag setzen
		move.w d5,d0
		move.l a2,a0		;und Rest-String
strloop1	move.b 1(a0),(a0)+
		subq #1,d0		;um eine Position nach
		bne strloop1
		subq #1,d5		;links schieben

plus		clr.l d0		;Position
		move.l a2,a0
strloop2	move.b (a0)+,d3 	;Zeichen holen
		cmpi.b #".",d3
		beq found		;Punkt gefunden
		addq #1,d0
		cmp.w d0,d5		;alles durchsucht
		beq nopoint
		bra  strloop2

found		subq #1,d0
		move.l d0,d4 		;höchster Exponent
		addq #1,d0
		move.l a2,a0		;Punkt aus String
strloop3	move.l a0,a6
		adda.l d0,a6		;eleminieren
		move.b 1(a6),(a6)
		addq #1,d0
		cmp.w d0,d5
		bne strloop3
		subq #1,d5
		bra  weiter1

nopoint		move.l d5,d4
		subq #1,d4  		;höchster Exponent
		
weiter1 	clr.l d6		;Position
		move.l a2,a5

strloop4	move.l d4,d0		;Exponenten holen
		CALLFFP SPFlt		;in Fliesskomma
		move.l d0,d1
		move.l stellentab,d0	;10 in Fliesskomma
		CALLMATHTRANS SPPow	;10 hoch x rechnen
		move.l a5,a6            ;Faktor holen (ASCII)
		adda.l d6,a6
		clr.l d1
		move.b (a6),d1
		subi.b #"0",d1		;minus 48 ("0") =
		move.l d0,d7		;Zahl in Fliesskomma
		move.l d1,d0		;mit 10 hoch x
		CALLFFP SPFlt
		move.l d7,d1
		CALLFFP SPMul		;Multiplizieren
		move.l float,d1
		CALLFFP SPAdd		;zu bisheriger Summe
		move.l d0,float		;addieren
		subq.l #1,d4		;Exponenten verringern
		addq #1,d6 		;Position erhöhen
		cmp.l d6,d5		;fertig ?
		bne strloop4
		move.l float,d0		;Negativ-Flag einblenden
		or.b EXP,d0
		move.l d0,(a3)
		move.l (a1)+,d0		;und Wert in Tabelle
		adda.l #16,a2
		move.l (a3)+,d0
		rts

float		dc.l 0
EXP		dc.w 0

* Tabelle mit Stringanfängen

strinfotabfak   dc.l strinfo1,strinfo2,strinfo3,strinfo4
		dc.l strinfo5,strinfo6,strinfo7,strinfo8

strinfotabexp   dc.l strinfo11,strinfo12,strinfo12,strinfo14
		dc.l strinfo15,strinfo16,strinfo17,strinfo18

strinfotabpar	dc.l strinfo20,strinfo21,strinfo22


* Wandelt Faktoren in Fliesskomma

wandelfak	lea strinfotabfak,a1 ;Tabelle mit Anfängen
		move.w #8,d2		 ;Anzahl Gadgets
		lea fakx1,a2	 ;Start Strings
strloop5	bsr  stringfloat
		subq.w #1,d2
		bne strloop5
		rts

* Wandelt Exponenten in Fliesskomma

wandelexp       lea strinfotabexp,a1 ;Tabelle mit Anfängen
		move.w #8,d2		 ;Anzahl Gadgets
		lea expx1,a2	 ;Start Strings
strloop6   	bsr  stringfloat
		subq.w #1,d2
		bne strloop6
		rts 

* Wandelt Parameter in Fliesskomma

wandelpar       lea strinfotabpar,a1 ;Tabelle mit Anfängen
		move.w #3,d2		 ;Anzahl Gadgets
		lea Untere,a2	 ;Start Strings
strloop7   	bsr  stringfloat
		subq.w #1,d2
		bne strloop7
  		rts

* Berechnungen. Daten ab xwert und ywert

berechnung	move.l #1,d6    	 	;Anzahl Wertepaare
		move.l floatuntere,d7   	;aktueller x-Wert
		lea xwert,a3
		
rechenloop	bsr  berechnez			;Zähler berechnen
		move.l float,d2			;Ergebnis merken
		move.l float,8000(a3) 
		bsr  berechnen			;Nenner berechnen
		move.l float,d0
		move.l float,12000(a3)
		clr.l d1			;Mit 0 vergleichen
		CALLFFP SPCmp
		tst.l d0			;Wenn Nenner = 0,
		bne ungleich
		move.l #$FFFFFFFF,d0		;Ergebnis = 
		bra  divbyzero			;unendlich
ungleich	move.l d2,d0
		move.l float,d1
		CALLFFP SPDiv			;Zähler/Nenner
		bsr  round			;runden
divbyzero	move.l d0,4000(a3)		;nach ywert
		move.l d7,d0
		bsr  round			;runden
		move.l d0,(a3)+			;nach xwert
		move.l d7,d0
		move.l floatschritt,d1		;schrittweite
		CALLFFP SPAdd			;hinzuaddieren
		move.l d0,d7			;ist neues x
		move.l floatobere,d1		;obere Grenze erreicht ?
		CALLFFP SPCmp
		cmpi.l #-1,d0
		beq rechenend			;ja, fertig
		addq #1,d6			;Zähler erhöhen
		bra  rechenloop

rechenend	move.w d6,paarzahl
		rts

paarzahl	dc.w 0
		cnop 0,4

*Werte runden nach y=int(y*1000|100|10+0.5)/1000|100|10

round		clr.l d2
		move.b stellen,d2
		subq #1,d2		;Nachkommastellen -1
		lsl.l #2,d2		;mal 4 wegen Langwort
		addi.l #stellentab,d2	;Plus Tabellenbasis
		move.l d2,a0
		move.l (a0),d2		;Wert holen (1000,100,10)
		move.l d2,d1
		CALLFFP SPMul		;Multiplizieren
		move.l #$80000040,d1	;0.5 addieren
		btst.l #7,d0		;Negativ-Flag gesetzt ?
		beq roundplus		;Nein
		ori.l #%00000000000000000000000010000000,d1
roundplus	CALLFFP SPAdd
		CALLFFP SPFix		;nach Integer
		CALLFFP SPFlt		;nach Fliesskomma
		move.l d2,d1
		CALLFFP SPDiv		;durch 1000/100/10 dividieren
		rts

stellentab	dc.b $A0,$00,$00,$44	;10 
		dc.b $C8,$00,$00,$47	;100
		dc.b $FA,$00,$00,$4A	;1000	

* Berechnung des Polynoms
* Durch DOS-Fehler länger als notwendig
* Gleicher Fehler wie beim C-64 !!! (z.B. -2 hoch 3 = -8, DOS sagt: +8)


polynom		clr.l float		;Summe löschen
		move.l #8,d3		;Zähler setzen
polyloop1	move.l d7,d0		;x-Wert holen
		clr.l d1		;kleiner null
		CALLFFP SPCmp		
		cmpi.l #1,d0
		bne ok			;nein, alles klar
		move.l #2,d0		
		CALLFFP SPFlt		;Zahl 2 in Fliesskomma
		move.l d0,d1
		move.l (a2),d0		;Exponenten holen
		CALLFFP SPDiv		;durch 2 teilen
		move.l d0,a5
		CALLFFP SPFix		;in Integer wandeln
		CALLFFP SPFlt		;wieder in Fliesskomma
		move.l a5,d1
		CALLFFP SPCmp		;beide Zahlen gleich ?
		tst.l d0		;ja, dann gerade Zahl
		beq ok
		move.l #$80,a5
		bra  neg

ok		move.l #0,a5
neg		move.l d7,d0		;x-Wert holen
		move.l (a2)+,d1		;Exponenten holen
		CALLMATHTRANS SPPow     ;x hoch berechnen
		move.l a5,d1		;eventuelles Negativ-
		or.l d1,d0		;Flag einblenden
		move.l (a1)+,d1		;Faktor holen
		CALLFFP SPMul		;Multiplizieren
		move.l float,d1		;Summe holen
		CALLFFP SPAdd		;Wert hinzuaddieren
		move.l d0,float 	;Summe speichern
		subq #1,d3
		bne polyloop1
		rts

*Zaehler berechnen

berechnez	lea floatexpz,a2
		lea floatfakz,a1
		bra  polynom

*Nenner berechnen

berechnen	lea floatexpn,a2
		lea floatfakn,a1
		bra  polynom

*Gibt ein x,y-Paar auf dem Bildschirm aus

xyout		bsr  clearstring		;String vorbereiten
		cmpi.l #$FFFFFFFF,d3	;Unendlich ?
		bne vernünftig		;nein
		move.l #11,d0
		lea textstring1+11,a0
		lea unendlichstr,a1
unloop		move.b (a1)+,(a0)+
		subq #1,d0
		bne unloop
		bra  p4

unendlichstr	dc.b "Unendlich",0
		even


vernünftig	lea textstring1,a0
		cmpi.b #$80,d3		;negative Zahl ?
		bmi positiv
		move.b #"-",(a0)	;Ja, Minuszeichen einfügen
		subi.b #$80,d3
positiv		move.l #1,d2		;Durchgang
		move.l #zehnhochxtab,d6 ;Tabelle mit Potenzen
		move.l #23,d5		;Anzahl der Nachkommastellen
w3		move.l #19,d0		;höchster Exponent
		sub.l d2,d0
		addq.l #3,d0		;Offset
		lsl.l #2,d0		;mal 4 wegen Langwort
		add.l d6,d0		;plus Basis der Tabelle
		move.l d0,a5
		move.l (a5),d0		;Wert holen
		move.l d0,d7
w2		move.l d7,d0
		move.l d3,d1		;mit Zahl vergleichen
		CALLFFP SPCmp		
		cmpi.l #-1,d0	
		beq next		;10 hoch x groesser
		move.l #textstring1,d0
		add.l d2,d0
		cmpi.l #20,d2
		blt w1
		addq #1,d0		;Wert der Position im
w1		move.l d0,a0		;String um eins
		clr.l d0
		move.b (a0),d0		;erhöhen
		addq #1,d0		
		move.b d0,(a0)
		move.l d3,d0
		move.l d7,d1		;Zahl verringern um
		CALLFFP SPSub
		move.l d0,d3		;10 hoch x
		bra  w2

next		addq #1,d2		;Zähler erhöhen
		cmp.l d5,d2		
		bne w3

*Überflüssige Nachkommastellen abschneiden

		move.l #20,d0
		add.b stellen,d0	;Nachkommastellen addieren
p1		move.l #textstring1,d1
		add.l d0,d1
		move.l d1,a0		;Wenn "0" gefunden,
		move.b (a0),d2
		tst.b d2		;eleminieren
		bne nonull
		subq #1,d0
		cmpi.l #20,d0
		bne p1
		clr.b -(a0)		;Keine Nachkommastellen
		bra  p4
nonull		clr.b 1(a0)

* Überflüssige Nullen am Anfang durch Leerzeichen ersetzen

p4		move.l #textstring1,a0
		adda.l #1,a0
p2		move.b (a0)+,d3		;Zeichen holen
		cmpi.b #"0",d3		;"0" ?
		bne pfertig		;Nein, fertig
		move.b (a0),d0
		cmpi.b #".",d0		;"." ?
		beq pfertig		;Ja, fertig
		tst.b d0
		beq pfertig		;Leerzeichen einfügen
		move.b -2(a0),-1(a0)
		move.b #" ",-2(a0)
		bra  p2

pfertig		rts

* Potenzen im Fliesskommaformat

		even
zehnhochxtab	dc.b $83,$12,$72,$37 	;10 hoch -3
		dc.b $A3,$D7,$0A,$3A	;10 hoch -2
		dc.b $CC,$CC,$CC,$3D	;10 hoch -1
		dc.b $80,$00,$00,$41	;10 hoch 0
		dc.b $A0,$00,$00,$44	;10 hoch 1
		dc.b $C8,$00,$00,$47	;10 hoch 2
		dc.b $FA,$00,$00,$4A	;10 hoch 3
		dc.b $9C,$40,$00,$4E	;10 hoch 4
		dc.b $C3,$50,$00,$51	;10 hoch 5
		dc.b $F4,$24,$00,$54	;10 hoch 6
		dc.b $98,$96,$80,$58	;10 hoch 7
		dc.b $BE,$BC,$20,$5B	;10 hoch 8
		dc.b $EE,$6B,$28,$5E	;10 hoch 9
		dc.b $95,$02,$F9,$62	;10 hoch 10
		dc.b $BA,$43,$B7,$65	;10 hoch 11
		dc.b $E8,$D4,$95,$68	;10 hoch 12
		dc.b $91,$84,$D1,$6C	;10 hoch 13
		dc.b $B5,$E5,$F7,$6F	;10 hoch 14
		dc.b $E3,$5F,$83,$72	;10 hoch 15	
		dc.b $8E,$1B,$A7,$76	;10 hoch 16
		dc.b $B1,$A2,$9B,$79	;10 hoch 17
		dc.b $DE,$0B,$50,$7C	;10 hoch 18
	
	cnop 0,4		


*x-Wert auf Bildschirm
		
xout		bsr  xyout
		bra  ausx

*y-Wert auf Bildschirm

yout		bsr  xyout
		bra  ausy

* Ausgabestring vorbereiten

clearstring	lea textstring1,a0
		move.b #" ",(a0)+
		move.l #23,d0		;23 Nullen schreiben
clearloop	move.b #"0",(a0)+
		subq #1,d0
		bne clearloop
		lea textstring1,a0
		move.b #".",20(a0)	;Punkt setzen
		rts


*x-Wert auf Drucker vorbereiten

xdruck		move.l #xstring,a0	;String löschen
		adda.l #1,a0
		move.l a0,a1		;24 Leerzeichen schreiben
		move.l #24,d0
xd1		move.b #" ",(a0)+
		subq #1,d0
		bne xd1
		bsr  xyout		;String generieren
		lea textstring1,a0
xd3		move.b (a0)+,d0		;Zeichen übernehmen
		beq xd2
		move.b d0,(a1)+
		bra  xd3
xd2		rts

*y-Wert auf Drucker vorbereiten

ydruck		lea ystring,a0	;String löschen
		move.l #24,d0
yd1		move.b #" ",(a0)+	;24 Leerzeichen schreiben
		subq #1,d0
		bne yd1
		bsr  xyout		;String generieren
		lea textstring1,a0
		lea ystring,a1
yd3		move.b (a0)+,d0		;Zeichen übernehmen
		beq yd2
		move.b d0,(a1)+
		bra  yd3
yd2		rts


* Wertepaar ausdrucken

druck		move.l printerpointer,d1
		move.l #xstring,d2
		move.l #56,d3		;Stringlänge
		CALLDOS Write
		rts
		even

xstring		dc.b "/",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
		dc.b "  /"
ystring		dc.b 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"  /",$0A


		even

*Überschrift ausdrucken

über		move.l printerpointer,d1
		move.l #überstring,d2
		move.l #112,d3
		CALLDOS Write
		rts

überstring	dc.b "/            X             /            Y             /",$0A
		dc.b "/--------------------------/--------------------------/",$0A

		even

* ENDE MENÜPUNKTE

exit2		move.l iwindowpointer,a0 ;Window schliessen
		CALLINT CloseWindow
		move.l plotpointer,a0	 ;Screen schliessen
		CALLINT CloseScreen
		bra  start		 ;Von vorne
		
exit            move.l iwindowpointer,a0
		CALLINT CloseWindow
exit1		bra  start


* E N D E   P R O G R A M M

ende 	move.l windowpointer,a0		;Menü löschen
	CALLINT ClearMenuStrip

	move.l windowpointer,a0		;Window schliessen
	CALLINT CloseWindow	
				
	move.l screenpointer,a0		;Screen schliessen
	CALLINT CloseScreen

	move.l _DOSBase,a1		;Alle Librarys schliessen
	CALLEXEC CloseLibrary
fini5	move.l _GfxBase,a1
	CALLEXEC CloseLibrary
fini4	move.l _MathTransBase,a1
	CALLEXEC CloseLibrary
fini3	move.l _IntuitionBase,a1
	CALLEXEC CloseLibrary
fini2 	move.l _MathBase,a1
	CALLEXEC CloseLibrary
fini1	rts

	cnop 0,2

		
_DOSBase  dc.l 0			;Basis-Pointer Librarys
_MathBase dc.l 0
_IntuitionBase  dc.l 0
_MathTransBase  dc.l 0
_GfxBase dc.l 0
					
dosname  dc.b "dos.library",0		;Namen Librarys
	cnop 0,2
grafname  dc.b "graphics.library",0
	cnop 0,2
ffpname  dc.b "mathffp.library",0
	cnop 0,2
intname  dc.b "intuition.library",0
	cnop 0,2
mathtransname dc.b "mathtrans.library",0
	cnop 0,2

* Strukturen
* a) SCREENS

screen_defs	SCREEN 320,200,2,screentitel
plot_defs	SCREEN 640,400,$8000,plottitel

screentitel  dc.b "Wertetabelle",0
	cnop 0,4

plottitel   dc.b "Funktion plotten",0
	cnop 0,4

screenpointer  dc.l 0
plotpointer	dc.l 0
  
* b) WINDOWS

zaehlwindow  WINDOW 0,20,280,180,$260,igadget1,zwindowname,point1,$1006             
nennwindow   WINDOW 0,20,280,180,$260,igadget1,nwindowname,point2,$1006      
parawindow   WINDOW 0,20,280,180,$260,igadget20,pwindowname,point3,$1006	     
auswindow    WINDOW 0,20,320,180,$260,igadget30,awindowname,point4,$1006
startwindow  WINDOW 60,60,200,80,$100,0,swindowname,point5,$1006
plotwindow   WINDOW 0,0,640,256,$200,0,plotwindowname,point6,$100E

zwindowname  dc.b   "Funktionseingabe Zaehler",0
	cnop 0,2
nwindowname  dc.b   "Funktionseingabe Nenner",0
	cnop 0,2
pwindowname  dc.b   "Parametereingabe",0
	cnop 0,2
awindowname  dc.b   "         x  Funktionswerte      y",0
	cnop 0,2
swindowname  dc.b   "Wertetabelle Amiga",0
	cnop 0,4
plotwindowname  dc.b "Grafische Funktionsdarstellung",0
	cnop 0,4


iwindowpointer  dc.l 0
windowpointer dc.l 0

		even	

* c) TEXTE
* Ausgabe x,y-Werte

ausx		move.l #2,d0
		lea textstringx,a1
		bra  ausweiter
	
ausy		move.l #125,d0
		lea textstringy,a1

ausweiter	clr.l d1
		move.b zeile,d1
		move.l iwindowpointer,a0
		move.l 50(a0),a0
		CALLINT PrintIText
		rts

textstringx	TEXTOUT textstring1+8
textstringy	TEXTOUT textstring1

textstring1	dc.b " 0000000000000000000.000",0,0,0
		even

zeile		dc.l 0


error  		TEXTOUT1 20,7,errortop
error1		TEXTOUT1 8,4,errorleft
error2		TEXTOUT1 8,4,errorright

errortop	dc.b "Ein- Ausgabefehler",0
		even
errorleft	dc.b "Nochmal",0
		even
errorright	dc.b "Abbruch",0
		even

*Requester aufrufen

requester	move.l windowpointer,a0
		lea error,a1
		lea error1,a2
		lea error2,a3
		clr.l d0
		clr.l d1
		move.l #200,d2
		move.l #55,d3
		CALLINT AutoRequest
		rts


print		PRINTOUT text1,30,20
		PRINTOUT text2,30,40
		PRINTOUT text3,30,60
		rts

 
text1		TEXTOUT text11
text2		TEXTOUT text22
text3		TEXTOUT text33
 
		even
text11          dc.b "Wertetabelle V1.0",0
		even
text22          dc.b "   (w) 1988 by   ",0
		even
text33		dc.b "F.Riemenschneider",0
		even

* d) MENÜS

		
menu		MENUE  menu1,10,0,titel0,eintrag000
menu1		MENUE  menu2,80,0,titel1,eintrag100
menu2		MENUE  0,160,0,titel2,eintrag200


eintrag000	MENUPUNKT eintrag010,0,0,120,$56,0,text000,"Z",0
eintrag010      MENUPUNKT eintrag020,0,15,120,$56,0,text010,"N",0
eintrag020      MENUPUNKT 0,0,30,120,$56,0,text020,"P",0

eintrag100      MENUPUNKT eintrag110,0,0,100,$52,0,text100,0,submenu
eintrag110	MENUPUNKT eintrag120,0,15,100,$52,0,text110,0,submenu1
eintrag120	MENUPUNKT 0,0,30,100,$56,0,text120,"E",0

eintrag200	MENUPUNKT eintrag210,0,0,120,$56,0,text200,"O",0
eintrag210	MENUPUNKT eintrag220,0,15,120,$56,0,text210,"U",0
eintrag220      MENUPUNKT 0,0,30,120,$56,0,text220,"F",0

submenu 	MENUPUNKT submenu01,110,0,115,$56,0,texts00,"B",0
submenu01	MENUPUNKT 0,110,15,115,$56,0,texts01,"D",0
        
submenu1	MENUPUNKT submenu11,110,0,115,$157,$FFFE,texts10,"1",0
submenu11	MENUPUNKT 0,110,15,115,$57,$FFFD,texts11,"A",0


		even
titel0          dc.b "Eingabe",0
		even
titel1		dc.b "Option",0
		even
titel2		dc.b "Plotten",0
		even

text000         TEXTOUT1 0,0,textt000
text010		TEXTOUT1 0,0,textt010
text020		TEXTOUT1 0,0,textt020
text100		TEXTOUT1 0,0,textt100
text110		TEXTOUT1 0,0,textt110
text120		TEXTOUT1 0,0,textt120
text200		TEXTOUT1 0,0,textt200
text210		TEXTOUT1 0,0,textt210
text220         TEXTOUT1 0,0,textt220

texts00          TEXTOUT1 0,0,textts00
texts01       	 TEXTOUT1 0,0,textts01
texts10		 TEXTOUT1 0,0,textts10
texts11		 TEXTOUT1 0,0,textts11


		even
textt000	dc.b "Zähler",0
		even
textt010	dc.b "Nenner",0
		even
textt020	dc.b "Parameter",0
		even
textt100	dc.b "Ausgabe",0
		even
textt110	dc.b "Masstab",0
		even
textt120	dc.b "Ende",0
		even
textt200	dc.b "Zähler",0
		even
textt210	dc.b "Nenner",0
		even
textt220        dc.b "Funktion",0
		even

textts00	dc.b "Bildschirm",0
		even
textts01	dc.b "Drucker",0
		even
textts10	dc.b "  1 : 1",0
		even
textts11	dc.b "  Anpassung",0
		even
 
* e) GADGETS

boarder 
	 dc.w 0,0  	;x,y-Offset
	 dc.b 3,1	;Farben
	 dc.b   0	;Farbmodus
	 dc.b   5	;Zahl Koordinatenpaare
	 dc.l  koord1	;Koordinatenpointer
	 dc.l   0	;Nächster Boarder

koord1          

	dc.w 	 -2,-2
	dc.w     122,-2
	dc.w     122,9
	dc.w     -2,9
	dc.w     -2,-2

regler
	 dc.w 0,0	   ;x,y-Offset
	 dc.w 16,7         ;16 x 7 Pixel groß
	 dc.w  1	   ;1 Bitplane
	 dc.l reglerdata   ;Reglerdaten
	 dc.b 1,0          ;Farben
	 dc.l 0		   ;Nächstes Image
	
reglerdata

	dc.w %0000001110000000
	dc.w %0000011111000000
	dc.w %0000111111100000
	dc.w %0001111111110000
	dc.w %0000001110000000
	dc.w %0000001110000000
	dc.w %0000001110000000
	 

propinfo

	dc.w  2		;Horizontal verschieblich
	dc.w 0,0	;x,y-Position
	dc.w $ffff/3    ;Schrittweite=1/20
	dc.w 0		;keine vertikale Verschiebung
	dc.w 0		;Breite
	dc.w 0		;Höhe
	dc.w 0		;Schrittweite horizontal
	dc.w 0		;Schrittweite vertikal
	dc.w 0		;Linker Rand
	dc.w 0		;Rechter Rand



string11        dc.b  "x",0
	even
string22        dc.b  " Untere Grenze :",0
	even
string33        dc.b  "  Obere Grenze :",0
	even
string44        dc.b  "  Schrittweite :",0
	even
string55        dc.b  "Nachkommastelle:",0
	even
string66	dc.b  "Eingabe beenden",0
	even
string77	dc.b  "1      2      3",0
	even

string88 	dc.b  "Scroll Aufwärts",0
	even
string99	dc.b  "Scroll Abwaerts",0
	even
string100	dc.b  "Ausgabe beenden",0
	even
string1111	dc.b  "--------------------------------------",0
	even


string1         STRING 125,0,string11,0
string2         STRING -133,0,string22,0
string3         STRING -133,0,string33,0
string4         STRING -133,0,string44,0
string5         STRING -133,0,string55,string7
string6		STRING 0,0,string66,0
string7		STRING 0,-10,string77,0
string8 	STRING 0,0,string88,string111
string9		STRING 0,0,string99,0
string10	STRING 0,0,string100,0
string111	STRING -2,-10,string1111,0

* Faktoren 

igadget1     	GADGET igadget2,10,20,4,boarder,string1,strinfo1,1
igadget2        GADGET igadget3,10,35,4,boarder,string1,strinfo2,2
igadget3        GADGET igadget4,10,50,4,boarder,string1,strinfo3,3
igadget4     	GADGET igadget5,10,65,4,boarder,string1,strinfo4,4
igadget5        GADGET igadget6,10,80,4,boarder,string1,strinfo5,5
igadget6        GADGET igadget7,10,95,4,boarder,string1,strinfo6,6
igadget7        GADGET igadget8,10,110,4,boarder,string1,strinfo7,7
igadget8        GADGET igadget11,10,125,4,boarder,string1,strinfo8,8

strinfo1         STRINF fakx1  
strinfo2         STRINF fakx1+16*1
strinfo3         STRINF fakx1+16*2
strinfo4         STRINF fakx1+16*3
strinfo5         STRINF fakx1+16*4
strinfo6         STRINF fakx1+16*5
strinfo7         STRINF fakx1+16*6
strinfo8         STRINF fakx1+16*7

fakx1  		ZAHLENSTRINGS "1","1","1","1","1","1","1","1"

* Exponenten

igadget11    	GADGET igadget12,150,20,4,boarder,0,strinfo11,11
igadget12       GADGET igadget13,150,35,4,boarder,0,strinfo12,12
igadget13       GADGET igadget14,150,50,4,boarder,0,strinfo13,13
igadget14     	GADGET igadget15,150,65,4,boarder,0,strinfo14,14
igadget15       GADGET igadget16,150,80,4,boarder,0,strinfo15,15
igadget16       GADGET igadget17,150,95,4,boarder,0,strinfo16,16
igadget17       GADGET igadget18,150,110,4,boarder,0,strinfo17,17
igadget18       GADGET igadget19,150,125,4,boarder,0,strinfo18,18
igadget19	GADGET 0,80,150,1,boarder,string6,0,111

strinfo11        STRINF expx1
strinfo12        STRINF expx1+16*1
strinfo13        STRINF expx1+16*2
strinfo14        STRINF expx1+16*3
strinfo15        STRINF expx1+16*4
strinfo16        STRINF expx1+16*5
strinfo17        STRINF expx1+16*6
strinfo18        STRINF expx1+16*7

expx1		ZAHLENSTRINGS "0","1","2","3","4","5","6","7"

* Parameter

igadget20       GADGET igadget21,140,30,4,boarder,string2,strinfo20,20
igadget21       GADGET igadget22,140,60,4,boarder,string3,strinfo21,21
igadget22       GADGET igadget23,140,90,4,boarder,string4,strinfo22,22
igadget23       GADGET igadget24,140,120,3,regler,string5,propinfo,23
igadget24	GADGET 0,80,150,1,boarder,string6,0,111


strinfo20        STRINF Untere
strinfo21        STRINF Obere
strinfo22        STRINF Schritt

* Ausgabefenster

igadget30       GADGET igadget31,10,140,1,boarder,string8,0,112
igadget31       GADGET igadget32,185,140,1,boarder,string9,0,113
igadget32	GADGET 0,105,160,1,boarder,string10,0,111

Untere		dc.b  "-2",0,0,0,0,0,0,0,0,0,0,0,0,0
		even
Obere           dc.b  "2",0,0,0,0,0,0,0,0,0,0,0,0,0,0
		even
Schritt		dc.b  "0.5",0,0,0,0,0,0,0,0,0,0,0,0
		even

Unterex1	dc.b  "-2",0,0,0,0,0,0,0,0,0,0,0,0,0
		even
	        dc.b  "2",0,0,0,0,0,0,0,0,0,0,0,0,0,0
		even
		dc.b  "0.5",0,0,0,0,0,0,0,0,0,0,0,0
		even


fakzaehler	ZAHLENSTRINGS "1","1","1","1","1","1","1","1"

expzaehler      ZAHLENSTRINGS "0","1","2","3","4","5","6","7"

faknenner	ZAHLENSTRINGS "1","1","1","1","1","1","1","1"

expnenner       ZAHLENSTRINGS "0","1","2","3","4","5","6","7"

floatfakz       ZAHLENFLOAT $80,$41,$80,$80,$80,$41,$41

floatexpz       ZAHLENFLOAT 0,0,$C0,$A0,$E0,$42,$43

floatfakn       ZAHLENFLOAT $80,$41,$80,$80,$80,$41,$41
		
floatexpn       ZAHLENFLOAT 0,0,$C0,$A0,$E0,$42,$43
		
* Fliesskommazahlen

floatuntere	dc.b   $80,0,0,$C2

floatobere	dc.b   $80,0,0,$42

floatschritt	dc.b   $80,0,0,$40

xwert		ds.l  1000

ywert		ds.l  1000

zaehlwert	ds.l  1000

nennwert	ds.l  1000