# Das Handbuch zu &ksplash;

&Teemu.Rytilahti; &Teemu.Rytilahti.mail;
&Brian.C.Ledbetter; &Brian.C.Ledbetter.mail;
&Ravikiran.Rajagopal; &Ravikiran.Rajagopal.mail;
Stephan Johach

    hunsum@gmx.de

Übersetzung
Thomas Reitelbach

    tr@erdfunkstelle.de

Übersetzung
2003 Teemu Rytilahti
2003-04 Ravikiran Rajagopal
&FDLNotice;
2003-01-10
1.01.00

&ksplash; ist ein Begrüßungsbildschirm, der den Fortschritt beim Start einer Anwendung anzeigt.

KDE kdebase ksplash ksplashml splashscreen eye candy

## Einleitung

&ksplash; ist ein netter Begrüßungsbildschirm, der während dem Startvorgang eines Programms angezeigt wird. Falls Sie Fehler finden oder neue Funktionen benötigen, melden Sie diese bitte an die &kde;-Mailinglisten. &ksplash; enthält die folgenden Funktionen:

- Verschiedene Designs
- Kann mittels Modulen erweitert und angepasst werden
- Kann von jedem DCOP-fähigen Programm genutzt werden

Dieses Handbuch zeigt Ihnen, wie Sie ein Design entwerfen können und es mit den derzeit verfügbaren Modulen verwenden. Falls keines der Module Ihren Ansprüchen genügt, können Sie auch lernen, wie &ksplash; angepasst wird. Dazu schreiben Sie ein kleines Programm in C++.

## Designs verwenden

Um fertige Designs von KDE-Look zu verwenden, entpacken Sie diese bitte nach `~/.kde/share/apps/ksplash/Themes/` oder für die systemweite Verwendung nach `$`KDEDIR`/share/apps/ksplash/Themes/`.

Diesen Schritt können Sie natürlich auch einfach über das Kontrollzentrum-Modul Startbildschirm unter Erscheindungsbild erledigen.

### Verwendung des &kcontrol;-Moduls

Mit dem &kcontrol;-Modul können Sie &ksplash;-Designs installieren, testen und auch wieder entfernen.

An der linken Seite des Moduls sehen Sie eine Liste der verfügbaren &ksplash;-Designs. Wenn Sie eines auswählen, wird auf der rechten Seite ein Vorschaubild angezeigt. Wenn Sie sich ein Design ausgesucht haben, das Sie gerne benutzen möchten, dann drücken Sie Ok oder Anwenden. Wenn Sie Abbrechen drücken, wird das Modul geschlossen ohne irgendwelche Änderungen vorzunehmen. Zuguterletzt bewirkt der Knopf Voreinstellungen, dass der voreingstellte Startbildschirm aktiviert wird.

Um ein neues Design zu installieren, drücken Sie bitte auf Hinzufügen ... und suchen Sie das heruntergeladene Design heraus. Sie müssen die Design-Datei nicht erst entpacken. Nur das reine Installieren eines Designs aktiviert es noch nicht. Wenn Sie das neu installierte Design auch benutzen möchten, dann wählen Sie es bitte in der linken Liste aus und drücken Ok oder Anwenden.

Zwar sehen Sie das Vorschaubild auf der rechten Seite, aber wahrscheinlich möchten Sie auch sehen, wie der Startbildschirm in Aktion aussieht. Sie können den Startbildschirm testen, indem Sie auf den Knopf Test drücken.

Natürlich können Sie nicht benutzte Designs auch wieder entfernen. Wählen Sie das entsprechende Design aus und drücken dann Entfernen. Unter Umständen hat allerdings Ihr Benutzerkonto keine ausreichenden Berechtigungen, um ein systemweites Design zu entfernen. Außerdem kann das Design "Standard" nicht entfernt werden.

## Wie man Designs für &ksplash; erstellt

### Allgemeines

Es ist nicht schwer, ein Design für &ksplash; zu erstellen. Wenn Sie ein Design fertiggestellt haben, können Sie es auf KDE-Look hochladen und somit anderen zur Verfügung stellen.

#### Einen Namen für das Design festlegen

Lassen Sie uns ein Design mit dem Namen `MeinDesign` erstellen. Damit &ksplash; Ihr Design finden kann, muss es in einem Ordner mit dem Namen `MeinDesign` unter `~/.kde/apps/ksplash/Themes/` gespeichert werden. Der Ordner muss die Datei `Theme.rc` enthalten; sie enthält die Einstellungen für Ihre Design. Sie können viele Einstellungen festlegen, &zb; welche Erweiterung Ihr Design verwenden soll. Sie müssen natürlich nicht alle Einstellungen selbst machen, die Voreinstellungen funktionieren meist recht gut. Die grundlegende Syntax für Ihre Einstellungen lautet `[option] = [wert]`. Die Definitionen für die möglichen Optionen finden Sie in den folgenden Abschnitten.

