# Het handboek van &ksplash;

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

&Rinse.Devries;

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

&ksplash; is een opstartscherm dat de voortgang toont van een programma dat aan het opstarten is.

KDE
kdebase
ksplash
ksplashml
opstartscherm
eye candy

## Inleiding

&ksplash; is een opstartscherm dat de voortgang toont van een programma dat aan het opstarten is. Meld elk probleem of functieverzoek aan de mailinglijsten van &kde;. De voornaamste functies van &ksplash; zijn:

- Met thema's aan te kleden
- Gebruikt plugins voor complete flexibiliteit
- Kan worden gebruikt door elk programma dat DCOP gebruikt

Dit handboek vertelt u hoe u thema's kunt aanmaken om te gebruiken met de plugins die al beschikbaar zijn. Als er geen plugins aanwezig zijn die aan uw wensen voldoen, dan kunt u leren hoe u het uiterlijk van &ksplash; compleet kunt veranderen door een plugin in C++ te schrijven.

## Thema's gebruiken

Om de thema's van KDE-Look te gebruiken pakt u ze uit naar uw persoonlijke map `~/.kde/share/apps/ksplash/Themes/`, of naar de globale &kde;-map `$`KDEDIR`share/apps/ksplash/Themes/`.

U kunt dit ook automatiseren door middel van de configuratiemodule Opstartscherm onder sectie Uiterlijk & gedrag in het Configuratiecentrum van &kde;.

### De configuratiemodule gebruiken

Met deze module kunt u &ksplash;-thema's installeren, testen en verwijderen.

Langs de linkerzijde van de module ziet u een lijst met de beschikbare &ksplash;-thema's. Als u er een selecteert zal in het middengedeelte een voorbeeld getoond worden. Selecteer het thema dat u wilt gebruiken en klik op OK of Toepassen. Klik op Annuleren of Herstellen om de module te verlaten zonder dat de wijzigingen worden toegepast. Klik op Standaard om het standaard opstartscherm terug te halen.

Om nieuwe modules te installeren, klik op Toevoegen... en zoek het thema op uw computer op. U hoeft het thema niet uit te pakken, selecteer gewoon het gecomprimeerde themabestand. De thema's die u installeert worden niet automatisch gebruikt. Selecteer ze na de installatie in de lijst en klik op de knop OK of Toepassen.

Alhoewel u een voorbeeld van het opstartscherm kunt zien krijgt u pas een goede indruk als u hem live in actie ziet. Zo kunt u ook de animatie van het thema beoordelen. U kunt de thema's daarom testen door ze te selecteren in de lijst en vervolgens op de knop Testen te klikken.

U kunt de thema's die u niet langer wilt gebruiken verwijderen. Selecteer de te verwijderen thema en klik op de knop Verwijderen. Opmerking: u kunt als gebruiker mogelijk geen systeemthema's verwijderen. Verder is het niet aan te raden dat u het Standaard opstartscherm verwijdert.

## Thema's voor &ksplash; maken

### Algemeen

Het maken van uw eigen thema's voor &ksplash; is eenvoudig. Nadat u klaar bent met uw thema's kunt u ze sturen naar KDE-Look, zodat anderen ze kunnen gebruiken.

#### Uw eigen thema identificeren

Laten we een thema maken met de naam `MyCoolTheme`. Om het thema te laten integreren in &ksplash; dient u het op te slaan in een submap genaamd `MyCoolTheme` in de map `kde/apps/ksplash/Themes/`. In deze submap dient het bestand `Theme.rc` aanwezig te zijn. Dit bestand bevat de instellingen van uw thema. U kunt een hele reeks instellingen van het thema opgeven, de pluginengine wijzigen, etc. U hoeft niet alle beschikbare instellingen te gebruiken. Normaliter hebben de instellingen een acceptabele standaardwaarde. De basissyntaxis voor ingaven in het bestand `Theme.rc` is `[optie] = [waarde]`. U kunt de definities van de verschillende opties vinden in de volgende secties.

##### Eenvoudig `Theme.rc`-bestand

    [KSplash Theme: MyCoolTheme]
    Name = MyCoolTheme
    Description = A nice theme using XpLike engine
    Version = 1.0
    Author = uw naam <naam@email.nl>
    ## Use the XpLike engine for this theme.
    Engine = XpLike
    Show Icon = false
    Welcome Text = Loading KDE

