In October 2011, I used the post Hello JavaFX 2.0: Introduction by NetBeans 7.1 beta to look at using NetBeans 7.1 beta to build a simple Hello, World style of JavaFX 2.0 application. In this post, I look at using NetBeans 7.1 (no longer in beta) to build a slightly more sophisticated JavaFX 2 application that makes heavy use of FXML.

Most of my posts on JavaFX 2 up to this point have emphasized the "pure Java" nature of JavaFX 2. The examples in these posts have been written in standard Java using JavaFX 2 APIs directly from the Java source code. These examples have also been built with the javac compiler and executed with the java application launcher. In this post, I take one of those examples [(Pure Java) JavaFX 2.0 Menus] and "port" it to use FXML for presentation layout.

For convenience, I include the entire Java listing for the "pure Java" implementation of the JavaFX 2 menus demonstration.

package dustin.examples;

import static java.lang.System.out;

import javafx.application.Application;
import javafx.beans.property.ReadOnlyDoubleProperty;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.control.*;
import javafx.scene.input.KeyCode;
import javafx.scene.input.KeyCodeCombination;
import javafx.scene.input.KeyCombination;
import javafx.scene.paint.Color;
import javafx.stage.Stage;

/**
 * Example of creating menus in JavaFX.
 * 
 * @author Dustin
 */
public class JavaFxMenus extends Application
{
   /**
    * Build menu bar with included menus for this demonstration.
    * 
    * @param menuWidthProperty Width to be bound to menu bar width.
    * @return Menu Bar with menus included.
    */
   private MenuBar buildMenuBarWithMenus(final ReadOnlyDoubleProperty menuWidthProperty)
   {
      final MenuBar menuBar = new MenuBar();

      // Prepare left-most 'File' drop-down menu
      final Menu fileMenu = new Menu("File");
      fileMenu.getItems().add(new MenuItem("New"));
      fileMenu.getItems().add(new MenuItem("Open"));
      fileMenu.getItems().add(new MenuItem("Save"));
      fileMenu.getItems().add(new MenuItem("Save As"));
      fileMenu.getItems().add(new SeparatorMenuItem());
      fileMenu.getItems().add(new MenuItem("Exit"));
      menuBar.getMenus().add(fileMenu);

      // Prepare 'Examples' drop-down menu
      final Menu examplesMenu = new Menu("JavaFX 2.0 Examples");
      examplesMenu.getItems().add(new MenuItem("Text Example"));
      examplesMenu.getItems().add(new MenuItem("Objects Example"));
      examplesMenu.getItems().add(new MenuItem("Animation Example"));
      menuBar.getMenus().add(examplesMenu);

      // Prepare 'Help' drop-down menu
      final Menu helpMenu = new Menu("Help");
      final MenuItem searchMenuItem = new MenuItem("Search");
      searchMenuItem.setDisable(true);
      helpMenu.getItems().add(searchMenuItem);
      final MenuItem onlineManualMenuItem = new MenuItem("Online Manual");
      onlineManualMenuItem.setVisible(false);
      helpMenu.getItems().add(onlineManualMenuItem);
      helpMenu.getItems().add(new SeparatorMenuItem());
      final MenuItem aboutMenuItem =
         MenuItemBuilder.create()
                        .text("About")
                        .onAction(
                            new EventHandler<ActionEvent>()
                            {
                               @Override public void handle(ActionEvent e)
                               {
                                  out.println("You clicked on About!");
                               }
                            })
                        .accelerator(
                            new KeyCodeCombination(
                               KeyCode.A, KeyCombination.CONTROL_DOWN))
                        .build();             
      helpMenu.getItems().add(aboutMenuItem);
      menuBar.getMenus().add(helpMenu);

      // bind width of menu bar to width of associated stage
      menuBar.prefWidthProperty().bind(menuWidthProperty);

      return menuBar;
   }

   /**
    * Start of JavaFX application demonstrating menu support.
    * 
    * @param stage Primary stage.
    */
   @Override
   public void start(final Stage stage)
   {
      stage.setTitle("Creating Menus with JavaFX 2.0");
      final Group rootGroup = new Group();
      final Scene scene = new Scene(rootGroup, 800, 400, Color.WHEAT);
      final MenuBar menuBar = buildMenuBarWithMenus(stage.widthProperty());
      rootGroup.getChildren().add(menuBar);
      stage.setScene(scene);
      stage.show();
   }

   /**
    * Main executable function for running examples.
    * 
    * @param arguments Command-line arguments: none expected.
    */
   public static void main(final String[] arguments)
   {
      Application.launch(arguments);
   }
}

Besides adding the ability to write JavaFX applications in "pure Java" as implemented in the last code listing, JavaFX 2 also provides FXML, an XML grammar for specifying a JavaFX application's layout. This approach is very similar to that provided by Flex's MXML, by OpenLaszlo's LZX, and by Mozilla's XUL. This approach works well with JavaFX's hierarchical Scene Graph.

The ported FXML code is shown next. It is easy to see the presentation structure in this XML.

<?xml version="1.0" encoding="UTF-8"?>

<?import java.lang.*?>
<?import javafx.scene.*?>
<?import javafx.scene.control.*?>
<?import javafx.scene.layout.*?>

<VBox id="vbox" prefHeight="400" prefWidth="800"
      xmlns:fx="http://javafx.com/fxml"
      fx:controller="dustin.examples.MenuController">
   <MenuBar fx:id="menuBar" onKeyPressed="#handleKeyInput">
      <menus>
         <Menu text="File">
            <items>
               <MenuItem text="New"/>
               <MenuItem text="Open"/>
               <MenuItem text="Save"/>
               <MenuItem text="Save As"/>
               <SeparatorMenuItem  />
               <MenuItem text="Exit"/>
            </items>
         </Menu>
         <Menu text="JavaFX 2.0 Examples">
            <items>
               <MenuItem text="Text Example"/>
               <MenuItem text="Objects Example"/>
               <MenuItem text="Animation Example"/>
            </items>
         </Menu>
         <Menu text="Help">
            <items>
               <MenuItem text="Search" disable="true"/>
               <MenuItem text="Online Manual" visible="false"/>
               <SeparatorMenuItem />
               <MenuItem text="About" onAction="#handleAboutAction"/>
            </items>
         </Menu>
      </menus>
   </MenuBar>
