Professionelle Bücher. Auch für Einsteiger.

Inhaltsverzeichnis
Vorwort
1 Java ist auch eine Sprache
2 Sprachbeschreibung
3 Klassen und Objekte
4 Der Umgang mit Zeichenketten
5 Mathematisches
6 Eigene Klassen schreiben
7 Angewandte Objektorientierung
8 Exceptions
9 Die Funktionsbibliothek
10 Threads und nebenläufige Programmierung
11 Raum und Zeit
12 Datenstrukturen und Algorithmen
13 Dateien und Datenströme
14 Die eXtensible Markup Language (XML)
15 Grafische Oberflächen mit Swing
16 Grafikprogrammierung
17 Netzwerkprogrammierung
18 Verteilte Programmierung mit RMI und Web-Services
19 JavaServer Pages und Servlets
20 Applets
21 Midlets und die Java ME
22 Datenbankmanagement mit JDBC
23 Reflection und Annotationen
24 Logging und Monitoring
25 Sicherheitskonzepte
26 Java Native Interface (JNI)
27 Dienstprogramme für die Java-Umgebung
A Die Begleit-DVD
Stichwort
Download: - ZIP, ca. 12,5 MB
Buch bestellen
Ihre Meinung?
<< zurück | Galileo Computing / <openbook> /Java-Insel | vor >>
Java ist auch eine Insel von Christian Ullenboom Programmieren mit der Java Standard Edition Version 6
Java ist auch eine Insel 7., aktualisierte Auflage geb., mit DVD (November 2007) 1.492 S., 49,90 Euro Galileo Computing ISBN 978-3-8362-1146-8 |
| 15 Grafische Oberflächen mit Swing
|  | 15.1 Das Abstract Window Toolkit und Swing
|  |  | 15.1.1 Abstract Window Toolkit (AWT)
|  |  | 15.1.2 Java Foundation Classes
|  |  | 15.1.3 Was Swing von AWT unterscheidet
|  |  | 15.1.4 Die Klasse Toolkit
|  | 15.2 Fenster unter grafischen Oberflächen
|  |  | 15.2.1 Swing-Fenster darstellen
|  |  | 15.2.2 AWT-Fenster darstellen
|  |  | 15.2.3 Sichtbarkeit des Fensters
|  |  | 15.2.4 Größe und Position des Fensters verändern
|  |  | 15.2.5 Unterklassen der Fenster-Klassen bilden
|  |  | 15.2.6 Fenster- und Dialog-Dekoration
|  |  | 15.2.7 Dynamisches Layout während einer Größenänderung
|  | 15.3 Beschriftungen (JLabel)
|  |  | 15.3.1 Mehrzeiliger Text, HTML in der Darstellung
|  | 15.4 Icon und ImageIcon für Bilder auf Swing-Komponenten
|  |  | 15.4.1 Die Schnittstelle Icon
|  | 15.5 Es tut sich was – Ereignisse beim AWT
|  |  | 15.5.1 Die Klasse AWTEvent
|  |  | 15.5.2 Events auf verschiedenen Ebenen
|  |  | 15.5.3 Swings Ereignisquellen und Horcher (Listener)
|  |  | 15.5.4 Listener implementieren
|  |  | 15.5.5 Listener bei dem Ereignisauslöser anmelden/abmelden
|  |  | 15.5.6 Aufrufen der Listener im AWT-Event-Thread
|  |  | 15.5.7 Adapterklassen nutzen
|  |  | 15.5.8 Innere Mitgliedsklassen und innere anonyme Klassen
|  | 15.6 Schaltflächen
|  |  | 15.6.1 Normale Schaltflächen (JButton)
|  |  | 15.6.2 Der aufmerksame ActionListener
|  |  | 15.6.3 Basisklasse AbstractButton
|  |  | 15.6.4 Wechselknopf (JToggleButton)
|  | 15.7 Swing Action
|  |  | 15.7.1 javax.swing.Action
|  |  | 15.7.2 Eigenschaften der Action-Objekte
|  | 15.8 JComponent und Component als Basis aller Komponenten
|  |  | 15.8.1 Tooltips
|  |  | 15.8.2 Rahmen (Border)
|  |  | 15.8.3 Fokus und Navigation
|  |  | 15.8.4 Ereignisse jeder Komponente
|  |  | 15.8.5 Die Größe und Position einer Komponente
|  |  | 15.8.6 Komponenten-Ereignisse
|  |  | 15.8.7 Hinzufügen von Komponenten
|  |  | 15.8.8 UI-Delegate – der wahre Zeichner
|  |  | 15.8.9 Undurchsichtige (opak) Komponente
|  |  | 15.8.10 Properties und Listener für Änderungen
|  |  | 15.8.11 Swing-Beschriftungen eine andere Sprache geben
|  | 15.9 Container
|  |  | 15.9.1 Standardcontainer (JPanel)
|  |  | 15.9.2 Bereich mit automatischen Rollbalken (JScrollPane)
|  |  | 15.9.3 Reiter (JTabbedPane)
|  |  | 15.9.4 Teilung-Komponente (JSplitPane)
|  | 15.10 Alles Auslegungssache: die Layoutmanager
|  |  | 15.10.1 Übersicht über Layoutmanager
|  |  | 15.10.2 Zuweisen eines Layoutmanagers
|  |  | 15.10.3 Im Fluss mit FlowLayout
|  |  | 15.10.4 Mit BorderLayout in allen Himmelsrichtungen
|  |  | 15.10.5 Rasteranordnung mit GridLayout
|  |  | 15.10.6 Der GridBagLayout-Manager
|  |  | 15.10.7 Null-Layout
|  |  | 15.10.8 BoxLayout
|  |  | 15.10.9 Weitere Layoutmanager
|  | 15.11 Rollbalken und Schieberegler
|  |  | 15.11.1 Schieberegler (JSlider)
|  |  | 15.11.2 Rollbalken (JScrollBar)
|  | 15.12 Kontrollfelder, Optionsfelder, Kontrollfeldgruppen
|  |  | 15.12.1 Kontrollfelder (JCheckBox)
|  |  | 15.12.2 ItemSelectable, ItemListener und das ItemEvent
|  |  | 15.12.3 Sich gegenseitig ausschließende Optionen (JRadioButton)
|  | 15.13 Fortschritte bei Operationen überwachen
|  |  | 15.13.1 Fortschrittsbalken (JProgressBar)
|  |  | 15.13.2 Dialog mit Fortschrittsanzeige (ProgressMonitor)
|  | 15.14 Menüs und Symbolleisten
|  |  | 15.14.1 Die Menüleisten und die Einträge
|  |  | 15.14.2 Menüeinträge definieren
|  |  | 15.14.3 Einträge durch Action-Objekte beschreiben
|  |  | 15.14.4 Mit der Tastatur: Mnemonics und Shortcut
|  |  | 15.14.5 Der Tastatur-Shortcut (Accelerator)
|  |  | 15.14.6 Tastenkürzel (Mnemonics)
|  |  | 15.14.7 Symbolleisten alias Toolbars
|  |  | 15.14.8 Popup-Menüs
|  |  | 15.14.9 System-Tray nutzen
|  | 15.15 Das Model-View-Controller-Konzept
|  | 15.16 Auswahlmenüs, Listen und Spinner
|  |  | 15.16.1 Auswahlmenü (JComboBox)
|  |  | 15.16.2 Zuordnung einer Taste mit einem Eintrag
|  |  | 15.16.3 Datumsauswahl
|  |  | 15.16.4 Listen (JList)
|  |  | 15.16.5 Drehfeld (JSpinner)
|  | 15.17 Texteingabefelder
|  |  | 15.17.1 Text in einer Eingabezeile
|  |  | 15.17.2 Die Oberklasse der Text-Komponenten (JTextComponent)
|  |  | 15.17.3 Geschützte Eingaben (JPasswordField)
|  |  | 15.17.4 Validierende Eingabefelder (JFormattedTextField)
|  |  | 15.17.5 Einfache mehrzeilige Textfelder (JTextArea)
|  |  | 15.17.6 Editor-Klasse (JEditorPane)
|  | 15.18 Tabellen (JTable)
|  |  | 15.18.1 Ein eigenes Tabellen-Model
|  |  | 15.18.2 Basisklasse für eigene Modelle (AbstractTableModel)
|  |  | 15.18.3 Vorgefertigtes Standard-Modell (DefaultTableModel)
|  |  | 15.18.4 Ein eigener Renderer für Tabellen
|  |  | 15.18.5 Zell-Editoren
|  |  | 15.18.6 Größe und Umrandung der Zellen
|  |  | 15.18.7 Spalteninformationen
|  |  | 15.18.8 Tabellenkopf von Swing-Tabellen
|  |  | 15.18.9 Selektionen einer Tabelle
|  |  | 15.18.10 Automatisches Sortieren und Filtern mit RowSorter
|  |  | 15.18.11 Ein professionelles Tabellenlayout mit JGrid
|  | 15.19 Bäume (JTree)
|  |  | 15.19.1 JTree und sein TreeModel und TreeNode
|  |  | 15.19.2 Selektionen bemerken
|  |  | 15.19.3 Das TreeModel von JTree
|  | 15.20 JRootPane, JLayeredPane und JDesktopPane
|  |  | 15.20.1 Wurzelkomponente der Top-Level-Komponenten (JRootPane)
|  |  | 15.20.2 JLayeredPane
|  |  | 15.20.3 JDesktopPane und die Kinder JInternalFrame
|  | 15.21 Dialoge und Window-Objekte
|  |  | 15.21.1 JWindow und JDialog
|  |  | 15.21.2 Modal oder nicht-modal
|  |  | 15.21.3 Standarddialoge mit JOptionPane
|  |  | 15.21.4 Der Farbauswahldialog JColorChooser
|  |  | 15.21.5 Der Dateiauswahldialog
|  | 15.22 Flexibles Java-Look
|  |  | 15.22.1 L & F global setzen
|  |  | 15.22.2 UIManager
|  |  | 15.22.3 Verbessern des Aussehens unter Windows mit JGoodies Looks
|  | 15.23 Die Zwischenablage (Clipboard)
|  |  | 15.23.1 Clipboard-Objekte
|  |  | 15.23.2 Auf den Inhalt zugreifen mit Transferable
|  |  | 15.23.3 DataFlavor ist das Format der Daten in der Zwischenablage
|  |  | 15.23.4 Einfügungen in der Zwischenablage erkennen
|  |  | 15.23.5 Drag
|  | 15.24 Undo durchführen
|  | 15.25 AWT, Swing und die Threads
|  |  | 15.25.1 Ereignisschlange (EventQueue) und AWT-Event-Thread
|  |  | 15.25.2 Swing ist nicht Thread-sicher
|  |  | 15.25.3 Swing-Elemente mit invokeLater() und invokeAndWait() bedienen
|  |  | 15.25.4 SwingWorker
|  |  | 15.25.5 Eigene Ereignisse in die Queue setzen
|  |  | 15.25.6 Auf alle Ereignisse hören
|  | 15.26 Barrierefreiheit mit der Java Accessibility API
|  | 15.27 Benutzerinteraktionen automatisieren
|  |  | 15.27.1 Automatisch in die Tasten hauen
|  |  | 15.27.2 Mausoperationen
|  |  | 15.27.3 Methoden zur Zeitsteuerung
|  |  | 15.27.4 Screenshots
|  |  | 15.27.5 MouseInfo und PointerInfo
|  | 15.28 Zeitliches Ausführen mit dem javax.swing.Timer
|  | 15.29 Alternativen zu AWT und Swing
|  |  | 15.29.1 XML-Beschreibungen der Oberfläche: Swixml, XUL/Luxor
|  |  | 15.29.2 SWT (Standard Widget Toolkit)
|  | 15.30 Zum Weiterlesen
## 15.11 Rollbalken und Schieberegler Ein Rollbalken (engl. scrollbar, auch Bildlaufleiste genannt) ist eine Komponente, die es einem Benutzer auf einfache Weise ermöglicht, einen ganzzahligen Wert aus einem vorher festgelegten Wertebereich auszuwählen. Ein Schieberegler (engl. slider) ist mit dem Rollbalken verwandt. Er dient im Speziellen jedoch zur Auswahl eines Werts aus einem Zahlenbereich. Beim Slider lässt sich zudem noch eine Skala aus verschieden großen Strichen (engl. tick marks) setzen. ### 15.11.1 Schieberegler (JSlider) Die Swing-Bibliothek implementiert Slider durch die Klasse JSlider. Dass Ticks gezeichnet werden, bestimmt der Aufruf setPaintTicks(true). Damit sich die Abstände der Unterteilungen setzen lassen, wird setMinorTickSpacing(int) oder auch setMajorTickSpacing(int) verwendet. Die letzten Methoden sind unabhängig voneinander. Zusätzlich zu den Ticks erlaubt die Klasse auch eine automatische Nummerierung der Striche. Dann muss die Methode setPaintLabels(true) gesetzt werden. Eigene Wertebereiche werden über setLabelTable(Dictionary labels) zugewiesen; der Assoziativspeicher verbindet Integer-Objekte für Positionen mit JComponent-Komponenten, die dann am JSlider gezeichnet werden. Auf Bewegungsereignisse horcht ein ChangeListener. Hier klicken, um das Bild zu vergrößern Abbildung 15.11 Die verschiedenen JSlider ohne Nummerierung Listing 15.26 com/tutego/insel/ui/swing/JSliderDemo.java
    package com.tutego.insel.ui.swing;

    import java.awt.GridLayout;
    import javax.swing.*;
    import javax.swing.event.*;

    public class JSliderDemo
    {
      public static void main( String[] args )
      {
        JFrame frame = new JFrame();
        frame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
        frame.setLayout( new GridLayout(4, 0, 0, 7) );

        JSlider slider1 = new JSlider( 0, 100, 50 );
        frame.add( slider1 );

        JSlider slider2 = new JSlider( 0, 100, 50 );
        slider2.setPaintTicks( true );
        slider2.setMinorTickSpacing( 5 );
        frame.add( slider2 );

        JSlider slider3 = new JSlider( 0, 100, 50 );
        slider3.setPaintTicks( true );
        slider3.setMajorTickSpacing( 10 );
        frame.add( slider3 );

        JSlider slider4 = new JSlider ( 0, 100, 50 );
        slider4.setPaintTicks(true);
        slider4.setMajorTickSpacing( 10 );
        slider4.setMinorTickSpacing( 2 );
        slider4.setPaintTrack( false );
        slider4.addChangeListener( new ChangeListener() {
          public void stateChanged( ChangeEvent e ) {
             System.out.println( ((JSlider) e.getSource()).getValue() );
          }
        } );
        frame.add( slider4 );

        frame.pack();
        frame.setVisible( true );
      }
    }
