Ignore:
Timestamp:
2010-02-18T13:37:21+01:00 (15 years ago)
Author:
guggis
Message:

'Tageditor plugin cleaned up'

Location:
applications/editors/josm/plugins/tageditor
Files:
4 added
1 deleted
21 edited
2 copied
9 moved

Legend:

Unmodified
Added
Removed

  • applications/editors/josm/plugins/tageditor/build.xml

    r19587 r20058  
    2828
    2929
    30         <property name="commit.message" value="Fixed NPE when icon is missing" />
    31         <property name="plugin.main.version" value="2830" />
     30        <property name="commit.message" value="Tageditor plugin cleaned up" />
     31        <property name="plugin.main.version" value="3015" />
    3232
    3333        <!--

  • applications/editors/josm/plugins/tageditor/src/org/openstreetmap/josm/plugins/tageditor/LaunchAction.java

    r15319 r20058  
    33import static org.openstreetmap.josm.tools.I18n.tr;
    44
    5 import java.awt.Component;
    6 import java.awt.Dimension;
    7 import java.awt.GraphicsConfiguration;
    8 import java.awt.Point;
    9 import java.awt.Rectangle;
    10 import java.awt.Window;
    115import java.awt.event.ActionEvent;
    126import java.awt.event.KeyEvent;
    … …  
    2519import org.openstreetmap.josm.tools.Shortcut;
    2620
    27 @SuppressWarnings("serial")
    2821public class LaunchAction extends JosmAction implements SelectionChangedListener {
    2922
    … …  
    6861                );
    6962
    70 
    71                 // register as dataset selection listener
    72                 //
    7363                DataSet.selListeners.add(this);
    74 
    75                 // insert a menu item
    76                 //
    7764                registerAsMenuItem();
    78 
    79                 // initially not enabled; becomes enabled when the selection becomes non-empty
    80                 //
    8165                setEnabled(false);
    82 
    83         }
    84 
    85         /**
    86          *
    87          * @return  the top window of the JOSM GUI; can be null
    88          */
    89         protected Window getTopWindow() {
    90                 if (Main.contentPane == null)
    91                         return null;
    92                 Component c = Main.contentPane;
    93                 while(c.getParent() != null) {
    94                         c = c.getParent();
    95                 }
    96                 if (c instanceof Window)
    97                         return (Window)c;
    98                 else
    99                         return null;
    100         }
    101 
    102         /**
    103          * tries to center the tag editor dialog on the top window or, alternatively,
    104          * on the screen
    105          *
    106          * @param dialog the dialog to be placed on the screen
    107          */
    108         protected void placeDialogOnScreen(TagEditorDialog dialog) {
    109                 Window w = getTopWindow();
    110                 if (w == null)
    111                         // don't center
    112                         return;
    113 
    114                 GraphicsConfiguration gc = w.getGraphicsConfiguration();
    115                 Rectangle screenBounds = null;
    116                 if (gc != null) {
    117                         screenBounds = gc.getBounds();
    118                 }
    119                 Rectangle winBounds = w.getBounds();
    120                 Dimension d = dialog.getPreferredSize();
    121 
    122                 Point p = new Point();
    123                 if (d.width <= winBounds.width && d.height <= winBounds.height) {
    124                         p.x = winBounds.x + ((winBounds.width - d.width)/2 );
    125                         p.y = winBounds.y + ((winBounds.height - d.height)/2 );
    126                 } else  {
    127                         p.x = screenBounds.x + ((screenBounds.width - d.width)/2 );
    128                         p.y = screenBounds.y + ((screenBounds.height - d.height)/2 );
    129                 }
    130 
    131                 dialog.setLocation(p);
    132 
    13366        }
    13467
    … …  
    14073                        return;
    14174                TagEditorDialog dialog = TagEditorDialog.getInstance();
    142                 placeDialogOnScreen(dialog);
    14375                dialog.startEditSession();
    14476                dialog.setVisible(true);
    … …  
    15284                setEnabled(newSelection != null && newSelection.size() >0);
    15385        }
    154 
    155 
    156 
    157 
    15886}

  • applications/editors/josm/plugins/tageditor/src/org/openstreetmap/josm/plugins/tageditor/TagEditorDialog.java

    r20044 r20058  
    1414import java.beans.PropertyChangeEvent;
    1515import java.beans.PropertyChangeListener;
    16 import java.util.Collection;
    1716import java.util.logging.Logger;
    1817
    … …  
    4342import org.openstreetmap.josm.plugins.tageditor.tagspec.ui.ITagSelectorListener;
    4443import org.openstreetmap.josm.plugins.tageditor.tagspec.ui.TabularTagSelector;
     44import org.openstreetmap.josm.tools.ImageProvider;
     45import org.openstreetmap.josm.tools.WindowGeometry;
    4546/**
    4647 * The dialog for editing name/value-pairs (aka <em>tags</em>) associated with {@link OsmPrimitive}s.
    4748 *
    48  *
    4949 */
    5050@SuppressWarnings("serial")
    5151public class TagEditorDialog extends JDialog {
    52 
    53         static private Logger logger = Logger.getLogger(TagEditorDialog.class.getName());
     52        static private final Logger logger = Logger.getLogger(TagEditorDialog.class.getName());
    5453
    5554        /** the unique instance */
    56         static protected  TagEditorDialog instance = null;
     55        static private  TagEditorDialog instance = null;
    5756
    5857        /**
    … …  
    6867        }
    6968
    70 
    71         /**
    72          * default preferred size
    73          */
     69        /** default preferred size */
    7470        static public final Dimension PREFERRED_SIZE = new Dimension(700, 500);
    75 
    7671
    7772        /** the properties table */
    7873        private TagEditor tagEditor = null;
    79         private TagEditorModel model = null;
    8074
    8175        /**  the auto completion list viewer */
    … …  
    8579        private AutoCompletionCache acCache = null;
    8680
    87         /** widgets */
    88         private JButton btnOK = null;
    89         private JButton btnCancel = null;
    90         private JButton btnAdd = null;
    91         private JButton btnDelete = null;
    9281        private OKAction okAction = null;
    9382        private CancelAction cancelAction = null;
    9483
    95 
    96         public OKAction getOKAction() {
    97                 return okAction;
    98         }
    99 
    10084        /**
    10185         * @return the tag editor model
    10286         */
    10387        public TagEditorModel getModel() {
    104                 return model;
    105         }
    106 
    107 
     88                return tagEditor.getModel();
     89        }
    10890
    10991        protected JPanel buildButtonRow() {
    110                 // create the rows of action buttons at the bottom
    111                 // of the dialog
    112                 //
    113                 JPanel pnl = new JPanel();
    114                 pnl.setLayout(new FlowLayout(FlowLayout.RIGHT));
    115 
     92                JPanel pnl = new JPanel(new FlowLayout(FlowLayout.CENTER));
     93               
    11694                // the ok button
    11795                //
    118                 okAction = new OKAction();
    119                 btnOK = new JButton(okAction);
     96                pnl.add(new JButton(okAction = new OKAction()));
    12097                getModel().addPropertyChangeListener(okAction);
    12198
    12299                // the cancel button
    123100                //
    124                 cancelAction = new CancelAction();
    125                 btnCancel = new JButton(cancelAction);
    126                 pnl.add(btnOK);
    127                 pnl.add(btnCancel);
    128 
    129                 JPanel pnl1 = new JPanel();
    130                 pnl.setLayout(new FlowLayout(FlowLayout.LEFT));
    131 
    132                 // the add button
    133                 //
    134                 btnAdd = new JButton(tagEditor.getAddAction());
    135                 btnDelete = new JButton(tagEditor.getDeleteAction());
    136 
    137                 pnl1.add(btnAdd);
    138                 pnl1.add(btnDelete);
    139 
    140                 JPanel pnl2 = new JPanel();
    141                 pnl2.setLayout(new BorderLayout());
    142                 pnl2.add(pnl1, BorderLayout.WEST);
    143                 pnl2.add(pnl, BorderLayout.EAST);
    144 
    145                 return pnl2;
    146         }
    147 
    148         /**
    149          * build the GUI
    150          */
    151         protected void build() {
    152                 getContentPane().setLayout(new BorderLayout());
    153 
    154                 // basic UI prpoperties
    155                 //
    156                 setModal(true);
    157                 setSize(PREFERRED_SIZE);
    158                 setTitle(tr("JOSM Tag Editor Plugin"));
    159 
    160 
     101                pnl.add(new JButton(cancelAction  = new CancelAction()));
     102                return pnl;
     103        }
     104
     105        protected JPanel buildTagGridPanel() {
    161106                // create tag editor and inject an instance of the tag
    162107                // editor model
    163108                //
    164109                tagEditor = new TagEditor();
    165                 tagEditor.setTagEditorModel(model);
    166 
    167 
     110               
    168111                // create the auto completion list viewer and connect it
    169112                // to the tag editor
    … …  
    174117                tagEditor.setAutoCompletionCache(acCache);
    175118                aclViewer.addAutoCompletionListListener(tagEditor);
     119                tagEditor.addComponentNotStoppingCellEditing(aclViewer);
    176120
    177121                JPanel pnlTagGrid = new JPanel();
    178122                pnlTagGrid.setLayout(new BorderLayout());
     123               
     124               
    179125                pnlTagGrid.add(tagEditor, BorderLayout.CENTER);
    180126                pnlTagGrid.add(aclViewer, BorderLayout.EAST);
    181127                pnlTagGrid.setBorder(BorderFactory.createEmptyBorder(5, 0,0,0));
    182 
     128               
     129                JSplitPane splitPane = new JSplitPane(
     130                                JSplitPane.HORIZONTAL_SPLIT,
     131                                tagEditor,
     132                                aclViewer
     133                );
     134                splitPane.setOneTouchExpandable(false);
     135                splitPane.setDividerLocation(600);             
     136                pnlTagGrid.add(splitPane, BorderLayout.CENTER);
     137                return pnlTagGrid;
     138        }
     139               
     140        /**
     141         * build the GUI
     142         */
     143        protected void build() {
     144                getContentPane().setLayout(new BorderLayout());
     145
     146                // basic UI prpoperties
     147                //
     148                setModal(true);
     149                setSize(PREFERRED_SIZE);
     150                setTitle(tr("JOSM Tag Editor Plugin"));
     151               
     152                JPanel pnlTagGrid = buildTagGridPanel();
    183153
    184154                // create the preset selector
    … …  
    189159                                        public void itemSelected(Item item) {
    190160                                                tagEditor.stopEditing();
    191                                                 model.applyPreset(item);
     161                                                tagEditor.getModel().applyPreset(item);
    192162                                                tagEditor.requestFocusInTopLeftCell();
    193163                                        }
    194164                                }
    195165                );
    196 
    197166
    198167                JPanel pnlPresetSelector = new JPanel();
    … …  
    208177                                        public void itemSelected(KeyValuePair pair) {
    209178                                                tagEditor.stopEditing();
    210                                                 model.applyKeyValuePair(pair);
     179                                                tagEditor.getModel().applyKeyValuePair(pair);
    211180                                                tagEditor.requestFocusInTopLeftCell();
    212181                                        }
    … …  
    218187                pnlTagSelector.setBorder(BorderFactory.createEmptyBorder(0,0,5,0        ));
    219188
    220 
    221 
    222 
    223189                // create the tabbed pane
    224190                //
    … …  
    227193                tabbedPane.add(pnlTagSelector, tr("Tags"));
    228194
     195               
    229196                // create split pane
    230197                //
    231                 JSplitPane splitPane = new JSplitPane(JSplitPane.VERTICAL_SPLIT,
    232                                 tabbedPane, pnlTagGrid);
     198                JSplitPane splitPane = new JSplitPane(
     199                                JSplitPane.VERTICAL_SPLIT,
     200                                tabbedPane,
     201                                pnlTagGrid
     202                );
    233203                splitPane.setOneTouchExpandable(true);
    234204                splitPane.setDividerLocation(200);
    … …  
    258228                );
    259229
    260 
    261230                // makes sure that 'Ctrl-Enter' in the properties table
    262231                // and in the aclViewer is handled by okAction
    … …  
    279248        }
    280249
    281 
    282 
    283250        /**
    284251         * constructor
    285252         */
    286253        protected TagEditorDialog() {
    287                 acCache = new AutoCompletionCache();
    288                 model = new TagEditorModel();
     254                acCache = new AutoCompletionCache();   
    289255                build();
    290256        }
    291257
    292 
    293         @Override
    294         public Dimension getPreferredSize() {
    295                 return PREFERRED_SIZE;
    296         }
    297 
    298 
     258    @Override
     259    public void setVisible(boolean visible) {
     260        if (visible) {
     261            new WindowGeometry(
     262                    getClass().getName() + ".geometry",
     263                    WindowGeometry.centerInWindow(
     264                            Main.parent,
     265                            PREFERRED_SIZE
     266                    )
     267            ).applySafe(this);
     268        } else if (!visible && isShowing()){
     269            new WindowGeometry(this).remember(getClass().getName() + ".geometry");
     270        }
     271        super.setVisible(visible);
     272    }
    299273
    300274        /**
    … …  
    304278         */
    305279        public void startEditSession() {
    306                 model.clearAppliedPresets();
    307                 model.initFromJOSMSelection();
     280                tagEditor.getModel().clearAppliedPresets();
     281                tagEditor.getModel().initFromJOSMSelection();
    308282                //acCache.initFromJOSMDataset();
    309283                getModel().ensureOneTag();
    310284        }
    311285
    312 
    313 
    314         @SuppressWarnings("serial")
    315286        class CancelAction extends AbstractAction {
    316 
    317287                public CancelAction() {
    318                         putValue(Action.NAME, tr("Cancel"));
    319                         putValue(Action.ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE,0));
     288                        putValue(NAME, tr("Cancel"));
     289                        putValue(SMALL_ICON, ImageProvider.get("cancel"));
     290                        putValue(ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE,0));
     291                        putValue(SHORT_DESCRIPTION, tr("Abort tag editing and close dialog"));
    320292                }
    321293
    … …  
    325297        }
    326298
    327 
    328 
    329         @SuppressWarnings("serial")
    330299        class OKAction extends AbstractAction implements PropertyChangeListener {
    331300
    332301                public OKAction() {
    333                         putValue(Action.NAME, tr("OK"));
    334                         putValue(Action.ACCELERATOR_KEY, KeyStroke.getKeyStroke("ctrl ENTER"));
     302                        putValue(NAME, tr("OK"));
     303                        putValue(SMALL_ICON, ImageProvider.get("ok"));
     304                        putValue(SHORT_DESCRIPTION, tr("Apply edited tags and close dialog"));
     305                        putValue(ACCELERATOR_KEY, KeyStroke.getKeyStroke("ctrl ENTER"));
    335306                }
    336307
    … …  
    342313                        tagEditor.stopEditing();
    343314                        setVisible(false);
    344                         model.updateJOSMSelection();
     315                        tagEditor.getModel().updateJOSMSelection();
    345316                        DataSet ds = Main.main.getCurrentDataSet();
    346317                        ds.fireSelectionChanged();

  • applications/editors/josm/plugins/tageditor/src/org/openstreetmap/josm/plugins/tageditor/ac/AutoCompletionContext.java

    r20045 r20058  
    22
    33import org.openstreetmap.josm.Main;
    4 
    54
    65public class AutoCompletionContext {
    … …  
    2019                selectionEmpty = (Main.main.getCurrentDataSet().getSelected().size() == 0);
    2120        }
    22 
    2321
    2422        public boolean isSelectionEmpty() {
    … …  
    4947                this.selectionIncludesRelations = selectionIncludesRelations;
    5048        }
    51 
    52 
    53 
    54 
    5549}

  • applications/editors/josm/plugins/tageditor/src/org/openstreetmap/josm/plugins/tageditor/ac/AutoCompletionListRenderer.java

    r15319 r20058  
    11package org.openstreetmap.josm.plugins.tageditor.ac;
    22
    3 import java.awt.Color;
    43import java.awt.Component;
     4import java.awt.Font;
     5import java.net.URL;
    56
    67import javax.swing.Icon;
    … …  
    89import javax.swing.JLabel;
    910import javax.swing.JTable;
     11import javax.swing.UIManager;
    1012import javax.swing.table.TableCellRenderer;
     13import org.openstreetmap.josm.gui.tagging.ac.AutoCompletionListItem;
     14import org.openstreetmap.josm.gui.tagging.ac.AutoCompletionItemPritority;
     15import static org.openstreetmap.josm.tools.I18n.tr;
    1116
    1217/**
    1318 * This is the table cell renderer for the list of auto completion list items.
    1419 *
    15  * It uses an instance of {@Link JLabel} to render an {@link AutoCompletionListItem}.
    16  *
    17  *
    1820 */
    19 public class AutoCompletionListRenderer implements TableCellRenderer {
    20 
     21public class AutoCompletionListRenderer extends JLabel implements TableCellRenderer {
    2122
    2223        static public final String RES_OSM_ICON = "/resources/osm.gif";
    2324        static public final String RES_SELECTION_ICON = "/resources/selection.gif";
    24         public static final Color BG_COLOR_SELECTED = new Color(143,170,255);
    25 
    26         /** the renderer component */
    27         private final JLabel renderer;
    2825
    2926        /** the icon used to decorate items of priority
    … …  
    4138         */
    4239        public AutoCompletionListRenderer() {
    43                 renderer = new JLabel();
    44                 renderer.setOpaque(true);
    45 
     40                setOpaque(true);
    4641                loadIcons();
    4742        }
    … …  
    5146         */
    5247        protected void loadIcons() {
    53                 java.net.URL imgURL = getClass().getResource(RES_OSM_ICON);
     48                URL imgURL = getClass().getResource(RES_OSM_ICON);
    5449                if (imgURL != null) {
    5550                        iconStandard = new ImageIcon(imgURL);
    … …  
    6863        }
    6964
    70 
    7165        /**
    7266         * prepares the renderer for rendering a specific icon
    … …  
    7771                if (item.getPriority().equals(AutoCompletionItemPritority.IS_IN_STANDARD)) {
    7872                        if (iconStandard != null) {
    79                                 renderer.setIcon(iconStandard);
     73                                setIcon(iconStandard);
    8074                        }
    8175                } else if (item.getPriority().equals(AutoCompletionItemPritority.IS_IN_SELECTION)) {
    8276                        if (iconSelection != null) {
    83                                 renderer.setIcon(iconSelection);
     77                                setIcon(iconSelection);
    8478                        }
    8579                }
    … …  
    9084         */
    9185        protected void resetRenderer() {
    92                 renderer.setIcon(null);
    93                 renderer.setText("");
    94                 renderer.setOpaque(true);
    95                 renderer.setBackground(Color.WHITE);
    96                 renderer.setForeground(Color.BLACK);
     86                setIcon(null);
     87                setText("");
     88                setFont(UIManager.getFont("Table.font"));
     89                setOpaque(true);
     90                setBackground(UIManager.getColor("Table.background"));
     91                setForeground(UIManager.getColor("Table.foreground"));
    9792        }
    9893
    … …  
    10196         */
    10297        protected void renderSelected() {
    103                 renderer.setBackground(BG_COLOR_SELECTED);
    104                 renderer.setForeground(Color.WHITE);
     98                setBackground(UIManager.getColor("Table.selectionBackground"));
     99                setForeground(UIManager.getColor("Table.selectionForeground"));
    105100        }
    106101
    … …  
    114109                        AutoCompletionListItem item = (AutoCompletionListItem)value;
    115110                        prepareRendererIcon(item);
    116                         renderer.setText(item.getValue());
     111                        setText(item.getValue());
     112                        setToolTipText(item.getValue());
    117113                } else if (value != null) {
    118                         renderer.setText(value.toString());
     114                        setText(value.toString());
     115                        setToolTipText(value.toString());
    119116                } else {
    120                         renderer.setText("<null>");
     117                        setText(tr("unknown"));
     118                        setFont(getFont().deriveFont(Font.ITALIC));
    121119                }
    122120
    … …  
    126124                        renderSelected();
    127125                }
    128 
    129 
    130                 return renderer;
    131 
     126                return this;
    132127        }
    133 
    134 
    135 
    136128}

  • applications/editors/josm/plugins/tageditor/src/org/openstreetmap/josm/plugins/tageditor/ac/AutoCompletionListViewer.java

    r20044 r20058  
    4141                setLayout(new BorderLayout());
    4242       
    43                
    4443                table = new JTable();
    4544               

  • applications/editors/josm/plugins/tageditor/src/org/openstreetmap/josm/plugins/tageditor/editor/PresetItemListCellRenderer.java

    r15319 r20058  
    33import static org.openstreetmap.josm.tools.I18n.tr;
    44
    5 import java.awt.Color;
    65import java.awt.Component;
    7 import java.awt.Font;
    86import java.util.logging.Logger;
    97
    … …  
    119import javax.swing.JList;
    1210import javax.swing.ListCellRenderer;
     11import javax.swing.UIManager;
    1312
    1413import org.openstreetmap.josm.plugins.tageditor.preset.Item;
    1514
    16 public class PresetItemListCellRenderer extends JLabel implements
    17 ListCellRenderer {
    18 
     15public class PresetItemListCellRenderer extends JLabel implements ListCellRenderer {
    1916        private static final Logger logger = Logger.getLogger(PresetItemListCellRenderer.class.getName());
    20         private static final Font DEFAULT_FONT =  new Font("SansSerif",Font.PLAIN,10);
    21         public static final Color BG_COLOR_SELECTED = new Color(143,170,255);
    2217
    2318        public Component getListCellRendererComponent(JList list, Object value,
    … …  
    3025                } else {
    3126                        if (isSelected) {
    32                                 setBackground(BG_COLOR_SELECTED);
     27                                setBackground(UIManager.getColor("Table.selectionBackground"));
     28                                setForeground(UIManager.getColor("Table.selectionForeground"));
    3329                        } else {
    34                                 setBackground(Color.WHITE);
     30                                setBackground(UIManager.getColor("Table.background"));
     31                                setForeground(UIManager.getColor("Table.foreground"));
    3532                        }
    3633                        setIcon(item.getIcon());
    … …  
    4138                        setText(sb.toString());
    4239                        setOpaque(true);
    43                         setFont(DEFAULT_FONT);
     40                        setFont(UIManager.getFont("Table.font"));
    4441                }
    4542                return this;
    4643        }
    47 
    4844}

  • applications/editors/josm/plugins/tageditor/src/org/openstreetmap/josm/plugins/tageditor/editor/PresetManager.java

    r15319 r20058  
    1919public class PresetManager extends JPanel {
    2020
    21         static private Logger logger = Logger.getLogger(PresetManager.class.getName());
     21        static private final Logger logger = Logger.getLogger(PresetManager.class.getName());
    2222
    2323        private JComboBox presets;
    … …  
    9999                this.model = model;
    100100        }
    101 
    102 
    103 
    104101}

  • applications/editors/josm/plugins/tageditor/src/org/openstreetmap/josm/plugins/tageditor/editor/TableCellRenderer.java

    r20045 r20058  
    99import java.util.logging.Logger;
    1010
    11 import javax.swing.BorderFactory;
    12 import javax.swing.ImageIcon;
    1311import javax.swing.JLabel;
    1412import javax.swing.JTable;
    15 import javax.swing.border.Border;
     13import javax.swing.UIManager;
    1614import javax.swing.border.EmptyBorder;
    1715
     16import org.openstreetmap.josm.gui.tagging.TagModel;
    1817import org.openstreetmap.josm.plugins.tageditor.preset.Item;
    1918import org.openstreetmap.josm.plugins.tageditor.preset.Tag;
    … …  
    2928       
    3029        private static Logger logger = Logger.getLogger(TableCellRenderer.class.getName());
    31        
    32         public static final Color BG_COLOR_SELECTED = new Color(143,170,255);
    3330        public static final Color BG_COLOR_HIGHLIGHTED = new Color(255,255,204);
    34        
    35         public static final Border BORDER_EMPHASIZED = BorderFactory.createLineBorder(new Color(253,75,45));
    36        
    37         /** the icon displayed for deleting a tag */
    38         private ImageIcon deleteIcon = null;
    39        
     31               
    4032        private Font fontStandard = null;
    4133        private Font fontItalic = null;
    … …  
    7062                        setText(tag.getValues().get(0));
    7163                } else if (tag.getValueCount() >  1) {
    72                         setText(tr("<multiple>"));
     64                        setText(tr("multiple"));
    7365                        setFont(fontItalic);
    7466                }
    7567        }
    76        
    77        
    7868       
    7969        /**
    … …  
    121111        }
    122112       
    123        
    124113        /**
    125114         * renders the background color. The default color is white. It is
    … …  
    132121         */
    133122        protected void renderBackgroundColor(TagModel tagModel, TagEditorModel model) {
    134                 setBackground(Color.WHITE); // standard color
     123                setBackground(UIManager.getColor("Table.background"));
    135124                if (belongsToSelectedPreset(tagModel, model)) {
    136125                        setBackground(BG_COLOR_HIGHLIGHTED);
    137126                }
    138127        }
    139        
    140 
    141128       
    142129        /**
    … …  
    154141        public Component getTableCellRendererComponent(JTable table, Object value,
    155142            boolean isSelected, boolean hasFocus, int rowIndex, int vColIndex) {
     143               
    156144                resetRenderer();
    157145               
    … …  
    159147                //
    160148                if (isSelected){
    161                         setBackground(BG_COLOR_SELECTED);
     149                        setBackground(UIManager.getColor("Table.selectionBackground"));
     150                        setForeground(UIManager.getColor("Table.selectionForeground"));
    162151                } else {
    163                         renderBackgroundColor(getModel(table).get(rowIndex), getModel(table));
     152                        setBackground(UIManager.getColor("Table.background"));
     153                        setForeground(UIManager.getColor("Table.foreground"));
    164154                }
    165                
    166155
     156                TagModel tagModel  = (TagModel)value;
    167157                switch(vColIndex) {
    168                         case 0: renderTagName((TagModel)value); break;
    169                         case 1: renderTagValue((TagModel)value); break;
    170                        
    171                         default: throw new RuntimeException("unexpected index in switch statement");   
     158                        case 0: renderTagName(tagModel); break;
     159                        case 1: renderTagValue(tagModel); break;
    172160                }
     161                renderBackgroundColor(tagModel, (TagEditorModel)table.getModel());
    173162                if (hasFocus && isSelected) {
    174163                        if (table.getSelectedColumnCount() == 1 && table.getSelectedRowCount() == 1) {
    175                                 boolean success = table.editCellAt(rowIndex, vColIndex);
    176 
    177164                                if (table.getEditorComponent() != null) {
    178165                                        table.getEditorComponent().requestFocusInWindow();
    … …  
    182169                return this;
    183170        }
    184 
    185 
    186171}

  • applications/editors/josm/plugins/tageditor/src/org/openstreetmap/josm/plugins/tageditor/editor/TagEditor.java

    r20044 r20058  
    22
    33import java.awt.BorderLayout;
     4import java.awt.Component;
     5import java.awt.GridBagConstraints;
     6import java.awt.GridBagLayout;
     7import java.awt.Insets;
    48import java.util.logging.Logger;
    59
     10import javax.swing.BoxLayout;
     11import javax.swing.DefaultListSelectionModel;
     12import javax.swing.JButton;
    613import javax.swing.JPanel;
    714import javax.swing.JScrollPane;
    8 import javax.swing.ScrollPaneConstants;
    9 
    10 import org.openstreetmap.josm.gui.dialogs.relation.RunnableAction;
     15import javax.swing.table.TableCellEditor;
     16
    1117import org.openstreetmap.josm.gui.tagging.TagTable;
    1218import org.openstreetmap.josm.gui.tagging.ac.AutoCompletionCache;
    … …  
    5258        private static final Logger logger = Logger.getLogger(TagEditor.class.getName());
    5359
    54         private final TagEditorModel tagEditorModel;
     60        private TagEditorModel tagEditorModel;
    5561        private TagTable tblTagEditor;
    5662        private PresetManager presetManager;
    57         private AutoCompletionList autoCompletionList;
    58 
    59 
     63       
     64         /**
     65     * builds the panel with the button row
     66     *
     67     * @return the panel
     68     */
     69    protected JPanel buildButtonsPanel() {
     70        JPanel pnl = new JPanel();
     71        pnl.setLayout(new BoxLayout(pnl, BoxLayout.Y_AXIS));
     72
     73        // add action
     74        JButton btn;
     75        pnl.add(btn = new JButton(tblTagEditor.getAddAction()));
     76        btn.setMargin(new Insets(0,0,0,0));
     77        tblTagEditor.addComponentNotStoppingCellEditing(btn);
     78
     79        // delete action
     80        pnl.add(btn = new JButton(tblTagEditor.getDeleteAction()));
     81        btn.setMargin(new Insets(0,0,0,0));
     82        tblTagEditor.addComponentNotStoppingCellEditing(btn);
     83        return pnl;
     84    }
     85   
     86    public void addComponentNotStoppingCellEditing(Component c) {
     87        tblTagEditor.addComponentNotStoppingCellEditing(c);
     88    }
     89   
     90    /**
     91     * builds the GUI
     92     */
     93    protected JPanel buildTagEditorPanel() {
     94        JPanel pnl = new JPanel(new GridBagLayout());
     95
     96                DefaultListSelectionModel rowSelectionModel = new DefaultListSelectionModel();
     97                DefaultListSelectionModel colSelectionModel = new DefaultListSelectionModel();
     98               
     99                tagEditorModel = new TagEditorModel(rowSelectionModel,colSelectionModel);
     100               
     101                // build the scrollable table for editing tag names and tag values
     102                //
     103                tblTagEditor = new TagTable(tagEditorModel, rowSelectionModel, colSelectionModel);
     104                tblTagEditor.setTagCellEditor(new TagSpecificationAwareTagCellEditor());
     105                TableCellRenderer renderer = new TableCellRenderer();
     106                tblTagEditor.getColumnModel().getColumn(0).setCellRenderer(renderer);
     107                tblTagEditor.getColumnModel().getColumn(1).setCellRenderer(renderer);
     108
     109                final JScrollPane scrollPane = new JScrollPane(tblTagEditor);
     110                JPanel pnlTagTable = new JPanel(new BorderLayout());
     111                pnlTagTable.add(scrollPane, BorderLayout.CENTER);
     112
     113        GridBagConstraints gc = new GridBagConstraints();
     114
     115        // -- buttons panel
     116        //
     117        gc.fill = GridBagConstraints.VERTICAL;
     118        gc.weightx = 0.0;
     119        gc.weighty = 1.0;
     120        gc.anchor = GridBagConstraints.NORTHWEST;
     121        pnl.add(buildButtonsPanel(),gc);
     122
     123        // -- the panel with the editor table
     124        //
     125        gc.gridx = 1;
     126        gc.fill = GridBagConstraints.BOTH;
     127        gc.weightx = 1.0;
     128        gc.weighty = 1.0;
     129        gc.anchor = GridBagConstraints.CENTER;
     130        pnl.add(pnlTagTable,gc);
     131       
     132        return pnl;
     133    }
     134   
    60135        /**
    61136         * builds the GUI
    … …  
    64139        protected void build() {
    65140                setLayout(new BorderLayout());
    66 
    67                 // build the scrollable table for editing tag names and tag values
    68                 //
    69                 tblTagEditor = new TagTable(tagEditorModel);
    70                 final JScrollPane scrollPane = new JScrollPane(tblTagEditor);
    71                 scrollPane.setHorizontalScrollBarPolicy(ScrollPaneConstants.HORIZONTAL_SCROLLBAR_AS_NEEDED);
    72                 scrollPane.setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED);
    73                 add(scrollPane, BorderLayout.CENTER);
    74 
    75                 // this adapters ensures that the width of the tag table columns is adjusted
    76                 // to the width of the scroll pane viewport. Also tried to overwrite
    77                 // getPreferredViewportSize() in JTable, but did not work.
    78                 //
    79 //              scrollPane.addComponentListener(
    80 //                              new ComponentAdapter() {
    81 //                                      @Override public void componentResized(ComponentEvent e) {
    82 //                                              super.componentResized(e);
    83 //                                              Dimension d = scrollPane.getViewport().getExtentSize();
    84 //                                              tblTagEditor.adjustColumnWidth(d.width);
    85 //                                      }
    86 //                              }
    87 //              );
     141               
     142                add(buildTagEditorPanel(), BorderLayout.CENTER);
    88143
    89144                // build the preset manager which shows a list of applied presets
    … …  
    94149        }
    95150
    96 
    97151        /**
    98152         * constructor
    99153         */
    100154        public TagEditor() {
    101                 // creates a default model and a default cache
    102                 //
    103                 tagEditorModel = new TagEditorModel();
    104 
    105155                build();
    106156        }
    107 
    108157
    109158        /**
    … …  
    114163                return tagEditorModel;
    115164        }
    116 
    117         /**
    118          * sets the tag editor model
    119          *
    120          * @param tagEditorModel the tag editor model
    121          */
    122         public void setTagEditorModel(TagEditorModel tagEditorModel) {
    123                 tblTagEditor.setModel(tagEditorModel);
    124                 for (int i=0; i<=1; i++) {
    125                         TableCellEditor editor = (TableCellEditor)tblTagEditor.getColumnModel().getColumn(i).getCellEditor();
    126                         if (editor != null) {
    127                                 editor.setTagEditorModel(tagEditorModel);
    128                         }
    129                 }
    130                 presetManager.setModel(tagEditorModel);
    131         }
    132 
    133         public RunnableAction getDeleteAction() {
    134                 return tblTagEditor.getDeleteAction();
    135         }
    136 
    137         public RunnableAction getAddAction() {
    138                 return tblTagEditor.getAddAction();
    139         }
    140 
     165       
    141166        public void clearSelection() {
    142167                tblTagEditor.getSelectionModel().clearSelection();
    … …  
    144169
    145170        public void stopEditing() {
    146                 TableCellEditor editor = (TableCellEditor) tblTagEditor.getCellEditor();
     171                TableCellEditor editor = tblTagEditor.getCellEditor();
    147172                if (editor != null) {
    148173                        editor.stopCellEditing();
    149174                }
    150175        }
    151 
    152         public AutoCompletionList getAutoCompletionList() {
    153                 return null;
    154                 //return ((org.openstreetmap.josm.gui.tagging.TagCellEditor)tblTagEditor.getCellEditor()).getAutoCompletionList();
    155         }
    156 
     176       
    157177        public void setAutoCompletionList(AutoCompletionList autoCompletionList) {
    158178                tblTagEditor.setAutoCompletionList(autoCompletionList);
    … …  
    164184
    165185        public void autoCompletionItemSelected(String item) {
    166                 org.openstreetmap.josm.plugins.tageditor.editor.TableCellEditor editor = ((org.openstreetmap.josm.plugins.tageditor.editor.TableCellEditor)tblTagEditor.getCellEditor());
     186                logger.info("autocompletion item selected ...");
     187                TagSpecificationAwareTagCellEditor editor = (TagSpecificationAwareTagCellEditor)tblTagEditor.getCellEditor();
    167188                if (editor != null) {
    168189                        editor.autoCompletionItemSelected(item);
    … …  
    173194                tblTagEditor.requestFocusInCell(0,0);
    174195        }
     196       
     197        public TagEditorModel getModel() {
     198                return tagEditorModel;
     199        }
    175200}

  • applications/editors/josm/plugins/tageditor/src/org/openstreetmap/josm/plugins/tageditor/editor/old/AutoCompletionCache.java

    r20045 r20058  
    1 package org.openstreetmap.josm.plugins.tageditor.ac;
     1package org.openstreetmap.josm.plugins.tageditor.editor.old;
    22
    33import java.util.ArrayList;

  • applications/editors/josm/plugins/tageditor/src/org/openstreetmap/josm/plugins/tageditor/editor/old/AutoCompletionItemPritority.java

    r20045 r20058  
    11// License: GPL. For details, see LICENSE file.
    2 package org.openstreetmap.josm.plugins.tageditor.ac;
     2package org.openstreetmap.josm.plugins.tageditor.editor.old;
    33
    44public enum AutoCompletionItemPritority implements Comparable<AutoCompletionItemPritority> {

  • applications/editors/josm/plugins/tageditor/src/org/openstreetmap/josm/plugins/tageditor/editor/old/AutoCompletionList.java

    r20045 r20058  
    1 package org.openstreetmap.josm.plugins.tageditor.ac;
     1package org.openstreetmap.josm.plugins.tageditor.editor.old;
    22
    33import java.util.ArrayList;
    … …  
    77import javax.swing.JTable;
    88import javax.swing.table.AbstractTableModel;
     9
    910
    1011/**

  • applications/editors/josm/plugins/tageditor/src/org/openstreetmap/josm/plugins/tageditor/editor/old/AutoCompletionListItem.java

    r20055 r20058  
    11// License: GPL. For details, see LICENSE file.
    2 package org.openstreetmap.josm.plugins.tageditor.ac;
     2package org.openstreetmap.josm.plugins.tageditor.editor.old;
     3
     4import org.openstreetmap.josm.gui.tagging.ac.AutoCompletionItemPritority;
     5
    36
    47/**

  • applications/editors/josm/plugins/tageditor/src/org/openstreetmap/josm/plugins/tageditor/editor/old/RunnableAction.java

    r20045 r20058  
    1 package org.openstreetmap.josm.plugins.tageditor.editor;
     1package org.openstreetmap.josm.plugins.tageditor.editor.old;
    22
    33import java.awt.event.ActionEvent;

  • applications/editors/josm/plugins/tageditor/src/org/openstreetmap/josm/plugins/tageditor/editor/old/TableCellEditor.java

    r20045 r20058  
    11// License: GPL. For details, see LICENSE file.
    2 package org.openstreetmap.josm.plugins.tageditor.editor;
     2package org.openstreetmap.josm.plugins.tageditor.editor.old;
    33
    44import java.awt.Component;
    … …  
    99import javax.swing.JTable;
    1010
    11 import org.openstreetmap.josm.plugins.tageditor.ac.AutoCompletionCache;
    1211import org.openstreetmap.josm.plugins.tageditor.ac.AutoCompletionContext;
    13 import org.openstreetmap.josm.plugins.tageditor.ac.AutoCompletionItemPritority;
    14 import org.openstreetmap.josm.plugins.tageditor.ac.AutoCompletionList;
    15 import org.openstreetmap.josm.plugins.tageditor.ac.AutoCompletionListItem;
    1612import org.openstreetmap.josm.plugins.tageditor.ac.IAutoCompletionListListener;
     13import org.openstreetmap.josm.plugins.tageditor.editor.TagEditorModel;
    1714import org.openstreetmap.josm.plugins.tageditor.tagspec.TagSpecifications;
    1815
    … …  
    7269                //
    7370                try {
    74                         autoCompletionList.add(TagSpecifications.getInstance().getKeysForAutoCompletion(context));
     71                        //autoCompletionList.add(TagSpecifications.getInstance().getKeysForAutoCompletion(context));
    7572                } catch(Exception e) {
    7673                        logger.log(Level.WARNING, "failed to initialize auto completion list with standard keys.", e);
    … …  
    8077                //
    8178                for (String key : acCache.getKeys()) {
    82                         autoCompletionList.add(
    83                                         new AutoCompletionListItem(key, AutoCompletionItemPritority.IS_IN_DATASET)
    84                         );
     79//                      autoCompletionList.add(
     80//                                      new AutoCompletionListItem(key, AutoCompletionItemPritority.IS_IN_DATASET)
     81//                      );
    8582                }
    8683
    … …  
    117114                //
    118115                try {
    119                         autoCompletionList.add(
    120                                         TagSpecifications.getInstance().getLabelsForAutoCompletion(forKey, context)
    121                         );
     116//                      autoCompletionList.add(
     117//                                      TagSpecifications.getInstance().getLabelsForAutoCompletion(forKey, context)
     118//                      );
    122119                } catch(Exception e){
    123120                        logger.log(Level.WARNING, "failed to initialize auto completion list with standard values", e);
    … …  
    125122
    126123                for (String value : acCache.getValues(forKey)) {
    127                         autoCompletionList.add(
    128                                         new AutoCompletionListItem(value, AutoCompletionItemPritority.IS_IN_DATASET)
    129                         );
     124//                      autoCompletionList.add(
     125//                                      new AutoCompletionListItem(value, AutoCompletionItemPritority.IS_IN_DATASET)
     126//                      );
    130127                }
    131128
    … …  
    135132                        for (String value : currentTag.getValues()) {
    136133                                //logger.info("adding ac item " + value + " with priority IN_SELECTION");;
    137                                 autoCompletionList.add(
    138                                                 new AutoCompletionListItem(value, AutoCompletionItemPritority.IS_IN_SELECTION)
    139                                 );
     134//                              autoCompletionList.add(
     135//                                              new AutoCompletionListItem(value, AutoCompletionItemPritority.IS_IN_SELECTION)
     136//                              );
    140137                        }
    141138                }
    … …  
    191188
    192189                if (currentColumn == 0) {
    193                         tagEditorModel.updateTagName(currentTag, editor.getText());
     190                        //tagEditorModel.updateTagName(currentTag, editor.getText());
    194191                } else if (currentColumn == 1){
    195192                        if (currentTag.getValueCount() > 1 && ! editor.getText().equals("")) {
    196                                 tagEditorModel.updateTagValue(currentTag, editor.getText());
     193                                //tagEditorModel.updateTagValue(currentTag, editor.getText());
    197194                        } else if (currentTag.getValueCount() <= 1) {
    198                                 tagEditorModel.updateTagValue(currentTag, editor.getText());
     195                                //tagEditorModel.updateTagValue(currentTag, editor.getText());
    199196                        }
    200197                }

  • applications/editors/josm/plugins/tageditor/src/org/openstreetmap/josm/plugins/tageditor/editor/old/TagFieldEditor.java

    r20045 r20058  
    11// License: GPL. For details, see LICENSE file.
    2 package org.openstreetmap.josm.plugins.tageditor.editor;
     2package org.openstreetmap.josm.plugins.tageditor.editor.old;
    33
    44import java.awt.event.FocusAdapter;
    … …  
    1414import javax.swing.text.PlainDocument;
    1515
    16 import org.openstreetmap.josm.plugins.tageditor.ac.AutoCompletionList;
    1716
    1817

  • applications/editors/josm/plugins/tageditor/src/org/openstreetmap/josm/plugins/tageditor/editor/old/TagModel.java

    r20045 r20058  
    11// License: GPL. For details, see LICENSE file.
    2 package org.openstreetmap.josm.plugins.tageditor.editor;
     2package org.openstreetmap.josm.plugins.tageditor.editor.old;
    33
    44import java.util.ArrayList;

  • applications/editors/josm/plugins/tageditor/src/org/openstreetmap/josm/plugins/tageditor/editor/old/TagTable.java

    r20045 r20058  
    11// License: GPL. For details, see LICENSE file.
    2 package org.openstreetmap.josm.plugins.tageditor.editor;
     2package org.openstreetmap.josm.plugins.tageditor.editor.old;
    33
    44import static org.openstreetmap.josm.tools.I18n.tr;
    … …  
    2929import javax.swing.table.TableModel;
    3030
    31 import org.openstreetmap.josm.plugins.tageditor.ac.AutoCompletionCache;
    32 import org.openstreetmap.josm.plugins.tageditor.ac.AutoCompletionList;
     31import org.openstreetmap.josm.plugins.tageditor.editor.TableCellRenderer;
     32import org.openstreetmap.josm.plugins.tageditor.editor.TagEditorModel;
    3333
    3434/**

  • applications/editors/josm/plugins/tageditor/src/org/openstreetmap/josm/plugins/tageditor/preset/Group.java

    r17637 r20058  
    11package org.openstreetmap.josm.plugins.tageditor.preset;
    22
    3 import java.awt.Image;
    4 import java.io.IOException;
    5 import java.net.URL;
    63import java.util.ArrayList;
    74import java.util.List;
    85import java.util.logging.Logger;
    96
    10 import javax.swing.Icon;
    11 import javax.swing.ImageIcon;
    12 
    13 import org.openstreetmap.josm.Main;
    14 import org.openstreetmap.josm.plugins.tageditor.util.IndentWriter;
    15 
    167/**
    178 * Group represents a named group of preset items. Groups can be nested.
    189 *
    19  *
    2010 */
    21 public class Group implements INameIconProvider {
     11public class Group extends AbstractNameIconProvider {
    2212       
    23         static private Logger logger = Logger.getLogger(Group.class.getName());
     13        static final private Logger logger = Logger.getLogger(Group.class.getName());
    2414       
    25         private String name;
    26         private String iconName;
    27         private ImageIcon icon;
    2815        private List<Item> items = null;
    2916       
    … …  
    3522                this();
    3623                setName(name);
    37         }
    38 
    39         public String getName() {
    40                 return name;
    41         }
    42 
    43         public void setName(String name) {
    44                 this.name = name;
    45         }
    46 
    47         public String getIconName() {
    48                 return iconName;
    49         }
    50 
    51         public void setIconName(String iconName) {
    52                 this.iconName = iconName;
    53         }
    54        
    55         public Icon getIcon() {
    56                 if (icon == null) {
    57                         // load the icon from the JOSM resources, use Main classloader
    58                         // for loading
    59                         URL url = Main.class.getResource("/images/" + getIconName());
    60                         if (url == null) {
    61                                 logger.warning("failed to create URL for resource 'images/" + getIconName() + "'");
    62                                 this.icon = null;
    63                         } else {
    64                                 icon =new ImageIcon(url);
    65                                 Image i = icon.getImage().getScaledInstance(16, 16, Image.SCALE_DEFAULT);
    66                                 icon = new ImageIcon(i);
    67 
    68                         }
    69                 }
    70                 return icon;
    7124        }
    7225       
    … …  
    8336                return items;
    8437        }
    85        
    86         public void dump(IndentWriter writer) throws IOException {
    87                 writer.indent();
    88                 writer.write("<group ");
    89                 writer.write(String.format("name=\"%s\" ", name));
    90                 writer.write(String.format("iconName=\"%s\" ", iconName));
    91                 writer.write(">");
    92                 writer.write("\n");
    93                 writer.incLevel();
    94                 for(Item item: items) {
    95                         item.dump(writer);
    96                 }
    97                 writer.decLevel();
    98                 writer.writeLine("</group>");
    99         }
    10038}

  • applications/editors/josm/plugins/tageditor/src/org/openstreetmap/josm/plugins/tageditor/preset/INameIconProvider.java

    r14326 r20058  
    44
    55public interface INameIconProvider {
    6 
    76        public String getName();
    87        public Icon  getIcon();

  • applications/editors/josm/plugins/tageditor/src/org/openstreetmap/josm/plugins/tageditor/preset/Item.java

    r19587 r20058  
    11package org.openstreetmap.josm.plugins.tageditor.preset;
    22
    3 import java.awt.Image;
    4 import java.io.IOException;
    5 import java.net.URL;
    63import java.util.ArrayList;
    74import java.util.List;
    85import java.util.logging.Logger;
    96
    10 import javax.swing.Icon;
    11 import javax.swing.ImageIcon;
     7public class Item  extends AbstractNameIconProvider {
    128
    13 import org.openstreetmap.josm.Main;
    14 import org.openstreetmap.josm.plugins.tageditor.util.IndentWriter;
     9        private final static Logger logger = Logger.getLogger(Item.class.getName());
    1510
    16 
    17 public class Item  implements INameIconProvider {
    18 
    19         private static Logger logger = Logger.getLogger(Item.class.getName());
    20 
    21         private String name;
    22         private String iconName;
    23         private ImageIcon icon;
    2411        private String label;
    2512        private List<Tag> tags;
    … …  
    3825        }
    3926
    40 
    4127        public String getLabel() {
    4228                return label;
    … …  
    4733        }
    4834
    49 
    5035        public Item(String name) {
    5136                setName(name);
    52         }
    53 
    54         public String getName() {
    55                 return name;
    56         }
    57 
    58         public void setName(String name) {
    59                 this.name = name;
    60         }
    61 
    62         public String getIconName() {
    63                 return iconName;
    64         }
    65 
    66         public void setIconName(String iconName) {
    67                 this.iconName = iconName;
    68         }
    69 
    70         public Icon getIcon() {
    71                 // FIXME: should also load icons from the image paths configured in the
    72                 // preferences for presets
    73                 //
    74                 if (icon == null) {
    75                         // load the icon from the JOSM resources, use Main classloader
    76                         // for loading
    77                         URL url = Main.class.getResource("/images/" + getIconName());
    78                         if (url == null) {
    79                                 logger.warning("failed to create URL for resource 'images/" + getIconName() + "'");
    80                                 return null;
    81                         } else {
    82                                 icon =new ImageIcon(url);
    83                         }               
    84                         Image i = icon.getImage().getScaledInstance(16, 16, Image.SCALE_DEFAULT);
    85                         icon = new ImageIcon(i);
    86 
    87                 }
    88                 return icon;
    8937        }
    9038
    … …  
    9543        public List<Tag> getTags() {
    9644                return tags;
    97         }
    98 
    99         public void dump(IndentWriter writer) throws IOException {
    100                 writer.indent();
    101                 writer.write("<item ");
    102                 writer.write(String.format("name=\"%s\" ", name));
    103                 writer.write(String.format("label=\"%s\" ", label));
    104                 writer.write(String.format("iconName=\"%s\" ", iconName));
    105                 writer.write(">");
    106                 writer.write("\n");
    107                 writer.incLevel();
    108                 for(Tag tag: tags) {
    109                         tag.dump(writer);
    110                 }
    111                 writer.decLevel();
    112                 writer.writeLine("</item>");
    11345        }
    11446

  • applications/editors/josm/plugins/tageditor/src/org/openstreetmap/josm/plugins/tageditor/preset/Presets.java

    r17637 r20058  
    33import static org.openstreetmap.josm.tools.I18n.tr;
    44
     5import java.io.File;
    56import java.io.IOException;
     7import java.io.InputStream;
    68import java.io.InputStreamReader;
    79import java.io.Reader;
    … …  
    2123import org.openstreetmap.josm.plugins.tageditor.preset.io.Parser;
    2224import org.openstreetmap.josm.plugins.tageditor.preset.io.PresetIOException;
    23 import org.openstreetmap.josm.plugins.tageditor.util.IndentWriter;
    2425
    2526public class Presets {
    … …  
    3738                //
    3839                if (Main.pref.getBoolean("taggingpreset.enable-defaults", true)) {
    39                         sources.add("resource://presets/presets.xml");
     40                        sources.add("resource://data/defaultpresets.xml");
    4041                }
    4142                sources.addAll(Main.pref.getCollection("taggingpreset.sources",
    4243                                new LinkedList<String>()));
    4344
     45                File zipIconArchive = null;
    4446                for (String source : sources) {
    45                         logger.log(Level.INFO, String.format(
    46                                         "starting to read presets from source '%1$s'", source));
    4747                        try {
    4848                                MirroredInputStream s = new MirroredInputStream(source);
     49                InputStream zip = s.getZipEntry("xml","preset");
     50                if(zip != null) {
     51                        zipIconArchive = s.getFile();
     52                }
    4953                                InputStreamReader r;
    5054                                try {
    … …  
    5357                                        r = new InputStreamReader(s);
    5458                                }
    55                                 presets = loadPresets(r, presets);
    56 
     59                                presets = loadPresets(r, presets, zipIconArchive);
    5760                        } catch (PresetIOException e) {
    5861                                logger
    … …  
    7780                        con.connect();
    7881                        Reader reader = new InputStreamReader(con.getInputStream());
    79                         return loadPresets(reader, null);
     82                        return loadPresets(reader, null, null);
    8083                } catch (Exception e) {
    8184                        logger.log(Level.SEVERE,
    … …  
    8386                        throw new PresetIOException(e);
    8487                }
    85 
    8688        }
    8789
    88         static public Presets loadPresets(Reader reader, Presets p) throws PresetIOException {
     90        static public Presets loadPresets(Reader reader, Presets p, File zipIconArchive) throws PresetIOException {
    8991                try {
    9092                        Parser parser = new Parser();
    … …  
    120122        }
    121123
    122         public void dump(IndentWriter writer) throws IOException {
    123                 writer.indent();
    124                 writer.write("<presets>\n");
    125                 writer.incLevel();
    126                 for (Group group : groups) {
    127                         group.dump(writer);
    128                 }
    129                 writer.decLevel();
    130                 writer.indent();
    131                 writer.write("</presets>");
    132         }
    133 
    134124        public List<Group> getGroups() {
    135125                return groups;
    136126        }
    137 
    138127}

  • applications/editors/josm/plugins/tageditor/src/org/openstreetmap/josm/plugins/tageditor/preset/Tag.java

    r14326 r20058  
    11package org.openstreetmap.josm.plugins.tageditor.preset;
    2 
    3 import java.io.IOException;
    4 
    5 import org.openstreetmap.josm.plugins.tageditor.util.IndentWriter;
    6 
    72
    83public class Tag {
    … …  
    4641                this.optional = optional;
    4742        }
    48        
    49        
    50         public void dump(IndentWriter writer) throws IOException {
    51                 writer.indent();
    52                 writer.write("<tag ");
    53                 writer.write(String.format("key=\"%s\" ", key));
    54                 writer.write(String.format("optional=\"%s\" ", Boolean.toString(optional)));
    55                 if (value != null) {
    56                         writer.write(String.format("value=\"%s\" ", value));
    57                 }
    58                 writer.write(String.format("displayName=\"%s\" ", displayName));
    59                 writer.write("/>");
    60                 writer.write("\n");
    61         }
    62          
    63        
    64        
    65        
    66 
    6743}

  • applications/editors/josm/plugins/tageditor/src/org/openstreetmap/josm/plugins/tageditor/preset/io/Parser.java

    r17637 r20058  
    11package org.openstreetmap.josm.plugins.tageditor.preset.io;
    22
     3import java.io.File;
    34import java.io.Reader;
    45import java.util.Stack;
    … …  
    2223public class Parser {
    2324       
    24         static private Logger logger = Logger.getLogger(Parser.class.getName());
     25        static final private Logger logger = Logger.getLogger(Parser.class.getName());
     26       
    2527    private Presets presets = null;
    2628        private Reader reader;
    … …  
    2931        private boolean inOptionalKeys = false;
    3032        private XMLReader parser;
     33        private File zipIconArchive;
    3134
    3235        public Parser() {
    … …  
    4952        public Reader getReader() {
    5053                return reader;
     54        }
     55       
     56        public void setZipIconArchive(File zipIconArchive) {
     57                this.zipIconArchive = zipIconArchive;
    5158        }
    5259       
    … …  
    122129        }
    123130       
    124        
    125131        protected String translatedAttributeValue(String attrValue) {
    126132                if (attrValue == null) {
    … …  
    134140                Group g = new Group();
    135141                g.setName(translatedAttributeValue(name));
    136                 g.setIconName(iconName);
     142                g.setIconName(iconName, zipIconArchive);
    137143                currentGroup.push(g);
    138144        }
    … …  
    146152                currentItem = new Item();
    147153                currentItem.setName(translatedAttributeValue(name));
    148                 currentItem.setIconName(iconName);
     154                currentItem.setIconName(iconName, zipIconArchive);
    149155        }
    150156       
    … …  
    238244                                           || "check".equals(qName)) {
    239245                                onTag(getAttribute(atts, "key"), getAttribute(atts, "value"), getAttribute(atts, "text"));
    240                         }
    241                        
     246                        }                       
    242247                }
    243248               

  • applications/editors/josm/plugins/tageditor/src/org/openstreetmap/josm/plugins/tageditor/preset/io/PresetIOException.java

    r14327 r20058  
    2222                // TODO Auto-generated constructor stub
    2323        }
    24 
    25        
    26        
    2724}

  • applications/editors/josm/plugins/tageditor/src/org/openstreetmap/josm/plugins/tageditor/tagspec/TagSpecification.java

    r16574 r20058  
    55
    66import org.openstreetmap.josm.plugins.tageditor.ac.AutoCompletionContext;
    7 
    87
    98/**
    … …  
    6362        }
    6463
    65 
    6664        /**
    6765         * sets the list of lables for this tag specification
    … …  
    7977        }
    8078
    81 
    8279        /**
    83          * adds a lable to the list of lables for this tag specification. The lable
     80         * Adds a label to the list of label for this tag specification. The label
    8481         * is only added if i
    8582         *
    86          * @param lable the lable to add; must not be null
     83         * @param lable the lalbe to add; must not be null
    8784         * @exception IllegalArgumentException thrown, if lable is null
    8885         */

  • applications/editors/josm/plugins/tageditor/src/org/openstreetmap/josm/plugins/tageditor/tagspec/TagSpecifications.java

    r15319 r20058  
    1111import java.util.logging.Logger;
    1212
     13import org.openstreetmap.josm.gui.tagging.ac.AutoCompletionItemPritority;
     14import org.openstreetmap.josm.gui.tagging.ac.AutoCompletionListItem;
    1315import org.openstreetmap.josm.plugins.tageditor.ac.AutoCompletionContext;
    14 import org.openstreetmap.josm.plugins.tageditor.ac.AutoCompletionItemPritority;
    15 import org.openstreetmap.josm.plugins.tageditor.ac.AutoCompletionListItem;
    1616import org.xml.sax.Attributes;
    1717import org.xml.sax.EntityResolver;
    … …  
    5858        private ArrayList<TagSpecification> tagSpecifications = null;
    5959
    60 
    61 
    6260        private static TagSpecifications instance = null;
    6361
    … …  
    123121                        parser = null;
    124122                }
    125 
    126 
    127 
    128123        }
    129124
    … …  
    160155                return items;
    161156        }
    162 
    163 
     157       
    164158        /**
    165159         * replies a list of {@see KeyValuePair}s for all {@see TagSpecification}s and
    … …  
    292286                }
    293287
    294 
    295288                /**
    296289                 * handles a start element with name <code>label</code>
    … …  
    359352                        logger.log(Level.WARNING, "XML parsing warning", e);
    360353                }
    361 
    362 
    363 
    364         }
    365 
     354        }
    366355
    367356        /**
    … …  
    383372        }
    384373
    385 
    386374        static public void main(String args[]) throws Exception{
    387375                TagSpecifications.loadFromResources();
    388376        }
    389 
    390377}

  • applications/editors/josm/plugins/tageditor/src/org/openstreetmap/josm/plugins/tageditor/tagspec/ui/ITagSelectorListener.java

    r14330 r20058  
    33import org.openstreetmap.josm.plugins.tageditor.tagspec.KeyValuePair;
    44
    5 
    65public interface ITagSelectorListener {
    7 
    86        public void itemSelected(KeyValuePair pair);
    97}

  • applications/editors/josm/plugins/tageditor/src/org/openstreetmap/josm/plugins/tageditor/tagspec/ui/KeyValueCellRenderer.java

    r15319 r20058  
    11package org.openstreetmap.josm.plugins.tageditor.tagspec.ui;
    22
    3 import java.awt.Color;
    43import java.awt.Component;
    54import java.awt.Font;
    … …  
    87import javax.swing.JLabel;
    98import javax.swing.JTable;
     9import javax.swing.UIManager;
    1010import javax.swing.table.TableCellRenderer;
    1111
    1212public class KeyValueCellRenderer extends JLabel implements TableCellRenderer  {
    1313
    14         private static Logger logger = Logger.getLogger(KeyValueCellRenderer.class.getName());
    15         public static final Color BG_COLOR_SELECTED = new Color(143,170,255);
    16 
     14        private static final Logger logger = Logger.getLogger(KeyValueCellRenderer.class.getName());
    1715
    1816        protected void init() {
    19                 setFont(new Font("Courier",Font.PLAIN,12));
     17                setFont(new Font("Courier",Font.PLAIN,getFont().getSize()));
    2018                setOpaque(true);
    2119        }
    … …  
    2927
    3028                if (isSelected) {
    31                         setBackground(BG_COLOR_SELECTED);
     29                        setBackground(UIManager.getColor("Table.selectionBackground"));
     30                        setForeground(UIManager.getColor("Table.selectionForeground"));
    3231                } else  {
    33                         setBackground(Color.WHITE);
     32                        setBackground(UIManager.getColor("Table.background"));
     33                        setForeground(UIManager.getColor("Table.foreground"));
    3434                }
    3535                setText((String)value);

  • applications/editors/josm/plugins/tageditor/src/org/openstreetmap/josm/plugins/tageditor/tagspec/ui/TabularTagSelector.java

    r15319 r20058  
    3131import org.openstreetmap.josm.plugins.tageditor.tagspec.KeyValuePair;
    3232
    33 
    34 
    3533public class TabularTagSelector extends JPanel {
    3634
    … …  
    4038        private JScrollPane scrollPane;
    4139        private final ArrayList<ITagSelectorListener> listeners = new ArrayList<ITagSelectorListener>();
    42 
    4340
    4441        protected JPanel buildFilterPanel() {
    … …  
    123120        }
    124121
    125 
    126122        protected JPanel buildControlButtonPanel() {
    127123                JPanel pnl = new JPanel();

  • applications/editors/josm/plugins/tageditor/src/org/openstreetmap/josm/plugins/tageditor/tagspec/ui/TagsTableModel.java

    r15319 r20058  
    1212import org.openstreetmap.josm.plugins.tageditor.tagspec.KeyValuePair;
    1313import org.openstreetmap.josm.plugins.tageditor.tagspec.TagSpecifications;
    14 
    1514
    1615public class TagsTableModel extends AbstractTableModel {
    … …  
    117116                return visibleItems.get(row);
    118117        }
    119 
    120118}
Note: See TracChangeset for help on using the changeset viewer.