Java Dingsda

Kettle Pentaho PDI mit SAP Verbindung einrichten

2017-08-03T23:13:00.001+02:00

Dieser Artikel beschreibt wie die Kettle Penthao PDI eingerichtet werden muss um mit einem SAP System per RFC zu kommunizieren. Weiterhin wird ein kurzer Blick auf die Vorgehensweise von Kettle bei der Informationsbeschaffung der Übergabeparameter und deren Typen gerichtet. Die Einrichtung erfolgt am Beispiel einer Windows 10 64-Bit Version.

Schritt 1: Kettle Pentaho PDI downloaden und entpacken
Schritt 2: In den Umgebungsvariablen von Windows sollten die Variablen JAVA_HOME und PENTAHO_JAVA gesetzt sein. Beide müssen auf das Verzeichniss des Java Runtime Enviroments (JRE) zeigen.
Beispiel:
JAVA_HOME = c:\Programm Files\Java\jre8
PENTAHO_JAVA = c:\Programm Files\Java\jre8

Es sollte die Java Installation genutzt werden, die zu dem Betriebssystem passt z.B. 64 Java Version zum 64 Bit Betriebssystem.

Schritt 3: Für die Kommunikation von Kettle mit dem SAP System wird der SAP Java Connector (JCo) benötigt. Dieser kann bei SAP heruntergeladen werden. Voraussetzung ist ein SAP Service Marketplace Zugang, den viele SAP Kunden besitzen. Es sollte auf die rfichtige Betriebssystem Version geachtet werden. Für das o.g. Beispiel wird die Windows 64 Bit Version benötigt. Es sollte immer die version des Betriebssystems gewählt werden, da Kettle sich automatich per Batch Datei auf das richtige System einstellt.
Der JCo wird in einer ZIP Datei geliefert. Diese muss entpackt werden um vier Dateien daraus zu kopieren. Diese sind:

sapjco3.dll
sapjco3.jar
sapjco3.pdb
sapjcomanifest.mf

Schritt 4: Dateien in das lib Verzeichniss kopieren. Die im Schritt 3 heruntergeladenen Dateien müssen in daslib Verzeichniss der Kettle Installation kopiert werden.

Schritt 5: Verbindung einrichten und testen

Verbindungsaufbau und laden von Funktionsbausteinen

Wenn Kettle nach einem Funktionsbausein sucht und dessen Parameter anzeigen möchte werden folgende Funktionsbausteine im Hintergurnd aufgerufen:

RFCPING
RFC_GET_FUNCTION_INTERFACE
DDIF_FIELDINFO_GET
RFC_FUNCTION_SEARCH
RFC_GET_NAMETAB

Falls irgendwas nicht richtig läfut kann das externe Debugging im SAP einschaltet werden um einen externen Breakpoint zu setzen. Anschließen können im Debug Modus Eingabe und Ausgabeparemeter der jeweiligen Funktionsbausteine überprüft werden. Oft ist die Stelle an der die Exception oder der Fehelr auftritt aussagekräftiger als die Fehlermeldung selbst. Ein Beispiel hierfür ist der Fehler TABLE_NOT_ACTIVE, welcher hier beschrieben wird.
Buzzwords: Penthao, Kettle, Spoon, SAP, JCo

Eclipse RCP - Heapspace vergrößern

2013-10-17T23:02:00.000+02:00

Version: Eclipse 3.7 Helios

Problembeschreibung: Heapspace einer Eclipse RCP oder eine normalen Java Anwendung vergrößern. Es soll sowohl der minimale Speicherverbrauch als auch der Maximale geändert/vergößert werden.

Fallunterscheidung: Applikationsstart aus der Entwicklungsumgebung oder Applikationsstart durch Aufruf einer Executable ("appName.exe") oder von der Kommandozeile aus.

Entwicklungsumgebung

Diese Einstellung bewirkt, dass Java Projekte und im speziellen Eclipse RCP Projekte mit gewünschtem minimal und maximal Speicher aus der Entwiclungsumgebung gestartet werden.

Vorgehensweise

Schritt 1.

Erzeuge ein Eclipse RCP Projekt oder ein Java Projekt.

Schritt 2.

Rechtsklick auf das Projekt. Im Kontextmenü "Run As" und anschließend "Run Configurations..." auswählen. Siehe Bild 1.

Bild 1

Schritt 3.

Den Reiter "Arguments" wie in Bild 2 für die gewünschte Konfiguration öffenen. Punkt 1 im Bild muss ausgewählt werden für eine Eclipse RCP Applikation, Punkt 2 entsprechend für eine normales Java Projekt.

Bild 2

Die Textbox "VM arguments" sollte dan folgende zwei Argumente besitzen -Xms40m und -Xmx512m. Xms gibt dabei den minimalen Heapspeicher an und Xmx den maximalen. Hier im Beispiel erfolgen die Angaben in Megabyte, da jeweils immer ein 'm' angegeben ist. Es sind ebenfalls Angaben in Kilobyte mit 'k' und in Gigabyte mit 'g' möglich. Ob Gros- oder Kleinbuchstaben bei der Gößenangebe benutzt werden spielt keine Rolle. Es ist deshalb -Xmx512m gleichwertig mit -Xmx512M

Applikationssstart über die Kommandozeile (in Windows cmd.exe)

Beim Starten einer Applikation von der Kommandozeile werden die Argumente in den Java interpreter Aufruf übergeben. In Bild 3 sehen wir ein Beispielaufruf der test.jar.

Bild 3

Applikationssstart durch eine Executable

Wird eine Eclipse RCP exportiert und dadurch ohne die Entwicklungsumgebung lauffähig gemacht, dann müssen die beiden Paremeter -Xms und -Xmx in der Product Configuration im Reiter Launching eingetragen werden. Dies ist in Bild 4 zu sehen.

Bild 4

Quellen:
http://javarevisited.blogspot.de/2011/11/hotspot-jvm-options-java-examples.html

Java - aus currentTimeMillis in formatierten Datum Srting

2013-09-10T23:00:00.000+02:00

Aufgabe:
Erzeuge aus der Milisekundenangabe des Systems (long java.lang.System.currentTimeMillis() ) einen Formatierten Datum String in der Form YYYYMMDD wobei YYYY = Jahr, MM = Monat, DD = Tag. Beispiele 20130213, 19990131, usw.

Lösung:

