Ich für meinen Teil finde die Lösung mit den Null-Layouts eigentlich ziemlich reizvoll, da sie eine einfache und übersichtliche Möglichkeit bieten Komponenten auf dem Bildschirm zu platzieren. Insofern trug mich der Gedanke zu einem Layoutmanager, der alle Objekt anfangs über die setBounds()-Methode platziert und ausrichtet, im Falle einer Größenänderung der umgebenen Komponente jedoch in der Lage ist, die Verhältnisse neu anzupassen. Nach Möglichkeit der Gestalt, das die ürsprünglichen Größen- und Abstandsverhältnisse beibehalten werden. Eine passende Lösung habe ich mittlerweile gefunden und will hier kurz beschreiben, wie das Implementieren eines entsprechenden Layoutmanagers in Java von statten geht.

In Java werden die Layoutmanager als Strategie zur Gestaltung von Anzeigeelement aufgefaßt und als Interface realisiert. Es gibt zwei Typen von Layoutmanagern (LayoutManager und LayoutManager2), die wir für die Implementierung heranziehen können. LayoutManager2 ist dabei von LayoutManager abgeleitet und bietet mehr Methoden an, bzw. erfordert vom Entwickler mehr Methoden zu implementieren. Will man einen Layoutmanager implementieren, so realisiert man eine Klasse und läßt diese per Implements-Statement von den LayoutManagern “erben”. Durch das Ausarbeiten der einzelnen Methode definiert man dann das Verhalten des Managers.

Der Kern beider Layoutmanager bildet die Methode “layoutComponent()“. Diese Methode bekommt eine Referenz auf jene Komponente übergeben, für das der Layoutmanager ein Layout berechnen soll. Vorher muß der Manager natürlich wissen, welche Komponenten er da eigentlich verwalten soll. Zu diesem Zweck muss der Manager buch über alle Komponenten führen, die einem Design hinzufügt wurden. Dafür ist die addLayoutComponent()-Methode zuständig, die offenkundig innerhalb der add()-Methode aufgerufen wird, über die jede von Container abgeleitete Klasse verfügt. Für die Entwicklung eines Layout-Managers, der initial mit Bounding-Boxes arbeiten soll, müssen wir jeder Komponente weitere Informationen mitgeben. Namentlich sind das die Angabe, wo sie im Anzeigebereich mit welchen Abmessungen platziert werden soll. Das Problem hier ist, das die add()-Methode neben der Übergabe der eigentlich Komponente lediglich ein weiteres Objekts als Parameter zuläßt (in der Dokumentation “Constrains” genannt). Ist die Komponente dem Layout hinzugefügt, können wir jedoch nicht mehr so einfach darauf zugreifen, um Einstellungen darauf vorzunehmen. Wir brauchen also ein Objekt (diesmal auch vom Typ Object) über die wir diese Informationen an den Layoutmanager herantragen können. Da es keine Standardklasse gibt (bzw. ich keine gefunden habe), die unsere Anforderungen erfüllt, müssen wir sie selbst implementieren. Wir erzeugen also eine Klasse und haben wir damit unseren Informationsträger, den wir der add()-Methode übergeben können. Per Default erben schließlich alle Klassen in Java von Object.  Die so erzeugten Objekte enthalten die absolute Position innerhalb des darstellenen Komponente, sowie deren Höhe und Breite als Attribute und stellen Methode bereit, um diese zu verändern. Für die Implementierung sind es reine “Wegwerf”-Objekte, die direkt im Aufruf der add()-Methode annonym erzeugt werden und vom Garbage-Collector wieder eingesammelt werden können, sobald die entsprechenden Informationen beim Layoutmanager angekommen und ausgelesen wurden. Hier der komplette Quelltext der Klasse:

public class Bounds
{
	private int x, y, width, height;

	public Bounds(int x, int y, int width, int height)
	{
		this.x = x;		// x Position
		this.y = y;		// y Position
		this.width = width;	// Breite
		this.height = height;	// Höhe
	}

	// Getter
	public int getX()
	{
		return x;
	}
	public int getY()
	{
		return y;
	}
	public int getWidth()
	{
		return width;
	}
	public int getHeight()
	{
		return height;
	}
}

Objekte dieses Typs werden die benötigten Informationen direkt im Konstruktor übergeben. Die Werte werden gespeichert und können dann vom Layoutmanager über die Getter genutze werden, um die Komponente zu platzieren. Man sieht: Eine recht einfache Klasse, die uns nur als Informationsträger dient.

Für die Verwaltung unserer Komponenten reichen diese beiden Klassen allerdings noch nicht aus. Unsere Layoutstrategie orientiert sich an der ursprünglichen Position aller Komponenten innerhalb der darstellenden Komponente und soll die Verhältnisse, die jede Komponente in Relation zu Höhe und Breite der umgebenen Komponente hatte, beim Neuberechnen des Layouts beibehalten (Den Satz kann man übrigens gern dreimal lesen…). Es reicht also nicht, wenn der Layoutmanager nur eine Referenz auf die verwalteten Komponente und deren ursprüngliche Position speichert, auch die Verhältnisse im ursprünglichen Anzeigebereich muß festgehalten werden. Zu diesem Zweck wird eine dritte Klasse benötigt. Die dritte Klasse speichert eine Referenz auf die verwaltete Komponente selbst und gleichzeitig für X und Y Koordinate, sowie für Höhe und Breite einen double Wert, der das Verhältnis von Höhe, Breite und Position in Relation zur aufnehmenden Komponente speichert. Hier einmal der Quelltext:

