{"id":1335,"date":"2012-05-27T11:02:17","date_gmt":"2012-05-27T09:02:17","guid":{"rendered":"http:\/\/www.tutego.de\/blog\/javainsel\/?p=1335"},"modified":"2012-05-31T23:26:31","modified_gmt":"2012-05-31T21:26:31","slug":"inselraus-swingauswahlmen-mit-separator","status":"publish","type":"post","link":"https:\/\/www.tutego.de\/blog\/javainsel\/2012\/05\/inselraus-swingauswahlmen-mit-separator\/","title":{"rendered":"Inselraus: Swing\/Auswahlmenü mit Separator"},"content":{"rendered":"

Standardm\u00e4\u00dfig unterst\u00fctzt die JList und auch JComboBox keine Separatoren, doch die Unterteilung in Segmente ist in der Praxis sehr n\u00fctzlich. Microsoft Word und PowerPoint benutzen sie zum Beispiel, um die zuletzt vom Benutzer ausgew\u00e4hlten Zeichens\u00e4tze prominent oben in der Liste zu haben (Excel dagegen tut dies nicht).<\/p>\n

\"Abbildung\"<\/a><\/p>\n

Abbildung 9.42: <\/strong>Separator in Words Zeichensatzauswahlliste<\/p>\n

Wir wollen diese M\u00f6glichkeit nachbilden und dabei noch einiges \u00fcber Modelle und Renderer lernen.<\/p>\n

\"Abbildung\"<\/a><\/p>\n

Abbildung 9.43: <\/strong>Eine eigene Variante mit JSeparator in JComboBox<\/p>\n

Bei der Umsetzung gibt es unterschiedliche Varianten, die sich au\u00dfer in der technischen Implementierung darin unterscheiden, ob das Modell eine Markierung f\u00fcr den Separator enth\u00e4lt oder nicht. Wir stellen beide Ans\u00e4tze vor und beginnen mit der ersten Variante, also damit, einem Zellen-Renderer Positionen mitzugeben, die sagen, wo ein Trennstrich zu zeichnen ist.<\/p>\n

package<\/span> com.tutego.insel.ui.list;<\/pre>\n
<\/pre>\n
import<\/span> javax.swing.*;<\/pre>\n
<\/pre>\n
public<\/span> class<\/span> JComboBoxWithSeparator1 {<\/pre>\n
  public<\/span> static<\/span> void<\/span> main( String[] args ) throws<\/span> Exception {<\/pre>\n
    UIManager.setLookAndFeel( UIManager.getSystemLookAndFeelClassName() );<\/pre>\n
    JFrame frame = new<\/span> JFrame();<\/pre>\n
    frame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );<\/pre>\n
    String[] items = { \"Cambria<\/span>\", \"Arial<\/span>\", \"Verdana<\/span>\", \"Times<\/span>\" };<\/pre>\n
    JComboBox<String> comboBox = new<\/span> JComboBox<>( items );<\/pre>\n
    ListCellRenderer<String> renderer = new<\/span> SeparatorAwareListCellRenderer1<>(<\/pre>\n
                                          comboBox.getRenderer(), 0 );<\/pre>\n
    comboBox.setRenderer( renderer );<\/pre>\n
    frame.add( comboBox );<\/pre>\n
    frame.pack();<\/pre>\n
    frame.setVisible( true<\/span> );<\/pre>\n
  }<\/pre>\n
}<\/pre>\n
Die eigene Klasse SeparatorAwareListCellRenderer1 ist ein ListCellRenderer, den die JComboBox zur Darstellung der Komponenten nutzt. Im Konstruktor des Renderers geben wir den Original-Renderer mit \u2013 es kann ein bestimmter Renderer schon vorinstalliert sein, den wollen wir dekorieren \u2013 sowie eine variable Argumentliste von Positionen. Das Beispiel \u00fcbergibt nur 0, da nach dem ersten Element (Index = 0) ein Trennzeichen zu setzen sein soll, sodass Cambria und Arial abgetrennt sind.<\/p>\n
package<\/span> com.tutego.insel.ui.list;<\/pre>\n
<\/pre>\n
import<\/span> java.awt.*;<\/pre>\n
import<\/span> java.util.Arrays;<\/pre>\n
<\/pre>\n
import<\/span> javax.swing.*;<\/pre>\n
<\/pre>\n
public<\/span> class<\/span> SeparatorAwareListCellRenderer1<E> implements<\/span> ListCellRenderer<E><\/pre>\n
{<\/pre>\n
  private<\/span> final<\/span> ListCellRenderer<? super<\/span> E> delegate<\/span>;<\/pre>\n
  private<\/span> final<\/span> int<\/span>[] indexes;<\/pre>\n
  private<\/span> final<\/span> JPanel panel = new<\/span> JPanel( new<\/span> BorderLayout() );<\/pre>\n
<\/pre>\n
  public<\/span> SeparatorAwareListCellRenderer1( ListCellRenderer<? super<\/span> E> delegate<\/span>,<\/pre>\n
                                          int<\/span>... indexes )<\/pre>\n
  {<\/pre>\n
    Arrays.sort( indexes );<\/pre>\n
    this<\/span>.delegate<\/span> = delegate<\/span>;<\/pre>\n
    this<\/span>.indexes  = indexes;<\/pre>\n
  }<\/pre>\n
<\/pre>\n
  @Override<\/pre>\n
  public<\/span> Component getListCellRendererComponent( JList<? extends E> list, E value,<\/pre>\n
                                                 int<\/span> index, boolean<\/span> isSelected,<\/pre>\n
                                                 boolean<\/span> cellHasFocus )<\/pre>\n
  {<\/pre>\n
    panel.removeAll();<\/pre>\n
    panel.add( delegate<\/span>.getListCellRendererComponent( list, value, index,<\/pre>\n
                                                      isSelected, cellHasFocus ) );<\/pre>\n
    if<\/span> ( Arrays.binarySearch( indexes, index ) >= 0 )<\/pre>\n
      panel.add( new<\/span> JSeparator(), BorderLayout.PAGE_END );<\/pre>\n
<\/pre>\n
    return<\/span> panel;<\/pre>\n
  }<\/pre>\n
}<\/pre>\n
Die Implementierung basiert auf der Idee, jede Komponente in einen Container (JPanel) zu setzen und in diesem Container dann je nach Bedarf ein JSeparatorunten an diesem Container anzuf\u00fcgen. Statt JPanel mit einem JSeparator auszustatten, kann ebenfalls auch ein Border unten gezeichnet werden. Die AnweisungArrays.binarySearch(indexes, index) >= 0 ist als \u00bbcontains\u00ab zu verstehen, also als ein Test, ob der Index im Feld ist \u2013 leider gibt es so eine Methode nicht in der Java API. Wenn der Index im Feld ist, soll der Separator unter der Komponente erscheinen. Dass sich eine Trennlinie auch am Anfang befinden kann, ber\u00fccksichtigt die L\u00f6sung nicht; diese Variante bleibt als \u00dcbungsaufgabe f\u00fcr die Leser.<\/p>\n
Diese L\u00f6sung ist einfach und funktioniert gut, denn vorhandene Renderer werden weiterverwendet, was sehr wichtig ist, denn gr\u00f6\u00dfere Swing-Anwendungen nutzen viele eigene Renderer, etwa um Icons und Text zusammenzufassen. Ein Nachteil ist, dass der Separator zu einen Element geh\u00f6rt, und wenn das Element etwa in der Liste ausgew\u00e4hlt wird, steht der Separator mit in der Selektion und ist nicht abgetrennt (das ist aber bei Word genauso).<\/p>\n
W\u00e4hrend die vorgestellte Variante in der Praxis gut funktioniert, wollen wir uns noch mit einer alternativen Umsetzung besch\u00e4ftigen. Sie ist deutlich komplexer und auch nicht so flexibel. Die L\u00f6sung basiert auf der Idee, dass die Modelldaten eine Markierung f\u00fcr den Separator enthalten \u2013 die folgende L\u00f6sung nutzt null daf\u00fcr. DaJList oder JComboBox eine null problemlos vertr\u00e4gt, ist die Basis schnell umgesetzt:<\/p>\n
JFrame frame = new<\/span> JFrame();<\/pre>\n
frame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );<\/pre>\n
String[] items = { \"Cambria<\/span>\", null<\/strong><\/span>, \"Arial<\/span>\", \"Cambria<\/span>\", \"Verdana<\/span>\", \"Times<\/span>\" };<\/pre>\n
JComboBox<String> comboBox = new<\/span> JComboBox<String>( items );<\/pre>\n
frame.add( comboBox );<\/pre>\n
frame.pack();<\/pre>\n
frame.setVisible( true<\/span> );<\/pre>\n
Wenn wir das Programm starten, zeigt es dort, wo das Model eine null liefert, einfach nichts an. Die Selektion dieses null-Elements ist auch m\u00f6glich und f\u00fchrt zu keiner Ausnahme.<\/p>\n
Damit Swing das null-Element nicht als Leereintrag anzeigt, verpassen wir unserer JComboBox einen Zellen-Renderer. Der soll immer dann, wenn das Element nullist, ein Exemplar von JSeparator zeichnen. Vom Design ist es das beste, wenn der Zell-Renderer selbst die null-Elemente darstellt, aber das Zeichnen der Nicht-null-Elemente an einen anderen Zell-Renderer abgibt, anstatt diese etwa durch einen BasicComboBoxRenderer (ein JLabel, das ListCellRendererimplementiert) selbst zu renderen \u2013 das w\u00fcrde die Flexibilit\u00e4t der L\u00f6sung massiv einschr\u00e4nken.<\/p>\n
package<\/span> com.tutego.insel.ui.list;<\/pre>\n
<\/pre>\n
import<\/span> java.awt.Component;<\/pre>\n
import<\/span> javax.swing.*;<\/pre>\n
<\/pre>\n
public<\/span> class<\/span> SeparatorAwareListCellRenderer2<E> implements<\/span> ListCellRenderer<E><\/pre>\n
{<\/pre>\n
  private<\/span> final<\/span> ListCellRenderer<? super<\/span> E> delegate<\/span>;<\/pre>\n
<\/pre>\n
  public<\/span> SeparatorAwareListCellRenderer2( ListCellRenderer<? super<\/span> E> delegate<\/span> )<\/pre>\n
  {<\/pre>\n
    this<\/span>.delegate<\/span> = delegate<\/span>;<\/pre>\n
  }<\/pre>\n
<\/pre>\n
  @Override<\/pre>\n
  public<\/span> Component getListCellRendererComponent( JList<? extends E> list, E value,<\/pre>\n
                                                 int<\/span> index, boolean<\/span> isSelected,<\/pre>\n
                                                 boolean<\/span> cellHasFocus )<\/pre>\n
  {<\/pre>\n
    if<\/span> ( value == null<\/span> )<\/pre>\n
      return<\/span> new<\/span> JSeparator();<\/pre>\n
<\/pre>\n
    return<\/span> delegate<\/span>.getListCellRendererComponent( list, value, index, isSelected, cellHasFocus );<\/pre>\n
  }<\/pre>\n
}<\/pre>\n
Die eigene Klasse SeparatorAwareListCellRenderer2 bekommt einen anderen ListCellRenderer \u00fcbergeben und liefert die Komponenten dieses Delegate-Renderers immer dann, wenn das Element ungleich null ist. Ist es dagegen gleich null, liefert getListCellRendererComponent() ein Exemplar des JSeparators.<\/p>\n
Im Beispielprogramm muss der Renderer nun angemeldet werden, und dazu ist Folgendes zu erg\u00e4nzen:<\/p>\n
comboBox.setRenderer(\r\n  new SeparatorAwareListCellRenderer2<String>(comboBox.getRenderer()) );<\/pre>\n
Nach dem Start des Programms ist das Ergebnis schon viel besser: Dort, wo vorher die JComboBox eine leere Zeile darstellte, ist nun ein Strich.<\/p>\n
Die L\u00f6sung ist jedoch nur ein Etappensieg, denn die Navigation mit der Tastatur durch die Liste zeigt eine Schwachstelle: Das null-Element l\u00e4sst sich ausw\u00e4hlen und erscheint auch als Linie im Editor\/Textfeld. Beheben l\u00e4sst sich das Problem nicht mit dem Renderer, denn der ist nur mit der Darstellung in der Liste beauftragt. Hier muss in die Interna der Swing-Komponente eingegriffen werden. Jede Swing-Komponente hat ein korrespondierendes UI-Delegate, das f\u00fcr das Verhalten und die Darstellung der Komponente verantwortlich ist. F\u00fcr die JComboBox sind das Unterklassen von ComboBoxUI, und zwei Methoden sind besonders interessant:selectNextPossibleValue() und selectPreviousPossibleValue().<\/p>\n
Da jede UI-Implementierung ihr eigenes Look and Feel (LAF) mitbringt, m\u00fcssen wir hier eigentlich einen Dekorator bauen und jede Methode bis auf die beiden genannten an das Original weiterleiten, doch das ist jetzt zu viel Arbeit, und so nehmen wir die Basisklasse WindowsComboBoxUI als Basisklasse, denn unser Beispiel nutzt das Windows-LAF. In der Unterklasse implementieren wir eigene Versionen der Methoden selectNextPossibleValue() undselectPreviousPossibleValue(), die so lange die Liste nach oben\/unten laufen m\u00fcssen, bis sie ein Element ungleich null finden.<\/p>\n
package<\/span> com.tutego.insel.ui.list;<\/pre>\n
<\/pre>\n
import<\/span> com.sun.java.swing.plaf.windows.WindowsComboBoxUI;<\/pre>\n
<\/pre>\n
public<\/span> class<\/span> SeparatorAwareComboBoxUI extends<\/span> WindowsComboBoxUI<\/pre>\n
{<\/pre>\n
  @Override<\/pre>\n
  protected<\/span> void<\/span> selectNextPossibleValue()<\/pre>\n
  {<\/pre>\n
    for<\/span> ( int<\/span> index = comboBox.getSelectedIndex() + 1;<\/pre>\n
          index < comboBox.getItemCount();<\/pre>\n
          index++ )<\/pre>\n
      if<\/span> ( comboBox.getItemAt( index ) != null<\/span> )<\/pre>\n
      {<\/pre>\n
        comboBox.setSelectedIndex( index );<\/pre>\n
        break<\/span>;<\/pre>\n
      }<\/pre>\n
  }<\/pre>\n
<\/pre>\n
  @Override<\/pre>\n
  protected<\/span> void<\/span> selectPreviousPossibleValue()<\/pre>\n
  {<\/pre>\n
    for<\/span> ( int<\/span> index = comboBox.getSelectedIndex() - 1;<\/pre>\n
          index >= 0;<\/pre>\n
          index-- )<\/pre>\n
      if<\/span> ( comboBox.getItemAt( index ) != null<\/span> )<\/pre>\n
      {<\/pre>\n
        comboBox.setSelectedIndex( index );<\/pre>\n
        break<\/span>;<\/pre>\n
      }<\/pre>\n
  }<\/pre>\n
}<\/pre>\n
Das UI-Objekt muss ebenfalls im main()-Programm angemeldet werden:<\/p>\n
comboBox.setUI( new SeparatorAwareComboBoxUI() );<\/pre>\n
Enth\u00e4lt die Liste null-Elemente, \u00fcberspringt die Tastennavigation \u00fcber die Cursor-Taste diese. Doch auch mit diesem Teilst\u00fcck fehlt ein weiteres Detail: Mit einem Klick l\u00e4sst sich die Linie doch noch ausw\u00e4hlen. Das ist keine Frage des Renderers und auch keine Frage der Tastaturnavigation \u2013 es muss untersagt werden, dass bei der Aktivierung ein null-Element zum Editor kommen kann. Hier ist die Methode setSelectedItem() von JComboBox entscheidend. Denn jedes Element, das selektiert wird \u2013 und dadurch auch in das Textfeld kommt \u2013, geht durch die Methode hindurch. Wenn wir die Methode \u00fcberschreiben und bei null-Elementen einfach nichts tun, wird auch das null-Element nicht selektiert, und im Textfeld bleibt das letzte Element stehen.<\/p>\n
Damit auch spezielle Implementierungen von JComboBox von diesem Verhalten profitieren k\u00f6nnen, m\u00fcssen wir wieder einen Dekorator schreiben, doch das kostet zu viel M\u00fche, und so \u00fcberschreibt eine einfache Unterklasse die setSelectedItem()-Methode. (Im Prinzip w\u00e4re auch eine \u00fcberschriebene Methode vonsetSelectedIndex() sinnvoll, denn das k\u00f6nnte eine programmierte Aktivierung von null vermeiden.)<\/p>\n
package<\/span> com.tutego.insel.ui.list;<\/pre>\n
<\/pre>\n
import<\/span> javax.swing.*;<\/pre>\n
<\/pre>\n
public<\/span> class<\/span> SeparatorAwareJComboBox<E> extends<\/span> JComboBox<E><\/pre>\n
{<\/pre>\n
  @SafeVarargs<\/pre>\n
  public<\/span> SeparatorAwareJComboBox( E... items )<\/pre>\n
  {<\/pre>\n
    super<\/span>( items );<\/pre>\n
  }<\/pre>\n
<\/pre>\n
  @Override<\/pre>\n
  public<\/span> void<\/span> setSelectedItem( Object anObject )<\/pre>\n
  {<\/pre>\n
    if<\/span> ( anObject != null<\/span> )<\/pre>\n
      super<\/span>.setSelectedItem( anObject );<\/pre>\n
  }<\/pre>\n
}<\/pre>\n
Im Hauptprogramm muss nur diese spezielle Klasse zum Einsatz kommen und so folgt:<\/p>\n
package com.tutego.insel.ui.list;<\/pre>\n
<\/pre>\n
import javax.swing.*;<\/pre>\n
<\/pre>\n
public<\/span> class<\/span> JComboBoxWithSeparator2<\/pre>\n
{<\/pre>\n
  public<\/span> static<\/span> void main( String<\/span>[] args ) throws Exception<\/pre>\n
  {<\/pre>\n
    UIManager.setLookAndFeel( UIManager.getSystemLookAndFeelClassName() );<\/pre>\n
\/\/    UIManager.setLookAndFeel( new<\/span> NimbusLookAndFeel() );<\/pre>\n
<\/pre>\n
    JFrame frame = new<\/span> JFrame();<\/pre>\n
    frame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );<\/pre>\n
    String<\/span>[] items = { \"Cambria<\/span>\", null, \"Arial<\/span>\", \"Verdana<\/span>\", \"Times<\/span>\" };<\/pre>\n
    JComboBox<String<\/span>> comboBox = new<\/span> SeparatorAwareJComboBox<>( items );<\/pre>\n
    comboBox.setRenderer( new<\/span> SeparatorAwareListCellRenderer2<>(comboBox.getRenderer()) );<\/pre>\n
    comboBox.setUI( new<\/span> SeparatorAwareComboBoxUI() );<\/pre>\n
    comboBox.setSelectedIndex( 1 );<\/pre>\n
    frame.add( comboBox );<\/pre>\n
    frame.pack();<\/pre>\n
    frame.setVisible( true<\/span> );<\/pre>\n
  }<\/pre>\n
}<\/pre>\n","protected":false},"excerpt":{"rendered":"
Standardm\u00e4\u00dfig unterst\u00fctzt die JList und auch JComboBox keine Separatoren, doch die Unterteilung in Segmente ist in der Praxis sehr n\u00fctzlich. Microsoft Word und PowerPoint benutzen sie zum Beispiel, um die zuletzt vom Benutzer ausgew\u00e4hlten Zeichens\u00e4tze prominent oben in der Liste zu haben (Excel dagegen tut dies nicht). Abbildung 9.42: Separator in Words Zeichensatzauswahlliste Wir wollen […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_jetpack_memberships_contains_paid_content":false,"footnotes":"","_links_to":"","_links_to_target":""},"categories":[11,10],"tags":[],"class_list":["post-1335","post","type-post","status-publish","format-standard","hentry","category-insel","category-swing"],"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"_links":{"self":[{"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/posts\/1335","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/comments?post=1335"}],"version-history":[{"count":4,"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/posts\/1335\/revisions"}],"predecessor-version":[{"id":1346,"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/posts\/1335\/revisions\/1346"}],"wp:attachment":[{"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/media?parent=1335"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/categories?post=1335"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/tags?post=1335"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}