# Manuel de &ksplash;

&Teemu.Rytilahti; &Teemu.Rytilahti.mail;
&Brian.C.Ledbetter; &Brian.C.Ledbetter.mail;
&Ravikiran.Rajagopal; &Ravikiran.Rajagopal.mail;
&traducteurGerardDelafond;
2003 Teemu Rytilahti
2003-04 Ravikiran Rajagopal
&FDLNotice;
2003-01-10
1.01.00

&ksplash; est un joli écran de démarrage qui montre la progression d'une application en chargement.

KDE kdebase ksplash ksplashml splashscreen agrément visuel

## Introduction

&ksplash; est un joli écran de démarrage qui montre la progression d'une application en chargement. Veuillez rapporter tout problème ou demande de fonctionnalité aux listes de diffusion de &kde;. Les principales fonctions de &ksplash; :

- Thémable
- Utilise des greffons pour une personnalisation complète
- Peut être utilisé par n'importe quelle application qui utilise DCOP

Ce manuel vous montrera comment créer des thèmes pour une utilisation avec les modules externes déjà disponibles. Si aucun des modules externes disponibles vous plaît, vous pouvez apprendre comment personnaliser l'apparence de &ksplash; en écrivant entièrement un module externe en C++.

## Utilisation de thèmes

Pour utiliser des thèmes de KDE-Look, extrayez-les dans `~/.kde/share/apps/ksplash/Themes/` pour un utilisateur ordinaire ou dans `$`KDEDIR`/share/apps/ksplash/Themes/` pour les rendre disponibles pour tous les utilisateurs de votre système.

Vous pouvez aussi utiliser le module Écran de démarrage sous Apparence et thèmes dans le Centre de configuration de &kde; pour faire cela automatiquement.

### Utilisation du module du ¢reConfiguration;

Ce module vous permet d'installer, tester et supprimer des thèmes &ksplash;.

Sur le côté du module se trouve une liste des thèmes &ksplash; actuellement disponibles. Lorsque vous en sélectionnez-un, un aperçu est affiché dans la partie principale de la fenêtre. Pour en utiliser un, appuyez sur OK ou Appliquer. Appuyez sur Annuler pour sortir du module sans faire de changements, et Par défaut pour retrouver l'écran de démarrage par défaut du système.

Pour installer un nouveau module, appuyez sur Ajouter..., et allez chercher le thème sur votre ordinateur. Vous n'avez pas besoin de décompacter les fichiers du thème, vous pouvez choisir le fichier compressé en toute tranquillité. Installer un thème ne fait pas de lui le thème utilisé. Pour cela, il faut le choisir dans la liste et appuyer sur OK ou Appliquer.

Bien que vous puissiez voir un aperçu de l'écran de démarrage, vous préférez sans doute voir à quoi il ressemble réellement, par exemple pour voir les animations. Vous pouvez tester le thème en le choisissant dans la liste puis en cliquant sur le bouton Tester.

Vous pouvez également supprimer un thème que vous ne souhaitez plus utiliser en le choisissant dans la liste et en actionnait le bouton Supprimer. Notez que votre compte utilisateur ne permet pas de supprimer les thèmes installés pour l'ensemble du système. Il est également recommandé de ne pas désinstaller l'écran de démarrage par défaut.

## Comment faire des thèmes pour &ksplash;

### Généralités

Faire votre propre thème pour &ksplash; est facile. Après que vous avez fini votre thème, vous pouvez le poster sur KDE-Look de telle manière que d'autres puissent l'utiliser.

#### Identification de votre thème

Créons un thème nommé `MonThemeSympa`. Pour que le thème soit reconnu par &ksplash;, il doit être stocké dans un dossier nommé `MonThemeSympa`, sous `~/.kde/apps/ksplash/Themes/`. Il doit avoir un fichier nommé `Theme.rc`, contenant les réglages pour le thème. Vous pouvez spécifier un grand nombre de choses spéciales pour le thème, changer le moteur de modules externes à utiliser, et ainsi de suite. Vous n'avez pas à utiliser tous les réglages disponibles ; habituellement, les réglages ont une valeur par défaut acceptable. La syntaxe de base pour les entrées dans le fichier `Theme.rc` est `[option] = [valeur]`. Vous pouvez trouver la définition des différentes options dans les sections suivantes.

Simple fichier `Theme.rc`

    [KSplash Theme: MonThemeSympa]
    Name = MonThemeSympa
    Description = A nice theme using XpLike engine
    Version = 1.0
    Author = Real Name <realmail@mail.com>
    ## Use the XpLike engine for this theme.
    Engine = XpLike
    Show Icon = false
    Welcome Text = Loading KDE