public class LayoutManagerComponent
{
	Component myComponent;
	double relativeX, relativeY;
	double relativeHeight, relativeWidth;
	double relativeFontSize;		

	public LayoutManagerComponent(Component comp)
	{
		myComponent = comp;
		relativeX = 0.0;
		relativeY = 0.0;
		relativeHeight = 0.0;
		relativeWidth = 0.0;
		relativeFontSize = 0.0;
	}
	// Setters
	public void setRelativeX(double relativeX)
	{
		this.relativeX = relativeX;
	}
	public void setRelativeY(double relativeY)
	{
		this.relativeY = relativeY;
	}
	public void setRelativeHeight(double relativeHeight)
	{
		this.relativeHeight = relativeHeight;
	}
	public void setRelativeWidth(double relativeWidth)
	{
		this.relativeWidth = relativeWidth;
	}
	public void setRelativeFontSize(double relativeFontSize)
	{
		this.relativeFontSize = relativeFontSize;
	}

	// Getters
	public Component getComponent()
	{
		return myComponent;
	}
	public double getRelativeX()
	{
		return relativeX;
	}
	public double getRelativeY()
	{
		return relativeY;
	}
	public double getRelativeHeight()
	{
		return relativeHeight;
	}
	public double getRelativeWidth()
	{
		return relativeWidth;
	}
	public double getRelativeFontSize()
	{
		return relativeFontSize;
	}
}

Wie man sieht, habe ich etwas gelogen. Diese Klasse speichert neben der relativen Position und relativen Größe auch einen Wert, der die relative Schriftgröße angibt. In der Tat ist auch die Größe der Schrift eine Aufgabe, die der Layoutmanager im Zweifel übernehmen muß, sonst passen sich zwar die Komponenten, die Schrift aufnehmen, der umgebenen Komponente an, der angezeigte Text bleibt jedoch unverändert. In jedem Fall sieht man auch hier, das die Klasse ein reiner Informationsträger ist und keinen Code enthält, der mehr mach als die Attribute zu verändern und diese von Außen zugänglich zu machen. Die Implementierung dieser Klasse erfolgt nun in Objekten des Layoutmanagers selbst. Werfen wir einen Blick auf den Quellcode des Layoutmanagers:

public class RelativeScaleAndPlacementLayout implements LayoutManager2
{
	ArrayList compsToCalc;
        double firstWidth, firstHeight;	

	public RelativeScaleAndPlacementLayout()
	{
		firstWidth = -1;
		firstHeight = -1;
		compsToCalc = new ArrayList();
	}
	public void addLayoutComponent(Component toAdd, Object bounds)
	{
		// Wir müssen erst casten.
		Bounds theBounds = (Bounds) bounds;
		// Anschließend Fonts ermitteln und dessen Größe speichern.
		// Die Relative Größe wird anhand der Höhe des Containers ermittelt.
		if (toAdd.getFont() != null)
		{
			Font tmpFont = toAdd.getFont().deriveFont(0, theBounds.getHeight() / 2);
			toAdd.setFont(tmpFont);
		}
		// Anschließend Platzieren.
		toAdd.setSize(theBounds.getWidth(), theBounds.getHeight());
		toAdd.setLocation(theBounds.getX(), theBounds.getY());
		compsToCalc.add(new LayoutManagerComponent(toAdd));
	}
	public Dimension maximumLayoutSize(Container parent)
	{
		int x, y;
		x = 0;
		y = 0;
		for (LayoutManagerComponent comp: compsToCalc)
		{
			y = y + comp.getComponent().getHeight();
			x = x + comp.getComponent().getWidth();
		}
		return new Dimension(x,y);
	}
	public void layoutContainer(Container parent)
	{
		Bounds tmpBs = new Bounds(0,0,0,0);
		float tmpFontSize = 0;
		Font tmpFont;
		// Wurde dieses Objekt schon initialisiert?
		if (firstWidth == -1 || firstHeight == -1)
		{
			// Nein, also speichern wir die augenblickliche Größe.
			firstHeight = parent.getHeight();
			firstWidth = parent.getWidth();
		}
		for (LayoutManagerComponent comp: compsToCalc)
		{
			if (comp.getRelativeX() == 0.0 && comp.getRelativeY() == 0.0)
			{
				comp.setRelativeX(comp.getComponent().getLocation().x / firstWidth);
				comp.setRelativeY(comp.getComponent().getLocation().y / firstHeight);
			}
			if (comp.getRelativeHeight() == 0.0 && comp.getRelativeWidth() == 0.0)
			{
				comp.setRelativeHeight(comp.getComponent().getHeight() / firstHeight);
				comp.setRelativeWidth(comp.getComponent().getWidth() / firstWidth);
			}
			if (comp.getRelativeFontSize() == 0.0)
			{
				comp.setRelativeFontSize(comp.getComponent().getFont().getSize2D() / firstHeight);
			}
			// Anschließend berechnet die neuen Bounds...
			tmpBs.setX((int)(parent.getWidth() * comp.getRelativeX()));
			tmpBs.setY((int)(parent.getHeight() * comp.getRelativeY()));
			tmpBs.setHeight((int)(parent.getHeight() * comp.getRelativeHeight()));
			tmpBs.setWidth((int)(parent.getWidth() * comp.getRelativeWidth()));
			// ...und die neue Schriftgröße...
			tmpFontSize = (float) (parent.getHeight() * comp.getRelativeFontSize());
			tmpFont = comp.getComponent().getFont().deriveFont(tmpFontSize);
			// ...dann wende sie auf das betrachtete Objekt an.
			comp.getComponent().setBounds(tmpBs.getX(), tmpBs.getY(), tmpBs.getWidth(), tmpBs.getHeight());
			comp.getComponent().setFont(tmpFont);
		}
	}
	public Dimension minimumLayoutSize(Container parent)
	{
		return maximumLayoutSize(parent);
	}
	public Dimension preferredLayoutSize(Container parent)
	{
		return maximumLayoutSize(parent);
	}
	public void removeLayoutComponent(Component comp)
	{
		for (LayoutManagerComponent comps : compsToCalc)
		{
			if (comps.getComponent() == comp)
			{
				compsToCalc.remove(comps);
				return;
			}
		}
	}
	public void addLayoutComponent(String name, Component toAdd)
	{
	}
	public float getLayoutAlignmentX(Container parent)
	{
		return 0;
	}
	public float getLayoutAlignmentY(Container parent)
	{
		return 0;
	}
	public void invalidateLayout(Container parent)
	{
	}
}

