SWT Einführung. MM Programmierung

SWT Einführung

Überblick Überblick über Java GUI SWT installieren Mit Widgets arbeiten SWT Layouts Event Handling Beispiel Anwendung

Überblick über Java GUI AWT Abstract Windowing Toolkit Als Teil von JDK 1.0 veröffentlicht (ab 1995) Heavyweight GUI Component Java erzeugt eine Peer Komponente des Betriebssystem und der Peer zeichnet sich selbst Prinzip des Kleinsten Gemeinsamen Nenners es können nur die GUI Komponenten umgesetzt werden, die auf allen Plattformen verfügbar sind => sonst geht die Plattformunabhängigkeit verloren Prinzipiell vernünftiger Ansatz, aber nicht leistungsfähig genug

Überblick über Java GUI (cont.) Swing (JFC - Java Foundation Class) Als Teil des JDK 1.1 veröffentlicht (ab 1998) Leightweight GUI Components keine Peer-Komponente, sondern Java zeichnet die Widgets selbst Leistungsfähiges Toolkit mit erweiterter MVC-Architektur und ausgezeichneter 2D Bibliothek Gute Portabilität. Allerdings Verzicht auf Einbettung in das Look and Feel der Zielplattform, bei gleichzeitigen Performanzeinbußen gegenüber den nativen GUI Komponenten. Starke Verbesserungen von Swing in den Versionen 1.4.2 und 1.5 des SDKs Trotzdem: kaum kommerzielle Relevanz für Swing

Überblick über Java GUI (cont.) SWT (Standard Widgest Toolkit) GUI Toolkit von IBM (ab 2001) Entwickelt als Teil der Eclipse IDE Das Beste beider Welten : Nutzung der nativen Widget (sowie verfügbar) und zusätzliche Implementationen als pure Java Widgets. Aussehen und Verhalten der nativen Widget wird übernommen. Durch die starke Anbindung an das Betriebssystem, muss SWT auf die jeweilige Plattform portiert werden. SWT ist für alle wesentliche Plattformen verfügbar. Damit sind SWT Applicationen portabel, solange keine systemspezifischen Funktionen genutzt werden (etwa OLE/ActiveX auf Windows Systemen)

SWT installieren Für die Comilierung und Ausführung von SWT Applikation benötigt man SWT jars (normalerweise nur swt.jar) Die nativen Laufzeitbibliotheken (z.b. swt-win32-3064.dll) Download und Installation SWT ist Teil von Eclipse 3.0 swt.jar und swt-win32-3064.dll

SWT installieren Der Java Klassenpfad (classpath) muss angepasst werden C:\SWT muss eingefügt werden). Damit findet Java das jar- Archiv swt.jar. Zusätzlich muss der Pfad auf die native Bibliothek in der Variablen java.library.path gesetzt werden Geben Sie den aktuellen Pfad aus System.out.println(System.getProperty("java.library.path")); Kopieren Sie die swt-win32-3064.dll in eines der Verzeichnisse - oder - Geben Sie den Pfad beim Starten von Java an java -Djava.library.path=C:\SWT classname

Eclipse SWT Startkonfiguration Name der Konfiguration Kommandozeilenargumente der VM (virtuellen Maschine) Arguments Tab -Djava.library.path=C:\users\milde\Programmierung\eclipse3\eclipse-SDK-3.0.2-win32\eclipse\plugins\org.eclipse.swt.win32_3.0.2\os\win32\x86

Eine Shell erzeugen und öffnen 1 import org.eclipse.swt.widgets.*; 2 import org.eclipse.swt.widgets.shell; 3 4 public class HelloWorld { 5 public static void main(string[] args) { 6 Display display = new Display(); 7 Shell shell = new Shell(display); 8 shell.settext("hello World"); 9 shell.setsize(250, 100); 10 11 shell.open(); 12 13 while (!shell.isdisposed()) { 14 if (!display.readanddispatch()) { 15 display.sleep(); 16 } 17 } 18 display.dispose(); 19 } 20 }

Eine Shell erzeugen und öffnen Das Shell Objekt ist vergleichbar mit dem JFrame in Swing Der oberste Container, welcher weitere Widgets aufnehmen kann Im Gegensatz zu Swing Muss ein Display Objekt erzeugt werden, welches das zugrundeliegende Windows System repräsentiert Wird jedem SWT Widget das jeweilige Elternwidget im Konstruktor übergeben Muss in die Shell Events in einer while Schleife abgefangen werden, andernfalls schliesst sich die Shell sofort Müssen die allokierten Ressourcen wieder freigegeben werden

