Changeset 10142 in josm for trunk/src/org/openstreetmap/josm/gui/dialogs/LayerListDialog.java

Timestamp:

2016-04-12T23:08:55+02:00 (8 years ago)

Author:

Don-vip

Message:

fix #12752 - Add more image filters (patch by michael2402, modified)

File:

• trunk/src/org/openstreetmap/josm/gui/dialogs/LayerListDialog.java (modified) (3 diffs)

trunk/src/org/openstreetmap/josm/gui/dialogs/LayerListDialog.java

@@ -532 +532 @@
         protected static final int SLIDER_STEPS = 100;
         private static final double MAX_GAMMA_FACTOR = 2;
+        private static final double MAX_SHARPNESS_FACTOR = 2;
+        private static final double MAX_COLORFUL_FACTOR = 2;
         private final LayerListModel model;
         private final JPopupMenu popup;
-        private JSlider opacitySlider;
-        private JSlider gammaSlider;
         private SideButton sideButton;
         private JCheckBox visibilityCheckbox;
+        final OpacitySlider opacitySlider = new OpacitySlider();
+        private final ArrayList<FilterSlider<?>> sliders = new ArrayList<>();
 
         /**
@@ -560 +562 @@
                 @Override
                 public void stateChanged(ChangeEvent e) {
-                    setVisible(visibilityCheckbox.isSelected());
+                    setVisibleFlag(visibilityCheckbox.isSelected());
                 }
             });
             content.add(visibilityCheckbox, GBC.eop());
 
-            content.add(new JLabel(ImageProvider.get("dialogs/layerlist", "transparency")), GBC.std().span(1, 2).insets(0, 0, 5, 0));
-            content.add(new JLabel(tr("Opacity")), GBC.eol());
-            opacitySlider = new JSlider(JSlider.HORIZONTAL);
-            opacitySlider.setMaximum(SLIDER_STEPS);
-            opacitySlider.addChangeListener(new ChangeListener() {
-                @Override
-                public void stateChanged(ChangeEvent e) {
-                    setOpacityValue(readOpacityValue(), opacitySlider.getValueIsAdjusting());
-                }
-            });
-            opacitySlider.setToolTipText(tr("Adjust opacity of the layer."));
-            content.add(opacitySlider, GBC.eop());
-
-            content.add(new JLabel(ImageProvider.get("dialogs/layerlist", "gamma")), GBC.std().span(1, 2).insets(0, 0, 5, 0));
-            content.add(new JLabel(tr("Gamma")), GBC.eol());
-            gammaSlider = new JSlider(JSlider.HORIZONTAL);
-            gammaSlider.setMaximum(SLIDER_STEPS);
-            gammaSlider.addChangeListener(new ChangeListener() {
-                @Override
-                public void stateChanged(ChangeEvent e) {
-                    setGammaValue(readGammaValue());
-                }
-            });
-            gammaSlider.setToolTipText(tr("Adjust gamma value of the layer."));
-            content.add(gammaSlider, GBC.eol());
-        }
-
-        protected double readOpacityValue() {
-            return (double) opacitySlider.getValue() / SLIDER_STEPS;
-        }
-
-        protected double readGammaValue() {
-            return (double) gammaSlider.getValue() / SLIDER_STEPS * MAX_GAMMA_FACTOR;
-        }
-
-        protected void setVisible(boolean visible) {
+            addSlider(content, opacitySlider);
+            addSlider(content, new ColorfulnessSlider());
+            addSlider(content, new GammaFilterSlider());
+            addSlider(content, new SharpnessSlider());
+        }
+
+        private void addSlider(JPanel content, FilterSlider<?> slider) {
+            content.add(new JLabel(slider.getIcon()), GBC.std().span(1, 2).insets(0, 0, 5, 0));
+            content.add(new JLabel(slider.getLabel()), GBC.eol());
+            content.add(slider, GBC.eop());
+            sliders.add(slider);
+        }
+
+        protected void setVisibleFlag(boolean visible) {
             for (Layer l : model.getSelectedLayers()) {
                 l.setVisible(visible);
             }
             updateValues();
-        }
-
-        protected void setOpacityValue(double value, boolean adjusting) {
-            if (value <= 0 && !adjusting) {
-                setVisible(false);
-            } else {
-                for (Layer l : model.getSelectedLayers()) {
-                    l.setOpacity(value);
-                }
-            }
-        }
-
-        protected void setGammaValue(double value) {
-            for (ImageryLayer imageryLayer : Utils.filteredCollection(model.getSelectedLayers(), ImageryLayer.class)) {
-                imageryLayer.setGamma(value);
-            }
         }
 
@@ -648 +612 @@
             visibilityCheckbox.setSelected(allVisible && !allHidden);
 
-            updateOpacitySlider(layers, allHidden);
-
-            updateGammaSlider(layers, allHidden);
-        }
-
-        private void updateGammaSlider(List<Layer> layers, boolean allHidden) {
-            Collection<ImageryLayer> gammaLayers = Utils.filteredCollection(layers, ImageryLayer.class);
-            if (gammaLayers.isEmpty() || allHidden) {
-                gammaSlider.setEnabled(false);
-            } else {
-                gammaSlider.setEnabled(true);
-                double gamma = gammaLayers.iterator().next().getGamma();
-                gammaSlider.setValue((int) (gamma * SLIDER_STEPS / MAX_GAMMA_FACTOR));
-            }
-        }
-
-        private void updateOpacitySlider(List<Layer> layers, boolean allHidden) {
-            if (layers.isEmpty() || allHidden) {
-                opacitySlider.setEnabled(false);
-            } else {
-                opacitySlider.setEnabled(true);
+            for (FilterSlider<?> slider : sliders) {
+                slider.updateSlider(layers, allHidden);
+            }
+        }
+
+        @Override
+        public boolean supportLayers(List<Layer> layers) {
+            return !layers.isEmpty();
+        }
+
+        @Override
+        public Component createMenuComponent() {
+            return new JMenuItem(this);
+        }
+
+        @Override
+        public void updateEnabledState() {
+            setEnabled(!model.getSelectedLayers().isEmpty());
+        }
+
+        /**
+         * Sets the corresponding side button.
+         * @param sideButton the corresponding side button
+         */
+        void setCorrespondingSideButton(SideButton sideButton) {
+            this.sideButton = sideButton;
+        }
+
+        /**
+         * This is a slider for a filter value.
+         * @author Michael Zangl
+         *
+         * @param <T> The layer type.
+         */
+        private abstract class FilterSlider<T extends Layer> extends JSlider {
+            private final double minValue;
+            private final double maxValue;
+            private final Class<T> layerClassFilter;
+
+            /**
+             * Create a new filter slider.
+             * @param minValue The minimum value to map to the left side.
+             * @param maxValue The maximum value to map to the right side.
+             * @param layerClassFilter The type of layer influenced by this filter.
+             */
+            FilterSlider(double minValue, double maxValue, Class<T> layerClassFilter) {
+                super(JSlider.HORIZONTAL);
+                this.minValue = minValue;
+                this.maxValue = maxValue;
+                this.layerClassFilter = layerClassFilter;
+                setMaximum(SLIDER_STEPS);
+                int tick = convertFromRealValue(1);
+                setMinorTickSpacing(tick);
+                setMajorTickSpacing(tick);
+                setPaintTicks(true);
+
+                addChangeListener(new ChangeListener() {
+                    @Override
+                    public void stateChanged(ChangeEvent e) {
+                        onStateChanged();
+                    }
+                });
+            }
+
+            /**
+             * Called whenever the state of the slider was changed.
+             * @see #getValueIsAdjusting()
+             * @see #getRealValue()
+             */
+            protected void onStateChanged() {
+                Collection<T> layers = filterLayers(model.getSelectedLayers());
+                for (T layer : layers) {
+                    applyValueToLayer(layer);
+                }
+            }
+
+            protected void applyValueToLayer(T layer) {
+            }
+
+            protected double getRealValue() {
+                return convertToRealValue(getValue());
+            }
+
+            protected double convertToRealValue(int value) {
+                double s = (double) value / SLIDER_STEPS;
+                return s * maxValue + (1-s) * minValue;
+            }
+
+            protected void setRealValue(double value) {
+                setValue(convertFromRealValue(value));
+            }
+
+            protected int convertFromRealValue(double value) {
+                int i = (int) ((value - minValue) / (maxValue - minValue) * SLIDER_STEPS + .5);
+                if (i < getMinimum()) {
+                    return getMinimum();
+                } else if (i > getMaximum()) {
+                    return getMaximum();
+                } else {
+                    return i;
+                }
+            }
+
+            public abstract ImageIcon getIcon();
+
+            public abstract String getLabel();
+
+            public void updateSlider(List<Layer> layers, boolean allHidden) {
+                Collection<? extends Layer> usedLayers = filterLayers(layers);
+                if (usedLayers.isEmpty() || allHidden) {
+                    setEnabled(false);
+                } else {
+                    setEnabled(true);
+                    updateSliderWhileEnabled(usedLayers, allHidden);
+                }
+            }
+
+            protected Collection<T> filterLayers(List<Layer> layers) {
+                return Utils.filteredCollection(layers, layerClassFilter);
+            }
+
+            protected abstract void updateSliderWhileEnabled(Collection<? extends Layer> usedLayers, boolean allHidden);
+        }
+
+        /**
+         * This slider allows you to change the opacity of a layer.
+         *
+         * @author Michael Zangl
+         * @see Layer#setOpacity(double)
+         */
+        class OpacitySlider extends FilterSlider<Layer> {
+            /**
+             * Creaate a new {@link OpacitySlider}.
+             */
+            OpacitySlider() {
+                super(0, 1, Layer.class);
+                setToolTipText(tr("Adjust opacity of the layer."));
+
+            }
+
+            @Override
+            protected void onStateChanged() {
+                if (getRealValue() <= 0.001 && !getValueIsAdjusting()) {
+                    setVisibleFlag(false);
+                } else {
+                    super.onStateChanged();
+                }
+            }
+
+            @Override
+            protected void applyValueToLayer(Layer layer) {
+                layer.setOpacity(getRealValue());
+            }
+
+            @Override
+            protected void updateSliderWhileEnabled(Collection<? extends Layer> usedLayers, boolean allHidden) {
                 double opacity = 0;
-                for (Layer l : layers) {
+                for (Layer l : usedLayers) {
                     opacity += l.getOpacity();
                 }
-                opacity /= layers.size();
+                opacity /= usedLayers.size();
                 if (opacity == 0) {
                     opacity = 1;
-                    setOpacityValue(opacity, false);
-                }
-                opacitySlider.setValue((int) (opacity * SLIDER_STEPS));
-            }
-        }
-
-        @Override
-        public boolean supportLayers(List<Layer> layers) {
-            return !layers.isEmpty();
-        }
-
-        @Override
-        public Component createMenuComponent() {
-            return new JMenuItem(this);
-        }
-
-        @Override
-        public void updateEnabledState() {
-            setEnabled(!model.getSelectedLayers().isEmpty());
-        }
-
-        /**
-         * Sets the corresponding side button.
-         * @param sideButton the corresponding side button
-         */
-        void setCorrespondingSideButton(SideButton sideButton) {
-            this.sideButton = sideButton;
+                    setVisibleFlag(true);
+                }
+                setRealValue(opacity);
+            }
+
+            @Override
+            public String getLabel() {
+                return tr("Opacity");
+            }
+
+            @Override
+            public ImageIcon getIcon() {
+                return ImageProvider.get("dialogs/layerlist", "transparency");
+            }
+
+            @Override
+            public String toString() {
+                return "OpacitySlider [getRealValue()=" + getRealValue() + "]";
+            }
+        }
+
+        /**
+         * This slider allows you to change the gamma value of a layer.
+         *
+         * @author Michael Zangl
+         * @see ImageryLayer#setGamma(double)
+         */
+        private class GammaFilterSlider extends FilterSlider<ImageryLayer> {
+
+            /**
+             * Create a new {@link GammaFilterSlider}
+             */
+            GammaFilterSlider() {
+                super(0, MAX_GAMMA_FACTOR, ImageryLayer.class);
+                setToolTipText(tr("Adjust gamma value of the layer."));
+            }
+
+            @Override
+            protected void updateSliderWhileEnabled(Collection<? extends Layer> usedLayers, boolean allHidden) {
+                double gamma = ((ImageryLayer) usedLayers.iterator().next()).getGamma();
+                setRealValue(gamma);
+            }
+
+            @Override
+            protected void applyValueToLayer(ImageryLayer layer) {
+                layer.setGamma(getRealValue());
+            }
+
+            @Override
+            public ImageIcon getIcon() {
+               return ImageProvider.get("dialogs/layerlist", "gamma");
+            }
+
+            @Override
+            public String getLabel() {
+                return tr("Gamma");
+            }
+        }
+
+        /**
+         * This slider allows you to change the sharpness of a layer.
+         *
+         * @author Michael Zangl
+         * @see ImageryLayer#setSharpenLevel(double)
+         */
+        private class SharpnessSlider extends FilterSlider<ImageryLayer> {
+
+            /**
+             * Creates a new {@link SharpnessSlider}
+             */
+            SharpnessSlider() {
+                super(0, MAX_SHARPNESS_FACTOR, ImageryLayer.class);
+                setToolTipText(tr("Adjust sharpness/blur value of the layer."));
+            }
+
+            @Override
+            protected void updateSliderWhileEnabled(Collection<? extends Layer> usedLayers, boolean allHidden) {
+                setRealValue(((ImageryLayer) usedLayers.iterator().next()).getSharpenLevel());
+            }
+
+            @Override
+            protected void applyValueToLayer(ImageryLayer layer) {
+                layer.setSharpenLevel(getRealValue());
+            }
+
+            @Override
+            public ImageIcon getIcon() {
+               return ImageProvider.get("dialogs/layerlist", "sharpness");
+            }
+
+            @Override
+            public String getLabel() {
+                return tr("Sharpness");
+            }
+        }
+
+        /**
+         * This slider allows you to change the colorfulness of a layer.
+         *
+         * @author Michael Zangl
+         * @see ImageryLayer#setColorfulness(double)
+         */
+        private class ColorfulnessSlider extends FilterSlider<ImageryLayer> {
+
+            /**
+             * Create a new {@link ColorfulnessSlider}
+             */
+            ColorfulnessSlider() {
+                super(0, MAX_COLORFUL_FACTOR, ImageryLayer.class);
+                setToolTipText(tr("Adjust colorfulness of the layer."));
+            }
+
+            @Override
+            protected void updateSliderWhileEnabled(Collection<? extends Layer> usedLayers, boolean allHidden) {
+                setRealValue(((ImageryLayer) usedLayers.iterator().next()).getColorfulness());
+            }
+
+            @Override
+            protected void applyValueToLayer(ImageryLayer layer) {
+                layer.setColorfulness(getRealValue());
+            }
+
+            @Override
+            public ImageIcon getIcon() {
+               return ImageProvider.get("dialogs/layerlist", "colorfulness");
+            }
+
+            @Override
+            public String getLabel() {
+                return tr("Colorfulness");
+            }
         }
     }