Integration von chinesischen Schriftzeichen

Kurze Einführung in die chinesische Schrift  

Wer chinesische oder chinesisch-deutsche Software entwickelt, der besitzt im Allgemeinen zumindest rudimentäre Chinesisch-Kenntnisse. Trotzdem möchte ich für diejenigen, die sich ganz neu mit dieser Materie befassen, hier kurz die Eigenarten des Chinesischen darstellen.

Man könnte es in etwa so formulieren: unsere europäischen Schriften sind das Abbild des Gesprochenen - chinesische Schrift ist das Abbild des Gedankens.

Schauen wir uns ein chinesisches Schriftzeichen genauer an. Greifen wir doch einmal dasjenige Schriftzeichen heraus, welches die Unicode-Nummer 23665 (5C71 in hexadezimaler Schreibweise) trägt:

Dieses Schriftzeichen hat die Bedeutung "Berg". Man kann die Idee, die in diesem Schriftzeichen steckt, leicht mit einer Bergkette assoziieren. Gesprochen wird dieses Schriftzeichen "shan". Wo wir vier Buchstaben brauchen, um das Wort phonetisch darzustellen, benötigt das Chinesische nur ein einzelnes Schriftzeichen zur Darstellung dieses Objektes.

Lässt man das Schriftzeichen für Berg und das Schriftzeichen für Stein zu einem neuen Schriftzeichen verschmelzen, erhält man ... na klar: Felsen.

Jedes Schriftzeichen hat also eine ihm eigene, individuelle Bedeutung, wobei die Aussprache immer aus einer einzigen Silbe besteht, was je nach Landesregion jedoch sehr unterschiedlich ausfallen kann. Und genau das macht den Reiz der chinesischen Schrift aus: man muss nicht die Aussprache kennen, es reicht, die Schriftzeichen zu kennen, um den Inhalt des Textes verstehen zu können.

Nun gibt es nicht für jeden Begriff ein eigenes Schriftzeichen. Genau, wie es im deutschen Worte gibt, die sich aus meist zwei anderen Worten zusammensetzen - "Fensterbank" z.B. -, gibt es solche Konstruktionen auch im Chinesischen. Schreibt man die Schriftzeichen für "Felsen" und für "dickflüssig" hintereinander, erhält man "dickflüssiges Gestein", nämlich "Lava".

Stellen wir nun einen deutschen Satz seiner korrekten Übersetzung in die chinesische Schrift und die Chinesische Sprache gegenüber. Alle drei folgenden Beispielstexte sind mit Schrift-Größe 12 erstellt, für die Texte in lateinischen Buchstaben wurde "Arial" benutzt, für die chinesischen Schriftzeichen "SimSun":

Hier erkennt man einen weiteren, nicht zu unterschätzenden Vorteil der chinesischen Schrift: da ein chinesisches Wort in der Niederschrift meist viel weniger Platz benötigt als ein deutsches Wort, lassen sich chinesische Texte in für uns Europäer erstaunlicher Geschwindigkeit "lesen", da man sofort die Idee erfassen kann und nicht erst den Umweg übers Phonetische gehen muss.

Für Software-Entwickler sind im Zusammenhang mit der chinesischen Schrift hingegen drei andere Aspekte besonders interessant, die ebenfalls an obigem Beispiel erkennbar sind:

• Chinesische Schriftzeichen haben alle das gleiche quadratische Format.
• Auf Grund ihres komprimierten Sinngehaltes benötigen chinesische Texte grundsätzlich erheblich weniger Platz als Texte europäischer Sprachen. Ein deutscher Satz, der in Deutsch niedergeschrieben zwei Zeilen lang ist, braucht auf chinesisch übersetzt und in Schriftzeichen dargestellt nur noch eine, höchstens anderthalb Zeilen.
• Jedes Schriftzeichen ist gleich weit vom nächsten entfernt, es wird kein Leerzeichen nach zwei (oder mehr) gemeinsam ein Wort bildenden Schriftzeichen gesetzt, selbst der Punkt ist in Blocksatz und wird nicht von einem Leerzeichen gefolgt.

CJK-Schriftarten  

Zur Not würden wir im Deutschen für das Schreiben von einfachen Blockschrift-Texten mit 26 Zeichen auskommen, mit denen man den Inhalt des gesamten Dudens wiedergeben könnte. In diesem Vergleich schlagen wir das Chinesische an Ressourcen-Ersparnis um Längen, denn so ökonomisch chinesische Schrift auch auf dem Papier und im alltäglichen Gebrauch ist, müssen chinesische Schriftarten hingegen scheinbar verschwenderisch mit Zeichen ausgestattet sein. Das lässt sich jedoch leicht verstehen, wenn man weiß, dass man für sehr einfache chinesische Texte auf 4.Klasse-Grundschul-Niveau schon ca. 1000 Schriftzeichen benötigt und jedes Schriftzeichen - wie wir nun wissen - anders ausschaut. Für komplexere Literatur benötigt man ca. 3000 Schriftzeichen, wissenschaftliche Literatur hingegen benötigt ca. 8000 Schriftzeichen und insgesamt existieren im Chinesischen über 40.000 Schriftzeichen. Darum sind asiatische "CJK-Schriftarten" (Chinese-Japanese-Korean-Schriftarten) im Durchschnitt 10 Megabyte groß, wohingegen eine bei uns gebräuchliche Schrift im Durchschnitt nur etwa 150 Kilobyte "auf die Waage bringt".

Mit unseren europäischen Schriftarten lassen sich nicht so einfach beliebige Mengen an Zeichen darstellen. Sie sind sehr ökonomisch aufgebaut und benutzen nur ein einzelnes Byte zum Darstellen von Zeichen. Da ein Byte 8 Bits umfasst, sind somit nur 256 Kombinationen der Ziffern 0 und 1 möglich. Jedem dieser möglichen Kombinationen von 0 bis 255 ist ein einzelnes Zeichen zugeordnet. Diese Zuordnung kann man der ANSI-Tabelle entnehmen. Man spricht bei dieser nur ein Byte umfassenden Darstellung von "SBCS" (Single-Byte Character Set).

Ein paar Beispiele für das bei uns übliche SBCS:

CByte(49) entspricht dem Zeichen "1"
CByte(104) entspricht dem Zeichen "h"
CByte(255) entspricht dem nicht direkt über die Tastatur erreichbare Zeichen "ÿ"
Das kann man mit etwas Code sofort nachvollziehen:

