skrueger/geotools/RenderingExecutor.java

package skrueger.geotools;

import java.awt.Graphics2D;
import java.awt.Rectangle;
import java.awt.geom.AffineTransform;

import javax.swing.SwingUtilities;

import org.geotools.geometry.jts.ReferencedEnvelope;
import org.geotools.renderer.GTRenderer;
import org.geotools.renderer.RenderListener;
import org.opengis.feature.simple.SimpleFeature;

import schmitzm.swing.SwingUtil;

/**
 * This class is used by {@link XMapPane} to start and stop the rendering a
 * {@link Thread} for rendering.
 */
class RenderingExecutor {

        /**
         * Instance to a {@link RenderThread} doing any work. It's volatile so the
         * correct value will always be visible to any {@link Thread}
         **/
        private volatile RenderThread renderThread;

        private final XMapPane mapPane;

        public RenderingExecutor(XMapPane mapPane) {
                this.mapPane = mapPane;
        }

        /**
         * Submit a new rendering task. If no rendering task is presently running
         * this new job will be accepted; otherwise it will be rejected and it
         * returns <code>false</code>.
         * 
         * @param envelope
         *            the map area (world coordinates) to be rendered.
         * @param graphics
         *            the graphics object to draw on.
         * @param paintArea
         *            size of the area to paint the world into.
         * @param worldToScreen
         *            the {@link AffineTransform} from world coordinates to screen
         *            coordinates.
         * @param renderer
         *            the {@link GTRenderer} to use.
         * 
         * @return true if the rendering task was accepted; false if it was rejected
         */
        public synchronized boolean submit(ReferencedEnvelope envelope,
                        Rectangle paintArea, Graphics2D graphics,
                        final GTRenderer renderer, AffineTransform worldToScreen) {
                if (renderThread == null || !renderThread.isAlive()) {
                        // System.out.println("is vacant... starting thread!");
                        renderThread = null;

                        renderThread = new RenderThread(paintArea, graphics, renderer,
                                        worldToScreen);
                        renderThread.start();

                        return true;
                } else {
                        // System.out.println("is busy... requesting stop!");
                        renderThread.getRenderer().stopRendering();
                        return false;
                }
        }

        /**
         * For every new rendering job submitted and accepted, an instance of this
         * {@link Thread} will be started.
         * 
         */
        class RenderThread extends Thread {

                private final GTRenderer renderer;

                public RenderThread(final Rectangle paintArea,
                                final Graphics2D graphics, GTRenderer renderer,
                                AffineTransform worldToScreen) {
                        super(new RenderRun(paintArea, graphics, renderer, worldToScreen));
                        this.renderer = renderer;

                        setName("Render" + getName());

                        // System.out.println("starting render thread " + getName());
                }

                public GTRenderer getRenderer() {
                        return renderer;
                }

        }

        /**
         * This {@link Runnable} will actually start the rendering
         */
        class RenderRun implements Runnable, RenderListener {
                private final Rectangle paintArea;
                private final Graphics2D graphics;
                private final AffineTransform worldToScreen;
                private final GTRenderer renderer;

                public RenderRun(Rectangle paintArea, Graphics2D graphics,
                                GTRenderer renderer, AffineTransform worldToScreen) {
                        this.paintArea = paintArea;
                        this.graphics = graphics;
                        this.renderer = renderer;
                        this.worldToScreen = worldToScreen;
                }

                @Override
                public void run() {
                        try {
                                renderer.addRenderListener(this);
                                System.out.println("start rendering...");
                                // try {
                                // Thread.sleep(1000);
                                // } catch (InterruptedException e) {
                                // e.printStackTrace();
                                // }

                                // Clear the graphics context
                                graphics.setBackground(mapPane.getMapBackgroundColor());
                                graphics.clearRect(paintArea.x, paintArea.y, paintArea.width,
                                                paintArea.height);

                                renderer.paint(graphics, paintArea, worldToScreen);

                                // Invoked later, so when onRenderingCompleted is called, the Thread is not running anymore (#isRunning = false)
                                SwingUtilities.invokeLater(new Runnable() {
                                        @Override
                                        public void run() {
                                                mapPane.onRenderingCompleted();
                                        };
                                });
                        } finally {
                                renderer.removeRenderListener(this);
                        }
                }

                @Override
                public void errorOccurred(Exception e) {
                        // System.out.println("rendering error");
                        mapPane.onRenderingFailed(e);
                }

                @Override
                public void featureRenderer(SimpleFeature feature) {
                }

        }

        /**
         * Ask to stop the rendering. May be called often.
         */
        public void cancelTask() {
                if (renderThread != null && renderThread.isAlive()) {
                        // System.out.println("request stop for thread " +task.getName());
                        renderThread.getRenderer().stopRendering();
                }
        }

        /**
         * @return <code>true</code> if the {@link Thread} is busy rendering.
         */
        public boolean isRunning() {
                // if (task != null)
                // System.out.println("is running "+task.getName()+" = true");
                return (renderThread != null && renderThread.isAlive());
        }