String formatedDate = new SimpleDateFormat("yyyyMMdd")
                        .format(new Date(System.currentTimeMillis());

Eclipse RCP E4 - Erste Anwendung

2013-03-21T00:02:00.000+01:00

Aufgabe: Erste RCP E4 Applikation erstellen. Es handels sich hierbei um ein generiertes Eclipse Application Project

Schritt 1: Im Menü File->New->Other... auswählen. Anschließend wie im Bild zu sehen Eclipse 4 Application Project auswählen. und Anschließend mit Next bestätigen

Abbildung 1

Schritt 2: Projektnamen unter ID eingeben und mit Next bestätigen.

Abbildung 2

Schritt 3: Mit Finish Projekt erzeugen

Abbildung 3

Schritt 4: Das Projekt wird gestartet durch einen Klick auf Launch an Eclipse application (Abblidung 5) in der Product Overview (Abbildung 4)

Abbildung 4

Abbildung 5

Fehlerbehebung: Sollten beim Ausführen Fehler auftreten (wie in Abbildung 6 und Listing 1 gezeigt), könnte der unten beschriebene Schritt helfen diese zu beheben.

Abbildung 6

Listing 1


!SESSION 2013-03-20 22:18:54.415 -----------------------------------------------
eclipse.buildId=unknown
java.version=1.7.0_13
java.vendor=Oracle Corporation
BootLoader constants: OS=win32, ARCH=x86, WS=win32, NL=de_DE
Framework arguments:  -product com.blogspot.javadingsda.firste4.product
Command-line arguments:  -product com.blogspot.javadingsda.firste4.product -data C:\Users\Steffi\workspace/../runtime-com.blogspot.javadingsda.firste4.product -dev file:C:/Users/Steffi/workspace/.metadata/.plugins/org.eclipse.pde.core/com.blogspot.javadingsda.firste4.product/dev.properties -os win32 -ws win32 -arch x86 -consoleLog

!ENTRY org.eclipse.equinox.app 0 0 2013-03-20 22:18:56.599
!MESSAGE Product com.blogspot.javadingsda.firste4.product could not be found.

!ENTRY org.eclipse.osgi 2 0 2013-03-20 22:18:56.663
!MESSAGE One or more bundles are not resolved because the following root constraints are not resolved:
!SUBENTRY 1 org.eclipse.osgi 2 0 2013-03-20 22:18:56.663
!MESSAGE Bundle initial@reference:file:plugins/org.eclipse.e4.ui.services_0.10.3.v20130123-162658.jar was not resolved.
!SUBENTRY 2 org.eclipse.e4.ui.services 2 0 2013-03-20 22:18:56.663
!MESSAGE Missing imported package org.w3c.dom.css_2.0.0.
!SUBENTRY 1 org.eclipse.osgi 2 0 2013-03-20 22:18:56.663
!MESSAGE Bundle initial@reference:file:plugins/org.eclipse.e4.ui.css.swt.theme_0.9.4.v20130123-162658.jar was not resolved.
!SUBENTRY 2 org.eclipse.e4.ui.css.swt.theme 2 0 2013-03-20 22:18:56.663
!MESSAGE Missing imported package org.w3c.dom.css_2.0.0.
!SUBENTRY 1 org.eclipse.osgi 2 0 2013-03-20 22:18:56.663

...

!SUBENTRY 2 com.blogspot.javadingsda.firste4 2 0 2013-03-20 22:18:56.756
!MESSAGE Missing required bundle org.eclipse.e4.ui.css.core_0.10.2.

!ENTRY org.eclipse.osgi 4 0 2013-03-20 22:18:56.756
!MESSAGE Application error
!STACK 1
java.lang.RuntimeException: No application id has been found.
 at org.eclipse.equinox.internal.app.EclipseAppContainer.startDefaultApp(EclipseAppContainer.java:242)
 at org.eclipse.equinox.internal.app.MainApplicationLauncher.run(MainApplicationLauncher.java:29)
 at org.eclipse.core.runtime.internal.adaptor.EclipseAppLauncher.runApplication(EclipseAppLauncher.java:110)
 at org.eclipse.core.runtime.internal.adaptor.EclipseAppLauncher.start(EclipseAppLauncher.java:79)
 at org.eclipse.core.runtime.adaptor.EclipseStarter.run(EclipseStarter.java:353)
 at org.eclipse.core.runtime.adaptor.EclipseStarter.run(EclipseStarter.java:180)
 at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
 at sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source)
 at sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source)
 at java.lang.reflect.Method.invoke(Unknown Source)
 at org.eclipse.equinox.launcher.Main.invokeFramework(Main.java:629)
 at org.eclipse.equinox.launcher.Main.basicRun(Main.java:584)
 at org.eclipse.equinox.launcher.Main.run(Main.java:1438)
 at org.eclipse.equinox.launcher.Main.main(Main.java:1414)
An error has occurred. See the log file

Fehlerursache 1: Unter Product Dependencies fehlen Plugins, die über den Button Add Required Plug-ins hinzugefügt werden können.
Das Plugin selbst (im Beispiel ist es com.blogspot.javadingsda.firste4) muss ebenfalls vorhanden sein.

Eclipse E4 Tutorial - Eclipse vorbereiten

2013-03-16T22:19:00.000+01:00

Aufgabe: Das Plugin Eclipse E4 Tools installieren.

Schritt 1: Install Dialog aufrufen

Im Menü Help -> Install New Software... ausführen

Schritt 2: Downloadlocation hinzufüguen

Downloadlocation für Installation von Eclipse E4 Tools hinzufügen:

http://download.eclipse.org/e4/downloads/drops/R-0.12-201206131100/repository

Schritt 3: Tools auswählen

Folgendes Tool sollte installiert werden.

E4 Tools -> Eclipse E4 Tools (Incubation) auswählen und mit Next bestätigen.

Schritt 4: Lizenzbestimmungen zustimmen und weiter mit Finish

Schritt 5: Eclipse neustarten

Der Tipp dieses Tool einzusetzen wird im Eclipse E4 Tutorial von http://eclipsesource.com erwähnt.

Eclipse RCP - Textboxen zur Schriftgröße unter Windows anpassen

2013-01-14T00:01:00.002+01:00

Artikelinhalt:Anpassen von Widgets wie Textboxen (org.eclipse.swt.widgets.Text) oder Labels (org.eclipse.swt.widgets.Label) an die Bildschirmauflösung.

Problembeschreibung: in Windows hat der Benutzer einer Eclipse RCP Anwendung die Möglichkeit die Schriftgröße in Standartapplikationen anzupassen. Unter Windows 7 ist dies in Systemsteuerung\Alle Systemsteuerungselemente\Anzeige möglich, indem die Textgröße auf Mittel 125% oder Größer 150% eingestellt wird. Weiterhin kann ein Benutzer auch unter Benutzerdefinierte Textgröße (DPI) festlegen die größe beliebig skalieren. Werden Widgets mit fester Größe erzeugt, so kann es vorkommen, dass ein Text im Label nicht mehr vollständig angezeigt wird.

Zu beachten ist, dass hier nicht die Schriftgröße skaliert wird, sonder die Auflösung (Anzahl der Bildpunkte oder oft auch DPI oder PPI genannt). In dieser Erkenntnis liegt auch die Lösung für das Problem.

Lösungsansatz: Mit Hilfe der Toolkit AWT Klasse ist es möglich die Bildschirmauflösung abzufragen. Unter Windows 7 ist die Textgröße von 100% gleichzusetzen mit 96 DPI. Die Textgröße von 150% entspricht dann 144 DPI.

Mit folgenden zwei Zeilen kann der DPI Wert ermittelt werden.


Toolkit tk = Toolkit.getDefaultToolkit();
System.out.println("Screen resolution = " + tk.getScreenResolution());

Beispielanwendung:

Schritt 1: Erzeuge eine Eclipse RCP Applikation mit den Namen com.blogspot.javadingsda.getweindowdpiaus aus dem Template RCP Application with a view

Schritt 2: Ändere die Klasse View wie folgt ab:


package com.blogspot.javadingsda.getweindowdpi;

import java.awt.Toolkit;

import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Text;
import org.eclipse.ui.part.ViewPart;

public class View extends ViewPart {
 public static final String ID = 
           "com.blogspot.javadingsda.getweindowdpi.view";

 public void createPartControl(Composite parent) {
  
  Toolkit tk = Toolkit.getDefaultToolkit();
  int resolution = tk.getScreenResolution();
  double factor = ((double)resolution) / 96;
  
  parent.setLayout(new GridLayout(1, false));
  
  // Text der sich der Auflösung anpasst
  Text textBox = new Text(parent,SWT.BORDER);
  GridData gdTextBox = new GridData();
  gdTextBox.widthHint = (int)(54 * factor);
  textBox.setLayoutData(gdTextBox);
  textBox.setText("Teststring!");
  
  // Text der sich nicht anpasst 
  Text textBox2 = new Text(parent,SWT.BORDER);
  GridData gdTextBox2 = new GridData();
  gdTextBox2.widthHint = 54;
  textBox2.setLayoutData(gdTextBox2);
  textBox2.setText("Teststring!");
  
 }

 public void setFocus() {
 }
}

Schritt 3: Die Schriftgröße wie oben genannt in Windows ändern und Anwendung ausprobieren. Das obere Text Feld sollte sich anpassen, während das untere immer die gleiche Größe behält.

Eclipse RCP / SWT - TreeViewer Sortierreihenfolge Teil 2

2012-12-05T23:58:00.001+01:00

Eclipse 3.7

Problem: Knoten im TreeViewer sollen sortiert werden.

Lösung: Der ViewSorter erledigt die Sortierung. In unserem Beispiel werden die Knoten alphabetisch sortiert. Im ersten Teil dieses Artikels wurde ein Beispiel vorbereitet. Im diesem Teil soll die Sortierung hinzugefügt werden.

Schritt 1: Erzeuge die Klasse StructureViewerComparator.


import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerComparator;

public class StructureViewerComparator extends ViewerComparator {

  @Override
  public int compare(Viewer viewer, Object e1, Object e2) {
    if ((e1 instanceof MyTreeNode) && (e2 instanceof MyTreeNode)){
      return e2.toString().compareTo(e1.toString());
    }
    return 0;
  }
}

