# Komponenten um weitere Hintergrund- bzw. Vordergrundfarbe erweitern



## detrix (5. Jul 2010)

Hallo liebe Java-Gemeinde,

für ein Projekt muss ich einige Swing-Komponenten so erweitern, dass eine zweite Hintergrund- bzw. Vordergrundfarbe zur Verfügung steht. 

Die Klassenstruktur sieht folgendermaßen aus:

TLabel erbt von JLabel,
TPanel erbt von JPanel,
TClock erbt von JComponent
...

Die Komponenten (TLabel, TPanel, TClock, ...) implementieren die Schnittstelle "IInversible". Die Funktionalität sieht wie folgt aus:


```
...
    public void setSuperBackground(Color bg) {
        super.setBackground(bg);
    }

    public void setSuperForeground(Color fg) {
        super.setForeground(fg);
    }

    @Override
    public void setBackground(Color bg) {
        defaultBackground = bg; // Zwischenspeichern der Hintergrundfarbe
        setSuperBackground(bg);
    }

    @Override
    public void setForeground(Color fg) {
        defaultForeground = fg; // Zwischenspeichern der Vordergrundfarbe
        setSuperForeground(fg);
    }

    public boolean isInverse() {
        return inverse;
    }

    public void setInverse(boolean inverse) {
        if (inversible) {
            if (inverse) {
                setSuperBackground(getInverseBackground());
                setSuperForeground(getInverseForeground());
            } else {
                setSuperBackground(defaultBackground);
                setSuperForeground(defaultForeground);
            }
        }
        this.inverse = inverse;
    }
    
    public Color getInverseBackground() {
        return inverseBackground;
    }

    public void setInverseBackground(Color inverseBackground) {
        this.inverseBackground = inverseBackground;
    }

    public Color getInverseForeground() {
        return inverseForeground;
    }

    public void setInverseForeground(Color inverseForeground) {
        this.inverseForeground = inverseForeground;
    }

    public boolean isInversible() {
        return inversible;
    }

    public void setInversible(boolean inversible) {
        this.inversible = inversible;
    }
    ...
```

Das funktioniert soweit auch recht gut, allerdings muss ich die Logik immer wieder neu kopieren... An dieser Stelle wäre Mehrfachvererbung wohl ganz praktisch. Wie löse ich das Problem? Vielleicht muss bzw. kann ich die Logik auch anderswo in Swing platzieren? Ideen?

Grüße detrix


----------



## slawaweis (5. Jul 2010)

detrix hat gesagt.:


> Das funktioniert soweit auch recht gut, allerdings muss ich die Logik immer wieder neu kopieren... An dieser Stelle wäre Mehrfachvererbung wohl ganz praktisch.


nicht unbedingt, Du müsstest immer noch von jeder benötigten Klasse ableiten.



detrix hat gesagt.:


> Wie löse ich das Problem? Vielleicht muss bzw. kann ich die Logik auch anderswo in Swing platzieren? Ideen?


über Komposition und get/putClientProperty. Dazu erstellst Du dir eine einzige Klasse die IInversible implementiert, nach diesem Muster:


```
public class InversibleImpl implements IInversible
{
 public InversibleImpl(JComponent component, Color param1/*, ...*/)
  {
  /*...*/
  }
 /*...*/
}
```

Dazu schreibst Du eine Utility-Klasse InversibleUtils mit folgender statischer Funktion:


```
public class InversibleUtils
{
 public static IInversible get(JComponent component)
  {
  IInversible invs = component.getClientProperty("provider-inversible-extension");
  if(invs == null)
    {
    invs = new InversibleImpl(component, Color.RED/*, ...*/);
    component.putClientProperty("provider-inversible-extension", invs);
    }
  return invs;
  }
}
```

und so wird es dann aufgerufen:


```
JLabel label = new JLabel("Text");

 /* ... */

 IInversible invs_label = InversibleUtils.get(label);
```

mit addPropertyChangeListener kannst Du in InversibleImpl darauf lauschen, ob anderswo die Hintergrund- bzw. Vordergrundfarbe verändert wurde. So kann man sogar schon bestehende Programme ganz einfach erweitern.

Slawa


----------



## detrix (5. Jul 2010)

Aber dann kann ich doch nicht mehr mit "super.setBackground(bg);" arbeiten?!

Grüße detrix


----------



## slawaweis (5. Jul 2010)

detrix hat gesagt.:


> Aber dann kann ich doch nicht mehr mit "super.setBackground(bg);" arbeiten?!


muss Du auch nicht, einfach "component.setBackground(bg);" schreiben.

