001: /*
002: * PageFlowDeleteAction.java
003: *
004: * Created on April 12, 2007, 12:22 PM
005: *
006: * To change this template, choose Tools | Template Manager
007: * and open the template in the editor.
008: */
009:
010: package org.netbeans.modules.web.jsf.navigation.graph.actions;
011:
012: import java.awt.EventQueue;
013: import java.awt.event.ActionEvent;
014: import java.awt.event.KeyEvent;
015: import java.io.IOException;
016: import java.util.ArrayList;
017: import java.util.Collection;
018: import java.util.HashSet;
019: import java.util.LinkedList;
020: import java.util.Queue;
021: import java.util.Set;
022: import java.util.logging.Logger;
023: import javax.swing.AbstractAction;
024: import javax.swing.KeyStroke;
025: import org.netbeans.modules.web.jsf.navigation.NavigationCaseEdge;
026: import org.netbeans.modules.web.jsf.navigation.Page;
027: import org.netbeans.modules.web.jsf.navigation.PageFlowToolbarUtilities;
028: import org.netbeans.modules.web.jsf.navigation.Pin;
029: import org.netbeans.modules.web.jsf.navigation.graph.PageFlowScene;
030: import org.netbeans.modules.web.jsf.navigation.graph.PageFlowSceneElement;
031: import org.openide.util.Exceptions;
032:
033: /**
034: *
035: * @author joelle
036: */
037: public class PageFlowDeleteAction extends AbstractAction {
038: private final PageFlowScene scene;
039: private static final Logger LOG = Logger
040: .getLogger("org.netbeans.modules.web.jsf.navigation.graph.actions.PageFlowDeleteAction");
041:
042: // private final static Logger LOG = Logger.getLogger("org.netbeans.modules.web.jsf.navigation.graph.actions.PageFlowDeleteAction");
043: // static {
044: // LOG.setLevel(Level.FINEST);
045: // }
046:
047: /** Creates a new instance of PageFlowDeleteAction
048: * @param scene
049: */
050: public PageFlowDeleteAction(PageFlowScene scene) {
051: super ();
052: this .scene = scene;
053: putValue("ACCELERATOR_KEY", KeyStroke.getKeyStroke(
054: KeyEvent.VK_DELETE, 0));
055: }
056:
057: /* These are edges that do not exist in the local facesConfig. */
058: private final Collection<NavigationCaseEdge> thoseEdges = new ArrayList<NavigationCaseEdge>();
059:
060: /* These are edges that exist in the local facesConfig. */
061: private final Collection<NavigationCaseEdge> theseEdges = new ArrayList<NavigationCaseEdge>();
062:
063: @Override
064: public boolean isEnabled() {
065: //Workaround: Temporarily Wrapping Collection because of Issue: 100127
066: Set<? extends Object> selectedObjs = scene.getSelectedObjects();
067: if (selectedObjs.isEmpty()) {
068: return false;
069: }
070:
071: for (Object selectedObj : selectedObjs) {
072: /* HACK until PinNode is made a Node */
073: if (!(selectedObj instanceof PageFlowSceneElement)) {
074: return false;
075: }
076: PageFlowSceneElement element = (PageFlowSceneElement) selectedObj;
077: /* Can usually assume the case is in the config file unless we are dealing with the SCOPE_ALL_FACESCONFIG. */
078: if (!element.isModifiable()) {
079: return false;
080: }
081:
082: if (scene
083: .getPageFlowView()
084: .getPageFlowController()
085: .isCurrentScope(
086: PageFlowToolbarUtilities.Scope.SCOPE_ALL_FACESCONFIG)
087: && element instanceof Page) {
088: /* These are edges in the local faces config */
089: thoseEdges.clear();
090: theseEdges.clear();
091:
092: Collection<NavigationCaseEdge> allEdges = new ArrayList<NavigationCaseEdge>();
093: Collection<Pin> pins = scene
094: .getNodePins((Page) element);
095: for (Pin pin : pins) {
096: allEdges
097: .addAll(scene.findPinEdges(pin, true, true));
098: }
099: for (NavigationCaseEdge edge : allEdges) {
100: if (edge.isModifiable()) {
101: theseEdges.add(edge);
102: } else {
103: thoseEdges.add(edge);
104: }
105: }
106: if (theseEdges.isEmpty()) {
107: return false;
108: }
109: }
110: }
111:
112: return super .isEnabled();
113: }
114:
115: public void actionPerformed(ActionEvent event) {
116:
117: Queue<PageFlowSceneElement> deleteNodesList = new LinkedList<PageFlowSceneElement>();
118: //Workaround: Temporarily Wrapping Collection because of Issue: 100127
119: Set<Object> selectedObjects = new HashSet<Object>(scene
120: .getSelectedObjects());
121: LOG.fine("Selected Objects: " + selectedObjects);
122: LOG.finest("Scene: \n" + "Nodes: " + scene.getNodes() + "\n"
123: + "Edges: " + scene.getEdges() + "\n" + "Pins: "
124: + scene.getPins());
125:
126: /*When deleteing only one item. */
127: if (selectedObjects.size() == 1) {
128: Object myObj = selectedObjects.toArray()[0];
129: if (myObj instanceof PageFlowSceneElement) {
130: deleteNodesList.add((PageFlowSceneElement) myObj);
131: deleteNodes(deleteNodesList);
132: return;
133: }
134: }
135:
136: Set<NavigationCaseEdge> selectedEdges = new HashSet<NavigationCaseEdge>();
137: Set<PageFlowSceneElement> selectedNonEdges = new HashSet<PageFlowSceneElement>();
138:
139: /* When deleting multiple objects, make sure delete all the links first. */
140: Set<Object> nonEdgeSelectedObjects = new HashSet<Object>();
141: for (Object selectedObj : selectedObjects) {
142: if (selectedObj instanceof PageFlowSceneElement) {
143: if (scene.isEdge(selectedObj)) {
144: assert !scene.isPin(selectedObj);
145: selectedEdges.add((NavigationCaseEdge) selectedObj);
146: } else {
147: assert scene.isNode(selectedObj)
148: || scene.isPin(selectedObj);
149: selectedNonEdges
150: .add((PageFlowSceneElement) selectedObj);
151: }
152: }
153: }
154:
155: /* I can not call deleteNodes on them separate because I need to guarentee that the edges are always deleted before anything else. */
156: deleteNodesList.addAll(selectedEdges);
157: deleteNodesList.addAll(selectedNonEdges);
158:
159: // for( Object selectedObj : nonEdgeSelectedObjects ){
160: // deleteNodesList.add((PageFlowSceneElement)selectedObj);
161: // }
162: deleteNodes(deleteNodesList);
163:
164: }
165:
166: // public Queue<Node> myDeleteNodes;
167: private void deleteNodes(Queue<PageFlowSceneElement> deleteNodes) {
168: final Queue<PageFlowSceneElement> myDeleteNodes = deleteNodes;
169: EventQueue.invokeLater(new Runnable() {
170: public void run() {
171: try {
172: //This should walk through in order.
173: for (PageFlowSceneElement deleteNode : myDeleteNodes) {
174: if (deleteNode.canDestroy()) {
175:
176: if (deleteNode instanceof NavigationCaseEdge) {
177: updateSourcePins((NavigationCaseEdge) deleteNode);
178: }
179:
180: if (scene
181: .getPageFlowView()
182: .getPageFlowController()
183: .isCurrentScope(
184: PageFlowToolbarUtilities.Scope.SCOPE_ALL_FACESCONFIG)) {
185: if (thoseEdges.isEmpty()) {
186: deleteNode.destroy();
187: } else {
188: for (NavigationCaseEdge edge : theseEdges) {
189: if (scene.findWidget(edge) != null) {
190: updateSourcePins(edge);
191: edge.destroy();
192: }
193: }
194: }
195: thoseEdges.clear();
196: } else {
197: deleteNode.destroy();
198: }
199: }
200: }
201: } catch (IOException ex) {
202: Exceptions.printStackTrace(ex);
203: }
204: }
205: });
206: }
207:
208: private void updateSourcePins(NavigationCaseEdge navCaseNode) {
209: Pin source = scene.getEdgeSource(navCaseNode);
210: if (source != null && !source.isDefault()) {
211: source.setFromOutcome(null);
212: }
213: return;
214: }
215:
216: }
|