### 15.11.2 Rollbalken (JScrollBar) Mittels eines verschiebbaren Knopfes oder der Bildlaufpfeile lässt sich ein Wert einstellen. Der Rollbalken kann vertikal oder horizontal angeordnet werden. Er besitzt für Verschiebungen folgende Regel hinsichtlich des internen Werts: Bei einem vertikalen Rollbalken liegt oben der größte Wert und bei einem horizontalen auf der linken Seite. Wird der Rollbalken verändert, werden AdjustmentEvent-Objekte erzeugt. Dem JScrollBar ist ein BoundedRangeModel zugewiesen, das die Daten speichert. Hier klicken, um das Bild zu vergrößern Abbildung 15.12 Ein Rollbalken #### Position eines Rollbalkens mit Textfeldeintrag synchron halten Das folgende Programm verwendet ein JScrollBar- und ein JTextField-Objekt. Beide benachrichtigen sich bei Änderungen. Wird also im Textfeld eine neue Zahl eingesetzt, zeigt der Rollbalken diese an. Verändern wir den Regler, so wird die passende Zahl in das Textfeld gesetzt. Sie werden mit Listener-Objekten betrieben. Listing 15.27 com/tutego/insel/ui/swing/JScrollBarDemo.java
    package com.tutego.insel.ui.swing;

    import java.awt.*;
    import java.awt.event.*;
    import javax.swing.*;

    public class JScrollBarDemo
    {
      public static void main( String[] args )
      {
        JFrame f = new JFrame();
        f.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
        f.setLayout( new GridLayout(2, 1) );

        final JScrollBar sb = new JScrollBar( Adjustable.HORIZONTAL, 50, 10, 0,
                                              100 + 10 );
        final JTextField tf = new JTextField( "" + sb.getValue(), 20 );

        f.add ( tf );
        f.add ( sb );

        tf.addActionListener( new ActionListener() {
          public void actionPerformed( ActionEvent e ) {
            sb.setValue( Integer.parseInt(tf.getText()) );
          }
        } );

        sb.addAdjustmentListener( new AdjustmentListener() {
          public void adjustmentValueChanged( AdjustmentEvent e ) {
            tf.setText( "" + sb.getValue() );
          }
        } );

        f.pack();
        f.setVisible( true );
      }
    }
