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.project.documents.view;

import java.text.NumberFormat;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Comparator;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import javax.swing.ImageIcon;

import org.apache.commons.lang3.StringUtils;

import org.apache.commons.lang3.tuple.ImmutablePair;

import org.apache.commons.lang3.tuple.Pair;

import org.gvsig.andami.IconThemeHelper;

import org.gvsig.andami.PluginServices;

import org.gvsig.andami.PluginsLocator;

import org.gvsig.andami.actioninfo.ActionInfo;

import org.gvsig.andami.actioninfo.ActionInfoManager;

import org.gvsig.andami.messages.NotificationManager;

import org.gvsig.andami.ui.mdiManager.IWindow;

import org.gvsig.app.project.Project;

import org.gvsig.app.project.ProjectManager;

import org.gvsig.app.project.documents.AbstractDocument;

import org.gvsig.app.project.documents.AbstractDocumentManager;

import org.gvsig.app.project.documents.Document;

import org.gvsig.app.project.documents.actions.CopyDocumentAction;

import org.gvsig.app.project.documents.actions.CutDocumentAction;

import org.gvsig.app.project.documents.actions.PasteDocumentAction;

import org.gvsig.app.project.documents.gui.IDocumentWindow;

import org.gvsig.app.project.documents.gui.WindowLayout;

import org.gvsig.app.project.documents.view.dalactions.AddFilterToLayerAction.AddFilterToLayerActionFactory;

import org.gvsig.app.project.documents.view.dalactions.CreateTemporalLayerAction;

import org.gvsig.app.project.documents.view.dalactions.ViewZoomAction.ViewZoomActionFactory;

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

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

import org.gvsig.app.project.documents.view.toc.AbstractActionInfoAdapterToTocContextMenuAction;

import org.gvsig.app.project.documents.view.toc.AbstractTocContextMenuAction;

import org.gvsig.app.project.documents.view.toc.ITocItem;

import org.gvsig.app.project.documents.view.toc.TocItemBranch;

import org.gvsig.app.project.documents.view.toc.actions.OldTocContextMenuAction;

import org.gvsig.fmap.dal.AbstractStoresRepository;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.feature.FeatureStore;

import org.gvsig.fmap.dal.feature.FeatureType;

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.fmap.mapcontext.MapContextLocator;

import org.gvsig.fmap.mapcontext.MapContextManager;

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

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

import org.gvsig.fmap.mapcontext.layers.vectorial.FLyrVect;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.extensionpoint.ExtensionBuilder;

import org.gvsig.tools.extensionpoint.ExtensionPoint;

import org.gvsig.tools.extensionpoint.ExtensionPointManager;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.util.UnmodifiableBasicSet;

import org.gvsig.tools.util.UnmodifiableBasicSetAdapter;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Factory of View.

 *

 * @author gvSIG Team

 *

 */

public class ViewManager extends AbstractDocumentManager {

    private static final Logger LOGGER = LoggerFactory.getLogger(ViewManager.class);

    private static class ViewDocumentStoresRepository extends AbstractStoresRepository {

        public ViewDocumentStoresRepository(String name) {

            super(name);

        }

        private List<ViewDocument> getOrderedViews() {

            Project project = ProjectManager.getInstance().getCurrentProject();

            List<Document> allViews = project.getDocuments(TYPENAME);

            List<Document> openViews = project.getOpenDocuments(TYPENAME);

            List<ViewDocument> views = new ArrayList<>();

            for (Document view : openViews) {

                views.add((ViewDocument) view);

            }

            for (Document view : allViews) {

                if( !openViews.contains(view) ) {

                    views.add((ViewDocument) view);

                }

            }

            return views;

        }