</VBox>

The important portion of this simple FXML can be viewed on a single page within NetBeans 7.1 as shown in the next screen snapshot.

Besides the conciseness of the FXML and the aesthetically pleasing hierarchical presentation, the FXML also should look familiar to anyone who has worked with Flex, OpenLaszlo, or XUL. Most of the presentation structure is easily identified in the FXML document. This example includes an onAction handler that responds to the "About" menu item and there is an onKeyPressed action associated with the menu bar as well (I could not figure out a way to easily associate this handler with the menu item itself). Both of these actions reference names that start with the # symbol. The names following the # are names of methods on the controller class (defined by the fx:controller attribute of the VBox as the class named dustin.examples.MenuController). The source for this controller class is shown next.

package dustin.examples;

import static java.lang.System.out;
import java.net.URL;
import java.util.ResourceBundle;
import javafx.event.ActionEvent;
import javafx.fxml.FXML;
import javafx.fxml.Initializable;
import javafx.scene.control.MenuBar;
import javafx.scene.input.InputEvent;
import javafx.scene.input.KeyCode;
import javafx.scene.input.KeyEvent;

/**
 * Controller class for JavaFX 2 Menus with FXML post and demonstration.
 * 
 * @author Dustin
 */
public class MenuController implements Initializable
{
   @FXML
   private MenuBar menuBar;

   /**
    * Handle action related to "About" menu item.
    * 
    * @param event Event on "About" menu item.
    */
   @FXML
   private void handleAboutAction(final ActionEvent event)
   {
      provideAboutFunctionality();
   }

   /**
    * Handle action related to input (in this case specifically only responds to
    * keyboard event CTRL-A).
    * 
    * @param event Input event.
    */
   @FXML
   private void handleKeyInput(final InputEvent event)
   {
      if (event instanceof KeyEvent)
      {
         final KeyEvent keyEvent = (KeyEvent) event;
         if (keyEvent.isControlDown() && keyEvent.getCode() == KeyCode.A)
         {
            provideAboutFunctionality();
         }
      }
   }

   /**
    * Perform functionality associated with "About" menu selection or CTRL-A.
    */
   private void provideAboutFunctionality()
   {
      out.println("You clicked on About!");      
   }

   @Override
   public void initialize(final URL url, final ResourceBundle rb)
   {
      menuBar.setFocusTraversable(true);
   }   
}

The above code from the controller class includes the two methods referenced as action handlers in the FXML with the # prefixes. These two methods are private and normally would not be visible to the FXML loader, but the use of the annotation @FXML gets around this problem. The menuBar attribute is also private but visible to the FXML loader thanks to its own @FXML annotation.

To get the application to respond to CTRL-A before any initial access of the menu bar, I found that I needed to have a reference to the menu bar in the controller and call setFocusTraversable(true) on that instance. Without doing that, the CTRL-A would only be responded to if I had first clicked on the menu bar once. The hook from the FXML to this attribute in the controller is the fx:id attribute used in the FXML. That attribute references the name "menuBar", which is (not coincidentally) also the name of the attribute in the controller class. In other words, the attribute fx:id="menuBar" ties the XML element that attribute is on in the FXML to the attribute with the same name in the controller.

I did not show much in this post specific to NetBeans 7.1, but it is worth noting that I had all the pertinent files created in a new project using NetBeans 7.1's New Project wizard and selecting a JavaFX FXML Application as the project type. This created a basic FXML file, a basic controller file, and a main class for loading the FXML and running the application. I modified these to the examples above for the FXML and for the controller class. The modified class that loads the FXML and starts the JavaFX application is shown next. (There's not a lot to it!)

package dustin.examples;

import javafx.application.Application;
import javafx.fxml.FXMLLoader;
import javafx.scene.Parent;
import javafx.scene.Scene;
import javafx.stage.Stage;

/**
 * Simple example of JavaFX 2 FXML used to demonstrate JavaFX 2 menus. This is a
 * "port" of the example featured using "pure Java" (no FXML) in the post
 * "(Pure Java) JavaFX 2.0 Menus"
 * (http://marxsoftware.blogspot.com/2011/12/pure-java-javafx-20-menus.html).
 * 
 * @author Dustin
 */
public class JavaFxMenusWithFxmlDemo extends Application
{
   /**
    * Main function for running this application.
    * 
    * @param arguments Command-line arguments: none expected.
    */
   public static void main(String[] arguments)
   {
      Application.launch(JavaFxMenusWithFxmlDemo.class, arguments);
   }

   /**
    * Overridden Application.start(Stage) method.
    * 
    * @param stage Primary stage.
    * @throws Exception JavaFX application exception.
    */
   @Override
   public void start(final Stage stage) throws Exception
   {
      final Parent fxmlRoot = FXMLLoader.load(getClass().getResource("JavaFx2Menus.fxml"));
      stage.setScene(new Scene(fxmlRoot));
      stage.show();
   }
}

I won't show the output here because it's essentially what the "pure Java" version produced, which is shown in my post on that approach. Besides generating the files that I adapted for my application, NetBeans 7.1's new project wizard for a JavaFX FXML application also created a project that automatically packages up what I need for my JavaFX application in an executable JAR. The contents of the JAR in this case are shown in the next screen snapshot.

