Toni Epple's Blog

at Eppleton

17. July 2007

Porting Kirk Pepperdine to the NetBeans Platform III

Filed under: Allgemein, netbeans — maxnitribitt @ 07:23

In my day job I’m right now tuning a java library that performs statistical analysis on very large data sets, and it would be great to have Peppy around to speed this up. So let’s get started:

In the last part of this series we have added a resizeable Balloon panel. Now we want to display real hints. First we need to create a list of hints and add some hyperlinks for further readings. The simplest solution is to have a properties file. For a start I wanted to display random hints, so we are using numbers as the keys, so we can easily use a random number to choose from them. Here’s my file:

# Sample Tips properties file

0=It looks like you're tuning an application.<br><br><a href="http://www.javaperformancetuning.com/">Do you need help?</a>

1=Use the final modifier on instance-variable definitions to create immutable internally accessible objects.<br><a href="http://www.oreilly.com/catalog/javapt/chapter/ch04.html">more...</a>

2=Use private and static methods, and final classes, to encourage inlining by the compiler.<br><a href="http://www.oreilly.com/catalog/javapt/chapter/ch04.html">more...</a>

3=ArrayList is faster than Vector except when there is no lock acquisition required in HotSpot JVMs (when they have about the same performance).<br><a href="http://www.onjava.com/pub/a/onjava/2001/05/30/optimization.html">more...</a>

4=Vector and ArrayList implementations have excellent performance for indexed access and update of elements, since there is no overhead beyond range checking.<br><a href="http://www.onjava.com/pub/a/onjava/2001/05/30/optimization.html">more...</a>

5=Adding elements to, or deleting elements from the end of a Vector or ArrayList also gives excellent performance except when the capacity is exhausted and the internal array has to be expanded.<br><a href="http://www.onjava.com/pub/a/onjava/2001/05/30/optimization.html">more...</a>

I’ve put it in a resources folder in my sources. Now we need to have the functionality to let Peppy display these hints. So first lets load the properties file, modify PeppyPanes constructor and add two variables like this:

    private Random randomGenerator;
    private Properties hints;
    /** Creates new form PeppyPane */
    public PeppyPane() {
        initComponents();
        setOpaque(false);
        hints = new Properties();
        try {
            hints.load(PeppyPane.class.getResourceAsStream("/de/eppleton/pepperdine/resources/hints.properties"));
        } catch (IOException ex) {
            ex.printStackTrace();
        }
        randomGenerator = new Random(System.currentTimeMillis());
    }

We want to display a different tip everytime Peppy shows up, so lets override setVisible:

    public void setVisible(boolean aFlag) {
        if (aFlag) balloonPanel1.setText( hints.getProperty(""+randomGenerator.nextInt(hints.size())));
        super.setVisible(aFlag);
    }

Do you see how efficient this is done? We’re only changing the text, when aFlag is true. Dude, this is going to be fast as lightning… Now we only need to get these hyperlinks to work. Shouldn’t be that hard, as NetBeans ships with a URLDisplayer. In the constructor of balloonpanel add this after the call to setText:

        advicePane.setText("<html background=#ffffc6>It looks like you're tuning an application.<br><br>Do you need help?</html>");
        advicePane.addHyperlinkListener(new HyperlinkListener() {
            public void hyperlinkUpdate(HyperlinkEvent e) {
             try{
		if (e.getEventType() == EventType.ACTIVATED)URLDisplayer.getDefault().showURL
		(e.getURL());//NOI18N
            } catch (Exception eee){
                return;

            }
            }
        });

And here we are, Peppy giving us useful tips on how to tune our applications:

Now you can follow the hyperlink to see the details in your browser.

Geertjan had some great ideas on how to go on with Peppy, like having other experts around for different tasks, like Roman Strobl giving you the tip of the day on how to use the IDE, or Greg Murray giving AJAX tips, or Heinz Kabutz could give tips from his Java Specialists’ newsletter… We even could have a framework to let people provide their own Peppys. Imagine James Gosling, Geertjan Wielenga and Romain Guy at your fingertips to help you programming. For a start, you now know the format, so if you would like to contribute: send me a gif (with transperency, the gimp is great for that) of your favorite programming guru and a properties file with some hints (in a zip-file to epple genomatix de), so I can try to create a framework and already include some Peppys right from the start :). And imagine the honor of receiving a “you’ve been ported” mail yourself :).

