geotools/selection/FeatureMapLayerSelectionSynchronizer.java

/*******************************************************************************
 * Copyright (c) 2009 Martin O. J. Schmitz.
 * 
 * This file is part of the SCHMITZM library - a collection of utility 
 * classes based on Java 1.6, focusing (not only) on Java Swing 
 * and the Geotools library.
 * 
 * The SCHMITZM project is hosted at:
 * http://wald.intevation.org/projects/schmitzm/
 * 
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser 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 Lesser General Public License (license.txt)
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 * or try this link: http://www.gnu.org/licenses/lgpl.html
 * 
 * Contributors:
 *     Martin O. J. Schmitz - initial API and implementation
 *     Stefan A. Krüger - additional utility classes
 ******************************************************************************/
/** 
 Copyright 2008 Stefan Alfons Krüger 

 atlas-framework - This file is part of the Atlas Framework

 This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version.
 This library 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 Lesser General Public License for more details.
 You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA

 Diese Bibliothek ist freie Software; Sie dürfen sie unter den Bedingungen der GNU Lesser General Public License, wie von der Free Software Foundation veröffentlicht, weiterverteilen und/oder modifizieren; entweder gemäß Version 2.1 der Lizenz oder (nach Ihrer Option) jeder späteren Version.
 Diese Bibliothek wird in der Hoffnung weiterverbreitet, daß sie nützlich sein wird, jedoch OHNE IRGENDEINE GARANTIE, auch ohne die implizierte Garantie der MARKTREIFE oder der VERWENDBARKEIT FÜR EINEN BESTIMMTEN ZWECK. Mehr Details finden Sie in der GNU Lesser General Public License.
 Sie sollten eine Kopie der GNU Lesser General Public License zusammen mit dieser Bibliothek erhalten haben; falls nicht, schreiben Sie an die Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA.
 **/
package skrueger.geotools.selection;

import java.awt.RenderingHints;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.Vector;

import javax.swing.JTable;
import javax.swing.ListSelectionModel;
import javax.swing.event.ListSelectionListener;

import org.geotools.map.MapLayer;
import org.geotools.renderer.GTRenderer;
import org.geotools.renderer.label.LabelCacheImpl;
import org.geotools.renderer.lite.StreamingRenderer;
import org.geotools.styling.FeatureTypeStyle;
import org.geotools.styling.Style;
import org.geotools.styling.visitor.DuplicatingStyleVisitor;
import org.opengis.feature.simple.SimpleFeature;
import org.opengis.filter.identity.FeatureId;

import schmitzm.geotools.FilterUtil;
import schmitzm.geotools.GTUtil;
import schmitzm.geotools.gui.JMapPane;
import schmitzm.geotools.map.event.FeatureSelectedEvent;
import schmitzm.geotools.map.event.JMapPaneEvent;
import schmitzm.geotools.map.event.JMapPaneListener;
import schmitzm.geotools.styling.StylingUtil;
import skrueger.geotools.MapPaneToolBar;
import skrueger.geotools.StyledLayerInterface;

/**
 * This class keeps the selection of a (feature) {@link JTable} synchronized
 * with the {@link StyledLayerSelectionModel} of a layer. This is done by
 * implementing:
 * <ul>
 * <li>a {@link PropertyChangeListener} which listens to the
 * {@link StyledLayerSelectionModel} and accordingly changes the {@link JTable}
 * selection</li>
 * <li>a {@link ListSelectionListener} which listens to the {@link JTable} and
 * accordingly changes the {@link StyledLayerSelectionModel} selection</li>
 * </ul>
 * After creating, the instance of this synchronizer must be added as listener
 * to both, the {@link StyledLayerSelectionModel} and the table's
 * {@link ListSelectionModel}.
 * 
 * @author <a href="mailto:[email protected]">Martin Schmitz</a>
 *         (University of Bonn/Germany)
 */
