[pago]

Hi.

Ich versuche gerade, ein TreeModel zu implementieren, dass das Dateisystem anzeigt.
Der Teil ist auch schon fertiggestellt - war ja auch kein wirkliches Problem.
Was nun aber nicht funktioniert ist das verändern von Dateien.

Ich habe einen Großteil des Codes für das EventHandling direkt aus DefaultTreeModel kopiert (umschreiben kann ich's ja später immer noch).
Wie gesagt, dass anzeigen ist kein Problem. Die Datei wird sogar umbenannt, nur der Tree wird nicht geupdatet, d.h. es wird der alte Name angezeigt.

Hier mal meine bisherige Arbeit:

private class FileTreeModel implements TreeModel {
		private File[] roots;
		private Comparator fileComparator;

		public FileTreeModel(File[] roots) {
			this.roots = roots;

			fileComparator = new Comparator() {
				public int compare(Object o, Object o1) {
					File a = (File) o;
					File b = (File) o1;

		    		if ((a.isDirectory() && b.isDirectory()) || (a.isFile() && b.isFile())) {
		    			return a.getName().compareTo(b.getName());
					} else if (a.isDirectory()) {
						return -1;
					}
					return 1;
				}
			};
		}

		public FileTreeModel() {
			this(fileSystemView.getRoots());
		}

		public Object getRoot() {
			return this;
		}

		protected File[] getChildren(Object parent) {
			if (parent == this) {
				return roots;
			}
			File[] files = fileSystemView.getFiles((File) parent, true);
			Arrays.sort(files, fileComparator);
			return files;
		}

		public Object getChild(Object parent, int index) {
			return getChildren(parent)[index];
		}

		public int getChildCount(Object parent) {
			return getChildren(parent).length;
		}

		public boolean isLeaf(Object node) {
			return node != this && !((File) node).isDirectory();
		}

		public void valueForPathChanged(TreePath path, Object newValue) {
			File file = (File) path.getLastPathComponent();
			File newFile = new File(newValue.toString());
			if(file.renameTo(newFile)) {
				nodeChanged(newFile);
				nodeStructureChanged(newFile);
			}
		}

		public int getIndexOfChild(Object parent, Object child) {
			File[] files = getChildren(parent);
			for (int i = 0; i < files.length; i++) {
				if (child == files[i]) {
					return i;
				}
			}
			return 0;
		}

		protected EventListenerList listenerList = new EventListenerList();

		public void addTreeModelListener(TreeModelListener l) {
			listenerList.add(TreeModelListener.class, l);
		}

		public void removeTreeModelListener(TreeModelListener l) {
			listenerList.remove(TreeModelListener.class, l);
		}

		public void nodeStructureChanged(File node) {
			if(node != null) {
		       fireTreeStructureChanged(this, getPathToRoot(node), null, null);
			}
		}

		protected void nodeChanged(File file) {
			if (file != null) {
				File parent = file.getParentFile();
				if (parent == null) {
					nodesChanged(file, null);
				}

				int index = getIndexOfChild(parent, file);
				if (index != -1) {
		    		nodesChanged(parent, new int[]{index});
				}
			}
		}

		private void nodesChanged(File parent, int[] indices) {
			if (indices == null) {
		    	fireTreeNodesChanged(this, getPathToRoot(parent), null, null);
			} else {
				Object[] childNodes = new Object[indices.length];
				for (int i = 0; i < indices.length; i++) {
		    		childNodes[i] = getChild(parent, indices[i]);
				}
		    	fireTreeNodesChanged(this, getPathToRoot(parent), indices, childNodes);
			}
		}

		public File[] getPathToRoot(File aNode) {
			return getPathToRoot(aNode, 0);
		}

		protected File[] getPathToRoot(File aNode, int depth) {
			File[] retNodes;
			// This method recurses, traversing towards the root in order
			// size the array. On the way back, it fills in the nodes,
			// starting from the root and working back to the original node.

			/* Check for null, in case someone passed in a null node, or
			   they passed in an element that isn't rooted at root. */
			if (aNode == null) {
				if (depth == 0) {
					return null;
				} else {
					retNodes = new File[depth];
				}
			} else {
				depth++;
				if (aNode == getRoot()) {
					retNodes = new File[depth];
				} else {
		    		retNodes = getPathToRoot(aNode.getParentFile(), depth);
				}
				retNodes[retNodes.length - depth] = aNode;
			}
			return retNodes;
		}

		protected void fireTreeNodesChanged(
				Object source, Object[] path,
				int[] childIndices,
				Object[] children) {
			// Guaranteed to return a non-null array
			Object[] listeners = listenerList.getListenerList();
			TreeModelEvent e = null;
			// Process the listeners last to first, notifying
			// those that are interested in this event
			for (int i = listeners.length - 2; i >= 0; i -= 2) {
				if (listeners[i] == TreeModelListener.class) {
					// Lazily create the event:
					if (e == null) {
		    			e = new TreeModelEvent(
		    		    		source, path,
		    		    		childIndices, children);
					}
		    		((TreeModelListener) listeners[i + 1]).treeNodesChanged(e);
				}
			}
		}

		protected void fireTreeNodesInserted(
				Object source, Object[] path,
				int[] childIndices,
				Object[] children) {
			// Guaranteed to return a non-null array
			Object[] listeners = listenerList.getListenerList();
			TreeModelEvent e = null;
			// Process the listeners last to first, notifying
			// those that are interested in this event
			for (int i = listeners.length - 2; i >= 0; i -= 2) {
				if (listeners[i] == TreeModelListener.class) {
					// Lazily create the event:
					if (e == null) {
		    			e = new TreeModelEvent(
		    		    		source, path,
		    		    		childIndices, children);
					}
		    		((TreeModelListener) listeners[i + 1]).treeNodesInserted(e);
				}
			}
		}

		protected void fireTreeNodesRemoved(
				Object source, Object[] path,
				int[] childIndices,
				Object[] children) {
			// Guaranteed to return a non-null array
			Object[] listeners = listenerList.getListenerList();
			TreeModelEvent e = null;
			// Process the listeners last to first, notifying
			// those that are interested in this event
			for (int i = listeners.length - 2; i >= 0; i -= 2) {
				if (listeners[i] == TreeModelListener.class) {
					// Lazily create the event:
					if (e == null) {
		    			e = new TreeModelEvent(
		    		    		source, path,
		    		    		childIndices, children);
					}
		    		((TreeModelListener) listeners[i + 1]).treeNodesRemoved(e);
				}
			}
		}

		protected void fireTreeStructureChanged(
				Object source, Object[] path,
				int[] childIndices,
				Object[] children) {
			// Guaranteed to return a non-null array
			Object[] listeners = listenerList.getListenerList();
			TreeModelEvent e = null;
			// Process the listeners last to first, notifying
			// those that are interested in this event
			for (int i = listeners.length - 2; i >= 0; i -= 2) {
				if (listeners[i] == TreeModelListener.class) {
					// Lazily create the event:
					if (e == null) {
		    			e = new TreeModelEvent(
		    		    		source, path,
		    		    		childIndices, children);
					}
		    		((TreeModelListener) listeners[i + 1]).treeStructureChanged(e);
				}
			}
		}

		private void fireTreeStructureChanged(Object source, TreePath path) {
			// Guaranteed to return a non-null array
			Object[] listeners = listenerList.getListenerList();
			TreeModelEvent e = null;
			// Process the listeners last to first, notifying
			// those that are interested in this event
			for (int i = listeners.length - 2; i >= 0; i -= 2) {
				if (listeners[i] == TreeModelListener.class) {
					// Lazily create the event:
					if (e == null) {
		    			e = new TreeModelEvent(source, path);
					}
		    		((TreeModelListener) listeners[i + 1]).treeStructureChanged(e);
				}
			}
		}
	}

Jemand eine Idee?

[pago]

Ok. Nachdem ich nun weitergetestet habe, hat sich folgendes herauskristalisiert: Nicht das Model ist schuld, denn das feuer die Events richtig ab und gibt auch die richtigen Daten wieder.
Schuld ist irgendwas zwischen Renderer und Tree. Soll heißen: Der Renderer bekommt das und nicht das neue File übergeben, kann also auch nicht ordentlich arbeiten.

Edit: Habe eine Lösung gefunden.
Gefällt mir zwar nicht, aber sie funktioniert.
Wie's geht? Ganz einfach: Statt direkt mit dem File-Objekt zu arbeiten habe ich es in einer Wrapper-Klasse (FileNode) untergebracht. ist zwar nicht schön, funktioniert aber hervorragend.

[NewYork]

Hallo,

dein Beitrag ist zwar schon ne ganze Weile her, aber vielleicht kannst Du nur kurz näher schreiben, wie du das gemacht hast. Ich bin auch gerade dabei ein TreeModel aufzubauen und die Aktualisierung klappt nicht.

Edit: Ich habs doch hinbekommen eine Erklärung ist also nicht mehr nötig

[pago]

Jau. TreeModel's schreiben ist echt nicht das einfachste - jedenfalls bis zu dem Zeitpunkt, an dem man es wirklich verstanden hat. Danach geht's recht flott von der Hand.