GUI-Creator in C#

[Holger K. (holgerkraehe)]

Hallo zusammen

Ich weiss nicht, ob es hier überhaupt C# Programmierer hat.
Auf jedenfall versuche ich es mal.

Folgender Hintergrund:

Ich zeichne auf einer Embedded Platform ein eigenes GUI mit 
verschiedenen Elementen wie Buttons etc. Nun möchte ich einen GUI-Editor 
für den PC entwerfen. Damit die Elemente identisch aussehen, würde ich 
die funktionen zum zeichnen dieser, auch in C# implementieren. Die 
Funktionen benutzen SetPixel zum zeichnen der Umrisse.

Nun bin ich also soweit, dass ich z.b. einen Button auf einem Bitmap 
meiner PictureBox in C# habe.
Schön und gut. Nun möchte ich diesen aber verschiebbar machen.

Eine option wäre:
bei klick auf die picturebox x,y merken und nachschauen in einem array, 
welches gezeichnete Element sich innerhalb dieses bereichs befindet. 
Wenn nun die Maus bewegt wird, zeichne ich das element neu mit dem 
offset um welchen die maus bewegt wurde.

Würde wohl funktionieren, damit es keine probleme mit vorhandenen 
elementen gibt, müsste ich für jedes element einen eigenen "layer" also 
ein leeres bitmap erzeugen und diese dann übereinander legen.

Sehr aufwändig. Daher dachte ich ich frage mal in die Runde ob jemand 
einen eleganteren Weg sieht.

Ach ja, beim klick auf das "element" soll ich auch die möglichkeit haben 
eigenschaten anzupassen.

Danke schonmal

[Wolfgang H. (drahtverhau)]

Windowsondevices.com.

[Arc N. (arc)]

Holger K. schrieb:
> Sehr aufwändig. Daher dachte ich ich frage mal in die Runde ob jemand
> einen eleganteren Weg sieht.
>
> Ach ja, beim klick auf das "element" soll ich auch die möglichkeit haben
> eigenschaten anzupassen.
>
> Danke schonmal

Ich würde es vom Framework (WPF, WinForms?) machen lassen ;)
Für die eigenen Elemente jeweils von Control erben, OnPaint und bei 
Bedarf  OnPaintBackground und OnResize überschreiben (WinForms). Dann 
können die ganz normal wie alle anderen Controls zur Design- und 
Laufzeit verwendet werden. Die Eigenschaften dieser Controls kann man 
sich zur Laufzeit bspw. mit dem PropertyGrid anzeigen und ändern lassen.

https://docs.microsoft.com/en-us/dotnet/api/system.windows.forms.propertygrid?view=netframework-4.7.1

Sieht viel aus, ist aber eigentlich einfach
https://docs.microsoft.com/en-us/dotnet/framework/winforms/controls/developing-custom-windows-forms-controls

class OwnControl : Control {
    public OwnControl() { ... }
    
    protected override void Dispose(bool disposing) {
        if (disposing) {
            // managed resources
        }
        // unmanaged resources
        base.Dispose(disposing);
    }

    private void InitializeComponent() {
        this.SuspendLayout();
        this.ResumeLayout(false);
    }

    protected override void OnPaint(PaintEventArgs e) { ... }

    [Category("MyControlCollectionWhatever")]
    [DefaultValue(true)]
    [Description("A simple boolean")]
    public bool ABooleanProperty {
        get { ... }
        set { ... Invalidate(); }
    } 
}

Will man die ererbten Eigenschaften später nicht in einem PropertyGrid 
sehen, gibt's ein paar Möglichkeiten: 
https://stackoverflow.com/questions/7054408/propertygrid-hide-base-class-properties-how

[Holger K. (holgerkraehe)]

Arc N. schrieb:
> Ich würde es vom Framework (WPF, WinForms?) machen lassen ;)
> Für die eigenen Elemente jeweils von Control erben, OnPaint und bei
> Bedarf  OnPaintBackground und OnResize überschreiben (WinForms).

