001: /*
002: * WebFolderListener.java
003: *
004: * Created on April 17, 2007, 6:07 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;
011:
012: import java.awt.EventQueue;
013: import java.util.Collection;
014: import org.netbeans.modules.web.jsf.navigation.pagecontentmodel.PageContentModelProvider;
015: import org.openide.filesystems.FileChangeAdapter;
016: import org.openide.filesystems.FileEvent;
017: import org.openide.filesystems.FileObject;
018: import org.openide.filesystems.FileRenameEvent;
019: import org.openide.filesystems.FileUtil;
020: import org.openide.loaders.DataObject;
021: import org.openide.loaders.DataObjectNotFoundException;
022: import org.openide.nodes.Node;
023: import org.openide.util.Exceptions;
024:
025: /**
026: *
027: * @author joelle
028: */
029: public class WebFolderListener extends FileChangeAdapter {
030:
031: private final PageFlowController pfc;
032: private final FileObject webFolder;
033:
034: /**
035: * This web folder listener listens to any modifications related to WebFolder and updates the faces config accordingly.
036: * @param pfc
037: */
038: public WebFolderListener(PageFlowController pfc) {
039: super ();
040: this .pfc = pfc;
041: webFolder = pfc.getWebFolder();
042: }
043:
044: private final Collection<? extends PageContentModelProvider> impls = PageFlowController
045: .getPageContentModelProviders();
046:
047: private boolean isKnownFileEvent(FileObject potentialChild) {
048: if (FileUtil.isParentOf(webFolder, potentialChild)) {
049: if (potentialChild.isFolder()) {
050: return pfc.isKnownFolder(potentialChild);
051: } else {
052: return pfc.isKnownFile(potentialChild);
053: }
054: }
055: return false;
056: }
057:
058: @Override
059: public void fileDataCreated(FileEvent fe) {
060: if (!pfc.getView().isShowing()) {
061: pfc.setFilesDirty();
062: return;
063: }
064:
065: final FileObject fileObj = fe.getFile();
066: EventQueue.invokeLater(new Runnable() {
067:
068: public void run() {
069: fileCreatedEventHandler(fileObj);
070: }
071: });
072: }
073:
074: @Override
075: public void fileDeleted(FileEvent fe) {
076: if (!pfc.getView().isShowing()) {
077: pfc.setFilesDirty();
078: return;
079: }
080: final FileObject fileObj = fe.getFile();
081: EventQueue.invokeLater(new Runnable() {
082:
083: public void run() {
084: fileDeletedEventHandler(fileObj);
085: }
086: });
087: }
088:
089: @Override
090: public void fileRenamed(FileRenameEvent fe) {
091: if (!pfc.getView().isShowing()) {
092: pfc.setFilesDirty();
093: return;
094: }
095: /* fileRenamed should not modify the faces-config because it should
096: * be up to refactoring to do this. If that is the case, FacesModelPropertyChangeListener
097: * should reload it.
098: */
099: final FileObject fileObj = fe.getFile();
100: final FileRenameEvent event = fe;
101: EventQueue.invokeLater(new Runnable() {
102:
103: public void run() {
104: fileRenamedEventHandler(fileObj, event.getName(), event
105: .getExt());
106: }
107: });
108: }
109:
110: private void fileDeletedEventHandler(FileObject fileObj) {
111: PageFlowView view = pfc.getView();
112: if (!pfc.removeWebFile(fileObj)) {
113: return;
114: }
115:
116: //DISPLAYNAME:
117: String pageDisplayName = Page.getFolderDisplayName(webFolder,
118: fileObj);
119:
120: Page oldNode = pfc.getPageName2Page(pageDisplayName);
121: if (oldNode != null) {
122: if (pfc.isPageInAnyFacesConfig(oldNode.getDisplayName())) {
123: // Node tmpNode = new AbstractNode(Children.LEAF);
124: // tmpNode.setName(pageDisplayName);
125: // oldNode.replaceWrappedNode(tmpNode);
126: // view.resetNodeWidget(oldNode, false); /* If I add a listener to PageFlowNode, then I won't have to do this*/
127: pfc.changeToAbstractNode(oldNode, pageDisplayName);
128: } else {
129: view.removeNodeWithEdges(oldNode);
130: pfc.removePageName2Page(oldNode, true);
131: }
132: view.validateGraph(); //Either action validate graph
133: }
134: }
135:
136: private void fileCreatedEventHandler(FileObject fileObj) {
137: PageFlowView view = pfc.getView();
138:
139: if (!isKnownFileEvent(fileObj)) {
140:
141: /* Semi Hack: The point is to update a model if a new model is created
142: for a given page as a sideeffect of an "UNKNOWN" page being created */
143: for (PageContentModelProvider provider : impls) {
144: FileObject jspFileObject = provider
145: .isNewPageContentModel(fileObj);
146: if (jspFileObject != null
147: && isKnownFileEvent(jspFileObject)) {
148:
149: //DataObject dobj = DataObject.find(jspFileObject);
150: //DISPLAYNAME:
151: //System.out.println("webFolder: " + webFolder);
152: String pageDisplayName = Page.getFolderDisplayName(
153: webFolder, jspFileObject);
154:
155: Page relevantPage = pfc
156: .getPageName2Page(pageDisplayName); /* I can't remember if this*/
157: if (relevantPage != null) {
158: relevantPage.updateContentModel();
159: view.resetNodeWidget(relevantPage, true);
160: view.validateGraph();
161: }
162: }
163: }
164: return;
165: }
166:
167: try {
168: if (pfc.isKnownFile(fileObj)) {
169: pfc.addWebFile(fileObj);
170: DataObject dataObj = DataObject.find(fileObj);
171: Node dataNode = dataObj.getNodeDelegate();
172: // PageFlowNode pageNode = pageName2Node.get(dataNode.getDisplayName());
173: //DISPLAYNAME:
174: Page pageNode = pfc.getPageName2Page(Page
175: .getFolderDisplayName(webFolder, fileObj));
176: if (pageNode != null) {
177: pageNode.replaceWrappedNode(dataNode);
178: view.resetNodeWidget(pageNode, false);
179: view.validateGraph();
180: } else if (pfc
181: .isCurrentScope(PageFlowToolbarUtilities.Scope.SCOPE_PROJECT)) {
182: Page node = pfc.createPage(dataNode);
183: view.createNode(node, null, null);
184: view.validateGraph();
185: }
186: }
187: } catch (DataObjectNotFoundException ex) {
188: Exceptions.printStackTrace(ex);
189: }
190: }
191:
192: private String oldFolderName;
193: private String newFolderName;
194:
195: private void fileRenamedEventHandler(FileObject fileObj,
196: String oldName, String extName) {
197: if (!pfc.containsWebFile(fileObj)
198: && !pfc.isKnownFolder(fileObj)) {
199: return;
200: }
201:
202: if (fileObj.isFolder()) {
203: //I may still need to modify display names.
204: if (oldName.equals(oldFolderName)
205: && fileObj.getName().equals(newFolderName)) {
206: //Folder rename triggers two listeners. Only pay attention to the first one.
207: return;
208: }
209: oldFolderName = oldName;
210: newFolderName = fileObj.getName();
211: renameFolder(fileObj, oldFolderName, newFolderName);
212: } else {
213: //DISPLAYNAME:
214: String newDisplayName = Page.getFolderDisplayName(
215: webFolder, fileObj);
216: String path = fileObj.getPath().replace(
217: fileObj.getNameExt(), "");
218: String oldDisplayName = Page.getFolderDisplayName(
219: webFolder, path, oldName + "." + extName);
220:
221: renameFile(fileObj, oldDisplayName, newDisplayName);
222: }
223: pfc.getView().validateGraph();
224: }
225:
226: private void renameFolder(FileObject folderObject,
227: String oldFolderName, String newFolderName) {
228: FileObject[] fileObjs = folderObject.getChildren();
229: for (FileObject file : fileObjs) {
230:
231: if (file.isFolder()) {
232: renameFolder(file, oldFolderName, newFolderName);
233: } else {
234: String newDisplayName = Page.getFolderDisplayName(
235: webFolder, file);
236: String oldDisplayName = newDisplayName.replaceFirst(
237: newFolderName, oldFolderName);
238: renameFile(file, oldDisplayName, newDisplayName);
239: }
240: }
241: }
242:
243: private void renameFile(FileObject fileObj, String oldDisplayName,
244: String newDisplayName) {
245: PageFlowView view = pfc.getView();
246: Page oldNode = pfc.getPageName2Page(oldDisplayName);
247: Page abstractNode = pfc.getPageName2Page(newDisplayName); // I know I do this twice, but I am trying to keep it less confusing.
248: if (oldNode == null && abstractNode != null) {
249: /* Probably a refactoring scenario */
250: Node dataNode = getNodeDelegate(fileObj);
251: abstractNode.replaceWrappedNode(dataNode);
252: view.resetNodeWidget(abstractNode, true);
253: view.validateGraph();
254: return;
255: }
256:
257: if (oldNode != null && oldNode.isRenaming()) {
258: return;
259: }
260:
261: Node newNodeDelegate = getNodeDelegate(fileObj);
262:
263: //If we are in project view scope
264: if (pfc
265: .isCurrentScope(PageFlowToolbarUtilities.Scope.SCOPE_PROJECT)) {
266: assert oldNode != null;
267: }
268:
269: if (abstractNode != null) {
270: // assert !abstractNode.isDataNode(); //Never should this have already been a file node.
271: if (abstractNode.isDataNode()) {
272: System.err.println("So Called Abstract Node: "
273: + abstractNode);
274: Thread.dumpStack();
275: }
276:
277: //Figure out what to do with old node.
278: if (pfc.isPageInAnyFacesConfig(oldDisplayName)) {
279: pfc.changeToAbstractNode(oldNode, oldDisplayName);
280: } else if (oldNode != null) {
281: view.removeNodeWithEdges(oldNode);
282: pfc.removePageName2Page(oldNode, true);
283: }
284: abstractNode.replaceWrappedNode(newNodeDelegate);
285: view.resetNodeWidget(abstractNode, true);
286: } else if (oldNode != null) {
287: if (pfc.isPageInAnyFacesConfig(oldDisplayName)) {
288: pfc.changeToAbstractNode(oldNode, oldDisplayName);
289: if (pfc
290: .isCurrentScope(PageFlowToolbarUtilities.Scope.SCOPE_PROJECT)) {
291: Page newNode = pfc.createPage(newNodeDelegate);
292: view.createNode(newNode, null, null);
293: }
294: } else {
295: view.resetNodeWidget(oldNode, false);
296: // pfc.removePageName2Page(oldDisplayName, false);
297: }
298: }
299: // view.validateGraph();
300: }
301:
302: private Node getNodeDelegate(FileObject fileObj) {
303: Node newNodeDelegate = null;
304: try {
305: newNodeDelegate = (DataObject.find(fileObj))
306: .getNodeDelegate();
307: } catch (DataObjectNotFoundException donfe) {
308: Exceptions.printStackTrace(donfe);
309: }
310: return newNodeDelegate;
311: }
312: }
|