Farbeinstellung soll in der Vorschau erhalten bleiben

[lempy]

Hallo Leute

ich bin dabei ein Spielfeld zu erstellen, dem man ein neues farbliches Outfit geben kann. Das passiert in zwei Formen.

Form1 = Hauptform. Form2 = Dialogform.

Wie ihr seht funktioniert die Übergabe der neuen Farbe auf die Hauptform einwandfrei.

Jetzt stehe ich vor dem Problem, dass die Vorschau auf der Form2 die neue Farbeinstellung beibehalten soll. Also die selben Farben aufweisen soll, wie das Spielfeld auf der Form1. Kann mir irgendwer dazu helfen?

Das ganze ist in C++/CLR - Forms.

Wenn Ihr den Code sehen möchtet meldet Euch.

Lieben Dank

lempy

[Klotzkopp]

Wie ihr seht funktioniert die Übergabe der neuen Farbe auf die Hauptform einwandfrei.

Woran soll man das sehen? Für mich sieht es so aus, als wären die Farben unterschiedlich.

Dass die Entwicklungsumgebung unnötigerweise mit auf dem Screenshot ist, macht's nicht übersichtlicher.

Allgemein sollte sich Form2 die Farbdaten aus derselben Quelle holen wie Form1, dann kann das gar nicht auseinanderlaufen.

[lempy]

Hey Klotzkopp

Im Hintergrund ist das Spielfeld auf der Form1 schon im neuen Farbdress. Beim Wiederaufruf des Dialogfeldes ist aber die neu Farbeinstellung nicht in der Vorschau übernommen worden, sondern wieder in die Ausgansfarben vor zu finden.

Allgemein sollte sich Form2 die Farbdaten aus derselben Quelle holen wie Form1, dann kann das gar nicht auseinanderlaufen.

Bearbeitet 5. Februar 2014 von lempy
Erster Absatz war weg

[Klotzkopp]

Im Hintergrund ist das Spielfeld auf der Form1 schon im neuen Farbdress. Beim Wiederaufruf des Dialogfeldes ist aber die neu Farbeinstellung nicht in der Vorschau übernommen worden, sondern wieder in die Ausgansfarben vor zu finden.

Dann musst du eben beim Öffnen des Dialogs die neue Farbe aus den gespeicherten Einstellungen auslesen.

Du speicherst die ausgewählte Farbe doch hoffentlich in einer Einstellung?

Du solltest übrigens nicht ohne sehr guten Grund C++/CLI für GUI-Programmierung benutzen. Eigentlich ist das eine Interop-Sprache, um zwischen Native und .NET vermitteln zu können.

Wenn du GUI machen willst, nimm C#. Wenn du C++ machen willst, mach kein Windows Forms. C++/CLI ist nämlich kein C++.

[lempy]

Lieber Klotzkopp

Meine Situation ist, das ich einen Fernkurs gemacht habe (noch nicht Fertig, aber Laufzeit überschritten und somit ruhend in der Fernschule). Grund Fernkurs begonnen und dann eine Umschulung von Arge zugewiesen bekommen an einen eher "Unkompetenten"

Bildungsträger. Bei meinem Start waren die Kollegen schon drei Monate dabei und was noch schlimmer war einige Lernfelder musste man im Selbststudium lernen. Jetzt möchte ich die restlichen drei Hefte noch durcharbeiten und dann nochmal dort anknüpfen wo ich aufgehört habe um die Umschulung zu mit gutem Abschluss zu schaffen. Weil das noch mal Talers kostet möchte

erst die restlichen Hefte durcharbeiten damit der Wiedereinstieg nicht ganz so teuer wird.

Vielleicht hilft es Dir wenn ich die Codefragment aus Form1 und die Form2 hier einfüge?

Lieben Gruß

lempy

[Klotzkopp]

Wenn du bezüglich der Wahl der Programmiersprache durch den Bildungsträger festgelegt bist, dann wäre das so ein "sehr guter Grund"

Die Frage ist jetzt, welchen Anspruch du an die Lösung stellst. Willst du, dass es nur irgendwie funktioniert, oder willst du lernen, wie man das ordentlich macht?

[lempy]

Hey

