Application: gvSIG desktop

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

 * This program is free software; you can redistribute it and/or modify it under

 * the terms of the GNU General Public License as published by the Free Software

 * Foundation; either version 3 of the License, or (at your option) any later

 * version.

 *

 * This program is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

 * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more

 * details.

 *

 * You should have received a copy of the GNU General Public License along with

 * this program; if not, write to the Free Software Foundation, Inc., 51

 * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us at info AT

 * gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.app.extension;

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

import javax.swing.JOptionPane;

import org.gvsig.andami.IconThemeHelper;

import org.gvsig.andami.PluginServices;

import org.gvsig.andami.plugins.Extension;

import org.gvsig.andami.preferences.IPreference;

import org.gvsig.andami.preferences.IPreferenceExtension;

import org.gvsig.app.ApplicationLocator;

import org.gvsig.app.ApplicationManager;

import org.gvsig.app.gui.preferencespage.ViewPage;

import org.gvsig.app.gui.preferencespage.dal.DALPage;

import org.gvsig.app.gui.preferencespage.databaseworkspace.DatabaseWorkspacePage;

import org.gvsig.app.gui.preferencespage.dialogreminder.DialogReminderPage;

import org.gvsig.app.project.Project;

import org.gvsig.app.project.ProjectManager;

import org.gvsig.app.project.documents.view.Encuadrator;

import org.gvsig.app.project.documents.view.ViewDocument;

import org.gvsig.app.project.documents.view.ViewManager;

import org.gvsig.app.project.documents.view.gui.ExtentListSelectorModel;

import org.gvsig.app.project.documents.view.gui.FPanelExtentSelector;

import org.gvsig.app.project.documents.view.gui.FPanelLocConfig;

import org.gvsig.app.project.documents.view.gui.IView;

import org.gvsig.app.project.documents.view.toc.gui.FPopupMenu;

import org.gvsig.fmap.geom.primitive.Envelope;

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.fmap.mapcontext.layers.FLayer;

import org.gvsig.fmap.mapcontext.layers.FLayers;

import org.gvsig.fmap.mapcontrol.MapControl;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.DataTypes;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Extensi?n que controla las operaciones b?sicas realizadas sobre la vista.

 *

 */

public class ViewControls extends Extension implements IPreferenceExtension {

    private static final Logger logger = LoggerFactory

            .getLogger(ViewInvertSelection.class);

    private static ViewPage viewPropertiesPage = null;

    public void execute(String s) {

        execute(s, null);

    }