Schritt 2: In der View Klasse, wird in der createPartControl Methode dem Viewer ein neuer Comparator vom Typ StructureViewerComparator hinzugefügt.


 
public void createPartControl(Composite parent) {
  viewer = new TreeViewer(parent, SWT.MULTI | SWT.H_SCROLL
    | SWT.V_SCROLL);
  viewer.setContentProvider(new TreeContentProvider());
  viewer.setInput(new MyTreeNode(0,""));
  viewer.setComparator(new StructureViewerComparator()); //Comparator hinzugefügt
}

Schritt 3: Code ausführen!

Eclipse RCP / SWT - TreeViewer Sortierreihenfolge Teil 1

2012-12-05T23:57:00.000+01:00

Eclipse 3.7

Problem: Knoten im TreeViewer sollen sortiert werden.

Lösung: Der ViewSorter erledigt die Sortierung. In unserem Beispiel werden die Knoten alphabetisch sortiert. Im ersten Teil dieses Artikels wird ein Beispiel vorbereitet. Im zweiten die Sortierung hinzugefügt.

Schritt 1: Erstelle die einfache TreeViewer Anwendung aus diesem Blog.

Schritt 2: Im zweiten Schritt wird das Modell der Knoten etwas abgeändert, damit eine Sortierung später nötig wird. Dazu wird der Klasse MyTreeNode ein Attribut prefix hinzugefügt, welches im Konstruktor initialisiert wird.


public class MyTreeNode {
 private int depth;
 private MyTreeNode parent = null;
 private ArrayList children;
 private String prefix; // neues Attribut

        //Übergabeparameter an den Konstruktor werden geändert 
 public MyTreeNode(int depth, String prefix) { 
  children = new ArrayList();
  this.prefix = prefix; // Initialisierung
  this.depth = depth;
 }

 ...

 public String toString() {
  StringBuffer sb = new StringBuffer();
  sb.append(prefix + " Knoten mit Tiefe ");
  sb.append(String.valueOf(depth));
  return sb.toString();
 }
        ...
}

Schritt 3: Im letzten Schritt wird an allen Stellen, an denen der Konstruktor aufgerufen wird der zweite Übergabeparameter mit einem willkürlichem String gefüllt. Dazu wird in der Klasse TreeContentProvider die Methode createChildNodes(Object parent) wie folgt geändert.


public class TreeContentProvider implements ITreeContentProvider {

...         

  public void createChildNodes(Object parent) {
    if (parent instanceof MyTreeNode) {
      MyTreeNode node = (MyTreeNode)parent;
      node.addChild(new MyTreeNode(node.getDepth() + 1, "1")); // zweiter 
      node.addChild(new MyTreeNode(node.getDepth() + 1, "5")); // Parameter 
      node.addChild(new MyTreeNode(node.getDepth() + 1, "3")); // mit beliebigen 
      node.addChild(new MyTreeNode(node.getDepth() + 1, "z")); // Werten
    }
  }
}

und zuletzt in der View Klasse die Methode createPartControl wie folgt geändert:


public void createPartControl(Composite parent) {
  viewer = new TreeViewer(parent, SWT.MULTI | SWT.H_SCROLL
    | SWT.V_SCROLL);
  viewer.setContentProvider(new TreeContentProvider());
  viewer.setInput(new MyTreeNode(0,"")); // hier ebenfalls aktualisiert
}

Eclipse RCP - 4.2 Juno Bug bei Applikation mit Template

2012-11-25T01:41:00.000+01:00

Problem: Nach der Installation von Eclipse Juno 4.2 RCP Developer Version treten beim Erstellen von Eclipse RCP Applikationen aus einem Template heraus mehrere Fehler auf.

Diese sehen wie folgt aus:


!ENTRY org.eclipse.e4.ui.workbench 4 0 2012-11-25 00:42:28.600
!MESSAGE Unable to retrieve the bundle from the URI: 
bundleclass://org.eclipse.e4.ui.workbench.addons.swt
/org.eclipse.e4.ui.workbench.addons.cleanupaddon.CleanupAddon


!ENTRY org.eclipse.e4.ui.workbench 4 0 2012-11-25 00:42:28.600
!MESSAGE Unable to retrieve the bundle from the URI: 
bundleclass://org.eclipse.e4.ui.workbench.addons.swt
/org.eclipse.e4.ui.workbench.addons.dndaddon.DnDAddon

!ENTRY org.eclipse.e4.ui.workbench 4 0 2012-11-25 00:42:28.600
!MESSAGE Unable to retrieve the bundle from the URI: 
bundleclass://org.eclipse.e4.ui.workbench.addons.swt
/org.eclipse.e4.ui.workbench.addons.minmax.MinMaxAddon

Schritte um das Problem nachzustellen:

Schritt 1: Download von Eclipse Juno (hier: Build id: 20120614-1722)

Schirtt 2: Komprimierte Datei entpacken und Eclipse starten

Schritt 3: Ein Plugin Projekt erstllen der auf dem Template "RCP application with a view" basiert.

Schritt 4: Pluginprojekt ausführen. In der Standardausgabe erscheinen dann die Fehlermeldungen.

Schritte für eine Lösung

Lösungsschritt 1: das plugin org.eclipse.e4.ui.workbench.addons.swt unter Dependencies im MANIFEST.MF hinzufügen siehe Abbildung 1.

Abbildung 1

Lösungsschritt 2:Speichern und Eclipse RCP Applikation ausführen. Fertig!

Dieser Artikel basiert auf der folgenden Quelle (Stand: 25.11.2012) : https://bugs.eclipse.org./bugs/show_bug.cgi?id=369073

Eclipse RCP - Datei im Bundle öffnen

2012-11-08T22:32:00.001+01:00

Eclipse Version 3.7

Problem: Wie öffne ich eine Datei, die sich im Bundle/meiner RCP Applikation befindet. In der Beispielanwendung wird eine BMP Datei geöffnet.

Schritt 1: Verzeichnis mit BMP Datei anlegen

Die Datei befindet sich im Rootverzeichnis des Projekts. Bild 1 zeigt eine Projektstruktur mit dem Verzeichnis myfiles und einer Bilddatei picture.bmp

Bild 1

Schritt 2: Build Configuration anpassen

In der Build Configuration des plugin.xml im Binary Build muss das Verzeichnis mit eingebunden sein. (Bild 2)

Bild 2

Schritt 3: Ausführenden Code einfügen

Der Quellcode kann z.B. in einen Command Handler eingefügt werden. Es wird die Standardapplikation für den jeweiligen Dateityp gestartet. Diese muss vorher im Betriebssystem definiert sein. In Windows ist dies z.B. Paint.


  URL fileURL = null;
  try {
    fileURL = FileLocator
               .toFileURL(Activator.getDefault()
               .getBundle()
               .getEntry("myfiles/picture.bmp"));
    String filePath = fileURL.getPath();

    File file = new File(filePath);
    Desktop.getDesktop().open(file);
  } catch (IOException e) {
     e.printStackTrace();
  }

Ein alternativer Code der die gleiche Wirkung hat wird im Codeache Blog von Hugo Corbucci beschrieben.


  Bundle bundle = Activator.getDefault().getBundle();
  Path path = new Path("myfiles/picture.bmp"); //$NON-NLS-1$
  URL url = FileLocator.find(bundle, path, Collections.EMPTY_MAP);
  URL fileUrl = null;
  try {
    fileUrl = FileLocator.toFileURL(url);
    File file = new File(fileUrl.getPath());
    Desktop.getDesktop().open(file);
  } catch (IOException e) {
    e.printStackTrace();
  }

Schritt 4: Ausführen. Fertig!

Eclipse RCP - Command und bedingtes Anzeigen von Menüeinträgen

2012-11-05T18:00:00.000+01:00

Problem: Die Applikation zeigt Menüs oder Contextmenüs (MenuContribution) an, die in Abhängigkeitei von der Selektion oder anderen Kriteren einen Menüeintrag (Command) Anzeigen soll. Die Commands sind deklarativ definiert.

Ein konkreteres Szenario könnte wie folgt aussehen:

Beim Rechtsklick auf ein Objekt in einem TreeViewer oder einen Tabelleneintrag im TableViewer soll ein Attribut aus dem jeweiligen Objekt abgefragt werden (test).

Lösung:

Diese Lösung ist nicht zu 100% deklarativ. Jedoch stellt diese einen kurzen und übersichtlichen Weg dar.

Schritt 1:
In der Handler Klasse muss die Methode isEnabled() überschrieben werden und immer dann true zurückliefern, wenn der Menüeintrag angezeigt werden soll. In allen Anderen Fällen muss diese Methode ein false zurückliefern.

