# The &ksplash; Handbook

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

    kde-en-gb@jriddell.org

Conversion to British English
2003 Teemu Rytilahti
2003-04 Ravikiran Rajagopal
&FDLNotice;
2003-01-10
1.01.00

&ksplash; is a nice splash screen that shows the progress of an application that is loading.

KDE kdebase ksplash ksplashml splashscreen eye candy

## Introduction

&ksplash; is a nice splash screen that shows the progress of an application that is loading. Please report any problems or feature requests to the &kde; mailing lists. The principal features of &ksplash;:

- Themeable
- Uses plugins to be completely customisable
- Can be used by any application that uses DCOP

This handbook will show you how to create themes for use with plugins that are already available. If none of the plugins available satisfy your tastes, you can learn how to customise the appearance of &ksplash; completely by writing a plugin in C++.

## Using themes

To use themes from KDE-Look, extract them to `~/.kde/share/apps/ksplash/Themes/` for a single user, or to `$`KDEDIR`/share/apps/ksplash/Themes/` to make them available to all users of your system.

You can also use the Splash Screen module under Appearance in the &kde; control centre to do this automatically.

### Using the &kcontrol; Module

This module allows you to install, test and remove &ksplash; themes.

Down the side of the module is a list of currently available &ksplash; themes. As you select one, a preview will display in the main part of the window. When you have selected the one you wish to use, press OK or Apply. Press Cancel to exit the module without making changes, and Defaults to restore the system default splash screen.

To install new modules, press Add..., and find the theme on your computer. You do not have to unpack theme files, you can safely select the compressed theme file. Installing a theme does not make it the theme in use until you select it in the list and press either OK or Apply.

Although you can see a preview of the splash screen, you may like to see how it looks in real use, for instance to see what the animation looks like. You can test themes by selecting them in the list and clicking the Test button.

You can also remove themes you no longer wish to use, by selecting them and pressing the Remove button. Note that your user account may not have the right to remove themes installed system-wide. It is also recommended you do not uninstall the Default splash screen.

## How to make themes for &ksplash;

### General

Making your own themes for &ksplash; is easy. After you have finished your themes you can post them on the KDE-Look so that others can use it.

#### Identifying your theme

Let us create a theme called `MyCoolTheme`. For the theme to be recognised by &ksplash;, it should be stored in a folder called `MyCoolTheme` under `~/.kde/apps/ksplash/Themes/`. It should have a file called `Theme.rc`, containing the settings of the theme. You can specify large numbers of special things to theme, change the plugin engine to use, and so on. You do not have to use all the settings available; usually, the settings have an acceptable default value. The basic syntax for entries in the `Theme.rc` file is `[option] = [value]` You can find the definitions of the various options in the following sections.

Simple `Theme.rc` file

    [KSplash Theme: MyCoolTheme]
    Name = MyCoolTheme
    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

After specifying the name, the description and the author of the theme, you should first choose a theme engine (also known as a plugin). Then, you can customise various features of the theme engine by assigning key-value pairs as in the example file above.

It is important that the name of the directory under which the theme files are stored (`~/.kde/apps/ksplash/Themes/MyCoolTheme` in our case) and the identifier (`[KSplash Theme: MyCoolTheme]` in our case) of the theme in the `Theme.rc` file are identical. Otherwise, &ksplash; will not recognise the theme.

#### Background files

When &ksplash; starts, it tries to find a background image for your current screen resolution, if the theme engine uses one. The background image file should be named in the following format: `Background-WWWxHHH.png`.

For example, you might use a file called `Background-1024x768`. If the background image for your screen resolution cannot be found, it tries to resize the original `Background.png` or the file specified in `Theme.rc` to suit the current resolution. Resizing on-the-fly will certainly take some time, so you should provide background images for at least the following sizes: 1280x1024, 1024x768 and 800x600.

### Options for Theme Engines

#### Standard Theme

Standard Theme Options

Name | Argument | Explanation
Statusbar Position | [top/bottom] | Toggles the position of the statusbar on the screen. Default is bottom.
Statusbar Visible | [true/false] | Indicates whether the statusbar should be shown. Default is true.
Progress Visible | [true/false] | Indicates whether loading progress should be shown. Default is true.
Statusbar Font | [fontname] | The font used in statusbar. Default is Helvetica.
Statusbar Font Size | [size] | The font size for the statusbar. Default is 16.
Statusbar Font Bold | [true/false] | Indicates whether the statusbar font should be bold. Default is true.
Statusbar Font Italic | [true/false] | Indicates whether the statusbar font should be italic. Default is false.
Statusbar Foreground | [color] | The foreground colour of statusbar. Default is white.
Statusbar Background | [color] | The background colour of statusbar. Default is black.
Statusbar Icon | [true/false] | Indicates whether the statusbar should have an icon.
Icons Visible | [true/false] | Indicates whether icons should be visible. Default is true.
Icons Jumping | [true/false] | Indicates whether icons should be jumping. Default is true.
Icon Position | [0-3,10-13] | Position where the icons are shown. Default is bottom-left.
Splash Screen | [name] | Changes the splash screen image that is shown.

