/[schmitzm]/branches/2.0-GP14/src/skrueger/geotools/RenderingExecutor.java
ViewVC logotype

Diff of /branches/2.0-GP14/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 530 by alfonx, Thu Nov 19 09:31:14 2009 UTC
# Line 2  package skrueger.geotools; Line 2  package skrueger.geotools;
2    
3  import gtmig.org.geotools.swing.XMapPane;  import gtmig.org.geotools.swing.XMapPane;
4    
 import java.awt.AlphaComposite;  
 import java.awt.Color;  
 import java.awt.Composite;  
5  import java.awt.Graphics2D;  import java.awt.Graphics2D;
6  import java.awt.Rectangle;  import java.awt.Rectangle;
7  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;  
8    
9  import org.geotools.geometry.jts.ReferencedEnvelope;  import org.geotools.geometry.jts.ReferencedEnvelope;
10  import org.geotools.renderer.GTRenderer;  import org.geotools.renderer.GTRenderer;
11  import org.geotools.renderer.RenderListener;  import org.geotools.renderer.RenderListener;
 import org.geotools.swing.JMapPane;  
12  import org.opengis.feature.simple.SimpleFeature;  import org.opengis.feature.simple.SimpleFeature;
13    
14  public class RenderingExecutor {  public class RenderingExecutor {
15    
16  private volatile RenderThread task;          private volatile RenderThread renderThread;
17  private final XMapPane mapPane;          private final XMapPane mapPane;
18    
19          public RenderingExecutor(XMapPane mapPane) {          public RenderingExecutor(XMapPane mapPane) {
20                  this.mapPane = mapPane;                  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       * Submit a new rendering task. If no rendering task is presently running                                  final Graphics2D graphics, GTRenderer renderer,
61       * this new task will be accepted; otherwise it will be rejected (ie. there                                  AffineTransform worldToScreen) {
62       * is no task queue).                          super(new RenderRun(paintArea, graphics, renderer, 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;  
63                          this.renderer = renderer;                          this.renderer = renderer;
64  //                      this.worldToScreen = worldToScreen;  
65                                                    System.out.println("starting render thread " + getName());
                         System.out.println("starting render thread "+getName());  
66                  }                  }
67            
68          public GTRenderer getRenderer() {                  public GTRenderer getRenderer() {
69                          return renderer;                          return renderer;
70                  }                  }
71    
72      }          }
73        
74      class RenderRun implements Runnable, RenderListener  {          class RenderRun implements Runnable, RenderListener {
75          private final Rectangle paintArea;                  private final Rectangle paintArea;
76                  private final Graphics2D graphics;                  private final Graphics2D graphics;
77                  private final AffineTransform worldToScreen;                  private final AffineTransform worldToScreen;
78                  private final GTRenderer renderer;                  private final GTRenderer renderer;
79    
80                  public RenderRun(Rectangle paintArea, Graphics2D graphics,                  public RenderRun(Rectangle paintArea, Graphics2D graphics,
81                                  GTRenderer renderer, AffineTransform worldToScreen) {                                  GTRenderer renderer, AffineTransform worldToScreen) {
82                                          this.paintArea = paintArea;                          this.paintArea = paintArea;
83                                          this.graphics = graphics;                          this.graphics = graphics;
84                                          this.renderer = renderer;                          this.renderer = renderer;
85                                          this.worldToScreen = worldToScreen;                          this.worldToScreen = worldToScreen;
86                  }                  }
87    
88                  @Override                  @Override
89                  public void run() {                  public void run() {
90                          try {                          try {
91                          renderer.addRenderListener(this);                                  renderer.addRenderListener(this);
92                          System.out.println("start rendering...");                                  System.out.println("start rendering...");
93                          try {                                  try {
94                                          Thread.sleep(1000);                                          Thread.sleep(1000);
95                                  } catch (InterruptedException e) {                                  } catch (InterruptedException e) {
96                                          // TODO Auto-generated catch block                                          // TODO Auto-generated catch block
97                                          e.printStackTrace();                                          e.printStackTrace();
98                                  }                                  }
99                          renderer.paint(graphics, paintArea, worldToScreen);                                  renderer.paint(graphics, paintArea, worldToScreen);
100                            
101                          mapPane.onRenderingCompleted();                                  mapPane.onRenderingCompleted();
102                  } finally {                          } finally {
103                          renderer.removeRenderListener(this);                                  renderer.removeRenderListener(this);
104                  }                          }
105                  }                  }
106    
107                  @Override                  @Override
108                  public void errorOccurred(Exception e) {                  public void errorOccurred(Exception e) {
109  //                      System.out.println("rendering error");                          // System.out.println("rendering error");
110                          mapPane.onRenderingFailed(e);                          mapPane.onRenderingFailed(e);
111                  }                  }
112    
113                  @Override                  @Override
114                  public void featureRenderer(SimpleFeature feature) {                  public void featureRenderer(SimpleFeature feature) {
115                  }                  }
116            
117      }          }
118    
119          public void cancelTask() {          public void cancelTask() {
120                  if (task!=null && task.isAlive()) {                  if (renderThread != null && renderThread.isAlive()) {
121  //                      System.out.println("request stop for thread " +task.getName());                          // System.out.println("request stop for thread " +task.getName());
122                          task.getRenderer().stopRendering();                          renderThread.getRenderer().stopRendering();
123                  }                  }
124          }          }
125    
126          public boolean isRunning() {          public boolean isRunning() {
127  //              if (task != null)                  // if (task != null)
128  //                      System.out.println("is running "+task.getName()+" = true");                  // System.out.println("is running "+task.getName()+" = true");
129                  return (task != null && task.isAlive());                  return (renderThread != null && renderThread.isAlive());
130          }          }
131    
132          public void dispose() {          public void dispose() {
133                  if (task != null) {                  if (renderThread != null) {
134                          task.renderer.stopRendering();                          renderThread.renderer.stopRendering();
135                          task = null;                          renderThread = null;
136                  }                  }
137          }          }
       
138    
139  }  }
   
Legend:
Removed from v.529  
changed lines
  Added in v.530
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26