Socket JFileChooser übers Internet

[Mr.Bross]

Hi,

Viele von euch kennen bestimmt Teamviewer (TeamViewer - Free Remote Access and Remote Desktop Sharing over the Internet). Mit diesem kann man leicht eine Remote-Verbindung zu einem anderen Remote-Computer herstellen. Man kann über das Programm sogar Daten über einen JFileChooser (zumindest etwas in der Art --> bestimmt kein Java) auf den PC laden.
Ist dies auch in Java möglich?? Also dass ich mit dem JFileChooser eine Datei des "Remote"-Computers auswählen kann??

 

[SlaterB]

notfalls müsste man den Dialog nachbauen oder soweit modifizieren,
dass bei Auswahl eines Verzeichnisses ein (beliebiger) Request an den anderen Rechner gesendet und die Rückgabe dargestellt wird

wenn man nur weit genug ausholt kann man mit einfachen Zeichenbefehlen für die GUI und einer Socket-Verbindung quasi alles zwischen zwei Rechnern nachbauen,
wie hoch möchtest du denn anfangen, wie wenig selber machen?

Suchergebnisse wie
Google
schon durchgeschaut?

 

[Mr.Bross]

Tut mir Leid habe leider nicht genau verstanden wie du das gemeint hast... Ich werde es natürlich selbst machen, wenn ich erstmal ein Grundgerüst habe, wie ich so etwas machen kann. Ich werde mich vorerst mal bei google erkundigen (unter genanntem Suchbegriff). Hatte vorher einfach nur die falschen Suchbegriffe...

 

[Mr.Bross]

Ich habe gerade alles mögliche durchgelesen und herausbekommen, dass es am besten funktioniert, wenn ich die Klasse FileSystemView verschicke. (ObjectOutputStream?) Doch leider implementiert diese Klasse nicht Serializable. Also habe ich mir gedacht, eine Unterklasse von FileSystemView zu erzeugen und Serializable implementieren zu lassen. Ging auch alles so weit, nur jetzt liegt mein Problem beim umcasten von FileSystemView zu meiner eigenen Klasse:

FileSystemViewimplm view = (FileSystemViewimplm) FileSystemView.getFileSystemView();

Doch leider schmeißt er hier eine ClassCastException... Woran liegt das?? Wie kann ich diese Exception loswerden??

MFG

 

[SlaterB]

weil in dieser Methode eben Code wie

	if(File.separatorChar == '\\') {
	    if(windowsFileSystemView == null) {
		windowsFileSystemView = new WindowsFileSystemView();
	    }
	    return windowsFileSystemView;
	}

steht,
nur weil du irgendwo eine irrelevante Klasse definierst, gibt dieses System-Methode doch nicht auf einmal was anderes zurück,

wenn dann müsstest du selber ein Objekt deiner Klasse erstellen, und den Konstruktor
JFileChooser(FileSystemView fsv)
verwenden

 

[Mr.Bross]

Wie genau hast du das gemeint mit "Objekt deiner Klasse erstellen, und den Konstruktor JFileChooser(FileSystemView fsv) verwenden"?? Ich habe jetzt eine neue Klasse gemacht, die Serializable implementiert und in deren Konstruktor ein FileSystemView mitgegeben wird:

public FileSystemViewimplm(FileSystemView view) {

		this.view = view;

	}

Jedoch kommt diese Exception:

Exception in thread "main" java.io.WriteAbortedException: writing aborted; java.io.NotSerializableException: javax.swing.filechooser.WindowsFileSystemView

Caused by: java.io.NotSerializableException: javax.swing.filechooser.WindowsFileSystemView

 

[SlaterB]

wie man ein Objekt einer Klasse erklärt und dieses Objekt im Konstruktor eines anderen Objektes als Parameter übergibt soll ich erklären?
oje

A a = new A(); // Objekt der Klasse A erzeugt
B b = new B(a); // a dem Konstruktor von B mitgeben

-------

deine Fehlermeldung hat ziemlich nichts mit diesem Thema oder dem geposteten Code zu tun,
du versuchst da ein WindowsFileSystemView-Objekt zu übertragen, was offensichtlich nicht deine eigenen Klasse ist sondern wieder an FileSystemView.getFileSystemView(); erinnert

 