Nadat u de naam, beschrijving en auteur van het thema hebt opgegeven is de volgende stap het kiezen van een theme-engine (ook wel bekend als een plugin). Daarna kunt u de verschillende mogelijkheden van de thema-engine instellen door de sleutel-waarde paren toe te wijzen zoals in bovenstaand voorbeeldbestand.

Ensure that the name of the directory that contains the theme files (`~/.kde/apps/ksplash/Themes/MyCoolTheme` in this example) and the identifier (`[KSplash Theme: MyCoolTheme]` in this example) of the theme in the `Theme.rc` file are identical. Otherwise, &ksplash; will not recognize the theme.

#### Achtergrondbestanden

Als &ksplash; start, zoekt het als eerste naar de achtergrondafbeelding voor uw huidige schermresolutie, als de theme-engine er een gebruikt. De naam van de achtergrondafbeelding dient de volgende opmaak te hebben: `Background-BBBxHHHpng`.

Bijvoorbeeld, u kunt een bestand genaamd `Background-1024x768` gebruiken. Als de achtergrondafbeelding voor uw schermresolutie niet gevonden wordt, dan probeert de engine de grootte van het originele bestand `Background.png` of het bestand dat is opgegeven in `Theme.rc` aan te passen op de huidige resolutie. Het veranderen van de grootte zal enige tijd in beslag nemen. U kunt daarom het beste achtergrondafbeeldingen meeleveren voor tenminste de volgende resoluties: 1280x1024, 1024x768 en 800x600.

### Opties voor theme-engines

#### Default Theme

##### Default Theme Options

Naam | Argument | Uitleg
Always Show Progress | [true/false] | Of het laadproces zal worden getoond. Standaard is true.
Label Foreground | [kleur] | Determines what color to use for the statusbar text. Default is #FFFFFF (white).
Icons Flashing | [true/false] | Indicates whether icons should flash. Default is true.

#### Standaardthema

##### Opties voor het standaardthema

Naam | Argument | Uitleg
Statusbar Position | [top/bottom] | Bepaalt de positie van de statusbalk op het scherm. Standaard is bottom.
Statusbar Visible | [true/false] | Of de statusbalk getoond zal worden. Standaard is true.
Progress Visible | [true/false] | Of het laadproces zal worden getoond. Standaard is true.
Statusbar Font | [lettertype] | Het te gebruiken lettertype in de statusbalk. Standaard is Helvetica.
Statusbar Font Size | [grootte] | De tekengrootte voor de statusbalk. Standaard is 16.
Statusbar Font Bold | [true/false] | Of het lettertype voor de statusbalk vet dient te zijn. Standaard is true.
Statusbar Font Italic | [true/false] | Of het lettertype voor de statusbalk cursief dient te zijn. Standaard is false.
Statusbar Foreground | [kleur] | De voorgrondkleur van de statusbalk. Standaard is white.
Statusbar Background | [kleur] | De achtergrondkleur van de statusbalk. Standaard is black.
Statusbar Icon | [true/false] | Of de statusbalk een pictogram zal hebben.
Icons Visible | [true/false] | Of de pictogrammen zichtbaar zullen zijn. Standaard is true.
Icons Jumping | [true/false] | Of de pictogrammen zullen stuiteren. Standaard is true.
Icon Position | [0-3,10-13] | De positie van de pictogrammen. Standaard is bottom-left.
Splash Screen | [naam] | Verandert de naam van de opstartafbeelding die wordt getoond.

#### Redmond-thema

##### Opties voor het Redmond-thema

Naam | Argument | Uitleg
Background Image | [bestandsnaam] | Gebruikerdegefinieerde achtergrondafbeelding om te gebruiken.
User Icon | [pictogramnaam] | Naam van het standaardpictogram dat wordt getoond. Standaard is `go`.
Welcome Text | [tekst] | De tekst die in het opstartscherm wordt getoond. Standaard is "Welcome".
Username Text | [tekst] | De tekst die wordt getoond ipv de echte naam van de gebruiker.
Welcome Text Position | [x,y] | Positie op het scherm waar de welkomtekst zal worden getoond.
Username Text Position | [x,y] | Positie op het scherm waar de gebruikersnaam zal worden getoond.
Action Text Position | [x,y] | Positie op het scherm waar de huidige actie wordt getoond.
Icon Position | [x,y] | Positie op het scherm waar het pictogram van de gebruiker wordt getoond.
Show Welcome Text | [true/false] | Of de welkomtekst zal worden getoond. Standaard is true.
Show Welcome Shadow | [true/false] | Of de welkomtekst een schaduw heeft. Standaard is true.
Show Username | [true/false] | Of de gebruikersnaam zal worden getoond. Standaard is true.
Show Action | [true/false] | Of de actie die momenteel wordt uitgevoerd zal worden getoond. Standaard is true.
Show Icon | [true/false] | Of het pictogram zal worden getoond. Standaard is true
Use KDM User Icon | [true/false] | Of het aanmeldpictogram van de gebruiker zal worden getoond. Standaard is true.

