XStream (http://xstream.codehaus.org/) ist neben
XmlBeans einer der bekanntesten XML-Serialisierer. Nun haben die Entwickler die Bibliothek erweitert, dass XStream auch als XML-JSON-Serialisierer (http://xstream.codehaus.org/json-tutorial.html) arbeitet. Die Methodenamen sind mit toXML() und fromXML() zwar nicht so passend, aber der Aufruf dennoch einfach:

Product product = new Product("Banana", "123", 23.00);
XStream xstream = new XStream(new JettisonMappedXmlDriver());
xstream.setMode(XStream.NO_REFERENCES);
xstream.alias("product", Product.class);
System.out.println(xstream.toXML(product));

Der andere Weg:

String json = "{\"product\":{\"name\":\"Banana\",\"id\":\"123\"" +
              ",\"price\":\"23.0\"}}";
XStream xstream = new XStream(new JettisonMappedXmlDriver());
xstream.alias("product", Product.class);
Product product = (Product)xstream.fromXML(json);
System.out.println(product.getName());

Unter http://www.antlr.org/wiki/display/ANTLR3/Tool+showing+grammatical+structure+of+Java+code gibt es ein hübsches Gui-Tool, welches nach der Java Grammatik vom Openjdk javac compiler project with ANTLR-based Java grammar die Struktur aufzeigt:

Sun hat Anfang Dezember 2008 JavaFX veröffentlicht. Es ist als Alternative zu MS Silverlight und Flash + Flex für Rich Internet Applications gedacht. Einige Links dazu:

• http://en.wikipedia.org/wiki/JavaFX
• http://en.wikipedia.org/wiki/JavaFX_Script
• http://en.wikipedia.org/wiki/JavaFX_Mobile
• http://www.theregister.co.uk/2008/01/24/javafx_tools_adobe/
• http://www.oreillynet.com/onjava/blog/2007/05/javafx_im_still_not_impressed.html

Zentrale Punkte von JavaFX 1.0 sind: (Zitiert von http://blogs.sun.com/javafx/entry/javafx_1_0_is_live)

• Fast and easy to use 2D graphics
• PerspectiveTransform for 3D effects
• KeyFrame animation
• Video and Audio support using both native and cross-platform codecs
• Swing Integration
• XML & JSON web services
• Pixel-filters and visual effects with GPU hardware acceleration
• CSS styling (more on that later)
• Windows XP+ and Mac 10.4+ support with Linux & Solaris in the works (more on that later too)
• The new JavaFX Script language with binding and animation built in, running 10->20x faster than Javascript
• Visually rich applets that you can drag to your desktop and save for later
• Integration with Photoshop and Illustrator
• Access to the world’s huge library of Java code and APIs
• A new website with docs, tutorials, and tons of BSD licensed sample code and as a nice bonus:
• A sneak-peek beta of JavaFX on mobile devices

Der Punkt Support with Linux & Solaris in the works macht sicherlich nicht jeden in der Community glücklich, aber gut…

Sun hat die schöne Seite http://javafx.com/ aufgebaut, um mehr über JavaFX zu lernen. Die NetBeans IDE 6.5 bringt volle Unterstützung für JavaFX (http://www.netbeans.org/features/javafx/index.html) mit. Für Eclipse gibt es bisher keine große Unterstützung.

http://www.reportmill.com/jfx/ bringt passend ein Tool auf Markt. Zentrale Elemente sind (Zitiert von der Webseite):

• Powerful Visual Designer
• Animation, Illustration and Page Layout
• Video, Sound and Image Effects
• Drag & Drop Application Components
• JDBC and POJO Data Binding
• HTTP Form Generation and Binding
• Navbar Generation, Page Transitions
• Graphs, Charts, Tables and Reports
• Full Featured Player/Document Reader
• Extension Plugins with Internet Directory

Eine JTable ist zwar eine einfache Komponente, doch schon in der HTML-Tabelle gibt es Eigenschaften, die die JTable nicht abbilden kann: Zellen, die über mehrere Zeilen und Spalten gehen. Hier ist einiges an Programmieraufwand nötig, der jedoch für diejenigen unnötig ist, die auf die freie Komponente JGrid zurückgreifen. Die Swing-Komponente gehört zu Pepper (http://jeppers.sourceforge.net/), einer Komponente für Tabellenkalkulationen, die sogar eine Formelauswertung ähnlich Excel versteht. Pepper selbst untersteht zwar der GPL, doch JGrid ist LGPL und lässt sich somit in eigene kommerzielle Anwendungen einbinden.

PS: tutego bietet nun auch ein GWT-Seminar an:

• Google Web Toolkit (GWT)

Jad (http://www.kpdus.com/jad.html) gehört immer noch zu den Klassikern der Java-Decompiler. Nun gibt es etwas neues, den “Java Decompiler” (http://java.decompiler.free.fr/). Mit dem Screenshot der Gui sieht das schon mal vielversprechend aus.

Kirill Grouchnikov hat unter http://www.pushing-pixels.org/?p=622 einen langen Blog verfasst, in dem er sich mit der Entwicklung und Einsatz der Ribbon-Komponente befasst. Der Blog mit seinen vielen Links ist auf jeden Fall lesenswert. Für Java hat Kirill eine Ribbon Komponente implementiert, die Teil vom Flamingo Framework (https://flamingo.dev.java.net/) ist. Die Dokumentation https://flamingo.dev.java.net/docs/ribbon/ribbon-overview.html zeigt Screenshots und die API dahinter.

http://www.mms-computing.co.uk/uk/co/mmscomputing/device/twain/ ist eine Java-API für die TWAIN-Schnittstelle, um etwa einen Scanner anzusteuern. Ein Beispiel ist schnell aufgebaut:

import java.awt.BorderLayout;
import java.awt.event.ActionEvent;

import javax.swing.AbstractAction;
import javax.swing.Action;
import javax.swing.JButton;

import org.jdesktop.swingx.JXFrame;
import org.jdesktop.swingx.JXImagePanel;
import org.jdesktop.swingx.JXImagePanel.Style;

import uk.co.mmscomputing.device.scanner.Scanner;
import uk.co.mmscomputing.device.scanner.ScannerIOException;
import uk.co.mmscomputing.device.scanner.ScannerIOMetadata;
import uk.co.mmscomputing.device.scanner.ScannerListener;
public class TwainExample
{
  @SuppressWarnings("serial")
  public static void main( String[] args )
  {
    final JXImagePanel imagePanel = new JXImagePanel();
    imagePanel.setStyle( Style.SCALED_KEEP_ASPECT_RATIO );
    final Scanner scanner = Scanner.getDevice();
    JXFrame f = new JXFrame( "SSP", true );
    Action action = new AbstractAction("Scan") {
      @Override public void actionPerformed( ActionEvent e ) {
        try { scanner.acquire(); } catch ( ScannerIOException ex ) { }
      }
    };
    f.add( new JButton(action), BorderLayout.PAGE_START );
    f.add( imagePanel );
    f.setSize( 1000, 700 );
    f.setVisible( true );
    scanner.addListener( new ScannerListener()
    {
      public void update( ScannerIOMetadata.Type type, ScannerIOMetadata metadata )
      {
        if ( ScannerIOMetadata.ACQUIRED.equals( type ) )
          imagePanel.setImage( metadata.getImage() );
      }
    } );
  }
}

Globale Mausbewegungen von Java zu überwachen ist mit dem MouseInfo.getPointerInfo().getLocation() kein Problem. Aber mitzubekommen, ob in einer anderen Java-Applikation eine Maustaste oder eine andere Keyboard-Taste gedrückt ist, schon. Wer vor dem Problem steht, dies unter Java und Windows abzufangen, kann SWT zusammen mit den SWT Win32 Extensions (http://www.swtui.cn/index.php) nutzen — auch wenn man selbst nicht mit SWT, sondern mit Swing arbeitet. Soll etwa global die <Pause> Taste abgefangen werden, kann man schreiben:

Hook.KEYBOARD.addListener(new HookEventListener() {
    public void acceptHookData( HookData hookData ) {
      if ( ((KeyboardHookData) hookData).getVirtualKeyCode() == KeyEvent.VK_PAUSE &&
          ! ((KeyboardHookData) hookData).getTransitionState() ) {
         // TU WAS DICH GLÜCKLICH MACHT
      }
} } );
Hook.KEYBOARD.install();

Neben Hook.KEYBOARD gibt es auch Hook.MOUSE.

Möchte man nun beides zusammen haben, also wissen, ob etwa STRG und eine Maustaste gedrückt wurde, meldet man einen HookEventListener für die Maus an und fragt die Taste wie folgt ab:

Extension.GetKeyState(Extension.VK_CONTROL) < 0

package com.tutego.traida.util;

import java.io.FileOutputStream;
import java.util.HashMap;

import com.lowagie.text.pdf.PdfReader;
import com.lowagie.text.pdf.PdfStamper;

public class PdfUtils
{
  public static void setMetaData( String sourceFilename, String targetFilename )
  {
    try
    {
      PdfReader pdfReader = new PdfReader( sourceFilename );
      PdfStamper stamp = new PdfStamper( pdfReader, new FileOutputStream( targetFilename ) );

      @SuppressWarnings("unchecked")
      HashMap<String, String> info = pdfReader.getInfo();
      info.put( "Title", "Rechnung für Beratung" );
      info.put( "Author", "tutego" );
      info.put( "Subject", "Rechnung" );
      info.put( "Keywords", "Rechnung, tutego" );
      info.put( "Creator", "http://www.tutego.com/" );
      info.put( "Producer", "tutego Training Software 1.2" );

      stamp.setMoreInfo( info );
      stamp.close();
      pdfReader.close();
    }
    catch ( Exception e )
    {
      e.printStackTrace();
    }
  }

  public static void main( String[] args )
  {
    setMetaData( "c:/a.pdf", "c:/new.pdf" );
  }
}

With iText of course:  http://www.lowagie.com/iText/

Das Eclipse-Plugin http://jacob-project.wiki.sourceforge.net/Jacob+Gen+Plugin erlaubt über einen Menüeintrag einfach das Erzeugen von Stub-Code für den Zugriff auf Windows-DLLs.

Der Generator geht einen interessanten Weg über Eclipse JET, wie es die Webseite erklärt:

The plug-in uses the old, JacobGen 0.7, c++ program (dll) which reads a Microsoft’s proprietary TLB file and writes out what it finds on stdout. From the information gathered the plug-in produces an ecore model based of what is found inside the TLB. At this point the plug-in has created a model of what’s inside the DLL file. I.E. what classes and enums exist. The plug-in uses Java Emitter Templates (JET) to generate java code based on the above ecore model. It also produces the java method bodies to automatically call JACOB methods with the correct parameters. This will create a strongly typed java proxy, via JACOB, into the windows DLL.
So to wrap up. The plug-in reads the TLB file (using the existing JacobGEN DLL), creates a model based on the TLB / DLL file, and then produces a java proxy. The JET generated classes are really a proxy into the DLL via JACOB. So the end result is a set of java classes hiding all JACOB internal knowledge.