Ich melde mich mal mit einer Kleinigkeit zurück.

Der Kunde wünscht sich bei der Auswahl von Nodes auch die Modifier der Tastatur zu ermitteln. Üblicherweise ist das gar nicht möglich, wenn man nur mit Lookup-Listener auf Results arbeitet (was ja die Regel sein sollte).

Da Swing ja singlethreaded ist und die meisten Lookup-Benachrichtigungen sich auch daran halten (außer man erzwingt Mutlithreading – was böse ist), kann man einfach über das AWT das aktuelle Event ermitteln:

AWTEvent currentEvent = EventQueue.getCurrentEvent();

Da AWTEvent recht schmalbrüstig ist, müssen wir es noch casten. Beispiel:

if ( currentEvent instanceof InputEvent ) {

  mods = ((InputEvent)currentEvent).getModifiers();

}

Ist kein aktuelles Event vorhanden, wird null zurückgegeben, was mit instanceof ohne NPE abgefangen wird. Dann erhalten wir aber auch keine Modifier.

Da auch JavaFX 2 mit einem eigenen Native-Loader kommt, haben wir in einer NetBeans Platform wieder das Problem, die DLL/SO/… Bibliotheken an die richtige Stelle zu bekommen.

Man kann natürlich den Anwender JavaFX installieren und bin-Pfade einrichten lassen. Aber bequemer ist es natürlich, wenn sich die Platform Application darum kümmert.

Hier eine extrem simple (und nicht für alle Plattformen gültige) Lösung.

Es wird davon ausgegangen, dass sich die javafx-2.0.jar in dem Ordner cluster/modules/ext/somename befindet. Cluster ist der suite-Name. Der Pfad modules/ext ist Standard für externe Bibliotheken und somename ist (ggf.) ein Codename-Base-Name der externen Bibliothek oder “lib” (das ist JavaFX aber egal). Ich habe z.B. com.oracle verwendet (die aus der Gruppen-ID meiner Maven-Artifakte kommt).

Will ich nun (nur) Windows in 32bit und 64bit unterstützen, lege ich in dem ext-Order noch bin und darunter amd63 und x86 an. Also: cluster/modules/ext/bin/amd64 und cluster/modules/ext/bin/x86. Der Native Loader von JavaFX sucht immer (von der javafx-2.0.jar) in ../bin. Ich muss also nun die DLL’s kopieren.

Hier ein Beispiel meiner Dateistrukturen:

Da JavaFX fast mit Java7 verheiratet ist, werde ich auch nur mit Java7-nio den Weg beschreiten:

public class Installer extends ModuleInstall {



  @Override

  public void restored() {

    Class c = Installer.class;

    URL u = c.getProtectionDomain().getCodeSource().getLocation();

    String path = u.getPath();

    if ( path.startsWith("file:/") && path.endsWith(".jar!/")) {

      path = path.substring(6);

      path = path.substring(0, path.length()-2);

      int pos = path.lastIndexOf("/");

      if ( pos >= 0 ) {

        path = path.substring(0, pos);

        FileSystem fs = FileSystems.getDefault();

        Path dest = fs.getPath(path, "ext", "bin");

        Path source = fs.getPath(path, "ext", "bin", System.getProperty("os.arch"));

        try {

          for (Path toCopy : Files.newDirectoryStream(source)) {

            Path destFile = fs.getPath(dest.toString(), toCopy.getFileName().toString());

            Files.copy(toCopy, destFile, StandardCopyOption.REPLACE_EXISTING, StandardCopyOption.COPY_ATTRIBUTES);

          }

        } catch (IOException ex) {

          Exceptions.printStackTrace(ex);

        }

      }

    }

  }

}

Am aufwendigsten ist die Ermittlung des Modulpfades per URL u = c.getProtectionDomain().getCodeSource().getLocation(); mit dem Extrahieren des eigentlichen Pfades (man sieht, WebStart wird nicht unterstützt). Den Path “source” ermittle ich ausschließlich über os.arch. Das ist natürlich nicht wirklich nützlich für Plattformen wie Linux. Wer weitere Plattformen unterstützen will, sollte noch zusätzliche Systemparameter ermitteln und weitere Unterordner anlegen. Ich würde aber explizit die Methoden aus org.openide.util.Utilities (isMac, isUnix, isWindows) verwenden. Die System Properties sind da zu geschwätzig.

Nehmen wir an, es würde alles fehl schlagen (weil wir Bibliotheken nicht mitliefern), dann sollte man noch eine eigene Hilfsklasse basteln, die den erfolgreichen (oder nicht erfolgreichen) Kopiervorgang an andere Module liefern kann (z.B. JavaFXHelper.isJavaFXAvailable()). Wenn man das nämlich nicht abprüft und doch JavaFX verwendet, sind die Abstürze so hart, dass häufig nicht mal das Hauptfenster angezeigt wird. Im Log findet ihr dann Fehler wie: java.lang.UnsatisfiedLinkError: Can’t load library: …

Was allerdings schön ist: mehr ist nicht zu machen. Man muss nicht (wie in einem alten Artikel von mir beschrieben) eine Startup-Klasse der Platform unterschieben, um JavaFX zu nutzen.

Einen Mini-WebBrowser fügt man so in eine TopComponent ein:

    final JFXPanel fxPanel = new JFXPanel();



    add(fxPanel);

    

    Platform.runLater(new Runnable() {



      @Override

      public void run() {

        Group group = new Group();

        Scene scene = new Scene(group);

        fxPanel.setScene(scene);

        

        view = new WebView();

        view.setMinSize(1024, 768);

        view.setPrefSize(1024, 768);

        group.getChildren().add (view);

      }

    });

view ist eine Feldvariable der TopComponent. Mit der Methode:

  public void browseTo (final String url) {

    Platform.runLater(new Runnable() {

      @Override

      public void run() {

        view.getEngine().load(url);

      }

    });

  }