[Mr.Bross]

Ich weiß schon, wie man ein Objekt im Kunstruktor übergibt :-D Ich wollte damit nur zeigen, dass es so auch nicht funktioniert...
Ich übergebe ja ein FileSystemView objekt mit einer Klasse(bzw in). Wird das Objekt dann automatisch auch Serializable oder muss ich da etwas beachten??
Das war eigentlich meine Frage!!!

 

[SlaterB]

ein Objekt ist genau dann Serializable, wenn die zugehörige Klasse (oder eine Oberklasse davon) das Interface implementiert

wie gesagt ist dein Problem wohl aktuell, dass du immer noch von FileSystemView.getFileSystemView() abhängst und deine eigene Klasse nicht beteiligt ist,

interessanten Code dazu hast du bisher nicht gepostet,
deine neue Klasse ist ja schön und gut, wichtiger ist aber, ob und wo sie dann im Gesamtprogramm ins Spiel kommt

 

[Mr.Bross]

Ok hier mal meine 3 Klassen:

Server:

import java.io.IOException;
import java.io.ObjectInputStream;
import java.net.ServerSocket;
import java.net.Socket;

import javax.swing.JFileChooser;
import javax.swing.JFrame;

public class FileChooserServer {

	private int x;
	private int y;

	public static void main(String args[]) throws IOException,
			InterruptedException, ClassNotFoundException
	{

		new FileChooserServer().los();

	}

	public void los() throws IOException, InterruptedException,
			ClassNotFoundException
	{

		ServerSocket sock = new ServerSocket(5009);

		Socket socket = sock.accept();

		System.out.println("accept");

		ObjectInputStream in = new ObjectInputStream(socket.getInputStream());

		JFrame frame = new JFrame();
		frame.setSize(500, 500);
		frame.setVisible(true);
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

		FileSystemViewimplm view = (FileSystemViewimplm) in.readObject();

		JFileChooser chooser = new JFileChooser();
		chooser.setFileSystemView(view.view);

		frame.add(chooser);

	}

}

Client:

import java.awt.AWTException;
import java.awt.Robot;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.net.Socket;

import javax.swing.filechooser.FileSystemView;

public class FileChooserClient {
	public static void main(String args[]) throws AWTException, IOException
	{

		new FileChooserClient().los();

	}

	public void los() throws AWTException, IOException
	{


		Socket sock = new Socket("localhost", 5009);

		FileSystemViewimplm view = new FileSystemViewimplm(FileSystemView
				.getFileSystemView());

		ObjectOutputStream ob = new ObjectOutputStream(sock.getOutputStream());

		ob.writeObject(view);
		ob.flush();

	}

}

Eigene Klasse: (Serializable implementiert)

import java.io.Serializable;

import javax.swing.filechooser.FileSystemView;

public class FileSystemViewimplm implements Serializable {

	private static final long serialVersionUID = 3725086757129163933L;

	public FileSystemView view;

	public FileSystemViewimplm(FileSystemView view) {

		this.view = view;

	}

}

 

[SlaterB]

ah, ok, jetzt versteh ich etwas mehr,
deine Klasse FileSystemViewimplm ist dann ziemlich wenig hilfreich, nur weil sie selber Serializable ist werden nicht beliebige enthaltene Attribute auch akzeptiert,
sonst könntest du ja ganz allgemein

class SeriUmschlag implements Serializable {
Object any; // beliebiges Objekt übertragen
}

kodieren und verwenden, der Klassenname wäre egal,
so gehts nun leider nicht,

du musst schon wirklich einen richtigen FileSystemView implementieren,
siehe z.B.
class MyFileSystemView extends FileSystemView
in
http://meinews.niuz.biz/jfilechooser-t50815.html

was bringt es aber auch überhaupt, den übers Netzwerk zu übertragen?
wenn eine Klasse lokal (Rechner A) Dateien lesen kann, kann man die Klasse doch nicht einfach übers Netz schicken und dann hoffen, dass sie dann dort auf Rechner B auf einmal Informationen über Rechner A anzeigt,