Wenn ich mich mit etwas beschäftige, dann soll es ordentlich werden. Schließlich möchte ich dass, was ich tue auch verstehen. Sonst macht das ganze keinen Sinn. Deswegen war mir Umschulung ja dann auch wichtiger als der Fernkurs, der dann zurückstecken musste.

Also ich werde Dir mal meine Codefragmente rüberreichen:

Aus der Form1 der Aufruf des MenüStrip, der dann die Form2 aufruft.

	private: System::Void farbeToolStripMenuItem_Click(System::Object^  sender, System::EventArgs^  e) 

			{

				Farbdialog ^neueFarbe = gcnew Farbdialog(this->HintergrundFarbe,this->RahmenFarbe);


				//Color Hintergrundzurück()

				//{

					// return HintergrundFarbe;

				//}


				//Color Rahmenzurück()

				//{

					// return RahmenFarbe;

				//}


				/*neueFarbe->liefereHintergrund(HintergrundFarbe);*/

				/*neueFarbe->Show();*/


				 if(neueFarbe->ShowDialog() == Windows::Forms::DialogResult::OK)

				 {

					spielfeld->BackColor = neueFarbe->setzeHintergrund();

					RahmenFarbe = neueFarbe->setzeRahmen();

					/*neueFarbe->Show();*/


					neueFarbe->Close();



			 }

		 }

Hier die gesamte Form2

#pragma once


using namespace System;

using namespace System::ComponentModel;

using namespace System::Collections;

using namespace System::Windows::Forms;

using namespace System::Data;

using namespace System::Drawing;



namespace PongTest {


	/// <summary>

	/// Zusammenfassung für Farbdialog

	///

	/// Warnung: Wenn Sie den Namen dieser Klasse ändern, müssen Sie auch

	///          die Ressourcendateiname-Eigenschaft für das Tool zur Kompilierung verwalteter Ressourcen ändern,

	///          das allen RESX-Dateien zugewiesen ist, von denen diese Klasse abhängt.

	///          Anderenfalls können die Designer nicht korrekt mit den lokalisierten Ressourcen

	///          arbeiten, die diesem Formular zugewiesen sind.

	/// </summary>

	public ref class Farbdialog : public System::Windows::Forms::Form