Gehen wir mal durch was diese Klasse tut. Es ist nicht viel. Eines der wichtigsten Attribute des Layoutmanages ist die ArrayList, die mit “LayoutManagerComponent” parametrisiert ist. Innerhalb des Layoutmanagers werden also alle Komponenten in einem Objekt vom Typ der zuvor besprochenen Klasse verwaltet. Wird dem Manager eine Komponente über die addLayoutComponent()-Methode hinzugefügt, wird die übergebenen Komponente zunächst auf die entsprechenden Abmessungen und Koordinaten eingestellt und ein neues LayoutManagerComponent-Objekt erzeugt, das die hinzugefügte Komponenten im Konstruktor als Parameter erhält und der ArrayList “compsToCalc” hinzugefügt wird. Im Konstruktor des LayoutManagerComponent-Objekts geschieht nichts weiter, als das die Referenz auf die zu verwaltende Komponente gespeichert wird und alle sonstigen Attribute auf 0.0 eingestellt werden. Damit sind zwar die Objekte initialisiert, aber noch nicht die richtigen Werte ermittelt und eingestellt. Diese Aufgabe wird in der layoutContainer()-Methode nachgeholt. Die layoutContainer()-Methode ist das Herzstück eines jeden Layoutmanagers. Diese Methode durch das Eventsystem jedesmal dann aufgerufen, wenn das Container-Objekt neugestaltet werden muß, da sich zum Beispiel die Größe geändert hat oder das Objekt zuvor verdeckt war und nun neu gezeichnet werden muß.

Wird die layoutContainer()-Methode dieses Layoutmanagers das erste mal aufgerufen (in der Regel also, wenn das Objekt zum ersten Mal auf dem Bildschirm angezeigt wird), so stehen noch die beiden Attribute “firstWidth” und “firstHeight” auf -1. Daran erkennt die Methode, das für diese Layoutmanager-Objekt noch keine initialen Werte gespeichert wurden und holt dies nach. Anschließend wird für jedes Objekt innerhalb der ArrayList geprüft, ob bereits die Werte für die relative Postion und Größe, sowie die relative Schriftgröße gespeichert wurden. Ist dies nicht der Fall, so werden diese Werte jetzt ermittelt und stehen ab dann für die Platzierung der Elemente zur Verfügung. Als Verhältnis wird einfach die aktuelle Position und Größe geteilt durch die initiale Höhe und Breite der Komponente angenommen. Die jeweiligen absoluten Positionen werden anhand der neuen Abmessungen des aufnehmenden Containers ermittelt, indem die entsprechenden Werte mit den relativen Werten multipliziert werden. Dieses Vorgehen wird auf alle Komponenten innerhalb der ArrayList angewandt und dies bei jedem Aufruf von layoutContainer.

Alle weiteren Methoden sind lediglich zier. Durch das LayoutManager-Konzept von Java sind sie zwingendermaßen zu implementieren und machen bei näherer Betrachtung auch Sinn. Für meine Fall waren sie aber einigermaßen bedeutungslos, auch wenn hier die ein oder andere Methode dennoch implementiert wurde.  Näheres dazu entnimmt man jedoch am Besten der Java-Dokumentation.