Comments (4)

15. July 2007

New NetBeans Usergroup munich (NUGM)

Filed under: Allgemein, netbeans — maxnitribitt @ 18:31

On thursday we had our first official NUGM meeting. Geertjan Wielenga from Sun in Prague gave a great talk about “How to port a Java application to the NetBeans Platform. And why???”. I was really happy that there were quite a lot of people there, even though it was our first meeting. Afterwards some of us went to a nice bar called GAP to have a few beer and we had some interesting discussions.

The NUGM is now part of the Java Usergroup Munich (JUGM) and thanks to Andreas Haug, who is running the JUGM we can have a homepage in the wiki there, as well as a news page with announcements, photos, and so on. So if you are from or near munich, and you would like to be informed of future events, meetings and so on, register for the JUGM mailing list. I will announce all the events there.

Comments (0)

Porting Kirk Pepperdine to the NetBeans Platform II

Filed under: netbeans — maxnitribitt @ 07:06

Your applications needs too much time or memory? And it bothers you so much that you simply wish you were on a sunny island far away from here? Well you no longer need to, because help is around the corner.

Yesterday I blogged about how to get started porting Kirk Pepperdine to the NetBeans platform. I’ve just returned from the Kocherlball so now I’m in the right mood for continuing with my plugin. Today we will improve the components, so you can display test of varying length. We still want our component look like a speech balloon, but it needs to be resizeable. So let’s cut the balloon into pieces (add transparency where needed):

Create a new BalloonPanel to hold the messages (New File -> Java GUI Forms -> JPanel Form) and set opaque to false. In the Inspector right click the Panel and set the layout to BorderLayout. Put 2 JLabels to NORTH and SOUTH remove the labels text, and add the respective image to each label. A JEditorPane in the center would be nice, but Matisse adds it together with a JScrollPane, so we’ll add it manually in the constructor:

    private JEditorPane advicePane = new JEditorPane();
    /** Creates new form BalloonPanel */
    public BalloonPanel() {
        initComponents();
        advicePane.setEditable(false);
        advicePane.setEditorKit(new HTMLEditorKit());
        advicePane.setBackground(new Color(255,255,198));
        advicePane.setText("Hello World");
        this.add(advicePane, BorderLayout.CENTER);
    }

The most important thing here is this line:

advicePane.setEditorKit(new HTMLEditorKit());

You might wonder, why we don’t do it like this:

advicePane.setContentType("text/html");

But this doesn’t do what we want in NetBeans. NetBeans registers it’s own EditorKit for “text/html”, so you would get syntax-highlighted tags instead of rendered html.

For EAST and WEST we need components that scale the image to the needed size:

public class StretchImage  extends JComponent{
    private Image image;
    private Dimension preferred = new Dimension(8,8);
    public StretchImage(){
    }

    public StretchImage(Image image){
        this.setImage(image);
    }

    protected void paintComponent(Graphics g) {
        if (image!=null){
            ((Graphics2D)g).drawImage(image, 0, 0, getWidth(), getHeight(),null );
        }
    }

    public Dimension getPreferredSize() {
        return preferred;
    }

    public Image getImage() {
        return image;
    }

    public void setImage(Image image) {
        this.image = image;
        preferred = new Dimension(image.getWidth(null),image.getHeight(null));
    }
}

We need to add these to our BalloonPane somehow. To do so, we’ll first add our new Component to the Palette. Right click the Palette and launch the Palette Manager. Select “add from project” and select your module project, now choose the StretchImage and add it to the Swing category. Voila, our StretchImage can be used from the Palette now. Add two of those to the left and right of your BalloonPane and give them their images:

