Sliding viewport over a JPanel

Question

I'm using drawLine() and friends to paint a graph onto a JPanel. There are tens of thousands of points to graph, so it takes 3-5 seconds. I want to have a viewport, like the blue one illustrated below, over the graph.

I would like this viewport to be updatable, as I have a MouseMotionListener on the JPanel that the graph is on. The problem is, if I redraw the viewport (the square) as it is now, (using drawRect()), I have to redraw the entire graph, which isn't desirable.

I've read some about GlassPanes, which may be useful for solving this problem, but they evidently are a part of JFrames, and not JPanels. (I have this panel along with other components inside of a JFrame already.)

What would be a nice way to handle this, staying in Swing and being efficient?

For what it's worth, I'm actually coding in Clojure, but that shouldn't change anything here.

Thank you very much!

Isaac

Answer 1

From the screenshot you posted, it shouldn't be taking 3-5 seconds to paint. You shouldn't have to use layers to accomplish what you're talking about. I have an application with as much data as you describe, but a more complicated visualization. It also has the same sort of viewport feature you discuss. It has no problem painting, and most times paints in 3-5 milliseconds.

Make sure that the data is stored in a way that the paint thread can access it quickly. The paint thread should spend all its time painting, and if it has to search through data to find what it needs, then it's wasting its time.

Collect timing information inside the paint method and write it to the console. Track down how much time each part of the method takes and figure out which line(s) of code are causing the delay. Figure out how to get rid of this delay. The paint method should only take 3-5 milliseconds to run. You're off by a factor of 1,000 - something can be optimized.

Make sure you're only painting what actually will be visible on the screen. Don't waste time painting things that will appear off-screen. Also make sure you're not painting really long lines that are only partly visible on the screen. (Like, if you zoom in a hell of a lot, and even the smallest line is now huge.) The whole thing has to be painted, whether or not it's visible.

I'd be surprised, based on the screenshot, that you have to use any sort of layering to accomplish this. 3-5 seconds is way too long for even one paint cycle.

Answer 2

My approach to this sort of problem was to consider the volatility of the data. Unless the chart is ticking along in real time, the only thing that will change from paint to paint is the position of the blue box. One way to minimize the paint time is to not repeat work you have already performed. For example:

protected void paintComponent(Graphics g) {
    // paint chart
    if (dirty || buffer == null) {
        buffer = new BufferedImage(getWidth(), getHeight(),
                                   BufferedImage.TYPE_ING_ARGB);
        // Paint the chart onto the buffered image
        dirty = false;
    }
    b.drawImage(0, 0, buffer);
    // Draw blue box
    ...
}

The very first call to paintComponent initializes the buffer and does the heavy lifting of painting the graph. Thereafter, the buffer is just painted. If you need to handle the case where the display is redrawn to show a different part of the data, you just need to invalidate the buffer.

public void invalidateBuffer() {
    dirty = true;
    repaint();
}