#### Redmond theme

Redmond theme options

Name | Argument | Explanation
Background Image | [filename] | User defined background image to use.
User Icon | [Iconname] | Name of standard icon to show for user. Default is `go`.
Welcome Text | [text] | Text shown in splash screen. Default is "Welcome".
Username Text | [text] | Text shown instead of user's real name.
Welcome Text Position | [x,y] | Position on the screen where the Welcome Text is shown.
Username Text Position | [x,y] | Position on the screen where the username is shown.
Action Text Position | [x,y] | Position on the screen where the current action is shown.
Icon Position | [x,y] | Position on the screen where the user icon is shown.
Show Welcome Text | [true/false] | Toggles showing of welcome text. Default is true.
Show Welcome Shadow | [true/false] | Toggles showing of welcome text's shadow. Default is true.
Show Username | [true/false] | Toggles showing of username. Default is true.
Show Action | [true/false] | Toggles showing of action currently being performed. Default is true.
Show Icon | [true/false] | Indicates whether icon should be shown. Default is true
Use KDM User Icon | [true/false] | Show user's login icon. Default is true.

#### MacX Theme

MacX Theme Options

Name | Argument | Explanation
Icon Size Minimum | [size] | Assign the minimum size for icons. Default is 16.
Icon Size Maximum | [size] | Assign the maximum size for icons. Default is 64.
Optimised Icon Rendering | [true/false] | Optimise icon rendering. Default is true.
Progress Bar Visible | [true/false] | Default is true.
Progress Bar Position | [top/bottom] | Toggles whether statusbar should be in bottom or top. Default is bottom.
Icons Jumping | [true/false] | Indicates whether icons should be jumping. Default is false.

#### MacClassic Theme

MacClassic Theme Options

Name | Argument | Explanation
Icon Position | [0-3,10-13] | Position of the icons on the screen. Default is bottom left.
Icons Jumping | [true/false] | Indicates whether icons should be jumping. Default is false.
Icons Visible | [true/false] | Indicates whether icons should be visible. Default is true.
Splash Screen | [name] | Changes the splash screen image that is shown.

#### 2k theme

2k theme options

Name | Argument | Explanation
Title Background Colour | [color] | The background colour of title. Default is dark blue.
Title Foreground Colour | [color] | The foreground colour of title. Default is white.
Status Text Colour | [color] | The colour of status texts. Default is the same as Title Background Colour.
Rotator Colour 1 | [color] | Defines the colour of rotator 1. Default is dark blue.
Rotator Colour 2 | [color] | Defines the colour of rotator 2. Default is cyan.
Rotator Speed | [value] | Defines the speed of the rotator. Default is 30.
Window Title | [text] | Specifies the title text of the window.
Logo File | [filename] | Defines the logo used.

## Using &ksplash; From Within Your Own Application

In this chapter, we describe a simple method for using &ksplash; as the splash screen for your &kde; application. If you do not develop applications for &kde;, you can skip this chapter.

### Basic Requirements

Your &kde; application must be &DCOP;-aware. &DCOP; is the &kde; technology used to communicate between applications. If you use the standard &kde; application framework, this is taken care of automatically. For information about &DCOP; and related &kde; technologies, please visit the &kde; developers' corner.

### Starting &ksplash;

Before your application starts its computation intensive work, or before it starts loading plugins, &etc;, invoke &ksplash; as follows:

    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 will assume that there is only one instance of &ksplash; running. Other cases are slightly more complex. Please see the &DCOP; documentation for further details.

### Showing messages

Before you show any messages, you need to set up the number of steps you will show. For example, the &kde; startup procedure uses 7 steps.

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

Whenever you want to display a message with or without an icon, use

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

Each time you call `programStarted`, the steps completed is incremented. When your program has finished its startup, do the following to make the splash screen go away:

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

That's it! You don't need anything more to take advantage of all that &ksplash; has to offer you.

## Writing new &ksplash; plugins

Writing new &ksplash; plugins is not difficult. In this chapter, we will write a simple plugin that will emulate the splash screen of a well known operating system. This tutorial assumes that you know the basics of C++, and a little bit of KDE/Qt programming.

### Basic Requirements

We will create a plugin called `2k`. The plugin name is used in various places, and is important that you consistently use it so that the plugin is recognised by &ksplash;. &ksplash; plugins are actually dynamically loadable libraries with the following naming convention:

- The library should be named as `ksplash+lowercasethemename`. For our theme, it will be `ksplash2k`.
- It should have a corresponding desktop file which is named as `ksplash+lowercasethemename.desktop`. For our theme, it will be `ksplash2k.desktop`.
- Finally, the object that is returned by the library should be a class which is named `Theme+themename`. For our example, it will be `Theme2k`.