Eine einfache `Theme.rc`-Datei

    [KSplash Theme: MeinDesign]
    Name = MeinDesign
    Description = Ein Design, das die Erweiterung XpLike benutzt
    Version = 1.0
    Author = Mein Name <meinname@mail.com>
    ## Das Darstellungsmodul XpLike verwenden.
    Engine = XpLike
    Show Icon = false
    Welcome Text = KDE wird gestartet

Nachdem Sie den Namen, die Beschreibung und den Autor des Designs festgelegt haben, sollten Sie als nächstes ein Darstellungsmodul wählen. Dann können Sie die verschiedenen Einstellungen für das Modul einrichten.

Stellen Sie bitte sicher, dass der Ordnername für das Design (`~/.kde/apps/ksplash/Themes/MeinDesign`) und der Bezeichner des Designs (`[KSplash Theme: MyCoolTheme]`) in `Theme.rc` identisch sind. Ansonsten wird &ksplash; Ihr Design nicht anzeigen.

#### Hintergrundbilder

Beim Start versucht &ksplash;, ein Hintergrundbild für die aktuelle Bildschirmauflösung zu finden (wenn das Darstellungsmodul eines verwendet). Das Hintergrundbild muss mit diesem Namensschema gespeichert werden: `Background-BBBxHHH.png`.

Sie könnten &zb; eine Datei mit dem Namen `Background-1024x768.png` verwenden. Wenn kein Hintergrundbild für Ihre Auflösung auffindbar ist, dann wird das Originalbild `Background.png` bzw. die in `Theme.rc` angegebene Datei in der Größe angepasst. Das Anpassen der Dateigröße nimmt natürlich ein paar Sekunden Zeit in Anspruch, daher sollten Sie zumindest Hintergrundbilder in den Auflösungen 1280x1024, 1024x768 und 800x600 zur Verfügung stellen.

### Optionen für die Darstellungsmodule

#### Standard-Design

Optionen für das Standard-Design

Name | Argument | Erklärung
Always Show Progress | [true/false] | Legt fest, ob der Fortschritt des Startvorgangs angezeigt werden soll. Voreinstellung ist true.
Label Foreground | [farbe] | Legt fest, welche Farbe für den Text in der Statusleiste benutzt werden soll. Voreinstellung ist #FFFFFF (weiß).
Icons Flashing | [true/false] | Legt fest, ob Symbole blinken sollen oder nicht. Voreinstellung ist true.

#### Standard-Design

Optionen für das Standard-Design

Name | Argument | Erklärung
Statusbar Position | [top/bottom] | Legt die Position der Statusleiste fest. Voreinstellung ist bottom.
Statusbar Visible | [true/false] | Legt fest, ob eine Statusleiste angezeigt werden soll. Voreinstellung ist true.
Progress Visible | [true/false] | Legt fest, ob der Fortschritt des Startvorgangs angezeigt werden soll. Voreinstellung ist true.
Statusbar Font | [schriftname] | Die in der Statusleiste benutzte Schriftart. Voreinstellung ist Helvetica.
Statusbar Font Size | [größe] | Die Schriftgröße in der Statusleiste. Voreinstellung ist 16.
Statusbar Font Bold | [true/false] | Legt fest, ob die Schrift in der Statusleiste fett sein soll. Voreinstellung ist true.
Statusbar Font Italic | [true/false] | Legt fest, ob die Schrift in der Statusleiste kursiv sein soll. Voreinstellung ist false.
Statusbar Foreground | [farbe] | Die Vordergrundfarbe der Statusleiste. Voreinstellung ist weiß.
Statusbar Background | [farbe] | Die Hintergrundfarbe der Statusleiste. Voreinstellung ist schwarz.
Statusbar Icon | [true/false] | Legt fest, ob die Statusleiste ein Symbol anzeigen soll.
Icons Visible | [true/false] | Legt fest, ob Symbole angezeigt werden sollen. Voreinstellung ist true.
Icons Jumping | [true/false] | Legt fest, ob die Symbole hüpfen sollen. Voreinstellung ist true.
Icon Position | [0-3,10-13] | Die Position, an der die Symbole angezeigt werden. Voreinstellung ist unten-links.
Splash Screen | [name] | Legt das angezeigte Startbild fest.

#### Redmond-Design

Optionen für das Redmond-Design