public BalloonPanel() {
        initComponents();
        ImageIcon leftImage = new ImageIcon(getClass().getResource("/de/eppleton/pepperdine/img/balloon_left.gif"));
        ImageIcon rightImage = new ImageIcon(getClass().getResource("/de/eppleton/pepperdine/img/balloon_right.gif"));
        stretchImage1.setImage(leftImage.getImage());
        stretchImage2.setImage(rightImage.getImage());
        advicePane.setEditable(false);
        advicePane.setEditorKit(new HTMLEditorKit());
        advicePane.setBackground(new Color(255,255,198));
        advicePane.setText("<html background=#ffffc6>It looks like you're tuning an application.<br>Do you need help?</html>");
        this.add(advicePane, BorderLayout.CENTER);
    }

Now we have a nice component that can be used to display text in a balloon. With a little work it could also be useful in many other places.

Now add the BalloonPanel to the palette as before and replace the balloon label in the PeppyPane with our nice new Balloon. In the properties-sheet, go to Layout and set Horizontal size to 185. That’s it, now we can display text of varying length with our balloon.

Stay tuned, for next time we will let Peppy display some enlightening hints.

Comments (2)

14. July 2007

Porting Kirk Pepperdine to the NetBeans Platform

Filed under: clippy, netbeans — maxnitribitt @ 17:25

I just returned from the Münchner Viktualienmarkt Biergarten where I had met Geertjan. He really is a Sun guy: he didn’t even want a table in the shadow when it was like 35 degrees celsius. Geertjan has started to port Kirk Pepperdine to the NetBeans Platform, and I think this is a great project, so I decided to contribute. Geertjan has already found a perfect name for my subproject. So say goodbye Clippy, for here comes PEPPy ( obviously this is an acronym for Performance Enhancement Personal Pundit)!

update: I confess, this is a pure backronym

Lets create the module (New Project-> Netbeans Plug-in Modules -> Module Project). Make it a standalone and add a Window component (New File -> NetBeans Module Development -> Window Component). We will use this window to launch Peppy. In the designer of your TopComponent (mine is called “SomeTopComponent”) add a JTextArea, select it and go to events. Click on the keytyped, and add a new Handler (call it “PepperdineHandler”).

To show Peppy above all other components in NetBeans we will need to get hold of the glasspane. In Winston Prakash’s blog I found information on how to get hold of the glasspane in NetBeans. So first we will create a GlassPane. You can take any component for this. We will use a JPanel (New File-> Java GUI Forms -> JPanel Form). Add a JLabel to the lower right corner with an image of a performance guru like this one:

and a second one just above to display a message:

You can change the second one to display a different message, or add a more elaborate component, but for a first shot this will be fine. Set your JPanel to be transparent by adding this to the constructor:

     /** Creates new form PeppyPane */
    public PeppyPane() {
        initComponents();
        setOpaque(false);
    }

Now we will add this as the GlassPane to NetBeans, add this variable to your TopComponent:

 private static PeppyPane glassPane = new PeppyPane();

and set it as the GlassPane in the constructor:

 private SomeTopComponent() {
        initComponents();
        final JFrame mainWin = (JFrame) WindowManager.getDefault().getMainWindow();
        mainWin.setGlassPane(glassPane);
        setName(NbBundle.getMessage(SomeTopComponent.class, "CTL_SomeTopComponent"));
        setToolTipText(NbBundle.getMessage(SomeTopComponent.class, "HINT_SomeTopComponent"));
//        setIcon(Utilities.loadImage(ICON_PATH, true));
    }

As you know the Microsoft Assistant had a very elaborate AI to pop up exactly when you need it, and only then. So it must be hard to model this behavior, right? Believe it or not: Sun has already implemented this exact behaviour in the java language :). So all you’ve got to do is add one variable to the TopComponent:

    private Random randomGenerator = new Random(System.currentTimeMillis());

and implement your PepperdineHandler method:

 private void PepperdineHandler(java.awt.event.KeyEvent evt) {
     if (randomGenerator.nextInt()%37==0)
        glassPane.setVisible(!glassPane.isVisible());
    }

And here we are, Kirk Pepperdine at your service:

Be sure to tune in next time when captain Kirk says “It looks like you’re tuning an application. Do you need help?”

Comments (1)