ohne dir jetzt direkt fertige Alternativen aufzuzeigen (nochmal die google-Suche) glaube ich dass dieser Ansatz erstmal zu nix führt,

eine eigene FileSystemView-Klasse ist vielleicht schon richtig, aber diese Klasse muss dann nicht Serializable sein und übertragen werden, sondern Anfragen an den anderen Rechner senden

 

[slawaweis]

@Mr.Bross
so wird es nicht gehen. Du hast den komplett falschen Ansatz. Ich versuche es mit einem Schachspiel über Brief zu erkläre. Zwei geographisch entfernte Spieler haben jeweils ein Schachbrett mit Figuren und schicken sich abwechseln nur den nächsten Zug. Du versuchst jedoch gerade das ganze Schachspiel in ein Postpaket zu stopfen und zu verschicken.

Was Du brauchst ist entferntes Dateimanagement, wie z.B. bei FTP. Es gibt noch andere Protokolle, besser oder schlechter. In Java ist es nicht per Default eingebaut, dass muss man sich selber basteln. Du musst dir ein eigenes FileSystemView ableiten und dahinter die Kommunikation mit anderen Rechnern regeln. Oder man sucht nach schon fertigen Lösungen. FileSystemView.getFileSystemView() ist nur die Ansicht des lokalen Systems, der lokalen Festplatten. Es ist nicht serialisierbar und es hat auch keinen Sinn das zu versuchen.

Slawa

 

[Mr.Bross]

Ich fand es für das Einfachste, da man einfach mit setFileSystemView() die Pfade einbauen kann. Ich könnte auch alle Daten auslesen und als Strings verschicken. Jedoch wie bekomme ich diese dann in den JFileChooser hinein??

 

[SlaterB]

du brauchst eine FileSystemView-Klasse, wie ich im letzten Post verlinkt hatte, wobei dort recht wenig implementiert ist,
google-Suche!

FileSystemView hat

getFiles

public File[] getFiles(File dir,
boolean useFileHiding)

Gets the list of shown (i.e. not hidden) files.

das wird vom JFileChooser angefragt und der FileSystemView kann dann was zurückliefern,
ob vom lokalen Dateisystem, aus einem Märchenbuch oder aus dem Netz auf beliebigen Wege ermittelt

andere Methoden wie
getRoots
oder
getHomeDirectory
bestimmen vielleicht die initiale Sicht des JFileChoosers

 

[slawaweis]

Ich fand es für das Einfachste, da man einfach mit setFileSystemView() die Pfade einbauen kann. Ich könnte auch alle Daten auslesen und als Strings verschicken. Jedoch wie bekomme ich diese dann in den JFileChooser hinein??

gar nicht. Alle Dateien könnte auch bedeuten ein paar Hunderttausend. Weiterhin besteht eine Datei aus mehr als nur einem Namen. Da ist die Größe, Attribute, Rechte, Kodierung usw.

Was Du brauchst ist ein System, welches nur die Metadaten anfragt, die gerade im JFileChooser angezeigt werden, also das aktuelle Verzeichnis. Immer wenn der Anwender zu einem anderen Verzeichnis wechselt, holt man sich die Daten für genau dieses Verzeichnis vom anderen System. So ist es sicher und performant. Für den JFileChooser muss man aber noch einen Layer bauen, eben eine eigene FileSystemView Klasse.

Darf ich die Aufgabe wissen? Weil ich das Gefühl habe, Du hast irgendwo einen globalen Denkfehler. Denn wo man Dateien anschaut, will man diese auch öffnen oder was anderes damit machen. Dann müssen diese aber auch übertragen werden. Für all das gibt es bereits Lösungen, vielleicht nur nicht mit dem JFileChooser. Ich würde Dir raten das VFS von Apache anzusehen:

Commons VFS - Commons Virtual File System

Da gibt es einen Wrapper für FTP. So bräuchte man nur einen FTP-Server auf einem Rechner und einen FileSystemView Wrapper für VFS auf dem anderen.

Slawa

 

[Mr.Bross]

Hi,

