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.

Wer von Java aus auf die Inhalte von Wikipedia zugreifen, und die Inhalte auch noch Rendern möchte, findet mit der quelloffenen Java Wikipedia API (http://www.matheclipse.org/en/Java_Wikipedia_API) eine passende Unterstützung.

Zum Laden einer Wikipedia-Seite und Renderer in eine Datei ist lediglich nötig:

User user = new User( "", "", "http://de.wikipedia.org/w/api.php" );
List<Page> queryContent = user.queryContent( Arrays.asList( "Java (Programmiersprache)" ) );
String content = queryContent.get( 0 ).getCurrentContent();

WikiModel wikiModel = new WikiModel( "http://de.wikipedia.org/wiki/${image}",
                                     "http://de.wikipedia.org/wiki/${title}" );

String rendererdHtmlContent = wikiModel.render( content );

FileWriter fw = new FileWriter("c:/test.html");
fw.write( rendererdHtmlContent );
fw.close();

Einige Dinge löst der Renderer aber nicht auf. So verbleiben im Text Wiki-Templates wie

• {{Infobox Programmiersprache}}
• {{IPA}}
• {{Wikiversity}}
• {{Wikibooks}}

oder bei anderen Texten

• {{Begriffsklärungshinweis}}
• {{Commonscat}}
• {{internetquelle}}
• {Literatur}}

Auch Bilder werden standardmäßig nicht richtig umgesetzt. So wird bei http://de.wikipedia.org/wiki/Linux aus

[[Bild:Linus Torvalds.jpeg|thumb|right|Linus Torvalds 2004]]

kein Bild, sondern ein Link

<a href="http://de.wikipedia.org/wiki/Bild:Linus_Torvalds.jpeg%7Cthumb%7Cright" id="w">Linus Torvalds 2004</a>

Dumm nur, dass %7Cthumb%7Cright falsch ist, sonst wäre wenigstens der Link korrekt. (%7C ist |)

VisualVM ist nun in der Version 1.0 final. Ein erstaunliche Neuerung ist, dass Sun VisualVM in das Update 7 von JDK 6 integriert hat; sonst wurden noch nie in Updates neue Tools integriert.

Die wichtigsten Features von der Webseite:

Display local and remote Java applications. VisualVM automatically detects and lists locally and remotely running Java applications (jstatd must be running on the remote host). You can also define applications manually by JMX connection. This way you can easily see what Java applications are running on your system or check if a remote J2EE server process is alive.

Display application configuration and runtime environment. For each application VisualVM shows basic runtime information: PID, main class, arguments passed to java process, JVM version, JDK home, JVM flags and arguments and system properties.

Monitor application memory consumption and runtime behavior. VisualVM monitors application heap and permanent generation memory, number of loaded classes and running threads. You can easily detect suspicious memory consumption and take an action – invoke garbage collection in the application or take a heap dump and browse the contents of application heap.

Monitor application threads. All threads running in a Java process are displayed in a timeline. You can track thread activity and uncover inefficient patterns like blocked Event Dispatch Thread or unused worker threads.

Profile application performance or analyze memory allocation. VisualVM has a built-in application profiler which can visualize where most of the time is being spent or which objects consume most of the memory by just one mouse click without any additional configuration.

Take and display thread dumps. Taking and displaying a thread dump is as easy as clicking a mouse button. You don’t need to deal with the command line at all to determine what’s currently happening in the application. Moreover, simultaneous thread dumps of multiple applications can be taken at once to start uncovering distributed deadlocks.

Take and browse heap dumps. When you need to browse contents of application memory or uncover a memory leak in your application, you’ll find the built-in HeapWalker tool really handy. It can read files written in hprof format and is also able to browse heap dumps created by the JVM on an OutOfMemoryException.

Analyze core dumps. When a Java process crashes, a core dump can be generated by the JVM containing important information about application state at the time of the crash. VisualVM is able to display application configuration and runtime environment and to extract thread and heap dumps from the core dump.

Analyze applications offline. VisualVM is able to save application configuration and runtime environment together with all taken thread dumps, heap dumps and profiler snaphots into a single application snapshot which can be later processed offline. This is especially useful for bug reports where users can provide a single file containing all the necessary information to identify runtime environment and application state.

Die Webseite sieht auch viel schicker aus (was für die anderen java.net-Projekte aber nicht gilt).

Werbung: Wir haben neue/aktualisierte Seminare.

• WebSphere AS Community Edition/Geronimo Administration
• SWT und JFace
• Apache HTTP Server

APIviz ist ein LGPL-Doclet, welches nicht nur die klassische JavaDoc-API erstellt, sondern gleich dabei noch UML-Diagramme. Die Diagramme werden generiert von http://www.graphviz.org/.