	{

	private:


		// eigene Attributte


		// für die Zeichenflaeche

		Graphics ^malflaeche;


		// für das Vorschau

		Rectangle VorschauGroesse;

		Int32 VorschauMaxX, VorschauMaxY, VorschauMinX, VorschauMinY;

		Int32 LinienBreite;


		// zum Zeichnen

		SolidBrush ^pinsel1;


		Color HintergrundFarbe, RahmenFarbe;


	public:

		Farbdialog(Color HintergrundFarbe, Color RahmenFarbe)

		{

			InitializeComponent();

			//

			//TODO: Konstruktorcode hier hinzufügen.

			//


			LinienBreite = 6;

			pinsel1 = gcnew SolidBrush(Color::White);

			malflaeche = panelVorschau->CreateGraphics();

			panelVorschau->BackColor = Color::Black;


			setzeVorschau();

			maleVorschau();


			/*liefereHintergrund();*/


			/*setzeHintergrund();*/

		}


	protected:

		/// <summary>

		/// Verwendete Ressourcen bereinigen.

		/// </summary>

		~Farbdialog()

		{

			if (components)

			{

				delete components;

			}

		}


	public:


		Void setzeVorschau()

		{

			VorschauGroesse = panelVorschau->ClientRectangle;


			VorschauMaxX = VorschauGroesse.Right - LinienBreite;

			VorschauMinX = VorschauGroesse.Left + LinienBreite + 1;

			VorschauMaxY = VorschauGroesse.Bottom - LinienBreite;

			VorschauMinY = VorschauGroesse.Top + LinienBreite;

		}


		Void maleVorschau()

		{

			malflaeche->FillRectangle(pinsel1, 0, 0, VorschauMaxX, LinienBreite);

			malflaeche->FillRectangle(pinsel1, VorschauMaxX, 0, LinienBreite, VorschauMaxY + LinienBreite);

			malflaeche->FillRectangle(pinsel1, 0, VorschauMaxY, VorschauMaxX, LinienBreite);

			malflaeche->FillRectangle(pinsel1, 0,0, LinienBreite, VorschauMaxX);

		}


		Color setzeHintergrund()

		{

			return HintergrundFarbe;

		}


		Color setzeRahmen()

		{

			return RahmenFarbe;

		}


		Void liefereHintergrund(Color hFarbe)

		{

			hFarbe = HintergrundFarbe;


			panelVorschau->Refresh();

		}


	private: System::Windows::Forms::Label^  labelRahmen;

	protected: 

	private: System::Windows::Forms::Button^  buttonRahmen;

	private: System::Windows::Forms::Label^  labelHintergrund;

	private: System::Windows::Forms::Button^  buttonHintergrund;

	private: System::Windows::Forms::Panel^  panelVorschau;

	private: System::Windows::Forms::Button^  buttonUebernehmen;

	private: System::Windows::Forms::Button^  buttonAbbrechen;

	private: System::Windows::Forms::ColorDialog^  Farbauswahl;





	private:

		/// <summary>

		/// Erforderliche Designervariable.

		/// </summary>

		System::ComponentModel::Container ^components;


#pragma region Windows Form Designer generated code

		/// <summary>

		/// Erforderliche Methode für die Designerunterstützung.

		/// Der Inhalt der Methode darf nicht mit dem Code-Editor geändert werden.

		/// </summary>

		void InitializeComponent(void)

		{

			this->labelRahmen = (gcnew System::Windows::Forms::Label());

			this->buttonRahmen = (gcnew System::Windows::Forms::Button());

			this->labelHintergrund = (gcnew System::Windows::Forms::Label());

			this->buttonHintergrund = (gcnew System::Windows::Forms::Button());

			this->panelVorschau = (gcnew System::Windows::Forms::Panel());

			this->buttonUebernehmen = (gcnew System::Windows::Forms::Button());

			this->buttonAbbrechen = (gcnew System::Windows::Forms::Button());

			this->Farbauswahl = (gcnew System::Windows::Forms::ColorDialog());

			this->SuspendLayout();

			// 

			// labelRahmen

			// 

			this->labelRahmen->AutoSize = true;

			this->labelRahmen->Location = System::Drawing::Point(30, 20);

			this->labelRahmen->Name = L"labelRahmen";

			this->labelRahmen->Size = System::Drawing::Size(47, 13);

			this->labelRahmen->TabIndex = 0;

			this->labelRahmen->Text = L"Rahmen";

			// 

			// buttonRahmen

			// 

			this->buttonRahmen->Location = System::Drawing::Point(106, 20);

			this->buttonRahmen->Name = L"buttonRahmen";

			this->buttonRahmen->Size = System::Drawing::Size(30, 30);

			this->buttonRahmen->TabIndex = 1;

			this->buttonRahmen->Text = L". . .";

			this->buttonRahmen->UseVisualStyleBackColor = true;

			this->buttonRahmen->Click += gcnew System::EventHandler(this, &Farbdialog::buttonRahmen_Click);

			// 

			// labelHintergrund

			// 

			this->labelHintergrund->AutoSize = true;

			this->labelHintergrund->Location = System::Drawing::Point(30, 77);

			this->labelHintergrund->Name = L"labelHintergrund";

			this->labelHintergrund->Size = System::Drawing::Size(62, 13);

			this->labelHintergrund->TabIndex = 2;

			this->labelHintergrund->Text = L"Hintergrund";

			// 

			// buttonHintergrund

			// 

			this->buttonHintergrund->Location = System::Drawing::Point(106, 77);

			this->buttonHintergrund->Name = L"buttonHintergrund";

			this->buttonHintergrund->Size = System::Drawing::Size(30, 30);

			this->buttonHintergrund->TabIndex = 3;

			this->buttonHintergrund->Text = L". . .";

			this->buttonHintergrund->UseVisualStyleBackColor = true;

			this->buttonHintergrund->Click += gcnew System::EventHandler(this, &Farbdialog::buttonHintergrund_Click);

			// 

			// panelVorschau

			// 

			this->panelVorschau->BorderStyle = System::Windows::Forms::BorderStyle::FixedSingle;

			this->panelVorschau->Location = System::Drawing::Point(12, 125);

			this->panelVorschau->Name = L"panelVorschau";

			this->panelVorschau->Size = System::Drawing::Size(357, 140);

			this->panelVorschau->TabIndex = 4;

			this->panelVorschau->Paint += gcnew System::Windows::Forms::PaintEventHandler(this, &Farbdialog::panelVorschau_Paint);

			// 

			// buttonUebernehmen

			// 

			this->buttonUebernehmen->DialogResult = System::Windows::Forms::DialogResult::OK;

			this->buttonUebernehmen->Location = System::Drawing::Point(39, 302);

			this->buttonUebernehmen->Name = L"buttonUebernehmen";

			this->buttonUebernehmen->Size = System::Drawing::Size(75, 23);

			this->buttonUebernehmen->TabIndex = 5;

			this->buttonUebernehmen->Text = L"Übernehmen";

			this->buttonUebernehmen->UseVisualStyleBackColor = true;

			// 

			// buttonAbbrechen

			// 

			this->buttonAbbrechen->Location = System::Drawing::Point(253, 304);

			this->buttonAbbrechen->Name = L"buttonAbbrechen";

			this->buttonAbbrechen->Size = System::Drawing::Size(75, 23);

			this->buttonAbbrechen->TabIndex = 6;

			this->buttonAbbrechen->Text = L"Abbrechen";

			this->buttonAbbrechen->UseVisualStyleBackColor = true;

			this->buttonAbbrechen->Click += gcnew System::EventHandler(this, &Farbdialog::buttonAbbrechen_Click);

			// 

			// Farbdialog

			// 

			this->AutoScaleDimensions = System::Drawing::SizeF(6, 13);

			this->AutoScaleMode = System::Windows::Forms::AutoScaleMode::Font;

			this->ClientSize = System::Drawing::Size(394, 334);

			this->ControlBox = false;

			this->Controls->Add(this->buttonAbbrechen);

			this->Controls->Add(this->buttonUebernehmen);

			this->Controls->Add(this->panelVorschau);

			this->Controls->Add(this->buttonHintergrund);

			this->Controls->Add(this->labelHintergrund);

			this->Controls->Add(this->buttonRahmen);

			this->Controls->Add(this->labelRahmen);

			this->Name = L"Farbdialog";

			this->RightToLeft = System::Windows::Forms::RightToLeft::Yes;

			this->ShowIcon = false;

			this->StartPosition = System::Windows::Forms::FormStartPosition::CenterParent;

			this->Text = L"Farbdialog";

			this->ResumeLayout(false);

			this->PerformLayout();


		}

#pragma endregion

	private: System::Void buttonAbbrechen_Click(System::Object^  sender, System::EventArgs^  e) 

			 {

				 Close();

			 }


private: System::Void panelVorschau_Paint(System::Object^  sender, System::Windows::Forms::PaintEventArgs^  e) 

		 {

			 maleVorschau();


		 }


private: System::Void buttonHintergrund_Click(System::Object^  sender, System::EventArgs^  e) 

		 {

			ColorDialog ^cd = gcnew ColorDialog();


			 if(cd->ShowDialog() == Windows::Forms::DialogResult::OK)

			 {

				 HintergrundFarbe = cd->Color;

				 buttonHintergrund->BackColor = cd->Color;


				 panelVorschau->BackColor = HintergrundFarbe;


			 }

		 }


private: System::Void buttonRahmen_Click(System::Object^  sender, System::EventArgs^  e) 

		 {

			 ColorDialog ^cc = gcnew ColorDialog();


			 if(cc->ShowDialog() == Windows::Forms::DialogResult::OK)

			 {

				 RahmenFarbe = cc->Color;

				 buttonRahmen->BackColor = cc->Color;


				 pinsel1->Color = RahmenFarbe;

				 maleVorschau();

			 }

		 }

};

}

