Tastatur Zeichnen (GDI+ oder fuschen?)

  • VB.NET

Es gibt 5 Antworten in diesem Thema. Der letzte Beitrag () ist von ErfinderDesRades.

    Tastatur Zeichnen (GDI+ oder fuschen?)

    Hallo,
    ich möchte in meiner Form eine Tastatur zeichnen.
    Ziel ist es, ein Programm zum testen der Tastatur zu schreiben.
    (die Tastatur soll mit der Größe der Form wachsen/schrumpfen)
    Betätige ich eine Taste auf der Tastatur, soll entsprechende Taste im Programm andersfarbig dargestellt werden.
    Beispiel aus einem anderen Programm:






    Ich bin mir aber nicht sicher, wie ich die Tastatur zeichnen soll.
    Anfangs habe ich versucht, das mit TableLayoutPanels zu lösen.
    Hat nur lausige 18 TableLayoutPanels gebraucht, bis ich ein Gebilde hatte, welches als Tastatur zu erkennen war :P
    Es war sogar noch ganz performant, wenn ich die Größe der Form verändert habe.
    Kleines Bildchen bei betätigter Leertaste:






    Aber irgendwie war mir das nicht Professionell genug. Ich wollte es direkt "richtig" machen.
    Also probierte ich jede Taste einzeln zu zeichnen. Natürlich nie in Pixel Angaben, sondern alles Prozentual zur Form Breite & Höhe:






    Funktionierte soweit auch gut. Zumindest solange bis ich mich das erste mal gefragt habe, wie ich die einzelnen gezeichneten Rechtecke farbig bekomme, wenn ich mal eine Taste drücke.
    Ich meine, das sind einfach hintereinander weg gezeichnete Rechtecke. Keine Objekte denen ich mal eben eine neue Farbe verpassen kann.

    Meinen Test Code kann ich auch mal anhängen:
    Spoiler anzeigen

    VB.NET-Quellcode

    1. ​
    2. Private Sub frmTestsInput_Paint(sender As Object, e As PaintEventArgs) Handles MyBase.Paint
    3. Dim z As Graphics = CreateGraphics()
    4. Dim pen As New Pen(Color.Black, 1)
    5. Dim BrushText As New SolidBrush(Color.White)
    6. Dim BrushRectangle As New SolidBrush(Color.Black)
    7. Dim font As New Font("Arial", 10)
    8. z.Clear(BackColor)
    10. 'ESC
    11. z.FillRectangle(BrushRectangle, 10, 10, CInt(Me.Width / 100 * 6), CInt(Me.Height / 100 * 10))
    12. z.DrawString("ESC", font, BrushText, 10, 10)
    14. ' F1 - F4
    15. z.FillRectangle(BrushRectangle, CInt(Me.Width / 100 * 10), 10, CInt(Me.Width / 100 * 6), CInt(Me.Height / 100 * 10))
    16. z.DrawString("F1", font, BrushText, CInt(Me.Width / 100 * 10), 10)
    17. z.FillRectangle(BrushRectangle, CInt(Me.Width / 100 * 16.5), 10, CInt(Me.Width / 100 * 6), CInt(Me.Height / 100 * 10))
    18. z.DrawString("F2", font, BrushText, CInt(Me.Width / 100 * 16.5), 10)
    19. z.FillRectangle(BrushRectangle, CInt(Me.Width / 100 * 23), 10, CInt(Me.Width / 100 * 6), CInt(Me.Height / 100 * 10))
    20. z.DrawString("F3", font, BrushText, CInt(Me.Width / 100 * 23), 10)
    21. z.FillRectangle(BrushRectangle, CInt(Me.Width / 100 * 29.5), 10, CInt(Me.Width / 100 * 6), CInt(Me.Height / 100 * 10))
    22. z.DrawString("F4", font, BrushText, CInt(Me.Width / 100 * 29.5), 10)
    23. End Sub




    Gleich mal noch eine Nebenbaustelle:
    Ich habe sowohl in meinem VB.Net Büchlein, als auch hier im Forums Tutorial gelesen, das ich im ​Paint Event ​e.Graphics verwenden soll/muss/kann.
    Das hat aber im Gegensatz zu ​Dim z As Graphics = CreateGraphics() den Nachteil, das sich beim ändern der Formgröße nichts aktualisiert. Habe ich da etwas falsch gemacht?


    Zurück zum Hauptproblem:
    Mir fehlt das nötige Konzept, um mein Vorhaben umsetzen zu können.
    Ich würde mich da über Vorschläge eurerseits freuen.

    Auf der Form zu zeichnen ist etwas langsamer. Benutzt lieber ein Panel oder eine Picturebox. Du kannst auch noch ein paar Styles in der Form oder dem Control setzen:

    VB.NET-Quellcode

    1. SetStyle(ControlStyles.AllPaintingInWmPaint | ControlStyles.ResizeRedraw | ControlStyles.UserPaint, true)

    Ein etwas anderer Ansatz

    ... aber vielleicht inspiriert er Dich ja:
    Anstatt die ganze Tastatur zu Zeichen, könntest Du auch ein eigenes Control erstellen, das eine Taste auf der Tastatur repräsentiert.
    Dann könntest Du Dein Control auch später in eine Lib. stecken und gegeben falls später erneut verwenden. :D

    Microsoft hat sogar im MSDN ein Artikel wie man solch ein eigenes Control erstellt: Erstellen von Visual-Basic-.NET-Steuerelementen

    Die Performance ist dieselbe, egal ob auf Form, Picturebox oder Panel gezeichnet wird. Weil sind alles Controls, und ihr PaintEventargs ist dasselbe.
    Aber auf ein Panel ist sinnvoll, damit man evtl. noch annere Sachen aufs Form packen kann.
    Und ja, ich würde auch ein Tastatur-Control erfinden, geerbt von Control.
    Aber zum Zeichnen muss noch 'ne Menge mehr erfunden werden, also da muss man richtig OOP anwenden - Vererbung habich schon genannt, aber auch eine Taste-Klasse als ZeichenObjekt wäre zu schaffen, also eine Einheit, die weiß, wie sie sich selbst als Taste zeichnet.
    Und dann ist vorteilhaft - na eiglich erforderlich, dass man mit Drawing2D.Graphicspath und Drawing2D.Matrix umgehen kann, sonst macht man sich nur schwer.

    @Anluin
    Ja, das hilft sehr. Genau so habe ich es jetzt gemacht.Das Tutorial war auch super.

    ErfinderDesRades schrieb:


    Und dann ist vorteilhaft - na eiglich erforderlich, dass man mit Drawing2D.Graphicspath und Drawing2D.Matrix umgehen kann, sonst macht man sich nur schwer.


    Inwieweit das für mich relevant ist konnte ich noch nicht feststellen.
    Dient es der Positionierung der Tasten?

    Mithilfe des oben genannten Tutorials habe ich mir folgende Control Klasse geschrieben:

    Spoiler anzeigen
    ​

    VB.NET-Quellcode

    1. Imports System.ComponentModel
    3. Public Class KeyboardKey : Inherits System.Windows.Forms.Control
    4. Public Enum KeyStatus
    5. KeyNotPressed = 1
    6. KeyIsPressing = 2
    7. KeyPressed = 3
    8. End Enum
    10. Dim mStatus As KeyStatus = KeyStatus.KeyNotPressed
    11. Dim mText As String
    12. Public Event StatusChanged(ByVal NewStatus As KeyStatus)
    14. <DefaultValue(KeyStatus.KeyNotPressed)> _
    15. Public Property Status() As KeyStatus
    16. Get
    17. Status = mStatus
    18. End Get
    19. Set(ByVal Value As KeyStatus)
    20. If mStatus <> Value Then
    21. mStatus = Value
    22. RaiseEvent StatusChanged(mStatus)
    23. Me.Invalidate()
    24. End If
    25. End Set
    26. End Property
    28. Public Overrides Property Text As String
    29. Get
    30. Return mText
    31. End Get
    32. Set(ByVal Value As String)
    33. mText = Value
    34. Me.Invalidate()
    35. End Set
    36. End Property
    38. Protected Overrides Sub OnPaint(ByVal e As System.Windows.Forms.PaintEventArgs)
    39. MyBase.OnPaint(e)
    40. Dim grfGraphics As System.Drawing.Graphics
    41. grfGraphics = e.Graphics
    43. Dim BrushText As New SolidBrush(Color.White)
    44. Dim ColorKey As Color
    45. Dim Font As New Font("Arial", 8)
    47. Select Case Status
    48. Case KeyStatus.KeyNotPressed
    49. ColorKey = Color.Black
    50. Case KeyStatus.KeyIsPressing
    51. ColorKey = Color.Red
    52. Case KeyStatus.KeyPressed
    53. ColorKey = Color.Green
    54. End Select
    56. Dim BrushRectangle As New SolidBrush(ColorKey)
    57. grfGraphics.FillRectangle(BrushRectangle, 0, 0, 100%, 100%)
    58. grfGraphics.DrawString(Text, Font, BrushText, 0, 0)
    60. ' Die Zeichnungsobjekte löschen.
    61. BrushText.Dispose()
    62. BrushRectangle.Dispose()
    63. Font.Dispose()
    64. grfGraphics.Dispose()
    65. End Sub
    67. Private Sub KeyboardKey_Resize(ByVal sender As Object, ByVal e As System.EventArgs) Handles MyBase.Resize
    68. Me.Invalidate()
    69. End Sub
    71. End Class



    Tasten sind nicht schön, aber erstmal funktionell.
    Jetzt ist natürlich die Frage, wie ich die Tasten positioniere, wenn ich das Fenster (die Form) skalierbar haben möchte.
    Was wäre die geeignetste Möglichkeit?

    ja, ok, das ist ja "ein etwas anderer Ansatz", da kommste offsichtlich auch ohne das Drawing2D-Instrumentarium aus.
    Halt um den Preis, dass du für jede Taste ein eigenes Control aufwenden musst (sind glaub > 100). Meine Vorstellung war eher, für die Gesamt-Tastatur ein einziges Control aufzuwenden, und alle Tasten darauf selbst zu zeichnen.
    Aber ich will dir nix einreden, mein Ansatz ist nicht ganz einfach.
    Vorzüge hat er im Bereich Resourcen-Schonung und Performance, zB kann ich mir vorstellen, dass deine 100 Controls beim Resizen ziemlich träge reagieren - falls du eine flexible Größe ühaupt unterstützt.

Facebook
Telefonspende