Softwareentwicklung ist eine komplizierte Sache, ich hoffe dennoch, ich konnte die Arbeit von Layoutmanagern in Java etwas veranschlaulichen. Wer sich den Quelltext der drei Klassen mal mit Kommentaren anschauen möchte, kann die Dateien unten herunterladen.

Bounds.java
Manager.java
ManagerComponent.java

Wie es bei solch einfachen Geräten asiatischer Herkunft oft so ist: Die Dokumentation ist wieder ziemlich sparsam. Insofern zeige ich hier mal kurz, wie man den Print-Server und das Laufwerk unter Window 7 zum Laufen bekommt. Nachdem das Gerät mit der FritzBox verbunden ist, beschafft es sich sofort eine Netzwerkadresse und bietet seine Dienste im Netz an. Die Konfiguration läuft auch bei diesem Gerät über eine HTML-Seite, die man aufrufen kann, wenn man die IP-Adresse des Gerätes in die Adresszeile des Browsers eintippt. Leider weiß man am Anfang nicht, welche Adresse das Gerät zugewiesen bekommen hat. Normalerweise könnte man die Adresse im Router selbst Auslesen, dieser fungiert bei den meisten als DHCP-Server und führt Buch über die vergebenen IP-Adressen. In meinem Fall spinnt die FritzBox etwas und läßt mich nicht mehr ins Routermenü, wo man solche Daten abfragen könnte. Abhilfe schafft hier der ARP-Befehl von Windows.

Unter Start "cmd" eingeben.

Über ARP lassen sich alle Netzwerkgeräte im lokalen Netz ausfindig machen (Wer mehr Hintergründe haben möchte, schau bitte hier.), solange sie über IP- oder MAC-Adresse verfügen. Ausgeführt wird er unter der Eingabe Aufforderung “CMD” von Windows. Unter Windows 7 geht man dazu auf “Start”, klickt in das “Suchen”-Feld ganz unten und gibt hier “cmd” ein. Nach dem Drücken der Eingabe-Taste sollte sich ein kleines Fenster mit schwarzem Hintergrund öffnen. Hier geben wir einfach den Befehl ein, zusammen mit der Option -a. Also:

“arp -a”

und Enter. Anschließend sehen wir eine Übersicht der Gerät im Netz, im Zweifel für jeden Netzwerkadapter eine. Es ist nicht sofort ersichtlich welches das Gerät ist, welches wir eigentlich suchen, da hier eine Menge mehr angezeigt wird, als wir eigentlich gewohnt sind. So sehen wir bei mir, als zweite Schnittstelle den Adressraum, die die FritzBox durch ihre Notfall-IP-Adresse aufspannt. Wir wissen ja, das die FritzBoxen in aller Regel auch über die “169.254.1.1″ zu erreichen ist. Ich will die Einträge nicht im einzelnen auseinander nehmen, wir suchen schließlich nur ein Gerät.

Übersicht der Adressen im lokalen Netzwerk.

Um das Richtige zu ermitteln, ist es hilfreich nur einen Rechner, den Router und eben den NAS-Adapter im Netz zu haben. Dann nämlich läßt sich die Adresse relativ leicht herausfinden. Wir konzentrieren uns bei der Suche auf die Geräte, die eine dynamische Adresse bezogen haben. Im Bereich 192.168.178.x sind dies genau zwei. Einmal die FritzBox selbst und der NAS-Adapter (mein Laptop hatte in diesem Beispiel die Adresse  192.168.178.21, diese steht oben drüber). Die FritzBox ist auf die 192.168.178.1 geeicht, also kann der Adapter nur 192.168.178.25 haben. Wir schnappen uns die Adresse und tippen sie in die Adresszeile des Browsers ein. Der Adapter begrüßt uns mit einer Anmeldemaske und fordert Benutzername und Kennwort. Standardmäßig ist dies “admin” und “admin”. Diese Daten sollten wir beim ersten Anmelden sofort ändern.

Menü des NAS-Adapters nach der Anmeldung.

Auf der Übersichtsseite kann man die ersten Informationen zu dem Gerät ablesen. Wir gehen als erstes in den Administrationsbereich und ändern das Kennwort des Standardbenutzers. Beim Passwort darauf achten, keine Umlaute zu verwenden, der Adapter ist auf englische Spracheinstellungen getrimmt. Hinterher ist es angebracht, im Menü “LAN Config” den dynamischen Adress-Bezug auf statisch zu ändern. Wir wollen Drucker und Laufwerk schließlich nicht jedes mal neu in Windows hinzufügen. Allerdings sollte man im Hinterkopf behalten, das die FritzBox unter Umständen die vergebene IP-Adresse später an ein anderes Gerät vergibt, insbesondere dann, wenn der NAS-Adapter mal ausgeschaltet sein sollte. Je nachdem, wie groß das eigene Netzwerk ist, wird diese Option Probleme machen. Dann sollte man darüber nachdenken, das gesamte Netzwerk mit statischen IP-Adressen zu betreiben. Im Menü “LAN Config” einfach den Punkt bei “Static IP as below” setzen und auf “apply” klicken. Anschließend können wir uns ein wenig im Menü umsehen und schauen, was das Gerät so macht.

