Methoden in Rescources speichern

[MatzeTechnology]

Hey JavaForum,

ich arbeite momentan an einem größeren Programm welches auf einem eigenen UserInterface basiert, welches verschiedene UI-Themes unterstützen soll.
Ich habe leider keine Ahnung wie ich verschiedene werte für unterschiedliche Themen hinterlege.
Mitlerweile habe ich von dem ResourcesBundle gehört, dies ist aber soweit ich das gesehen habe nur für die Unterstützung verschiedener Sprachen geeignet da man nur Strings ablegen kann.
Es wäre zwar noch möglich Farben zu einem String zu konvertieren und wieder zurück aber das ist doch ein wenig unschön.

Ein weiteres und das Hauptproblem ist, dass in dem "WhiteTheme" der Hintergrund eines Fensters mit einer Textur gezeichnet wird. Im "BlackTheme" soll der Hintergrund aber nur mit einer Farbe gefüllt werden.
Für den Hintergrund brauche ich also eine Methode, welche Textur lädt und zeichnet.
Tja, wie bekomme ich jetzt Methoden abgespeichert und kann sie bequem wechseln?

Ein Ablauf beispiel:

Als Theme wird das BlackTheme gesetzt;
Ein Fenster (F1) wird geöffnet, all seine unter Components sollen auch BlackTheme sein;
Das Theme wird auf WhiteTheme gesetzt;
Ein weiteres Fenster (F2) wird geöffnet (all seine unter Components sollen auch WhiteTheme sein)
Nun wird interaktiv vom User ein Button in F1 gedrückt der ein neues Fenster öffnet. Da F1 im BlackTheme ist soll das neue Fenster, und all seine unter Components , natürlich auch im BlackTheme sein.

So, hier ist mein Wunsch, stürzt euch darauf
Ich hoffe es ist soweit einigermaßen verständlich. Wie du dieses Problem nun löst ist vollkommen dir überlassen.
Also Zusatz Information noch: das gesamte UI basiert auf Swing (/AWT)

Sollte es bereits eine Lösung im Internet geben oder auch eine von Java direkt und ich war einfach zu schlecht beim googlen, dann fallt ruhig über mich her, aber ich habe wirklich nichts gefunden.

Ich bedanke mich im voraus für jede Antwort oder jeden google hinweiß wonach ich suchen sollte.
Viele Grüße
Matze

 

[diggaa1984]

Was spricht dagegen den Theme als String abzuspeichern und einfach für jeden Theme ne entsprechende Klasse bereitzuhalten?
Du kannst natürlich auch über Interfaces und Reflection arbeiten und dynamisch nach vorhandenen Ressourcen suchen, aber wäre glaube ich unnötig kompliziert.

 

[turtle]

Ein weiteres und das Hauptproblem ist, dass in dem "WhiteTheme" der Hintergrund eines Fensters mit einer Textur gezeichnet wird. Im "BlackTheme" soll der Hintergrund aber nur mit einer Farbe gefüllt werden.
Für den Hintergrund brauche ich also eine Methode, welche Textur lädt und zeichnet.
Tja, wie bekomme ich jetzt Methoden abgespeichert und kann sie bequem wechseln?

Wie diggaa1984 bereits richtig anmerkte, würde ich dies gar nicht in Properties hinterlegen, sondern der Code muss alles (richtig) auflösen. Ich würde nur keine Strings nehmen

Nehmen wir an es gibt zwei verschiedene Themes:

class WhiteThemePanel extends JPanel implements ThemeWechsel;
class BlackThemePanel extends JPanel implements ThemeWechsel;

Also "weiss" WhiteThemePanel, das es den Hintergrund mit einer Textur malen soll. Alle weiteren Panels, die geöffnet werden können, muss es dann ebenfalls in White|Black-Ausführungen geben.

Gemeinsames Verhalten kannst du über das Interface ThemeWechsel ermöglichen, wobei ich nicht weiss, was da wirklich drin sein könnte.

