12:33 p.m.
Author: dgolovin
Date: 2008-08-11 13:33:40 -0400 (Mon, 11 Aug 2008)
New Revision: 9643
Added:
tags/jbosstools-3.0.0.Alpha1/common/plugins/org.jboss.tools.common.model/src/org/jboss/tools/common/model/filesystems/impl/FolderImpl.java
Log:
fix https://jira.jboss.org/jira/browse/JBIDE-2614
Copied:
tags/jbosstools-3.0.0.Alpha1/common/plugins/org.jboss.tools.common.model/src/org/jboss/tools/common/model/filesystems/impl/FolderImpl.java
(from rev 9642,
trunk/common/plugins/org.jboss.tools.common.model/src/org/jboss/tools/common/model/filesystems/impl/FolderImpl.java)
===================================================================
---
tags/jbosstools-3.0.0.Alpha1/common/plugins/org.jboss.tools.common.model/src/org/jboss/tools/common/model/filesystems/impl/FolderImpl.java
(rev 0)
+++
tags/jbosstools-3.0.0.Alpha1/common/plugins/org.jboss.tools.common.model/src/org/jboss/tools/common/model/filesystems/impl/FolderImpl.java 2008-08-11
17:33:40 UTC (rev 9643)
@@ -0,0 +1,1031 @@
+/*******************************************************************************
+ * Copyright (c) 2007 Exadel, Inc. and Red Hat, Inc.
+ * Distributed under license by Red Hat, Inc. All rights reserved.
+ * This program is made available under the terms of the
+ * Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * Exadel, Inc. and Red Hat, Inc. - initial API and implementation
+ ******************************************************************************/
+package org.jboss.tools.common.model.filesystems.impl;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.*;
+
+import org.eclipse.core.internal.resources.ResourceException;
+import org.eclipse.core.resources.IContainer;
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.IFolder;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.IResource;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IPath;
+import org.eclipse.core.runtime.Path;
+import org.jboss.tools.common.model.markers.ResourceMarkers;
+import org.jboss.tools.common.model.plugin.ModelPlugin;
+import org.eclipse.swt.widgets.Display;
+
+import org.jboss.tools.common.meta.action.XActionInvoker;
+import org.jboss.tools.common.model.ServiceDialog;
+import org.jboss.tools.common.model.XModelException;
+import org.jboss.tools.common.model.XModelObject;
+import org.jboss.tools.common.model.filesystems.BodySource;
+import org.jboss.tools.common.model.filesystems.FileAuxiliary;
+import org.jboss.tools.common.model.filesystems.FilePathHelper;
+import org.jboss.tools.common.model.filesystems.XFileObject;
+import org.jboss.tools.common.model.impl.RegularObjectImpl;
+import org.jboss.tools.common.model.impl.XModelImpl;
+import org.jboss.tools.common.model.loaders.Reloadable;
+import org.jboss.tools.common.model.loaders.XObjectLoader;
+import org.jboss.tools.common.model.util.Paths;
+import org.jboss.tools.common.model.util.XModelObjectLoaderUtil;
+import org.jboss.tools.common.util.FileUtil;
+
+public class FolderImpl extends RegularObjectImpl implements FolderLoader {
+ private static final long serialVersionUID = 8082046187736790127L;
+ protected boolean loaded = false;
+ protected IContainer resource = null;
+ protected String pathForResource = null;
+ protected Map<String, File> linked = new HashMap<String, File>();
+ protected Map<String, IResource> linkedResources = new HashMap<String,
IResource>();
+
+ public FolderImpl() {}
+
+ public int getFileType() {
+ return FOLDER;
+ }
+
+ protected Comparator<XModelObject> createComparator() {
+ return new FileObjectComparator();
+ }
+
+ protected FileSystemImpl getFileSystem() {
+ FolderImpl folder = (FolderImpl)getParent();
+ return (folder == null) ? null : folder.getFileSystem();
+ }
+
+ public boolean isChildEditable(XModelObject o) {
+ if(!isObjectEditable()) return false;
+ File f = getChildIOFile(o);
+ if(f == null) return true;
+ return (!f.isFile() || f.canWrite());
+ }
+
+ protected File getFile() {
+ String path = getAbsolutePath();
+ return (path == null) ? null :
+ new File(Paths.expand(path, getModel().getProperties()));
+ }
+
+ public BodySource getBodySource(String filename) {
+ File f = getFile();
+ return (f == null) ? null : getBodySource(getChildIOFile(filename));
+ }
+
+ BodySource getBodySource(File f) {
+ IFile ef = getChildFile(f.getName());
+ if(ef != null) return new EclipseFileBodySource(ef, f);
+ return new FileBodySource(f);
+ }
+
+ public boolean isAttributeEditable(String name) {
+ return false;
+ }
+
+ protected String getAbsolutePath() {
+ FolderImpl parent = (FolderImpl)getParent();
+ String p = (parent == null) ? null : parent.getAbsolutePath();
+ if(parent.linked.containsKey(getPathPart())) {
+ return parent.linked.get(getPathPart()).getAbsolutePath();
+ }
+ return (p == null) ? null : p + "/" + name();
+ }
+
+ public IProject getProject() {
+ return (getParent() == null) ? null : ((FolderImpl)getParent()).getProject();
+ }
+
+ private File[] getFiles() {
+ File f = getFile();
+ if(f == null) return null;
+ if (!f.isDirectory()) return new File[0];
+ File[] fs = f.listFiles();
+ return (fs == null) ? new File[0] : fs;
+ }
+
+ public void set(String name, String value) {
+ if("NAME".equals(name) && isActive()) {
+ if(value != null && !value.equals(get(name))) copy();
+ }
+ super.set(name, value);
+ }
+
+ protected void loadChildren() {
+ if(loaded || !isActive()) return;
+ File[] fs = getFiles();
+ IResource[] rs = getResources();
+ if(fs == null || rs == null) return;
+ loaded = true;
+ ((XModelImpl)getModel()).addLoader();
+ try {
+ loadChildren(fs, rs);
+ } finally {
+ ((XModelImpl)getModel()).removeLoader();
+ }
+ }
+ private void loadChildren(File[] fs, IResource[] rs) {
+ FileSystemPeer peer = getFileSystem().getPeer();
+ for (int i = 0; i < fs.length; i++) {
+ _loadChild(peer, fs[i]);
+ }
+ for (int i = 0; i < rs.length; i++) {
+ if(!rs[i].isAccessible()) continue;
+ if(!rs[i].isLinked()) continue;
+ File f = rs[i].getLocation().toFile();
+ String pp = FilePathHelper.toPathPath(f.getName());
+ linked.put(pp, f);
+ linkedResources.put(pp, rs[i]);
+ _loadChild(peer, f);
+ }
+ fire = true;
+ }
+
+ private void _loadChild(FileSystemPeer peer, File f) {
+ if(f.isDirectory()) {
+ Properties p = new Properties();
+ p.setProperty("name", f.getName());
+ XModelObject c = getModel().createModelObject("FileFolder", p);
+ String pp = FilePathHelper.toPathPath(f.getName());
+ if(linked.containsKey(pp)) {
+ c.setObject("file", linked.get(pp));
+ }
+ addChild(c);
+ } else {
+ createFileObject(f);
+ }
+ peer.register(f);
+ }
+
+ private Properties getEntityProperties(File f) {
+ Properties p = new Properties();
+ parseFileName(p, f.getName());
+ String ext = p.getProperty("extension");
+ String body = null;
+ String entity = getModel().getEntityRecognizer().getEntityName(ext, body);
+ if("FileAny".equals(entity)) {
+ boolean isText = XModelObjectLoaderUtil.isTextFile(f, 100);
+ if(f.length() > 100000 || !isText) entity = "FileAnyLong";
+ else if(isText) entity = "FileTXT";
+ } else if(entity == null) {
+ body = getBodySource(f).get();
+ entity = getModel().getEntityRecognizer().getEntityName(ext, body);
+ }
+ if(entity == null || getModel().getMetaData().getEntity(entity) == null) entity =
"FileAny";
+ p.setProperty("entity", entity);
+ if(body != null) p.setProperty("body", body);
+ return p;
+ }
+
+ private void createFileObject(File f) {
+ createFileObject(f, getEntityProperties(f));
+ }
+
+ private void createFileObject(File f, Properties p) {
+ BodySource bs = getBodySource(f);
+ String body = p.getProperty("body");
+ String entity = p.getProperty("entity");
+ XModelObject c = getModel().createModelObject(entity, p);
+ if(c == null) {
+ ModelPlugin.getPluginLog().logInfo("Cannot create file for entity " +
entity);
+ return;
+ }
+ if(isLateloadFile2(c)) {
+ ((FileAnyImpl)c).setBodySource(bs);
+ } else {
+ XObjectLoader loader = XModelObjectLoaderUtil.getObjectLoader(c);
+ if(loader != null) {
+ if(body == null) body = bs.get();
+ XModelObjectLoaderUtil.setTempBody(c, body);
+ loader.load(c);
+ } else if(c.getModelEntity().getAttribute("_file") != null) {
+ c.set("_file", f.getAbsolutePath());
+ }
+ }
+ if(linked.containsValue(f)) {
+ c.setObject("file", f);
+ }
+ addChild(c);
+ }
+
+ int updateLock = 0;
+ Set<String> unsynchronized = null;
+ public boolean update() {
+ if(!loaded) return true;
+ if(updateLock > 0) return true;
+ updateLock++;
+ Map<String,File> mf = new HashMap<String,File>();
+ linked.clear();
+ XModelObject fileSystem = getFileSystem();
+ if(fileSystem == null) return false;
+ FileSystemsImpl fsi = (FileSystemsImpl)fileSystem.getParent();
+ try {
+ if(resource != null && resource.exists() &&
!resource.isSynchronized(IResource.DEPTH_ONE)) try {
+ fsi.lockUpdate();
+ resource.refreshLocal(IResource.DEPTH_ZERO, null);
+ if(resource.exists()) {
+ IResource[] rs = resource.members();
+ for (int i = 0; i < rs.length; i++) {
+ if(!rs[i].isSynchronized(IResource.DEPTH_ZERO)) {
+ if(unsynchronized == null) unsynchronized = new HashSet<String>();
+ String pp = FilePathHelper.toPathPath(rs[i].getName());
+ unsynchronized.add(pp);
+ }
+ }
+ if(resource.exists()) {
+ resource.refreshLocal(IResource.DEPTH_ONE, null);
+ }
+ }
+ } catch (ResourceException re) {
+ IPath p = resource.getLocation();
+ if(p != null && p.toFile().exists()) {
+ ModelPlugin.getPluginLog().logError("Exception caught in
FolderImpl.update()", re);
+ } else {
+ //ignore we cannot prevent this when project is removed externally
+ }
+ } catch (CoreException e) {
+ ModelPlugin.getPluginLog().logError("Exception caught in
FolderImpl.update()");
+ } finally {
+ fsi.unlockUpdate();
+ }
+
+
+ try {
+ if(resource != null && resource.exists()) {
+ IResource[] rs = resource.members();
+ for (int i = 0; i < rs.length; i++) {
+ if(rs[i].isLinked()) {
+ File f = rs[i].getLocation().toFile();
+ String p = FilePathHelper.toPathPath(f.getName());
+ mf.put(p, f);
+ linked.put(p, f);
+ linkedResources.put(p, rs[i]);
+ }
+ }
+ }
+ } catch (CoreException ex) {
+ ModelPlugin.getPluginLog().logError("Exception caught in
FolderImpl.update()");
+ }
+
+ File[] fs = getFiles();
+ for (int i = 0; i < fs.length; i++) {
+ String p = FilePathHelper.toPathPath(fs[i].getName());
+ mf.put(p, fs[i]);
+ }
+
+ Map<String,XModelObject> mc = children.getObjectsMap();
+
+ updateAuxiliary(mc, mf);
+
+ Map<String,XModelObject> toRemove = new
HashMap<String,XModelObject>();
+ Iterator<String> io = mc.keySet().iterator();
+ while(io.hasNext()) {
+ String nm = io.next();
+ if(mf.containsKey(nm)) continue;
+ XModelObject o = (XModelObject)mc.get(nm);
+ File of = getChildIOFile(o);
+ if(o.getFileType() == XModelObject.FOLDER) {
+ if(!getFileSystem().getPeer().containsDir(of)) continue;
+ } else {
+ if(!getFileSystem().getPeer().contains(of)) continue;
+ }
+ toRemove.put(nm, o);
+ io.remove();
+ }
+
+ Iterator<String> it = mf.keySet().iterator();
+ while(it.hasNext()) {
+ String nm = it.next();
+ File f = (File)mf.get(nm);
+ XModelObject o = (XModelObject)mc.get(nm);
+ if(o != null) {
+ updateLoaded(o, f);
+ mc.remove(nm);
+ } else {
+ updateNew(nm, f, toRemove);
+ }
+ }
+ it = toRemove.keySet().iterator();
+ while(it.hasNext()) {
+ String nm = (String)it.next();
+ updateRemove((XModelObject)toRemove.get(nm));
+ }
+ } catch (NoClassDefFoundError error) {
+ //Most probably Eclipse is shutting down.
+ return true;
+ } catch (XModelException t) {
+ ModelPlugin.getPluginLog().logError("Exception caught in
FolderImpl.update()");
+ } finally {
+ updateLock--;
+ unsynchronized = null;
+ }
+ return true;
+ }
+
+ protected File getChildIOFile(XModelObject o) {
+ String s = FileAnyImpl.toFileName(o);
+ File f = (File)o.getObject("file"); //for links
+ if(f == null && linked.containsKey(o.getPathPart())) {
+ f = linked.get(o.getPathPart());
+ }
+ if(f == null) {
+ f = new File(getFile(), s);
+ }
+ return f;
+ }
+
+ protected File getChildIOFile(String filename) {
+ File f = null;
+ String p = FilePathHelper.toPathPath(filename);
+ if(linked.containsKey(p)) {
+ f = linked.get(p);
+ }
+ if(f == null) {
+ f = new File(getFile(), filename);
+ }
+ return f;
+ }
+
+ private void updateAuxiliary(Map<String,XModelObject> mc,
Map<String,File> mf) throws XModelException {
+ Iterator<String> it = mf.keySet().iterator();
+ while(it.hasNext()) {
+ String nm = (String)it.next();
+ File f = mf.get(nm);
+ XModelObject o = mc.get(nm);
+ if(o == null ||
!o.getModelEntity().getName().equals(FileAuxiliary.AUX_FILE_ENTITY)) continue;
+ it.remove();
+ FileAnyAuxiliaryImpl aux = (FileAnyAuxiliaryImpl)o;
+ mc.remove(nm);
+ if(aux.isObsolete()) {
+ FileAuxiliary h = aux.getAuxiliaryHelper();
+ XModelObject main = aux.getMainObject();
+ if(main != null && main.isActive() && h != null) {
+ String n = h.getAuxiliaryName(main);
+ String p = n + "." +
aux.getAttributeValue("extension");
+ XModelObject other = getChildByPath(p);
+ if(other != null && other != aux) other.removeFromParent();
+ aux.fileRenamed(n, aux.getAttributeValue("extension"));
+ aux.updateBodySource();
+ if(!isOverlapped()) {
+ File r = new File(f.getParentFile(), FileAnyImpl.toFileName(aux));
+ if(!r.equals(f) && f.exists()) {
+ if(!r.exists()) {
+ FileUtil.copyFile(f, r);
+ f.delete();
+ FileSystemPeer peer = getFileSystem().getPeer();
+ peer.unregister(f);
+ peer.register(r);
+
+ IFile ef = getChildFile(f.getName());
+ if(ef != null && !ef.isSynchronized(0)) {
+ try {
+ ef.refreshLocal(0, null);
+ } catch (CoreException e) {
+ ModelPlugin.getPluginLog().logError("Exception caught
in FolderImpl.update()");
+ }
+ }
+ ef = getChildFile(r.getName());
+ if(ef != null && !ef.isSynchronized(0)) {
+ try {
+ ef.refreshLocal(0, null);
+ } catch (CoreException e) {
+ ModelPlugin.getPluginLog().logError("Exception caught
in FolderImpl.update()");
+ }
+ }
+
+ } else {
+ f.delete();
+ getFileSystem().getPeer().unregister(f);
+ IFile ef = getChildFile(f.getName());
+ if(ef != null && !ef.isSynchronized(0)) {
+ try {
+ ef.refreshLocal(0, null);
+ } catch (CoreException e) {
+ //ignore
+ }
+ }
+ }
+ }
+ }
+ } else {
+ if(!isOverlapped()) {
+ updateRemove(aux);
+ f.delete();
+ getFileSystem().getPeer().unregister(f);
+ }
+ }
+ } else {
+ FileSystemPeer peer = getFileSystem().getPeer();
+ if(!registerFileInPeer(peer, f)) continue;
+ XModelObject main = aux.getMainObject();
+ if(main == null) continue;
+ File fmain = (File)mf.get(main.getPathPart());
+ if(fmain == null) continue;
+ peer.unregister(fmain);
+ setForceLoadProperty(main, true);
+ updateLoaded(main, fmain);
+ setForceLoadProperty(main, false);
+ mc.remove(main.getPathPart());
+ }
+ }
+ }
+
+ //returns true if registration was really done
+ private synchronized boolean registerFileInPeer(FileSystemPeer peer, File f) {
+ if(f.isFile() && peer.contains(f) && !peer.isUpdated(f)) return
false;
+ peer.register(f);
+ return true;
+ }
+
+ private void setForceLoadProperty(XModelObject f, boolean b) {
+ f.set("forceLoad", b ? "true" : "");
+ }
+
+ protected void updateLoaded(XModelObject o, File f) throws XModelException {
+ FileSystemPeer peer = getFileSystem().getPeer();
+ if(o instanceof FolderImpl) {
+ if(!o.getAttributeValue("name").equals(f.getName())) {
+ o.setAttributeValue("name", f.getName());
+ ((FolderImpl)o).getResource();
+ }
+ ((FolderImpl)o).update();
+ } else {
+ if(!registerFileInPeer(peer, f)) {
+ if(!f.getName().equals(FileAnyImpl.toFileName(o))) {
+ String n = f.getName();
+ int i = n.lastIndexOf(".");
+ String nm = (i >= 0) ? n.substring(0, i) : n;
+ String ext = (i >= 0) ? n.substring(i + 1) : "";
+ ((FileAnyImpl)o).fileRenamed(nm, ext);
+ }
+ return;
+ }
+ String p = FilePathHelper.toPathPath(f.getName());
+ int i = (!o.isModified() || unsynchronized == null ||
!unsynchronized.contains(p)) ? 0 : question(f);
+ if(i == 0) {
+ reload(o, f);
+ } else if(i == -100) {
+ final XModelObject o1 = o;
+ final File f1 = f;
+ Display.getDefault().asyncExec(new Runnable() {
+ public void run() {
+ if(question(f1) == 0) {
+ try {
+ reload(o1, f1);
+ } catch (XModelException e) {
+ ModelPlugin.getPluginLog().logError(e);
+ }
+ }
+ }
+ });
+ }
+ }
+ }
+
+ private int question(File f) {
+ if(Display.getCurrent() == null) return -100;
+ return getModel().getService().showDialog("Update",
+ "File " + f.getAbsolutePath() + " is externally modified.\n" +
+ "Do you want to reload it?", new String[]{"Yes", "No"},
null,
+ ServiceDialog.QUESTION);
+ }
+
+ public void updateChildFile(XModelObject o, File f) throws XModelException {
+ FileSystemPeer peer = getFileSystem().getPeer();
+ if(!registerFileInPeer(peer, f)) return;
+ int i = (!o.isModified()) ? 0 :
+ question(f);
+ if(i == 0) {
+ reload(o, f);
+ }
+ }
+
+ public boolean isChangedEntity(XModelObject o, File f) {
+ Properties p = getEntityProperties(f);
+ return (!o.getModelEntity().getName().equals(p.getProperty("entity")));
+ }
+
+ private void reload(XModelObject o, File f) throws XModelException {
+ Properties p = getEntityProperties(f);
+ if(!o.getModelEntity().getName().equals(p.getProperty("entity"))) {
+ o.removeFromParent();
+ createFileObject(f, p);
+ return;
+ }
+ BodySource bs = getBodySource(f);
+ if(isLateloadFile(o)) {
+ FileAnyImpl impl = (FileAnyImpl)o;
+ if(impl.getBodySource() != null) {
+ impl.setBodySource(bs);
+ fireObjectChanged(null);
+ } else {
+ impl.edit(bs.get());
+ impl.setModified(false);
+ XModelObjectLoaderUtil.updateModifiedOnSave(impl);
+ }
+ } else {
+ XObjectLoader loader = XModelObjectLoaderUtil.getObjectLoader(o);
+ if(loader != null) {
+ XModelObjectLoaderUtil.setTempBody(o, bs.get());
+ loader.update(o);
+ } else if(o instanceof Reloadable) {
+ ((Reloadable)o).reload();
+ } else if("FileAnyLong".equals(o.getModelEntity().getName())) {
+ o.setModified(false);
+ }
+ }
+ }
+
+ protected boolean updateNew(String pathpart, File f, Map<String,XModelObject>
toRemove) throws XModelException {
+ FileSystemPeer peer = getFileSystem().getPeer();
+ if(peer.contains(f) && !peer.isUpdated(f)) return false;
+ XModelObject c = null;
+ if(f.isDirectory()) {
+ Properties p = new Properties();
+ p.setProperty("name", f.getName());
+ c = getModel().createModelObject("FileFolder", p);
+ String pp = FilePathHelper.toPathPath(f.getName());
+ if(linked.containsKey(pp)) {
+ c.setObject("file", linked.get(pp));
+ }
+ } else {
+ Properties ep = getEntityProperties(f);
+ XModelObject old = findOldObject(ep.getProperty("entity"), toRemove);
+ if(old != null) {
+ String ofn = FileAnyImpl.toFileName(old);
+ if(!f.getName().equals(ofn)) {
+ File of = new File(f.getParent(), ofn);
+ peer.unregister(of);
+ String nm = ep.getProperty("name");
+ String ext = ep.getProperty("extension");
+ ((FileAnyImpl)old).fileRenamed(nm, ext);
+ }
+ updateLoaded(old, f);
+ } else {
+ createFileObject(f, ep);
+ }
+ }
+ peer.register(f);
+ return (c != null && addChild(c));
+ }
+
+ private XModelObject findOldObject(String entity, Map<String,XModelObject>
toRemove) {
+ if(entity == null || toRemove.size() == 0) return null;
+ Iterator<String> it = toRemove.keySet().iterator();
+ while(it.hasNext()) {
+ String nm = it.next().toString();
+ XModelObject o = (XModelObject)toRemove.get(nm);
+ if(o.getModelEntity().getName().equals(entity)) {
+ toRemove.remove(nm);
+ return o;
+ }
+ }
+ return null;
+ }
+
+ protected void updateRemove(XModelObject o) throws XModelException {
+ boolean d = (o instanceof FolderImpl);
+ FileSystemPeer peer = getFileSystem().getPeer();
+ File rf = getChildIOFile(o);
+ boolean c = (d && peer.containsDir(rf)) || ((!d) &&
peer.contains(rf));
+ if(!c) return;
+ int i = (!o.isModified()) ? 1 : question(o);
+ if(i != 0) {
+ o.removeFromParent();
+ } else {
+ saveChild(o, peer, rf);
+ XActionInvoker.invoke("Open", o, null);
+ }
+ if(d) peer.unregisterDir(rf); else peer.unregister(rf);
+ }
+
+ public void removeChildFile(XModelObject o) {
+ boolean d = (o instanceof FolderImpl);
+ FileSystemPeer peer = getFileSystem().getPeer();
+ File rf = getChildIOFile(o);
+ boolean c = (d && peer.containsDir(rf)) || ((!d) &&
peer.contains(rf));
+ if(!c) return;
+ if(o.getModel().getModelBuffer().source() == o && rf.exists() &&
o.getModelEntity().getAttribute("_file") != null) {
+ File temp = null;
+ try {
+ temp = File.createTempFile("efs_", rf.getName());
+ } catch (IOException e) {
+ ModelPlugin.getPluginLog().logError(e);
+ }
+ if(temp != null) {
+ FileUtil.copyFile(rf, temp);
+ temp.deleteOnExit();
+ o.set("_file", temp.getAbsolutePath());
+ }
+ }
+ IResource r = (d) ? (IResource)
getChildContainer(o.getAttributeValue("name"))
+ : (IResource) getChildFile(FileAnyImpl.toFileName(o));
+ o.removeFromParent();
+ if(r.exists()) {
+ try {
+ r.delete(true, null);
+ } catch (CoreException e) {
+ ModelPlugin.getPluginLog().logError(e);
+ }
+ } else {
+ rf.delete();
+ }
+ if(d) peer.unregisterDir(rf); else peer.unregister(rf);
+ XModelObjectLoaderUtil.updateModifiedFlag(this);
+ }
+
+ private static int question(XModelObject o) {
+ String t = "File" + " " +
o.getModelEntity().getRenderer().getTitle(o);
+ return o.getModel().getService().showDialog("Update",
+ t + " is removed from the disk.\n " +
+ "Do you want to save your changes?", new
String[]{"Yes", "No"}, null,
+ ServiceDialog.QUESTION);
+ }
+
+ private boolean fire = false;
+
+ protected void fireStructureChanged(int kind, Object info) {
+ if(fire) super.fireStructureChanged(kind, info);
+ }
+
+ public boolean hasChildren() {
+ boolean q = super.hasChildren();
+ if (q || loaded) return q;
+ if(getParent() instanceof FolderImpl) {
+ FolderImpl p = (FolderImpl)getParent();
+ if(p.linked.containsKey(getPathPart())) return true;
+ }
+ File[] fs = getFiles();
+ q = (fs != null && fs.length > 0);
+ if(!q) loaded = fire = true;
+ return q;
+ }
+
+ public boolean save() {
+ File f = getFile();
+ if(f == null) return true;
+ if(f.exists() && !isModified()) return true;
+ if(isOverlapped()) return true;
+ boolean b = true;
+ if(!f.exists()) {
+ IContainer c = getResource();
+ if(getFileType() == FOLDER && c instanceof IFolder) {
+ IFolder ef = (IFolder)c;
+ try {
+ ef.create(true, ef.getParent().isLocal(0), null);
+ } catch (CoreException e) {
+ ModelPlugin.getPluginLog().logError(e);
+ }
+ }
+ if(!f.exists()) f.mkdirs();
+ }
+ File[] fs = getFiles();
+ Map<String,File> t = new HashMap<String,File>();
+ for (int i = 0; i < fs.length; i++) {
+ String p = FilePathHelper.toPathPath(fs[i].getName());
+ t.put(p, fs[i]);
+ }
+ FileSystemPeer peer = getFileSystem().getPeer();
+ peer.register(f);
+ XModelObject[] cs = getChildren();
+ for (int i = 0; i < cs.length; i++) {
+ if(cs[i].getModelEntity().getName().equals(FileAuxiliary.AUX_FILE_ENTITY))
continue;
+ if(cs[i] instanceof FolderLoader) {
+ b &= ((FolderLoader)cs[i]).save();
+ } else {
+ File d = linked.get(cs[i].getPathPart());
+ if(d == null) {
+ d = new File(f, FileAnyImpl.toFileName(cs[i]));
+ }
+ try {
+ b &= saveChild(cs[i], peer, d);
+ } catch (XModelException ee) {
+ //TODO maybe it should be rethrown
+ ModelPlugin.getPluginLog().logError(ee);
+ }
+ }
+ t.remove(cs[i].getPathPart());
+ }
+
+ cs = getChildren(FileAuxiliary.AUX_FILE_ENTITY);
+ for (int i = 0; i < cs.length; i++) {
+ File cf = getChildIOFile(cs[i]);
+ if(!cf.exists()) continue;
+ peer.register(cf);
+ FileAnyImpl impl = (FileAnyImpl)cs[i];
+ if(impl.getBodySource() == null) impl.setBodySource(getBodySource(cf));
+ t.remove(cs[i].getPathPart());
+ }
+
+ Iterator<File> it = t.values().iterator();
+ while(it.hasNext()) {
+ File df = it.next();
+ boolean d = df.isDirectory();
+ boolean r = (d && peer.containsDir(df)) || ((!d) &&
peer.contains(df));
+ if(!r) continue;
+ XModelObjectLoaderUtil.remove(df);
+ if(d) peer.unregisterDir(df); else peer.unregister(df);
+ }
+ if(b) setModified(false);
+ return b;
+ }
+
+ public boolean saveChild(XModelObject c) throws XModelException {
+ if(c == null || c.getParent() != this) return false;
+ if(!c.isModified()) return true;
+ File folder = getFile();
+ if(folder==null || !folder.exists()) return save();
+ updateLock++;
+ boolean b = false;
+ try {
+ File d = linked.get(c.getPathPart());
+ if(d == null) {
+ d = new File(folder, FileAnyImpl.toFileName(c));
+ }
+ saveChild(c, getFileSystem().getPeer(), d);
+ if(b) XModelObjectLoaderUtil.updateModifiedOnSave(c);
+ } finally {
+ updateLock--;
+ }
+ update(); // on action
+ ResourceMarkers.refreshProblemMarkersAsync(c);
+ return b;
+ }
+
+ private boolean saveChild(XModelObject c, FileSystemPeer peer, File cf) throws
XModelException {
+ boolean b = true;
+ if(!cf.exists()) c.setModified(true);
+ if(!c.isModified()) return true;
+ XObjectLoader loader = XModelObjectLoaderUtil.getObjectLoader(c);
+ if(loader != null) b &= loader.save(c);
+ BodySource bs = getBodySource(cf);
+ boolean h = (loader == null) || bs.write(c);
+ if(loader == null) saveFileWithoutLoader(cf, c);
+ if(h && c.isModified() || isChangedEntity(c, cf)) reload(c, cf);
+ b &= h;
+ peer.register(cf);
+ if(isLateloadFile(c)) {
+ FileAnyImpl impl = (FileAnyImpl)c;
+ if(impl.getBodySource() == null) impl.setBodySource(bs);
+ }
+ return b;
+ }
+
+ /**
+ * Used only by ObjectMultiPageEditor to prevent
+ * reload after saveX method. This is a precaution
+ * for the case when file update job may fail.
+ * @param child
+ */
+
+ public void updateRegistration(XModelObject child) {
+ if(child == null || child.getParent() != this) return;
+ File folder = getFile();
+ if(folder == null || !folder.exists() || getFileSystem() == null) return;
+ FileSystemPeer peer = getFileSystem().getPeer();
+ File cf = new File(folder, FileAnyImpl.toFileName(child));
+ if(!cf.exists()) child.setModified(true);
+ if(child.isModified()) return;
+ peer.register(cf);
+ }
+
+ private boolean saveFileWithoutLoader(File f, XModelObject o) {
+ if(!o.isModified()) return true;
+ if(o.getModelEntity().getAttribute("_file") == null) return true;
+ String sfn = o.get("_file");
+ if(sfn.length() == 0) return true;
+ if(f.getAbsolutePath().equalsIgnoreCase(sfn)) {
+ o.setModified(false);
+ return true;
+ }
+ File sf = new File(sfn);
+ if(sf.isFile()) {
+ f.getParentFile().mkdirs();
+ FileUtil.copyFile(sf, f);
+ }
+ o.set("_file", f.getAbsolutePath());
+ o.setModified(false);
+ return true;
+ }
+
+ public boolean changeChildTimeStamp(XModelObject c) throws XModelException {
+ if(c == null || c.getParent() != this) return false;
+ File cf = new File(getFile(), FileAnyImpl.toFileName(c));
+ if(!cf.exists()) return saveChild(c);
+ long s = cf.lastModified();
+ if(c.isModified()) {
+ saveChild(c);
+ if(s != cf.lastModified()) return true;
+ }
+ cf.setLastModified(System.currentTimeMillis());
+ getFileSystem().getPeer().register(cf);
+ return true;
+ }
+
+ public void discardChildFile(XModelObject c) throws XModelException {
+ if(c == null || !c.isActive() || !c.isModified() || c.getParent() != this) return;
+ c.setModified(false);
+ XModelObjectLoaderUtil.updateModifiedOnSave(c);
+ File folder = getFile();
+ if(!folder.exists()) return;
+ File cf = new File(folder, FileAnyImpl.toFileName(c));
+ String path = c.getPath();
+ setForceLoadProperty(c, true);
+ reload(c, cf);
+ setForceLoadProperty(c, false);
+ c = getModel().getByPath(path);
+ if(c != null) c.getChildren();
+
+ }
+
+ public static void parseFileName(Properties p, String fn) {
+ int i = fn.lastIndexOf('.');
+ String n = (i < 0) ? fn : fn.substring(0, i);
+ String e = (i < 0) ? "" : fn.substring(i + 1);
+ p.setProperty("name", n);
+ p.setProperty("extension", e);
+ }
+
+ public String getPathPart() {
+ String s = get("NAME");
+ return FilePathHelper.toPathPath(s);
+ }
+
+ public XModelObject getChildByPathPart(String pathpart) {
+ pathpart = FilePathHelper.toPathPath(pathpart);
+ return super.getChildByPathPart(pathpart);
+ }
+
+ static boolean isLateloadFile(XModelObject o) {
+ return (o.getModelEntity().getAttribute("_lateload") != null
&&
+ o.getModelEntity().getAttribute("body") != null);
+ }
+
+ static boolean isLateloadFile2(XModelObject o) {
+ return (o.getModelEntity().getAttribute("_lateload") != null);
+ }
+
+ protected void copy_children(XModelObject copy, boolean transform) {
+ super.copy_children(copy, transform);
+ if(copy instanceof FolderImpl) {
+ FolderImpl f = (FolderImpl)copy;
+ f.loaded = true;
+ f.fire = true;
+ }
+ }
+
+ private static int editability = -1;
+
+ private void initEditability() {
+ if(editability > -1) return;
+ editability = (null !=
getModelEntity().getActionList().getItem("DeleteActions").getItem("Delete"))
+ ? 1 : 0;
+ }
+
+ public boolean isObjectEditable() {
+ initEditability();
+ return (editability == 1 &&
!"true".equals(get("overlapped")) && isActive());
+ }
+
+ public String getMainIconName() {
+ if("true".equals(get("overlapped")) && isActive()) {
+ String oin = get("overlappedSystem");
+ XModelObject o = (oin == null || oin.length() == 0) ? null :
getModel().getByPath(oin);
+ if(o == null) {
+ o = this;
+ while(o != null && o.getFileType() != XFileObject.SYSTEM) o =
o.getParent();
+ }
+ if(o != null && o != this) return o.getMainIconName();
+ }
+ return super.getMainIconName();
+ }
+
+ public IContainer getChildContainer(String name) {
+ if(linked.containsKey(name)) {
+ IResource r = linkedResources.get(name);
+ return r instanceof IContainer ? (IContainer)r : null;
+ }
+ IContainer c = getResource();
+ return (c == null) ? null : c.getFolder(new Path("/" + name));
+ }
+
+ public IFile getChildFile(String name) {
+ if(linked.containsKey(name)) {
+ IResource r = linkedResources.get(name);
+ return r instanceof IFile ? (IFile)r : null;
+ }
+ IContainer c = getResource();
+ return (c == null) ? null : c.getFile(new Path("/" + name));
+ }
+
+ public IContainer getResource() {
+ if(!needUpdateResource()) return resource;
+ resource =
((FolderImpl)getParent()).getChildContainer(getAttributeValue("name"));
+ pathForResource = getPath();
+ return resource;
+ }
+
+ protected boolean needUpdateResource() {
+ if(resource != null &&
!resource.getName().equals(getAttributeValue("name"))) return true;
+ if(!isActive()) return false;
+ if(pathForResource == null || resource == null) return true;
+ String path = getPath();
+ return (path != null && !path.equals(pathForResource));
+ }
+
+ public IResource[] getResources() {
+ try {
+ if(!isActive()) return null;
+ IContainer c = getResource();
+ return (c != null && c.isAccessible()) ? c.members() : new IResource[0];
+ } catch (CoreException e) {
+ ModelPlugin.getPluginLog().logError(e);
+ return new IResource[0];
+ }
+ }
+
+ public boolean isOverlapped() {
+ XModelObject p = this;
+ while(p != null && !"true".equals(get("overlapped"))) p =
p.getParent();
+ return p != null;
+ }
+
+ public Object getAdapter(Class adapter) {
+ if(IResource.class == adapter) return getResource();
+ return super.getAdapter(adapter);
+ }
+
+ public boolean isRemoved() {
+ return resource != null && !resource.exists();
+ }
+
+}
+
+class FileBodySource implements BodySource {
+ private File f = null;
+
+ public FileBodySource(File f) {
+ this.f = f;
+ }
+
+ public String get() {
+ return XModelObjectLoaderUtil.readFile(f);
+ }
+
+ public boolean write(Object object) {
+ if(!(object instanceof XModelObject)) return false;
+ XModelObject o = (XModelObject)object;
+ return XModelObjectLoaderUtil.saveBody(f, o);
+ }
+
+}
+
+class EclipseFileBodySource implements BodySource {
+ private IFile ef = null;
+ private File f;
+
+ public EclipseFileBodySource(IFile ef, File f) {
+ this.ef = ef;
+ this.f = f;
+ }
+
+ public String get() {
+ return XModelObjectLoaderUtil.readFile(f);
+ }
+
+ public boolean write(Object object) {
+ if(!(object instanceof XModelObject)) return false;
+ XModelObject o = (XModelObject)object;
+ try {
+ XModelObjectLoaderUtil.saveBody(f, o);
+ /*
+ String r = XModelObjectLoaderUtil.getTempBody(o);
+ ByteArrayInputStream is = new ByteArrayInputStream(r.getBytes());
+ if(ef.exists()) ef.setContents(is, true, false, null);
+ else ef.create(is, true, null);
+ */
+ o.setModified(false);
+ XModelObject p = o.getParent();
+ while(p != null && p.getFileType() < XFileObject.FOLDER) p =
p.getParent();
+ if(p instanceof FolderImpl) {
+ ((FolderImpl)p).getFileSystem().getPeer().register(f);
+ }
+ ef.refreshLocal(IFile.DEPTH_INFINITE, null);
+ } catch (CoreException e) {
+ ModelPlugin.getPluginLog().logError(e);
+ }
+ return true;
+ }
+
+}