Private Sub Command1_Click()
    Text1.Text = Chr$(49) & " " & Chr$(104) & " " & Chr$(255)
End Sub

Listing 1

Gibt man jedoch Chr$(256) ein, so wird dies mit der Fehlermeldung "Ungültiger Prozeduraufruf oder ungütiges Argument" quittiert. Was nicht verwundert, da wir wissen, dass ein Byte nur 256 unterschiedliche Werte annehmen kann und da der kleinste Wert 0 ist, liegt 256 außerhalb des zulässigen Wertebereichs.

Schriftarten, die eine solch große Menge an Zeichen darstellen müssen wie die CJK-Schriften, benötigen also zwei Bytes, was "DBCS" (Double Byte Character Set) genannt wird. Durch die Erweiterung auf zwei Bytes können 65536 verschiedene Zeichen dargestellt werden, was also selbst für so eine Schriftzeichen-reiche Sprache wie das Chinesische ausreicht.

SBCS/DBCS-Modus des Betriebssystems ermitteln  

Öffnen wir ein neues Projekt und fügen folgenden Quellcode ein:

'Prüfen, ob sich das Betriebssystem im SBCS- oder
'DBCS-Modus befindet
 
Option Explicit

Private Declare Function GetSystemMetrics _
   Lib "user32" (ByVal nIndex As Long) As Long

Private Const SM_DBCSENABLED = 42

Private Sub Form_Load()
      'Gibt 0 zurück, wenn Betriebssystem im SBCS-Modus ist
      MsgBox "DBCS = " & Str$(GetSystemMetrics(SM_DBCSENABLED))
End Sub

Listing 2

Wird der Wert 0 zurückgegeben, so befindet sich das Betriebssystem im SBCS-Modus, was bedeutet, dass viele Programme - und bedauerlicherweise auch das Visual Studio 6 - die Verarbeitung von solchen Zeichen verweigern, die zur Darstellung zwei Bytes benötigen. Nur Singlebyte-Zeichen werden von ihnen korrekt dargestellt.

Leider gibt es im Betriebssystem keine Option, zwischen diesen beiden Modi zu wechseln. Noch besser wäre es, wenn das Betriebssystem sich grundsätzlich im DBCS-Modus befinden würde, also standardmäßig Doppelbyte-Zeichen verarbeiten würde. Das sind jedoch Microsoft-interne Entscheidungen über den Aufbau des Windows-Betriebssystems, auf die wir keinen Einfluss haben. Was wir jedoch können: unserem PC Chinesisch beibringen.

Windows lernt Chinesisch  

Zunächst muss auf dem PC die Sprachunterstützung für ostasiatische Sprachen - zu denen auch das uns interessierende Chinesisch gehört - nachinstalliert werden. Unter Windows XP erreicht man dies, indem man auf der Registerkarte "Sprachen" der "Regions- und Sprachoptionen" (über die "Systemsteuerung" zu erreichen), vor dem Eintrag "Dateien für ostasiatische Sprachen installieren" ein Häkchen setzt.

Nach dem notwendigen System-Neustart - nur Neuanmeldung reicht nicht! - nochmals auf der gleichen Registerkarte der "Regions- und Sprachoptionen" die Schaltfläche "Details" klicken, woraufhin sich das unten abgebildete Fenster "Textdienste und Eingabesprachen" öffnet.

Dort zunächst auf die Schaltfläche "Hinzufügen" klicken und als Eingabegebietsschema "Chinesisch (VR China)", sowie als Tastaturlayout/IME "Chinesisch (vereinfacht) - US-Tastatur" auswählt. Als zweites noch für die "Eingabegebietsschema-Leiste" die Anzeige auf dem Desktop einstellen, und schon kann man zwischen den Spracheinstellungen "Deutsch" und "Chinesisch" wählen. Die zu dieser neuen Funktion zugehörige Software - der IME-Editor - findet man im Unterordner "IME" des System-Ordners.

Um die Bedienung des IME-Editors noch komfortabler zu machen, kann man in dem Dialogfenster, welches sich durch Klick auf die Schaltfläche "Tastatur ..." öffnet, Hotkeys für das Umschalten zwischen deutscher und chinesischer Spracheingabe einstellen. Dazu auf "Wechseln zu Chinesisch" und auf "Wechseln zu Deutsch" doppelklicken und im sich öffnenden Dialogfenster jeweils eine Tastenkombination einstellen. Aber Achtung: es stehen in dem Drop-Down-Menü für die dritte Taste nicht nur die Zahlen von 0 bis 9 zur Auswahl, sondern auch die Tilde und der Accent grave. Das ist auf amerikanischen PCs kein Problem, da deren Tastaturbelegung mit derjenigen von chinesischen PCs übereinstimmt. Da diese beiden Sonderzeichen bei deutscher Tastaturbelegung jedoch anderen Tasten zugeordnet sind als bei amerikanischer bzw. chinesischer Tastaturbelegung, funktioniert eine Hotkey-Kombination nicht ohne weiteres, wenn sie eine dieser beiden Tasten enthält.

Chinesische Schriftzeichen im Text-Editor  

Ist bei geöffnetem Notepad die Spracheinstellung "CH" mit der Auswahl "Chinese" aktiviert, und eine entsprechende Schriftart eingestellt, so kann man nun solche Schriftzeichen mittels ihrer Laut-Umschreibung eingeben.

Stellt man in der Eingabegebietsleiste die Sprache "Chinesisch" ein und schreibt z.B. die Pinyin-Silben "ni" und "hao" (jede eingegebene Silbe mit der Return-Taste bestätigen), so erscheint jedes Mal anstatt der lateinischen Buchstaben auf dem Notepad-Blatt der Text zunächst in einem kleinen Eingabefeld. Dieses Eingabefeld ist Bestandteil des im Hintergrund arbeitenden IME-Editors (Input Method Editor), ein oft auch "Front-End-Prozessor" genanntes Applet, mit dessen Hilfe man beliebige chinesische Schriftzeichen per europäischer Standard-Tastatur darstellen kann. Nach Drücken der Return-Taste sucht der IME-Editor alle zu der eingegebenen Silbe gehörenden Schriftzeichen heraus und überträgt das gebräuchlichste auf das Notepad-Blatt.