Schritt 2:
In der Datei plugin.xml muss im Tag MenuContribution das Command wie folgt definiert sein:


 <command 
       commandid="com.blogger.javadingsda.beispielCommand" 
       label="Menüeintrag">
    <visiblewhen checkenabled="true"></visiblewhen>
 </command>

(... Fortsetzung mit einem ausführlichen Beispiel folgt)

Labels:

visibleWhen, property, test, expressions framework, command core expressions

Eclipse RCP - There is no handler to execute for command

2012-11-03T23:30:00.000+01:00

Eclipse Version 3.7

Problem: Ihr habt ein Command angelegt. Zusätzlich habt ihr ein Handler zum Command angelegt und eine Klasse zum Handler erstellt die org.eclipse.core.commands.IHandler oder org.eclipse.core.commands.IHandler2 implementiert bzw. vom org.eclipse.core.commands.AbstractHandler erbt. Diese Klasse ist beim Handler eingetragen. Eigentlich sollte dann alles laufen, ihr erhält aber dennoch eine Exception mit dem Text "There is no handler to execute for command...".
Lösung:

In der Klasse die zum Händler gehört muss die Methode istHandled() ein true zurückgeben, da sonst das Fremework eine NotHandledException wirft. Wenn es nicht unbedingt nötig sollte man auf das Überschreiben der isHandled Methode verzichten bzw. vom Abstract Handler erben.


@Override
public boolean isHandled() {

    return true;

}

Dieser Artikel basiert auf dem Forumbeitrag http://slopjong.de/2010/04/01/there-is-no-handler-to-execute-for-command/

Eclipse RCP - SWT ScrolledComposite schneller scrollen

2012-09-07T14:49:00.001+02:00

Die Codezeile Zeigt wie ein ScrolledComposite dazu gebracht werden kann schneller über die Buttons zu Scrollen. Das Beispiel scrollt die ScrolledComposite sc vertikal fünf mal schneller.

sc.getVerticalBar().setIncrement(sc.getVerticalBar().getIncrement()*3);

Quelle: http://www.richclient2.de/2006_10_03/scrolledcomposite-and-the-mouse-wheel/

Reguläre Ausdrücke

2012-08-20T13:15:00.000+02:00

Habe neulich ein Tutorial für Reguläre Ausdrücke gesucht und bin fündig geworden. Da ich der Meinung bin, dass ein gutes Tuorial es verdient verlinkt zu werden hier der Link zum Tutorial.

Eclipse RCP - Fenster Applikationsname ändern programmatisch

2012-07-31T23:30:00.000+02:00

Dieses kurze Tutorial zeigt wie in einer Eclipse RCP Anwendung der Titel im Fenster beim Start via Code (programmatisch) geändert werden kann.

Eclipse Version 3.7

Schritt 1: RCP Applikation mit dem Namen com.blogspot.javadingsda.windowtitle aus der Vorlage 'RCP application with a view' erstellen.

Schritt 2: Füge in der Klasse ApplicationWorkbenchAdvisor in der Methode createWorkbenchWindowAdvisor die Zeile configurer.setTitle("My Title!"); hinzu.


public class ApplicationWorkbenchAdvisor extends WorkbenchAdvisor {
 
 @Override
 public WorkbenchWindowAdvisor createWorkbenchWindowAdvisor(
                                 IWorkbenchWindowConfigurer configurer) {
   configurer.setTitle("My Title!"); 
   return new ApplicationWorkbenchWindowAdvisor(configurer);
 }

 @Override
 public String getInitialWindowPerspectiveId() {
  return Perspective.ID;
 } 
}

Schritt 3: Kompilieren und testen!

Eclipse RCP - Widgets in der Statusleiste (StatusLine/Statusbar)

2012-03-29T23:37:00.000+02:00

Eclipse Version 3.7

Dieser Artikel zeigt wie eine Statusleiste(im folgenden Text auch Statusline genannt) aktiviert werden kann und wie einige Widgets zu dieser hinzugefügt werden können.

Problemstellung:

In der Statusleiste einer Eclipse RCP Anwendung soll eine Textbox mit einer Schaltfläche (Button) erscheinen. Beim Klick auf die Schalfläche soll der Text aus der Textbox in der view erscheinen.

Lösung
Es gibt zwei wichtige Schritte die beachtet werden müssen, um eine Statusleiste zu erzeugen. Erstens muss in der Klasse, die vom WorkbenchWindowAdvisor erbt (in unserem Beispiel ist es die Klasse ApplicationWorkbenchWindowAdvisor) in der Methode preWindowOpen die Anzeige der Statusline aktiviert werden. Zweitens muss die Methode fillStatusLine in er Klasse ApplicationActionBarAdvisor überschrieben werden um dort eine ControlContribution einzufügen, die den Ihnalt der Statusleiste repräsentiert. Alle nötigen Schritte werden unten genauer beschrieben.

Schritt 1
Erzeuge eine RCP Application aus dem Template RCP Eclipse Application with a view mit dem Namen com.blogspot.javadingsda.statusline.

Schritt 2
Erzeuge die Klasse StatusLineTextBox. Diese repräsentiert die Statuszeile.


package com.blogspot.javadingsda.statusline;

import org.eclipse.jface.action.ControlContribution;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Text;

public class StatusLineTextBox extends ControlContribution {

 Text textBox;
 private View view;

 public StatusLineTextBox(String str) {
  super(str);
 }

 @Override
 protected Control createControl(Composite parent) {

  textBox = new Text(parent, SWT.BORDER );
  textBox.setText("hier was eingeben!");
  
  Button button = new Button(parent, SWT.NONE);
  button.setText("Text oben ausgeben");
  button.addSelectionListener(new SelectionAdapter() {
   public void widgetSelected(SelectionEvent e) {
    view.setText(textBox.getText());
    view.update();
   }
  });

  return textBox;
 }

 public void addView(View view) {
  this.view = view;
 }
}

Schritt 3
Füge zur Klasse ApplicationActionBarAdvisor die Methode fillStatusLine hinzu. Die Klasse sollte wie folgt aussehen:


package com.blogspot.javadingsda.statusline;

import org.eclipse.jface.action.IStatusLineManager;
import org.eclipse.ui.application.ActionBarAdvisor;
import org.eclipse.ui.application.IActionBarConfigurer;

public class ApplicationActionBarAdvisor extends ActionBarAdvisor {

 public static StatusLineTextBox textBox = new StatusLineTextBox("MyBox");
 public ApplicationActionBarAdvisor(IActionBarConfigurer configurer) {
  super(configurer);
 }
 
 @Override
 protected void fillStatusLine(IStatusLineManager statusLine) {
  super.fillStatusLine(statusLine);
  statusLine.add(textBox);
 }
}

Schritt 4


package com.blogspot.javadingsda.statusline;

import org.eclipse.swt.graphics.Point;
import org.eclipse.ui.application.ActionBarAdvisor;
import org.eclipse.ui.application.IActionBarConfigurer;
import org.eclipse.ui.application.IWorkbenchWindowConfigurer;
import org.eclipse.ui.application.WorkbenchWindowAdvisor;

public class ApplicationWorkbenchWindowAdvisor extends WorkbenchWindowAdvisor {

 public ApplicationWorkbenchWindowAdvisor(
   IWorkbenchWindowConfigurer configurer) {
  super(configurer);
 }

 public ActionBarAdvisor createActionBarAdvisor(
   IActionBarConfigurer configurer) {
  return new ApplicationActionBarAdvisor(configurer);
 }

 @Override
 public void preWindowOpen() {
  IWorkbenchWindowConfigurer configurer = getWindowConfigurer();
  configurer.setInitialSize(new Point(400, 300));
  configurer.setShowCoolBar(false);
  configurer.setShowStatusLine(true); // auf true setzen
  configurer.setTitle("RCP Application");
 }
}

Schritt 5
Anschließend muss nur noch die View modifiziert werden.


package com.blogspot.javadingsda.statusline;

import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Label;
import org.eclipse.ui.part.ViewPart;

public class View extends ViewPart {
 public static final String ID = "com.blogspot.javadingsda.statusline.view";

 private String text = "Testmich!";

 private Label l1;

 public void createPartControl(Composite parent) {
  ApplicationActionBarAdvisor.textBox.addView(this);
  l1 = new Label(parent, SWT.NONE);
  l1.setText(text);
 }