        private Map<String, Pair<DataStoreParameters,DataStore>> getAll() {

            Map<String, Pair<DataStoreParameters,DataStore>> all = new HashMap<>();

            List<ViewDocument> views = getOrderedViews();

            for (ViewDocument view : views) {

                for (FLayer layer : view.layers()) {

                    if (layer instanceof FLyrVect) {

                        FeatureStore store = ((FLyrVect) layer).getFeatureStore();

                        if (store!=null ) {

                            String theName = layer.getName();

                            if( all.containsKey(theName) ) {

                                theName = theName+"$";

                                int  counter = 1;

                                while( all.containsKey(theName+counter) ) {

                                    counter++;

                                }

                                theName = theName+counter;

                            }

                                all.put(theName, new ImmutablePair<>(store.getParameters(),store));

                        }

                    }

                }

            }

            if (all.isEmpty()) {

                return null;

            }

            return all;

        }

        private Map<String, Pair<FeatureType,FeatureStore>> getAllFeatureTypes() {

            Map<String, Pair<FeatureType,FeatureStore>> all = new HashMap<>();

            Project project = ProjectManager.getInstance().getCurrentProject();

            List<Document> views = project.getDocuments(TYPENAME);

//            MutablePair<DataStore,String> storeAndName = new MutablePair<>();

            for (Document view : views) {

                for (FLayer layer : ((ViewDocument) view).layers()) {

                    if (layer instanceof FLyrVect) {

                        FeatureStore store = ((FLyrVect) layer).getFeatureStore();

                        if (store!=null ) {

                            String theName = layer.getName();

                            if( all.containsKey(theName) ) {

                                theName = theName+"$";

                                int  counter = 1;

                                while( all.containsKey(theName+counter) ) {

                                    counter++;

                                }

                                theName = theName+counter;

                            }

//                            storeAndName.setLeft(store);

//                            storeAndName.setRight(theName);

//                            if( filter == null || filter.test(storeAndName) ) {

                                all.put(theName, new ImmutablePair<>(store.getDefaultFeatureTypeQuietly(),store));

//                            }

                        }

                    }

//                    if (limit > 0 && all.size() >= limit) {

//                        break;

//                    }

                }

            }

            if (all.isEmpty()) {

                return null;

            }

            return all;

        }

        @Override

        protected DataStoreParameters getMyParameters(final String name) {

            Map<String, Pair<DataStoreParameters, DataStore>> all = this.getAll();

            if (all == null) {

                return null;

            }

            Pair<DataStoreParameters, DataStore> data = all.get(name);

            if( data == null ) {

                return null;

            }

            return data.getLeft();

        }

        @Override

        protected FeatureType getMyFeatureType(String name) {

            Map<String, Pair<FeatureType, FeatureStore>> all = this.getAllFeatureTypes();

            if (all == null) {

                return null;

            }

            Pair<FeatureType, FeatureStore> data = all.get(name);

            if( data == null ) {

                return null;

            }

            return all.get(name).getLeft();

        }

        @Override

        public DataStore getStore(String name) {

            Map<String, Pair<DataStoreParameters, DataStore>> all = this.getAll();

            if (all == null) {

                return null;

            }

            Pair<DataStoreParameters, DataStore> data = all.get(name);

            if( data == null ) {

                return null;

            }

            return data.getRight();

        }

        @Override

        public boolean containsKey(final String key) {

            Map<String, Pair<DataStoreParameters, DataStore>> all =this.getAll();

            if (all == null) {

                return false;

            }

            return all.containsKey(key);

        }

        @Override

        protected UnmodifiableBasicSet<String> getMyKeySet() {

            Map<String, Pair<DataStoreParameters, DataStore>> all = this.getAll();

            if (all == null) {

                return null;

            }

            return new UnmodifiableBasicSetAdapter<>(all.keySet());

        }

        @Override

        protected boolean isEmptyMyRepository() {

            Map<String, Pair<DataStoreParameters, DataStore>> all = this.getAll();

            return all.isEmpty();

        }

        @Override

        protected int getMySize() {

            Map<String, Pair<DataStoreParameters, DataStore>> all = this.getAll();

            return all.size();

        }

        @Override

        public Iterator<DataStoreParameters> iterator() {

            Map<String, Pair<DataStoreParameters, DataStore>> all = this.getAll();

            Iterator<Pair<DataStoreParameters, DataStore>> it = all.values().iterator();

            return new Iterator<DataStoreParameters>() {

                @Override

                public boolean hasNext() {

                    return it.hasNext();

                }

                @Override

                public DataStoreParameters next() {

                    return it.next().getLeft();

                }

            };

        }