Name | Argument | Erklärung
Background Image | [dateiname] | Legt das zu verwendende benutzerdefiniertes Hintergrundbild fest.
User Icon | [symbolname] | Legt den Namen des Standard-Symbols für Benutzer fest. Voreinstellung ist `go`.
Welcome Text | [text] | Der im Startbildschirm angezeigte Willkommenstext. Voreinstellung ist "Willkommen".
Username Text | [text] | Dieser Text wird anstelle des Benutzernamens angezeigt.
Welcome Text Position | [x,y] | Die Bildschirmposition, an der der Willkommenstext angezeigt wird.
Username Text Position | [x,y] | Die Bildschirmposition, an der der Benutzername angezeigt wird.
Action Text Position | [x,y] | Die Bildschirmposition des Textes, der die derzeit laufende Aktivität anzeigt.
Icon Position | [x,y] | Die Bildschirmposition, an der das Benutzersymbol angezeigt wird.
Show Welcome Text | [true/false] | Legt fest, ob der Willkommenstext angezeigt wird oder nicht. Voreinstellung ist true.
Show Welcome Shadow | [true/false] | Legt fest, ob der Willkommenstext einen Schatten werfen soll. Voreinstellung ist true.
Show Username | [true/false] | Legt fest, ob der Benutzername angezeigt werden soll. Voreinstellung ist true.
Show Action | [true/false] | Legt fest, ob die derzeit laufende Aktivität angezeigt werden soll. Voreinstellung ist true.
Show Icon | [true/false] | Legt fest, ob das Symbol angezeigt werden soll. Voreinstellung ist true.
Use KDM User Icon | [true/false] | Legt fest, ob das Anmeldebild von KDM benutzt werden soll. Voreinstellung ist true.

#### MacX-Design

Optionen für das MacX-Design

Name | Argument | Erklärung
Icon Size Minimum | [größe] | Legt die Minimalgröße für Symbole fest. Voreinstellung ist 16 Pixel.
Icon Size Maximum | [größe] | Legt die Maximalgröße für Symbole fest. Voreinstellung ist 64 Pixel.
Optimized Icon Rendering | [true/false] | Legt fest, ob die Darstellung von Symbolen optimiert werden soll. Voreinstellung ist true.
Progress Bar Visible | [true/false] | Voreinstellung ist true.
Progress Bar Position | [top/bottom] | Legt fest, ob die Fortschrittsanzeige oben oder unten angezeigt werden soll. Voreinstellung ist unten.
Icons Jumping | [true/false] | Legt fest, ob die Symbole hüpfen sollen. Voreinstellung ist nein.

#### MacClassic-Design

Optionen für das MacClassic-Design

Name | Argument | Erklärung
Icon Position | [0-3,10-13] | Die Bildschirmposition der Symbole. Voreinstellung ist links-unten.
Icons Jumping | [true/false] | Legt fest, ob die Symbole hüpfen sollen. Voreinstellung ist nein.
Icons Visible | [true/false] | Legt fest, ob Symbole angezeigt werden sollen. Voreinstellung ist true.
Splash Screen | [name] | Legt das angezeigte Startbild fest.

#### 2k-Design

Optionen für das 2k-Design

Name | Argument | Erklärung
Title Background Color | [farbe] | Die Hintergrundfarbe für den Titel. Voreinstellung ist dunkelblau.
Title Foreground Color | [farbe] | Die Vordergrundfarbe für den Titel. Voreinstellung ist weiß.
Status Text Color | [farbe] | Die Farbe des Status-Textes. Die Voreinstellung ist dasselbe wie die Titel-Hintergrundfarbe.
Rotator Color 1 | [farbe] | Legt die Farbe für Rotator 1 fest. Voreinstellung ist dunkelblau.
Rotator Color 2 | [farbe] | Legt die Farbe für Rotator 2 fest. Voreinstellung ist cyan.
Rotator Speed | [wert] | Legt die Geschwindigkeit des Rotators fest. Voreinstellung ist 30.
Window Title | [text] | Legt den Text des Fenstertitels fest.
Logo File | [dateiname] | Legt das benutzte Logo fest.

## &ksplash; in eigenen Programmen

In diesem Kapitel wird beschrieben, wie Sie &ksplash; als Startbild für Ihr &kde;-Programm benutzen können. Wenn Sie keine Programme für &kde; entwickeln, können Sie diesen Abschnitt überspringen.

### Grundvoraussetzungen

Ihr Programm muss mit &DCOP; umgehen können. &DCOP; ist die &kde;-Technologie, die Programme zur Kommunikation untereinander verwenden. Wenn Sie das übliche &kde; Entwickler-Grundgerüst verwenden, brauchen Sie sich darum nicht weiter kümmern. Informationen über &DCOP; und verwandte &kde;-Technologien finden Sie in der &kde; Entwicklerecke.

### Der Aufruf von &ksplash;

