/[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 533 by alfonx, Thu Nov 19 17:27:01 2009 UTC branches/2.0-RC1/src/skrueger/geotools/RenderingExecutor.java revision 604 by alfonx, Wed Dec 9 14:15:53 2009 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;
# Line 14  import org.opengis.feature.simple.Simple Line 15  import org.opengis.feature.simple.Simple
15   * {@link Thread} for rendering.   * {@link Thread} for rendering.
16   */   */
17  class RenderingExecutor {  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           * Instance to a {@link RenderThread} doing any work. It's volatile so the
21           * 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 48  class RenderingExecutor {
48           * @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
49           */           */
50          public synchronized boolean submit(ReferencedEnvelope envelope,          public synchronized boolean submit(ReferencedEnvelope envelope,
51                          Rectangle paintArea, Graphics2D graphics,                          Rectangle paintArea, Graphics2D graphics, final GTRenderer renderer
52                          final GTRenderer renderer, AffineTransform worldToScreen) {          // , AffineTransform worldToScreen
53            ) {
54                  if (renderThread == null || !renderThread.isAlive()) {                  if (renderThread == null || !renderThread.isAlive()) {
55                          // System.out.println("is vacant... starting thread!");                          // System.out.println("is vacant... starting thread!");
56                          renderThread = null;                          renderThread = null;
57    
58                          renderThread = new RenderThread(paintArea, graphics, renderer,                          renderThread = new RenderThread(paintArea, graphics, renderer,
59                                          worldToScreen, envelope);                          // worldToScreen,
60                                            envelope);
61                          renderThread.start();                          renderThread.start();
62    
63                          return true;                          return true;
# Line 76  class RenderingExecutor { Line 79  class RenderingExecutor {
79    
80                  public RenderThread(final Rectangle paintArea,                  public RenderThread(final Rectangle paintArea,
81                                  final Graphics2D graphics, GTRenderer renderer,                                  final Graphics2D graphics, GTRenderer renderer,
82                                  AffineTransform worldToScreen, ReferencedEnvelope mapEnv) {                                  // AffineTransform worldToScreen,
83                          super(new RenderRun(paintArea, graphics, renderer, mapEnv, worldToScreen));                                  ReferencedEnvelope mapEnv) {
84                            super(new RenderRun(paintArea, graphics, renderer, mapEnv
85                            // , worldToScreen
86                                            ));
87                          this.renderer = renderer;                          this.renderer = renderer;
88    
89                          setName("Render" + getName());                          setName("Render" + getName());
# Line 97  class RenderingExecutor { Line 103  class RenderingExecutor {
103          class RenderRun implements Runnable, RenderListener {          class RenderRun implements Runnable, RenderListener {
104                  private final Rectangle paintArea;                  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;                  private final ReferencedEnvelope mapEnv;
109    
110                  public RenderRun(Rectangle paintArea, Graphics2D graphics,                  public RenderRun(Rectangle paintArea, Graphics2D graphics,
111                                  GTRenderer renderer, ReferencedEnvelope mapEnv, AffineTransform worldToScreen) {                                  GTRenderer renderer, ReferencedEnvelope mapEnv
112                    // ,
113                    // AffineTransform worldToScreen
114                    ) {
115                          this.paintArea = paintArea;                          this.paintArea = paintArea;
116                          this.graphics = graphics;                          this.graphics = graphics;
117                          this.renderer = renderer;                          this.renderer = renderer;
118                          this.mapEnv = mapEnv;                          this.mapEnv = mapEnv;
119                          this.worldToScreen = worldToScreen;                          // this.worldToScreen = worldToScreen;
120                  }                  }
121    
122                  @Override                  @Override
123                  public void run() {                  public void run() {
124                          try {                          try {
125                                  renderer.addRenderListener(this);                                  renderer.addRenderListener(this);
126                                  System.out.println("start rendering...");                                  LOGGER.debug("start rendering...");
                                 // try {  
                                 // Thread.sleep(1000);  
                                 // } catch (InterruptedException e) {  
                                 // e.printStackTrace();  
                                 // }  
127    
128                                  // Clear the graphics context                                  // Clear the graphics context
129                                  graphics.setBackground(mapPane.getMapBackgroundColor());                                  graphics.setBackground(mapPane.getMapBackgroundColor());
130                                  graphics.clearRect(paintArea.x, paintArea.y, paintArea.width,                                  graphics.clearRect(paintArea.x, paintArea.y, paintArea.width,
131                                                  paintArea.height);                                                  paintArea.height);
132    
133                                  renderer.paint(graphics, paintArea, mapEnv, worldToScreen);                                  renderer.paint(graphics, paintArea, mapEnv);
134    
135                                  // Kill the reference to this Thread to #isRunning will def. say false                                  // Kill the reference to this Thread so #isRunning will say
136                                    // false directly
137                                  renderThread = null;                                  renderThread = null;
138                                  mapPane.onRenderingCompleted();                                  mapPane.onRenderingCompleted();
139                                                            } catch (Exception e) {
140                                    mapPane.onRenderingFailed(e);
141                          } finally {                          } finally {
142                                  renderer.removeRenderListener(this);                                  renderer.removeRenderListener(this);
143                          }                          }
# Line 152  class RenderingExecutor { Line 158  class RenderingExecutor {
158           * Ask to stop the rendering. May be called often.           * Ask to stop the rendering. May be called often.
159           */           */
160          public void cancelTask() {          public void cancelTask() {
161                  if (renderThread != null && renderThread.isAlive()) {                  if (renderThread != null)
162                          // System.out.println("request stop for thread " +task.getName());                          synchronized (renderThread) {
163                          renderThread.getRenderer().stopRendering();                                  if (renderThread.isAlive()) {
164                  }                                          if (renderThread.getRenderer() != null)
165                                                    renderThread.getRenderer().stopRendering();
166                                    }
167                            }
168          }          }
169    
170          /**          /**
171           * @return <code>true</code> if the {@link Thread} is busy rendering.           * @return <code>true</code> if the {@link Thread} is busy rendering.
172           */           */
173          public boolean isRunning() {          public boolean isRunning() {
                 // if (task != null)  
                 // System.out.println("is running "+task.getName()+" = true");  
174                  return (renderThread != null && renderThread.isAlive());                  return (renderThread != null && renderThread.isAlive());
175          }          }
176    
Legend:
Removed from v.533  
changed lines
  Added in v.604
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26