Type TViewport
	Field x:Int = 0
	Field y:Int = 0
	Field width:Int = 0
	Field height:Int = 0
	
	Field oldX:Int = 0
	Field oldY:Int = 0
	Field oldWidth:Int = 0
	Field oldHeight:Int = 0
	
	Method Create:TViewport(x:Int, y:Int, w:Int, h:Int)
		Self.Set(x, y, w, h)
		Return Self
	End Method
	Method Set(x:Int, y:Int, w:Int, h:Int)
		Self.x = x
		Self.y = y
		Self.width = w
		Self.height = h
	End Method
	
	Method apply(xoffset:Int, yoffset:Int)
		GetViewport(oldX, oldY, oldWidth, oldHeight)
		SetViewport(x + xoffset, y + yoffset, width, height)
	End Method
	
	Method ApplyWithIntersect(xoffset:Int, yoffset:Int)
		'xoffset + yoffset sind für eventuelle verschiebungen, die an einem fenster oder ähnlichem vorgenommen wurden.
		
		GetViewport(oldX, oldY, oldWidth, oldHeight)
		
		Local vpX:Int = Max(x + xoffset, oldx) 'den größeren von beiden werten bevorzugen: Sollte der viewport eines Textfields links aus dem fenster rausragen!
		Local vpY:Int = Max(y + yoffset, oldy) 's.o -> nach oben hin begrenzen 
		
		Local vpX2:Int = Min(x + xoffset + width, oldx + oldwidth) 'begrenzen nach rechts: Ragt der textfield-viewport über das fenster hinaus, wirds begrenzt.
		Local vpY2:Int = Min(y + yoffset + height, oldy + oldheight) 's.o. -> nach unten hin begrenzen
		
		SetViewport(vpX, vpY, vpX2 - vpX, vpY2 - vpY)
		
	End Method
	
	Method Restore()
		SetViewport(oldX, oldY, oldWidth, oldHeight)
	End Method
End Type

Type tTextfield
     Field x:Int,y:Int,w:Int,h:Int
     Function Create:TTextfield(x:Int,y:Int,w:Int,h:Int)
           Local tf:TTextfield = New TTextfield
           tf.x = x
           tf.y = y
           tf.w = w
           tf.h = h
           Return tf
      End Function
End Type

Local window:TTextfield = TTextfield.Create(50,50,100,100) 'der einfachheithalber als "dummy" fürs fenster. Nur zum erklären :>
Local textfeld:TTextfield = TTextfield.Create(100,100,100,100) 

SetViewport(window.x,window.y,window.w, window.h) ' fenster setzen
'inhalte zeichnen

'nun zum textfield:
Local tmpx:Int = textfeld.x
Local tmpy:Int = textfeld.y
Local tmpw:Int = textfeld.w
Local tmph:Int = textfeld.h

'tmpX etc enthalten unsere viewport werte. Nun prüfen wir, ob diese eventuell das fenster-viewport krams überschreiten würden:

If tmpx < window.x Then
     tmpx = window.x 'neues start-x angeben
     tmpw = tmpw - (window.x-textfeld.x) ' von der aktuellen breite die differenz abziehen. 
             ' Da window.x größer ist, erhalten wir mit window.x-textfeld.x die differenz, um welche wir grade tmp.x "erhöht" haben -> dieser wert muss von der alten breite abgezogen werden, damit der "endpunkt" des rechtecks erhalten bleibt.
EndIf

If tmpx + tmpw > window.x + window.w Then
     'die breite würde das fenster überschreiten. Also: aus obieger abfrage die differenz rausziehen und als tmpw setzen :)
     tmpw = tmpw -  ((window.x + window.w) - (tmpx +tmpw)) ' beispiel: 100 -( (50 + 100) - (100 + 100))
    'unser textfield würde also bei koordinate 200 enden. das fenster ended aber bei 150. Ergo: wir ziehen die differenz, hier 50, von tmpw ab.
EndIf
'selbes spiel nochmal für y und h werte.


'oder direkt vereinfacht: wir nutzen min und max:

tmpx = Max( textfield.x , window.x) 'größerer von beiden werten wird wiedergegeben. hier also: textfield.x
tmpy = Max( textfield.y , window.y) 'siehe oben

tmpx2 = Min( textfield.x + textfield.w, window.x+window.w) 'trickiger: wir berechnen erst einen zwischenschritt, tmpx2. Dieser ist der totale xkoordinaten punkt, welcher durch x+breite gebildet wird. wir nehmen den kleineren der beiden werte: entweder window oder textfeld.  
tmpy2 = Min( textfield.y + textfield.h, window.y + window.h ) 'siehe oben

tmpw = tmpx2-tmpx ' die differenz zu tmpx bildet nun unsere wunschbreite
tmph = tmpy2 - tmpy 'siehe oben.

Local textbreite:Int = TextWidth( _string)
Local sliderPosition:Float = slider.getPosition() 'ausgehend hier: wert zwischen 0.0 und 1.0 als skalierfaktor
Local textFieldWidth:Float = Self.width

SetOrigin ( -(textbreite - textfieldwidth) * sliderposition, 0) 'scrollen :)