UML diagram for JVLC, the Java Multimedia Library for VideoLAN

I created an UML diagram for the JVLC Java Multimedia Library version 0.9.

Inselupdate: Properties einer Bean erfragen

Eine Bean besitzt Properties (Eigenschaften), die in Java (bisher) durch Setter und Getter ausgedrückt werden, also Methoden, die einer festen Namenskonvention folgen. Gibt es Interesse an den Properties, lässt sich natürlich getMethods() auf dem Class-Objekt aufrufen und nach den Methoden filtern, die der Namenskonvention entsprechen. Die Java-Bibliothek bietet aber im Paket java.beans eine einfachere Lösung für Beans: einen PropertyDescriptor.

Beispiel Gebe alle Properties – es gibt nur lesbare – von Color aus:

Listing 21.9 com/tutego/insel/meta/PropertyDescriptors.java, main()

BeanInfo beanInfo = Introspector.getBeanInfo( Color.class );

for ( PropertyDescriptor pd : beanInfo.getPropertyDescriptors() )

 System.out.println( pd.getDisplayName() + " : " +

                     pd.getPropertyType().getName() );

Die Ausgabe ist

RGB : int

alpha : int

blue : int

class : java.lang.Class

colorSpace : java.awt.color.ColorSpace

green : int

red : int

transparency : int

Interessanter sind vom PropertyDescriptor die Methoden getReadMethod() und getWriteMethod(), die beides ein Method-Objekt liefern – wenn das denn verfügbar ist – um so die Methode gleich aufrufen zu können.

Die Physik-Engine Phys2D

Phys2D ist eine 2D Physik-Engine, welches Massen, Trägheiten, Reibung simuliert. Die Bibliothek ist in Java 1.4 programmiert und unterstützt

• Boxes
• Circles
• Static Lines
• Restituion and Friction
• Fixed, Elastic and Loose Joints
• Angluar Velocity/Momentum
• Simple API
• Quad Tree Collision
• Gideon Smeding's Polygon

Ein Demo gibt es via via webstart.

Java Collection API gegen Standard Template Library (STL)

Unter C++ ist die Standard Template Library (STL) eine Bibliothek, die Datenstrukturen und Algorithmen implementiert. Der Vergleich von STL und der Collection-API ist schwierig, obwohl beide Konzepte wie Listen, Mengen und Iteratoren besitzen. So gibt es in Java nur eine Klasse pro Datenstruktur (auch durch Generics), was die STL durch Templateklassen (daher Template Library) realisiert, die auch primitive Werte (ohne die lästigen Java-Wrapper) speichert. Während Java über den globalen Basistyp Object jedes Objekt in jede Datenstruktur erlaubt und sich auf die Prüfung zur Laufzeit verlässt, ist C++ da viel strenger. Die Java-Datenstrukturen referenzieren die Objekte und speichern nicht ihre Zustände an sich, wie es bei der STL üblich ist ¬– hier steht Referenz-Semantik gegen Wert-Semantik. Fehler werden von der Collection-API über Exceptions angezeigt, während die STL kaum Ausnahmen auslöst und oft undefinierte Zustände hinterlässt; Entwickler müssen eben korrekte Anfragen stellen. STL nutzt überladen Operatoren wie == statt dem Java-equals(), < für die Ordnung in sortierten Sammlungen, [] beim Zugriff und Überschreiben und den Operator ++ für Iteratoren. Iteratoren spielen bei der STL eine sehr große Rolle – es gibt auch einen Random Access-Iterator, der Indexierung durch [] erlaubt. Die STL-Algorithmen sind von den Datenstrukturen abgetrennt – anders als in Java – und bekommen die Elemente über Iteratoren. Zudem ist die STL reichhaltiger und bietet beispielsweise Funktionsobjekte; hier gibt es Ansätze, wie http://jga.sourceforge.net/, die STL bestmöglich auf Java zu übertragen.

Fehlt da noch was in der Aufzählung?