        public static void selfRegister() {

            DataManager dataManager = DALLocator.getDataManager();

            dataManager.getStoresRepository().addRepository(new ViewDocumentStoresRepository("Project layers"));            

        }

    }

    private static final String PERSISTENCE_VIEW_DOCUMENT_DEFINITION_NAME

            = "DefaultViewDocument";

    public static String TYPENAME = "project.document.view2d";

    private DynStruct persistenceDefinition;

    private static int countSeparators = 0;

    public ViewManager() {

        // Do nothing

    }

    @Override

    public int getPriority() {

        return 0;

    }

    @Override

    public ImageIcon getIcon() {

        return PluginServices.getIconTheme().get("document-view-icon");

    }

    @Override

    public ImageIcon getIconSelected() {

        return PluginServices.getIconTheme().get("document-view-icon-sel");

    }

    @Override

    public String getTitle() {

        return PluginServices.getText(this, "Vista");

    }

    @Override

    public String getTypeName() {

        return TYPENAME;

    }

    @Override

    public Class getMainWindowClass() {

        return DefaultViewPanel.class;

    }

    @Override

    public AbstractDocument createDocument() {

        AbstractDocument doc = new DefaultViewDocument(this);

        if (this.notifyObservers(NOTIFY_AFTER_CREATEDOCUMENT, doc).isCanceled()) {

            return null;

        }

        return doc;

    }

    @Override

    public IWindow getMainWindow(Document doc, WindowLayout layout) {

        IDocumentWindow win = (IDocumentWindow) super.getMainWindow(doc, layout);

        if (win == null) {

            win = this.createDocumentWindow(doc);

            if (layout != null && win != null) {

                win.setWindowLayout(layout);

            }

            if (this.notifyObservers(NOTIFY_AFTER_CREATEMAINWINDOW, win).isCanceled()) {

                return null;

            }

        }

        if (this.notifyObservers(NOTIFY_AFTER_GETMAINWINDOW, win).isCanceled()) {

            return null;

        }

        ((AbstractDocument) doc).raiseEventCreateWindow(win);

        return win;

    }

    @Override

    public IWindow getPropertiesWindow(Document doc) {

        IWindow win = super.getPropertiesWindow(doc);

        if (win == null) {

            win = new ViewProperties((DefaultViewDocument) doc);

            if (this.notifyObservers(NOTIFY_AFTER_CREATEPROPERTIESWINDOW, win).isCanceled()) {

                return null;

            }

        }

        if (this.notifyObservers(NOTIFY_AFTER_GETPROPERTIESWINDOW, win).isCanceled()) {

            return null;

        }

        return win;

    }

    public void addTOCContextAction(String theAction) {

        ActionInfoManager actionManager = PluginsLocator.getActionInfoManager();

        ActionInfo action = actionManager.getAction(theAction);

        if (action == null) {

            String errmsg = "Action '" + theAction + "' not found";

            LOGGER.info(errmsg);

            throw new RuntimeException(errmsg);

        }

        this.addTOCContextAction(action);

    }

    public void addTOCContextAction(String theAction, String group, int groupOrder, int order) {

        ActionInfoManager actionManager = PluginsLocator.getActionInfoManager();

        ActionInfo action = actionManager.getAction(theAction);

        if (action == null) {

            String errmsg = "Action '" + theAction + "' not found";

            LOGGER.info(errmsg);

            throw new RuntimeException(errmsg);

        }

        this.addTOCContextAction(

                action.getName(),

                new ActionInfoAdapterToContextMenuAction(action, group, groupOrder, order)

        );

    }

    public void addTOCContextAction(ActionInfo action) {

        this.addTOCContextAction(action.getName(), new ActionInfoAdapterToContextMenuAction(action, "default", 9000));

    }

    public void addTOCContextAction(ActionInfo action, String group, int groupOrder) {

        this.addTOCContextAction(action.getName(), new ActionInfoAdapterToContextMenuAction(action, group, groupOrder));

    }