    public void execute(String command, Object[] args) {

        ApplicationManager application = ApplicationLocator.getManager();

        IView view = (IView) application.getActiveComponent(ViewDocument.class);

        if (view == null) {

            return;

        }

        ViewDocument document = view.getViewDocument();

        MapContext mapa = document.getMapContext();

        MapControl mapCtrl = view.getMapControl();

        if (command.equalsIgnoreCase("view-navigation-zoom-all")) {

            Envelope all = mapa.getLayers().getFullEnvelope();

            if (all != null && !all.isEmpty()) {

                mapa.getViewPort().setEnvelope(all);

                document.setModified(true);

            }

        } else if (command.equalsIgnoreCase("view-navigation-frame-manager")) {

            FPanelExtentSelector l = new FPanelExtentSelector();

            ProjectExtension p = (ProjectExtension) PluginServices.getExtension(org.gvsig.app.extension.ProjectExtension.class);

            Project project = p.getProject();

            ExtentListSelectorModel modelo = new ExtentListSelectorModel(project);

            project.addPropertyChangeListener(modelo);

            l.setModel(modelo);

            l.addSelectionListener(new Encuadrator(project, mapa, view));

            document.setModified(true);

            PluginServices.getMDIManager().addWindow(l);

        } else if (command.equalsIgnoreCase("view-locator-setup")) {

            FPanelLocConfig m_panelLoc = new FPanelLocConfig(view.getMapOverview());

            PluginServices.getMDIManager().addCentredWindow(m_panelLoc);

            document.setModified(true);

        } else if (command.equalsIgnoreCase("view-navigation-pan")) {

            mapCtrl.setTool("pan");

            document.setModified(true);

        } else if (command.equalsIgnoreCase("view-navigation-zoom-in-topoint")) {

            mapCtrl.setTool("zoomIn");

            document.setModified(true);

        } else if (command.equalsIgnoreCase("view-navigation-zoom-out-topoint")) {

            mapCtrl.setTool("zoomOut");

            document.setModified(true);

        } else if (command.equalsIgnoreCase("layer-set-visible")) {

            setVisibles(true, mapa.getLayers());

            document.setModified(true);

            application.refreshMenusAndToolBars();

        } else if (command.equalsIgnoreCase("active-layer-set-hide")) {

            setActivesVisibles(false, mapa.getLayers());

            document.setModified(true);

            application.refreshMenusAndToolBars();

        } else if (command.equalsIgnoreCase("active-layer-set-visible")) {

            setActivesVisibles(true, mapa.getLayers());

            document.setModified(true);

            application.refreshMenusAndToolBars();

        } else if (command.equalsIgnoreCase("active-layer-bring-front")) {

            FLayers layers = mapa.getLayers();

            List<FLayer> orderedLayers = bringToFront(layers);

            if(orderedLayers != null){

                layers.clearLayers();

                layers.addAll(orderedLayers);

            }

            document.setModified(true);

            application.refreshMenusAndToolBars();

        } else if (command.equalsIgnoreCase("active-layer-send-back")) {

            FLayers layers = mapa.getLayers();

            List<FLayer> orderedLayers = sendToBack(layers);

            if(orderedLayers != null){

                layers.clearLayers();

                layers.addAll(orderedLayers);

            }

            document.setModified(true);

            application.refreshMenusAndToolBars();

        } else if (command.equalsIgnoreCase("active-layer-move-ahead")) {

            moveAhead(mapa.getLayers());

            document.setModified(true);

            application.refreshMenusAndToolBars();

        } else if (command.equalsIgnoreCase("active-layer-move-behind")) {

            moveBehind(mapa.getLayers());

            document.setModified(true);

            application.refreshMenusAndToolBars();

        } else if (command.equalsIgnoreCase("layer-set-hide")) {

            setVisibles(false, mapa.getLayers());

            document.setModified(true);

            application.refreshMenusAndToolBars();

        } else if (command.equalsIgnoreCase("layer-set-active")) {

            setActives(true, mapa.getLayers());

            document.setModified(true);

            application.refreshMenusAndToolBars();

        } else if (command.equalsIgnoreCase("layer-set-inactive")) {

            setActives(false, mapa.getLayers());

            document.setModified(true);

            application.refreshMenusAndToolBars();

        } else if (command.equalsIgnoreCase("group-set-active-all-layers")) {

            for (FLayer active : mapa.getLayers().getActives()) {

                if(active instanceof FLayers){

                    ((FLayers) active).setActive(true, true);

                }

            }

            document.setModified(true);

            application.refreshMenusAndToolBars();

        } else if (command.equalsIgnoreCase("group-set-inactive-all-layers")) {

            for (FLayer active : mapa.getLayers().getActives()) {

                if(active instanceof FLayers){

                    ((FLayers) active).setActive(false, true);

                    ((FLayers) active).setActive(true, false);

                }

            }

            document.setModified(true);

            application.refreshMenusAndToolBars();

        } else if (command.equalsIgnoreCase("view-navigation-zoom-in-center")) {

            mapCtrl.zoomIn();

            document.setModified(true);

        } else if (command.equalsIgnoreCase("view-navigation-zoom-out-center")) {

            mapCtrl.zoomOut();

            document.setModified(true);

        } else if (command.equalsIgnoreCase("view-change-scale")) {

            try {

                Long newscale = (Long) ToolsLocator.getDataTypesManager().coerce(DataTypes.LONG, args[0]);

                long prevscale = mapa.getScaleView();

                mapa.setScaleView(newscale);

                if(prevscale != newscale) {

                    document.setModified(true);

                }

            } catch (Throwable ex) {

                logger.info("Can't change scale of view.", ex);

                application.message("Can't change scale of view.", JOptionPane.ERROR_MESSAGE);

            }

        }

    }

    private ViewPage getViewPropertiesPage() {

        if (viewPropertiesPage == null) {

            viewPropertiesPage = new ViewPage();

        }

        return viewPropertiesPage;

    }

    /**

     * Pone todas las capas visibles o no visibles.

     *

     * @param visible true si que quieren poner a visibles.

     * @param mapa FMap sobre el que actuar.

     */

    private void setVisibles(boolean visible, FLayers layers) {

        int layerCount = layers.getLayersCount();

        for (int i = 0; i < layerCount; i++) {

            FLayer layer = layers.getLayer(i);

            layer.setVisible(visible);

            if (layer instanceof FLayers) {

                setVisibles(visible, (FLayers) layer);

            }

        }

    }