Prinzipiell scheint dieser kleine Netzwerkapdater nicht ganz dumm zu sein. Gesetzt dem Fall, man schließt den Druker an die richtige USB-Buchse an, erkennt das Gerät den Drucker und macht ihn gleich im Netzwerk verfügbar. Man sieht es, wenn man auf “Print-Server” clickt. In meinem Fall hat er den Namen und Hersteller des Gerätes schon erkannt. Gut, dann fügen wir das Gerät auf dem Laptop hinzu. Das Hinzufügen ist unter Windows meiner Meinung nach etwas verwirrend, da man bei Einrichten von Netzwerkdruckern keinen Netzwerkdrucker installiert, sondern einen lokalen Drucker. Aber alles der Reihe nach.

Wir fügen einen lokalen Drucker hinzu!

Wir klicken auf “Start->Geräte” und Drucker und dort auf “Drucker hinzufügen” und gehen den Assistenten durch. Es beginnt, wie ich schon sagte, mit der verwirrenden Option “Einen lokalen Drucker hinzufügen”. Auf der nächsten Seite sollen wir den Anschluß am Rechner auswählen. Auch hier ist die Verwirrung erstmal groß, da der Druck ja nicht am Rechner angeschlossen ist und die Netzwerkkarte ist nicht dabei. Wir erstellen uns also wir einen neuen Anschluß. Ja, wir erstellen ihn einfach. Ohne auf die Details einzugehen: Aus Sicht des Betriebssystems sind alle Anschlüsse am Rechner nur als Software verfügbar, die über die Treiber der Hardware zur Verfügung gestellt werden. Für Windows macht es keinen großen Unterschied, ob das Gerät tatsächlich am Rechner angeschlossen ist oder nicht, das Betriebssystem muß nur wissen, wie es mit dem Gerät kommunizieren soll. Für Drucker hat sich bereits ein Standard entwickelt, der von so gut wie allen Netzwerkkarten unterstützt wird. Wir können diesen Standard nutzen. Der Begriff “Anschluß” ist hier mehr eine Metapher.

Standard TCP/IP-Porr wählen.

Wir wählen also als Option “Standard TCP/IP-Port”, da wir den Drucker ja über das Netzwerkprotokoll nutzen möchten. Und klicken auf “weiter”. Anschließend möchte Windows von uns wissen, wo der Drucker wohl zu finden ist. Hier tragen wir wieder die IP-Adresse des NAS-Adapters ein. Der Adapter weiß schon, was er zu tun hat, wenn wir ihn mit dem entsprechenden Print-Server-Protokoll ansprechen. Wir lassen den Haken bei “Drucker abfragen und den verwendeten Druckertreiber automatisch auswählen”. Vermutlich wird Windows nicht in der Lage sein, den Treiber automatisch auszuwählen, einen Versuch ist es jedoch wert. Hiernach versucht Windwos eine Verbindung zu dem Gerät aufzubauen. Dies kann eine Zeit dauern, man sollte also Geduld haben. Wurde der Drucker im Netz gefunden, wird Windows auf den Dialog “Abschließende Anschlussinformationen erforderlich” wechseln. Hier ändern wir die Option “Standard” auf “Benutzerdefiniert” und klicken auf “Einstellungen”. Im Nachfolgenden Dialog sind dann nochmal ein paar Optionen von Nöten, wie sie auch schon aus der “Dokumentation” des NAS-Adapters ersichtlich sind.

Einstellungen für den Druckerport.

Ich habe mich hier (ohne genau zu wissen, wofür die einzelnen Optionen da sind) einfach an die Vorgaben aus der Anleitung gehalten. Dabei habe ich den Portnamen wie in der Anleitung auf “IP_192.168.178.25″ geändert. Den Punkt bei “LPR” gesetzt, den Queue Name “LRxxxx” vergeben und den Byte-Zähler aktiviert. Anschließend auf “Ok” und im vorigen Dialog auf “weiter”. Windows sollte jetzt fragen, welchen Druckertreiber er für diesen Drucker verwenden soll. Bei meinem Drucker war es recht leicht, da er gleich in Windows 7 integriert war, ich mußte ihn nur noch auswählen. Sollte der Drucker nicht in der Auswählliste erscheinen, sollte man den entsprechenden Treiber installieren.

Am Schluß wird Windows eine Übersicht anzeigen und die Möglichkeit geben, eine Testseite zu drucken. Den Testdruck nehmen wir mit. Im Idealfall fängt der Drucker gleich an zu rödeln. Anschließend speichern; der Drucker sollte nun als Drucker in der Systemsteuerung verfügbar sein und damit von allen Anwendungen aus nutzbar sein.