        /**
         * Will stop rendering and remove the reference to the {@link Thread}.
         */
        public void dispose() {
                if (renderThread != null) {
                        renderThread.renderer.stopRendering();
                        renderThread = null;
                }
        }

}
1	package skrueger.geotools;
2
3	import java.awt.Graphics2D;
4	import java.awt.Rectangle;
5	import java.awt.geom.AffineTransform;
6
7	import javax.swing.SwingUtilities;
8
9	import org.geotools.geometry.jts.ReferencedEnvelope;
10	import org.geotools.renderer.GTRenderer;
11	import org.geotools.renderer.RenderListener;
12	import org.opengis.feature.simple.SimpleFeature;
13
14	import schmitzm.swing.SwingUtil;
15
16	/**
17	* This class is used by {@link XMapPane} to start and stop the rendering a
18	* {@link Thread} for rendering.
19	*/
20	class RenderingExecutor {
21
22	/**
23	* Instance to a {@link RenderThread} doing any work. It's volatile so the
24	* correct value will always be visible to any {@link Thread}
25	**/
26	private volatile RenderThread renderThread;
27
28	private final XMapPane mapPane;
29
30	public RenderingExecutor(XMapPane mapPane) {
31	this.mapPane = mapPane;
32	}
33
34	/**
35	* Submit a new rendering task. If no rendering task is presently running
36	* this new job will be accepted; otherwise it will be rejected and it
37	* returns <code>false</code>.
38	*
39	* @param envelope
40	* the map area (world coordinates) to be rendered.
41	* @param graphics
42	* the graphics object to draw on.
43	* @param paintArea
44	* size of the area to paint the world into.
45	* @param worldToScreen
46	* the {@link AffineTransform} from world coordinates to screen
47	* coordinates.
48	* @param renderer
49	* the {@link GTRenderer} to use.
50	*
51	* @return true if the rendering task was accepted; false if it was rejected
52	*/
53	public synchronized boolean submit(ReferencedEnvelope envelope,
54	Rectangle paintArea, Graphics2D graphics,
55	final GTRenderer renderer, AffineTransform worldToScreen) {
56	if (renderThread == null \|\| !renderThread.isAlive()) {
57	// System.out.println("is vacant... starting thread!");
58	renderThread = null;
59
60	renderThread = new RenderThread(paintArea, graphics, renderer,
61	worldToScreen);
62	renderThread.start();
63
64	return true;
65	} else {
66	// System.out.println("is busy... requesting stop!");
67	renderThread.getRenderer().stopRendering();
68	return false;
69	}
70	}
71
72	/**
73	* For every new rendering job submitted and accepted, an instance of this
74	* {@link Thread} will be started.
75	*
76	*/
77	class RenderThread extends Thread {
78
79	private final GTRenderer renderer;
80
81	public RenderThread(final Rectangle paintArea,
82	final Graphics2D graphics, GTRenderer renderer,
83	AffineTransform worldToScreen) {
84	super(new RenderRun(paintArea, graphics, renderer, worldToScreen));
85	this.renderer = renderer;
86
87	setName("Render" + getName());
88
89	// System.out.println("starting render thread " + getName());
90	}
91
92	public GTRenderer getRenderer() {
93	return renderer;
94	}
95
96	}
97
98	/**
99	* This {@link Runnable} will actually start the rendering
100	*/
101	class RenderRun implements Runnable, RenderListener {
102	private final Rectangle paintArea;
103	private final Graphics2D graphics;
104	private final AffineTransform worldToScreen;
105	private final GTRenderer renderer;
106
107	public RenderRun(Rectangle paintArea, Graphics2D graphics,
108	GTRenderer renderer, AffineTransform worldToScreen) {
109	this.paintArea = paintArea;
110	this.graphics = graphics;
111	this.renderer = renderer;
112	this.worldToScreen = worldToScreen;
113	}
114
115	@Override
116	public void run() {
117	try {
118	renderer.addRenderListener(this);
119	System.out.println("start rendering...");
120	// try {
121	// Thread.sleep(1000);
122	// } catch (InterruptedException e) {
123	// e.printStackTrace();
124	// }
125
126	// Clear the graphics context
127	graphics.setBackground(mapPane.getMapBackgroundColor());
128	graphics.clearRect(paintArea.x, paintArea.y, paintArea.width,
129	paintArea.height);
130
131	renderer.paint(graphics, paintArea, worldToScreen);
132
133	// Invoked later, so when onRenderingCompleted is called, the Thread is not running anymore (#isRunning = false)
134	SwingUtilities.invokeLater(new Runnable() {
135	@Override
136	public void run() {
137	mapPane.onRenderingCompleted();
138	};
139	});
140	} finally {
141	renderer.removeRenderListener(this);
142	}
143	}
144
145	@Override
146	public void errorOccurred(Exception e) {
147	// System.out.println("rendering error");
148	mapPane.onRenderingFailed(e);
149	}
150
151	@Override
152	public void featureRenderer(SimpleFeature feature) {
153	}
154
155	}
156
157	/**
158	* Ask to stop the rendering. May be called often.
159	*/
160	public void cancelTask() {
161	if (renderThread != null && renderThread.isAlive()) {
162	// System.out.println("request stop for thread " +task.getName());
163	renderThread.getRenderer().stopRendering();
164	}
165	}
166
167	/**
168	* @return <code>true</code> if the {@link Thread} is busy rendering.
169	*/
170	public boolean isRunning() {
171	// if (task != null)
172	// System.out.println("is running "+task.getName()+" = true");
173	return (renderThread != null && renderThread.isAlive());
174	}
175
176	/**
177	* Will stop rendering and remove the reference to the {@link Thread}.
178	*/
179	public void dispose() {
180	if (renderThread != null) {
181	renderThread.renderer.stopRendering();
182	renderThread = null;
183	}
184	}
185
186	}