/[schmitzm]/branches/2.3.KECK/src/skrueger/geotools/RenderingExecutor.java
ViewVC logotype

Diff of /branches/2.3.KECK/src/skrueger/geotools/RenderingExecutor.java

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

branches/1.0-gt2-2.6/src/skrueger/geotools/RenderingExecutor.java revision 530 by alfonx, Thu Nov 19 09:31:14 2009 UTC branches/2.3.KECK/src/skrueger/geotools/RenderingExecutor.java revision 1103 by alfonx, Thu Oct 14 09:45:14 2010 UTC
# Line 1  Line 1 
1  package skrueger.geotools;  package skrueger.geotools;
2    
 import gtmig.org.geotools.swing.XMapPane;  
   
3  import java.awt.Graphics2D;  import java.awt.Graphics2D;
4  import java.awt.Rectangle;  import java.awt.Rectangle;
5  import java.awt.geom.AffineTransform;  import java.awt.geom.AffineTransform;
6    
7    import org.apache.log4j.Logger;
8  import org.geotools.geometry.jts.ReferencedEnvelope;  import org.geotools.geometry.jts.ReferencedEnvelope;
9  import org.geotools.renderer.GTRenderer;  import org.geotools.renderer.GTRenderer;
10  import org.geotools.renderer.RenderListener;  import org.geotools.renderer.RenderListener;
11  import org.opengis.feature.simple.SimpleFeature;  import org.opengis.feature.simple.SimpleFeature;
12    
13  public class RenderingExecutor {  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;          private volatile RenderThread renderThread;
26    
27          private final XMapPane mapPane;          private final XMapPane mapPane;
28    
29          public RenderingExecutor(XMapPane mapPane) {          public RenderingExecutor(XMapPane mapPane) {
# Line 22  public class RenderingExecutor { Line 32  public class RenderingExecutor {
32    
33          /**          /**
34           * Submit a new rendering task. If no rendering task is presently running           * Submit a new rendering task. If no rendering task is presently running
35           * this new task will be accepted; otherwise it will be rejected (ie. there           * this new job will be accepted; otherwise it will be rejected and it
36           * is no task queue).           * returns <code>false</code>.
37           *           *
38           * @param envelope           * @param envelope
39           *            the map area (world coordinates) to be rendered           *            the map area (world coordinates) to be rendered.
40           * @param graphics           * @param graphics
41           *            the graphics object to draw on           *            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           * @return true if the rendering task was accepted; false if it was rejected
51           */           */
52          public synchronized boolean submit(ReferencedEnvelope envelope,          public synchronized boolean submit(ReferencedEnvelope envelope,
53                          Rectangle paintArea, Graphics2D graphics,                          Rectangle paintArea, Graphics2D graphics, final GTRenderer renderer
54                          final GTRenderer renderer, AffineTransform worldToScreen) {          // , AffineTransform worldToScreen
55                  System.out.println("submit..:");          ) {
56                  if (renderThread == null || !renderThread.isAlive()) {                  if (renderThread == null || !renderThread.isAlive()) {
57                          System.out.println("is vacant... starting thread!");                          // System.out.println("is vacant... starting thread!");
58                            renderThread = null;
59    
60                          renderThread = new RenderThread(paintArea, graphics, renderer,                          renderThread = new RenderThread(paintArea, graphics, renderer,
61                                          worldToScreen);                          // worldToScreen,
62                                            envelope);
63                          renderThread.start();                          renderThread.start();
64    
65                          return true;                          return true;
66                  } else {                  } else {
67                          System.out.println("is busy... requesting stop!");                          // System.out.println("is busy... requesting stop!");
68                          renderThread.getRenderer().stopRendering();                          renderThread.getRenderer().stopRendering();
69                            return false;
70                  }                  }
   
                 return false;  
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 {          class RenderThread extends Thread {
79    
80                  private final GTRenderer renderer;                  private final GTRenderer renderer;
81    
82                  public RenderThread(final Rectangle paintArea,                  public RenderThread(final Rectangle paintArea,
83                                  final Graphics2D graphics, GTRenderer renderer,                                  final Graphics2D graphics, GTRenderer renderer,
84                                  AffineTransform worldToScreen) {                                  // AffineTransform worldToScreen,
85                          super(new RenderRun(paintArea, graphics, renderer, worldToScreen));                                  ReferencedEnvelope mapEnv) {
86                            super(new RenderRun(paintArea, graphics, renderer, mapEnv
87                            // , worldToScreen
88                                            ));
89                          this.renderer = renderer;                          this.renderer = renderer;
90    
91                          System.out.println("starting render thread " + getName());                          setName("Render" + getName());
92    
93                            // System.out.println("starting render thread " + getName());
94                  }                  }
95    
96                  public GTRenderer getRenderer() {                  public GTRenderer getRenderer() {
# Line 71  public class RenderingExecutor { Line 99  public class RenderingExecutor {
99    
100          }          }
101    
102            /**
103             * This {@link Runnable} will actually start the rendering
104             */
105          class RenderRun implements Runnable, RenderListener {          class RenderRun implements Runnable, RenderListener {
106                  private final Rectangle paintArea;                  private final Rectangle paintArea;
107                  private final Graphics2D graphics;                  private final Graphics2D graphics;
108                  private final AffineTransform worldToScreen;                  // private final AffineTransform worldToScreen;
109                  private final GTRenderer renderer;                  private final GTRenderer renderer;
110                    private final ReferencedEnvelope mapEnv;
111    
112                  public RenderRun(Rectangle paintArea, Graphics2D graphics,                  public RenderRun(Rectangle paintArea, Graphics2D graphics,
113                                  GTRenderer renderer, AffineTransform worldToScreen) {                                  GTRenderer renderer, ReferencedEnvelope mapEnv
114                    // ,
115                    // AffineTransform worldToScreen
116                    ) {
117                          this.paintArea = paintArea;                          this.paintArea = paintArea;
118                          this.graphics = graphics;                          this.graphics = graphics;
119                          this.renderer = renderer;                          this.renderer = renderer;
120                          this.worldToScreen = worldToScreen;                          this.mapEnv = mapEnv;
121                            // this.worldToScreen = worldToScreen;
122                  }                  }
123    
124                  @Override                  @Override
125                  public void run() {                  public void run() {
126                            long startT = System.currentTimeMillis();
127                          try {                          try {
128                                  renderer.addRenderListener(this);                                  renderer.addRenderListener(this);
129                                  System.out.println("start rendering...");  //                              LOGGER.debug("start rendering...");
                                 try {  
                                         Thread.sleep(1000);  
                                 } catch (InterruptedException e) {  
                                         // TODO Auto-generated catch block  
                                         e.printStackTrace();  
                                 }  
                                 renderer.paint(graphics, paintArea, worldToScreen);  
130    
131                                  mapPane.onRenderingCompleted();                                  // 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 {                          } finally {
145                                  renderer.removeRenderListener(this);                                  renderer.removeRenderListener(this);
146                          }                          }
# Line 106  public class RenderingExecutor { Line 148  public class RenderingExecutor {
148    
149                  @Override                  @Override
150                  public void errorOccurred(Exception e) {                  public void errorOccurred(Exception e) {
                         // System.out.println("rendering error");  
151                          mapPane.onRenderingFailed(e);                          mapPane.onRenderingFailed(e);
152                  }                  }
153    
# Line 116  public class RenderingExecutor { Line 157  public class RenderingExecutor {
157    
158          }          }
159    
160            /**
161             * Ask to stop the rendering. May be called often.
162             */
163          public void cancelTask() {          public void cancelTask() {
164                  if (renderThread != null && renderThread.isAlive()) {                  if (renderThread != null)
165                          // System.out.println("request stop for thread " +task.getName());                          synchronized (renderThread) {
166                          renderThread.getRenderer().stopRendering();                                  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() {          public boolean isRunning() {
                 // if (task != null)  
                 // System.out.println("is running "+task.getName()+" = true");  
177                  return (renderThread != null && renderThread.isAlive());                  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() {          public void dispose() {
184                  if (renderThread != null) {                  if (renderThread != null) {
185                          renderThread.renderer.stopRendering();                          renderThread.renderer.stopRendering();
Legend:
Removed from v.530  
changed lines
  Added in v.1103
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26