/[schmitzm]/branches/2.4.x/src/skrueger/geotools/RenderingExecutor.java
ViewVC logotype

Diff of /branches/2.4.x/src/skrueger/geotools/RenderingExecutor.java

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

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