#### MacX-thema

##### Opties voor het MacX-thema

Naam | Argument | Uitleg
Icon Size Minimum | [grootte] | Minimumgrootte voor pictogrammen. Standaard is 16.
Icon Size Maximum | [grootte] | Maximumgrootte voor pictogrammen. Standaard is 64.
Optimized Icon Rendering | [true/false] | Pictogramweergave optimaliseren. Standaard is true.
Progress Bar Visible | [true/false] | Voortgangsbalk zichtbaar. Standaard is true.
Progress Bar Position | [top/bottom] | Of de positie van de statusbalk bottom (onder) of top (boven) is. Standaard is bottom.
Icons Jumping | [true/false] | Of pictogrammen zullen stuiteren. Standaard is false.

#### MacClassic-thema

##### Opties voor het MacClassic-thema

Naam | Argument | Uitleg
Icon Position | [0-3,10-13] | Positie van de pictogrammen op het scherm. Standaard is bottom left.
Icons Jumping | [true/false] | Of pictogrammen zullen stuiteren. Standaard is false.
Icons Visible | [true/false] | Of de pictogrammen zichtbaar zullen zijn. Standaard is true.
Splash Screen | [naam] | Verandert de naam van de opstartafbeelding die wordt getoond.

#### 2k-thema

##### Opties voor het 2k-thema

Naam | Argument | Uitleg
Title Background Color | [kleur] | De achtergrondkleur voor de titel. Standaard is dark blue.
Title Foreground Color | [kleur] | De voorgrondkleur van de titel. Standaard is wit.
Status Text Color | [kleur] | De kleur van de statusteksten. Standaard is hetzelfde als de titelachtergrondkleur.
Rotator Color 1 | [kleur] | De kleur van rotator 1. Standaard is dark blue.
Rotator Color 2 | [kleur] | De kleur van rotator 2. Standaard is cyan.
Rotator Speed | [waarde] | De snelheid van de rotator. Standaard is 30.
Window Title | [tekst] | De titeltekst van het venster.
Logo File | [bestandsnaam] | Het te gebruiken logo.

## &ksplash; in uw eigen programma gebruiken

In dit hoofdstuk beschrijven we een eenvoudige methode waarop u &ksplash; kunt gebruiken als opstartscherm voor uw &kde;-programma. Als u geen programma's voor &kde; schrijft kunt u dit hoofdstuk overslaan.

### Basisvereisten

Uw &kde;-programma dient &DCOP;-aware te zijn. &DCOP; is de &kde;-technologie die wordt gebruikt om te communiceren tussen programma's. Als u het standaard &kde; application framework gebruikt, dan wordt dit automatisch voor u geregeld. Meer informatie over &DCOP; en gerelateerde &kde;-technologieën kunt u vinden in de &kde; developers' corner.

### &ksplash; starten

Voordat uw programma begint met het rekenintensieve werk, of voordat het begint met het laden van plugins, &etc;, roep &ksplash; als volgt aan:

    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.
    }

We gaan er vanuit dat er slechts een exemplaar van &ksplash; draait. In het geval er meer draaien wordt het iets complexer. Lees voor meer informatie de documentatie van &DCOP;.

### Berichten tonen

Voordat u berichten gaat tonen dient u te bepalen hoeveel stappen u wilt tonen. Bijvoorbeeld, de &kde;-opstartprocedure gebruikt 7 stappen.

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

Telkens als u een bericht met of zonder pictogram wilt tonen gebruikt u

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

Telkens als u `programStarted` aanroept zijn de voltooide stappen oplopend. Als uw programma klaar is met opstarten gebruikt u het volgende om het opstartscherm te laten verdwijnen:

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

Dat is alles!. U hebt verder niets nodig om gebruik te kunnen maken van alle mogelijkheden die &ksplash; u biedt.

