[no subject]

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index] [List Home]
[no subject]
An/listinfo/udig-dev">https: //locationtech.org/mailman/listinfo/udig-dev<= </blockquote> </body>
Delivered-to: udig-dev@xxxxxxxxxxxxxxxx
Ech.org/mailman/listinfo/udig-dev">https: //locationtech.org/mailman/listi= ________________________________ IBYKUS AG f=FCr Informationstechnologie, Erfurt / HRB 108616 - D-Jena / Vorstand: Helmut C. Henkel, Dr. Lutz Richter Vorsitzender des Aufsichtsrates: Dr. Wolfgang Habel _______________________________________________<b= udig-dev mailing list <a moz-do-not-send=3D"true" href=3D"mailto:udig-dev@xxxxxxxxxxxxxxxx" target=3D"_blank">udig-dev@xxxxxxxxxxxxxxxx</a>= To change your delivery options, retrieve your password, or unsubscribe from this list, visit<br= <a moz-do-not-send=3D"true" href=3D"https://locationtech.org/mailman/listin= rel=3D"noreferrer" target=3D"_blank">https://lo= . </blockquote> _______________________________________________ udig-dev mailing list <a moz-do-not-send=3D"true" href=3D"mailto:udig-dev@xxxxxxxxxxxxxxxx" target=3D"_blank">udig-dev@xxxxxxxxxxxxxxxx</a><b= To change your delivery options, retrieve your password, or unsubscribe from this list, visit <a moz-do-not-send=3D"true" href=3D"https://locationtech.org/mailman/listinfo= rel=3D"noreferrer" target=3D"_blank">https://loca= ________________________________ IBYKUS AG f=FCr Informationstechnologie, Erfurt / HRB 108616 - D-Jena / Vorstand: Helmut C. Henkel, Dr. Lutz Richter Vorsitzender des Aufsichtsrates: Dr. Wolfgang Habel _______________________________________________ udig-dev mailing list <a moz-do-not-send=3D"true" href=3D"mailto:udig-dev@xxxxxxxxxxxxxxxx" target=3D"_blank">udig-dev@xxxxxxxxxxxxxxxx</a><b= To change your delivery options, retrieve your password, or unsubscribe from this list, visit <a moz-do-not-send=3D"true" href=3D"https://locationtech.org/mailman/listinfo= rel=3D"noreferrer" target=3D"_blank">https://loca= </div> </div> . </blockquote> _______________________________________________ udig-dev mailing list <a moz-do-not-send=3D"true" href=3D"mailto:udig-dev@xxxxxxxxxxxxxxxx">udig-dev@loca= To change your delivery options, retrieve your password, or unsubscribe from this list, visit <a moz-do-not-send=3D"true" href=3D"https://locationtech.org/mailman/listinfo/udig-= rel=3D"noreferrer" target=3D"_blank">https://locationte= </blockquote> </div> </div> <fieldset class=3D"mimeAttachmentHeader"></fieldset> <pre wrap=3D"">_______________________________________________
Ilto: udig-dev@xxxxxxxxxxxxxxxx">udig-dev@xxxxxxxxxxxxxxxx</a> </blockquote> <fieldset class=3D"mimeAttachmentHeader"></fieldset> <pre wrap=3D"">_______________________________________________
Ilto: udig-dev@xxxxxxxxxxxxxxxx">udig-dev@xxxxxxxxxxxxxxxx</a> </blockquote> <fieldset class=3D"mimeAttachmentHeader"></fieldset> <pre wrap=3D"">_______________________________________________
--------------010006090801010406040100
Content-Type: text/plain; charset=UTF-8;
 name="New-render-managet-implementation-with-queuebased-re.patch"
Content-Transfer-Encoding: 7bit
Content-Disposition: attachment;
 filename*0="New-render-managet-implementation-with-queuebased-re.patch"