Bestätigt man eine eingegebene Silbe statt mit der Return-Taste hingegen mit der Leertaste, so wird das Schriftzeichen unterstrichen. Setzt man mit der Pfeiltaste links nun den Cursor links vor das Schriftzeichen, dann öffnet sich ein Auswahlfeld mit allen homonymen Schriftzeichen, also mit allen Schriftzeichen, welche die identische Aussprache haben. Mit den Pfeiltasten oben/unten bewegt man sich durch das Auswahlfenster. Hat man das richtige Schriftzeichen gefunden, bestätigt man mit der Return-Taste, und das Schriftzeichen erscheint auf dem Notepad-Blatt.

Probiert man diese Eingabe jedoch in der Textbox eines mit Visual Basic 6 geschriebenen Programms aus, so wird man enttäuscht feststellen, dass die Textbox diese Zeichen scheinbar nicht verarbeiten kann, sondern immer nur diese verhassten Fragezeichen angezeigt werden.

Das bedeutet nicht, dass Visual Basics Steuerelemente nicht Unicode-fähig sind, sondern sie sind quasi zu eng an die Systemeinstellungen gekoppelt, so dass immer nur derjenige Modus unterstützt wird, der gerade im Betriebssystem aktiv ist. Die Steuerelemente aus Visual Basic 6 können solche Zeichen nämlich sehr wohl darstellen, vorausgesetzt, das Betriebssystem befindet sich im DBCS-Modus.

Testen wir mittels des oben vorgestellten kleinen Quellcodes den aktuellen Modus, in dem sich das Betriebssystem gerade befindet, so wird immer noch "0" zurückgegeben. Das Betriebssystem befindet sich also trotz nachinstallierter Sprachunterstützung für Chinesisch immer noch im SBCS-Modus.

Windows im DBCS-Modus  

Gehen wir wieder in die Systemsteuerung, klicken auf die "Regions- und Sprachoptionen" und wechseln diesmal auf die Registerkarte "Erweitert". Im Drop-Down-Feld als Sprachversion muss z.B. "Chinesisch (VR China)" eingestellt werden.

Nach einem System-Neustart (Achtung: ab- und neu anmelden allein reicht nicht) ergibt der Test mit unserem kleinen Programm nun, dass auf dem PC tatsächlich der DBCS-Modus aktiviert ist - wir haben also endlich einen "chinesischen PC".

Öffnen wir ein neues Projekt, fügen eine Textbox hinzu und folgenden Code:

Wie man sehen kann, akzeptiert Visual Basic nun sogar das Einfügen von Schriftzeichen direkt in den Quellcode. Wird das Projekt gestartet, steht nun tatsächlich das chinesische Schriftzeichen für "Berg" sowohl in der Textbox, als auch im Titel des Formulars. Es macht also keinen Unterschied, ob man ein Schriftzeichen direkt im Quellcode eingibt, oder seine Unicode-Nummer.

Chinesische Schriftzeichen reichen vom Unicode-Codierungspunkt 19968 (hexadezimal: 4E00) bis 40869 (hexadezimal: 9FA5). Alle übrigen Unicode-Codierungspunkte einer CJK-Schriftart produzieren Zeichen, die nicht zum Chinesischen gehören.

Wer mehr über Unicode erfahren möchte, dem kann ich die Kolumne 20: "Unicode" von Philipp Stephani empfehlen und natürlich die sehr informative Website des Unicode-Konsortiums: http://www.unicode.org/.

Zurück zu unserem Problem, was dadurch jedoch nicht gelöst ist, denn in dem Moment, wo das Betriebssystem in den deutschen Modus zurückgeschaltet ist (Im Drop-Down-Feld des "Regionen und Sprachoptionen"-Fensters als Sprachversion wieder "Deutsch" auswählen und System neu starten), hat Visual Basic all seine Chinesisch-Kenntnisse wieder vergessen. Auch wenn man das Projekt in der chinesischen Umgebung kompiliert, läuft es unter deutscher Einstellung nicht mehr korrekt.

Für das Nachvollziehen aller weiteren Schritte in diesem Tutorial wird davon ausgegangen, dass das Betriebssystem wieder auf die bei uns übliche Sprachversion "Deutsch" zurückgestellt worden ist.

Anwendungen speziell für den chinesischen Markt  

Bei Anwendungen, die für den internationalen Markt entwickelt werden, die jedoch immer nur jeweils die landeseigene Sprache benötigen (z.B. eine CD-Brenn-Software), wird unter der landesüblichen Einstellung des Betriebssystems automatisch entweder der SBCS- oder der DBCS-Modus korrekt eingestellt sein. Somit kann man sicher sein, dass die Steuerelemente einer mit Visual Basic erstellten Software jeweils immer genau die richtigen Zeichen akzeptieren. Da in den meisten Anwendungen die Schriftart aller Steuerelemente auf der standardmässig vorgegebenen Einstellung "MS Sans Serif" belassen wird, kann man ebenfalls sicher sein, dass auf dem PC eines chinesischen Kunden eine Systemschrift ausgewählt wird, die dem "CJK Unified Ideographs"-Standard entspricht und somit chinesische Zeichen enthält. Man muss an seine chinesischen Kunden zusammen mit der Software also keine Schrift-Datei ausliefern.

Beschriftungen und Texte der Software sollte man der Software in separaten INI-Dateien mitliefern - pro Sprache eine Datei -, wobei man bei Programmstart je nach im Betriebssystem eingestellter Sprache die entsprechende INI-Datei aufruft. Näheres zum Umgang mit INI-Dateien findet man in den Tips 'n Tricks, z.B. dem INI-Dateien Werte und Felder, erstellen und lesen [Tipp 0108] . Wie man die System-Sprache und ggf. weitere benötigte Systeminformationen erhält, wird z.B. Verfügbare Ländereinstellungen auslesen [Tipp 0206] oder Länderspezifische Einstellungen auslesen [Tipp 0277] erklärt.

Es ist nicht möglich, chinesische und deutsche Texte und Beschriftungen als Ressourcendatei in die Software einzubinden. Denn erstellt man die Ressource in chinesischer Sprachumgebung, so lässt sie keine deutschen Sonderzeichen zu; in deutscher Umgebung hingegen können keine chinesischen Schriftzeichen eingegeben werden.