Also ich schreibe an einer Art "TeamViwer". Bild-zu-Bild übertragung, Maus bewegen, mit Tastatur schreiben(nicht alle Eingaben, da man ja unter Java so schlecht schreiben kann mit Robot), usw klappt auch schon (nach der Bestätigung).(Läuft alles über einen Server --> bisschen langsam) Es ist keine Schulaufgabe, wollte es einfach mal hinbekommen =) und habe leider kein Informatik in der Schule, da es nicht angeboten wird =( Bei Teamviewer gibt es ja auch die Möglichkeit, hin-und-herzuswitchen. Man sollte dort dann neue Verzeichnisse erstellen können, wie auch Dateien hoch und runterladen (ausgewähltess Verzeichnis). Dies kann ich jedoch noch mit einem Listener machen. Mein Problem besteht einfach darin, die Verzeichnisse am entfernten Rechner anzuzeigen.
Wie ich es jetzt verstanden habe, könnte ich jedes mal wenn ich in ein anderes Verzeichnis switche, eine Anfrage an den anderen Client schicken und dieser antwortet dann (durch Files? oder Strings?) mit den Verzeichnissen und Dateien die dort drinliegen.
Falls ich falsch liege, bitte korigieren =)

PS: Non-Standard-Klassen will ich nicht unbedingt benutzen, da nicht jeder diese runterladen müssen sollte, der das Programm starten will.

 

[Mr.Bross]

Liege ich nun richtig oder falsch?? Und wenn ich richtig liege, was für ein Objekt sollte ich dann verschicken?? (String, File, ...)

 

[SlaterB]

du liegst richtig und verschickst Strings, falls du keinen Grund für Files hast,
ich habe keinen, mehr als Name + Pfad brauchst du nicht

 

[Mr.Bross]

Und wie füge ich diesen String (mit dem Pfad zur Datei oder Namen von der Datei) dem JFileChooser hinzu??

 

[SlaterB]

upps Endlosschleife, das kommt mir so bekannt vor

29.06.2010, 15:00

Jedoch wie bekomme ich diese dann in den JFileChooser hinein??

29.06.2010, 15:07:

du brauchst eine FileSystemView-Klasse, wie [..]

es ist gewiss nicht einfach, aber doch ein Thema, was man finden kann,
ganz ohne Reaktion auf die diversen Tipps dann die Frage schlicht zu wiederholen ist etwas dürftig

 

[Mr.Bross]

So, ich bin nun durch viel Probieren ein bisschen weiter gekommen. Hier mal der Code (Noch nichts mit Sockets usw.):

MyFileSystemView-Klasse:

package de.rhz.jfilechooser;

import java.io.File;
import java.io.IOException;
import java.io.Serializable;
import java.util.HashMap;

import javax.swing.filechooser.FileSystemView;

public class MyFileSystemView extends FileSystemView implements Serializable {

	private HashMap<Integer, File> myFiles = new HashMap<Integer, File>();

	private static final long serialVersionUID = 3725086757129163933L;

	public void setMyFiles(File myFiles[])
	{

		try
		{

			HashMap<Integer, File> files = new HashMap<Integer, File>();

			for (int i = 0; i < myFiles.length; i++)
			{

				files.put(i, myFiles[i]);

			}

			this.myFiles.putAll(files);

		}
		catch (Exception ex)
		{

			ex.printStackTrace();

		}

	}

	public File createNewFolder(File folder) throws IOException
	{

		try
		{
			folder.createNewFile();
			return folder;

		}
		catch (Exception ex)
		{

			ex.printStackTrace();

			return null;

		}
	}

