SWT Einführung. MM Programmierung
|
|
- Lars Glöckner
- vor 7 Jahren
- Abrufe
Transkript
1 SWT Einführung
2 Überblick Überblick über Java GUI SWT installieren Mit Widgets arbeiten SWT Layouts Event Handling Beispiel Anwendung
3 Ü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
4 Ü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 und 1.5 des SDKs Trotzdem: kaum kommerzielle Relevanz für Swing
5 Ü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)
6 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-win dll) Download und Installation SWT ist Teil von Eclipse 3.0 swt.jar und swt-win dll
7 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-win dll in eines der Verzeichnisse - oder - Geben Sie den Pfad beim Starten von Java an java -Djava.library.path=C:\SWT classname
8 Eclipse SWT Startkonfiguration Name der Konfiguration Kommandozeilenargumente der VM (virtuellen Maschine) Arguments Tab -Djava.library.path=C:\users\milde\Programmierung\eclipse3\eclipse-SDK win32\eclipse\plugins\org.eclipse.swt.win32_3.0.2\os\win32\x86
9 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); shell.open(); while (!shell.isdisposed()) { 14 if (!display.readanddispatch()) { 15 display.sleep(); 16 } 17 } 18 display.dispose(); 19 } 20 }
10 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
11 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 } public static void openshell(shell shell) { 12 shell.open(); // 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
12 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 }
13 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.)
14 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.
15 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); // 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
16 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"); // 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
17 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"); // pack and show 15 shell.pack(); 16 SWTUtil.openShell(shell); 17 } 18 } Unterschiedliche Textfelder, die durch Stilbits parameterisiert werden können
18 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); // pack and show 20 shell.pack(); 21 SWTUtil.openShell(shell); 22 } 23 } Auswahllisten, aus denen ein oder mehrere Elemente ausgewählt werden können.
19 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); // 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(" ");
20 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); 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"); 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
21 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
22 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
23 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
24 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); 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()); // Menu, das an den Eintrag gebunden ist 19 Menu menui = new Menu(shell, SWT.DROP_DOWN); 20 mi.setmenu(menui); createmenuentries(menui, menuentries[i]); // see next slide 23 } Text text = new Text(shell, SWT.MULTI SWT.BORDER SWT.V_SCROLL SWT.H_SCROLL); 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
25 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
26 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 } public void widgetdefaultselected(selectionevent e) {} 14 }; Menu popupmenu = generatepopupmenu(shell, li); // next slide 17 text.setmenu(popupmenu); 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)
27 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
28 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 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 } // pack and show 20 shell.pack(); 21 SWTUtil.openShell(shell); 22 } 23 } Gruppiert Widgets visuell und logisch Vergleichbar mit JPanel in Swing
29 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()); Browser browser = new Browser(shell, SWT.BORDER); 13 browser.setsize(900, 500); 14 browser.seturl(" // pack and show 17 shell.pack(); 18 SWTUtil.openShell(shell); 19 } 20 } Öffnet ein komplettes Browser Widget Basiert auf dem jeweiligen Standardbrowser des Systems.
30 SWT Widgets: Browser
31 Dialogfenster
32 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
33 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.
34 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
35 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)); final FontDialog fd = new FontDialog(shell); 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 } public void widgetdefaultselected(selectionevent e) {} 24 }); 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
36 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)); 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 (*.*)" }); addbuttonlistener(button, text, filechooser); // next slide shell.pack(); 24 SWTUtil.openShell(shell); FileDialog öffnet mehrere Dateien Mit den Extensionen avi, mov, mpg Verarbeitung im Listeners des Buttons (Folgefolie)
37 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) { 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 } } 20 } 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
38 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)); final DirectoryDialog dd = new DirectoryDialog(shell); 13 dd.settext("select a directory"); 14 dd.setmessage("choose a directory to list"); 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 } public void widgetdefaultselected(selectionevent e) {} 25 }); shell.pack(); 28 SWTUtil.openShell(shell); Der DirectoryDialog wählt ein Verzeichnis aus Die Dateien werden im List aufgeführt
39 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
40 SWT Widgets: MessageBox SWT.ICON_ERROR SWT.ICON_WARNING SWT.ICON_ERROR SWT.ICON_WORKING SWT.ICON_QUESTION SWT.YES SWT.NO
41 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
42 SWT Widgets: Kombination von Buttons
43 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(); style = SWT.ICON_QUESTION SWT.YES SWT.NO; 12 generatemessagebox(shell, style).open(); style = SWT.ICON_WARNING; 15 generatemessagebox(shell, style).open(); style = SWT.ICON_WORKING; 18 generatemessagebox(shell, style).open(); 19 } 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
44 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
45 Komplexe SWT Widgets
46 Komplexe SWT Widgets SWT verfügt über eine Reihe komplexere Widgets 1 Tree und TreeItem 2 Table, TableItem und TableColumn 3 TabFolder und TabItem dienen der Anzeige von hierarchischen, bzw. tabellenartigen Datenstrukturen Der TabFolder ordnet die Sichten einer GUI zu logischen Einheiten
47 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 } tree.addselectionlistener(generateselectionlistener()); 24 // see next slide 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)
48 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
49 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 } 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 } for (int k = 0; k < COLUMNS; k++) { 21 TableColumn tc = table.getcolumn(k); 22 tc.pack(); 23 } table.addselectionlistener(generateselectionlistener()); 26 // see previous slide 27 table.setsize(500, 300); 28 shell.pack(); 29 SWTUtil.openShell(shell);
50 Layouts in SWT
51 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
52 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)); 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 } // 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
53 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)); 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 } // 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
54 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()); 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"); 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()); ((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
55 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
56 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 // 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"); // Password 19 new Label(shell, SWT.RIGHT).setText("Password:"); 20 new Text(shell, SWT.BORDER SWT.PASSWORD). setlayoutdata(new GridData(GridData.FILL_HORIZONTAL)); // 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); 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
57 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
58 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
59 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"); FormData formdata = new FormData(); 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); button1.setlayoutdata(formdata); 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
60 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)
61 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); FormData fd1 = new FormData(); 13 fd1.left = new FormAttachment(lastButton); 14 fd1.top = new FormAttachment(lastButton, 0, SWT.TOP); 15 b.setlayoutdata(fd1); 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
62 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); 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); FormData fd = new FormData(); 21 fd.right = new FormAttachment(100); 22 fd.top = new FormAttachment(text, 0, SWT.CENTER); 23 findbutton.setlayoutdata(fd); (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"); 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(); 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); (rechts)
63 SWT Event Handling
64 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
65 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
66 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 }; button.addlistener(swt.selection, l); 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
67 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); 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
68 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 (???)
69 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)
70 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)); // 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); 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 }); addcheckbutton(shell); // see next slide 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
71 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 }); } fügt CheckButton ein und reagiert auf SelectionEvent
72 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.
73 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
74 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
75 Beispiel Applikation: ein einfacher Browser Entwickeln Sie einen einfachen Browser mit SWT (< 300 Zeilen) Verwenden Sie SWTUtil.java
76 JFace:
77 Aufbau einer SWT Anwendung: Das Zusammenspiel der Komponenten
78 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"); 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"); 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?
79 SWT Anwendung: Subclassing Fehler org.eclipse.swt.swtexception: Subclassing not allowed
80 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
81 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
82 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
83 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
84 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
85 MVC: Model, View, Controller
86 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
87 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
88 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
89 Liste aller SWT Widgets
90 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.
91 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.
92 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.
93 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.
94 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.
Mi. 12. Nov. 2003 WA73 - R. 0611. Projekt Software Engeneering 2003/04. SWT & JFace. Norman Thomas Rogowski
Mi. 12. Nov. 2003 WA73 - R. 0611 Projekt Software Engeneering 2003/04 SWT & JFace Norman Thomas Rogowski Was ist SWT? Standard Widget Toolkit Baut auf native Oberfläche auf Aussehen entspricht exakt dem
MehrSWT. -The Standard Widget Toolkit- Inhaltsverzeichnis. Thomas Wilhelm SWT. 1. Was ist SWT?
Java -The Standard Widget Toolkit- Inhaltsverzeichnis 1. Was ist? - Vorteile von - Nachteile von 2. Vorbereitungen für 3. Das erste Programm in 4. Widgets und Styleparameter 5. - Layouts Was ist ein Widget?
MehrEclipse - SWT. Studiendepartment Informatik Technical and Applied Informatics
University of Applied Sciences Fakultät Technik und (TI) Eclipse - SWT 1 GUI-Frameworks Fakultät Technik und (TI) GUI - Philosophien Minimalistic Approach Das Thema GUI (Graphic User Interface) ist gewaltig
MehrEclipse s SWT Basic Widgets
In dieser Starthilfe Um was geht s? Grundstruktur einer SWT Applikation Grundlegende Widgets Label, Text, Button, Listen, Combo, Composite Events Selektion, Key, Mouse, Text, Focus & Traverse Zusammenfassung
MehrProgrammieren II. Java im Vergleich zu anderen Sprachen. Einführung: GUI. Einführung: Grafische Benutzeroberflächen. Dr.
Programmieren II Dr. Klaus Höppner Hochschule Darmstadt SS 2008 1 / 22 2 / 22 Einführung: GUI Fast alle Programme besitzen mittlerweile eine grafische Benutzeroberfläche (engl: Graphical User Interface,
MehrFunktionale und Objekt-Orientierte Programmierkonzepte
Funktionale und Objekt-Orientierte Programmierkonzepte Prof. Marc Fischlin, Wintersemester 15/16 Kapitel 17: GUI, Threads und verschachtelte Klassen 13. Oktober 2010 Dr.Marc Fischlin Kryptosicherheit 1
MehrProf. Dr. Oliver Haase Karl Martin Kern Achim Bitzer. Programmiertechnik GUI-Programmierung mit Swing
Prof. Dr. Oliver Haase Karl Martin Kern Achim Bitzer Programmiertechnik GUI-Programmierung mit Swing AWT und Swing Java enthält zwei Pakete zur Programmierung graphischer Oberflächen. java.awt: Das Abstract
MehrNeben der Verwendung von Klassen ist Vererbung ein wichtiges Merkmal objektorientierter
Kapitel 1 Der vierte Tag 1.1 Vererbung Neben der Verwendung von Klassen ist Vererbung ein wichtiges Merkmal objektorientierter Sprachen. Unter Vererbung versteht man die Möglichkeit, Eigenschaften vorhandener
MehrEinführung: Grafische Benutzeroberflächen. Programmieren II. Dr. Klaus Höppner. Hochschule Darmstadt Sommersemester / 22
Programmieren II Dr. Klaus Höppner Hochschule Darmstadt Sommersemester 2010 1 / 22 Einführung: Grafische Benutzeroberflächen 2 / 22 Einführung: GUI Fast alle Programme besitzen mittlerweile eine grafische
MehrGUI-Programmierung. Teil I. Unterlagen zum Modul OOP mit Java V by MOU2/BFH-TI. Berner Fachhochschule Technik und Informatik
GUI-Programmierung mit Java Teil I Unterlagen zum Modul OOP mit Java V 3.0 2007 by WBR1/BFH-TI 2011 by MOU2/BFH-TI GUI-Programmierung V3.0 2011 by WBR1&MOU2/BFH-TI Lernziele Die Kursteilnehmer sind in
MehrAlgorithmen und Datenstrukturen
Algorithmen und Datenstrukturen Tafelübung 03 Vererbung, Polymorphie, Sichtbarkeit, Interfaces Clemens Lang T2 11. Mai 2010 14:00 16:00, 00.152 Tafelübung zu AuD 1/26 Klassen und Objekte Klassen und Objekte
MehrProgrammieren in Java -Eingangstest-
Programmieren in Java -Eingangstest- Nummer: 1. Studiengang: Informatik B.Sc. Informatik M.Sc. ESE B.Sc. ESE M.Sc. Sonstiges: Fachsemester: Bitte Fragen, die Sie nicht beantworten können unbedingt mit
MehrJAVA Look & Feel Design Guidelines
JAVA Look & Feel Design Guidelines Stefan Diener / Jul 24, 2007 / Page 1 Überblick Motivation Abstände Labels Allgemeine Regeln für Dialoge Toolbar & Menüs Shortcuts & Mnemonics Texte im GUI Weitere interessante
MehrWebentwicklung mit Vaadin 7. Theoretische und praktische Einführung in Vaadin 7. Christian Dresen, Michael Gerdes, Sergej Schumilo
Webentwicklung mit Vaadin 7 Theoretische und praktische Einführung in Vaadin 7 Christian Dresen, Michael Gerdes, Sergej Schumilo Agenda Allgemeines Architektur Client-Side Server-Side Vaadin UI Components
MehrObjektorientierte Programmierung Studiengang Medieninformatik
Objektorientierte Programmierung Studiengang Medieninformatik Hans-Werner Lang Hochschule Flensburg Vorlesung 5 12.04.2017 Was bisher geschah... Objektorientierte Programmierung Klassen und Objekte, Attribute
MehrTheorie zu Übung 8 Implementierung in Java
Universität Stuttgart Institut für Automatisierungstechnik und Softwaresysteme Prof. Dr.-Ing. M. Weyrich Theorie zu Übung 8 Implementierung in Java Klasse in Java Die Klasse wird durch das class-konzept
MehrEinstieg in die Informatik mit Java
1 / 22 Einstieg in die Informatik mit Java Grundlagen Gerd Bohlender Institut für Angewandte und Numerische Mathematik Gliederung 2 / 22 1 Kommentare 2 Bezeichner für Klassen, Methoden, Variablen 3 White
Mehr12 Abstrakte Klassen, finale Klassen und Interfaces
12 Abstrakte Klassen, finale Klassen und Interfaces Eine abstrakte Objekt-Methode ist eine Methode, für die keine Implementierung bereit gestellt wird. Eine Klasse, die abstrakte Objekt-Methoden enthält,
MehrGUI Programmierung mit JAVA Swing
GUI Programmierung mit JAVA Swing Komponenten Layout Event Handling Imaging 2001 Thomas Weiler 1 JAVA Swing Bibliothek zur Erstellung grafischer Benutzerschnittstellen in JAVA Bietet Klassen für grafische
MehrEinstieg in die Informatik mit Java
Vorlesung vom 18.4.07, Grundlagen Übersicht 1 Kommentare 2 Bezeichner für Klassen, Methoden, Variablen 3 White Space Zeichen 4 Wortsymbole 5 Interpunktionszeichen 6 Operatoren 7 import Anweisungen 8 Form
MehrSwing : Komponeneten I (Teil 1) Was ist Swing?
Was ist Swing? 1 Unterschied zu AWT (Abstract window Toolkit) Zusätzliche Komponenten von Swing,die zu Oberflächenerzeugung genutzt werden können: Keyboard Accelerators, also Tastenkombination zur Steuerung
MehrInstitut für Informatik
Technische Universität München Institut für Informatik Lehrstuhl für Computer Graphik & Visualisierung WS 2009 Praktikum: Grundlagen der Programmierung Aufgabenblatt 11 Prof. R. Westermann, R. Fraedrich,
MehrKapitel 9. Programmierkurs. Attribute von Klassen, Methoden und Variablen. 9.1 Attribute von Klassen, Methoden und Variablen
Kapitel 9 Programmierkurs Birgit Engels Anna Schulze Zentrum für Angewandte Informatik Köln Objektorientierte Programmierung Attribute von Klassen, Methoden und Variablen Interfaces WS 07/08 1/ 18 2/ 18
MehrJavakurs FSS Lehrstuhl Stuckenschmidt. Tag 3 - Objektorientierung
Javakurs FSS 2012 Lehrstuhl Stuckenschmidt Tag 3 - Objektorientierung Warum Objektorientierung Daten und Funktionen möglichst eng koppeln und nach außen kapseln Komplexität der Software besser modellieren
MehrBeispiele für Ausdrücke. Der imperative Kern. Der imperative Kern. Imperativer Kern - Kontrollstrukturen. Deklarationen mit Initialisierung
Beispiele für Ausdrücke Der imperative Kern Deklarationen mit Initialisierung Variablendeklarationen int i = 10; int j = 15; Beispiele für Ausdrücke i+j i++ i & j i j [] [static]
MehrImplementieren von Klassen
Implementieren von Klassen Felder, Methoden, Konstanten Dr. Beatrice Amrhein Überblick Felder/Mitglieder (Field, Member, Member-Variable) o Modifizierer Konstanten Methoden o Modifizierer 2 Felder und
MehrGUI Programmierung in Java
vs und niemals mischen! Daher muss man sich für eine Klasse entscheiden 1 (Abstract Window Toolkit) schwergewichtige Alle Elemente werden vom Betriebssytem gemalt sehen aus wie alle anderen Programme auf
MehrGUI Programmierung mit javax.swing
java.awt Swing Komponenten Layout Manager Ausblick GUI Programmierung mit University basierend auf Folien von Dr. Beatrice Amrhein (Bern), 19. Juni 2006 java.awt Swing Komponenten Layout Manager Ausblick
MehrJava für Computerlinguisten
Java für Computerlinguisten 5. Grafische Userinterfaces Christian Scheible Institut für Maschinelle Sprachverarbeitung 31. Juli 2009 Christian Scheible Java für Computerlinguisten 31. Juli 2009 1 / 33
MehrSchablonen für Klassen, Interfaces oder Methoden, die noch nicht festgelegte Datentypen verwenden
Generics Schablonen für Klassen, Interfaces oder Methoden, die noch nicht festgelegte Datentypen verwenden Typvariablen statt (fester) Datentypen werden hinter Bezeichnern in spitzen Klammern aufgezählt
MehrGraphical User Interfaces
Graphical User Interfaces SEP 184 Toolkits es gibt verschiedene Toolkits (= Sammlungen von Klassen, Anbindungen an Betriebssystem, etc.) für grafische Oberflächen Abstract Windows Toolkit (AWT) Swing Standard
MehrEinstieg in die Informatik mit Java
1 / 25 Einstieg in die Informatik mit Java Objektorientierte Programmierung und Klassen Gerd Bohlender Institut für Angewandte und Numerische Mathematik Gliederung 2 / 25 1 Die Philosophie 2 Definition
MehrEinführung in die Informatik: Programmierung und Software-Entwicklung, WS 15/16. Kapitel 7. Grafische Benutzeroberflächen 1
Kapitel 7 Grafische Benutzeroberflächen Grafische Benutzeroberflächen 1 Ziele Grafische Benutzeroberflächen (Graphical User Interfaces) als Anwendungsbeispiel für die objektorientierte Programmierung kennenlernen.
MehrSession 1: Classes and Applets
Session 1: Classes and Applets Literature Sprechen Sie Java, ISBN 3-89864-117-1, dpunkt deutsch Java für Studenten, ISBN 3-8273-7045-0, PearsonStudium deutsch Java in a Nutshell, ISBN: 0-59600-283-1, O'Reilly
MehrHeute. Grafische Benutzeroberflächen (Anonyme) innere Klassen Einfache Simulationen main / ausführbare jar-files IT I - VO 11 1
Heute Grafische Benutzeroberflächen (Anonyme) innere Klassen Einfache Simulationen main / ausführbare jar-files 17.01.2017 IT I - VO 11 1 Organisatorisches Noch zwei UE und eine Wissensüberprüfung Heute
Mehrsynedra View Embedded Michael Doppler, synedra it GmbH <m.doppler@synedra.com>
synedra View Embedded Michael Doppler, synedra it GmbH 2015 synedra information technologies Zusammenfassung IndiesemDokumentwirdbeschrieben,wiesynedraViewEmbeddedinApplikationenandererHerstellerintegriertwerdenkann.
MehrProgrammiertechnik GUI Programmierung mit Java Swing
Programmiertechnik GUI Programmierung mit Java Swing Prof. Dr. Oliver Haase Software Engineering und Verteilte Systeme Raum F012 haase@htwg-konstanz.de Tel: 07531/206-720 Oliver Haase Hochschule Konstanz
MehrTag 8 Repetitorium Informatik (Java)
Tag 8 Repetitorium Informatik (Java) Dozent: Michael Baer Lehrstuhl für Informatik 2 (Programmiersysteme) Friedrich-Alexander-Universität Erlangen-Nürnberg Wintersemester 2017/2018 Informatik-Repetitorium
MehrDas Einsteigerseminar Objektorientierte Programmierung in Java
Alexander Niemann Das Einsteigerseminar Objektorientierte Programmierung in Java -H-H Inhalt Vorwort 13 Einleitung 15 1 Java 21 1.1 Die Geschichte von Java 22 1.2 Das Konzept 24 Klassisch - Compiler und
MehrGrundlagen der Programmierung (GP) Prof. Dr. H. Schlingloff Joachim Hänsel
Grundlagen der Programmierung (GP) Prof. Dr. H. Schlingloff Joachim Hänsel 17. 6. 2010 Kapitel 8: Java-Programmierung 8.1 Ereignisbehandlung, Benutzungsschnittstellen 8.2 Graphikprogrammierung 8.1 Ereignisbehandlung
MehrJava. Von den Grundlagen bis zu Threads und Netzen von Prof. Dr. Ernst-Wolfgang Dieterich Fachhochschule Ulm
Java Von den Grundlagen bis zu Threads und Netzen von Prof. Dr. Ernst-Wolfgang Dieterich Fachhochschule Ulm R.Oldenbourg Verlag München Wien 1999 1. Einleitung 11 2. Java-Entwicklungsumgebung 15 2.1 JDK
MehrTeil 5 - Java. Programmstruktur Operatoren Schlüsselwörter Datentypen
Teil 5 - Java Programmstruktur Operatoren Schlüsselwörter Datentypen 1 Kommentare in Java In Java gibt es drei Möglichkeiten zur Kommentierung: // Kommentar Alle Zeichen nach dem // werden ignoriert. für
MehrObjektorientierte Programmierung und Klassen
Objektorientierte Programmierung und Klassen Gerd Bohlender Institut für Angewandte und Numerische Mathematik Vorlesung: Einstieg in die Informatik mit Java 16.5.07 G. Bohlender (IANM UNI Karlsruhe) OOP
Mehr11. GUI-Programmierung mit SWING Überblick
11. GUI-Programmierung mit SWING Überblick 11.1 Einführung 11.2 Einfache Swing Komponenten 11.3 Ereignisbehandlung und Adapterklassen 11.4 Zeichnen 11.5 Dialoge 11.6 Layout Manager 11.7 Komplexere Swing
MehrLösungsvorschläge zur Nachklausur zum Kurs 1618 Sommersemester 2001 am
Aufgabe 1 Lösungsvorschläge zur Nachklausur zum Kurs 1618 Sommersemester 2001 am 16.3.2002 Folgende Implementierung löst die gestellte Aufgabe : public interface Figur { public void anzeigen (); public
MehrEclipse User Interface Guidelines
SS 2009 Softwarequalität 06.05.2009 C. M. Bopda, S. Vaupel {kaymic/vaupel84}@mathematik.uni-marburg.de Motivation (Problem) Motivation (Problem) Eclipse is a universal tool platform - an open, extensible
MehrObjektorientierte Programmierung Studiengang Medieninformatik
Objektorientierte Programmierung Studiengang Medieninformatik Hans-Werner Lang Hochschule Flensburg Vorlesung 1 15.03.2017 Objektorientierte Programmierung (Studiengang Medieninformatik) Form: Prüfung:
Mehr14 Abstrakte Klassen, finale Klassen, Interfaces
Eine abstrakte Objekt-Methode ist eine Methode, für die keine Implementierung bereit gestellt wird. Eine Klasse, die abstrakte Objekt-Methoden enthält, heißt ebenfalls abstrakt. Für eine abstrakte Klasse
MehrEinführung in GUI-Programmierung. javax.swing
Einführung in GUI-Programmierung javax.swing GUI Graphical User Interface ( Grafische Benutzerschnittstelle ) Anschaulichere und leichtere Möglichkeit zur Dateneingabe und Kontrolle von Programmen Stellt
Mehr14 Abstrakte Klassen, finale Klassen, Interfaces. Auswertung von Ausdrücken. Beispiel. Abstrakte Methoden und Klassen
Auswertung von Ausdrücken Eine abstrakte Objekt-Methode ist eine Methode, für die keine Implementierung bereit gestellt wird. Eine Klasse, die abstrakte Objekt-Methoden enthält, heißt ebenfalls abstrakt.
MehrHandbuch für die Erweiterbarkeit
Handbuch für die Erweiterbarkeit Inhalt Pakete für die Erweiterbarkeit... 2 Actions... 2 Items... 2 Itemset... 2 Die UseCaseNewAction... 3 Eigene Shapes... 4 Der Shape Container... 5 User Objects... 6
MehrNEWSLETTER. FileDirector Version 2.5 Novelties. Filing system designer. Filing system in WinClient
Filing system designer FileDirector Version 2.5 Novelties FileDirector offers an easy way to design the filing system in WinClient. The filing system provides an Explorer-like structure in WinClient. The
Mehr14 Abstrakte Klassen, finale Klassen, Interfaces
Eine abstrakte Objekt-Methode ist eine Methode, für die keine Implementierung bereit gestellt wird. Eine Klasse, die abstrakte Objekt-Methoden enthält, heißt ebenfalls abstrakt. Für eine abstrakte Klasse
MehrProgrammieren II. Innere Klassen. Heusch 10, Ratz 5.2.1, Institut für Angewandte Informatik
Programmieren II Innere Klassen Heusch 10, 13.10 Ratz 5.2.1, 9.8 KIT Die Forschungsuniversität in der Helmholtz-Gemeinschaft www.kit.edu Innere Klassen Bisher kennen wir nur Klassen, die entweder zusammen
MehrJava Tools JDK. IDEs. Downloads. Eclipse. IntelliJ. NetBeans. Java SE 8 Java SE 8 Documentation
Java Tools JDK http://www.oracle.com/technetwork/java/javase/ Downloads IDEs Java SE 8 Java SE 8 Documentation Eclipse http://www.eclipse.org IntelliJ http://www.jetbrains.com/idea/ NetBeans https://netbeans.org/
MehrInhaltsverzeichnis 1 Einführung Die Software JGIS Grundlagen raumbezogener Daten
1 Einführung... 1 1.1 Was wird vermittelt?... 1 1.2 Hinweise zum Buch... 3 1.3 Hinweise zur Buch-CD... 4 1.4 Hinweise zum Forum... 4 1.5 Allgemeine Hinweise... 5 2 Die Software JGIS... 7 2.1 Start des
MehrInstrumentierung und Dekodierung
116 Copyright 1996-1998 by Axel T. Schreiner. All Rights Reserved. Instrumentierung und Dekodierung Erweiterung der Grafikklassen Das awt-paket erweitert alle Klassen für Grafikobjekte in java.awt, so
MehrInhaltsverzeichnis. Grundlagen und Einführung (1. Band) 1
Inhaltsverzeichnis Grundlagen und Einführung (1. Band) 1 1 Einleitung und Vorwort 1 1.1 Vorwort zur 13. Auflage....................... 1 1.2 Vorwort zur 10. Auflage....................... 1 1.3 Voraussetzungen...........................
MehrInfo B VL 11: Innere Klassen/Collections
Info B VL 11: Innere Klassen/Collections Objektorientiere Programmierung in Java 2003 Ute Schmid (Vorlesung) Elmar Ludwig (Übung) FB Mathematik/Informatik, Universität Osnabrück Info B VL 11: Innere Klassen/Collections
MehrProbeklausur: Programmierung WS04/05
Probeklausur: Programmierung WS04/05 Name: Hinweise zur Bearbeitung Nimm Dir für diese Klausur ausreichend Zeit, und sorge dafür, dass Du nicht gestört wirst. Die Klausur ist für 90 Minuten angesetzt,
MehrJavakurs für Fortgeschrittene
Javakurs für Fortgeschrittene Einheit 03: Swing Lorenz Schauer Lehrstuhl für Mobile und Verteilte Systeme Heutige Agenda Einführung in GUI-Programmierung Motivation Grundlagen von Swing Praxis: UI für
MehrAlles neu mit SWT? Bernd Kolb Martin Lippert
Alles neu mit SWT? Bernd Kolb (b.kolb@kolbware.de, www.kolbware.de) Martin Lippert (martin.lippert@it-agile.de, www.it-agile.de) Inhalt Was ist SWT Woher kommt SWT Wie funktioniert SWT Inside SWT Ausblick:
MehrEINFÜHRUNG IN DIE PROGRAMMIERUNG
EINFÜHRUNG IN DIE PROGRAMMIERUNG OBJEKTORIENTIERTES PROGRAMMIEREN Tobias Witt 25.03.2014 10:30-12:00 Täglich Übungen zur Vertiefung Laptop hier nicht erforderlich Aber in den Übungen! Linux, OS X http://hhu-fscs.de/linux-install-party/
MehrJFS 2005: Java und JFace in der Praxis
E2 JFS 2005: Java SWT und JFace in der Praxis Dr. Hartmut Kocher Kirchplatz 5 82049 Pullach im Isartal Tel.: 089-7448500 http://www.cortex-brainware.de hwk@cortex-brainware.de Bild 1 Übersicht Einführung
MehrEINFÜHRUNG IN DIE PROGRAMMIERUNG
EINFÜHRUNG IN DIE PROGRAMMIERUNG OBJEKTORIENTIERTES PROGRAMMIEREN Tobias Witt 25.03.2014 09:00-10:30 Täglich Übungen zur Vertiefung Laptop hier nicht erforderlich Linux, OS X Freitag: http://hhu-fscs.de/linux-install-party/
MehrSoftwaretechnik (Medieninformatik): GUIs mit Swing Überblick
Softwaretechnik (Medieninformatik): GUIs mit Swing Überblick 1 Einführung 2 Einfache Swing Komponenten 3 Ereignisbehandlung und Adapterklassen 4 Zeichnen 5 Layout Manager 6 Komplexere Swing Komponenten
MehrKapitel 8: Grafische Benutzerschnittstellen
Einführung in die Informatik: Programmierung und Softwareentwicklung Wintersemester 2018/19 Kapitel 8: Grafische Benutzerschnittstellen Prof. Dr. David Sabel Lehr- und Forschungseinheit für Theoretische
MehrFachhochschule Wedel 31. Januar 2004 Prof. Dr. Uwe Schmidt
Fachhochschule Wedel 31. Januar 2004 Prof. Dr. Uwe Schmidt Aufgaben zur Klausur C und Objektorientierte Programmierung im WS 2003/04 (WI h103, II h105, MI h353) Zeit: 150 Minuten erlaubte Hilfsmittel:
MehrProf. Dr. Wolfgang Schramm. Vorlesung. Techniken der Programmentwicklung. Exkurs: Anonyme Klassen
Prof. Dr. Wolfgang Schramm Vorlesung Exkurs: Anonyme Klassen Techniken der Programmentwicklung Prof. Dr. Wolfgang Schramm Vorlesung Exkurs: Anonyme Klassen Techniken der Programmentwicklung Anonyme Klassen
MehrGraphische Benutzungsoberflächen mit Java. Einführung in NetBeans
Graphische Benutzungsoberflächen mit Java Einführung in NetBeans Graphische Benutzungsoberflächen! Interaktion mit dem Programm! Datenein- und ausgabe! Rückmeldungen über Verarbeitung der Daten! Visualisierung
MehrEreignisse (Events) in Java
Ereignisse (Events) in Java werden durch Aktionen an GUI-Komponenten ausgelöst Quelle: GUI-Komponente, die ein Ereignis als Instanz einer Event-Klasse erzeugt Beispiel: ein Button, der angeklickt wird
MehrEINFÜHRUNG IN DIE PROGRAMMIERUNG
EINFÜHRUNG IN DIE PROGRAMMIERUNG GRUNDLAGEN Tobias Witt!! 24.03.2014 ORGANISATORISCHES 09:00-10:30! Täglich Übungen zur Vertiefung! Laptop hier nicht erforderlich! Linux, OS X! Freitag: http://hhu-fscs.de/linux-install-party/
MehrPhysikalisch Technische Lehranstalt Wedel 31. Januar 2004 Prof. Dr. Uwe Schmidt
Physikalisch Technische Lehranstalt Wedel 31. Januar 2004 Prof. Dr. Uwe Schmidt Aufgaben zur Klausur Objektorientierte Programmierung im WS 2003/04 (IA 252) Zeit: 90 Minuten erlaubte Hilfsmittel: keine
MehrHochschule Ravensburg - Weingarten Technik Wirtschaft Sozialwesen 21.12.2006 SWT. Standard Widget Toolkit WI 15895 WI 15839
SWT Standard Widget Toolkit 1 Inhaltsverzeichnis 1 1. Vorwort... 4 2. SWT im Vergleich... 5 2.1. Abstract Window Toolkit (AWT)... 5 2.2. Swing... 6 2.3. Standard Widget Toolkit (SWT)... 7 3. Die Vorbereitung
MehrAlgorithmen und Datenstrukturen II
Algorithmen und Datenstrukturen II in JAVA D. Rösner Institut für Wissens- und Sprachverarbeitung Fakultät für Informatik Otto-von-Guericke Universität Magdeburg Sommer 2009, 31. März 2009, c 2009 D.Rösner
MehrProgrammieren 2 Java Überblick
Programmieren 2 Java Überblick 1 Klassen und Objekte 2 Vererbung 4 Innere Klassen 5 Exceptions 6 Funktionsbibliothek 7 Datenstrukturen und Algorithmen 8 Ein-/Ausgabe 9 Graphische Benutzeroberflächen 10
MehrJAVA Oberflächen mit Swing
JAVA Oberflächen mit Swing Grafik von http://javafx.com 159 AGENDA Grundlagen GUI Swing JavaFX 160 GRAPHISCHE BENUTZEROBERFLÄCHEN (1) AWT = Abstract Window Toolkit Verwendet die jeweiligen GUI-Komponenten
MehrGUI-Programmierung mit Java. Informatik B - Objektorientierte Programmierung in Java. Vorlesung 11: GUI 1: AWT (1) GUI-Programmierung mit Java.
Universität Osnabrück 1 GUI-Programmierung mit Java 3 - Objektorientierte Programmierung in Java Vorlesung 11: GUI 1: AWT (1) SS 2004 Prof. Dr. F.M. Thiesing, FH Dortmund Alle unsere bisherigen Anwendungsbeispiele
MehrEinstieg in die Informatik mit Java
1 / 22 Einstieg in die Informatik mit Java Generics Gerd Bohlender Institut für Angewandte und Numerische Mathematik Gliederung 2 / 22 1 Überblick Generics 2 Generische Klassen 3 Generische Methoden 4
MehrObjektorientierte Programmierung. Kapitel 22: Aufzählungstypen (Enumeration Types)
Stefan Brass: OOP (Java), 22. Aufzählungstypen 1/20 Objektorientierte Programmierung Kapitel 22: Aufzählungstypen (Enumeration Types) Stefan Brass Martin-Luther-Universität Halle-Wittenberg Wintersemester
MehrInnere Klassen. Gerd Bohlender. Institut für Angewandte und Numerische Mathematik. Vorlesung: Einstieg in die Informatik mit Java
Innere Klassen Gerd Bohlender Institut für Angewandte und Numerische Mathematik Vorlesung: Einstieg in die Informatik mit Java 13.06.07 G. Bohlender (IANM UNI Karlsruhe) Innere Klassen 13.06.07 1 / 11
MehrEinführung in GUI-Programmierung. javax.swing
Einführung in GUI-Programmierung javax.swing GUI Graphical User Interface ( Grafische Benutzerschnittstelle ) Anschaulichere und leichtere Möglichkeit zur Dateneingabe und Kontrolle von Programmen Stellt
MehrInstitut für Programmierung und Reaktive Systeme. GUIs mit Swing. Markus Reschke
GUIs mit Swing Markus Reschke 28.08.2014 Beispiel: Ein einfaches GUI-Programm Siehe Painter.java Markus Reschke GUIs mit Swing 2 GUI Frameworks in Java AWT war das erste GUI-Framework, welches mit Java
MehrDeklaration einer Klasse Innere innerhalb Klassen einer in Ja anderen v a Klasse
Innere Klassen in Java Java 1.0: nur top-level Klassen Seit Java Version 1.1: Innere Klassen Deklaration einer Klasse innerhalb einer anderen Klasse Illustration Eigenschaften Vorteile Anwendungsmöglichkeiten
MehrObjektorientierte Programmierung
Objektorientierte Programmierung Exkurs: Graphische Benutzeroberflächen FH Braunschweig/Wolfenbüttel Sommersemester 2009 1 / 22 Gliederung I Wiederholung Klassen, Objektorientierung (Kapitel 10,11) Exkurs:
MehrMultimedia im Netz Wintersemester 2012/13
Multimedia im Netz Wintersemester 2012/13 Übung 10 Ludwig-Maximilians-Universität München Multimedia im Netz WS 2012/13 - Übung 10-1 Lösung zu Übungsblatt 08 Ludwig-Maximilians-Universität München Multimedia
MehrRepetitorium Informatik (Java)
Repetitorium Informatik (Java) Tag 6 Lehrstuhl für Informatik 2 (Programmiersysteme) Übersicht 1 Klassen und Objekte Objektorientierung Begrifflichkeiten Deklaration von Klassen Instanzmethoden/-variablen
MehrJavakurs für Fortgeschrittene
Javakurs für Fortgeschrittene Einheit 07: Nebenläufigkeit Lorenz Schauer Lehrstuhl für Mobile und Verteilte Systeme Heutige Agenda Einführung in die Nebenläufigkeit und Java Thread Konzept: Motivation
MehrEinstieg in die Informatik mit Java
1 / 13 Einstieg in die Informatik mit Java Schnittstellen Gerd Bohlender Institut für Angewandte und Numerische Mathematik Gliederung 2 / 13 1 Einführung 2 Definition einer Schnittstelle 3 Implementierung
MehrTeil 2: Weitere Aspekte der Objektorientierung
Teil 2: Weitere Aspekte der Objektorientierung Klassenvariablen So wie es Instanzvariablen gibt, die zu einer gewissen Instanz (Objekt) gehören und deren Attribute speichern, so gibt es aus Klassenvariablen:
MehrObjektorientierung II & die Java Klassenbibliothek. Kristian Bergmann und Arthur Lochstampfer
Java Kurs Objektorientierung II & die Java Klassenbibliothek Kristian Bergmann und Arthur Lochstampfer Vergleich class Apfel { String farbe; int gewicht; String geerntetin; class Erdbeere { String farbe;
MehrZentrale Objekte zur Programmierung graphischer Benutzeroberflächen (GUI)
1 JAVA für Bauingenieure Alexander Karakas SS 2008 Zentrale Objekte zur Programmierung graphischer Benutzeroberflächen (GUI) 21.05.2008 2 Was ist ein(e) GUI? GUI = Graphical User Interface = Graphische
MehrWiederholung. Klassenhierarchie:
Wiederholung Klassenhierarchie: class Unter extends Ober {... Die Unterklasse Unter erweitert die Funktionalität ihrer Oberklasse Ober. Objekte der Klasse Unter können anstelle von Objekten der Klasse
MehrJavakurs für Anfänger
Javakurs für Anfänger Einheit 13: Interfaces Lorenz Schauer Lehrstuhl für Mobile und Verteilte Systeme 1. Teil: Interfaces Motivation Eigenschaften Besonderheiten Anonyme Klassen Lambda-Ausdrücke Praxis:
MehrDie abstrakte Klasse Expression:
Die abstrakte Klasse Expression: Expression abstract evaluate() Add Neg Const 501 Die abstrakte Klasse Expression: Expression abstract evaluate() Add Neg Const Leider (zum Glück?) lässt sich nicht die
MehrEinstieg in die Informatik mit Java
1 / 16 Einstieg in die Informatik mit Java Innere Klassen Gerd Bohlender Institut für Angewandte und Numerische Mathematik Gliederung 2 / 16 1 Einführung 2 Element-Klassen 3 Lokale Klassen 4 Anonyme Klassen
Mehr