Jürgen's programmier blog

jmbde-QT V 0.5.0

2017-12-21T10:51:00.000+01:00

Das Programm it noch pre alpha.

Die neueste Version des Source-Codes wurde auf GitHub veröffentlicht. Das Programm funktioniert bereits kann aber noch nicht produktiv eingesetzt werden. Es können Datensätze hinzugefügt oder geändert werden.

Getestet habe ich es mit macOS 10.13 und Windows 10.

Qt 5.3 Release Candidate Available

2014-05-10T15:59:00.001+02:00

Qt 5.3 Release Candidate Available

QT Projekte als MSI-Pakete vertreiben

2013-12-15T19:15:00.000+01:00

Wenn man versucht Programme zu schreiben, will man diese auch irgendwann unter die Leute bringen. Dabei hilft ein guter Installations-Paket-Generator. Hier werden verschiedene Möglichkeiten angeboten. Ich habe einiges probiert und getestet. Es gibt für das Windows Betriebssystem sowohl Freie wie auch kommerzielle Paket Generatoren. Ich bevorzuge die freien Versionen.

Möglichkeiten

Lange Zeit habe ich mit NSIS gearbeitet. Aber ich denke das Projekt wird im Moment nicht mehr sehr aktiv gepflegt. Es gibt zwar wieder ein Release vom 14. Juli 2013. Aber das ist das erste seit 2009.

Aus diesem Grund habe ich dann einfach Inno Setup getestet. Ich ich muss sagen das ist ein richtiger Lichtblick. Da ist einiges einfacher als in NSIS. Zumal es hier ein GUI gibt. Mit dieser Grafischen Benutzeroberfläche lassen sich schnell und einfach Programmpaket erstellen.

MSI

Aber Microsoft geht in den neueren Versionen von Windows etwas andere Wege. Mit Windows wird ein Installationsprogramm ausgeliefert. Das Installationspaket selbst ist dabei nur noch eine Datenbank. Also wenn man schnell ein Programmpaket vertreiben will ist der einfachste Weg, man nutzt Inno Setup oder die freie Version von des Advanced Installer.

Ich habe zwar nur den Inno Setup getestet. Aber mit diesem Programm ist es wirklich einfach ein eigenes Projekt zur Installation bereitzustellen. Inno Setup erzeugt eine EXE mit einem beinhalteten Programm, das dann die eigentliche Installation durchführt.

Den Advanced Installer habe ich noch nicht getestet. Dieses Programm erzeugt immerhin MSI’s

WiX

Um alle Möglichkeiten auszuschöpfen die ein MSI Paket bieten könnte führt aber kein Weg an einem kommerziellen Programm oder WiX vorbei. WiX ist der Windows Installer XML, der ein komplettes Toolset zur Generierung von MSI’s zur Verfügung stellt. WiX wird von Microsoft als freie Software zur Verfügung gestellt.

WiX habe ich für mein aktuelles Projekt genutzt. Nun gut es kostet Nerven und einige Zeit bis man durchblickt. Aber es hat nicht nur den Vorteil kostenlos zu sein. Man muss die XML-Dateien zwar schreiben und an verschiedene Stellen GUID’s eintragen. Aber es besteht die Möglichkeit Modul zu verwenden. Ich programmiere zur Zeit mit Qt und konnte dank WiX eine Modul-Datei schreiben die alle benötigten DLL’s in das MSI packt und später in das richtige Verzeichnis in dem Zielsystem schreibt. Dieses Modul lässt sich in allen Projekte einsetzen die Qt verwenden.

Qt5 Windows Programme veröffentlichen

2013-09-21T18:55:00.000+02:00

Es ist schön mit Qt Programme zu erstellen. Das Qt-Projekt hat eine gute und komplett API mit sehr vielen Klassen und Funktion. Das ganze Paket ist genauso komplett wie die von Apple zur Verfügung gestellte Klassenbibliothek. Gegenüber dem Toolkit von Apple hat die Qt-Biblothek einen starken Vorteil; Programme die mit dem Qt als Grundlage entwickelt wurden laufen überall. Die Projekte müssen nur noch auf der Zielplattform neu kompiliert werden.
Ein Programm das in die Qt5 Bibliotheken eingebunden wurde ist recht klein. Das ist kein Wunder, denn durch die vielen Bereitgestellten Funktionen kann man sich einige Zeilen Code sparen.

Es müssen Grundsätzlich alle Qt5 Bibliotheken mitgegeben werden mit denen das Programm auch gebaut wurde. Diese sind leicht zu identifizieren. In der "pro" Datei sind die leicht zu finden.

Die Zeile

QT       += core gui sql

sagt aus: Dieses Projekt benötigt die Core, die Gui und dieSql Bibliothek. Für ein Qt5 Projekt wird zusätzlich immer noch die Widget Bibliothek benötigt.

Ein Setup Paket zusammenstellen

In der Microsoft-Welt ist es unbedingt notwendig sicherzustellen dass die Biblotheken alle zur Verfügung stehen. Qt steht in der Windows Welt in zwei Opensource Versionen zur Verfügung. Eine Version basiert auf die VS Umgebung. Somit wird die von Microsoft zur Verfügung gestellte Entwicklungsumgebung VisualStudio genutzt. Hauptsächlich wird aber eine auf MinGW 4.8 basierende Entwicklungsumgebung zur Verfügung gestellt. Diese nutze ich auch. Da die zur Verfügung gestellten Pakete in der jeweiligen Umgebung gebaut wurden, müssen auch die Progamme zur Laufzeit die richtigen "dll's" finden.
Zu allem Überfluss wird auch noch einen vorgegebene Ordnerstruktur erwartet. Wenn das eigene Programm und die Standardbibliotheken die Ordnerstruktur und die für die Ausführung nötigen Bibliotheken nicht findet hagelt es Fehlermeldungen.

Hier eine Bildschirmkopie meines aktuellen Projekts.