	public File[] getFiles(File ordner, boolean is)
	{

		File system[] = super.getFiles(ordner, false);

		int pieces = 0;

		HashMap<Integer, File> allFiles = new HashMap<Integer, File>();

		try
		{

			for (int i = 0; i < system.length; i++)
			{

				allFiles.put(pieces, system[i]);

				pieces++;

			}

			for (int i = 0; i < this.myFiles.size(); i++)
			{

				String myFilessplit[] = myFiles.get(i).getPath().split("\\\\");

				String myFilesPath = "";

				for (int i2 = 0; i2 < myFilessplit.length - 1; i2++)
				{

					if (myFilesPath.length() == 0)
					{
						myFilesPath = myFilesPath + myFilessplit[i2] + "/";
					}
					else
					{

						myFilesPath = myFilesPath + myFilessplit[i2];

					}

				}

				File myFilePath = new File(myFilesPath);

				if (ordner.getPath().length() <= myFilePath.getPath().length())
				{

					if (ordner.getPath().equals(
							(myFilePath.getPath()).substring(0, ordner
									.getPath().length())))
					{

						System.out.println("--------------- "
								+ this.myFiles.get(i));

						allFiles.put(pieces, this.myFiles.get(i));

						pieces++;

					}
					else
					{

						System.out.println("wrong: ");
						System.out.println(ordner.getPath());
						System.out.println(myFilePath.getPath());

					}

				}
				

			}

			File allFilesright[] = new File[allFiles.size()];

			for (int i = 0; i < allFiles.size(); i++)
			{

				allFilesright[i] = allFiles.get(i);

			}

			return allFilesright;
		}
		catch (Exception ex)
		{

			ex.printStackTrace();

			File allFilesright[] = new File[allFiles.size()];

			for (int i = 0; i < allFiles.size(); i++)
			{

				allFilesright[i] = allFiles.get(i);

			}

			return allFilesright;

		}

	}

}

und hier die main-Klasse:

package de.rhz.jfilechooser;

import java.io.File;
import java.io.IOException;

import javax.swing.JFileChooser;
import javax.swing.JFrame;

public class MainClass {

	private int x;
	private int y;

	public static void main(String args[]) throws IOException,
			InterruptedException, ClassNotFoundException
	{

		new MainClass().los();

	}

	public void los() throws IOException, InterruptedException,
			ClassNotFoundException
	{

		JFrame frame = new JFrame();
		frame.setSize(500, 500);

		File files[] = new File[5];

		files[0] = new File("C:/test1/lalalala.exe");
		files[1] = new File("C:/test2.jar");
		files[2] = new File("C:/test3.bat");
		files[3] = new File("C:/test4.ink");
		files[4] = new File("G:/test5.exe");

		JFileChooser chooser = new JFileChooser();

		MyFileSystemView fsv = new MyFileSystemView();

		fsv.setMyFiles(files);

		chooser.setFileSystemView(fsv);

		frame.add(chooser);

		frame.setVisible(true);
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

	}

}

Es klappt auch fast alles. Das Problem liegt bei Pfaden, die es nicht gibt (Ordner).
Nehmen wir dieses Beispiel: Ein File mit diesem Wert: "C:/test/test12345.exe". Er erstellt keinen Ordner, sondern erstellt auf C:/ einfach eine test12345.exe... . Vorausgesetzt man wechselt gerade in das Verzeichnis C:/ . Wenn es den Ordner test jedoch gibt, erstellt er auch nur in diesem die test12345.exe .

Woran liegt das?? Habe ich einen Denkfehler in meinem Programm??

PS: Ich habe das File extra hinzugefüght, nicht in der MainClass, sonst wäre es ja gar nicht hinzugefügt worden. Nur mal so, bevor hier gefragt wird =)

@SlaterB Viel gefunden habe ich nicht, jedoch hätte ich wirklich erst mal ein bisschen probieren sollen. Ich bin ja auch zu einem Ergebnis gekommen. Hiermit entschuldige ich mich =)

 

[SlaterB]

> Es klappt auch fast alles.

also bei mir klappt wenig, ich sehe am Anfang meinen Eigene Dateien-Ordner,
viele Methoden der FileSystemView sind ja auch nicht überschrieben

> Das Problem liegt bei Pfaden, die es nicht gibt (Ordner).
> Nehmen wir dieses Beispiel: Ein File mit diesem Wert: "C:/test/test12345.exe". Er erstellt keinen Ordner,

worum gehts hier, wie 'nimmt' man ein File?
geht es um den JFileChooser, welche Sicht ist vorher zu sehen, was wird ausgewählt, was gedrückt/ eingetippt?

oder hat es mit anderen Befehlen aus deiner main-Methode zu tun, etwa
files[0] = new File("C:/test1/lalalala.exe");
usw?

ist irgendeine Methode des MyFileSystemView deines Wissens nach beteiligt oder was passiert?

--------

