/[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 544 by alfonx, Sat Nov 21 17:13:31 2009 UTC trunk/src/skrueger/geotools/RenderingExecutor.java revision 740 by alfonx, Wed Mar 3 10:32:14 2010 UTC
# Line 4  import java.awt.Graphics2D; Line 4  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    import schmitzm.geotools.gui.XMapPane;
14    
15  /**  /**
16   * This class is used by {@link XMapPane} to start and stop the rendering a   * This class is used by {@link XMapPane} to start and stop the rendering a
17   * {@link Thread} for rendering.   * {@link Thread} for rendering.
18   */   */
19  class RenderingExecutor {  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           * Instance to a {@link RenderThread} doing any work. It's volatile so the
23           * correct value will always be visible to any {@link Thread}           * correct value will always be visible to any {@link Thread}
# Line 47  class RenderingExecutor { Line 50  class RenderingExecutor {
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
55  //                      , AffineTransform worldToScreen          ) {
                         ) {  
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;                          renderThread = null;
59    
60                          renderThread = new RenderThread(paintArea, graphics, renderer,                          renderThread = new RenderThread(paintArea, graphics, renderer,
61  //                                      worldToScreen,                          // worldToScreen,
62                                          envelope);                                          envelope);
63                          renderThread.start();                          renderThread.start();
64    
# Line 79  class RenderingExecutor { Line 81  class RenderingExecutor {
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                                  ReferencedEnvelope mapEnv) {                                  ReferencedEnvelope mapEnv) {
86                          super(new RenderRun(paintArea, graphics, renderer,                          super(new RenderRun(paintArea, graphics, renderer, mapEnv
87                                          mapEnv                          // , worldToScreen
 //                                      ,                                       worldToScreen  
88                                          ));                                          ));
89                          this.renderer = renderer;                          this.renderer = renderer;
90    
# Line 104  class RenderingExecutor { Line 105  class RenderingExecutor {
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;                  private final ReferencedEnvelope mapEnv;
111    
112                  public RenderRun(Rectangle paintArea, Graphics2D graphics,                  public RenderRun(Rectangle paintArea, Graphics2D graphics,
113                                  GTRenderer renderer, ReferencedEnvelope mapEnv                                  GTRenderer renderer, ReferencedEnvelope mapEnv
114  //                              ,                  // ,
115  //                              AffineTransform worldToScreen                  // 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.mapEnv = mapEnv;                          this.mapEnv = mapEnv;
121  //                      this.worldToScreen = worldToScreen;                          // 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) {  
                                 // e.printStackTrace();  
                                 // }  
130    
131                                  // Clear the graphics context                                  // Clear the graphics context
132                                  graphics.setBackground(mapPane.getMapBackgroundColor());                                  graphics.setBackground(mapPane.getMapBackgroundColor());
# Line 141  class RenderingExecutor { Line 138  class RenderingExecutor {
138                                  // Kill the reference to this Thread so #isRunning will say                                  // Kill the reference to this Thread so #isRunning will say
139                                  // false directly                                  // false directly
140                                  renderThread = null;                                  renderThread = null;
141                                  mapPane.onRenderingCompleted();                                  mapPane.onRenderingCompleted(System.currentTimeMillis()-startT);
142                          } catch (Exception e) {                          } catch (Exception e) {
143                                  mapPane.onRenderingFailed(e);                                  mapPane.onRenderingFailed(e);
144                          } finally {                          } finally {
# Line 164  class RenderingExecutor { Line 161  class RenderingExecutor {
161           * Ask to stop the rendering. May be called often.           * 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          /**          /**
Legend:
Removed from v.544  
changed lines
  Added in v.740
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26