Es kann jedoch auch beim Einbinden von INI-Dateien Probleme geben, wenn das Programm auf einem PC mit chinesischer Spracheinstellung kompiliert wird. So geben manche API-Funktionen unter Umständen falsche Werte zurück, wie z.B. die API GetPrivateProfileString zum Lesen von Einträgen aus INI-Dateien. Hier wird als Funktionswert die Länge des Eintrags zurückgegeben, die aber, wenn die INI-Datei als Unicode gespeichert wird und die Einträge DBCS-Zeichenfolgen enthalten, nicht mehr stimmt. Abhilfe kann man dadurch schaffen, dass man das Projekt mit deutscher Spracheinstellung kompiliert oder der API keinen String übergibt, sondern Unicode.

Da - wie wir inzwischen wissen - chinesische Worte und Texte kürzer sind als deutsche, gibt es diesbezüglich keinerlei Schwierigkeiten zu überwinden.

Mein Button kann Chinesisch  

Für all diejenigen, die in eine für den deutschen Markt produzierte Software chinesische Schriftzeichen integrieren möchten, tun sich große Hürden auf, denn wie wir inzwischen wissen, verleugnen die Steuerelemente von Visual Basic in SBCS-Umgebung hartnäckig ihre Unicode-Fähigkeiten - bis auf RichTextBox, Form und PictureBox!

Öffnen wir ein neues Projekt, positionieren eine PictureBox und eine Schaltfläche auf dem Form und geben der PictureBox folgende Eigenschaften: Height und Width je 1000, Fontsize 40.

Nun noch den folgenden Quellcode einfügen und anschliessend das Projekt starten.

Private Declare Function TextOutW Lib "gdi32" Alias "TextOutW" _
                         (ByVal hdc As Long, ByVal nXStart As Long, _
                         ByVal nYStart As Long, lpUnicode As Any, _
                         ByVal cbString As Long) As Long
                         
Private Sub Command1_Click()
    Dim MeinUnicode As Long
    
    MeinUnicode = 23721    'Unicode-Wert des Zeichens für "Felsen"
    Call TextOutW(Picture1.hdc, 0, 0, MeinUnicode, 1)
End Sub

Listing 3

Und siehe da, wenn man auf die Schaltfläche klickt, wird in das angesprochene Fenster (in unserem Fall Picture1) das Schriftzeichen für "Felsen" gezeichnet. Wem das Zeichen zu klobig aussieht, könnte in der Font-Eigenschaft der PictureBox eine andere Schrift einstellen. Die eleganteste und meist verbreitetste Schrift ist "SimSun", die auf chinesischen PCs im Allgemeinen die voreingestellte System-Schrift ist.

Möchte man zwei oder mehr Schriftzeichen hintereinander ausgeben, so wiederholt man den API-Aufruf mit entsprechend anderem Unicode-Wert. Außerdem muss das zweite Schriftzeichen horizontal nach rechts verschoben werden. Da kommt uns zu Hilfe, dass jedes Schriftzeichen quadratisch ist. Wenn wir das zweite Schriftzeichen um den Schriftgrößen-Wert nach rechts verschieben, so stoßen die beiden Schriftzeichen unmittelbar aneinander an. Etwas Raum kann man schaffen, indem man nochmals die Hälfte der Schriftgröße hinzuaddiert. Um den folgenden Quellcode korrekt darstellen zu können, muss die Größe der PictureBox verdoppelt und der Code der Click-Prozedur etwas erweitert werden:

Private Sub Command1_Click()
Dim MeinUnicode As Long, Verschiebung As Integer
Verschiebung = Picture1.FontSize + (Picture1.FontSize / 2)

    'Ausgabe des ersten Schriftzeichens
    MeinUnicode = 23721    'Unicode für "Felsen"
    Call TextOutW(Picture1.hdc, 0, 0, MeinUnicode, 1)

    'Ausgabe des zweiten Schriftzeichens
    MeinUnicode = 27974    'Unicode für "dickflüssig"
Call TextOutW(Picture1.hdc, Verschiebung, 0, MeinUnicode, 1)

    'Ausgabe des dritten Schriftzeichens in der zweiten Zeile
    MeinUnicode = 23665    'Unicode für "Berg"
Call TextOutW(Picture1.hdc, 0, Verschiebung, MeinUnicode, 1)

End Sub

Listing 4

Wie man sieht, lassen sich einzelne Schriftzeichen auf diese Weise problemlos in eine PictureBox zeichnen. So kann man sich aus der Kombination mit einer PictureBox leicht ein Benutzersteuerelement erstellen, z.B. eine Schaltfläche, dessen Caption beliebige Schriftzeichen darstellen kann. Ein chinesisches Textverarbeitungsprogramm auf diese Art zu erstellen und zu verarbeiten ist sicher möglich, aber wohl eher nicht empfehlenswert.

Beispielprojekt 1: Unicode darstellen 

Microsoft Forms 2.0 Object Library  

Diese Steuerelemente sind zwar alle voll Unicode-fähig, sprich: sie können auch in der SBCS-Umgebung chinesische Schriftzeichen darstellen. Leider hat Microsoft ausdrücklich untersagt, diese Steuerelemente mit eigenen Anwendungen zusammen weiterzugeben. Originalton Microsoft: "Forms 2.0 is part of Microsoft Office and is not redistributable. Therefore, you cannot distribute Forms 2.0 (fm20.dll) with your application. It must already be on the target machines." Wer eine Software ausschließlich für den eigenen Gebrauch benutzt und diese Steuerelemente auf dem PC hat, oder wer sicher weiß, dass der Anwender Microsoft eine bestimmte Version des Microsoft Office auf seinem PC hat, kann sie zwar trotzdem verwenden, nur sind sie fehlerbehaftet, was die Freude über ihre Unicode-Fähigkeiten dann leider schnell dämpft. Erstaunlicherweise treten diese Fehler fast nie innerhalb der IDE auf, sondern immer erst im kompilierten Programm. So kann es vorkommen, dass nach Programmstart in eine eingebundene TextBox der Object Library kein Text eingegeben werden kann, oder diese TextBox deaktiviert erscheint. Ebenso kann es bei Copy&Past-Operationen innerhalb einer solchen TextBox im laufenden Programm zu Programmabstürzen kommen.

Chinesische Version von Visual Basic 6  

Sich solch eine Version zu besorgen ist leider keine Lösung, denn auch die mit einem chinesischen Visual Basic kompilierte Software kann in der SBCS-Umgebung keine Schriftzeichen darstellen. Dabei spielt es keine Rolle, ob das Programm auf einem PC mit chinesischer Spracheinstellung kompiliert wurde, oder auf einem PC, auf dem ein echtes chinesisches Windows läuft. Trotzdem kann es gerade für die Entwicklung von Software für den chinesischen Markt durchaus Vorteile haben, ein chinesisches Visual Basic 6 zu benutzen, da textverarbeitende Steuerelemente die Eigenschaft besitzen, den IME-Editor per Programmcode zu manipulieren. Allerdings kann man solch eine "IME-Eigenschaft" auch selbst per Code implementieren, wie wir weiter unten noch sehen werden.