Shell-Script-Editor (ShellEd) und Eclipse Target Management Project/Remote System Explorer

ShellEd (Bild) ist ein Shell-Script-Editor für Unix-Skripte (also ash, bsh, bash, csh, ksh, sh, zsh). Mit Manual und Vervollständigung. Interessant dazu ist das relativ unbekannte Target Management Project, wo man remote, etwa über SSH oder FTP auf einem Server arbeiten und zum Beispiel Dokumente editieren kann. Siehe dazu den Screenshot zum Remote System Explorer (RSE).

Mehr Eclipse-Plugins gibt's unter http://www.tutego.com/java/eclipse/plugin/eclipse-plugins.html.

Some day, perhaps, but not now (Antwort auf Suns Bug ID 4888066)

Zur Frage, wenn denn nun typsicherer Arrays gibt, sagt Sun einfach nur

Work Around: N/A

Evaluation: Some day, perhaps, but not now.

Das ist das Schöne am Gottsein :-)

Korrekte Inhaltsbreite in paintComponent() durch Insets beachten

Entwickler eigener Swing-Komponenten werden fürs Zeichnen auf getWidth() und getHeight() zurückgreifen. Wegen möglichen Insets sollte man jedoch beim Zeichen die Größenveränderungen betrachten.

@Override
protected void paintComponent( Graphics g )
{
  Insets insets = getInsets();
  int x = insets.left;
  int y = insets.top;
  int width = getWidth() - insets.left - insets.right;
  int height = getHeight() - insets.top - insets.bottom;

  ...

range() in Java

A range is a very handy feature of programing languages like Python.

• range( 10 ) -> 0 1 2 3 4 5 6 7 8 9
• range( 5, 10 ) -> 5 6 7 8 9
• range( 0, 10, 3 ) -> 0 3 6 9
• range( '0', '9' ) -> 012345678

 

package com.tutego;



import static com.tutego.Range.range;



public class RangeDemo

{

  public static void main( String[] args )

  {

    for ( int i : range( 10 ) )

      System.out.print( i + " " );



    System.out.println();



    for ( int i : range( 5, 10 ) )

      System.out.print( i + " " );



    System.out.println();



    for ( int i : range( 0, 10, 3 ) )

      System.out.print( i + " " );



    System.out.println();



    for ( int i : range( '0', '9' ) )

      System.out.print( (char) i  );



    System.out.println();



    String[] a = { "Mary", "had", "a", "little", "lamb" };

    for ( int i : range(a.length ) )

      System.out.printf( "%d %s%n", i, a[i] );

  }

}

And the main class Range

/*

 * This project is made available under the terms of the BSD license, more information can be found at

 * http://www.opensource.org/licenses/bsd-license.html

 *

 * Copyright (c) 2007. Christian Ullenboom (http://www.tutego.com/) and contributors. All rights reserved.

 */

package com.tutego;



import java.util.Iterator;



/**

 * Class that generates immutable sequences (ranges) as Iterable<Integer>

 * objects. A range represents a start (0 if not given), an stop (mandatory) and

 * an optional step (1 by default). The start value is included in the range,

 * the stop value is exclusive. Every range is handled by an Iterable<Integer>

 * which can by used in an extended for loop.

 * 

 * <pre>

 * for ( int i : range( 0, 10, 3 ) )

 *   System.out.print( i + " " ); // 0 3 6 9

 * </pre>

 * 

 * @author Christian Ullenboom (tutego)

 * @version 1.0

 */

public class Range

{

  public static Iterable<Integer> range( final int start, final int stop, final int step )

  {

    if ( step <= 0 )

      throw new IllegalArgumentException( "step > 0 isrequired!" );



    return new Iterable<Integer>()

    {

      public Iterator<Integer> iterator()

      {

        return new Iterator<Integer>()

        {

          private int counter = start;



          public boolean hasNext()

          {

            return counter < stop;

          }



          public Integer next()

          {

            try

            {

              return counter;

            }

            finally { counter += step; }

          }



          public void remove() { }

        };

      }

    };

  }



  public static Iterable<Integer> range( final int start, final int stop )

  {

    return range( start, stop, 1 );

  }



  public static Iterable<Integer> range( final int stop )

  {

    return range( 0, stop, 1 );

  }

}

JavaServer Faces 2.0 Draft und Diskussionen

Dinge, die aktuell diskutiert werden und ich interessanter finde:

• The act of writing JSF applications and components "by hand" will be made much easier by this JSR.
• Allow for "zero configuration" web applications. No faces-config.xml, no web.xml. If necessary, annotations will be used to supplement the configuration data.
• Leverage annotations to declare JSF artifacts (components, managed beans, navigation rules, etc) to the runtime.
• Eliminate the need to author a JSP tag handler when writing JSF components.
• Real world, production view description technology, including templating: include something influenced by Facelets, JSFTemplating or Tiles in the specification
• All the artifacts that comprise a JSF application can be modified while the application is running.
• Expand the request processing lifecycle to be aware of Ajax.
• Decent client side, inter-component and form-level validation (leveraging JSR-303 validation if possible).
• Strategic additions to the Standard HTML RenderKit: Date Picker, Tree, Tab View, File Upload components.
• Provide a mechanism to minimize the "Lost Update" and "Duplicate Button Press" problems.
• Page actions: The ability to say, "when this page loads, invoke this action (via Ajax if necessary)."
• Allow JSF application resources to be accessed via REST. Add support for REST (JSR 311)
• "Skinning", or "Themeing" of components.
• WebBeans (JSR-299)

Die Dinge (und mehr) könnten Teil von Java EE 6 werden.

Links zu dem Thema:

• https://javaserverfaces-spec-public.dev.java.net/proposals/JSF-2_0-draft.html
• http://weblogs.java.net/blog/edburns/archive/2007/03/prejcpfiled_dra_1.html
• http://www.jsfcentral.com/editorial/jsf2_wishlist_1.html
• http://wiki.java.net/bin/view/Projects/Jsf2RequirementsScratchpad
• http://www.theserverside.com/news/thread.tss?thread_id=44836

So etwas bei RowSetMetaDataImpl in den Sun-Quellen zu sehen tut weh

Neue String-Objekte als Kopie von existierende Strings aufzubauen ist ganz schön übel. Aus javax.sql.rowset.RowSetMetaDataImpl:

public void setColumnLabel(int columnIndex, String label) throws SQLException

{

 checkColRange(columnIndex);

 if (label != null) {

  colInfo[columnIndex].columnLabel = new String(label);

 } else {

  colInfo[columnIndex].columnLabel = new String("");

 }

}

Wie die API-Doku zum Konsturktor so schön schreibt:

Unless an explicit copy of {@code original} is needed, use of this constructor is unnecessary since Strings are immutable.

Inselupdate: javax.swing.Action

Aktiviert der Nutzer eine Schaltfläche, etwa für „Ende“ oder einen Eintrag im Menü, löst er damit eine Aktion aus. Das Hinzufügen der Ereignisbehandler an die Schalflächen ist die sofort offensichtliche Möglichkeit. Swing bietet mit Aktionen aber noch eine andere Möglichkeit, deren Sinn sich ergibt, wenn wir uns folgendes Szenario überlegen: Der Benutzer soll über das Menü eine Aktion auslösen, aber genauso über die Symbolleiste. Die spontane Antwort ist, einfach den beiden Schaltflächen den gleichen Ereignisbehandler zu geben. Sicherlich ist das möglich, aber gehen wir einen Schritt weiter. Was ist, wenn auf Grund eines bestimmten Zustands die beiden Auslöser deaktiviert werden müssen? Und wie sieht der Aufbau aus, wenn etwa beide das gleiche Icon, den gleichen Tooltip und den gleichen Text tragen? Das wäre Quellcodeduplizierung und unschön.

Swing beantwortet die Fragen mit der Schnittstelle javax.swing.Action. Sie bilden Objekte mit Zustand wie Aufschrift und Text und erweitert für die Programmlogik den ActionListener. In unserem Szenario müssten wir nun einmal das Action-Objekt aufbauen und dann in das Menü und die Symbolleiste hängen.

Während Action eine Schnittstelle ist, die ActionListener erweitert und zusätzliche Operationen deklariert, nutzen wir im Allgemeinen Unterklassen von AbstractAction. Bei dieser Klasse müssen wir nur noch actionPerformed() überschreiben und dort die Aktion implementieren.

Listing 15.11 com/tutego/insel/ui/swing/JButtonAction.java, Ausschnitt

Action exitAction = new AbstractAction( "Ende" ) {

public void actionPerformed( ActionEvent e ) {

System.exit( 0 );

}

};

JButton button2 = new JButton( exitAction );

frame.add( button2 );

Ein Action-Objekt lässt sich in jedem Konstruktor einer Schaltfläche übergeben, so auch dem JButton oder JMenuItem. Sie kann alternativ über setAction(Action) mit jeder Schaltfläche verbunden werden, die AbstractButton erweitert.

Eigenschaften der Action-Objekte

Eigenschaften wie Beschriftung oder Tooltip bestimmten Eigenschaften, die putValue(String, Object) setzt. Für den Schlüssel von putValue() deklariert die Klasse bestimmte Zeichenketten über Konstanten, die mit speziellen Bedeutungen verbunden sind. Die wichtigsten sind:

Action.NAME. Name der Aktion, die für die Schaltfläche oder das Menü verwendet wird

Action.SHORT_DESCRIPTION. Kurzbeschreibung für Tooltips

Action.LONG_DESCRIPTION. Längere Beschreibung, die für Hilfe verwendet werde könnte

Action.ACCELERATOR_KEY. Tastatur-Shortcut

Action.MNEMONIC_KEY. Mnemonic

Action.SMALL_ICON. Kleines Icon für Menüeinträge

Action.LARGE_ICON_KEY. Größeres Icon für Symbolleisten und Schaltflächen

Die Icons werden nicht für JCheckBox, JToggleButton oder JRadioButton verwendet. Ist für JButton kein LARGE_ICON_KEY definiert, nimmt es ein SMALL_ICON. Ob eine Aktion aktiviert ist bestimmt setEnabled(boolean) und erfragt isEnabled(). Während putValue(String,Object) den Wert setzt, erfragt ihn getValue(String).

Beispiel Ein Action-Objekt mit zwei gesetzten Properties zum Beenden der Applikation:

JButtonAction2.java, ExitAction

class ExitAction extends AbstractAction

{

{

putValue( Action.NAME, "Beenden" );

putValue( Action.DISPLAYED_MNEMONIC_INDEX_KEY, 0 );

}

public void actionPerformed( ActionEvent e )

{

System.exit( 0 );

}

}

Indem wir DISPLAYED_MNEMONIC_INDEX_KEY auf 0 setzen, erreichen wir, dass vom String „Beenden“ das „B“ unterstrichen und ein Tastenkürzel wird.

Java EE 6 -- das Spiel geht weiter

Es war klar, dass es nach der Java EE 5 ein Java EE 6 geben wird. Nun wurde die neue JSR 313: JavaTM Platform, Enterprise Edition 6 (Java EE 6) Specification ausgerufen. Teil der Java EE 6 wird sein:

• JSR-196 Java Authentication SPI for Containers
• JSR-236 Timer for Application Servers
• JSR-237 Work Manager for Application Servers
• JSR-299 Web Beans
• JSR-311 JAX-RS: Java API for RESTful Web Services

Auf Web-Beans bin ich gespannt, denn da gehen die Ideen von JBoss Seam ein, also EJB 3 und JSF zu verheiraten.

Aktualisiert werden laut Standard:

• Enterprise JavaBeans
• Java Persistence API
• Servlets
• JavaServer Faces
• JAX-WS

Und Verschoben sind:

• JSR-168 Portlet Specification
• JSR-170 Content Repository for Java technology API
• JSR-207 Process Definition for Java
• JSR-208 Java Business Integration (JBI)
• JSR-225 XQuery API for Java (XQJ)
• JSR-235 Service Data Objects
• JSR-286 Portlet Specification 2.0
• JSR-289 SIP Servlet v1.1
• JSR-301 Portlet Bridge Specification for JavaServer Faces

Das Release ist für das 3 Q 2008 angedacht. Viel Zeit also noch.

Das "Swing Application Framework" (JSR 296)

Hans Mueller schrieb schon für JavaOne 2007 eine kleine Einführung in das vielleicht zukünftige Swing-Framework (JSR 296) in Java 7: http://weblogs.java.net/blog/hansmuller/archive/ts-3399-final.pdf. Neben https://appframework.dev.java.net/intro/index.html ist nun unter http://weblogs.java.net/blog/diverson/archive/2007/04/swing_applicati.html ist nun eine weitere keine Beschreibung dazugekommen.

Um die Aufgaben kurz zusammenzufassen: Das Swing-Framwork soll eine (sehr?) leichtgewichtige Alternative zu Eclipse RPC und dem NetBeans Framework werden, um Actions, Properties und Voreinstellungen komfortabel zusammenzubringen. Zentral ist die Klasse Application, die den Lebenszyklus einer Swing-Applikation definiert.

Von https://appframework.dev.java.net/intro/index.html

Im Allgemeinen werden eigene Klassen dann von Application abgeleitet.

public class MySwingApp extends Application {

    JFrame mainFrame = null;

    @Override protected void startup( String[] args ) {

        mainFrame = new JFrame();

        mainFrame.setDefaultCloseOperation( JFrame.DO_NOTHING_ON_CLOSE );

        mainFrame.pack();

        mainFrame.setVisible( true );

    }

    public static void main( String[] args ) {

        launch( MySwingApp.class, args );

    }

}

In startup() werden nun die Komponenten aufgebaut. Dabei können Elemente wie das JLabel auf Eigenschaften aus Property-Dateien zurückgreifen:

JLabel l = new JLabel();

l.setName( "myLabel" );

Unter dem Namen myLabel gibt es einen Property-Eintrag:

myLabel.text=Text vom Label.

Auch der Name des Fensters lässt sich so setzen:

Application.title=Hallo Welt!

Um einem JButton eine Action zuzuweisen (Listener sind nicht mehr nötig), bekommt jede Aktion einen Namen, die in einer Map eingetragen ist.

ApplicationActionMap aMap = ApplicationContext.getInstance().getActionMap( getClass(), this );
JButton btn = new JButton();
b.setName( "myButton" ); 

b.setAction( aMap.get( "los" ) );

Die Aktionen selbst kommen von Methoden, die mit @Action annotiert sind.  Standardmäßig bestimmt der Methodenname den Namen der Action, doch das kann mit name überschrieben werden.

@Action( name = "los" );

public void myAction( ActionEvent e ) {

  System.out.println( "Es hat klick gemacht." );

}

Properties der Schaltflächen lassen weitere Eigenschaften zu:

myButton.Action.text = &Klick mich...

myButton.Action.accelerator = control K

myButton.Action.shortDescription = klicke und du wirst was erleben

Weitere Links:

• http://www.javalobby.org/java/forums/t71186.html


• http://www.artima.com/lejava/articles/swingframework.html


• https://appframework.dev.java.net/

Eclipse auf das Basis von Swing

Gerade habe ich ein interessantes Projekt gefunden: http://eos.sourceforge.net/. Zwar gab es seit einiger Zeit kein Update, dennoch sehen die Screenshots schon sehr gut aus: http://eos.sourceforge.net/gallery/Eos%20-%204th%20Release%20(Beta%20Status)/index.html.