2 files changed, 26 insertions, 10 deletions

diff --git a/core/launcher/launcherview.cpp b/core/launcher/launcherview.cpp
index 2b34cc5..e7229ee 100644
--- a/core/launcher/launcherview.cpp
+++ b/core/launcher/launcherview.cpp
@@ -199,265 +199,282 @@ void LauncherItem::paintAnimatedIcon( QPainter *p )
        bounceY = bounceY < 0 ? -bounceY : bounceY;
     }
 #endif
     p2.drawPixmap( x1, y1 + bounceY, *pixmap() );
 #ifdef USE_ANIMATED_BUSY_ICON_OVERLAY
     p2.drawPixmap( x1, y1 + bounceY, liv->busyPixmap(), w * pic, 0, w, h );
 #else
     Q_UNUSED( pic )
 #endif
     p->drawPixmap( x1, y1, dblBuf );
 }
 
 void LauncherItem::animateIcon()
 {
     LauncherIconView* liv = (LauncherIconView*)iconView();
 
     if ( liv->busyItem() != this || !app )
     return;
 
     // Highlight the icon
     if ( iteration == 0 ) {
         QPixmap src;
         pixiter it;
         if (isEyeImage() && (it=LauncherIconView::sm_EyeCache->find(appLnk()->file()))!=LauncherIconView::sm_EyeCache->end()) {
             src = (*it);
         } else {
             src = ((isBigIcon ? app->bigPixmap() : app->pixmap()));
         }
         QImage img = src.convertToImage();
         QRgb *rgb;
         int count;
         if ( img.depth() == 32 ) {
             rgb = (QRgb*)img.bits();
             count = img.bytesPerLine()/sizeof(QRgb)*img.height();
         } else {
             rgb = img.colorTable();
             count = img.numColors();
         }
         for ( int r = 0; r < count; r++, rgb++ ) {
 #if defined(BRIGHTEN_BUSY_ICON)
             QColor c(*rgb);
             int h, s, v;
             c.hsv(&h,&s,&v);
             c.setHsv(h,QMAX(s-24,0),QMIN(v+48,255));
             *rgb = qRgba(c.red(),c.green(),c.blue(),qAlpha(*rgb));
 #elif defined(ALPHA_FADE_BUSY_ICON)
             *rgb = qRgba(qRed(*rgb),qGreen(*rgb),qBlue(*rgb),qAlpha(*rgb)/2);
 #endif
         }
         src.convertFromImage( img );
         setPixmap( src );
     }
 
     iteration++;
 
     // Paint animation overlay
     QPainter p( liv->viewport() );
     paintAnimatedIcon( &p );
 }
 
 void LauncherItem::resetIcon()
 {
     iteration = 0;
     if (isEyeImage()) {
         QMap<QString,QPixmap>::Iterator it = LauncherIconView::sm_EyeCache->find(appLnk()->file());
         if (it != LauncherIconView::sm_EyeCache->end()) {
             setPixmap(*it);
             return;
         }
     }
     setPixmap(isBigIcon ? app->bigPixmap() : app->pixmap());
 }
 
 void LauncherItem::setEyePixmap(const QPixmap&aIcon)
 {
     if (!isEyeImage()) return;
     setPixmap(aIcon);
     m_EyeImageSet = EYE_ICON;
 }
 
 //===========================================================================
 // Implemantation of LauncherIconview start
 //===========================================================================
 
 QMap<QString,QPixmap>* LauncherIconView::sm_EyeCache=0;
 
 LauncherIconView::LauncherIconView( QWidget* parent, const char* name )
     : QIconView(parent,name),tf(""),cf(0),bsy(0),busyTimer(0),bigIcns(TRUE),bgColor(white),numColumns(0)
 {
     m_EyeCallBack = 0;
     if (!sm_EyeCache) sm_EyeCache = new QMap<QString,QPixmap>();
     sortmeth = Name;
     hidden.setAutoDelete(TRUE);
     ike = FALSE;
     calculateGrid( Bottom );
     connect(&m_eyeTimer,SIGNAL(timeout()),this,SLOT(stopEyeTimer()));
+    Config config( "Launcher" );
+    config.setGroup( "GUI" );
+    staticBackground = config.readEntry( "StaticBackground", false );
+    if ( staticBackground )
+    {
+        setStaticBackground( true );
+        verticalScrollBar()->setTracking( false );
+    }
 }
 
 LauncherIconView::~LauncherIconView()
 {
     odebug << "LauncherIconView::~LauncherIconView()" << oendl;
 #if 0 // debuggery
     QListIterator<AppLnk> it(hidden);
     AppLnk* l;
     while ((l=it.current())) {
         ++it;
         //odebug << "" << l << ": hidden (should remove)" << oendl;
     }
 #endif
 }
 
 int LauncherIconView::compare(const AppLnk* a, const AppLnk* b)
 {
     switch (sortmeth) {
     case Name:
         return a->name().lower().compare(b->name().lower());
     case Date: {
         QFileInfo fa(a->linkFileKnown() ? a->linkFile() : a->file());
         QFileInfo fb(b->linkFileKnown() ? b->linkFile() : b->file());
         return fa.lastModified().secsTo(fb.lastModified());
     }
     case Type:
         return a->type().compare(b->type());
     }
     return 0;
 }
 
 void LauncherIconView::setSortMethod( SortMethod m )
 {
     if ( sortmeth != m ) {
         sortmeth = m;
         sort();
     }
 }
 
 void LauncherIconView::setCategoryFilter( int catfilter, bool resort )
 {
         if ( catfilter == -2 )
             cf = 0;
         else
             cf = catfilter;
         hideOrShowItems(resort);
 }
 
 void LauncherIconView::setTypeFilter(const QString& typefilter, bool resort)
 {
     tf = QRegExp(typefilter,FALSE,TRUE);
     hideOrShowItems(resort);
 }
 
 void LauncherIconView::setItemTextPos( ItemTextPos pos )
 {
     calculateGrid( pos );
     QIconView::setItemTextPos( pos );
 }
 
 void LauncherIconView::drawBackground( QPainter *p, const QRect &r )
 {
-    if ( !bgPixmap.isNull() ) {
-        p->drawTiledPixmap( r, bgPixmap,
-                QPoint( (r.x() + contentsX()) % bgPixmap.width(),
-                (r.y() + contentsY()) % bgPixmap.height() ) );
-    } else {
+    if ( bgPixmap.isNull() )
+    {
         p->fillRect( r, bgColor );
     }
+    else
+    {
+        if ( staticBackground )
+        {
+            p->drawPixmap( r.x(), r.y(), bgPixmap, r.x(), r.y(), r.width(), r.height() );
+        }
+        else
+        {
+            p->drawTiledPixmap( r, bgPixmap, QPoint( (r.x() + contentsX()) % bgPixmap.width(),
+                                                     (r.y() + contentsY()) % bgPixmap.height() ) );
+        }
+    }
 }
 
 void LauncherIconView::addCatsAndMimes(AppLnk* app)
-    {
+{
     //  QStringList c = app->categories();
     //  for (QStringList::ConstIterator cit=c.begin(); cit!=c.end(); ++cit) {
     //      cats.replace(*cit,(void*)1);
     //  }
     QString maj=app->type();
     int sl=maj.find('/');
     if (sl>=0) {
         QString k;
         k = maj.left(12) == "application/" ? maj : maj.left(sl);
         mimes.replace(k,(void*)1);
     }
 }
 
 void LauncherIconView::setBusy(bool on)
 {
 #ifdef USE_ANIMATED_BUSY_ICON_OVERLAY
     if ( busyPix.isNull() ) {
         int size = ( bigIcns ) ? AppLnk::bigIconSize() : AppLnk::smallIconSize();
         busyPix.convertFromImage( Resource::loadImage( "busy" ).smoothScale( size * 16, size ) );
     }
 #endif
 
     if ( on ) {
         busyTimer = startTimer( 100 );
     } else {
         if ( busyTimer ) {
             killTimer( busyTimer );
         busyTimer = 0;
         }
     }
 
     LauncherItem *c = on ? (LauncherItem*)currentItem() : 0;
 
     if ( bsy != c ) {
         LauncherItem *oldBusy = bsy;
         bsy = c;
         if ( oldBusy )  {
         oldBusy->resetIcon();
                     }
         if ( bsy )   {
                                 bsy->setBusyIndicatorType( busyType ) ;
         bsy->animateIcon();
                     }
     }
 }
 
 void LauncherIconView::clear()
 {
     mimes.clear();
     cats.clear();
     QIconView::clear();
     hidden.clear();
 }
 
 QStringList LauncherIconView::mimeTypes() const
 {
     QStringList r;
     QDictIterator<void> it(mimes);
     while (it.current()) {
         r.append(it.currentKey());
         ++it;
     }
     r.sort();
     return r;
 }
 
 LauncherItem*LauncherIconView::findDocItem(const QString&fname)
 {
     LauncherItem* item = (LauncherItem*)firstItem();
     while (item) {
         if (item->appLnk()->file()==fname) {
             break;
         }
         item = (LauncherItem*)item->nextItem();
     }
     return item;
 }
 
 void LauncherIconView::setEyePixmap(const QPixmap&aPixmap,const QString&aFile,int width)
 {
     int s = ( bigIcns ) ? AppLnk::bigIconSize() : AppLnk::smallIconSize();
     if (s!=width) return;
     LauncherItem*item = findDocItem(aFile);
     if (!item||!item->isEyeImage()) return;
     (*sm_EyeCache)[aFile]=aPixmap;
     item->setEyePixmap(aPixmap);
 }
 
 void LauncherIconView::checkCallback()
 {
     if (!m_EyeCallBack) {
         m_EyeCallBack = new LauncherThumbReceiver();
         connect(m_EyeCallBack,SIGNAL(sig_Thumbnail(const QPixmap&,const QString&,int)),
             this,SLOT(setEyePixmap(const QPixmap&,const QString&,int)));
     }
     m_eyeTimer.changeInterval(600000);
diff --git a/core/launcher/launcherview.h b/core/launcher/launcherview.h
index e2869eb..97b1dea 100644
--- a/core/launcher/launcherview.h
+++ b/core/launcher/launcherview.h
@@ -1,255 +1,254 @@
 /**********************************************************************
 ** Copyright (C) 2000-2002 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 #ifndef LAUNCHERVIEW_H
 #define LAUNCHERVIEW_H
 
 #include <qtopia/storage.h>
 #include <qtopia/applnk.h>
 
 #include <qvbox.h>
 #include <qiconview.h>
 #include <qtimer.h>
 #include <qmap.h>
 
 class CategorySelect;
 class LauncherIconView;
 class LauncherItem;
 class QIconViewItem;
 class QLabel;
 class QWidgetStack;
 class MenuButton;
 class QComboBox;
 
-
-
 enum BusyIndicatorType {
     BIT_Normal = 0,
     BIT_Animated
 };
 
 class LauncherView : public QVBox
 {
     Q_OBJECT
 
 public:
     LauncherView( QWidget* parent = 0, const char* name = 0, WFlags fl = 0 );
     ~LauncherView();
 
     void hideIcons();
 
     bool removeLink(const QString& linkfile);
     void addItem(AppLnk* app, bool resort=TRUE);
     void changeItem(const AppLnk&old,AppLnk*nlink);
 
     void removeAllItems();
     void setSortEnabled(bool);
     void setUpdatesEnabled(bool);
     void sort();
 
     void setToolsEnabled(bool);
     void updateTools();
 
     void setBusy(bool);
     void setBusyIndicatorType( const QString& );
 
     enum ViewMode { Icon, List };
     void setViewMode( ViewMode m );
     ViewMode viewMode() const { return vmode; }
 
     enum BackgroundType { Ruled, SolidColor, Image };
     void setBackgroundType( BackgroundType t, const QString & );
     BackgroundType backgroundType() const { return bgType; }
 
     void setTextColor( const QColor & );
     QColor textColor() const { return textCol; }
 
     void setViewFont( const QFont & );
     void clearViewFont();
-    
+
     void setColNumber( int );
 
     void relayout(void);
 
 signals:
     void clicked( const AppLnk * );
     void rightPressed( AppLnk * );
 
 protected slots:
     void selectionChanged();
     void returnPressed( QIconViewItem *item );
     void itemClicked( int, QIconViewItem * );
     void itemPressed( int, QIconViewItem * );
     void sortBy(int);
     void showType(int);
     void showCategory( int );
     void resizeEvent(QResizeEvent *);
     void flushBgCache();
 
 protected:
     void paletteChange( const QPalette & );
 
     void fontChanged(const QFont &);
 
 private:
     static bool bsy;
     QWidget* tools;
     LauncherIconView* icons;
     QComboBox *typemb;
     QStringList typelist;
     CategorySelect *catmb;
     ViewMode vmode;
     BackgroundType bgType;
     QString bgName;
     QColor textCol;
 
     QImage loadBackgroundImage(QString &fname);
 
 };
 
 /* from opie-eye */
 struct PixmapInfo {
     PixmapInfo() : width( -1 ), height( -1 ) {}
     bool operator==( const PixmapInfo& r ) {
         if ( width  != r.width  ) return false;
         if ( height != r.height ) return false;
         if ( file   != r.file   ) return false;
         return true;
     }
     int width, height;
     QString file;
     QPixmap pixmap;
 };
 
 class LauncherThumbReceiver:public QObject
 {
     Q_OBJECT
     typedef QValueList<PixmapInfo> PixmapInfos;
 public:
     LauncherThumbReceiver();
     ~LauncherThumbReceiver();
     void requestThumb(const QString&file,int width,int height);
 
 public slots:
     void recieve( const QCString&, const QByteArray& );
 protected slots:
     virtual void sendRequest();
 
 signals:
     void sig_Thumbnail(const QPixmap&,const QString&,int);
 
 protected:
     PixmapInfos m_inThumbNail;
 };
 
 class LauncherIconView : public QIconView {
     Q_OBJECT
 public:
     LauncherIconView( QWidget* parent, const char* name=0 );
     ~LauncherIconView();
     QIconViewItem* busyItem() const;
 
 #ifdef USE_ANIMATED_BUSY_ICON_OVERLAY
     QPixmap busyPixmap() const { return busyPix; }
 #endif
     void setBigIcons( bool bi );
     void updateCategoriesAndMimeTypes();
     void setBusyIndicatorType ( BusyIndicatorType t );
     void doAutoScroll()
     {
     // We don't want rubberbanding (yet)
     }
 
     void setBusy(bool on);
     bool inKeyEvent() const { return ike; }
 
     void addItem(AppLnk* app, bool resort=TRUE);
     bool removeLink(const QString& linkfile,bool removeCache = true);
     void changeItem(const AppLnk&old,AppLnk*nlink);
 
     QStringList mimeTypes() const;
     QStringList categories() const;
     void clear();
     void addCatsAndMimes(AppLnk* app);
 
     void setBackgroundOrigin( QWidget::BackgroundOrigin ) {}
 
     void setBackgroundPixmap( const QPixmap &pm ) {
         bgPixmap = pm;
     }
 
     void setBackgroundColor( const QColor &c ) {
         bgColor = c;
     }
 
     void setColNumber( int );
-    
+
     void drawBackground( QPainter *p, const QRect &r );
     void setItemTextPos( ItemTextPos pos );
     void hideOrShowItems(bool resort);
 
     void setTypeFilter(const QString& typefilter, bool resort);
     void setCategoryFilter( int catfilter, bool resort );
 
     enum SortMethod { Name, Date, Type };
 
     void setSortMethod( SortMethod m );
     int compare(const AppLnk* a, const AppLnk* b);
     void requestEyePix(const LauncherItem*which);
 
     static QMap<QString,QPixmap>* sm_EyeCache;
 
 protected:
     virtual void timerEvent( QTimerEvent *te );
     void styleChange( QStyle &old );
     void calculateGrid( ItemTextPos pos );
     void focusInEvent( QFocusEvent * ) {}
     void focusOutEvent( QFocusEvent * ) {}
     LauncherItem*findDocItem(const QString&);
     void addCheckItem(AppLnk* app);
     void checkCallback();
     virtual void keyPressEvent(QKeyEvent* e);
 
 protected slots:
     void setEyePixmap(const QPixmap&,const QString&,int width);
     void stopEyeTimer();
 
 private:
     QList<AppLnk> hidden;
     QDict<void> mimes;
     QDict<void> cats;
     SortMethod sortmeth;
     QRegExp tf;
     int cf;
     LauncherItem* bsy;
     int busyTimer;
     bool ike;
     bool bigIcns;
     QPixmap bgPixmap;
     QColor bgColor;
     LauncherThumbReceiver*m_EyeCallBack;
 #ifdef USE_ANIMATED_BUSY_ICON_OVERLAY
     QPixmap busyPix;
 #endif
     BusyIndicatorType busyType;
     QTimer m_eyeTimer;
     int numColumns;
+    bool staticBackground;
 };
 
 #endif // LAUNCHERVIEW_H