Hier ein Beispiel, wie das nach dem Erzeugen aussieht:

net.gleamynode.netty.buffer
Class HeapChannelBuffer

java.lang.Object
  net.gleamynode.netty.buffer.AbstractChannelBuffer
      net.gleamynode.netty.buffer.HeapChannelBuffer

All Implemented Interfaces:

Comparable<ChannelBuffer>, ChannelBuffer

Direct Known Subclasses:

BigEndianHeapChannelBuffer, LittleEndianHeapChannelBuffer

public abstract class HeapChannelBuffer
extends AbstractChannelBuffer

Version:

$Rev$, $Date$

Author:

The Netty Project (netty@googlegroups.com), Trustin Lee (trustin@gmail.com)

Wer für die Java ME entwickelt, der muss vieles selbst machen, da die CLDC/MIDP-Bibs doch relativ schwach sind. Zwei Open-Source Bibs, die dort Arbeit abnehmen können, sind:

• kommons – JavaME reusable objects; hat nix mit KDE zu tun 🙂
  The goal of the project kommons is to provide a set of reusable objects useful to make networking, object persistence (Caching), logging, working with Strings (Iso, UTF8) and many more…
• 59pixels Open Source J2ME Libraries
  Some of the libraries which 59Pixels have built up over the last year. Most of them are the first generation versions and are not as polished or as efficient as they could be but we have been able to distribute our products on over 150 handsets so I’m sure they will be useful to you.

Von http://poi.apache.org, der Open-Source Bib. zum Verarbeiten von MS Excel-, PowerPoint-, Visio- und Word-Dateien, gibt es eine neue Version. Änderungen sind unter anderem:

Highlights in POI-HSSF - Java API To Access Microsoft Excel Format Files:

• Major improvements in formula evaluation
• Support for conditional formatting
• Support for Excel hyperlinks
• Handling of embedded OLE2 documents
• Support for getting excel cell comments when extracting text
• Support for specifying a policy to HSSF on missing / blank cells when fetching

Highlights in  POI-HSLF - Java API To Access Microsoft PowerPoint Format Files:

• Support for getting embedded sounds
• Support for getting embedded OLE objects
• Support for Tables
• Improved text extraction
• Export PowerPoint slides into image
• Java2D Graphics driver

Highlights in POI-HWPF - Java API To Access Microsoft Word Format Files

• Handling of embedded OLE2 documents
• Support for extracting Escher images from HWPF files
• Improved Range.replaceText()

Ich bin gespannt, ob sich mit der MS-Initiative, Dokus anzubieten, die Bib. noch weiter und vollständiger entwickeln wird:

• Microsoft legt Dokumentationen zu Dateiformaten und Protokollen vor

Ein abgefahrendes Projekt ist eine JPA-Schnittstelle für die Amazon SimpleDB (Amazon S3 (Simple Storage Service)). Mit http://code.google.com/p/simplejpa/ lässt sich auf die Amazon-Datenbank über das standardisierte JPA zugreifen. Die Doku unter http://code.google.com/p/simplejpa/wiki/GettingStarted listet alles nötigen Jar-Dateien auf und zeigt anhand eines kleines Beispiels die Nutzung. Da die Amazon-DB keine "richtige" relationale DB ist, gibt es auch einige Einschränkungen, etwa "Can only query on a single object type, no joins." Auf der anderen Seite:

• Supports ManyToOne references with lazy loading
• Supports OneToMany collections with lazy loading
• Large object (LOB) support via Amazon S3
• Caches objects for quick response after first retrieval
• Retrieves result sets concurrently for fastest retrieval from SimpleDB
• JPA Queries (subset)
• @ManyToOne – object references. Stores id reference to another object in another Domain
• @OneToMany (java.util.List only, must be generified, must be bi-directional with mappedBy parameter) – Collection support. Please be careful with collections, usually better to just query for what you want rather than attaching via collections.
• @Inheritance – Only SINGLE_TABLE supported (only one that makes sense).
• @MappedSuperClass – Useful for a common ID and timestamping class.
• @Lob – stores lobs in S3 so make it as big as you want (up to 5GB).
• @Id – MUST be a string
• JPA Queries – see JPAQuery page
• Integer and Long – no problems, all good.
• Double – pads to 20 digits on each side of the decimal by default so fine for a lot of cases, but if you plan to use Double’s, let us know so we can work it out perfectly. SimpleDB makes it hard to work with these numbers because it treats everything as a String.
• BigDecimal – same problems as Double
• String
• no primitives yet! Please use wrappers only for now.
• @Enumerated (ordinal and string)
• @Column (name only)