Das RichTextBox-Steuerelement  

Die RichTextBox (im Folgenden RTB genannt) ist schon von sich aus Unicode-fähig. Ist der IME-Editor auf Chinesisch umgeschaltet, kann man in eine RTB jedes beliebige Schriftzeichen direkt eintragen. An die Grenzen stößt man jedoch in dem Moment, wo man das eingegebene Schriftzeichen weiterverarbeiten will, oder ein Schriftzeichen per Quellcode in die RTB einfügen möchte. Der folgende Quellcode produziert leider nur ein Fragezeichen in der RTB: RichTextBox1.Text = ChrW(30020)

Da die RTB genau wie die oben schon besprochene PictureBox über die Eigenschaft "hWnd" verfügt, kann man auch in der RTB Schriftzeichen per API darstellen. Öffnen wir dazu ein neues Projekt, fügen die Komponente "Microsoft Rich Textbox Control 6.0", ordnen eine RichTextBox auf dem Formular an und kopieren folgenden Quellcode in das Projekt:

Private Declare Function SendMessage Lib "user32.dll" _
        Alias "SendMessageA" (ByVal hWnd As Long, _
        ByVal wMsg As Long, ByVal wParam As Long, _
        ByRef lParam As Any) As Long

Private Type SETTEXTEX
    flags As Long
    codepage As Long
End Type

Private Const WM_USER As Long = &H400&
Private Const EM_SETTEXTEX As Long = WM_USER + 97
Private Const ST_DEFAULT As Long = 0
Private Const CODEPAGE_UNICODE As Long = 1200

Private Sub Form_Load()
    Call CH_schreiben (RichTextBox1, 23721)
End Sub

Private Sub CH_schreiben (c As RichTextBox, ByVal UCode As Long)
    Dim Data As SETTEXTEX
    
    Data.flags = ST_DEFAULT
    Data.codepage = CODEPAGE_UNICODE    
    Call SendMessage(c.hWnd, EM_SETTEXTEX, VarPtr(Data), UCode)
End Sub

Listing 5

Als Codepage wurde Unicode (= 1200) gewählt. Die Codepage für vereinfachtes Chinesisch ist zwar eigentlich 950, nur werden die chinesischen Schriftzeichen dann nicht in der Reihenfolge ausgegeben, wie sie das Unicode-Konsortium im Unicode-Standard festgelegt hat. Und das würde in unserem Fall zu einem ganz anderen als dem gewünschten "Felsen"-Schriftzeichen führen.

Um den Unicode-Wert eines eingegebenen Schriftzeichens ermitteln zu können, benötigt man die WinAPI-Funktion SendMessageA. Die allgemeine Deklaration muss folgendes enthalten:

Private Declare Function SendMessageA Lib "user32.dll" _
        (ByVal hWnd As Long, ByVal Msg As Long, _
        ByVal wParam As Long, ByVal lParam As Long) As Long

Private Type GETTEXTEX
    cb As Long
    flags As Long
    codepage As Long
End Type

Private Const WM_USER As Long = &H400&
Private Const EM_GETTEXTEX As Long = WM_USER + 94
Private Const GT_DEFAULT As Long = 0
Private Const CODEPAGE_UNICODE As Long = 1200

Listing 6

Der WinAPI-Funktion SendMessageA muss als letztes Argument ein Leerstring in genau der Länge übergeben werden, wie der Inhalt der auszulesenden RTB lang ist. Da ein einzugebendes chinesisches Schriftzeichen jedoch immer noch mit einem Return abgeschlossen werden muss, ist es zwingend notwendig, den String um ein Leerzeichen länger zu machen, als er tatsächlich ist. Um die Länge des Inhaltes einer RichTextBox auszulesen, gibt es zweierlei Möglichkeiten, entweder mit Len(), oder mittels einer weiteren WinAPI-Funktion. Warum API, wenn's auch ohne geht ..., darum hier zunächst erst einmal ohne die API-Funktion GetWindowTextLengthA.

Nennen wir unsere neue Funktion UC_ermitteln. Übergeben wird wieder die Adresse einer RichTextBox, sowie die Länge des auszulesenden Inhaltes. Die funktionsaufrufende Codezeile, mit der der Unicode des in einer RTB stehenden Schriftzeichens in die Titelleiste des Forms geschrieben wird, würde dann z.B. so aussehen:

Me.Caption = UC_ermitteln(RichTextBox1, Len(RichTextBox1.Text))

Listing 7

Es ist dabei unerheblich, dass Visual Basic das in der RTB dargestellte Schriftzeichen gar nicht "lesen" kann, es wird intern als "?" dargestellt, pro Schriftzeichen ein "?", die Textlänge wird mit Len() also auf jeden Fall korrekt angegeben.

Private Function UC_ermitteln(c As RichTextBox, Laenge As Long) As Long
    Dim DataG As GETTEXTEX
    Dim CH As String

Laenge = Laenge + 1 
    
    CH = String$(Laenge, 0)

    DataG.cb = Laenge * 2
    DataG.flags = GT_DEFAULT
    DataG.codepage = CODEPAGE_UNICODE

    Laenge = SendMessageA(c.hWnd, EM_GETTEXTEX, VarPtr(DataG), StrPtr(CH))
    
UC_ermitteln = AscW(Left$(CH, Laenge))

End Function

Listing 8

Um die Länge des Strings hingegen per API auszulesen, muss die API

Private Declare Function GetWindowTextLengthA Lib "user32.dll" _
        (ByVal hWnd As Long) As Long

Listing 9

eingebunden werden. Der Funktion UC_ermitteln braucht nun nicht die Stringlänge übergeben werden, sondern das wird innerhalb der Funktion selbst gemacht:

Dim Laenge As Long
Laenge = GetWindowTextLengthA(c.hWnd) + 1

Listing 10

AscW gibt nur Integerwerte zurück, kann also keine Werte ausgeben, die größer als 32767 sind - alles was größer ist, wird zur negativen Integer-Zahl. Da Unicode jedoch Long-Werte sind, kann solch eine Überschreitung des Wertebereiches häufig vorkommen. Folglich bedarf es einer weiteren Funktion, diesen Integer-Wert in einen korrekten Long-Wert umzuwandeln.

