Application: gvSIG desktop

import org.gvsig.symbology.swing.SymbologySwingManager;

    public void initialize() {

        // modules for symbol editor

        SymbologySwingManager symbologySwingManager = SymbologySwingLocator.getSwingManager();

        symbologySwingManager.registerSymbolEditor(SimpleFill.class, Geometry.TYPES.SURFACE);

        symbologySwingManager.registerSymbolEditor(SimpleMarker.class, Geometry.TYPES.POINT);

        symbologySwingManager.registerSymbolEditor(SimpleLine.class, Geometry.TYPES.CURVE);

        symbologySwingManager.registerSymbolEditor(SimpleFill.class, Geometry.TYPES.MULTISURFACE);

        symbologySwingManager.registerSymbolEditor(SimpleMarker.class, Geometry.TYPES.MULTIPOINT);

        symbologySwingManager.registerSymbolEditor(SimpleLine.class, Geometry.TYPES.MULTICURVE);

        //FIXME 

        symbologySwingManager.registerSymbolEditor(PictureMarker.class, Geometry.TYPES.POINT);

        symbologySwingManager.registerSymbolEditor(PictureLine.class, Geometry.TYPES.CURVE);

        symbologySwingManager.registerSymbolEditor(PictureFill.class, Geometry.TYPES.SURFACE);

        symbologySwingManager.registerSymbolEditor(MarkerFill.class, Geometry.TYPES.SURFACE);

        symbologySwingManager.registerSymbolEditor(PictureMarker.class, Geometry.TYPES.MULTIPOINT);

        symbologySwingManager.registerSymbolEditor(PictureLine.class, Geometry.TYPES.MULTICURVE);

        symbologySwingManager.registerSymbolEditor(PictureFill.class, Geometry.TYPES.MULTISURFACE);

        symbologySwingManager.registerSymbolEditor(MarkerFill.class, Geometry.TYPES.MULTISURFACE);

        // legends available 

        symbologySwingManager.registerLegendEditor(Quantities.class);

        symbologySwingManager.registerLegendEditor(Features.class);

        symbologySwingManager.registerLegendEditor(Categories.class);

        symbologySwingManager.registerLegendEditor(MultipleAttributes.class);

        symbologySwingManager.registerLegendEditor(SingleSymbol.class);

        symbologySwingManager.registerLegendEditor(VectorialInterval.class);

        symbologySwingManager.registerLegendEditor(VectorialUniqueValue.class);

        // labeling strategies (inverse order to the wanted to be shown)

        symbologySwingManager.registerLabelingEditor(AttrInTableLabeling.class);

        // pages

        ThemeManagerWindow.addPage(General.class);

        ThemeManagerWindow.addPage(LegendManager.class);

        ThemeManagerWindow.addPage(LabelingManager.class);

        ThemeManagerWindow.setTabEnabledForLayer(General.class, FLyrVect.class, true);

        ThemeManagerWindow.setTabEnabledForLayer(LegendManager.class, FLyrVect.class, true);

        ThemeManagerWindow.setTabEnabledForLayer(LabelingManager.class, FLyrVect.class, true);

        registerIcons();

    }

import java.util.List;

import org.gvsig.symbology.swing.SymbologySwingLocator;

import org.gvsig.symbology.swing.SymbologySwingManager;