Cargo (von Vincent Massol) bietet Java-APIs sowie Ant und Maven Unterstützung, um Web- und Java EE-Container zu starten/stoppen und Module zu deployen. Die Liste der Server ist erst einmal toll: Geronimo, JBoss, Jetty, Resin, WebLogic, Tomcat (kein WebSphere!). So gut die Idee auch ist, leider ist das Projekt soweit gestorben. Wer Lust hat, darf gerne project lead werden. Na ja, die letzte Version ist von 10/03/07 und bisher hat sich noch keiner gefunden.

JIDE ist ein Unternehmen, welches schon seit vielen Java qualitativ hochwertige Swing-Komponenten baut. Einige der Komponenten sind frei (JIDE Common Layer (Open Source Project)), weitere wie das Docking-Framework, Action Framework, (Pivot) Grids, Code Editor und weitere gehören zum kommerziellen Teil. Die Komponenten aus dem JIDE Common Layer stehen unter dual-license: GPL und free commercial license.

Textbox, die sich automatisch erweitert

Tabelle und Liste mit Checkboxen, Split-Pane mit mehreren Bereichen

Neue Border und Border-Layout mit anderer Anordnung Norden und Süden

Button-Gruppe und Datums, Popupmenü verbreiterbarer Größe und Zeit/Datum-Auswahl

Neue Standard-Dialoge

Verzeichnisauswahl

Overlay legt Komponenten über andere Komponenten

Scrollpane mit Platz für weitere Komponenten, Slider mit zwei Enden

Container mit Suche und Selektion

Statt Scrollbar automatisches Scrollen durch Pfeile

Diverse Label

Reiterkomponente

Mit der Google Java API (http://code.google.com/apis/gdata/javadoc/) lässt sich leicht auf die Dokumente oder Kalender zurückgreifen. Ein erstes Beispiel für eine Liste der Google-Calender ist schnell formuliert:

import java.net.URL;
import com.google.gdata.client.calendar.CalendarService;
import com.google.gdata.client.docs.DocsService;
import com.google.gdata.data.calendar.CalendarEntry;
import com.google.gdata.data.calendar.CalendarFeed;
import com.google.gdata.data.docs.DocumentListEntry;
import com.google.gdata.data.docs.DocumentListFeed;

public class GoogleExample
{
  public static void main( String[] args ) throws Exception
  {
    String user = „user@gmail.com“, pass = „pass“;

    CalendarService calService = new CalendarService( „Mein Kalender“ );
    calService.setUserCredentials( user, pass );

    CalendarFeed resultFeed = calService.getFeed(
                                new URL( „http://www.google.com/calendar/feeds/default/allcalendars/full“ ),
                                CalendarFeed.class );

    for ( CalendarEntry entry : resultFeed.getEntries() )
      System.out.println( entry.getTitle().getPlainText() );

    DocsService service = new DocsService( „Meine Dokumente“ );
    service.setUserCredentials( user, pass );

   DocumentListFeed feed = service.getFeed(
                              new URL( „http://docs.google.com/feeds/documents/private/full“ ),
                              DocumentListFeed.class );

    for ( DocumentListEntry doc : feed.getEntries() )
      System.out.println( doc.getId() + „/“ + doc.getTitle().getPlainText() );
  }
}

Die notwendigen Java-Archive nimmt man aus dem lib-Verzeichnis des Archivs http://gdata-java-client.googlecode.com/files/gdata.java-1.15.2.zip. Um auf die Dokumente zurückzugreifen (oder auch nur aufzulisten), ist mail.jar ebenfalls nötig.

Die kleine (native) unter Linux und Windows arbeitende Bibliothek JNotify meldet Änderungen an Dateien. Ein Beispiel:

String path = "c:/";

int mask = JNotify.FILE_CREATED | JNotify.FILE_DELETED | JNotify.FILE_MODIFIED | JNotify.FILE_RENAMED;


boolean watchSubtree = true;


int watchID = JNotify.addWatch(path, mask, watchSubtree, new JNotifyListener()
{
@Override
public void fileCreated( int arg0, String arg1, String arg2 )
{
 System.out.println( "created" );
}


@Override
public void fileDeleted( int arg0, String arg1, String arg2 )
{
 System.out.println( "deleted" );
}

@Override
public void fileModified( int arg0, String arg1, String arg2 )
{
 System.out.println( "modified" );
}

@Override
public void fileRenamed( int arg0, String arg1, String arg2, String arg3 )
{
 System.out.println( "renamed" );
}
} );

Und am Ende:

JNotify.removeWatch(watchID);