Lieben Dank

lempy

[Klotzkopp]

Der Code hat mehrere Probleme.

Deine Klasse Farbdialog hat zwei Color-Member:

Color HintergrundFarbe, RahmenFarbe;

Der Konstruktor hat zwei Parameter:

Farbdialog(Color HintergrundFarbe, Color RahmenFarbe)

{

...[/code]




Möglicherweise erwartest du, dass die Farben, die du an den Konstruktor übergibst, in deinen Membern landen. Das passiert hier aber nicht.



Die Parameter haben zwar dieselben Namen wie die Member, aber dadurch kommt keine Wertübergabe zustande. Die Parameter [b]verdecken[/b] die gleichnamigen Member im Konstruktor. Wenn du hier die Member mit Inhalt füllen willst, musst du das im Konstruktor-Rumpf ausdrücklich hinschreiben, z.B. so:

[code]this->HintergrundFarbe = HintergrundFarbe;

Das this-> dient hier dazu, dass der Member als Ziel der Zuweisung der Member verwendet wird, nicht der gleichnamige Parameter. Wenn die Namen nicht gleich sind, kannst du das weglassen.

Ein weiteres Problem:

Die Namen deiner setze- und liefere-Methoden sind verdreht. Setter sind die Methoden, die die Member verändern. Getter sind die, die die Werte zurückgeben. Das ist ein reines Problem der Namensgebung, aber es ist sehr verwirrend.

[lempy]

Hallo

Wenn ich das richtig verstanden habe, dann ist die "Methode" liefereHintergrund (Getter) der Pad, der mit return die Farbe zurück gibt und die "setzeRahmen"-Methode (Setter) der, in dem ich der "Variable" die Farbe zu weise?

In einer schon etwas fortgeschrittener Version dieses Spiels hatte ich das Problem mit Radiobuttons, mit denen ich die Spielfeldgröße ändern kann. (neuem Betriebssystem wegen neuem Rechner(Windows8) funktioniert der Programmteil das nicht mehr so wie auf Windows7) Hier sollte die neue Auswahl der Größe beim Wiederaufruf des Dialogfeldes ebenfalls nicht verloren gehen und ausgewählt bleiben. Wie gesagt auf Windows7 lief es so. Vielleicht habe ich den Fehler begangen es nur auf den neuen Rechner zu kopieren. Habe ich noch nicht weiter ausprobiert, weil ich zur Not den alten Rechner wieder her holen kann.

Andererseits stelle ich mir die Frage, ob ich eventuell noch eine dritte Form für dieses Problem erstelle? Habe mal ein Probeprogramm in C++/CLR Konsole erstellt mit zwei "Klassen". Aber da wird das ganze Programm ja von main aus gesteuert oder eher ausgeführt. So weit ich bisher mitbekommen habe soll dass in Forms ja über Formen und Methoden laufen.

Hier mal das kleine Testprogramm in C++/CLR Konsole:

// TomTest1.cpp: Hauptprojektdatei.


#include "stdafx.h"


using namespace System;


ref class Aendern 

{

	Int32 MeinWert;


public:


	Void setzeWert()

	{

		/*Console::WriteLine();*/

		Console::WriteLine("{0}",MeinWert);

		/*return MeinWert;*/

	}


	Int32 leseWert()

	{

		return MeinWert;

	}


	Void FrageBenutzer()

	{

		/*MeinWert = 0;*/


		Console::Write("Bitte in Funktion \"FrageBenutzer\" der Klasse \"Ändern\" eine Zahl eingeben.\n");

		Console::WriteLine();

		/*MeinWert = Convert::ToInt32(Console::Read());*/

		MeinWert = Int32::Parse(Console::ReadLine());


		Console::WriteLine();


		/*leseWert();


		Console::WriteLine();*/

	}

};


ref class Klasse1

{

public:


	Int32 MeinWert;


public:


	Void aufruf()

	{

		Console::WriteLine();

		Console::WriteLine("Aus Klass \"Klasse1\"\n");

		/*Console::WriteLine();*/

		Aendern ^test1 = gcnew Aendern();

		Console::WriteLine("Neuen wert eingeben\n");

		MeinWert = test1->leseWert();

		/*Console::WriteLine();

		Console::WriteLine("Ausgabe dew neuen Wertes\n");*/

		test1->FrageBenutzer();

		Console::WriteLine("Ausgabe des neuen Weres\n");


		test1->setzeWert();

		Console::WriteLine();


	}


	/*Void ausgeben()

	{

		Aendern ^test1 = gcnew Aendern();

		test1->leseWert();

		Console::WriteLine();

	}*/


};


int main(array<System::String ^> ^args)

{

	/*Aendern ^test1 = gcnew Aendern();


	test1->FrageBenutzer();*/


	Console::WriteLine("In Funktion \"main\"");


	Console::WriteLine();


	Klasse1 ^test2 = gcnew Klasse1();


	test2->MeinWert = 12;


	/*Console::WriteLine();*/


	Console::WriteLine(test2->MeinWert);


	test2->aufruf();


	/*Console::WriteLine(test2->MeinWert);*/


	/*Console::ReadKey();*/


	/*Console::WriteLine();*/


	/*Aendern ^test3 = gcnew Aendern();

	test3->leseWert();*/


	Console::Read();


	return 0;

}


Vielleicht ist es Dir möglich mich an Hand dieses Testes in die richtige Richtung zu schupsen.


Lieben Dank


lempy

[Klotzkopp]

Wenn ich das richtig verstanden habe, dann ist die "Methode" liefereHintergrund (Getter) der Pad, der mit return die Farbe zurück gibt und die "setzeRahmen"-Methode (Setter) der, in dem ich der "Variable" die Farbe zu weise?

So ungefähr. Getter liefern Informationen über eine Eigenschaft eines Objekts, Setter ändern diese Eigenschaft. Was genau in solchen Methoden passiert, kommt auf den Einzelfall an. Oft steht eine Membervariable dahinter, das muss aber nicht so sein. Diese Art Methoden können auch Zusatzaufgaben beinhalten. Getter können Werte berechnen, statt sie direkt aus einem Member zu ziehen. Setter können eine Gültigkeitsprüfung des Parameters enthalten.

Was in deinem Programm völlig fehlt, ist ein Modell. In deinem Programm gibt es ja offenbar ein Spielfeld, aber eine Klasse Spielfeld gibt es nicht. Statt dessen speicherst du die Eigenschaften des Spielfelds in einzelnen Variablen und reichst diese hin und her. Diese Vorgehensweise ist bei größeren Programmen fehlerträchtig und erschwert die Wartung.

Andererseits stelle ich mir die Frage, ob ich eventuell noch eine dritte Form für dieses Problem erstelle?

Welches Problem meinst du?

Vielleicht ist es Dir möglich mich an Hand dieses Testes in die richtige Richtung zu schupsen.

Ich verstehe nicht ganz, was das Programm überhaupt tun oder zeigen soll. Auch in diesem Programm hast du mehrfache Variablen mit identischen Namen. Ich bin mir nicht ganz sicher, ob dir klar ist, dass diese Variablen nichts miteinander zu tun haben. Du tust dir selbst einen Gefallen, wenn du deinen Variablen ordentliche Namen gibst, die deren Aufgabe wiedergeben.

[lempy]

Hallo Klotzkopp

Das Programm soll ein kleines Pong-Spiel werden und das sind jetzt nur Codeschnipsel, weil im Vollständigem Programm zu viele Versuche Auskommentiert sind.

Ich bin mir nicht ganz sicher, ob dir klar ist, dass diese Variablen nichts miteinander zu tun haben.

Es ist mir durchaus schon klar das die Variablen nur in ihrem Bereich Gültigkeit haben also nur in Form1 bzw Form2 oder in ihren Funktionen/Methoden. Je nach dem.

Bilder sagen vielleicht mehr als Worte, da ich nicht so firm bin diese immer zu finden.

Wie Du siehst habe ich die neue Farbauswahl getroffen, die auch auf das Form1 übernommen wird. (Der erste Screenshor ein paar Antworten früher). Ich denke es ist auch genau in diesem Teil des Programm, wo ich eine Funktion/Methode "suche" die diese Farbänderung auf der Form2 festhält, beibehält, speichert wie auch immer. Auf jeden Fall soll diese neue Farbeinstellung in meiner Vorschau zu sehen sein, wenn ich wieder eine neue Einstellung vornehmen möchte.

Von der Form2 aus kann oder darf ich nicht auf die Form1 zugreifen. Oder doch? Ich denke eher nicht da Form1 ja die Hauptform ist. Also bliebe da nur eine Methode auf der Form1, weil diese ja auf Form2 zugreifen kann.

Da schwirrt mir eben so eine Idee im Kopf rum: Könnte es eventuell mit einem Vergleich der beiden (oder vielmehr 4) Variablen funktionieren? Hab im Moment nur noch keinen Schimmer wie der Code aussehen könnte und wo ich den schreiben muss.

Lieben Dank

lempy

[Klotzkopp]

Das Programm soll ein kleines Pong-Spiel werden und das sind jetzt nur Codeschnipsel, weil im Vollständigem Programm zu viele Versuche Auskommentiert sind.

Ich meinte das Konsolenprogramm.

Hab im Moment nur noch keinen Schimmer wie der Code aussehen könnte und wo ich den schreiben muss.

Die Farben kommen über den Konstruktor in Farbdialog an, du machst nur nichts damit.

Was du wo tun musst, habe ich dir bereits erklärt.

[lempy]

Hey Klotzkopp

Die Farben kommen über den Konstruktor in Farbdialog an, du machst nur nichts damit.

Ich glaube so langsam entwirrt sich mein Wollknäuel im Gedankengang. Muss nur noch den roten Faden finden.

Ich hoffe das zumindest mein jetziger Gedanke die richtige Richtung hat.

Gedanke: Eine Funktion/Methode auf der Form2, die die neue Farbeinstellung speichert und in Form1 vor dem Klicken auf dem Übernehmen aufgerufen wird? Oder doch eher die ganze Methode Vorschau in einer Variable speichert und dann wieder im Konstruktor oder in Paint der Form2 aufgerufen wird? :confused:

Werde jetzt erstmal meinen Termin wahrnehmen. Vielleicht hast Du bis dahin ja noch ein oder zwei Hinweise, die mir den Aha-Effekt bringen.

Lieben Dank

lempy

[Klotzkopp]

Gedanke: Eine Funktion/Methode auf der Form2, die die neue Farbeinstellung speichert und in Form1 vor dem Klicken auf dem Übernehmen aufgerufen wird?

Du brauchst nicht zu speichern. Es ist alles da.

Farbdialog(Color [COLOR="#B22222"]HintergrundFarbe[/COLOR], Color [COLOR="#B22222"]RahmenFarbe[/COLOR])

{

	InitializeComponent();

	//

	//TODO: Konstruktorcode hier hinzufügen.

	//

	LinienBreite = 6;

	pinsel1 = gcnew SolidBrush([COLOR="#0000FF"]Color::White[/COLOR]);

	malflaeche = panelVorschau->CreateGraphics();

	panelVorschau->BackColor = [COLOR="#0000FF"]Color::Black[/COLOR];[/code]


Die [color=#B22222]richtigen Farben[/color] kommen als Parameter im Farbdialog-Konstruktor an. Trotzdem benutzt du sie weder für die Initialisierung deiner Farb-Variablen noch deiner Steuerelemente. Erstere initialisierst du gar nicht, für letztere nimmst du [color=#0000FF]Schwarz und Weiß[/color]. Bring das doch einfach in Ordnung.

[lempy]

Hey Kloztkopp

In die Richtung sind meine Gedanken überhaupt nicht gewandert. Ich war voll auf Funktionen und Methoden fixiert. Nachdem ich die Farbe des Pinsels geändert habe, bleibt der Rahmen in der geänderten Farbe erhalten. Nur der Hintergrund meines Panals macht noch nicht mit.

Mein jetziger Gedanke geht in die Richtung die Farbe im Hintergrund des Panals mit Clear zu löschen und dann in der Set-Methode neu zu setzen.

Werde mir für Heute mal die Lektionen über Panal ansehen (Heft und zusätzliche Bücher unteranderem auch eines für C#) und das erstmal ausprobieren. Nebenbei werde ich das Ding mir der Rahmenfarbe erstmal sacken lassen und dann zumindest für diese Variablen zwei verschiedene ausdenken um den Lauf des Programm nachvollziehen zu können.

Vielleicht gibt es noch einen Tipp für den Hintergrund, aber erstmal möchte ich versuchen das an Hand meiner neuen Erkenntnisse selbe zu lösen.

Recht lieben, lieben Dank

lempy

[lempy]

Hallo Klotzkopp:D:D

Funktioniert wie es soll. Lieben, lieben Dank noch mal. Brauchte eben noch ne Zeit, bis ich das ganze richtig Verarbeitet habe. Auch der Hintergrund! Hatte vergessen auf der "Form1" Hintergrundfarbe = neuefarbe->lieferehintergrund() zu schreiben. Ich würde sagen mal wieder viel zu kompliziert gedacht oder?

Lieben Gruß

lempy