zeichnen von Linien und Rechtecken
hallo.
bin neuling in c#.
hab mal ne frage: wie muss ich generell ran gehen wenn ich auf einer Form verschiedene Dinge zeichnen will, wie Linien, Rechtecke usw.??
gibts da ein Zeichenobjekt, ne zeichenoberfläche oder sowas??
kann mir da jemand ein paar einsteigertipps geben??
danke!!
Such mal nach GDI+. Habe damit auch mal bisschen rumgespielt. Wenn du nur Linien und sowas zeichnen willst, sollte es deinen Anforderungen genügen.
Hallo c#_gast,
ich denke du meinst das Zeichen auf einem Control.
Schau dir in der Doku mal die Themen zu Graphics an. Da solltest du einige Beispiele dazu finden.
Solltest du den Designer meinen, dass geht nicht. Der Designer kann nur Objekte (Controls) verwalten, anzeigen und bearbeiten. Willst du eine Grafik auf einer Form haben, gibt es die PictureBox, in welche du deine Grafik reinzeichnen musst, siehe oben, oder du gibst ein Bild (z.B. BMP) an, welches angezeigt wird.
Gruss
Friedel
Ohne Ziel ist auch der Weg egal.
na ich will im programm, also zur Laufzeit Linien zeichnen oder so, z.B. wenn ein Button gedrückt wurde. wie muss ich das machen??
Antwort s.o. ohne 2. Absatz +
Gib "Zeichnen von Linien und Formen mit GDI+" in die Suche der SDK (Doku) ein und du findest alles was du brauchst !
Friedel
Ohne Ziel ist auch der Weg egal.
Hallo c#_gast,
OnPaint überschreiben und mit den Methoden von e.Graphics zeichnen (Graphics-Klasse).
Du kannst aber nicht einfach zeichnen, wenn ein Button gedrückt wurde. Du musst immer und nur in OnPaint zeichnen. Windows ruft die Methode auf, wenn (neu) zu zeichnen ist. Wenn du willst, dass neu gezeichnet wird, musst du Control.Invalidate aufrufen.
herbivore
_Original von c#gast
na ich will im programm, also zur Laufzeit Linien zeichnen oder so, z.B. wenn ein Button gedrückt wurde. wie muss ich das machen??
es gibt zu jedem steuerelement eine Paint-Aktion, in dieser wird festgelegt was auf das steuerelement gezeichnet wird.
natürlich kannst du diese aktion dann auch per buttonklick ausführen.
du brauchst ein "Graphics"-Objekt und kannst dann über methoden drawLine, drawRectengle etc figuren zeichnen und auch über andere methoden füllen.
bin grad noch auf arbeit.... wenn ich daheim bin stell ich dir mal n kleines beispiel rein.
Original von herbivore
Du kannst aber nicht einfach zeichnen, wenn ein Button gedrückt wurde. Du musst immer und nur in OnPaint zeichnen. Windows ruft die Methode auf, wenn (neu) zu zeichnen ist. Wenn du willst, dass neu gezeichnet wird, musst du Control.Invalidate aufrufen.
naja wie du ja auch schon andeutest. das geht schon wenn man z.B. n bissl mit hilfsvariablen rumtrickst.
Original von Flippo
bin grad noch auf arbeit.... wenn ich daheim bin stell ich dir mal n kleines beispiel rein.
das wär spitze!! danke!!
Hallo c#_gast,
ohne Flippos Beispiele traurig machen zu wollen, solange musst du gar nicht warten. In der SDK-Doku findest du ebenfalls Codebeispiele, z.B. bei der Control.OnPaint-Methode.
Hallo Flippo,
naja wie du ja auch schon andeutest. das geht schon wenn man z.B. n bissl mit hilfsvariablen rumtrickst.
ja und nein. Ich wollte nur zum Ausdruck bringen, dass die Logik umgekehrt wird. Statt dass man selber bestimmt, wann man zeichnet, bestimmt Windows, wann man zeichnet. Wenn man im EventHandler des ButtonClick zeichnen würde (was erstmal geht), dann ist das Gezeichnete wieder weg, wenn man das Fenster minimiert und und wiederherstellt. Man sollte also Zeichenmethoden nur in OnPaint benutzen!
herbivore
Es gibt unter CodeProject auch ein Control, welches ein reine Zeichenfläche darstellt und entsprechende Operationen zu malen anbieten.
Der Vorteil ist, dass man nicht mit den Graphics-Objekten rummachen muss und auch vor OnPaint verschont bleibt- Solange man also wirklick nur in einem freien Fensterbereich malen will, würde ich das als Easy-to-use-Methode empfehlen.
Hallo svenson,
was kann das Teil mehr oder besser als eine PictureBox?
herbivore
Das "malen" auf einer picturebox funktioniert ja genauso wie auf einem control..
Der einzige Vorteil wenn ich eine Klasse von Control ableite, ist dass ich das Zeichnen nicht im picturebox.Paint Event machen muss, sondern direkt die Methode Control.OnPaint überschreiben kann und das dort machen kann.
Aber funktionieren tut das genau gleich, jeweils mit PaintEventArgs e, die ein Graphics object zur Verfügung stellen!
Nur ist das auf einem control halt schöner gekapselt.
lg,
kakaomilch.
Hallo kakaomilch,
natürlich kann man bei einer PictureBox im OnPaint malen, aber das ist m.E. nicht der Sinn der Sache. Den Nutzen entfaltet die PictureBox m.E. erst, wenn man in Graphics.FromImage (picbox.Image) zeichnet.
herbivore
Sorry hab die Nachricht nicht genau genug gelesen 😦
Dass es hier um ein SPEZIELLES Control geht...
Jetzt sag ich nix mehr 🙂
lg,
kakaomilch.
Original von herbivore
was kann das Teil mehr oder besser als eine PictureBox?
Im Prinzip gar nix, mehr als GDI gibts ja nicht. Aber es ist "leichter" zu benutzen, weil man halt Methode hat wie DrawLine(), die man nicht in einer OnPaint-Routine sammeln muss, sondern man hat einen objektorientierten Ansatz:
drawPane.DrawCircle();
...
drawPane.DrawRect();
oder so.
Auf gut deutsch: Man kann malen, ohne zu wissen, dass es GDI überhaupt gibt. Halt easy-to-use.
Dahinter steckt sogar ein bißchen an Aufwand, denn jede Zeichenoperation darf ja nicht direkt gezeichnet werden, sondern muss erst in eine temporäre Bitmap um von dort in OnPaint() auf den Schirm geblittet zu werden. Ansonsten würde jedes Verschieben des Fensters ja das Bild vernichten.
Hallo svenson,
ja, aber (fast) genau so macht die PictureBox das auch.
herbivore
Keine Frage, der PictureBox fehlen halt nur die DrawXYZ()-Methoden... 😉
Hallo svenson,
ok, danke. Dann hat es also keine echten Vorteile, denn bei der PictureBox kommt man ja über Graphics.FromImage (picbox.Image) an die Draw-Methoden.
herbivore
Original von herbivore
Hallo c#_gast,ohne Flippos Beispiele traurig machen zu wollen, solange musst du gar nicht warten. In der SDK-Doku findest du ebenfalls Codebeispiele, z.B. bei der Control.OnPaint-Methode.
Hallo Flippo,
naja wie du ja auch schon andeutest. das geht schon wenn man z.B. n bissl mit hilfsvariablen rumtrickst.
ja und nein. Ich wollte nur zum Ausdruck bringen, dass die Logik umgekehrt wird. Statt dass man selber bestimmt, wann man zeichnet, bestimmt Windows, wann man zeichnet. Wenn man im EventHandler des ButtonClick zeichnen würde (was erstmal geht), dann ist das Gezeichnete wieder weg, wenn man das Fenster minimiert und und wiederherstellt. Man sollte also Zeichenmethoden nur in OnPaint benutzen!herbivore
- richtig sdk-doku findet man auch sehr gute einfache beispiele.
- richtig ja - auserhalb von onPaint machts nicht viel sinn.
_Original von c#gast
Original von Flippo
bin grad noch auf arbeit.... wenn ich daheim bin stell ich dir mal n kleines beispiel rein.das wär spitze!! danke!!
sorry sorry sorry - ich bin gestern heim gekommen und mein internetanschluss hat nicht funktioniert.
wie gesagt wend dich erst mal an die sdk-doku - und sonst schau ich mal dass ich heut im laufe des tages mal dazu komm.
hallo.
also ich hab das jetz einiger maßen hinbekommen mit dem zeichnen. hab dazu ne picturebox und zeichne im paint-event.
jetz noch ne frage: ist es möglich z.B. die gezeichnete Linie im nachhinein zuverschieben? also wie ein einzelnenes Objekt. ich glaub nicht, oder?!?
wie könnte ich das sonst noch realisieren, dass man z.b. mit der maus ähnlich wie in mspaint eine linie ziehen kann? diese würde ich anschließend gerne noch verschieben können und in der größe ändern können!!
is das irgendwie möglich??
Klar Du musst Dir die Linie als Objekt merken.
Ich habe mal was ähnliches gemacht. War nur im größeren Stil, eine ältere Version habe ich hier angefügt.
Es ist schon drin, einzelne Objekte auswählen, auswählen per Foucs-Rechteck (hier sind aber noch Fehler zu korrigieren) und mit der Maus anfassen und verschieben.
Bisher sind aber alle Objekte von mir rechteckig. Du kannst Dir aber beliebige Formen definieren.
Alle Formen die sich darauf befinden, können also immer noch im nachhinein mit der Maus verschoben werden.
Folgender Aufbau liegt dem zugrunde:
Es gibt eine GraphView und ein GraphDoc. Im GraphDoc sind alle Objekte vorhanden, das GraphView-Objekt, zeigt alle Objekte die auf das GraphDoc hinzugefügt werden automatisch an. So hat man auch später noch auf dem GraphView die Möglichkeit die Ansichten zu skalieren, Lineale einzublenden usw.
Die Objekt die du hinzufügst sind GraphDocs.
Anhand der Button-Click-Events kannst Du gucken, wie das ganze funktioniert.
Aber wie gesagt ist eine sehr alte Version. Die sollte Dir aber mehr als reichen.
Auch doublebuffering kann eingeschalten werden.
Viel Spaß beim Probieren.
Seit der Erkenntnis, dass der Mensch eine Nachricht ist, erweist sich seine körperliche Existenzform als überflüssig.
HILFE!!!!
Ich komm nicht weiter!
@dr4g0n76: Danke nochmal für dein Beispiel, so ungefähr stell ich mir des auch vor mit den Rechtecken verschieben und so!!
Aber ich steig da nicht durch. Ich bin noch zu neu in C# um dein Programm zu vertstehen!
Kannst du mir, oder jemand anderes, erklären wie man das grundsätzlich macht, dass man ein Rechteck auf einer Fläche (z.B. einem Panel) zeichnet und dieses dann aber als einzelnes Objekt hat und verschieben und vergrößern kann!?!
wäre wirklich sehr wichtig! Hab mich sehr mit dem Grafikeditorbeispiel beschäftigt, aber ich verstehs einfach nicht.
wär spitze wenn mir jemand was dazu sagen könnte!!
vielen dank!!
Hallo,
ich dachte mir, ich schreib das mal in diesen Thread hinein anstatt extra einen neuen zu eröffnen.
Ich bin noch ziemlicher Anfänger in C# und versuch mich auch gerade am zeichnen.
Ich habe einige Objekte namens "Feld", die in einem Array "spielfeld" liegen. Diese Objekte sollen sich alle während des Programmablaufs hin und wieder selber zeichnen (also die besitzen "Koordinaten", anhand derer sollen die sich jedesmal neu auf dem spielfeld zeichnen). Ich habe mal einige Auszüge hier hineingestellt, der ganze Quelltext wäre etwas zu lang.
// Auszüge
public class Feld
{
int x;
int y;
Besetzung farbe;
// Konstruktor
public Feld(int x, int y, Besetzung farbe)
{
this.x = x;
this.y = y;
this.farbe = farbe;
}
...
//Main Methode
Fenster startFenster = new Fenster();
Application.Run(startFenster);
...
spielfeld[j,i].Zeichnen();
...
Das hier ist dann die (vorläufige) Zeichnen Methode des Feldes:
public void Zeichnen(PaintEventArgs pe)
{
Pen rotstift = new Pen(Color.Red);
pe.Graphics.DrawEllipse(rotstift,x*10,y*10,10,10);
}
Ich hoffe, ihr versteht in etwa mein Problem.
Ich glaube, ich habe da entweder a) einen schweren Fehler oder b) einen klitzekleinen übersehen 🙂
Hallo MjReaper,
was ist denn das Problem/der Fehler? Hast du nicht beschrieben und ich habs übersehen.
herbivore
Achso, ja, stimmt, hätte ich deutlicher hervorheben sollen:
Fehler habe ich eigentlich (noch) keinen, es liegt mehr daran, dass ich nicht weiß, wie die Methode genau funktionieren kann.
Also ich habe ja das Array mit den einzelnen Objekten des Typs "Feld". Ich möchte jetzt ein Objekt über spielfeld[j,i].Zeichnen() zeichnen lassen.
Da ich mich allerdings nicht genauer mit dem Zeichnen an sich aus kenne, habe ich erstmal gedacht, ich erstelle in der Klasse Feld eine Methode die sich da nennt Zeichnen().
Da jedes Objekt spezifische Koordinaten (x und y) besitzt kann ich anhand derer ja spezifische ellipsen zeichnen lassen.
Jetzt kommt der Punkt, an dem ich etwas hänge:
Ich habe ja ein Fenster mit Namen "startFenster" erstellt. Auf diesem Fenster soll jedesmal, wenn aus der Main-Methode der Aufruf Zeichnen() erfolgt, gezeichnet werden. Wie übermittel ich das? Und wie ist das mit den "PaintEventArgs" zu verstehen? Ich habe ja (ist z.T. aus einem Buch) in der Zeichnen Methode als Parameter pe mit drin, ansonsten kann ich ja nicht zeichnen (pe.graphics.drawellipse...). Aber wie übergebe ich diesen Parameter? Bzw. was muss da stehen?
Ich hoffe, man versteht mich jetzt 🙂
Hallo MjReaper,
Auf diesem Fenster soll jedesmal, wenn aus der Main-Methode der Aufruf Zeichnen() erfolgt, gezeichnet werden.
in Main sollte nur das Erzeugen den Forms und Application.Run stehen. Jedenfalls keine eigene Logik, die die Anwendung steuert. In Konsolen-Anwendungen ist die Steuerungslogik im Main, in Windows-Forms-Anwendungen nicht.
Du musst dich davon verabschieden, dass du das Zeichnen anstößt. Windows sagt, wann du zeichnen musst. Alles läuft über OnPaint/Paint. An den Codestellen, an denen du etwas Zeichnen wollen würdest, mache folgendes: Ändere das spielfeld-Array so ab, wie du es haben willst, und rufe dann Invalidate () oder Refresh () für die Zeichenfläche auf. Dann schickt Windows dir die Nachricht, dass neu gezeichnet werden soll, sprich Windows ruft OnPaint auf und da oder im Paint-EventHandler zeichnest du dann das spielfeld-Array in dem Zustand, wie es eben gerade ist.
Aber wie übergebe ich diesen Parameter? Bzw. was muss da stehen?
In OnPaint bzw. deinem PaintEventHandler bekommst du automatisch die PaintEventArgs übergeben. Das Graphics-Objekt musst du dann an deine Zeichnen-Methode übergeben. Also sowas in der Art wie:
foreach (Feld feld in spielfeld) {
feld.Zeichnen (pe.Graphics)
}
herbivore
Danke, das hab ich gut verstanden und auch umgesetzt, allerdings will der das hier noch nicht kompilieren, da sagt er, dass Klammern fehlen u.ä., was kann denn hier noch falsch sein?
// Hier treten die Fehler auf
protected override void OnPaint(PaintEventArgs pe)
{
foreach (Feld meinFeld in spielfeld) do
{
meinFeld.Zeichnen(pe);
}
// funktioniert
startFenster.refresh;
// der Vollständigkeitshalber:
public void Zeichnen(PaintEventArgs pe)
{
Pen rotstift = new Pen(Color.Red);
pe.Graphics.DrawEllipse(rotstift,x*10,y*10,10,10);
}
kommt foreach evtl. nicht mit mehrdimensionalen arrays aus?
Hallo MjReaper,
lass das 'do' weg.
herbivore
Danke... äh... ich will ja nicht nerven... aber jetzt sagt der mir noch "The name 'spielfeld' doesn't exist in the current context". D.h. ich muss das noch übergeben... also einfach in startfenster.refresh() als parameter in die klammern?
Hallo MjReaper,
nein, Spielfeld sollte eine Instanzvariable der Klasse sein, die OnPaint überschreibt.
herbivore
ich muss doch noch einmal stören...
ich hab das ganze jetzt mal ein wenig umgewandelt, feld und spieler sind jetzt jeweils keine klassen mehr sondern strukturen (reicht für meine zwecke genausogut). Dementsprechend ist jetzt spielfeld ein array aus feld.
Die Main()-Methode hab ich durch
public class Start
{
public static void Main()
{
// Spiel erzeugen
Spiel meinSpiel = new Spiel();
}
}
verändert. nicht mehr, nicht weniger.
die klasse spiel beinhaltet jetzt alles weitere.
dort findet sich auch:
startFenster.Refresh()
...
public void Zeichnen(PaintEventArgs pe)
{
Pen rotstift = new Pen(Color.Red);
foreach (Feld einFeld in spielfeld)
pe.Graphics.DrawEllipse(rotstift,einFeld.x*10,einFeld.y*10,10,10);
}
Ferner sieht mein Fenster nun so aus (wird in der Klasse Spiel erzeugt):
public class Fenster : Form
{
public Fenster()
{
this.Text = "Zeichnen";
this.Size = new Size(100, 100);
this.BackColor = Color.White;
}
protected override void OnPaint(PaintEventArgs pe)
{
meinSpiel.Zeichnen(pe);
}
}
Das Problem: er meldet mir, das spielfeld in Zeichnen() und meinspiel in onpaint() "doesn't exist in the context"... irgendwo hab ich da anscheinend noch einen großen Hänger... Bitte entschuldigt wenn ich noch keine großen Kenntnisse aufweisen kann... Ich hab schon soviel ausprobiert, aber irgendwie komm ich da nicht weiter.
Hallo MjReaper,
also es geht noch ein bisschen durcheinander. 🙂
Ich denke für den Anfang wäre es günstig auf eine separate Klasse Spiel zu verzichten und Spiel und Fenster zu SpielFenster zu vereinigen. SpielFenster muss dann von Form erben.
Dann erzeugst du in Main ein SpielFenster-Objekt und übergibst dass an Application.Run, also
Application.Run (new SpielFenster);
Statt meinSpiel.Zeichnen(pe); schreibst du dann einfach this.Zeichnen(pe); oder noch einfacher Zeichnen(pe);
Und spielfeld ist ja dann auch in SpielFenster deklariert und dadurch kannst du in Zeichnen auch darauf zugreifen.
herbivore
Danke erstmal für deine vielen Bemühungen Herbivore!!
Ich hab es jetzt fast geschafft... nur noch eine Fehlermeldung:
// Hier definiere ich spielfeld in der Klasse SpielFenster
Feld[,] spielfeld = new Feld[7,6];
Jetzt sagt er mir allerdings, obwohl die Methode Zeichnen() in der Klasse SpielFenster liegt, dass er spielfeld nicht finden kann, also hier:
public void Zeichnen(PaintEventArgs pe)
{
Pen rotstift = new Pen(Color.Red);
foreach (Feld einFeld in spielfeld)
pe.Graphics.DrawEllipse(rotstift,einFeld.x*10,einFeld.y*10,10,10);
}
Kann das daran liegen, dass spielfeld nicht "public" ist? aber wenn ich public davor schreibe, dann erwartet der noch viel mehr, also erwartet fast eine methode ( z.b. "{" o.ä.).
Hallo MjReaper,
nein, public sollten Variablen nie sein. Aber private solltest du explizit davor schreiben. Ich vermute mal, dass die Zeile Feld[,] spielfeld = new Feld[7,6]; in einer Methode steht. Sie sollte jedoch außerhalb einer Methode, aber innerhalb der Klasse SpielFenster stehen.
Wenn das dein Problem war, fehlen dir noch ein paar Grundlagen, die du dir mit Hilfe eines Buchs aneignen solltest.
herbivore
Danke, du hast mir sehr geholfen. Jetzt funktioniert es.
Ich werde deinen Ratschlag zu Herzen nehmen und nochmal die Bücher durchstöbern.
Gruß
MjReaper
Original von herbivore
Hallo c#_gast,ohne Flippos Beispiele traurig machen zu wollen, solange musst du gar nicht warten. In der SDK-Doku findest du ebenfalls Codebeispiele, z.B. bei der Control.OnPaint-Methode.
.........
Sry, aber meinst du die SDK-Doku von Microsoft, oder eine andere?? Wenn lezteres der Fall ist, dann poste doch bitte den Link. Ich find das beim besten willen nicht. 😉
Gruß... 8)
Hallo Bubgar,
Als SDK-Doku wird hier normalerweise die Dokumentation aus dem .NET Framework SDK bezeichnet. Du findest sie bei installierstem SDK unter "Start" -> "Programme" -> ".NET Framework SDK <version>" -> "Documetation". Alles was in der SDK-Doku steht, steht aber auch in der MSDN-Library. Die gibt es als Offline-Version (zusammen mit VS oder also Online-Version unter http://msdn2.microsoft.com/de-de/default.aspx bzw. http://msdn2.microsoft.com/en-us/default.aspx
Gruß,
Thomas
A wise man can learn more from a foolish question than a fool can learn from a wise answer!
Bruce Lee
Populanten von Domizilen mit fragiler, transparenter Außenstruktur sollten sich von der Translation von gegen Deformierung resistenter Materie distanzieren!
Wer im Glashaus sitzt, sollte nicht mit Steinen werfen.
Besten dank, dann kann es ja los gehen mit dem Programmmieren. 😉
gurß..