    public void addTOCSeparator(String group, int groupOrder, int order) {

        String effectiveGroup = group + "/-" + (countSeparators++) + "-";

        this.addTOCContextAction(

//            group + "/-",

            effectiveGroup,    

            new IContextMenuAction() {

                @Override

                public boolean isVisible(Object item, Object[] selectedItems) {

                    return true;

                }

                @Override

                public boolean isEnabled(Object item, Object[] selectedItems) {

                    return true;

                }

                @Override

                public void execute(Object item, Object[] selectedItems) {

                }

                @Override

                public String getGroup() {

                    return effectiveGroup; //group + "/-";

                }

                @Override

                public int getGroupOrder() {

                    return groupOrder;

                }

                @Override

                public int getOrder() {

                    return order;

                }

                @Override

                public String getText() {

                    return "-";

                }

                @Override

                public String getDescription() {

                    return "";

                }

            }

        );

    }

    class ActionInfoAdapterToContextMenuAction extends AbstractActionInfoAdapterToTocContextMenuAction {

        ActionInfoAdapterToContextMenuAction(ActionInfo action, String group, int groupOrder) {

            super(action, group, groupOrder);

        }

        ActionInfoAdapterToContextMenuAction(ActionInfo action, String group, int groupOrder, int order) {

            super(action, group, groupOrder, order);

        }

    }

    /**

     * @deprecated use addTOCContextAction(ActionInfo action, String group, int

     * groupOrder)

     * @param id

     * @param action

     */

    public void addTOCContextAction(String id, IContextMenuAction action) {

        initializeRegisterTOCActions();

        ExtensionPoint exPoint = ToolsLocator.getExtensionPointManager().add(

                "View_TocActions", "");

        if (action instanceof ExtensionBuilder) {

            exPoint.append(id, "", (ExtensionBuilder) action);

            return;

        }

        exPoint.append(id, "", new ContextMenuActionAdapterToExtensionBuilder(action));

    }

    class ContextMenuActionAdapterToExtensionBuilder implements ExtensionBuilder {

        IContextMenuAction menuAction = null;

        ContextMenuActionAdapterToExtensionBuilder(IContextMenuAction menuAction) {

            this.menuAction = menuAction;

        }

        @Override

        public Object create() {

            return this.menuAction;

        }

        @Override

        public Object create(Object[] args) {

            return this.menuAction;

        }

        @Override

        public Object create(Map args) {

            return this.menuAction;

        }

    }

    private static void initializeRegisterTOCActions() {

        ExtensionPointManager epManager = ToolsLocator.getExtensionPointManager();

        if (!epManager.has("View_TocActions")) {

            epManager.add(

                    "View_TocActions",

                    "Context menu options of the TOC "

                    + " in the view window "

                    + "(register instances of "

                    + "org.gvsig.app.gui.toc.AbstractTocContextMenuAction)"

            );

        }

    }

    /**

     * Registers in the points of extension the Factory with alias.

     *

     */