Slawa


----------



## detrix (6. Jul 2010)

Hm, ich muss immer zwischen der "normalen" und der "inversen" Farbe wechseln können. Es kann auch sein, dass sich die "normale" Farbe zur Laufzeit verändert. Mit "component.setBackground(bg);" würde ich ja die "normale" Hintergrundfarbe immer überschreiben…

Außerdem muss jedes TLabel, TPanel, etc. diese Funktionalität beinhalten. Sprich: Für jeden Komponente mit "InversibleUtils" arbeiten, finde ich ziemlich umständlich… Wobei ich das ja direkt in die Komponenten setzten könnte...

Auf Knopfdruck müssen alle Komponenten in die inverse bzw. normale Farben "switchen". Bisher so gelöst, dass die Komponenten geparst werden:


```
...
    private void inverse(JComponent component, boolean inverse) {
        if (component instanceof IInversible) {
            IInversible c = (IInversible)component;
            c.setInverse(inverse);
        }
        for (Component child : component.getComponents()) {
            try {
                inverse((JComponent)child, inverse);
            } catch (Exception ex) {}
        }
    }
    ...
```


----------



## slawaweis (6. Jul 2010)

detrix hat gesagt.:


> Hm, ich muss immer zwischen der "normalen" und der "inversen" Farbe wechseln können. Es kann auch sein, dass sich die "normale" Farbe zur Laufzeit verändert. Mit "component.setBackground(bg);" würde ich ja die "normale" Hintergrundfarbe immer überschreiben…


die "normale" Hintergrundfarbe musst Du natürlich zwischenspeichern, wie Du es ja auch in deinem ersten Beispiel gemacht hast. Was das Ändern der Farbe zu Laufzeit angeht, da habe ich bereits auf addPropertyChangeListener verwiesen:

Container (Java Platform SE 6)



detrix hat gesagt.:


> Außerdem muss jedes TLabel, TPanel, etc. diese Funktionalität beinhalten. Sprich: Für jeden Komponente mit "InversibleUtils" arbeiten, finde ich ziemlich umständlich… Wobei ich das ja direkt in die Komponenten setzten könnte...


wenn es für Dich einfacher ist von jeder benötigten Komponente eine eigene Klasse mit eigener Funktionalität abzuleiten, dann arbeite so. Ich weis ja am Ende nicht, was Du alles geplant hast. Ich wollte nur eine Idee geben, wie man die Logik anderswo in Swing platzieren kann.



detrix hat gesagt.:


> Auf Knopfdruck müssen alle Komponenten in die inverse bzw. normale Farben "switchen". Bisher so gelöst, dass die Komponenten geparst werden:


dann musst Du InversibleUtils so abändern, dass die IInversible nur in den benötigten Komponenten installiert wird, mit einer Funktion "install(JComponent component)" oder der Erweiterung "get(JComponent component, boolean install)".

Slawa


----------



## detrix (7. Jul 2010)

Danke für Deine bisherige Mühe und ich bin für jeden Vorschlag dankbar, das sollte nicht falsch rüberkommen.

Ich benötige mein TLabel, das von JLabel erbt, weil es noch etwas mehr Logik beinhaltet.

Die Hinter- bzw. Vordergrundfarbe speichere ich zwischen, in dem ich die "setBackground()" bzw. "setForeground()" überschreibe (s. oben).

Wenn ich nun mit "component.setBackground(bg)" arbeite, endet das in einem Ping-Pong Spiel zwischen TLabel und TLabel. Mit "super.setBackground(bg)" würde das TLabel die Farbe an JLabel weitergeben... Gibt es da einen Ausweg, ohne jetzt z.B. eine Eigenschaft "normalBackground" bzw. "normalForeground" einzuführen.


----------



## slawaweis (7. Jul 2010)

detrix hat gesagt.:


> Danke für Deine bisherige Mühe und ich bin für jeden Vorschlag dankbar, das sollte nicht falsch rüberkommen.
> 
> Ich benötige mein TLabel, das von JLabel erbt, weil es noch etwas mehr Logik beinhaltet.


das wusste ich nicht. Ich dachte bei den T* Klassen ging es nur darum, dass diese um IInversible erweitert werden.



detrix hat gesagt.:


> Die Hinter- bzw. Vordergrundfarbe speichere ich zwischen, in dem ich die "setBackground()" bzw. "setForeground()" überschreibe (s. oben).
> 
> Wenn ich nun mit "component.setBackground(bg)" arbeite, endet das in einem Ping-Pong Spiel zwischen TLabel und TLabel. Mit "super.setBackground(bg)" würde das TLabel die Farbe an JLabel weitergeben... Gibt es da einen Ausweg, ohne jetzt z.B. eine Eigenschaft "normalBackground" bzw. "normalForeground" einzuführen.