Ein Problem bei diesen Printservern ist natürlich, das Multifunktionsgeräte etwas Stiefmütterlich behandelt werden. So kann der NAS-Adapter lediglich Drucken und nicht den Scanner an meinem Gerät bedienen (heißt ja auch Print-Server das Teil). Das nehme ich in Kauf, wenn ich doch mal etwas Scannen muß, wird der Drucker kurz direkt an den Laptop angeschlossen. Das kommt allerdings recht selten vor, deshalb mache ich mir darum noch keine Gedanken. Schauen wir einmal weiter, wie wir das Laufwerk einbinden können.

Unter dem Menüpunkt “Disk Tool” im Menü des Adapters können wir unser USB-Laufwerk im Idealfall bereits sehen. Dummerweise verlangt der Adapter von uns, das wir das Laufwerk als erstes Formatieren. Der Adapter unterstützt nur FAT32-Formatierungen und selbst, wenn das Laufwerk bereits im entsprechenden Format vorliegt, müssen wir die Platte erst formatieren. Offenbar wird durch die Formatierung ein Prozess angestoßen, durch den die Rechteverwaltung für das Laufwerk installiert wird. Augenscheinlich läuft auf diesem Apater ein abgespecktes Linux (oder ähnliches), welches die Ressourcen verwaltet. How ever. Wir müssen die Platte formatieren, gleichgültig ob es ein FAT32-Laufwerk ist oder nicht. Erst dann können wir auf das Laufwerk über diesen Adpater zugreifen.

Rechtsklick auf "Netzwerk".

Bei mir ging die Formatierung recht fix und ist sie abgeschlossen, kann man sich die beiden Optionen “File Server” und “FTP-Server” anschauen. Für beide Servertypen hat der Adapter Benutzer eingereichtet, die auf entsprechende Verzeichnisse zu greifen können. Auch hier gehen wir als erste daran und ändern die Kennwörter. Wenn wir beim Fileserver (übrigens ein Samba-Server, weshalb ich auf den Gedanken mit dem abgespeckten Linux gekommen bin) den Standardbenutzer  markieren und auf “modify” klicken, können wir oben das Kennwort ändern. In der Auswahl darunter sehen wir die Verzeichnisse, auf die der Benutzer Zugriff haben soll. Wir merken uns den Namen des Verzeichnisses, welches standardmäßig vergeben ist. Bei mir war es “public” und auf dieses Verzeichnis konnte sowohl der FTP-Benutzer als auch der Samba-Benutzer zugreifen. Es ist jedoch auch möglich hier neue Verzeichnisse anzulegen und entsprechende User dafür anzulegen. Je nachdem, wie man es mag. In Windows wird das entsprechende Verzeichnis später als Laufwerk zu sehen sein. Es ist also möglich mehrere Verzeichnisse anzulegen und entsprechend viele Netzwerklaufwerke einzubinden. Wenn wir den Benutzernamen und das Verzeichnis kennen, öffnen wir den Dateibrowser von Windows und schauen auf der linken Seite nach dem Menüpunkt “Netzwerk”. Darauf machen wir einen Rechtsklick und wählen die Option “Netzlaufwerk verbinden”. Nun geht ein Dialogfenster auf, in das wir die Adresse des Laufwerks eintragen müssen. Die Adresse ist abermals die IP-Adresse, die wir für den NAS-Adapter ermittelt haben.

Adresse und Pfad zum Laufwerk eintragen.

In meinem Fall also wieder die “192.168.178.25″. Wichtig ist hierbei, die Adresse mit zwei Schrägstrichen zu versehen (”Alt GR” + “ß”), sonst findet Windows nichts. Nach der Adresse selbst müssen wir noch das Verzeichnis angeben, welches wir vorhin im Menü “File Server” in den Benutzereinstellungen gefunden haben. In meinem Fall war dies “public”. Ist beides eingetragen, gehen wir auf “Fertig stellen” und Windows sollte anfangen das Laufwerk zu suchen. Hat Windows das Lauferk gefunden, fragt das Betriebssystem sofort nach den Anmeldedaten. Hiermit sind abermals die Daten gemeint, die in der Benutzerverwaltung des File Servers hinterlegt wurden. Sind diese Daten richtig eingetragen, fügt Windows das Laufwerk im Dateibrowser unter dem angegebenen Laufwerksbuchstaben hinzu. Ab jetzt kann normal darauf zugegriffen werden. Wir können also Dateien speichern, löschen und von dort kopieren. Verzeichnisse erstellen und entfernen. Gerad so, wie man es von Windows gewohnt ist.

Und jetzt probiere ich mal aus, was passiert, wenn man den Adapter vom Strom nimmt und zur Arbeit fährt…

Update: Alles Prima. Übrigens: Auf XP-Systemen läuft das Einbinden von Netzlaufwerk und Einrichten des Druckers genauso. Die Dialog sehen auch fast genauso aus.

Mehr Infos gibt´s auf den Wettbewerbsseiten selbst oder hier.