## Nieuwe &ksplash;-plugins schrijven

Het schrijven van nieuwe &ksplash;-plugins is niet moeilijk. In dit hoofdstuk leert u hoe u een eenvoudige plugin kunt schrijven dat een opstartscherm van een welbekend besturingssysteem zal nabootsen. Deze uitleg gaat er vanuit dat u de basis kent van C++ en een beetje bekend bent met KDE/Qt-programmeren.

### Basisvereisten

We gaan een plugin genaamd `2k` maken. De pluginnaam zal op verschillende plekken worden gebruikt, en het is belangrijk dat u consequent dezelfde naam gebruikt. Anders zal &ksplash; de plugin niet herkennen. &ksplash;-plugins zijn in feite dynamisch laadbare bibliotheken met de volgende naamconventie:

- De bibliotheeknaam dient de opmaak `ksplash+themanaaminkleineletters` te hebben. Voor ons thema is dat dus `ksplash2k`.
- Vervolgens hebben we een overeenkomend desktop-bestand genaamd `ksplash+themanaaminkleineletters.desktop` nodig. Voor ons thema wordt dat dus `ksplash2k.desktop`.
- Tot slot dient het object dat door de bibltioheek wordt teruggegeven een klasse genaamd `Theme+themanaam` te zijn. In ons voorbeeld is dat `Theme2k`.

Mocht u bovenstaande niet helemaal begrijpen, geen nood, we komen hier nog uitgebreid op terug. Tot slot is het erg belangrijk dat de pluginklasse kan worden afgeleid van `ThemeEngine`.

### Het skelet-framework bouwen

We gaan gebruik maken van het &kde; application framework. Dit framework zal de plugin bouwen en zorgen voor platformonafhankelijkheid zonder dat wij er verder iets voor hoeven te doen. Om te kunnen werken met het application framework heeft u het pakket `kdesdk` nodig. Voer het commando `kapptemplate` uit om een programma genaamd "2k" aan te maken. Het commando maakt een hoofdmap aan met generieke bestanden zoals AUTHORS, &etc;. We zijn het meest geïntereseerd in de submap `2k`. Open deze submap en verwijder alle bestanden die er in staan. We hebben nu het skelet dat we nodig hebben.