du baust allgemein einen normalen FileSystemView nach oder?
mit welchem Ziel, von remote ist noch nicht viel zu sehen,
einen wirklichen FileSystemView braucht nur der Client für den JFileChooser als Anschluss,
wenn dann der Server angefragt wird, können es dort ganz normale Methoden einer beliebigen Klasse sein,
zur Vermeidung von Verwechslung besser nicht auch FileSystemView nennen, vielleicht FileServer oder so

 

[Mr.Bross]

Ich habe mir das so vorgestellt:

- Ich schicke eine Anfrage an den Clienten
- Dieser schickt mir die Ordner und Dateien von C:/
- Ich erstelle einen JFileChooser und übergebe diesem meine überschriebene FileSystemView-Klasse. Dieser übergebe ich dann diese Dateien und zeige sie an (setMyFiles).
- Wenn ich einen Ordner wechsle schickt der Server wieder eine Anfrage und bekommt wieder die Dateien und Ordner als Antwort
- Dies wird dann wieder meiner überschriebenen Klasse übergeben
- usw...

Mein Problem liegt beim anzeigen der Ordner im JFileChooser. Wenn ich ein File-Objekt mit dem Wert "C:/test/test111.exe" habe und ich es übergebe stimmt es noch. Doch in der überschriebenen Methode getFiles() ignoriert er einfach den ganzen Pfad und nimmt einfach nur den Namen der Datei (hier test111.exe) und fügt diesen hinzu.

 

[SlaterB]

hmm, ich persönlich kann da nicht mehr folgen, bei sind wie gesagt die 'Eigenen Dateien' zu sehen,
gewiss abhängig von FileSystemView-Methoden wie

public File getDefaultDirectory()

Return the user's default starting directory for the file chooser.

die du noch nicht überschrieben hast

-------

deine losen Beschreibungen wie
> Doch in der überschriebenen Methode getFiles() ignoriert er einfach den ganzen Pfad und nimmt einfach nur den Namen der Datei (hier test111.exe)

lassen mich auch vermuten, dass es etwas mit deinem Code wie
> String myFilessplit[] = myFiles.get(i).getPath().split("\\\\");
oder
> myFilePath.getPath()).substring(0, ordner.getPath().length()))
zu tun hat

gerade letzteres mag durchaus nicht funktionieren wenn es diese Verzeichnisse auf dem lokalen Rechner nicht gibt,
was brauchst du System-Methoden wie File.getPath() für deinen internen Code?
arbeite lieber nur mit Strings, die weißt doch genau wo jedes / oder \ steht usw.

in jedem Fall wären mehr konkrete Infos sinnvoll,
lasse JFileChooser weg und prüfe mit System.out.println was du an MyFileSystemView übergibst, und was danach drin steht/ zurückgegeben wird

 

[Mr.Bross]

Ok, jetzt schildere ich nochmal mein Problem. Ich habe es vorher wohl ein bisschen Dumm ausgedrückt. Und ich habe vorher nur als Probe meine eigenen Dateien anzeigen lassen. Einfach diese Methode ersetzen, dass es nur die neuen Dateien anzeigt:

public File[] getFiles(File ordner, boolean is)
	{

		int pieces = 0;

		HashMap<Integer, File> allFiles = new HashMap<Integer, File>();

		try
		{

			for (int i = 0; i < this.myFiles.size(); i++)
			{

				String myFilessplit[] = myFiles.get(i).getPath().split("\\\\");

				String myFilesPath = "";

				for (int i2 = 0; i2 < myFilessplit.length - 1; i2++)
				{

					if (myFilesPath.length() == 0)
					{
						myFilesPath = myFilesPath + myFilessplit[i2] + "/";
					}
					else
					{

						myFilesPath = myFilesPath + myFilessplit[i2];

					}

				}

				File myFilePath = new File(myFilesPath);

				if (ordner.getPath().length() <= myFilePath.getPath().length())
				{

					if (ordner.getPath().equals(
							(myFilePath.getPath()).substring(0, ordner
									.getPath().length())))
					{

						System.out.println("--------------- "
								+ this.myFiles.get(i));

						allFiles.put(pieces, this.myFiles.get(i));

						pieces++;

					}
					else
					{

						System.out.println("wrong: ");
						System.out.println(ordner.getPath());
						System.out.println(myFilePath.getPath());

					}

				}

			}

			File allFilesright[] = new File[allFiles.size()];

			for (int i = 0; i < allFiles.size(); i++)
			{

				allFilesright[i] = allFiles.get(i);

			}

			return allFilesright;
		}
		catch (Exception ex)
		{

			ex.printStackTrace();

			File allFilesright[] = new File[allFiles.size()];

			for (int i = 0; i < allFiles.size(); i++)
			{

				allFilesright[i] = allFiles.get(i);

			}

			return allFilesright;

		}

	}

