# File scribble22.rb, line 254
                        def drawFunction(function,zoomTarget,zoomValue,xCoordTarget,yCoordTarget)
                                        FXDCWindow.new(@canvas) do |dc|
                                        dc.foreground = @canvas.backColor
                                        dc.fillRectangle(0, 0, @canvas.width, @canvas.height)
                                        @dirty = false
                                
# Regulärer Ausdruck zur Zerlegung des Polynoms in Monome
                                        monomExp = /([\+|-]?\d+\.\d+\*x\*\*\d+)/

                                        functionArray = function.to_s.scan(monomExp)
                                        zoom   = zoomTarget.to_s.to_f+0.5
                                        xCoord = xCoordTarget.to_s.to_f
                                        yCoord = yCoordTarget.to_s.to_f

# neue Polynominstanz                                   
                                        @pol= Polynom.new

# Ermitteln der Koeffizienten und Exponenten
# jedes einzelnen Monoms mit Hilfe von reg. Ausdrücken
                                        for i in 0..functionArray.length-1 do
                                                coeff = functionArray[i].to_s.scan(/[\+|-]?\d+.\d+/)[0].to_f
                                                exp   = functionArray[i].to_s.scan(/\d+/)[2].to_i
                                                monom=Monom.new(coeff,exp)
                                                @pol.extPoly(monom)
                                        end
                                        
# Nullstelle des Polynoms zur Justierung von Koordinatenursprung und Zoomfaktor
                                        intersectY = @pol.evalPoly(0)

# Berechnung des nötigen Zoomfaktors
                        if !zoomValue        
                                        const =50
                                        if intersectY > 0
                                                while intersectY*const > yCoord
                                                        const = const/2
                                                end
                                        else
                                                if intersectY != 0
                                                        while (intersectY*const).abs > (@canvas.height-yCoord)
                                                                const = const/2
                                                        end
                                                end
                                        end        
                        else
                                const = zoom
                        end
                        
# Zeichnen und Skalieren der y-Achse                            
                                        dc.foreground = 'black'
                                        dc.drawLine(xCoord, 0, xCoord, @canvas.height)
                                        i = yCoord
                                        j = yCoord
                                        while ((i.abs+j.abs) <= 2*@canvas.height)
                                                dc.drawLine(xCoord-5, i+const, xCoord+5, i+const)
                                                i += const
                                                dc.drawLine(xCoord-5, j-const, xCoord+5, j-const)
                                                j -= const
                                        end
                                        
# Zeichnen und Skalieren der x-Achse
                                        dc.drawLine(0, yCoord, @canvas.width, yCoord)
                                        i = xCoord
                                        j = xCoord
                                        while ((i.abs+j.abs) <= 2*@canvas.width)
                                                dc.drawLine(i+const, yCoord-5, i+const, yCoord+5)
                                                i += const
                                                dc.drawLine(j-const, yCoord-5, j-const, yCoord+5)
                                                j -= const
                                        end
                                        
# Berechnen und Zeichnen der Funktion
                                        dc.foreground = @drawColor.rgba
                                        i=-12*(50/const)
                                        while i<12*(50/const)
                                                dc.drawPoint(xCoord+i*const      , yCoord-@pol.evalPoly(i)*const)
                                                dc.drawLine(xCoord+(i-0.1)*const , yCoord-@pol.evalPoly(i-0.1)*const,
                                                                                                xCoord+i*const       , yCoord-@pol.evalPoly(i)*const)
                                                i=i+0.1
                                        end
                                end
                        end