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