Bevor Ihr Programm seine eigentliche Arbeit beginnt oder bevor &zb; Module und Erweiterungen geladen werden, starten Sie &ksplash;:

    DCOPClient *c = kapp->dcopClient();
    QString error;
    QCString KSplashName;
    int pid = 0;
    QStringList args;
    args << "--theme=MeinDesign" << "--managed";
    if (kapp->startServiceByDesktopName("ksplash", args, &error,
    &KSplashName, &pid))
    {
      KMessageBox::sorry(0, error, "Unable to invoke KSplash");
      // Some error processing here.
    }

Wir gehen in diesem Fall davon aus, dass nur eine Instanz von &ksplash; gleichzeitig läuft. Andere Fälle sind etwas komplizierter. Lesen Sie dazu bitte die &DCOP;-Dokumentation.

### Anzeigen von Meldungen

Bevor Sie irgendwelche Meldungen anzeigen können, müssen Sie die Anzahl der anzuzeigenden Schritte festlegen. Der &kde;-Start &zb; benutzt sieben Schritte.

    QByteArray data;
        QDataStream arg(data,IO_WriteOnly);
        arg << eineZahl;
        if (!(c->send(KSplashName, "KSplashIface", "setStartupItemCount(int)",
    data))
          // Some error processing here.

Immer wenn Sie eine Meldung mit oder ohne Symbol anzeigen möchten, verwenden Sie

    arg << QString("symbolName") << QString("programmName") <<
    QString("Eine Beschreibung");
        if (!(c->send(KSplashName, "KSplashIface",
    "programStarted(QString,QString,QString)", data))
        {
          // Some error processing here.
        }

Jedesmal wenn Sie `programStarted` aufrufen, wird ein Schritt als abgeschlossen markiert und inkrementiert. Wenn Ihr Programm mit dem Start fertig ist, können Sie den Startbildschirm auf diese Weise wieder ausblenden:

    if (!(c->send(KSplashName, "KSplashIface", "startupComplete()", data))
        {
          // Some error processing here.
        }

Das ist alles! Mehr ist nicht nötig, um von &ksplash;s Möglichkeiten zu profitieren :)

## Erstellen eines Moduls für &ksplash;

Es ist nicht schwer, ein Darstellungsmodul für &ksplash; zu schreiben. In diesem Abschnitt beschäftigen wir uns mit diesem Thema und schreiben ein Modul, das den Startbildschirm eines sehr bekannten Betriebssystems emuliert. In diesem Abschnitt wird vorausgesetzt, dass Sie mit den Grundlagen von C++ sowie KDE/Qt-Programmierung vertraut sind.

### Grundvoraussetzungen

Wir erzeugen ein Darstellungsmodul mit dem Namen `2k`. Der Modulname wird an vielen Stellen verwendet und es ist wichtig, dass Sie den Namen durchgängig korrekt verwenden, damit &ksplash; Ihr Modul finden und benutzen kann. &ksplash;s Darstellungsmodule sind dynamisch ladbare Bibliotheken und folgen dieser Namenskonvention:

- Die Bibliothek sollte den Namen `ksplash+designname` tragen. Verwenden Sie keine Großbuchstaben! In unserem Beispiel lautet der Name `ksplash2k`.
- Außerdem benötigt Ihr Modul eine Desktop-Datei mit dem Namen `ksplash+designname.desktop`. Hier dürfen ebenfalls keine Großbuchstaben verwendet werden. In unserem Beispiel heißt die Datei `ksplash2k.desktop`.
- Schlussendlich muss das von der Bibliothek zurückgegebene Objekt eine Klasse mit dem Namen `Theme+designname` sein. In unserem Beispiel als `Theme2k`.

Ein weiterer wichtiger Punkt ist, dass Ihre Modulklasse von `ThemeEngine` abgeleitet sein muss. Falls Ihnen von den obigen Dingen noch etwas unklar sein sollte, brauchen Sie sich erstmal keine Gedanken zu machen. Wir werden später noch auf jeden Punkt im einzelnen eingehen.

### Erstellen des Grundgerüstes

Wir benutzen das &kde; application framework, welches sich um den Bau des Moduls und um Plattformunabhängigkeit kümmert, ohne das wir selber etwas dazu tun müssen. Dafür müssen Sie das Paket `kdesdk` installiert haben. Führen Sie den Befehl `kapptemplate` aus und erzeugen Sie ein Programm mit dem Namen "2k". Für Sie wird ein Basisordner erzeugt, der allgemeine Dateien wie &zb; AUTHORS etc. enthält. Unser Interesse gilt nun aber erstmal nur dem Unterordner `2k`. Wechseln Sie in diesen Ordner und löschen Sie dort alle Dateien. Nun haben wir das benötigte Grundgerüst.

Als nächsten Schritt erzeugen wir eine `.desktop`-Datei. Wenn diese installiert wird, weiß &ksplash;, dass Ihr Darstellungsmodul verfügbar ist. Nach den beschriebenen Namenskonventionen aus dem vorigen Kapitel erzeugen Sie nun eine Datei mit dem Namen `ksplash2k.desktop`. Sie sollte folgenden Inhalt haben:

    [Desktop Entry]
    Encoding=UTF-8
    Type=Service
    Comment=KSplash Plugin
    Name=KSplash2k
    ServiceTypes=KSplash/Plugin
    X-KDE-Library=ksplash2k
    X-KSplash-Default=true
    X-KSplash-PluginName=2k
    X-KSplash-ObjectName=Theme2k

Die Einträge `Encoding`, `Type`, `Comment` und `ServiceTypes` sind für alle Darstellungsmodule gleich. Der Modul- und Bibliotheksname folgen den vorher genannten Namenskonventionen. Der Eintrag `X-KSplash-Default` kann einen Wahrheitswert enthalten und legt fest, ob das Modul im Kontrollzentrum angezeigt wird. Normalerweise ist der Wert hier `true`; es gibt nur ganz wenige Ausnahmen.

### Deklaration der Modul-Klasse

Nun haben wir die Vorbereitungen abgeschlossen und können mit dem schönen Teil beginnen - dem Erzeugen einer Klasse die das gewünschte Verhalten festlegt. Die Klasse kann im Grunde alles tun, was wir möchten, mit ein paar wenigen Einschränkungen:

1. Modul-Klassen müssen von der Klasse `ThemeEngine` abgeleitet sein.

2. Modul-Klassen müssen die Namenskonvention Theme+DesignName einhalten. (Das "+" muss ausgelassen werden.)

3. Modul-Klassen müssen eine `static`-Funktion namens `names` enthalten, die eine Liste der Namen zurückgibt, mit denen sie aufgerufen werden kann.

4. Falls das Modul im Kontrollzentrum eingerichtet werden kann, muss es eine von `ThemeEngineConfig` abgeleitete Klasse zur Einrichtung enthalten.

5. Modul-Klassen müssen mindestens eine der virtuellen Funktionen `slotSetText`, `slotSetPixmap`, `slotUpdateProgress` und `slotUpdatSteps` überschreiben.

6. Der Konstruktor sollte die Form `ThemeEngine( QWidget *parent, const char *name, const QStringList &args)` haben, damit es mit KGenericFactory genutzt werden kann.

Die letzte Anforderung scheint kompliziert zu sein, aber Sie werden später feststellen, dass dies durch nur eine einzige Zeile im Quelltext erledigt werden kann.

### Der Quelltext der Headerdatei

Nachdem wir nun diese Bedingungen kennen, lassen Sie uns schauen, wie die Headerdatei `theme2k.h` aussieht:

Quelltext für `theme2k.h`

    #ifndef __THEME2K_H__
    #define __THEME2K_H__

    #include <qlabel.h>
    #include <qwidget.h>

    #include <kdialogbase.h>
    #include <kpixmap.h>
    #include <ksplash/themeengine.h>

    class RotWidget;

    class Cfg2k: public ThemeEngineConfig
    {
      Q_OBJECT
    public:
      Cfg2k( KConfig * );
    };

    class ObjKsTheme;
    class Theme2k: public ThemeEngine
    {
      Q_OBJECT
    public:
      Theme2k( QWidget *, const char *, const QStringList& );

      inline const QString name()
      {
        return( QString("KSplash2k") );
      }
      inline const KDialogBase *config( KConfig *kc )
      {
        return new Cfg2k( kc );
      }
      static QStringList names()
      {
        QStringList Names;
        Names << "KSplash2k";
        Names << "ks2k";
        Names << "2k";
        Names << "2000";
        return( Names );
      };

    public slots:
      inline void slotSetText( const QString& s )
      {
        if( mText && mText->text() != s ) mText->setText( s );
      };

    private:
      void initUi();
      void readSettings();

      QLabel *mText;
      RotWidget *mRotator;
      QColor mTBgColor, mTFgColor, mRotColor1, mRotColor2, mStatusColor;
      int mRotSpeed;
      QString mWndTitle, mLogoFile;
    };

    #endif

Nun gut, gehen wir die obige Auflistung durch: Die Klasse Theme2k ist von ThemeEngine abgeleitet und erfüllt die Namenskonvention. Sie enthält die Funktion Theme2k::names() und hat einen Konstruktor mit den benötigten Parametern: `Theme2k( QWidget *, const char *, const QStringList& );` und enthält eine einfache Methode Theme2k::slotSetText(). Kümmern Sie sich erstmal nicht um die Klasse RotWidget; sie erzeugt nur ein hübsches Bildschirmelement. Unser Modul ist sehr einfach gehalten und zeigt keine Symbole oder eine Fortschrittsanzeige an. Wenn Sie das möchten, überschreiben Sie die Funktion `slotSetPixmap`. Ähnliche Funktionen gibt es auch für die Schritte der Fortschrittsanzeige (`slotUpdateSteps`) und zum Inkrementieren (`slotUpdateProgress`) des aktuellen Schrittes.

### Die Implementierung des Moduls

Wir schauen uns nun die wichtigsten Teile der Implementation an. Eine Auflistung des gesamten Codes finden Sie im Anhang. Als erstes schauen wir uns die Voraussetzungen für die Bibliothek an:

Voraussetzung für die Bibliothek

    K_EXPORT_COMPONENT_FACTORY( ksplash2k, KGenericFactory<Theme2k> );

Das Makro `K_EXPORT_COMPONENT_FACTORY` ist in `kgenericfactory.h` deklariert. Gut, nun weiter zum Konstruktor! Weil es sich hier um ein sehr einfaches Modul handelt, ist der Konstruktor ebenso einfach.

Der Konstruktor des Moduls

    Theme2k::Theme2k( QWidget *parent, const char *name, const QStringList &args
     )
        :ThemeEngine( parent, name, args )
    {
      readSettings();
      initUi();
    }

Die Methode `readSettings()` zeigt, wie Sie die Design-Einstellungen einlesen. (Sie wollen ja schließlich, dass Ihr Modul auch von Designs verwendet wird, richtig?)

Das Einlesen der Design-Einstellungen

    void Theme2k::readSettings()
    {
      if( !mTheme )
        return;

      KConfig *cfg = mTheme->themeConfig();
      if( !cfg )
        return;

      cfg->setGroup( QString("KSplash Theme: %1").arg(mTheme->theme()) );

      QColor DefaultTBgColor( Qt::darkBlue );
      QColor DefaultTFgColor( Qt::white );

      mTBgColor = cfg->readColorEntry( "Title Background Color",
    &DefaultTBgColor );
      mTFgColor = cfg->readColorEntry( "Title Foreground Color",
    &DefaultTFgColor );
      mStatusColor = cfg->readColorEntry("Status Text Color", &mTBgColor );

      QColor DefaultRot1( Qt::darkBlue );
      QColor DefaultRot2( Qt::cyan );
      mRotColor1 = cfg->readColorEntry( "Rotator Color 1", &DefaultRot1 );
      mRotColor2 = cfg->readColorEntry( "Rotator Color 2", &DefaultRot2 );

      mRotSpeed = cfg->readNumEntry( "Rotator Speed", 30 );
      mWndTitle = cfg->readEntry( "Window Title", i18n("Please wait...") );
      mLogoFile = cfg->readEntry( "Logo File", QString::null );
    }

Weil wir unseren Benutzern wohlgesonnen sind, legen wir sinnvolle Voreinstellungen fest. Wir stellen unsere Gruppe immer auf "KSplash Theme: designname" ein, um mit zukünftigen Design-Spezifikationen kompatibel zu sein. Die Methode `initUI()` ist nicht sonderlich interessant, denn Sie erzeugt nur die Bildschirmelemente. Details finden Sie im Anhang.

### Das Kompilieren des Moduls

Weil wir uns für das &kde; application framework entschieden haben, müssen wir die Datei `Makefile.am` erstellen. Sie sollte so aussehen:

Quelltext von `Makefile.am`

    INCLUDES = $(all_includes)

    kde_module_LTLIBRARIES = ksplash2k.la

    ksplash2k_la_SOURCES = theme2k.cpp rotwidget.cpp
    ksplash2k_la_LDFLAGS = $(all_libraries) $(KDE_RPATH)
    ksplash2k_la_LIBADD = $(LIB_KDEUI) -lksplashthemes

    METASOURCES = AUTO

    noinst_HEADERS        = theme2k.h rotwidget.h

    servicesdir = $(kde_servicesdir)
    services_DATA = ksplash2k.desktop

    themedir = $(kde_datadir)/ksplash/Themes/2k
    theme_DATA = Theme.rc Preview.png

Informationen, wie man `Makefile.am`-Dateien für &kde; schreibt, finden Sie auf der &kde; Webseite. Das einzig zu beachtende hier ist, dass wir ein Standard-Design bereitstellen, das unser Modul benutzt, sowie ein Vorschaubild dafür. Um den Benutzern einen Gefallen zu tun, sollten Sie eine Beispieldatei `Theme.rc` bereitstellen, die die verschiedenen Optionen aufzeigt.

## Fragen und Antworten

&reporting.bugs; &updating.documentation;

Ich kann keine Designs finden, die mit &ksplash; funktionieren. Warum?

Wahrscheinlich haben Sie nicht die korrekten Darstellungsmodule installiert. Die Module befinden sich im Paket `kdeartwork`. Laden Sie es herunter und installieren Sie es. Danach versuchen Sie es erneut.

Was ist die Datei `Theme.rc` und wie kann ich eine erstellen?

`Theme.rc` ist die Datei, in der Sie die Einstellungen eines Designs festlegen. Weitere Informationen finden Sie im Kapitel Erstellen von Designs für &ksplash;.

## Mitwirkende und Lizenz

&ksplash;

Copyright des Programms © 2003 &Ravikiran.Rajagopal; &Ravikiran.Rajagopal.mail;

Beiträge

- &Brian.C.Ledbetter; &Brian.C.Ledbetter.mail;

Copyright der Dokumentation © 2003 &Teemu.Rytilahti; &Teemu.Rytilahti.mail;

&underFDL; &underGPL;

## Installation

### Voraussetzungen

&ksplash; benötigt &kde; in der Version 3.2 oder höher. Einige Designs können spezielle Module benötigen. Funktioniert ein Design nicht, setzen Sie sich mit dem Autor des Designs in Verbindung, um herauszufinden wo Sie das benötigte Modul erhalten können.

### Kompilierung und Installation

&install.compile.documentation;

## Quelltext

### Quelltext von `theme2k.cpp`

    #include <qlabel.h>
    #include <qwidget.h>

    #include <kapplication.h>
    #include <kconfig.h>
    #include <kdebug.h>
    #include <kdialogbase.h>
    #include <kgenericfactory.h>
    #include <kglobalsettings.h>
    #include <klocale.h>
    #include <ksplash/objkstheme.h>
    #include <kstandarddirs.h>

    #include "rotwidget.h"
    #include "theme2k.h"
    #include "theme2k.moc"

    K_EXPORT_COMPONENT_FACTORY( ksplash2k, KGenericFactory<Theme2k> );

    Cfg2k::Cfg2k( KConfig * )
    {}

    Theme2k::Theme2k( QWidget *parent, const char *name, const QStringList &args
     )
        :ThemeEngine( parent, name, args )
    {
      readSettings();
      initUi();
    }

    void Theme2k::initUi()
    {
      QVBox *vbox = new QVBox( this );
      vbox->setFrameShape( QFrame::WinPanel );
      vbox->setFrameShadow( QFrame::Raised );

      QHBox *labelBox = new QHBox( vbox );
      labelBox->setPalette( mTBgColor );
      labelBox->setMargin( 1 );
      QLabel *lbl = new QLabel( mWndTitle, labelBox );
      lbl->setFont( QFont( "Arial", 12, QFont::Bold ) );
      lbl->setPaletteForegroundColor( mTFgColor );

      QLabel *logo = new QLabel( vbox );
      logo->setPalette( Qt::white );

      QString px( locate( "appdata", mTheme->themeDir() +
    (mLogoFile.isNull()?QString("/Logo.png"):mLogoFile) ) );
      if (px.isNull())
        px = locate("appdata","Themes/Default/splash_top.png");
      if( !px.isNull() )
      {
        QPixmap pix( px );
        logo->setPixmap( pix );
      }
      else
      {
        logo->setText( "<B>KDE</B>2000" );
        logo->setAlignment( AlignCenter|AlignVCenter );
      }

      mRotator = new RotWidget( vbox, mRotColor1, mRotColor2, mRotSpeed );

      QHBox *hbox = new QHBox( vbox );
      labelBox->setSpacing( 4 );
      labelBox->setMargin( 4 );

      mText = new QLabel( hbox );
      mText->setPaletteForegroundColor( mStatusColor );
      mText->setPaletteBackgroundColor( mTFgColor );
      mText->setText( mWndTitle );
      mText->setFixedHeight( 48 );

      setFixedSize( vbox->sizeHint() );
      QRect rect(KGlobalSettings::splashScreenDesktopGeometry());
      move( rect.x() + (rect.width() - size().width())/2,
            rect.y() + (rect.height() - size().height())/2 );
    }

    void Theme2k::readSettings()
    {
      if( !mTheme )
        return;

      KConfig *cfg = mTheme->themeConfig();
      if( !cfg )
        return;

      cfg->setGroup( QString("KSplash Theme: %1").arg(mTheme->theme()) );

      QColor DefaultTBgColor( Qt::darkBlue );
      QColor DefaultTFgColor( Qt::white );

      mTBgColor = cfg->readColorEntry( "Title Background Color",
    &DefaultTBgColor );
      mTFgColor = cfg->readColorEntry( "Title Foreground Color",
    &DefaultTFgColor );
      mStatusColor = cfg->readColorEntry("Status Text Color", &mTBgColor );

      QColor DefaultRot1( Qt::darkBlue );
      QColor DefaultRot2( Qt::cyan );
      mRotColor1 = cfg->readColorEntry( "Rotator Color 1", &DefaultRot1 );
      mRotColor2 = cfg->readColorEntry( "Rotator Color 2", &DefaultRot2 );

      mRotSpeed = cfg->readNumEntry( "Rotator Speed", 30 );
      mWndTitle = cfg->readEntry( "Window Title", i18n("Please wait...") );
      mLogoFile = cfg->readEntry( "Logo File", QString::null );
    }

### Quelltext von `rotwidget.h`

    #ifndef         __ROTWIDGET_H__
    #define         __ROTWIDGET_H__

    #include <qlabel.h>
    #include <qtimer.h>
    #include <qwidget.h>

    #include <kdialogbase.h>
    #include <kpixmap.h>

    /**
     * @short Display a rotating-gradient widget.
     */
    class         RotWidget: public QWidget
    {
      Q_OBJECT
    public:
      RotWidget( QWidget *, const QColor&, const QColor&, int );
      ~RotWidget();

    private slots:
      void stepEvent();

    protected:
      void        preparePixmap( int );
      void        paintEvent( QPaintEvent * );
      void        resizeEvent( QResizeEvent * );

      QColor m_color1, m_color2;
      int m_step, m_speed;
      QTimer *m_stepTimer;

      QList<KPixmap> m_stepPixmap;
    };

    #endif

### Quelltext von `rotwidget.cpp`

    #include <kdebug.h>
    #include <kdialogbase.h>
    #include <kpixmapeffect.h>

    #include <qlabel.h>
    #include <qpainter.h>
    #include <qwidget.h>

    #include "rotwidget.h"
    #include "rotwidget.moc"

    RotWidget::RotWidget( QWidget *parent, const QColor& c1, const QColor&
    c2, int sp )
        :QWidget(parent), m_color1(c1), m_color2(c2), m_step(0), m_speed(sp)
    {
      if( (m_speed <= 0) || (m_speed > 20) )
        m_speed = 1;
      setFixedHeight( 6 );

      for( int i = 0; i <= width(); i++ )
        preparePixmap( i );

      m_stepTimer = new QTimer( this );
      connect(m_stepTimer, SIGNAL(timeout()), this, SLOT(stepEvent()));
      m_stepTimer->start( 50 );
    }

    RotWidget::~RotWidget()
    {
    }

    void RotWidget::stepEvent()
    {
      // This is inefficient as we create too many pixmaps, optimize later.
      m_step += m_speed;
      if( m_step > width() )
        m_step = 0;
      repaint( true );
    }

    // Todo: Optimize drawing.
    void RotWidget::paintEvent( QPaintEvent *pe )
    {
      QPainter p;
      p.begin( this );

      QRect r = pe->rect();

      if( m_stepPixmap.at( m_step ) )
        bitBlt( this, r.x(), r.y(), m_stepPixmap.at( m_step ), r.x(), r.y(),
    r.width(), r.height() );
      else
        p.fillRect( rect(), Qt::black );
      p.end();
    }

    void RotWidget::resizeEvent( QResizeEvent *re )
    {
      m_stepPixmap.clear();
      for( int i = 0; i <= re->size().width(); i++ )
        preparePixmap( i );
    }

    void RotWidget::preparePixmap( int step )
    {
      if( step < 0 )
        return;

      // Explicitly draw our first pixmap. The rest we will bitBlt() from here.
      if( step == 0 )
      {
        KPixmap tmp; tmp.resize( size().width() / 2, size().height() );
        KPixmap tmp2(tmp);
        KPixmapEffect::gradient( tmp, m_color1, m_color2,
    KPixmapEffect::HorizontalGradient );
        KPixmapEffect::gradient( tmp2, m_color2, m_color1,
    KPixmapEffect::HorizontalGradient );
        KPixmap *px = new KPixmap( size() );
        QPainter p;
        p.begin( px );
        p.drawPixmap( 0, 0, tmp );
        p.drawPixmap( size().width()/2, 0, tmp2 );
        p.end();
        m_stepPixmap.append( px );
      }
      else if( m_stepPixmap.at( step-1 ) )
      {
        QPixmap *prev = m_stepPixmap.at( step-1 );
        QPixmap next; next.resize( size() );
        // convert
        // prev = "[------------]"
        // to
        // next = "------------]["
        bitBlt( &next, 0, 0, prev, 1, 0, prev->width()-1, prev->height()
    );
        bitBlt( &next, width()-1, 0, prev, 0, 0, 1, prev->height() );
        KPixmap *n = new KPixmap( next );
        m_stepPixmap.append( n );
      }
    }

&documentation.index;