Revision 2125 org.gvsig.vectorediting/trunk/org.gvsig.vectorediting/org.gvsig.vectorediting.swing/org.gvsig.vectorediting.swing.impl/src/main/java/org/gvsig/vectorediting/swing/impl/contextmenu/DefaultEditingContextMenu.java

View differences:

DefaultEditingContextMenu.java
26 26

  
27 27
import java.awt.Component;
28 28
import java.awt.event.ActionEvent;
29
import java.util.List;
29 30
import java.util.Map;
30 31

  
31 32
import javax.swing.AbstractAction;
......
34 35
import javax.swing.JSeparator;
35 36
import javax.swing.SwingConstants;
36 37
import javax.swing.SwingUtilities;
38
import org.apache.commons.lang3.StringUtils;
37 39

  
38 40
import org.slf4j.Logger;
39 41
import org.slf4j.LoggerFactory;
......
42 44
import org.gvsig.tools.ToolsLocator;
43 45
import org.gvsig.tools.i18n.I18nManager;
44 46
import org.gvsig.tools.task.RunnableWithParameters;
47
import org.gvsig.vectorediting.lib.api.EditingService;
45 48
import org.gvsig.vectorediting.lib.api.EditingServiceParameter;
46 49
import org.gvsig.vectorediting.lib.api.EditingServiceParameter.TYPE;
50
import org.gvsig.vectorediting.lib.api.exceptions.InvalidEntryException;
51
import org.gvsig.vectorediting.swing.api.EditingContext;
47 52
import org.gvsig.vectorediting.swing.api.contextmenu.AcceptValueListener;
48 53
import org.gvsig.vectorediting.swing.api.contextmenu.EditingContextMenu;
49 54

  
......
54 59
public class DefaultEditingContextMenu extends EditingContextMenuView implements
55 60
EditingContextMenu {
56 61

  
57
    private static Logger logger = LoggerFactory
62
    private static Logger LOGGER = LoggerFactory
58 63
        .getLogger(DefaultEditingContextMenu.class);
59 64

  
60 65
    private static final long serialVersionUID = -3207749321400180897L;
......
65 70

  
66 71
    private EditingServiceParameter parameter;
67 72

  
73
    private EditingContext context;
74

  
68 75
    /**
69 76
     * @param parent
70 77
     * @param listener
......
73 80
    public DefaultEditingContextMenu(Component parent,
74 81
        AcceptValueListener listener, EditingServiceParameter parameter) {
75 82

  
83
        this(parent, listener, parameter, null);
84
    }
85

  
86
    /**
87
     * @param parent
88
     * @param listener
89
     * @param parameter
90
     * @param context
91
     */
92
    public DefaultEditingContextMenu(Component parent,
93
        AcceptValueListener listener, EditingServiceParameter parameter, EditingContext context) {
94

  
76 95
        super();
77 96
        this.listener = listener;
78 97
        this.parent = parent;
79 98
        this.parameter = parameter;
99
        this.context = context;
80 100
        initActions();
81 101
    }
82 102

  
83 103
    @SuppressWarnings("serial")
84 104
    private void initActions() {
105
        
106
        EditingService service = context.getActiveService();
107
        List<EditingServiceParameter> parameters = service.getParameters();
108
        
109
        for (EditingServiceParameter param : parameters) {
110
            if(param.equals(this.parameter)){
111
                continue;
112
            }
113
            if(param.isOptional() && service.isEnabled(param)){
114
                initAction(param, new AcceptValueListener() {
85 115

  
116
                    @Override
117
                    public void acceptValue(Object value) {
118
                        try {
119
                            context.setValue(param, (String)value);
120
                        } catch (InvalidEntryException ex) {
121
                            LOGGER.warn("Invalid value", ex);
122
                        }
123
                    }
124
                });
125
            }
126
        }
127
        
128
        initAction(parameter, this.listener);
129

  
86 130
        I18nManager i18nManager = ToolsLocator.getI18nManager();
87 131
        AbstractAction action = null;
88 132

  
89
        for (final TYPE type : parameter.getTypes()) {
133
        this.add(new JSeparator(SwingConstants.HORIZONTAL));
134
        action = new AbstractAction(i18nManager.getTranslation("cancel")) {
90 135

  
136
            public void actionPerformed(ActionEvent e) {
137
                listener.acceptValue(null);
138
            }
139
        };
140
        this.add(action);
141

  
142

  
143
        ((JComponent) parent).add(this);
144

  
145
    }
146
    
147
    private void initAction(EditingServiceParameter param, AcceptValueListener listener){
148
        
149
        I18nManager i18nManager = ToolsLocator.getI18nManager();
150
        AbstractAction action = null;
151

  
152
        for (final TYPE type : param.getTypes()) {
153

  
91 154
            switch (type) {
92 155
            case OPTION:
93
                Map<String, String> options = parameter.getOptions();
156
                Map<String, String> options = param.getOptions();
94 157
                for (String key : options.keySet()) {
95 158
                    String value = i18nManager.getTranslation(options.get(key));
96 159
                    action = new AbstractAction(value) {
......
106 169
                break;
107 170
            case VALUE:
108 171
                String name =
109
                i18nManager.getTranslation(parameter.getName()) + " ("
172
                i18nManager.getTranslation(param.getName()) + " ("
110 173
                    + i18nManager.getTranslation("value") + ")";
111
                ;
112 174
                action = new AbstractAction(name) {
113 175

  
114 176
                    public void actionPerformed(ActionEvent e) {
115
                        String value = showValueDialog(parameter);
116
                        if (value != null) {
177
                        String value = showValueDialog(param);
178
                        if (StringUtils.isNotEmpty(value)) {
117 179
                            listener.acceptValue(value);
118 180
                        }
119 181
                    }
......
124 186
            case POSITION:
125 187
            case LIST_POSITIONS:
126 188
                name =
127
                i18nManager.getTranslation(parameter.getName()) + " ("
189
                i18nManager.getTranslation(param.getName()) + " ("
128 190
                    + i18nManager.getTranslation("point") + ")";
129 191
                action = new AbstractAction(name) {
130 192

  
131 193
                    public void actionPerformed(ActionEvent e) {
132
                        String value = showPointDialog(parameter);
194
                        String value = showPointDialog(param);
133 195
                        if (value != null) {
134 196
                            listener.acceptValue(value);
135 197
                        }
......
145 207

  
146 208
        }
147 209

  
148
        this.add(new JSeparator(SwingConstants.HORIZONTAL));
149
        action = new AbstractAction(i18nManager.getTranslation("cancel")) {
150

  
151
            public void actionPerformed(ActionEvent e) {
152
                listener.acceptValue(null);
153
//                setVisible(false);
154
            }
155
        };
156
        this.add(action);
157

  
158
        ((JComponent) parent).add(this);
159

  
160 210
    }
161 211

  
162 212
    /**
......
199 249
            try {
200 250
                SwingUtilities.invokeAndWait(runnable);
201 251
            } catch (Exception e) {
202
                logger.info("Can't show point dialog.", e);
252
                LOGGER.info("Can't show point dialog.", e);
203 253
            }
204 254
        }
205 255

  
......
243 293
            try {
244 294
                SwingUtilities.invokeAndWait(runnable);
245 295
            } catch (Exception e) {
246
                logger.info("Can't show value dialog.", e);
296
                LOGGER.info("Can't show value dialog.", e);
247 297
            }
248 298
        }
249 299

  

Also available in: Unified diff