public class FeatureMapLayerSelectionSynchronizer extends
                StyledLayerSelectionModelSynchronizer<StyledFeatureLayerSelectionModel>
                implements JMapPaneListener {
        public static final String SELECTION_STYLING = "SELECTION";
        /**
         * Holds the {@link MapLayer} to keep synchronized with the layer selection
         * model.
         */
        protected final MapLayer mapLayer;
        protected final StyledLayerInterface<?> styledLayer;
        protected final JMapPane mapPane;
        private final MapPaneToolBar toolBar;
        private final HashMap<Object, Object> defaultGTRenderingHints;

        /**
         * Creates a new synchronizer
         * 
         * @param layerSelModel
         *            layer selection model to keep synchronized with the
         *            {@link MapLayer}
         * 
         * @param mapLayer
         *            {@link MapLayer} to keep synchronized with.
         */
        public FeatureMapLayerSelectionSynchronizer(
                        StyledFeatureLayerSelectionModel layerSelModel,
                        StyledLayerInterface<?> styledLayer, MapLayer mapLayer,
                        JMapPane mapPane, MapPaneToolBar toolBar, HashMap<Object, Object> defaultGTRenderingHints) {

                super(layerSelModel);
                this.styledLayer = styledLayer;

                this.mapLayer = mapLayer;
                this.mapPane = mapPane;
                this.toolBar = toolBar;
                if (defaultGTRenderingHints != null)
                        this.defaultGTRenderingHints = defaultGTRenderingHints;
                else 
                        this.defaultGTRenderingHints = new HashMap<Object, Object>();
        }

        /**
         * Called by {@link StyledLayerSelectionModel} when a the selection on other
         * selection components (map, chart, ...) has changed. When calling this
         * 
         * method changes the {@link MapLayer} selection according to the
         * {@link StyledLayerSelectionModel} selection.
         * 
         * @param evt
         *            an event
         */
        @Override
        public void propertyChange(PropertyChangeEvent evt) {

                if (!isEnabled())
                        return;

                if (!(evt instanceof StyledLayerSelectionEvent))
                        return;
                StyledLayerSelectionEvent selEvt = (StyledLayerSelectionEvent) evt;
                // Only react on own layer and ignore events invoked by
                // this component itself
                if (selEvt.getEmitter() != layerSelModel || selectionChangeCausedByMe)
                        return;
                // Apply new selection on table (except this event is one of
                // some more events)
                Vector<String> newSelection = layerSelModel.getSelection();
                if (newSelection == null)
                        return;

                // Avoid event circles in valueChanged(..)
                selectionChangeCausedByMe = true;

                changeLayerStyle(newSelection);

                // Danger of event circles in valueChanged(..) banned
                selectionChangeCausedByMe = false;
        }

        /**
         * Changes the Style of the {@link MapLayer} to reflect changes of the
         * selection.
         * 
         * @param newSelection
         *            A {@link Vector} of SimpleFeature-IDs that are selected.
         */
        private void changeLayerStyle(final Vector<String> newSelection) {
                try {
                        
                        Style originalStyle = mapLayer.getStyle();
                        if (newSelection.isEmpty()) {

                                // Check if the Style contains a SELECTION FTS
                                
                                FeatureTypeStyle[] clone = originalStyle.featureTypeStyles().toArray( new FeatureTypeStyle[] {} ).clone();
                                
                                for (FeatureTypeStyle fts : clone) {
                                        if (fts.getName() != null
                                                        && fts.getName().equals(SELECTION_STYLING)) {
                                                originalStyle.featureTypeStyles().remove(fts);
                                                
                                                replaceRenderer();
//                                              mapPane.refresh();
                                                

                                                return;
                                        }
                                }

                        } else {
                                LOGGER.debug("SELECTION .. change style");

                                // We take Style from the MapLayer that is displayed at the
                                // moment. We do not use the styledLayer.getStyle, because in
                                // the atlas, this always return the default style, but
                                // additional styles might be selected.
                                // Taking the style from the mapLayer indicated, that we have to
                                // remove any selection rules first.

                                FeatureTypeStyle selectionFTStyle = StylingUtil
                                                .createSelectionStyle(styledLayer.getGeoObject());

                                selectionFTStyle.setName(SELECTION_STYLING);

                                /**
                                 * 
                                 * Add a Filter to the selectionMapStyle, so that it is only
                                 * used on objects that are selected. <br/>
                                 * 
                                 * Note 1:<br/>
                                 * It is NEVER allowed to GeoTools extend Filter () { .. } (and
                                 * write tests into the evaluate block). Especially for the
                                 * ShapeFileRenderer, we may only use a geotools Filter.<br/>
                                 * 
                                 * Note 2:<br/>
                                 * The FilterUtil.FILTER_FAC2.id(fids) wants a set of
                                 * FeatureId-Objects!
                                 */

                                Set<FeatureId> fids = new HashSet<FeatureId>();
                                for (String fid : newSelection) {
                                        fids.add(FilterUtil.FILTER_FAC2.featureId(fid));
                                }

                                selectionFTStyle.rules().get(0).setFilter(
                                                FilterUtil.FILTER_FAC2.id(fids));

                                // Maybe there has already been another selection
                                // FeatureTypeStyle... Let's replace it...
                                boolean foundAndReplaced = false;
                                for (FeatureTypeStyle fts : originalStyle.featureTypeStyles()) {
                                        if (fts.getName() != null
                                                        && fts.getName().equals(SELECTION_STYLING)) {
                                                foundAndReplaced = true;
                                                fts.rules().clear();
                                                fts.rules().addAll(selectionFTStyle.rules());
                                                break;
                                        }
                                }
                                if (!foundAndReplaced) {
                                        originalStyle.featureTypeStyles().add(selectionFTStyle);
                                }
                                
                                

                                // Refresh the map
//                              mapPane.refresh();
                                
                                DuplicatingStyleVisitor dsv = new DuplicatingStyleVisitor();
                                dsv.visit(originalStyle);
                                Style newStyle = (Style)dsv.getCopy();
                                
//                              Style newStyle = StylingUtil.STYLE_BUILDER.createStyle();
//                              newStyle.featureTypeStyles().addAll(originalStyle.featureTypeStyles());
                                mapLayer.setStyle(newStyle);
                                
                                replaceRenderer();
                        }

                } catch (Exception e) {
                        LOGGER.error("Error while trying to create a selection style", e);
                }
        }

        private void replaceRenderer() {
//
//              // Has to be done before we apply the new Renderer
//              mapLayer.setStyle(style);

                GTRenderer oldRenderer = mapPane.getRenderer();

                /**
                 * Explicitly putting a new instance of LabelCacheDefault into the
                 * renderer instance, so JMapPane doesn't reuse the old one. This is
                 * very useful when changing the TextSymbolizer with AtlasStyler<br/>
                 * SK 9.7.09: It's not enought to user LabelCache.clear(). We can not
                 * reuse the old Renderer - better to create a new one!
                 */
                final GTRenderer newRenderer = GTUtil.createGTRenderer();

                final HashMap<Object, Object> rendererHints = defaultGTRenderingHints;
                rendererHints.put(StreamingRenderer.LABEL_CACHE_KEY,
                                new LabelCacheImpl());

                newRenderer.setRendererHints(rendererHints);
                mapPane.setRenderer(newRenderer);

                if (oldRenderer != null) {
                        
                        RenderingHints java2DHints = oldRenderer.getJava2DHints();
                        if (java2DHints != null) {
                                newRenderer.setJava2DHints(java2DHints);
                        }
                        
                        oldRenderer.setContext(null);
                        oldRenderer = null;
                }
                
                mapPane.refresh();

        }

        /**
         * Used to synchronize {@link FeatureSelectedEvent}s with the
         * {@link StyledFeatureLayerSelectionModel}
         */
        @Override
        public void performMapPaneEvent(JMapPaneEvent e) {

                // Ignore event if it is caused by us or the synchronizer is disabled.
                if (!isEnabled() || selectionChangeCausedByMe)
                        return;

                if (!(e instanceof FeatureSelectedEvent)) {
                        // LOGGER.debug("Ignoring event " + e);
                        return;
                }

                /**
                 * Only listen to FeatureSelectedEvents if an appropriate tool is
                 * selected.
                 */
                final int selectedTool = toolBar.getSelectedTool();
                if (selectedTool != MapPaneToolBar.TOOL_SELECTION_ADD
                                && selectedTool != MapPaneToolBar.TOOL_SELECTION_REMOVE
                                && selectedTool != MapPaneToolBar.TOOL_SELECTION_SET) {
                        return;
                }

                // only listen to events directly coming from JMapPane
                // selection (ignore selections from FilterDialog)
                if (e.getSourceObject() != this.mapPane)
                        return;

                FeatureSelectedEvent fse = (FeatureSelectedEvent) e;

                /**
                 * Checking, that the FeatureSelectedEvent actually contains features
                 * from this layer
                 */
                final String sourceID = fse.getSourceLayer().getTitle();
                final String syncForID = mapLayer.getTitle();
                if (sourceID != null && syncForID != null
                                && !sourceID.equals(syncForID)) {
                        LOGGER.debug("Ignoring a FeatureSelectedEvent from " + sourceID);
                        return;
                }

                LOGGER.debug("do event " + fse);

                // Avoid event circles in propertyChange(..)
                selectionChangeCausedByMe = true;

                Iterator<SimpleFeature> fi = fse.getSelectionResult().iterator();

                // reset the selection of the DpLayerSelectionModel
                // layerSelModel.setValueIsAdjusting(true);

                if (selectedTool == MapPaneToolBar.TOOL_SELECTION_ADD) {
                        layerSelModel.setValueIsAdjusting(true);

                        for (int fIdx = 0; fi.hasNext(); fIdx++) {
                                SimpleFeature f = fi.next();
                                layerSelModel.addSelection(f.getID());
                        }
                        layerSelModel.setValueIsAdjusting(false);
                } else if (selectedTool == MapPaneToolBar.TOOL_SELECTION_SET) {
                        layerSelModel.setValueIsAdjusting(true);
                        layerSelModel.clearSelection();

                        for (int fIdx = 0; fi.hasNext(); fIdx++) {
                                SimpleFeature f = fi.next();
                                layerSelModel.addSelection(f.getID());
                        }

                        // LOGGER.debug("Setting selection to " + fi.());

                        layerSelModel.setValueIsAdjusting(false);
                } else if (selectedTool == MapPaneToolBar.TOOL_SELECTION_REMOVE) {
                        layerSelModel.setValueIsAdjusting(true);
                        for (int fIdx = 0; fi.hasNext(); fIdx++) {
                                SimpleFeature f = fi.next();
                                layerSelModel.removeSelection(f.getID());
                        }
                        layerSelModel.setValueIsAdjusting(false);
                }

                // Show selected features in the map, which is not automatically done by
                // the origin: FeatureSelectedEvent
                changeLayerStyle(layerSelModel.getSelection());

                // Danger of event circles in propertyChange(..) banned
                selectionChangeCausedByMe = false;
        }

}
1	/*******************************************************************************
2	* Copyright (c) 2009 Martin O. J. Schmitz.
3	*
4	* This file is part of the SCHMITZM library - a collection of utility
5	* classes based on Java 1.6, focusing (not only) on Java Swing
6	* and the Geotools library.
7	*
8	* The SCHMITZM project is hosted at:
9	* http://wald.intevation.org/projects/schmitzm/
10	*
11	* This program is free software; you can redistribute it and/or
12	* modify it under the terms of the GNU Lesser General Public License
13	* as published by the Free Software Foundation; either version 3
14	* of the License, or (at your option) any later version.
15	*
16	* This program is distributed in the hope that it will be useful,
17	* but WITHOUT ANY WARRANTY; without even the implied warranty of
18	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19	* GNU General Public License for more details.
20	*
21	* You should have received a copy of the GNU Lesser General Public License (license.txt)
22	* along with this program; if not, write to the Free Software
23	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
24	* or try this link: http://www.gnu.org/licenses/lgpl.html
25	*
26	* Contributors:
27	* Martin O. J. Schmitz - initial API and implementation
28	* Stefan A. Krüger - additional utility classes
29	******************************************************************************/
30	/**
31	Copyright 2008 Stefan Alfons Krüger
32
33	atlas-framework - This file is part of the Atlas Framework
34
35	This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version.
36	This library 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 Lesser General Public License for more details.
37	You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA
38
39	Diese Bibliothek ist freie Software; Sie dürfen sie unter den Bedingungen der GNU Lesser General Public License, wie von der Free Software Foundation veröffentlicht, weiterverteilen und/oder modifizieren; entweder gemäß Version 2.1 der Lizenz oder (nach Ihrer Option) jeder späteren Version.
40	Diese Bibliothek wird in der Hoffnung weiterverbreitet, daß sie nützlich sein wird, jedoch OHNE IRGENDEINE GARANTIE, auch ohne die implizierte Garantie der MARKTREIFE oder der VERWENDBARKEIT FÜR EINEN BESTIMMTEN ZWECK. Mehr Details finden Sie in der GNU Lesser General Public License.
41	Sie sollten eine Kopie der GNU Lesser General Public License zusammen mit dieser Bibliothek erhalten haben; falls nicht, schreiben Sie an die Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA.
42	**/
43	package skrueger.geotools.selection;
44
45	import java.awt.RenderingHints;
46	import java.beans.PropertyChangeEvent;
47	import java.beans.PropertyChangeListener;
48	import java.util.HashMap;
49	import java.util.HashSet;
50	import java.util.Iterator;
51	import java.util.Set;
52	import java.util.Vector;
53
54	import javax.swing.JTable;
55	import javax.swing.ListSelectionModel;
56	import javax.swing.event.ListSelectionListener;
57
58	import org.geotools.map.MapLayer;
59	import org.geotools.renderer.GTRenderer;
60	import org.geotools.renderer.label.LabelCacheImpl;
61	import org.geotools.renderer.lite.StreamingRenderer;
62	import org.geotools.styling.FeatureTypeStyle;
63	import org.geotools.styling.Style;
64	import org.geotools.styling.visitor.DuplicatingStyleVisitor;
65	import org.opengis.feature.simple.SimpleFeature;
66	import org.opengis.filter.identity.FeatureId;
67
68	import schmitzm.geotools.FilterUtil;
69	import schmitzm.geotools.GTUtil;
70	import schmitzm.geotools.gui.JMapPane;
71	import schmitzm.geotools.map.event.FeatureSelectedEvent;
72	import schmitzm.geotools.map.event.JMapPaneEvent;
73	import schmitzm.geotools.map.event.JMapPaneListener;
74	import schmitzm.geotools.styling.StylingUtil;
75	import skrueger.geotools.MapPaneToolBar;
76	import skrueger.geotools.StyledLayerInterface;
77
78	/**
79	* This class keeps the selection of a (feature) {@link JTable} synchronized
80	* with the {@link StyledLayerSelectionModel} of a layer. This is done by
81	* implementing:
82	* <ul>
83	* <li>a {@link PropertyChangeListener} which listens to the
84	* {@link StyledLayerSelectionModel} and accordingly changes the {@link JTable}
85	* selection</li>
86	* <li>a {@link ListSelectionListener} which listens to the {@link JTable} and
87	* accordingly changes the {@link StyledLayerSelectionModel} selection</li>
88	* </ul>
89	* After creating, the instance of this synchronizer must be added as listener
90	* to both, the {@link StyledLayerSelectionModel} and the table's
91	* {@link ListSelectionModel}.
92	*
93	* @author <a href="mailto:[email protected]">Martin Schmitz</a>
94	* (University of Bonn/Germany)
95	*/
96	public class FeatureMapLayerSelectionSynchronizer extends
97	StyledLayerSelectionModelSynchronizer<StyledFeatureLayerSelectionModel>
98	implements JMapPaneListener {
99	public static final String SELECTION_STYLING = "SELECTION";
100	/**
101	* Holds the {@link MapLayer} to keep synchronized with the layer selection
102	* model.
103	*/
104	protected final MapLayer mapLayer;
105	protected final StyledLayerInterface<?> styledLayer;
106	protected final JMapPane mapPane;
107	private final MapPaneToolBar toolBar;
108	private final HashMap<Object, Object> defaultGTRenderingHints;
109
110	/**
111	* Creates a new synchronizer
112	*
113	* @param layerSelModel
114	* layer selection model to keep synchronized with the
115	* {@link MapLayer}
116	*
117	* @param mapLayer
118	* {@link MapLayer} to keep synchronized with.
119	*/
120	public FeatureMapLayerSelectionSynchronizer(
121	StyledFeatureLayerSelectionModel layerSelModel,
122	StyledLayerInterface<?> styledLayer, MapLayer mapLayer,
123	JMapPane mapPane, MapPaneToolBar toolBar, HashMap<Object, Object> defaultGTRenderingHints) {
124
125	super(layerSelModel);
126	this.styledLayer = styledLayer;
127
128	this.mapLayer = mapLayer;
129	this.mapPane = mapPane;
130	this.toolBar = toolBar;
131	if (defaultGTRenderingHints != null)
132	this.defaultGTRenderingHints = defaultGTRenderingHints;
133	else
134	this.defaultGTRenderingHints = new HashMap<Object, Object>();
135	}
136
137	/**
138	* Called by {@link StyledLayerSelectionModel} when a the selection on other
139	* selection components (map, chart, ...) has changed. When calling this
140	*
141	* method changes the {@link MapLayer} selection according to the
142	* {@link StyledLayerSelectionModel} selection.
143	*
144	* @param evt
145	* an event
146	*/
147	@Override
148	public void propertyChange(PropertyChangeEvent evt) {
149
150	if (!isEnabled())
151	return;
152
153	if (!(evt instanceof StyledLayerSelectionEvent))
154	return;
155	StyledLayerSelectionEvent selEvt = (StyledLayerSelectionEvent) evt;
156	// Only react on own layer and ignore events invoked by
157	// this component itself
158	if (selEvt.getEmitter() != layerSelModel \|\| selectionChangeCausedByMe)
159	return;
160	// Apply new selection on table (except this event is one of
161	// some more events)
162	Vector<String> newSelection = layerSelModel.getSelection();
163	if (newSelection == null)
164	return;
165
166	// Avoid event circles in valueChanged(..)
167	selectionChangeCausedByMe = true;
168
169	changeLayerStyle(newSelection);
170
171	// Danger of event circles in valueChanged(..) banned
172	selectionChangeCausedByMe = false;
173	}
174
175	/**
176	* Changes the Style of the {@link MapLayer} to reflect changes of the
177	* selection.
178	*
179	* @param newSelection
180	* A {@link Vector} of SimpleFeature-IDs that are selected.
181	*/
182	private void changeLayerStyle(final Vector<String> newSelection) {
183	try {
184
185	Style originalStyle = mapLayer.getStyle();
186	if (newSelection.isEmpty()) {
187
188	// Check if the Style contains a SELECTION FTS
189
190	FeatureTypeStyle[] clone = originalStyle.featureTypeStyles().toArray( new FeatureTypeStyle[] {} ).clone();
191
192	for (FeatureTypeStyle fts : clone) {
193	if (fts.getName() != null
194	&& fts.getName().equals(SELECTION_STYLING)) {
195	originalStyle.featureTypeStyles().remove(fts);
196
197	replaceRenderer();
198	// mapPane.refresh();
199
200
201	return;
202	}
203	}
204
205	} else {
206	LOGGER.debug("SELECTION .. change style");
207
208	// We take Style from the MapLayer that is displayed at the
209	// moment. We do not use the styledLayer.getStyle, because in
210	// the atlas, this always return the default style, but
211	// additional styles might be selected.
212	// Taking the style from the mapLayer indicated, that we have to
213	// remove any selection rules first.
214
215	FeatureTypeStyle selectionFTStyle = StylingUtil
216	.createSelectionStyle(styledLayer.getGeoObject());
217
218	selectionFTStyle.setName(SELECTION_STYLING);
219
220	/**
221	*
222	* Add a Filter to the selectionMapStyle, so that it is only
223	* used on objects that are selected. <br/>
224	*
225	* Note 1:<br/>
226	* It is NEVER allowed to GeoTools extend Filter () { .. } (and
227	* write tests into the evaluate block). Especially for the
228	* ShapeFileRenderer, we may only use a geotools Filter.<br/>
229	*
230	* Note 2:<br/>
231	* The FilterUtil.FILTER_FAC2.id(fids) wants a set of
232	* FeatureId-Objects!
233	*/
234
235	Set<FeatureId> fids = new HashSet<FeatureId>();
236	for (String fid : newSelection) {
237	fids.add(FilterUtil.FILTER_FAC2.featureId(fid));
238	}
239
240	selectionFTStyle.rules().get(0).setFilter(
241	FilterUtil.FILTER_FAC2.id(fids));
242
243	// Maybe there has already been another selection
244	// FeatureTypeStyle... Let's replace it...
245	boolean foundAndReplaced = false;
246	for (FeatureTypeStyle fts : originalStyle.featureTypeStyles()) {
247	if (fts.getName() != null
248	&& fts.getName().equals(SELECTION_STYLING)) {
249	foundAndReplaced = true;
250	fts.rules().clear();
251	fts.rules().addAll(selectionFTStyle.rules());
252	break;
253	}
254	}
255	if (!foundAndReplaced) {
256	originalStyle.featureTypeStyles().add(selectionFTStyle);
257	}
258
259
260
261	// Refresh the map
262	// mapPane.refresh();
263
264	DuplicatingStyleVisitor dsv = new DuplicatingStyleVisitor();
265	dsv.visit(originalStyle);
266	Style newStyle = (Style)dsv.getCopy();
267
268	// Style newStyle = StylingUtil.STYLE_BUILDER.createStyle();
269	// newStyle.featureTypeStyles().addAll(originalStyle.featureTypeStyles());
270	mapLayer.setStyle(newStyle);
271
272	replaceRenderer();
273	}
274
275	} catch (Exception e) {
276	LOGGER.error("Error while trying to create a selection style", e);
277	}
278	}
279
280	private void replaceRenderer() {
281	//
282	// // Has to be done before we apply the new Renderer
283	// mapLayer.setStyle(style);
284
285	GTRenderer oldRenderer = mapPane.getRenderer();
286
287	/**
288	* Explicitly putting a new instance of LabelCacheDefault into the
289	* renderer instance, so JMapPane doesn't reuse the old one. This is
290	* very useful when changing the TextSymbolizer with AtlasStyler<br/>
291	* SK 9.7.09: It's not enought to user LabelCache.clear(). We can not
292	* reuse the old Renderer - better to create a new one!
293	*/
294	final GTRenderer newRenderer = GTUtil.createGTRenderer();
295
296	final HashMap<Object, Object> rendererHints = defaultGTRenderingHints;
297	rendererHints.put(StreamingRenderer.LABEL_CACHE_KEY,
298	new LabelCacheImpl());
299
300	newRenderer.setRendererHints(rendererHints);
301	mapPane.setRenderer(newRenderer);
302
303	if (oldRenderer != null) {
304
305	RenderingHints java2DHints = oldRenderer.getJava2DHints();
306	if (java2DHints != null) {
307	newRenderer.setJava2DHints(java2DHints);
308	}
309
310	oldRenderer.setContext(null);
311	oldRenderer = null;
312	}
313
314	mapPane.refresh();
315
316	}
317
318	/**
319	* Used to synchronize {@link FeatureSelectedEvent}s with the
320	* {@link StyledFeatureLayerSelectionModel}
321	*/
322	@Override
323	public void performMapPaneEvent(JMapPaneEvent e) {
324
325	// Ignore event if it is caused by us or the synchronizer is disabled.
326	if (!isEnabled() \|\| selectionChangeCausedByMe)
327	return;
328
329	if (!(e instanceof FeatureSelectedEvent)) {
330	// LOGGER.debug("Ignoring event " + e);
331	return;
332	}
333
334	/**
335	* Only listen to FeatureSelectedEvents if an appropriate tool is
336	* selected.
337	*/
338	final int selectedTool = toolBar.getSelectedTool();
339	if (selectedTool != MapPaneToolBar.TOOL_SELECTION_ADD
340	&& selectedTool != MapPaneToolBar.TOOL_SELECTION_REMOVE
341	&& selectedTool != MapPaneToolBar.TOOL_SELECTION_SET) {
342	return;
343	}
344
345	// only listen to events directly coming from JMapPane
346	// selection (ignore selections from FilterDialog)
347	if (e.getSourceObject() != this.mapPane)
348	return;
349
350	FeatureSelectedEvent fse = (FeatureSelectedEvent) e;
351
352	/**
353	* Checking, that the FeatureSelectedEvent actually contains features
354	* from this layer
355	*/
356	final String sourceID = fse.getSourceLayer().getTitle();
357	final String syncForID = mapLayer.getTitle();
358	if (sourceID != null && syncForID != null
359	&& !sourceID.equals(syncForID)) {
360	LOGGER.debug("Ignoring a FeatureSelectedEvent from " + sourceID);
361	return;
362	}
363
364	LOGGER.debug("do event " + fse);
365
366	// Avoid event circles in propertyChange(..)
367	selectionChangeCausedByMe = true;
368
369	Iterator<SimpleFeature> fi = fse.getSelectionResult().iterator();
370
371	// reset the selection of the DpLayerSelectionModel
372	// layerSelModel.setValueIsAdjusting(true);
373
374	if (selectedTool == MapPaneToolBar.TOOL_SELECTION_ADD) {
375	layerSelModel.setValueIsAdjusting(true);
376
377	for (int fIdx = 0; fi.hasNext(); fIdx++) {
378	SimpleFeature f = fi.next();
379	layerSelModel.addSelection(f.getID());
380	}
381	layerSelModel.setValueIsAdjusting(false);
382	} else if (selectedTool == MapPaneToolBar.TOOL_SELECTION_SET) {
383	layerSelModel.setValueIsAdjusting(true);
384	layerSelModel.clearSelection();
385
386	for (int fIdx = 0; fi.hasNext(); fIdx++) {
387	SimpleFeature f = fi.next();
388	layerSelModel.addSelection(f.getID());
389	}
390
391	// LOGGER.debug("Setting selection to " + fi.());
392
393	layerSelModel.setValueIsAdjusting(false);
394	} else if (selectedTool == MapPaneToolBar.TOOL_SELECTION_REMOVE) {
395	layerSelModel.setValueIsAdjusting(true);
396	for (int fIdx = 0; fi.hasNext(); fIdx++) {
397	SimpleFeature f = fi.next();
398	layerSelModel.removeSelection(f.getID());
399	}
400	layerSelModel.setValueIsAdjusting(false);
401	}
402
403	// Show selected features in the map, which is not automatically done by
404	// the origin: FeatureSelectedEvent
405	changeLayerStyle(layerSelModel.getSelection());
406
407	// Danger of event circles in propertyChange(..) banned
408	selectionChangeCausedByMe = false;
409	}
410
411	}
Name	Value
svn:eol-style	native
svn:keywords	Id
svn:mime-type	text/plain