Also mein Problem liegt ganz einfach darin, Ordner hinzuzufügen. Bei Dateien gibt es keine Probleme:

Sagen wir ich bin gerade in C:/ und ich habe diese Files hinzugefügt gehabt: (setMyFiles())

"C:/test1.exe"
"C:/test2.exe"
"D:/test3.exe"
"C:/TestOrdner/test4.exe"
"G:/test5.exe"

Jetzt werden genau diese Dateien angezeigt:

"test1.exe"
"test2.exe"
"test4.exe"

Bei "C:/TestOrdner/test4.exe" wird der "TestOrdner" ignoriert und einfach die test4.exe angezeigt. Und auch bei einem neuen Laufwerk ("G:/test5.exe") erzeugt er dieses nicht.
Wahrscheinlich liegt es daran, dass ich manche Methoden noch überschreiben muss, die ich noch nicht überschrieben habe. Jedoch welche sind dies?? Wann wird welche Methode aufgerufen??

Ich habe mal nach deiner Antwort getDefaultDirectory() überschrieben:

public File getDefaultDirectory()
	{

		System.out.println("Default");

		return null;

	}

Jedoch wird, egal was ich im JFileChooser mache, diese Methode nicht aufgerufen. Also ist es eigentlich unnötig diese Methode zu überschreiben?

MFG und Danke für die Gedult =)

 

[SlaterB]

die Methode wird evtl. nur einmal am Anfang aufgerufen, dafür müsstest du fsv im Konstruktor des JFileChoosers übergeben,

bei den Files gibts noch eine einfache Erklärung, auf die ich schon früher hätte kommen können, in
> public File[] getFiles(File ordner, boolean is)
sollst du exakt die Sicht des Verzeichnisses zurückgeben, da passt 'C:/TestOrdner/test4.exe' natürlich nicht rein, da müsstest du
'C:/TestOrdner/' zurückgeben,
und ob das dann eine Datei oder ein Verzeichnis ist, entscheidet vielleicht die Methode aus File, also müsstest du die File-Klasse überschreiben..,
oder es reicht die Methoden getSystemIcon(File f) + getSystemDisplayName(File f) im FileSystemView zu überschreiben

was FileSystemView alles kann musst du dir natürlich genau anschauen oder bei google suchen, was du bestimmt wieder nicht getan hast,
ich werde das nicht komplett für dich begleiten, das Thema scheint mir viel zu hoch für dich,
vorerst werde ich nicht mehr antworten, jedenfalls nicht so detailliert, höchstens bei wirklichen Kleinigkeiten,

zu den Laufwerken noch, weil ich mir das halb für mich selber angeschaut habe:

zu überschreibene Methoden für eine gewisse Wirkung, gibt noch mehr:

    public String getSystemDisplayName(File f)
    {
        System.out.println("getSystemDisplayName");
        return f.toString();
    }

    public boolean isFileSystemRoot(File dir)
    {
        System.out.println("isFileSystemRoot: "+dir);
        return dir.toString().length() < 4;
    }

    public boolean isRoot(File f)
    {
        System.out.println("isRoot "+f);
        return f.toString().length() < 4;
    }

    public File[] getRoots()
    {
        System.out.println("getRoots");
        
        File files[] = new File[2];

        files[0] = new File("C:/");
        files[1] = new File("G:/");
        return files;
    }

 

[Mr.Bross]

Ok Vielen Dank werd mich mal jetzt ein bisschen damit beschäftigen =) Und ich habe bei google mehrere Suchbegriffe eingegeben, jedoch nichts passendes gefunden, z.B. welche Methoden ich überschreiben muss.

 