    public static void setActivesVisibles(boolean visible, FLayers layers) {

        int layerCount = layers.getLayersCount();

        for (int i = 0; i < layerCount; i++) {

            FLayer layer = layers.getLayer(i);

            if (layer.isActive()) {

                layer.setVisible(visible);

            }

            if (layer instanceof FLayers) {

                setActivesVisibles(visible, (FLayers) layer);

            }

        }

    }

    /**

     * Pone todas las capas activas o no activas.

     *

     * @param active true si que quieren poner a activas.

     * @param mapa FMap sobre el que actuar.

     */

    private void setActives(boolean active, FLayers layers) {

        int layerCount = layers.getLayersCount();

        for (int i = 0; i < layerCount; i++) {

            FLayer layer = layers.getLayer(i);

            layer.setActive(active);

            if (layer instanceof FLayers) {

                setActives(active, (FLayers) layer);

            }

        }

    }

    public boolean isVisible() {

        ApplicationManager application = ApplicationLocator.getManager();

        IView view = (IView) application.getActiveComponent(ViewDocument.class);

        if (view == null) {

            return false;

        }

        ViewDocument document = view.getViewDocument();

        MapContext mapa = document.getMapContext();

        return mapa.getLayers().getLayersCount() > 0;

    }

    public void initialize() {

        registerIcons();

    }

    public void postInitialize() {

        FPopupMenu.registerExtensionPoint();

        ProjectManager projectManager = ApplicationLocator.getProjectManager();

        ViewManager viewManager = (ViewManager) projectManager.getDocumentManager(ViewManager.TYPENAME);

        viewManager.addTOCContextAction("view-layer-add");

    }

    private void registerIcons() {

        IconThemeHelper.registerIcon("action", "view-navigation-zoom-in-topoint", this);

        IconThemeHelper.registerIcon("action", "view-navigation-zoom-out-topoint", this);

        IconThemeHelper.registerIcon("action", "view-navigation-zoom-all", this);

        IconThemeHelper.registerIcon("action", "view-navigation-zoom-in-center", this);

        IconThemeHelper.registerIcon("action", "view-navigation-zoom-out-center", this);

        IconThemeHelper.registerIcon("action", "view-navigation-pan", this);

        IconThemeHelper.registerIcon("action", "view-navigation-frame-manager", this);

        IconThemeHelper.registerIcon("action", "edit-undo-redo-actions-modify", this);

        IconThemeHelper.registerIcon("action", "edit-undo-redo-actions-add", this);

        IconThemeHelper.registerIcon("action", "edit-undo-redo-actions-delete", this);

        IconThemeHelper.registerIcon("preferences", "dialog-remember-preferences", this);

        IconThemeHelper.registerIcon("preferences", "dal-preferences", this);

        IconThemeHelper.registerIcon("preferences", "databaseworkspace-preferences", this);

    }

    public boolean isEnabled() {

        ApplicationManager application = ApplicationLocator.getManager();

        IView view = (IView) application.getActiveComponent(ViewDocument.class);

        if (view == null) {

            return false;

        }

        ViewDocument document = view.getViewDocument();

        MapContext mapa = document.getMapContext();

        FLayers layers = mapa.getLayers();

        for (int i = 0; i < layers.getLayersCount(); i++) {

            if (layers.getLayer(i).isAvailable()) {

                return true;

            }

        }

        return false;

    }

    @Override

    public IPreference[] getPreferencesPages() {

        List<IPreference> prefs = new ArrayList<>();

        prefs.add(getViewPropertiesPage());

        prefs.add(new DialogReminderPage());

        prefs.add(new DALPage());

        prefs.add(new DatabaseWorkspacePage());

        return prefs.toArray(new IPreference[prefs.size()]);

    }

    private List<FLayer> bringToFront(FLayers groupLayers) {

        List<FLayer> res = new ArrayList<>();

        List<FLayer> activeLayers = new ArrayList<>();

        List<FLayer> nonActiveLayers = new ArrayList<>();

        for (FLayer layer : groupLayers) {

            if(layer.isActive()){

                activeLayers.add(layer);

            } else {

                nonActiveLayers.add(layer);

            }

            if(layer instanceof FLayers){

                FLayers group = (FLayers)layer;

                List<FLayer> layers = bringToFront(group);

                if(layers != null){

                    group.clearLayers(); //NOTE: Don't use clear method because also remove metadata 

                    group.addAll(layers);

                }

            }

        }

        if(activeLayers.isEmpty() || nonActiveLayers.isEmpty()){

            return null;

        }

        res.addAll(nonActiveLayers);

        res.addAll(activeLayers);

        return res;

    }