#### Die JScrollBar-API Die wichtigen Properties einer JScrollBar sind: Orientierung (horizontal, vertikal), Minimalwert, Maximalwert, aktueller Wert. Für die Orientierung sind zwei Konstanten in der Schnittstelle java.awt.Adjustable deklariert; die JScrollBar implementiert HORIZONTAL und VERTICAL. Ein Rollbalken kann immer nur eines von beiden sein. Das Minimum steht standardmäßig auf 0 und das Maximum auf 100.
    class javax.swing.JScrollBar
    extends JComponent
    implements Adjustable, Accessible
JScrollBar() Erzeugt einen vertikalen Rollbalken. JScrollBar( int orientation ) Erzeugt einen neuen Rollbalken mit der angegebenen Richtung. JScrollBar( int orientation, int value, int extent, int minimum, int maximum ) Erzeugt einen neuen Rollbalken mit der angegebenen Richtung. Zudem werden der Initialwert, die Größe, das Minimum und das Maximum gesetzt. Die Eigenschaften minimum und maximum geben die Grenzen des Werts an, die der Rollbalken annehmen kann. Geben wir maximum kleiner oder gleich minimum an, dann wird maximum = minimum + 1 gesetzt. Der weitere zusätzliche Parameter value bestimmt den Startwert des Rollbalkens. value darf nicht kleiner als minimum sein. Ist er es dennoch, so wird value = minimum gesetzt. Der value steht bei beiden auf 0, das heißt, bei einem vertikalen Rollbalken steht der Knopf unten und bei einem horizontalen Rollbalken links. Mit extent können wir die Größe des Schiebers bestimmen. Daneben hat extent aber noch eine andere Funktion, denn es bestimmt zusätzlich die Größe der Veränderung, wenn der Schieber bewegt wird – mit anderen Worten: die Schrittweite. Da die Schieber unter Windows nicht proportional zur Größe des darzustellenden Inhalts sind, lässt sich hier einfach ein proportionaler Rollbalken implementieren. So können wir leicht von der Größe des Knopfs auf den Umfang schließen. Der Wert von extent muss kleiner sein als der Wertebereich des Rollbalkens (extent <= maximum – minimum). Verstößt visible gegen die einfache Gleichung, wird visible = maximum – minimum gewählt. Erreicht extent einen Wert kleiner 1, wird dieser zurück auf 1 gesetzt. Für die beiden anderen Konstruktoren ist der Wert von extent auf 10 festgelegt. int getOrientation() Liefert die Orientierung des Rollbalkens. void setOrientation( int orientation ) Setzt die Orientierung neu. int getMaximum(), getMinimum() Liefert das Maximum beziehungsweise Minimum des Rollbalkens. void setMaximum( int newMaximum ), void setMinimum( int newMinimum ) Setzt den maximalen beziehungsweise minimalen anzunehmenden Wert des Rollbalkens. int getValue() Liefert den aktuellen Wert des Rollbalkens. void setValue( int newValue ) Setzt einen neuen Wert. int getBlockIncrement() Liefert die Blockschrittweite vom Rollbalken. Diese definiert beim Druck auf die Bildlaufleiste (nicht Pfeile), um wie viele Zeilen weitergeblättert wird. Im Allgemeinen führt ein Druck auf die Bild-runter-Taste zu demselben Effekt. void setBlockIncrement( int v ) Setzt die Blockschrittweite für den Rollbalken. int getUnitIncrement() Liefert die Schrittweite des Rollbalkens, die bestimmt, wie weit die aktuelle Seite weitergeblättert wird, wenn die Pfeile des Rollbalkens angewählt werden. Die Operation ist mit einem Druck auf die Hoch/Runter-Pfeiltasten vergleichbar. void setUnitIncrement( int v ) Setzt die Schrittweite neu. int getVisibleAmount() Liefert die Größe des sichtbaren Bereichs. void setVisibleAmount( int extent ) Setzt eine neue Größe des sichtbaren Bereichs. void setValues( int newValue, int newExtent, int newMin, int newMax ) Setzt die vier Eigenschaften des Rollbalkens. void addAdjustmentListener( AdjustmentListener l ) Fügt einen AdjustmentListener hinzu, der auf AdjustmentEvents hört. void removeAdjustmentListener( AdjustmentListener l ) Entfernt den AdjustmentListener wieder. #### Der AdjustmentListener, der auf Änderungen hört Objekte, die an Änderungen interessiert sind, müssen die Schnittstelle AdjustmentListener implementieren und sich beim jeweiligen Rollbalken registrieren. AdjustmentListener spielen bis auf JScrollBar in Swing keine weitere Rolle; unter AWT haben sie bei der java.awt.Scrollbar die Bewegungen gemeldet.
    interface java.awt.event.AdjustmentListener
    extends EventListener