Private Function Int_zu_Long(tmpUC As Long) As Long
    If tmpUC < 0 Then
        tmpUC = tmpUC * (-1)
        tmpUC = 32769 - tmpUC + 32767
    End If

    Int_zu_Long = tmpUC
End Function

Listing 11

Bevor die Funktion UC_ermitteln einen Wert zurückgibt, kann dieser nun zunächst an diese Umwandlungsfunktion übergeben werden, so dass wir sicher sein können, wirklich einen Long-Wert zurückzubekommen.

UC_ermitteln = Int_zu_Long(AscW(Left$(CH, Laenge)))

Listing 12

Da man selten nur ein einziges Schriftzeichen in einer RTB verarbeiten möchte, kann man die Prozeduren und Funktionen so modifizieren, dass man ihnen ein Array übergeben kann, bzw. sie ein Array zurückgeben.

Public Sub CH_schreiben(c As RichTextBox, ByRef UCode() As Long, Optional ZeichenNr As Integer = 1)
    Dim Data As SETTEXTEX
    
    Data.flags = ST_DEFAULT
    Data.codepage = CODEPAGE_UNICODE
    
    Call SendMessage(c.hWnd, EM_SETTEXTEX, VarPtr(Data), UCode(ZeichenNr - 1))

End Sub

Listing 13

So, wie diese Funktion nun ist, kann man z.B. aus einem längeren chinesischen Text ein einzelnes Schriftzeichen in eine andere RTB übertragen lassen. Man kann sie aber noch beliebig erweitern, dass nicht nur einzelne Schriftzeichen, sondern z.B. auch ganze Abschnitte verarbeitet werden...

Ebenso wäre sinnvoll, dass die Funktion UC_ermitteln sämtliche Unicode-Werte eines Strings in einer RTB auf einmal zurückgeben könnte.

Public Function Unicode_ermitteln(c As RichTextBox) As Long()

Listing 14

Der erste Teil der Funktion bleibt unverändert. Unmittelbar hinter den API-Aufruf, der ja den kompletten String in die Variable CH schreibt, kann man den String in einzelne Schriftzeichen auf ein Array aufteilen und das komplette Array dann zurückgeben lassen. Auch hier ist unerheblich, dass Visual Basic z.B. im Debug-Modus statt eines Schriftzeichens nur ein Fragezeichen anzeigt - die Übermittlung funktioniert trotzdem korrekt.

Dim s() As Long, i As Integer, ss As String
ReDim s(0 To Len(CH) - 1)
    
For i = 0 To UBound(s)
        ss = Mid$(CH, i + 1, 1)
        s(i) = AscW(ss)
        s(i) = Int_zu_Long(s(i))
Next i

Unicode_ermitteln = s

Listing 15

Oder je nach Geschmack in Kurzfassung - mit identischem Ergebnis:

For i = 0 To UBound(s)
    s(i) = Int_zu_Long(AscW(Mid$(CH, i + 1, 1)))
Next i

Listing 16

Der Inhalt des zurückgegebenen Arrays kann z.B. in einer Liste ausgegeben werden. Der Aufruf und das übertragen in eine Listbox würden so aussehen:

Private Sub Command1_Click()
    Dim x() As Long, i As Integer
    List1.Clear
    
x = Unicode_ermitteln(RichTextBox3)
    
    For i = 0 To UBound(x)
        If x(i) > 0 Then List1.AddItem (CStr(x(i)))
    Next i
    
End Sub

Listing 17

Wie oben erwähnt, gibt die VB-eigene Funktion Len() die korrekte Anzahl der in einer RTB geschriebenen chinesischen Schriftzeichen zurück. Hingegen liefern RichTextBox-eigene Funktionen wie z.B. ".SelStart" nicht immer das gewünschte Ergebnis, da die chinesischen Schriftzeichen intern von der RTB auf Grund ihrer zwei Bytes als zwei Zeichen gezählt werden.

Öffnen wir ein neues Projekt, fügen ihm eine RichTextBox hinzu und ändern den Namen in RTB, ausserdem wird noch eine Textbox benötigt, bei der die Eigenschaft "MultiLine" auf True gesetzt ist, sowie eine Schaltfläche. Im Quellcode sollte stehen:

Private Sub Form_Load()
    RTB.Text = "Dieser Text hat 26 Zeichen"
End Sub

Private Sub Command1_Click()
    Text1.Text = "Len() = " & Len(RTB.Text) & vbNewLine & _
                 vbNewLine & _
                 "Länge der Selektion = " & RTB.SelLength & vbNewLine & _
                 "Start der Selektion hinter dem Zeichen Nr." & RTB.SelStart & vbNewLine & _
                 "Ende der Selektion hinter dem Zeichen Nr." & RTB.SelStart + RTB.SelLength
 End Sub

Listing 18

Wenn man nun einige Buchstaben in der RTB auswählt, erfährt man, hinter welchem Zeichen jeweils der Start- und der Endpunkt der Auswahl ist, sowie die Menge an ausgewählten Zeichen.

Gibt man nun einige chinesische Schriftzeichen in die RTB ein und wählt z.B. das allererste Schriftzeichen, so wird der Startpunkt der Auswahl wie erwartet mit 0 angegeben, der Endpunkt jedoch mit 2. Grundsätzlich gilt also bei Verarbeitung chinesischer Texte in einer RTB, dass man solche Werte zunächst einmal halbieren muss, um das gewünschte Ergebnis zu erhalten.

Wie man sehen kann, arbeitet das RichTextBox-Steuerelement also tatsächlich recht gut mit chinesischen Texten zusammen. Wenn man bedenkt, dass man andernfalls vollkommen auf die Integration chinesischer Schriftzeichen in ein Visual Basic-Projekt verzichten müsste, ist das eine durchaus brauchbare Alternative.

Beispielprojekt 2: CH RTF 

Weitere Alternativen  

Wer mit Visual Basic Anwendungen entwickeln möchte, in denen chinesische Texte in einer Textbox auf einem deutschen PC angezeigt und verarbeitet werden müssen (z.B. einen Deutsch/Chinesisch-Vokabeltrainer), für den gibt es zwei alternative Lösungen:

1. Das ActiveX-Steuerelement UniBox von Woodbury Associates - eine Demoversion kann man bei http://www.woodbury.co.uk/products.htm herunterladen. Die UniBox enthält unter anderem eine voll Unicode-fähige Textbox, die jedoch - und das ist vor allem in Anbetracht des hohen Preises unverzeihlich - keine IMEMode-Eigenschaft besitzt.

2. VB .NET, welches mit 16-Bit-Zeichencodierung programmiert ist und somit vollständig und uneingeschränkt unicodefähig ist, was ebenso für alle mit VB .NET entwickelten Programme zutrifft. Obendrein besitzen alle textverarbeitenden Steuerelemente von VB .NET standardmäßig die Eigenschaft IMEMode, mit dem der IME-Editor "ferngesteuert" werden kann.

Die IME-Eigenschaft  

Der folgende kleine Beispielcode soll die Fähigkeiten der Eigenschaft "IMEMode" demonstrieren. Man kann dieses Beispiel jedoch nur nachvollziehen, wenn man die Microsoft Forms 2.0 Object Library besitzt. Öffnen wir ein neues Projekt, binden als zusätzliche Komponente die besagte Object Library ein, ordnen auf dem Form zwei der Textboxen aus der Object Library an und kopieren folgenden Code in das Projekt:

Private Sub Form_Load()
    TextBox1.IMEMode = fmIMEModeOn
    TextBox2.IMEMode = fmIMEModeOff
End Sub

Listing 19

Nachdem das Programm gestartet wurde, kann man beobachten, dass jedes mal, wenn die TextBox1 den Focus erhält, der IME-Editor auf Chinesisch umspringt, wodurch man in die Lage versetzt wird, Schriftzeichen per Silbeneingabe schreiben zu können. Setzt man den Focus auf TextBox2, wechselt der IME-Editor von Chinesisch auf Deutsch zurück. Die Eigenschaft IMEMode ist also quasi eine Fernsteuerung für den IME-Editor.

Legt man die IME-Eigenschaften der Textboxen nicht per Code fest, ist der Anwender gezwungen, bei jedem Wechsel zwischen den Textboxen den IME-Editor per Hand (Sprich: Maus oder Hotkeys) höchstpersönlich umzuschalten. Ein Zustand, der einem schnell den Spaß an der Eingabe verschiedensprachiger Inhalte vergehen lässt!

Wie stattet man ein selbsterstelltes Chinesisch-Textfeld mit solch einer Fernbedienung aus? Dafür ist zunächst wichtig, im IME-Editor Hotkey-Tasten für das Umschalten zwischen den Sprachen festzulegen, wie weiter oben erklärt wurde. Im folgenden Beispiel wird von folgender Tastaturbelegung ausgegangen:

Chinesisch aktivieren: Linke Alt + Umschalt + 2
Deutsch aktivieren: Linke Alt + Umschalt + 1

Öffnen wir ein neues Projekt, fügen ihm mindestens zwei normale Textfelder hinzu - eines sollte den Namen txtChinesisch bekommen - und kopieren den folgenden Code:

'API zum systemweiten Senden der Hotkeys
Private Declare Sub keybd_event Lib "user32" _
                (ByVal bVk As Byte, ByVal bScan As Byte, _
                ByVal dwFlags As Long, ByVal dwExtraInfo As Long)

Private Const KEYEVENTF_KEYUP = &H2
Private HotKeyIME(0 To 3)        'Userdefinierte Hotkeys
Private IMEModus As Boolean    'beobachtet das Umschalten

Private Sub Form_Load()
    'Hotkeys um Deutsch zu aktivieren (ggf. ändern)
    HotKeyIME(0) = vbKeyMenu
    HotKeyIME(1) = vbKey1
    'Hotkeys um Chinesisch zu aktivieren (ggf. ändern)
    HotKeyIME(2) = vbKeyMenu
    HotKeyIME(3) = vbKey2
End Sub

Private Sub Form_Terminate()
    'IME-Editor auf Deutsch zurücksetzen    
    If IMEModus = True Then Call IME_ fernsteuern (False)
End Sub

Private Sub txtChinesisch_GotFocus()
    'Schaltet auf Chinesisch
    Call IME_ fernsteuern (True)
End Sub

Private Sub txtChinesisch _LostFocus()
    Call IME_ fernsteuern (False)
End Sub

Private Sub IME_fernsteuern(chinesisch As Boolean)
    Dim x As Integer, y As Integer
    If chinesisch = True Then
        x = 0: y = 1
    Else
        x = 2: y = 3
    End If

    'Hotkey für Sprachauswahl virtuell systemweit "drücken"
    Call keybd_event(HotKeyIME(x), 0, 0, 0)
    Call keybd_event(vbKeyShift, 0, 0, 0)
    Call keybd_event(HotKeyIME(y), 0, 0, 0)
    'Alle Tasten in umgekehrter Reihenfolge wieder "loslassen"
    Call keybd_event(HotKeyIME(x), 0, KEYEVENTF_KEYUP, 0)
    Call keybd_event(vbKeyShift, 0, KEYEVENTF_KEYUP, 0)
    Call keybd_event(HotKeyIME(y), 0, KEYEVENTF_KEYUP, 0)
    
IMEModus = chinesisch

End Sub

Listing 20

Jedes Mal, wenn txtChinesisch den Focus erhält, wird per API systemweit die vorher festgelegte Hotkey-Kombination ausgesandt, mit der der IME-Editor von Deutsch auf Chinesisch umgeschaltet wird. Verliert txtChinesisch den Focus, wird diejenige Hotkey-Kombination systemweit gesendet, mit der der IME-Editor wieder zu Deutsch zurückgeschaltet wird.

Noch besser wäre natürlich, unser Programm könnte die Hotkey-Kombinationen, mit denen der IME-Editor umgeschaltet wird, bei Programmstart selbst ermitteln. Diese Angaben finden sich mit etwas Wühlen in der Registry unter HKEY_CURRENT_USER/Control Panel//Input Method/Hot Keys. Die Hotkey-Kombination für das Umschalten auf Chinesisch findet sich im Unterordner 00000100, der Ordner 00000101 enthält die Hotkey-Kombination für das Umschalten auf Deutsch. Fehlt einer dieser Ordner, so wurde für die entsprechende Option noch kein Hotkey vergeben.

Öffnen wir ein neues Projekt und fügen ihm ein Modul hinzu, in welches folgender Quellcode kopiert wird:

Private Declare Function RegCloseKey Lib "advapi32.dll" _
        (ByVal hKey As Long) As Long