 public void setFocus() {}

 public void setText(String text) {
  this.text = text;
 }

 public void update() {
  l1.setText(text);
 }
}

Anwendung ausführen. Fertig!

Dieser Artikel basiert auf den folgenden Quellen: www.java-tips.org und www.saxonysoft.de

Eclipse RCP - TreeViewer drag and drop (DnD)

2012-03-06T23:42:00.002+01:00

Eclipse Version 3.7 (Indigo)

In diesem Artikel (Tutorial) wird ein einfaches 'Drag and Drop' Beispiel mit einem TreeViewer gezeigt.

Problem:
In einem TreeViewer sollen die Knoten per 'Drag and Drop' umgeordnet werden. Es soll möglich sein, einen Knoten des TreeViewer gezielt vor oder hinter einen anderen Knoten einzufügen. Es ist nicht möglich die Knoten eines TreeViewer zwischen zwei Fenstern zu schieben. Sollte ein Interesse an solch einem Tutorial bestehen, dann schickt mir bitte eine kurze Info per Mail.

Schritt 1:
RCP Applikation mit dem Namen com.blogspot.javadingsda.dndfirst aus der Vorlage 'RCP application with a view' erstellen.

Schritt 2:
Entferne alle inneren Klassen, Methoden und Attribute aus der View Klasse und ersetze sie durch den unten aufgeführten Code. Die View Klasse sollte wie folgt aussehen.


package com.blogspot.javadingsda.dndfirst;

import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.dnd.DND;
import org.eclipse.swt.dnd.TextTransfer;
import org.eclipse.swt.dnd.Transfer;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.ui.part.ViewPart;

public class View extends ViewPart {
 public static final String ID = "com.blogspot.javadingsda.dndfirst.view";

 private TreeViewer viewer;
 Model model = new Model();

 public void createPartControl(Composite parent) {
  viewer = new TreeViewer(parent, SWT.H_SCROLL | SWT.V_SCROLL);
  viewer.setContentProvider(new ViewContentProvider());
  Transfer[] transferTypes = new Transfer[] { 
                                                    TextTransfer.getInstance() };
  viewer.addDragSupport(DND.DROP_MOVE | DND.DROP_COPY, 
                                      transferTypes,
          new NodeDragListener(viewer));
  viewer.addDropSupport(DND.DROP_MOVE | DND.DROP_COPY, 
                                      transferTypes,
          new NodeDropListener(this, viewer));
  viewer.setInput(model.getRoot());
 }

 public void setFocus() {
  viewer.getControl().setFocus();
 }
}

Schritt 3:
Erzeuge die Klasse ViewContentProvider. Die Funktionalität dieser Klasse (bzw. der Klasse ITreeContentProvider) wird im Artikel Eclipse RCP / SWT - Einfaches TreeViewer Beispiel erläutert.


package com.blogspot.javadingsda.dndfirst;

import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.Viewer;

public class ViewContentProvider implements ITreeContentProvider {

 public void inputChanged(Viewer v, Object oldInput, Object newInput) {
 }

 public void dispose() {
 }

 public Object[] getElements(Object parent) {
  TreeNode ret = (TreeNode) parent;
  return ret.getChildren();
 }

 @Override
 public Object[] getChildren(Object parentElement) {
  TreeNode node = (TreeNode) parentElement;
  return node.getChildren();
 }

 @Override
 public Object getParent(Object element) {
  TreeNode node = (TreeNode) element;
  return node.getParent();
 }

 @Override
 public boolean hasChildren(Object element) {
  TreeNode node = (TreeNode) element;
  return node.getChildren().length > 0;
 }
}

Schritt 4:
Erzeuge die Klasse TreeNode. Diese repräsentiert die Knotenpunkte im Baum. Abgesehen von den standard Methoden wie getParent und addChild besitzt diese Klasse die Methoden insertAfter und insertBefore. Die Methode insertAfter fügt einen Knoten hinter einen anderen Knoten hinzu. Die Methode insertBefore fügt einen Knoten vor einen anderen Knoten.

package com.blogspot.javadingsda.dndfirst;

import java.util.LinkedList;
import java.util.List;

public class TreeNode {

 private List<TreeNode> children = new LinkedList<TreeNode>();
 private String name; // visible name
 private TreeNode parent;

 public TreeNode(String name) {
  this.name = name;
 }

 public void addChild(TreeNode child) {
  if (child.getParent() != null) {
   ((TreeNode) child.getParent()).children.remove(child);
  }
  child.setParent(this);
  children.add(child);
 }

 public void removeChild(TreeNode node) {
  children.remove(node);
  node.setParent(null);
 }

 public void insertAfter(Object targetObj) {
  TreeNode target = convertToTreeNode(targetObj);
  List<TreeNode> childrenList = target.parent.children;
  int targetIndex = childrenList.indexOf(target);
  int thisIndex;
  int index;
  if (target.parent == this.parent) {
   thisIndex = childrenList.indexOf(this);
   if (thisIndex < targetIndex)
    index = targetIndex;
   else
    index = targetIndex + 1;
  } else {
   index = targetIndex + 1;
  }
  insertChild(target, index);
 }

 public void insertBefore(Object targetObj) {
  TreeNode target = convertToTreeNode(targetObj);
  int index;
  int thisIndex;
  int targetIndex = target.parent.children.indexOf(target);
  if (target.parent == this.parent){
   thisIndex = target.parent.children.indexOf(this);
   if (thisIndex < targetIndex) {
    index = targetIndex - 1;
   } else {
    index = targetIndex;
   }
  } else {
   index = targetIndex;
  }
  insertChild(target, index);
 }

 private void insertChild(TreeNode target, int index) {
  if (parent != null)
   parent.removeChild(this);
  target.parent.children.add(index, this);
  this.setParent(target.parent);
 }

 private TreeNode convertToTreeNode(Object obj) {
  if (obj instanceof TreeNode) {
   return (TreeNode) obj;
  }
  return null;
 }

 private void setParent(TreeNode parent) {
  this.parent = parent;
 }

 public String toString() {
  return name;
 }

 public Object[] getChildren() {
  return children.toArray();
 }

 public Object getParent() {
  return parent;
 }
}

Schritt 5:
Erzeuge die Model Klasse. Die Model Klasse erzeugt einen Baum in dem die Knoten durchnummeriert sind. Die Reihenfolge ist willkürlich.


package com.blogspot.javadingsda.dndfirst;

import java.util.HashMap;

public class Model {

 private TreeNode root = new TreeNode("root");
 private HashMap<String, TreeNode> map = new HashMap<String, TreeNode>();

 public Model() {

  TreeNode node1 = new TreeNode("Node1");
  TreeNode node2 = new TreeNode("Node2");
  TreeNode node3 = new TreeNode("Node3");
  TreeNode node4 = new TreeNode("Node4");
  TreeNode node5 = new TreeNode("Node5");
  TreeNode node6 = new TreeNode("Node6");
  TreeNode node7 = new TreeNode("Node7");
  TreeNode node8 = new TreeNode("Node8");
  TreeNode node9 = new TreeNode("Node9");
  TreeNode node10 = new TreeNode("Node10");
  TreeNode node11 = new TreeNode("Node11");
  TreeNode node12 = new TreeNode("Node12");
  TreeNode node13 = new TreeNode("Node13");

  map.put("root", root);
  map.put("Node1", node1);
  map.put("Node2", node2);
  map.put("Node3", node3);
  map.put("Node4", node4);
  map.put("Node5", node5);
  map.put("Node6", node6);
  map.put("Node7", node7);
  map.put("Node8", node8);
  map.put("Node9", node9);
  map.put("Node10", node10);
  map.put("Node11", node11);
  map.put("Node12", node12);
  map.put("Node13", node13);

  root.addChild(node1);
  root.addChild(node2);
  node1.addChild(node3);
  node1.addChild(node4);
  node1.addChild(node5);
  node2.addChild(node6);
  node2.addChild(node7);
  node2.addChild(node8);
  node2.addChild(node9);
  node2.addChild(node10);
  root.addChild(node11);
  root.addChild(node12);
  root.addChild(node13);
 }

 public TreeNode getRoot() {
  return root;
 }

 public TreeNode get(String nodeName) {
  return map.get(nodeName);
 }
}