diff --git a/plugins/org.locationtech.udig.project.ui/src/org/locationtech/udig/project/ui/internal/NextGenRenderManager.java b/plugins/org.locationtech.udig.project.ui/src/org/locationtech/udig/project/ui/internal/NextGenRenderManager.java
new file mode 100644
index 0000000..ee24a23
--- /dev/null
+++ b/plugins/org.locationtech.udig.project.ui/src/org/locationtech/udig/project/ui/internal/NextGenRenderManager.java
@@ -0,0 +1,1142 @@
+package org.locationtech.udig.project.ui.internal;
+
+import static org.locationtech.udig.project.ui.internal.Trace.RENDER;
+
+import java.awt.Color;
+import java.awt.Graphics2D;
+import java.awt.Rectangle;
+import java.awt.image.BufferedImage;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.concurrent.LinkedBlockingQueue;
+
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.Status;
+import org.eclipse.core.runtime.jobs.Job;
+import org.eclipse.emf.common.notify.Adapter;
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.geotools.geometry.jts.ReferencedEnvelope;
+import org.locationtech.udig.project.ILayer;
+import org.locationtech.udig.project.internal.ContextModelListenerAdapter;
+import org.locationtech.udig.project.internal.Layer;
+import org.locationtech.udig.project.internal.Map;
+import org.locationtech.udig.project.internal.ProjectPackage;
+import org.locationtech.udig.project.internal.ProjectPlugin;
+import org.locationtech.udig.project.internal.render.CompositeRenderContext;
+import org.locationtech.udig.project.internal.render.ExecutorVisitor;
+import org.locationtech.udig.project.internal.render.RenderContext;
+import org.locationtech.udig.project.internal.render.RenderExecutor;
+import org.locationtech.udig.project.internal.render.RenderPackage;
+import org.locationtech.udig.project.internal.render.SelectionLayer;
+import org.locationtech.udig.project.internal.render.impl.CompositeRenderContextImpl;
+import org.locationtech.udig.project.internal.render.impl.RenderExecutorComposite;
+import org.locationtech.udig.project.internal.render.impl.RenderExecutorMultiLayer;
+import org.locationtech.udig.project.internal.render.impl.RenderManagerImpl;
+import org.locationtech.udig.project.internal.render.impl.RenderTask;
+import org.locationtech.udig.project.internal.render.impl.RenderTaskType;
+import org.locationtech.udig.project.internal.render.impl.RendererConfigurator;
+import org.locationtech.udig.project.internal.render.impl.RootCompositeRenderExecutor;
+import org.locationtech.udig.project.internal.render.impl.RootCompositeRendererImpl;
+import org.locationtech.udig.project.render.IRenderContext;
+import org.locationtech.udig.project.render.IRenderer;
+import org.locationtech.udig.project.render.RenderException;
+import org.locationtech.udig.project.render.displayAdapter.IMapDisplay;
+import org.locationtech.udig.project.ui.render.displayAdapter.ViewportPane;
+
+import com.vividsolutions.jts.geom.Envelope;
+
+/**
+ * {@link RenderManagerDynamic} replacement with better synchronized concurrent logic based on
+ * rendering tasks queue and various optimizations.
+ * 
+ * @author vitalid
+ *
+ */
+public class NextGenRenderManager extends RenderManagerImpl {
+    
+    
+    /**
+     * Optimizes real multithreading requests by compressing
+     * {@link RenderTask}s into a single event that causes refreshing the map image.
+     * 
+     * @author vitalid
+     *
+     */
+    class RenderTaskCompressor{
+
+        static final int UNKNOWN = 0;
+        static final int REFRESH_ALL = 0x01;
+        static final int REFRESH_LAYERS = 0x01 << 1;
+        static final int REFRESH_SELECTION = 0x01 << 2;
+        static final int REFRESH_IMAGE_BUFFER = 0x01 << 3;
+
+        Envelope bounds;
+
+        List<ILayer> layers;
+        
+        SelectionLayer selectionLayer;
+
+        int refreshType = UNKNOWN;
+
+        RenderTaskCompressor(){
+        }
+
+        void compress(RenderTask task){
+
+            switch(task.getTaskType()){
+            case MAP_BOUNDS_CHANGED:
+                refreshType |= REFRESH_ALL;
+
+                break;
+            case LAYER_ADDED:
+            case LAYER_STATE_CHANGED:
+                refreshType |= REFRESH_LAYERS;
+                break;
+            case LAYER_SELECTION_CHANGED:
+                refreshType |= REFRESH_SELECTION;
+                break;
+            case LAYER_ZORDER_CHANGED:
+                refreshType |= REFRESH_LAYERS;
+                refreshType |= REFRESH_IMAGE_BUFFER;
+                break;
+            case LAYER_REMOVED:
+                refreshType |= REFRESH_LAYERS;
+                refreshType |= REFRESH_IMAGE_BUFFER;
+                break;
+
+            }
+
+        }
+        
+        void addRefreshingLayer(ILayer layer){
+            if(layers == null){
+                layers = new LinkedList<ILayer>();
+            }
+            layers.add(layer);
+        }
+        
+        void setSelectionLayer(SelectionLayer selectionLayer) {
+            this.selectionLayer = selectionLayer;
+        }
+        
+    }
+    
+    class RenderTaskQueueJob extends Job {
+        
+
+        private LinkedBlockingQueue<RenderTask> requests = new LinkedBlockingQueue<RenderTask>(); 
+
+        public RenderTaskQueueJob(){
+            super("RenderTaskQueueJob"); //$NON-NLS-1$
+            setPriority(INTERACTIVE);
+        }
+
+        protected void addRenderTask(RenderTask renderTask){
+            this.requests.add(renderTask);
+        }
+
+        @Override
+        protected IStatus run(IProgressMonitor monitor) {
+
+            int size = requests.size();
+            if(size == 0)
+                return Status.OK_STATUS;
+
+            try{
+
+                Collection<RenderContext> cachedRenderContexts = null;
+                RenderTaskCompressor taskCompressor =  new RenderTaskCompressor();
+                while(!requests.isEmpty()){
+                    
+                    if(monitor.isCanceled()){
+                        return Status.CANCEL_STATUS;
+                    }
+
+                    if(cachedRenderContexts == null){
+                        cachedRenderContexts = getRenderContexts();
+                    }
+                    //                List<RenderTask> liveRequests;
+                    //                synchronized(requests){
+                    //                    liveRequests = new ArrayList<RenderTask>(requests.size());
+                    //                    requests.drainTo(liveRequests);
+                    //                }
+
+                    RenderTask next = null;
+                    try {
+                        next = requests.take();
+                    } catch (InterruptedException e1) {
+                        // TODO Auto-generated catch block
+                        e1.printStackTrace();
+                        continue;//Bad request
+                    }
+                    taskCompressor.compress(next);
+
+                    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+                    // Compression
+                    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+                    RenderExecutor renderExecutor = getRenderExecutor();//Require lazy initialization
+                    RendererConfigurator configurator = getConfigurator();
+
+                    //                RenderTask task = null;
+                    //                for (RenderTask rt : liveRequests) {
+                    //                    if(task == null)
+                    //                        task = new RenderTask(rt);
+                    //                    else
+                    //                        if(!task.compress(rt)){
+                    //                            
+                    //                        }
+                    //                }
+
+
+                    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+                    // Sync with RendererConfigurator state.
+                    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+                    switch(next.getTaskType()){
+                    case MAP_BOUNDS_CHANGED:
+
+                        break;
+                    case LAYER_ADDED:
+                    case LAYER_REMOVED:
+                        configurator.update(next);
+                        break;
+
+                    default:
+
+                    }
+
+
+                    switch(next.getTaskType()){
+                    case MAP_BOUNDS_CHANGED:
+
+                        break;
+                    case LAYER_STATE_CHANGED:
+                    {
+                        for( ILayer layerToRender : next.getLayers() ) {
+                            taskCompressor.addRefreshingLayer(layerToRender);
+                        }
+                        break;
+                    }
+                    case LAYER_SELECTION_CHANGED:
+
+                        List<ILayer> layers = next.getLayers();
+                        final ILayer layer = layers.get(0);
+                        final Envelope bounds = next.getBounds();
+
+                        final SelectionLayer selectionLayer = configurator.findSelectionLayer(layer);
+                        taskCompressor.setSelectionLayer(selectionLayer);
+
+                        break;
+
+                    case LAYER_ADDED:
+                    {
+                        layers = next.getLayers();
+
+                        List<Layer> layersToRender = synchronizeRenderers(cachedRenderContexts);
+                        for( Layer layerToRender : layersToRender ) {
+                            //                        layerToRender.refresh(null);
+                            taskCompressor.addRefreshingLayer(layerToRender);
+                        }
+                    }
+                    break;
+                    case LAYER_ZORDER_CHANGED:
+                    {
+                        layers = next.getLayers();
+
+                        List<Layer> layersToRender = synchronizeRenderers(cachedRenderContexts);
+                        for( Layer layerToRender : layersToRender ) {
+                            //                        layerToRender.refresh(null);
+                            taskCompressor.addRefreshingLayer(layerToRender);
+                        }
+                        //                    manager.synchronizeAndRefresh(task.getEvent());
+                        //                    try {
+                        //                        ((RootCompositeRendererImpl) renderExecutor.getRenderer()).refreshImage();
+                        //                    } catch (RenderException e) {
+                        //                        // won't happen.
+                        //                        e.printStackTrace();
+                        //                    }
+                        //                    ((ViewportPane) getMapDisplay()).renderDone();
+                    }
+                    break;
+                    case LAYER_REMOVED:
+                    {
+                        layers = next.getLayers();
+                        List<Layer> layersToRender = synchronizeRenderers(cachedRenderContexts);
+                        for( Layer layerToRender : layersToRender ) {
+                            //                      layerToRender.refresh(null);
+                            taskCompressor.addRefreshingLayer(layerToRender);
+                        }
+
+                        //                    manager.synchronizeAndRefresh(task.getEvent());
+                        //                    try {
+                        //                        ((RootCompositeRendererImpl) renderExecutor.getRenderer()).refreshImage();
+                        //                    } catch (RenderException e) {
+                        //                        // won't happen.
+                        //                        e.printStackTrace();
+                        //                    }
+                        //                    ((ViewportPane) getMapDisplay()).renderDone();
+                    }
+                    break;
+
+                    default:
+                    }
+                }
+
+                if(monitor.isCanceled()){
+                    return Status.CANCEL_STATUS;
+                }
+
+                if( (taskCompressor.refreshType & RenderTaskCompressor.REFRESH_ALL) == RenderTaskCompressor.REFRESH_ALL){
+
+                    configurator.reset();
+                    Collection<RenderContext> configuration = configurator.getConfiguration();
+
+                    //                  getRendererCreator().reset();
+                    //                  validateRendererConfiguration();
+                    validateRenderers();
+                    
+                    try {
+                        getRenderExecutor().setRenderBounds(taskCompressor.bounds);
+                        getRenderExecutor().render();
+                    } catch (RenderException e) {
+                        // Won't happen
+                    }
+                }else if( (taskCompressor.refreshType & RenderTaskCompressor.REFRESH_LAYERS) == RenderTaskCompressor.REFRESH_LAYERS
+                        && taskCompressor.layers != null){
+
+                    configurator.reset();
+                    validateRenderers();
+                    cachedRenderContexts=null;
+                    
+                    this.refreshLayers(taskCompressor.layers, null);
+
+                }else if( (taskCompressor.refreshType & RenderTaskCompressor.REFRESH_SELECTION) == RenderTaskCompressor.REFRESH_SELECTION){
+
+
+                    if (taskCompressor.selectionLayer != null){
+
+                        configurator.reset();
+                        validateRenderers();
+                        cachedRenderContexts=null;
+
+                        refreshSelection(taskCompressor.selectionLayer, null);
+                    }
+
+                }else if( (taskCompressor.refreshType & RenderTaskCompressor.REFRESH_IMAGE_BUFFER) == RenderTaskCompressor.REFRESH_IMAGE_BUFFER){
+
+                    validateRenderers();
+                    try {
+                        ((RootCompositeRendererImpl) renderExecutor.getRenderer()).refreshImage();
+                    } catch (RenderException e) {
+                        // won't happen.
+                        e.printStackTrace();
+                    }
+                    ((ViewportPane) getMapDisplay()).renderDone();
+                }else{
+
+                    System.out.println("WRONG LOGIC IN RENDER TASK QUEUE JOB: no compressing was done..");
+                }
+
+
+            }catch(Exception exc){
+                ProjectUIPlugin.log("Failed to process rendering events in RenderTaskQueueJob", exc); //$NON-NLS-1$
+            }
+
+            return Status.OK_STATUS;
+        }
+        
+        private void refreshLayers(final List<ILayer> layers, Envelope bounds){
+            
+            final List<SelectionLayer> selectionLayers = new ArrayList<SelectionLayer>(layers.size());
+            for (ILayer layer : layers) {
+                SelectionLayer selectionLayer = configurator.findSelectionLayer(layer);
+                if(selectionLayer != null){
+                    selectionLayers.add(selectionLayer);
+                }
+            }
+
+            final ReferencedEnvelope bbox = bounds == null
+                    || bounds instanceof ReferencedEnvelope ? (ReferencedEnvelope) bounds
+                    : new ReferencedEnvelope(bounds, getRenderExecutor().getContext().getCRS());
+
+            getRenderExecutor().visit(new ExecutorVisitor() {
+                public void visit(RenderExecutor executor) {
+                    
+                    if(executor instanceof RootCompositeRenderExecutor){
+                        
+                        RootCompositeRenderExecutor compositeExecutor = (RootCompositeRenderExecutor)executor;
+                        List<RenderExecutor> executors = new ArrayList<RenderExecutor>(
+                                compositeExecutor.getRenderer().getRenderExecutors());
+                        
+                        for (RenderExecutor child : executors) {
+                            child.visit(this);
+                        }
+                        
+                    }else if (layers.contains(executor.getContext().getLayer())
+                            || selectionLayers.contains(executor.getContext().getLayer())) {
+                        // tell the renderer the area of the screen to refresh
+                        executor.getRenderer().setRenderBounds(bbox);
+                        // register our interest in seeing the screen redrawn
+                        executor.getRenderer().setState(IRenderer.RENDER_REQUEST);
+                    }
+                }
+
+                public void visit(RenderExecutorMultiLayer executor) {
+                    
+                    for (ILayer layer : layers) {
+                        if (executor.getContext().getLayers().contains(layer)){
+                            executor.getRenderer().setState(IRenderer.RENDER_REQUEST);
+                            break;
+                        }
+                    }
+                    if(!selectionLayers.isEmpty()){
+                        for (SelectionLayer selectionLayer : selectionLayers) {
+                            if(executor.getContext().getLayers().contains(
+                                    selectionLayer)){
+                                executor.getRenderer().setState(IRenderer.RENDER_REQUEST);
+                                break;
+                            }
+                            
+                        }
+                    }
+                    
+
+                    
+
+                }
+
+                public void visit(RenderExecutorComposite executor) {
+//                    List<RenderExecutor> executors = new ArrayList<RenderExecutor>(
+//                            executor.getRenderer().getRenderExecutors());
+//                    for (RenderExecutor child : executors) {
+//                        child.visit(this);
+//                    }
+                }
+            });
+        }
+        
+        private void refreshSelection(final SelectionLayer selectionLayer, final Envelope bounds){
+
+
+            getRenderExecutor().visit(new ExecutorVisitor() {
+                public void visit(RenderExecutor executor) {
+                    
+                    IRenderContext context = executor.getContext();
+                    if(executor instanceof RootCompositeRenderExecutor){
+                        RootCompositeRenderExecutor compositeExecutor = (RootCompositeRenderExecutor)executor;
+                        List<RenderExecutor> executors = new ArrayList<RenderExecutor>(
+                                compositeExecutor.getRenderer().getRenderExecutors());
+                        
+                        for (RenderExecutor child : executors) {
+                            child.visit(this);
+                        }
+                        
+                        
+                    }else if (selectionLayer == context.getLayer()) {
+                        executor.getRenderer().setRenderBounds(bounds);
+                        if (bounds != null) {
+                            Rectangle bounds2 = context.toShape(
+                                    new ReferencedEnvelope(bounds,
+                                            getViewportModelInternal().getCRS()))
+                                    .getBounds();
+                            context.clearImage(bounds2);
+                        } else {
+                            context.clearImage();
+                        }
+                        executor.getRenderer().setState(IRenderer.RENDER_REQUEST);
+                    }
+                }
+
+                public void visit(RenderExecutorMultiLayer executor) {
+                    CompositeRenderContext contexts = executor.getContext();
+                    for (IRenderContext context : contexts.getContexts()) {
+                        if (context.getLayer() == selectionLayer) {
+                            executor.getRenderer().setState(
+                                    IRenderer.RENDER_REQUEST);
+                            return;
+                        }
+                    }
+                }
+
+                public void visit(RenderExecutorComposite executor) {
+                    for (RenderExecutor child : executor.getRenderer()
+                            .getRenderExecutors())
+                        child.visit(this);
+                }
+            });
+            
+        }
+
+    }
+    
+    /**
+     * Watches the layer add / delete / change of zorder and style changes.
+     */
+    ContextModelListenerAdapter contextModelAdapter = NextGenRenderManagerAdapters.createContextModelListener(this);
+    /**
+     * Watches the viewport model and triggers some kind of refresh. This is the
+     * bounds and the crs changing; panning zooming swooshing and other assorted
+     * user drive fun.
+     */
+    Adapter viewportListener = NextGenRenderManagerAdapters.createViewportListener(this);
+
+    /**
+     * listents to the viewport model (using the provided viewportListener)
+     * and morphing the events into something for the map to be updated with?
+     * 
+     */
+    private Adapter viewportModelChangeListener = NextGenRenderManagerAdapters.createViewportModelChangeListener(this, viewportListener, contextModelAdapter);
+
+    private Adapter selectionListener = NextGenRenderManagerAdapters.createLayerListener(this);
+
+    
+    
+    protected RendererConfigurator configurator;
+    
+    
+    /**
+     * Current configuration
+     */
+    protected volatile Collection<RenderContext> renderContexts = null;
+    
+    private RenderTaskQueueJob renderQueueJob;
+
+    /**
+     * <!-- begin-user-doc --> <!-- end-user-doc -->
+     * 
+     * @generated NOT
+     */
+    @SuppressWarnings("unchecked")
+    public NextGenRenderManager() {
+        super();
+        eAdapters().add(viewportModelChangeListener);
+    }
+    
+    
+
+    protected RenderTaskQueueJob getRenderQueueJob(){
+        
+        if(renderQueueJob == null){
+            synchronized(this){
+                if(renderQueueJob == null){
+                renderQueueJob = new  RenderTaskQueueJob();
+                }
+            }
+        }
+        return renderQueueJob;
+    }
+    
+    protected RendererConfigurator getConfigurator(){
+        return this.configurator;
+    }
+    
+    /**
+     * Adds render task to the queue.
+     * 
+     * @param renderTask
+     */
+    protected void queueRenderTask(RenderTask renderTask){
+        getRenderQueueJob().addRenderTask(renderTask);
+    }
+    
+    protected int getRenderQueueSize(){
+        return getRenderQueueJob().requests.size();
+    }
+    
+    protected void scheduleQueueJob(){
+        if(getRenderQueueSize() != 0){
+            getRenderQueueJob().schedule();
+        }
+    }
+    
+    protected Collection<RenderContext> getRenderContexts() {
+        return renderContexts;
+    }
+
+    /**
+     * @see org.locationtech.udig.project.render.impl.RenderManagerImpl#refresh(org.locationtech.udig.project.Layer)
+     */
+    public void refresh(final ILayer layer, Envelope bounds) {
+        checkState();
+        if (!renderingEnabled) {
+            return;
+        }
+
+        if (getMapDisplay() == null || getRenderExecutor() == null) {
+            return; // we are not set up to renderer yet!
+        }
+        
+        RenderTask renderTask = new RenderTask(RenderTaskType.LAYER_STATE_CHANGED, layer, bounds);
+        queueRenderTask(renderTask);
+        
+        scheduleQueueJob();
+        
+        
+    }
+    
+
+    
+    @Override
+    public void refreshImage() {
+        try {
+            ((RootCompositeRendererImpl)getRenderExecutor().getRenderer()).refreshImage();
+            getRenderExecutor().setState(IRenderer.DONE);
+        } catch (RenderException e) {
+            ProjectPlugin.log("", e); //$NON-NLS-1$
+        }
+    }
+
+    /**
+     * @see org.locationtech.udig.project.render.impl.RenderManagerImpl#refreshSelection(com.vividsolutions.jts.geom.Envelope)
+     */
+    public void refreshSelection(final ILayer layer, final Envelope bounds) {
+        checkState();
+        if (!renderingEnabled) {
+            return;
+        }
+
+        if (getMapDisplay() == null || getRenderExecutor() == null)
+            return;
+
+        
+        RenderTask renderTask = new RenderTask(RenderTaskType.LAYER_SELECTION_CHANGED, layer, bounds);
+        queueRenderTask(renderTask);
+        
+        scheduleQueueJob();
+        
+    }
+
+    /**
+     * @see org.locationtech.udig.project.render.IRenderManager#clearSelection(ILayer)
+     */
+    public void clearSelection(ILayer layer) {
+        checkState();
+        if (getMapDisplay() == null || getRenderExecutor() == null)
+            return;
+        
+        final Layer selectionLayer = configurator.findSelectionLayer(layer);
+
+        if (selectionLayer == null)
+            return;
+
+        try {
+            RootCompositeRendererImpl renderer = (RootCompositeRendererImpl) getRenderExecutor().getRenderer();
+            renderer.refreshImage();
+            renderer.setState(IRenderer.DONE);
+
+        } catch (RenderException e) {
+            ProjectUIPlugin.log("", e); //$NON-NLS-1$
+        }
+    }
+
+    /**
+     * <!-- begin-user-doc --> <!-- end-user-doc -->
+     * 
+     * @generated NOT
+     */
+    @SuppressWarnings("unchecked")
+    public void refresh(final Envelope bounds) {
+        
+        checkState();
+        if (!renderingEnabled) {
+            return;
+        }
+        
+        getViewportModelInternal().setInitialized(true);
+        
+        if (getMapDisplay() == null) {
+            return;
+        }
+        if (getMapDisplay().getWidth() < 1 || getMapDisplay().getHeight() < 1)
+            return;
+        
+        RenderTask renderTask = new RenderTask(RenderTaskType.MAP_BOUNDS_CHANGED);
+        queueRenderTask(renderTask);
+        
+        if(getRenderQueueSize() != 0){
+            getRenderQueueJob().schedule();
+        }
+    }
+    
+
+    /**
+     * <!-- begin-user-doc --> <!-- end-user-doc -->
+     * 
+     * @generated NOT
+     */
+    @SuppressWarnings("unchecked")
+    public void dispose() {
+        if(renderQueueJob != null){
+            renderQueueJob.cancel();
+        }
+        renderQueueJob=null;
+        
+        if(this.configurator != null){
+            this.configurator.dispose();
+        }
+        
+        this.renderingEnabled = false;
+        this.renderContexts = null;
+        
+        //Destroy renderexecutor
+//      try{
+//          RenderExecutor re = getRenderExecutor();
+//          re.dispose();
+//      }catch(Exception exc){
+//          exc.printStackTrace();
+//      }
+        Map mapObj = getMapInternal();
+        removeAdapters(mapObj);
+//      mapObj.eAdapters().remove(selectionListener);
+        mapObj.removeDeepAdapter(selectionListener);
+        removeAdapters(mapObj.getContextModel());
+        
+        Iterator<EObject> iter = getMapInternal().eAllContents();
+        while (iter.hasNext()) {
+            EObject obj = iter.next();
+            removeAdapters(obj);
+        }
+        removeAdapters(getRenderExecutor());
+        ((ViewportPane) mapDisplay).setRenderManager(null);
+        eAdapters().remove(viewportModelChangeListener);
+        
+        this.contextModelAdapter = null;
+        this.renderExecutorListener=null;
+        this.viewportModelChangeListener = null;
+        this.viewportListener = null;
+        this.selectionListener = null;
+        
+        super.dispose();
+    }
+
+    /**
+     * @param obj
+     */
+    private void removeAdapters(EObject obj) {
+        obj.eAdapters().remove(this.viewportListener);
+        obj.eAdapters().remove(this.viewportModelChangeListener);
+        obj.eAdapters().remove(this.contextModelAdapter);
+        obj.eAdapters().remove(this.renderExecutorListener);
+        obj.eAdapters().remove(this.selectionListener);
+    }
+
+    /**
+     * <!-- begin-user-doc --> <!-- end-user-doc -->
+     * 
+     * @generated
+     */
+    public void setDisplayGen(IMapDisplay newDisplay) {
+        IMapDisplay oldDisplay = mapDisplay;
+        mapDisplay = newDisplay;
+        if (eNotificationRequired())
+            eNotify(new ENotificationImpl(this, Notification.SET,
+                    RenderPackage.RENDER_MANAGER__MAP_DISPLAY, oldDisplay,
+                    mapDisplay));
+    }
+
+    /**
+     * TODO summary sentence for setViewport ...
+     * 
+     * @see org.locationtech.udig.project.render.RenderManager#setDisplay(org.locationtech.udig.project.render.displayAdapter.IMapDisplay)
+     * @param value
+     */
+    public void setDisplay(IMapDisplay value) {
+        checkState();
+        ((ViewportPane) value).setRenderManager(this);
+        setDisplayGen(value);
+    }
+
+    Adapter renderExecutorListener = RenderManagerAdapters.getRenderExecutorListener(this);
+
+    /**
+     * @see org.locationtech.udig.project.render.impl.RenderManagerImpl#setRenderExecutor(org.locationtech.udig.project.render.RenderExecutor)
+     */
+    @SuppressWarnings("unchecked")
+    public void setRenderExecutor(RenderExecutor newRenderExecutor) {
+        checkState();
+        if (renderExecutor != null) {
+            renderExecutor.eAdapters().remove(renderExecutorListener);
+        }
+        if (newRenderExecutor != null
+                && !newRenderExecutor.eAdapters().contains(
+                        renderExecutorListener)) {
+            newRenderExecutor.eAdapters().add(renderExecutorListener);
+        }
+        super.setRenderExecutor(newRenderExecutor);
+    }
+
+    /**
+     * @see org.locationtech.udig.project.render.impl.RenderManagerImpl#basicSetMap(org.locationtech.udig.project.Map,
+     *      org.eclipse.emf.common.notify.NotificationChain)
+     */
+    @SuppressWarnings("unchecked")
+    public NotificationChain basicSetMapInternal(Map newMap,
+            NotificationChain msgs) {
+        if (getMapInternal() != null) {
+            getMapInternal().eAdapters().remove(selectionListener);
+            getMapInternal().removeDeepAdapter(selectionListener);
+        }
+        if (newMap != null) {
+            newMap.eAdapters().add(selectionListener);
+            newMap.addDeepAdapter(selectionListener);
+        }
+        
+
+        
+        NotificationChain notificationChain = super.basicSetMapInternal(newMap, msgs);
+//        if(newMap != null){
+//            if (!getMapInternal().getContextModel().eAdapters().contains(contextModelAdapter))
+//                getMapInternal().getContextModel().eAdapters().add(contextModelAdapter);
+//        }
+        
+        return notificationChain;
+    }
+
+    
+    
+ 
+
+    /**
+     * 
+     */
+    private void initRenderExecutor() {
+        checkState();
+//        MultiLayerRenderer rootRenderer = RenderFactory.eINSTANCE.createCompositeRenderer();
+        RootCompositeRendererImpl rootRenderer = new RootCompositeRendererImpl();
+        CompositeRenderContext context = new CompositeRenderContextImpl() {
+            @Override
+            public synchronized BufferedImage getImage(int width, int height) {
+                if (image == null || image.getWidth() < width
+                        || image.getHeight() < height) {
+                    image = new BufferedImage(width, height,
+                            BufferedImage.TYPE_3BYTE_BGR);
+                    Graphics2D g = image.createGraphics();
+                    g.setBackground(Color.WHITE);
+                    g.clearRect(0, 0, width, height);
+                    g.dispose();
+                }
+
+                return image;
+            }
+
+            @Override
+            public synchronized void clearImage(Rectangle paintArea) {
+                if (image == null)
+                    return;
+                Graphics2D g = image.createGraphics();
+                g.setBackground(Color.WHITE);
+                g.clearRect(paintArea.x, paintArea.y, paintArea.width,
+                        paintArea.height);
+                g.dispose();
+                // // FIXME Arbonaut Oy , Vitali Diatchkov
+                // System.out.println(
+                // "synchronized CompositeRenderContext.clearImage()");
+            }
+
+        };
+        context.setMapInternal(getMapInternal());
+        context.setRenderManagerInternal(this);
+        rootRenderer.setContext(context);
+        rootRenderer.setName(Messages.RenderManagerDynamic_allLayers);
+        
+        initRendererConfigurator(context);
+        
+        rootRenderer.setRendererConfigurator(getRendererConfigurator());
+        
+//        setRenderExecutor(RenderFactory.eINSTANCE.createRenderExecutor(rootRenderer));
+        RootCompositeRenderExecutor executor = new RootCompositeRenderExecutor(this);
+        executor.setRenderer(rootRenderer);
+        setRenderExecutor(executor);
+        
+    }
+
+    private void logRendererTypes() {
+        if (ProjectUIPlugin.isDebugging(RENDER)) {
+
+            final StringBuffer log = new StringBuffer("Current Renderers:"); //$NON-NLS-1$
+            getRenderExecutor().visit(new ExecutorVisitor() {
+                public void visit(RenderExecutor executor) {
+                    log
+                            .append("\n\t" + executor.getClass().getSimpleName() + ":" + //$NON-NLS-1$ //$NON-NLS-2$
+                                    executor.getRenderer().getClass()
+                                            .getSimpleName() + "-" + //$NON-NLS-1$
+                                    executor.getContext().getLayer().getName());
+                }
+
+                public void visit(RenderExecutorComposite executor) {
+                    log
+                            .append("\n\t" + executor.getRenderer().getClass().getSimpleName()); //$NON-NLS-1$
+                    for (RenderExecutor child : executor.getRenderer()
+                            .getRenderExecutors())
+                        child.visit(this);
+                }
+
+                public void visit(RenderExecutorMultiLayer executor) {
+                    log
+                            .append("\n\t" + executor.getRenderer().getClass().getSimpleName()); //$NON-NLS-1$
+                }
+            });
+            System.out.println(log);
+        }
+    }
+
+    
+    public RenderExecutor getRenderExecutor() {
+        checkState();
+        if (renderExecutor == null) {
+            synchronized(this){
+                if (renderExecutor == null) {
+                    initRenderExecutor();
+                }
+            }
+        }
+
+        return renderExecutor;
+    }
+    
+    
+
+    protected void initRendererConfigurator(CompositeRenderContext context){
+        
+        configurator = new RendererConfigurator();
+//        RenderContext context = new RenderContextImpl(){
+//            @Override
+//            public Map getMapInternal() {
+//                return NextGenRenderManager.this.getMapInternal();
+//            }
+//            @Override
+//            public Map getMap() {
+//                return NextGenRenderManager.this.getMapInternal();
+//            }
+//            @Override
+//            public RenderManager getRenderManagerInternal() {
+//                return NextGenRenderManager.this;
+//            }
+//
+//            @Override
+//            public IRenderManager getRenderManager() {
+//                return NextGenRenderManager.this;
+//            }
+//        };
+        configurator.setContext(context);
+        List<Layer> layers = getMapInternal().getLayersInternal();
+        ENotificationImpl notification = new ENotificationImpl(this,
+                Notification.ADD_MANY, ProjectPackage.CONTEXT_MODEL__LAYERS,
+                null, layers);
+        configurator.changed(notification);
+    }
+    
+    public RendererConfigurator getRendererConfigurator(){
+        return this.configurator;
+    }
+
+
+    /** 
+     * This method is responsible for spitting out a list of layers that need 
+     * to be refreshed in response to the provided notification.
+     * <p>
+     * 
+     * 
+     * @param msg notifcation message (such as a zorder change) causing this change
+     * @param configuration RemderContexts being drawn into...
+     * @param rendererCreator RemderCreator responsible for setting up renderers associated with these layers
+     * @return List of layers to refresh or other wise schedule for redrawing
+     */
+    
+    @Deprecated
+    private List<Layer> synchronizeRenderers( final Notification msg) {
+        
+        /**
+         * This is a back up of the render context (ie with buffered image and stuff) so
+         * we can recycle them...
+         * 
+         */
+        
+        HashMap<RenderContext, RenderContext> oldToCopy = new HashMap<RenderContext, RenderContext>();
+        Collection<RenderContext> configuration2= this.renderContexts;
+        if (configuration2 != null)
+            for( RenderContext context : configuration2 ) {
+                //We skip outdated/removed layers
+                if(context.getMap() == null)
+                    continue;
+                
+                oldToCopy.put(context, context.copy());
+            }
+        /// smack the render creator and ask it to create us up some new renderers
+        configurator.changed(msg);
+        
+        //// new configuration of render context ...
+        configuration2= configurator.getConfiguration();
+        
+       // this is the list of layers we need to ask to be redrawn at the end of the day
+        List<Layer> toRender = new ArrayList<Layer>();
+        
+        for( RenderContext newcontext : configuration2 ) {
+            if (!oldToCopy.containsKey(newcontext)
+                    && !(newcontext.getLayer() instanceof SelectionLayer)) {
+                // if it is something that was not there before we need to render it!
+                toRender.add(newcontext.getLayerInternal());
+            } else {
+                if (newcontext instanceof CompositeRenderContext) {
+                    // we got children ... that will slow us down a bit...
+                    List<Layer> oldLayers = new ArrayList<Layer>(((CompositeRenderContext) oldToCopy.get(newcontext))
+                            .getLayersInternal());
+                    // these are our old layers; we want to check if they are in a different order or something ...
+                    for( Layer layer : ((CompositeRenderContext) newcontext).getLayersInternal() ) {
+                        if (!oldLayers.contains(layer)) {
+                            // our child is new we better ask it to get drawn...
+                            toRender.add(newcontext.getLayerInternal());
+                            break;
+                        }
+                        oldLayers.remove(layer); // we have this one already
+                        // XXX
+                    }
+                    if (!oldLayers.isEmpty()){
+                        // this is stuff we no longer need
+                        toRender.add(newcontext.getLayerInternal()); // perhaps the old stuff will be removed by someone?
+                    }
+                }
+                oldToCopy.remove(newcontext);
+            }
+        }
+        // we never check oldtoCopy for leftovers ... ie so we could dispose them?
+        
+        return toRender; // the end of the day
+    }
+    
+    
+    
+   private List<Layer> synchronizeRenderers( Collection<RenderContext> currentRenderContexts) {
+        
+        /**
+         * This is a back up of the render context (ie with buffered image and stuff) so
+         * we can recycle them...
+         * 
+         */
+        
+        HashMap<RenderContext, RenderContext> oldToCopy = new HashMap<RenderContext, RenderContext>();
+//        Collection<RenderContext> configuration2= this.renderContexts;
+        if (currentRenderContexts != null)
+            for( RenderContext context : currentRenderContexts ) {
+                //We skip outdated/removed layers
+                if(context.getMap() == null)
+                    continue;
+                
+                oldToCopy.put(context, context.copy());
+            }
+        /// smack the render creator and ask it to create us up some new renderers
+//        configurator.changed(msg);
+        
+        //// new configuration of render context ...
+        Collection<RenderContext> newRenderContexts= configurator.getConfiguration();
+        
+       // this is the list of layers we need to ask to be redrawn at the end of the day
+        List<Layer> toRender = new ArrayList<Layer>();
+        
+        for( RenderContext newcontext : newRenderContexts ) {
+            if (!oldToCopy.containsKey(newcontext)
+                    && !(newcontext.getLayer() instanceof SelectionLayer)) {
+                // if it is something that was not there before we need to render it!
+                toRender.add(newcontext.getLayerInternal());
+            } else {
+                if (newcontext instanceof CompositeRenderContext) {
+                    // we got children ... that will slow us down a bit...
+                    List<Layer> oldLayers = new ArrayList<Layer>(((CompositeRenderContext) oldToCopy.get(newcontext))
+                            .getLayersInternal());
+                    // these are our old layers; we want to check if they are in a different order or something ...
+                    for( Layer layer : ((CompositeRenderContext) newcontext).getLayersInternal() ) {
+                        if (!oldLayers.contains(layer)) {
+                            // our child is new we better ask it to get drawn...
+                            toRender.add(newcontext.getLayerInternal());
+                            break;
+                        }
+                        oldLayers.remove(layer); // we have this one already
+                        // XXX
+                    }
+                    if (!oldLayers.isEmpty()){
+                        // this is stuff we no longer need
+                        toRender.add(newcontext.getLayerInternal()); // perhaps the old stuff will be removed by someone?
+                    }
+                }
+                oldToCopy.remove(newcontext);
+            }
+        }
+        // we never check oldtoCopy for leftovers ... ie so we could dispose them?
+        
+        return toRender; // the end of the day
+    }
+    
+    
+    /**
+     * Ensures that the current configuration of renderer is a valid choice. For
+     * example the each of the layers in the map has a renderer that can render
+     * it.
+     */
+    private void validateRenderers() {
+        checkState();
+        Collection<RenderContext> configuration;
+        synchronized (this) {
+            if (this.renderContexts == null) {
+                configuration = null;
+            } else {
+                configuration = new ArrayList<RenderContext>(this.renderContexts);
+            }
+        }
+        Collection<RenderContext> configuration2;
+        if (configuration != null) {
+            configuration2 = configurator.getConfiguration();
+            List<RenderContext> removeList = new ArrayList<RenderContext>();
+            List<RenderContext> addList = new ArrayList<RenderContext>();
+            for (IRenderContext context : configuration) {
+                if (!configuration2.contains(context))
+                    removeList.add((RenderContext) context);
+            }
+            for (RenderContext context : configuration2) {
+                if (configuration.contains(context))
+                    continue;
+
+                addList.add(context);
+            }
+            CompositeRenderContext compositecontext = (CompositeRenderContext) getRenderExecutor()
+                    .getContext();
+            compositecontext.removeContexts(removeList);
+            if (!addList.isEmpty())
+                compositecontext.removeContexts(addList);
+            compositecontext.addContexts(addList);
+
+        } else {
+//            initRenderExecutor();
+            configuration2 = configurator.getConfiguration();
+
+            CompositeRenderContext compositecontext = (CompositeRenderContext) getRenderExecutor()
+                    .getContext();
+            // need this because this is taking place in a non-synchronized
+            // block so it is possible for
+            // this code to be executed twice. I want the second run to be
+            // accurate.
+            // might need to be thought about more.
+            compositecontext.clear();
+            compositecontext.addContexts(configuration2);
+        }
+        synchronized (this) {
+            this.renderContexts = configuration2;
+        }
+        logRendererTypes();
+
+    }
+    
+//    public void synchronizeAndRefresh(Notification msg) {
+//        List<Layer> toRender = synchronizeRenderers(msg);
+//        for( Layer layer : toRender ) {
+//            layer.refresh(null);
+//        }
+//    }
+}
diff --git a/plugins/org.locationtech.udig.project.ui/src/org/locationtech/udig/project/ui/internal/NextGenRenderManagerAdapters.java b/plugins/org.locationtech.udig.project.ui/src/org/locationtech/udig/project/ui/internal/NextGenRenderManagerAdapters.java
new file mode 100644
index 0000000..675325c
--- /dev/null
+++ b/plugins/org.locationtech.udig.project.ui/src/org/locationtech/udig/project/ui/internal/NextGenRenderManagerAdapters.java
@@ -0,0 +1,544 @@
+package org.locationtech.udig.project.ui.internal;
+
+
+import java.io.IOException;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.Adapter;
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.impl.AdapterImpl;
+import org.geotools.data.FeatureEvent;
+import org.geotools.geometry.jts.JTS;
+import org.geotools.geometry.jts.ReferencedEnvelope;
+import org.locationtech.udig.project.ILayer;
+import org.locationtech.udig.project.internal.ContextModel;
+import org.locationtech.udig.project.internal.ContextModelListenerAdapter;
+import org.locationtech.udig.project.internal.Layer;
+import org.locationtech.udig.project.internal.Map;
+import org.locationtech.udig.project.internal.ProjectPackage;
+import org.locationtech.udig.project.internal.ProjectPlugin;
+import org.locationtech.udig.project.internal.render.MultiLayerRenderer;
+import org.locationtech.udig.project.internal.render.RenderListenerAdapter;
+import org.locationtech.udig.project.internal.render.RenderManager;
+import org.locationtech.udig.project.internal.render.RenderPackage;
+import org.locationtech.udig.project.internal.render.ViewportModel;
+import org.locationtech.udig.project.internal.render.impl.RenderManagerImpl;
+import org.locationtech.udig.project.internal.render.impl.RenderTask;
+import org.locationtech.udig.project.internal.render.impl.RenderTaskType;
+import org.locationtech.udig.project.preferences.PreferenceConstants;
+import org.locationtech.udig.project.render.RenderException;
+import org.locationtech.udig.project.ui.ApplicationGIS;
+import org.locationtech.udig.project.ui.render.displayAdapter.ViewportPane;
+import org.opengis.filter.Filter;
+import org.opengis.referencing.crs.CoordinateReferenceSystem;
+import org.opengis.referencing.operation.MathTransform;
+import org.opengis.referencing.operation.TransformException;
+
+import com.vividsolutions.jts.geom.Envelope;
+
+/**
+ * Provides factory methods for various Listeners used by RenderManagerDynamic.
+ */
+
+public class NextGenRenderManagerAdapters {
+
+    static Adapter createViewportListener( final NextGenRenderManager manager ) {
+        return new AdapterImpl(){
+            /**
+             * @see org.eclipse.emf.common.notify.impl.AdapterImpl#notifyChanged(org.eclipse.emf.common.notify.Notification)
+             */
+            public void notifyChanged( Notification msg ) {
+                manager.checkState();
+                switch( msg.getFeatureID(ViewportModel.class) ) {
+                case RenderPackage.VIEWPORT_MODEL__BOUNDS: {
+                    if (ApplicationGIS.getActiveMap() != null
+                            && ApplicationGIS.getVisibleMaps().contains(
+                                    ApplicationGIS.getActiveMap())) {
+                        refreshDirtyArea(msg);
+                    }
+                    break;
+                }
+                case RenderPackage.VIEWPORT_MODEL__CRS: {
+                    manager.refresh(null);
+                    break;
+                }
+                case RenderPackage.VIEWPORT_MODEL__CURRENT_TIMESTEP: {
+                    manager.refresh(null);
+                    break;
+                }
+                case RenderPackage.VIEWPORT_MODEL__CURRENT_ELEVATION: {
+                    manager.refresh(null);
+                    break;
+                }
+                }// switch
+            }
+
+            private void refreshDirtyArea( Notification msg ) {
+                manager.refresh(null);
+            }
+        };
+    }
+    
+    
+    /**
+     * Creates a new viewport listener for a tiled render manager.
+     * 
+     * <p>This viewport listeners calls a soft refresh function with doesn't clear
+     * existing contexts or rerender tiles before drawing so it should reuse tiles if they have already been
+     * loaded.  New tiles will be rendered.</p>
+     * <p>A CRS change causes a full refresh; flushing all the tiles as currently tiles do not
+     * have a CRS associated with them so they have to be cleared so the wrong projection tiles
+     * are not used.</p>
+     * 
+     * <p>This listeners listens to:
+     * <ul>
+     *   <li>RenderPackage.VIEWPORT_MODEL__BOUNDS
+     *   <li>RenderPackage.VIEWPORT_MODEL__CRS
+     * </ul>
+     */
+    static Adapter createViewportListener( final TiledRenderManagerDynamic manager ) {
+        return new AdapterImpl(){
+            /**
+             * @see org.eclipse.emf.common.notify.impl.AdapterImpl#notifyChanged(org.eclipse.emf.common.notify.Notification)
+             */
+            public void notifyChanged( Notification msg ) {
+                manager.checkState();
+                switch( msg.getFeatureID(ViewportModel.class) ) {
+                case RenderPackage.VIEWPORT_MODEL__BOUNDS: {
+                    manager.viewportChanged(msg);
+                    break;
+                }
+                case RenderPackage.VIEWPORT_MODEL__CRS: {
+                    manager.crsChanged(msg);
+                    break;
+                }
+                }// switch
+            }
+        };
+    }
+    
+    /**
+     * Who are you and what do you do? It does not actually
+     * get added anywhere so we do not know where and how.
+     * 
+     * @param manager 
+     * @returnContext
+     */
+    static ContextModelListenerAdapter createContextModelListener(
+            final NextGenRenderManager manager ) {
+        return new ContextModelListenerAdapter(){
+            /**
+             * @see org.locationtech.udig.project.ContextModelListenerAdapter#commandExecuted(org.eclipse.emf.common.notify.Notification)
+             */
+            public void notifyChanged( Notification msg ) {
+                super.notifyChanged(msg);
+            }
+
+            /**
+             * Will sychronizeAndRefresh( the manager based on the notification; and
+             * updateImage().
+             * 
+             * @see org.locationtech.udig.project.ContextModelListenerAdapter#zorderChanged(org.eclipse.emf.common.notify.Notification)
+             */
+            protected void zorderChanged( Notification msg ) {
+                RenderTask task = new RenderTask(RenderTaskType.LAYER_ZORDER_CHANGED, (ILayer)msg.getNewValue());
+                task.setEvent(msg);
+                manager.queueRenderTask(task);
+                
+                manager.scheduleQueueJob();
+//                manager.synchronizeAndRefresh(msg);
+//                updateImage();
+            }
+
+            /**
+             * @see org.locationtech.udig.project.ContextModelListenerAdapter#layerAdded(org.eclipse.emf.common.notify.Notification)
+             */
+            protected void layerAdded( Notification msg ) {
+                RenderTask task = new RenderTask(RenderTaskType.LAYER_ADDED, (ILayer)msg.getNewValue());
+                task.setEvent(msg);
+                manager.queueRenderTask(task);
+                
+                manager.scheduleQueueJob();
+//                manager.synchronizeAndRefresh(msg);
+//                updateImage();
+            }
+
+            /**
+             * @see org.locationtech.udig.project.ContextModelListenerAdapter#layerRemoved(org.eclipse.emf.common.notify.Notification)
+             */
+            protected void layerRemoved( Notification msg ) {
+                RenderTask task = new RenderTask(RenderTaskType.LAYER_REMOVED, (ILayer)msg.getOldValue());
+                task.setEvent(msg);
+                manager.queueRenderTask(task);
+                
+                manager.scheduleQueueJob();
+//                manager.synchronizeAndRefresh(msg);
+//                manager.validateRendererConfiguration();
+//                updateImage();
+            }
+
+            /**
+             * @see org.locationtech.udig.project.ContextModelListenerAdapter#manyLayersAdded(org.eclipse.emf.common.notify.Notification)
+             */
+            protected void manyLayersAdded( Notification msg ) {
+                RenderTask task = new RenderTask(RenderTaskType.LAYER_ADDED, (List<ILayer>)msg.getNewValue());
+                task.setEvent(msg);
+                manager.queueRenderTask(task);
+                
+                manager.scheduleQueueJob();
+                
+//                manager.synchronizeAndRefresh(msg);
+//                updateImage();
+            }
+
+            /**
+             * @see org.locationtech.udig.project.ContextModelListenerAdapter#manyLayersRemoved(org.eclipse.emf.common.notify.Notification)
+             */
+            protected void manyLayersRemoved( Notification msg ) {
+                RenderTask task = new RenderTask(RenderTaskType.LAYER_REMOVED, (List<ILayer>)msg.getOldValue());
+                task.setEvent(msg);
+                manager.queueRenderTask(task);
+                
+                manager.scheduleQueueJob();
+                
+//                manager.synchronizeAndRefresh(msg);
+//                manager.validateRendererConfiguration();
+//                updateImage();
+            }
+
+            public void updateImage() {
+                try {
+                    ((MultiLayerRenderer) manager.getRenderExecutor().getRenderer()).refreshImage();
+                } catch (RenderException e) {
+                    // won't happen.
+                    e.printStackTrace();
+                }
+                ((ViewportPane) manager.getMapDisplay()).renderDone();
+            }
+
+        };
+
+    }
+    
+//    /**
+//     * This private method is called by the context model listener when a layer
+//     * has been added/removed/moved in order to refresh the image.  
+//     *  
+//     * <p>
+//     * This implementation hunts down a layer can calls layer.refresh( null ) in order
+//     * to ask it to redraw pretty much everything it has... the synchronizeRenderers
+//     * will hunt down the list of layers effected by this notification....scared.
+//     * <p>
+//     * 
+//     * @param msg
+//     * @param manager
+//     */
+//    private static void synchronizeAndRefresh(Notification msg, TiledRenderManagerDynamic manager) {
+//        //something has happened and we need to re-create the contexts when we 
+//        //go to render a tile
+//        manager.invalidateAllTileContext();
+//        List<Layer> toRender = synchronizeRenderers(msg, (TiledRendererCreatorImpl)manager.getRendererCreator());
+//        for( Layer layer : toRender ) {
+//            layer.refresh(null);
+//        }
+//    }
+//    
+//    /** 
+//     * This method is responsible for spitting out a list of layers that need 
+//     * to be refreshed in response to the provided notification.
+//     * <p>
+//     * 
+//     * 
+//     * @param msg notifcation message (such as a zorder change) causing this change
+//     * @param configuration RemderContexts being drawn into...
+//     * @param rendererCreator RemderCreator responsible for setting up renderers associated with these layers
+//     * @return List of layers to refresh or other wise schedule for redrawing
+//     */
+//    public static List<Layer> synchronizeRenderers( final Notification msg, 
+//            final TiledRendererCreatorImpl rendererCreator) {
+//        
+//        
+//        //This call updates the layers list in the renderer creator
+//        //this layer list is the list of layers drawn on the screen
+//        //For the Tile Render Manager this deals with keeping and removing contexts as required
+//        rendererCreator.changed(msg);
+//        
+//        //what are the new layers?
+//        //these layers need to be kicked for redraw
+//        ArrayList<Layer> addedLayers = new ArrayList<Layer>();
+//        switch( msg.getEventType() ) {
+//        case Notification.ADD: {
+//            //layer has been added need to add to layers list
+//            //if selectable layer also add a selection layer
+//            Layer layer = (Layer) msg.getNewValue();
+//            addedLayers.add(layer);
+//            break;
+//        }
+//        case Notification.ADD_MANY: {
+//            for( Layer layer : (Collection< ? extends Layer>) msg.getNewValue() ) {
+//                addedLayers.add(layer);
+//            }
+//        }}
+//        return addedLayers;
+//    }
+    
+    
+//    /**
+//     * This private method is called by listeners (such as the context model listener)
+//     * in order to kick layers into life.
+//     * <p>
+//     * This implementation hunts down a layer can calls layer.refresh( null ) in order
+//     * to ask it to redraw pretty much everything it has... the synchronizeRenderers
+//     * will hunt down the list of layers effected by this notification....scared.
+//     * <p>
+//     * 
+//     * @param msg
+//     * @param manager
+//     */
+//    private static void synchronizeAndRefresh(Notification msg, NextGenRenderManager manager) {
+//        List<Layer> toRender = synchronizeRenderers(msg, manager.configuration, manager.getRendererCreator());
+//        for( Layer layer : toRender ) {
+//            layer.refresh(null);
+//        }
+//    }
+    
+
+    /**
+     * <!-- begin-user-doc -->
+     * Listens to the setMap or setViewportModel methods getting called; will wire up
+     * our viewportListener so we can tell what is going on at runtime.
+     *  <!-- end-user-doc -->
+     * 
+     * @generated NOT
+     */
+    static Adapter createViewportModelChangeListener( final RenderManagerImpl manager,
+            final Adapter viewportListener, final ContextModelListenerAdapter contextModelListener ) {
+        return new AdapterImpl(){
+            /**
+             * @see org.eclipse.emf.common.notify.impl.AdapterImpl#notifyChanged(org.eclipse.emf.common.notify.Notification)
+             */
+          
+            public void notifyChanged( Notification msg ) {
+                manager.checkState();
+
+                switch( msg.getFeatureID(RenderManager.class) ) {
+                case RenderPackage.RENDER_MANAGER__VIEWPORT_MODEL_INTERNAL: {
+                    if (msg.getOldValue() != null)
+                        ((ViewportModel) msg.getOldValue()).eAdapters().remove(viewportListener);
+                    if (msg.getNewValue() != null)
+                        ((ViewportModel) msg.getNewValue()).eAdapters().add(viewportListener);
+                    break;
+                }// case
+                case RenderPackage.RENDER_MANAGER__MAP_INTERNAL: {
+                    if (msg.getOldValue() != null)
+                        ((Map) msg.getOldValue()).getContextModel().eAdapters().remove(
+                                contextModelListener);
+                    if (msg.getNewValue() != null)
+                        ((Map) msg.getNewValue()).getContextModel().eAdapters().add(
+                                contextModelListener);
+                    break;
+                }// case
+
+                }
+            }
+        };
+    }
+
+    static Adapter createLayerListener( final NextGenRenderManager manager ) {
+        return new AdapterImpl(){
+            /**
+             * @see org.eclipse.emf.common.notify.impl.AdapterImpl#notifyChanged(org.eclipse.emf.common.notify.Notification)
+             */
+            public void notifyChanged( Notification event ) {
+                manager.checkState();
+
+                if (event.getNotifier() instanceof Map) {
+                    if (ProjectPackage.MAP__CONTEXT_MODEL == event.getFeatureID(Map.class)) {
+                        if (event.getOldValue() != null) {
+                            ((ContextModel) event.getOldValue()).removeDeepAdapter(this);
+                        }
+                        if (event.getNewValue() != null) {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-Id: uDig project developer discussion <udig-dev.locationtech.org>
List-Unsubscribe: <https://locationtech.org/mailman/options/udig-dev>,
	<mailto:udig-dev-request@xxxxxxxxxxxxxxxx?subject=unsubscribe>
List-Archive: <https://locationtech.org/mhonarc/lists/udig-dev>
List-Post: <mailto:udig-dev@xxxxxxxxxxxxxxxx>
List-Help: <mailto:udig-dev-request@xxxxxxxxxxxxxxxx?subject=help>
List-Subscribe: <https://locationtech.org/mailman/listinfo/udig-dev>,
	<mailto:udig-dev-request@xxxxxxxxxxxxxxxx?subject=subscribe>
X-List-Received-Date: Fri, 27 May 2016 16:16:38 -0000

Was missing some pre-reqs when trying to start udig_internal


---
This email has been checked for viruses by Avast antivirus software.
https://www.avast.com/antivirus
Prev by Date: [no subject]
Previous by thread: [no subject]
Index(es):
- Date
- Thread
Breadcrumbs