Après avoir spécifié le nom, la description et l'auteur du thème, vous devriez choisir un moteur de thème (aussi connu comme module externe). Puis, vous pouvez personnaliser différentes fonctionnalités du moteur de thème en assignant des paires de clé-valeur comme dans le fichier d'exemple ci-dessus.

Assurez-vous que le nom du dossier qui contient les fichiers du thème (`~/.kde/apps/ksplash/Themes/MyCoolTheme` dans notre cas) et l'identificateur (`[KSplash Theme: MyCoolTheme]` dans notre cas) du thème dans le fichier `Theme.rc` sont identiques. Dans le cas contraire, &ksplash; ne reconnaîtra pas le thème.

#### Fichiers d'arrière-plan

Quand &ksplash; démarre, il essaye de trouver une image de fond pour votre résolution d'écran courante, si le moteur de thèmes en utilise une. Le fichier d'image de fond doit être nommé dans le format suivant : `Background-LLLxHHH.png`.

Par exemple, vous devriez utiliser un fichier nommé `Background-1024x768`. Si l'image de fond pour votre résolution d'écran est introuvable, il essaye de redimensionner le `Background.png` ou le fichier spécifié dans `Theme.rc` pour s'adapter à la résolution actuelle. Le redimensionnement au vol prendra certainement du temps, ce qui fait que vous devriez fournir des images dans les tailles 1280x1024, 1024x768 et 800x600.

### Options pour les moteurs de thèmes

#### Thème par défaut

Options du thème par défaut

Nom | Argument | Explication
Toujours afficher la progression | [vrai/faux] | Indique si la progression du chargement doit être affichée. La valeur par défaut est True.
Avant-plan du label | [couleur] | Détermine la couleur à utiliser pour le texte de la barre d'état. La valeur par défaut est #FFFFFF (blanc).
Icônes clignotantes | [vrai/faux] | Indique si l'icône doit clignoter. La valeur par défaut est true.

#### Thème standard

Options de thème standard

Nom | Argument | Explication
Position de la barre d'état | [haut/bas] | Inverse la position de la barre d'état sur l'écran. La valeur par défaut est en bas.
Barre d'état visible | [vrai/faux] | Indique si la barre d'état doit être affichée. La valeur par défaut est True.
Progression visible | [vrai/faux] | Indique si la progression du chargement doit être affichée. La valeur par défaut est True.
Police de la barre d'état | [nom de la police] | La police utilisée dans la barre d'état. La valeur par défaut est Helvetica.
Taille de la police de la barre d'état | [taille] | La taille de la police pour la barre d'état. La valeur par défaut est 16.
Police de barre d'état en gras | [vrai/faux] | Indique si la police de la barre d'état doit être en gras. La valeur par défaut est True.
Police de barre d'état en italique | [vrai/faux] | Indique si la police de la barre d'état doit être en italique. La valeur par défaut est False.
Avant-plan de la barre d'état | [couleur] | La couleur d'avant-plan pour la barre d'état. La valeur par défaut est Blanc.
Arrière-plan de la barre d'état | [couleur] | La couleur d'arrière-plan pour la barre d'état. La valeur par défaut est Noir.
Icône de barre d'état | [vrai/faux] | Indique si la barre d'état doit avoir une icône.
Icônes visibles | [vrai/faux] | Indique si les icônes doivent être visibles. La valeur par défaut des True.
Icônes sautantes | [vrai/faux] | Indique si les icônes doivent sauter. La valeur par défaut est True.
Position des icônes | [0-3,10-13] | La position où les icônes sont affichées. La valeur par défaut est en bas à gauche.
Écran de démarrage | [nom] | Change l'image d'écran de démarrage qui est affichée.

#### Thème Redmond

Options du thème Redmond