Schritt 6:
Erzeuge die Klasse NodeDragListener. Die vom DragScourceAdapter geerbte Methode dragSetData(DragSourceEvent event) hat die Aufgabe den Text des beim 'draggen' selektierten Knotens im data Attribut abzulegen. Sollte die Selektion nicht auf einem TreeViewer statt finden, dann wird die 'Drag and Drop' Aktion abgebrochen.


package com.blogspot.javadingsda.dndfirst;

import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.TreeSelection;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.swt.dnd.DragSourceAdapter;
import org.eclipse.swt.dnd.DragSourceEvent;

public class NodeDragListener extends DragSourceAdapter {

  private TreeViewer treeViewer;

  public NodeDragListener(TreeViewer treeViewer) {
    this.treeViewer = treeViewer;
  }

  @Override
  public void dragSetData(DragSourceEvent event) {
    ISelection selection = treeViewer.getSelection();

    if (selection instanceof TreeSelection) {
      TreeSelection treeSelection = (TreeSelection) selection;
      event.data = ((TreeNode) treeSelection.getFirstElement())
                                  .toString();
    } else {
      event.doit = false;
    }
  }
}

Schritt 7:
Erzeuge die Klasse NodeDropListener. Diese Klasse steuert den 'Drop', d.h. die Ereignisse wenn der Benutzer einen Knoten wieder im Baum losläßt. Die Methode validateDrop prüft ob ein Element auf der definierten stelle losgelassen ('gedropt') werden kann. Diese wird vom ViewDropAdapter benutzt. Die drop Methode kümmert sich um das Verschieben der TreeNode im Baum, indem sie die Aufgabe an die richtige Methode der Ziel TreeNode delegiert. Das Attribut operation zeigt an, in welcher Relation die TreeNode zur Ziel TreeNode hinzugefügt werden soll.


package com.blogspot.javadingsda.dndfirst;

import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jface.viewers.ViewerDropAdapter;
import org.eclipse.swt.dnd.DropTargetEvent;
import org.eclipse.swt.dnd.TransferData;

class NodeDropListener extends ViewerDropAdapter {

  private View view;
  private TreeViewer treeViewer;
  private TreeNode target;
  private int operation;

  public NodeDropListener(View view, TreeViewer treeViewer) {
    super(treeViewer);
    this.view = view;
    this.treeViewer = treeViewer;
  }

  @Override
  public void drop(DropTargetEvent event)  {

    if (event.data instanceof String) {
      operation = this.determineLocation(event);
      TreeNode dropedNode = this.view.model.get((String) event.data);
      TreeNode parentDropedNode = (TreeNode) dropedNode.getParent();
      if (dropedNode == target)
        return;
      switch (this.operation) {
        case ViewerDropAdapter.LOCATION_AFTER:
          dropedNode.insertAfter(target);
          System.out.println(dropedNode + " wurde hinter " + target + " eingefügt.");
          break;
        case ViewerDropAdapter.LOCATION_BEFORE:
          dropedNode.insertBefore(target);
          System.out.println(dropedNode + " wurde vor " + target + " eingefügt.");
          break;
        case ViewerDropAdapter.LOCATION_ON:
          if (dropedNode != target.getParent())
               target.addChild(dropedNode);
          System.out.println(dropedNode + " wurde zur " + target + " eingefügt.");
          break;
        case ViewerDropAdapter.LOCATION_NONE:
          break;
        default:
          break;
      }
      super.drop(event);
      treeViewer.refresh(this.target.getParent(), true);
      treeViewer.refresh(parentDropedNode, true);
    }
  }

  @Override
  public boolean performDrop(Object data) {
    return true;
  }

  @Override
  public boolean validateDrop(Object target, int operation,
                              TransferData transferType) {
    if (target instanceof TreeNode) {
      this.target = (TreeNode) target;
      this.operation = operation;
      return true;
    } else {
      this.target = null;
      this.operation = 0;
      return false;
    }
  }
}

Wird die Anwendung ausgeführt, dann wird in der Standardkonsole die Position des einzufügenden Knotens angezeigt.
Dieser Artikel baut auf dem Artikel Eclipse Drag and Drop. von Lars Vogel

Eclipse RCP - Plug-in Problem

2012-03-01T16:13:00.003+01:00

Problem:
Beim Ausführen eines Plugin Projekts erhält man die Fehlermeldung:

!SESSION 2012-03-01 16:09:21.828 -----------------------------------------------
eclipse.buildId=unknown
java.version=1.6.0_22
java.vendor=Sun Microsystems Inc.
BootLoader constants: OS=win32, ARCH=x86, WS=win32, NL=de_DE
Framework arguments: -application com.blogspot.javadingsda.databindingeasy.application
Command-line arguments: -application com.blogspot.javadingsda.databindingeasy.application -data C:\dev\workspaces\databinding/../runtime-com.blogspot.javadingsda.databindingeasy.application -dev file:C:/dev/workspaces/databinding/.metadata/.plugins/org.eclipse.pde.core/com.blogspot.javadingsda.databindingeasy.application/dev.properties -os win32 -ws win32 -arch x86 -consoleLog

!ENTRY org.eclipse.osgi 2 0 2012-03-01 16:09:23.296
!MESSAGE One or more bundles are not resolved because the following root constraints are not resolved:
!SUBENTRY 1 org.eclipse.osgi 2 0 2012-03-01 16:09:23.296
!MESSAGE Bundle initial@reference:file:../../../workspaces/databinding/com.blogspot.javadingsda.databindingeasy/ was not resolved.
!SUBENTRY 2 com.blogspot.javadingsda.databindingeasy 2 0 2012-03-01 16:09:23.296
!MESSAGE Missing required bundle org.eclipse.core.databinding.beans_1.2.100.

!ENTRY org.eclipse.osgi 2 0 2012-03-01 16:09:23.312
!MESSAGE The following is a complete list of bundles which are not resolved, see the prior log entry for the root cause if it exists:
!SUBENTRY 1 org.eclipse.osgi 2 0 2012-03-01 16:09:23.312
!MESSAGE Bundle com.blogspot.javadingsda.databindingeasy_1.0.0.qualifier [32] was not resolved.
!SUBENTRY 2 com.blogspot.javadingsda.databindingeasy 2 0 2012-03-01 16:09:23.312
!MESSAGE Missing required bundle org.eclipse.core.databinding.beans_1.2.100.

!ENTRY org.eclipse.osgi 4 0 2012-03-01 16:09:23.312
!MESSAGE Application error
!STACK 1
java.lang.RuntimeException: Application "com.blogspot.javadingsda.databindingeasy.application" could not be found in the registry. The applications available are: org.eclipse.equinox.app.error.
at org.eclipse.equinox.internal.app.EclipseAppContainer.startDefaultApp(EclipseAppContainer.java:248)

so oder ähnlich .
In der plugin.xml wurden die benötigten Plugins aber hinzugefügt.

Mögliche Lösung:

Rechter Mausklick auf das Projekt. Im Kontext Menü 'Properties' auswählen. Dann 'Run/Debug Settings'. Das zum Projekt passende Produkt auswählen und mit dem Edit Button bearbeiten. Reiter Plug-ins auswählen und nachsehen ob beim bemängelten Bundle ein Häckchen steht. In diesem Beispiel ist es 'org.eclipse.core.databinding.beans_1.2.100'. Falls dies nicht der Fall ist, Häckchen setzen.

Java - Temporäre Datei erstellen

2012-02-10T22:38:00.001+01:00

Zwei richtig gute Seiten in denen recht ausfürlich beschrieben wird, wie eine temporäre Datei erstellt wird.

http://dpunkt.de/java/Programmieren_mit_Java/Streams/13.html
http://www.javabeginners.de/Dateien_und_Verzeichnisse/Datei_in_temp-Verzeichnis_erstellen.php

Eclipse RCP - Tutorial Videos

2012-02-10T22:35:00.001+01:00

Eine Linksammlung zu Video Tutorials in deutsch:
View anzeigen und öffnen - Teil 1
View anzeigen und öffnen - Teil 2
Java3D und Eclipse RCP
Eclipse RCP: Mehrsprachigkeit von Ralf Ebert

Eclipse RCP - MessageBox

2011-12-18T20:01:00.000+01:00

Wie erhalte ich eine MessageBox und wie setze ich die MessageBox ein?

Ein sehr gutes MessageBox Beispiel findet ihr bei www.java2s.com Die entscheidende Stelle hier nochmal kurz als Codesnippet:


MessageBox messageBox = 
  new MessageBox(shell, 
            SWT.ICON_WARNING | SWT.ABORT | SWT.RETRY | SWT.IGNORE);
        
messageBox.setText("Warning");
messageBox.setMessage("Save the changes before exiting?");
int buttonID = messageBox.open();

Quelle: http://www.java2s.com/Code/Java/SWT-JFace-Eclipse/MessageBoxExample.htm

Der zweite Parameter der MessageBox steuert die Anzahl und Art der Buttons die in der MessageBox angezeigt werden. Weiterhin kann mit dem zweiten Paremeter der Typ der MessageBox (hier Warnung) bestimmt werden.

Die MessageBox wird modal aufgerufen. Die Methode open() öffnet die MessageBox. Am Rückgabewert kann identifiziert werden, welcher Button vom Benutzer gedrückt wurde.

Die buttonId kann mit dafür vorgesehenen Konstanten der Klasse SWT verglichen werden, z.B. if ( buttonID == SWT.CANCEL ) { ...

Die aufgeführte Liste zeigt einige Konstanten für die Buttons:


SWT.ABORT 
SWT.CANCEL 
SWT.IGNORE 
SWT.NO 
SWT.OK 
SWT.RETRY 
SWT.YES

Eclipse RCP - Hintergrundfarbe und Image eines Labels im TreeViewer

2011-11-25T20:30:00.000+01:00

Dieser Artikel beschreibt wie die Hintergrundfarbe eines Labels in einem TreeViewer geändert werden kann.

Das Aussehen eines Knotens in einem TreeViewer wird mit einem LabelProvider gesteuert. Der LabelProvider wird mit der Methode setLabelProvider der Klasse TreeViewer gesetzt.


// deklaration des TreeViewers in einer View Klasse 
public TreeViewer viewer;

...
// createPartControl Methode der View Klasse 
public void createPartControl(Composite parent) { 

...

  viewer.setLabelProvider(new ViewLabelProvider());

...
}

Die Aufgaben des LabelProviders werden von den geerbten Klassen bzw. den implementierten Interfaces bestimmt. Die Klasse LabelProvider bietet die Methoden getText und getImage, mit denen der Text und das Bild bestimmt werden können. Der Übergabeparameter obj vom Typ Object ist das TreeElement, dass einen Knoten im Tree repräsentiert.

In der hier gezeigten Implementierung liefert der Parameter obj den Text der im Label angezeigt wird, bzw. das Image das zum Label angezeigt wird. Würde man in der Methode getImage immer das gleiche Bild zurückgeben, dann würde der TreeViewer das gleiche Bild für alle Knoten anzeigen.


import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.swt.graphics.Image;

class ViewLabelProvider extends LabelProvider implements IColorProvider {

 @Override
 public String getText(Object obj) {
     return obj.toString();
 }
 
 @Override
 public Image getImage(Object obj) {
     Image img = ((TreeObject)obj).getIcon();
     return img; 
 }

 @Override
 public Color getForeground(Object element) {
     return new Color(PlatformUI.getWorkbench().getDisplay(),
                      new RGB(255,255,255));
 }

  @Override
  public Color getBackground(Object element) {
    return new Color(PlatformUI.getWorkbench().getDisplay(), 
                     new RGB(100,100,100));
  }
}

Die Methoden getForeground und getBackground bestimmen die Schriftfarbe und die Hintergrundfarbe.

Es sollte beachtet werden, dass Bilder und Farben in einer Eclipse RCP Applikation verwaltet werden sollten. Das bedeutet, dass einmal erstellte Farben und Bilder wieder freigegeben werden sollten. Mehr dazu im Bilder verwalten Artikel und im Artikel zur Farbverwaltung

Eclipse RCP / SWT - Einfaches TreeViewer Beispiel

2011-11-05T18:52:00.000+01:00

Eclipse 3.7 Indigo

In diesem Artikel wird ein einfaches TreeViewer Beispiel gezeigt. Das Beispiel konzentriert sich nur auf das Anzeigen eines Baumes, wodurch alle anderen Aspekte wie Menüs, andere ViewPart Elemente und andere GUI Elemente vernachlässigt werden. Es wird ein unendlicher binärer Baum dargestellt, dessen Hierarchierstufen gezählt werden. Alle notwendigen Schritte werden in einem HandsOn Tutorial nachvollzogen.

Schritt 1: RCP Applikation mit dem Namen com.blogspot.javadingsda.easytreeviewer aus der Vorlage 'RCP application with a view' erstellen.

Schritt 2: Entferne alle inneren Klassen, Methoden und Attribute aus der View Klasse und ersetze sie durch den unten aufgeführten Code. Die View Klasse sollte wie folgt aussehen.


package com.blogspot.javadingsda.easytreeviewer;

import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.ui.part.ViewPart;

public class View extends ViewPart {
  public static final String ID = 
    "com.blogspot.javadingsda.easytreeviewer.view";
  private TreeViewer treeViewer; 

  public void createPartControl(Composite parent) {
    treeViewer = new TreeViewer(parent);
    treeViewer.setContentProvider(new TreeContentProvider());
    treeViewer.setInput(new MyTreeNode(0));
  }

  public void setFocus() {
  }
}

Um mit den darzustellenden Daten versorgt zu werden, benötigt der TreeViewer eine Klasse, die das Interface ITreeContentProvider implementiert. Die Methoden des ITreeContentProvider werden im Posting ITreeContentProvider Methoden beschrieben. Für unser Beispiel sind die Methoden hasChildren(Object parent), getChildren(Object parent), getParent(Object child) und getElements(Object parent)wichtig. Die Funktionsweise der Methoden wird weiter unten in Bezug auf unser Beispiel näher erläutert. In unserem Beispiel implementiert die Klasse ViewContentProvider dieses Interface und wird dem TreeViewer mit der Methode setContntProvider(IContentProvider provider) bekannt gemacht.
Die Methode setInput(Object input) initialiseirt den Baum mit dem Root Knoten. Dieser wird nicht angezeigt.

Schritt 3: Erstelle die Klase MyTreeNode.


package com.blogspot.javadingsda.easytreeviewer;

import java.util.ArrayList;

public class MyTreeNode {
    
  private int depth;
  private MyTreeNode parent = null;
  private ArrayList children; 
    
  public MyTreeNode(int depth) {
    children = new ArrayList();
    this.depth = depth;
  }
    
  public MyTreeNode getParent() {
    return parent;
  }
    
  public Object[] getChildren() {
    return children.toArray();
  }
    
  public void addChild(MyTreeNode childNode) {
    childNode.setParent(this);
    this.children.add(childNode);
  }

  private void setParent(MyTreeNode parent) {
    this.parent = parent;
  }
    
  public String toString() {
    StringBuffer sb = new StringBuffer();
    sb.append("Knoten mit Tiefe ");
    sb.append(String.valueOf(depth));
    return sb.toString();
  }

  public int getDepth() {
    return this.depth;
  }
}

Die Klasse MyTreeNode ist für die Informationen eines Knotens verantworltich. Sie enthält eine Referenz auf einen Parent und Referenzen auf alle Kinderknoten. Die Tiefe wird mit dem Attribut depth dargestellt und ist nur für unser Beispiel relevant. Die toString Methode liefert die bezeichung des Labels im Knoten. Diese Klasse ist dann optional, wenn der ITreeContentProvider die gesamte Darstellung übernimmt und nicht auf den hier vorgestellten MyTreeNode Objekten arbeitet, sondern den Baum irgendwie anders verwaltet.

Schritt 4: Erstelle die Klase TreeContentProvider.


package com.blogspot.javadingsda.easytreeviewer;

import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.Viewer;

public class TreeContentProvider implements ITreeContentProvider {

  @Override
  public void dispose() {
  }

  @Override
  public void inputChanged(Viewer viewer, Object oldInput, 
                           Object newInput) {
  }

  @Override
  public Object[] getElements(Object inputElement) {
    createChildNodes(inputElement);
    return getChildren(inputElement);
  }

  @Override
  public Object[] getChildren(Object parentElement) {
    if (parentElement instanceof MyTreeNode) {
      MyTreeNode parentNode = (MyTreeNode) parentElement;
      return parentNode.getChildren();
    }
    return null;
  }

  @Override
  public Object getParent(Object element) {
    if (element instanceof MyTreeNode) {
      MyTreeNode node = (MyTreeNode) element;
      return node.getParent();
    }
    return null;
  }

  @Override
  public boolean hasChildren(Object element) {
    if (element instanceof MyTreeNode) {
      MyTreeNode node = (MyTreeNode) element;
      if (node.getChildren().length == 0) {
        createChildNodes(node);
      }
      return true;
    }
    return false;
  }

  public void createChildNodes(Object parent) {
    if (parent instanceof MyTreeNode) {
      MyTreeNode node = (MyTreeNode)parent;
      node.addChild(new MyTreeNode(node.getDepth() + 1));
      node.addChild(new MyTreeNode(node.getDepth() + 1));
    }
  }
}

public Object[] getElements(Object inputElement)

Diese Methode wird aufgerufen, wenn der Baum das erste mal initialieriert wird, und zwar wenn die Methode setInput(Object input) des TreeViewers aufgerufen wird. In unserem Beispiel werden in dieser Methode die ersten Kinderknoten erzeugt und wiedergegeben.

public Object[] getChildren(Object parentElement)

getChildren gibt die Kinderknoten zum parentElement wieder. In unserem Beispiel hält jeder Knoten Referenzen auf die Kinderknoten. Diese können mit der getChildren Methode abgefragt werden. getChildren wird immer dann aufgerufen, wenn die Kinderknoten angezeigt werden sollen.

public Object getParent(Object element)

Wird vom TreeViewer aufgerufen, wenn dieser geschlossene Knoten programmatisch aufdecken möchte und wenn der TreeViewer den 'geöffnet' Status programmatisch setzen möchte. In unserem Beipiel kommt diese Methode nicht zum Einsatz, wird aber implementiert um der Vollständigkeit zu genügen.

public boolean hasChildren(Object element)

Bevor der TreeViewer die Kinder eines Knotens anzeigt, wird dem Benutzer visuell angezeigt, dass sich unter einem geschlossenen Knoten weitere Knoten befinden. Das Aussehen ist Betriebssystemspezifisch. In WinXP ist dies ein kleines plus Zeichen, Win7 verwendet hingegen ein kleines Dreieck links neben dem Knoten. Die Methode hasChildren liefert für diese Anzeige die Information, ob sich unter dem Knoten weitere Kinderknoten befinden. Der Übergabeparameter element ist dabei der Elternknoten. In unserem Beispiel werden zwei neue Kinderknoten für einen Elternknoten erzeugt, wenn dieser keine Kinderknoten besitzt. Somit entseht der unendliche binäre Baum.

public void createChildNodes(Object parent)

Diese Methode erzeugt zwei Kinderknoten zu einem Elternknoten.

An dieser Stelle muss noch erwähnt werden, dass das Erzeugen der Kinderknoten auch in der MyTreeNode Klasse hätte implementiert werden können. Es ist generell eine Designfrage, ob der ITreeContentProvider alle informationen von den Knoten abfragt oder diese ermittelt.

Schritt 4: Anwendung starten.
Die Anwendung kann ausgeführt und getestet werden.

Weiterlesen:

TreeViewer mit 'Drag and Drop'

TreeViewer – Ereignisse beim öffnen/schließen eines Baumkontens im TreeViewer

TreeViewer - Methoden des ITreeContentProvider

Eclipse RCP - Hintergrundfarbe und Image eines Labels im TreeViewer

Eclipse RCP - Bilder laden und verwalten für Fortgeschrittene

2011-10-23T21:16:00.005+02:00

Bilder werden mit Eclipse (bzw. SWT) unabhängig vom Dateityp in Image Objekte geladen. Bilder die an vielen Stellen und häufig in einer RCP Applikaiton verwendet werden, sollten mit der ImageRegistry verwaltet werden. Dieser Artikel zeigt dies in einem einfachen Beispiel wie Bilder in und aus der ImageRegistry geladen werden.
Weiterhin werden drei Möglichkeiten wie ein Pfad zu einem Bild angegeben werden kann vorgestellt.

Schritt 1: erstelle eine RCP Eclipse Anwendung die auf dem Template "RCP Application with a view" basiert

Schritt 2: kopiere das Bild "alt_window_32.gif" in das Package in dem sich die View Klasse befindet. Das Projektverzeichnis sollte wie in Abbildung 1 dargestellt aussehen.

Abbildung 1

Schritt 3: in der Klasse View müssen alle inneren Klassen und Attribute gelöscht werden. Der Inhalt der Methoden createPartControl und setFocus sollte ebenfalls gelöscht werden. Der Inhalt der Methode createPartControl wird mit dem Inhalt wie im Programmauszug 1 ersetzt.


import org.eclipse.jface.resource.ImageRegistry;
import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Label;
import org.eclipse.ui.part.ViewPart;

public class View extends ViewPart {
  public static final String ID = 
               "com.blogspot.javadingsda.testimageregistry.view";

  public void createPartControl(Composite parent) {
    GridLayout layout = new GridLayout();
    layout.marginHeight = 0;
    layout.marginWidth = 0;
    parent.setLayout(layout);

    ImageRegistry reg = Activator.getDefault().getImageRegistry();

    Label label = new Label(parent, SWT.NONE);
    GridData gridData = new GridData();
    label.setData(gridData);
    label.setImage(reg.get("testpic"));

    label = new Label(parent, SWT.NONE);
    gridData = new GridData();
    label.setData(gridData);
    label.setImage(reg.get("testpic2"));

    label = new Label(parent, SWT.NONE);
    gridData = new GridData();
    label.setData(gridData);
    label.setImage(reg.get("testpic3"));

  }

  public void setFocus() {}
}

Programmauszug 1

Schritt 4: das Laden der Bilder in die ImagerRegistry kann an beliebiger Stelle erfolgen. Es sollte nur vor der ersten Verwendung erfolgen. Wir entscheiden und dies in der Perspective Klasse zu tun. Programmauszug 2 zeigt die modifizierte Klasse.
Bei Lösung 1 und Lösung 2 wird das Bild aus dem icons Verzeichnis geladen. Lösung 3 läd das Bild aus dem Package in dem sich die View.class befindet.


import java.net.URL;

import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.resource.ImageRegistry;
import org.eclipse.ui.IPageLayout;
import org.eclipse.ui.IPerspectiveFactory;
import org.osgi.framework.Bundle;

public class Perspective implements IPerspectiveFactory {

  public void createInitialLayout(IPageLayout layout) {
    layout.setEditorAreaVisible(false);
    layout.setFixed(true);

    ImageRegistry regystry = 
                     Activator.getDefault().getImageRegistry();
    String pathStr = "icons/alt_window_32.gif";
    Path path = new Path(pathStr);

    // Lösung 1
    Bundle bundle = Platform.getBundle(Activator.PLUGIN_ID);
    URL url = FileLocator.find(bundle, path, null);
    ImageDescriptor imageDescriptor = 
                    ImageDescriptor.createFromURL(url);
    regystry.put("testpic", imageDescriptor);
    // Lösung 2
    ImageDescriptor imageDescriptor2 = 
                    Activator.getImageDescriptor(pathStr);
    regystry.put("testpic2", imageDescriptor2);
    // Lösung 3
    ImageDescriptor imageDescriptor3 = 
       ImageDescriptor.createFromFile(View.class, "alt_window_32.gif");
    regystry.put("testpic3", imageDescriptor3);
  }
}

Programmauszug 2

Die gezeigten Beispiele bauen auf folgenden Quellen:

//http://www.javalobby.org/forums/thread.jspa?threadID=16557
//http://www.eclipse.org/articles/Article-RCP-2/tutorial2.html
//http://www.eclipse.org/articles/Article-Using%20Images%20In%20Eclipse/Using%20Images%20In%20Eclipse.html
//http://www.eclipse.org/articles/Article-SWT-images/graphics-resources.html

Eclipse RCP / SWT Tabulator Reihenfolge bestimmen

2011-10-21T22:35:00.001+02:00

Um die Tabulator Reihenfolge zu bestimmen müssen die Referenzen der Widgets in einem Array in der gewünschten Reihenfolge an das Composite übergeben werden, dass die Widgets enthält.


@Override
public void createPartControl(Composite parent) { 
    ... 
    Button b1 = new Button(parent, SWT.NONE); 
    ... 
    Button b2 = new Button(parent, SWT.NONE); 
    .... 
    Button b3 = new Button(parent, SWT.NONE); 
    ...
    Control[] controls = new Control[] { b2, b1, b3 }; 
    parent.setTabList(controls); 
}