2 files changed, 77 insertions, 30 deletions

diff --git a/noncore/graphics/drawpad/drawpad.cpp b/noncore/graphics/drawpad/drawpad.cpp
index c0f42d9..158a5ed 100644
--- a/noncore/graphics/drawpad/drawpad.cpp
+++ b/noncore/graphics/drawpad/drawpad.cpp
@@ -1,319 +1,356 @@
 /***************************************************************************
  *                                                                         *
  *   DrawPad - a drawing program for Opie Environment                      *
  *                                                                         *
  *   (C) 2002 by S. Prud'homme <prudhomme@laposte.net>                     *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 
 #include "drawpad.h"
 
 #include "drawpadcanvas.h"
 #include "ellipsetool.h"
 #include "erasetool.h"
 #include "exportdialog.h"
 #include "filledellipsetool.h"
 #include "filledrectangletool.h"
 #include "filltool.h"
 #include "importdialog.h"
 #include "linetool.h"
 #include "newpagedialog.h"
 #include "page.h"
 #include "pageinformationdialog.h"
 #include "pointtool.h"
 #include "rectangletool.h"
 #include "texttool.h"
 #include "thumbnailview.h"
 
 #include <opie2/qcolordialog.h>
 #include <opie2/ocolorpopupmenu.h>
+#include <opie2/oresource.h>
 
 #include <qpe/applnk.h>
 #include <qpe/config.h>
 #include <qtoolbar.h>
-#include <qpe/resource.h>
 #include <qpe/qpeapplication.h>
 
 #include <qmenubar.h>
 #include <qaction.h>
 #include <qfile.h>
 #include <qmessagebox.h>
 #include <qspinbox.h>
 #include <qtoolbutton.h>
 #include <qtooltip.h>
 #include <qwhatsthis.h>
 
 using namespace Opie::Ui;
 DrawPad::DrawPad(QWidget* parent, const char* name,  WFlags /*fl*/ )
     : QMainWindow(parent, name, WStyle_ContextHelp)
 {
     // init members
     connect( qApp, SIGNAL(appMessage(const QCString&, const QByteArray&)),
              this, SLOT(slotAppMessage(const QCString&, const QByteArray&)) );
 
     m_pDrawPadCanvas = new DrawPadCanvas(this, this);
 
     connect(m_pDrawPadCanvas, SIGNAL(pagesChanged()), this, SLOT(updateView()));
 
     setCentralWidget(m_pDrawPadCanvas);
 
     // init menu
 
     setToolBarsMovable(false);
 
     QToolBar* menuToolBar = new QToolBar(this);
     QMenuBar* menuBar = new QMenuBar(menuToolBar);
 
     QPopupMenu* toolsPopupMenu = new QPopupMenu(menuBar);
 
     QAction* deleteAllAction = new QAction(tr("Delete All"), QString::null, 0, this);
     connect(deleteAllAction, SIGNAL(activated()), this, SLOT(deleteAll()));
     deleteAllAction->addTo(toolsPopupMenu);
 
     toolsPopupMenu->insertSeparator();
 
     QAction* importPageAction = new QAction(tr("Import"), tr("Import..."), 0, this);
     connect(importPageAction, SIGNAL(activated()), this, SLOT(importPage()));
     importPageAction->addTo(toolsPopupMenu);
 
     QAction* exportPageAction = new QAction(tr("Export"), tr("Export..."), 0, this);
     connect(exportPageAction, SIGNAL(activated()), this, SLOT(exportPage()));
     exportPageAction->addTo(toolsPopupMenu);
 
     toolsPopupMenu->insertSeparator();
 
     QAction* thumbnailViewAction = new QAction(tr("Thumbnail View"), tr("Thumbnail View..."), 0, this);
     connect(thumbnailViewAction, SIGNAL(activated()), this, SLOT(thumbnailView()));
     thumbnailViewAction->addTo(toolsPopupMenu);
 
     QAction* pageInformationAction = new QAction(tr("Page Information"), tr("Page Information..."), 0, this);
     connect(pageInformationAction, SIGNAL(activated()), this, SLOT(pageInformation()));
     pageInformationAction->addTo(toolsPopupMenu);
 
     toolsPopupMenu->insertSeparator();
 
     m_pAntiAliasingAction = new QAction(tr("Anti-Aliasing"), QString::null, 0, this);
     m_pAntiAliasingAction->setToggleAction(true);
     m_pAntiAliasingAction->addTo(toolsPopupMenu);
 
     menuBar->insertItem(tr("Tools"), toolsPopupMenu);
 
     // init page toolbar
 
     QToolBar* pageToolBar = new QToolBar(this);
 
-    QAction* newPageAction = new QAction(tr("New Page"), Resource::loadPixmap("new"), QString::null, 0, this);
+    QAction* newPageAction = new QAction(tr("New Page"), Opie::Core::OResource::loadPixmap("new", Opie::Core::OResource::SmallIcon),
+                                         QString::null, 0, this);
     connect(newPageAction, SIGNAL(activated()), this, SLOT(newPage()));
     newPageAction->addTo(pageToolBar);
     newPageAction->setWhatsThis( tr( "Click here to add a new sheet." ) );
 
-    QAction* clearPageAction = new QAction(tr("Clear Page"), Resource::loadPixmap("drawpad/clear"), QString::null, 0, this);
+    QAction* clearPageAction = new QAction(tr("Clear Page"),
+                                           Opie::Core::OResource::loadPixmap("drawpad/clear", Opie::Core::OResource::SmallIcon),
+                                           QString::null, 0, this);
     connect(clearPageAction, SIGNAL(activated()), this, SLOT(clearPage()));
     clearPageAction->addTo(pageToolBar);
     clearPageAction->setWhatsThis( tr( "Click here to erase the current sheet." ) );
 
-    QAction* deletePageAction = new QAction(tr("Delete Page"), Resource::loadPixmap("trash"), QString::null, 0, this);
+    QAction* deletePageAction = new QAction(tr("Delete Page"),
+                                            Opie::Core::OResource::loadPixmap("trash", Opie::Core::OResource::SmallIcon),
+                                            QString::null, 0, this);
     connect(deletePageAction, SIGNAL(activated()), this, SLOT(deletePage()));
     deletePageAction->addTo(pageToolBar);
     deletePageAction->setWhatsThis( tr( "Click here to remove the current sheet." ) );
 
     QToolBar* emptyToolBar = new QToolBar(this);
     emptyToolBar->setHorizontalStretchable(true);
 
     // init navigation toolbar
 
     QToolBar* navigationToolBar = new QToolBar(this);
 
-    m_pUndoAction = new QAction(tr("Undo"), Resource::loadIconSet("undo"), QString::null, 0, this);
+    m_pUndoAction = new QAction(tr("Undo"), Opie::Core::OResource::loadPixmap("undo", Opie::Core::OResource::SmallIcon),
+                                QString::null, 0, this);
     connect(m_pUndoAction, SIGNAL(activated()), m_pDrawPadCanvas, SLOT(undo()));
     m_pUndoAction->addTo(navigationToolBar);
     m_pUndoAction->setWhatsThis( tr( "Click here to undo the last action." ) );
 
-    m_pRedoAction = new QAction(tr("Redo"), Resource::loadIconSet("redo"), QString::null, 0, this);
+    m_pRedoAction = new QAction(tr("Redo"), Opie::Core::OResource::loadPixmap("redo", Opie::Core::OResource::SmallIcon),
+                                QString::null, 0, this);
     connect(m_pRedoAction, SIGNAL(activated()), m_pDrawPadCanvas, SLOT(redo()));
     m_pRedoAction->addTo(navigationToolBar);
     m_pRedoAction->setWhatsThis( tr( "Click here to re-perform the last action." ) );
 
-    m_pFirstPageAction = new QAction(tr("First Page"), Resource::loadIconSet("fastback"), QString::null, 0, this);
+    m_pFirstPageAction = new QAction(tr("First Page"),
+                                     Opie::Core::OResource::loadPixmap("fastback", Opie::Core::OResource::SmallIcon),
+                                     QString::null, 0, this);
     connect(m_pFirstPageAction, SIGNAL(activated()), m_pDrawPadCanvas, SLOT(goFirstPage()));
     m_pFirstPageAction->addTo(navigationToolBar);
     m_pFirstPageAction->setWhatsThis( tr( "Click here to view the first page." ) );
 
-    m_pPreviousPageAction = new QAction(tr("Previous Page"), Resource::loadIconSet("back"), QString::null, 0, this);
+    m_pPreviousPageAction = new QAction(tr("Previous Page"),
+                                        Opie::Core::OResource::loadPixmap("back", Opie::Core::OResource::SmallIcon),
+                                        QString::null, 0, this);
     connect(m_pPreviousPageAction, SIGNAL(activated()), m_pDrawPadCanvas, SLOT(goPreviousPage()));
     m_pPreviousPageAction->addTo(navigationToolBar);
     m_pPreviousPageAction->setWhatsThis( tr( "Click here to view the previous page." ) );
 
-    m_pNextPageAction = new QAction(tr("Next Page"), Resource::loadIconSet("forward"), QString::null, 0, this);
+    m_pNextPageAction = new QAction(tr("Next Page"),
+                                    Opie::Core::OResource::loadPixmap("forward", Opie::Core::OResource::SmallIcon),
+                                    QString::null, 0, this);
     connect(m_pNextPageAction, SIGNAL(activated()), m_pDrawPadCanvas, SLOT(goNextPage()));
     m_pNextPageAction->addTo(navigationToolBar);
     m_pNextPageAction->setWhatsThis( tr( "Click here to view the next page." ) );
 
-    m_pLastPageAction = new QAction(tr("Last Page"), Resource::loadIconSet("fastforward"), QString::null, 0, this);
+    m_pLastPageAction = new QAction(tr("Last Page"),
+                                    Opie::Core::OResource::loadPixmap("fastforward", Opie::Core::OResource::SmallIcon),
+                                    QString::null, 0, this);
     connect(m_pLastPageAction, SIGNAL(activated()), m_pDrawPadCanvas, SLOT(goLastPage()));
     m_pLastPageAction->addTo(navigationToolBar);
     m_pLastPageAction->setWhatsThis( tr( "Click here to view the last page." ) );
 
     // init draw mode toolbar
 
     QToolBar* drawModeToolBar = new QToolBar(this);
 
     m_pLineToolButton = new QToolButton(drawModeToolBar);
     m_pLineToolButton->setToggleButton(true);
     QWhatsThis::add( m_pLineToolButton, tr( "Click here to select one of the available tools to draw lines." ) );
 
 
     QPopupMenu* linePopupMenu = new QPopupMenu(m_pLineToolButton);
 
-    m_pPointToolAction = new QAction(tr("Draw Point"), Resource::loadPixmap("drawpad/point"), "", 0, this);
+    m_pPointToolAction = new QAction(tr("Draw Point"),
+                                     Opie::Core::OResource::loadPixmap("drawpad/point", Opie::Core::OResource::SmallIcon),
+                                     "", 0, this);
     connect(m_pPointToolAction, SIGNAL(activated()), this, SLOT(setPointTool()));
     m_pPointToolAction->addTo(linePopupMenu);
 
-    m_pLineToolAction = new QAction(tr("Draw Line"), Resource::loadPixmap("drawpad/line"), "", 0, this);
+    m_pLineToolAction = new QAction(tr("Draw Line"),
+                                    Opie::Core::OResource::loadPixmap("drawpad/line", Opie::Core::OResource::SmallIcon),
+                                    "", 0, this);
     connect(m_pLineToolAction, SIGNAL(activated()), this, SLOT(setLineTool()));
     m_pLineToolAction->addTo(linePopupMenu);
 
     m_pLineToolButton->setPopup(linePopupMenu);
     m_pLineToolButton->setPopupDelay(0);
 
     m_pRectangleToolButton = new QToolButton(drawModeToolBar);
     m_pRectangleToolButton->setToggleButton(true);
     QWhatsThis::add( m_pRectangleToolButton, tr( "Click here to select one of the available tools to draw rectangles." ) );
 
     QPopupMenu* rectanglePopupMenu = new QPopupMenu(m_pRectangleToolButton);
 
-    m_pRectangleToolAction = new QAction(tr("Draw Rectangle"), Resource::loadPixmap("drawpad/rectangle"), "", 0, this);
+    m_pRectangleToolAction = new QAction(tr("Draw Rectangle"),
+                                         Opie::Core::OResource::loadPixmap("drawpad/rectangle", Opie::Core::OResource::SmallIcon),
+                                         "", 0, this);
     connect(m_pRectangleToolAction, SIGNAL(activated()), this, SLOT(setRectangleTool()));
     m_pRectangleToolAction->addTo(rectanglePopupMenu);
 
-    m_pFilledRectangleToolAction = new QAction(tr("Draw Filled Rectangle"), Resource::loadPixmap("drawpad/filledrectangle"), "", 0, this);
+    m_pFilledRectangleToolAction = new QAction(tr("Draw Filled Rectangle"),
+                                               Opie::Core::OResource::loadPixmap("drawpad/filledrectangle",
+                                               Opie::Core::OResource::SmallIcon), "", 0, this);
     connect(m_pFilledRectangleToolAction, SIGNAL(activated()), this, SLOT(setFilledRectangleTool()));
     m_pFilledRectangleToolAction->addTo(rectanglePopupMenu);
 
     m_pRectangleToolButton->setPopup(rectanglePopupMenu);
     m_pRectangleToolButton->setPopupDelay(0);
 
     m_pEllipseToolButton = new QToolButton(drawModeToolBar);
     m_pEllipseToolButton->setToggleButton(true);
     QWhatsThis::add( m_pEllipseToolButton, tr( "Click here to select one of the available tools to draw ellipses." ) );
 
     QPopupMenu* ellipsePopupMenu = new QPopupMenu(m_pEllipseToolButton);
 
-    m_pEllipseToolAction = new QAction(tr("Draw Ellipse"), Resource::loadPixmap("drawpad/ellipse"), "", 0, this);
+    m_pEllipseToolAction = new QAction(tr("Draw Ellipse"),
+                                       Opie::Core::OResource::loadPixmap("drawpad/ellipse", Opie::Core::OResource::SmallIcon),
+                                       "", 0, this);
     connect(m_pEllipseToolAction, SIGNAL(activated()), this, SLOT(setEllipseTool()));
     m_pEllipseToolAction->addTo(ellipsePopupMenu);
 
-    m_pFilledEllipseToolAction = new QAction(tr("Draw Filled Ellipse"), Resource::loadPixmap("drawpad/filledellipse"), "", 0, this);
+    m_pFilledEllipseToolAction = new QAction(tr("Draw Filled Ellipse"),
+                                             Opie::Core::OResource::loadPixmap("drawpad/filledellipse",
+                                             Opie::Core::OResource::SmallIcon), "", 0, this);
     connect(m_pFilledEllipseToolAction, SIGNAL(activated()), this, SLOT(setFilledEllipseTool()));
     m_pFilledEllipseToolAction->addTo(ellipsePopupMenu);
 
     m_pEllipseToolButton->setPopup(ellipsePopupMenu);
     m_pEllipseToolButton->setPopupDelay(0);
 
-    m_pTextToolAction = new QAction(tr("Insert Text"), Resource::loadPixmap("drawpad/text"), QString::null, 0, this);
+    m_pTextToolAction = new QAction(tr("Insert Text"),
+                                    Opie::Core::OResource::loadPixmap("drawpad/text", Opie::Core::OResource::SmallIcon),
+                                    QString::null, 0, this);
     m_pTextToolAction->setToggleAction(true);
     connect(m_pTextToolAction, SIGNAL(activated()), this, SLOT(setTextTool()));
     m_pTextToolAction->addTo(drawModeToolBar);
     m_pTextToolAction->setWhatsThis( tr( "Click here to select the text drawing tool." ) );
 
-    m_pFillToolAction = new QAction(tr("Fill Region"), Resource::loadPixmap("drawpad/fill"), QString::null, 0, this);
+    m_pFillToolAction = new QAction(tr("Fill Region"),
+                                    Opie::Core::OResource::loadPixmap("drawpad/fill", Opie::Core::OResource::SmallIcon),
+                                    QString::null, 0, this);
     m_pFillToolAction->setToggleAction(true);
     connect(m_pFillToolAction, SIGNAL(activated()), this, SLOT(setFillTool()));
     m_pFillToolAction->addTo(drawModeToolBar);
     m_pFillToolAction->setWhatsThis( tr( "Click here to select the fill tool." ) );
 
-    m_pEraseToolAction = new QAction(tr("Erase Point"), Resource::loadPixmap("drawpad/erase"), QString::null, 0, this);
+    m_pEraseToolAction = new QAction(tr("Erase Point"),
+                                     Opie::Core::OResource::loadPixmap("drawpad/erase", Opie::Core::OResource::SmallIcon),
+                                     QString::null, 0, this);
     m_pEraseToolAction->setToggleAction(true);
     connect(m_pEraseToolAction, SIGNAL(activated()), this, SLOT(setEraseTool()));
     m_pEraseToolAction->addTo(drawModeToolBar);
     m_pEraseToolAction->setWhatsThis( tr( "Click here to select the eraser tool." ) );
 
     m_pTool = 0;
     setRectangleTool();
     setEllipseTool();
     setPointTool();
 
     emptyToolBar = new QToolBar(this);
     emptyToolBar->setHorizontalStretchable(true);
     emptyToolBar->addSeparator();
 
     // init draw parameters toolbar
 
     QToolBar* drawParametersToolBar = new QToolBar(this);
 
     m_pPenWidthSpinBox = new QSpinBox(1, 9, 1, drawParametersToolBar);
     connect(m_pPenWidthSpinBox, SIGNAL(valueChanged(int)), this, SLOT(changePenWidth(int)));
 
     QToolTip::add(m_pPenWidthSpinBox, tr("Pen Width"));
     m_pPenWidthSpinBox->setValue(1);
     m_pPenWidthSpinBox->setFocusPolicy(QWidget::NoFocus);
     QWhatsThis::add( m_pPenWidthSpinBox, tr( "Click here to select the width of the drawing pen." ) );
 
+    bool useBigIcon = qApp->desktop()->size().width() > 330;
+
     m_pPenColorToolButton = new QToolButton(drawParametersToolBar);
-    m_pPenColorToolButton->setPixmap(Resource::loadPixmap("drawpad/pencolor"));
+    m_pPenColorToolButton->setUsesBigPixmap( useBigIcon );
+    m_pPenColorToolButton->setPixmap(Opie::Core::OResource::loadPixmap("drawpad/pencolor", Opie::Core::OResource::SmallIcon));
     QWhatsThis::add( m_pPenColorToolButton, tr( "Click here to select the color used when drawing." ) );
 
     Opie::OColorPopupMenu* penColorPopupMenu = new Opie::OColorPopupMenu(Qt::black, m_pPenColorToolButton);
     connect(penColorPopupMenu, SIGNAL(colorSelected(const QColor&)), this, SLOT(changePenColor(const QColor&)));
 
     QToolTip::add(m_pPenColorToolButton, tr("Pen Color"));
     m_pPenColorToolButton->setPopup(penColorPopupMenu);
     m_pPenColorToolButton->setPopupDelay(0);
 
     changePenColor(Qt::black);
 
     m_pBrushColorToolButton = new QToolButton(drawParametersToolBar);
-    m_pBrushColorToolButton->setPixmap(Resource::loadPixmap("drawpad/brushcolor"));
+    m_pBrushColorToolButton->setUsesBigPixmap( useBigIcon );
+    m_pBrushColorToolButton->setPixmap(Opie::Core::OResource::loadPixmap("drawpad/brushcolor", Opie::Core::OResource::SmallIcon));
     QWhatsThis::add( m_pBrushColorToolButton, tr( "Click here to select the color used when filling in areas." ) );
 
     Opie::OColorPopupMenu* brushColorPopupMenu = new Opie::OColorPopupMenu(Qt::white, m_pBrushColorToolButton);
     connect(brushColorPopupMenu, SIGNAL(colorSelected(const QColor&)), this, SLOT(changeBrushColor(const QColor&)));
 
     QToolTip::add(m_pBrushColorToolButton, tr("Fill Color"));
     m_pBrushColorToolButton->setPopup(brushColorPopupMenu);
     m_pBrushColorToolButton->setPopupDelay(0);
 
     changeBrushColor(Qt::white);
 
     // delay the rest of the initialization and do it from within the mainloop
     // if we don't do this, the widget layout may not be constructed upon
     // and we will end up with a wrong QScrollview page size (Mickeyl)
     QTimer::singleShot( 100, this, SLOT( finishStartup() ) );
 }
 
 
 void DrawPad::finishStartup()
 {
     // init pages
 
     QFile file(Global::applicationFileName("drawpad", "drawpad.xml"));
 
     if (file.open(IO_ReadOnly)) {
         m_pDrawPadCanvas->load(&file);
         file.close();
     } else {
         m_pDrawPadCanvas->initialPage();
     }
 
     loadConfig();
 
 }
 
 DrawPad::~DrawPad()
 {
     saveConfig();
 
     QFile file(Global::applicationFileName("drawpad", "drawpad.xml"));
 
     if (file.open(IO_WriteOnly)) {
         m_pDrawPadCanvas->save(&file);
         file.close();
     }
 }
 
 bool DrawPad::antiAliasing()
