Index: applications/editors/josm/plugins/pdfimport/src/pdfimport/FilePlacement.java =================================================================== --- applications/editors/josm/plugins/pdfimport/src/pdfimport/FilePlacement.java (revision 34397) +++ applications/editors/josm/plugins/pdfimport/src/pdfimport/FilePlacement.java (revision 34398) @@ -14,14 +14,18 @@ public class FilePlacement { - public Projection projection = null; - public double minX = 0; - public double maxX = 1; - public double minY = 0; - public double maxY = 1; - - public double minEast = 0; - public double maxEast = 10000; - public double minNorth = 0; - public double maxNorth = 10000; + /* + * provide data and services to place a PDF-File to world coordinates + * enhanced by FilePlacement18 but kept for compatibilty to existing code + */ + protected Projection projection = null; + protected double minX = 0; + protected double maxX = 1; + protected double minY = 0; + protected double maxY = 1; + + protected double minEast = 0; + protected double maxEast = 10000; + protected double minNorth = 0; + protected double maxNorth = 10000; private AffineTransform transform; @@ -41,5 +45,5 @@ } - public Properties toProperties() { + protected Properties toProperties() { Properties p = new Properties(); if (projection != null) { @@ -59,8 +63,8 @@ } - public void fromProperties(Properties p) { + protected void fromProperties(Properties p) { String projectionCode = p.getProperty("Projection", null); if (projectionCode != null) { - projection = ProjectionInfo.getProjectionByCode(projectionCode); + projection = ProjectionInfo.getProjectionByCode(projectionCode); // TODO: Handle non-core Projections } else { projection = null; @@ -78,5 +82,5 @@ } - private double parseProperty(Properties p, String name, double defaultValue) { + protected double parseProperty(Properties p, String name, double defaultValue) { if (!p.containsKey(name)) { return defaultValue; @@ -92,5 +96,5 @@ } - public String prepareTransform() { + protected String prepareTransform() { if (this.minX > this.maxX) { return tr("Transform error: Min X must be smaller than max"); @@ -181,5 +185,5 @@ Point2D src = new Point2D.Double(); - public Bounds getWorldBounds(PathOptimizer data) { + protected Bounds getWorldBounds(PathOptimizer data) { LatLon min = this.tranformCoords(new Point2D.Double(data.bounds.getMinX(), data.bounds.getMinY())); LatLon max = this.tranformCoords(new Point2D.Double(data.bounds.getMaxX(), data.bounds.getMaxY())); @@ -187,5 +191,5 @@ } - public LatLon tranformCoords(Point2D pt) { + protected LatLon tranformCoords(Point2D pt) { if (this.projection == null) { @@ -199,5 +203,5 @@ } - public EastNorth reverseTransform(LatLon coor) { + protected EastNorth reverseTransform(LatLon coor) { if (this.projection == null) { return new EastNorth(coor.lon() * 1000, coor.lat() * 1000); Index: applications/editors/josm/plugins/pdfimport/src/pdfimport/FilePlacement18.java =================================================================== --- applications/editors/josm/plugins/pdfimport/src/pdfimport/FilePlacement18.java (revision 34398) +++ applications/editors/josm/plugins/pdfimport/src/pdfimport/FilePlacement18.java (revision 34398) @@ -0,0 +1,420 @@ +// License: GPL. For details, see LICENSE file. +package pdfimport; + +import static org.openstreetmap.josm.tools.I18n.tr; + +import java.awt.Color; +import java.awt.GridBagConstraints; +import java.awt.GridBagLayout; +import java.awt.Insets; +import java.awt.event.ActionEvent; +import java.awt.event.ActionListener; +import java.awt.event.FocusEvent; +import java.awt.event.FocusListener; +import java.io.File; +import java.io.FileInputStream; +import java.io.FileOutputStream; +import java.io.IOException; +import java.util.Collection; +import java.util.Properties; + +import javax.swing.BorderFactory; +import javax.swing.JButton; +import javax.swing.JComponent; +import javax.swing.JLabel; +import javax.swing.JPanel; +import javax.swing.SwingConstants; + +import org.openstreetmap.josm.data.coor.EastNorth; +import org.openstreetmap.josm.data.coor.LatLon; +import org.openstreetmap.josm.data.osm.Node; +import org.openstreetmap.josm.data.osm.OsmPrimitive; +import org.openstreetmap.josm.data.projection.Projection; +import org.openstreetmap.josm.gui.MainApplication; + +public class FilePlacement18 extends FilePlacement { + /* + * Handle plasement of a pdf File + * provide transformation, load & save, GUI-componennt + * superseeds (legacy) class FilePlacement + */ + + public class PlacementPanel { + private class CoorFields { + /* + * Coordinte Fields + * keep Fields representing a Coordinate together + * functionality: allow entering coordinate in the first field and transfer Y-Part to the second field + * TODO: encapsulate to Componente + */ + private GuiFieldDouble x; + private GuiFieldDouble y; + + private void checkCoords( GuiFieldDouble x, GuiFieldDouble y) { + int splitpos = 0; + String val2 = x.getText().trim(); + if ((splitpos = val2.indexOf(';')) >= 0) { + // Split a coordinate into its parts for ease of data entry + y.setText(val2.substring(splitpos + 1).trim()); + x.setText(val2.substring(0, splitpos).trim()); + } + y.checker.check(y); + x.checker.check(x); + } + + @SuppressWarnings("unused") + private CoorFields() { + } + + public CoorFields(GuiFieldDouble X, GuiFieldDouble Y) { + x = X; + y = Y; + x.addFocusListener(new FocusListener() { + @Override + public void focusLost(FocusEvent e) { + checkCoords(x, y); + } + + @Override + public void focusGained(FocusEvent e) { + } + }); + } + public void SetCoor(EastNorth en) { + x.setValue(en.getX()); + y.setValue(en.getY()); + } + public EastNorth getCorr() { + return new EastNorth(x.getValue(),y.getValue()); + } + } + + private GuiFieldDouble minXField; + private GuiFieldDouble minYField; + private GuiFieldDouble minEastField; + private GuiFieldDouble minNorthField; + private JButton getMinButton; + private JButton getMaxButton; + private GuiFieldDouble maxNorthField; + private GuiFieldDouble maxEastField; + private GuiFieldDouble maxYField; + private GuiFieldDouble maxXField; + private GuiPanel panel; + private JLabel hintField; + private CoorFields pdfMin; + private CoorFields pdfMax; + private CoorFields worldMin; + private CoorFields worldMax; + private GuiProjections projectionChooser; + private FilePlacement18 fc = null; // reference to enclosing FilePlacement + private JComponent dependsOnValid = null; + + public PlacementPanel(FilePlacement18 parrent) { + if (parrent==null) throw new IllegalArgumentException(); + fc=parrent; + } + + private PlacementPanel () { + + } + + private class Monitor implements FocusListener { + + private PlacementPanel target=null; + + public Monitor(PlacementPanel home) { + target=home; + } + + @Override + public void focusGained(FocusEvent e) { + } + + @Override + public void focusLost(FocusEvent e) { + try { + target.Verify(); + } catch (Exception ee) { + } + } + } + + void load() { + /* + * load GUI from setting + */ + try { + minXField.setValue(fc.minX); + maxXField.setValue(fc.maxX); + minYField.setValue(fc.minY); + maxYField.setValue(fc.maxY); + minEastField.setValue(fc.minEast); + maxEastField.setValue(fc.maxEast); + minNorthField.setValue(fc.minNorth); + maxNorthField.setValue(fc.maxNorth); + projectionChooser.setProjection(fc.projection); + } finally { + Verify(); + } + } + + void build() { +/* + * Construct Objects + * + */ + Monitor monitor = new Monitor(this); + projectionChooser = new GuiProjections(); + + pdfMin = new CoorFields(minXField = new GuiFieldDouble(0), minYField = new GuiFieldDouble(0)); + minXField.setToolTipText(tr("X-value of buttom left reference point")); + minXField.addFocusListener(monitor); + minYField.setToolTipText(tr("Y-value of buttom left reference point")); + minYField.addFocusListener(monitor); + +// + worldMin = new CoorFields(minEastField = new GuiFieldDouble(0), minNorthField = new GuiFieldDouble(0)); + minEastField.setToolTipText(tr("East-value of buttom left reference point")); + minEastField.addFocusListener(monitor); + minNorthField.setToolTipText(tr("North-value of buttom left reference point")); + minNorthField.addFocusListener(monitor); +// + getMinButton = new JButton(tr("Get from Preview")); + getMinButton.setToolTipText(tr("Select a single node from preview")); + getMinButton.addActionListener(new ActionListener() { + @Override + public void actionPerformed(ActionEvent e) { + setFromCoor(pdfMin); + } + }); +// + pdfMax = new CoorFields(maxXField = new GuiFieldDouble(1000), maxYField = new GuiFieldDouble(1000)); + maxXField.setToolTipText(tr("X-value of top right reference point")); + maxXField.addFocusListener(monitor); + maxYField.setToolTipText(tr("Y-value of top right reference point")); + maxYField.addFocusListener(monitor); +// + worldMax = new CoorFields(maxEastField = new GuiFieldDouble(1), maxNorthField = new GuiFieldDouble(1)); + maxEastField.setToolTipText(tr("East-value of top right reference point")); + maxEastField.addFocusListener(monitor); + maxNorthField.setToolTipText(tr("North-value of top right reference point")); + maxNorthField.addFocusListener(monitor); +// + getMaxButton = new JButton(tr("Get from Preview")); + getMaxButton.setToolTipText(tr("Select a single node from preview")); + getMaxButton.addActionListener(new ActionListener() { + @Override + public void actionPerformed(ActionEvent e) { + setFromCoor(pdfMax); + } + }); + +// + hintField = new JLabel(tr("Check Placement"),SwingConstants.CENTER); + hintField.setForeground(Color.RED); +// + panel = new GuiPanel(new GridBagLayout()); + panel.setBorder(BorderFactory.createTitledBorder(tr("Bind to coordinates"))); + + GridBagConstraints cBasic = new GridBagConstraints(GridBagConstraints.RELATIVE, GridBagConstraints.RELATIVE, + 1, 1, 0.0, 0.0, GridBagConstraints.HORIZONTAL, GridBagConstraints.LINE_START, + new Insets(1, 0, 0, 4), 0, 0); + cBasic.gridx = GridBagConstraints.RELATIVE; + cBasic.gridy = GridBagConstraints.RELATIVE; + cBasic.insets = new Insets(1, 0, 0, 4); + cBasic.anchor = GridBagConstraints.LINE_START; + cBasic.fill = GridBagConstraints.HORIZONTAL; + cBasic.gridheight = 1; + cBasic.gridwidth = 1; + cBasic.ipadx = 0; + cBasic.ipady = 0; + cBasic.weightx = 0.0; + cBasic.weighty = 0.0; + GridBagConstraints cCornerHeading = (GridBagConstraints) cBasic.clone(); + cCornerHeading.gridwidth = GridBagConstraints.REMAINDER; + cCornerHeading.gridx = 0; + cCornerHeading.insets = new Insets(3, 0, 0, 0); + + GridBagConstraints cLine = (GridBagConstraints) cBasic.clone(); + + GridBagConstraints cGetButton = (GridBagConstraints) cBasic.clone(); + cGetButton.gridx = 1; + cGetButton.gridwidth = GridBagConstraints.REMAINDER; + cGetButton.fill = GridBagConstraints.NONE; + + GridBagConstraints c = new GridBagConstraints(); + /* + * Projection + */ + panel.add(projectionChooser.getPanel(), cCornerHeading); + /* + * Max Corner + */ + panel.add(new JLabel(tr("Top right (max) corner:"),SwingConstants.CENTER), cCornerHeading); + c = (GridBagConstraints) cLine.clone(); + c.weightx = 0.0; panel.add(new JLabel(tr("X:"),SwingConstants.RIGHT),c); + c.weightx = 1.0; panel.add(maxXField, c); + c.weightx = 0.0; panel.add(new JLabel(tr("East:"),SwingConstants.RIGHT),c); + c.weightx = 1.0; panel.add(maxEastField, c); + + c.gridy = 4; + c.weightx = 0.0; panel.add(new JLabel(tr("Y:"),SwingConstants.RIGHT),c); + c.weightx = 1.0; panel.add(maxYField, c); + c.weightx = 0.0; panel.add(new JLabel(tr("North:"),SwingConstants.RIGHT),c); + c.weightx = 1.0; panel.add(maxNorthField, c); + panel.add(getMaxButton, cGetButton); + /* + * Min Corner + */ + panel.add(new JLabel(tr("Bottom left (min) corner:"),SwingConstants.CENTER), cCornerHeading); + c = (GridBagConstraints) cLine.clone(); + c.weightx = 0.0; panel.add(new JLabel(tr("X:"),SwingConstants.RIGHT),c); + c.weightx = 1.0; panel.add(minXField, c); + c.weightx = 0.0; panel.add(new JLabel(tr("East:"),SwingConstants.RIGHT),c); + c.weightx = 1.0; panel.add(minEastField, c); + + c.gridy = 8; + c.weightx = 0.0; panel.add(new JLabel(tr("Y:"),SwingConstants.RIGHT),c); + c.weightx = 1.0; panel.add(minYField, c); + c.weightx = 0.0; panel.add(new JLabel(tr("North:"),SwingConstants.RIGHT),c); + c.weightx = 1.0; panel.add(minNorthField, c); + + panel.add(getMinButton, cGetButton); + /* + * Hints + */ + c.gridx = 0;c.gridy = 11;c.gridwidth = GridBagConstraints.REMAINDER; c.fill = GridBagConstraints.HORIZONTAL; + panel.add(hintField, cGetButton); + } + + private EastNorth getSelectedCoor() { + /* + * Assumtions: + * selection is from preview, + * preview has been create without any projection / transformation + * TODO: enshure this + */ + hintField.setText(""); + Collection selected = MainApplication.getLayerManager().getEditDataSet().getSelected(); + + if (selected.size() != 1 || !(selected.iterator().next() instanceof Node)) { + hintField.setText(tr("Please select exactly one node.")); + return null; + } + + LatLon ll = ((Node) selected.iterator().next()).getCoor(); +// FilePlacement pl = new FilePlacement(); +// return pl.reverseTransform(ll); + return new EastNorth(ll.lon() * 1000, ll.lat() * 1000); + } + + private void Verify() { + hintField.setText(""); + String Hint = ""; + fc.valid = false; + FilePlacement placement = fc; + try { + placement.projection = projectionChooser.getProjection(); + try { + placement.setPdfBounds(minXField.getValue(), minYField.getValue(), maxXField.getValue(), + maxYField.getValue()); + placement.setEastNorthBounds(minEastField.getValue(), minNorthField.getValue(), + maxEastField.getValue(), maxNorthField.getValue()); + } catch (Exception e) { + Hint=(tr("Check numbers")); + return; + } + String transformError = placement.prepareTransform(); + if (transformError != null) { + Hint=(transformError); + return; + } + fc.valid = true; + } finally { + hintField.setText(Hint); + if (dependsOnValid!=null) dependsOnValid.setEnabled(fc.valid && panel.isEnabled()); + } + + return; + } + + public void setDependsOnValid(JComponent c) { + dependsOnValid=c; + } + + void setFromCoor(CoorFields f) { + EastNorth en = getSelectedCoor(); + + if (en != null) { + f.SetCoor(en); + } + + } + + } + + private PlacementPanel panel=null; + private boolean valid=false; // the data is consistent and the object ready to use for transformation + + public boolean isValid() { + return valid; + } + public void setDependsOnValid(JComponent c) { + panel.setDependsOnValid(c); + } + + public JPanel getGui() { + if (panel==null) panel = new PlacementPanel(this); + if (panel.panel==null) panel.build(); + return panel.panel; + } + + public FilePlacement18 () { + panel = new PlacementPanel(this); + } + + public void load(File baseFile) throws IOException { + File file = new File(baseFile + ".placement"); + Properties p = new Properties(9); + try (FileInputStream s = new FileInputStream(file)){ + p.load(s); + s.close(); + }; + fromProperties(p); + } + + public void verify() { + panel.Verify(); + } + + public void save(File baseFile) throws IOException { + File file = new File(baseFile + ".placement"); + FileOutputStream s = new FileOutputStream(file); + Properties p = toProperties(); + p.store(s, "PDF file placement on OSM"); + s.close(); + } + + private Projection getProjection(Properties p, String name) { + String projectionCode = p.getProperty("Projection", null); + if (projectionCode != null) { + return ProjectionInfo.getProjectionByCode(p.getProperty("Projection", null)); + } + return null; + } + + private double getDouble(Properties p, String name, double defaultValue) { + try { + return Double.parseDouble(p.getProperty(name)); + } catch (Exception e) { + return defaultValue; + } + } + + @Override + protected void fromProperties(Properties p) { + super.fromProperties(p); + panel.load(); + } + +} Index: applications/editors/josm/plugins/pdfimport/src/pdfimport/GuiFieldBool.java =================================================================== --- applications/editors/josm/plugins/pdfimport/src/pdfimport/GuiFieldBool.java (revision 34398) +++ applications/editors/josm/plugins/pdfimport/src/pdfimport/GuiFieldBool.java (revision 34398) @@ -0,0 +1,83 @@ +// License: GPL. For details, see LICENSE file. + +package pdfimport; + +import javax.swing.Action; +import javax.swing.Icon; +import javax.swing.JCheckBox; +import javax.swing.JComponent; +import javax.swing.event.ChangeEvent; +import javax.swing.event.ChangeListener; + +public class GuiFieldBool extends JCheckBox { + private JComponent companion =null; + private boolean value = false; + + public JComponent getCompanion() { + return companion; + } + + public void setCompanion(JComponent c) { + companion = c; + if (companion != null) companion.setEnabled(isSelected()); + } + + public boolean getValue() { + return super.isSelected(); + } + + public void setValue(boolean value) { + value = value; + super.setSelected(value); + } + + public GuiFieldBool() { + super(); + addChangeListener(new Monitor()); + } + + public GuiFieldBool(Action a) { + super(a); + addChangeListener(new Monitor()); + } + + public GuiFieldBool(Icon icon, boolean selected) { + super(icon, selected); + addChangeListener(new Monitor()); + } + + public GuiFieldBool(Icon icon) { + super(icon); + addChangeListener(new Monitor()); + } + + public GuiFieldBool(String text, boolean selected) { + super(text, selected); + addChangeListener(new Monitor()); + } + + public GuiFieldBool(String text, Icon icon, boolean selected) { + super(text, icon, selected); + addChangeListener(new Monitor()); + } + + public GuiFieldBool(String text, Icon icon) { + super(text, icon); + addChangeListener(new Monitor()); + } + + public GuiFieldBool(String text) { + super(text); + addChangeListener(new Monitor()); + } + + private class Monitor implements ChangeListener { + + @Override + public void stateChanged(ChangeEvent e) { + GuiFieldBool o = (GuiFieldBool) e.getSource(); + value = o.isSelected(); + if (o.companion != null) o.companion.setEnabled(value); + } + } +} Index: applications/editors/josm/plugins/pdfimport/src/pdfimport/GuiFieldDouble.java =================================================================== --- applications/editors/josm/plugins/pdfimport/src/pdfimport/GuiFieldDouble.java (revision 34398) +++ applications/editors/josm/plugins/pdfimport/src/pdfimport/GuiFieldDouble.java (revision 34398) @@ -0,0 +1,67 @@ +// License: GPL. For details, see LICENSE file. + +package pdfimport; + +import java.awt.Color; +import java.awt.event.FocusEvent; +import java.awt.event.FocusListener; + +import javax.swing.BorderFactory; + +public class GuiFieldDouble extends GuiFieldString { + + private double value; + public CheckDouble checker; + + public GuiFieldDouble() { + super(); + addFocusListener(checker = new CheckDouble()); + setValue(0.0); + } + + @SuppressWarnings("unused") + private GuiFieldDouble(String text) { + super(text); + addFocusListener(checker = new CheckDouble()); + } + + public GuiFieldDouble(double v) { + super(); + addFocusListener(checker = new CheckDouble()); + setValue(v); + } + + public void setValue(double v) { + super.setText(Double.toString(v)); + this.checker.check(this); + } + + public double getValue() throws NumberFormatException { + if (!dataValid) throw new NumberFormatException(); + return value; + } + + public class CheckDouble implements FocusListener { + + @Override + public void focusGained(FocusEvent e) { + } + + @Override + public void focusLost(FocusEvent event) { + check((GuiFieldDouble) event.getSource()); + } + + public void check(GuiFieldDouble field) { + try { + value = Double.parseDouble(field.getText()); + dataValid =true; + field.setBorder(defaultBorder); + } catch (NumberFormatException e) { + field.setBorder(BorderFactory.createLineBorder(Color.red)); + value = Double.NaN; + dataValid = false; + } + } + } +} Index: applications/editors/josm/plugins/pdfimport/src/pdfimport/GuiFieldHex.java =================================================================== --- applications/editors/josm/plugins/pdfimport/src/pdfimport/GuiFieldHex.java (revision 34398) +++ applications/editors/josm/plugins/pdfimport/src/pdfimport/GuiFieldHex.java (revision 34398) @@ -0,0 +1,79 @@ +/** + * License: GPL. For details, see LICENSE file. + */ +package pdfimport; + +import java.awt.Color; +import java.awt.event.FocusEvent; +import java.awt.event.FocusListener; + +import javax.swing.BorderFactory; + +/** + * @author Nzara + * + */ +public class GuiFieldHex extends GuiFieldString { + + private int value; + public CheckHex checker; + + public GuiFieldHex() { + super(); + addFocusListener(checker = new CheckHex()); + setValue(0); + } + + @SuppressWarnings("unused") + public GuiFieldHex(String text) { + super(text); + addFocusListener(checker = new CheckHex()); + } + + public GuiFieldHex(int v) { + super(); + addFocusListener(checker = new CheckHex()); + setValue(v); + } + + public void setValue(int v) { + super.setText("#" + Integer.toHexString(v)); + value=v; + this.checker.check(this); + } + + public int getValue() throws NumberFormatException { + if (!dataValid) throw new NumberFormatException(); + return value; + } + + @Override + public void setEnabled(boolean enabled) { + super.setEnabled(enabled); + this.checker.check(this); + } + + public class CheckHex implements FocusListener { + + @Override + public void focusGained(FocusEvent e) { + } + + @Override + public void focusLost(FocusEvent event) { + check((GuiFieldHex) event.getSource()); + } + + public void check(GuiFieldHex field) { + try { + value = Integer.decode(field.getText()); +// value = Integer.parseUnsignedInt(field.getText().replace("#", ""), 16); + dataValid = true; + field.setBorder(defaultBorder); + } catch (NumberFormatException e) { + field.setBorder(BorderFactory.createLineBorder(Color.red)); + dataValid = false; + } + } + } +} Index: applications/editors/josm/plugins/pdfimport/src/pdfimport/GuiFieldInteger.java =================================================================== --- applications/editors/josm/plugins/pdfimport/src/pdfimport/GuiFieldInteger.java (revision 34398) +++ applications/editors/josm/plugins/pdfimport/src/pdfimport/GuiFieldInteger.java (revision 34398) @@ -0,0 +1,68 @@ +// License: GPL. For details, see LICENSE file. + +package pdfimport; + +import java.awt.Color; +import java.awt.event.FocusEvent; +import java.awt.event.FocusListener; + +import javax.swing.BorderFactory; + + +public class GuiFieldInteger extends GuiFieldString { + + private int value; + public CheckInteger checker; + + public GuiFieldInteger() { + super(); + addFocusListener(checker = new CheckInteger()); + setValue(0); + } + + @SuppressWarnings("unused") + private GuiFieldInteger(String text) { + super(text); + addFocusListener(checker = new CheckInteger()); + } + + public GuiFieldInteger(int v) { + super(); + addFocusListener(checker = new CheckInteger()); + setValue(v); + } + + public void setValue(int v) { + super.setText(Integer.toString(v)); + value=v; + this.checker.check(this); + } + + public int getValue() throws NumberFormatException { + if (!dataValid) throw new NumberFormatException(); + return value; + } + + public class CheckInteger implements FocusListener { + + @Override + public void focusGained(FocusEvent e) { + } + + @Override + public void focusLost(FocusEvent event) { + check((GuiFieldInteger) event.getSource()); + } + + public void check(GuiFieldInteger field) { + try { + value = Integer.valueOf(field.getText()); + dataValid = true; + field.setBorder(defaultBorder); + } catch (NumberFormatException e) { + field.setBorder(BorderFactory.createLineBorder(Color.red)); + dataValid = false; + } + } + } +} Index: applications/editors/josm/plugins/pdfimport/src/pdfimport/GuiFieldLong.java =================================================================== --- applications/editors/josm/plugins/pdfimport/src/pdfimport/GuiFieldLong.java (revision 34398) +++ applications/editors/josm/plugins/pdfimport/src/pdfimport/GuiFieldLong.java (revision 34398) @@ -0,0 +1,68 @@ +// License: GPL. For details, see LICENSE file. + +package pdfimport; + +import java.awt.Color; +import java.awt.event.FocusEvent; +import java.awt.event.FocusListener; + +import javax.swing.BorderFactory; + + +public class GuiFieldLong extends GuiFieldString { + + private long value; + public CheckLong checker; + + public GuiFieldLong() { + super(); + addFocusListener(checker = new CheckLong()); + setValue(0); + } + + @SuppressWarnings("unused") + private GuiFieldLong(String text) { + super(text); + addFocusListener(checker = new CheckLong()); + } + + public GuiFieldLong(long v) { + super(); + addFocusListener(checker = new CheckLong()); + setValue(v); + } + + public void setValue(long v) { + super.setText(Long.toString(v)); + value=v; + this.checker.check(this); + } + + public long getValue() throws NumberFormatException { + if (!dataValid) throw new NumberFormatException(); + return value; + } + + public class CheckLong implements FocusListener { + + @Override + public void focusGained(FocusEvent e) { + } + + @Override + public void focusLost(FocusEvent event) { + check((GuiFieldLong) event.getSource()); + } + + public void check(GuiFieldLong field) { + try { + value = Long.valueOf(field.getText()); + dataValid = true; + field.setBorder(defaultBorder); + } catch (NumberFormatException e) { + field.setBorder(BorderFactory.createLineBorder(Color.red)); + dataValid = false; + } + } + } +} Index: applications/editors/josm/plugins/pdfimport/src/pdfimport/GuiFieldString.java =================================================================== --- applications/editors/josm/plugins/pdfimport/src/pdfimport/GuiFieldString.java (revision 34398) +++ applications/editors/josm/plugins/pdfimport/src/pdfimport/GuiFieldString.java (revision 34398) @@ -0,0 +1,29 @@ +// License: GPL. For details, see LICENSE file. + +package pdfimport; + +import javax.swing.JTextField; +import javax.swing.border.Border; + +public class GuiFieldString extends JTextField { + + protected Border defaultBorder; + protected boolean dataValid; + + public GuiFieldString() { + super(); + defaultBorder = getBorder(); + } + + public GuiFieldString(String text) { + super(text); + defaultBorder = getBorder(); + } + + public boolean isDataValid() { + return dataValid; + } + +} + + Index: applications/editors/josm/plugins/pdfimport/src/pdfimport/GuiPanel.java =================================================================== --- applications/editors/josm/plugins/pdfimport/src/pdfimport/GuiPanel.java (revision 34398) +++ applications/editors/josm/plugins/pdfimport/src/pdfimport/GuiPanel.java (revision 34398) @@ -0,0 +1,27 @@ +// License: GPL. For details, see LICENSE file. + +package pdfimport; + +import java.awt.Component; +import java.awt.LayoutManager; + +import javax.swing.JPanel; + +public class GuiPanel extends JPanel{ + + public GuiPanel() { + super(); + } + + public GuiPanel(LayoutManager layout) { + super(layout); + } + + @Override + public void setEnabled(boolean enabled) { + for (Component c : this.getComponents()) { + c.setEnabled(enabled); + } + super.setEnabled(enabled); + } +} Index: applications/editors/josm/plugins/pdfimport/src/pdfimport/GuiProjections.java =================================================================== --- applications/editors/josm/plugins/pdfimport/src/pdfimport/GuiProjections.java (revision 34398) +++ applications/editors/josm/plugins/pdfimport/src/pdfimport/GuiProjections.java (revision 34398) @@ -0,0 +1,272 @@ +// License: GPL. For details, see LICENSE file. + +package pdfimport; + +import static org.openstreetmap.josm.tools.I18n.tr; + +import java.awt.GridBagConstraints; +import java.awt.GridBagLayout; +import java.awt.Insets; +import java.awt.event.ActionEvent; +import java.awt.event.ActionListener; + +import javax.swing.JComboBox; +import javax.swing.JLabel; +import javax.swing.JPanel; +import javax.swing.SwingConstants; + +import org.openstreetmap.josm.Main; +import org.openstreetmap.josm.data.ProjectionBounds; +import org.openstreetmap.josm.data.projection.Projection; +import org.openstreetmap.josm.gui.preferences.projection.CodeProjectionChoice; +import org.openstreetmap.josm.gui.preferences.projection.CustomProjectionChoice; +import org.openstreetmap.josm.gui.preferences.projection.ProjectionChoice; +import org.openstreetmap.josm.gui.preferences.projection.ProjectionPreference; +import org.openstreetmap.josm.gui.preferences.projection.SingleProjectionChoice; +import org.openstreetmap.josm.spi.preferences.Config; +import org.openstreetmap.josm.tools.Logging; + +public class GuiProjections { + /* + * provide a component let the user select a projection + */ + private GuiPanel panel = null; + private Chooser chooser = null; + private JLabel pCode = null; + private JLabel pName = null; + private JLabel pInfo = null; + private Projection projection = null; + + private class Chooser extends JComboBox { + /* + * Component to choose a Projection + */ + public Chooser() { + setEditable(false); + setToolTipText(tr("Projection of the PDF-Document")); + Monitor monitor = new Monitor(); + for (ProjectionChoice p : ProjectionPreference.getProjectionChoices()) { + if ((p instanceof CodeProjectionChoice)) continue; // can not handle this projection for now + if ((p instanceof CustomProjectionChoice)) continue; // can not handle this projection for now + addItem(p); + } + addActionListener(monitor); + setProjection (Main.getProjection()); + } + + public void setProjection (Projection p) { + /* + * set current Projection to @p + * update internal variables + */ + if (p==null) return; // better keep the old one + projection = p; + pName.setText(p.toString()); + pCode.setText(p.toCode()); + pInfo.setText(userHints(p)); + /* + * find projectionChoice that matches current code + */ + final String projectionCode = p.toCode(); + for (ProjectionChoice projectionChoice : ProjectionPreference.getProjectionChoices()) { + for (String code : projectionChoice.allCodes()) { + if (code.equals(projectionCode)) { + setSelectedItem(projectionChoice); + return; // stop searching + } + } + } + /* + * Not found ==> search in combobox + */ + final String localId = "PdfImport:" + projectionCode; + for (int i=getItemCount()-1; i>=0; i--) { + ProjectionChoice projectionChoice = getItemAt(i); + if (!(projectionChoice instanceof SingleProjectionChoice)) continue; + if (localId.equals(projectionChoice.getId())) { + setSelectedItem(projectionChoice); + return; // stop searching + } + } + /* + * Still not found ==> add it now + */ + Logging.debug("New projection encountered"); + ProjectionChoice px = new SingleProjectionChoice(p.toString(), localId, projectionCode) ; + addItem(px); + setSelectedItem(px); + } + + private class Monitor implements ActionListener { + /* + * (non-Javadoc) + * @see java.awt.event.ActionListener#actionPerformed(java.awt.event.ActionEvent) + * + * monitor user selection and set internal var accordingly + */ + @Override + public void actionPerformed(ActionEvent e) { + try { + ProjectionChoice pc = (ProjectionChoice)((Chooser) e.getSource()).getSelectedItem(); + setProjection(pc.getProjection()); + } catch (Exception X) { + } + } + } + } + + public GuiProjections(){ + build(); + } + + public static String getDefault() { + /* + * provide default projection + */ + return Config.getPref().get("projection.default"); + } + + public JPanel getPanel() { + return panel; + } + + public Projection getProjection() { + return projection; + } + + public void setProjection(Projection p) { + chooser.setProjection(p); + } + + private String userHints(Projection p) { + /* + * Provide some hints about projection @p + */ + String s=""; + ProjectionBounds bd; + try { + bd=p.getWorldBoundsBoxEastNorth(); + s += String.format("Center: (%.0f %.0f) Min:(%.0f %.0f) Max:(%.0f %.0f)", bd.getCenter().east(),bd.getCenter().north(), bd.getMin().east(),bd.getMin().north(),bd.getMax().east(),bd.getMax().north()); + } catch (Exception e) { + // Leave it, if we cant get it + } + return s; + } + + private void build() { +// JButton specBtn = new JButton(tr("Specifiy")); + pCode = new JLabel("code",SwingConstants.RIGHT); + pName = new JLabel("Name",SwingConstants.RIGHT); + pInfo = new JLabel("Info",SwingConstants.RIGHT); + chooser = new Chooser(); + + GridBagConstraints c = new GridBagConstraints(); + c.fill = GridBagConstraints.NONE; + c.insets = new Insets(1, 1, 1, 4); + c.anchor = GridBagConstraints.LINE_END; + + panel = new GuiPanel(new GridBagLayout()); + panel.add(new JLabel(tr("Projection:"),SwingConstants.RIGHT),c); + panel.add(pCode,c); + c.weightx = 1.0; c.gridx = 2; panel.add(chooser,c); + c.weightx = 0.0; c.gridy = 1; c.gridx = 0; c.gridwidth = 3; c.anchor = GridBagConstraints.LINE_END; + panel.add(pInfo,c); + } +} + +//class ProjectionSubPrefsDialog extends JDialog { +///* +// * note currently non-functional ==> not used +// */ +//private final ProjectionChoice projPref; +//private OKAction actOK; +//private CancelAction actCancel; +//private JPanel projPrefPanel; +// +//ProjectionSubPrefsDialog(Component parent, ProjectionChoice pr) { +// super(JOptionPane.getFrameForComponent(parent), ModalityType.DOCUMENT_MODAL); +// +// projPref = pr; +// +// setTitle(tr("Projection Preferences")); +// setDefaultCloseOperation(DISPOSE_ON_CLOSE); +// +// build(); +//} +// +//protected void makeButtonRespondToEnter(SideButton btn) { +// btn.setFocusable(true); +// btn.getInputMap(JComponent.WHEN_FOCUSED).put(KeyStroke.getKeyStroke(KeyEvent.VK_ENTER, 0), "enter"); +// btn.getActionMap().put("enter", btn.getAction()); +//} +// +//protected JPanel buildInputForm() { +// return projPref.getPreferencePanel(null); +//} +// +//protected JPanel buildButtonRow() { +// JPanel pnl = new JPanel(new FlowLayout()); +// +// actOK = new OKAction(); +// actCancel = new CancelAction(); +// +// SideButton btn; +// pnl.add(btn = new SideButton(actOK)); +// // makeButtonRespondToEnter(btn); +// // pnl.add(btn = new SideButton(actCancel)); +// // makeButtonRespondToEnter(btn); +// return pnl; +//} +// +//protected void build() { +// projPrefPanel = buildInputForm(); +// getContentPane().setLayout(new BorderLayout()); +// getContentPane().add(projPrefPanel, BorderLayout.CENTER); +// getContentPane().add(buildButtonRow(), BorderLayout.SOUTH); +// pack(); +// +// // make dialog respond to ESCAPE +// getRootPane().getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT) +// .put(KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE, 0), "escape"); +// getRootPane().getActionMap().put("escape", actCancel); +//} +// +//class OKAction extends AbstractAction { +// OKAction() { +// putValue(NAME, tr("OK")); +// putValue(SHORT_DESCRIPTION, tr("Close the dialog and apply projection preferences")); +// putValue(SMALL_ICON, ImageProvider.get("ok")); +// } +// +// @Override +// public void actionPerformed(ActionEvent e) { +// projPref.setPreferences(projPref.getPreferences(projPrefPanel)); +// setVisible(false); +// } +//} +// +//class CancelAction extends AbstractAction { +// CancelAction() { +// putValue(NAME, tr("Cancel")); +// putValue(SHORT_DESCRIPTION, tr("Close the dialog, discard projection preference changes")); +// putValue(SMALL_ICON, ImageProvider.get("cancel")); +// } +// +// @Override +// public void actionPerformed(ActionEvent e) { +// setVisible(false); +// } +//} +// +//@Override +//public void setVisible(boolean visible) { +// if (visible) { +// new WindowGeometry(getClass().getName() + ".geometry", +// WindowGeometry.centerOnScreen(new Dimension(400, 300))).applySafe(this); +// } else if (isShowing()) { // Avoid IllegalComponentStateException like in #8775 +// new WindowGeometry(this).remember(getClass().getName() + ".geometry"); +// } +// super.setVisible(visible); +//} +//} + Index: applications/editors/josm/plugins/pdfimport/src/pdfimport/LoadPdfDialog.java =================================================================== --- applications/editors/josm/plugins/pdfimport/src/pdfimport/LoadPdfDialog.java (revision 34397) +++ applications/editors/josm/plugins/pdfimport/src/pdfimport/LoadPdfDialog.java (revision 34398) @@ -4,5 +4,4 @@ import static org.openstreetmap.josm.tools.I18n.tr; -import java.awt.BorderLayout; import java.awt.Color; import java.awt.Component; @@ -12,27 +11,16 @@ import java.awt.GridBagConstraints; import java.awt.GridBagLayout; +import java.awt.Insets; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; -import java.awt.event.FocusEvent; -import java.awt.event.FocusListener; -import java.awt.event.KeyEvent; import java.awt.event.WindowAdapter; import java.awt.event.WindowEvent; import java.io.File; -import java.io.FileInputStream; import java.io.FileNotFoundException; -import java.io.FileOutputStream; import java.io.IOException; -import java.util.Collection; -import java.util.Properties; - -import javax.swing.AbstractAction; + import javax.swing.BorderFactory; -import javax.swing.BoxLayout; import javax.swing.JButton; -import javax.swing.JCheckBox; -import javax.swing.JComboBox; import javax.swing.JComponent; -import javax.swing.JDialog; import javax.swing.JFileChooser; import javax.swing.JFrame; @@ -42,27 +30,17 @@ import javax.swing.JProgressBar; import javax.swing.JTextField; -import javax.swing.KeyStroke; +import javax.swing.SwingConstants; import javax.swing.SwingUtilities; -import javax.swing.border.Border; import javax.swing.filechooser.FileFilter; import org.openstreetmap.josm.Main; -import org.openstreetmap.josm.data.coor.EastNorth; -import org.openstreetmap.josm.data.coor.LatLon; import org.openstreetmap.josm.data.osm.DataSet; -import org.openstreetmap.josm.data.osm.Node; -import org.openstreetmap.josm.data.osm.OsmPrimitive; import org.openstreetmap.josm.data.osm.UploadPolicy; import org.openstreetmap.josm.gui.MainApplication; -import org.openstreetmap.josm.gui.SideButton; import org.openstreetmap.josm.gui.io.importexport.OsmExporter; import org.openstreetmap.josm.gui.layer.OsmDataLayer; -import org.openstreetmap.josm.gui.preferences.projection.ProjectionChoice; -import org.openstreetmap.josm.gui.preferences.projection.ProjectionPreference; import org.openstreetmap.josm.gui.progress.ProgressMonitor; import org.openstreetmap.josm.gui.progress.ProgressRenderer; import org.openstreetmap.josm.gui.progress.swing.SwingRenderingProgressMonitor; -import org.openstreetmap.josm.gui.util.WindowGeometry; -import org.openstreetmap.josm.tools.ImageProvider; import org.openstreetmap.josm.tools.Logging; @@ -71,1145 +49,706 @@ public class LoadPdfDialog extends JFrame { - static class LoadProgressRenderer implements ProgressRenderer { - private final JProgressBar pBar; - private String title = ""; - - LoadProgressRenderer(JProgressBar pb) { - this.pBar = pb; - this.pBar.setMinimum(0); - this.pBar.setValue(0); - this.pBar.setMaximum(1); - this.pBar.setString(""); - this.pBar.setStringPainted(true); - - } - - @Override - public void setCustomText(String message) { - this.pBar.setString(this.title + message); - } - - @Override - public void setIndeterminate(boolean indeterminate) { - this.pBar.setIndeterminate(indeterminate); - } - - @Override - public void setMaximum(int maximum) { - this.pBar.setMaximum(maximum); - } - - @Override - public void setTaskTitle(String taskTitle) { - this.title = taskTitle; - this.pBar.setString(this.title); - } - - @Override - public void setValue(int value) { - this.pBar.setValue(value); - } - - public void finish() { - this.pBar.setString(tr("Finished")); - this.pBar.setValue(this.pBar.getMaximum()); - } - - } - - private File pdfFile; - private PathOptimizer data; - private OsmDataLayer layer; - - /** - * Combobox with all projections available - */ - private JComboBox projectionCombo; - private JButton projectionPreferencesButton; - private JTextField minXField; - private JTextField minYField; - private JTextField minEastField; - private JTextField minNorthField; - private JButton getMinButton; - private JButton okButton; - private JButton cancelButton; - private JButton getMaxButton; - private JTextField maxNorthField; - private JTextField maxEastField; - private JTextField maxYField; - private JTextField maxXField; - private JButton loadFileButton; - private JButton showButton; - private JButton saveButton; - private JCheckBox debugModeCheck; - private JCheckBox mergeCloseNodesCheck; - private JTextField mergeCloseNodesTolerance; - private JCheckBox removeSmallObjectsCheck; - private JTextField removeSmallObjectsSize; - private JTextField colorFilterColor; - private JCheckBox colorFilterCheck; - private JCheckBox removeParallelSegmentsCheck; - private JTextField removeParallelSegmentsTolerance; - private JCheckBox removeLargeObjectsCheck; - private JTextField removeLargeObjectsSize; - private JProgressBar loadProgress; - protected OsmDataLayer newLayer; - - private LoadProgressRenderer progressRenderer; - private JCheckBox limitPathCountCheck; - private JTextField limitPathCount; - private JCheckBox splitOnColorChangeCheck; - private JCheckBox splitOnShapeClosedCheck; - private JCheckBox splitOnSingleSegmentCheck; - private JCheckBox splitOnOrthogonalCheck; - private Border defaulfBorder = (new JTextField()).getBorder(); - - public LoadPdfDialog() { - Logging.debug("PdfImport:LoadPdfDialog"); - this.buildGUI(); - FilePlacement pl = new FilePlacement(); - this.setPlacement(pl); - this.addListeners(); - this.removeLayer(); - if (PdfImportPlugin.Preferences.guiMode == PdfImportPlugin.GuiMode.Simple) this.loadFilePressed();; - } - - private class CheckDouble implements FocusListener { + public static class MainButtons { + public JButton okButton; + public JButton cancelButton; + public JButton showButton; + public JButton saveButton; + public JPanel panel; + + public MainButtons() { + } + + void build(LoadPdfDialog loadPdfDialog) { + /* + * build the dialog Window from components + */ + okButton = new JButton(tr("Import")); + okButton.addActionListener(new ActionListener() { + @Override + public void actionPerformed(ActionEvent e) { + loadPdfDialog.importAction(); + } + }); + saveButton = new JButton(tr("Save")); + saveButton.addActionListener(new ActionListener() { + @Override + public void actionPerformed(ActionEvent e) { + loadPdfDialog.saveAction(); + } + }); + + showButton = new JButton(tr("Show target")); + showButton.addActionListener(new ActionListener() { + @Override + public void actionPerformed(ActionEvent e) { + loadPdfDialog.showAction(); + } + }); + + cancelButton = new JButton(tr("Cancel")); + cancelButton.addActionListener(new ActionListener() { + @Override + public void actionPerformed(ActionEvent e) { + loadPdfDialog.cancelAction(); + } + }); + + panel = new JPanel(new FlowLayout()); + panel.add(cancelButton); + panel.add(showButton); + panel.add(okButton); + panel.add(saveButton); + showButton.setVisible(Preferences.isLegacyActions()); + saveButton.setVisible(Preferences.isLegacyActions()); + } + } + + + private static class Config { + /* + * encapsulate options for Path optimizer + * provide GUI + */ + public GuiFieldBool debugModeCheck; + public GuiFieldBool mergeCloseNodesCheck; + public GuiFieldDouble mergeCloseNodesTolerance; + public GuiFieldBool removeSmallObjectsCheck; + public GuiFieldDouble removeSmallObjectsSize; + public JTextField colorFilterColor; + public GuiFieldBool colorFilterCheck; + public GuiFieldBool removeParallelSegmentsCheck; + public GuiFieldDouble removeParallelSegmentsTolerance; + public GuiFieldBool removeLargeObjectsCheck; + public GuiFieldDouble removeLargeObjectsSize; + public GuiFieldBool limitPathCountCheck; + public GuiFieldInteger limitPathCount; + public GuiFieldBool splitOnColorChangeCheck; + public GuiFieldBool splitOnShapeClosedCheck; + public GuiFieldBool splitOnSingleSegmentCheck; + public GuiFieldBool splitOnOrthogonalCheck; + private JPanel panel; + + public Config() { + build(); + } + + public JComponent getComponent() { + return panel; + } + + private void build() { + + + debugModeCheck = new GuiFieldBool(tr("Debug info"), Preferences.isDebugTags()); + + mergeCloseNodesTolerance = new GuiFieldDouble(Preferences.getMergeNodesValue()); + mergeCloseNodesCheck = new GuiFieldBool(tr("Merge close nodes"), Preferences.isMergeNodes()); + mergeCloseNodesCheck.setCompanion(mergeCloseNodesTolerance); + + removeSmallObjectsSize = new GuiFieldDouble(Preferences.getRemoveSmallValue()); + removeSmallObjectsCheck = new GuiFieldBool(tr("Remove objects smaller than"),Preferences.isRemoveSmall()); + removeSmallObjectsCheck.setCompanion(removeSmallObjectsSize); + + removeLargeObjectsSize = new GuiFieldDouble((Preferences.getRemoveLargeValue())); + removeLargeObjectsCheck = new GuiFieldBool(tr("Remove objects larger than"),Preferences.isRemoveLarge()); + removeLargeObjectsCheck.setCompanion(removeLargeObjectsSize); + + colorFilterColor = new GuiFieldHex(Preferences.getLimitColorValue()); + colorFilterCheck = new GuiFieldBool(tr("Only this color"), Preferences.isLimitColor()); + colorFilterCheck.setCompanion(colorFilterColor); + + removeParallelSegmentsTolerance = new GuiFieldDouble((Preferences.getRemoveParallelValue())); + removeParallelSegmentsCheck = new GuiFieldBool(tr("Remove parallel lines"),Preferences.isRemoveParallel()); + removeParallelSegmentsCheck.setCompanion(removeParallelSegmentsTolerance); + + limitPathCount = new GuiFieldInteger((Preferences.getLimitPathValue())); + limitPathCountCheck = new GuiFieldBool(tr("Take only first X paths"),Preferences.isLimitPath()); + limitPathCountCheck.setCompanion(limitPathCount); + + splitOnColorChangeCheck = new GuiFieldBool(tr("Color/width change"),Preferences.isLayerAttribChange()); + splitOnShapeClosedCheck = new GuiFieldBool(tr("Shape closed"), Preferences.isLayerClosed()); + + splitOnSingleSegmentCheck = new GuiFieldBool(tr("Single segments", Preferences.isLayerSegment())); + splitOnOrthogonalCheck = new GuiFieldBool(tr("Orthogonal shapes", Preferences.isLayerOrtho())); + + panel = new JPanel(new GridBagLayout()); + panel.setBorder(BorderFactory.createTitledBorder(tr("Import settings"))); + + GridBagConstraints cBasic = new GridBagConstraints(); + cBasic.gridx = GridBagConstraints.RELATIVE; + cBasic.gridy = GridBagConstraints.RELATIVE; + cBasic.insets = new Insets(0, 0, 0, 4); + cBasic.anchor = GridBagConstraints.LINE_START; + cBasic.fill = GridBagConstraints.HORIZONTAL; + cBasic.gridheight = 1; + cBasic.gridwidth = 1; + cBasic.ipadx = 0; + cBasic.ipady = 0; + cBasic.weightx = 0.0; + cBasic.weighty = 0.0; + + GridBagConstraints cLeft = (GridBagConstraints) cBasic.clone(); + cLeft.gridx = 0; + + GridBagConstraints cMiddle = (GridBagConstraints) cBasic.clone(); + cMiddle.gridx = 1; + cMiddle.anchor = GridBagConstraints.LINE_END; + + GridBagConstraints cRight = (GridBagConstraints) cBasic.clone(); + cRight.gridx = 2; + + panel.add(mergeCloseNodesCheck, cLeft); + panel.add(new JLabel(tr("Tolerance:"),SwingConstants.RIGHT), cMiddle); + panel.add(mergeCloseNodesTolerance, cRight); + + panel.add(removeSmallObjectsCheck, cLeft); + panel.add(new JLabel(tr("Tolerance:"),SwingConstants.RIGHT), cMiddle); + panel.add(removeSmallObjectsSize, cRight); + + panel.add(removeLargeObjectsCheck, cLeft); + panel.add(new JLabel(tr("Tolerance:"),SwingConstants.RIGHT), cMiddle); + panel.add(removeLargeObjectsSize, cRight); + + panel.add(removeParallelSegmentsCheck, cLeft); + panel.add(new JLabel(tr("Max distance:"),SwingConstants.RIGHT), cMiddle); + panel.add(removeParallelSegmentsTolerance, cRight); + + panel.add(limitPathCountCheck, cLeft); + panel.add(limitPathCount, cRight); + + panel.add(colorFilterCheck, cLeft); + panel.add(colorFilterColor, cRight); + + panel.add(debugModeCheck, cLeft); + + cLeft.gridy = 8; panel.add(new JLabel(tr("Introduce separate layers for:")), cLeft); + cMiddle.gridy = 8; panel.add(splitOnShapeClosedCheck, cMiddle); + cRight.gridy = 8; panel.add(splitOnSingleSegmentCheck, cRight); + cMiddle.gridy = 9; panel.add(splitOnColorChangeCheck, cMiddle); + cRight.gridy = 9;panel.add(splitOnOrthogonalCheck, cRight); + } + } + + static class LoadProgressRenderer implements ProgressRenderer { + private final JProgressBar pBar; + private String title = ""; + + LoadProgressRenderer(JProgressBar pb) { + this.pBar = pb; + this.pBar.setMinimum(0); + this.pBar.setValue(0); + this.pBar.setMaximum(1); + this.pBar.setString(""); + this.pBar.setStringPainted(true); + + } @Override - public void focusGained(FocusEvent e) { + public void setCustomText(String message) { + this.pBar.setString(this.title + message); } @Override - public void focusLost(FocusEvent event) { - check((JTextField) event.getSource()); - } - - public void check(JTextField t) { + public void setIndeterminate(boolean indeterminate) { + this.pBar.setIndeterminate(indeterminate); + } + + @Override + public void setMaximum(int maximum) { + this.pBar.setMaximum(maximum); + } + + @Override + public void setTaskTitle(String taskTitle) { + this.title = taskTitle; + this.pBar.setString(this.title); + } + + @Override + public void setValue(int value) { + this.pBar.setValue(value); + } + + public void finish() { + this.pBar.setString(tr("Finished")); + this.pBar.setValue(this.pBar.getMaximum()); + } + + } + + private File pdfFile; + private final FilePlacement18 placement = new FilePlacement18(); + + private PathOptimizer pdfData; + private OsmDataLayer dataLayer; + + private final JButton loadFileButton = new JButton(tr("Load preview ...")); + + private final JProgressBar loadProgress = new JProgressBar(); +; + private OsmDataLayer newLayer; + + private LoadProgressRenderer progressRenderer; + + public LoadPdfDialog() { + buildGUI(); + removeLayer(); + if (Preferences.getGuiMode() == Preferences.GuiMode.Simple) { + loadFileButton.setVisible(false); + configPanel.panel.setVisible(false); + actionPanel.saveButton.setVisible(false); + actionPanel.showButton.setVisible(false); + setSize(new Dimension(380, 350)); + loadAction(); + } else { + setSize(new Dimension(450, 600)); +// setSize(450, 600); + } + } + + Component placementPanel = placement.getGui(); + MainButtons actionPanel = new MainButtons(); + Config configPanel = new Config(); + + private void buildGUI() { + /* + * build the GUI from Components + */ + GridBagConstraints c = new GridBagConstraints(); + c.gridheight = 1; + c.gridwidth = 1; + c.gridx = 0; + c.gridy = GridBagConstraints.RELATIVE; + c.fill = GridBagConstraints.BOTH; + c.insets = new java.awt.Insets(0, 0, 0, 0); + + actionPanel.build(this); + + loadFileButton.addActionListener(new ActionListener() { + @Override + public void actionPerformed(ActionEvent e) { + loadAction(); + } + }); + + progressRenderer = new LoadProgressRenderer(loadProgress); + + JPanel panel = new JPanel(new GridBagLayout()); + + panel.add(configPanel.getComponent(), c); + c.fill = GridBagConstraints.HORIZONTAL; + panel.add(loadFileButton, c); + c.fill = GridBagConstraints.BOTH; + panel.add(placementPanel, c); + panel.add(actionPanel.panel, c); + c.fill = GridBagConstraints.HORIZONTAL; + panel.add(this.loadProgress, c); + + setContentPane(panel); + addWindowListener(new WindowAdapter() { + @Override + public void windowClosing(WindowEvent e) { + cancelAction(); + } + }); + placement.setDependsOnValid(actionPanel.okButton); + + /* + * TODO: Make okButton to default Button of Dialog, make cancelButton to react on ESC-Key + */ +// SwingUtilities.getRootPane(panel).setDefaultButton(actionPanel.okButton); + } + + private void loadAction() { + /* + * perform load PDF file to preview + */ + final File newFileName = this.chooseFile(); + + if (newFileName == null) { + return; + } + Logging.debug("PdfImport: Load Preview"); + this.removeLayer(); + + this.loadFileButton.setEnabled(false); + + this.runAsBackgroundTask(new Runnable() { + @Override + public void run() { + // async part + LoadPdfDialog.this.loadProgress.setVisible(true); + SwingRenderingProgressMonitor monitor = new SwingRenderingProgressMonitor(progressRenderer); + monitor.beginTask("Loading file", 1000); + pdfData = loadPDF(newFileName, monitor.createSubTaskMonitor(500, false)); + OsmBuilder.Mode mode = LoadPdfDialog.this.configPanel.debugModeCheck.getValue() + ? OsmBuilder.Mode.Debug + : OsmBuilder.Mode.Draft; + + if (pdfData != null) { + LoadPdfDialog.this.newLayer = LoadPdfDialog.this.makeLayer( + tr("PDF preview: ") + newFileName.getName(), new FilePlacement(), mode, + monitor.createSubTaskMonitor(500, false)); + } + + monitor.finishTask(); + progressRenderer.finish(); + } + }, new ActionListener() { + + @Override + public void actionPerformed(ActionEvent event) { + // sync part + LoadPdfDialog.this.pdfFile = newFileName; + if (pdfData != null) { + LoadPdfDialog.this.placeLayer(newLayer, new FilePlacement()); + try { + LoadPdfDialog.this.placement.load(newFileName); + } catch (IOException e) { + // Dont care + } finally { + LoadPdfDialog.this.placement.verify(); + } + LoadPdfDialog.this.newLayer = null; + LoadPdfDialog.this.loadFileButton.setEnabled(true); + LoadPdfDialog.this.placementPanel.setEnabled(true); + LoadPdfDialog.this.actionPanel.panel.setEnabled(true); + LoadPdfDialog.this.actionPanel.showButton.setEnabled(true); + LoadPdfDialog.this.actionPanel.saveButton.setEnabled(true); + LoadPdfDialog.this.actionPanel.okButton.setEnabled(true); + LoadPdfDialog.this.loadProgress.setVisible(false); + } + } + }); + } + + private void importAction() { + + if (!placement.isValid()) return; + + Logging.debug("PdfImport: Import"); + this.removeLayer(); + + this.runAsBackgroundTask(new Runnable() { + @Override + public void run() { + // async part + LoadPdfDialog.this.loadProgress.setVisible(true); + SwingRenderingProgressMonitor monitor = new SwingRenderingProgressMonitor(progressRenderer); + LoadPdfDialog.this.newLayer = LoadPdfDialog.this.makeLayer(tr("PDF: ") + pdfFile.getName(), placement, + OsmBuilder.Mode.Final, monitor); + progressRenderer.finish(); + } + }, new ActionListener() { + + @Override + public void actionPerformed(ActionEvent e) { + // sync part + // rebuild layer with latest projection + LoadPdfDialog.this.placeLayer(newLayer, placement); + LoadPdfDialog.this.setVisible(false); + } + }); + } + + private void saveAction() { + /* + * perform save preview layer to file + * TODO: is this action valueable? Can be easily performed from main menu + */ + + if (!placement.isValid()) return; + + final java.io.File file = this.chooseSaveFile(); + + if (file == null) { + return; + } + + this.removeLayer(); + + this.runAsBackgroundTask(new Runnable() { + @Override + public void run() { + // async part + SwingRenderingProgressMonitor monitor = new SwingRenderingProgressMonitor(progressRenderer); + LoadPdfDialog.this.saveLayer(file, placement, monitor); + progressRenderer.finish(); + } + }, new ActionListener() { + + @Override + public void actionPerformed(ActionEvent e) { + // sync part + LoadPdfDialog.this.setVisible(false); + } + }); + } + + private void showAction() { + /* + * perform show action + * TODO: is this action valuable? User can do it easy from OSM Main Menu + */ + if (!placement.isValid()) return; + + // zoom to new location + MainApplication.getMap().mapView.zoomTo(placement.getWorldBounds(pdfData)); + MainApplication.getMap().repaint(); + } + + private void cancelAction() { + /* + * perform cancel action + */ + removeLayer(); + setVisible(false); + } + + // Implementation methods + + private static JFileChooser loadChooser = null; + + private java.io.File chooseFile() { + // get PDF file to load + if (loadChooser == null) { + loadChooser = new JFileChooser(Preferences.getLoadDir()); + loadChooser.setAcceptAllFileFilterUsed(false); + loadChooser.setMultiSelectionEnabled(false); + loadChooser.setFileFilter(new FileFilter() { + @Override + public boolean accept(java.io.File pathname) { + return pathname.isDirectory() || pathname.getName().endsWith(".pdf"); + } + + @Override + public String getDescription() { + return tr("PDF files"); + } + }); + } else { + loadChooser.rescanCurrentDirectory(); + } + int result = loadChooser.showDialog(this, tr("Import PDF")); + if (result != JFileChooser.APPROVE_OPTION) { + return null; + } else { + Preferences.setLoadDir(loadChooser.getSelectedFile().getParentFile().getAbsolutePath()); + return loadChooser.getSelectedFile(); + } + } + + private java.io.File chooseSaveFile() { + // get file name + JFileChooser fc = new JFileChooser(); + fc.setAcceptAllFileFilterUsed(true); + fc.setMultiSelectionEnabled(false); + fc.setFileFilter(new FileFilter() { + @Override + public boolean accept(java.io.File pathname) { + return pathname.isDirectory() || pathname.getName().endsWith(".osm"); + } + + @Override + public String getDescription() { + return tr("OSM files"); + } + }); + int result = fc.showOpenDialog(Main.parent); + + if (result != JFileChooser.APPROVE_OPTION) { + return null; + } else { + return fc.getSelectedFile(); + } + } + + private void runAsBackgroundTask(final Runnable task, final ActionListener after) { + /* + * run @task in background (asychronosly , run @after when @task has finished + */ + this.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR)); + Thread t = new Thread(new Runnable() { + @Override + public void run() { + task.run(); + + SwingUtilities.invokeLater(new Runnable() { + @Override + public void run() { + setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR)); + after.actionPerformed(null); + } + }); + } + }); + t.start(); + } + + private PathOptimizer loadPDF(File fileName, ProgressMonitor monitor) { + /* + * postprocess load PDF-file according to options + */ + + monitor.beginTask("", 100); + monitor.setTicks(0); + monitor.setCustomText(tr("Preparing")); + + double nodesTolerance = 0.0; + Color color = null; + int maxPaths = Integer.MAX_VALUE; + + if (configPanel.mergeCloseNodesCheck.getValue() && configPanel.mergeCloseNodesTolerance.isDataValid()) { + nodesTolerance = configPanel.mergeCloseNodesTolerance.getValue(); + } + + if (configPanel.colorFilterCheck.getValue()) { try { - Double.valueOf(t.getText()); - t.setBorder((LoadPdfDialog.this.defaulfBorder)); - } catch (NumberFormatException e) { - t.setBorder(BorderFactory.createLineBorder(Color.red)); - } - } - } - -private CheckDouble doublelistener = new CheckDouble(); - - private void addListeners() { - - this.maxEastField.addFocusListener(doublelistener); - this.maxEastField.addFocusListener(new FocusListener() { - @Override - public void focusLost(FocusEvent e) { - checkCoords(LoadPdfDialog.this.maxEastField, LoadPdfDialog.this.maxNorthField); - } - - @Override - public void focusGained(FocusEvent e) { - } - }); - this.maxNorthField.addFocusListener(doublelistener); - - this.minEastField.addFocusListener(doublelistener); - this.minEastField.addFocusListener(new FocusListener() { - @Override - public void focusLost(FocusEvent e) { - checkCoords(LoadPdfDialog.this.minEastField, LoadPdfDialog.this.minNorthField); - } - - @Override - public void focusGained(FocusEvent e) { - } - }); - - this.minNorthField.addFocusListener(doublelistener); - - this.minXField.addFocusListener(doublelistener); - this.minXField.addFocusListener(doublelistener); - this.minXField.addFocusListener(new FocusListener() { - @Override - public void focusLost(FocusEvent e) { - checkCoords(LoadPdfDialog.this.minXField, LoadPdfDialog.this.minYField); - } - - @Override - public void focusGained(FocusEvent e) { - } - }); - - this.minYField.addFocusListener(doublelistener); - - this.maxXField.addFocusListener(doublelistener); - this.maxXField.addFocusListener(new FocusListener() { - @Override - public void focusLost(FocusEvent e) { - checkCoords(LoadPdfDialog.this.maxXField, LoadPdfDialog.this.maxYField); - } - - @Override - public void focusGained(FocusEvent e) { - } - }); - - this.maxYField.addFocusListener(doublelistener); - - this.projectionCombo.addActionListener(new ActionListener() { - @Override - public void actionPerformed(ActionEvent e) { - updateProjectionPrefButton(); - } - - }); - this.projectionPreferencesButton.addActionListener(new ActionListener() { - @Override - public void actionPerformed(ActionEvent e) { - showProjectionPreferences(); - } - }); - - this.loadFileButton.addActionListener(new ActionListener() { - @Override - public void actionPerformed(ActionEvent e) { - loadFilePressed(); - } - }); - - this.okButton.addActionListener(new ActionListener() { - @Override - public void actionPerformed(ActionEvent e) { - okPressed(); - } - }); - - this.saveButton.addActionListener(new ActionListener() { - @Override - public void actionPerformed(ActionEvent e) { - savePressed(); - } - }); - - this.showButton.addActionListener(new ActionListener() { - @Override - public void actionPerformed(ActionEvent e) { - showPressed(); - } - }); - - this.cancelButton.addActionListener(new ActionListener() { - @Override - public void actionPerformed(ActionEvent e) { - cancelPressed(); - } - }); - - this.addWindowListener(new WindowAdapter() { - @Override - public void windowClosing(WindowEvent e) { - cancelPressed(); - } - }); - - this.getMinButton.addActionListener(new ActionListener() { - @Override - public void actionPerformed(ActionEvent e) { - getMinPressed(); - } - }); - - this.getMaxButton.addActionListener(new ActionListener() { - @Override - public void actionPerformed(ActionEvent e) { - getMaxPressed(); - } - }); - } - - JPanel projectionPanel = null; - JPanel okCancelPanel = null; - - private void buildGUI() { - GridBagConstraints c = new GridBagConstraints(); - c.gridheight = 1; c.gridwidth = 1; c.weightx = 1; c.weighty = 1; c.fill = GridBagConstraints.BOTH; - c.insets = new java.awt.Insets(0,0,0,0); -// c.ipadx = 1; c.ipady = 1; - - this.projectionCombo = new JComboBox<>(); - for (ProjectionChoice p: ProjectionPreference.getProjectionChoices()) { - this.projectionCombo.addItem(p); - } - - this.projectionPreferencesButton = new JButton(tr("Prefs")); - updateProjectionPrefButton(); - - this.loadFileButton = new JButton(tr("Load preview ...")); - this.okButton = new JButton(tr("Import")); - this.saveButton = new JButton(tr("Save")); - this.showButton = new JButton(tr("Show target")); - this.cancelButton = new JButton(tr("Cancel")); - this.loadProgress = new JProgressBar(); - this.progressRenderer = new LoadProgressRenderer(this.loadProgress); - - this.minXField = new JTextField(""); - this.minYField = new JTextField(""); - this.minEastField = new JTextField(""); - this.minNorthField = new JTextField(""); - this.getMinButton = new JButton(tr("Take X and Y from selected node")); - - this.maxXField = new JTextField(""); - this.maxYField = new JTextField(""); - this.maxEastField = new JTextField(""); - this.maxNorthField = new JTextField(""); - this.getMaxButton = new JButton(tr("Take X and Y from selected node")); - - this.debugModeCheck = new JCheckBox(tr("Debug info"),PdfImportPlugin.Preferences.DebugTags); - this.mergeCloseNodesCheck = new JCheckBox(tr("Merge close nodes"),PdfImportPlugin.Preferences.MergeNodes); - this.mergeCloseNodesTolerance = new JTextField(Double.toString(PdfImportPlugin.Preferences.MergeNodesValue)); - - this.removeSmallObjectsCheck = new JCheckBox(tr("Remove objects smaller than"),PdfImportPlugin.Preferences.RemoveSmall); - this.removeSmallObjectsSize = new JTextField(Double.toString(PdfImportPlugin.Preferences.RemoveSmallValue)); - - this.removeLargeObjectsCheck = new JCheckBox(tr("Remove objects larger than"),PdfImportPlugin.Preferences.RemoveLarge); - this.removeLargeObjectsSize = new JTextField(Double.toString(PdfImportPlugin.Preferences.RemoveLargeValue)); - - - this.colorFilterCheck = new JCheckBox(tr("Only this color"),PdfImportPlugin.Preferences.LimitColor); - this.colorFilterColor = new JTextField(PdfImportPlugin.Preferences.LimitColorValue); - - this.removeParallelSegmentsCheck = new JCheckBox(tr("Remove parallel lines"),PdfImportPlugin.Preferences.RemoveParallel); - this.removeParallelSegmentsTolerance = new JTextField(Double.toString(PdfImportPlugin.Preferences.RemoveParallelValue)); - - this.limitPathCountCheck = new JCheckBox(tr("Take only first X paths"),PdfImportPlugin.Preferences.LimitPath); - this.limitPathCount = new JTextField(Integer.toString(PdfImportPlugin.Preferences.LimitPathValue)); - - this.splitOnColorChangeCheck = new JCheckBox(tr("Color/width change"),PdfImportPlugin.Preferences.LayerAttribChange); - this.splitOnShapeClosedCheck = new JCheckBox(tr("Shape closed"),PdfImportPlugin.Preferences.LayerClosed); - this.splitOnSingleSegmentCheck = new JCheckBox(tr("Single segments",PdfImportPlugin.Preferences.LayerSegment)); - this.splitOnOrthogonalCheck = new JCheckBox(tr("Orthogonal shapes",PdfImportPlugin.Preferences.LayerOrtho)); - - JPanel configPanel = new JPanel(new GridBagLayout()); - configPanel.setBorder(BorderFactory.createTitledBorder(tr("Import settings"))); - c.gridx = 0; c.gridy = 0; c.gridwidth = 1; - configPanel.add(this.mergeCloseNodesCheck, c); - c.gridx = 1; c.gridy = 0; c.gridwidth = 1; c.anchor = GridBagConstraints.NORTHEAST; - configPanel.add(new JLabel("Tolerance :"), c); - c.gridx = 2; c.gridy = 0; c.gridwidth = 1; c.anchor = GridBagConstraints.NORTHWEST; - configPanel.add(this.mergeCloseNodesTolerance, c); - - c.gridx = 0; c.gridy = 1; c.gridwidth = 1; - configPanel.add(this.removeSmallObjectsCheck, c); - c.gridx = 1; c.gridy = 1; c.gridwidth = 1; c.anchor = GridBagConstraints.NORTHEAST; - configPanel.add(new JLabel("Tolerance :"), c); - c.gridx = 2; c.gridy = 1; c.gridwidth = 1; c.anchor = GridBagConstraints.NORTHWEST; - configPanel.add(this.removeSmallObjectsSize, c); - - c.gridx = 0; c.gridy = 2; c.gridwidth = 1; - configPanel.add(this.removeLargeObjectsCheck, c); - c.gridx = 1; c.gridy = 2; c.gridwidth = 1; c.anchor = GridBagConstraints.NORTHEAST; - configPanel.add(new JLabel("Tolerance :"), c); - c.gridx = 2; c.gridy = 2; c.gridwidth = 1; c.anchor = GridBagConstraints.NORTHWEST; - configPanel.add(this.removeLargeObjectsSize, c); - - c.gridx = 0; c.gridy = 3; c.gridwidth = 1; - configPanel.add(this.removeParallelSegmentsCheck, c); - c.gridx = 1; c.gridy = 3; c.gridwidth = 1; c.anchor = GridBagConstraints.NORTHEAST; - configPanel.add(new JLabel("Max distance :"), c); - c.gridx = 2; c.gridy = 3; c.gridwidth = 1; c.anchor = GridBagConstraints.NORTHWEST; - configPanel.add(this.removeParallelSegmentsTolerance, c); - - - c.gridx = 0; c.gridy = 4; c.gridwidth = 2; - configPanel.add(this.limitPathCountCheck, c); - c.gridx = 2; c.gridy = 4; c.gridwidth = 1; - configPanel.add(this.limitPathCount, c); - - c.gridx = 0; c.gridy = 5; c.gridwidth = 1; - configPanel.add(this.colorFilterCheck, c); - c.gridx = 2; c.gridy = 5; c.gridwidth = 1; - configPanel.add(this.colorFilterColor, c); - - c.gridx = 0; c.gridy = 6; c.gridwidth = 2; - configPanel.add(this.debugModeCheck, c); - - - c.gridx = 0; c.gridy = 7; c.gridwidth = 1; - configPanel.add(new JLabel(tr("Introduce separate layers for:")), c); - c.gridx = 1; c.gridy = 7; c.gridwidth = 1; - configPanel.add(this.splitOnShapeClosedCheck, c); - c.gridx = 2; c.gridy = 7; c.gridwidth = 1; - configPanel.add(this.splitOnSingleSegmentCheck, c); - c.gridx = 1; c.gridy = 8; c.gridwidth = 1; - configPanel.add(this.splitOnColorChangeCheck, c); - c.gridx = 2; c.gridy = 8; c.gridwidth = 1; - configPanel.add(this.splitOnOrthogonalCheck, c); - if (PdfImportPlugin.Preferences.guiMode == PdfImportPlugin.GuiMode.Simple) configPanel.setVisible(false); - - projectionPanel = new JPanel(new GridBagLayout()); - projectionPanel.setBorder(BorderFactory.createTitledBorder(tr("Bind to coordinates"))); -// projectionPanel.setVisible(false); - - JPanel projectionSubPanel = new JPanel(); - projectionSubPanel.setLayout(new BoxLayout(projectionSubPanel, BoxLayout.X_AXIS)); - - projectionSubPanel.add(new JLabel(tr("Projection:"))); - projectionSubPanel.add(this.projectionCombo); - projectionSubPanel.add(this.projectionPreferencesButton); - this.projectionPreferencesButton.setEnabled(false); // ToDo: disabled do avoid bugs - - c.gridx = 0; c.gridy = 0; c.gridwidth = 3; - projectionPanel.add(projectionSubPanel, c); - - c.gridx = 0; c.gridy = 1; c.gridwidth = 2; - projectionPanel.add(new JLabel(tr("Bottom left (min) corner:")), c); - c.gridx = 0; c.gridy = 2; c.gridwidth = 1; - projectionPanel.add(new JLabel(tr("PDF X and Y")), c); - c.gridx = 1; c.gridy = 2; c.gridwidth = 1; - projectionPanel.add(new JLabel(tr("East and North")), c); - c.gridx = 0; c.gridy = 3; c.gridwidth = 1; - projectionPanel.add(this.minXField, c); - c.gridx = 0; c.gridy = 4; c.gridwidth = 1; - projectionPanel.add(this.minYField, c); - c.gridx = 1; c.gridy = 3; c.gridwidth = 1; - projectionPanel.add(this.minEastField, c); - c.gridx = 1; c.gridy = 4; c.gridwidth = 1; - projectionPanel.add(this.minNorthField, c); - c.gridx = 0; c.gridy = 5; c.gridwidth = 1; - projectionPanel.add(this.getMinButton, c); - - - c.gridx = 0; c.gridy = 6; c.gridwidth = 2; - projectionPanel.add(new JLabel(tr("Top right (max) corner:")), c); - c.gridx = 0; c.gridy = 7; c.gridwidth = 1; - projectionPanel.add(new JLabel(tr("PDF X and Y")), c); - c.gridx = 1; c.gridy = 7; c.gridwidth = 1; - projectionPanel.add(new JLabel(tr("East and North")), c); - c.gridx = 0; c.gridy = 8; c.gridwidth = 1; - projectionPanel.add(this.maxXField, c); - c.gridx = 0; c.gridy = 9; c.gridwidth = 1; - projectionPanel.add(this.maxYField, c); - c.gridx = 1; c.gridy = 8; c.gridwidth = 1; - projectionPanel.add(this.maxEastField, c); - c.gridx = 1; c.gridy = 9; c.gridwidth = 1; - projectionPanel.add(this.maxNorthField, c); - c.gridx = 0; c.gridy = 10; c.gridwidth = 1; - projectionPanel.add(this.getMaxButton, c); - - okCancelPanel = new JPanel(new FlowLayout()); -// okCancelPanel.setVisible(false); - okCancelPanel.add(this.cancelButton); - okCancelPanel.add(this.showButton); - okCancelPanel.add(this.okButton); - okCancelPanel.add(this.saveButton); - - JPanel panel = new JPanel(new GridBagLayout()); - c.gridx = 0; c.gridy = 0; c.gridwidth = 1; - panel.add(configPanel, c); - c.gridx = 0; c.gridy = 1; c.gridwidth = 1; c.fill = GridBagConstraints.HORIZONTAL; - panel.add(loadFileButton, c); - c.gridx = 0; c.gridy = 2; c.gridwidth = 1; - panel.add(projectionPanel, c); - c.gridx = 0; c.gridy = 3; c.gridwidth = 1; - panel.add(okCancelPanel, c); - c.gridx = 0; c.gridy = 4; c.gridwidth = 1; c.anchor = GridBagConstraints.NORTH; c.fill = GridBagConstraints.HORIZONTAL; - panel.add(this.loadProgress, c); - - this.setSize(450, 550); - this.setContentPane(panel); - if (PdfImportPlugin.Preferences.guiMode == PdfImportPlugin.GuiMode.Simple) { - loadFileButton.setVisible(false); - configPanel.setVisible(false); - saveButton.setVisible(false); - showButton.setVisible(false); - } - } - - private class ProjectionSubPrefsDialog extends JDialog { - private final ProjectionChoice projPref; - private OKAction actOK; - private CancelAction actCancel; - private JPanel projPrefPanel; - - ProjectionSubPrefsDialog(Component parent, ProjectionChoice pr) { - super(JOptionPane.getFrameForComponent(parent), ModalityType.DOCUMENT_MODAL); - - projPref = pr; - - setTitle(tr("Projection Preferences")); - setDefaultCloseOperation(DISPOSE_ON_CLOSE); - - build(); - } - - protected void makeButtonRespondToEnter(SideButton btn) { - btn.setFocusable(true); - btn.getInputMap(JComponent.WHEN_FOCUSED).put(KeyStroke.getKeyStroke(KeyEvent.VK_ENTER, 0), "enter"); - btn.getActionMap().put("enter", btn.getAction()); - } - - protected JPanel buildInputForm() { - return projPref.getPreferencePanel(null); - } - - protected JPanel buildButtonRow() { - JPanel pnl = new JPanel(new FlowLayout()); - - actOK = new OKAction(); - actCancel = new CancelAction(); - - SideButton btn; - pnl.add(btn = new SideButton(actOK)); - makeButtonRespondToEnter(btn); - pnl.add(btn = new SideButton(actCancel)); - makeButtonRespondToEnter(btn); - return pnl; - } - - protected void build() { - projPrefPanel = buildInputForm(); - getContentPane().setLayout(new BorderLayout()); - getContentPane().add(projPrefPanel, BorderLayout.CENTER); - getContentPane().add(buildButtonRow(), BorderLayout.SOUTH); - pack(); - - // make dialog respond to ESCAPE - getRootPane().getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT).put( - KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE, 0), "escape"); - getRootPane().getActionMap().put("escape", actCancel); - } - - class OKAction extends AbstractAction { - OKAction() { - putValue(NAME, tr("OK")); - putValue(SHORT_DESCRIPTION, tr("Close the dialog and apply projection preferences")); - putValue(SMALL_ICON, ImageProvider.get("ok")); - } - - @Override - public void actionPerformed(ActionEvent e) { - projPref.setPreferences(projPref.getPreferences(projPrefPanel)); - setVisible(false); - } - } - - class CancelAction extends AbstractAction { - CancelAction() { - putValue(NAME, tr("Cancel")); - putValue(SHORT_DESCRIPTION, tr("Close the dialog, discard projection preference changes")); - putValue(SMALL_ICON, ImageProvider.get("cancel")); - } - - @Override - public void actionPerformed(ActionEvent e) { - setVisible(false); - } - } - - @Override - public void setVisible(boolean visible) { - if (visible) { - new WindowGeometry( - getClass().getName() + ".geometry", - WindowGeometry.centerOnScreen(new Dimension(400, 300))).applySafe(this); - } else if (isShowing()) { // Avoid IllegalComponentStateException like in #8775 - new WindowGeometry(this).remember(getClass().getName() + ".geometry"); - } - super.setVisible(visible); - } - } - - private void updateProjectionPrefButton() { -// ProjectionChoice proj = (ProjectionChoice) projectionCombo.getSelectedItem(); - - //TODO - // Enable/disable pref button -// if(!(proj instanceof ProjectionSubPrefs)) { -// projectionPreferencesButton.setEnabled(false); -// } else { - projectionPreferencesButton.setEnabled(true); -// } - } - - private void checkCoords(JTextField x, JTextField y) { - int splitpos = 0; - String eastVal = x.getText().trim(); - if ((splitpos = eastVal.indexOf(';')) >= 0) { - // Split a coordinate into its parts for easy of data entry - y.setText(eastVal.substring(splitpos + 1).trim()); - x.setText(eastVal.substring(0, splitpos).trim()); - } - doublelistener.check(x); - doublelistener.check(y); - } - - private void showProjectionPreferences() { - ProjectionChoice proj = (ProjectionChoice) projectionCombo.getSelectedItem(); - - ProjectionSubPrefsDialog dlg = new ProjectionSubPrefsDialog(this, proj); - dlg.setVisible(true); - - } - - private void loadFilePressed() { - final File newFileName = this.chooseFile(); - - if (newFileName == null) { - return; - } - Logging.debug("PdfImport: Load Preview"); - this.removeLayer(); - - this.loadFileButton.setEnabled(false); - this.loadFileButton.setText(tr("Loading...")); - - this.runAsBackgroundTask( - new Runnable() { - @Override - public void run() { - //async part - LoadPdfDialog.this.loadProgress.setVisible(true); - SwingRenderingProgressMonitor monitor = new SwingRenderingProgressMonitor(progressRenderer); - monitor.beginTask("Loading file", 1000); - data = loadPDF(newFileName, monitor.createSubTaskMonitor(500, false)); - OsmBuilder.Mode mode = LoadPdfDialog.this.debugModeCheck.isSelected() ? OsmBuilder.Mode.Debug : OsmBuilder.Mode.Draft; -// OsmBuilder.Mode mode = Logging.isDebugEnabled() ? OsmBuilder.Mode.Debug : OsmBuilder.Mode.Draft; - - if (data != null) { - LoadPdfDialog.this.newLayer = LoadPdfDialog.this.makeLayer( - tr("PDF preview: ") + newFileName.getName(), new FilePlacement(), mode, monitor.createSubTaskMonitor(500, false)); - } - - monitor.finishTask(); - progressRenderer.finish(); - } - }, - new ActionListener() { - - @Override - public void actionPerformed(ActionEvent e) { - //sync part - if (data != null) { - LoadPdfDialog.this.placeLayer(newLayer, new FilePlacement()); - pdfFile = newFileName; - newLayer = null; - LoadPdfDialog.this.loadFileButton.setText(tr("Preview") + ": " + LoadPdfDialog.this.pdfFile.getName()); - LoadPdfDialog.this.loadFileButton.setEnabled(true); - FilePlacement placement = LoadPdfDialog.this.loadPlacement(pdfFile); - LoadPdfDialog.this.setPlacement(placement); - } - } - }); - } - - private FilePlacement preparePlacement() { - FilePlacement placement = this.parsePlacement(); - if (placement == null) { - return null; - } - - String transformError = placement.prepareTransform(); - if (transformError != null) { - JOptionPane.showMessageDialog(Main.parent, transformError); - return null; - } - - this.savePlacement(placement); - - return placement; - } - - private void okPressed() { - - final FilePlacement placement = preparePlacement(); - if (placement == null) { - return; - } - Logging.debug("PdfImport: Import"); - this.removeLayer(); - - this.runAsBackgroundTask( - new Runnable() { - @Override - public void run() { - //async part - LoadPdfDialog.this.loadProgress.setVisible(true); - SwingRenderingProgressMonitor monitor = new SwingRenderingProgressMonitor(progressRenderer); - LoadPdfDialog.this.newLayer = LoadPdfDialog.this.makeLayer( - tr("PDF: ") + pdfFile.getName(), placement, OsmBuilder.Mode.Final, monitor); - progressRenderer.finish(); - } - }, - new ActionListener() { - - @Override - public void actionPerformed(ActionEvent e) { - //sync part - //rebuild layer with latest projection - LoadPdfDialog.this.placeLayer(newLayer, placement); - LoadPdfDialog.this.setVisible(false); - } - }); - } - - private void savePressed() { - - final FilePlacement placement = preparePlacement(); - if (placement == null) { - return; - } - - final java.io.File file = this.chooseSaveFile(); - - if (file == null) { - return; - } - - this.removeLayer(); - - this.runAsBackgroundTask( - new Runnable() { - @Override - public void run() { - //async part - SwingRenderingProgressMonitor monitor = new SwingRenderingProgressMonitor(progressRenderer); - LoadPdfDialog.this.saveLayer(file, placement, monitor); - progressRenderer.finish(); - } - }, - new ActionListener() { - - @Override - public void actionPerformed(ActionEvent e) { - //sync part - LoadPdfDialog.this.setVisible(false); - } - }); - } - - private void showPressed() { - - FilePlacement placement = preparePlacement(); - if (placement == null) { - return; - } - - //zoom to new location - MainApplication.getMap().mapView.zoomTo(placement.getWorldBounds(this.data)); - MainApplication.getMap().repaint(); - } - - private void cancelPressed() { - this.removeLayer(); - this.setVisible(false); - } - - private void getMinPressed() { - EastNorth en = this.getSelectedCoor(); - - if (en != null) { - this.minXField.setText(Double.toString(en.east())); - this.minYField.setText(Double.toString(en.north())); - } - } - - private void getMaxPressed() { - EastNorth en = this.getSelectedCoor(); - - if (en != null) { - this.maxXField.setText(Double.toString(en.east())); - this.maxYField.setText(Double.toString(en.north())); - } - } - - // Implementation methods - - private EastNorth getSelectedCoor() { - Collection selected = MainApplication.getLayerManager().getEditDataSet().getSelected(); - - if (selected.size() != 1 || !(selected.iterator().next() instanceof Node)) { - JOptionPane.showMessageDialog(Main.parent, tr("Please select exactly one node.")); - return null; - } - - LatLon ll = ((Node) selected.iterator().next()).getCoor(); - FilePlacement pl = new FilePlacement(); - return pl.reverseTransform(ll); - } - - private static JFileChooser loadChooser = null; - - private java.io.File chooseFile() { - //get PDF file to load - if (loadChooser == null) { - loadChooser = new JFileChooser(PdfImportPlugin.Preferences.LoadDir); - loadChooser.setAcceptAllFileFilterUsed(false); - loadChooser.setMultiSelectionEnabled(false); - loadChooser.setFileFilter(new FileFilter() { - @Override - public boolean accept(java.io.File pathname) { - return pathname.isDirectory() || pathname.getName().endsWith(".pdf"); - } - - @Override - public String getDescription() { - return tr("PDF files"); - } - }); - } else { - loadChooser.rescanCurrentDirectory(); - } - int result = loadChooser.showDialog(this, tr("Preview")); - if (result != JFileChooser.APPROVE_OPTION) { - return null; - } else { - return loadChooser.getSelectedFile(); - } - } - - private java.io.File chooseSaveFile() { - //get file name - JFileChooser fc = new JFileChooser(); - fc.setAcceptAllFileFilterUsed(true); - fc.setMultiSelectionEnabled(false); - fc.setFileFilter(new FileFilter() { - @Override - public boolean accept(java.io.File pathname) { - return pathname.isDirectory() || pathname.getName().endsWith(".osm"); - } - - @Override - public String getDescription() { - return tr("OSM files"); - } - }); - int result = fc.showOpenDialog(Main.parent); - - if (result != JFileChooser.APPROVE_OPTION) { - return null; - } else { - return fc.getSelectedFile(); - } - } - - private void runAsBackgroundTask(final Runnable task, final ActionListener after) { - this.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR)); - Thread t = new Thread(new Runnable() { - @Override - public void run() { - task.run(); - - SwingUtilities.invokeLater(new Runnable() { - @Override - public void run() { - setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR)); - after.actionPerformed(null); - } - }); - } - }); - t.start(); - } - - private PathOptimizer loadPDF(File fileName, ProgressMonitor monitor) { - - monitor.beginTask("", 100); - monitor.setTicks(0); - monitor.setCustomText(tr("Preparing")); - - double nodesTolerance = 0.0; - Color color = null; - int maxPaths = Integer.MAX_VALUE; - - if (this.mergeCloseNodesCheck.isSelected()) { - try { - nodesTolerance = Double.parseDouble(this.mergeCloseNodesTolerance.getText()); - } catch (Exception e) { - JOptionPane - .showMessageDialog( - Main.parent, - tr("Tolerance is not a number")); - return null; - } - } - - if (this.colorFilterCheck.isSelected()) { - try { - String colString = this.colorFilterColor.getText().replace("#", ""); - color = new Color(Integer.parseInt(colString, 16)); - } catch (Exception e) { - JOptionPane - .showMessageDialog( - Main.parent, - tr("Could not parse color")); - return null; - } - } - - if (this.limitPathCountCheck.isSelected()) { - try { - maxPaths = Integer.parseInt(this.limitPathCount.getText()); - } catch (Exception e) { - JOptionPane - .showMessageDialog( - Main.parent, - tr("Could not parse max path count")); - return null; - } - } - - - monitor.setTicks(10); - monitor.setCustomText(tr("Parsing file")); - - PathOptimizer data = new PathOptimizer(nodesTolerance, color, this.splitOnColorChangeCheck.isSelected()); - - try { - PdfBoxParser parser = new PdfBoxParser(data); - parser.parse(fileName, maxPaths, monitor.createSubTaskMonitor(80, false)); - - } catch (FileNotFoundException e1) { - JOptionPane - .showMessageDialog( - Main.parent, - tr("File not found.")); - return null; - } catch (Exception e) { - e.printStackTrace(); - JOptionPane - .showMessageDialog( - Main.parent, - tr("Error while parsing: {0}", e.getMessage())); - return null; - } - - monitor.setTicks(80); - - if (this.removeParallelSegmentsCheck.isSelected()) { - try { - double tolerance = Double.parseDouble(this.removeParallelSegmentsTolerance.getText()); - monitor.setCustomText(tr("Removing parallel segments")); - data.removeParallelLines(tolerance); - } catch (Exception e) { - JOptionPane - .showMessageDialog( - Main.parent, - tr("Max distance is not a number")); - return null; - } - } - - if (nodesTolerance > 0.0) { - monitor.setTicks(83); - monitor.setCustomText(tr("Joining nodes")); - data.mergeNodes(); - } - - monitor.setTicks(85); - monitor.setCustomText(tr("Joining adjacent segments")); - data.mergeSegments(); - - if (this.removeSmallObjectsCheck.isSelected()) { - try { - double tolerance = Double.parseDouble(this.removeSmallObjectsSize.getText()); - monitor.setTicks(90); - monitor.setCustomText(tr("Removing small objects")); - - data.removeSmallObjects(tolerance); - } catch (Exception e) { - JOptionPane - .showMessageDialog( - Main.parent, - tr("Tolerance is not a number")); - return null; - } - } - - if (this.removeLargeObjectsCheck.isSelected()) { - try { - double tolerance = Double.parseDouble(this.removeLargeObjectsSize.getText()); - monitor.setTicks(90); - monitor.setCustomText(tr("Removing large objects")); - data.removeLargeObjects(tolerance); - } catch (Exception e) { - JOptionPane - .showMessageDialog( - Main.parent, - tr("Tolerance is not a number")); - return null; - } - } - - monitor.setTicks(95); - monitor.setCustomText(tr("Finalizing layers")); - data.splitLayersByPathKind( - this.splitOnShapeClosedCheck.isSelected(), - this.splitOnSingleSegmentCheck.isSelected(), - this.splitOnOrthogonalCheck.isSelected()); - data.finish(); - - monitor.finishTask(); - return data; - } - - private FilePlacement parsePlacement() { - ProjectionChoice selectedProjection = (ProjectionChoice) this.projectionCombo.getSelectedItem(); - - if (selectedProjection == null) { - JOptionPane.showMessageDialog(Main.parent, tr("Please set a projection.")); - return null; - } - - FilePlacement placement = new FilePlacement(); - - placement.projection = selectedProjection.getProjection(); - - try { - placement.setPdfBounds( - Double.parseDouble(this.minXField.getText()), - Double.parseDouble(this.minYField.getText()), - Double.parseDouble(this.maxXField.getText()), - Double.parseDouble(this.maxYField.getText())); - placement.setEastNorthBounds( - Double.parseDouble(this.minEastField.getText()), - Double.parseDouble(this.minNorthField.getText()), - Double.parseDouble(this.maxEastField.getText()), - Double.parseDouble(this.maxNorthField.getText())); - } catch (Exception e) { - JOptionPane.showMessageDialog(Main.parent, tr("Could not parse numbers. Please check.")); - return null; - } - - return placement; - } - - private void setPlacement(FilePlacement placement) { - - if (placement == null) { - //use default values. - placement = new FilePlacement(); - } - - if (placement.projection != null) { - String projectionCode = placement.projection.toCode(); - BIG_LOOP: - for (ProjectionChoice projectionChoice: ProjectionPreference.getProjectionChoices()) { - for (String code: projectionChoice.allCodes()) { - if (code.equals(projectionCode)) { - projectionChoice.getPreferencesFromCode(projectionCode); - this.projectionCombo.setSelectedItem(projectionChoice); - break BIG_LOOP; - } - } - } - } - - this.minXField.setText(Double.toString(placement.minX)); - this.maxXField.setText(Double.toString(placement.maxX)); - this.minYField.setText(Double.toString(placement.minY)); - this.maxYField.setText(Double.toString(placement.maxY)); - this.minEastField.setText(Double.toString(placement.minEast)); - this.maxEastField.setText(Double.toString(placement.maxEast)); - this.minNorthField.setText(Double.toString(placement.minNorth)); - this.maxNorthField.setText(Double.toString(placement.maxNorth)); - projectionPanel.setEnabled(true); - okCancelPanel.setEnabled(true);; - this.showButton.setEnabled(true); - this.saveButton.setEnabled(true); - this.okButton.setEnabled(true); - this.getMaxButton.setEnabled(true); - this.getMinButton.setEnabled(true); - } - - private FilePlacement loadPlacement(File BaseFile) { - FilePlacement pl = null; - //load saved transformation - File propertiesFile = new File(BaseFile.getAbsoluteFile() + ".placement"); - try { - - if (propertiesFile.exists()) { - pl = new FilePlacement(); - Properties p = new Properties(); - p.load(new FileInputStream(propertiesFile)); - pl.fromProperties(p); - } - } catch (Exception e) { - pl = null; - e.printStackTrace(); - } - - return pl; - } - - private void savePlacement(FilePlacement pl) { - //load saved transformation - File propertiesFile = new File(pdfFile.getAbsoluteFile()+ ".placement"); - try { - Properties p = pl.toProperties(); - p.store(new FileOutputStream(propertiesFile), "PDF file placement on OSM"); - } catch (Exception e) { - e.printStackTrace(); - } - } - - private OsmDataLayer makeLayer(String name, FilePlacement placement, OsmBuilder.Mode mode, ProgressMonitor monitor) { - monitor.beginTask(tr("Building JOSM layer"), 100); - OsmBuilder builder = new OsmBuilder(placement); - DataSet data = builder.build(this.data.getLayers(), mode, monitor.createSubTaskMonitor(50, false)); - monitor.setTicks(50); - monitor.setCustomText(tr("Postprocessing layer")); - OsmDataLayer result = new OsmDataLayer(data, name, null); - data.setUploadPolicy(UploadPolicy.BLOCKED); - result.setUploadDiscouraged(true); - result.setBackgroundLayer(true); - result.onPostLoadFromFile(); - - monitor.finishTask(); - return result; - } - - private void placeLayer(OsmDataLayer _layer, FilePlacement placement) { - this.removeLayer(); - this.layer = _layer; - MainApplication.getLayerManager().addLayer(this.layer); - MainApplication.getMap().mapView.zoomTo(placement.getWorldBounds(this.data)); - } - - private void removeLayer() { - if (this.layer != null) { - MainApplication.getLayerManager().removeLayer(this.layer); - this.layer.data.clear(); //saves memory - this.layer = null; - } -// projectionPanel.setVisible(false); -// okCancelPanel.setVisible(false); -// loadProgress.setVisible(false); - this.showButton.setEnabled(false); - this.saveButton.setEnabled(false); - this.okButton.setEnabled(false); - this.getMaxButton.setEnabled(false); - this.getMinButton.setEnabled(false); - - } - - private void saveLayer(java.io.File file, FilePlacement placement, ProgressMonitor monitor) { - monitor.beginTask(tr("Saving to file."), 1000); - - OsmBuilder builder = new OsmBuilder(placement); - DataSet data = builder.build(this.data.getLayers(), OsmBuilder.Mode.Final, monitor.createSubTaskMonitor(500, false)); - OsmDataLayer layer = new OsmDataLayer(data, file.getName(), file); - - monitor.setCustomText(tr(" Writing to file")); - monitor.setTicks(500); - - OsmExporter exporter = new OsmExporter(); - - try { - exporter.exportData(file, layer); - } catch (IOException e) { - Logging.error(e); - } - - monitor.finishTask(); - } + String colString = this.configPanel.colorFilterColor.getText().replace("#", ""); + color = new Color(Integer.parseInt(colString, 16)); + } catch (Exception e) { + JOptionPane.showMessageDialog(Main.parent, tr("Could not parse color")); + return null; + } + } + + if (configPanel.limitPathCountCheck.getValue() && configPanel.limitPathCount.isDataValid()) { + maxPaths = configPanel.limitPathCount.getValue(); + } + + monitor.setTicks(10); + monitor.setCustomText(tr("Parsing file")); + + PathOptimizer data = new PathOptimizer(nodesTolerance, color, configPanel.splitOnColorChangeCheck.getValue()); + + try { + PdfBoxParser parser = new PdfBoxParser(data); + parser.parse(fileName, maxPaths, monitor.createSubTaskMonitor(80, false)); + + } catch (FileNotFoundException e1) { + JOptionPane.showMessageDialog(Main.parent, tr("File not found.")); + return null; + } catch (Exception e) { + e.printStackTrace(); + JOptionPane.showMessageDialog(Main.parent, tr("Error while parsing: {0}", e.getMessage())); + return null; + } + + monitor.setTicks(80); + + if (configPanel.removeParallelSegmentsCheck.getValue() && configPanel.removeParallelSegmentsTolerance.isDataValid()) { + double tolerance = configPanel.removeParallelSegmentsTolerance.getValue(); + monitor.setCustomText(tr("Removing parallel segments")); + } + + if (nodesTolerance > 0.0) { + monitor.setTicks(83); + monitor.setCustomText(tr("Joining nodes")); + data.mergeNodes(); + } + + monitor.setTicks(85); + monitor.setCustomText(tr("Joining adjacent segments")); + data.mergeSegments(); + + if (configPanel.removeSmallObjectsCheck.getValue() && configPanel.removeSmallObjectsSize.isDataValid()) { + double tolerance = configPanel.removeSmallObjectsSize.getValue(); + monitor.setTicks(90); + monitor.setCustomText(tr("Removing small objects")); + + data.removeSmallObjects(tolerance); + + } + + if (configPanel.removeLargeObjectsCheck.getValue() && configPanel.removeLargeObjectsSize.isDataValid()) { + double tolerance = configPanel.removeLargeObjectsSize.getValue(); + monitor.setTicks(90); + monitor.setCustomText(tr("Removing large objects")); + data.removeLargeObjects(tolerance); + } + + monitor.setTicks(95); + monitor.setCustomText(tr("Finalizing layers")); + data.splitLayersByPathKind(configPanel.splitOnShapeClosedCheck.getValue(), + configPanel.splitOnSingleSegmentCheck.getValue(), + configPanel.splitOnOrthogonalCheck.getValue()); + data.finish(); + + monitor.finishTask(); + return data; + } + + private OsmDataLayer makeLayer(String name, FilePlacement placement, OsmBuilder.Mode mode, + ProgressMonitor monitor) { + /* + * create a layer from data + */ + monitor.beginTask(tr("Building JOSM layer"), 100); + OsmBuilder builder = new OsmBuilder(placement); + DataSet data = builder.build(pdfData.getLayers(), mode, monitor.createSubTaskMonitor(50, false)); + data.setUploadPolicy(UploadPolicy.BLOCKED); + monitor.setTicks(50); + monitor.setCustomText(tr("Postprocessing layer")); + OsmDataLayer result = new OsmDataLayer(data, name, null); + result.setUploadDiscouraged(true); + result.setBackgroundLayer(true); + result.onPostLoadFromFile(); + + monitor.finishTask(); + return result; + } + + private void placeLayer(OsmDataLayer _layer, FilePlacement placement) { + /* + * + */ + removeLayer(); + dataLayer = _layer; + MainApplication.getLayerManager().addLayer(dataLayer); + MainApplication.getMap().mapView.zoomTo(placement.getWorldBounds(pdfData)); + } + + private void removeLayer() { + /* + * remove preview layer + */ + if (dataLayer != null) { + MainApplication.getLayerManager().removeLayer(dataLayer); + dataLayer.data.clear(); // saves memory + dataLayer = null; + } + // No layer ==> no actions + actionPanel.showButton.setEnabled(false); + actionPanel.saveButton.setEnabled(false); + actionPanel.okButton.setEnabled(false); + placementPanel.setEnabled(false); + + } + + private void saveLayer(java.io.File file, FilePlacement placement, ProgressMonitor monitor) { + /* + * save layer to file + * TODO: is this methode valuable? Functionality can easily performed from Main-Menu + */ + monitor.beginTask(tr("Saving to file."), 1000); + + OsmBuilder builder = new OsmBuilder(placement); + DataSet data = builder.build(this.pdfData.getLayers(), OsmBuilder.Mode.Final, + monitor.createSubTaskMonitor(500, false)); + OsmDataLayer layer = new OsmDataLayer(data, file.getName(), file); + + monitor.setCustomText(tr(" Writing to file")); + monitor.setTicks(500); + + OsmExporter exporter = new OsmExporter(); + + try { + exporter.exportData(file, layer); + } catch (IOException e) { + Logging.error(e); + } + + monitor.finishTask(); + } } Index: applications/editors/josm/plugins/pdfimport/src/pdfimport/PdfImportAction.java =================================================================== --- applications/editors/josm/plugins/pdfimport/src/pdfimport/PdfImportAction.java (revision 34397) +++ applications/editors/josm/plugins/pdfimport/src/pdfimport/PdfImportAction.java (revision 34398) @@ -33,4 +33,7 @@ //show dialog asking to select coordinate axes and input coordinates and projection. + /* + * TODO: make dialog reusable + */ LoadPdfDialog dialog = new LoadPdfDialog(); dialog.setAlwaysOnTop(true); Index: applications/editors/josm/plugins/pdfimport/src/pdfimport/PdfImportPlugin.java =================================================================== --- applications/editors/josm/plugins/pdfimport/src/pdfimport/PdfImportPlugin.java (revision 34397) +++ applications/editors/josm/plugins/pdfimport/src/pdfimport/PdfImportPlugin.java (revision 34398) @@ -4,7 +4,10 @@ import org.openstreetmap.josm.gui.MainApplication; import org.openstreetmap.josm.gui.MainMenu; +import org.openstreetmap.josm.gui.preferences.PreferenceSetting; +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.plugins.Plugin; import org.openstreetmap.josm.plugins.PluginInformation; -import org.openstreetmap.josm.spi.preferences.Config; /** @@ -14,77 +17,39 @@ public class PdfImportPlugin extends Plugin { - public enum GuiMode { - Auto, Expert, Simple - }; - - public static class Preferences { - - public static String LoadDir; - public static GuiMode guiMode; - public static boolean MergeNodes; - public static double MergeNodesValue; - public static boolean RemoveSmall; - public static double RemoveSmallValue; - public static boolean RemoveLarge; - public static double RemoveLargeValue; - public static boolean RemoveParallel; - public static double RemoveParallelValue; - public static boolean LimitPath; - public static int LimitPathValue; - public static boolean LimitColor; - public static String LimitColorValue; - public static boolean DebugTags; - public static boolean LayerClosed; - public static boolean LayerSegment; - public static boolean LayerAttribChange; - public static boolean LayerOrtho; - - protected static int GuiCode; - - private static String PreFix; - - private Preferences() { - return; - } - - public static void reload(String Name) { - Preferences.PreFix = Name + "."; - Preferences.LoadDir = Config.getPref().get(Preferences.PreFix + "loadDir"); - Preferences.GuiCode = Config.getPref().getInt(Preferences.PreFix + "GuiCode",0 ); - switch (Preferences.GuiCode) { - case 1: - Preferences.guiMode = GuiMode.Expert; - break; - case 2: - Preferences.guiMode = GuiMode.Simple; - break; - default: - Preferences.guiMode = GuiMode.Expert; - } - Preferences.MergeNodes = Config.getPref().getBoolean(Preferences.PreFix + "MergeNodes"); - Preferences.MergeNodesValue = Config.getPref().getDouble(Preferences.PreFix + "MergeNodes.Value", 1e-3); - Preferences.RemoveSmall = Config.getPref().getBoolean(Preferences.PreFix + "RemoveSmall"); - Preferences.RemoveSmallValue = Config.getPref().getDouble(Preferences.PreFix + "RemoveSmall.Value", 1); - Preferences.RemoveLarge = Config.getPref().getBoolean(Preferences.PreFix + "RemoveLarge"); - Preferences.RemoveLargeValue = Config.getPref().getDouble(Preferences.PreFix + "RemoveLarge.Value", 10); - Preferences.RemoveParallel = Config.getPref().getBoolean(Preferences.PreFix + "RemoveParallel"); - Preferences.RemoveParallelValue = Config.getPref().getDouble(Preferences.PreFix + "RemoveParalle.Value", 3); - Preferences.LimitPath = Config.getPref().getBoolean(Preferences.PreFix + "LimitPath"); - Preferences.LimitPathValue = Config.getPref().getInt(Preferences.PreFix + "LimitPath.Value", 10000); - Preferences.LimitColor = Config.getPref().getBoolean(Preferences.PreFix + "LimitColor"); - Preferences.LimitColorValue = Config.getPref().get(Preferences.PreFix + "LimitColor.Value","#000000"); - Preferences.DebugTags = Config.getPref().getBoolean(Preferences.PreFix + "DebugTags"); - Preferences.LayerClosed = Config.getPref().getBoolean(Preferences.PreFix + "LayerClosed"); - Preferences.LayerSegment = Config.getPref().getBoolean(Preferences.PreFix + "LayerSegment"); - Preferences.LayerAttribChange = Config.getPref().getBoolean(Preferences.PreFix + "LayerAttribChanges"); - Preferences.LayerOrtho = Config.getPref().getBoolean(Preferences.PreFix + "LayerOrtho"); - } - } public PdfImportPlugin(PluginInformation info) { super(info); MainMenu.add(MainApplication.getMenu().imagerySubMenu, new PdfImportAction()); - Preferences.reload(this.getPluginInformation().name); + new Preferences(getPluginInformation().name); } + public class pdfimportPrefs implements SubPreferenceSetting + { + @Override + public TabPreferenceSetting getTabPreferenceSetting(PreferenceTabbedPane gui) + { + return null; + } + + @Override + public void addGui(PreferenceTabbedPane gui) { + return; + } + + @Override + public boolean ok() { + return false; + } + + @Override + public boolean isExpert() { + return false; + } + } + + @Override + public PreferenceSetting getPreferenceSetting() { + return new pdfimportPrefs(); + } + } Index: applications/editors/josm/plugins/pdfimport/src/pdfimport/Preferences.java =================================================================== --- applications/editors/josm/plugins/pdfimport/src/pdfimport/Preferences.java (revision 34398) +++ applications/editors/josm/plugins/pdfimport/src/pdfimport/Preferences.java (revision 34398) @@ -0,0 +1,122 @@ +/** + * License: GPL. For details, see LICENSE file. + */ +package pdfimport; + +import org.openstreetmap.josm.spi.preferences.Config; + +public class Preferences { + + public enum GuiMode { + Auto, Expert, Simple + }; + + public static String getLoadDir() { + return Config.getPref().get(Preferences.prefix + "loadDir"); + } + + public static void setLoadDir(String loadDir) { + Config.getPref().put(Preferences.prefix + "loadDir", loadDir); + } + + public static GuiMode getGuiMode() { + int GuiCode = Config.getPref().getInt(Preferences.prefix + "guiCode", 0); + switch (GuiCode) { + case -1: + case 1: + return GuiMode.Expert; + case 2: + return GuiMode.Simple; + default: + if (Config.getPref().getBoolean("expert")) + return GuiMode.Expert; + else + return GuiMode.Simple; + } + } + + public static boolean isLegacyActions() { + return (Config.getPref().getInt(Preferences.prefix + "guiCode", 0) == -1); + } + + public static boolean isMergeNodes() { + return Config.getPref().getBoolean(Preferences.prefix + "mergeNodes"); + } + + public static double getMergeNodesValue() { + return Config.getPref().getDouble(Preferences.prefix + "mergeNodes.value", 1e-3); + } + + public static boolean isRemoveSmall() { + return Config.getPref().getBoolean(Preferences.prefix + "removeSmall"); + } + + public static double getRemoveSmallValue() { + return Config.getPref().getDouble(Preferences.prefix + "removeSmall.value", 1); + } + + public static boolean isRemoveLarge() { + return Config.getPref().getBoolean(Preferences.prefix + "removeLarge"); + } + + public static double getRemoveLargeValue() { + return Config.getPref().getDouble(Preferences.prefix + "removeLarge.value", 10); + } + + public static boolean isRemoveParallel() { + return Config.getPref().getBoolean(Preferences.prefix + "removeParallel"); + } + + public static double getRemoveParallelValue() { + return Config.getPref().getDouble(Preferences.prefix + "removeParallel.value", 3); + } + + public static boolean isLimitPath() { + return Config.getPref().getBoolean(Preferences.prefix + "limitPath"); + } + + public static int getLimitPathValue() { + return Config.getPref().getInt(Preferences.prefix + "limitPath.value", Integer.MAX_VALUE); + } + + public static boolean isLimitColor() { + return Config.getPref().getBoolean(Preferences.prefix + "limitColor"); + } + + public static String getLimitColorValue() { + return Config.getPref().get(Preferences.prefix + "limitColor.value","#000000"); + } + + public static boolean isDebugTags() { + return Config.getPref().getBoolean(Preferences.prefix + "debugTags"); + } + + public static boolean isLayerClosed() { + return Config.getPref().getBoolean(Preferences.prefix + "layerClosed"); + } + + public static boolean isLayerSegment() { + return Config.getPref().getBoolean(Preferences.prefix + "layerSegment"); + } + + public static boolean isLayerAttribChange() { + return Config.getPref().getBoolean(Preferences.prefix + "layerAttribChanges"); + } + + public static boolean isLayerOrtho() { + return Config.getPref().getBoolean(Preferences.prefix + "layerOrtho"); + } + + protected static int GuiCode; + + private static String prefix; + + private Preferences() { + return; + } + + public Preferences (String p) { + prefix = p + "." ; + } + +} Index: applications/editors/josm/plugins/pdfimport/src/pdfimport/ProjectionInfo.java =================================================================== --- applications/editors/josm/plugins/pdfimport/src/pdfimport/ProjectionInfo.java (revision 34397) +++ applications/editors/josm/plugins/pdfimport/src/pdfimport/ProjectionInfo.java (revision 34398) @@ -2,5 +2,4 @@ package pdfimport; -import java.util.Collection; import java.util.HashMap; import java.util.Map; @@ -9,4 +8,5 @@ import org.openstreetmap.josm.gui.preferences.projection.ProjectionChoice; import org.openstreetmap.josm.gui.preferences.projection.ProjectionPreference; +import org.openstreetmap.josm.gui.preferences.projection.SingleProjectionChoice; public final class ProjectionInfo { @@ -27,13 +27,15 @@ public static Projection getProjectionByCode(String code) { - Projection p = allCodes.get(code); - if (p != null) return p; - ProjectionChoice pc = allCodesPC.get(code); - if (pc == null) return null; - Collection pref = pc.getPreferencesFromCode(code); - pc.setPreferences(pref); - p = pc.getProjection(); - allCodes.put(code, p); - return p; + return new SingleProjectionChoice(code.toString(), code.toString(), code).getProjection() ; + +// Projection p = allCodes.get(code); +// if (p != null) return p; +// ProjectionChoice pc = allCodesPC.get(code); +// if (pc == null) return null; +// Collection pref = pc.getPreferencesFromCode(code); +// pc.setPreferences(pref); +// p = pc.getProjection(); +// allCodes.put(code, p); +// return p; } }