Da ich heute beschlossen habe, mal einen Tag frei zu machen, wollte ich es wissen. Mit ist schon vor einiger Zeit das “Freetz“-Projekt untergekommen. Die Entwickler dort haben es sich zur Aufgabe gemacht, eine einfach zu bedienende Umgebung für die Modifikation der FritzBoxen bereit zu stellen. Im Wesentlichen besteht sie aus einem Ubuntu-Linux, welches AVM-Firmewares generieren kann. Dieses Firmware kann man in seiner Box als Firmwareupdate hochladen. Ich habe das heute mal getestet. Also wie es klappt, was zu tun ist und wie das Ergebnis aussieht. Ich hatte mich schon auf das Schlimmste vorbereitet. Anleitungen und Recovery-Software von AVM besorgt, eine Sicherung der Einstellungen gemacht (meine 7113 ist immerhin die einzige Verbindung zur Außenwelt) und einfach mal darauflos getestet. Ergebnis: Wenn man den Tutorials auf der Freetz-Seite penibel folgt, dann klappt das mit den modifizierten Firmwares offenbar sehr gut. Nach dem Hochladen der Freetz-Firmware mußte ich bei mir nicht einmal die Zugangsdaten neu eintragen. Alle Einstellungen sind erhalten geblieben, bis hin zu den Anrufsperren, die ich für diverse Call-Center verhängt hatte.

Nun gut, die neue Firmware macht noch nichts außer eines weiteren Menüs anzubieten, dennoch fängt man sofort an zu überlegen, wie man die verbliebenen kBit des RAMs mit mehr oder weniger sinnvoller Software fülllen kann. Spätestens jetzt wird es Zeit für mich, sich auch mal mehr mit Linux-Systemen auseinander zu setzen. Und dann mal schauen, was man der Box noch so alles beibringen kann…

Neuerdings (oder mit ist es neulich zuerst aufgefallen) finden sich auch Werbeprospekte als Beilagen zu dieser Zeitschrift. Natürlich nur zu Umwelt relevanten Themen und vermutlich sogar auch recyceltem Papier. Dieses mal waren zwei Prospekte von Investment-Fonds dabei, die in Umweltprojekte investieren und mit guten Renditen locken. Ein Windenergie-Fonds und das Andasol-Projekt im Süden-Spaniens. Bemerkenswert, wie sich die Mitgliederstruktur der Partei verändert zu haben scheint, wenn Investment-Fonds jetzt gezielt an die Mitglieder der grünen Partei herantreten. Natürlich wird man dort am Ehesten auf Resonanz stoßen, allerdings mutet der Finanzdienstleisterjargon im grünen Umfeld doch schon sehr gewöhnungsbedürftig an. Oder kann mir jemand ad hoc sagen, was direkte und indirekte Kommanditbeteiligungen sind? Put-Options? Anyone? Bemerkenswert auch, das die Beteiligungssummen mindestens 5000 € betragen. Wer mehr will, muß in Tausenderschritten staffeln. Wenn das mal nicht nach Partei der Besserverdienenden klingt.

Natürlich wird die Energiewende zu mehr erneuerbaren Energien nicht ohne immensen Kapitaleinsatz von statten gehen und es ist auch nicht verwerflich, wenn jemand darin eine Chance sieht seine Rente etwas aufzubessern. Aber macht man deshalb gleich offensiv Werbung dafür in einer Mitgliederzeitung. Ich meine, das Andasol-Projekt wirbt offensiv mit dem Namen RWE, um das solide Finanzierungskonzept hervorzuheben. Also gerade die Firma, die Greanpeace immer wieder an den Pranger stellt für ihre eigentümliche Green-Washing-Kampangen. Und das in einer Ausgabe der Zeitung, in der auch ein Artikel über Green-Washing innerhalb der Autoindustrie zu finden ist.

Was ich mich als erste Frage ist:  Weswegen finde ich nur Material über geschlossene Fondsgesellschaften? Gessellschaften, die Beteiligungssummen von einem drittel Jahresgehalt erfordern, bevor man sie überhaupt erst in Erwägung ziehen kann? Es gibt doch noch andere Formen von Beteiligungsmöglichkeiten. Meines Wissens gibt es eine ganze Reihe von lokalen Projekten, die rund um das Thema “Erneuerbare Energien” enstanden sind und vorzugsweise als Genossenschaften organisiert werden. Das würde mich viel eher interessieren und darüber Informationen zu sammeln ist weitaus schwieriger. Meistens sind sie von der Größe her meist so klein, das sie weit unterhalb des Aufmerksamkeitsradars der etablierten Medien bleiben. Da könnte so eine Mitgliederzeitung doch eigentlich mal in die Bresche springen.

Die Aufgabe, die ich mir ausgesucht habe dreht sich um die Implementierung eines relativ einfachen Brettspiels. Der Name ist Claim It. Eine nähere Beschreibung gibt es hier. Zie der Aufgabe ist es im Wesentlichen ein funktionierendes Programm zu entwickeln, mit welchem sich Claim It spielen läßt. Dazu wurde ein Server zur Verfügung gestellt, mit dem sich verschiedene Clients verbinden können, um gegeneinander zu spielen. Die Entwicklung eines solchen Clients ist nun meine Aufgabe in den nächsten Wochen. Wobei es mit einem Client allein nicht getan ist. Zwar soll am Ende ein stabiles Programm stehen, welches mit einer ansprechenden Benutzeroberfläche daher kommt, mit dem ein menschlicher Spieler das Spiel spielen kann. Weiterhin soll aber auch eine kleine, abgestufte KI entwickelt werden, gegen die man spielen kann bzw. die gegen andere KI-Spieler antritt. Entwickelt wird in Java 1.5.

