Development/Tutorials/KDE4 Porting Guide (de): Difference between revisions

    From KDE TechBase
    (Created Page)
     
    (First parts translated)
    Line 2: Line 2:


    ==Einführung==
    ==Einführung==
    A tutorial intended to help developers port their Qt3/KDE3 based applications to Qt4/KDE4. Porting a KDE3 based application needn't be a difficult process. Already, there are many scripts and sources of documentation which can help.
    Diese Anleitung richtet sich an Entwickler, die ihre Qt3/KDE3 basierten Applikationen nach Qt4/KDE4 portieren wollen. Das muß nämlich kein komplizierter Prozess sein. Es gibt bereits viele Skripte und Dokumentationen, die dabei helfen.


    ==Konverntionen==
    ==Konventionen==
    For the instructions in this tutorial we use the following shorthand:
    Für die Anweisungen dieser Anleitung gelten folgende Konventionen:
    * {{program|program}} refers to an executable program
    * {{program|program}} bezeichnet ein ausführbares Programm
    * {{path|path}} refers to a path
    * {{path|path}} bezeichnet einen Pfad
    * {{path|file}} refers to a file
    * {{path|file}} bezeichnet eine Datei
    * $SVN is the fullpath to the location of your KDE subversion checkout
    * $SVN ist der vollständige Pfad zu Ihrem KDE subversion depot.


    ==CMake==
    ==CMake==
    Unlike KDE3, KDE4 applications will be built with the help of [[Development/Tutorials/CMake | CMake]]. The easiest way to port your autotools system to CMake is with the help of the {{program|am2cmake}} script which can be found in the {{path|cmake/scripts}} directory of the [http://websvn.kde.org/trunk/KDE/kdesdk/ kdesdk] module. This will create a series of {{path|CMakeLists.txt}} files alongside your old buildsystem files.
    Anders als KDE4 werden KDE4 Applikationen mit der Hilfe von [[Development/Tutorials/CMake (de)| CMake]] erstellt. Der einfachste Weg die autotools Dateien nach CMake zu portieren ist, das Script {{program|am2cmake}} zu benutzen, welches im Verzeichnis {{path|cmake/scripts}} des [http://websvn.kde.org/trunk/KDE/kdesdk/ kdesdk] Modules zu finden ist. Das erzeugt eine Reihe von {{path|CMakeLists.txt}} Dateien neben den alten autotools Dateien.


    For example, if your source code is located in {{path|/path/to/src}} then:
    Ist Ihr Code zum Beispiel unter {{path|/path/to/src}} gespeichert, dann:
    <code bash>
    <code bash>
    % cd /path/to/src
    % cd /path/to/src
    % $SVN/trunk/KDE/kdesdk/cmake/scripts/am2cmake --kde4
    % $SVN/trunk/KDE/kdesdk/cmake/scripts/am2cmake --kde4
    </code>
    </code>
    Run <tt> am2cmake --help</tt> to check whether you need the <tt>--kde4</tt> flag.
    Führen Sie <tt>am2cmake --help</tt> aus, um zu prüfen, ob Sie das <tt>--kde4</tt> Flag benötigen.


    There is also a tool that looks in your resulting {{path|CMakeList.txt}} files for potential problems. This tool called {{program|cmakelint.pl}} is located in {{path|$SVN/trunk/kde/kdesdk/scripts}}.  Use it like so:
    Weiterhin gibt es ein Werkzeug, welches in den erzeugten {{path|CMakeList.txt}} Dateien nach möglichen Problemen sucht. Dieses Werkzeugt heißt {{program|cmakelint.pl}} und ist unter{{path|$SVN/trunk/kde/kdesdk/scripts}} gespeichertBenutzen Sie es folgendermaßen:
    <code bash>
    <code bash>
    % cd /path/to/src
    % cd /path/to/src
    % $SVN/trunk/KDE/kdesdk/scripts/cmakelint.pl CMakeLists.txt
    % $SVN/trunk/KDE/kdesdk/scripts/cmakelint.pl CMakeLists.txt
    </code>
    </code>
    Or, to run it over your entire source directory:
    Oder wenden Sie es auf das gesamte Quellcodevrzeichnis an:
    <code bash>
    <code bash>
    % cd /path/to/src
    % cd /path/to/src

    Revision as of 12:36, 27 November 2007


    Development/Tutorials/KDE4_Porting_Guide


    Einführung

    Diese Anleitung richtet sich an Entwickler, die ihre Qt3/KDE3 basierten Applikationen nach Qt4/KDE4 portieren wollen. Das muß nämlich kein komplizierter Prozess sein. Es gibt bereits viele Skripte und Dokumentationen, die dabei helfen.

    Konventionen

    Für die Anweisungen dieser Anleitung gelten folgende Konventionen:

    • program bezeichnet ein ausführbares Programm
    • path bezeichnet einen Pfad
    • file bezeichnet eine Datei
    • $SVN ist der vollständige Pfad zu Ihrem KDE subversion depot.

    CMake

    Anders als KDE4 werden KDE4 Applikationen mit der Hilfe von CMake erstellt. Der einfachste Weg die autotools Dateien nach CMake zu portieren ist, das Script am2cmake zu benutzen, welches im Verzeichnis cmake/scripts des kdesdk Modules zu finden ist. Das erzeugt eine Reihe von CMakeLists.txt Dateien neben den alten autotools Dateien.

    Ist Ihr Code zum Beispiel unter /path/to/src gespeichert, dann: % cd /path/to/src % $SVN/trunk/KDE/kdesdk/cmake/scripts/am2cmake --kde4 Führen Sie am2cmake --help aus, um zu prüfen, ob Sie das --kde4 Flag benötigen.

    Weiterhin gibt es ein Werkzeug, welches in den erzeugten CMakeList.txt Dateien nach möglichen Problemen sucht. Dieses Werkzeugt heißt cmakelint.pl und ist unter$SVN/trunk/kde/kdesdk/scripts gespeichert. Benutzen Sie es folgendermaßen: % cd /path/to/src % $SVN/trunk/KDE/kdesdk/scripts/cmakelint.pl CMakeLists.txt Oder wenden Sie es auf das gesamte Quellcodevrzeichnis an: % cd /path/to/src % find . -name CMakeLists.txt | \

     xargs $SVN/trunk/KDE/kdesdk/scripts/cmakelint.pl
    

    Qt4 API

    An overview of the Qt3 to Qt4 transition is provided in Trolltech's "Moving from Qt 3 to Qt 4" paper. This document provides an excellent overview into the major functionality changes with Qt4 and is highly recommended.

    The follow-on "Porting to Qt 4" page gives an amazingly detailed description of the porting process, along with a list of the changes in the classes and functions.

    These documents describe a tool provided by Trolltech called qt3to4 that can help port the Qt parts of your code from Qt3 to Qt4, using compatibility functions. Run qt3to4 as follows: % $SVN/trunk/qt-copy/bin/qt3to4 [options] <Infile>, [Infile], ... Infile can be a source file or a project file. If you specify a project file, ending with '.pro' or '.pri', qt3to4 will port all files specified in that project.

    For more information, run qt3to4 with the "--help" option or visit the "qt3to4-The Qt 3 to 4 Porting Tool" page.

    Additionally, there is a program called remove-qt3-support.pl in the kdesdk module that will search and replace lots of deprecated Qt3 stuff for you. Simply run this program without any options in the source directory. % $SVN/trunk/KDE/kdesdk/scripts/qt4/remove-qt3-support.pl

    KDE4 API

    Much of the porting effort consists of simply renaming class names and header files. Since it would be rather tedious to change all these by hand, there is a handy script in the scripts/qt4 directory of kdesdk called adapt-to-kde4-api.pl. This will scan all your files and create a diff output which can then be used to patch your code.

    Once that simple code substitution has been done, you will still have to go through your code to port to, for example, the new KAction API. Documentation about all API changes is kept in the KDE4PORTING.html file in the kdelibs module.

    Qt Designer UI Dateien

    Qt designer ".ui" files created using Qt3 must be converted to the new Qt4 format. This can be done using the uic3 program available from your Qt4 installation.

    % $SVN/trunk/qt-copy/bin/uic3 -convert file.ui > foo.ui % mv foo.ui file.ui

    Or, if you prefer a graphical tool, you can use Qt4's designer program

    % $SVN/trunk/qt-copy/bin/designer file.ui (you can save file.ui over top itself, or save to a new file)

    Warning
    Beware, the conversion process loses any custom slots, table columns, etc. So, you may need to put some stuff back by hand.

    You should also run the fixuifiles program from the kdesdk module, it performs cleanups and sanify checks: % $SVN/trunk/KDE/kdesdk/scripts/fixuifiles

    D-Bus

    Instead of DCOP in KDE3, KDE4 now uses D-Bus for its interprocess communication. Porting from DCOP to D-Bus is a large topic that is covered in great detail in the Porting to D-Bus tutorial.

    For more information, please see all our D-Bus tutorials.

    Icons

    KDE4 uses the freedesktop.org icon naming specification as the basis for icon names. This means that both the icons that ship with KDE4 (Oxygen) as well as components in kdelibs that use icons follow this specification.

    Porting your app from the icon names used in KDE3 to the ones used in KDE4 is as easy as running the adapt-to-icon-spec.py script from the root directory of your project and follow the instructions on screen.

    The script automatically converts confirmable positives (e.g. uses of KIcon or KIconLoader), skips confirmable negatives and prompts for what to do with possible positives. It shows the latter with additonal context if desired and makes it a simple matter of pressing 'y' or 'n' for the possible hits to complete the porting.

    Internationalization

    To create your ".pot" file, copy the commands from the 'messages' rule in your projects Makefile.am to a shell script called Messages.sh. You may assume the same variables ($PREPARETIPS, $XGETTEXT, $podir, etc.) still exist, but keep in mind the differences between Makefile and shell script syntax.

    Also be careful that if you use the -k parameter with $XGETTEXT, you will need to explicitely list all variants that you use.

    For example, the 'messages' creation rule: messages: rc.cpp

           rm -f tips.cpp
           $(PREPARETIPS) > tips.cpp
           $(XGETTEXT) -ktranslate *.cpp *.h -o $(podir)/kmail.pot
           rm -f tips.cpp
    

    becomes the following Messages.sh script:

    1. ! /usr/bin/env bash

    $PREPARETIPS > tips.cpp $XGETTEXT -ktranslate:1,1t -ktranslate:1c,2,2t *.cpp *.h -o $podir/kmail.pot rm -f tips.cpp

    Do's und Don'ts

    • Do NOT use the old-style socket classes.
    • Do NOT use QPtrList, and in general, setAutoDelete()
    • Do NOT make use of raster operations.
    • Do NOT do code painting on widgets outside paint events.
    • Try not to use QHBox, QVBox, QGrid. Prefer layouts instead.
    • Do NOT play with frames of groupboxes, labels, or lineedits to fake a different widget. Use the appropriate widget instead. e.g., instead of setting a label to have a sunken lineedit border, how about using a readonly KLineEdit instead? And instead of using a KLineEdit without a border for a copyable widget, use KActiveLabel.
    • Do NOT use a groupbox without border to group widgets! Just use a layout.

    Mehr Informationen

    Dokumentation

    Weitere Hilfe

    • #kde4-devel on irc.freenode.net