void adjustmentValueChanged( AdjustmentEvent e ) Wird vom Rollbalken aufgerufen, wenn das Objekt seinen Wert verändert. Das AdjustmentEvent verrät uns, welches Ereignis zu der Veränderung geführt hat.
    class java.awt.AdjustmentEvent
    extends AWTEvent
Adjustable getAdjustable() Gibt das Adjustable-Objekt zurück, bei dem das Event auftrat. int getValue() Gibt den Wert im Adjustment-Objekt zurück. int getAdjustmentType() Gibt eine der Konstanten UNIT_INCREMENT, UNIT_DECREMENT, BLOCK_INCREMENT, BLOCK_ DECREMENT oder TRACK zurück, die den Typ des Ereignisses beschreiben. Wir beschreiben im folgenden Programmlisting einen AdjustmentListener, der alle möglichen Informationen über die Bewegung des Rollbalkens protokolliert. Listing 15.28 com/tutego/insel/ui/swing/AllAdjustmentListener.java, adjustmentValueChanged()
    @Override public void adjustmentValueChanged( AdjustmentEvent e )
    {
        System.out.println( e.getAdjustable().getOrientation() ==
                                                               Adjustable.HORIZONTAL ?
                            "Adjustable.HORIZONTAL" : "Adjustable.VERTICAL" );

      switch ( e.getAdjustmentType() )
      {
        case AdjustmentEvent.UNIT_INCREMENT:
          System.out.println( "AdjustmentEvent.UNIT_INCREMENT" );
          break;
        case AdjustmentEvent.UNIT_DECREMENT:
          System.out.println( "AdjustmentEvent.UNIT_DECREMENT" );
          break;
        case AdjustmentEvent.BLOCK_DECREMENT:
          System.out.println( "AdjustmentEvent.BLOCK_DECREMENT" );
          break;
        case AdjustmentEvent.BLOCK_INCREMENT:
          System.out.println( "AdjustmentEvent.BLOCK_INCREMENT" );
          break;
        case AdjustmentEvent.TRACK:
          System.out.println( "AdjustmentEvent.TRACK" );
          break;
      }
      System.out.println( " value: " + e.getValue() );
    }
### Ihr Kommentar Wie hat Ihnen das <openbook> gefallen? Wir freuen uns immer über Ihre freundlichen und kritischen Rückmeldungen.
Name |
E-Mail |
Ihr Kommentar |
<< zurück | <top> | vor >>

Copyright © Galileo Press 2008
Für Ihren privaten Gebrauch dürfen Sie die Online-Version natürlich ausdrucken. Ansonsten unterliegt das <openbook> denselben Bestimmungen, wie die gebundene Ausgabe: Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung, Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.

[Galileo Computing]
Galileo Press, Rheinwerkallee 4, 53227 Bonn, Tel.: 0228.42150.0, Fax 0228.42150.77, info@galileo-press.de