Hilfsklasse: SWTUtil.java 1 import org.eclipse.swt.widgets.*; 2 3 public class SWTUtil { 4 private static Display display = new Display(); 5 6 public static Shell getshell() { 7 Shell shell = new Shell(display); 8 return shell; 9 } 10 11 public static void openshell(shell shell) { 12 shell.open(); 13 14 // This loop keeps the shell open constantly listening for events 15 while (!shell.isdisposed()) { 16 if (!display.readanddispatch()) { 17 display.sleep(); 18 } 19 } 20 display.dispose(); 21 } 22 } Erzeugt Display als Klassenvariable Liefert neue Shell für das aktuelle Display Öffnet Shell und dispatched Events

Anwendung von SWTUtil.java 1 import org.eclipse.swt.widgets.*; 2 3 public class HelloWorld { 4 public static void main(string[] args) { 5 Shell shell = SWTUtil.getShell(); 6 shell.settext("still Hello World"); 7 shell.setsize(250, 100); 8 9 SWTUtil.openShell(shell); 10 } 11 }

SWT Widgets erzeugen Ein SWT wird erzeugt indem man Ein Elternwidget (parent) angibt Den Stil (Style) des Widgets festlegt Das Elternwidget ist der Container, der das erzeugte Widget enthält. Der Stil wird durch eine Konstante der Klasse SWT beschrieben (SWT.PUSH, SWT.BORDER, SWT.LEFT etc.)

SWT Widgets erzeugen (cont) Die jeweiligen auf ein Widget anwendbaren Stilbits sind im Javadoc der Klasse beschrieben. Die Stilbits können durch bitweise Oderverknüpfung ( ) kombiniert werden SWT.MULTI SWT.V_SCROLL SWT.H_SCROLL SWT.BORDER erzeugen eine mehrzeiliges Textfeld mit Scrollbars und Rahmen SWT.NONE ist ein unspezifischer Standardstil. Stilbits sind lediglich Hinweise (hints). Steht eine Entsprechung auf der Zielplattform nicht zur Verfügung, hat man Pech.

SWT Widgets: Label 1 import org.eclipse.swt.swt; 2 import org.eclipse.swt.layout.gridlayout; 3 import org.eclipse.swt.widgets.*; 4 5 public class LabelWorld { 6 public static void main(string[] args) { 7 Shell shell = SWTUtil.getShell(); 8 9 shell.settext("label World"); 10 shell.setlayout(new GridLayout()); // layouts are 11 explained later 12 // Create labels 13 new Label(shell, SWT.NONE).setText("Regular label"); 14 new Label(shell, SWT.SEPARATOR); 15 new Label(shell, SWT.SEPARATOR SWT.HORIZONTAL); 16 17 // pack and show 18 shell.pack(); 19 SWTUtil.openShell(shell); 20 } 21 } Nichtselektierbarer, nicht editierbarer Text SWT.VERTICAL oder SWT.HORIZONTAL können in Verbindung mit SWT.SEPARATOR verwendet werden, um einen vertikalen/horizontalen Trennstrich zu erzeugen

SWT Widgets: Button 1 import org.eclipse.swt.swt; 2 import org.eclipse.swt.layout.gridlayout; 3 import org.eclipse.swt.widgets.*; 4 5 public class ButtonWorld { 6 public static void main(string[] args) { 7 Shell shell = SWTUtil.getShell(); 8 shell.settext("button World"); 9 shell.setlayout(new GridLayout(2, true)); // layouts are 10 explained later 11 new Button(shell, SWT.PUSH SWT.FLAT).setText("Flat Push Button"); 12 new Button(shell, SWT.CHECK).setText("Check Button"); 13 new Button(shell, SWT.TOGGLE).setText("Toggle Button"); 14 new Button(shell, SWT.RADIO).setText("Radio Button"); 15 16 // pack and show 17 shell.pack(); 18 SWTUtil.openShell(shell); 19 } 20 } Unterschiedliche Formen von Buttons: aktive Elemente, die angeklickt werden können: Push buttons Check buttons Toggle buttons Radio buttons

SWT Widgets: Text 1 public class TextWorld { 2 public static void main(string[] args) { 3 Shell shell = SWTUtil.getShell(); 4 shell.settext("text World"); 5 shell.setlayout(new GridLayout()); // layouts are explained later 6 7 new Text(shell, SWT.NONE).setText("Missing something..."); 8 new Text(shell, SWT.BORDER); // regular textfield 9 new Text(shell, SWT.PASSWORD SWT.BORDER).setText("password"); 10 new Text(shell, SWT.READ_ONLY SWT.BORDER).setText("Can't type inside"); 11 new Text(shell, SWT.MULTI SWT.V_SCROLL SWT.WRAP 12 SWT.BORDER).setText("\n\n\n"); 13 14 // pack and show 15 shell.pack(); 16 SWTUtil.openShell(shell); 17 } 18 } Unterschiedliche Textfelder, die durch Stilbits parameterisiert werden können

SWT Widgets: List 1 import org.eclipse.swt.swt; 2 import org.eclipse.swt.layout.gridlayout; 3 import org.eclipse.swt.widgets.*; 4 5 public class ListWorld { 6 public static void main(string[] args) { 7 Shell shell = SWTUtil.getShell(); 8 shell.settext("list World"); 9 shell.setlayout(new GridLayout(2, true)); // layouts are 10 explained later 11 String[] items = "One Two Three Four Five Six".split(" "); 12 List one = new List(shell, SWT.SINGLE SWT.BORDER); 13 one.setitems(items); 14 one.select(2); 15 List two = new List(shell, SWT.MULTI SWT.BORDER); 16 two.setitems(items); 17 two.setselection(items); 18 19 // pack and show 20 shell.pack(); 21 SWTUtil.openShell(shell); 22 } 23 } Auswahllisten, aus denen ein oder mehrere Elemente ausgewählt werden können.

SWT Widgets: Combo 1 import org.eclipse.swt.swt; 2 import org.eclipse.swt.layout.gridlayout; Combolisten 3 import org.eclipse.swt.widgets.*; 4 kombinieren Text- 5 public class ComboWorld { 6 public static void main(string[] args) { und Listwidget 7 Shell shell = SWTUtil.getShell(); 8 shell.settext("combo World"); Liste + Text Dropdown Liste 12 Combo one = new Combo(shell, SWT.DROP_DOWN); 13 one.setitems(items); 14 Combo two = new Combo(shell, SWT.DROP_DOWN SWT.READ_ONLY); 15 two.setitems(items); 16 Combo three = new Combo(shell, SWT.SIMPLE); 17 three.setitems(items); 18 19 // pack and show 20 shell.pack(); 21 SWTUtil.openShell(shell); 22 } 23 } 9 shell.setlayout(new GridLayout(3, true)); // layouts are 10 explained later 11 String[] items = "One Two Three Four Five Six".split(" ");

SWT Widgets: ToolBar 1 ToolBar toolbar = new ToolBar(shell, SWT.HORIZONTAL); 2 3 ToolItem open = new ToolItem(toolbar, SWT.PUSH); 4 open.settext("open"); 5 ToolItem close = new ToolItem(toolbar, SWT.PUSH); 6 close.settext("close"); 7 close.settooltiptext("press here for closing something"); 8 9 ToolItem s1 = new ToolItem(toolbar, SWT.SEPARATOR); 10 11 ToolItem cut = new ToolItem(toolbar, SWT.PUSH); 12 Image cutimage = new Image(shell.getDisplay(), 13 "c:\\users\\milde\\schere.gif"); 14 cut.setimage(cutimage); 15 cut.settext("cut"); 16 17 ToolItem copy = new ToolItem(toolbar, SWT.PUSH); 18 copy.settext("copy"); 19 ToolItem paste = new ToolItem(toolbar, SWT.PUSH); 20 paste.settext("paste"); Mit ToolBar und ToolItem definiert man horizontale oder vertikale Buttonleisten Diese können optional ein Image als Icon aufnehmen Das Stilbit SWT.SEPARATOR definiert eine Trennlinie zwischen den Buttons Aktionen werden über die Registrierung eines entsprechenden Listeners ausgelöst Tooltip des Close Buttons

SWT Widgets: Menu Menüs organisieren den Zugriff auf Systemfunktionen in einer hierarchischen Form Menüs werden in SWT durch zwei Objekte realisiert Menu dient der Organisition von UI Objekten zu einem Menü MenuItem selektierbares UI Objekt, dass einen Menüeintrag repräsentiert Menüs sind nutzbar als Toplevelmenüs In Menükaskaden Popupmenüs DropDown Menüs in Eclipse Views

SWT Widgets: Menu 1 2a 2b 6 Aufbau eines Toplevelmenüs in 4 Schritten (Folgefolie): Definition der Menuleiste Jeweils nur eine Menüleiste vom Type SWT.BAR Menüleiste muss für die shell gesetzt werden 5a Definition der Einträge in der Menüleiste Menuitems werden als SWT.CASCADE definiert 5b Ankoppelung der DropDown Menüs Untermenüs sind vom Type SWT.DROP_DOWN Definition der Einträge im jeweiligen DropDown Menü Eigentliche Einträge sind vom Typ SWT.PUSH_DOWN

SWT Widgets: Menu 1 Menu menu = new Menu(shell, SWT.BAR); shell.setmenubar(menu); 2a 5a MenuItem mi = new MenuItem(menu, SWT.CASCADE); 6 MenuItem me = new MenuItem(menui, SWT.PUSH); Menu menui = new Menu(shell, SWT.DROP_DOWN); mi.setmenu(menui); 2b 5b

SWT Widgets: Menu 1 Shell shell = SWTUtil.getShell(); 2 shell.settext("menu World"); 3 shell.setlayout(new FillLayout()); 4 5 String[] menubarentries = "File,Edit,Source,Help".split(","); 6 String[] menuentries = { "Open, Save, Close, --, Exit", 7 "Undo, Redo, --, Cut, Copy, Paste", "Build, Clean", 8 "Help, --, About" }; 9 10 Menu menu = new Menu(shell, SWT.BAR); 11 shell.setmenubar(menu); 12 13 for (int i = 0; i < menubarentries.length; i++) { 14 // Eintrag im Hauptmenu 15 MenuItem mi = new MenuItem(menu, SWT.CASCADE); 16 mi.settext(menubarentries[i].trim()); 17 18 // Menu, das an den Eintrag gebunden ist 19 Menu menui = new Menu(shell, SWT.DROP_DOWN); 20 mi.setmenu(menui); 21 22 createmenuentries(menui, menuentries[i]); // see next slide 23 } 24 25 Text text = new Text(shell, SWT.MULTI SWT.BORDER SWT.V_SCROLL SWT.H_SCROLL); 26 27 shell.setsize(300, 120); // setsize and show 28 SWTUtil.openShell(shell); Aufbau der Menüstruktur Zunächst die Menüleiste Einfügen der eigentlichen DropDown Menüs (Folgefolie!) Zum Schluss noch ein Textfeld

SWT Widgets: Menu 1 private void createmenuentries(menu mi, String string) { 2 String[] entries = string.split(","); 3 for (int i = 0; i < entries.length; i++) { 4 if (entries[i].trim().equalsignorecase("--")) { 5 MenuItem me = new MenuItem(mi, SWT.SEPARATOR); 6 } else { 7 MenuItem me = new MenuItem(mi, SWT.PUSH); 8 me.settext(entries[i].trim()); 9 } 10 } 11 } Aufbau der DropDown Menüs aus einer Liste von Strings Falls der String den Wert -- annimmt, soll ein Separator eingefügt werden Sonst wird der Menüeintrag als Pushbutton erzeugt Durch Tabulator im String können Shortcuts definiert werden: Open \t Ctrl+o

SWT Widgets: Menu (Popup) 1 Shell shell = SWTUtil.getShell(); 2 shell.settext("popupmenuworld"); 3 shell.setlayout(new FillLayout()); 4 5 Text text = new Text(shell, SWT.NONE); 6 7 SelectionListener li = new SelectionListener() { 8 public void widgetselected(selectionevent e) { 9 int dataval = Integer.parseInt((String) e.widget.getdata()); 10 System.out.println("Knopf " + dataval + " gedrückt"); 11 } 12 13 public void widgetdefaultselected(selectionevent e) {} 14 }; 15 16 Menu popupmenu = generatepopupmenu(shell, li); // next slide 17 text.setmenu(popupmenu); 18 19 shell.setsize(400, 300); 20 SWTUtil.openShell(shell); Popup Menüs werden an spezifische Widgets (hier an ein Text Widget) gebunden und können kontextsensitiv aufgebaut werden (Folgefolie) Standardmäßig werden sie über die Klick der rechten Maustaste aktiviert (WinXX)

SWT Widgets: Menu (Popup) 1 private Menu generatepopupmenu(shell shell, 2 SelectionListener li) { 3 4 Menu popupmenu = new Menu(shell, SWT.POP_UP); 5 6 for (int i = 0; i < 10; i++) { 7 MenuItem mi = new MenuItem(popupMenu, 8 (i % 4 == 3)? SWT.SEPARATOR: SWT.PUSH); 9 mi.settext("funktion " + i); 10 mi.setdata(i + ""); 11 mi.addselectionlistener(li); 12 } 13 return popupmenu; 14 } Erzeugt das Popup Menu (SWT.POP_UP) Einträge werden als MenuItems hinzugefügt Zusätzlich werden jeweils Daten an die Einträge gebunden, die in der späteren Auswertung des SelectionListeners ausgewertet werden Der SelectionListener wird an den Menüeintrag gebunden

SWT Widgets: Group 1 import org.eclipse.swt.swt; 2 import org.eclipse.swt.layout.gridlayout; 3 import org.eclipse.swt.widgets.*; 4 5 public class GroupWorld { 6 public static void main(string[] args) { 7 Shell shell = SWTUtil.getShell(); 8 shell.settext("group World"); 9 shell.setlayout(new GridLayout()); // layouts are 10 explained later 11 12 Group buttongroup = new Group(shell, SWT.SHADOW_OUT); 13 buttongroup.settext("six buttons"); 14 buttongroup.setlayout(new GridLayout(3, true)); 15 for(int i = 0; i < 6; i++) { 16 new Button(buttonGroup, SWT.RADIO).setText("Bottle " + (i + 1)); 17 } 18 19 // pack and show 20 shell.pack(); 21 SWTUtil.openShell(shell); 22 } 23 } Gruppiert Widgets visuell und logisch Vergleichbar mit JPanel in Swing

SWT Widgets: Browser 1 import org.eclipse.swt.swt; 2 import org.eclipse.swt.browser.browser; 3 import org.eclipse.swt.layout.filllayout; 4 import org.eclipse.swt.widgets.shell; 5 6 public class BrowserWorld { 7 public static void main(string[] args) { 8 Shell shell = SWTUtil.getShell(); 9 shell.settext("browser World"); 10 shell.setlayout(new FillLayout()); 11 12 Browser browser = new Browser(shell, SWT.BORDER); 13 browser.setsize(900, 500); 14 browser.seturl("http://www.eclipse.org/swt/"); 15 16 // pack and show 17 shell.pack(); 18 SWTUtil.openShell(shell); 19 } 20 } Öffnet ein komplettes Browser Widget Basiert auf dem jeweiligen Standardbrowser des Systems.

SWT Widgets: Browser

Dialogfenster

SWT Widgets: Dialogfenster Dialogfenster stellen grundlegende Möglichkeiten der Benutzerinteraktion zur Verfügung Auswahl von Ressourcen (Vor)-Filterung der Auswahl nach spezifizierbaren Parametern Einfache Konfiguration (Icon, Knöpfe, Text, Message etc.) Einfache Verarbeitung der Rückgabewerte Modalität kann festgelegt werden Look and Feel der Zielplattform wird aufgegriffen

Vordefinierte Dialogfenster ColorDialog Dialog zur Auswahl eines Farbwertes. FontDialog Dialog zur Auswahl eines Textfonts. FileDialog Dialog zur Auswahl einer Datei (speichern oder laden). DirectoryDialog Dialog zur Auswahl eines Verzeichnises. MessageBox Dialog zur Ausgabe von Informationen und Anforderungen von Benutzerreaktionen.

SWT Widgets: ColorDialog 1 Shell shell = SWTUtil.getShell(); 2 3 ColorDialog cd = new ColorDialog(shell); 4 cd.setrgb(new RGB(100,200,40)); 5 RGB rgb = cd.open(); 6 7 if (rgb!= null) { 8 System.out.println(rgb); 9 } ColorDialog erlaubt die Auswahl eines Farbwertes Der initiale Farbwert kann gesetzt werden Es wird ein RGB Farbwert zurückgeliefert Wurde kein Farbwert ausgewählt, liefert der Dialog null

SWT Widgets: FontDialog 1 Shell shell = SWTUtil.getShell(); 2 shell.settext("fontdialogworld"); 3 shell.setlayout(new RowLayout(SWT.VERTICAL)); 4 5 Button button = new Button(shell, SWT.PUSH); 6 button.settext("font"); 7 8 int style = SWT.BORDER SWT.V_SCROLL SWT.H_SCROLL; 9 final Text text = new Text(shell, style); 10 text.setlayoutdata(new RowData(400, 200)); 11 12 final FontDialog fd = new FontDialog(shell); 13 14 button.addselectionlistener(new SelectionListener() { 15 public void widgetselected(selectionevent e) { 16 if (fd.open()!= null) { 17 FontData[] list = fd.getfontlist(); 18 Font font = new Font(SWTUtil.getDisplay(), list); 19 text.setfont(font); 20 } 21 } 22 23 public void widgetdefaultselected(selectionevent e) {} 24 }); 25 26 shell.pack(); 27 SWTUtil.openShell(shell); Font gesetzt Die Fontauswahl erfolgt im Eventlistener des Buttons Wurde ein Font ausgewählt, wird ein (nicht allokiertes) FontData Objekt zurückgeliefert Dieses erlaubt die Erzeugung des zu setzenden Fonts

SWT Widgets: FileDialog 1 Shell shell = SWTUtil.getShell(); 2 shell.settext("filedialogworld"); 3 4 shell.setlayout(new RowLayout(SWT.VERTICAL)); 5 6 Button button = new Button(shell, SWT.PUSH); 7 button.settext("file"); 8 9 int style = SWT.BORDER SWT.V_SCROLL SWT.H_SCROLL; 10 final Text text = new Text(shell, style); 11 text.setlayoutdata(new RowData(500, 200)); 12 13 final FileDialog filechooser = 14 new FileDialog(shell, SWT.OPEN SWT.MULTI); 15 filechooser.settext("open movie files"); 16 filechooser.setfilterextensions( 17 new String[] { "*.avi; *.mov; *.mpg", "*.*" }); 18 filechooser.setfilternames( 19 new String[] {"movie files (*.avi; *.mov; *.mpg)", "all (*.*)" }); 20 21 addbuttonlistener(button, text, filechooser); // next slide 22 23 shell.pack(); 24 SWTUtil.openShell(shell); FileDialog öffnet mehrere Dateien Mit den Extensionen avi, mov, mpg Verarbeitung im Listeners des Buttons (Folgefolie)

SWT Widgets: FileDialog 1 private void addbuttonlistener(button button, 2 final Text text, 3 final FileDialog filechooser) { 4 5 button.addselectionlistener(new SelectionListener() { 6 public void widgetselected(selectionevent e) { 7 String filename = filechooser.open(); 8 9 if (filename!= null) { 10 11 text.settext(""); 12 String path = filechooser.getfilterpath(); 13 String[] names = filechooser.getfilenames(); 14 for (int i = 0; i < names.length; i++) { 15 String string = names[i]; 16 text.append(path + \\ + string + "\n"); 17 } 18 19 } 20 } 21 22 public void widgetdefaultselected(selectionevent e) {} 23 }); 24 } Öffnen des FileDialog Falls der Rückgabewert nicht gleich null Wird der Text zurückgesetzt Das Verzeichnis geholt Die ausgewählten Dateinamen geholt Und die vollständigen Dateinamen (absoluter Pfad) in der Textkomponente angezeigt

SWT Widgets: DirectoryDialog 1 Shell shell = SWTUtil.getShell(); 2 shell.settext("directorydialogworld"); 3 shell.setlayout(new RowLayout(SWT.VERTICAL)); 4 5 Button button = new Button(shell, SWT.PUSH); 6 button.settext("select dir"); 7 8 int style = SWT.BORDER SWT.V_SCROLL SWT.H_SCROLL; 9 final List list = new List(shell, style); 10 list.setlayoutdata(new RowData(300, 200)); 11 12 final DirectoryDialog dd = new DirectoryDialog(shell); 13 dd.settext("select a directory"); 14 dd.setmessage("choose a directory to list"); 15 16 button.addselectionlistener(new SelectionListener() { 17 public void widgetselected(selectionevent e) { 18 if (dd.open()!= null) { 19 File directory = new File(dd.getFilterPath()); 20 list.setitems(directory.list()); 21 } 22 } 23 24 public void widgetdefaultselected(selectionevent e) {} 25 }); 26 27 shell.pack(); 28 SWTUtil.openShell(shell); Der DirectoryDialog wählt ein Verzeichnis aus Die Dateien werden im List aufgeführt

SWT Widgets: MessageBox Die MessageBox gibt Informations- oder Warnmeldungen an den Benutzer aus SWT unterscheidet 5 MessageBox Typen (Stilbits) SWT.ICON_ERROR SWT.ICON_INFORMATION SWT.ICON_QUESTION SWT.ICON_WARNING SWT.ICON_WORKING Trotz der Namensgebung (ICON_*) muss nicht notwendigerweise ein Icon in der MessageBox erscheinen

SWT Widgets: MessageBox SWT.ICON_ERROR SWT.ICON_WARNING SWT.ICON_ERROR SWT.ICON_WORKING SWT.ICON_QUESTION SWT.YES SWT.NO

SWT Widgets: MessageBox Buttons In einer MessageBox können unterschiedliche Buttonkombinationen verwendet werden SWT.OK SWT.OK SWT.CANCEL SWT.YES SWT.NO SWT.YES SWT.NO SWT.CANCEL SWT.ABORT SWT.RETRY SWT.ABORT SWT.RETRY SWT.IGNORE 1 2 3 4 5 6

SWT Widgets: Kombination von Buttons 1 4 2 5 3 6

SWT Widgets: MessageBox 1 public static void main(string[] args) { 2 Shell shell = SWTUtil.getShell(); 3 shell.settext("messageboxworld"); 4 5 int style = SWT.ICON_ERROR; 6 generatemessagebox(shell, style).open(); 7 8 style = SWT.ICON_INFORMATION; 9 generatemessagebox(shell, style).open(); 10 11 style = SWT.ICON_QUESTION SWT.YES SWT.NO; 12 generatemessagebox(shell, style).open(); 13 14 style = SWT.ICON_WARNING; 15 generatemessagebox(shell, style).open(); 16 17 style = SWT.ICON_WORKING; 18 generatemessagebox(shell, style).open(); 19 } 20 21 private static MessageBox generatemessagebox(shell shell, 22 int style) { 23 MessageBox mb = new MessageBox(shell, style); 24 mb.setmessage("nachricht der MessageBox"); 25 mb.settext("kopfzeile der MessageBox"); 26 return mb; 27 } Aussehen und Funktion einer MessageBox wird bestimmt durch die Stylebits für Typ und Buttonkombination Nachricht und Kopfzeile der MessageBox werden separat gesetzt

SWT Widgets: MessageBox 1 Shell shell = SWTUtil.getShell(); 2 shell.settext("messageboxworld"); 3 4 int style = SWT.ICON_QUESTION 5 SWT.YES SWT.NO SWT.CANCEL; 6 int result = generatemessagebox(shell, style).open(); 7 8 switch (result) { 9 case SWT.YES: 10 System.out.println("yes pressed"); 11 break; 12 case SWT.NO: 13 System.out.println("no pressed"); 14 break; 15 case SWT.CANCEL: 16 System.out.println("cancel pressed"); 17 break; 18 } Rückgabewerte einer Messagebox sind die vordefinierten Standardwerte der angezeigten Knöpfe Die Verarbeitung kann über eine entsprechende Entscheidungskaskade erfolgen

Komplexe SWT Widgets

Komplexe SWT Widgets SWT verfügt über eine Reihe komplexere Widgets 1 Tree und TreeItem 2 Table, TableItem und TableColumn 3 TabFolder und TabItem 1 + 2 dienen der Anzeige von hierarchischen, bzw. tabellenartigen Datenstrukturen Der TabFolder ordnet die Sichten einer GUI zu logischen Einheiten

SWT Widgets: Tree 1 Shell shell = SWTUtil.getShell(); 2 shell.settext("treeworld"); 3 shell.setlayout(new FillLayout()); 4 5 Tree tree = new Tree(shell, SWT.V_SCROLL SWT.H_SCROLL); 6 TreeItem root = new TreeItem(tree, SWT.PUSH); 7 root.settext("corpus"); 8 root.setbackground(new Color(SWTUtil.getDisplay(), 200, 200, 200)); 9 10 for (int i = 0; i < TOPLEVEL_NODES; i++) { 11 TreeItem ti = new TreeItem(root, SWT.PUSH); 12 ti.settext("session" + i); 13 for (int j = 0; j < 5; j++) { 14 TreeItem tj = new TreeItem(ti, SWT.PUSH); 15 tj.settext("layer" + j); 16 for (int k = 0; k < 10; k++) { 17 TreeItem tk = new TreeItem(tj, SWT.PUSH); 18 tk.settext("event" + k); 19 } 20 } 21 } 22 23 tree.addselectionlistener(generateselectionlistener()); 24 // see next slide 25 26 shell.setsize(200, 600); 27 SWTUtil.openShell(shell); Der Baum wird initialisiert. Trees sind standardmäßig als Scrollable Widgets implementiert, auch dann, wenn das Stilbit SWT.V/H_SCROLL nicht gesetzt wurde Zunächst wird ein Wurzelknoten eingefügt Dessen Text und Hintergrundfarbe gesetzt Und abschliessend die weiteren Ebenen eingefügt. Durch einen SelectionListener wird auf die Knotenauswahl reagiert (siehe Folgefolie)

SWT Widgets: Tree 1 private static SelectionListener generateselectionlistener() { 2 return 3 new SelectionListener() { 4 public void widgetselected(selectionevent e) { 5 System.out.println(e); 6 } 7 8 public void widgetdefaultselected(selectionevent e) {} 9 }; 10 } Der SelectionListener gibt lediglich den auslösenden Event aus

SWT Widgets: Table 1 Shell shell = SWTUtil.getShell(); 2 shell.settext("tableworld"); 3 4 Table table = new Table(shell, SWT.CHECK SWT.MULTI); 5 table.setheadervisible(true); 6 table.setlinesvisible(true); 7 8 for (int j = 0; j < COLUMNS; j++) { 9 TableColumn tc = new TableColumn(table, SWT.NONE); 10 tc.settext("spalte" + j); 11 } 12 13 for (int i = 0; i < ROWS; i++) { 14 TableItem ti = new TableItem(table, SWT.NULL); 15 for (int j = 0; j < COLUMNS; j++) { 16 ti.settext(j, "(" + i + "," + j + ")"); 17 } 18 } 19 20 for (int k = 0; k < COLUMNS; k++) { 21 TableColumn tc = table.getcolumn(k); 22 tc.pack(); 23 } 24 25 table.addselectionlistener(generateselectionlistener()); 26 // see previous slide 27 table.setsize(500, 300); 28 shell.pack(); 29 SWTUtil.openShell(shell);

Layouts in SWT

SWT Layouts Layouts wurden mit dem AWT eingeführt Erleichtern die Anordnung von Componenten der GUI Erleichtern ein Plattform-übergreifendes GUI-Design SWT bietet 5 Layouts: FillLayout RowLayout StackLayout GridLayout FormLayout Man setzt das Layout eines Composites durch Aufruf der Methode SetLayout() Der Einsatz von Layout ist nicht verpflichtend http://www.eclipse.org/articles/understanding%20layouts/understanding%20layouts.htm

SWT Layouts: FillLayout 1 import org.eclipse.swt.swt; 2 import org.eclipse.swt.layout.filllayout; 3 import org.eclipse.swt.widgets.*; 4 5 public class FillLayoutExample { 6 public static void main(string[] args) { 7 Shell shell = SWTUtil.getShell(); 8 shell.settext("filllayoutexample"); 9 shell.setlayout(new FillLayout(SWT.HORIZONTAL)); 10 11 for(int i = 0; i < 3; i ++) { 12 new Button(shell, 13 (i % 2 == 0)? SWT.RADIO : SWT.PUSH).setText("Button " + i); 14 new Text(shell, SWT.BORDER).setText("same size"); 15 } 16 17 // pack and show 18 shell.pack(); 19 SWTUtil.openShell(shell); 20 } 21 } Die Widgets werden in einer Reihe/Spalte angeordnet SWT.HORIZONTAL SWT.VERTICAL Alle Widgets erhalten die gleiche Größe

SWT Layouts: RowLayout 1 import org.eclipse.swt.swt; 2 import org.eclipse.swt.layout.rowdata; 3 import org.eclipse.swt.layout.rowlayout; 4 import org.eclipse.swt.widgets.*; 5 6 public class RowLayoutExample { 7 public static void main(string[] args) { 8 Shell shell = SWTUtil.getShell(); 9 shell.settext("rowlayoutexample"); 10 shell.setlayout(new RowLayout(SWT.HORIZONTAL)); 11 12 for(int i = 0; i < 3; i ++) { 13 new Button(shell, 14 (i % 2 == 0)? SWT.RADIO : SWT.PUSH).setText("Button " + i); 15 new Text(shell, SWT.BORDER).setLayoutData(new RowData(5, 50)); 16 } 17 18 // pack and show 19 shell.pack(); 20 SWTUtil.openShell(shell); 21 } 22 } Vergleichbar mit FillLayout Widget können unterschiedliche Größe haben Bricht Zeilen um, falls nicht ausreichend Platz vorhanden Mit RowData setzt man die initiale Größe der Widgets resize

SWT Layouts: StackLayout 1 import org.eclipse.swt.swt; 2 import org.eclipse.swt.custom.stacklayout; 3 import org.eclipse.swt.events.*; 4 import org.eclipse.swt.widgets.*; 5 6 public class StackLayoutExample { 7 public static void main(string[] args) { 8 final Shell shell = SWTUtil.getShell(); 9 shell.settext("stacklayoutexample"); 10 shell.setlayout(new StackLayout()); 11 12 final Button button1 = new Button(shell, SWT.PUSH); 13 button1.settext("button One"); 14 final Button button2 = new Button(shell, SWT.PUSH); 15 button2.settext("button Two"); 16 17 class StackLayoutAdapter extends SelectionAdapter { 18 public void widgetselected(selectionevent event) { 19 ((StackLayout)shell.getLayout()).topControl = 20 (event.widget == button1)? button2 : button1; 21 shell.layout(); 22 } 23 } 24 button1.addselectionlistener(new StackLayoutAdapter()); 25 button2.addselectionlistener(new StackLayoutAdapter()); 26 27 ((StackLayout)shell.getLayout()).topControl = button1; 28 shell.pack(); 29 SWTUtil.openShell(shell); 30 } 31 } Vergleichbar mit dem CardLayout von Swing Widgets werden als Stack organisiert Nur das oberste Widget ist sichtbar Das topcontrol Attribut steuert, welches Widget sichtbar ist Nach einer Zuweisung von topcontrol muss das Layout mit layout() neu berechnet werden push

SWT Layouts: GridLayout Leistungsfähiges Layout organisiert die Widgets in einem Raster Resizing des Layouts ist einfach zu parameterisieren GridLayout verfügt über 6 Attribute: int horizontalspacing: horizontaler Abstand in Pixeln int verticalspacing: vertikaler Abstand in Pixeln boolean makecolumnsequalwidth: alle Spalten sind gleich breit int marginwidth: rechter und linker Randabstand in Pixeln int marginheight: oberer und unterer Randabstand in Pixeln int numcolumns: Anzahl der Spalten im Layout Konstruktor: GridLayout(int numcolumns, boolean makecolumnsequalwidth) GridData Objekt erlaubt die genauere Positionierung (viele Attribute) Achtung: GridData Objekte können nicht wiederverwendet werden pro Widget ein zugeordnetes GridData Objekt erzeugen

SWT Layouts: GridLayout 1 import org.eclipse.swt.swt; 2 import org.eclipse.swt.layout.*; 3 import org.eclipse.swt.widgets.*; 4 5 public class GridLayoutExample { 6 public static void main(string[] args) { 7 Shell shell = SWTUtil.getShell(); 8 shell.settext("gridlayoutexample"); 9 shell.setlayout(new GridLayout(2, false)); // 2 columns, not same width 10 11 // Username 12 new Label(shell, SWT.RIGHT).setText("Username:"); 13 Combo cmbusername = new Combo(shell, SWT.DROP_DOWN); 14 cmbusername.setlayoutdata(new GridData(GridData.FILL_HORIZONTAL)); 15 cmbusername.setitems(new String[]{"Howard", "Admin", "Kalman"}); 16 cmbusername.settext("admin"); 17 18 // Password 19 new Label(shell, SWT.RIGHT).setText("Password:"); 20 new Text(shell, SWT.BORDER SWT.PASSWORD). setlayoutdata(new GridData(GridData.FILL_HORIZONTAL)); 21 22 // Login Button 23 Button loginbutton = new Button(shell, SWT.PUSH SWT.FLAT); 24 loginbutton.settext("proceed to your account"); 25 GridData data = new GridData(GridData.FILL_HORIZONTAL); 26 data.horizontalspan = 2; // span 2 columns 27 loginbutton.setlayoutdata(data); 28 29 shell.pack(); 30 SWTUtil.openShell(shell); 31 } 32 } resize Initialisierung des GridLayouts auf 2 Spalten GridData definiert Positionierung des Widgets i.d.f. Werden Widgets horizontal aufgefüllt Der Button nimmt den Raum von 2 Spalten ein

SWT Layouts: FormLayout Komplexestes Layout des SWT Erlaubt maximale Flexibilität Widgets werden in Abhängigkeit voneinander platziert Layout Algorithmus basiert auf der Geradengleichung (y = ax + b) Nachteil gegenüber GridLayout Kein Konzept von Zeilen/Spalten => keine automatische Größenanpassung der Widgets

SWT Layouts: FormLayout Das FormLayout nutzt FormAttachments, die die Position jeder Seite eines Widgets festlegen. Die FormAttachments werden in FormData Objekten abgelegt und als LayoutData des Widgets gespeichert. Das FormAttachment verbindet eine Seite des Widgets entweder mit einer Position des Elternwidgets, oder einem anderen Widget innerhalb des aktuellen Layouts Dies ermöglicht eine enorme Flexibilität im Layout. Weiterhin ist das FormLayout wesentlich unanfälliger für Reihenfolgeänderungen im Rendering. FormData Objekte spezifizieren genauer, wie das Widget im FormLayout positioniert wird. FormData Objekt definiert die Layouteigenschaften aller vier Seiten eines Widgets (Attribute: top, bottom, left, right) FormData Objekt legen die Höhe/Breite eines Widgets fest

SWT Layouts: FormLayout 1 Shell shell = SWTUtil.getShell(); 2 shell.settext("formlayout example"); 3 4 FormLayout layout = new FormLayout(); 5 layout.marginheight = 5; 6 layout.marginwidth = 5; 7 shell.setlayout(layout); 8 9 Button button1 = new Button(shell, SWT.PUSH); 10 button1.settext("b1"); 11 12 FormData formdata = new FormData(); 13 14 formdata.top = new FormAttachment(0, 60); 15 formdata.bottom = new FormAttachment(100, -5); 16 formdata.left = new FormAttachment(20, 0); 17 formdata.right = new FormAttachment(100, -3); 18 19 button1.setlayoutdata(formdata); 20 21 shell.pack(); 22 SWTUtil.openShell(shell); Die Position von Button button1 wird durch das FormData Objekt festgelegt: Von allen Werten werden 5 Pixel marginheight/marginwidth abgezogen Top: obere Kante liegt bei 60 Pixeln absolut Bottom: untere Kante liegt bei 100% der Höhe weniger 5 Pixeln Offset Left: linke Kante liegt bei 20% der Breite Right: rechte Kante liegt bei 100% weniger 3 Pixeln Offset resize

SWT Layouts: FormAttachments FormAttachment (int numerator) this (numerator, 100, 0); FormAttachment (int numerator, int offset) this (numerator, 100, offset); FormAttachment (int numerator, int denominator, int offset) FormAttachment (Control control) this (control, 0, SWT.DEFAULT); FormAttachment (Control control, int offset, int alignment)

SWT Layouts: FormLayout 1 Button lastbutton = new Button(shell, SWT.PUSH); 2 lastbutton.settext("anfang"); 3 FormData fl = new FormData(); 4 fl.left = new FormAttachment(0, 50); 5 fl.top = new FormAttachment(0, 40); 6 lastbutton.setlayoutdata(fl); 7 8 for (int i = 1; i < 10; i++) { 9 Button b = new Button(shell, SWT.PUSH); 10 b.settext("b" + i); 11 12 FormData fd1 = new FormData(); 13 fd1.left = new FormAttachment(lastButton); 14 fd1.top = new FormAttachment(lastButton, 0, SWT.TOP); 15 b.setlayoutdata(fd1); 16 17 lastbutton = b; 18 } FormLayout erlaubt die relative Positionierung der Widgets Zunächst wird der Button lastbutton absolut positioniert (obere linke Ecke an der Position 50,40) Die folgenden Buttons werden dann jeweils an der Position des Vorgängers ausgerichtet Durch die Angabe von SWT.TOP wird sichergestellt, dass die Widgets an der oberen Kante aligniert werden

SWT Layouts: FormLayout 1 Text text = new Text(shell, SWT.BORDER); 2 Label label = new Label(shell, SWT.NONE); 3 label.settext("find what?"); 4 Button findbutton = new Button(shell, SWT.PUSH); 5 findbutton.settext("find next"); 6 Button cancelbutton = new Button(shell, SWT.PUSH); 7 cancelbutton.settext("cancel"); 8 9 FormData ld = new FormData(); 10 ld.left = new FormAttachment(0); 11 ld.top = new FormAttachment(text, 0, SWT.CENTER); 12 label.setlayoutdata(ld); 13 14 FormData td = new FormData(200, SWT.DEFAULT); 15 td.top = new FormAttachment(0); 16 td.left = new FormAttachment(label); 17 td.right = new FormAttachment(findButton); 18 text.setlayoutdata(td); 19 20 FormData fd = new FormData(); 21 fd.right = new FormAttachment(100); 22 fd.top = new FormAttachment(text, 0, SWT.CENTER); 23 findbutton.setlayoutdata(fd); 9-12 1-15 (rechts) 1 Group dg = new Group(shell, SWT.BORDER); 2 FillLayout fill = new FillLayout(SWT.HORIZONTAL); 3 dg.setlayout(fill); 4 dg.settext("direction"); 5 Button upbutton = new Button(dg, SWT.RADIO); 6 upbutton.settext("up"); 7 upbutton.setselection(true); 8 Button downbutton = new Button(dg, SWT.RADIO); 9 downbutton.settext("down"); 10 11 FormData gd = new FormData(100, SWT.DEFAULT); 12 gd.top = new FormAttachment(text); 13 gd.right = new FormAttachment (findbutton); 14 dg.setlayoutdata(gd); 15 dg.pack(); 16 17 FormData cd = new FormData(); 18 cd.top = new FormAttachment(text); 19 cd.right = new FormAttachment(100); 20 cd.left = new FormAttachment(dg); 21 cancelbutton.setlayoutdata(cd); 14-18 20-23 17-21 (rechts)

SWT Event Handling

SWT Event Handling Ansatz vergleichbar mit Swing SWT Widget reagieren auf Events event listening Verarbeitung mittels EventListener Listener ist definiert durch ein Interface Listener kann für eine Anzahl von Events zuständig sein Applikation wählt aus, welche Information relevant ist Einfache Lösung: Verwendung von Adaptern Adapter stellt Basisimplementation zur Verfügung

SWT Event Handling SWT unterscheidet zwischen ungetypten events getypten events Ungetypte Events werden durch das Implementierung des Listener Interfaces verarbeitet (s.a. Liste am Ende!) Getype Events werden durch spezialisierte EventListener verarbeitet

SWT Event Handling: Listener 1 Shell shell = SWTUtil.getShell(); 2 shell.settext("button World"); 3 shell.setlayout(new FillLayout(SWT.VERTICAL)); 4 5 Button button = new Button(shell, SWT.PUSH); 6 button.settext("press me"); 7 8 Listener l = new Listener() { 9 public void handleevent(event event) { 10 Button b = (Button) (event.widget); 11 System.out.println(b.getText()); 12 } 13 }; 14 15 button.addlistener(swt.selection, l); 16 17 shell.pack(); 18 SWTUtil.openShell(shell); Das Listener Interface ist die generische Superklasse aller SWT Listener Sie erfordert die Implementierung der Methode handleevent() Über den Event kann auf das auslösende Widget zugegriffen werden Hier muss ein Typecast vorgenommen werden Registrierung für spezifischen Event

SWT Event Handling: Untyped Listener 1 Shell shell = SWTUtil.getShell(); 2 shell.settext("untypedeventsworld"); 3 shell.setlayout(new FillLayout()); 4 5 Text text = new Text(shell, SWT.BORDER 6 SWT.V_SCROLL SWT.H_SCROLL); 7 MyTextListener listen = new MyTextListener(text); 8 // see next slide 9 text.addlistener(swt.mouseenter, listen); 10 text.addlistener(swt.mouseexit, listen); 11 text.addlistener(swt.mousedown, listen); 12 text.addlistener(swt.mouseup, listen); 13 text.addlistener(swt.mousehover, listen); 14 text.addlistener(swt.mousedoubleclick, listen); 15 text.addlistener(swt.keydown, listen); 16 text.addlistener(swt.keyup, listen); 17 18 shell.setsize(400, 300); 19 SWTUtil.openShell(shell); Das Beispiel zeigt die Registrierung einer Reihe unterschiedlicher Events für ein Widget (Text) Der Listener (Folgefolie) identifiziert den Event und fügt einen beschreibende Zeile in das Text Widget ein

SWT Event Handling: Untyped Listener 1 private static final class MyTextListener implements Listener { 2 // Deklaration vom Feld Text, Konstruktor und Methode out fehlen!!! 3 4 public void handleevent(event event) { 5 switch (event.type) { 6 case SWT.MouseEnter: 7 out("mouse entered"); 8 break; 9 case SWT.MouseExit: 10 out("mouse exit"); 11 break; 12 case SWT.MouseDown: 13 out("mouse down"); 14 break; 15 case SWT.MouseUp: 16 out("mouse up"); 17 break; 18 case SWT.MouseHover: 19 out("mouse hovering"); 20 break; 21 case SWT.MouseDoubleClick: 22 out("mouse double click"); 23 break; 24 case SWT.KeyDown: 25 out("key down"); 26 break; 27 case SWT.KeyUp: 28 out("key up"); 29 Break; 30 }}} Über das Feld type kann der Event klassifiziert werden Die entsprechenden SWT Konstanten werden zur Unterscheidung verwendet Die Methode out hängt die Ausgabe an das Text-Widget des Hauptfensters an Im Beispiel funktioniert MouseHover nicht in der gewünschten Form (???)

SWT Event Handling: Adapter/Listener FocusListener/FocusAdapter: reagiert auf Verlust/Erhalt des (Maus/Keyboard) Fokus KeyListener/KeyAdapter: reagiert auf Tastendruck/Lösen der Taste ModifyListener(nur 1 Methode): reagiert auf Veränderungen des Texts VerifyListener: reagiert und auf Veränderungen des Textes und fängt diese evtl. ab (über das doit Attribut des Events). MouseListener/MouseAdapter: reagiert auf Druck, Movement und Dragging der Maustasten SelectionListener/SelectionAdapter: reagiert auf die Auswahl von Elementen (vergleichbar mit dem ActionListener in Swing)

SWT Event Handling: VerifyListener 1 import org.eclipse.swt.swt; 2 import org.eclipse.swt.events.*; 3 import org.eclipse.swt.layout.*; 4 import org.eclipse.swt.widgets.*; 5 6 public class EventHandling { 7 private static boolean numbersonly = true; 8 9 public static void main(string[] args) { 10 Shell shell = SWTUtil.getShell(); 11 shell.settext("eventhandling"); 12 shell.setlayout(new GridLayout(2, false)); 13 14 // input 15 Label lblinput = new Label(shell, SWT.RIGHT); 16 lblinput.settext("type in here:"); 17 GridData data = new GridData(GridData.HORIZONTAL_ALIGN_END); 18 lblinput.setlayoutdata(data); 19 Text input = new Text(shell, SWT.BORDER); 20 21 input.addverifylistener(new VerifyListener() { 22 public void verifytext(verifyevent vevent) { 23 vevent.doit = false; // don't allow anything but numbers 24 if (!numbersonly vevent.character == '\b') { 25 vevent.doit = true; 26 } else if (Character.isDigit(vEvent.character) && numbersonly) { 27 vevent.doit = true; 28 } 29 } 30 }); 31 32 addcheckbutton(shell); // see next slide 33 34 shell.pack(); 35 SWTUtil.openShell(shell); 36 } 37 } Fängt alle nicht numerischen Eingaben in das Textfeld ab Event handling für den CheckButton auf der nächsten Folie

SWT Event Handling: VerifyListener 1 private static void addcheckbutton(shell shell) { 2 GridData data; 3 Button btnallow = new Button(shell, SWT.CHECK); 4 btnallow.settext("allow numbers only"); 5 data = new GridData(GridData.HORIZONTAL_ALIGN_CENTER); 6 data.horizontalspan = 2; 7 btnallow.setlayoutdata(data); 8 9 btnallow.addselectionlistener(new SelectionAdapter() { 10 public void widgetselected(selectionevent selectionevent) { 11 numbersonly = ((Button) (selectionevent.widget)).getselection(); 12 } 13 }); 14 15 } fügt CheckButton ein und reagiert auf SelectionEvent

SWT Execution: asyncexec/syncexec Alle Updates auf das GUI sollten im User Interface Thread ablaufen Langlaufende Aufgaben frieren das Interface ein Aber: externe Thread können das GUI nicht updaten (Verboten in SWT) Lösung: Starten des externen Thread durch asyncexec() oder syncexec() Dadurch wird der Thread in das Dispatching des User Interface Threads integriert.

SWT Execution: asyncexec/syncexec 1 public static void main(string[] args) { 2 Shell shell = SWTUtil.getShell(); 3 4 shell.settext("display time"); 5 shell.setlayout(new GridLayout()); 6 Label clock = new Label(shell, SWT.NONE); 7 clock.settext(new Date().toString()); 8 shell.setsize(250, 100); 9 10 StartThread(shell, clock); 11 //see next slide 12 SWTUtil.openShell(shell); 13 } Einfache Shell, die die aktuelle Zeit in einem Label anzeigt Zeit-Thread läuft im User Interface Thread

SWT Execution: asyncexec/syncexec 1 private static void startthread(final Shell shell, final Label clock) { 2 new Thread(new Runnable() { 3 public void run() { 4 Display display = shell.getdisplay(); 5 6 while (!shell.isdisposed()) { 7 try { 8 display.asyncexec(new Runnable() { 9 public void run() { 10 clock.settext(new Date().toString()); 11 } 12 }); 13 Thread.sleep(1000); 14 } catch (InterruptedException e) { 15 e.printstacktrace(); 16 } 17 } 18 } 19 }).start(); 20 } Der ausführende Thread wird separat gestartet. Solange die shell noch nicht disposed wurde, wird ein neues Runnable erzeugt und in das Dispatching des User Interface Threads integriert

Beispiel Applikation: ein einfacher Browser Entwickeln Sie einen einfachen Browser mit SWT (< 300 Zeilen) Verwenden Sie SWTUtil.java

JFace:

Aufbau einer SWT Anwendung: Das Zusammenspiel der Komponenten

SWT Anwendung: SubclassingError 1 public class SubclassingError extends MessageBox { 2 Das Ableiten 3 public SubclassingError(Shell shell, int style) { 4 super(shell, style); 5 } 6 7 public static void main(string[] args) { 8 Shell shell = SWTUtil.getShell(); 9 shell.settext("subclassingerror"); 10 11 int style = SWT.ICON_ERROR SWT.OK; 12 SubclassingError sbe = new SubclassingError(shell, style); 13 sbe.setmessage("subclassing does not Work"); 14 sbe.settext("fehler: in SWT klappt das hier nicht"); 15 16 shell.open(); 17 SWTUtil.openShell(shell); 18 } 19 } (Subclassing) von SWT Widgets ist verboten siehe auch Folgefolie Lediglich Canvas kann abgeleitet werden Frage: wie kann man sinnvoll eigene Klassen auf den SWT Widgets aufbauen?

SWT Anwendung: Subclassing Fehler org.eclipse.swt.swtexception: Subclassing not allowed

Lösungsansatz 1: nur eine GUI Klasse Die gesamte GUI wird in einer Klasse definiert Alle GUI Komponenten sind als Instanz- oder statische Variablen der Klasse kodiert Durch Refactoring (Extract Method) zieht man die Definitionen in eigenständige Routinen Strings werden extrahiert und in einer externen Ressourcendatei gespeichert EventListener werden als anonyme, innere Klassen realisiert und direkt an die Widgets gebunden

Vorteile/Nachteile Lösungsansatz 1 Event Listener haben direkten Zugriff auf den internen Zustand der GUI Klasse Allerdings müssen die Variablen als final deklariert werden und sind damit immutable (nicht veränderbar) Starker Widerspruch zum objektorientierten Paradigma Keine Generalisierung/Spezialisierung und Kapselung der GUI Komponenten

Lösungsansatz 2: Delegateklassen Direkte Vererbung ist nicht möglich Definition von Delegateklassen, die das public interface des Widgets reimplementieren Delegate speichert Widget als Instanzvariable Methodenaufrufe werden weitergeleitet Das Delegate kann dann in herkömmlicher Weise erweitert werden Nachbildung des Interface Definition einer Interfaceklasse mit entsprechenden Signaturen der Methoden Anschliessend das Interface in der Delegateklasse implementieren und Die Methoden automatisch generieren lassen Konstruktoren hinzufügen

Vorteil/Nachteile Lösungsansatz 2 Objektorientiertere Implementation Adapterklasse verdeckt die fehlende Erweiterbarkeit Aber: Zugriff auf Sichtbarkeit protected und paket ist nicht gegeben keine vollständige Vererbung Interface kann komplex sein Hohe Aufwand bei der Rekonstruktion der Methoden

Mögliche Grundstruktur Aufteilung der Anwendung in 3 operative Einheiten View: Grafische Oberfläche inklusive aller Dialoge und EventListener Model: Programmlogik definiert das Model und die auf diesem aufsetzenden Operationen Controller: Dünne Zwischenschicht als Mittler zwischen GUI und Programmlogik Je nach Architektur: CallbackListener zur Aktualisierung des Views bei Änderung im Modell

MVC: Model, View, Controller

Verfeinerung: Paketstruktur GUI Teilkomponenten der GUI in jeweils eigenem Paket organisieren, z.b. de.fulda.mmprog.gui Haupt- und Nebenfenster de.fulda.mmprog.gui.listener z.b. ButtonListener, MenuListener: benötigen Zugriff auf View und Controller de.fulda.mmprog.gui.widgets alle zusätzlichen Dialoge, z.b. AboutDialog, ExitDialog, FileOpenDialog

Aufbau der GUI Aufbau der GUI sollte schrittweise und modularisiert vorgenommen werden Erzeugung des Hauptmenüs Definition und Parameterisierung des Layouts Definition und Einfügen der Komponenten des Hauptfensters Definition und Anbindung der EventListener Erzeugung und Initialisierung der Dialoge

Sichtbarkeit und Benamung Klassen sollten maximal (!) gekapselt werden Keinen direkten Zugriff auf Instanzvariablen Grundsätzlich private als Sichtbarkeit Zugriff über Getter/Setter (auch innerhalb der Klasse selbst!!!!) Bean Konventionen bei der Benennung Parameter von Methoden sind final zu deklarieren Möglichst geringe Verwendung von statischen Methoden Sammeln in Utilityklassen Sichbarkeit sollte immer explizit gemacht werden Weitgehende Verzicht auf Paketsichtbarkeit Benamungskonventionen von Sun einhalten

Liste aller SWT Widgets

Alphabetische Liste aller SWT Widgets Button - Selectable control that issues notification when pressed and/or released. Canvas - Composite control that provides a surface for drawing arbitrary graphics. Often used to implement custom controls. Caret - An "I-beam" that is typically used as the insertion point for text. Combo - Selectable control that allows the user to choose a string from a list of strings, or optionally type a new value into an editable text field.

Alphabetische Liste aller SWT Widgets Composite - Control that is capable of containing other widgets. CoolBar - Composite control that allows users to dynamically reposition the cool items contained in the bar. CoolItem - Selectable user interface object that represents a dynamically positioned area of a cool bar. Group - Composite control that groups other widgets and surrounds them with an etched border and/or label. Label - Non-selectable control that displays a string or an image.

Alphabetische Liste aller SWT Widgets List - Selectable control that allows the user to choose a string or strings from a list of strings. Menu - User interface object that contains menu items. MenuItem - Selectable user interface object that represents an item in a menu. ProgressBar - Non-selectable control that displays progress to the user, typically in the form of a bar graph. Sash - Selectable control that allows the user to drag a rubber banded outline of the sash within the parent window. Used to allow users to resize child widgets by repositioning their dividing line.

Alphabetische Liste aller SWT Widgets Scale - Selectable control that represents a range of numeric values. ScrollBar - Selectable control that represents a range of positive numeric values. Used in a Composite that has V_SCROLL and/or H_SCROLL styles. Shell - Window that is managed by the OS window manager. Shells can be parented by a Display (toplevel shells) or by another shell (secondary shells). Slider - Selectable control that represents a range of numeric values. A slider is distinguished from a scale by providing a draggable thumb that can adjust the current value along the range.

Alphabetische Liste aller SWT Widgets TabFolder - Composite control that groups pages that can be selected by the user using labeled tabs. TabItem - Selectable user interface object corresponding to a tab for a page in a tab folder Table - A Selectable control that displays a list of table items that can be selected by the user. Items are presented in rows that display multiple columns representing different aspects of the items. TableColumn - Selectable user interface object that represents a column in a table. TableItem - Selectable user interface object that represents an item in a table.