der Sinn ist natürlich, dass wenn man eine Klasse InversibleImpl hat, man IInversible nicht mehr in den T* Klassen implementiert. Weiterhin muss es nicht in einem Ping-Pong Spiel enden, wenn man ein Flag verwendet, ob man selber die Eigenschaften ändert oder es irgendwo von außen passiert. Weiterhin verstehe ich das mit "normalBackground" nicht ganz, Du hast doch schon zwei Variablen "defaultBackground" und "inverseBackground". Ist "normalBackground" != "defaultBackground"?

Aber wenn Du schon sowieso ableitest, gäbe es noch eine Variante, über ein zusätzliches Service-Interface:


```
public interface IInversibleService
{
 public IInversible getInversible();
}
```

das kann man dann so verwenden:


```
TLabel label = ...;

 label.getInversible().setInverseBackground(Color.RED);
```

dann kann man mit Delegation arbeiten und nur setBackground/setForeground jeweils überschreiben.

Slawa


----------



## detrix (7. Jul 2010)

Wird dann in der Methode "getInversible()" eine Instanz von "InversibleImpl" erzeugt bzw. zurück gegeben, die wiederum einen Verweis auf den Komponent hat? Sprich: new InversibleImp(this);

Wo ist dann die setBackground() bzw. setForeground() Methode, um die normale Farbe zwischenzuspeichern? Beziehungsweiße, wie würde das Zwischenspeichern konkret aussehen? 

Ich stehe da gerade irgendwie auf dem Schlauch. 

Kann ich dann weiterhin mit NetBeans im Eigenschaftsfenster den Inversen-Hintergrund setzten, mit dem Weg über das Service-Interface?

Danke Dir!


----------



## slawaweis (7. Jul 2010)

detrix hat gesagt.:


> Wird dann in der Methode "getInversible()" eine Instanz von "InversibleImpl" erzeugt bzw. zurück gegeben, die wiederum einen Verweis auf den Komponent hat? Sprich: new InversibleImp(this);


ja, das ist der Sinn wegen, Zitat: "allerdings muss ich die Logik immer wieder neu kopieren".



detrix hat gesagt.:


> Wo ist dann die setBackground() bzw. setForeground() Methode, um die normale Farbe zwischenzuspeichern? Beziehungsweiße, wie würde das Zwischenspeichern konkret aussehen?


die sind in den T* Klassen:


```
@Override
    public void setBackground(Color bg) {
        inversible_impl.setDefaultBackground(bg); // Zwischenspeichern der Hintergrundfarbe
        super.setBackground(bg);
    }
    ...
```



detrix hat gesagt.:


> Kann ich dann weiterhin mit NetBeans im Eigenschaftsfenster den Inversen-Hintergrund setzten, mit dem Weg über das Service-Interface?


nein

Slawa


----------



## detrix (7. Jul 2010)

Okay, danke. Und wie greife ich bei "setInverse()" auf "super.setBackground(inverseBackground)" zu?  Befindet sich ja in "InversibleImpl"...


----------



## slawaweis (8. Jul 2010)

detrix hat gesagt.:


> Okay, danke. Und wie greife ich bei "setInverse()" auf "super.setBackground(inverseBackground)" zu?  Befindet sich ja in "InversibleImpl"...




```
public class TLabel ...
{
    public TLabel(...) {
        inversible_impl = new InversibleImpl(this);
    }

    @Override
    public void setBackground(Color bg) {
        inversible_impl.setDefaultBackground(bg); // Zwischenspeichern der Hintergrundfarbe
        super.setBackground(bg);
    }
}
```


```
public class InversibleImpl ...
{
    Color defaultBackground = ...;
    Component component = null;
    boolean ignore_set = false;

    public InversibleImpl(Component comp) {
        this.component = comp;
    }

    @Override
    public void setDefaultBackground(Color bg) {
        if(!ignore_set)
          defaultBackground = bg;
    }

    public void setInverse(boolean inverse) {
        ignore_set = true;
            if (inverse) {
                component.setBackground(getInverseBackground());
                component.setForeground(getInverseForeground());
            } else {
                component.setBackground(defaultBackground);
                component.setForeground(defaultForeground);
            }
        ignore_set = false;
        this.inverse = inverse;
    }

}
```

Slawa


----------