Die nächsten Wochen kann es also passieren, das hier verstärkt programmier-technisches Bla-Bla eingeht. Wenn das nicht interessiert, einfach ausblenden, das vergeht auch wieder.

Jetzt muß ich mal schauen, wie MEIN Arbeitgeber zu VDSL in meiner Gegend steht. Gut, war gemein ihm nicht zu sagen, das ich alles andere als Branchenfremd bin.

Ergänzen kann man nur noch: Um die Abozahlen hoch zu halten und damit den Preis für die Anzeigen im Blatt selbst, ist es unbedingt anzuraten viele kostenfreie Kuzrabos zu vergeben. Mindestens einmal im Quartal sind dazu alle Nicht-Abonennten, deren Kontaktdaten sich dennoch in den Datenbanken befinden, anzurufen und zwei wöchige Abos aufzuquatschen.

Die Bürger seien beim Selbstschutz ihrer Daten und Computer überfordert – Staat und Provider müssten sie dabei unterstützen. “Es ist falsch, im Staat eine bedrohende Instanz zu sehen. Er ist eine beschützende Instanz”, schrieb de Maizière.

Es ist schon länger klar, mit welchem Filter die üblichen Verdächtigen auf die Welt blicken; der unmündige Bürger ist dabei so etwas wie der Klassiker und das schon seit Adenauers Zeiten. Nichts anderes bedeutet es ja, wenn jemand den Menschen die Fähigkeit abspricht sich selbst um ihre Belange zu kümmern, um sich anschließend selbst für deren Erledigung ins Gespräch zu bringen. Der Bürger ist dumm und muß vor sich selbst beschützt werden. Dabei ist es unerheblich, ob nun gute Absicht vorherrscht oder nicht, ob uns jemand beschützen will oder nicht. Ob er es ermst meint oder ihn Hintergedanken plagen, die in der Durchsetzung ganz anderer Interessen begründet sind. Er erklärt mich für unfähig und bringt sogar noch dritte ins Gespräch, die dann meine Angelegenheiten bestellen sollen. Konzerne. Kopfschütteln reicht da eigentlich nicht mehr aus, ich liege schon mit dem Kopf auf der Tischplatte und hoffe, das der Schmerz nachläßt.
Von Erich Mielke ist der Satz überliefert: “Ich liebe doch alle Menschen.” und ich vermute, er hat damit nicht einmal gelogen. Sogar unser Innenminister will nur unser Bestes, was er nicht begreifen kann und will ist: Es liegt nicht in seiner Hand. Daran ändert sich auch nichts, wenn dem Minister laufend die Branchen- und Interessenverbände, undedarfte Internetnutzer und Industriekonzerne in den Ohren liegen und anmerken, man müsse mal was tun. Anstatt den Ministerflüsterern mal zu sagen, das sie ihre Angelegenheiten gefälligst selbst bestellen sollen (so wie man es von mündigen Bürgern erwartet), fühlt sich der gerade Berufene geehrt und rennt los und macht halt irgendwas. Und redet halt mal ein wenig. Nur, es liegt nicht in seiner Macht.
Reden wir über die Daten und Computer der Bürger, verlassen wir den Bereich der Inneren Sicherheit und sind direkt im Privaten; im ganz Privaten. Dafür ist keiner der Berliner Minister zuständig. Weder Minister, noch Kanzler, noch Bundespräsident, noch alle Zusammen und auf einmal. Das ist Sache der Bürger und nur der Bürger. Und sind diese nicht in der Lage ihre Angelegenheiten zu regeln, dann haben wir kein Problem in Sachen Innere Angelegenheiten, sondern ganz banal ein Bildungsproblem. Damit ist es Sache von Frau Schavan. In der Tat ist ganau das das Einzige, was ich unserem Gemeinswesen an Eingriff gestatten würde. Fortbildung in Sachen Internet. Solche kann das Innenministerium gern und zu hauf finanzieren und für alle Mitbürger kostenfrei halten. Herr  de Maizière könnte meinem Arbeitgeber auch die Kosten für meine Arbeit erstatten, damit ich auch in Zukunft den Internetnutzern das Internet erklären kann. Dummerweise habe ich nicht den Eindruck, das der Innenminister mit Mitteln winkt um die Situation zu verbessern. Nein, er und seines Gleichen wollen Gesetze machen. Der einzige Unterschied zu vorher ist, sie haben in den letzten ein einhalb Jahren Gegenwind verspürt und wollen wieder etwas Ruhe in die ganze Sache bringen. Da will jemand Ruhe in ein Medium bringen, welches von Unruhe lebt. Dummerweise ist dies nicht das einzige Mißverständnis.