    public static void register() {

        ViewManager factory = new ViewManager();

        ProjectManager.getInstance().registerDocumentFactory(factory);

        PersistenceManager manager = ToolsLocator.getPersistenceManager();

        manager.registerFactory(factory);

        initializeRegisterTOCActions();

        ProjectManager.getInstance().registerDocumentAction(TYPENAME, new CopyDocumentAction());

        ProjectManager.getInstance().registerDocumentAction(TYPENAME, new CutDocumentAction());

        ProjectManager.getInstance().registerDocumentAction(TYPENAME, new PasteDocumentAction());

        IconThemeHelper.registerIcon("document", "document-view-icon", ViewManager.class);

        IconThemeHelper.registerIcon("document", "document-view-icon-sel", ViewManager.class);

        IconThemeHelper.registerIcon("cursor", "cursor-busy", ViewManager.class);

        IconThemeHelper.registerIcon("cursor", "cursor-crux", ViewManager.class);

        IconThemeHelper.registerIcon("cursor", "cursor-info-by-point", ViewManager.class);

        IconThemeHelper.registerIcon("cursor", "cursor-pan", ViewManager.class);

        IconThemeHelper.registerIcon("cursor", "cursor-query-area", ViewManager.class);

        IconThemeHelper.registerIcon("cursor", "cursor-select-by-point", ViewManager.class);

        IconThemeHelper.registerIcon("cursor", "cursor-select-by-polygon", ViewManager.class);

        IconThemeHelper.registerIcon("cursor", "cursor-select-by-rectangle", ViewManager.class);

        IconThemeHelper.registerIcon("cursor", "cursor-zoom-in", ViewManager.class);

        IconThemeHelper.registerIcon("cursor", "cursor-zoom-out", ViewManager.class);

        IconThemeHelper.registerIcon("layer", "layer-icon", ViewManager.class);

        IconThemeHelper.registerIcon("layer", "layer-icon-group", ViewManager.class);

        IconThemeHelper.registerIcon("layer", "layer-icon-vectorial", ViewManager.class);

        IconThemeHelper.registerIcon("layer", "layer-icon-csv", ViewManager.class);

        IconThemeHelper.registerIcon("layer", "layer-icon-dgn", ViewManager.class);

        IconThemeHelper.registerIcon("layer", "layer-icon-dxf", ViewManager.class);

        IconThemeHelper.registerIcon("layer", "layer-icon-postgresql", ViewManager.class);

        IconThemeHelper.registerIcon("layer", "layer-icon-mysql", ViewManager.class);

        IconThemeHelper.registerIcon("layer", "layer-icon-jdbc", ViewManager.class);

        //IconThemeHelper.registerIcon("layer", "layer-icon-unavailable", ViewManager.class);

        IconThemeHelper.registerIcon("layer", "layer-chk-unavailable", ViewManager.class);

        IconThemeHelper.registerIcon("layer", "layer-chk-temporary", ViewManager.class);

        IconThemeHelper.registerIcon("action", "active-layer-bring-front", ViewManager.class);

        IconThemeHelper.registerIcon("action", "active-layer-move-ahead", ViewManager.class);

        IconThemeHelper.registerIcon("action", "active-layer-move-behind", ViewManager.class);

        IconThemeHelper.registerIcon("action", "active-layer-send-back", ViewManager.class);

        IconThemeHelper.registerIcon("action", "active-layer-set-hide", ViewManager.class);

        IconThemeHelper.registerIcon("action", "active-layer-set-visible", ViewManager.class);

        IconThemeHelper.registerIcon("action", "layer-set-visible", ViewManager.class);

        IconThemeHelper.registerIcon("action", "layer-set-hide", ViewManager.class);

        IconThemeHelper.registerIcon("action", "layer-set-inactive", ViewManager.class);

        IconThemeHelper.registerIcon("action", "layer-set-active", ViewManager.class);

        IconThemeHelper.registerIcon("legend", "legend-overview-single-symbol", ViewManager.class);

        IconThemeHelper.registerIcon("legend", "legend-overview-vectorial-interval", ViewManager.class);

        IconThemeHelper.registerIcon("legend", "legend-overview-vectorial-unique-value", ViewManager.class);

        MapContextManager mapContextMgr = MapContextLocator.getMapContextManager();

        mapContextMgr.registerIconLayer("CSV", "layer-icon-csv");

        mapContextMgr.registerIconLayer("DGN", "layer-icon-dgn");

        mapContextMgr.registerIconLayer("DXF", "layer-icon-dxf");

        mapContextMgr.registerIconLayer("jdbc", "layer-icon-jdbc");

        mapContextMgr.registerIconLayer("PostgreSQL", "layer-icon-postgresql");

        mapContextMgr.registerIconLayer("MySQL", "layer-icon-mysql");

        if (factory.persistenceDefinition == null) {

            factory.persistenceDefinition = manager.addDefinition(

                    ViewDocument.class,

                    PERSISTENCE_VIEW_DOCUMENT_DEFINITION_NAME,

                    "Default view document persistence definition",

                    null,

                    null

            );

            factory.persistenceDefinition.extend(manager.getDefinition(AbstractDocument.PERSISTENCE_DEFINITION_NAME));

            factory.persistenceDefinition.addDynFieldBoolean("useMapOverview").setMandatory(true);

            factory.persistenceDefinition.addDynFieldObject("mainMapContext").setClassOfValue(MapContext.class).setMandatory(true);

            factory.persistenceDefinition.addDynFieldObject("overviewMapContext").setClassOfValue(MapContext.class).setMandatory(false);

            factory.persistenceDefinition.addDynFieldObject("propertiesHelper").setClassOfValue(ExtendedPropertiesHelper.class)

                    .setMandatory(false);

        }

        ViewDocumentStoresRepository.selfRegister();

        ViewZoomActionFactory.selfRegister();

        AddFilterToLayerActionFactory.selfRegister();

        CreateTemporalLayerAction.CreateTemporalLayerActionFactory.selfRegister();

    }