Private Declare Function RegOpenKey Lib "advapi32.dll" _
        Alias "RegOpenKeyA" (ByVal hKey As Long, ByVal lpSubKey As String, _
        phkResult As Long) As Long
Private Declare Function RegQueryValueEx Lib "advapi32.dll" _
        Alias "RegQueryValueExA" (ByVal hKey As Long, _
        ByVal lpValueName As String, ByVal lpReserved As Long, _
        lpType As Long, lpData As Any, lpcbData As Long) As Long

Private Const HKEY_CURRENT_USER = &H80000001
Public HotKey(0 To 3) As Long   'Nimmt die ermittelten Tasten auf

Sub Main()
    Dim tmpArray As Variant, i As Integer
    
    'HotKey-Kombination für Chinesisch ermitteln
    tmpArray = Bytes_lesen("00000100", "Key Modifiers")
    'Überprüfen, ob ein Array zurückgegeben wurde und dieses
    'ggf in einen String umwandeln
    If IsArray(tmpArray) Then
        For i = LBound(tmpArray) To UBound(tmpArray)
            HotKey(0) = HotKey(0) & CLng(tmpArray(i))
        Next
    End If

    tmpArray = Bytes_lesen("00000100", "Virtual Key")
    'Überprüfen, ob ein Array zurückgegeben wurde und dieses
    'ggf in einen String umwandeln
    If IsArray(tmpArray) Then
        For i = LBound(tmpArray) To UBound(tmpArray)
            HotKey(1) = HotKey(1) & CLng(tmpArray(i))
        Next
    Else
        MsgBox "Für Chinesisch ist noch kein Hotkey festgelegt"
    End If
    
    'HotKey-Kombination für Deutsch ermitteln
    tmpArray = Bytes_lesen("00000101", "Key Modifiers")
    'Überprüfen, ob ein Array zurückgegeben wurde und dieses
    'ggf in einen String umwandeln
    If IsArray(tmpArray) Then
        For i = LBound(tmpArray) To UBound(tmpArray)
            HotKey(2) = HotKey(2) & CLng(tmpArray(i))
        Next
    End If
        
    tmpArray = Bytes_lesen("00000101", "Virtual Key")
    If IsArray(tmpArray) Then
        For i = LBound(tmpArray) To UBound(tmpArray)
            HotKey(3) = HotKey(3) & CStr(tmpArray(i))
        Next
    Else
        MsgBox "Für Deutsch ist noch kein Hotkey festgelegt"
    End If
    
    'Das Form zum Testen wird gestartet
    Load Form1
    Form1.Show

End Sub

Private Function Bytes_lesen(Pfad As String, Inhalt As String) As Variant
    Dim Wertetyp As Long, BuffSize As Long
    Dim RegistryInhalt As Long, HtKey As Long
    Dim Buff() As Byte
    
    RegistryInhalt = RegOpenKey(HKEY_CURRENT_USER, "Control Panel\Input Method\Hot Keys\" & Pfad, HtKey)
    RegistryInhalt = RegQueryValueEx(HtKey, Inhalt, 0, Wertetyp, ByVal 0, BuffSize)
    If RegistryInhalt = 0 Then
        ReDim Buff(BuffSize - 1) As Byte
        RegistryInhalt = RegQueryValueEx(HtKey, Inhalt, 0&, Wertetyp, Buff(0), BuffSize)
        Bytes_lesen = Buff
    End If

    RegistryInhalt = RegCloseKey(HtKey)
    
End Function

Listing 21

Da im IME-Editor die mittlere Taste der aus drei Tasten bestehenden Hotkey-Kombination immer die Umschalt-Taste ist, genügt es, sowohl für Deutsch als auch für Chinesisch jeweils nur die erste und letzte Taste auszulesen. Existiert jedoch noch keine Hotkey-Kombination, wird eine Nachricht ausgegeben.

Auf dem Form1 des Projektes werden nun vier Textboxen angeordnet. In Text1 und Text2 sollen die beiden Hotkeys für die Aktivierung des Chinesisch-Modus angezeigt werden, Text3 und Text4 zeigen die Hotkeys für Deutsch.

'Dieses Projekt startet per Sub Main, dieses
'Form ist nur zur Kontrolle der Daten.
'Als Startobjekt in den Projekteigenschaften SubMain einstellen.

Private Sub Form_Load()
    Text1.Text = Analysieren(HotKey(0))
    Text2.Text = Analysieren(HotKey(1))
    Text3.Text = Analysieren(HotKey(2))
    Text4.Text = Analysieren(HotKey(3))
End Sub


Private Function Analysieren(tmpWert As Long) As String
    Select Case tmpWert
        Case Is < 48000: Analysieren = ""
        '49-57 entspricht den Ascii-Werten der Zifferntasten 0-9
        Case Is <= 57000: Analysieren = Chr(Left$(CStr(tmpWert), 2))
        Case 619200: Analysieren = "Strg"
        Case 96000: Analysieren = "Accent grave"
        Case 126000: Analysieren = "~"
        Case 519200: Analysieren = "Linke Alt"
    End Select
End Function

Listing 22

In der Funktion "Analysieren" werden die aus der Registry ausgelesenen Werte in die entsprechenden Tasten-Bezeichnungen umgewandelt und in den Textfeldern angezeigt.

Beispielprojekt 3: IME steuern 

Schlusswort  

Wie gezeigt wurde, lässt sich chinesische Schrift bei Bedarf mit relativ wenig Aufwand in ein mit Visual Basic 6 erstelltes Projekt integrieren, man ist nicht zwangsläufig gezwungen, sofort auf VB .NET umzusteigen.

Natürlich sind die im Tutorial aufgeführten Beispiele als Grundlage für ein Benutzersteuerelement, welches chinesische Texte verarbeiten kann, bestens geeignet. Ich würde mich freuen, wenn jemand solch ein fertiges Ergebnis in den Upload stellen würde. Auch kann man die Eigenschaften eines solchen Benutzersteuerelementes bei Bedarf noch erweitern, Anregungen dafür gibt es unter MSDN Microsoft.

Ihre Meinung  

Falls Sie Fragen zu diesem Tutorial haben oder Ihre Erfahrung mit anderen Nutzern austauschen möchten, dann teilen Sie uns diese bitte in einem der unten vorhandenen Themen oder über einen neuen Beitrag mit. Hierzu können sie einfach einen Beitrag in einem zum Thema passenden Forum anlegen, welcher automatisch mit dieser Seite verknüpft wird.