De volgende stap is het aanmaken van een `.desktop`-bestand. Dit bestand, wanneer geïnstalelerd zal &ksplash; vertellen dat onze plugin beschikbaar is. Consistent met de naamconventies uit de voorgaande sectie maken we een bestand aan genaamd `ksplash2k.desktop` in die map. Het bestand dient de volgende regels te bevatten:

    [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

`Encoding`, `Type`, `Comment` en `Servicetypes` zijn hetzelfde bij alle plugins. De pluginnaam en bibliotheeknaam dient de eerdergenoemde naamconventies te volgen. De ingave `X-Splash-Default` heeft een boleaanse waarde waarmee bepaald wordt of de plugin standaard getoond zal worden in configuratiemodule of niet. Met uitzondering van enkele zeldzame gevallen dient de waarde `true` te zijn.

### Declaratie van pluginklasse

Nu we het voorbereidende werk gedaan hebben, laten we beginnen met het leuke gedeelte - het aanmaken van een klasse die het gewenste gedrag aanlevert. Terwijl we vrij zijn om deze klasse bijna alles te laten doen wat we willen zijn er enkele restricties.

1. De plugin moet de klasse `ThemeEngine` overerven.

2. Pluginklassen dienen te worden genoemd volgens de regel: `theme+pluginnaam`.

3. Pluginklassen dienen een `statische` functie genaamd `names` aan te leveren, welke een lijst met namen teruggeeft die de plugin kunnen aanroepen.

4. Als de plugin kan worden ingesteld in de configuratiemodule, dan dient het een op `ThemeEngineConfig`-gebaseerde klasse aan te leveren voor de configuratie.

5. Pluginklassen dienen tenminste een van de virtuele functies `slotSetText`, `slotSetPixmap`, `slotUpdateProgress` en `slotUpdateSteps` te onderdrukken (override) om het bruikbaar te maken.

6. De constructor dient de form `ThemeEngine( QWidget *parent, const char *name, const QStringList &args )` aan te nemen, zodat het kan worden gebruikt met `KGenericFactory`.

De laatste vereiste lijkt moeilijk, maar, zoals we later zullen zien, door één regel tekst toe te voegen aan uw broncoderegels kunt u het meestal negeren.

### Code voor het header-bestand

Aan de hand van voorgaande informatie ziet het header-bestand `theme2k.h` er als volgt uit:

#### Inhoud van `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

Laten we de bovenstaande inhoud analyseren. De klasse `Theme2k` voldoet aan de naamconventies en is overgeërfd van `ThemeEngine`. De klasse levert een `Theme2k::names()`, en heeft een constructor die de vereiste paramaters pakt: `Theme2k( QWidget *, const char *, const QStringList& );` en ook een eenvoudige methode `Theme2k::slotSetText()`levert. Maak u op dit moment niet druk over de klasse `RotWidget`. Het is een kleine widget die wat eye candy voor de gebruiker aanlevert. Onze plugin is erg eenvoudig en toont geen pictogrammen of voortgangsbalk. Als u pictogrammen wilt gebruiken, onderdruk (override) dan de functie `slotSetPixmap`. Vergelijkbare functies bestaan voor het instellen van de voorgangsbalkbereik (`slotUpdateSteps` en het ophogen van de huidige stap (`slotUpdateProgress`).

### Implementatie van de plugin

We gaan alleen de relevante onderdelen van de implementatie doornemen. Voor een overzicht van de volledige implementatie kunt u terecht in de bijlage. Het eerste dat we zullen doen is de bibliotheekvereiste uit de weg ruimen:

#### Bibliotheekvereiste

    K_EXPORT_COMPONENT_FACTORY( ksplash2k, KGenericFactory<Theme2k> );

De macro `K_EXPORT_COMPONENT_FACTORY` is gedeclareerd in `kgenericfactory.h`. Nu naar de constructor! Omdat het een eenvoudige plugin is, is de constructor vrij rechtlijnig.

#### Pluginconstructor

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

De methode `readSettings()` beschrijft de juiste manier om uw thema-instellingen te verkrijgen. (U wilt immers dat gebruikers uw plugins in hun thema's gaan gebruiken, of niet?)

#### Thema-instellingen verkrijgen

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

Omdat we blij zijn met onze gebruikers leveren we bruikbare standaardwaarden aan voor parameters die niet in het themabestand staan. Merk op dat we altijd onze groep dienen in te stellen op "KSplash Theme: themanaam" om compatible te blijven met toekomstige themaspecificaties. De methode `initUI()` is niet echt interessant, ze bouwt enkel de widgets. Zie de bijlage voor meer details.

### De plugin compileren

Omdat we gebruik maken van het &kde;-framework voor het compileren van de plugin hebben we het bestand `Makefile.am` nodig. Dit bestand hoort er als volgt uit te zien:

#### Inhoud van `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

For more information on writing `Makefile.am` files for &kde;, please see the &kde; developers' website. The only thing of note is that we provide a default theme based on this plugin, and provide a preview image for it. As a matter of courtesy to your users, you should provide an example `Theme.rc` file illustrating the use of the various options.

## Vragen en antwoorden

&reporting.bugs; &updating.documentation;

Ik kan geen enkel thema vinden dat werkt in &ksplash;. Hoe komt dat?

U hebt waarschijnlijk niet de juiste plugins voor het thema. De plugins bevinden zich in het pakket `kdeartwork`. Download en installeer dit pakket, en probeer het opnieuw.

Wat is `Theme.rc` voor bestand, en hoe maak ik er een aan?

`Theme.rc` is het bestand waarin u de instellingen van een thema kunt opgeven. Voor meer informatie kijk in sectie Thema's voor &ksplash; maken.

## Dankbetuigingen en licentie

&ksplash;

Programma copyright © 2003 &Ravikiran.Rajagopal; &Ravikiran.Rajagopal.mail;

### Met bijdragen van

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

Documentatie copyright © 2003 &Teemu.Rytilahti; &Teemu.Rytilahti.mail;

&underFDL; &underGPL;

## Installatie

### Benodigdheden

Om &ksplash; te kunnen gebruiken heeft u &kde; versie 3.2 of hoger nodig. Sommige thema's hebben specifieke plugins nodig. Als een thema niet werkt, neem dan contact op met de auteur ervan om er achter te komen waar u de benodigde plugin vandaan kunt halen.

### Compilatie en installatie

&install.compile.documentation;

## Broncode

### Inhoud van `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 );
    }

### Inhoud van `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

### Inhoud van `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;