Hier sind die alle für das Programm notwendigen Bibliotheken (dll's) enthalten.

libgcc_s_dw2-1.dll - GNU Compiler dll
libstdc++6.dll - GNU Standard C++ Bibliothek
libwinpthreads-1.dll - GNU Threads für Windows
icudt51.dll
icuin51.dll
icuuc51.dll - International Component for Unicode
Qt5Core.dll - Die Kernbibliothek von Qt
Qt5Gui.dll - Die GUI Bibliothek von Qt
Qt5Widgets.dll - Die Widgets Bibliothek von Qt

platforms - Dieses Verzeichnis und der Inhalt ist wichtig sonst läuft nichts!

qtwindows.dll - Das ist die Plattform dll für Windows

Mein Projekt soll zusätzlich eine SQL-Datenbank nutzen. Deswegen ist noch ein weiteres Verzeichnis und sind auch zwei zusätzliche Bibliotheken in dem Projekt enthalten:

Qt5Sql.dll - Die Qt Sql Bibliothek

sqldrivers - Dieses Verzeichnis enthält die eigentliche Datenbank Bibliothek.

qsqlite.dll - Für die SQLite Datenbank

Es ist wichtig alle Qt-Bibliotheken aus dem Verzeichnis <QtDir>\mingw48_32\bin zu holen. Ich benutze für Windows den Inno Setup Installer und habe das Script so gestaltet dass die benötigten "dll's" direkt von hier in den Setup kopiert werden. Für die VisualStudio Umgebung sind die lib*-Dateien nicht notwendig. Anstelle dieser Dateien werden die MSVCP<xx>.dll und MSVCR<xx>.dll Dateien benötigt. Anstelle der <xx> steht selbstverständlich die richtige Versionsnummer. Das sollte für VisualStudio 2010 die Versionsnummer 100 sein.

Die anderen Dateien, die in der Bildschirmkopie zu sehen sind, sind für den Installer. Außer die "bde.db" Datei. Das ist die Datenbank.

OS X Installationspakete erzeugen

2013-07-06T21:35:00.000+02:00

Für Anwender ist es immer angenehmer ein Installationspaket zu haben. Das ist immer ein besseres Gefühl als irgendetwas irgendwohin zu kopieren.

Üblicherweise werden die Programme für den Mac als DMG angeboten. In diesen Disk Images sind dann die APPS versteckt. Die Installation des Programms ist dann auch ganz einfach. Mit der linken Maustaste das Programm-Icon packen und über dem Programm Ordner loslassen. Dadurch wird die Anwendung in das Programmverzeichnis kopiert und kann dort ab sofort gestartet werden. In vielen der DMG's ist zusätzlich zu den Programmen auch eine Verknüpfung zu dem Programm-Verzeichnis vorhanden.

Wenn man selbst Programme schreibt muss man also einfach ein Disk Image erzeugen und kann dieses zum Download zur Verfügung stellen. Das ist recht einfach.

Hier die Anleitung

Ein Diskimage erstellen.
Das kann am einfachsten mit dem GUI-Tool "Festplattendienstprogramm" aus dem Ordner "Dienstprogramme" bewerkstelligt werden.
Einfach dieses Programm starten und aus der Toolbar "Neues Image" wählen...
Alternativ kann das Image auch mit dem Kommandozeilenwerkzeug "hdiutil" erzeugt werden. Im dem geöffnetem Terminal erzeugt der Befehl "hdiutil create -size 10m /tmp/tmp.dmg -ov -fs HFS+" ein neues Image mit dem Namen "tmp.dmg" in dem "/tmp" Ordner. Die maximale Größe ist in diesem Beispiel 10MB.
Das Image mounten (anklicken)
Das klingt kompliziert ist aber einfach. Ich hier davon aus das Image ist in dem "/tmp" Ordner. Im Finder mit "Gehe zu" in den "/tmp" Ordner wechseln und mit einem Doppelklick das Diskimage öffnen. Dadurch wird das Laufwerkssymbol auf dem Desktop angezeigt und lässt sich in dem Finder Fenster direkt anwählen.
Mit Xcode ein install generieren lassen.
XCode hat auch ein Kommandozeilenwerkzeug. Dieses wird jetzt benötigt. Mit "xcodebuild" erzeugen wir jetzt ein zur Installation vorgesehene Version unseres Projektes. Dafür brauchen wir das Terminal und müssen in das Verzeichnis wechseln in dem unser Projekt zu Hause ist. Mit dem Befehl "xcodebuild clean install" räumen wir zuerst auf, danach wir ein neues komplettes Build durchgeführt. Das Ergebnis landet aber diesesmal nicht in den tiefen des Library-Verzeichnisses sondern in "/tmp". Da sind wir bereits im Finder. Durch den Aufruf von xcodebuild wurde hier ein neues Verzeichnis erzeugt. Dieses Verzeichnis trägt den Namen des Projekts mit dem Anhang ".dst". In diesem Verzeichnis finden wir unsere für den nächsten Schritt benötigten Dateien.
Das Programm in das Image kopieren.
In dem oben genannten Verzeichnis existiert ein Unterordner. Dieser hat den nicht sehr überraschenden Namen "Applications". Alles was hier zu finden ist muss in das neue Diskimage kopiert werden. Zusätzlich könnten hierher noch eine Versionshistorie und die Lizenzinformationen landen.
Einen symbolischen Link auf das Programmverzeichnis generieren.
Da wir die Vorgänge für unsere Anwender so einfach wie möglich gestalten wollen stellen wir noch einen Link zu dem Anwendungen Verzeichnis zur Verfügung. Jetzt kommen wir aber ohne die Kommandozeile nicht mehr weiter. Zuerst müssen wir in das Diskimage wechseln. Da funktioniert über den Befehl "cd /Volumes/<Name des Laufwerks>". Da wir keinen Namen vergeben hatten lautet dieser bei uns "untitled". Jetzt könnten wir kurz und knackig den symbolischen Link erzeugen. Dafür geben wir in die Befehlszeile: "ln -s /Applications Applications" ein.
Kopieren ins Projektverzeichnis
Alles was in dem Verzeichnis "/tmp" steht lebt nur bis zum nächsten Reboot. Deswegen müssen wir unser neues Werk als letzten Schritt noch in das Projektverzeichnis oder anders Verzeichnis unserer Wahl kopieren.
Abschluß
Das war alles. Jetzt haben wir ein fertiges professionell aussehenden Paket zur Installation unseres Programms erzeugt. Dieses Paket können wir schön verbreiten.

OS X Software internationalisieren

2013-01-13T16:32:00.001+01:00

Die Sprache der Computer und Programmentwicklung ist englisch. Das wirft dann die Frage auf wie bekomme ich mein anständig auf englisch entwickeltes Programm dazu deutsche Texte zu verwenden. Das sollte selbstverständlich mit geringem Aufwand zu bewerkstelligen sein. Das am besten mit den vorhandenen Bordmitteln.

Lösung

In der NS (NS steht für NextStep) Bibliothek wird ein Makro zur Verfügung gestellt. Mit der Hilfe dieses Makro's können die bereitgestellten Texte durch die der nativen Sprache ersetzt werden. Da das Foundation Framework sehr umfangreich ist wird das Makro in verschiedenen Ausprägungen zur Verfügung gestellt. Die Standard Version ist NSLocalizedString. Mit dieser Version wird anstelle des normalen Textes ein Platzhalter angegeben. Über diesen Platzhalter wird dann der auszugebende Text geholt.

Das Makro "NSLocalizedString(@"Message", @"Comment")" würde den Text "Message" ausgeben. Wenn allerdings eine Internationalisierungsdatei vorhanden wäre, würde der Text "Message" durch die jeweilige Anpassung ersetzt. Wäre also eine Datei "de.lproj" an der richtigen Stelle vorhanden könnte die Ausgabe "Nachricht" lauten.
In der Datei "de.lproj" muss dafür die Zeile Message=Nachricht stehen. Wogegen in der original englischen Datei "en.lproj" die Zeile Tag=Message steht.

Xcode

Voraussetzung für die Lokalisierung eines Projekts ist die Erweiterung des Projekts in Xcode-Projekts. Es muss zu der immer vorhandenen englischen Sprachanpassung die neue Sprache hinzugefügt werden. Das wird in der Projektansicht von Xcode erledigt.

Nach dem der Plus-Knopf angeklickt wurde zeigt Xcode die möglichen Dateien die lokalisiert werden können an. Wenn zuviel oder unnötige Dateien angezeigt werden kann durch Deselektierung in diesem Dialog die jeweilige Datei ausgespart werden.

Die zuvor angebotenen Dateien stehen ab sofort in dem Projekt zu Lokalisierung bereit. In dem linkem Fenster wir dies durch das kleine Dreieck angezeigt. Ein Klick darauf klappt die Dateien auf und zeigt die möglichen Übersetzungen.

Bei den einfachen Textdateien ist nun die Übersetzung problemlos möglich.

Sonderfall XIB

Die XIB-Dateien erfordern eine großen Aufwand. So ist hier keine direkte Übersetzung möglich. Es besteht die Möglichkeit die Benutzeroberfläche komplett in der neuen Sprache zu erstellen. Doch dieser große Aufwand ist in der Regel nur bei kleinen bis sehr kleinen Projekten zu vertreten. In der Regel machen Programmieren genauso ungern Übersetzungen wie Dokumentationen. So ist davon auszugehen das dieser Weg im wirklichen Leben nie beschritten wird.

Von Apple wird ein Kommandozeilen Werkzeug zur Verfügung gestellt. Dieses Programm extrahiert die zu übersetzenden Zeichenkette aus der XIB Datei. Die so gewonnen Zwischendateien können gut Übersetzt werden. Auch hier ist etwas Aufwand nötig.

CMake und OS X

2012-11-17T16:24:00.001+01:00

CMake ist ein sehr nützliches Werkzeug. Mit diesem Tool wird die Entwicklung von Programmen sehr erleichtert.
Dieses Werkzeug wird von Kitware als Opensource vertrieben und steht über diese Adresse http://www.cmake.org/cmake/resources/software.html zum Download bereit. Ursprünglich kommt das Werkzeug aus der Linux-Ecke. Allerdings steht es auch für Windows und für den OS X zur Verfügung. Wobei Mac OS X der interessante Teil für mich ist.

Installation

Nach dem Download steht auf dem Mac ein DMG in dem Download Ordner bereit. Nach dem dieses Disk-Image durch einen Doppelklick geöffnet wurde kann man es einfach installieren. Bei der Installation wird angeboten einen symbolischen Link für die Kommando-Zeile zur Verfügung zu stellen. Das macht absolut Sinn. Außer man ist geneigt für jeden Kommandozeilen Aufruf richtig viel zu tippen. Die Eingabe würde ohne den symbolischen Link auch den kompletten Pfad, einschließlich den Pfad in der App erfordern.

Nutzung

Am leichtesten lässt sich CMake mit der Hilfe des mitgelieferten GUI-Tools nutzen. Damit ist schnell und einfach die notwendige Datei CListMake.txt zu erzeugen. Diese Datei ist notwendig um das Makefile zu generieren. So lassen sich mit ein paar einfachen leicht zu verstehenden Befehlen komplizierte Projekte erstellen. Das geht sogar so weit dass ein Zusatzmodul dabei ist mit dem sich die Paketskript erzeugen lassen. Also kann man aus der CListMake.txt Datei erzeugte Programme gleich in die folgenden Pakete zusammenpacken:

TGZ
STGZ
TBZ2
TZ
ZIP
NSIS
DragNDrop (OSX)
PackageMaker (OSX)
OSXX1 (OSX)
Bundle (OSX)
CygwinBinary und CygwinSource
DEB (Linux)
RPM (Linux)

Ich gebe zu das ist sehr beeindruckend. Allerdings werde ich trotzdem nicht damit arbeiten. Warum ist im nächsten Abschnitt zu lesen.

Fazit

Nach dem die "großen" Qt und Xcodehttps://developer.apple.com/xcode/ ein durchdachtes Konzept für die IDE's zur Programm Kompilierung eingesetzt haben macht CMake nicht mehr richtig Sinn. In der Umgebung in der ich arbeite schon einmal gar nicht. CMake macht hier aus einem "freien" Projekt ein Xcode Projekt. Da kann man sein Projekt doch gleich in der richtigen Umgebung starten. Ich glaube es würde niemand auf die Idee kommen sein Projekt frei aufzusetzen. Zumal die aktuellen Projekte, die mit GUI, sehr aufwändig sind.

Quelldateien kommentieren

2012-03-28T19:52:00.001+02:00

Das ist von mir und auch wohl von den meisten anderen die sich mit der Programmierung von Software beschäftigen ein sehr ungeliebtes Thema. Neuere IDE's und Framework bieten aber hier Werkzeuge an die das Thema etwas ansprechender machen.

JAVA

Mit dem JDKwurde es populär. Man kann den Quelltext des Programms kommentieren. Wenn man das schön macht und sich an die Vorgaben hält bekommt man eine ansprechende Dokumentation. Das im JDKenthaltene Werkzeugs javadoc erstellt aus den Tags ein Paket von HTML-Dokumente. In der Regeln steuert man das über die Kommandozeile. Das ganze kann man auch um einiges komfortabler mit Netbeans anstelle des direkten Aufrufs von javadoc über die Kommandozeile erreichen. javadocerstellte die Dokumentation für den kompletten Quelltext Ordner. Außerdem kann man selbstverständlich auch externe Verweise einbinden. So ist es möglich auch Verweise auf Systembibliotheken einzubinden.

Objective-C (Apple)

Applestellt im Bereich der OpensourceSoftware auch ein Werkzeug zur Bildung einer Quelltext Dokumentation zur Verfügung. Das in Perlgeschriebene Werkzeug headerdoc2htmlwird unter der BSD-Lizenzzur Verfügung gestellt. Sie können es separat herunterladen. Wer allerdings Xcodeinstalliert hat es automatisch mit installiert. Im Gegensatz zu den beiden zuerst beschriebenen Hilfsprogrammen kann headerdoc2htmlauch andere Dialekte.

Sie müssen sich logischer Weise an den Syntax der Dokumentations-Tags halten und schon erhalten sie eine schöne Dokumentation. Leider hat das Apple-Tool einen gravierenden Nachteil, es erzeugt zwar für jedes Modul eine schönen Datei, aber keine Zentrale HTML-Datei aus der sich alle Module ansprechen lassen. Hierfür gibt es ein zusätzliches Werkzeug: gatherheaderdocdas ein Zentraldokument erzeugt. Die dafür bereitgestellt CSS-Datei und die Vorlage ist aber so schwach dass es sich wirklich nicht lohnt sich mit diesen Werkzeug intensiv auseinanderzusetzen. In dem Paket ist zusätzlich ein Programm enthalten mit dem sie Man-Pages für ihre Programme erstellen können. Hier müssen dann natürlich spezielle Tags verwendet werden.

Doxygen

Mein Favorit ist Doxygen.
Doxygenkann fast soviel Quellen wie das Apple-Tool:

Der Syntax von headerdoc2htmlist an Doxygenangelehnt. Also wenn sie ihren Code so kommentieren dass headerdoc2htmleine gute Ausgabe erzeugt so wird diese auch mit Doxygengut aussehen.
Aber Doxygenkann etwas was das Apple-Tool nicht oder nur schlecht kann. Es wird wie bei javadocein Zentraldokument erzeugt. Aus diesem Dokument können sie dann alle Module des Projekts erreichen.
Außerdem bietet dieses Werkzeug noch mehr Ausgabemöglichkeiten. Es können neben den üblichen HTML-Dokumenten auch LaTeX, RTF, Postscript, PDFund MAN-Dateien erzeugt werden. Als i-Tüpfelchen besteht die Möglichkeit ein Klassendiagramm zu erzeugen. Um dieses Diagramm anzuzeigen muss das GraphVizPaket installiert sein.

Zurück bei QT und Java

2012-03-20T19:37:00.001+01:00

Nachdem ich jetzt einen enthusiastischen Ausflug und Versuch mit MONO gemacht hatte trat die Realität wieder ein.

MONO

Microsoft hatte ein gutes Projekt gestartet. Die .NET-Welt ist gut und einen gesunde Weiterentwicklung von JAVA und C++. Ich mag Microsoft nicht, trotzdem das haben die gut angefangen. Miguel de Icaza hatte dann die Idee dieses Framework der Opensource Welt zu bringen. Daraus ist MONO geworden noch besser.

Die Probleme

Ich ging eigentlich davon aus, man entwickelt ein Programm, versendet das Komplilat und das Ding läuft. So ist es bei JAVA. Bei MONO und .NET ist es nur annähernd so. MONO wurde auf der Basis von Linux und GTK entwickelt und .NET von Microsoft. Die Programmierer von Microsoft können dabei wohl genauso wenig aus ihrer Haupt wie die Opensource Gemeinde. Man muss also vorher wissen wohin der Weg gehen soll.

Der Test

Ich bin Mac-Besitzer und Nutzer. Um auch etwas für diesen tollen Computer machen zu können habe ich mir Programmier-Bücher zugelegt. Aus dem Buch "Einstieg in Objektive-C 2.0 und Cocoa" von Kai Surendorf programmiere ich das Beispiel Projekt "WebLogClient" nach. Dabei kam ich auf die Idee, ich könnte versuchen zusätzlich das native OS X Projekt in einer portablen oder mehrere Plattformen unterstützenden Umgebung zusätzlich zu realisieren. Das habe ich dann auch so umgesetzt. Mit MONO, Qt und JAVA.

Qt ist Klasse. Toll integriert allerdings muss das Projekt für jede Plattform neu gebaut werden. Mein Favorit.
JAVA ist Java. Läuft überall. Sieht auch überall ein wenig fremd aus.
MONO Läuft auch überall. Sieht genauso fremd aus wie JAVA. Ist schlechter integriert außer bei Linux.

QT-Programme sehen beim Mac so aus wie Mac Programme aussehen sollten und fühlen sich auch so an. Allerdings sind diese Applikationen nicht binär kompatibel. Java mit Swing baut man einmal. Dann die JAR auf die andere Plattform und läuft. Ähnlich ist es mit MONO. Allerdings habe ich mich von MONO verabschiedet. Das Framework ist nicht so gut. Das hat sich bei der Umsetzung des Projekts WebLogClient gezeigt. Wo ich mit Qt und Java einfach die Voreinstlellungen des Programms lesen und schreiben konnte ging bei Mono hier gar nichts.
Ich habe das Internet durchsucht und hier zwar etwas gefunden das aber nur in der Windows Welt funktioniert und nicht mit MONO. Bei MONO muss man sich selbst etwas bauen...

Fazit

Gut ich habe einfach keine Lust mehr auf MONO. Selbstverständliche Funktionen wie das Speichern von Einstellungen sollte vorhanden sein. Ich habe keine Lust hier etwas zu programmieren. Für die entsprechende Plattform müsste ich auch suchen wo die Benutzer- oder Systemeinstellungen gespeichert werden. Deswegen willkommen zurück Qt und JAVA

Mono die ersten Schritte

2012-03-03T23:39:00.000+01:00

Da ich bereits eine paar Erfahrungen in Java gesammelt hatte dachte ich eigentlich Mono sollte kein Problem darstellen. Doch das ist weit gefehlt. Da besteht doch ein weiter unterschied. Das sehr verschiedene Dialekte.

IDE's

Die Standard IDE für Mono ist im Linux und Mac Umfeld MonoDevelop. Es gibt diese IDE auch für Windows. Trotzdem gehe ich davon aus dass für Windows SharpDevelop der Standard ist. Das ist aber bei Windows nicht eindeutig festzulegen weil Microsoft die ganze .NET Welt erschaffen hat. Selbstverständlich wird von Microsoft hier auch eine IDE angeboten. VisualStudio gibt es in einer freien hier "Express" genannten Version und zu kaufen.

Monodevelop

Im Windows Umfeld bewege ich mich nur noch an meinem Arbeitsplatz. Zu Hause sitze ich vor meinem Mac. Auf dem läuft in der VirtualBox auch Linux. Also gehe ich jetzt nur noch auf MonoDevelop ein. Obwohl ich auf meinem Arbeitsplatz PC SharpDevelop installiert habe. MonoDevelop ist einfach zu installieren. Das trifft sowohl auf die Linux Umgebung zu, wie auch auf dem Mac. Bei Linux ist das einfach ein Paket in der Paketverwaltung für den Mac ist auf der Mono-Projekt-Seite ein Paket mit der Runtime und dem SDK vorhanden das alles was das Herz begehrt enthält. Die MonoDevelop muss extra heruntergeladen und installiert werden. Dieses Programm prüft hier sogar ob eine neuere Version der IDE zur Verfügung steht. Wenn dies der Fall ist so wird angeboten diese herunter zuladen und anschließend zu installieren.
Für Windows gibt es eine GTK-Spezial Version für .NET.

Der Beginn

Wenn die Laufzeitumgebung von Mono und die IDE installiert sind kann es direkt losgehen. Die Laufzeitumgebung ist komplett. Das bedeutet es ist eine Kommandozeilen Schnittstelle vorhanden. Für die Darstellung grafischer Elemente, das GUI, sind für jede Plattform die GTK Bibliotheken vorhanden. Das ist besonders praktisch wenn man Programme einwickeln will die überall laufen. Sollte man bei Windows den Wunsch verspüren anstelle von GTK das Original .NET-Paket zu verwenden kann man die leichte Version von Mono installieren. Außerdem ist es sinnvoll Programme die rein in der Windows Umgebung laufen soll mit der SharpDevelop IDE zu entwickeln. SharpDevelop erlaubt es die WinForms zu verwenden.

Die Möglichkeiten

Für den Mac stehen diese Projektvorlagen bereit:

Bei Linux fehlen die Einträge "Mono für Android", "MonoMac" und "Mono Touch". Selbstverständlich stehen unter Linux Pakete bereit um die Möglichkeiten hier zu erhöhen.

Das erste Projekt

Zum Testen und probieren gibt es zu Glück auf der Mono-Prejekt-Seite ein GTK Projekt. Das habe ich versucht mit der Mac IDE nachzubauen. Dabei musste ich leider feststellen dass die IDE wackelt. Sie stürzt leider bei dem Zusammenflicken der GUI ab. Ich habe dann die GUI in der VirtualBox gebastelt dann hat alles funktioniert. Allerdings sind bei meiner realen Maschine (Mac) und der Virtuellen Maschine (Linux) die SDK Versionen nicht gleich. Deswegen kann man zwar Projekt in beiden Systemen abwechselnd bearbeitet aber nur beim Mac bauen.

Fazit
Es macht sogar Spaß etwas mit Mono zu machen. Und das obwohl ich mich eigentlich immer gegen .NET gewehrt hatte. Vielleicht hat mich der Umstieg zum Mac in dieser Richtung geläutert. Ein kleiner Zwang besteht natürlich auch hier, Microsoft lässt die alten Programmsprachen für die Systemverwaltung sterben. Also habe ich keine Lust mehr mich mit "CMD" und "VBS" auseinanderzusetzen. Mein primäres System ist der Mac. Trotzdem möchte ich ein SDK nutzen das es mir ermöglicht für alle Plattformen etwas zu machen. Java scheint mir im Moment etwas halbherzig vorangebracht zu werden. Was soll ich sagen, Mono fängt bereits an ein wenig Spaß zu machen.

QT Übersetzungen Extern oder im Programm

2011-05-05T23:35:00.000+02:00

Alternativen

Das QT-Paket bietet zwei Möglichkeiten die übersetzten Texte in das Programm zu integrieren.

Methode 1 (Linux like)

In einer externen Datei. Diese Datei enthält die entsprechenden lokalisierten Texte. Für jede Sprache ist eine Datei notwendig. Typisch ist das Sammeln dieser Dateien in dem Verzeichnis translations. In dem Programm, der Datei main.cpp ist der Code:


QString locale = QLocale::system().name();

QTranslator translator;
translator.load(QString("translations" +
QDir::separator() +
"jmnsishelper_") + locale);
a.installTranslator(&translator);

zu dem laden der Übersetzung notwendig. In der ersten Zeile wird ermittelt in was für einer Lokalisierung das Programm aktuell seine Arbeit tut. Das Ergebnis wird in die Variable locale gespeichert. Diese Variable enthält eine Zeichenkette, die für Deutschland de lautet. Diese Zeichenkette wird dann dem Dateinamen angehängt. Die neu gebildete Zeichenkette, die den Dateinamen enthält, wird jetzt der Klasse QTranslator übergeben. Die in der Bibliothek enthaltenen Funktionen kümmern sich dann um den Rest.

Methode 2 (Windows like)

Die zweite Möglichkeit stellt die Übersetzung als Resource bereit. Dazu wird die mit LRelease erzeugte qm Datei benötigt. Diese Datei wird dann in C++ Quelltext umgewandelt. Dieser Quelltext wird kompiliert um dann mit den anderen Quellkode Dateien zu einem Programm gelinkt zu werden.

Für das hinzufügen der Übersetzungen ist ein QRC Datei notwendig:


<rcc><qresource prefix="ts">
<file>jmnsishelper_de.qm</file>
<file>jmnsishelper_es.qm</file>
<file>jmnsishelper_it.qm</file>
<file>jmnsishelper_tr.qm</file>
</qresource></rcc>

Die Resource sieht so aus:


static const unsigned char qt_resource_data[] = {
0x0,0x0,0xa,0x55,
0x3c,
0xb8,0x64,0x18,0xca,0xef,0x9c,0x95, ...

da diese immer vom QMake Werkzeug oder besse mit CMake erzeugt wird muss man (zum Glück) hier nichts tun.
Der Quelltext der main.cpp sieht hier auch anders aus.


QString lang = QLocale::system().name();

QTranslator translator;
translator.load("jmnsishelper_" + lang, ":/ts/");
a.installTranslator(&translator);

Vorteile und Nachteile

Die zweite Möglichkeit vereinfacht das Zusammenstellen des Pakets. Außerdem spart man sich ein Unterverzeichnis. Auch der in main.cpp geschriebene Quellcode ist kürzer. Allerdings hat diese Methode aus Nachteile. Wenn die Übersetzung auf den neuesten Stand gebracht wurde ist das Programm komplett zu kompilieren und zu linken. Bei der Methode eins kann man einfach die qm-Datei im Verzeichnis translations ersetzen. Außerdem gibt es, zumindest bei Linux auch Werkzeuge die, die qm-Datei auslesen können. Das geht nach der Methode zwei nicht.

CMake für Programmpakete

2011-04-11T10:03:00.000+02:00

Hallo zusammen, wie bereits in früheren Einträgen beschrieben ist CMake sehr vielseitig. Im Gegensatz zu QMake lässt es sich für alle Arten von Projekten verwenden. Es ist nicht an eine Umgebung gebunden.

CPACK

Als zusätzliche Funktion haben die Entwickler sogar einen Paket Builder intergriert. Mit diesem, in dem normalen Programmumfang enthaltenen, Zusatzmodul kann man einfach das aktuelle Projekt packen. Wie nicht anders zu erwarten bietet CMake hier viele Ziele für verschiedene Umgebungen zu Verfügung.

Wie funktioniert es ?

Doch wie werden diese Funktion aufgerufen ? Das ist ganz einfach. Der CMakeLists.txt Datei muss nur eine Zeile hinzugefügt werden. INCLUDE(CPack)Dadurch wird nicht nur eine zusätzliche Textdatei mit dem Namen CPackList.txt erzeugt sondern auch ein neues Ziel in dem Makefile. Durch den Aufruf


make package

wird das für die aktuelle Umgebung definierte Standardpaket erzeugt. Die entsprechenden Optionen sollten in der CMakeLists.txt Datei festgelegt werden. So können Sie entsprechend der dem CMake bekannten Syntax festlegen wie das System das Paket erzeugt. Außerdem kann auch bei dem Aufruf noch die Variable belegt werden:

cmake -DCPACK_GENERATOR=DEB

würde ein Debian Paket erzeugt. Das geht alles einfach und locker von der Hand. Eine Warnung aber trotzdem noch. Die Betonung liegt hier wirklich auf einfach. Große komplizierte Paket lassen sich mit dieser Funktion natürlich auch nicht einfach erzeugen. Hier muss der Paketbetreuer oder der Programmierer verständlicherweise mehr Aufwand betreiben. Ein einfaches Beispiel ist hier zu finden.

Programmanleitungen erstellen

2011-03-28T10:10:00.000+02:00

Hallo zusammen,

ich teste gerade welches Werkzeug sich am besten eignet um Anleitungen und Online-Hilfe für Programme zu erstellen. Die erste Anleitung habe mit der Unterstützung von asciidoc erstellt. Das funktioniert recht gut und ist einfach zu erstellen. Das Programm asciidoc ist in Python programmiert und setzt deswegen einen installierten Python Interpreter voraus. Wenn sie die Funktion a2x verwenden wollen werden zusätzlich noch einige andere Softwarepakete benötigt. Für den vollen Funktionsumfang ist das:

xsltproc: (all formats except text): http://xmlsoft.org/XSLT/
DocBook XSL Stylesheets (all formats except text): http://docbook.sourceforge.net/projects/xsl/
dblatex (pdf, dvi, ps, tex formats): http://dblatex.sourceforge.net/
FOP (pdf format — alternative PDF file generator): http://xmlgraphics.apache.org/fop/
w3m (text format): http://w3m.sourceforge.net/index.en.html
Lynx (text format — alternative text file generator): http://lynx.isc.org/
epubcheck (epub format — EPUB file validator): http://code.google.com/p/epubcheck/

Die Paketverwaltung ihrer Linuxdistributation hilft ihnen die richtigen Pakete alle zu installieren.

Das Quellcode Format

Wer bereits das Format APT von Apache Maven Doxia kennt wird nicht überrascht sein. Die Formate ähneln sich etwas. Die komplette Anleitung ist hier zu finden. Ich werde hier an dem Beispiel der Anleitung zu meinem Programm jmnsishelper, das noch lange nicht fertig ist, erläutern wie asciidoc funktioniert.

Ein Dokument muss einen Header und eine Section enthalten um gültig zu sein.

Header

Ich habe bei meiner Dokumentation allerdings mit einem Kommentarblock begonnen. Der Kommentarblock beginnt und endet mit der Zeichenfolge: "////", das müssen mindesten vier gleiche Zeichen sein. Können aber natürlich auch mehr Zeichen sein.

Jetzt kommt auch bei mir der Header. Doch hier erst einmal ein Beispiel was wir bis jetzt haben:


//////////////////////////////////////////
Der Kommentar
//////////////////////////////////////////

Anleitung für JMNSISHelper
==========================
Jürgen Mülbert 
V0.1, März 2011

Der Header enthält den Titel des Dokuments. Das sind die beiden Zeilen, Anleitung für JMNSISHelper und ==========================. In der nächsten Zeile steht dann der Autor des Dokuments.Wahlweise können Sie in dieser Zeile auch noch die EMail-Adresse des Verfassers anhängen.In der letzten Zeile des Headers kommen dann noch zwei Informationen. Die Version des Dokuments und das Erstellungsdatum.

Das sieht doch schon gut aus.

Section

Die Section(en) enthalten den Inhalt der Dokumentation, also die gesamten Texte und eventuelle Illustrationen. Dazu gibt es wieder ein paar zusätzliche Formatbefehle.

Überschriften

Level 0 (top level):     ======================

Level 1:                 ----------------------

Level 2:                 ~~~~~~~~~~~~~~~~~~~~~~

Level 3:                 ^^^^^^^^^^^^^^^^^^^^^^

Level 4 (bottom level):  ++++++++++++++++++++++

Listen

* Listeneintrag

Bilder

image:images/document-new.png[document new] Neu

Links

https://launchpad.net/jmnsishelper[Projektseite] - extern

link:menuleiste[Die Menüleiste] 
        - intern (innerhalb des Dokuments.

Formattierung

*FETT* - Dieses Wort wird Fett dargestellt.

_EMPHASED_ - Dieses Wort wird betont dargestellt.

Am Ende der Zeile ein Leerzeichen gefolgt von einem 
 + erzeugt einen Zeilenumbruch.

Erzeugen von Zieldokumenten

XHTML

Das generieren eines (X)HTML-Dokumentes ist einfach. Hier wird nachdem das Quelldokument gespeichert wurde der Befehl asciidoc dateiname eingegeben. Dadurch wird mit der Hilfe der Quelldatei eine HTML-Datei erzeugt.

Andere Formate

Wenn alle Zusatzmodule installiert wurden ist es möglich aus der Quelldatei verschiedene andere Ziele zu erzeugen.

Es können Ziele für folgende Formate erzeugt werden: chunked, docbook, dvi, epub, htmlhelp, manpage, pdf (default), ps, tex, text, xhtml.

Dafür wird der Befehl a2x benötigt. Zum Beispiel erzeugt der Befehl a2x -L -f pdf dateiname auf der Datei ein PDF-Dokument.

Programm Anleitungen erstellen.

2011-03-06T10:08:00.000+01:00

Hallo zusammen,

lange habe ich gesucht und probiert.

Die Problemstellung war: Wie kann ich eine gute Anleitung für meine Programme erstellen ? Ich erstelle wie viele andere auch nicht gerne Programmdokumentationen und Anleitungen.

Java

Für die Java-Umgebung gibt es immerhin maven mit einem guten Werkzeug um auch Internetseiten zu erzeugen. Mit diesem Werkzeug könnt ihr sowohl Websites wie auch Source-Code, Abhängikeiten und Mitwirkende veröffentlichen. Maven ist ein komplettes Werkzeug mit dem alles was veröffentlicht werden soll auch veröffentlicht werden kann. Die Internetseiten können auch für mehrere Sprachen veröffentlicht werden. Toll.

C++ und andere Sprachen

Hier gibt es so etwas nicht. Dafür habe ich versucht qdoc3 aus der QT4 Entwicklungsumgebung zu verwenden. Das würde auch funktionieren. Allerdings erfüllt das Werkzeug dann seinen eigentlichen Zweck nicht mehr. Es werden gute Internetseiten aber schlechte Dokumentationen erzeugt.

Internet und Anleitungen trennen.

Also hilfe es nur diese beiden Verwendungszwecke zu trennen. Es funktioniert bei maven im Internet gut. Es werden sehr viele Dateien für das Web erzeugt, aber keine davon lässt sich als Programmdokumentation verwenden. Das ist sowohl für Online-Hilfe zutreffend, wie auch für die "beigepackte" Anleitung. Bei QT4 ist es genau anders herum. Hier wird, wenn man das ganze nicht vorher umbiegt, eine gute Online-Hilfe oder lokale Programmanleitung erzeugt aber ein mäßige Website. Oder man muss für diesen Zweck zwei Anleitungen erzeugen. Das ist nicht sehr zielführend...

Lösungen:

asciidoc

Mit asciidoc lassen sich aus normalen Textdateien gute HTML-Dokumente erzeugen. Außerdem kann mit dem Werkzeug a2x aus der Quelldatei ein PDF-Dokument erzeugt werden. asciidoc eignet sich auch zu der Generierung ganzer Websites. Also mehrere Textdokumente mit einem Menü versehen...

docbook-xsl

Mit Docbook können aus einer XML-Quelldatei verschiedene Dateien erzeugt werden:

html - Eine große Html-Datei
htmlchunked - Mehrere HTML-Datei
javahelp
MSHelp
PDF

Dieses Format ist also sehr vielseitig und in der Linuxwelt sehr verbreitet.

LaTex

Mit LaTex werden meistens sehr hochwertige Dokumentationen oder Bücher geschrieben. Auch dieses Format ist sehr vielseitig:

html
xhtml
docbook
openoffice
pdf
javadoc

Das ist erst einmal mehr wie docbook kann. Und dazu kommt noch die Möglichkeit LaTex zu docbook zu konvertieren. Das verspricht sehr interessant zu werden...

QDoc kann nicht für Websites eingesetzt werden!

2011-03-02T23:43:00.000+01:00

Hallo zusammen!
Ich habe es jetzt geschafft meine Dokumentation fürJMNSISHelper soweit fertigzustellen. Den HTML-Rahmen hatte ich auch an meine Website angepasst. Es kam eine passable Website heraus- Diese generierte Seite passte dann, wie von mir gewünscht, in der Form und Gestaltung zu den vorhandenen anderen Seiten. Die Seite sieht so aus:

Das was ich bis zu dieser Zeile geschrieben habe passt nicht zur Überschrift. Wer aber in meinem Blog schon gelesen hat, weis da kommt noch was.
Jetzt nachdem eigentlich alles gut war habe ich mit dem Hilfsprogramm qhelpgenerator die kompilierte Hilfsdatei erzeugt. Eine gute kurze englische Anleitung zu den QT-Hilfsprogrammen gibt es hier. Diese Programmhilfe habe ich mir danach gleich mit dem Assistant angesehen. Leider war das Ergebnis nicht so wie erwartert. Es wird hier trotz der gesetzten "-creator" Option immer noch die Online-Version erzeugt. Es wird auch hier der komplette HTML-Vorspann und HTML-Fuss mit eingebunden. Das Ergebnis könnte man fast genauso ins Web setzen. Das würde natürlich nicht funktionieren, weil Dateien mit der ".qhc" oder ".qhp" Erweiterung für einen Webbrowser nicht darstellbar sind. Es werden auch nicht alle Skripte im Kopf und Fuß der erzeugten Dateien eingebunden. Die Hilfedatei sieht so aus:

Also wenn der Wunsch aufkommt die Programmdokumentation in das Internet zu stellen qdoc3 nicht benutzen. Da erzeugt das Programm asciidoc schönere Ergebnisse. Dieses Programm kann auch zu der Generierung ganzer Website's genutzt werden. Ich werde das testen und hier berichten. Versprochen!
qdoc3 ist hervorragend geeignet um Programm-Anleitungen und Hilfen zu erzeugen. Der qhelpgenerator baut aus der qdoc-Datei eine komprimierte Hilfedatei, die über sqlite ausgelesen wird. Hier bin gerade beschäftigt das ganze mit cmake zu erzeugen. Ich bin gespannt wie das funktionieren wird...

QT und CMake

2011-02-17T22:17:00.000+01:00

Hallo liebe Leser,

nach dem ich jetzt bereits einige Erfahrungen mit C++ und qmake gemacht habe will ich euch etwas neues berichten. Ich habe das Thema erstellen von Programmen versucht aus der CMake Sicht anzugehen. Ich probiere immer gerne etwas neues. Es ist aber in diesem Fall wirklich so, CMake ist besser und hat auch andere Vorteile gegenüber qmake.

CMake ist nicht nur für QT geeignet.
CMake enthält auch Unterstützung für Installer.
CMake unterstützt findet aus dem System installierte Pakete und Script-Sprachen.

Natürlich ist auch ein klein wenig Schatten vorhanden. So ein Paket kann ja nicht nur glänzen. Allerdings ist der Mängel den ich entdeckt habe und über den ich am Anfang gestolpert bin nicht durch CMake verursacht. Das Problem liegt an der Windows-Version des QT-GPL Paketes. Bei dieser Version ist ein "MINGW32-MAKE" enthalten das zusammen mit CMake nicht funktioniert. Wer also genau wie ich es bei QT-Windows mit CMake versuchen will muss zuerst zusätzlich das MINGW in der aktuellen Version installieren. Die neu installierte Version funktioniert dann einwandfrei.
Um den Bau eines neuen Programms zu vereinfachen legt ihr euch am besten eine BATCH Datei an die, die Umgebungsvariablen setzt. Die Alternative wäre unter Arbeitsplatz die entsprechenden Pfade unter PATH hinzuzufügen. Ich habe hier nur "C:\MINGW\bin" eingetragen damit die GUI-Variante von CMake auch den Compiler findet. Die restlichen Pfade werden in einem Script gesetzt das ich "CMakeShell.bat" genannt habe. Es ist nicht der kreativste Name, aber er trifft doch genau. In dieser Datei werden die Pfade zu dem QT-Verzeichnis, dem MINGW-Verzeichnis und dem CMake-Verzeichnis gesetzt. Jeder kann diese einfache kleine Datei bei bedarf erweitern:


echo Setting up a MinGW/Qt only environment...
set QTDIR=C:\Qt\2010.05\qt
set CMAKEDIR="C:\Programme\CMake 2.8"
set MINGWDIR=C:\MinGW
set PATH=C:\Qt\2010.05\qt\bin
set PATH=%PATH%;%QTDIR%\bin;%MINGWDIR%\bin;%CMAKEDIR%\bin
set PATH=%PATH%;%SystemRoot%\System32

Jetzt müsst ihr nur beachten dass nicht das Batch-Script direkt gestartet wird. Das würde nur dazu führen das ein DOS-Fenster sich für einen Moment auf dem Bildschirm zeigt um gleich wieder zu verschwinden. Der Trick hier besteht darin eine neue Verknüpfung anzulegen. Diese Verknüpfung muss dann unter Ziel so anfangen: "C:\WINDOWS\system32\cmd.exe /K ". Direkt nach dem Leerzeichen folgt dann der Pfad zu dem Batch-Script.

So und nun viel Spaß mit dem Testen von CMake. Ich werde zu diesem Thema hier auch bald wieder etwas schreiben.

QDoc nutzen

2011-01-23T23:20:00.000+01:00

Ich arbeite an dem Programm jmnsishelper

Das ist mein erstes C++ und QT Projekt. Deswegen probiere ich selbstverständlich auch viel aus. Schließlich ist alles neu.

Deswegen war es auch klar das ich versucht habe mit QDOC die Programmdokumentation und die zugehörige Website zu erstellen. Das hat wieder einmal sehr viel Zeit gekostet. Aber dadurch habe ich auch gelernt wie QT4 hier "tickt". Schon wieder anders wie erwartet. Ich hatte mir anhand des Quellcode einfach ein Beispiel in mein Projektverzeichnis kopiert. Jetzt hatte ich gedacht, einfach loslegen ist doch alles ganz einfach.

Dies wäre zwar schön gewesen. Doch leider ist alle Arbeit mit Mühe verbunden. Die Probleme die sich bei diesen Versuchen herausstellten:

Es wurden trotz mehrfach geänderten Eingaben in der Konfigurationsdatei immer nur die vorgegeben CSS und JavaScript Dateien in die HTML Datei geschrieben.
Die lokalisierte Version lies sich nicht erstellen,

Das zweite Problem hat nur indirekt etwas mit QDOC zu tun. Hier hilft nur eine Überarbeitung des QMAKE Files. Wie weiter oben erwähnt habe ich ein Original QT4 Projekt als Grundlage gewählt. Deswegen habe ich keine PRO-Datei als QMAKE-Datei sondern eine inklude Datei die die Endung PRI hat. In dieser Datei habe ich dann zusätzlich zu den vorhandenen Zeilen, die Zeilen für die deutsche Version hinzugefügt. Es ist hier wichtig die erzeugten Dateien in einem seperaten Verzeichnis erzeugen zu lassen weil der aktuelle Inhalt des Verzeichnisses gelöscht wird bevor die neuen Datei erzeugt werden. Wer Interessiert ist kann sich die angepasste Datei hier ansehen.

Das zweite Problem war noch schwieriger zu lösen. Genauso wie bei dem ersten geschilderten Problem habe ich selbst im Web keine verwendbare Lösung gefunden. Es wurde im Kopf der HTML-Datei immer diese Zeilen erzeugt:

  
<script src="scripts/jquery.js" 
type="text/javascript"></script>
<script src="scripts/functions.js" 
type="text/javascript"></script>

</head>

Sämtliche Änderungen an der Konfigurationsdatei haben nichts geholfen. Ich hatte versucht das ganze mit dem YUI-Framework zu realisiern. Aber weder die Änderung der Zeile HTML.stylesheets = classic.css noch der Zeile HTML.style = "CSS-Code ..." änderten irgend etwas. Eigentlich hatte ich erwartet hier etwas beeinflussen zu können. Also bei den CSS und JaveScript geht hier gar nichts. Aber die Textzeile hinter HTML.postheader, HTML.postpostheader und HTML.footer werden übernommen. Seltsam.

Eine richtige Lösung konnte ich hier nicht finden. Aber das Problem soweit umgehen das ich an dem jmnsishelper wieder weiterarbeiten kann. Ich habe mir den Quellcode von QT4 geladen und die Quellen von dem QDOC-Tool genauer angesehen. Das Problem ist, die Konfigurationszeilen, die die Stylesheets betreffen werden einfach nicht berücksichtigt. Deswegen ändert sich auch nichts egal was hier steht. Nun kann man so eine schöne aber extra schlichte HTML-Seite nicht oder sehr schlecht in meiner Web-Präsenz einbinden. Ich war eigentlich dabei auf das YUI-Framework umzustellen. Aber das kann ich jetzt vergessen. Es gibt zwar eine Lösung um eine wirklich nutzbare HTML-Seite zu erzeugen, aber hier wird das jQuery Skript zugrundegelegt. Der Aufwand mit dem YUI-Framework war schon gross und beides will ich nicht. Deswegen zurückrudern und umstellen auf jQuery und Superfish. Aber nach diesem Ausflug. Diese Zeile erzeugt QDOC im online Modus.

 
<link rel="stylesheet" 
type="text/css" href="style/style.css" />
<script src="scripts/jquery.js" 
type="text/javascript"></script>
<script src="scripts/functions.js" 
type="text/javascript"></script>
<script src="./scripts/superfish.js" 
type="text/javascript"></script>
<link rel="stylesheet" 
type="text/css" href="style/superfish.css" /> 
<script src="./scripts/narrow.js" 
type="text/javascript"></script>
<link rel="stylesheet" 
type="text/css" href="style/narrow.css" />
<!--[if IE]>
<meta name="MSSmartTagsPreventParsing" content="true">
<meta http-equiv="imagetoolbar" content="no">
<![endif]-->
<!--[if lt IE 7]>
<link rel="stylesheet" 
type="text/css" href="style/style_ie6.css">
<![endif]-->
<!--[if IE 7]>
<link rel="stylesheet" 
type="text/css" href="style/style_ie7.css">
<![endif]-->
<!--[if IE 8]>
<link rel="stylesheet" 
type="text/css" href="style/style_ie8.css">
<![endif]-->
</head>
<body class="" onload="CheckEmptyAndLoadList();">

Also deutlich mehr Zeilen. Wie oben bereits angedeutet mit ein paar zusätzlichen CSS und JaveScript Dateien. Die hier erzeugten Zeilen sind genauso wie die Zeilen im QDOC creator Modus vorgegeben und lassen sich nicht ändern. Jetzt wird auch dem Footer etwas hinzugefügt.


<script src="scripts/functions.js" 
type="text/javascript"></script>
<!-- <script type="text/javascript">
var _gaq = _gaq || [];
_gaq.push(['_setAccount', 'UA-4457116-5']);
_gaq.push(['_trackPageview']);
(function() {
var ga = document.createElement('script'); 
ga.type = 'text/javascript'; 
ga.async = true;
ga.src = ('https:' == document.location.protocol 
? 'https://ssl' : 'http://www') 
+ '.google-analytics.com/ga.js';
var s = document
.getElementsByTagName('script')[0]; 
s.parentNode.insertBefore(ga, s);
})();
</script> -->

Richtig die Zeile mit functions.js hatten wir im Kopf der Datei bereits. Bemerkenswert finde ich das automatisch der Code für Google Anlytics erzeugt wird. Mit dem Account von Nokia-QT. Klar. Zum Glück aber nur halb so schlimm wie es auf den ersten Blick wirkt. Der Code ist auskommentiert. Den auf dieser Seite angezeigten Code habe ich teilweise neu formartiert damit er in den vorgesehenen Textrahmen passt. Den Code habe ich nicht verändert.

QMake und Linux Projekte

2011-01-14T21:59:00.000+01:00

Hallo zusammen,

wieder eine Erfahrung mehr mit dem QT-Frameworks. Das Gute daran ist: "Diese Umgebung gefällt mir jetzt noch besser".

Ich hatte bereits früher Pakete für Ubuntu geschnürt. Allerdings nur Projekte die auf Java basieren. Da ich mich mehr mit C++ und QT vergnüge habe ich selbstverständlich jetzt auch neue Herausforderungen. Jetzt aktuell wollte ich ein Paket für mein aktuelles Projekt JMNSISHelper bauen. Das kompilieren ist dank der guten Unterstützung durch qmake kein Problem. Die Reihenfolge qmake <projektname.pro> gefolgt von make kompiliert das Programm. Zumindest unter Ubuntu lässt sich das Ergebnis jetzt einfach starten und testen. Jetzt haben wir aber erst die erste Hälfte des Weges hinter uns. Das Ziel war ein Paket zu bauen. Mit der Standard qmake.pro Datei ist das aber unmöglich:


#-------------------------------------------------
#
# Project created by QtCreator 2010-10-29T21:58:42
#
#-------------------------------------------------

QT       += core gui

TARGET = jmnsishelper
TEMPLATE = app

SOURCES += main.cpp\
mainwindow.cpp \
highlighter.cpp

HEADERS  += mainwindow.h \
highlighter.h

FORMS    += mainwindow.ui

TRANSLATIONS += translations/jmnsishelper_de.ts\
translations/jmnsishelper_es.ts\
translations/jmnsishelper_it.ts


RESOURCES += \
jmnsishelper.qrc

Das hilft uns deswegen nicht weil wir Unix-Entwickler im Gegensatz zu den Windows-Leuten eine feste Struktur haben. Wir wollen unsere Programme nicht einmal in \usr\bin\, dann wieder in \sbin speichern. Das würde die Zahl der Fans unserer Programme in das uferlose steigen lassen. Deswegen sollte es doch irgendwie möglich sein qmake mitzuteilen, wohin der gute Entwickler sein Produkt installieren will. Es wird wieder niemand wundern, die haben das eingebaut. Denn wenn wir die folgenen Zeilen einfügen:


# Definition of Target
target.path = /usr/share/jmnsishelper
INSTALLS += target

# Definition for Data
data.path = /usr/share/jmnsishelper
data.files = data/*
INSTALLS += data

# Definition for QM's
qm.path = /usr/share/jmnsishelper
qm.files = build/*.qm
INSTALLS += qm

bekommen wir ein schönes Makefile, das uns die oben genannten Probleme beseitigt. Selbstredend sollte der Projektname JMNSISHelper durch Ihr eigenes Projekt (den Namen) ersetzt werden. In meinem Programm werden durch den Befehl make install alle erzeugten Dateien in das Verzeichnis das hinter target.path oder anders ausgedrückt hinter der jeweiligen *.path-Zeile angeben ist kopiert. Deswegen ist jetzt die Struktur vorhanden die wir uns weiter oben so sehr gewünscht haben. Die Paket Werkzeuge rufen immer die beiden Befehlsfolgen make und make install auf. Hier findet dann unser debuild oder pbuilder schon fast alles was es benötigt. Wir müssen aber in der rules Datei noch kleine Hilfestellungen geben:


build-stamp:
dh_testdir

# Hier die Kommandos zu kompilieren einfügen.
qmake-qt4 -config release
make

Das build-stamp: habe ich mitgenommen um zu zeigen wohin der erste Teile gehört. Hier sind die beiden Zeilen nach dem Kommentar # Hier ... wichtig. Erste Zeile das Makefile generieren. In der zweiten Zeile wird das Programm gebaut. Dann noch eine Kleinigkeit einfügen:


install:
...
# Hier den Befehl zum installieren des
# Pakets in das Verzeichnis debian/
make INSTALL_ROOT=`pwd`/debian/jmnsishelper install

Mit diesen Veränderungen konnte ich mein erstes QT4 C++ bauen. Damit meine Bemühungen auch Sinn machen habe ich das dann auch in meinem PPA zur Verfügung gestellt.

Ich freue mich das ich hier weitergekommen bin und überlege mir bereits die nächsten Schritte...
Bis demnächst.

Kompilierung der TS-Dateien mit QMAKE

2011-01-01T19:43:00.000+01:00

Bei dem erzeugen einer ausführbaren Datei ist das QMAKE-Tool des QT-Frameworks ein sehr hilfreiches Werkzeug. Einmal ehrlich, wer von uns will sich noch ernsthaft damit beschäftigen eine richtige Makefile Datei zu erstellen ?
Die Antwort kann hier nur niemand lauten. Deswegen sind die beiden Werkzeuge qmake und natürlich auch cmake sehr hilfreich.
Doch wieder zurück zum Thema. Trotz der Zeilen


TRANSLATIONS += translations/jmnsishelper_de.ts\
translations/jmnsishelper_es.ts\
translations/jmnsishelper_it.ts\
translations/jmnsishelper_tr.ts

passiert in der Richtung automatisch Übersetzung nicht viel, eher gar nichts. Diese Zeilen machen natürlich wirklich Sinn. Es geht hier darum den beiden Werkzeugen LUPDATE und LRELEASE mitzuteilen wohin die zu übersetzenden Texte zu schreiben sind. Dazu werden mit der Hilfe des Tools LUPDATE die in den SOURCES und FORMS angegebenen Quellen durchsucht. Die hier gefundenen Texte werden dann in die unter TRANSLATIONS angegebenen Dateien geschrieben und können hier mit dem LINGUIST übersetzt werden. Mit dem LRELEASE Tool werden dann die TS-Dateien in QM-Dateien umgewandelt, die dem fertigen Programm die übersetzten Worte und Sätze zur Verfügung stellt.
Schön, habe ich gedacht, wäre es wenn wenigsten die QM-Dateien in dem Release Verzeichnis landen würden. Also wieder einmal durch die leider nur in englisch vorhandene Dokumentation gekämpft. Leider nichts zu finden. Aber das Internet bietet fast für alle Probleme irgendeine Lösung. Hier habe ich ein SNIPPET gefunden das die TS-Dateien in die Release-Version QM-Datei umwandelt. Diese Lösung ist dann auch noch so gut dass wieder ein Schritt automatisch bei dem Bauen des Programms mitgemacht wird. Aber das war mir noch nicht genug. Ich möchte die QM-Dateien auch noch in dem richtigen Verzeichnis haben. Also habe ich mir das SNIPPET genau angeschaut.


!isEmpty(TRANSLATIONS) {

isEmpty(QMAKE_LRELEASE) {
win32:QMAKE_LRELEASE = $$[QT_INSTALL_BINS]\lrelease.exe
else:QMAKE_LRELEASE = $$[QT_INSTALL_BINS]/lrelease
}

isEmpty(TS_DIR):TS_DIR = Translations

TSQM.name = lrelease ${QMAKE_FILE_IN}
TSQM.input = TRANSLATIONS
TSQM.output = $$TS_DIR/${QMAKE_FILE_BASE}.qm
TSQM.commands = $$QMAKE_LRELEASE ${QMAKE_FILE_IN}
TSQM.CONFIG = no_link
QMAKE_EXTRA_COMPILERS += TSQM
PRE_TARGETDEPS += compiler_TSQM_make_all
} else:message(No translation files in project)

vielen Dank hier an Qt-interest Archive. Ich habe diese Zeile in meine QMAKE Projektdatei eingefügt und zu erst einmal getestet was hier passiert. Das Ergebnis war gut aber nicht perfekt. Die QM-Dateien wurden im gleichen Verzeichnis erzeugt in dem die TS-Dateien bereits vorhanden waren :-(
Also ein paar kleine Änderungen:
Das Verzeichnis Translations ist bei meinem Projekt komplett klein geschrieben. Hier die erste Anpassung: isEmpty(TS_DIR):TS_DIR = translations.
Als nächstes die QM-Dateien noch in das richtige Verzeichnis. Dazu muss die Zeile in der das LRELEASE-Tool aufgerufen wird erweitert werden. Die neue geänderte Zeile sieht jetzt so aus: TSQM.commands = $$QMAKE_LRELEASE ${QMAKE_FILE_IN} -qm $$DESTDIR/${QMAKE_FILE_BASE}.qm. Durch die Erweiterung -qm [Datei] wird LRELEASE mitgeteilt das Ergebnis nicht einfach an den gleichen Ort abzuspeichern wie die Quelle, sondern in der angegebenen Datei. Das Ergebnis kann sich sehen lassen:

QTHelp oder QTAssistant für I18N-Hilfe

2010-12-24T00:15:00.001+01:00

Hallo zusammen,

hier wieder einmal ein Problem das sich mir gestellt hatte und ich dann lösen konnte.

Es geht wieder einmal um die Internationalisierung. In diesem Fall einmal nicht um Teile des Programmes, sondern um die Hilfe oder Anleitung. Ich habe bereits in vorherigen Artikeln begeistert geschrieben dass QT hier komplett ist. Deswegen ist auch ein Tool dabei um Hilfeseiten oder sogar Kontext bezogene Hilfe anzeigen zu können. Das ist toll und funktioniert sehr gut bei reinen englischen Texten. Oder Sie verzichten auf englisch und machen gleich alles auf deutsch. Das ist aber nicht so prickelnd.

Als ich auf diese Problematik gestoßen bin habe ich erst einmal im Netz gesucht, aber keine Lösung gefunden. Deswegen habe ich dann selbst das Problem beseitigt.

Die komprimierte Hilfedatei muss für jede Sprache für die das Programm zur Verfügung gestellt wird extra kompiliert werden. Jetzt muss natürlich dem Assistant mitgeteilt werden wie der an die "richtige" Sprache kommt. Dazu habe ich dafür gesorgt das die Lokalisierung, auf der der Computer läuft mit übergeben wird:

bool Assistant::startAssistant(const QString &locale) {
QString country = locale.left(2);

Die Begrenzung auf nur zwei Zeichen für die Lokalisierung hat den Vorteil dass man sich spart für jedes Land mit der gleichen Sprache ein extra Hilfedatei bereitzustellen. (de_DE, de_AT usw...).
Jetzt muss natürlich noch geprüft werden ob die Hilfedatei existiert. Wenn das der Fall ist kann diese geladen werden. Es soll vorkommen das Projekte (Programme) in vielen Sprachen bereitgestellt werden. Deswegen ist es sicher öfters so dass die Hilfe und Anleitung nicht für alle Sprachen bereitsteht. Hier stehen zwei oder sogar drei Möglichkeiten zur Reaktion frei.

1. Es wird eine Fehlermeldung ausgegeben. Die Hilfe steht für Ihre Sprache nicht zur Verfügung.. Der Benutzer muss halt damit leben.

2. Es wird keine Fehlermeldung ausgegeben und einfach die grundlegenden (meistens englische) Hilfe und Anleitung geladen.

3. Es wird eine Fehlermeldung ausgegeben. Die Hilfe steht für Ihre Sprache nicht zur Verfügung. Es kann aber die englische Hilfe geladen werden.

Die Fehler und Hinweistexte sind dann selbstverständlich in der Sprache des Anwenders angezeigt. Ach ja ich bevorzuge die dritte Möglichkeit und werde den entsprechenden Code in diesem Betrag ergänzen.

QTCreator kann keine Unterverzeichnisse

2010-12-14T19:21:00.000+01:00

Hallo liebe Leserinnen und Leser,

ich arbeite gerade an einem QT Projekt, dem JMNSISInstaller. Ich wollte von Anfang an allzu großes Chaos vermeiden. Deswegen habe ich gedacht, ich könnte hier auch mit Unterverzeichnissen arbeiten. Ich kannte es so aus meiner bisherigen Erfahrung mit JAVA. Das Programm qmake bietet diese Möglichkeit schließlich auch. Also sollte das kein Problem sein. Falsch gedacht.
Die Einstellung vom QTCreator bieten hier keine Lösung für diese Idee. Da ich mich ein wenig mit qmake beschäftigt hatte war es kein Problem die Projekt .pro Datei ein wenig anzupassen. Danach funktioniert das kompilieren und linken des Projekts ohne Probleme. Aber die Quelldateien müssen dem Projekt erst wieder bekannt gemacht werden. Nach diesem Schritt sieht es so aus als ob alles gut sein sollte...
Wie aus den Worten des letzen Absatzes zu erwarten war ist dem nicht so. Kommt man jetzt auf die aberwitzige Idee dem Projekt eine zusätzliche Klasse, also Datei, zu spendieren gibt es eine Überraschung. Die neue Datei landet nicht im dem dafür vorgesehenen src oder ui Verzeichnis. Sie wird wieder an der alte früher dafür vorgesehenen Stelle dem Wurzelverzeichnis erzeugt.
Deswegen QT Framework kann es, der QTCreator (noch) nicht. Ich habe die Änderungen in der Projekt .pro Datei wieder rückgängig gemacht. Bis es von QT Nokia hier eine bessere Lösung gibt werde ich mit vielen Dateien im Wurzelverzeichnis arbeiten.

Aus QT4 Programme starten

2010-11-21T13:45:00.000+01:00

Hallo,
hier mein nächster Erfahrungsbericht über die Programmentwicklung mit dem QT-Framework.
Ich habe damit begonnen ein Programm mit dem QT4 Framework zu schreiben. Ziel dieses Programms ist es die Entwickung von NSIS Installer-Skripten zu unterstützen. Die Fortschritte und Entwicklung dieses Programms kann auf der Projektseite verfolgt werden.
Doch nun zu dem Thema. Wie startet man eigentlich ein Programm aus einem laufenden anderen Programm mit dem QT-Framework? Richtig da gibt es eine Klasse dafür. Also einfach:
QProcess System_Call;
System_Call.start("notepad.exe");
hilft nicht wirklich. Hier muss schon ein etwas größerer Aufwand betrieben werden. Ich habe mich auch erst einmal im Netz umsehen müssen bevor ich mein Ziel erreicht hatte.
Als erstes ist der komplette Pfad der Datei hilfreich. Also C:\programme\nsis\makensis.exe oder /usr/bin/makensis hat bei mir funktioniert. Ohne den Pfad hatte der Computer keine Lust das externe Programm zu starten. Jetzt kommt natürlich noch eine kleines aber nicht unwichtiges Detail. Wurde das Programm das ich aufgerufen hatte ausgeführt, wenn ja fehlerfrei ?
Um das auch noch sicherzustellen muss der Programmkode erweitert werden:

if( System_Call.waitForStarted() == false ) {
qDebug("error");
QMessageBox::warning(this, tr("JMNSisHelper"),
tr("Error compiling the script %1\n.")
.arg(curFile));
} else {
System_Call.waitForFinished();
QByteArray X = System_Call.readAllStandardOutput();
qDebug(X.constData());
QByteArray Y = System_Call.readAllStandardError();
qDebug(Y.constData());
QMessageBox::warning(this, tr("JMNSisHelper"),
tr("Error compiling the script %1.\n\n%2")
.arg(curFile)
.arg(X.constData()));
}
Das ist ein Codeausschnitt aus dem oben erwähnten Programm Projektseite. Hier ist zu erkennen das es eine Abfrage gibt ob das externe Programm gestartet werden konnte. Wenn hier ein Fehler auftritt wird ein entsprechende Meldung ausgegeben. Am Schluß, nach dem das Programm fertig ist wird dann nochmal eine Meldung ausgegeben.

NSIS Installer für QT Projekte

2010-11-04T11:56:00.001+01:00

Hallo,
wie ich in dem letztem Beitrag versprochen habe, gehe ich diesmal intensiv auf das Thema NSIS Installer ein. Der NSIS (Nullsoft Scriptable Install System) ist sehr vielseitig konfigurierbar und deswegen können die Skripte groß werden. Ich habe mich mit diesem Thema jetzt beschäftigt und ein erstes Skript geschrieben, mit Anregungen von vorhandenen Install-Skripten, mit dem das Erstellen von Setup.exe erleichtert werden soll.
Das habe ich versucht zu erreichen in dem ich an dem Anfang dieses Skriptes mit viel Variablen arbeite. Doch jetzt genug der Einführung, hier das Skript mit den zugehörigen Erklärungen.
Der Installer ist wieder für das Adressbuch Beispiel aus Qt.


!define PRODUCT_NAME "AddressBookSample"
Name "${PRODUCT_NAME}"
!define EXE_NAME "part2.exe"
!define PRODUCT_VERSION "0.2"
!define VER_MAJOR 0
!define VER_MINOR 2
!define VER_REVISION 2
!define VER_BUILD 10
!define PRODUCT_PUBLISHER "Jürgen Mülbert"
!define PRODUCT_WEBSITE 
             "http://www.juergen-muelbert.de"
!define PRODUCT_SUPPORT_SITE 
             "http://www.juergen-muelbert.de/support.html"
!define PRODUCT_DIR_REGKEY 
             "Software\Microsoft\Windows\CurrentVersion\
              App Paths\${EXE_NAME}"
!define PRODUCT_UNINST_KEY 
             "Software\Microsoft\Windows\CurrentVersion\
              Uninstall\${PRODUCT_NAME}"
!define REG_KEY "SOFTWARE\$(^NAME)"
!define INSTALL_ROOT_KEY HKLM

Die meisten oben gezeigten Definitionen erklären sich selbst.HKLM ist der RegistryKey für die "lokale Maschine". Ansonsten gleich weiter...


;--------------------------------
;Configuration
Caption "${PRODUCT_NAME} ${PRODUCT_VERSION} Setup"
BrandingText " © Jürgen Mülbert "
!ifdef OUTFILE
OutFile "${OUTFILE}"
!else
OutFile 
   ..\${PRODUCT_NAME}-${PRODUCT_VERSION}-setup.exe
!endif
;Installer attributes
InstallDir $PROGRAMFILES\${PRODUCT_NAME}
InstallDirRegKey 
  ${INSTALL_ROOT_KEY} "${PRODUCT_DIR_REGKEY}" ""

Wie hier in dem oben genannten Text zu sehen ist wird bereits bei der Konfiguration ausgiebig auf definierten Konstanten zugegriffen. Das zieht sich durch die gesamte Datei wie wir am nächsten Beispiel sehen werden.


;--------------------------------
;Installer Sections
Section !$(secmain) secmain

SetDetailsPrint textonly
DetailPrint "Installing ${PRODUCT_NAME} Core Files..."
SetDetailsPrint listonly
SectionIn 1 2 3 RO
SetShellVarContext all
SetOutPath $INSTDIR
SetOverwrite on
File ${EXE_NAME}
File changelog.txt
File libgcc_s_dw2-1.dll
File mingwm10.dll
File QtCore4.dll
File QtGui4.dll
File addressbook_de.qm

WriteRegStr ${INSTALL_ROOT_KEY} "${REG_KEY}\Components" sec_main 1
SectionEnd

Hier ist als letztes Beispiel die Hauptsektion aufgeführt. In diesem Abschnitt werden alle notwendigen Komponenten installiert damit das Programm überhaupt laufen kann. Wie hier schön zu sehen ist taucht als Variable der PRODUCT_NAME auf. Der wird zwar nur für das Detailprotokoll verwendet, aber immerhin. Die INSTALLDIR wurde schließlich auch mit dem PRODUCT_NAME initialisiert und das viel weiter oben. Übrigens der Befehl SetShellVarContext legt mit der Option all fest das diese Installation für alle Benutzer dieses Computer durchgeführt wird. SetOverwrite on bewirkt alle vorhandenen Dateien werden durch die Dateien im Installationsarchiv überschrieben. Die nächste benutzte Variable ist EXE_NAME, die einfach den Namen des ausführbaren Programms enthält. Der Inhalt der Datei changelog.txt wird nach der Installation angezeigt:
!define MUI_FINISHPAGE_SHOWREADME $INSTDIR\changelog.txt
!define MUI_FINISHPAGE_SHOWREADME_TEXT changelog.txt
Die DLL's sind notwendig. Das sind die zwei DLL's mit dem QT kompiliert wurde. Ohne die benutzten Qt-Bibliotheken würde es natürlich auch nicht funktionieren. Am Ende der Dateiliste steht noch die Übersetzungsdatei für die deutschen Texte des Adressbuch Beispiels. Zum Schluß dieses Abschnitts wird noch in die Windows-Registry geschrieben das die Hauptkomponente installiert wurden.
Wie gesagt das zieht sich so durch das gesamte Skript, das mit diesem Link vollständig zu sehen ist. Auf meiner Website gibt es jetzt die Projekte JMNSISHelper und NSIS4Java zu diesem Thema.

QT Projekte internationalisieren

2010-10-17T20:06:00.000+02:00

Eine interessante Frage stellte sich durch Zufall recht früh. Das Thema Internationalisierung. Ich arbeite zum Kennenlernen das QT-Frameworks das Adressbuch Beispiel (Tutorial) durch. Bereits im zweiten Kapitel tauchte die Zeile: setWindowTitle(tr("Simple Address Book")); auf. Nun gut, ich hatte mich schon einmal mit QT beschäftigt. Deswegen ist mir bekannt, die Zeichenfolge tr("text") bedeutet: Der Text "text" soll internationalisiert werden. Also habe ich an dieser Stelle gleich einmal den Kurs verlassen und mich mit diesem Thema auseinandergesetzt.

Also wie funktioniert das und ist ein einfach oder umständlich?

Es ist wirklich einfach ein Programm zu schreiben und dieses an verschiedene Spracheräume anzupassen.
Als erstes muss in der Projekt.pro Datei die Zeile TRANSLATIONS = programm_de.ts programm_es.ts hinzugefügt werden. Wobei der Name "programm" für den Namen der erzeugten Sprachdatei steht. Die Erweiterung "_de", "_es" oder eine beliebige andere gültige Spracherweiterung sorgt dafür dass später die Lokalisierung erfolgen kann. Normalerweise sollten die ".ts" Dateien beim build-Prozess automatisch aktualisiert werden. Bis jetzt ist mir das mit dem QTCreator unter Windows noch nicht gelungen. Es geht aber auch von Hand. In dem Projekt Verzeichnis des QT-Befehl lupdate aufrufen. Dieser Befehl bringt alle ".ts" Dateien, die in der Projekt.pro stehen auf den neuesten Stand. Das bedeutet die "c++"-Quelldateien werden auf die weiter oben erwähnten tr() Zeichenfolgen überprüft. Wenn so etwas gefunden wird wandert das in die Sprach-Quelldateien. Aber das ist noch nicht alles. Es werden natürlich auch die Formular-Quellen ".ui" auf Texte untersucht. Auch die hier gefundenen Texte wandern in die Sprach-Quelldateien.

Diese Sprach-Quelldatei(en) werden dann mit dem QTLinguist bearbeitet. Vollständig und als gültig erklärte Texte werden dann später in dem ausgeführten Programm auch lokalisiert angezeigt.

In dem oben gezeigten Beispiel sind überall grüne Haken zu sehen. Das bedeutet alle Texte für diese Anwendung sind komplett übersetzt. Sollte hier außer der grünen Haken auch ein Ausrufe- oder ein Frage-Zeichen zu sehen sein, so wird der so gekennzeichnete Text später in der Sprache ausgegeben werden, in der der Programmierer den Originaltext hinterlegt hat. Die Originaltexte der meisten Programme werden in englisch hinterlegt und später übersetzt. Das ist selbstverständlich auch gut so, denn ist ein Programm nicht vollständig übersetzt, wird zumindest dann der Originaltext ausgegeben. Das erspart uns leere Schaltflächen oder Textfelder vor denen keine Erklärung steht.

Die so bearbeiteten Sprach-Quelldateien müssen aber noch kompiliert werden. Das erledigt das Werkzeug lrelease für uns. Auch hier hilft die Projekt.pro-Datei wieder. Alle Sprach-Quellen, die hier aufgeführt sind werden auch kompiliert. Ein einzelne Datei kann aber auch über den QTLinguist direkt kompiliert werden. Hier gibt es in dem Datei-Menü den Befehl "Freigeben" oder "Freigeben als...". Das bedeutet schließlich nichts anderes als der Befehl lrelease.
Jetzt sollte alles funktionieren, aber ess fehlt noch etwas. Die kompilierten Sprachdatei ist in das Verzeichnis in der sich das Programm befindet kopiert, trotzdem klappt es nicht. Woran liegt es ?
Ganz einfach unserem lieben Programm haben wir noch garnicht mitgeteilt: "Jetzt kannst du mehrere Sprachen". Das holen wir jetzt ganz schnell nach. Das funktioniert, mich wundert es langsam nicht mehr, bei dem QT-Frameworks ganz einfach. Vier zusätzliche Programmzeilen in der main.cpp Datei helfen hier:

QString locale = QLocale::system().name();
QTranslator translator;
translator.load(QString("addressbook_") + locale);
a.installTranslator(&translator);

Diese vier Zeile holen die lokalen Einstellungen unter der dieser Computer seine Arbeit tut. Dann wird die für diese Einstellung richtige Sprachdatei geholt, falls vorhanden. Zu Schluß bekommt die QApplication noch mitgeteilt: Es gibt eine Übersetzung. Nach diesen Änderungen das Programm neu erstellen. Dann ein neuer Test. Es funktioniert.
Allerdings nicht direkt aus dem QTCreator. Hier gibt es anscheinend noch ein paar spezielle Einstellung die das verhindern. Das schaue ich mir später nochmal an...
Ich habe dann auch versucht den Installer zu internationalisieren. Also anscheinend ist das bei der MS Umgebung nicht vorgesehen. Das hat mich dazu bewegt mich wieder ganz schnell von WiXEdit und MS Installer Pakete zu verabschieden. Also willkommen zurück NSIS, das auch als Installer für QT verwendet wird. Dazu mehr demnächst...

Programmieren mit QT

2010-10-13T22:18:00.000+02:00

Hallo zusammen,

nach längerer Zeit wieder einmal etwas neues hier.

Ich ware lange Zeit ein JAVA Fan. Nichts ging über JAVA, bis vor kurzem. Ich habe versucht mit der Hilfe des BSAF eine Anwendung zu schreiben. Außer viel ärgern hat das nichts bewirkt.
Deswegen ganz etwas anderes. Die erste Idee war "Probiere doch einfach einmal Mono oder das Microsift NET Framework. Aber irgendwie kann ich mich im Moment damit nicht anfreunden. Außerdem bin ich UBUNTU Fan, habe einen Launchpad Account, bin Ubuntero und habe bereits Projekte in REVU gestellt. In LINUX wird eigentlich nur eine Programmiersprache richtig akzeptiert. Das ist C bzw. C++.
Deswegen habe ich mit jetzt für das QT Framework entschieden. Die ersten Versuch waren in der Windows Umgebung sehr vielversprechend. Es ist hier überraschend mit wie mit wenigen Zeilen bereits ein funktionierendes Mini-Programm zu erstellen ist.
Als erstes werde ich jetzt einmal das mitgelieferte Adressbuch-Beispiel eingeben und testen. Dann werde ich versuchen dieses Beispiel zu internationalisieren.
Mit diesem paar Dateien:

Lässt sich bereits das erzeugen:

Das ist zwar im Moment noch eher langweilig, aber wenn ich sehe wie wenig ich kodieren muss um dieses Ergebnis zu erreichen doch sehr beeindruckend.

Ich bin gespannt wie es weitergeht und werde hier berichten.