kann man eine Webseite öffnen (http:// muss aber am Anfang der URL stehen).

Viel Spaß mit JavaFX in der NetBeans Platform.

Seit kurzer Zeit ist ein neues Release von NetBeans fertig und kann hier heruntergeladen werden.

Die Version 7.1.1 bring kleinere Neuerungen:

• Java ME SDK 3.0.5 Unterstützung
• Bundle GlassFish 3.1.2 Update
• JavaFX 2.0.3 SDK Unterstützung
• Maven 3.0.4 Upgrade

Dazu wurden 123 Fehler berichtigt, die noch in 7.1 waren oder bis 7.1.1 entdeckt wurden. Hier eine Liste der P1 Fehler:

Es gibt ein paar kleine Tricks, um mit der IDE etwas schneller arbeiten zu können. Die folgende Liste ist bei weitem nicht vollständig, sondern beschreibt nur die Shortcuts, die ich gerne nutze (auch die Verwendung von einigen Assistenten).

Zwischenablage / Clipboard

Mehr durch Zufall bekommt man mit, dass Strg+C / Ctrl-C die komplette Zeile in die Zwischenablage kopiert, wenn man kein Zeichen selektiert. Das ist sehr praktisch, weil man sich die Tastenkürzel für das Markieren einer kompletten Zeile ersparen kann.

Strg-V / Ctrl-V fügt die Zwischenablage ein. Aber mit der Umschalt/Shift Taste wird der importierte Quelltext noch zugleich formatiert. Umschalt+Strg+V ist damit meine häufigst verwendete Tastaturkombination.

Löschen

Strg+E löscht eine komplette Zeile, ohne sie markieren zu müssen.

Auskommentieren

Schnell muss mal eine Zeile raus aus den Programmablauf, löschen will man sie aber nicht. Toggle Comment [Strg+Umschalt+C] hilft hier, um selektierte Zeilen schnell auszukommentieren oder die Kommentare wieder zu entfernen.

Zeilen bewegen / duplizieren

Mit den Pfeil/Cursor Tasten und Alt+Umschalt / Alt-Shift, kann man die aktuelle Zeile oder die markierten Zeilen nach oben oder unten verschieben, bzw. ein- oder ausrücken.

Sehr praktisch ist auch das Kopieren der aktuellen Zeile (oder der markierten Zeilen). Pfeil / Cursor auf und ab mit Strg+Umschalt / Ctrl+Shift erzeugt eine Kopie über oder unter dem Original. Dabei wird die Zwischenablage / Clipboard nicht verändert.

So kann man z.B. relativ schnell Felder in Klassen duplizieren, um dann nur den Namen zu ändern.

Actions für “Java-Zeile beenden”

Das sind Shortcut-Actions, die auf deutschen Tastaturen nicht funktionieren. Bevor man diese Funktionen nutzen kann, muss man diese in den Options neu zuweisen. Dazu geht man in die Optionen (Tools -> Options), dort auf die Keymap. Im Suchfeld gibt man “Complete Line” ein. Man bekommt zwei Editor Actions die auf Ctrl+SEMICOLON und Ctrl+Shift+SEMICOLON hören. Die eine Action (Complete Line) wird auf ALT+COMMA geändert, die andere (Complete Line and Create New Line) auf Ctrl-Alt-COMMA.

Jetzt kann man mitten im Bearbeiten der Zeile die Shortcuts eingeben. Die IDE fügt dann ein ; an das Ende der Zeile an und fügt (auf Wunsch) eine neue Zeile ein.

Rechteckige Selektion im Editor

Die Texteditoren haben neuerdings zu der klassischen Zeichen/Zeilen-Selektion nun eine rechteckige Selektion. Die kann man mit Strg+Umschalt+R aktivieren und deaktivieren. Man kann dann mit der Maus oder Umschalt+Pfeiltaste einen rechteckigen Bereich markieren. Das Besondere ist nicht das Kopieren des Bereiches, sondern die Eingabe von neuen Daten in den Bereich. Jede Zeile aus dem rechteckigen bereich erhält die neue Eingabe. Somit kann man z.B. sehr schnell einen Bereich von public Feldern in private ändern.

public int a;
public String b;
public double c;

Nun mit Strg+Umschalt+R den Selektionsmodus auf Rechteckig ändern und alle drei public’s selektieren. Dann einfach private eingeben. Alle drei Felddeklarationen haben nun private als Modifier. Es ist zu empfehlen die Selektion nach solchen Operationen wieder zurückzusetzen.

Alles hybsch machen

Mit Strg+Umschalt+F wird der selektierte Bereich (oder alles, wenn keine Markierung existiert) neu durchformatiert.

Quelltextvervollständigung / Codecompletion

Import Statements aufräumen und ergänzen

Die Tastenkombination Strg+Umschalt+I wirft ungenutzte Imports raus, löst *-Imports auf und fügt fehlende Imports hinzu. Wenn Klassennamen doppelt existieren, dann muss man die passenden Klassen in einem Dialog bestätigen. Man braucht die Kombination seltener, seit dem Strg+V und Strg+Umschalt+V automatisch die Imports mit übertragen. Aber manchmal braucht man es doch noch.

Methoden überschreiben

Man kann den Alt-Einf / Alt-Insert Assistenten verwenden, oder direkt den Namen der zu überschreibenden Methode eingeben und dann Strg+Leertaste / Ctrl-SPACE drücken (natürlich im Body der Klasse). Es wird dann vorgeschlagen, eine Methode aus der Liste zum Überschreiben auszuwählen. Mit Enter bestätigen, erzeugt die Methode mit dem super-Aufruf der überschriebenen Methode.

Variablenzuweisungen von der IDE

Ma sollte möglichst nicht mit einer VAriablenzuweisung beginnen, sondern erst den Methodenaufruf  schreibe. Beispiel:

getDimension();

Man bleibt mit dem Eingabecursor hinter den Semikolon. Die IDE wird schon jetzt eine gelbe Lanpe (Hint) bei der Zeilennummer einblenden. Nicht mit der Maus anklicken (dauert zu lange), einfach Alt+Enter. Es erscheint idR. nur ein Hinweis: Einen Rückgabewert einer neuen Variable zuordnen. Einfach mit Enter bestätigen und die IDE erzeugt:

Dimension dimension = getDimension();

Dazu den passenden Import. Außerdem ist der Variablenname dimension markiert, so dass man ihn ggf. überschreiben kann.

POJOs erzeugen

Ein sehr einfacher Weg, um Plain Old Java Objects zu erzeugen, ist wieder per Assistent. Erstmal eine Klasse anlegen. Im Body der Klasse nur Alt+Einfügen / Alt+Insert tippen.

In der Auswahlbox “Add Property” auswählen. Der Assistent erlaubt nun neben den Namen und Typ auch weitere nützliche Optionen zu aktivieren. Insbesondere “Bound” erleichtert viel Arbeit, weil damit das PropertyChangeSupport für die set’er Methoden erzeugt wird.

Nie wieder muss man diesen Boilerplate Code schreiben:

/**
 * Set the value of name
 *
 * @param name new value of name
 */
public void setName(String name) {
   String oldName = this.name;
   this.name = name;
   propertyChangeSupport.firePropertyChange(PROP_NAME, oldName, name);
}

Nun kann man mit den Klassen erstmal arbeiten. Wenn man später die Architektur etwas aufmöbeln will, kann man aus der Klasse ein Interface extrahieren (Im Kontextmenü: Refactor -> Extract Interface).

Navigation

Hyperlinks für Klassen, Methoden und Felder

Strg-Taste / CTRL  halten und mit dem Mauszeiger über einen Namen (Methode, Feld, Klassenname) gehen. Es erscheint ein Hyperlink. Ein Klick darauf und man springt zur Deklaration (öffnet dabei ggf. einen neuen Editor).

Aktuelle Editor-Datei im Projektfenster markieren

Wenn man keine sofortige Synchronisation aktiviert hat (View -> Synchronize Editor with Views), dann stimmt die markierte Datei im Projektfenster nicht mit der aktuell bearbeiteten Datei im Editor überein. Strg+Umschalt+1 markiert die Datei im Projektfenster (und öffnet ggf. das zugehörige Projekt). Das ist dann besonders nützlich, wenn man in eine Klasse per Strg+Mausklick (wie ein Browser-Hyperlink) über Methodennamen gesprungen ist oder der Debugger die Quelltexte geöffnet hatte.

Klasse suchen

Strg+O (Goto Type) ist ein Suchdialog für Klassennamen. In dem Dialog den Suchbegriff eingeben, Doppelklick auf eines der Ergebnisse öffnet die Datei. Strg-Umschalt-1 zeigt die Datei dann in der Projekts-Struktur.

Zu Zeilennummer springen

Strg+G (Goto Linenumber) öffnet einen Dialog, um eine Zeilennummer einzugeben. Dorthin springt dann der Eingabecursor. Wer Exceptions per Mail zugeschickt bekommt, wird das Feature lieben.

Alle Implementationen eines Interfaces

Vor der Deklarationszeile eines Interfaces, abstrakter Klassen und überschriebener Klassen erscheint in der Zeilennummer ein kleines (i). Klickt man darauf, wird eine Liste aller bekannten Implementationen angezeigt. Per Klick kann man in die einzelnen Implementationen springen. Das ist nützlich, wenn man Interface erweitert (neue Methoden-Signaturen) und damit die Kassen angepasst werden müssen.

Editor maximieren

Eigentlich ist der Editor immer zu klein, zumindest geht es mir so. Der Doppelklick auf die Registerzunge zum Maximieren des Editors ist nett aber umständlich. Das Tastenkürzel Maximize Windows [Strg+ESC] ist da schneller. Entgegen des Namens setzt [Strg+ESC] die vergrößerte Registerzunge auch wieder zurück.

Generelle Probleme mit Tastenkürzel

Wer Ubuntu verwendet, wird mit allen Tastenkürzeln unglücklich werden, die mit Alt+Umschalt / Alt+Shift eingeleitet werden. Das klappt unter Ubuntu nicht, da Alt+Umschalt schon vom System belegt ist. Man muss diese Kürzel unter Tools -> Options -> Keymap ändern.

Nutzer deutscher Tastenlayouts kämpfen mit den Shortcuts, deren Keycodes sowieso per Umschalt / Shift zu erreichen sind (Komma, Semikolon, Stern) oder per AltGr (geschweifte und Eckige Klammern). Da muss man meistens die Zugriffs-Kürzel der Actions ebenfalls unter Tools -> Options -> Keymap anpassen.

Hi!

The new updated Refcard #80 by Heiko Böck, Anton Epple, Miloš Šilhánek, Andreas Stefik, Geertjan Wielenga, and Tom Wheeler for the brand new NetBeans 7 Platform is published.

You can find many informations about the NetBeans Platform, a getting started intro, main features, NetBeans Platform modules,  NetBeans Platform APIs, reusable GUI components and  more.

In this Refcard, you are introduced to the key concerns of the NetBeans Platform so that you can save years of work when developing robust and extensible applications.

Six pages packed with many informations, download this Refcard #80 now!

Moin!

Bin gerade mit 1001 Sachen beschäftigt und habe mein Blog etwas vernachlässigt. Aber einen kleinen Tipp habe ich gerade zur Hand. In einem älteren Blogeintrag erwähnte ich die Fähigkeit, dass NetBeans in den 7′er Dev-Builds Bundle Einträge in ein Code-Fold bringen kann. Es wird dann der Wert des Standard-Bundle angezeigt.

Es gibt aber noch ein nettes Feature. Man kann mit der Strg-Taste + Mausklick nun auch direkt zur Bundle-Datei zum Schlüssel springen. Es funktioniert genau so, wie man auch zu Klassen, Methoden und Variablen-Deklarationen springen kann.

Mit dem Klick wird die Bundle-Datei geöffnet und der Cursor auf den Schlüssel gesetzt. Wenn man nun die Tastenkombination Strg+1 drückt, wird diese Bundle Datei auch im Project Explorer selektiert (soweit man nicht sowieso eine automatische Selektion aktiviert hat).

Beste Grüße!

Hi!

Here is my next test with the JavaFX 2.0 ea release. I’ve created a 200-liner to capture parts from the desktop. The “Snipper” detects mouse dragging and two different key strokes (Escape and the letter ‘A’). The captured picture is automatically stored in the user.home/snapshot path.

Before I start to explain the code, I show a small picture about the different scene graph nodes:

At the bottom is the Desktop (I use only the primary screen, but it’s possible to detect all additional screens). The stage is created by the JavaFX Launcher class. I modify the stage to a transparent style and fullscreen mode. The scene (embedded in the stage) captures the mouse events (button pressed, released and dragging). The scene itself has a transparent fill color and contains one group with three different nodes. In the KeyPane-Node I capture the key events. The node is focusable and transparent to mouse events (any mouse event sinks down to the scene). GlassPane is a node with a Shape created by the screen bounds with a rectangular hole. This hole is calculated by the mouse gestures from the user. At last I’ve a visual representation for the user interaction: a red rectangular lasso node.

Disclaimer: The solution here is based on the early access release through the JavaFX partner program. This “best practice” may change significantly between now and the final version. However, I’ll show only a concept, not compilable code.

Here the start up:

  @Override

  public void start(final Stage stage) {

    primaryStage = stage;

    Group group = new Group();

    Scene scene = new Scene(group);

    scene.setFill(Color.TRANSPARENT); // default is white

    scene.setCursor(Cursor.CROSSHAIR);



    stage.setStyle(StageStyle.TRANSPARENT);

    stage.setFullScreen(true);

    stage.setScene(scene);

    stage.setVisible(true);



    screenBounds = new Rectangle (

      Screen.getPrimary().getBounds().getWidth(),

      Screen.getPrimary().getBounds().getHeight()

    );

Nothing special. Only few notes: The Scene-fill must be transparent and the Screen class provides more than the primary screen. But this small example captures only from the primary screen.

I have a special helper class named Rebounder. This class creates and manipulates the lasso rectangle and calculates the shape with the hole for the GlassPane. The KeyPane needs the Rebounder for a fullscreen capture. The scene mouse handlers are call the rebounder with the current mouse points.

  class Rebounder {

    Rectangle lasso;

    double px;

    double py;

    Rebounder() {

      lasso = new Rectangle(0, 0);

      lasso.setFill(null);

      lasso.setSmooth(false);

      lasso.setStroke(Color.RED);

      lasso.setStrokeWidth(1);

      lasso.setStrokeType(StrokeType.OUTSIDE);

      lasso.setMouseTransparent(true);

      lasso.setVisible(false);

    }



    Rectangle start(double x, double y) {

      lasso.setX(x);

      lasso.setY(y);

      lasso.setWidth(0);

      lasso.setHeight(0);

      px = x;

      py = y;

      lasso.setVisible(true);

      return lasso;

    }



    Rectangle rebound(double x, double y) {

      lasso.setWidth(Math.abs(x - px));

      lasso.setHeight(Math.abs(y - py));

      lasso.setX(Math.min(x, px));

      lasso.setY(Math.min(y, py));

      return lasso;

    }



    Rectangle stop(double x, double y) {

      rebound(x, y);

      lasso.setVisible(false);

      return lasso;

    }



    boolean isStopped() { return !lasso.isVisible(); }



    Node getLasso() { return lasso; }



    Shape shapeBuilder(Rectangle r) {

      return r != null

        ? Path.subtract(screenBounds, r)

        : new Rectangle(screenBounds.getWidth(), screenBounds.getHeight());

    }

  }

In the constructor I create the lasso node. The three methods start(x,y), rebound(x,y) and stop (x,y) are called by mousePressed, mouseDragged and mouseReleased. The shapeBuilder-method returns a shape for the GlassPane.

Here are my mouse handlers:

    scene.setOnMousePressed(new EventHandler() {

      @Override public void handle(MouseEvent me) {

        glassPane.setShape(

          rebounder.shapeBuilder(rebounder.start(me.getX(), me.getY())), false);

      }

    });



    scene.setOnMouseDragged(new EventHandler() {

      @Override public void handle(MouseEvent me) {

        glassPane.setShape(

          rebounder.shapeBuilder(rebounder.rebound(me.getX()+1, me.getY()+1)), false);

      }

    });



    scene.setOnMouseReleased(new EventHandler() {

      @Override public void handle(MouseEvent me) {

        if ( !rebounder.isStopped() ) {

          capture(rebounder.stop(me.getX()+1, me.getY()+1));

        }

      }

    });

A very straight forward implementation.

Ok we miss the KeyPane and the GlassPane. The KeyPane is complete transparent, contains only a screen wide rectangle which is focusable and captures key events:

  class KeyPane extends Group {

    public KeyPane(final Stage stage, final Rebounder rebounder) {

      final Rectangle keyEventPane =

        new Rectangle(screenBounds.getWidth(), screenBounds.getHeight());

      keyEventPane.setFill(Color.TRANSPARENT);

      keyEventPane.setStroke(null);

      keyEventPane.setMouseTransparent(true);

      keyEventPane.setFocusTraversable(true); // for keyPressed events

      keyEventPane.setOnKeyPressed(new EventHandler() {

        @Override public void handle(KeyEvent key) {

          if (key.getCode() == KeyCode.VK_ESCAPE) {

            stage.setVisible(false); // == Close

          } else if (key.getCode() == KeyCode.VK_A) {

            capture(new Rectangle(screenBounds.getWidth()+1, screenBounds.getHeight()+1));

          }

        }

      });

      getChildren().add (keyEventPane);

    }

  }

In my GlassPane I’ve only the calculated shape and a small help text:

  class GlassPane extends Group {

    void setShape(Shape shape, boolean showInfo) {

      while (!getChildren().isEmpty()) {

        getChildren().remove(0);

      }

      if ( shape != null ) {

        double BLUE = 0.95;

        Stop[] stops = new Stop[] {

          new Stop(0.00, Color.color(BLUE, BLUE, 1, 0.3)),

          new Stop(0.2, Color.color(BLUE, BLUE, 1, 0.7)),

          new Stop(0.25, Color.color(BLUE, BLUE, 1, 0.5)),

          new Stop(0.4, Color.color(BLUE, BLUE, 1, 0.3)),

          new Stop(0.70, Color.color(BLUE, BLUE, 1, 0.7)),

          new Stop(1.0, Color.color(BLUE, BLUE, 1, 0.3)),

        };

        LinearGradient lg = new LinearGradient(0, 0, 1, 1, true, CycleMethod.NO_CYCLE, stops);

        shape.setFill(lg);

        shape.setMouseTransparent(true);

        shape.setStroke(null);

        getChildren().add(shape);



        if ( showInfo ) {

          Text info = new Text("'ESC' to leave the Snipper\n"

                        + "'A' to capture the whole screen\n"

                        + "Drag the mouse to capture a rectangle");

          info.setFill(Color.WHITE);

          info.setTranslateX(200);

          info.setTranslateY(60);

          info.setScaleX(2);

          info.setScaleY(2);

          info.setEffect(new DropShadow());

          info.setMouseTransparent(true);

          getChildren().add (info);

        }

      }

    }

  }

I fill the shape with a LinearGradient paint.

In the start method I stick all panes together:

    KeyPane keyPane = new KeyPane(stage, rebounder = new Rebounder());

    glassPane = new GlassPane();

    glassPane.setShape(rebounder.shapeBuilder(null), true); 



    group.getChildren().addAll(new Node[] {keyPane, glassPane, rebounder.getLasso()});

Ok where is the heart of my Snipper application? The capture method?

The capture method is currently developed with the java.awt.Robot class. So we need to leave the JavaFX thread and dive into the EventQueue. But first we must hide the whole stage window to get an good image from the desktop. But don’t use stage.setVisible (false) (it closes the application). I resize the stage to a zero dimension. Here my capture method:

  public void capture(final Rectangle finished) {

    primaryStage.setWidth(0);

    primaryStage.setHeight(0);

    EventQueue.invokeLater(new Runnable() {

      @Override public void run() {

        if ( (((finished.getWidth()-1) * (finished.getHeight()-1) ) > 0.0d ) ) {

          try {

            Robot robot = new Robot();

            BufferedImage img = robot.createScreenCapture(

              new java.awt.Rectangle(

                (int)finished.getX(), (int)finished.getY(),

                (int)finished.getWidth()-1, (int)finished.getHeight()-1));

            File folder = new File (System.getProperty("user.home"), "snapshots");

            folder.mkdirs();

            File file = File.createTempFile("jfx2_screen_capture", ".jpg", folder);

            ImageIO.write(img, "jpg", file);

          } catch (Exception ex) {

            Logger.getLogger(Snipper.class.getName()).log(Level.SEVERE, null, ex);

          }

        }

        Platform.runLater(new Runnable() {

          @Override public void run() {

            glassPane.setShape(rebounder.shapeBuilder(null), true);

            primaryStage.setWidth(screenBounds.getWidth());

            primaryStage.setHeight(screenBounds.getHeight());

          }

        });

      }

    });

  }

With this few 200 lines I’ve created a very useful screen capture application. The start up time is incredible: Between the main method and the complete visible stage the JavaFX framework needs only 500ms on my one year old double-core notebook. The complete startup (double-click the jar) is under a second (hard to stop the time). I need only one AWT dependency to the Robot class. I hope this could be changed to increase the startup time (e.g. with the internal FXRobot class).

best regards,
Josh.

Hi!

Alan O’Leary shows in his blog a WebView integration in Swing. It is a not good documented feature, how to integrate JavaFX 2.0 controls into a swing application. But an integration is a main goal for the JavaFX 2.0 release.

As an enthusiastic NetBeans Platform/RCP developer and JavaFX partner, I work since two days to marriage JavaFX 2.0 and a NetBeans Platform Application. And yes, it works

I’ve created a maven based platform application with a special starter Main.class. I need to launch the JavaFX toolkit system before any other module bootstrapping. The solution here is based on the early access release through the JavaFX partner program. This “best practice” may change significantly between now and the final version. However, I’ll show only a concept, not compilable code.

The solution behind the bootstrapping a NetBeans Platform is based on a FAQ by Tom Wheeler. My Main.class is a JavaFX Application class – I need this Application instance to get rid of from invoke exceptions. The created Stage object by the Launcher can be ignored.

public class Main extends Application{



  private static final String NB_MAIN_CLASS = "org.netbeans.core.startup.Main";



  public static void main(String[] args) throws Exception {

    // do whatever you need here (e.g. show a custom login form)

    System.out.println("Launch Java FX");

    long ms = System.currentTimeMillis();



    Launcher.launch(Main.class, args); // This is the main start up for JavaFX 2.0



    System.out.println("Launched Java FX in " + (System.currentTimeMillis() - ms) + "ms");



    // once you're done with that, hand control back to NetBeans

    ClassLoader classloader = Thread.currentThread().getContextClassLoader();

    Class mainClass = Class.forName(NB_MAIN_CLASS, true, classloader);



    Object mainObject = mainClass.newInstance();

    Method mainMethod = mainClass.getDeclaredMethod("main", new Class[]{String[].class});

    mainMethod.invoke(mainObject, (Object) args);

  }



  @Override

  public void start(Stage stage) {

    // Nothing to do, forget the stage....

  }

}

The Main class is in a standard Java archive. This JAR file and all the JavaFX files must be in the platform/core folder.

At runtime all the core-Libs are available to the whole NetBeans Platform modules (and plugins). For the compiler I need a special dependency to the runtime:

<dependency>

 <groupId>sun.javafx</groupId>

 <artifactId>tools</artifactId>

 <version>2.0.0</version>

 <scope>system</scope>

 <systemPath>${basedir}/../../corelauncher/mainlauncher/src/main/lib/jfxrt.jar</systemPath>

</dependency>

The system path depends on your project structure.

Now I can access all the JavaFX classes in a NetBeans module.

Please note, any scene construction needs to be build up in the JavaFX event queue thread. This is not the EventDispatcher-Thread from Swing!

My favorite call to jump in the JavaFX event thread is: Toolkit.getDefault().defer (Runnable) javafx.application.Platform.runLater (Runnable). But the Toolkit class is in a com.* package. IMHO in the future we get an official way to do this.

The creation of a WebView component is pretty similar to the sample from Alan. But I don’t need a stage object:

    Platform.runLater(new Runnable() {



      @Override

      public void run() {

        group = new Group();

        Scene scene = new Scene(group);



        browser = new WebView(new WebEngine());

        browser.getEngine().addChangeListener(PropertyReference.WILDCARD, new ChangeListener() {



          @Override

          public void handle(Bean paramBean, PropertyReference paramPropertyReference) {

            if ("title".equals(paramPropertyReference.getName())) {

              EventQueue.invokeLater(new Runnable() {

                // Jump to Swing EventDispatcher...

                @Override

                public void run() {

                  BrowserTopComponent.this.setDisplayName(browser.getEngine().getTitle());

                }

              });

            }

            if ("url".equals(paramPropertyReference.getName())) {

              EventQueue.invokeLater(new Runnable() {

                // Jump to Swing EventDispatcher...

                @Override

                public void run() {

                  String url = browser.getEngine().getUrl();

                  tfUrl.setText(url);

                  addHistory(url);

                }

              });

            }

          }

        });



        group.getChildren().add(browser);

        group.setScaleX(0.8d);

        group.setScaleY(0.8d);

        Reflection r = new Reflection();

        r.setTopOffset(8);

        group.setEffect(r);



        scene.setFill(javafx.scene.paint.Color.BLACK);

        browser.setWidth(panel.getWidth());

        browser.setHeight(panel.getHeight());



        panel.setScene(scene);

      }

    });



    panel.addComponentListener(new ComponentAdapter() {

      @Override

      public void componentResized(ComponentEvent e) {

        Platform.runLater (new Runnable() {

          // Jump from Swing-EventDispatcher to the JavaFX Thread:

          @Override

          public void run() {

            browser.setWidth(panel.getWidth());

            browser.setHeight(panel.getHeight());

          }

        });

      }

    });

I’ve added some useful listeners. Please aware the switches between different threads (Swing and JavaFX).

The result is a beautiful NetBeans Platform application with an embedded JavaFX 2.0 WebView:

PS.: I like the Twitter message from Dean Riverson: “Ok, I call a moratorium on rotating and reflecting WebView…” (origin).  -

I have to write 100 times:

Moin!

Letzten Donnerstag und Freitag war es mal wieder soweit, ein sehr intensives und hoffentlich für die Teilnehmer spannendes Training ist zu Ende gegangen.

In zwei Tagen haben wir (Geertjan und ich) mehr als 20 Teilnehmern, an der Fachhochschule Osnabrück Lingen/Ems, die NetBeans Plattform in einem Trainings-Kurs nahe gebracht. Es hat uns besonders gefreut, dass alle Anwesenden bis 18:00 am Freitag durchgehalten haben. Und nein, die Tür war nicht abgeschlossen

Die Inhalte waren, wie immer, nicht ohne. Windows System API, Lookups, System File System, Nodes, Explorer und Visual Library waren die Kernthemen. Durch all diese Themen zog sich natürlich: “Modulare Softwareentwicklung”. So wurde den Studenten schnell klar, dass es ohne Theorie nicht geht. Es schien auch einige überrascht zu haben, dass es hier nicht nur darum ging, in der NetBeans Plattform ein paar Swing-Programme zu entwickeln. Wir vermitteln immer dazu – völlig vom Produkt losgelöst – wichtige Paradigmen der modularen Entwicklung von Software. Darunter fallen Punkte wie Separation of Concern, Single Responsible Principle, Komponentenorientierung, Kohäsion und Entkopplung.

Mit vielen eingeschobenen Workshops haben wir dieses Thema von der trockenen Grundlage auf das praktische Feld verschoben.

Für einen besonders guten Einstieg in die NetBeans Platform API haben alle Teilnehmer des Kurses eine DZone NetBeans Platform Refcard erhalten. Ich hoffe, dass sich diese 2-seitige DIN-A3 Karte nun immer neben dem Bildschirm befindet.

Ich war begeistert, dass einige Studenten sich am Freitag Abend zu kleinen Entwicklergruppen zusammengeschlossen haben, um erste Projekte in der NetBeans RCP Welt zu realisieren. Ich freue mich auf die Ergebnisse!

Ganz großen Dank an die Organisation des Events und kulinarische Betreuung. Es gab immer genug Kaffee und andere Getränke und vor allem ein fantastisches Buffet. Da kommen wir doch gerne wieder!

Auf unseren edu-Seiten gibt es unsere Präsentationen zum nachlesen und nacharbeiten: Trainings-Präsentationen. Ein sehr wichtiger Anlaufpunkt ist auf jeden Fall die Platform-Seite: platform.netbeans.org.

Fragen im Nachgang werden über die NetBeans Platform Certified Students Mailingliste abgehandelt. Natürlich stehen auch die englisch- und deutschsprachigen NetBeans Foren zur Verfügung.

Beste Grüße!

Moin!

Gestern kündigte ich ja die Beta2 zur NetBeans 7.0 IDE an. Zwei Dinge hatte ich da unterschlagen, die hier noch einer besonderen Erwähnung bedürfen.

Git

In der Beta2 kann man nun (ohne Plugin) git als Versionierungssystem nutzen. Der Git Plan im Wiki gibt schon einen recht guten Überblick, was funktioniert und worauf man noch warten muss.

Folgende Features sollten funktionieren:

• Quick overview of file status in IDE
• View_Modifications_(Show_Changes)
• Add
• Commit
• Add oder Exclude bei commit
• Reset Changes (Lokale Änderungen zurücknehmen)
• Diff – Lokale Änderungen vergleichen
• Inline diff -Lokale Änderungen in der Files sidebar
• Repository Init
• Ignore
• Checkout
• Create Branch
• Switch to Branch , siehe Checkout
• Merge from Branch

Bis zum Finale ist noch einiges zu tun, gerade für das Distributing steht noch was aus (Repository Clone, Pull, Push, Fetch), die Vervollständigung der Branching und Merging Tools (Merge from Branch, Export uncommited changes (Local changes), Apply Patch) sowie Search history of files und eine Blame Integration.

JUnit

Trotz der verwirrenden und unterschiedlichen, teils negativen, Meldungen wird JUnit natürlich weiter von NetBeans unterstützt. Allerdings muss JUnit in Zukunft extra aus dem Plugin-Center geladen werden. Fest integriert ist nur ein Bridge-Modul zu JUnit. Unabhängig zu rechtlichen Vorgaben hat das in Zukunft vielleicht sogar Vorteile, wenn es um die Integration von anderen Unit-Tools geht (z.B durch eine einheitliche API).

Ich hoffe, dass heute der Download nicht so überlastet ist wie gestern. Viel Spaß mit NetBeans 7.

Beste Grüße,
Josch.

Moin!

Ab heute ist NetBeans 7.0 Beta 2 verfügbar zum Download.

Die Highlights sind:

• JDK 7 Unterstützung
• Integration des WebLogic Servers
• Verbesserungen, um eine Oracle Datenbank einzubinden
• Glassfish 3.1 Unterstützung
• Maven 3 Support
• Remote URL-JavaDoc Support (JavaDoc muss nicht mehr lokal installiert sein)
• Neuer GridBagLayout Customizer
• Für JavaEE CDI, REST Dienste und Java Persistence Verbesserungen, zudem Bean Validation
• JSF Component Bibliothekenunterstützung,  PrimeFaces ist mit an Board
• Verbesserte EL-Unterstützung in JSF
• HTML5
• JSON
• PHPDoc-Generierung
• PHP Rename Refactoring und Safe delete Refactoring
• PHP 5.3 Alias-Unterstützung
• C/C++ kann nun besser Binär-Libs importieren
• C/C++ Projekt-Typ mit Quelltexten auf Remote-Servern
• Endlich für PHP User: Word-Wrap im Editor
• Der Profiler wurde aufgebohrt
• Verbesserte Überprüfung von externen Änderungen an Quelltexten außerhalb der IDE

Auch die NetBeans Platform bekommt Erweiterungen:

• Annotationen für Actions, TopComponents und NbBundle.
• Eigene Annotationen für Maven-Projekte
• Performance Steigerungen und bessere Integration des Profilers
• Und etliche API-Änderungen, hier ein paar schöne Änderungen rausgepickt:
  • Icons für Update-Center
  • openInstallWizard für den PluginMananger
  • QuickSearch im TreeView (de)aktivieren
  • OutlineView-Tree-Spalte kann nun eine horizontale Scrollbar erhalten. (Sehr nützlich!)
  • Eigene TableCellRenderer

Ich hoffe nur die Maven Artifacts werden für Beta2 zeitnah freigegeben, am SNAPSHOT teste ich ungern.

Die aktuellen Release-Notes (en) stehen natürlich auch zur Verfügung. Sehr umfangreich ist, wie immer, die NewAndNoteworthy Seite.

Beste Grüße,
Josch.

Moin!

Ich habe mal wieder was für meine Ideensammlung: Plugins, die ich schon immer mal programmieren wollte, aber nie die Zeit dazu fand.

Heute der native2ascii Konverter für Dateien, die man im Project-Explorer markiert hat. Kontextmenü mit folgenden Befehlen:

• To ASCII…
• Reverse to native…
• Native to native…

To ASCII wandelt von einem vorgegebenen Encoding in die \u-Notation. Reverse to native fragt nach eine Encoding, in der die Datei konvertiert werden soll und Native to native fast beide Transformationen zusammen.

Vielleicht kann man das dem existierenden kenai.com Projekt NATIVE2ASCII hinzufügen? Ich muss mal Hlavki fragen und mit einem hg-clone einen Prototypen schreiben… wenn ich mal wieder Zeit habe.

Beste Grüße,
Josch.

Moin!

Eines der massiv unterschätzten Themen ist Java auf dem Desktop. Immer wieder höre ich von Entwicklern, dass Web-Oberflächen, Java EE, Server und Backend-Development die Domäne für Java sei.

Ich denke mal, man muss da ein wenig über den Tellerrand hinaus schauen. Sicherlich ist Java nicht die 1a Desktop Sprache, weil für die vielen netten Gimmiks einfach die nativen OS spezifischen Schnittstellen fehlen. Aber mal ehrlich, warum sollte eine so robuste Programmiersprache auf dem Desktop nichts taugen? Seit 15 Jahren entwickele ich Java-Desktop-Applikationen zunächst für eine kurze Zeit mit AWT, dann seit Swing 1.1 raus war, Swing-Applikationen.Ich plagte mich davor mit der Microsoft Welt und auch mit 4GL Sprachen rum. Aber kein Framework hat mir so viele Freiheiten und so eine stabile Grundlage gegeben, wie es Java mit Swing und den ganzen zusätzlichen Bibliotheken konnte.

Zwar spricht man heute bei Java vom Cobol des einundzwanzigsten Jahrhunderts, aber auch das ist völlig unterschätzt. Denn neben der Masse an Programmen, die Java (wie ehemals Cobol) trägt, gibt es doch eine Weiterentwicklung die ganz sicher keine Stagnation erfährt.

Geertjan hat in seinem Blog selbst mal wieder eine Lanze für den Desktop Einsatz von Java gebrochen und da ein Zitat von James Gosling ausgegraben, das ich hier gerne wiederhole:

If I had to say I’m jaded it’s sort of about the fact that people’s attention is so focused on the web. And it feels to me like that’s 10% of the computing landscape. If you look at what goes on in, say, biology. Huge, huge computational problems in biology. The people who do protein folding up in San Francisco, which is kind of everybody there, that stuff is really really cool. It sure doesn’t show up on anybody’s “cool” radar but, you know, all modern medicine research, it’s computers. Right, it’s computing. And none of that has any magic pixie dust coolness on it and modern materials. It’s, again, all computer simulation and all the rest of that and the computing behind that and the rest of that, most people don’t even think of it as computing because it’s something that a scientist does. Talk to most people in physics, they spend most of their time writing code, not doing physics experiments. And it’s just a cool world filled with thousands and thousands of different things and it feels like the web is only a corner of it.

Hinter dem ganzen Internet mit all seinen Online-Applikationen, Webservices, Shops, Social Media, Blogs, Twitter-Diensten, Online-Spielen usw. verbirgt sich eine Welt in der Computer auch für etwas anderes gebraucht werden. Eine Welt im Business-Bereich, eine Welt in der Forschung und Wissenschaft, eine Welt in der Produktentwicklung, eine Welt von Künstlern, Designern, Entwicklern und Autoren. Welten, wo Programme auf browserbasierten Oberflächen nur die zweite Wahl sind.

Wenn man sich das mal klar macht, kann man Goslings Aussage verstehen, wenn er vom Internet nur als eine 10% Ecke der Computerwelt spricht. Gefühlt wird jeder immer sagen, das ist mehr: Das Internet füllt mein Leben als Computer-Nerd sicher zu 90% aus. Aber die produktive Entwicklungsarbeit geschieht immer noch auf dem Desktop. Sicher, Server- und Webgestützt, aber Desktopprogramme schlagen Browser-Ajax-Anwendungen immer noch in ihrer Bedienbarkeit, Reaktion und Funktionalität.

Auch die NetBeans-Plattform als klassisches RCP Framework zeigt mit seinen ganzen existierenden Derivaten, dass der Desktop eben nicht eine verarmte Softwarelandschaft ist. Im Gegenteil, da wo massive Robustheit, gute Wartbarkeit und flexible Schnittstellen zu anderen tausenden Frameworks benötigt werden, ist Java auf dem Desktop, nach meinem Dafürhalten, die zentrale Plattform.

Was tatsächlich allein schon auf der NetBeans Plattform existiert, zeigt eindrucksvoll die Liste auf netbeans.org. Hier ein paar Screenshots:

und Hundert mehr. Diese Applikationen sind ausschließlich auf der NetBeans Plattform entstanden und stellen keine vollständige Liste dar. Dazu gibt es wieder unzählige reine Swing-Applikationen und Anwendungen, die auf dem Eclipse RCP Framework basieren.

Alles Anwendungen die stabil und robust in den Firmen dieser Welt werkeln. Vielleicht unbeachtet und nicht immer sichtbar in dem omnipräsenten Internet, aber wichtig für Entwicklung und Wirtschaft.

Aber die Entwickler stöhnen, sie vermissen den Anschluss zu den ganzen schönen Gimmicks, die Silverlight, Adobe Air und andere Frameworks bieten, um Desktop-Anwender das 110%-Feeling zu geben. Unabhängig davon, ob man das wirklich braucht, vielleicht gibt es mit JavaFX for Swing eine Lösung, die Desktop-Apps auch für den privaten Desktop wieder attraktiver macht. Vielleicht schaffen wir es SwingX und Labs-Komponenten verstärkt in das JDK aufzunehmen. Vielleicht wird es endlich eine HTML-Browser-Komponente in den Standard-Runtimes geben. Eventuell sieht man die Notwendigkeit, dass Java einfacher mit nativen Schnittstellen arbeiten kann, sei es zum OS, sei es zu Hardware-Schnittstellen.

Ich denke schon, dass es da eine Zukunft gibt. Die geballte Wucht der vorhandenen Applikationen kann sowieso nur eine Richtung vorgeben. Ich hoffe nur, dass die Macht des Faktischen auch bei Oracle erhört wird.

Beste Grüße,
Josch.

You can find an English version on NetBeans Zone.

Moin!

Bei den NetBeans Certified Trainings übernehme ich regelmäßig den Teil Nodes & Explorer Views (pdf). Dabei stelle ich regelmäßig die unterschiedlichen Views vor. Dafür habe ich ein kleines Demo-Programm geschrieben. Das Programm zeigt allerdings nicht nur die Vorzüge der Views, sondern auch die Probleme mit deren Darstellungen. Gerade das IconView glänzt nicht gerade mit schöner Optik. Ich hatte aus der Not eine Tugend gemacht und gerade für das Training eine eigene Implementation vorbereitet. Damit kann man den Teilnehmern sehr leicht zeigen, wie man eigene Views für die Nodes-API erstellen kann.

Dieses BetterIconView hat es Toni Epple angetan und er zeigte es im Dezember letzten Jahres Jaroslav Tulach. Er hatte gestern Zeit gehabt, meine paar Codezeilen zu nehmen, um damit das alte IconView zu ersetzen.

Wie man an dem Beispiel des alten IconView erkennen kann, funktioniert so einiges nicht. Fokusrahmen fehlt, Größenberechnung in der Höhe ist zu groß und die Nodes überlappen sich bei langen Texten.

Meine neue Implementation ist zwar recht einfach und nicht im jeden Detail perfekt, aber sicherlich um einiges besser, als die alte Version in der NetBeans Plattform.

Hier ein Screenshot mit drei selektierten Nodes und dem korrekten Fokusrahmen-Verhalten:

Den Quelltext kann man hier einsehen. Es ist wirklich sehr einfach ein ListView zu erweitern, um ein neues IconView zu erzeugen, deswegen werden da keine großen Überraschungen auftauchen.

Man sollte nur berücksichtigen, dass man in Views nicht mit dem Nodes aus dem Modell des Entwicklers arbeitet, sondern mit optimierten Wrappern. In einem Renderer (hier ListCellRenderer) konvertiert man das übergebene Value-Objekt in ein Node mit der Hilfsklasse Visualizer:

Node node = Visualizer.findNode(value);

Hat man diese Hürde geschafft, kann man alles realisieren, was Swing zu bieten hat. Der Kreativität sind also keine Grenzen gesetzt. Ich möchte da zum Beispiel auch auf Geertjans Blog verweisen, wo er die Visual Library als Explorer-View nutzt.

Beste Grüße,
Josch.

Moin!

Leider erreichte mich heute über die Mailingliste eine nicht sehr schöne Nachricht. Die Ruby On Rails Entwicklung wird nicht mehr vom NetBeans Core Team unterstützt.

Tinuola Awopetu von Oracle beschreibt es so:

After thorough consideration, we have taken the difficult step to discontinue support for Ruby on Rails in the NetBeans IDE.

Dabei werden zwei Hauptgründe genannt. Erstens:

Java SE 7 and Java Development Kit 7 (JDK 7) are the next major releases of the Java SE platform, which Oracle is committed to deliver in 2011. A key objective of the NetBeans IDE has always been to offer superior support for the Java platform. To maintain that objective and capitalize on the JDK 7 release themes–multi-language support, developer productivity and performance–it is necessary that our engineering resources are committed to a timely and quality release of NetBeans IDE 7.0.

Das Entwicklerteam will sich auf den Fokus JDK 7 konzentrieren, damit NetBeans 7 eine 100% Unterstützung mit dem Release bieten kann. Damit setzt Oracle (wie auch schon in der Vergangenheit angekündigt wurde), verstärkt auf die Java-Entwicklung. Ruby on Rails kann da nicht in der gewünschten Qualität einfließen.

Oracle sieht aber nicht nur einen stärkeren Fokus bei Java, sondern sieht Ruby on rails überhaupt im Abwind. Das ist der zweite Grund:

Second: Although our Ruby support has historically been well received, based on existing low usage trends we are unable to justify the continued allocation of resources to support the feature.

Ab dem 27. Januar 2011 wird Ruby on rails aus den Dev-Builds verschwinden. Entwickler aus der Community, die Ruby on Rails weiter unterstützen wollen, werden auf die NetBeans Ruby Support Seite verwiesen.

Feedback zu dieser Entscheidung wird ebenfalls gewünscht. Oracle verweist dazu auf die Mailinglisten/Foren, Twitter oder den direkten Kontakt zum NetBeans IDE Team.

Beste Grüße,
Josch.

Moin!

Nur ein kleines Appetithäppchen. Wenn man transparente JButtons benötigt, weil die dahinter liegenden JPanels Grafiken oder Farbverläufe haben, benötigt man besonders beim Windows-System Look&Feel einen Trick.

Zunächst reicht es nicht, nur setOpaque (false) zu verwenden. Es wird trotzdem ein Hintergrund als Füller gemalt. Die ui-Klasse ist so leider programmiert. Man kann aber eine transparente Hintergrundfarbe setzen:

public class TransparentButton extends JButton {

  public TransparentButton () {

    super();

    setBackground (new Color (255, 255, 255, 0));

    setOpaque (false);

  }

}

Wenn man bei (halb-) transparenten Hintergrundfarben das setOpaque (false) vergisst, hat man übrigens sehr unschöne Back-Buffer Effekte. D.h. die Optimierungen im Swing-Framework verursachen dann unschöne zerhackte Grafikeffekte. In Kombination funktioniert es aber super.

Beste Grüße,
Josch.

Moin!

Die Frage kommt immer wieder mal, deswegen wollte ich hier eine kleine Liste an Programmen erfassen, die Java-Programme in native Betriebssysteme integrieren, Installer erzeugen oder das Starten vereinfachen.

Ich habe dafür drei Gruppen. Die Launcher sind Executables, die Java-Programme wie native Programme starten lassen. Das ist üblicherweise nur unter Windows notwendig. Linux und Mac behandeln Java-Programme wie alle anderen Executables. Die nächste Gruppe wäre Installer. Diese Werkzeuge erzeugen aus Java-Projekten Installationspakete, die es dem Anwender ermöglichen per Kommandozeile oder Assistenten Java-Programme zu installieren oder später zu deinstallieren. Die letzte Gruppe behandelt Packer. Darin fasse ich Tools zusammen, die 3rd-Party-Libs in ein JAR zusammenfassen, JARs komprimieren oder Klassen so umbenennen, so dass eine Quelltextwiederherstellung sehr schwer gemacht wird (Obfuscator).

Ich würde mich freuen, wenn ein paar Anregungen und Erfahrungsberichte rein kommen würden. Für die NetBeans Platform gibt es schon integrierte Installer für Windows, Linux, MacOS und Solaris sowie eine WebStart Variante. Außerdem einen Pack200 Tool für den Installer. Da braucht man für die meisten Fälle keine externen Tools.

Hier also eine Liste, die ich schon so gesammelt habe:

Launcher

• WinRun4J
  • Lizenz: CPL
  • OS: Windows
  • Integration: Kommandozeile, Eclipse Plugin
  • Ein Executable mit native Bindings, Windows DDE-Zugriff, konfigurierbarem Icon, INI-Datei für Startparameter, Dienste-Wrapper, Systemlog-Unterstützung und Konsolenmodus.
  • Es unterstützt auch das Packaging von 3rd-Party Bibliotheken.
  • Soweit ich das sehen kann, hat man mindestens immer ein JAR und eine Java-Umgebung muss installiert sein.
• Launch4j
  • Lizenz: BSD und MIT
  • OS: Alle Java-Plattformen (Ziel bleibt aber Windows)
  • Integration: Kommandozeile, Ant, Maven, GUI (Wizard)
  • Launch4j erzeugt eine Windows Executable-Datei, die alle JARs, native Bibliotheken und sogar ein Embedded JRE enthalten kann.
  • Es unterstützt eigene Icons für die Exe, JAR’s werden nicht beim Start extrahiert, unterstützt auch Konsolenanwendungen,

Installer

• Open Installer (Crossplatform Installer)
  • Lizenz: CDDL 1.0
  • OS: Alle Java-Plattformen
  • Integration: Kommandozeile, NetBeans Platform Installer
  • Ich erwähne den Open Installer hier, weil dieser in der NetBeans Platform integriert ist und als Installer für den Glassfish verwendet wird. Ansonsten würde ich als Entwickler die Finger davon lassen, weil das Projekt extrem schlecht dokumentiert ist. Am besten den Quelltext anschauen, wenn man eine hohes Maß an Interesse und Leidensfähigkeit hat.
• Antigen (Ant Installer Generator)
  • Lizenz: k/a
  • OS: Alle Java-Plattformen
  • Integration: Ant, Kommandozeile, (evtl. Maven)
  • Erzeugt aus Ant-Scripts einen grafischen Installer
  • Alle Programmbestandteile werden in einem JAR-Installer gepackt. Eine Java Runtime muss auf dem Zielrechner existieren.
• InstallJammer
  • Lizenz: GPL mit “Special Exception“, darf kommerziell genutzt werden
  • OS: Multiplattform (tck/tcl), Windows 98, ME, 2000, XP, 2003, Vista, 2008, Linux, FreeBSD, Solaris, HP-UX, AIX
  • Integration: Kommandozeile, GUI
  • InstallJammer ist eine mächtige OpenSource Lösung die einen nativen Installer mit umfangreicher Buildumgebung anbietet. Der Installer ist nicht auf Java-Programme beschränkt. JRE wird vom Installer nur gesucht, aber nicht bei Bedarf installiert. Man kann aber das JRE wohl über Actions mitinstallieren.
  • Mehrsprachigkeit, Multiplattform, Nativer Installer im OS-Look, Benutzerdefinierte Aktionen, Installer-Profile (Kommandozeile, GUI, Silent, usw), GUI-Bearbeitung der Assistenten-Panels, Themen, Deinstallationsroutinen.
  • Umfangreiche Dokumentation
• Install4j
  • Lizenz: Kommerziell (Windows Single ab 600€, Multiplatform Single ab 1700€, nach oben offen…)
  • OS: Win32, Win64, Linux RPM, MacOS, Unix
  • Integration: Ant, Kommandozeile, GUI
  • Dieser kommerzielle Installer bietet einen GUI oder Kommandozeileninstaller (auch Silent), JRE-Pacakging oder Detection, GUI und Scriptsprache, Mehrsprachigkeit, Dienste-Unterstützung, eigenes Icon und sehr vieles mehr.
• Advanced Installer for Java Freeware Edition
  • Lizenz: Kommerziell, Freeware Edition
  • OS: Windows
  • Integration: Kommandozeile, GUI
  • Die Freeware Edition bietet einen MSI Installer Generator für Java Programme mit UAC Unterstützung, Registry-Zugriff, 32bit und 64bit, Scripting über XML-Konfiguration.
  • JRE Bundling ist nicht in der Free Edition, Custom Icon ist nicht möglich.
  • Feature Matrix

Packer

• one-jar
  • Lizenz: Proprietär, OpenSource, BSD?
  • OS: Alle Java-Plattformen
  • Integration: Ant, Maven
  • Erzeugt aus mehreren JAR-Bibliotheken eine einzelne ausführbare JAR-Datei
  • Unterstützt auch native Bibliotheken, die während des Starts in das Dateisystem entpackt werden.
• ProGuard (Obfuscator)
  • Lizenz: GPL
  • OS: Alle Java-Plattformen
  • Integration: Kommandozeile, Ant
  • Verändert sprechende Bezeichner (z.B. Paket und Klassennamen) in kompilierten JARs in verkürzte oder randomisierte Namen, um die Wiederherstellung von bearbeitbaren Quelltext zu erschweren.
  • Unterstützt viele Plattformen (Java 1.1 bis 6, ME, Android)
• pack200 JAR Packager
  • Lizenz: Oracle License
  • OS: Alle Java-Plattformen
  • Integration: Kommandozeile
  • Ein Tool des Java SE SDKs von Oracle, dass seit Java 5 JAR Dateien besonders effizient packen kann.
  • Der Einsatz sind üblicherweise webbasierte Java-Anwendungen, damit diese im Download möglichst wenig Bandbreite verwenden
• Ant Script für die NetBeans IDE
  • Lizenz: k/a
  • OS: Alle Java-Plattformen
  • Integration: Ant, NetBeans IDE
  • Es handelt sich dabei nicht um ein Programm, sondern ein Ant-Target-Script zum Erstellen von Single-JARs. Der verlinkte Blogeintrag beschreibt, wie man in NetBeans dieses Script integrieren kann.

Moin!

Kohsuke Kawaguchi hat es gestern veröffentlicht. Der Name Hudson CI ist gestorben. Der Continious Integration Server soll in Jenkins (CI?) umbenannt werden.

Wie Kohsuke in einer Nachricht schreibt, konnte Oracle, trotz einer ein Monat langen Kommunikation, nicht davon überzeugt werden, dass der Name Hudson CI in einer “neutralen Organisation” gut aufgehoben wäre.

The central issue was that we couldn’t convince Oracle to put the trademark under a neutral party’s custody (such as Software Freedom Conservancy), to level the playing field.

Er führt aber auch aus, dass Oracle Pläne mit Hudson verfolgen will, die der aktuellen Entwicklung des CI-Servers nicht entspricht. Dazu gehöre auch eine erheblich formalisiertere Projektstruktur, Änderungen in der Architektur und das verstärkte Einbinden von 3rd-Party Abhängigkeiten.

Aside from this, Oracle wanted a broader change to the way the Hudson project operates, including a far more formal change review process, architectures, 3rd party dependencies and their licenses, and so on.

[...]

All of those still might not have been a show-stopper if we felt that there is a genuine trust between us, but in this case, we just failed to build such a relationship, even after a month long conversation.

Als Konsequenz soll das Projekt in Jenkins umbenannt werden. Dieser Name ist erneut ein “Buttler”-Name aus dem englischen Sprachraum und soll aktuell von keinem anderen Software-Projekt beansprucht sein.

So in the end, we’d like to propose the community that we regrettably abandon the name “Hudson” and rename to “Jenkins” — it’s another English-sounding butler name that doesn’t collide with any software project as far as I can tell.

Das Proposal für die Namensänderung wurde im Hudson Lab veröffentlicht:

The Proposal

First, we rename the project – the choice for a new name is Jenkins, which we think evokes the same sort of English butler feel as Hudson. We’ve already registered domains, Twitter users, etc for the new name, and have done our best to verify that there are no existing trademarks which would conflict with it. Kohsuke will be registering the trademark for Jenkins in his name, with the intent of transferring ownership of the trademark to the umbrella of the Software Freedom Conservancy once the Jenkins project has been admitted to it (which, I should add, is very much our plan, hopefully in their next round of new projects in a few months – we’ve already had preliminary contacts with SFC). We still invite Oracle to remain involved with the project, on equal terms with all other contributors, and hope they’ll take us up on this invitation.

[...]

Das Proposal umfasst aber mehr als nur eine Namensänderung. Außerdem soll die Infrastruktur des Projektes komplett von Oracle weg verschoben und ein Governance Board eingerichtet werden.

Ich würde mich freuen, wenn der CI Server auch in Zukunft in der NetBeans IDE unterstützt wird. Hudson nutze ich schon seit einiger Zeit, um zentralisierte Maven- und Ant-Builds durchzuführen.

Noch besser wäre es, Oracle würde mit seinem verbleibenden Hudson Projekt sich nicht zu weit von Jenkins entfernen. Konkurrenz belebt zwar das Geschäft, aber in diesem Fall wäre der Nutzen für die Anwender fraglich.

Beste Grüße,
Josch.

Moin!

Wenn man kleine schnelle Testumgebungen für NetBeans IDE-Plugins haben möchte, sollte man sich diese FAQ anschauen.

DevFaqNetBeansFullHack

Can I test changes to the IDE without going through the license check and so on?

Ja, tatsächlich geht das. Mit einem kleinen Parameter netbeans.full.hack auf true gesetzt, werden einiges an Dialogen, Test und Remotezugriffen (Auto Update Center, Maven Index) deaktiviert:

• Auto Update background check (to see if updates are available); you can still use AU via Tools > Plugin Manager
• prompting about still-running tasks when shutting down
• license dialog
• import of old user directory
• IDE registration dialog
• dialog suggesting that you submit usage statistics
• welcome screen displayed by default and RSS feed refreshed
• blocking dialog when some modules could not be loaded
• use of ~/NetBeansProjects/ for newly created projects (java.io.tmpdir will be used instead)
• resizing gesture submit dialog (SubmitStatus.resize)
• weekly Maven repository indexing (can be configured in Options dialog)
• long package name for default group ID in new Maven project (test used instead)

So können Plugin-Tests und automatisierte Tasks mit Aufruf der NetBeans IDE ohne störende Dialoge durchgeführt werden.

Beste Grüße,
Josch.

Moin!

Das Plugin SevenBeans bringt für die NetBeans IDE das 100% Native-Feeling auf Windows 7 Betriebssystemen.

Mit diesem Plugin erhält man zu dem NetBeans-Taskbar Icon eine

• Jumplist (spezielles Kontextmenü per rechter Maustaste),
• Iconoverlays (d.h. ein Build wird in der Taskbar als Badged Icon dargestellt),
• Den hellgrünen Fortschrittsbalken im Taskbar-Icon,
• Minivorschau der geöffneten Tabs, wenn man mit der Maus über das Taskbar-Icon fährt
• und einen Konfigurationsdialog in den Options, um alle neuen Features ein- oder auszuschalten.

SevenBeans basiert auf der Technologie von J7Goodies, ein Framework um Swing-Anwendungen mit solchen Features auszustatten.

Eine Jumplist wird so zum Kinderspiel:

DestinationList albums;

albums.addFile("C:\\Users\\Alex\\My Pictures\\Bachelor Party.alb");

albums.addFile("C:\\Users\\Alex\\My Pictures\\Family.alb");

albums.addFile("C:\\Users\\Alex\\My Pictures\\Flowers.alb");



DestinationList tasks;

tasks.addTask("/camera", "Import from camera", cameraIconPath);

tasks.addTask("/scan", "Scan a photo", scannerIconPath);



JumpList jumpList;

jumpList.appendRecentCategory();

jumpList.appendCustomCategory("Albums", albums);

jumpList.appendTasks(tasks);

jumpList.save();

Viele weitere Beispiele finden sich auf der J7Goodies Homepage.

Schön ist es, dass das Plugin für NetBeans schon fertig ist. Die aktuelle Version kann hier heruntergeladen werden.

Beste Grüße,
Josch.