Index: /applications/editors/josm/plugins/build-common.xml =================================================================== --- /applications/editors/josm/plugins/build-common.xml (revision 31469) +++ /applications/editors/josm/plugins/build-common.xml (revision 31470) @@ -13,6 +13,6 @@ - - + + Index: /applications/editors/josm/plugins/rasterfilters/.classpath =================================================================== --- /applications/editors/josm/plugins/rasterfilters/.classpath (revision 31470) +++ /applications/editors/josm/plugins/rasterfilters/.classpath (revision 31470) @@ -0,0 +1,9 @@ + + + + + + + + + Index: /applications/editors/josm/plugins/rasterfilters/.project =================================================================== --- /applications/editors/josm/plugins/rasterfilters/.project (revision 31470) +++ /applications/editors/josm/plugins/rasterfilters/.project (revision 31470) @@ -0,0 +1,23 @@ + + + rasterfilters + JavaCC Nature + + + + + sf.eclipse.javacc.javaccbuilder + + + + + org.eclipse.jdt.core.javabuilder + + + + + + org.eclipse.jdt.core.javanature + sf.eclipse.javacc.javaccnature + + Index: /applications/editors/josm/plugins/rasterfilters/.settings/sf.eclipse.javacc.prefs =================================================================== --- /applications/editors/josm/plugins/rasterfilters/.settings/sf.eclipse.javacc.prefs (revision 31470) +++ /applications/editors/josm/plugins/rasterfilters/.settings/sf.eclipse.javacc.prefs (revision 31470) @@ -0,0 +1,13 @@ +CLEAR_CONSOLE=true +JAVACC_OPTIONS= +JJDOC_OPTIONS= +JJTREE_OPTIONS= +JJ_NATURE=true +JTB_OPTIONS=-ia -jd -tk +KEEP_DEL_FILES_IN_HISTORY=false +MARK_GEN_FILES_AS_DERIVED=true +RUNTIME_JJJAR= +RUNTIME_JTBJAR= +RUNTIME_JVMOPTIONS= +SUPPRESS_WARNINGS=false +eclipse.preferences.version=1 Index: /applications/editors/josm/plugins/rasterfilters/LICENSE =================================================================== --- /applications/editors/josm/plugins/rasterfilters/LICENSE (revision 31470) +++ /applications/editors/josm/plugins/rasterfilters/LICENSE (revision 31470) @@ -0,0 +1,15 @@ +DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE + Version 2, December 2004 + + Copyright (C) 2004 Sam Hocevar + + Everyone is permitted to copy and distribute verbatim or modified + copies of this license document, and changing it is allowed as long + as the name is changed. + + DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. You just DO WHAT THE FUCK YOU WANT TO. + +Icon made by http://www.freepik.com" from "http://www.flaticon.com" is licensed under "http://creativecommons.org/licenses/by/3.0/" Index: /applications/editors/josm/plugins/rasterfilters/build.xml =================================================================== --- /applications/editors/josm/plugins/rasterfilters/build.xml (revision 31470) +++ /applications/editors/josm/plugins/rasterfilters/build.xml (revision 31470) @@ -0,0 +1,20 @@ + + + + + + + + + + + + + + + + + + + + Index: /applications/editors/josm/plugins/rasterfilters/src/org/openstreetmap/josm/plugins/rasterfilters/RasterFiltersPlugin.java =================================================================== --- /applications/editors/josm/plugins/rasterfilters/src/org/openstreetmap/josm/plugins/rasterfilters/RasterFiltersPlugin.java (revision 31470) +++ /applications/editors/josm/plugins/rasterfilters/src/org/openstreetmap/josm/plugins/rasterfilters/RasterFiltersPlugin.java (revision 31470) @@ -0,0 +1,136 @@ +package org.openstreetmap.josm.plugins.rasterfilters; + +import java.awt.Container; +import java.io.File; +import java.io.IOException; + +import javax.swing.JPanel; + +import org.openstreetmap.josm.Main; +import org.openstreetmap.josm.gui.MapFrame; +import org.openstreetmap.josm.gui.MapView; +import org.openstreetmap.josm.gui.MapView.LayerChangeListener; +import org.openstreetmap.josm.gui.SideButton; +import org.openstreetmap.josm.gui.dialogs.LayerListDialog; +import org.openstreetmap.josm.gui.layer.ImageryLayer; +import org.openstreetmap.josm.gui.layer.Layer; +import org.openstreetmap.josm.gui.preferences.PreferenceSetting; +import org.openstreetmap.josm.plugins.Plugin; +import org.openstreetmap.josm.plugins.PluginInformation; +import org.openstreetmap.josm.plugins.rasterfilters.actions.ShowLayerFiltersDialog; +import org.openstreetmap.josm.plugins.rasterfilters.gui.FiltersDialog; +import org.openstreetmap.josm.plugins.rasterfilters.preferences.FiltersDownloader; +import org.openstreetmap.josm.plugins.rasterfilters.preferences.RasterFiltersPreferences; + +public class RasterFiltersPlugin extends Plugin implements LayerChangeListener { + + private SideButton filterButton; + private ShowLayerFiltersDialog action; + private PreferenceSetting setting; + + public RasterFiltersPlugin(PluginInformation info) { + super(info); + Main.debug("Loading RasterFiltersPlugin"); + + File file = new File(getPluginDir()); + if (file.mkdir()) { + file = new File(file.getAbsoluteFile() + "\\urls.map"); + if (!file.exists()) { + try { + file.createNewFile(); + } catch (IOException e) { + Main.debug("Cannot create file" + file.getAbsolutePath() + "\n" + e.getMessage()); + } + } + } + + FiltersDownloader.setPluginDir(getPluginDir()); + } + + @Override + public void mapFrameInitialized(MapFrame oldFrame, MapFrame newFrame) { + if (Main.isDisplayingMapView()) { + MapView.addLayerChangeListener(this); + } + } + + @Override + public void activeLayerChange(Layer oldLayer, Layer newLayer) { + if (!(newLayer instanceof ImageryLayer)) { + filterButton.setEnabled(false); + } else { + filterButton.setEnabled(true); + } + + } + + @Override + public void layerAdded(Layer newLayer) { + + if (filterButton == null) { + + // filter reading and adding to the collections of + // FilterDownloader + FiltersDownloader.downloadFiltersInfoList(); + FiltersDownloader.initFilters(); + + LayerListDialog dialog = Main.map + .getToggleDialog(LayerListDialog.class); + + if (action == null) { + action = new ShowLayerFiltersDialog(); + } + + if (newLayer instanceof ImageryLayer) { + filterButton = new SideButton(action, false); + filterButton.setEnabled(true); + } else { + filterButton = new SideButton(action, false); + filterButton.setEnabled(false); + } + + JPanel buttonRowPanel = (JPanel) ((JPanel) dialog.getComponent(2)) + .getComponent(0); + buttonRowPanel.add(filterButton); + + Main.debug("Layer " + newLayer.getName() + "was added"); + } + + if (newLayer instanceof ImageryLayer) { + FiltersDialog dialog = new FiltersDialog((ImageryLayer) newLayer); + action.addFiltersDialog(dialog); + } + + } + + @Override + public void layerRemoved(Layer oldLayer) { + Main.debug("Layer " + oldLayer.getName() + "was removed"); + + if (oldLayer instanceof ImageryLayer) { + FiltersDialog dialog = action.getDialogByLayer(oldLayer); + ((ImageryLayer) oldLayer).removeImageProcessor(dialog.getFiltersManager()); + dialog.closeFrame(); + action.removeFiltersDialog(dialog); + } + + if (Main.map.mapView.getAllLayersAsList().size() == 0) { + + Container container = filterButton.getParent(); + container.remove(filterButton); + FiltersDownloader.destroyFilters(); + filterButton = null; + + } + } + + @Override + public PreferenceSetting getPreferenceSetting() { + if (setting == null) { + setting = new RasterFiltersPreferences(); + } + + return setting; + } + +} Index: /applications/editors/josm/plugins/rasterfilters/src/org/openstreetmap/josm/plugins/rasterfilters/actions/ShowLayerFiltersDialog.java =================================================================== --- /applications/editors/josm/plugins/rasterfilters/src/org/openstreetmap/josm/plugins/rasterfilters/actions/ShowLayerFiltersDialog.java (revision 31470) +++ /applications/editors/josm/plugins/rasterfilters/src/org/openstreetmap/josm/plugins/rasterfilters/actions/ShowLayerFiltersDialog.java (revision 31470) @@ -0,0 +1,90 @@ +package org.openstreetmap.josm.plugins.rasterfilters.actions; + +import static org.openstreetmap.josm.tools.I18n.tr; + +import java.awt.Component; +import java.awt.event.ActionEvent; +import java.net.MalformedURLException; +import java.util.ArrayList; +import java.util.List; + +import javax.swing.AbstractAction; +import javax.swing.JMenuItem; + +import org.openstreetmap.josm.Main; +import org.openstreetmap.josm.gui.dialogs.LayerListDialog.ShowHideLayerAction; +import org.openstreetmap.josm.gui.layer.ImageryLayer; +import org.openstreetmap.josm.gui.layer.Layer; +import org.openstreetmap.josm.gui.layer.Layer.LayerAction; +import org.openstreetmap.josm.plugins.rasterfilters.gui.FiltersDialog; +import org.openstreetmap.josm.tools.ImageProvider; + +public final class ShowLayerFiltersDialog extends AbstractAction implements LayerAction { + + private List dialogs = new ArrayList(); + + /** + * Creates a {@link ShowHideLayerAction} which will toggle the visibility of + * the currently selected layers + * + */ + public ShowLayerFiltersDialog() { + putValue(NAME, tr("Filters")); + putValue(SHORT_DESCRIPTION, tr("Choose Filter")); + putValue(SMALL_ICON, ImageProvider.get("josm_filters_48.png")); + } + + public void addFiltersDialog(FiltersDialog dialog) { + dialogs.add(dialog); + } + + public void removeFiltersDialog(FiltersDialog dialog) { + dialogs.remove(dialog); + } + + @Override + public void actionPerformed(ActionEvent e) { + + Layer layer = Main.map.mapView.getActiveLayer(); + + if (layer instanceof ImageryLayer) { + for (FiltersDialog temp : dialogs) { + + if (temp.getLayer().equals(layer)) { + try { + + temp.createAndShowGUI(); + + } catch (MalformedURLException e1) { + e1.printStackTrace(); + } + + break; + } + + } + } + } + + public FiltersDialog getDialogByLayer(Layer layer) { + for (FiltersDialog dialog : dialogs) { + + if (dialog.getLayer().equals(layer)) { + return dialog; + } + + } + + return null; + } + + @Override + public boolean supportLayers(List layers) { + return true; + } + + @Override + public Component createMenuComponent() { + return new JMenuItem(this); + } +} Index: /applications/editors/josm/plugins/rasterfilters/src/org/openstreetmap/josm/plugins/rasterfilters/filters/Filter.java =================================================================== --- /applications/editors/josm/plugins/rasterfilters/src/org/openstreetmap/josm/plugins/rasterfilters/filters/Filter.java (revision 31470) +++ /applications/editors/josm/plugins/rasterfilters/src/org/openstreetmap/josm/plugins/rasterfilters/filters/Filter.java (revision 31470) @@ -0,0 +1,17 @@ +package org.openstreetmap.josm.plugins.rasterfilters.filters; + +import java.awt.image.BufferedImage; +import java.rmi.server.UID; + +import javax.json.JsonObject; + +public interface Filter { + + public JsonObject changeFilterState(JsonObject filterState); + + public BufferedImage applyFilter(BufferedImage img); + + public void setId(UID id); + + public UID getId(); +} Index: /applications/editors/josm/plugins/rasterfilters/src/org/openstreetmap/josm/plugins/rasterfilters/gui/FilterGuiListener.java =================================================================== --- /applications/editors/josm/plugins/rasterfilters/src/org/openstreetmap/josm/plugins/rasterfilters/gui/FilterGuiListener.java (revision 31470) +++ /applications/editors/josm/plugins/rasterfilters/src/org/openstreetmap/josm/plugins/rasterfilters/gui/FilterGuiListener.java (revision 31470) @@ -0,0 +1,141 @@ +package org.openstreetmap.josm.plugins.rasterfilters.gui; + +import java.awt.Color; +import java.awt.event.ActionEvent; +import java.awt.event.ActionListener; +import java.awt.event.ItemEvent; +import java.awt.event.ItemListener; +import java.beans.PropertyChangeEvent; +import java.beans.PropertyChangeListener; +import java.rmi.server.UID; +import java.util.HashSet; +import java.util.Set; + +import javax.swing.ComboBoxModel; +import javax.swing.JCheckBox; +import javax.swing.JComboBox; +import javax.swing.JSlider; +import javax.swing.event.ChangeEvent; +import javax.swing.event.ChangeListener; + +import org.openstreetmap.josm.plugins.rasterfilters.model.FilterStateModel; +import org.openstreetmap.josm.plugins.rasterfilters.model.StateChangeListener; +import org.openstreetmap.josm.plugins.rasterfilters.values.BooleanValue; +import org.openstreetmap.josm.plugins.rasterfilters.values.ColorValue; +import org.openstreetmap.josm.plugins.rasterfilters.values.SelectValue; +import org.openstreetmap.josm.plugins.rasterfilters.values.SliderValue; + +import com.bric.swing.ColorPicker; + +public class FilterGuiListener implements ChangeListener, ItemListener, +ActionListener, PropertyChangeListener, FilterStateOwner { + + private StateChangeListener handler; + private FilterStateModel filterState; + private Set> models = new HashSet<>(); + private UID filterId; + + public FilterGuiListener(StateChangeListener handler) { + this.handler = handler; + } + + public void setFilterState(FilterStateModel state) { + this.filterState = state; + } + + @Override + public void stateChanged(ChangeEvent e) { + + JSlider slider = (JSlider) e.getSource(); + + if (!slider.getValueIsAdjusting()) { + slider.setToolTipText(String.valueOf((double) slider.getValue() / 100)); + } + + String parameterName = slider.getName(); + + if (filterState.getParams().containsKey(parameterName)) { + + SliderValue value = (SliderValue) filterState.getParams().get(parameterName); + + if (value.isDouble()) { + value.setValue((double) slider.getValue() / 100); + } else { + value.setValue(slider.getValue()); + } + + filterState.getParams().put(parameterName, value); + } + + // notify about state is changed now so send msg to FiltersManager + handler.filterStateChanged(filterId, filterState); + } + + @Override + public FilterStateModel getState() { + return filterState; + } + + public ComboBoxModel addModel(ComboBoxModel model) { + models.add(model); + return model; + } + + public void setFilterId(UID filterId) { + this.filterId = filterId; + } + + public UID getFilterId() { + return filterId; + } + + @Override + public void itemStateChanged(ItemEvent e) { + + JCheckBox box = (JCheckBox) e.getSource(); + + String parameterName = box.getName(); + + BooleanValue value = (BooleanValue) filterState.getParams().get( + parameterName); + value.setValue(box.isSelected()); + + handler.filterStateChanged(filterId, filterState); + + } + + @Override + public void actionPerformed(ActionEvent e) { + + JComboBox box = (JComboBox) e.getSource(); + + String parameterName = box.getName(); + SelectValue value = (SelectValue) filterState.getParams().get(parameterName); + + ComboBoxModel model = box.getModel(); + String selectedItem = (String) model.getSelectedItem(); + + value.setValue(selectedItem); + + // notify about state is changed now so send msg to FiltersManager + handler.filterStateChanged(filterId, filterState); + + } + + @Override + public void propertyChange(PropertyChangeEvent evt) { + ColorPicker picker = (ColorPicker) evt.getSource(); + + int r = picker.getColor().getRed(); + int g = picker.getColor().getGreen(); + int b = picker.getColor().getBlue(); + + String parameterName = picker.getName(); + + ColorValue value = (ColorValue) filterState.getParams().get(parameterName); + value.setValue(new Color(r, g, b)); + + handler.filterStateChanged(filterId, filterState); + } + +} Index: /applications/editors/josm/plugins/rasterfilters/src/org/openstreetmap/josm/plugins/rasterfilters/gui/FilterPanel.java =================================================================== --- /applications/editors/josm/plugins/rasterfilters/src/org/openstreetmap/josm/plugins/rasterfilters/gui/FilterPanel.java (revision 31470) +++ /applications/editors/josm/plugins/rasterfilters/src/org/openstreetmap/josm/plugins/rasterfilters/gui/FilterPanel.java (revision 31470) @@ -0,0 +1,321 @@ +package org.openstreetmap.josm.plugins.rasterfilters.gui; + +import static org.openstreetmap.josm.tools.I18n.tr; + +import java.awt.Color; +import java.awt.Component; +import java.awt.Dimension; +import java.awt.FlowLayout; +import java.awt.Font; +import java.awt.event.ActionListener; +import java.awt.event.ItemListener; +import java.rmi.server.UID; +import java.util.Hashtable; + +import javax.json.JsonArray; +import javax.json.JsonObject; +import javax.swing.BorderFactory; +import javax.swing.Box; +import javax.swing.BoxLayout; +import javax.swing.DefaultComboBoxModel; +import javax.swing.JButton; +import javax.swing.JCheckBox; +import javax.swing.JComboBox; +import javax.swing.JComponent; +import javax.swing.JLabel; +import javax.swing.JOptionPane; +import javax.swing.JPanel; +import javax.swing.JSlider; +import javax.swing.border.Border; +import javax.swing.border.EmptyBorder; + +import org.openstreetmap.josm.Main; +import org.openstreetmap.josm.plugins.rasterfilters.model.FiltersManager; + +import com.bric.swing.ColorPicker; + +public class FilterPanel extends JPanel { + + private static final long serialVersionUID = 1L; + private UID filterId; + private int neededHeight; + + public FilterPanel() { + super(); + setLayout(new BoxLayout(this, BoxLayout.PAGE_AXIS)); + setBackground(Color.white); + } + + public JComponent addGuiElement(JsonObject json) { + String type = json.getString("type"); + + if (type.equals("linear_slider")) { + + setNeededHeight(getNeededHeight() + 70); + + return createSlider(json); + + } else if (type.equals("checkbox")) { + + setNeededHeight(getNeededHeight() + 30); + + JCheckBox checkBox = createCheckBox(json.getString("title")); + checkBox.setSelected(json.getBoolean("default")); + checkBox.setName(json.getString("name")); + + return checkBox; + + } else if (type.equals("select")) { + + setNeededHeight(getNeededHeight() + 50); + + return createSelect(json); + + } else if (type.equals("colorpicker")) { + + setNeededHeight(getNeededHeight() + 220); + + return createColorPicker(json); + } + return null; + } + + private JComponent createSelect(JsonObject json) { + + Font font = new Font("Arial", Font.PLAIN, 14); + + JPanel selectPanel = new JPanel(); + + selectPanel.setBorder(new EmptyBorder(5, 5, 5, 5)); + selectPanel.setBackground(Color.white); + selectPanel.setLayout(new BoxLayout(selectPanel, BoxLayout.X_AXIS)); + selectPanel.setMaximumSize(new Dimension(300, 40)); + + JLabel selectTitle = new JLabel(json.getString("title")); + + selectTitle.setFont(font); + selectTitle.setBackground(Color.white); + + JsonArray valuesArray = json.getJsonArray("values"); + + DefaultComboBoxModel model = new DefaultComboBoxModel<>(); + + model.setSelectedItem(json.getString("default")); + + for (int i = 0; i < valuesArray.size(); i++) { + model.addElement(valuesArray.getString(i)); + } + + JComboBox selectBox = new JComboBox<>(model); + selectBox.setMinimumSize(new Dimension(140, 30)); + + selectPanel.add(selectTitle); + selectPanel.add(Box.createHorizontalGlue()); + selectPanel.add(selectBox); + selectBox.setName(json.getString("name")); + + this.add(selectPanel); + + return selectBox; + } + + public JComponent createColorPicker(JsonObject json) { + + ColorPicker picker = new ColorPicker(false, false); + picker.setPreferredSize(new Dimension(200,180)); + picker.setMode(ColorPicker.HUE); + picker.setName(json.getString("name")); + + addControlTitle(json.getString("title")); + + this.add(picker); + + return picker; + } + + public JCheckBox createCheckBox(String text) { + + JPanel checkBoxPanel = new JPanel(); + checkBoxPanel.setMaximumSize(new Dimension(300, 30)); + checkBoxPanel.setLayout(new BoxLayout(checkBoxPanel, BoxLayout.X_AXIS)); + checkBoxPanel.setBackground(Color.white); + + JCheckBox checkBox = new JCheckBox(text); + Font font = new Font("Arial", Font.PLAIN, 12); + + checkBox.setFont(font); + checkBox.setBackground(Color.white); + checkBox.setName(text); + + checkBoxPanel.add(checkBox); + + this.add(checkBoxPanel); + + return checkBox; + } + + private JCheckBox createDisableBox(ItemListener listener) { + JCheckBox disable = new JCheckBox("Disable"); + Font font = new Font("Arial", Font.PLAIN, 12); + + disable.addItemListener(listener); + disable.setFont(font); + + return disable; + } + + private JButton createRemoveButton(ActionListener listener) { + JButton removeButton = new JButton("Remove"); + Font font = new Font("Arial", Font.PLAIN, 12); + + removeButton.setFont(font); + removeButton.setName("remove"); + + removeButton.addActionListener(listener); + + return removeButton; + } + + public JPanel createBottomPanel(FiltersManager listener) { + + this.add(Box.createRigidArea(new Dimension(0, 10))); + JPanel bottom = new JPanel(); + + bottom.setLayout(new BoxLayout(bottom, BoxLayout.X_AXIS)); + bottom.setMaximumSize(new Dimension(300, 40)); + bottom.setBorder(BorderFactory + .createMatteBorder(2, 0, 0, 0, Color.gray)); + + bottom.add(createDisableBox(listener)); + bottom.add(Box.createHorizontalGlue()); + bottom.add(createRemoveButton(listener)); + + this.add(bottom); + + return bottom; + } + + private void addControlTitle(String labelText) { + Font labelFont = new Font("Arial", Font.PLAIN, 14); + + JPanel sliderLabelPanel = new JPanel(); + sliderLabelPanel.setMaximumSize(new Dimension(400, 30)); + sliderLabelPanel.setLayout(new FlowLayout(FlowLayout.LEFT)); + sliderLabelPanel.setBackground(Color.white); + + JLabel sliderLabel = new JLabel(labelText, JLabel.LEFT); + sliderLabel.setFont(labelFont); + sliderLabel.setAlignmentX(Component.LEFT_ALIGNMENT); + sliderLabel.setVisible(true); + + sliderLabelPanel.add(sliderLabel); + + this.add(sliderLabelPanel); + } + + public JSlider createSlider(JsonObject json) { + + Border sliderBorder = new EmptyBorder(5, 5, 5, 5); + + addControlTitle(json.getString("title")); + + Hashtable labelTable = new Hashtable<>(); + + JsonArray array = json.getJsonArray("scale"); + + String valueType = json.getString("value_type"); + + JSlider slider = null; + if (valueType.equals("integer")) { + int minValue = array.getInt(0); + int maxValue = array.getInt(1); + int initValue = json.getInt("default"); + + try { + slider = new JSlider(JSlider.HORIZONTAL, minValue, maxValue, + initValue); + slider.setName(json.getString("name")); + slider.setToolTipText(String.valueOf(slider.getValue())); + slider.setMinorTickSpacing(maxValue / 4); + } catch(IllegalArgumentException e) { + + JOptionPane.showMessageDialog( + Main.parent, + tr("JSlider initialization's error. Make sure your meta-inf is correct."), + tr("Error"), + JOptionPane.ERROR_MESSAGE); + } + + } else if (valueType.equals("float")) { + + // every value is supplied by 10 to be integer for slider + double minValueDouble = array.getJsonNumber(0).doubleValue(); + double maxValueDouble = array.getJsonNumber(1).doubleValue(); + Main.debug("DminValue: " + String.valueOf(minValueDouble) + + "DmaxValue: " + String.valueOf(maxValueDouble)); + + int minValue = (int) (minValueDouble * 100); + int maxValue = (int) (maxValueDouble * 100); + + + double initValue = json.getJsonNumber("default").doubleValue() * 100; + double delta = (maxValue - minValue) / 100; + + for (int i = 0; i <= maxValue; i++) { + + if ((i % 20) == 0) { + + labelTable.put(new Integer(i), + new JLabel(String.valueOf(i * delta / 100))); + + } + } + Main.debug("minValue: " + String.valueOf(minValue) + + "\nmaxValue: " + String.valueOf(maxValue) + + "\ninitValue: " + new Double(initValue).intValue()); + + try { + + slider = new JSlider(JSlider.HORIZONTAL, minValue, maxValue, + new Double(initValue).intValue()); + slider.setMinorTickSpacing(maxValue / 4); + slider.setName(json.getString("name")); + slider.setToolTipText(String.valueOf((double) slider.getValue() / 100)); + slider.setBackground(this.getBackground()); + slider.setBorder(sliderBorder); + slider.setPaintTicks(true); + slider.setPaintLabels(true); + this.add(slider); + + } catch (IllegalArgumentException e) { + + JOptionPane.showMessageDialog( + Main.parent, + tr("JSlider initialization's error. Make sure your meta-inf is correct."), + tr("Error"), + JOptionPane.ERROR_MESSAGE); + + } + + } + + return slider; + } + + public void setFilterId(UID filterId) { + this.filterId = filterId; + } + + public UID getFilterId() { + return filterId; + } + + public int getNeededHeight() { + return neededHeight; + } + + public void setNeededHeight(int neededHeight) { + this.neededHeight = neededHeight; + } + +} Index: /applications/editors/josm/plugins/rasterfilters/src/org/openstreetmap/josm/plugins/rasterfilters/gui/FilterStateOwner.java =================================================================== --- /applications/editors/josm/plugins/rasterfilters/src/org/openstreetmap/josm/plugins/rasterfilters/gui/FilterStateOwner.java (revision 31470) +++ /applications/editors/josm/plugins/rasterfilters/src/org/openstreetmap/josm/plugins/rasterfilters/gui/FilterStateOwner.java (revision 31470) @@ -0,0 +1,9 @@ +package org.openstreetmap.josm.plugins.rasterfilters.gui; + +import org.openstreetmap.josm.plugins.rasterfilters.model.FilterStateModel; + +public interface FilterStateOwner { + + public FilterStateModel getState(); + +} Index: /applications/editors/josm/plugins/rasterfilters/src/org/openstreetmap/josm/plugins/rasterfilters/gui/FiltersDialog.java =================================================================== --- /applications/editors/josm/plugins/rasterfilters/src/org/openstreetmap/josm/plugins/rasterfilters/gui/FiltersDialog.java (revision 31470) +++ /applications/editors/josm/plugins/rasterfilters/src/org/openstreetmap/josm/plugins/rasterfilters/gui/FiltersDialog.java (revision 31470) @@ -0,0 +1,249 @@ +package org.openstreetmap.josm.plugins.rasterfilters.gui; + +import java.awt.Color; +import java.awt.Component; +import java.awt.Dimension; +import java.awt.event.ActionEvent; +import java.awt.event.ActionListener; +import java.net.MalformedURLException; +import java.util.HashSet; +import java.util.Set; + +import javax.swing.Box; +import javax.swing.BoxLayout; +import javax.swing.DefaultComboBoxModel; +import javax.swing.JButton; +import javax.swing.JComboBox; +import javax.swing.JFrame; +import javax.swing.JLabel; +import javax.swing.JPanel; +import javax.swing.JScrollPane; +import javax.swing.border.EmptyBorder; + +import org.openstreetmap.josm.gui.layer.ImageryLayer; +import org.openstreetmap.josm.gui.layer.Layer; +import org.openstreetmap.josm.plugins.rasterfilters.model.FiltersManager; +import org.openstreetmap.josm.plugins.rasterfilters.preferences.FiltersDownloader; + +public class FiltersDialog { + + public JFrame frame; + private JComboBox filterChooser; + private JPanel pane; + private JButton addButton; + private DefaultComboBoxModel listModel = new DefaultComboBoxModel(); + private Set showedFiltersTitles = new HashSet<>(); + private JPanel filterContainer; + private Layer layer; + private FiltersManager filtersManager; + private JScrollPane filterContainerScroll; + + public FiltersDialog(ImageryLayer layer) { + this.layer = layer; + this.filtersManager = new FiltersManager(this); + layer.addImageProcessor(filtersManager); + } + + public JPanel createFilterContainer() { + if (filterContainer == null) { + + filterContainer = new JPanel(); + filterContainer.setLayout(new BoxLayout(getFilterContainer(), + BoxLayout.Y_AXIS)); + filterContainer.setBackground(Color.white); + + filterContainerScroll = new JScrollPane(getFilterContainer(), + JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED, + JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED); + + pane.add(filterContainerScroll); + + } + + return filterContainer; + } + + public void deleteFilterContainer() { + + Component parent = filterContainerScroll.getParent(); + filterContainerScroll.removeAll(); + ((JPanel) parent).remove(filterContainerScroll); + + filterContainer = null; + + parent.revalidate(); + parent.repaint(); + } + + public JFrame createAndShowGUI() throws MalformedURLException { + listModel.removeAllElements(); + + Set filterTitles = FiltersDownloader.filterTitles; + + for (String temp : filterTitles) { + + if (!showedFiltersTitles.contains(temp)) { + listModel.addElement(temp); + } + + } + + if (frame != null) { + + filterChooser.setModel(listModel); + filterChooser.revalidate(); + frame.setVisible(true); + + } else { + + frame = new JFrame(); + String title = "Filters | " + layer.getName(); + frame.setTitle(title); + frame.setMinimumSize(new Dimension(350, 420)); + frame.setPreferredSize(new Dimension(350, 420)); + + pane = new JPanel(); + pane.setLayout(new BoxLayout(pane, BoxLayout.Y_AXIS)); + + pane.setBorder(new EmptyBorder(10, 5, 10, 5)); + pane.setPreferredSize(new Dimension(300, 400)); + pane.setBackground(Color.white); + + JPanel topPanel = new JPanel(); + topPanel.setLayout(new BoxLayout(topPanel, BoxLayout.Y_AXIS)); + topPanel.setMaximumSize(new Dimension(300, 50)); + topPanel.setMinimumSize(new Dimension(300, 50)); + topPanel.setBackground(Color.white); + + JPanel labelPanel = new JPanel(); + labelPanel.setLayout(new BoxLayout(labelPanel, BoxLayout.X_AXIS)); + labelPanel.setMaximumSize(new Dimension(300, 20)); + labelPanel.setBackground(Color.white); + + JLabel label = new JLabel("Add filter"); + labelPanel.add(label); +// pane.add(labelPanel); + + // TODO why after add clicked the top panel is resized??? + + // panel that contains the checkBox and add button + JPanel chooseFilterPanel = new JPanel(); + chooseFilterPanel.setMinimumSize(new Dimension(300, 30)); + chooseFilterPanel.setLayout(new BoxLayout(chooseFilterPanel, + BoxLayout.X_AXIS)); + chooseFilterPanel.setBackground(Color.white); + + filterChooser = new JComboBox<>(getListModel()); + filterChooser.setMaximumSize(new Dimension(200, 30)); + chooseFilterPanel.add(filterChooser); + + // empty space area between select and add button + chooseFilterPanel.add(Box.createRigidArea(new Dimension(10, 0))); + + addButton = new JButton(); + addButton.setText("add"); + addButton.setAlignmentX(Component.CENTER_ALIGNMENT); + addButton.setMaximumSize(new Dimension(90, 30)); + addButton.addActionListener(new AddFilterToPanelListener()); +// +// // check if there is no meta information +// Main.debug("Empty " + String.valueOf(FiltersDownloader.filterTitles.isEmpty())); +// if (FiltersDownloader.filterTitles.isEmpty() || listModel.getSize() == 0) { +// addButton.setEnabled(false); +// filterChooser.setEnabled(false); +// } else { +// addButton.setEnabled(true); +// filterChooser.setEnabled(true); +// } + + chooseFilterPanel.add(getAddButton()); + + topPanel.add(labelPanel); + topPanel.add(chooseFilterPanel); + pane.add(topPanel); +// pane.add(chooseFilterPanel); +// pane.add(Box.createRigidArea(new Dimension(0, 20))); + + frame.setContentPane(pane); + frame.pack(); + frame.setVisible(true); + } + + + if (FiltersDownloader.filterTitles.isEmpty() || listModel.getSize() == 0) { + addButton.setEnabled(false); + filterChooser.setEnabled(false); + } else { + addButton.setEnabled(true); + filterChooser.setEnabled(true); + } + + return frame; + } + + public FiltersManager createFilterManager() { + return new FiltersManager(this); + } + + public void closeFrame() { + if (frame != null) { + if (frame.isShowing()) { + frame.dispose(); + } + } + } + + public Layer getLayer() { + return layer; + } + + public JPanel getFilterContainer() { + return filterContainer; + } + + public DefaultComboBoxModel getListModel() { + return listModel; + } + + public JComboBox getFilterChooser() { + return filterChooser; + } + + public JButton getAddButton() { + return addButton; + } + + public FiltersManager getFiltersManager() { + return filtersManager; + } + + class AddFilterToPanelListener implements ActionListener { + + @Override + public void actionPerformed(ActionEvent e) { + + String title = (String) listModel.getSelectedItem(); + JPanel panel = null; + + panel = filtersManager.createPanelByTitle(title); + + if (panel != null) { + filterContainer = createFilterContainer(); + filterContainer.add(panel); + } + + listModel.removeElement(title); + showedFiltersTitles.add(title); + + if (listModel.getSize() == 0) { + filterChooser.setEnabled(false); + addButton.setEnabled(false); + } + + } + } + + public Set getShowedFiltersTitles() { + return showedFiltersTitles; + } +} Index: /applications/editors/josm/plugins/rasterfilters/src/org/openstreetmap/josm/plugins/rasterfilters/model/FilterInitializer.java =================================================================== --- /applications/editors/josm/plugins/rasterfilters/src/org/openstreetmap/josm/plugins/rasterfilters/model/FilterInitializer.java (revision 31470) +++ /applications/editors/josm/plugins/rasterfilters/src/org/openstreetmap/josm/plugins/rasterfilters/model/FilterInitializer.java (revision 31470) @@ -0,0 +1,46 @@ +package org.openstreetmap.josm.plugins.rasterfilters.model; + + +public class FilterInitializer { +/* + public static Set filterTitles = new TreeSet<>(); + public static List filtersMeta = FiltersInfoListDownloader.filtersMeta; + public static Set urls = new HashSet<>(); + public static ClassLoader loader; + + public static void initFilters() { + + for (JsonObject json : filtersMeta) { + + filterTitles.add(json.getString("title")); + + JsonArray binaries = json.getJsonArray("binaries"); + + for (int i = 0; i < binaries.size(); i++) { + + File file = new File(binaries.getString(i)); + + if (file.exists()) { + URL url; + try { + url = new URL("jar", "", file.toURI().toURL() + "!/"); + urls.add(url); + } catch (MalformedURLException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } + + } + } + + loader = new URLClassLoader(urls.toArray(new URL[urls.size()]), + FilterInitializer.class.getClassLoader()); + } + + public static void destroyFilters() { + filterTitles.clear(); + urls.clear(); + FiltersInfoListDownloader.filtersMeta.clear(); + }*/ +} Index: /applications/editors/josm/plugins/rasterfilters/src/org/openstreetmap/josm/plugins/rasterfilters/model/FilterStateModel.java =================================================================== --- /applications/editors/josm/plugins/rasterfilters/src/org/openstreetmap/josm/plugins/rasterfilters/model/FilterStateModel.java (revision 31470) +++ /applications/editors/josm/plugins/rasterfilters/src/org/openstreetmap/josm/plugins/rasterfilters/model/FilterStateModel.java (revision 31470) @@ -0,0 +1,151 @@ +package org.openstreetmap.josm.plugins.rasterfilters.model; + +import java.awt.Color; +import java.util.HashMap; +import java.util.Map; +import java.util.Map.Entry; + +import javax.json.Json; +import javax.json.JsonObject; +import javax.json.JsonObjectBuilder; + +import org.openstreetmap.josm.plugins.rasterfilters.values.BooleanValue; +import org.openstreetmap.josm.plugins.rasterfilters.values.ColorValue; +import org.openstreetmap.josm.plugins.rasterfilters.values.SelectValue; +import org.openstreetmap.josm.plugins.rasterfilters.values.SliderValue; +import org.openstreetmap.josm.plugins.rasterfilters.values.Value; + +public class FilterStateModel { + + private Map> params = new HashMap<>(); + private String filterClassName; + + public FilterStateModel() { + + } + + public Map> getParams() { + return params; + } + + public String getFilterClassName() { + return filterClassName; + } + + public void setFilterClassName(String filterClassName) { + this.filterClassName = filterClassName; + } + + public void addParams(JsonObject json) { + + String parameterName = json.getString("name"); + String valueType = json.getString("value_type"); + + // setting up the beginning state of filter + // according to its metainfo + if (json.getString("type").equals("linear_slider")) { + + if (valueType.equals("float") || valueType.equals("double")) { + + double defaultValue = json.getJsonNumber("default") + .doubleValue(); + + SliderValue value = new SliderValue<>(parameterName, + defaultValue); + params.put(parameterName, value); + + } else if (valueType.equals("integer")) { + + int defaultValue = json.getJsonNumber("default").intValue(); + + SliderValue value = new SliderValue<>(parameterName, + defaultValue); + params.put(parameterName, value); + + } + + } else if (json.getString("type").equals("checkbox")) { + + boolean defaultValue = json.getBoolean("default"); + + BooleanValue value = new BooleanValue(parameterName, defaultValue); + params.put(parameterName, value); + + } else if (json.getString("type").equals("select")) { + + String defaultValue = json.getString("default"); + + SelectValue value = new SelectValue<>(parameterName, + defaultValue); + params.put(parameterName, value); + + } else if (json.getString("type").equals("colorpicker")) { + + JsonObject defaultColorJson = json.getJsonObject("default"); + int r = defaultColorJson.getInt("red"); + int g = defaultColorJson.getInt("green"); + int b = defaultColorJson.getInt("blue"); + + Color defaultColor = new Color(r, g, b); + + ColorValue value = new ColorValue<>(parameterName, + defaultColor); + params.put(parameterName, value); + + } + } + + public JsonObject encodeJson() { + + JsonObjectBuilder jsonBuilder = Json.createObjectBuilder(); + + for (Entry> entry : params.entrySet()) { + + Object value = entry.getValue().getValue(); + + if (value instanceof String) { + + jsonBuilder.add(entry.getKey(), + Json.createObjectBuilder().add("value", (String) value) + .build()); + + } + + if (value instanceof Boolean) { + jsonBuilder.add(entry.getKey(), + Json.createObjectBuilder() + .add("value", (Boolean) value).build()); + } + + if (value instanceof Number) { + + if (value instanceof Double) { + + jsonBuilder.add(entry.getKey(), Json.createObjectBuilder() + .add("value", (Double) value).build()); + + } else if (value instanceof Integer) { + + jsonBuilder.add(entry.getKey(), Json.createObjectBuilder() + .add("value", (Integer) value).build()); + + } + } + + if (value instanceof Color) { + + jsonBuilder.add(entry.getKey(), + Json.createObjectBuilder() + .add("value", Json.createObjectBuilder() + .add("red", ((Color) value).getRed()) + .add("green", ((Color) value).getGreen()) + .add("blue", ((Color) value).getBlue()) + .build()) + .build()); + + } + } + + return jsonBuilder.build(); + } +} Index: /applications/editors/josm/plugins/rasterfilters/src/org/openstreetmap/josm/plugins/rasterfilters/model/FiltersManager.java =================================================================== --- /applications/editors/josm/plugins/rasterfilters/src/org/openstreetmap/josm/plugins/rasterfilters/model/FiltersManager.java (revision 31470) +++ /applications/editors/josm/plugins/rasterfilters/src/org/openstreetmap/josm/plugins/rasterfilters/model/FiltersManager.java (revision 31470) @@ -0,0 +1,264 @@ +package org.openstreetmap.josm.plugins.rasterfilters.model; + +import java.awt.Dimension; +import java.awt.event.ActionEvent; +import java.awt.event.ActionListener; +import java.awt.event.ItemEvent; +import java.awt.event.ItemListener; +import java.awt.image.BufferedImage; +import java.rmi.server.UID; +import java.util.HashSet; +import java.util.Iterator; +import java.util.LinkedHashMap; +import java.util.Map; +import java.util.Set; + +import javax.json.JsonArray; +import javax.json.JsonObject; +import javax.swing.BorderFactory; +import javax.swing.JButton; +import javax.swing.JCheckBox; +import javax.swing.JComboBox; +import javax.swing.JComponent; +import javax.swing.JPanel; +import javax.swing.JSlider; + +import org.openstreetmap.josm.Main; +import org.openstreetmap.josm.gui.layer.ImageProcessor; +import org.openstreetmap.josm.plugins.rasterfilters.filters.Filter; +import org.openstreetmap.josm.plugins.rasterfilters.gui.FilterGuiListener; +import org.openstreetmap.josm.plugins.rasterfilters.gui.FilterPanel; +import org.openstreetmap.josm.plugins.rasterfilters.gui.FiltersDialog; +import org.openstreetmap.josm.plugins.rasterfilters.preferences.FiltersDownloader; + +import com.bric.swing.ColorPicker; + +public class FiltersManager implements StateChangeListener, ImageProcessor, +ActionListener, ItemListener { + + public Map filtersMap = new LinkedHashMap<>(); + public Set disabledFilters = new HashSet<>(); + public FiltersDialog dialog; + + public FiltersManager(FiltersDialog dialog) { + this.dialog = dialog; + } + + private JPanel createFilterWithPanel(JsonObject meta) { + + FilterPanel fp = new FilterPanel(); + + // listener to track sliders and checkbox of creating filter + FilterGuiListener filterListener = new FilterGuiListener(this); + + String filterClassName = meta.getString("classname"); + + String filterTitle = meta.getString("title"); + + fp.setName(filterTitle); + + // creating model of the filter + FilterStateModel filterState = new FilterStateModel(); + filterState.setFilterClassName(filterClassName); + + // loading jar with filter at runtime + Class clazz; + + // filter for adding to map states + Filter filter = null; + + try { + Main.debug("ClassName for loading " + filterState.getFilterClassName()); + clazz = FiltersDownloader.loader.loadClass(filterState + .getFilterClassName()); + filter = (Filter) clazz.newInstance(); + + } catch (InstantiationException | IllegalAccessException e) { + + e.printStackTrace(); + + } catch (ClassNotFoundException e) { + + e.printStackTrace(); + + } + + if (filter != null) { + + UID filterId = new UID(); + fp.setFilterId(filterId); + filterListener.setFilterId(filterId); + filter.setId(filterId); + filtersMap.put(filterId, filter); + + // all filters enabled in the beggining by default + } + + fp.setBorder(BorderFactory.createTitledBorder(meta.getString("title"))); + + JsonArray controls = meta.getJsonArray("controls"); + + for (int i = 0; i < controls.size(); i++) { + + JsonObject temp = controls.getJsonObject(i); + // Main.debug(temp.toString()); + + JComponent component = fp.addGuiElement(temp); + + if (component != null) { + + if (component instanceof JSlider) { + ((JSlider) component).addChangeListener(filterListener); + } else if (component instanceof JCheckBox) { + ((JCheckBox) component).addItemListener(filterListener); + } else if (component instanceof JComboBox) { + ((JComboBox) component).addActionListener(filterListener); + } else if (component instanceof ColorPicker) { + ((ColorPicker) component).addPropertyChangeListener(filterListener); + } + + // adding parameters to the filter instance + filterState.addParams(temp); + } + + } + + fp.setNeededHeight(fp.getNeededHeight() + 60); + fp.setMaximumSize(new Dimension(300, fp.getNeededHeight())); + fp.setPreferredSize(new Dimension(300, fp.getNeededHeight())); + + filter.changeFilterState(filterState.encodeJson()); + Main.map.mapView.getActiveLayer().setFilterStateChanged(); + + fp.createBottomPanel(this); + + filterListener.setFilterState(filterState); + + Main.debug("The number of elems in the Filters map is equal \n" + + filtersMap.size()); + + return fp; + } + + /** + * The method notifies about changes in the filter's status + * + * @param filterState + * - model that contains info about filter which was changed + */ + @Override + public void filterStateChanged(UID filterId, FilterStateModel filterState) { + + if (filtersMap.get(filterId) != null) + filtersMap.get(filterId).changeFilterState(filterState.encodeJson()); + + Main.map.mapView.getActiveLayer().setFilterStateChanged(); + + } + + public JPanel createPanelByTitle(String title) { + + for (JsonObject json : FiltersDownloader.filtersMeta) { + + if (json.getString("title").equals(title)) { + return createFilterWithPanel(json); + } + } + + return null; + } + + @Override + public BufferedImage process(BufferedImage image) { + + Iterator it = filtersMap.values().iterator(); + + // iterating through map of filters according to the order + while (it.hasNext()) { + + Filter curFilter = it.next(); + + if (!disabledFilters.contains(curFilter)) { + // if next filter will return null + // we should take an old example of the image + BufferedImage oldImg = image; + + // applying filter to the current image + image = curFilter.applyFilter(image); + + if (image == null) { + image = oldImg; + } + } + } + + return image; + } + + @Override + public void actionPerformed(ActionEvent e) { + + FilterPanel filterPanel = (FilterPanel) ((JButton) e.getSource()) + .getParent().getParent(); + + UID filterId = filterPanel.getFilterId(); + + // removing filter from the filters chain + filtersMap.remove(filterId); + + dialog.getShowedFiltersTitles().remove(filterPanel.getName()); + + // add filterTitle to the 'choose list' on the top + dialog.getListModel().addElement(filterPanel.getName()); + + // removing panel from filterContainer + filterPanel.removeAll(); + dialog.getFilterContainer().remove(filterPanel); + + if (dialog.getFilterContainer().getComponentCount() == 0) { + + dialog.deleteFilterContainer(); + + } else { + + dialog.getFilterContainer().revalidate(); + dialog.getFilterContainer().repaint(); + + } + + // if there were no elements in the list + // but then it appeared + // button should be enabled + if (!dialog.getAddButton().isEnabled()) { + dialog.getFilterChooser().setEnabled(true); + dialog.getAddButton().setEnabled(true); + } + + Main.map.mapView.getActiveLayer().setFilterStateChanged(); + + } + + @Override + public void itemStateChanged(ItemEvent e) { + + JCheckBox enableFilter = (JCheckBox) e.getSource(); + FilterPanel filterPanel = (FilterPanel) enableFilter.getParent() + .getParent(); + + if (enableFilter.isSelected()) { + + UID filterId = filterPanel.getFilterId(); + disabledFilters.add(filtersMap.get(filterId)); + + Main.map.mapView.getActiveLayer().setFilterStateChanged(); + + } else { + + UID filterId = filterPanel.getFilterId(); + disabledFilters.remove(filtersMap.get(filterId)); + + Main.map.mapView.getActiveLayer().setFilterStateChanged(); + + } + } +} Index: /applications/editors/josm/plugins/rasterfilters/src/org/openstreetmap/josm/plugins/rasterfilters/model/StateChangeListener.java =================================================================== --- /applications/editors/josm/plugins/rasterfilters/src/org/openstreetmap/josm/plugins/rasterfilters/model/StateChangeListener.java (revision 31470) +++ /applications/editors/josm/plugins/rasterfilters/src/org/openstreetmap/josm/plugins/rasterfilters/model/StateChangeListener.java (revision 31470) @@ -0,0 +1,9 @@ +package org.openstreetmap.josm.plugins.rasterfilters.model; + +import java.rmi.server.UID; + +public interface StateChangeListener { + + public void filterStateChanged(UID filterId, FilterStateModel filterState); + +} Index: /applications/editors/josm/plugins/rasterfilters/src/org/openstreetmap/josm/plugins/rasterfilters/preferences/FiltersDownloader.java =================================================================== --- /applications/editors/josm/plugins/rasterfilters/src/org/openstreetmap/josm/plugins/rasterfilters/preferences/FiltersDownloader.java (revision 31470) +++ /applications/editors/josm/plugins/rasterfilters/src/org/openstreetmap/josm/plugins/rasterfilters/preferences/FiltersDownloader.java (revision 31470) @@ -0,0 +1,381 @@ +package org.openstreetmap.josm.plugins.rasterfilters.preferences; + +import java.awt.event.ActionEvent; +import java.awt.event.ActionListener; +import java.io.BufferedInputStream; +import java.io.BufferedOutputStream; +import java.io.BufferedReader; +import java.io.BufferedWriter; +import java.io.File; +import java.io.FileOutputStream; +import java.io.FileReader; +import java.io.FileWriter; +import java.io.IOException; +import java.io.InputStreamReader; +import java.io.OutputStream; +import java.io.StringReader; +import java.net.HttpURLConnection; +import java.net.MalformedURLException; +import java.net.URL; +import java.net.URLClassLoader; +import java.net.URLConnection; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Random; +import java.util.Set; +import java.util.TreeSet; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +import javax.json.Json; +import javax.json.JsonArray; +import javax.json.JsonObject; +import javax.json.JsonReader; + +import org.jsoup.Jsoup; +import org.jsoup.nodes.Document; +import org.jsoup.nodes.Element; +import org.jsoup.select.Elements; +import org.openstreetmap.josm.Main; + +public class FiltersDownloader implements ActionListener { + private static volatile String pluginDir; + + public static Set filtersMeta = new HashSet<>(); + public static Set filterTitles = new TreeSet<>(); + public static Set binariesLocalUrls = new HashSet<>(); + public static ClassLoader loader; + public static Map urlsMap = new HashMap<>(); + + private static Set filtersMetaToLoad = new HashSet<>(); + static List filtersInfoList = new ArrayList<>(); + + public static List downloadFiltersInfoList() { + + JsonObject jsonRequest = Json + .createObjectBuilder() + .add("id", new Random().nextInt()) + .add("method", "wiki.getPageHTML") + .add("params", + Json.createArrayBuilder().add("ImageFilters").build()) + .build(); + + String jsonRequestString = jsonRequest.toString(); + + URL wikiApi; + HttpURLConnection wikiConnection; + try { + wikiApi = new URL("https://josm.openstreetmap.de/jsonrpc"); + wikiConnection = (HttpURLConnection) wikiApi.openConnection(); + wikiConnection.setDoOutput(true); + wikiConnection.setDoInput(true); + + wikiConnection.setRequestProperty("Content-Type", + "application/json"); + wikiConnection.setRequestProperty("Method", "POST"); + wikiConnection.connect(); + + OutputStream os = wikiConnection.getOutputStream(); + os.write(jsonRequestString.getBytes("UTF-8")); + os.close(); + + int HttpResult = wikiConnection.getResponseCode(); + if (HttpResult == HttpURLConnection.HTTP_OK) { + + JsonReader jsonStream = Json + .createReader(new InputStreamReader(wikiConnection + .getInputStream(), "utf-8")); + + JsonObject jsonResponse = jsonStream.readObject(); + jsonStream.close(); + + Elements trTagElems = Jsoup.parse( + jsonResponse.getString("result")) + .getElementsByTag("tr"); + for (Element element : trTagElems) { + + Elements elems = element.getElementsByTag("td"); + if (!elems.isEmpty()) { + String name = elems.get(0).text(); + String owner = elems.get(1).text(); + String description = elems.get(2).text(); + + String link = elems.get(0).getElementsByTag("a") + .attr("href"); + + JsonObject meta = loadMeta(link); + + String paramName = "rasterfilters." + + meta.getString("name"); + + boolean needToLoad = Main.pref.getBoolean(paramName); + + if (needToLoad) { + JsonArray binaries = meta.getJsonArray("binaries"); + filterTitles.add(meta.getString("title")); + for (int i = 0; i < binaries.size(); i++) { + filtersMetaToLoad.add(meta); + loadBinaryToFile(binaries.getString(i)); + } + } + FilterInfo newFilterInfo = new FilterInfo(name, + description, meta, needToLoad); + newFilterInfo.setOwner(owner); + + if (!filtersInfoList.contains(newFilterInfo)) { + filtersInfoList.add(newFilterInfo); + } + } + } + + } else { + Main.debug("Error happenned while requesting for the list of filters"); + } + } catch (IOException e1) { + // TODO Auto-generated catch block + e1.printStackTrace(); + } + + loadBinariesFromMeta(filtersMetaToLoad); + + return filtersInfoList; + } + + public static JsonObject loadMeta(String link) { + + Pattern p = Pattern.compile("ImageFilters/\\w.*"); + Matcher m = p.matcher(link); + + if (m.find()) { + link = link.substring(m.start()); + } + + JsonObject jsonRequest = Json.createObjectBuilder() + .add("id", new Random().nextInt()) + .add("method", "wiki.getPageHTML") + .add("params", Json.createArrayBuilder().add(link).build()) + .build(); + + String jsonStringRequest = jsonRequest.toString(); + + URL wikiApi; + HttpURLConnection wikiConnection; + JsonObject meta = null; + + try { + wikiApi = new URL("https://josm.openstreetmap.de/jsonrpc"); + wikiConnection = (HttpURLConnection) wikiApi.openConnection(); + wikiConnection.setDoOutput(true); + wikiConnection.setDoInput(true); + + wikiConnection.setRequestProperty("Content-Type", + "application/json"); + wikiConnection.setRequestProperty("Method", "POST"); + wikiConnection.connect(); + + OutputStream os = wikiConnection.getOutputStream(); + os.write(jsonStringRequest.getBytes("UTF-8")); + os.close(); + + int HttpResult = wikiConnection.getResponseCode(); + if (HttpResult == HttpURLConnection.HTTP_OK) { + + JsonReader jsonStream = Json + .createReader(new InputStreamReader(wikiConnection + .getInputStream(), "UTF-8")); + + JsonObject jsonResponse = jsonStream.readObject(); + jsonStream.close(); + + String jsonPage = jsonResponse.getString("result"); + + Document doc = Jsoup.parse(jsonPage, "UTF-8"); + String json = doc.getElementsByTag("pre").first().text(); + + JsonReader reader = Json.createReader(new StringReader(json)); + meta = reader.readObject(); + reader.close(); + + } else { + Main.debug(wikiConnection.getResponseMessage()); + } + } catch (IOException e1) { + e1.printStackTrace(); + } + + filtersMeta.add(meta); + + return meta; + } + + public static void initFilters() { + File file = new File(pluginDir + "\\urls.map"); + Main.debug("EXIST FILE? " + file.exists()); + + try { + FileReader fileReader = new FileReader(file); + BufferedReader br = new BufferedReader(fileReader); + + String temp = null; + + while ((temp = br.readLine()) != null) { + String[] mapEntry = temp.split("\\t"); + File fileUrl = new File(mapEntry[1]); + if (fileUrl.exists()) { + URL url; + try { + url = new URL("jar", "", fileUrl.toURI().toURL() + "!/"); + Main.debug("binaryUrl: " + url.toString()); + binariesLocalUrls.add(url); + } catch (MalformedURLException e) { + Main.debug("Initializing filters with unknown protocol. \n" + + e.getMessage()); + } + } + } + + br.close(); + } catch (IOException e) { + e.printStackTrace(); + } + + Main.debug("BinariesLocal : " + binariesLocalUrls.toString()); + + loader = new URLClassLoader( + binariesLocalUrls.toArray(new URL[binariesLocalUrls.size()]), + FiltersDownloader.class.getClassLoader()); + } + + public static void destroyFilters() { + filterTitles.clear(); + binariesLocalUrls.clear(); + FiltersDownloader.filtersMeta.clear(); + } + + @Override + public void actionPerformed(ActionEvent e) { + + for (FilterInfo temp : filtersInfoList) { + if (temp.isNeedToDownload()) { + + if (!filtersMetaToLoad.contains(temp.getMeta())) { + filtersMetaToLoad.add(temp.getMeta()); + } + + filterTitles.add(temp.getMeta().getString("title")); + } else { + filterTitles.remove(temp.getMeta().getString("title")); + } + } + + loadBinariesFromMeta(filtersMetaToLoad); + + filtersMetaToLoad.clear(); + } + + public static void loadBinariesFromMeta(Set metaList) { + + File file = new File(pluginDir + "\\urls.map"); + + FileWriter fileWriter = null; + BufferedWriter writer = null; + try { + fileWriter = new FileWriter(file); + writer = new BufferedWriter(fileWriter); + } catch (IOException e) { + e.printStackTrace(); + } + + for (JsonObject temp : metaList) { + JsonArray binaries = temp.getJsonArray("binaries"); + + for (int i = 0; i < binaries.size(); i++) { + + String localFile = loadBinaryToFile(binaries.getString(i)); + + try { + writer.append(binaries.getString(i)); + writer.append("\t"); + writer.append(localFile); + writer.append("\n"); + } catch (IOException e) { + e.printStackTrace(); + } + } + } + + try { + writer.close(); + fileWriter.close(); + } catch (IOException e) { + e.printStackTrace(); + } + } + + public static void setPluginDir(String dir) { + pluginDir = dir; + } + + public static String loadBinaryToFile(String fromUrl) { + + // Main.debug("Need to load binary from " + fromUrl); + + URL url = null; + URLConnection con = null; + + Pattern p = Pattern.compile("\\w.*/"); + Matcher m = p.matcher(fromUrl); + + String localFile = null; + + if (m.find()) { + + File plugin = new File(pluginDir); + if (plugin.exists()) { + + String plugDir = plugin.getAbsolutePath(); + localFile = plugDir + "\\" + fromUrl.substring(m.end()); + + } + } + + try { + url = new URL(fromUrl); + con = url.openConnection(); + File file = new File(localFile); + + if (file.exists()) { + Main.debug("File " + localFile + " already exists"); + + return localFile; + } else { + + BufferedInputStream in = new BufferedInputStream( + con.getInputStream()); + BufferedOutputStream out = new BufferedOutputStream( + new FileOutputStream(file)); + int i; + + while ((i = in.read()) != -1) { + out.write(i); + } + + out.flush(); + out.close(); + in.close(); + + return localFile; + } + } catch (MalformedURLException e1) { + e1.printStackTrace(); + } catch (IOException e) { + e.printStackTrace(); + } + + return null; + } + +} Index: /applications/editors/josm/plugins/rasterfilters/src/org/openstreetmap/josm/plugins/rasterfilters/preferences/RasterFiltersPreferences.java =================================================================== --- /applications/editors/josm/plugins/rasterfilters/src/org/openstreetmap/josm/plugins/rasterfilters/preferences/RasterFiltersPreferences.java (revision 31470) +++ /applications/editors/josm/plugins/rasterfilters/src/org/openstreetmap/josm/plugins/rasterfilters/preferences/RasterFiltersPreferences.java (revision 31470) @@ -0,0 +1,262 @@ +package org.openstreetmap.josm.plugins.rasterfilters.preferences; + +import java.awt.GridBagConstraints; +import java.awt.GridBagLayout; +import java.util.List; + +import javax.json.JsonObject; +import javax.swing.JButton; +import javax.swing.JPanel; +import javax.swing.JScrollPane; +import javax.swing.JTable; +import javax.swing.border.EmptyBorder; +import javax.swing.event.TableModelEvent; +import javax.swing.event.TableModelListener; +import javax.swing.table.AbstractTableModel; +import javax.swing.table.TableModel; + +import org.openstreetmap.josm.Main; +import org.openstreetmap.josm.gui.preferences.PreferenceTabbedPane; +import org.openstreetmap.josm.gui.preferences.SubPreferenceSetting; +import org.openstreetmap.josm.gui.preferences.TabPreferenceSetting; +import org.openstreetmap.josm.gui.preferences.map.MapPreference; +import org.openstreetmap.josm.tools.GBC; + +public class RasterFiltersPreferences implements SubPreferenceSetting { + + private FiltersDownloader downloader = new FiltersDownloader(); + AbstractTableModel model; + JPanel holder; + + @Override + public void addGui(PreferenceTabbedPane gui) { + + model = new FiltersTableModel(); + + if (holder == null) { + holder = new JPanel(); + holder.setLayout(new GridBagLayout()); + + holder.setBorder(new EmptyBorder(10, 10, 10, 10)); + + model.addTableModelListener(new TableModelListener() { + + @Override + public void tableChanged(TableModelEvent e) { + int row = e.getFirstRow(); + int col = e.getColumn(); + TableModel model = (TableModel) e.getSource(); + + Boolean isDownloadedUpdate = (Boolean) model.getValueAt( + row, col); + List filtersList = ((FiltersTableModel) model).filtersInfoList; + + filtersList.get(row).setNeedToDownload(isDownloadedUpdate); + + } + }); + + JTable table = new JTable(model); + table.getTableHeader().setReorderingAllowed(false); + table.getColumnModel().getColumn(3).setMaxWidth(20); + JScrollPane pane = new JScrollPane(table); + + holder.add(pane, GBC.eol().fill(GBC.BOTH)); + + GridBagConstraints c = GBC.eol(); + c.anchor = GBC.EAST; + + JButton download = new JButton("Download"); + download.addActionListener(downloader); + holder.add(download, c); + } + + MapPreference pref = gui.getMapPreference(); + pref.addSubTab(this, "Image Filters", holder); + + } + + @Override + public boolean ok() { + List filtersInfoList = ((FiltersTableModel) model).getFiltersInfoList(); + + for (FilterInfo temp : filtersInfoList) { + JsonObject meta = temp.getMeta(); + String paramName = meta.getString("name"); + paramName = "rasterfilters." + paramName; + Main.pref.put(paramName, temp.isNeedToDownload()); + } + + return false; + } + + @Override + public boolean isExpert() { + // TODO Auto-generated method stub + return false; + } + + @Override + public TabPreferenceSetting getTabPreferenceSetting(PreferenceTabbedPane gui) { + return gui.getMapPreference(); + } + + class FiltersTableModel extends AbstractTableModel { + + String[] columnNames = { "Filter Name", "Author", "Description", "" }; + Class[] columnClasses = { String.class, String.class, String.class, Boolean.class }; + List filtersInfoList; + Object[][] data; + + public FiltersTableModel() { + + filtersInfoList = FiltersDownloader.downloadFiltersInfoList(); + data = new Object[filtersInfoList.size()][4]; + + for (int i = 0; i < filtersInfoList.size(); i++) { + data[i][0] = filtersInfoList.get(i).getName(); + data[i][1] = filtersInfoList.get(i).getOwner(); + data[i][2] = filtersInfoList.get(i).getDescription(); + data[i][3] = filtersInfoList.get(i).isNeedToDownload(); + } + + } + + @Override + public int getRowCount() { + return filtersInfoList.size(); + } + + @Override + public int getColumnCount() { + return columnNames.length; + } + + @Override + public Object getValueAt(int rowIndex, int columnIndex) { + switch (columnIndex) { + case 0: + return filtersInfoList.get(rowIndex).getName(); + case 1: + return filtersInfoList.get(rowIndex).getOwner(); + case 2: + return filtersInfoList.get(rowIndex).getDescription(); + case 3: + return filtersInfoList.get(rowIndex).isNeedToDownload(); + default: + return null; + } + } + + @Override + public String getColumnName(int col) { + return columnNames[col]; + } + + @Override + public Class getColumnClass(int col) { + return columnClasses[col]; + } + + @Override + public boolean isCellEditable(int row, int col) { + if (col == 3) { + return true; + } + + return false; + } + + @Override + public void setValueAt(Object value, int row, int col) { + if (col == 3) { + filtersInfoList.get(row).setNeedToDownload((boolean) value); + fireTableCellUpdated(row, col); + } + } + + public List getFiltersInfoList() { + return filtersInfoList; + } + } + +} + +class FilterInfo { + private String name; + private String description; + private JsonObject meta; + private boolean needToDownload; + private String owner; + + public FilterInfo() { + + } + + public FilterInfo(String name, String description, JsonObject meta, + boolean needToDownload) { + this.setName(name); + this.setDescription(description); + this.meta = meta; + this.setNeedToDownload(needToDownload); + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public String getDescription() { + return description; + } + + public void setDescription(String description) { + this.description = description; + } + + public JsonObject getMeta() { + return meta; + } + + public void setMeta(JsonObject meta) { + this.meta = meta; + } + + public boolean isNeedToDownload() { + return needToDownload; + } + + public void setNeedToDownload(boolean needToDownload) { + this.needToDownload = needToDownload; + } + + public String getOwner() { + return owner; + } + + public void setOwner(String owner) { + this.owner = owner; + } + + @Override + public String toString() { + return "name: " + getName() + "\nDescription: " + getDescription() + + "\nMeta: " + getMeta(); + } + + @Override + public boolean equals(Object o) { + if (o instanceof FilterInfo) { + if (name.equals(((FilterInfo) o).getName()) && + meta.equals(((FilterInfo) o).getMeta()) && + description.equals(((FilterInfo) o).getDescription())) { + return true; + } + } + + return false; + } +} Index: /applications/editors/josm/plugins/rasterfilters/src/org/openstreetmap/josm/plugins/rasterfilters/values/BooleanValue.java =================================================================== --- /applications/editors/josm/plugins/rasterfilters/src/org/openstreetmap/josm/plugins/rasterfilters/values/BooleanValue.java (revision 31470) +++ /applications/editors/josm/plugins/rasterfilters/src/org/openstreetmap/josm/plugins/rasterfilters/values/BooleanValue.java (revision 31470) @@ -0,0 +1,33 @@ +package org.openstreetmap.josm.plugins.rasterfilters.values; + +public class BooleanValue implements Value { + + private Boolean value; + private String parameterName; + + public BooleanValue(String parameterName, Boolean value) { + this.value = value; + this.parameterName = parameterName; + } + + @Override + public Boolean getValue() { + return value; + } + + @Override + public void setValue(Boolean value) { + this.value = value; + } + + @Override + public String getParameterName() { + return parameterName; + } + + @Override + public void setParameterName(String name) { + this.parameterName = name; + } + +} Index: /applications/editors/josm/plugins/rasterfilters/src/org/openstreetmap/josm/plugins/rasterfilters/values/ColorValue.java =================================================================== --- /applications/editors/josm/plugins/rasterfilters/src/org/openstreetmap/josm/plugins/rasterfilters/values/ColorValue.java (revision 31470) +++ /applications/editors/josm/plugins/rasterfilters/src/org/openstreetmap/josm/plugins/rasterfilters/values/ColorValue.java (revision 31470) @@ -0,0 +1,33 @@ +package org.openstreetmap.josm.plugins.rasterfilters.values; + +public class ColorValue implements Value{ + + private Color value; + private String parameterName; + + public ColorValue(String parameterName, Color color) { + this.parameterName = parameterName; + this.value = color; + } + + @Override + public Color getValue() { + return value; + } + + @Override + public void setValue(Color value) { + this.value = value; + } + + @Override + public String getParameterName() { + return parameterName; + } + + @Override + public void setParameterName(String name) { + this.parameterName = name; + } + +} Index: /applications/editors/josm/plugins/rasterfilters/src/org/openstreetmap/josm/plugins/rasterfilters/values/SelectValue.java =================================================================== --- /applications/editors/josm/plugins/rasterfilters/src/org/openstreetmap/josm/plugins/rasterfilters/values/SelectValue.java (revision 31470) +++ /applications/editors/josm/plugins/rasterfilters/src/org/openstreetmap/josm/plugins/rasterfilters/values/SelectValue.java (revision 31470) @@ -0,0 +1,33 @@ +package org.openstreetmap.josm.plugins.rasterfilters.values; + +public class SelectValue implements Value { + + private T selectedItem; + private String parameterName; + + public SelectValue(String parameterName, T value) { + this.selectedItem = value; + this.parameterName = parameterName; + } + + @Override + public T getValue() { + return selectedItem; + } + + @Override + public void setValue(T value) { + this.selectedItem = value; + } + + @Override + public String getParameterName() { + return parameterName; + } + + @Override + public void setParameterName(String name) { + this.parameterName = name; + } + +} Index: /applications/editors/josm/plugins/rasterfilters/src/org/openstreetmap/josm/plugins/rasterfilters/values/SliderValue.java =================================================================== --- /applications/editors/josm/plugins/rasterfilters/src/org/openstreetmap/josm/plugins/rasterfilters/values/SliderValue.java (revision 31470) +++ /applications/editors/josm/plugins/rasterfilters/src/org/openstreetmap/josm/plugins/rasterfilters/values/SliderValue.java (revision 31470) @@ -0,0 +1,38 @@ +package org.openstreetmap.josm.plugins.rasterfilters.values; + +public class SliderValue implements Value { + + private String parameterName; + private Number value; + + public SliderValue(String parameterName, Number value) { + this.value = value; + this.parameterName = parameterName; + } + + @Override + public Number getValue() { + return value; + } + + @Override + public void setValue(Number value) { + this.value = value; + } + + @Override + public String getParameterName() { + return parameterName; + } + + @Override + public void setParameterName(String name) { + this.parameterName = name;; + } + + public boolean isDouble() { + if (value instanceof Double) + return true; + return false; + } +} Index: /applications/editors/josm/plugins/rasterfilters/src/org/openstreetmap/josm/plugins/rasterfilters/values/Value.java =================================================================== --- /applications/editors/josm/plugins/rasterfilters/src/org/openstreetmap/josm/plugins/rasterfilters/values/Value.java (revision 31470) +++ /applications/editors/josm/plugins/rasterfilters/src/org/openstreetmap/josm/plugins/rasterfilters/values/Value.java (revision 31470) @@ -0,0 +1,12 @@ +package org.openstreetmap.josm.plugins.rasterfilters.values; + +public interface Value { + + public T getValue(); + + public void setValue(T value); + + public String getParameterName(); + + public void setParameterName(String name); +}