Robert Marcano's blog

Subclipse added to Fedora Extras

robert — Sat, 26 Aug 2006 21:14:26 -0400

After approval I added Subclipse (Subversion Eclipse plugin) to the Fedora Extras repository. :-P The news reached Fedora People and Planet GCC.

JBoss Inc. to be acquired by Red Hat

robert — Mon, 10 Apr 2006 13:05:20 -0400

Amazing news.....

Java = APIs, Oracle = Wrong APIs implementations

robert — Wed, 23 Nov 2005 14:50:39 -0500

Since JDBC 3.0 it has been posible to retrieve the keys that are generated on a database when an SQL insert is executed, using the getGeneratedKeys() method on the statement object. For some reason the latest Oracle JDBC driver that claims that implement this method, has a non standard behaviour (that is not strange on Oracle):

It does not returns the generated keys values, it only returns a value for a propietary object implementation named ROWID. One of the solutions was to use that ROWID in a query to retrieve the other generated columns:

SELECT KEY_1, KEY_2, KEY_3 FROM MYTABLE WHERE ROWID = ?

where KEY_1, KEY_2, KEY_3 are the generated columns I want to know its value. The other solution is not to use the int parameter (with the value Statement.RETURN_GENERATED_KEYS) in the PreparedStatement, instead use the one that needs the generated column names or indexes.

Another reason why I prefer IBM DB2 and PostgreSQL over Oracle.

Java Desktop Search

robert — Mon, 11 Jul 2005 21:42:11 -0400

I am in the process of learning Java-GNOME and to do that I am building a desktop search tool. I have currently working the basic UI and basic file indexing.

Why am I doing this? before anyone start asking why I do not use Beagle, these are my reasons

I want to learn.
I believe that GCJ/Classpath are a more open solution than Mono, remember that this is my personal decission and you are free to use what you preffer.
I think that still are many gaps on the amount of GNOME and POSIX APIs available to Java programmers, so I intend with a popular type of application to detect what can be enhanced, for example, bindings to FAM/gamin, inotify and others.

Here is an very early screenshot of what is being developed, there will not be any release until something more useful is ready (stay tuned :-) ):

Java has a great community

robert — Mon, 11 Jul 2005 17:00:41 -0400

Last week I was reading one of the posts on Santhosh Kumar's Weblog and as the problem explained was related to and old one I had, I decided to ask for a little help; later a full post was published with Santhosh solution. Thanks.

My friends always ask me why I write tips or solutions to software development problems. My answer is always the same: "because someone need it", that is the only way I have to say thanks to the people that had helped anonymously.

Hibernate criteria API limitation

robert — Thu, 07 Jul 2005 22:30:06 -0400

I tried a few hours to solve the following problem: having a class named Group that has zero or more roles, where each role is a String, and the mapping is the following:

<set
    name="roles"
    table="GROUPROLES"
    lazy="true"
    <key column="GROUP"/>
    <element column="ROLE"/>
</set>

create a Criteria based query that returns the groups that has assigned a particular role. Well, this is not posible without resorting to direct SQL, and this is a limitation of Hibernate when one of relationship sides is not a mapped class, like this case that is a String.

The workaround: use a SQL expresion with a susbselect:

Expresion.sql("EXISTS (SELECT * FROM GROUPROLES"
                    + " WHERE GROUP = {alias}.GROUP"
                    + "    AND ROLE = ?)",
              "myrole",
              Hibernate.STRING)

Litte glasspane bug report accepted

robert — Thu, 07 Jul 2005 14:11:17 -0400

I have reported a bug when using a glasspane to show the wait cursor and it has been approved. The problem is that the cursor does not change when the glasspane is used in a JDialog with no parent window.

JTabbedPane background on Windows XP

robert — Wed, 06 Jul 2005 15:13:56 -0400

I am not a fan of the usage of notebook like widgets because I think that they tend to make the application interface cluttered, I prefer wizard like structures, but sometimes they are the best solution available. In Java this kind of component is called a JTabbedPane

For some reason when looking a JTabbedPane with the Windows look and feel on Windows XP (Luna theme), a small anoyance is revealed: JPanel components on the JTabbedPane are opaque thus hiding the tabbed pane default background, like this:

To solve this remember to set your JPanels and other components like radio buttons and checkboxes non opaque:

panel.setOpaque(false);

and you will get a nicer tabbed pane

Update 07/06/2005: I forgot to tell that this only works with JSE 5.0 because the Windows Look and Feel on previous releases did not implemented the correct JTabbedPane background

Update 07/08/2005: This probably is a bug in the Sun implementation as said by one of the commentators, but I think they will not change that because JPanels on the Windows L&F has been always opaque. My solution involves the usage of a custom utility method that traverse the components tree and change the opacity for the panels when the Windows L&F is active.