Bleibt noch die Konfiguration des Panels. Hier kannst du den Klassennamen in eine Property schreiben und dein Code instanziert die richtige Klasse (via Reflection)

HauptPanel=my.package.Main.Panel.WhiteThemePanel

 

[diggaa1984]

Ich würde nur keine Strings nehmen [/CODE]

Mir ging es da eher um eine Standard-Theme-Setting was ausserhalb definiert werden könnte, wenn der User die Freiheit haben soll. Ich weiss ja nicht ob bereits properties genutzt werden oder nich, wäre ja ein leichtes dort noch derartiges hineinzubauen. Die jeweiligen Eigenschaften, Farbwerte etc. pp haben da natürlich nichts zu suchen.

 

[MatzeTechnology]

Leider bin ich mir momentan nicht ganz sicher ob ich verstehe was ihr meint... Ich poste mal meine aktuelle Lösung und ihr könnt dann dazu vllt nochmal Stellung nehmen, bzw sie verbessern.

Ich habe eine Klasse DWindow, welche von JWindow erbt. Diese klasse ist in der Lage mir ein "schönes" fenster auf den bildschrim zu zaubern. DWindow hat eine Instanzvariable userInterfaceTheme.

Hier die beiden wichtigen Klassen:

package UserInterface.Themes;

public class UserInterfaceTheme {

	public static UserInterfaceTheme actualTheme = new BlackTheme();

	public WindowTheme windowTheme;

	public abstract class WindowTheme {

		public abstract void paintBackground(Graphics g, Rectangle rect);

		public void paintBackground(Graphics g, Component comp) {
			this.paintBackground(g,
					new Rectangle(new Point(0, 0), comp.getSize()));
		}
        public abstract int getPadding();

	}

}

package UserInterface.Themes;

public class BlackTheme extends UserInterfaceTheme {

	public BlackTheme() {
		
		windowTheme = new WindowTheme() {
			
			@Override
			public void paintBackground(Graphics g, Rectangle rect) {
				Graphics2D g2 = (Graphics2D) g;
				g2.addRenderingHints(new RenderingHints(
						RenderingHints.KEY_ANTIALIASING,
						RenderingHints.VALUE_ANTIALIAS_ON));
				g2.setColor(Color.gray);
				g2.fill(rect); 
			}

			@Override
			public int getPadding() {
				return 4;
			}

		};

	}

}

Im Konstruktor von DWindow steht nun: this.userInterfaceTheme = UserInterfaceTheme.actualTheme;
so kann ich bevor ich das window erstelle diese statische variable einfach anpassen, die information welches theme genutzt werden soll steht dann für jedes folgend erstellte UI-Element zur verfügung, jedes UI-Element setzt sein Theme dann beim initialisieren.

Ich sehe noch ein paar dinge die mir nicht besonders gefallen:
1.Ich muss für jeden simplen integer wert der irgendeinen padding/margin darstellt eine methode verwenden, finde ich persönlich umständlich, geht das einfacher? aber damit könnte ich mcih abfinden denke ich

2.Wenn ich erst ein Fenster des Whitethemes erstelle und dann eines des BlackThemes findet sich im actualUserInterfaceTheme ein BlackTheme wieder, ich müsste also bevor ich einen neuen Component dynamisch initialisiere das actualUserInterfaceTheme überprüfen...
Ich sehe aber auch keinen anderen weg, mir fällt momentan kein weg ein wie ein Kind-Component eines JPanels oder ein Fenster, welches aus einem anderen heraus erzeugt wird, herausfinden soll wo es herkommt bzw was denn das Mutter-Objekt ist/für ein Theme hat...

Bei der ersten Entwicklung dieses Konzepts habe ich mich ein wenig an den AndroidSystem mit der R Klasse orientiert, da ich das eigentlich ganz praktisch fand, wenn ich eine Farbe für mein DWindow einfach mit: UserInterfaceTheme.Window.backgroundColor aufrufen kann oder mit UserInterfaceTheme.Window.paintBackground(Graphics g);