skrueger/geotools/RenderingExecutor.java

package skrueger.geotools;

import gtmig.org.geotools.swing.XMapPane;

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

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

public class RenderingExecutor {

        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 task will be accepted; otherwise it will be rejected (ie. there
         * is no task queue).
         * 
         * @param envelope
         *            the map area (world coordinates) to be rendered
         * @param graphics
         *            the graphics object to draw on
         * 
         * @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) {
                System.out.println("submit..:");
                if (renderThread == null || !renderThread.isAlive()) {
                        System.out.println("is vacant... starting thread!");

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

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

                return false;
        }

        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;

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

                public GTRenderer getRenderer() {
                        return renderer;
                }

        }

        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) {
                                        // TODO Auto-generated catch block
                                        e.printStackTrace();
                                }
                                renderer.paint(graphics, paintArea, worldToScreen);

                                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) {
                }

        }

        public void cancelTask() {
                if (renderThread != null && renderThread.isAlive()) {
                        // System.out.println("request stop for thread " +task.getName());
                        renderThread.getRenderer().stopRendering();
                }
        }

        public boolean isRunning() {
                // if (task != null)
                // System.out.println("is running "+task.getName()+" = true");
                return (renderThread != null && renderThread.isAlive());
        }

        public void dispose() {
                if (renderThread != null) {
                        renderThread.renderer.stopRendering();
                        renderThread = null;
                }
        }

}
1	package skrueger.geotools;
2
3	import gtmig.org.geotools.swing.XMapPane;
4
5	import java.awt.Graphics2D;
6	import java.awt.Rectangle;
7	import java.awt.geom.AffineTransform;
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	public class RenderingExecutor {
15
16	private volatile RenderThread renderThread;
17	private final XMapPane mapPane;
18
19	public RenderingExecutor(XMapPane mapPane) {
20	this.mapPane = mapPane;
21	}
22
23	/**
24	* Submit a new rendering task. If no rendering task is presently running
25	* this new task will be accepted; otherwise it will be rejected (ie. there
26	* is no task queue).
27	*
28	* @param envelope
29	* the map area (world coordinates) to be rendered
30	* @param graphics
31	* the graphics object to draw on
32	*
33	* @return true if the rendering task was accepted; false if it was rejected
34	*/
35	public synchronized boolean submit(ReferencedEnvelope envelope,
36	Rectangle paintArea, Graphics2D graphics,
37	final GTRenderer renderer, AffineTransform worldToScreen) {
38	System.out.println("submit..:");
39	if (renderThread == null \|\| !renderThread.isAlive()) {
40	System.out.println("is vacant... starting thread!");
41
42	renderThread = new RenderThread(paintArea, graphics, renderer,
43	worldToScreen);
44	renderThread.start();
45
46	return true;
47	} else {
48	System.out.println("is busy... requesting stop!");
49	renderThread.getRenderer().stopRendering();
50	}
51
52	return false;
53	}
54
55	class RenderThread extends Thread {
56
57	private final GTRenderer renderer;
58
59	public RenderThread(final Rectangle paintArea,
60	final Graphics2D graphics, GTRenderer renderer,
61	AffineTransform worldToScreen) {
62	super(new RenderRun(paintArea, graphics, renderer, worldToScreen));
63	this.renderer = renderer;
64
65	System.out.println("starting render thread " + getName());
66	}
67
68	public GTRenderer getRenderer() {
69	return renderer;
70	}
71
72	}
73
74	class RenderRun implements Runnable, RenderListener {
75	private final Rectangle paintArea;
76	private final Graphics2D graphics;
77	private final AffineTransform worldToScreen;
78	private final GTRenderer renderer;
79
80	public RenderRun(Rectangle paintArea, Graphics2D graphics,
81	GTRenderer renderer, AffineTransform worldToScreen) {
82	this.paintArea = paintArea;
83	this.graphics = graphics;
84	this.renderer = renderer;
85	this.worldToScreen = worldToScreen;
86	}
87
88	@Override
89	public void run() {
90	try {
91	renderer.addRenderListener(this);
92	System.out.println("start rendering...");
93	try {
94	Thread.sleep(1000);
95	} catch (InterruptedException e) {
96	// TODO Auto-generated catch block
97	e.printStackTrace();
98	}
99	renderer.paint(graphics, paintArea, worldToScreen);
100
101	mapPane.onRenderingCompleted();
102	} finally {
103	renderer.removeRenderListener(this);
104	}
105	}
106
107	@Override
108	public void errorOccurred(Exception e) {
109	// System.out.println("rendering error");
110	mapPane.onRenderingFailed(e);
111	}
112
113	@Override
114	public void featureRenderer(SimpleFeature feature) {
115	}
116
117	}
118
119	public void cancelTask() {
120	if (renderThread != null && renderThread.isAlive()) {
121	// System.out.println("request stop for thread " +task.getName());
122	renderThread.getRenderer().stopRendering();
123	}
124	}
125
126	public boolean isRunning() {
127	// if (task != null)
128	// System.out.println("is running "+task.getName()+" = true");
129	return (renderThread != null && renderThread.isAlive());
130	}
131
132	public void dispose() {
133	if (renderThread != null) {
134	renderThread.renderer.stopRendering();
135	renderThread = null;
136	}
137	}
138
139	}