//	private static ArrayList<Class<? extends ILabelingStrategyPanel>> installedPanels = new ArrayList<Class<? extends ILabelingStrategyPanel>>();

                SymbologySwingManager symbologySwingManager = SymbologySwingLocator.getSwingManager();

                Iterator<ILabelingStrategyPanel> it = symbologySwingManager.getLabelingEditors().iterator();

                while( it.hasNext() ) {

                    ILabelingStrategyPanel pnl = it.next();

                    strategyPanels.put(pnl.getLabelingStrategyClass(), pnl);

        /**

         * 

         * @deprecated use {#SymbolSwingManger.

         */

            SymbologySwingManager symbologySwingManager = SymbologySwingLocator.getSwingManager();

            symbologySwingManager.registerLabelingEditor(iLabelingStrategyPanelClass);

import java.util.Iterator;

import org.gvsig.symbology.swing.SymbologySwingLocator;

import org.gvsig.symbology.swing.SymbologySwingManager;

//    private static ArrayList<Class<? extends ILegendPanel>> legendPool =

//        new ArrayList<Class<? extends ILegendPanel>>();

     * @deprecated use SymbologySwingManager.registerLegendEditor

    public static void addLegendPage(Class<? extends ILegendPanel> iLegendPanelClass) {

        SymbologySwingManager manager = SymbologySwingLocator.getSwingManager();

        manager.registerLegendEditor(iLegendPanelClass);

            SymbologySwingManager manager = SymbologySwingLocator.getSwingManager();

            Iterator<ILegendPanel> it = manager.getLegendEditors(layer).iterator();

            while( it.hasNext() ) {

                ILegendPanel page = it.next();

                pages.put(page.getClass(), page); 

                ILegendPanel page = enume.nextElement();

 * 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.

import java.util.ArrayList;

import java.util.Collections;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Map;

import java.util.logging.Level;

import org.gvsig.app.gui.styling.TypeSymbolEditor;

import org.gvsig.app.project.documents.view.legend.gui.ILabelingStrategyPanel;

import org.gvsig.app.project.documents.view.legend.gui.ILegendPanel;

import org.gvsig.fmap.geom.type.GeometryType;

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

import org.gvsig.fmap.mapcontext.rendering.legend.styling.ILabelingStrategy;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.i18n.I18nManager;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

 *

        SymbologySwingManager {

    private static final Logger logger = LoggerFactory.getLogger(DefaultSymbologySwingManager.class);

    private I18nManager i18nmanager = null;

    private static Map<Integer, List<Class<? extends TypeSymbolEditor>>> symbolEditorRegistry;

    private List<Class<? extends ILegendPanel>> legendEditorRegistry = null;

    private List<Class<? extends ILabelingStrategyPanel>> labelingEditorRegistry = null;

        this.colorTablesFactory = new DefaultColorTablesFactory();

        this.legendEditorRegistry = new ArrayList<Class<? extends ILegendPanel>>();

        this.labelingEditorRegistry = new ArrayList<Class<? extends ILabelingStrategyPanel>>();

        if (this.i18nmanager == null) {

            this.i18nmanager = ToolsLocator.getI18nManager();

        }

        return this.i18nmanager.getTranslation(key);

    public void setColorTablesFactory(ColorTablesFactory factory) {

        colorTablesFactory = factory;

    }

    public List<ColorTablePainter> createColorTables() {

        if (colorTablesFactory != null) {

            return colorTablesFactory.createColorTables();

        }

        return null;

    }

    public ColorTablesFactory getColorTablesFactory() {

        return this.colorTablesFactory;

    }

    /**

     * @deprecated use registerTypeSymbolEditor

     */

    public void addSymbolEditorPanel(Class abstractTypeSymbolEditorPanelClass, int shapeType) {

        Class<? extends TypeSymbolEditor> symbolEditor = abstractTypeSymbolEditorPanelClass;

        this.registerSymbolEditor(symbolEditor, shapeType);

    }

    public void registerSymbolEditor(Class<? extends TypeSymbolEditor> symbolEditor, int shapeType) {

        if (symbolEditorRegistry == null) {

            symbolEditorRegistry = new HashMap<Integer, List<Class<? extends TypeSymbolEditor>>>();

        }

        Integer key = new Integer(shapeType);

        List<Class<? extends TypeSymbolEditor>> l = symbolEditorRegistry.get(key);

        if (l == null) {

            l = new ArrayList<Class<? extends TypeSymbolEditor>>();

        }

        l.add(symbolEditor);

        symbolEditorRegistry.put(key, l);

    }

    public List<Class<? extends TypeSymbolEditor>> getSymbolEditorClassesByGeometryType(GeometryType geometryType) {

        if (symbolEditorRegistry == null) {

            return Collections.emptyList();

        }

        Iterator it = symbolEditorRegistry.keySet().iterator();

        while (it.hasNext()) {

            int currentType = (Integer) it.next();

            if (geometryType.isTypeOf(currentType)) {

                return (List) symbolEditorRegistry.get(currentType);

            }

        }

        return Collections.emptyList();

    }

    public void registerLegendEditor(Class<? extends ILegendPanel> legendEditor) {

        if (this.legendEditorRegistry == null) {

            this.legendEditorRegistry = new ArrayList<Class<? extends ILegendPanel>>();

        }

        if (!this.legendEditorRegistry.contains(legendEditor)) {

            this.legendEditorRegistry.add(legendEditor);

        }

    }

    public List<Class<? extends ILegendPanel>> getLegendEditorClasses() {

        return Collections.unmodifiableList(this.legendEditorRegistry);

    }

    public List<ILegendPanel> getLegendEditors(FLayer layer) {

        List<ILegendPanel> editors = new ArrayList<ILegendPanel>();

        Class<? extends ILegendPanel> legendEditorClass = null;

        ILegendPanel editor = null;

        for (int i = 0; i < legendEditorRegistry.size(); i++) {

            legendEditorClass = legendEditorRegistry.get(i);

            try {

                editor = null;

                editor = (ILegendPanel) legendEditorClass.newInstance();

            } catch (Exception e) {

                logger.info("Unable to instantiate legend editor.", e);

            }

            if (editor != null && editor.isSuitableFor(layer)) {

                editors.add(editor);

            }

        }

        return editors;

    }

    public void registerLabelingEditor(Class<? extends ILabelingStrategyPanel> labelingEditor) {

        if (!this.labelingEditorRegistry.contains(labelingEditor)) {

            this.labelingEditorRegistry.add(labelingEditor);

        }

    }

    public List<ILabelingStrategyPanel> getLabelingEditors() {

        List<ILabelingStrategyPanel> labelingEditors = new ArrayList<ILabelingStrategyPanel>();

        Iterator<Class<? extends ILabelingStrategyPanel>> it = this.labelingEditorRegistry.iterator();

        while (it.hasNext()) {

            Class<? extends ILabelingStrategyPanel> labelingEditorClass = it.next();

            try {

                ILabelingStrategyPanel labelingEditor = labelingEditorClass.newInstance();

                labelingEditors.add(labelingEditor);

            } catch (Exception ex) {

                String msg = "Can't create the labeling editor associated to '"+labelingEditorClass.getName()+"'.";

                logger.warn(msg,ex);

                throw new RuntimeException(msg,ex);

            }

        }

        return labelingEditors;

    }

public abstract class AbstractTypeSymbolEditor implements TypeSymbolEditor {

import java.util.Map;

import org.gvsig.symbology.swing.SymbologySwingLocator;

import org.gvsig.symbology.swing.SymbologySwingManager;

                SymbologySwingManager symbologySwingManager = SymbologySwingLocator.getSwingManager();

		List editors = symbologySwingManager.getSymbolEditorClassesByGeometryType(shapeType);

        /**

         * @deprecated use SymblogySwingManager

         */

	public static void addSymbolEditorPanel(Class<? extends TypeSymbolEditor> symbolEditor, int shapeType) {

            SymbologySwingManager manager = SymbologySwingLocator.getSwingManager();

            manager.registerSymbolEditor(symbolEditor, shapeType);

        /**

         * @deprecated use SymblogySwingManager

         */

            SymbologySwingManager manager = SymbologySwingLocator.getSwingManager();

            return manager.getSymbolEditorClassesByGeometryType(geometryType);

/**

 * 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.gui.styling;

import javax.swing.JPanel;

import org.gvsig.fmap.mapcontext.rendering.symbols.ISymbol;

public interface TypeSymbolEditor {

    boolean canManageSymbol(ISymbol symbol);

    /**

     * Returns the editor tools that are handled by this configuration panel.

     * @return <b>EditorTool</b>

     */

    EditorTool[] getEditorTools();

    /**

     * Produces and returns  the ISymbol according with the user settings.

     *

     * @return the ISymbol.

     */

    ISymbol getLayer();

    /**

     * <p>

     * Returns the name of the config tabs that will be shown in the selector combo box.

     * This is typically a human-readable (and also translatable) name for the symbol that

     * this TypeEditorPanel deals with, but maybe you prefer to use any other one.<br>

     * </p>

     * <p>

     * The order of the entries in the combo is alphabetically-based. So you can force a

     * position by defining a name that suits your needs.

     * </p>

     * @return A human-readable text naming this panel

     */

    String getName();

    /**

     * <p>

     * Due to the complexity that many symbols settings can reach, the SymbolEditorPanel is

     * designed in a tabbed-based fashion. So, you can use as many of pages you want to put

     * your components. This pages are regular JPanels that will be automatically added to

     * the SymbolEditor dialog.<br>

     * </p>

     * <p>

     * In case you need only one page, just return a JPanel array with a length of 1.

     * </p>

     * @return An array of JPanel containing the setting's interface.

     */

    JPanel[] getTabs();

    /**

     * Invoked when the user selects or adds a new layer. This method fills up

     * the components on the right according on the layer properties

     * @param <b>ISymbol</b> layer, the symbol

     */

    void refreshControls(ISymbol layer);

}

/**

 * 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.legend.gui;

import javax.swing.ImageIcon;

import javax.swing.JPanel;

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

import org.gvsig.fmap.mapcontext.rendering.legend.ILegend;

/**

 * @author jaume dominguez faus - jaume.dominguez@iver.es

 *

 * Este interfaz es el que debe cumplir cualquier panel que empleemos

 * para confeccionar una leyenda. Se le pasa una capa para que

 * tome su leyenda, y con el m?todo getLegend tomamos la leyenda

 * que ha confeccionado el usuario.

 */

public interface ILegendPanel {

	/**

	 * Initializes the data required for this legend panel. That is, the layer that

	 * will adopt the changes and the current legend that this layer has. If the

	 * legend is not the type of legend that this panel manages then it initializes

	 * the panel with the default values. In case it is, then the panel should

	 * refresh its components with the current values of the Legend.

	 * @param lyr,  target layer

	 * @param legend, the legend currently applied to lyr

	 */

	public void setData(FLayer lyr, ILegend legend);

	/**

	 * Returns an instance of Legend

	 * @return Legend, the legend result of the settings

	 */

	public ILegend getLegend();

	/**

	 * Returns a brief human-readable description about what kind of legend builds this panel

	 * @return String with a brief description

	 */

	public String getDescription();

	/**

	 * Returns the icon which should graphically describe what this panel's legend does.

	 * @return ImageIcon with the icon to be displayed

	 */

	public ImageIcon getIcon();

	/**

	 * If this panel should appear as a subnode of the legends tree, in other words it is not

	 * a first-level node, then this method would return <b>its parent's class</b>. Otherwise, if

	 * it is a first-level node, then it will return <b>null</b>.

	 * @return String containing the parent's title.

	 */

	public Class getParentClass();

	/**

	 * Returns the title (a human-readable one) of this panel.

	 */

	public String getTitle();

	/**

	 * <p>If this is a complete panel (it is a child node in the legend tree) to set up a legend

	 * this method will return a <b>JPanel</b> containing the necessary components. Otherwise, if

	 * it is just a classification node (it has children) in the legend tree it will return

	 * just <b>null</b>.<br></p>

	 *

	 * <p>If <b>null</b> is returned, the ILegendPanel that will be shown and selected each time

	 * it is selected is the very first child of this parent node.</p>

	 */

	public JPanel getPanel();

	/**

	 * Returns the class of the legend produced by this ILegendPanel.

	 */

	public Class getLegendClass();

	/**

	 * Returns <b>true</b> if this legend is applicable to this layer, <b>false</b> otherwise.

	 */

	public boolean isSuitableFor(FLayer layer);

}

/**

 * 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.legend.gui;

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

import org.gvsig.fmap.mapcontext.rendering.legend.styling.ILabelingStrategy;

/**

 * Interface to be implemented for those panels whose purpose is to

 * set up labeling strategies.

 *

 * ILabelingStrategyPanel.java

 *

 *

 * @author jaume dominguez faus - jaume.dominguez@iver.es Jun 13, 2008

 *

 */

public interface ILabelingStrategyPanel {

	/**

	 * Invoked when de user accepts the settings, the returned value

	 * is a always ready-to-work labeling strategy.

	 *

	 * @return ILabelingStrategy, a labeling strategy completely set up.

	 */

	public ILabelingStrategy getLabelingStrategy();

	/**

	 * Sets the model of the panel. As a general contract, after invoke

	 * this method, the panel should be filled with all the values

	 * needed and be able to be repainted successfully.

	 *

	 * @param layer, the layer to whom the labeling strategy is associated.

	 * @param str, the current labeling strategy.

	 */

	public void setModel(FLayer layer, ILabelingStrategy str);

	/**

	 * A human-readable localized text to make this strategy easily

	 * recognizable among all the available strategies.

	 * @return

	 */

	public String getLabelingStrategyName();

	/**

	 * <p>

	 * The panel shown in the layer properties dialog is selected through

	 * the class of the labeling strategy. This method returns such class.

	 * <br>

	 * </p>

	 * <p>

	 * <b>Note</b> that, as a collateral effect, the panel that sets up a labeling strategy

	 * can be substituted programatically by other of your wish if

	 * you return the same labeling strategy class than the one to

	 * be replaced with your new one. The last panel installed, will

	 * be the one to be shown.

	 * </p>

	 * @return Class, the labeling strategy's Class

	 */

	public Class getLabelingStrategyClass();

}

import org.gvsig.app.gui.styling.TypeSymbolEditor;

import org.gvsig.app.project.documents.view.legend.gui.ILabelingStrategyPanel;

import org.gvsig.app.project.documents.view.legend.gui.ILegendPanel;

import org.gvsig.fmap.geom.type.GeometryType;

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

    public void registerSymbolEditor(Class<? extends TypeSymbolEditor> symbolEditor, int shapeType);

    public List<Class<? extends TypeSymbolEditor>> getSymbolEditorClassesByGeometryType(GeometryType geometryType);

    public void registerLegendEditor(Class<? extends ILegendPanel> legendEditor);

    public List<Class<? extends ILegendPanel>> getLegendEditorClasses();

    public List<ILegendPanel> getLegendEditors(FLayer layer);

    public void registerLabelingEditor(Class<? extends ILabelingStrategyPanel> labelingEditor);

    public List<ILabelingStrategyPanel> getLabelingEditors();