    @SuppressWarnings("rawtypes")

    @Override

    public DynStruct getDefinition(String className) {

        if (this.persistenceDefinition.getName().equalsIgnoreCase(className)) {

            return this.persistenceDefinition;

        }

        if (this.persistenceDefinition.getFullName().equalsIgnoreCase(className)) {

            return this.persistenceDefinition;

        }

        if (this.getDocumentClass().getName().equals(className)) {

            return this.persistenceDefinition;

        }

        return null;

    }

    @SuppressWarnings("rawtypes")

    @Override

    protected Class getDocumentClass() {

        return DefaultViewDocument.class;

    }

    @Override

    public boolean manages(Object object) {

        return object instanceof ViewDocument;

    }

    public List<IContextMenuAction> getTOCContextMenuActions(MapContext mapContext, FLayer[] selecteds, ITocItem nodeUserObject) {

        List<IContextMenuAction> actions =  new ArrayList<>();

        ExtensionPoint exPoint = ToolsLocator.getExtensionPointManager().add("View_TocActions", "");

        Iterator<org.gvsig.tools.extensionpoint.ExtensionPoint.Extension> iter = exPoint.iterator();

        IContextMenuAction action;

        boolean contains = false;

        ITocItem tocItem = nodeUserObject;

        if (tocItem instanceof TocItemBranch) {

            for (int i = 0; i < selecteds.length; i++) {

                if (selecteds[i].equals(((TocItemBranch) tocItem)

                    .getLayer())) {

                    contains = true;

                    break;

                }

            }

        } else {

            contains = true;

        }

        if (contains) {

            while (iter.hasNext()) {

                action = null;

                try {

                    action = (IContextMenuAction) iter.next().create();

                } catch (Exception e) {

                    NotificationManager.addError(e);

                }

                if (action != null ) {

                        if( action instanceof AbstractTocContextMenuAction

                                && !(action instanceof OldTocContextMenuAction)) {

                                ((AbstractTocContextMenuAction)action).setMapContext(mapContext);

                        }

                    if (action.isVisible(nodeUserObject,

                        selecteds)) {

                        actions.add(action);

                    }

                }

            }

            Collections.sort(actions, new CompareAction());

            return actions;

        }

        return null;

    }

    private class CompareAction implements Comparator<IContextMenuAction> {

        public int compare(IContextMenuAction o1, IContextMenuAction o2) {

            // FIXME: falta formatear los enteros!!!!

            NumberFormat formater = NumberFormat.getInstance();

            formater.setMinimumIntegerDigits(6);

            String key1 =

                "" + formater.format(o1.getGroupOrder()) + formater.format(o1.getOrder()) + o1.getGroup();

            String key2 =

                "" + formater.format(o2.getGroupOrder()) + formater.format(o2.getOrder()) + o2.getGroup();

            return key1.compareTo(key2);

        }

    }

    public boolean existsTOCContextMenuActions(String name) {

        ExtensionPoint exPoint = ToolsLocator.getExtensionPointManager().add("View_TocActions", "");

        Iterator<org.gvsig.tools.extensionpoint.ExtensionPoint.Extension> iter = exPoint.iterator();

        while (iter.hasNext()) {

            ExtensionPoint.Extension action = iter.next();

            if (action != null ) {

                if(StringUtils.equalsIgnoreCase(name, action.getName())){

                    return true;

                }

            }

        }

        return false;

    }

}