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.symbology.swing.impl;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Collections;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import javax.swing.Action;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.app.gui.labeling.LabelClassEditor;

import org.gvsig.app.gui.labeling.LabelClassEditorFactory;

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.dal.feature.FeatureStore;

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

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

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

import org.gvsig.gui.ColorTablePainter;

import org.gvsig.gui.ColorTablesFactory;

import org.gvsig.gui.DefaultColorTablesFactory;

import org.gvsig.symbology.SymbologyLocator;

import org.gvsig.symbology.SymbologyManager;

import org.gvsig.symbology.swing.SymbologySwingManager;

import org.gvsig.symbology.swing.SymbologyWindowManager;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.i18n.I18nManager;

/**

 * Default implementation of the {@link SymbologySwingManager}.

 *

 * @author gvSIG Team

 * @version $Id$

 */

@SuppressWarnings("UseSpecificCatch")

public class DefaultSymbologySwingManager implements

        SymbologySwingManager {

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

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

  private final SymbologyManager manager;

  private final Map<String, LabelClassEditorFactory> labelClassEditorFactories = new HashMap<>();

  private I18nManager i18nmanager = null;

  private SymbologyWindowManager windowManager;

  private ColorTablesFactory colorTablesFactory;

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

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

  private List<Action> optionalActionsOfLegendsPanel;

  public DefaultSymbologySwingManager() {

    this.manager = SymbologyLocator.getSymbologyManager();

    this.windowManager = new DefaultSymbologyWindowManager();

    this.colorTablesFactory = new DefaultColorTablesFactory();

    this.legendEditorRegistry = new ArrayList<>();

    this.labelingEditorRegistry = new ArrayList<>();

  }

  @Override

  public SymbologyManager getManager() {

    return this.manager;

  }

  @Override

  public String getTranslation(String key) {

    if (this.i18nmanager == null) {

      this.i18nmanager = ToolsLocator.getI18nManager();

    }

    return this.i18nmanager.getTranslation(key);

  }

  @Override

  public void registerWindowManager(SymbologyWindowManager manager) {

    this.windowManager = manager;

  }

  @Override

  public SymbologyWindowManager getWindowManager() {

    return this.windowManager;

  }

  @Override

  public void setColorTablesFactory(ColorTablesFactory factory) {

    colorTablesFactory = factory;

  }

  @Override

  public List<ColorTablePainter> createColorTables() {

    if (colorTablesFactory != null) {

      return colorTablesFactory.createColorTables();

    }

    return null;

  }

  @Override

  public ColorTablesFactory getColorTablesFactory() {

    return this.colorTablesFactory;

  }

  /**

   * @param abstractTypeSymbolEditorPanelClass

   * @param shapeType

   * @deprecated use registerTypeSymbolEditor

   */

  public void addSymbolEditorPanel(Class abstractTypeSymbolEditorPanelClass, int shapeType) {

    Class<? extends TypeSymbolEditor> symbolEditor = abstractTypeSymbolEditorPanelClass;

    this.registerSymbolEditor(symbolEditor, shapeType);

  }

  @Override

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

    if (symbolEditorRegistry == null) {

      symbolEditorRegistry = new HashMap<>();

    }

    Integer key = shapeType;

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

    if (l == null) {

      l = new ArrayList<>();

    }

    l.add(symbolEditor);

    symbolEditorRegistry.put(key, l);

  }

  @Override

  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();

  }

  @Override

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

    if (this.legendEditorRegistry == null) {

      this.legendEditorRegistry = new ArrayList<>();

    }

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

      this.legendEditorRegistry.add(legendEditor);

    }

  }

  @Override

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

    return Collections.unmodifiableList(this.legendEditorRegistry);

  }

  @Override

  public List<ILegendPanel> getLegendEditors(FLayer layer) {

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

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

      Class<? extends ILegendPanel> legendEditorClass = null;

      try {

        legendEditorClass = legendEditorRegistry.get(i);

        ILegendPanel editor = (ILegendPanel) legendEditorClass.newInstance();

        if (editor.isSuitableFor(layer)) {

          editors.add(editor);

        }

      } catch (Throwable e) {

        LOGGER.warn("Unable to initialize legend editor ("+(legendEditorClass==null?"NULL":legendEditorClass.getName())+").", e);

      }

    }

    return editors;

  }

  @Override

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

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

      this.labelingEditorRegistry.add(labelingEditor);

    }

  }

  @Override

  public List<ILabelingStrategyPanel> getLabelingEditors() {

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

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

    while (it.hasNext()) {

      Class<? extends ILabelingStrategyPanel> labelingEditorClass = null;

      try {

        labelingEditorClass = it.next();

        ILabelingStrategyPanel labelingEditor = labelingEditorClass.newInstance();

        labelingEditors.add(labelingEditor);

      } catch (Throwable ex) {

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

        LOGGER.warn(msg, ex);

      }

    }

    return labelingEditors;

  }

  @Override

  public void registerLabelClassEditor(LabelClassEditorFactory factory) {

    this.labelClassEditorFactories.put(factory.getID().toLowerCase(), factory);

  }

  @Override

  public Collection<LabelClassEditorFactory> getLabelClassEditorFactories() {

    return Collections.unmodifiableCollection(this.labelClassEditorFactories.values());

  }

  @Override

  public LabelClassEditorFactory getLabelClassEditorFactory(String id) {

    if (id == null) {

      return null;

    }

    return this.labelClassEditorFactories.get(id.toLowerCase());

  }

  @Override

  public LabelClassEditorFactory getLabelClassEditorFactory(ILabelClass labelClass) {

    Iterator<LabelClassEditorFactory> it = this.labelClassEditorFactories.values().iterator();

    while (it.hasNext()) {

      LabelClassEditorFactory labelClassEditorFactory = null;

      try {

        labelClassEditorFactory = it.next();

        if ( labelClassEditorFactory.accept(labelClass.getClass())) {

          return labelClassEditorFactory;

        }

      } catch(Throwable th) {

        LOGGER.warn("Can't check factory '"+(labelClassEditorFactory==null?"NULL":labelClassEditorFactory.getName())+"'.", th);

      }

    }

    return null;

  }

  @Override

  public LabelClassEditor createLabelClassEditor(ILabelClass labelClass, FeatureStore store) {

    LabelClassEditorFactory f = this.getLabelClassEditorFactory(labelClass);

    if (f == null) {

      return null;

    }

    return f.createEditor(labelClass, store);

  }

  @Override

  public Iterable<Action> getOptionalActionOfLegendsPanel() {

    if (this.optionalActionsOfLegendsPanel == null) {

      this.optionalActionsOfLegendsPanel = new ArrayList<>();

    }

    return this.optionalActionsOfLegendsPanel;

  }

  @Override

  public void addOptionalActionToLegendsPanel(Action action) {

    if (this.optionalActionsOfLegendsPanel == null) {

      this.optionalActionsOfLegendsPanel = new ArrayList<>();

    }

    this.optionalActionsOfLegendsPanel.add(action);

  }

}