Das fertige Ergebnis sollte folgendermaßen aussehen (In Anlehnung an den rechts dargestellten Baum – die Nummerierung erfolgt von links nach rechts):

[Wurzel] + [Blatt 1, Ebene 1] + [Blatt 1, Ebene 2] + [Blatt 1, Ebene 3]
         |                    |                    ` [Blatt 2, Ebene 3]
         |                    ` [Blatt 2, Ebene 1] + [Blatt 3, Ebene 3]
         |                                         ` [Blatt 4, Ebene 3]
         `[Blatt 2, Ebene 1] + [Blatt 3, Ebene 2] + [Blatt 5, Ebene 3]
                             |                    ` [Blatt 2, Ebene 3]
                              ` [Blatt 2, Ebene 1] + [Blatt 3, Ebene 3]
                                                    ` [Blatt 4, Ebene 3]

Wir zeichnen also bei jeder Verzweigung ein Plus, dann den Namen des Blattes und immer so weiter, bis ein Blatt erreicht ist, dass sich nicht mehr verzweigt. Dann wird eine neue Zeile begonnen und so lange unter jedes Plus ein “|” geschrieben, bis man wieder auf dem Level angelangt ist, zu dem das Blatt gehört. Soweit so gut, ist ja nicht so komplex.

Die Probleme fingen bei mir an, als ich diese Idee in Code umsetzen musste: Ich hatte eine Liste mit Objektinstanzen, aus denen ein Baum generiert werden sollte.

Jedes Objekt hatte drei für die Ausgabe relevante Attribute:

Objekt* child1; //Der Pointer auf das erste Blatt dieser Objektinstanz
Objekt* child2; //Der Pointer auf das zweite Blatt dieser Objektinstanz
string name; // Der Name dieser Objektinstanz
//Die Pointer beziehen sich jeweils auf andere, in der Liste vorhandene Instanzen.

Also hatte ich folgende fixe Idee: Ich baue in das Objekt eine Funktion ein, die mir den String zusammenbastelt und sich, um die Verschachtelung darzustellen, wieder selbst aufruft. Damit muss ich nicht festhalten, welche Information von welchem Blatt nun ausgegeben werden soll. Fassen wir diese Idee in Pseudo-Pseudocode zusammen:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

# Die Funktion erhält eine Liste, in der jeder Index eine Zeile symbolisiert
# Zeile 1 also Index 0 usw...
def generate_tree (list_of_strings):
 # An die aktuelle Zeile den Namen unseres Blattes dranhängen
 list_of_strings.back().append( name )
 
# Wenn unser Objekt ein Kind hat, dann müssen wir ein 
# Plus dranhängen und die Rekursion anstoßen.
# Die Unterscheidung ob "+" oder "-" ist nicht notwendig, 
# sieht aber am Ende schicker aus:
 if has_child1:
  if has_child2:
   list_of_strings.back().append( "+" )
  else:
   list_of_strings.back().append("-")
 
  # Hiermit starten wir die Rekursion
  # Das Folgende soll einen Memberaufruf symbolisieren :)
  child1.generate_tree( list_of_strings )
 
 if has_child2: # Ein Objekt kann ja bis zu zwei Kinder haben
  buffer = "" #Einen Buffer anlegen
  # Die Position des letzten Plusses rausfinden
  p = list_of_strings.back().find_last_of( "+" ) 
  # Die Position des letzten Strichs rausfinden
  k = list_of_strings.back().find_last_of( "|" ) 
 
  if p < k: #Den höheren Wert der beiden müssen wir nehmen
   p = k
 
# Von 0 bis p in Einerschritten durchgehen
  for i=0 | i <= p | i++
   if i < p:
    if list_of_strings.back()[i] == "+" or list_of_strings.back()[i] == "|":
     buffer.append( "|")
    else:
     buffer.append( " " )
   else if i == p:
    buffer.append( "`" )
 
  list_of_strings.append( buffer )
 
  # Wieder eine Rekursion starten
  # Das ist auch ein Memberaufruf
  child2.generate_tree( list_of_strings )
# ENDE der Funktion

So…diese Zeilen verlangen ein wenig nach Erklärung:
Zeile 1: Wir hängen den Namen des Blattes an das letzte Element in der Liste dran. Es ist egal ob die aktuelle Instanz jetzt Wurzel ist oder nicht. Wichtig ist nur, dass die übergebene Liste nicht leer ist. Dafür muss beim Aufruf der Funktion beim Wurzelelement gesorgt sein.

Zeile 11-15: Hier wird nur unterschieden, ob die aktuelle Instanz ein oder zwei Blätter hat und dementsprechend das Verbindungszeichen gewählt

Zeile 19/20: Hier wird die Funktion generate_tree bei dem ersten Kind aufgerufen, mit Übergabe der auch von dieser Funktion verwendeten Liste. Dadurch ist gewährleistet, dass alle ersten Kinder des jeweils vorhergehenden Blatts in einer Zeile stehen.

Zeile 21: Nun ist die Funktion für das erste Kind durchgelaufen, wenn es ein zweites Kind gibt, wird es nun etwas schwieriger, einen String zusammenzubauen.

Zeile 22-26: Es wird ein Puffer angelegt (er wird am Ende die neue Zeile enthalten, die wir zusammengebaut haben), der Index des letzten Plusses und der Index des letzten senkrechten Striches herausgefunden. Zur Erinnerung: Striche sollten die Verzweigung über mehrere Zeilen hinweg kenntlich machen. Plusse sollten zeigen, dass dieses Blatt mehr als ein Kind hat.