Do not worry about it if you don't understand all of the above. We will consider each of those points in detail later. The other very important detail is that the plugin class should be derived from `ThemeEngine`.

### Building the skeleton framework

We will use the &kde; application framework which will take care of building the plugin and will provide us with platform independence without any work on our part. To do that, make sure you have the `kdesdk` package installed. Run the command `kapptemplate` to produce an application named "2k". It will create a toplevel folder which contains generic files such as AUTHORS, &etc;. We are most interested in the subfolder called `2k`. Go into that subfolder and delete all the files there. Now we have the skeleton we require.

The next step is to create a `.desktop` file which, when installed, will tell &ksplash; that our plugin is available. Consistent with the naming conventions laid out in the preceding section, create a file called `ksplash2k.desktop` in that folder. It should contain the following lines:

    [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

The `Encoding`, `Type`, `Comment` and `ServiceTypes` are the same for all plugins. The plugin name and the library name follow the conventions noted earlier. The entry `X-KSplash-Default` takes a boolean value which determines whether it is shown in the control panel configuration module by default. Except for some very rare cases, it should be `true`.

### Declaration of plugin class

Now that we have the preliminary work done, let us get into the actual fun part - creating a class that will provide the behaviour we want. While we are free to make this class do almost anything we want it to do, there are a few restrictions.

1. Plugin classes must inherit the `ThemeEngine` class.

2. Plugin classes must be named according to the rule: Theme+PluginName.

3. Plugin classes should provide a `static` function called `names` that returns a list of names by which it can be invoked.

4. If the plugin can be configured in the control centre module, it should provide a `ThemeEngineConfig`-based class for the configuration.

5. Plugin classes must override at least one of the virtual functions `slotSetText`, `slotSetPixmap`, `slotUpdateProgress` and `slotUpdateSteps` to make it usable.

6. The constructor should take the form `ThemeEngine( QWidget *parent, const char *name, const QStringList &args )` so that it can be used with KGenericFactory.

The last requirement may seem complicated, but, as we will see later, by adding a single line to your source files, you can usually ignore it.

### Code for the header file

Given the constaints, we will now see what the header file `theme2k.h` looks like this:

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

Let us analyse the listing above. The Theme2k class satisfies the naming conventions, and is inherited from ThemeEngine. It provides a Theme2k::names(), and has a constructor that takes the required parameters: `Theme2k( QWidget *, const char *, const QStringList& );` and also provides a simple Theme2k::slotSetText() method. For the moment, do not worry about the RotWidget class. It is a small widget that provides some eye candy for the user. Our plugin is very simple and does not display any icons or show a progressbar. If you would like to display icons, override the `slotSetPixmap` function. Similar functions exist for setting the progressbar range (`slotUpdateSteps`) and incrementing(`slotUpdateProgress`) the current step.

### Implementation of the plugin

We will examine only the relevant parts of the implementation. For a listing of the whole implementation, please see the appendix. The first thing we will do is to get the library requirement out of the way:

Library requirement

    K_EXPORT_COMPONENT_FACTORY( ksplash2k, KGenericFactory<Theme2k> );

The macro `K_EXPORT_COMPONENT_FACTORY` is declared in `kgenericfactory.h`. Onwards to the constructor! Since this is a very simple plugin, the constructor is pretty straightforward.

Plugin constructor

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

The method `readSettings()` illustrates the proper way to obtain your theme settings. (You do want people to use your plugins in their themes, don't you?)

Obtaining theme settings

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

Since we like our users, we provide sensible defaults for parameters that are not present in the theme file. Note that we should always set our group to "KSplash Theme: themename" to remain compatible with future theme specifications. The `initUI()` method is not very interesting, as it merely builds up the widgets. Please see the appendix for details.

### Compiling the plugin

Since we decided to use the &kde; framework for compiling the plugin, we need to create a `Makefile.am`. It should look like this:

Listing of `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.

## Questions and Answers

&reporting.bugs; &updating.documentation;

I can't find any themes that work in &ksplash;. Why is that?

You probably don't have the correct plugins for the theme. The plugins are in the `kde-artwork` package. Download and install it, and try then again.

What is file `Theme.rc` and how do I make one?

`Theme.rc` is the file where you can specify a theme's settings. For more information, take a look at How to make themes for &ksplash;.

## Credits and Licence

&ksplash;

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

Contributors

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

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

&underFDL; &underGPL;

## Installation

### Requirements

In order to successfully use &ksplash;, you need &kde; version 3.2 or higher. Some themes may require specific plugins. If a theme does not work, please contact the theme author to find out where to obtain the appropriate plugin.

### Compilation and Installation

&install.compile.documentation;

## Source code

### Listing of `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 of `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 of `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, optimise 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;