    private List<FLayer> sendToBack(FLayers groupLayers) {

        List<FLayer> res = new ArrayList<>();

        List<FLayer> activeLayers = new ArrayList<>();

        List<FLayer> nonActiveLayers = new ArrayList<>();

        for (FLayer layer : groupLayers) {

            if(layer.isActive()){

                activeLayers.add(layer);

            } else {

                nonActiveLayers.add(layer);

            }

            if(layer instanceof FLayers){

                FLayers group = (FLayers)layer;

                List<FLayer> layers = sendToBack(group);

                if(layers != null){

                    group.clearLayers(); //NOTE: Don't use clear method because also remove metadata 

                    group.addAll(layers);

                }

            }

        }

        if(activeLayers.isEmpty() || nonActiveLayers.isEmpty()){

            return null;

        }

        res.addAll(activeLayers);

        res.addAll(nonActiveLayers);

        return res;

    }

    private int getPositionInFlayersGroup(FLayers groupLayers, FLayer layer) {

        for (int i = 0; i < groupLayers.getLayersCount(); i++) {

            FLayer actualLayer = groupLayers.getLayer(i);

            if (actualLayer.equals(layer)) {

                int correction = groupLayers.getLayersCount() - 1 - i;

                return correction;

            }

        }

        return -1;

    }

    private int getValidTocPosition(int position, FLayers groupLayers, int move) {

        int totalSize = groupLayers.getLayersCount();

        int newPosition = position + move;

        if (newPosition <= 0) {

            return 0;

        }

        if (newPosition >= totalSize) {

            return totalSize - 1;

        }

        return newPosition;

    }

    private List<FLayer> getFirstLevelActivesFromLayers(FLayers groupLayers, boolean reverse) {

        ArrayList<FLayer> actives = new ArrayList<>();

        for (FLayer layer : groupLayers) {

            if (layer.isActive()) {

                actives.add(layer);

            }

        }

        if (reverse) {

            Collections.reverse(actives);

        }

        return actives;

    }

    private List<FLayers> getFirstLevelGroupsFromLayers(FLayers groupLayers) {

        ArrayList<FLayers> flayers = new ArrayList<>();

        for (FLayer layer : groupLayers) {

            if (layer instanceof FLayers) {

                flayers.add((FLayers) layer);

            }

        }

        Collections.reverse(flayers);

        return flayers;

    }

    private void moveAhead(FLayers groupLayers) {

        List<FLayer> actives = getFirstLevelActivesFromLayers(groupLayers, true);

        for (FLayer layer : actives) {

            FLayers layers = layer.getParentLayer();

            int position = this.getPositionInFlayersGroup(layers, layer);

            if( position < 1 ) {

                FLayers layersParent = layers.getParentLayer();

                if( layersParent!=null ) {

                    int layersPosition = this.getPositionInFlayersGroup(layersParent, layers);

                    layersParent.add(layersParent.size() - layersPosition, layer);

                    layers.remove(layer);

                }

            } else {

                int newPosition =  getValidTocPosition(position, layers, -1);

                layers.moveTo(position,newPosition);

            }

        }

        List<FLayers> flayersGroup = getFirstLevelGroupsFromLayers(groupLayers);

        for (FLayers fLayer : flayersGroup) {

            this.moveAhead(fLayer);

        }

    }

    private void moveBehind(FLayers groupLayers) {

        List<FLayer> actives = getFirstLevelActivesFromLayers(groupLayers, false);

        for (FLayer layer : actives) {

            FLayers layers = layer.getParentLayer();

            int position = this.getPositionInFlayersGroup(layers, layer);

            if( position >= layers.size()-1 ) {

                FLayers layersParent = layers.getParentLayer();

                if( layersParent!=null ) {

                    int layersPosition = this.getPositionInFlayersGroup(layersParent, layers);

                    layersParent.add(layersParent.size() - layersPosition - 1, layer);

                    layers.remove(layer);

                }

            } else {

                int newPosition =  getValidTocPosition(position, layers, +1);

                layers.moveTo(position, newPosition);

            }

        }

        List<FLayers> flayersGroup = getFirstLevelGroupsFromLayers(groupLayers);

        for (FLayers fLayer : flayersGroup) {

            this.moveBehind(fLayer);

        }

    }

}