[Mr.Bross]

Mmmhh eigentlich ist es ja eine Kleinigkeit, jedoch finde ich es bei google nicht... Ich habe die Methode getSystemDisplayName() überschrieben, und übergebe so meine Dateinamen. Auch das mit den Ordnern funktioniert jetzt =), nur leider wird kein Ordnericon angezeigt, sondern das Fileicon... Woran kann das denn jetzt liegen??

PS: Ist mir gerade aufgefallen. Wenn ich einen Pfad nehme, der existiert (z.B. C:/Users/) wird dieser auch mit dem richtigen Ordnericon angezeigt. Nur bei meinen "erfundenen" nicht, trotzdem kann man sie anklicken...

 

[Mr.Bross]

Ich habe herausgefunden, warum kein Ordnericon angezeigt wird:
Es wird gar nicht als Ordner angesehen. Wenn man normalerweise einen Ordner öffnet , muss man ihn doppelklicken. Bei diesem ohne Icon öffnet er sich jedoch sofort. Und wenn ich wieder zurückgehe, wird die gleiche Datei als Datei angesehen. D.h. ich kann sie so oft anklicken wie ich will, sie lässt sich nicht als Ordner öffnen, sondern nur als Datei. (Der JFileChooser verschwindet)

Tut mir Leid, aber ich komme einfach nicht auf die Lösung. Ich habe jetzt bei Google alles mögliche gesucht und auch ein paar Sachen ausprobiert (z.B. ein "/" oder "\\" hinter das File). Ich bitte dich, noch ein letztes mal zu helfen, denn wenn das klappt, muss ich nur noch die Server/Client - Angelegenheit machen, mit der ich keine Probleme haben sollte, da ich in diesem Thema viel mehr Erfahrung als bei diesem Thema habe =)

 

[SlaterB]

tja, ein bisschen habe ich wieder geschaut, (wenigstens dich eine Weile warten lassen ) aber ich wüßte da selber kaum weiter außer durch probieren
dass getSystemIcon() mit dem Icon zu tun hat ist nicht schwer zu erkennen, wenn du darauf nicht kommst..,
richtig selber Icons zurückgeben möchte man da aber kaum, dem Quellcode der Oberklassen nach ist nun wirklich File.isDirectory() entscheidend,
die Klasse kann man auch überschreiben und diese Methode


hinsichtlich Doppelklick schien mir Boolean isTraversable(File f) interessant, so richtig weit bin ich da aber nicht gekommen,
dafür liefert google bei 'isTraversable FileSystemView' aber nun wirklich auch Artikel, z.B.
Zeig' mir wer Du bist


so, doch wieder ne Antwort, aber kürzer..

 

[Mr.Bross]

Hi,

dass mit derMethode isTraversable(File f) klappt schon fast. Nun bin ich aber erstmal am Zweifeln... Kann man bei einem JFileChooser die Methode überschreiben, die aufgerufen wird, wenn ein File oder Ordner doppelgeklickt wird?? Denn es darf ja nicht einfach gestartet werden, es muss ja immer eine Anfrage an den Clienten gestellt werden. (Die Datei existiert auf diesem Rechner ja nicht)
Soll ich vllt doch lieber ein normales JFrame nehmen und dort die Dateien in einer JList hinzufügen??

PS: Falls du es wissen möchtest ich habe gegoogelt. Jedoch kein fund zum überschreiben des listeners (Doppelklick).
Das habe ich schonmal gefunden, zum Button überschreiben:

NetBeans-Forum • Thema anzeigen - jFileChooser mit dem Netbeans visual editor verwenden

Jedoch wie ich den MouseListener? überschreibe, habe ich nicht gefunden.

 

[SlaterB]

wieso einen Listener?
normal wäre doch, dass wieder im FileSystemView
> public File[] getFiles(File)
aufgerufen wird, und diese deine Methode dann alles weitere erledigt,

aber du hattest ja letztes Mal schon die 'letzte Frage', da brauch ich ja nun nicht mehr helfen

 

[Mr.Bross]

Ou man bin ich dumm... Stimmt ja =)