@@ -509,109 +546,111 @@ void DrawPad::setTextTool()
     m_pTextToolAction->setOn(true);
     m_pFillToolAction->setOn(false);
     m_pEraseToolAction->setOn(false);
 }
 
 void DrawPad::setFillTool()
 {
     if (m_pTool) {
         delete m_pTool;
     }
 
     m_pTool = new FillTool(this, m_pDrawPadCanvas);
 
     m_pLineToolButton->setOn(false);
     m_pRectangleToolButton->setOn(false);
     m_pEllipseToolButton->setOn(false);
     m_pTextToolAction->setOn(false);
     m_pFillToolAction->setOn(true);
     m_pEraseToolAction->setOn(false);
 }
 
 void DrawPad::setEraseTool()
 {
     if (m_pTool) {
         delete m_pTool;
     }
 
     m_pTool = new EraseTool(this, m_pDrawPadCanvas);
 
     m_pLineToolButton->setOn(false);
     m_pRectangleToolButton->setOn(false);
     m_pEllipseToolButton->setOn(false);
     m_pTextToolAction->setOn(false);
     m_pFillToolAction->setOn(false);
     m_pEraseToolAction->setOn(true);
 }
 
 void DrawPad::changePenWidth(int value)
 {
     m_pen.setWidth(value);
 }
 
 void DrawPad::changePenColor(const QColor& color)
 {
     m_pen.setColor(color);
 
     QPainter painter;
     painter.begin(m_pPenColorToolButton->pixmap());
-    painter.fillRect(QRect(0, 12, 14, 2), m_pen.color());
+    int size = AppLnk::smallIconSize();
+    painter.fillRect(QRect(0, 6*size/7+1, size, size/7), m_pen.color());
     painter.end();
 
     m_pPenColorToolButton->popup()->hide();
 }
 
 void DrawPad::changeBrushColor(const QColor& color)
 {
     m_brush = QBrush(color);
 
     QPainter painter;
     painter.begin(m_pBrushColorToolButton->pixmap());
-    painter.fillRect(QRect(0, 12, 14, 2), m_brush.color());
+    int size = AppLnk::smallIconSize();
+    painter.fillRect(QRect(0, 6*size/7+1, size, size/7), m_brush.color());
     painter.end();
 
     m_pBrushColorToolButton->popup()->hide();
 }
 
 void DrawPad::updateView()
 {
     uint pagePosition = m_pDrawPadCanvas->pagePosition();
     uint pageCount = m_pDrawPadCanvas->pageCount();
 
     setCaption( tr( "DrawPad - Page %1/%2" ).arg( pagePosition ).arg( pageCount ) );
 
     m_pUndoAction->setEnabled(m_pDrawPadCanvas->currentPage()->undoEnabled());
     m_pRedoAction->setEnabled(m_pDrawPadCanvas->currentPage()->redoEnabled());
 
     m_pFirstPageAction->setEnabled(m_pDrawPadCanvas->goPreviousPageEnabled());
     m_pPreviousPageAction->setEnabled(m_pDrawPadCanvas->goPreviousPageEnabled());
     m_pNextPageAction->setEnabled(m_pDrawPadCanvas->goNextPageEnabled());
     m_pLastPageAction->setEnabled(m_pDrawPadCanvas->goNextPageEnabled());
 }
 
 void DrawPad::deleteAll()
 {
     QMessageBox messageBox(tr("Delete All"), tr("Do you want to delete\nall the pages?"),
                            QMessageBox::Information, QMessageBox::Yes,
                            QMessageBox::No | QMessageBox::Escape | QMessageBox::Default,
                            QMessageBox::NoButton, this);
 
     messageBox.setButtonText(QMessageBox::Yes, tr("Yes"));
     messageBox.setButtonText(QMessageBox::No, tr("No"));
 
     if (messageBox.exec() == QMessageBox::Yes) {
         m_pDrawPadCanvas->deleteAll();
     }
 }
 
 void DrawPad::importPage()
 {
     ImportDialog importDialog(this);
 
     if ( QPEApplication::execDialog( &importDialog ) == QDialog::Accepted ) {
         const DocLnk* docLnk = importDialog.selected();
 
         if (docLnk) {
             m_pDrawPadCanvas->importPage(docLnk->file());
             delete docLnk;
         }
     }
diff --git a/noncore/graphics/drawpad/thumbnailview.cpp b/noncore/graphics/drawpad/thumbnailview.cpp
index 1ccf484..d190ffe 100644
--- a/noncore/graphics/drawpad/thumbnailview.cpp
+++ b/noncore/graphics/drawpad/thumbnailview.cpp
@@ -1,70 +1,71 @@
 /***************************************************************************
  *                                                                         *
  *   DrawPad - a drawing program for Opie Environment                      *
  *                                                                         *
  *   (C) 2002 by S. Prud'homme <prudhomme@laposte.net>                     *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 
 #include "thumbnailview.h"
 
 #include "drawpad.h"
 #include "drawpadcanvas.h"
 #include "newpagedialog.h"
 #include "page.h"
 
+#include <opie2/oresource.h>
+
 #include <qpe/config.h>
-#include <qpe/resource.h>
 #include <qpe/timestring.h>
 
 #include <qapplication.h>
 #include <qlayout.h>
 #include <qmessagebox.h>
 #include <qtoolbutton.h>
 #include <qwhatsthis.h>
 
 #define THUMBNAIL_SIZE 48
 
 PageListBoxItem::PageListBoxItem(Page* page, QListBox* parent)
     : QListBoxItem(parent)
 {
     m_pPage = page;
 
     QImage image = m_pPage->pixmap()->convertToImage();
 
     int previewWidth = THUMBNAIL_SIZE;
     int previewHeight = THUMBNAIL_SIZE;
 
     float widthScale = 1.0;
     float heightScale = 1.0;
 
     if (previewWidth < image.width()) {
         widthScale = (float)previewWidth / float(image.width());
     }
 
     if (previewHeight < image.height()) {
         heightScale = (float)previewHeight / float(image.height());
     }
 
     float scale = (widthScale < heightScale ? widthScale : heightScale);
     QImage thumbnailImage = image.smoothScale((int)(image.width() * scale) , (int)(image.height() * scale));
 
     m_thumbnail.convertFromImage(thumbnailImage);
 
     m_titleText = QObject::tr( "Title: %1" ).arg( m_pPage->title() );
     m_dimensionText = QObject::tr( "Dimension: %1x%2" ).
                         arg( m_pPage->pixmap()->width() ).
                         arg( m_pPage->pixmap()->height() );
     m_dateText = QObject::tr( "Date: %1" ).arg( dateTimeString(m_pPage->lastModified()) );
 
     QColor baseColor = parent->colorGroup().base();
     int h, s, v;
     baseColor.hsv(&h, &s, &v);
 
     if (v > 128) {
         m_alternateColor = baseColor.dark(115);
@@ -194,122 +195,129 @@ void PageListBox::updateView()
         }
         
         select(m_pDrawPadCanvas->currentPage());
     }
 }
 
 void PageListBox::select(Page* page)
 {
     uint i = 0;
     uint itemCount = count();
 
     while (i < itemCount) {
         PageListBoxItem* currentItem = (PageListBoxItem*)item(i);
 
         if (currentItem->page() == page) {
             setCurrentItem(currentItem);
             break;
         }
 
         i++;
     }
 }
 
 Page* PageListBox::selected() const
 {
     Page* page;
 
     PageListBoxItem* selectedItem = (PageListBoxItem*)item(currentItem());
 
     if (selectedItem) {
         page = selectedItem->page();
     } else {
         page = NULL;
     }
 
     return page;
 }
 
 ThumbnailView::ThumbnailView(DrawPad* drawPad, DrawPadCanvas* drawPadCanvas, QWidget* parent, const char* name)
     : QWidget(parent, name, Qt::WType_Modal | Qt::WType_TopLevel | Qt::WStyle_ContextHelp)
 {
     inLoop = false;
 
     m_pDrawPad = drawPad;
     m_pDrawPadCanvas = drawPadCanvas;
 
     setCaption(tr("DrawPad - Thumbnail View"));
 
+    bool useBigIcon = qApp->desktop()->size().width() > 330;
+
     QToolButton* newPageButton = new QToolButton(this);
-    newPageButton->setIconSet(Resource::loadIconSet("new"));
+    newPageButton->setUsesBigPixmap( useBigIcon );
+    newPageButton->setPixmap(Opie::Core::OResource::loadPixmap("new", Opie::Core::OResource::SmallIcon));
     newPageButton->setAutoRaise(true);
     connect(newPageButton, SIGNAL(clicked()), this, SLOT(newPage()));
     QWhatsThis::add( newPageButton, tr( "Click here to add a new sheet." ) );
 
     QToolButton* clearPageButton = new QToolButton(this);
-    clearPageButton->setIconSet(Resource::loadIconSet("drawpad/clear"));
+    clearPageButton->setUsesBigPixmap( useBigIcon );
+    clearPageButton->setPixmap(Opie::Core::OResource::loadPixmap("drawpad/clear", Opie::Core::OResource::SmallIcon));
     clearPageButton->setAutoRaise(true);
     connect(clearPageButton, SIGNAL(clicked()), this, SLOT(clearPage()));
     QWhatsThis::add( clearPageButton, tr( "Click here to erase the current sheet." ) );
 
     QToolButton* deletePageButton = new QToolButton(this);
-    deletePageButton->setIconSet(Resource::loadIconSet("trash"));
+    deletePageButton->setUsesBigPixmap( useBigIcon );
+    deletePageButton->setPixmap(Opie::Core::OResource::loadPixmap("trash", Opie::Core::OResource::SmallIcon));
     deletePageButton->setAutoRaise(true);
     connect(deletePageButton, SIGNAL(clicked()), this, SLOT(deletePage()));
     QWhatsThis::add( deletePageButton, tr( "Click here to remove the current sheet." ) );
 
     m_pMovePageUpButton = new QToolButton(this);
-    m_pMovePageUpButton->setIconSet(Resource::loadIconSet("up"));
+    m_pMovePageUpButton->setUsesBigPixmap( useBigIcon );
+    m_pMovePageUpButton->setPixmap(Opie::Core::OResource::loadPixmap("up", Opie::Core::OResource::SmallIcon));
     m_pMovePageUpButton->setAutoRaise(true);
     connect(m_pMovePageUpButton, SIGNAL(clicked()), this, SLOT(movePageUp()));
     QWhatsThis::add( m_pMovePageUpButton, tr( "Click here to move the current sheet up one position in the list." ) );
-    
+
     m_pMovePageDownButton = new QToolButton(this);
-    m_pMovePageDownButton->setIconSet(Resource::loadIconSet("down"));
+    m_pMovePageDownButton->setUsesBigPixmap( useBigIcon );
+    m_pMovePageDownButton->setPixmap(Opie::Core::OResource::loadPixmap("down", Opie::Core::OResource::SmallIcon));
     m_pMovePageDownButton->setAutoRaise(true);
     connect(m_pMovePageDownButton, SIGNAL(clicked()), this, SLOT(movePageDown()));
     QWhatsThis::add( m_pMovePageDownButton, tr( "Click here to move the current sheet down one position in the list." ) );
 
     m_pPageListBox = new PageListBox(m_pDrawPadCanvas, this);
     connect(m_pPageListBox, SIGNAL(selectionChanged()), this, SLOT(changePage()));
 
     QVBoxLayout* mainLayout = new QVBoxLayout(this, 4, 4);
     QHBoxLayout* buttonLayout = new QHBoxLayout(0);
 
     buttonLayout->addWidget(newPageButton);
     buttonLayout->addWidget(clearPageButton);
     buttonLayout->addWidget(deletePageButton);
     buttonLayout->addStretch();
     buttonLayout->addWidget(m_pMovePageUpButton);
     buttonLayout->addWidget(m_pMovePageDownButton);
 
     mainLayout->addLayout(buttonLayout);
     mainLayout->addWidget(m_pPageListBox);
 
     updateView();
 }
 
 ThumbnailView::~ThumbnailView()
 {
     hide();
 }
 
 void ThumbnailView::updateView()
 {
     m_pMovePageUpButton->setEnabled(m_pDrawPadCanvas->goPreviousPageEnabled());
     m_pMovePageDownButton->setEnabled(m_pDrawPadCanvas->goNextPageEnabled());
 }
 
 void ThumbnailView::hide()
 {
     QWidget::hide();
 
     if (inLoop) {
         inLoop = false;
         qApp->exit_loop();
     }
 }
 
 void ThumbnailView::exec()
 {
     show();