The trickiest part about using FXML is the relatively less available documentation. The pure Java APIs have the strong Javadoc API documentation, but I know of no such thing for FXML (including no documentation or schema for the namespace http://javafx.com/fxml). There are some great resources of FXML such as Getting Started with FXML and Introduction to FXML. Perhaps the best document for figuring out what elements and attributes FXML provides is Introducing FXML: A Markup Language for JavaFX, which explains the "mapping" of JavaFX standard Java API classes to JavaFX FXML elements and attributes.

FXML appears to be a fairly attractive approach for building a JavaFX application because it nicely separates presentation (FXML) from business logic (controller class and classes that would be called by controller methods). This can make it easier to visually see the GUI layout in the hierarchical XML and keep the logic and presentation from cluttering each other.

Original posting available at http://marxsoftware.blogspot.com/ (Inspired by Actual Events)

Tattletale is a highly useful development tool that not only has a catchy name, but also has a clever slogan: "Betraying your project's naughty little secrets." Tattletale scours JAR files to find various naught little secrets about dependencies, multiple versions, extraneous versions of classes, JARs in multiple locations, and so forth. It is a simple tool that can be run from the command-line to generate simple HTML reports of multiple characteristics about JARs and classes.

To demonstrate Tattletale, I will execute it against a Spring Framework 2.5.6 installation. It is simple to run Tattletale and this is demonstrated in the next screen snapshot.

The tattletale.jar is an executable JAR and so is run with java -jar tattletale.jar. The first argument passed to it is the directory to be recursively searched (Spring 2.5.6 distribution in this case) and the second argument is the directory to which the HTML reports should be written (spring-output in this example). The directory listing of the spring-output directory is shown next.

As the two previous snapshots indicate, it is very straightforward to run Tattletale against a desired directory. A web browser can be used to open the index.html page as the starting page. This is shown in the next screen snapshot.

Only a subset of the available reports are shown in the above snapshot. Clicking on links brings up the individual reports. I show portions of select reports (circular dependencies, class locations, multiple copies of JARs, transitive dependencies, and transitive dependents) next.

Tattletale is so easy to use, very little documentation is necessary. However, there is a slide presentation and a User's Guide with introductory information. The 32-page User Guide covers running Tattletale (similar to this post) along with providing details on how to configure the tool via jboss-tattletale.properties and providing an overview of the many reports that Tattletale provides about one's project.

To address and correct a project's naughtiest little secrets, one must know what they are. Tattletale is an easy-to-use tool that exposes these naughty secrets so that they can be addressed.

Original posting available at http://marxsoftware.blogspot.com/ (Inspired by Actual Events)

One of the new code hints provided by NetBeans 7.1 is the Unused Assignment hint. A simple code sample that will cause this hint to be displayed in NetBeans 7.1 is shown next.

   /**
    * Demonstrate NetBeans 7.1 code hint for situation in which variable
    * assignment is made but never used.
    * 
    * @return Integer.
    */
   private static int demoUnusedAssignment()
   {
      int i = 2;
      // ... do some good stuff, but without changing i's assignment or
      //     accessing i's value ...
      i = 3;
      return i;
   }

In the code above, the local variable "i" is initialized to 2, but is never used and then is initialized again, making the first initialization unnecessary. The next image is a screen snapshot that shows NetBeans 7.1 displaying a warning code hint for the unused assignment.

As the above image indicates, NetBeans 7.1 warns of "The assigned value is never used."

The New And Noteworthy in NetBeans IDE 7.1 page mentions this hint among others and states:

Unused Assignment

A new pair of hints, Unused Assignment and Dead Branch, was introduced. The Unused Assignment finds values that are computed and assigned to a variable, but never used by reading the variable. The Dead Branch hint searches for branches of code that can never be executed.

Oh Dead Branch Hint, Where Art Thou?

The Unused Assignment Hint seems to work as suggested based on the example shown above. However, I have not been able to generate code that demonstrates the "Dead Branch" hint. I wonder if the Dead Branch hint is not yet supported and text related to it is not supposed to be under the "Unused Assignment" heading.

The following code contains a listing with several methods that I would expect might potentially lead to a warning about a dead code branch. None of these cause this code hint to appear in any form (warning or error) in my installation of NetBeans 7.1.

package dustin.examples;

import static java.lang.System.out;

/**
 * Class demonstrating NetBeans 7.1's hint for dead code.
 * 
 * @author Dustin
 */
public class DeadCode
{
   /**
    * Nonsense method that includes an "else" clause that can never be executed.
    * 
    * @param someInt Any primitive int.
    */
   private static void neverExecutedElse(final int someInt)
   {
      if (someInt < 0)
      {
         out.println("The integer you provided is less than zero.");
      }
      else if (someInt > 0)
      {
         out.println("The integer you provided is greater than zero.");
      }
      else if (someInt == 0)
      {
         out.println("The integer is equal to zero.");
      }
      else
      {
         out.println("Unable to categorize provided integer.");
      }
   }

   /**
    * Nonsense method that has executable code following conditions that are
    * always true and always lead to premature termination of the method.
    */
   private static void codeAfterAlwaysTrueConditional()
   {
      if (true)
      {
         throw new RuntimeException("Ouch!");
      }
      final String nothingHere = "Nothing here.";
      out.println(nothingHere);

      if (true)
      {
         return;
      }
      final String nothingHereEither = "Nothing here either.";
      out.println(nothingHereEither);
   }

   /**
    * Nonsense method that prints text to standard output only if the provided
    * boolean can be both {@code true} and {@code false} at the same time.
    * 
    * @param boolValue Boolean value of no consequence.
    */
   private static void cannotHaveItBothWays(final boolean boolValue)
   {
      if (boolValue)
      {
         if (!boolValue)
         {
            out.println("Make up your mind (true or false)!");
         }
      }
      else
      {
         if (boolValue)
         {
            out.println("Make up your mind (false or true)!");
         }
      }
   }

   /**
    * Runs else-if that is same as previous if such that one conditonal
    * prevents the second conditional's implementation from ever being executed.
    * 
    * @param boolValue A boolean value of no consequence.
    */
   private static void pesterUntilItWorks(boolean boolValue)
   {
      boolValue = true;
      if (boolValue)
      {
         out.println("It matches once.");
      }
      else if (boolValue)
      {
         out.println("It matches twice.");
      }
      else if (!boolValue)
      {
         out.println("No match once.");
      }
      else if (!boolValue)
      {
         out.println("No match twice!");
      }
   }

   /**
    * Cover all conditions in first conditional and include a never-can-happen
    * else portion of conditional.
    */
   private static void completeConditionalCoverage()
   {
      boolean boolValue = true;
      if (boolValue || !boolValue)
      {
         out.println("I'm always going to happen.");
      }
      else
      {
         out.println("I'm never going to happen.");
      }

      if (boolValue && !boolValue)
      {
         out.println("I'll never happen either.");
      }
      else
      {
         out.println("I'll also always happen.");
      }
   }

   /**
    * Main executable function.
    * 
    * @param arguments Command-line arguments: none expected.
    */
   public static void main(final String[] arguments)
   {
      if (false)
      {
         neverExecutedElse(5);
         codeAfterAlwaysTrueConditional();
         cannotHaveItBothWays(true);
         pesterUntilItWorks(true);
         demoUnusedAssignment();
         completeConditionalCoverage();
      }
   }
}

Although none of the methods in the directly previous code listing lead to the Dead Branch code hint, NetBeans 7.1 does include configuration options for the Dead Branch hint. This is shown in the next screen snapshot (selecting Tools->Options followed by the "Editor" tab and then selecting "Hints").

The NetBeans 7.1 News and Noteworthy page shows examples of other new hints, but does not show an example of the Dead Branch hint. Also, the text talking about Dead Branch is mixed with the section on Unused Assignment and under a heading that only talks about Unused Assignment. As my previous code listing demonstrates, I attempted to come up with a code sample to demonstrate the Dead Branch hint, but have not been able to do so. The purpose of this hint ("search[ing] for branches of code that can never be executed") sounds like a nice complement to compiler errors such as "unreachable statement" and "exception already caught" and other NetBeans "green" warnings such as "variable such-and-such is not used."

I have blogged about NetBeans hints before and the addition of new hints in NetBeans 7.1 is welcome. If anyone knows of a code sample that will demonstrate the Dead Branch hint in NetBeans 7.1, please share!

Original posting available at http://marxsoftware.blogspot.com/ (Inspired by Actual Events)

One of the "new and noteworthy" features of NetBeans 7.1 is the ability to compare two heap dumps. Specifically, the easy-to-use feature allows one to quickly ascertain the difference in number of each class's instances between two dump files. This brief post shows how easy it is to use.

Heap dumps can be generated in a variety of ways. For purposes of this post, I have created two heap dumps on two totally separate applications using the Oracle JDK-provided jmap (Java Memory Map) tool to attach to the processes's Java PIDs and create heap dumps (creatively named Heap1.map and Heap2.map in my example). It's probably not useful in most cases to compare heap dumps of two entirely different applications. I only do so in this example to make the differences calculated in the comparison results obvious.

The next screen snapshot shows NetBeans 7.1 started with the option "Load heap dump..." being selected under the "Profile" menu. This is done to load the first heap dump of the two to be compared.

The next screen image shows the results of selecting "Load heap dump..." (the popup titled "Open Heap Dump File") and indicates selecting one of the heap dumps (Heap1.map).

The next screen snapshot shows how NetBeans 7.1 looks with the selected heap dump displayed with the "Summary" tab in focus.

The last image showed the heap file loaded in NetBeans 7.1 with the "Summary" tab in focus. The next image is a snapshot of the IDE switched to the "Classes" tab in the heap dump report area.

The last image indicates that NetBeans shows the number of instances of different classes in the Java application whose heap dump is being analyzed. By default, the instances are listed in descending order of number of instances, but one can click on the "Size" column header to sort by total size. Just above the column headings "Instances" and "Size" is a link that says, "Compare with another heap dump" and that is the main focus of this post.

Clicking on the "Compare with another heap dump" link in the "Classes" tab of NetBeans 7.1's heap dump analysis tool leads to a popup ("Select Heap Dump to Compare") for selecting the second heap dump to be compared. This is indicated in the next screen snapshot.

In my example, I had two other heap dump files in the same directory as the originally selected one (Heap2.map and Heap3.map). Selecting Heap3.map leads to the comparison being made. This can take a few seconds for the NetBeans IDE to update the representation and it might be worth moving the scroll bar on the right down and back up to make sure it has updated. The next two screen snapshots show the comparison displayed with the first screen snapshot showing the types for which the first heap dump has more instances than the other (top) and the second image showing the types for which the second heap dump has more instances than the other (bottom).

The + and - signs indicate the number of instances greater (+) or fewer (-) in the first heap dump file analyzed (Heap1.map) as compared to that of the second heap dump file analyzed (Heap3.map). In other words, types with positive numbers have more instances represented in the originally loaded heap dump and types wiuth negative numbers have fewer instances represented in the originally loaded heap dump.

When comparing two separate applications, this doesn't provide much that's interesting other than to illustrate the tool. However, given two instances of the same application at the same execution point with different context or data sets might prove more interesting when comparing heap dumps. Perhaps the most enlightening use of this tool is for comparing heap dumps taken from the same application at different points in its execution. With NetBeans 7.1, it is easy to rapidly determine the difference between two heap dumps in terms of instances loaded at the time each heap dump was taken. When it's the delta or difference that matters, this tool can be useful.

Original posting available at http://marxsoftware.blogspot.com/ (Inspired by Actual Events)

Packt Publishing recently invited me to review the book JBoss AS 7 Configuration, Deployment and Administration. I readily accepted because I have not used or even read about JBoss in several years and welcomed the opportunity to read about its latest features. In this post, I provide a very brief first impression of the PDF version of this book similar to the brief preliminary review I previously provided of the Packt book Java EE 6 Development with NetBeans 7. I intend to provide a more thorough review of JBoss AS 7 Configuration, Deployment and Administration in a future post with a level of detail similar to that I provided for Java EE 6 Development with NetBeans 7.

The subtitle of author Francesco Marchioni's book JBoss AS 7 Configuration, Deployment and Administration is: "Build a fully-functional, efficient application server using JBoss AS." The "About the Author" section of the book states that Marchioni runs the site http://www.mastertheboss.com/, which has a main page with the subtitle "JBoss and Java EE tutorials." Two links currently shown on that main page are to posts about publication of JBoss AS 7 Configuration, Deployment and Administration and about winning a free copy of JBoss AS 7 Configuration, Deployment and Administration. Marchioni has also written the books JBoss AS 5 Development and JBoss AS 5 Performance Tuning.

The Packt Publishing page for JBoss AS 7 Configuration, Deployment and Administration provides a look at the book's Table of Contents, provides a free sample chapter, and provides more details on what the book covers.

Perusing the Table of Contents of JBoss AS 7 Configuration, Deployment and Administration leads me to believe that the 11 chapters will provide broad coverage of administrating and developing with JBoss AS 7. The chapters include the titles Installing JBoss AS 7, Configuring the Application Server, Configuring Enterprise Services, JBoss Web Server Configuration, Configuring a JBoss AS Domain, Deploying Applications on JBoss AS 7, Managing the Application Server, Clustering, Load-balancing Web Applications, Securing JBoss AS 7, and the particular trendy title Taking JBoss AS 7 in the Cloud. The Appendix looks useful with sections summarizing options and commands for JBoss 7 Command Line Interface (CLI).

I look forward to reading JBoss AS 7 Configuration, Deployment and Administration and learning more about JBoss AS 7. I will post a lengthier review based on my experience reading it.

Original posting available at http://marxsoftware.blogspot.com/ (Inspired by Actual Events)

By all accounts I have read and others have expressed, OSCON Java 2011 was a tremendous success. OSCON Java 2011 was O'Reilly's Java-specific conference held in conjunction with OSCON 2011 and the post Why OSCON Java? explains some of the reasons for the Java-specific conference being held last year. In 2012, it appears that the separate Data and Java conferences of 2011 are being brought back into the main OSCON 2012 conference. The page states, "Those who attended last year's OSCON Data and OSCON Java told us that they wanted to be part of the 'main' OSCON, so we're bringing Data and Java back into fold in 2012."

The About OSCON page explains OSCON: "Now in its 14th year, OSCON is the best place on the planet to prepare for what comes next ... OSCON is a unique gathering of all things open source." One example of praise for the OSCON conference is available in the post Why I Won’t Be At OSCON This Year.

According to the main OSCON 2012 page, "roughly 400 people will be presenting" and speaker proposals are due 12 January 2012. OSCON 2012 is to be held July 16-20, 2012, in Portland, Oregon, with registration opening in March.

Original posting available at http://marxsoftware.blogspot.com/ (Inspired by Actual Events)

Perhaps the biggest news in all of Javadom this past week was the release of NetBeans 7.1.

JavaFX 2.0 [specifically JavaFX 2.0.2 SDK support (release notes), which is downloaded separately] is the featured attraction for NetBeans 7.1. The Oracle press release (5 January 2012) announcing NetBeans 7.1 refers to it as the "first IDE to Support JavaFX 2.0" and the NetBeans 7.1 Release Notes list "Support for JavaFX 2.0" first on the list of new features. In NetBeans 7.1 geared for building better user interfaces, Joab Jackson states that this release "adds full support for Swing, JSF, and JavaFX 2."

The title of Charles Humble's post is "NetBeans 7.1 Shipped with JavaFX 2.0 and CSS3 Support" and talks about NetBeans "active users" exceeding one million last summer. As that post's title suggests, improved CSS3 support (including for JavaFX) is also featured in NetBeans 7.1. The NetBeans for PHP blog features a post on NetBeans 7.1 and its improved PHP features.

NetBeans 7.1 offers other new features and improvements such as more hints (see my post Seven Indispensable NetBeans Java Hints for more information on NetBeans hints). Improvements and new features related to Maven are offered as are C/C++ improvements. The new Visual Debugger and profiler improvements are also welcome.

No product is perfect, especially when first released, and NetBeans 7.1 has some known issues. The post Netbeans 7.1 is out but watch out before you grab that hot cake! references some of these.

Not only has the release of NetBeans 7.1 generated significant press and blogosphere coverage, but adoption seems robust as well. Although still in its very early stages, a new Java.net poll asking "How soon do you plan to start using the just-released NetBeans 7.1?" currently shows 33% of the respondents stating they are already using NetBeans 1.7 and another 15% stating they intend to upgrade within the month. Given that almost 1/3 of the respondents are saying "Never, since I don't use NetBeans," that's a large percentage of the NetBeans users who have or soon will be upgrading.

Original posting available at http://marxsoftware.blogspot.com/ (Inspired by Actual Events)

The pair class is familiar to those of us who have used C++ for any considerable length of time. Although there has been talk of adding it to Java as a standard part of the SDK, it is a somewhat controversial topic. Several folks have formally requested it and bugs have even been filed (4947273, 4983155, and 6229146) to get it in Java. In a post asking the question Do we want a java.util.Pair?, Alex Miller does a nice job of covering both sides of the issue.

There are already implementations of Pair or a Pair-like equivalent out there for Java. Besides the unknown number of custom ones in local code bases, there are publicly available examples such as those provided by the post Java Pair Class, examples provided in a StackOverflow thread, Ideograph's Generic Pair, and (no surprise) Java Tuples's Pair. The Android SDK also features a Pair class. The one that has surprised me the most is the existence of JavaFX 2.0's javafx.util.Pair class.

The package and class name most often proposed for an SDK version of the Pair class has been java.util.Pair and the JavaFX version is similar in package name: javafx.util.Pair. Running javap against this class in the JavaFX SDK, leads to the following output.

Compiled from "Pair.java"
public class javafx.util.Pair<K, V> {
public K getKey();
public V getValue();
public javafx.util.Pair(K, V);
public java.lang.String toString();
public int hashCode();
public boolean equals(java.lang.Object);
}

As the above javap output indicates, this is a relatively simple class with a basic parameterized constructor, "get" methods for the key and value portions of the Pair, and "common" methods toString(), equals(Object), and hashCode(). The next code listing demonstrates using the parameterized constructor to provide the key and value to each instance of Pair that is instantiated.

/**
* Provide a collection of famous pairs.
*
* @return Collection of famous pairs.
*/
private static Collection<Pair<String,String>> createFamousPairs()
{
final Collection<Pair<String,String>> pairs =
new ArrayList<Pair<String,String>>();
pairs.add(new Pair("Yin", "Yang"));
pairs.add(new Pair("Action", "Reaction"));
pairs.add(new Pair("Salt", "Pepper"));
pairs.add(new Pair("Starsky", "Hutch"));
pairs.add(new Pair("Fox", "Mulder"));
pairs.add(new Pair("Batman", "Robin"));
pairs.add(new Pair("Fred Astaire", "Ginger Rogers"));
pairs.add(new Pair("Flotsam", "Jetsam"));
pairs.add(new Pair("Brutus", "Nero"));
pairs.add(new Pair("Tom", "Jerry"));
pairs.add(new Pair("Jekyll", "Hyde"));
pairs.add(new Pair("Holmes", "Watson"));
pairs.add(new Pair("Mario", "Luigi"));
pairs.add(new Pair("Pinky", "The Brain"));
pairs.add(new Pair("Wallace", "Gromit"));
return pairs;
}

Accessing the key and value of each Pair is also easy as shown in the next code sample.

/**
* Write provided collection of pairs to standard output.
*
* @param title Title for output written to standard output.
* @param pairsToPrint Pairs to be written to standard output.
*/
private static void writeCollectionOfPairs(
final String title,
final Collection<Pair<String,String>> pairsToPrint)
{
out.println(title + ":");
for (final Pair<String,String> pair : pairsToPrint)
{
out.println("\t" + pair.getKey() + " and " + pair.getValue());
}
}

The above example is relatively contrived, but could be argued to be a most effective use of Pair because, in that particular example, it really is a "pair" concept being represented. One of the biggest complaints about adding Pair to the SDK or using it in general is that it is not named specific enough to cover the business purpose for an object's existence. I actually had thought about using the JavaFX Pair class when I wrote my Christmas Tree example for the post JavaFX 2.0 Christmas Tree (JavaFX 2.0 Shapes). I ended up deciding against this and used a more appropriately-named nested Coordinate class. However, I could have easily used Pair in that example. The next code listing contains that very example with the nested Coordinate class removed and references to it replaced by Pair.

package dustin.examples;

import javafx.application.Application;
import javafx.event.EventHandler;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.effect.Glow;
import javafx.scene.input.MouseEvent;
import javafx.scene.paint.Color;
import javafx.scene.paint.Paint;
import javafx.scene.shape.*;
import javafx.scene.text.Font;
import javafx.scene.text.Text;
import javafx.stage.Stage;
import javafx.util.Pair;

/**
* Simple example of using JavaFX 2.0's Path to create a simple Christmas tree.
*
* @author Dustin
*/
public class ChristmasTreePathWithPair extends Application
{
/** Number of branches on Christmas tree. */
private final static int NUMBER_BRANCHES = 4;
/** X-coordinate of very top of Christmas tree. */
private final static int TOP_CENTER_X = 400;
/** Y-coordinate of very top of Christmas tree. */
private final static int TOP_CENTER_Y = 25;
/** Horizontal distance to end of each branch. */
private final static int DELTA_X = 125;
/** Vertical distance to end of each branch. */
private final static int DELTA_Y = 100;
/** Length of each branch as measured on bottom of branch. */
private final static int BRANCH_LENGTH = 75;
/** Width of tree stump. */
private final static int STUMP_WIDTH = 100;
/** Height of tree stump. */
private final static int STUMP_HEIGHT = 150;
/** X-coordinate of top left corner of tree stump. */
private final static int LEFT_STUMP_X = TOP_CENTER_X - STUMP_WIDTH/2;
/** Y-coordinate of top left corner of tree stump. */
private final static int LEFT_STUMP_Y = TOP_CENTER_Y + DELTA_Y * NUMBER_BRANCHES;
/** Width of Christmas tree bottom. */
private final static int TREE_BOTTOM_WIDTH = (DELTA_X-BRANCH_LENGTH) * NUMBER_BRANCHES * 2;

/**
* Draw left side of the Christmas tree from top to bottom.
*
* @param path Path for left side of Christmas tree to be added to.
* @param startingX X portion of the starting coordinate.
* @param startingY Y portion of the starting coordinate.
* @return Coordinate with x and y values.
*/
private Pair<Integer, Integer> drawLeftSide(
final Path path, final int startingX, final int startingY)
{
int coordX = startingX - DELTA_X;
int coordY = startingY + DELTA_Y;
final LineTo topLeft = new LineTo(coordX, coordY);
path.getElements().add(topLeft);

coordX += BRANCH_LENGTH;
final LineTo topLeftHorizontal = new LineTo(coordX, coordY);
path.getElements().add(topLeftHorizontal);

coordX -= DELTA_X;
coordY += DELTA_Y;
final LineTo secondLeft = new LineTo(coordX, coordY);
path.getElements().add(secondLeft);

coordX += BRANCH_LENGTH;
final LineTo secondLeftHorizontal = new LineTo(coordX, coordY);
path.getElements().add(secondLeftHorizontal);

coordX -= DELTA_X;
coordY += DELTA_Y;
final LineTo thirdLeft = new LineTo(coordX, coordY);
path.getElements().add(thirdLeft);

coordX += BRANCH_LENGTH;
final LineTo thirdLeftHorizontal = new LineTo(coordX, coordY);
path.getElements().add(thirdLeftHorizontal);

coordX -= DELTA_X;
coordY += DELTA_Y;
final LineTo fourthLeft = new LineTo(coordX, coordY);
path.getElements().add(fourthLeft);

coordX += BRANCH_LENGTH;
final LineTo fourthLeftHorizontal = new LineTo(coordX, coordY);
path.getElements().add(fourthLeftHorizontal);

return new Pair(coordX, coordY);
}

/**
* Draw right side of the Christmas tree from bottom to top.
*
* @param path Path for right side of Christmas tree to be added to.
* @param startingX X portion of the starting coordinate.
* @param startingY Y portion of the starting coordinate.
* @return Coordinate with x and y values.
*/
private Pair<Integer, Integer> drawRightSide(
final Path path, final int startingX, final int startingY)
{
int coordX = startingX + BRANCH_LENGTH;
int coordY = startingY;
final LineTo bottomHorizontal = new LineTo(coordX, coordY);
path.getElements().add(bottomHorizontal);

coordX -= DELTA_X;
coordY -= DELTA_Y;
final LineTo bottomBranch = new LineTo(coordX, coordY);
path.getElements().add(bottomBranch);

coordX += BRANCH_LENGTH;
final LineTo secondHorizontal = new LineTo(coordX, coordY);
path.getElements().add(secondHorizontal);

coordX -= DELTA_X;
coordY -= DELTA_Y;
final LineTo secondBottomBranch = new LineTo(coordX, coordY);
path.getElements().add(secondBottomBranch);

coordX += BRANCH_LENGTH;
final LineTo thirdHorizontal = new LineTo(coordX, coordY);
path.getElements().add(thirdHorizontal);

coordX -= DELTA_X;
coordY -= DELTA_Y;
final LineTo thirdBottomBranch = new LineTo(coordX, coordY);
path.getElements().add(thirdBottomBranch);

coordX += BRANCH_LENGTH;
final LineTo fourthHorizontal = new LineTo(coordX, coordY);
path.getElements().add(fourthHorizontal);

coordX -= DELTA_X;
coordY -= DELTA_Y;
final LineTo fourthBottomBranch = new LineTo(coordX, coordY);
path.getElements().add(fourthBottomBranch);

return new Pair(coordX, coordY);
}

/**
* Draw stump of tree.
*
* @return Path representing Christmas tree stump.
*/
private Path buildStumpPath()
{
final Path path = new Path();

int coordX = LEFT_STUMP_X;
int coordY = LEFT_STUMP_Y;
final MoveTo startingPoint = new MoveTo(coordX, coordY);
path.getElements().add(startingPoint);

coordY += STUMP_HEIGHT;
final LineTo leftStumpSide = new LineTo(coordX, coordY);
path.getElements().add(leftStumpSide);

coordX += STUMP_WIDTH;
final LineTo stumpBottom = new LineTo(coordX, coordY);
path.getElements().add(stumpBottom);

coordY -= STUMP_HEIGHT;
final LineTo rightStumpSide = new LineTo(coordX, coordY);
path.getElements().add(rightStumpSide);

coordX -= STUMP_WIDTH;
final LineTo topStump = new LineTo(coordX, coordY);
path.getElements().add(topStump);

path.setFill(Color.BROWN);

return path;
}

/**
* Build the exterior path of a Christmas Tree.
*
* @return Path representing the exterior of a simple Christmas tree drawing.
*/
private Path buildChristmasTreePath()
{
int coordX = TOP_CENTER_X;
int coordY = TOP_CENTER_Y;
final Path path = new Path();
final MoveTo startingPoint = new MoveTo(coordX, coordY);
path.getElements().add(startingPoint);

final Pair<Integer, Integer> bottomLeft = drawLeftSide(path, coordX, coordY);
coordX = bottomLeft.getKey() + TREE_BOTTOM_WIDTH;
coordY = bottomLeft.getValue();

final LineTo treeBottom = new LineTo(coordX, coordY);
path.getElements().add(treeBottom);

drawRightSide(path, coordX, coordY);

path.setFill(Color.GREEN);

return path;
}

/**
* Create a bulb based on provided parameters and associate a MouseEvent to
* it such that clicking on a bulb will increase its size and enable the glow
* effect.
*
* @param centerX X-coordinate of center of bulb.
* @param centerY Y-coordinate of center of bulb.
* @param radius Radius of bulb.
* @param paint Paint/color instance to be used for bulb.
* @return Christmas tree bulb with interactive support.
*/
private Circle createInteractiveBulb(
final int centerX, final int centerY, final int radius, final Paint paint)
{
final Circle bulb = new Circle(centerX, centerY, radius, paint);
bulb.setOnMouseClicked(
new EventHandler<MouseEvent>()
{
@Override
public void handle(MouseEvent mouseEvent)
{
bulb.setEffect(new Glow(1.0));
bulb.setRadius(bulb.getRadius() + 5);
}
});
return bulb;
}

/**
* Add colored circles (bulbs) to the provided Group.
*
* @param group Group to which 'bulbs' are to be added.
*/
private void addBulbs(final Group group)
{
final Circle bulbOne = createInteractiveBulb(350,100,10, Color.RED);
group.getChildren().add(bulbOne);
final Circle bulbTwo = createInteractiveBulb(285,210,10, Color.YELLOW);
group.getChildren().add(bulbTwo);
final Circle bulbThree = createInteractiveBulb(325,300,10, Color.WHITE);
group.getChildren().add(bulbThree);
final Circle bulbFour = createInteractiveBulb(475,290,10, Color.BLUE);
group.getChildren().add(bulbFour);
final Circle bulbFive = createInteractiveBulb(380,150,10, Color.CADETBLUE);
group.getChildren().add(bulbFive);
final Circle bulbSix = createInteractiveBulb(550,390,10, Color.VIOLET);
group.getChildren().add(bulbSix);
final Circle bulbSeven = createInteractiveBulb(375,400,10, Color.GOLD);
group.getChildren().add(bulbSeven);
final Circle bulbEight = createInteractiveBulb(445,195,10, Color.SILVER);
group.getChildren().add(bulbEight);
final Circle bulbNine = createInteractiveBulb(220,385,10, Color.DARKSALMON);
group.getChildren().add(bulbNine);
}

/**
* Add text portions to Christmas Tree group.
*
* @param group Group for text to be added to.
*/
private void addText(final Group group)
{
final Text text1 = new Text(25, 125, "Merry\nChristmas!");
text1.setFill(Color.RED);
text1.setFont(Font.font(java.awt.Font.SERIF, 50));
group.getChildren().add(text1);

final Text text2 = new Text(600, 150, "2011");
text2.setFill(Color.DARKGREEN);
text2.setFont(Font.font(java.awt.Font.SERIF, 75));
group.getChildren().add(text2);
}

/**
* Starting method of JavaFX application.
*
* @param stage Primary stage.
* @throws Exception Thrown for exceptional circumstances.
*/
@Override
public void start(final Stage stage) throws Exception
{
stage.setTitle("JavaFX 2.0: Christmas Tree 2011 (Pair)");
final Group rootGroup = new Group();
final Scene scene = new Scene(rootGroup, 800, 600, Color.WHITE);
stage.setScene(scene);
rootGroup.getChildren().add(buildChristmasTreePath());
rootGroup.getChildren().add(buildStumpPath());
addBulbs(rootGroup);
addText(rootGroup);
stage.show();
}

/**
* Main function that kicks off this JavaFX demonstrative application.
*
* @param arguments Command-line arguments; none expected.
*/
public static void main(final String[] arguments)
{
Application.launch(arguments);
}
}

Removing the nested Coordinate class reduces the overall lines of code for the application, but argument against this is that Pair is not as readable or specific as Coordinate was. This example exemplifies what I typically do: make simple custom classes rather than using a generic Pair.

What's perhaps most interesting to me about JavaFX having a Pair class is the implication of this when one considers that JavaFX will likely be standardized and made part of Java SE. This Pair class could very well end up in the Java SDK as-is. Other options would be to include a standard java.util.Pair class as a replacement for the JavaFX version, to have both in the SDK (having more than one in the SDK itself), or to not add the new one and remove the JavaFX version. There are ramifications on maintenance of existing applications either way. Several people have commented that it is a code smell or feels dirty to use a Pair rather than a custom object pairing two attributes. It would probably only make things feel even dirtier to use an implied JavaFX-specific class (javafx.util.Pair) in code that has nothing to do with JavaFX or even with presentation or user interface.

Original posting available at http://marxsoftware.blogspot.com/ (Inspired by Actual Events)

JavaFX 2.0 provides the CheckBox (notice capital 'B' versus AWT's Checkbox's lowercase 'b') control that supports three states ("undefined", "checked", and "unchecked"). The AWT Checkbox only supports two states (on/true or off/false), but JavaFX's CheckBox can optionally support three states. If one desires the JavaFX version to support three states (the third being indeterminate), this is done by invoking allowIndeterminateProperty() on the CheckBox instance. Alternatively, setAllowIndeterminate(boolean) can be used to enable three states (passing it true) or only two states (passing it false).

The next code listing provides the source code for a simple JavaFX application that demonstrates the tri-state JavaFX CheckBox control. All the application does is to change the text associated with the CheckBox to indicate what state that CheckBox is in. As described in the CheckBox's Javadoc documentation, the three states of the CheckBox consist of "undefined" (indeterminate), "checked" (determinate and selected), or "unchecked" (determinate and not selected). This simple example boils these three states down to "determinate", "selected", and "unselected" and uses nested conditional ternary operators to set that String.

CheckboxExample.java

package dustin.examples;

import javafx.application.Application;
import javafx.event.EventHandler;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.control.CheckBox;
import javafx.scene.control.CheckBoxBuilder;
import javafx.scene.input.MouseEvent;
import javafx.scene.paint.Color;
import javafx.stage.Stage;

/**
* Simple example of JavaFX 2.0 Checkbox control.
*
* @author Dustin
*/
public class CheckboxExample extends Application
{
/**
* Provides a checkbox instance with specified String and supporting three
* states (supporting indeterminate state).
*
* @param checkboxText Text to go with checkbox.
* @return Checkbox with text.
*/
private CheckBox buildTriStateCheckbox(final String checkboxText)
{
// Note that AWT's Checkbox does not have capital 'b'
final CheckBox checkbox =
CheckBoxBuilder.create()
.allowIndeterminate(true)
.indeterminate(true)
.prefHeight(50)
.prefWidth(300)
.text(checkboxText)
.build();

checkbox.setOnMouseClicked(
new EventHandler<MouseEvent>()
{
@Override
public void handle(final MouseEvent mouseEvent)
{
final String newText =
checkbox.isIndeterminate()
? "Indeterminate!"
: checkbox.isSelected() ? "Selected!": "Unselected!";
checkbox.setText(newText);
}
}
);
return checkbox;
}

/**
* Overridden method defined in parent class and used in JavaFX application
* lifecycle.
*
* @param stage
* @throws Exception Exception during JavaFX sample application.
*/
@Override
public void start(final Stage stage) throws Exception
{
stage.setTitle("JavaFX 2 Checkbox Demo");
final Group rootGroup = new Group();
rootGroup.getChildren().add(buildTriStateCheckbox("Tri-State CheckBox"));
final Scene scene = new Scene(rootGroup, 300, 50, Color.CADETBLUE);
stage.setScene(scene);
stage.show();
}

/**
* Main function for running demonstration of JavaFX 2 Checkbox example.
*
* @param arguments Command-line arguments: none expected;
*/
public static void main(final String[] arguments)
{
Application.launch(arguments);
}
}

This is another all-Java example of JavaFX and it can be compiled with the normal Java compiler (assuming JavaFX on the classpath) and executed with the normal Java application launcher (again assuming JavaFX on the classpath). When executed it behaves as demonstrated in the following series of static snapshots. The first screen snapshot is its initial appearance with initially set text and the three images following that one indicate the changing of the state of the CheckBox as it is clicked on.

The JavaFX 2 CheckBox class, like other JavaFX controls, provides significant more styling flexibility than the defaults I've shown here. The CheckBox is easy to use and can support two or three states as needed.

Original posting available at http://marxsoftware.blogspot.com/ (Inspired by Actual Events)