Revision 47733 trunk/org.gvsig.desktop/org.gvsig.desktop.plugin/org.gvsig.app/org.gvsig.app.mainplugin/src/main/java/org/gvsig/app/extension/evalexpression/EvaluateExpressionExtension.java

View differences:

EvaluateExpressionExtension.java
1 1
package org.gvsig.app.extension.evalexpression;
2 2

  
3
import java.awt.event.ActionEvent;
4
import java.awt.event.ActionListener;
3
import java.util.HashSet;
4
import java.util.Set;
5 5
import org.gvsig.andami.plugins.Extension;
6 6
import org.gvsig.app.ApplicationLocator;
7
import org.gvsig.app.ApplicationManager;
7
import org.gvsig.app.extension.evalexpression.notifierfactory.AbstractUpdaterFactory;
8
import org.gvsig.app.extension.evalexpression.notifierfactory.CurrentLayerSelectionChangedFactory;
9
import org.gvsig.app.extension.evalexpression.notifierfactory.UpdaterFactory;
10
import org.gvsig.app.extension.evalexpression.notifierfactory.ViewExtentChangedFactory;
8 11
import org.gvsig.fmap.dal.feature.FeatureStore;
9
import org.gvsig.fmap.mapcontext.layers.FLayer;
10 12
import org.gvsig.fmap.mapcontext.layers.vectorial.FLyrVect;
11
import org.gvsig.tools.swing.api.ActionListenerSupport;
13
import org.gvsig.tools.arguments.Arguments;
14
import org.gvsig.tools.observer.Observer;
12 15
import org.gvsig.tools.swing.api.ToolsSwingLocator;
13 16
import org.gvsig.tools.swing.api.windowmanager.WindowManager;
14 17

  
......
16 19
 *
17 20
 * @author jjdelcerro
18 21
 */
19
public class EvaluateExpressionExtension extends Extension implements ActionListenerSupport {
22
public class EvaluateExpressionExtension extends Extension { 
20 23

  
21
    private ActionListenerSupport listenerHelper;
24
    private WindowFocusChangedUpdaterFactory windowFocusChangedFactory;
22 25

  
23 26
    @Override
24 27
    public void initialize() {
25
        this.listenerHelper = ToolsSwingLocator.getToolsSwingManager().createActionListenerSupport();
28
        this.windowFocusChangedFactory = new WindowFocusChangedUpdaterFactory();
29
        EvaluateExpressionPanel.registerUpdater(windowFocusChangedFactory);
30
        EvaluateExpressionPanel.registerUpdater(new ViewExtentChangedFactory());
31
        EvaluateExpressionPanel.registerUpdater(new CurrentLayerSelectionChangedFactory());
26 32
    }
27 33

  
28 34
    @Override
29 35
    public void execute(String actionCommand) {
36
        execute(actionCommand,null);
37
    }
38
    public void execute(String actionCommand, Object[] args) {
39
        Arguments arguments = Arguments.create(args);
30 40
        switch(actionCommand) {
31 41
            case "tools-scripting-evaluateexpression":
32
                doEvaluateExpression();
42
                doEvaluateExpression(arguments);
33 43
                break;
34 44
        }
35 45
    }
36 46

  
37
    private void doEvaluateExpression() {
47
    private void doEvaluateExpression(Arguments arguments) {
38 48
        WindowManager windowManager = ToolsSwingLocator.getWindowManager();
39 49
        FeatureStore store = null;
40 50
        try {
......
43 53
        } catch (Exception ex) {
44 54
            //Do nothing
45 55
        }
46
        windowManager.showWindow(new EvaluateExpressionPanel(this, store), "Expression", WindowManager.MODE.WINDOW);
56
        EvaluateExpressionPanel panel = new EvaluateExpressionPanel(store);
57
        panel.setParameters(arguments);
58
        if( ! arguments.contains("execute") ) {
59
            windowManager.showWindow(panel, "Expression", WindowManager.MODE.WINDOW);
60
        }
47 61
    }
48 62
    
49 63
    @Override
50 64
    public boolean isEnabled() {
51
        try {
52
            this.listenerHelper.fireActionEvent(null);
53
        } catch(Throwable th) {
54
            
55
        }
65
        this.windowFocusChangedFactory.updateAll();
56 66
        return true;
57 67
    }
58 68

  
......
61 71
        return true;
62 72
    }
63 73

  
64
    @Override
65
    public void addActionListener(ActionListener listener) {
66
        this.listenerHelper.addActionListener(listener);
67
    }
74
    private class WindowFocusChangedUpdaterFactory extends AbstractUpdaterFactory {
68 75

  
69
    @Override
70
    public ActionListener[] getActionListeners() {
71
        return this.listenerHelper.getActionListeners();
72
    }
76
        private final Set<WindowFocusChangedUpdater> windowFocusChangedUpdaters = new HashSet<>();
73 77

  
74
    @Override
75
    public void removeActionListener(ActionListener listener) {
76
        this.listenerHelper.removeActionListener(listener);
77
    }
78
        private class WindowFocusChangedUpdater extends AbstractUpdaterFactory.AbstractUpdater {
78 79

  
79
    @Override
80
    public void removeAllActionListener() {
81
        this.listenerHelper.removeAllActionListener();
82
    }
80
            @SuppressWarnings("Convert2Lambda")
81
            public WindowFocusChangedUpdater(UpdaterFactory factory, Observer observer) {
82
                super(factory, observer);
83
            }
83 84

  
84
    @Override
85
    public void fireActionEvent(ActionEvent event) {
86
        this.listenerHelper.fireActionEvent(event);
85
            @Override
86
            public void add() {
87
                windowFocusChangedUpdaters.add(this);
88
            }
89

  
90
            @Override
91
            public void remove() {
92
                windowFocusChangedUpdaters.remove(this);
93
            }
94

  
95
        }
96

  
97
        public WindowFocusChangedUpdaterFactory() {
98
            super("WindowFocusChanged", "Actualizar cuando cambie la ventana activa");
99
        }
100

  
101
        @Override
102
        public UpdaterFactory.Updater create(Observer observer) {
103
            UpdaterFactory.Updater updater = new WindowFocusChangedUpdater(this, observer);
104
            return updater;
105
        }
106

  
107
        public void updateAll() {
108
            for (WindowFocusChangedUpdater windowFocusChangedUpdater : windowFocusChangedUpdaters) {
109
                windowFocusChangedUpdater.update();
110
            }        
111
        }
87 112
    }
88 113

  
89
    @Override
90
    public boolean hasActionListeners() {
91
        return this.listenerHelper.hasActionListeners();
92
    }
93
    
94 114
}

Also available in: Unified diff