Zeile 28-Ende: Die Zuweisung in Zeile 29 macht nur Sinn, wenn man sich die for-Schleife danach anschaut. Wir gehen jeden einzelnen Index der letzten Zeile in der Liste bis p durch. p ist der Index des letzten Plusses/letzten Striches, je nachdem welcher Index höher ist. Solange i < p gilt, wird unter jeden Strich/jedes Plus ein weiterer Strich gehängt (indem man dieses Zeichen an den Puffer hängt). Haben wir p erreicht, so wird ein “`” an den Puffer gehängt, weil jetzt endlich der Name des zweiten Kindes kommen kann.
Dazu hängen wir den Buffer an die Liste dran (er symbolisiert ja eine neue Zeile) und rufen generate_tree bei dem zweiten Kind auf, mit unserer Liste als Parameter.

—–

Eine Implementierung dieses Algorithmus in C++ könnte folgendermaßen aussehen: *klick*

Die Funktion funktioniert allerdings nur unter zwei Bedingungen:

• Verwendung eines Monospace-Fonts bei der Ausgabe
• Die übergebene Liste ist beim Aufruf der Funktion beim Wurzelelement NICHT leer. Sie muss mindestens einen leeren String enthalten.

Zuerst einmal hat man die Wahl zwischen splashy und fbsplash. Ich habe mich für fbsplash entschieden und werde es in diesem Artikel behandeln.

fbsplash findet man im AUR und im Wiki eine sehr gute Einführung dazu. Ich bin den Leitfaden mehrere Male durchgegangen und immer wieder auf die gleiche Problematik gestoßen:

• Beim Hochfahren bekomme ich eine Fehlermeldung: ‘fbsplash was unable to start…theme not found’
• Beim Herunterfahren funktioniert der Splash

Abhilfe lässt sich mit folgender kleinen Änderung an den Kernelargumenten schaffen:

logo.nologo quiet console=tty1 vga=792 splash=silent,fadein,
fadeout,theme:<theme-name>

Den oben rot markierten Framebuffer-Wert gilt es nun mit dem gewünschten (und vom  Theme unterstützten!) Auflösungswert zu ersetzen, damit der Framebuffer auf den Wert gesetzt ist für den das Theme in /etc/conf.d/splash konfiguriert wurde – sonst startet fbsplash einfach nicht und es gibt die bekannte Fehlermeldung. Über diesen gesuchten Wert gibt uns folgender Befehl Aufschluss:

# hwinfo --framebuffer

hwinfo im AUR

In meinem Fall sähe die geänderte Argumentzeile folgendermaßen aus:

logo.nologo quiet console=tty1 vga=0x0324 splash=silent,fadein,
fadeout,theme:archax

Natürlich kann man die 0×0324 auch in 804 konvertieren und hinter vga= schreiben, das ist aber reine Geschmackssache.

Ich vermute, dass die Startschwierigkeiten entweder mit meiner x86_64-Version von Arch zusammenhängen oder mit meiner Hardware:

AMD Phenom II X4 955 BE

4GB OCZ DDR3-1600

ATI Radeon HD 4870 Vapor-X 2GB von Sapphire

Im Wiki ist nämlich auch ein Wikipedia-Artikel mit den Framebuffer-Codes verlinkt, die für 1280×1024 funktionieren sollen – bei mir tun sie es _nicht_: *klick*

Nachdem fbsplash nun bei mir startete, flackerte es kurz nach seinem Start und wurde nach links verschoben – irgenwdie unschön. Die einzige Lösung die ich dafür finden konnte, war folgende Änderung an /etc/mkinitcpio.conf vorzunehmen und damit den Start von fbsplash hinter die Änderung der Bildschirmauflösung durch den Kernel zu legen:

HOOKS=”base udev fbsplash autodetect pata scsi sata filesystems”

ändern zu

HOOKS=”base udev autodetect pata scsi sata filesystems fbsplash“

Es funktioniert, aber man sieht eben mehr von der Konsole und weniger vom Splash.

Für jegliche Lösungsvorschläge bin ich dankbar!

Für alle, die an einem nicht so wirklich richtig funktionieren Paketmanager gescheitert sind, ist hier der Leitfaden:

1.  Qwt Libraries runterladen und entpacken in Verzeichnis X:

http://www.qwt.sourceforge.net

tar -xzf foo.tar.gz

2. Dann folgende Konsolenschritte:

cd ‘X‘ //Pfad in dem sich das extrahierte Qwt findet

qmake

sudo make

sudo make install

3. Damit sei es getan, könnte man meinen, doch ich musste die qwt-Libraries noch vermerken und zwar in /usr/local/lib/libc.conf

/usr/local/qwt-Name/lib

/*Name war in meinem Fall qwt-5.2.0*/

4. Und zum Schluss:

sudo ldconfig

Teilt mir bitte Fehler mit, ich habe die Methode bisher nur ein paar Mal verwendet.

adi64 und n0stradamus waren beim Osterpraktikum dieses Jahr dabei und konnten sich also den Laden etwas genauer anschauen.

Den ganzen Text sowie detaillierte Ausführungen zu jedem Tag gibts auf der extra Seite.