Nom | Argument | Explication
Image de fond | [nom de fichier] | Image de fond à utiliser, définie par l'utilisateur.
Icône utilisateur | [nom d'icône] | Nom de l'icône standard à afficher pour l'utilisateur. La valeur par défaut est `go`.
Texte de bienvenue | [texte] | Le texte affiché dans l'écran de démarrage. La valeur par défaut est « Bienvenue ».
Texte de nom d'utilisateur | [texte] | Le texte affiché au lieu du vrai nom de l'utilisateur.
Position du texte de bienvenue | [x,y] | La position sur l'écran où le texte de bienvenue est affiché.
Position du texte de nom d'utilisateur | [x,y] | La position sur l'écran où le nom d'utilisateur est affiché.
Position du texte d'action | [x,y] | Position sur l'écran où l'action courante est affichée.
Position des icônes | [x,y] | La position sur l'écran où l'icône d'utilisateur est affichée.
Afficher le texte de bienvenue | [vrai/faux] | Inverse l'affichage du texte de bienvenue. La valeur par défaut est True.
Afficher l'ombre de bienvenue | [vrai/faux] | Inverse l'affichage de l'ombre du texte de bienvenue. La valeur par défaut est True.
Afficher le nom d'utilisateur | [vrai/faux] | Inverse l'affichage du nom d'utilisateur. La valeur par défaut est True.
Afficher l'action | [vrai/faux] | Inverse l'affichage de l'action actuellement en cours. La valeur par défaut est True.
Afficher l'icône | [vrai/faux] | Indique si l'icône doit être affichée. La valeur par défaut est True
Utiliser l'icône d'utilisateur de KDM | [vrai/faux] | Afficher l'icône de connexion de l'utilisateur. La valeur par défaut est True.

#### Thème MacX

Options du thème MacX

Nom | Argument | Explication
Taille d'icône minimale | [taille] | Assigner la taille minimale pour les icônes. La valeur par défaut est 16.
Taille d'icône maximale | [taille] | Assigner la taille maximale pour les icônes. La valeur par défaut est 64.
Rendu optimisé des icônes | [vrai/faux] | Optimise le rendu des icônes. La valeur par défaut est True.
Barre de progression visible | [vrai/faux] | La valeur par défaut est True.
Position de la barre de progression | [haut/bas] | Inverse la position de la barre d'état en haut ou en bas. La valeur par défaut est en bas.
Icônes sautantes | [vrai/faux] | Indique si les icônes doivent sauter. La valeur par défaut est False.

#### Thème MacClassic

Options du thème MacClassic

Nom | Argument | Explication
Position des icônes | [0-3,10-13] | La position des icônes sur l'écran. La valeur par défaut est en bas à gauche.
Icônes sautantes | [vrai/faux] | Indique si les icônes doivent sauter. La valeur par défaut est False.
Icônes visibles | [vrai/faux] | Indique si les icônes doivent être visibles. La valeur par défaut des True.
Écran de démarrage | [nom] | Change l'image d'écran de démarrage qui est affichée.

#### Thème 2k

Options du thème 2k

Nom | Argument | Explication
Couleur du titre du fond | [couleur] | La couleur du titre du fond. La valeur par défaut est bleu foncé.
Couleur de l'avant-plan du titre | [couleur] | La couleur d'avant-plan du titre. La valeur par défaut est blanc.
Couleur du texte d'état | [couleur] | La couleur pour le texte d'état. La valeur par défaut est la même que la couleur d'arrière plan du titre.
Couleur 1 du dégradé défilant | [couleur] | Définit la première couleur du dégradé défilant. La valeur par défaut est bleu foncé.
Couleur 2 du dégradé défilant | [couleur] | Définit la première couleur du dégradé défilant. La valeur par défaut est cyan.
Vitesse de défilement | [valeur] | Définit la vitesse du rotateur. La valeur par défaut est 30.
Titre de la fenêtre | [texte] | Spécifie le texte du titre de la fenêtre.
Fichier de logo | [nom de fichier] | Définit le logo utilisé.

## Utilisation de &ksplash; depuis votre propre application

Dans ce chapitre, nous décrivons une méthode simple pour utiliser &ksplash; comme écran de démarrage pour votre application &kde;. Si vous ne développez pas d'application pour &kde;, vous pouvez sauter ce chapitre.

### Nécessités de base

Votre application &kde; doit être prévue pour &DCOP;. &DCOP; est la technologie de &kde; utilisée pour communiquer entre applications. Si vous utilisez le cadre d'application standard de &kde;, ceci est pris en charge automatiquement. Pour des informations sur &DCOP; et les technologies &kde; en rapport, veuillez visiter le coin des développeurs de &kde;.

### Lancer &ksplash;

Avant que votre application en commence son travail de calcul intensif, ou avant qu'elle ne commence à charger des modules externes, &etc;, invoquez &ksplash; comme suit :

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

Nous supposons qu'il n'y a qu'une instance de &ksplash; en fonctionnement. Les autres cas sont un peu plus complexes. Veuillez voir la documentation de &DCOP; pour des détails plus approfondis.

### Afficher des messages

Avant que vous n'affichiez des messages, vous avez besoin de régler le nombre d'étapes que vous afficherez. Par exemple, la procédure de démarrage de &kde; utilise 7 étapes.

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

Si vous voulez afficher un message avec ou sans icône, utilisez

    arg << QString("iconName") << QString("programName") <<
    QString("Some description");
        if (!(c->send(KSplashName, "KSplashIface",
    "programStarted(QString,QString,QString)", data))
        {
          // Some error processing here.
        }

À chaque fois que vous appelez `programStarted`, les étapes terminées sont incrémentées. Quand votre programme a fini de démarrer, faites les choses suivantes pour éliminer l'écran de démarrage :

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

C'est tout ! Vous n'avez pas besoin d'autre chose pour prendre avantage de tout ce que &ksplash; vous offre.

## Écrire de nouveaux modules externes pour &ksplash;

Écrire un nouveau module externe pour &ksplash; n'est pas difficile. Dans ce chapitre, nous écrirons un simple module externe qui émulera l'écran de démarrage d'un système d'exploitation bien connu. Ce didacticiel suppose que vous connaissez les bases du C++, et un peu de programmation KDE/QT.

### Nécessités de base

Nous créerons un module externe nommé `2k`. Le nom du module externe est utilisé dans plusieurs endroits, et il est important que vous utilisiez d'une manière cohérente pour que l'additif soit reconnu par &ksplash;. Les modules externes de &ksplash; sont en fait des bibliothèques chargeables dynamiquement avec la convention de nommage suivante :

- La bibliothèque doit être nommée comme `ksplash+lowercasethemename`. Pour notre thème, ce sera `ksplash2k`.
- Il devrait y avoir un fichier desktop correspondant nommé `ksplash+lowercasethemename.desktop`. Pour notre thème, ce sera `ksplash2k.desktop`.
- Enfin, l'objet qui est retourné par la bibliothèque doit être une classe nommée `Theme+themename`. Pour notre exemple, ce sera `Theme2k`.

Ne vous inquiétez pas si vous ne comprenez pas tout ce qui précède. Nous considérerons chacun de ces points en détail plus tard. L'autre détail très important est que la classe de l'additif doit être dérivée de `ThemeEngine`.

### Construire le squelette du cadre

Nous utiliserons le cadre d'application de &kde; qui prendra soin de construire l'additif et nous fournira une indépendance de la plate-forme sans travail de notre part. Pour faire cela, assurez-vous d'avoir installé le paquet `kdesdk`. Lancez la commande `kapptemplate` pour produire une application nommée « 2k ». Il créera un dossier de plus haut niveau qui contient des fichiers génériques comme AUTHORS, &etc; Nous sommes surtout intéressés par le sous-dossier nommé `2k`. Allez dedans et supprimez tous les fichiers qui s'y trouvent. Maintenant, nous avons le squelette nécessaire.

L'étape suivante est de créer un fichier `.desktop`, qui, lorsqu'installé, dira à &ksplash; que notre additif est disponible. Comme dit dans les conventions de nommage expliquées dans la section précédente, créez un fichier nommé `ksplash2k.desktop` dans ce dossier. Il devrait contenir les lignes suivantes :

    [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

Les `Encoding`, `Type`, `Comment` et `ServiceTypes` sont les mêmes pour tous les modules externes. Le nom de l'additif et le nom de la bibliothèque suivent les conventions notées plus tôt. L'entrée `X-KSplash-Default` prend une valeur booléenne qui détermine si elle est affichée dans le module du centre de configuration par défaut. Sauf pour certains rares cas, ça devrait être `true`.

### Déclaration de la classe de l'additif

Maintenant que nous avons fait le travail préliminaire, entrons dans la partie vraiment amusante - la création d'une classe qui fournira le comportement que nous voulons. Bien que nous soyons libres de faire que cette classe fasse presque tout ce que nous voulons, il y a quelques restrictions.

1. Les classes de modules externes doivent hériter de la classe `ThemeEngine`.

2. Les classes de modules externes doivent être nommées en fonction de la règle : Theme+PluginName.

3. Les classes de modules externes devraient fournir une fonction `static` nommée `names`, qui retourne une liste de noms par lesquels elle peut être invoquée.

4. Si l'additif peut être configuré dans le module du centre de configuration, il devrait fournir une classe `ThemeEngineConfig` pour la configuration.

5. La classe de l'additif doit écraser au moins une des fonctions virtuelles`slotSetText`, `slotSetPixmap`, `slotUpdateProgress` et `slotUpdateSteps` pour la rendre utilisable.

6. Le constructeur doit prendre la forme `ThemeEngine( QWidget *parent, const char *name, const QStringList &args )` de telle manière qu'il peut être utilisé avec KGenericFactory.

La dernière chose nécessaire peut sembler compliquée, mais, comme nous le verrons plus tard, en ajoutant une simple ligne à vos fichiers source, vous pouvez habituellement ignorer cela.

### Code pour le fichier d'en-tête

Étant données les contraintes, nous verrons maintenant à quoi le fichier d'en-tête `theme2k.h` ressemble :

Listing pour `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

Analysons le listing ci-dessus. La classe Theme2k satisfait les conventions de nommage, et est héritée de ThemeEngine. Elle fournit un Theme2k::names(), et a un constructeur qui prend les paramètres requis : `Theme2k( QWidget *, const char *, const QStringList& );`, et fournit aussi une méthode Theme2k::slotSetText() simple. Pour le moment, ne vous inquiétez pas à propos de la classe RotWidget. C'est un petit widget qui fournit des choses agréables à l'œil pour l'utilisateur. Notre additif est très simple et n'affiche pas d'icône ou de barre de progression. Si vous voulez afficher des icônes, écrasez la fonction `slotSetPixmap`. Des fonctions similaires existent pour la plage de la barre de progression (`slotUpdateSteps`) et l'incrémentation (`slotUpdateProgress`) le pas courant.

### Implémentation de l'additif

Nous n'examinerons que les parties significatives de l'implémentation. Pour un listing de l'implémentation complète, veuillez voir l'appendice. La première chose que nous ferons est de ne plus avoir besoin des prérequis :

Bibliothèques nécessaires

    K_EXPORT_COMPONENT_FACTORY( ksplash2k, KGenericFactory<Theme2k> );

La macro `K_EXPORT_COMPONENT_FACTORY` est déclarée dans `kgenericfactory.h`. En avant vers le constructeur ! Comme c'est un additif très simple, le constructeur est minimaliste.

Constructeur d'additif

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

La méthode `readSettings()` illustre la bonne manière d'obtenir vos réglages de thème. (Vous voulez pas que les gens utilisent vos additifs dans leurs thèmes, n'est-ce pas ?)

Obtenir les réglages du thème

    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 );
    }

Comme nous aimons nos utilisateurs, nous fournissons des paramètres par défaut qui ne sont pas présents dans le fichier de thème. Notez que nous devrions toujours positionner notre groupe sur « KSplash Theme: themename » pour rester compatible avec les futures spécifications de thèmes. La méthode `initUI()` n'est pas très intéressante, car elle fabrique essentiellement les widgets. Veuillez voir l'appendice pour les détails.

### Compilation de l'additif

Comme nous avons décidé d'utiliser le cadre de &kde; pour compiler l'additif, nous devons créer un `Makefile.am`. Il devrait ressembler à ça :

Listing de `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

Pour plus d'informations sur l'écriture des fichiers `Makefile.am` pour &kde;, veuillez voir Le site web des développeurs de &kde;. La seule chose à noter est que nous fournissons un thème par défaut basé sur cet additif, et en fournissons une image d'aperçu. Par courtoisie pour vos utilisateurs, vous devriez fournir un fichier d'exemple de `Theme.rc`, illustrant l'utilisation des diverses options.

## Questions et réponses

&reporting.bugs; &updating.documentation;

Je ne peux pas trouver de thème qui fonctionne dans &ksplash;. Qu'est-ce ?

Vous n'avez probablement pas le bon additif pour le thème. Les modules externes sont dans le paquet `kde-artwork`. Téléchargez-le et installez-le, et réessayez.

Qu'est le fichier `Theme.rc` et comment en faire un ?

`Theme.rc` est le fichier où vous pouvez spécifier les réglages d'un thème. Pour plus d'informations, jetez un œil à Comment faire des thèmes pour &ksplash;.

## Remerciements et licence

&ksplash;

Program Copyright © 2003 &Ravikiran.Rajagopal; &Ravikiran.Rajagopal.mail;

Contributeurs

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

Documentation Copyright © 2003 &Teemu.Rytilahti; &Teemu.Rytilahti.mail;

&underFDL; &underGPL;

## Installation

### Prérequis

Dans le but d'utiliser avec succès &ksplash;, vous avez besoin de &kde; version 3.2 ou supérieur. Certains thèmes peuvent nécessiter des modules externes spécifiques. Si un thème ne fonctionne pas, veuillez contacter l'auteur du thème pour trouver où obtenir le bon additif.

### Compilation et installation

&install.compile.documentation;

## Code source

### Listing de `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 );
    }

### Listing de `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

### Listing de `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;