Danke für deinen Vorschlag.
Gefällt mir grundsätzlich sehr gut.

Habe gelesen, WinForms sei tot. Nach ein paar Versuchen scheint mir aber 
WinForms für mein Ziel einfacher zu sein, da vieles schon vorhanden ist.
Oder irre ich mich da? Sollte ich lieber auf WPF setzen?

Ich bin ziemlich neu mit C# und WinForms / WPF.
Habe bisher nur Delphi programmiert (auf PC seite).

Arc N. schrieb:
> Sieht viel aus, ist aber eigentlich einfach
> 
https://docs.microsoft.com/en-us/dotnet/framework/winforms/controls/developing-custom-windows-forms-controls

Ich werde mich in deinen Link sowie die Klasse mal einarbeiten.
Das Konzept ist mir klar, wie wo was geschrieben werden muss, muss ich 
mir noch anschauen.

Danke.

[Holger K. (holgerkraehe)]

Funktioniert hervorragend!
Vielen Dank.

Fragt sich, ob ich denn auch zoomen kann.
Es soll ja ein virtuelles Display dargestellt werden.
Dafür würde ich ein panel nehmen.

Aber zoomen?

[Arc N. (arc)]

Holger K. schrieb:
> Arc N. schrieb:
>> Ich würde es vom Framework (WPF, WinForms?) machen lassen ;)
>> Für die eigenen Elemente jeweils von Control erben, OnPaint und bei
>> Bedarf  OnPaintBackground und OnResize überschreiben (WinForms).
>
> Danke für deinen Vorschlag.
> Gefällt mir grundsätzlich sehr gut.
>
> Habe gelesen, WinForms sei tot. Nach ein paar Versuchen scheint mir aber
> WinForms für mein Ziel einfacher zu sein, da vieles schon vorhanden ist.
> Oder irre ich mich da? Sollte ich lieber auf WPF setzen?

WinForms wird zwar ganz gerne für tot erklärt, bekommt aber 
nichtsdestotrotz zumindest div. Wartungen bspw. 4.7 wiederum verbesserte 
HiDPI-Unterstützung 4.7.1 Accessibility, High Contrast etc.
WPF ist deutlich flexibler, bessere Trennung von Code und UI, bessere 
Abstraktionsmöglichkeiten, XAML wird für alles mögliche genutzt WPF, 
UWP, Cross-Platform z.B. Xamarin (leider nicht für W7) oder Avalonia 
(Linux, iOS, Android, Windows https://github.com/AvaloniaUI/Avalonia), 
aber am Anfang auch mit deutlich steilerer Lernkurve
Performance: YMMV... bei großen Datenmengen ist man, egal wo, schnell 
bei OpenGL, WebGL oder DirectX

> Ich bin ziemlich neu mit C# und WinForms / WPF.
> Habe bisher nur Delphi programmiert (auf PC seite).

Delphi, C#, WinForms, .NET haben viele Gemeinsamkeiten, Stichwort Anders 
Hejlsberg, relativ wenig Umgewöhnung (nutze für einige Sachen hier immer 
noch den C++Builder)

Holger K. schrieb:
> Funktioniert hervorragend!
> Vielen Dank.
>
> Fragt sich, ob ich denn auch zoomen kann.
> Es soll ja ein virtuelles Display dargestellt werden.
> Dafür würde ich ein panel nehmen.
>
> Aber zoomen?

https://msdn.microsoft.com/library/ms158413 wäre eine Möglichkeit

 
foreach (Control c in containerPanel.Controls) {
    c.Scale(new SizeF(xFactor, yFactor));
}

Oder "manuell" als separate Eigenschaft der CustomControls 
unabhängig/zusätzlich vom/zum vorhandenen Skalierungs-Mechanismus

[Wolfgang H. (drahtverhau)]

Ich würde trotzdem zu wpf bzw xaml raten.