Java-GNOME

robert — Sun, 03 Jul 2005 18:30:04 -0400

Now that many Linux distributions are packaging updated versions of GCJ, Eclipse and Java-GNOME, never has been so easy to develop GNOME applications using Java. I am using Fedora Core 4 and for this little tutorial you must have installed:

eclipse-jdt
libgtk-java
libgnome-java
libgconf-java
libglade-java

You can use yum to install them:

yum install eclipse-jdt libgnome-java libgconf-java libglade-java libgtk-java

Start Eclipse and create a Java project. Edit the build path of your new project adding the following external jars

/usr/share/java/gtk2.6.jar
/usr/share/java/gconf2.10.jar
/usr/share/java/glade2.10.jar
/usr/share/java/gnome2.10.jar

Now you can try with this example:

public static void main(String[] args) {
	// intializing GTK
	Gtk.init(args);

	// creating the widget tree
	Window window = new Window(WindowType.TOPLEVEL);
	window.setTitle("Testing GTK");
	window.add(new Button("Test..."));

	// adding a listener to detect when the window is closed to end the
	// event dispatch main cycle and exit the application
	window.addListener(new LifeCycleListener() {
		public void lifeCycleEvent(LifeCycleEvent evnt) {
			if (evnt.getType() == LifeCycleEvent.Type.UNREALIZE)
				Gtk.mainQuit();
		}

		public boolean lifeCycleQuery(LifeCycleEvent evnt) {
			return false;
		}
	});
	// showing the window
	window.showAll();

	// starting the event dispatch cycle
	Gtk.main();
}

Test the application and you will get something like this:

Extended documentation can be found on the Java-GNOME documentation page and the original GNOME documentation (C based APIs)

Disabling Keyboard Input - Swing

robert — Thu, 09 Jun 2005 16:11:28 -0400

A good programmer using Swing knows that long operations must be executed outside the Swing event dispatch thread, and there are many utlities to do that like the SwingWorker class. One of the problems that arises when another thread in opened to do processing is that sometimes is needed to inhibit any input made by the user. One of the solutions is the usage of the glass pane in order to capture input events, adding a mouse listener to the glass pane we can capture all mouse input events in order to block them.

But what about key events? a key listener works, but is required to transfer the focus to the glass pane, and that remove the focus from the current focused component. For this key events problem I take another approach: use the KeyboardFocusManager. This class allows to install a KeyEventDispatcher that is able to route the event to the appropiate component. If a dispatcher is installed that always returns true, no key event will be sent to any component until the dispatcher is removed. See the following example:

import java.awt.KeyEventDispatcher;
import java.awt.KeyboardFocusManager;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.MouseAdapter;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JTextField;
import javax.swing.WindowConstants;

public class TestWindow {
    private static JFrame frame;

    private static KeyEventDispatcher dispatcher = new KeyEventDispatcher() {
        public boolean dispatchKeyEvent(KeyEvent e) {
            // returning true will make the KeyboardFocusManager to not send the
            // event the component
            return true;
        }
    };

    public static void main(String[] args) {
        frame = new JFrame();
        frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);

        // building the components tree
        frame.setBounds(0, 0, 400, 400);
        JTextField tf = new JTextField();
        frame.getContentPane().add(tf);
        frame.setVisible(true);

        // enter on the text field will call a new thread performing a long
        // operation without blocking the swing events dispatch thread
        tf.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                // setting a glass pane
                JPanel gp = new JPanel();
                gp.setOpaque(false);
                frame.setGlassPane(gp);
                gp.setVisible(true);

                // this empty mouse listener will capture all the mouse events
                gp.addMouseListener(new MouseAdapter() {
                });

                // installing the dispatcher
                KeyboardFocusManager kfm = KeyboardFocusManager
                        .getCurrentKeyboardFocusManager();
                kfm.addKeyEventDispatcher(dispatcher);

                // starting the thread
                Thread t = new LongOperation();
                t.start();
            }
        });
    }

    private static class LongOperation extends Thread {
        public void run() {
            try {
                // doing someting for a long time
                Thread.sleep(5000);
            } catch (Exception e) {
                e.printStackTrace();
            }

            // hidding the glass pane
            frame.getGlassPane().setVisible(false);

            // removing the dispatcher
            KeyboardFocusManager kfm = KeyboardFocusManager
                    .getCurrentKeyboardFocusManager();
            kfm.removeKeyEventDispatcher(dispatcher);
        }
    }
}

Calling the action on the JTextField (enter key) a glass pane will be installed to consume mouse events, and a KeyEventDispatcher to consume key events, next the long operation thread will start. At the end the glass pane and the dispatcher are removed to allow normal processing of the events. In the period that the new thread is executing, no input will be accepted by the user, that was the idea.