skrueger/geotools/RenderingExecutor.java

package skrueger.geotools;

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

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

import schmitzm.geotools.gui.XMapPane;

/**
 * This class is used by {@link XMapPane} to start and stop the rendering a
 * {@link Thread} for rendering.
 */
public class RenderingExecutor {
        private final static Logger LOGGER = Logger.getLogger(RenderingExecutor.class);
        /**
         * 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,
                                        envelope);
                        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,
                                ReferencedEnvelope mapEnv) {
                        super(new RenderRun(paintArea, graphics, renderer, mapEnv
                        // , 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;
                private final ReferencedEnvelope mapEnv;

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

                @Override
                public void run() {
                        long startT = System.currentTimeMillis();
                        try {
                                renderer.addRenderListener(this);
//                              LOGGER.debug("start rendering...");

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

                                renderer.paint(graphics, paintArea, mapEnv);

                                // Kill the reference to this Thread so #isRunning will say
                                // false directly
                                renderThread = null;
                                mapPane.onRenderingCompleted(System.currentTimeMillis()-startT);
                        } catch (Exception e) {
                                mapPane.onRenderingFailed(e);
                        } finally {
                                renderer.removeRenderListener(this);
                        }
                }

                @Override
                public void errorOccurred(Exception e) {
                        mapPane.onRenderingFailed(e);
                }

                @Override
                public void featureRenderer(SimpleFeature feature) {
                }

        }

        /**
         * Ask to stop the rendering. May be called often.
         */
        public void cancelTask() {
                if (renderThread != null)
                        synchronized (renderThread) {
                                if (renderThread.isAlive()) {
                                        if (renderThread.getRenderer() != null)
                                                renderThread.getRenderer().stopRendering();
                                }
                        }
        }

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