[Windows] 2DDrawing Befehle mit AntiAliasing durch GDI+

[ts-soft]

Ohne PB Logo wäre es aber noch interessanter

[rolaf]

Da blinkt ein "Zipfel" übern PB-Schild.

[PureLust]

@Danilo:

Und das Bild hast'e mit Deiner neuen GDI+DrawingLib erstellt? Krass !!!

Kannst'e mir davon mal den Source zukommen lassen?

[Danilo]

Und das Bild hast'e mit Deiner neuen GDI+DrawingLib erstellt? Krass !!!

Nein, das war nur um das warten zu verkürzen...


Update 0.70:

Code: Alles auswählen

gSetUnit( unit.l, unitScale.f )      -     setzen der Maßeinheit für den Zeichenbereich:
                                                #UnitWorld       ; 0 -- World coordinate (non-physical unit)
                                                #UnitDisplay     ; 1 -- Variable -- For PageTransform only
                                                #UnitPixel       ; 2 -- Each unit is one device pixel.
                                                #UnitPoint       ; 3 -- Each unit is a printer's point, or 1/72 inch.
                                                #UnitInch        ; 4 -- Each unit is 1 inch.
                                                #UnitDocument    ; 5 -- Each unit is 1/300 inch.
                                                #UnitMillimeter  ; 6 -- Each unit is 1 millimeter.

                                            Default ist #UnitPixel.
                                            
                                            Über den optionalen Skalierungsfaktor kann man die
                                            Maßeinheit ändern.
                                            gSetUnit( #UnitMillimeter , 10 ) ergibt Zentimeter.
                                            
                                            Nach gSetUnit() sind alle Positions- und Größenangaben
                                            bei Zeichenbefehlen, Font- und Pengröße in der gewählen Maßeinheit.
                                            
                                            gSetUnit( #UnitMillimeter , 10 )
                                            gBox(1,2,5,10)                   ; zeichnet bei 1cm,2cm eine box
                                                                             ; mit der Größe 5cm * 10cm


gGetDpiX()                           -      gibt die DPI-Auflösung des Zeichenbereichs in X-Richtung zurück

gGetDpiY()                           -      gibt die DPI-Auflösung des Zeichenbereichs in Y-Richtung zurück

gSetPenStyle()                       -      2 optionale parameter hinzugefügt um mit dem Style #PenStyleCustom
                                            eigene Liniestile zu erzeugen.

gSetPenAlignment()                   -      ändert die Art wie dicke Pinsel gezeichnet werden.
                                            
                                            gSetPenAlignment( #PenAlignmentCenter ) - pen der größer 1 ist,
                                                                                      wird drumherum gezeichnet,
                                                                                      nach aussen und innen
                                            
                                            gSetPenAlignment( #PenAlignmentInset  ) - pen der größer 1 ist,
                                                                                      wird nach innen gezeichnet

gSetPenCapsScale()                   -      setzen der PenCaps-Größen relativ zur Linienstärke
                                            (gewünscht von STARGÅTE)

gSetPenCaps()                        -      neues Flag #PenCapOpenArrowAnchor um einen offenen
                                            Pfeil zu zeichnen.

gCurve()                             -      zeichnen von Cardinal Splines

gClosedCurve()                       -      zeichnen von geschlossenen Cardinal Splines

gEllipseXY()                         -      diese 4 Befehle nehmen x,y nicht als Mittelpunkt
gCircleXY()                                 sondern wie die anderen Befehle (gBox() usw.) ist
gArcXY()                                    hier x,y der Anfangspunkt in der oberen linken Ecke.
gPieXY()

Die Änderung von PureLust mit der Fontgröße ist wieder raus.
Alle Größen sind dadurch nun auf dem Bildschirm und auf dem Drucker exakt gleich.

Wer es nur für den Bildschirm verwendet, der kann selbst umrechnen:
FontSize = (FontSize * gGetDpiY() / 72)

Der Fehler bei drucken auf diesen Ghostscript-PDF-Druckern sollte
weg sein. Ich habe es mit richtigem Drucker und bullzip getestet.
Hier der Test dazu:

Code: Alles auswählen

XIncludeFile "gDrawing.pbi"

Procedure DrawTo( output )
    If gStartDrawing( output )
        gClear($FFFFFFFF)

        gSetUnit(#UnitMillimeter)               ; use millimeters
    
        pensize.f = 0.1                         ; 0.1mm
        
        gSetPen(RGBA($00,$00,$00,$FF),pensize)
        gSetFont("Arial",40)                    ; fontheight is 40mm

        gDrawingMode(#PB_2DDrawing_Outlined)
        ;gDrawingMode(#PB_2DDrawing_Default)
        gDrawText(5, 5, "gDrawing")             ; draw text at 5mm , 5mm

        gDrawingMode(#PB_2DDrawing_Outlined)
        h = gTextHeight()
        gBox(5,5,gTextWidth("gDrawing"),h)

        gSetPenAlignment(#PenAlignmentInset)
        gSetPenSize(1)                          ; pen size 1mm
        gBox(5,10+h,100,100)                    ; box is 100mm x 100mm
        gLine(6,11+h,98,98)
        gSetFont("Arial",10)
        gDrawingMode(#PB_2DDrawing_Default)
        gDrawText(105,10+h,Str(gGetDpiX())+" x "+Str(gGetDpiY())+" DPI");, RGBA(0,0,0,$FF))
        
        pensize = 0.01
        For i = 0 To 30
            gSetPenSize(pensize)                          ; pen size in mm
            gLineXY(110+i*3,30+h,110+i*3,80+h,$FF000000)
            pensize + 0.05
        Next i
        
        gStopDrawing()
    EndIf
EndProcedure

If gInit()
    mainWin = OpenWindow(#PB_Any,0,0,800,600,"gDrawing printer test 01",#PB_Window_SystemMenu|#PB_Window_ScreenCentered)
    img = CreateImage(#PB_Any,800,600,24)
    DrawTo( ImageOutput(img) )
    imgWin  = ImageGadget(#PB_Any,0,0,800,600,ImageID(img))

    Repeat : Until WaitWindowEvent()=#PB_Event_CloseWindow

    If PrintRequester()
        If StartPrinting("gDrawing() Print Test")

            DrawTo( PrinterOutput() )

            StopPrinting()
        EndIf
    EndIf
    gEnd()
EndIf

Auf Druckern kann man natürlich auch kleinere Pengrößen nehmen.
Auf dem Bildschirm werden Pens die kleiner als 1 Pixel sind, immer
als 1 Pixel groß angezeigt. Auf dem Drucker ist 1 Pixel dann meist
nicht sichtbar, da zu klein - bei meist 600 DPI oder mehr.


Hier ein Beispiel für die Custom Line Styles:

Code: Alles auswählen

;
; gSetPenStyle with #PenStyleCustom
;
XIncludeFile "gDrawing.pbi"

Procedure Draw()
    gDrawingMode( #PB_2DDrawing_Outlined )
    gSetPen($FF000000,3)
    gCircle(200,200,100,RGBA($00,$00,$00,$FF))
    gLineXY(10,400,780,400)

    gSetPenStyle(#PenStyleDot)
    gCircle(410,200,100,RGBA($00,$00,$00,$FF))
    gLineXY(10,410,780,410)


    Dim myStyle.f(5)
    myStyle(0)=5   ; length of line
    myStyle(1)=2   ; length of space
    myStyle(2)=5   ; length of line
    myStyle(3)=2   ; length of space
    myStyle(4)=25  ; length of line
    myStyle(5)=20  ; length of space

    gSetPenStyle(#PenStyleCustom,@myStyle(),6)

    gCircle(620,200,100,RGBA($00,$00,$00,$FF))
    gLineXY(10,420,780,420)


EndProcedure

If gInit()
    mainWin = OpenWindow(#PB_Any,0,0,800,600,"gDrawing feature demo",#PB_Window_SystemMenu|#PB_Window_ScreenCentered)
    img = CreateImage(#PB_Any,800,600,24)
    If gStartDrawing( ImageOutput(img) )
        gClear( RGBA($80,$80,$80,$FF) )
        Draw()
        gStopDrawing()
    EndIf
    imgWin  = ImageGadget(#PB_Any,0,0,800,600,ImageID(img))
    Repeat : Until WaitWindowEvent()=#PB_Event_CloseWindow
    gEnd()
EndIf

Man übergibt also einen Speicherbereich (z.b. Array) mit Floats (.f),
die immer abwechselnd die Länge der Linie und die Länge des
Zwischenraumes angeben.


Hier sehr ihr was gSetPenAlignment() bewirkt:

Code: Alles auswählen

;
; gSetPenAlignment( #PenAlignmentCenter )
;
; gSetPenAlignment( #PenAlignmentInset  )
;
XIncludeFile "gDrawing.pbi"

Procedure Draw()
    gDrawText(100,50,"gSetPenAlignment( #PenAlignmentCenter )")
    gDrawText(400,50,"gSetPenAlignment( #PenAlignmentInset )")

    gDrawingMode( #PB_2DDrawing_Outlined )
    gSetPenSize(20)
    gCircle(200,200,100,RGBA($80,$FF,$80,$FF))
    gSetPenSize(3)
    gCircle(200,200,100,RGBA($00,$00,$00,$FF))

    gSetPenAlignment( #PenAlignmentInset )

    gSetPenSize(20)
    gCircle(500,200,100,RGBA($80,$FF,$80,$FF))
    gSetPenSize(3)
    gCircle(500,200,100,RGBA($00,$00,$00,$FF))

EndProcedure

If gInit()
    mainWin = OpenWindow(#PB_Any,0,0,800,600,"gDrawing feature demo",#PB_Window_SystemMenu|#PB_Window_ScreenCentered)
    img = CreateImage(#PB_Any,800,600,24)
    If gStartDrawing( ImageOutput(img) )
        gClear( RGBA($80,$80,$80,$FF) )
        Draw()
        gStopDrawing()
    EndIf
    imgWin  = ImageGadget(#PB_Any,0,0,800,600,ImageID(img))
    Repeat : Until WaitWindowEvent()=#PB_Event_CloseWindow
    gEnd()
EndIf

Wie kann ich die Pfeilgröße bei #LineCapArrowAnchor ändern, also relativ größer zur Linienstärke ?

Mit gSetPenCapsScale():

Code: Alles auswählen

;
; new #PenCapOpenArrowAnchor for gSetPenCaps
;
; gSetPenCapsScale( StartCapScaleFactor.f, EndCapScaleFactor.f )
;
XIncludeFile "gDrawing.pbi"

Procedure Draw()
    gSetPen($FF000000,3)
    gSetPenCaps(#PenCapArrowAnchor,#PenCapRoundAnchor)
    scale.f = 1.5
    For i = 20 To 780 Step 50
        gSetPenCapsScale(scale,11-scale)
        gLineXY(i,50,i,150)
        scale + 0.5
    Next i

    gSetPenCaps(#PenCapOpenArrowAnchor,#PenCapSquareAnchor)
    scale.f = 1.5
    For i = 20 To 780 Step 50
        gSetPenCapsScale(scale,11-scale)
        gLineXY(i,200,i,300)
        scale + 0.5
    Next i

    gSetPenSize(5)
    gSetPenCaps(#PenCapDiamondAnchor,#PenCapRound)
    scale.f = 1.5
    For i = 20 To 780 Step 50
        gSetPenCapsScale(scale,11-scale)
        gLineXY(i,350,i,450)
        scale + 0.5
    Next i
EndProcedure

If gInit()
    mainWin = OpenWindow(#PB_Any,0,0,800,600,"gDrawing feature demo",#PB_Window_SystemMenu|#PB_Window_ScreenCentered)
    img = CreateImage(#PB_Any,800,600,24)
    If gStartDrawing( ImageOutput(img) )
        gClear( RGBA($80,$80,$80,$FF) )
        Draw()
        gStopDrawing()
    EndIf
    imgWin  = ImageGadget(#PB_Any,0,0,800,600,ImageID(img))
    Repeat : Until WaitWindowEvent()=#PB_Event_CloseWindow
    gEnd()
EndIf

gCurve() / gClosedCurve() Beispiel:

Code: Alles auswählen

XIncludeFile "gDrawing.pbi"

Procedure Draw()
    tension.f = 0
    gSetPen($AAFFFFFF,2)
    gSetFont("Arial",18)
    For i = 0 To 16
        gDrawingMode( #PB_2DDrawing_Default  ) : gCurve      (10,200,50, 50,90,200,tension)
        gDrawingMode( #PB_2DDrawing_Outlined ) : gCurve      (10,200,50, 50,90,200,tension,$FF000000)
        gDrawingMode( #PB_2DDrawing_Default  ) : gClosedCurve(10,400,50,250,90,400,tension)
        gDrawingMode( #PB_2DDrawing_Outlined ) : gClosedCurve(10,400,50,250,90,400,tension,$FF000000)
        gDrawingMode( #PB_2DDrawing_Default  )
        gDrawText(30,205,StrF(tension,2),$FFFFFFFF)
        tension + 0.4
        gSetOrigin(115,0)
    Next i
EndProcedure

If gInit()
    mainWin = OpenWindow(#PB_Any,0,0,800,600,"gDrawing feature demo",#PB_Window_SystemMenu|#PB_Window_ScreenCentered)
    img = CreateImage(#PB_Any,2000,650,24)
    If gStartDrawing( ImageOutput(img) )
        gClear( RGBA($AA,$AA,$AA,$FF) )
        Draw()
        gStopDrawing()
    EndIf
    ScrollAreaGadget(#PB_Any,0,0,800,600,2000,650)
        imgWin  = ImageGadget(#PB_Any,0,0,2000,650,ImageID(img))
    CloseGadgetList()
    Repeat : Until WaitWindowEvent()=#PB_Event_CloseWindow
    gEnd()
EndIf

gArcXY, gPieXY, gEllipseXY, gCircleXY:

Code: Alles auswählen

;
; gArcXY, gPieXY, gEllipseXY, gCircleXY
;
XIncludeFile "gDrawing.pbi"

Procedure Draw()
    gDrawingMode( #PB_2DDrawing_Outlined )

    gBox      (100,100,100,70)
    gArcXY    (100,100,100,70,0,180,$FF000000)

    gBox      (210,100,100,70)
    gEllipseXY(210,100,100,70,$FF000000)

    gBox      (320,100,100,70)
    gCircleXY (320,100,70,$FF000000)

    gBox      (430,100,100,70)
    gPieXY    (430,100,100,70,0,120,$FF000000)
EndProcedure

If gInit()
    mainWin = OpenWindow(#PB_Any,0,0,800,600,"gDrawing feature demo",#PB_Window_SystemMenu|#PB_Window_ScreenCentered)
    img = CreateImage(#PB_Any,800,600,24)
    If gStartDrawing( ImageOutput(img) )
        gClear( RGBA($AA,$AA,$AA,$FF) )
        Draw()
        gStopDrawing()
    EndIf
    imgWin  = ImageGadget(#PB_Any,0,0,800,600,ImageID(img))
    Repeat : Until WaitWindowEvent()=#PB_Event_CloseWindow
    gEnd()
EndIf

EDIT: Include 0.71, kleiner Fehler im Zusammenhang mit gSetPenStyle() behoben.

[Danilo]

Keine Beschwerden = Drucken funktioniert nun korrekt?

Noch kleine Vorschau aufs Wochenende...

[Falko]

[STARGÅTE]

@Danilo

Ich hab' dann noch noch 'n "Beschwerde":
Und zwar, gefallen mir dir Rückgabewerte von gTextWidth() nicht.
gTextHeight() scheint richtig zu arbeiten, aber bei gTextWidth() wird immer "etwas" zu viel Freiraum dazu addiert.
Wenn man (wie ich) nun ein Text mit verschiedenen Font-Blocken zusammen bau, stehen die weiter auseinander, als sie dürften.

Code: Alles auswählen

XIncludeFile "gDrawing.pbi"

gInit()

OpenWindow(1, 0, 0, 800, 600, "gStyledText", #PB_Window_MinimizeGadget|#PB_Window_ScreenCentered)
LoadFont(1, "Arial", 48)
Text$ = "Äq"
gStartDrawing(WindowOutput(1))
	gSetUnit(#UnitPoint)
	gSetFont("Arial", 48)
	gBox(10, 10, gTextWidth(Text$), gTextHeight(Text$), $FFFFFFFF)
	gDrawText(10, 10, Text$, $FF000000)
	DrawingMode(#PB_2DDrawing_Transparent)
	DrawingFont(FontID(1))
	Box(10, 200, TextWidth(Text$), TextHeight(Text$), $FFFFFF)
	DrawText(10, 200, Text$, $000000, $FFFFFF)
gStopDrawing()

Repeat : Until WaitWindowEvent() = #PB_Event_CloseWindow

PS: Auch beginnt gDrawText irgendwie "zu weit rechts"

[Danilo]

@Danilo
Ich hab' dann noch noch 'n "Beschwerde":
Und zwar, gefallen mir dir Rückgabewerte von gTextWidth() nicht.

Habe ich gerade mal angeschaut, Danke.
Sieht allerdings so aus, das ich da wohl nichts machen kann. Kommt so von GDI+
und auch Änderungen des StringFormats brachten nichts. Mal schauen ob mir da
noch etwas einfällt, aber ich glaube eher nicht.


Neue Version 0.80:

Heute gibt es wieder ein paar neue Zeichenbefehle und Clipping für
rechteckige sowie frei definierbare Bereiche:



Und hier die Zusammenfassung:

Code: Alles auswählen

Änderungen:

gSetPenImage()                                               - unterstützt jetzt auch den Alphakanal von PB Images,
                                                               so daß Transparenz mit PenImages möglich ist.

Neuigkeiten:

gDrawImage( Image, x, y [,width, height] )                   - wie PB, zeichnen von Bildern mit optionaler Skalierung nach (width,height).

gDrawAlphaImage( Image, x, y [,width, height [,Alpha] ] )    - zeichnen von Bildern mit optionaler Skalierung nach (width,height).
                                                               dabei kann zusätzlich ein Alphawert angegeben werden um auch
                                                               Bilder ohne Alphakanal transparent zu zeichnen.
                                                               Der Alphawert kann zwischen 0.0 und 1.0 liegen (nicht wie bei PB 0-255).


gDrawClippedImage( Image, x,y,width,height, clipX, clipY, clipWidth, clipHeight [,Alpha] )

                                                             - zeichnen von Bildern mit optionaler Skalierung nach (width,height)
                                                               und Clipping.
                                                               Die Clipping-Parameter geben dabei an, welcher Ausschnitt aus dem
                                                               Bild angezeigt werden soll.
                                                               Zusätzlich kann auch hier ein optionaler Alphawert zwischen 0.0 und 1.0
                                                               angegeben werden.


Alle 3 DrawImage-Befehle ( gDrawImage(), gDrawAlphaImage(), gDrawClippedImage() )
haben als erstes Argument ein 'Image'.
'Image' kann sein:
    1.) eine PureBasic Image Nummer
    2.) eine ImageID()
    3.) ein gepuffertes Bild, siehe gBufferImage()


gImage.i = gBufferImage()                                    - gibt ein gImage zurück. Das ist ein GDI+ Image, und kann somit schneller
                                                               verarbeitet werden als PB Images, da diese immer erst in GDI+ Images
                                                               gewandelt werden müssen.
                                                               Bei wiederholtem anzeigen des gleichen Bildes oder Performance-Problemen
                                                               ist gBufferImage() zu empfehlen.

gFreeImage(gImage)                                           - gibt ein gImage wieder frei, welches mit gBufferImage() erstellt wurde.
                                                               Nicht frei gegebene gImages werden beim beenden des Programmes in gEnd()
                                                               automatisch frei gegeben.



gRoundBox( x, y, width, height, roundX, roundY [, Color] )   - wie PB



gClipBox( x, y, width, height [,combineMode] )               - setzt den Clippingbereich für die nachfolgenden Zeichenoperationen
                                                               in Form eines Rechtecks.
                                                               Nachfolgende Zeichenoperationen sind auf den Clippingbereich beschränkt.

gResetClip()                                                 - setzt den Clippingbereich zurück, so daß nachfolgende Zeichenbefehle
                                                               wieder auf den ganzen Zeichenbereich wirken.

gClipPath( [path [,combineMode]] )                           - setzt den Clippingbereich für die nachfolgenden Zeichenoperationen
                                                               in Form eines Paths.
                                                               Damit kann man nicht-rechteckige Formen als Clippingbereich setzen.
                                                               Nachfolgende Zeichenoperationen sind auf diesen Clippingbereich beschränkt.
                                                               Optional kann ein Path angegeben werden. Ist dieser Path = #PB_Default,
                                                               wird der interne Path von gDrawingMode(#PB_2DDrawing_Path) verwendet.
                                                               
gClipBox() und gClipPath() unterstützen beide den
optionalen Parameter 'combineMode'. Dadurch kann
man Clippingbereiche kombinieren.
Folgende Flags werden für combineMode unterstützt:

  #CombineModeReplace     ; 0 - Specifies that the existing clipping region is replaced by the new clipping region.
  #CombineModeIntersect   ; 1 - Specifies that the existing clipping region is replaced by the intersection of itself and the new clipping region. 
  #CombineModeUnion       ; 2 - Specifies that the existing clipping region is replaced by the union of itself and the new clipping region.
  #CombineModeXor         ; 3 - Specifies that the existing clipping region is replaced by the result of performing an XOR on the two clipping regions.
                          ;     A point is in the XOR of two clipping regions if it is in one clipping region or the other but not in both clipping regions.
  #CombineModeExclude     ; 4 - Specifies that the existing clipping region is replaced by the portion of itself that is outside of the new clipping region.
  #CombineModeComplement  ; 5 (Exclude From)
                          ;   - Specifies that the existing clipping region is replaced by the portion of the new clipping region that is outside of the existing clipping region. 

Default ist #CombineModeReplace, um einen neuen Clippingbereich anzulegen.
Mit #CombineModeUnion fügt man den neuen Clippingbereich dem Alten hinzu.



gDrawingMode(#PB_2DDrawing_Path)                             - neuer Zeichenmodus #PB_2DDrawing_Path mit dem man in ein internes
                                                               Path-Objekt zeichnet.
                                                               Nachfolgende Zeichenoperationen sind nicht auf dem Zeichenbereich
                                                               sichtbar, sondern werden in dem internen Path-Objekt aufgenommen.
                                                               Man zeichnet also, sozusagen, in einen virtuellen Zeichenbereich.
                                                               
                                                               Nachdem man in diesen Path gezeichnet hat, kann man ihn:
                                                                 
                                                                 - mit gDrawPath() anzeigen
                                                                 
                                                                 - mit gGetPath() zwischenspeichern
                                                               
                                                                 - mit gClipPath() als Clippingbereich festlegen


gClearPath( [path.i]                                         - ohne argument: leert den aktuellen Path, der von gDrawingMode(#PB_2DDrawing_Path) verwendet wird
                                                               mit  argument: leert den angegebenen Path

gGetPath()                                                   - gibt den internen, aktuellen Path von gDrawingMode(#PB_2DDrawing_Path) zur
                                                               Zwischenspeicherung zurück.

gFreePath( path.i )                                          - gibt den angegebenen Path wieder frei (löscht ihn).
                                                               Nicht frei gegebene Paths werden automatisch am Ende bei gEnd() gelöscht.

gClosePath( [path.i] )                                       - schließt die Figur, die in den Path gezeichnet wurde.

gDrawPath( [path.i] )                                        - zeichnet die Figur, die in den Path gezeichnet wurde.
                                                               ohne argument wird der aktuelle Path von gDrawingMode(#PB_2DDrawing_Path) gezeichnet.
                                                               mit  argument wird der entsprechende Path gezeichnet.
                                                               
                                                               der Path wird je nach gDrawingMode() gefüllt oder umrandet gezeichnet:
                                                               - #PB_2DDrawing_Default  füllt    den Path mit dem aktuellen Zeichenstift
                                                               - #PB_2DDrawing_Outlined umrandet den Path mit dem aktuellen Zeichenstift



Folgende Zeichenbefehle, die in einen Path gezeichnet werden, werden automatisch
miteinander verbunden:
    - gPlot() (ein Punkt)
    - gLine() / gLineXY()
    - gArc()  / gArcXY()
    - gBezier()
    - gCurve()

Also alle Zeichenbefehle, die keine geschlossene Form ergeben.
Zeichne ich als 5 Punkte in einen Path, werden diese Punkte
automatisch durch Linien verbunden.
Um den letzten Punkt mit dem ersten zu verbinden, und dadurch
eine geschlossene Form zu erstellen, verwendet man gClosePath().

Die neuen Beispiele:

Code: Alles auswählen

Beispiel11.pb - zeigt gDrawClippedImage()
Beispiel12.pb - zeigt gRoundBox() neben PB's RoundBox()
Beispiel13.pb - zeigt einfaches gClipBox()
Beispiel14.pb - zeigt gClipBox() mit dem Flag #CombineModeUnion
Beispiel15.pb - zeigt gDrawingMode(#PB_2DDrawing_Path)
Beispiel17.pb - zeigt erweitertes Clipping mit gDrawingMode(#PB_2DDrawing_Path)
Beispiel18.pb - zeigt gDrawingMode(#PB_2DDrawing_Path) mit Text

Da die Include nicht mehr in die Beschränkung der Beitragsgröße dieses Forums passt,
nun als Download:


DOWNLOAD: gDrawing_v0.80.zip oder gDrawing_v0.80.zip (33,3k)

[ullmann]

Hallo Danilo,

ganz herzlichen Dank für die Bereitstellung von gDrawing. Ich finde das super gut gelungen und umgesetzt.

Darf ich die gDrawing.pbi in meinen Projekten frei verwenden? (Lizenz?, Einschränkungen?)

Wenn du alle geplanten Befehle fertig hast, könntest du dazu noch eine Hilfedatei mitliefern, die Befehlsübersicht, Zweck des
Befehles, Syntax, Parameterbeschreibungen und evtl. je ein kurzes Beispiel enthält? Sonst müsste man beim
Programmieren auf die Beschreibungen in diesem Thread zurückgreifen und sich durch teils veraltete Postings hangeln - das
wäre nicht wirklich zweckmäßig.

Ich habe mir mal die "gDrawing feature demo" angeschaut. Die Struktur mit Funktionsauswahl links und Einstellungen rechts ist
dir sehr gut gelungen. Wünschenswert wäre rechts ein Gadget, mit welchem ich alle Slider auf die Startwerte zurücksetzen
kann. Nachdem ich alles verstellt hatte, musste ich das Programm erst schließen und wieder öffnen um die nächsten Funktionen
mir wieder mit vernünftigen Einstellungen anschauen zu können.

Hier zu der o.g. Demo noch eine kleine Mängelliste:

Ich habe XP / SP3 und sehe bei folgenden Funktionen nur das graue Fenster - ohne das etwas darauf gezeichnet wäre:
gLine() / gLineXY(), gBezier(), gTriangle() und gPoly()
Die anderen Funktionsbeispiele werden gezeichnet.

Bitte bleib dran und entwickele dieses Paket noch zum fertigen Release.

Gruß Rainer

[Danilo]

Hallo Danilo,

ganz herzlichen Dank für die Bereitstellung von gDrawing. Ich finde das super gut gelungen und umgesetzt.

Vielen Dank, das freut mich!

Darf ich die gDrawing.pbi in meinen Projekten frei verwenden? (Lizenz?, Einschränkungen?)

Natürlich kannst Du es frei verwenden wie Du möchtest. Ist nicht nur zum anschauen da.

Wenn du alle geplanten Befehle fertig hast, könntest du dazu noch eine Hilfedatei mitliefern, die Befehlsübersicht, Zweck des
Befehles, Syntax, Parameterbeschreibungen und evtl. je ein kurzes Beispiel enthält?

Halte ich auch für sinnvoll. Meine Motivation neigt sich allerdings langsam
dem Ende zu... mir juckt es in den Fingern meine eigenen Projekte weiter
zu machen - muß mich schon ziemlich zusammenreißen um noch hier dran
zu bleiben.

Ich habe mir mal die "gDrawing feature demo" angeschaut. Die Struktur mit Funktionsauswahl links und Einstellungen rechts ist
dir sehr gut gelungen. Wünschenswert wäre rechts ein Gadget, mit welchem ich alle Slider auf die Startwerte zurücksetzen
kann. Nachdem ich alles verstellt hatte, musste ich das Programm erst schließen und wieder öffnen um die nächsten Funktionen
mir wieder mit vernünftigen Einstellungen anschauen zu können.

Gute Idee, Danke.

Hier zu der o.g. Demo noch eine kleine Mängelliste:

Ich habe XP / SP3 und sehe bei folgenden Funktionen nur das graue Fenster - ohne das etwas darauf gezeichnet wäre:
gLine() / gLineXY(), gBezier(), gTriangle() und gPoly()
Die anderen Funktionsbeispiele werden gezeichnet.

Das ist normal, für diese Befehle gibts noch keine Demo.
Siehe im Source:

Code: Alles auswählen

Procedure demo_gLine()
EndProcedure

Procedure demo_gBezier()
EndProcedure

Procedure demo_gTriangle()
EndProcedure

Procedure demo_gPoly()
EndProcedure

Bitte bleib dran und entwickele dieses Paket noch zum fertigen Release.

Ich versuche es.
Geht ja langsam vorwärts Richtung v1.0...