Add application config

4 files changed, 54 insertions, 5 deletions

diff --git a/noncore/graphics/drawpad/drawpad.cpp b/noncore/graphics/drawpad/drawpad.cpp
index b29f5ba..4eb47a5 100644
--- a/noncore/graphics/drawpad/drawpad.cpp
+++ b/noncore/graphics/drawpad/drawpad.cpp
@@ -1,621 +1,650 @@
 /***************************************************************************
  *                                                                         *
  *   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 <opie/colordialog.h>
 #include <opie/colorpopupmenu.h>
 
 #include <qpe/applnk.h>
+#include <qpe/config.h>
 #include <qpe/global.h>
 #include <qpe/qpemenubar.h>
 #include <qpe/qpetoolbar.h>
 #include <qpe/resource.h>
 
 #include <qaction.h>
 #include <qfile.h>
 #include <qmessagebox.h>
 #include <qpainter.h>
 #include <qspinbox.h>
 #include <qtoolbutton.h>
 #include <qtooltip.h>
 
 DrawPad::DrawPad(QWidget* parent, const char* name)
     : QMainWindow(parent, name)
 {
     // init members
 
     m_pDrawPadCanvas = new DrawPadCanvas(this, this);
 
     connect(m_pDrawPadCanvas, SIGNAL(pagesChanged()), this, SLOT(updateNavigationToolButtons()));
     connect(m_pDrawPadCanvas, SIGNAL(pagesChanged()), this, SLOT(updateCaption()));
     connect(m_pDrawPadCanvas, SIGNAL(pageBackupsChanged()), this, SLOT(updateUndoRedoToolButtons()));
 
     setCentralWidget(m_pDrawPadCanvas);
 
     // init menu
 
     setToolBarsMovable(false);
 
     QPEToolBar* menuToolBar = new QPEToolBar(this);
     QPEMenuBar* menuBar = new QPEMenuBar(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
 
     QPEToolBar* pageToolBar = new QPEToolBar(this);
 
     QAction* newPageAction = new QAction(tr("New Page"), Resource::loadIconSet("new"), QString::null, 0, this);
     connect(newPageAction, SIGNAL(activated()), this, SLOT(newPage()));
     newPageAction->addTo(pageToolBar);
 
     QAction* clearPageAction = new QAction(tr("Clear Page"), Resource::loadIconSet("drawpad/clear"), QString::null, 0, this);
     connect(clearPageAction, SIGNAL(activated()), this, SLOT(clearPage()));
     clearPageAction->addTo(pageToolBar);
 
     QAction* deletePageAction = new QAction(tr("Delete Page"), Resource::loadIconSet("trash"), QString::null, 0, this);
     connect(deletePageAction, SIGNAL(activated()), this, SLOT(deletePage()));
     deletePageAction->addTo(pageToolBar);
 
     QPEToolBar* emptyToolBar = new QPEToolBar(this);
     emptyToolBar->setHorizontalStretchable(true);
 
     // init navigation toolbar
 
     QPEToolBar* navigationToolBar = new QPEToolBar(this);
 
     m_pUndoAction = new QAction(tr("Undo"), Resource::loadIconSet("drawpad/undo"), QString::null, 0, this);
     connect(m_pUndoAction, SIGNAL(activated()), m_pDrawPadCanvas, SLOT(undo()));
     m_pUndoAction->addTo(navigationToolBar);
 
     m_pRedoAction = new QAction(tr("Redo"), Resource::loadIconSet("drawpad/redo"), QString::null, 0, this);
     connect(m_pRedoAction, SIGNAL(activated()), m_pDrawPadCanvas, SLOT(redo()));
     m_pRedoAction->addTo(navigationToolBar);
 
     m_pFirstPageAction = new QAction(tr("First Page"), Resource::loadIconSet("fastback"), QString::null, 0, this);
     connect(m_pFirstPageAction, SIGNAL(activated()), m_pDrawPadCanvas, SLOT(goFirstPage()));
     m_pFirstPageAction->addTo(navigationToolBar);
 
     m_pPreviousPageAction = new QAction(tr("Previous Page"), Resource::loadIconSet("back"), QString::null, 0, this);
     connect(m_pPreviousPageAction, SIGNAL(activated()), m_pDrawPadCanvas, SLOT(goPreviousPage()));
     m_pPreviousPageAction->addTo(navigationToolBar);
 
     m_pNextPageAction = new QAction(tr("Next Page"), Resource::loadIconSet("forward"), QString::null, 0, this);
     connect(m_pNextPageAction, SIGNAL(activated()), m_pDrawPadCanvas, SLOT(goNextPage()));
     m_pNextPageAction->addTo(navigationToolBar);
 
     m_pLastPageAction = new QAction(tr("Last Page"), Resource::loadIconSet("fastforward"), QString::null, 0, this);
     connect(m_pLastPageAction, SIGNAL(activated()), m_pDrawPadCanvas, SLOT(goLastPage()));
     m_pLastPageAction->addTo(navigationToolBar);
 
     // init draw mode toolbar
 
     QPEToolBar* drawModeToolBar = new QPEToolBar(this);
 
     m_pLineToolButton = new QToolButton(drawModeToolBar);
     m_pLineToolButton->setToggleButton(true);
 
     QPopupMenu* linePopupMenu = new QPopupMenu(m_pLineToolButton);
 
     m_pPointToolAction = new QAction(tr("Draw Point"), Resource::loadIconSet("drawpad/point.png"), "", 0, this);
     connect(m_pPointToolAction, SIGNAL(activated()), this, SLOT(setPointTool()));
     m_pPointToolAction->addTo(linePopupMenu);
 
     m_pLineToolAction = new QAction(tr("Draw Line"), Resource::loadIconSet("drawpad/line.png"), "", 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);
 
     QPopupMenu* rectanglePopupMenu = new QPopupMenu(m_pRectangleToolButton);
 
     m_pRectangleToolAction = new QAction(tr("Draw Rectangle"), Resource::loadIconSet("drawpad/rectangle.png"), "", 0, this);
     connect(m_pRectangleToolAction, SIGNAL(activated()), this, SLOT(setRectangleTool()));
     m_pRectangleToolAction->addTo(rectanglePopupMenu);
 
     m_pFilledRectangleToolAction = new QAction(tr("Draw Filled Rectangle"), Resource::loadIconSet("drawpad/filledrectangle.png"), "", 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);
 
     QPopupMenu* ellipsePopupMenu = new QPopupMenu(m_pEllipseToolButton);
 
     m_pEllipseToolAction = new QAction(tr("Draw Ellipse"), Resource::loadIconSet("drawpad/ellipse.png"), "", 0, this);
     connect(m_pEllipseToolAction, SIGNAL(activated()), this, SLOT(setEllipseTool()));
     m_pEllipseToolAction->addTo(ellipsePopupMenu);
 
     m_pFilledEllipseToolAction = new QAction(tr("Draw Filled Ellipse"), Resource::loadIconSet("drawpad/filledellipse.png"), "", 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::loadIconSet("drawpad/text.png"), QString::null, 0, this);
     m_pTextToolAction->setToggleAction(true);
     connect(m_pTextToolAction, SIGNAL(activated()), this, SLOT(setTextTool()));
     m_pTextToolAction->addTo(drawModeToolBar);
 
     m_pFillToolAction = new QAction(tr("Fill Region"), Resource::loadIconSet("drawpad/fill.png"), QString::null, 0, this);
     m_pFillToolAction->setToggleAction(true);
     connect(m_pFillToolAction, SIGNAL(activated()), this, SLOT(setFillTool()));
     m_pFillToolAction->addTo(drawModeToolBar);
 
     m_pEraseToolAction = new QAction(tr("Erase Point"), Resource::loadIconSet("drawpad/erase.png"), QString::null, 0, this);
     m_pEraseToolAction->setToggleAction(true);
     connect(m_pEraseToolAction, SIGNAL(activated()), this, SLOT(setEraseTool()));
     m_pEraseToolAction->addTo(drawModeToolBar);
 
     m_pTool = 0;
     setRectangleTool();
     setEllipseTool();
     setPointTool();
 
     emptyToolBar = new QPEToolBar(this);
     emptyToolBar->setHorizontalStretchable(true);
     emptyToolBar->addSeparator();
 
     // init draw parameters toolbar
 
     QPEToolBar* drawParametersToolBar = new QPEToolBar(this);
 
-    QSpinBox* penWidthSpinBox = new QSpinBox(1, 9, 1, drawParametersToolBar);
-    connect(penWidthSpinBox, SIGNAL(valueChanged(int)), this, SLOT(changePenWidth(int)));
+    m_pPenWidthSpinBox = new QSpinBox(1, 9, 1, drawParametersToolBar);
+    connect(m_pPenWidthSpinBox, SIGNAL(valueChanged(int)), this, SLOT(changePenWidth(int)));
 
-    QToolTip::add(penWidthSpinBox, tr("Pen Width"));
-    penWidthSpinBox->setValue(1);
-    penWidthSpinBox->setFocusPolicy(QWidget::NoFocus);
+    QToolTip::add(m_pPenWidthSpinBox, tr("Pen Width"));
+    m_pPenWidthSpinBox->setValue(1);
+    m_pPenWidthSpinBox->setFocusPolicy(QWidget::NoFocus);
 
     m_pPenColorToolButton = new QToolButton(drawParametersToolBar);
     m_pPenColorToolButton->setPixmap(Resource::loadPixmap("drawpad/pencolor.png"));
 
     ColorPopupMenu* penColorPopupMenu = new ColorPopupMenu(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.png"));
 
     ColorPopupMenu* brushColorPopupMenu = new ColorPopupMenu(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);
 
     // 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()
 {
     return (m_pAntiAliasingAction->isOn());
 }
 
 void DrawPad::newPage()
 {
     QRect rect = m_pDrawPadCanvas->contentsRect();
 
     NewPageDialog newPageDialog(rect.width(), rect.height(), m_pen.color(), m_brush.color(), this);
 
     if (newPageDialog.exec() == QDialog::Accepted) {
         m_pDrawPadCanvas->newPage(newPageDialog.selectedTitle(), newPageDialog.selectedWidth(),
                                   newPageDialog.selectedHeight(), newPageDialog.selectedColor());
     }
 }
 
 void DrawPad::clearPage()
 {
     QMessageBox messageBox(tr("Clear Page"), tr("Do you want to clear\nthe current page?"),
                            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->clearPage();
     }
 }
 
 void DrawPad::deletePage()
 {
     QMessageBox messageBox(tr("Delete Page"), tr("Do you want to delete\nthe current page?"),
                            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->deletePage();
     }
 }
 
 void DrawPad::setPointTool()
 {
     if (m_pTool) {
         delete m_pTool;
     }
 
     m_pTool = new PointTool(this, m_pDrawPadCanvas);
 
     m_pLineToolButton->setIconSet(m_pPointToolAction->iconSet());
     QToolTip::add(m_pLineToolButton, m_pPointToolAction->text());
 
     disconnect(m_pLineToolButton, SIGNAL(clicked()), 0, 0);
     connect(m_pLineToolButton, SIGNAL(clicked()), m_pPointToolAction, SIGNAL(activated()));
 
     m_pLineToolButton->setOn(true);
     m_pRectangleToolButton->setOn(false);
     m_pEllipseToolButton->setOn(false);
     m_pTextToolAction->setOn(false);
     m_pFillToolAction->setOn(false);
     m_pEraseToolAction->setOn(false);
 }
 
 void DrawPad::setLineTool()
 {
     if (m_pTool) {
         delete m_pTool;
     }
 
     m_pTool = new LineTool(this, m_pDrawPadCanvas);
 
     m_pLineToolButton->setIconSet(m_pLineToolAction->iconSet());
     QToolTip::add(m_pLineToolButton, m_pLineToolAction->text());
 
     disconnect(m_pLineToolButton, SIGNAL(clicked()), 0, 0);
     connect(m_pLineToolButton, SIGNAL(clicked()), m_pLineToolAction, SIGNAL(activated()));
 
     m_pLineToolButton->setOn(true);
     m_pRectangleToolButton->setOn(false);
     m_pEllipseToolButton->setOn(false);
     m_pTextToolAction->setOn(false);
     m_pFillToolAction->setOn(false);
     m_pEraseToolAction->setOn(false);
 }
 
 void DrawPad::setRectangleTool()
 {
     if (m_pTool) {
         delete m_pTool;
     }
 
     m_pTool = new RectangleTool(this, m_pDrawPadCanvas);
 
     m_pRectangleToolButton->setIconSet(m_pRectangleToolAction->iconSet());
     QToolTip::add(m_pRectangleToolButton, m_pRectangleToolAction->text());
 
     disconnect(m_pRectangleToolButton, SIGNAL(clicked()), 0, 0);
     connect(m_pRectangleToolButton, SIGNAL(clicked()), m_pRectangleToolAction, SIGNAL(activated()));
 
     m_pLineToolButton->setOn(false);
     m_pRectangleToolButton->setOn(true);
     m_pEllipseToolButton->setOn(false);
     m_pTextToolAction->setOn(false);
     m_pFillToolAction->setOn(false);
     m_pEraseToolAction->setOn(false);
 }
 
 void DrawPad::setFilledRectangleTool()
 {
     if (m_pTool) {
         delete m_pTool;
     }
 
     m_pTool = new FilledRectangleTool(this, m_pDrawPadCanvas);
 
     m_pRectangleToolButton->setIconSet(m_pFilledRectangleToolAction->iconSet());
     QToolTip::add(m_pRectangleToolButton, m_pFilledRectangleToolAction->text());
 
     disconnect(m_pRectangleToolButton, SIGNAL(clicked()), 0, 0);
     connect(m_pRectangleToolButton, SIGNAL(clicked()), m_pFilledRectangleToolAction, SIGNAL(activated()));
 
     m_pLineToolButton->setOn(false);
     m_pRectangleToolButton->setOn(true);
     m_pEllipseToolButton->setOn(false);
     m_pTextToolAction->setOn(false);
     m_pFillToolAction->setOn(false);
     m_pEraseToolAction->setOn(false);
 }
 
 void DrawPad::setEllipseTool()
 {
     if (m_pTool) {
         delete m_pTool;
     }
 
     m_pTool = new EllipseTool(this, m_pDrawPadCanvas);
 
     m_pEllipseToolButton->setIconSet(m_pEllipseToolAction->iconSet());
     QToolTip::add(m_pEllipseToolButton, m_pEllipseToolAction->text());
 
     disconnect(m_pEllipseToolButton, SIGNAL(clicked()), 0, 0);
     connect(m_pEllipseToolButton, SIGNAL(clicked()), m_pEllipseToolAction, SIGNAL(activated()));
 
     m_pLineToolButton->setOn(false);
     m_pRectangleToolButton->setOn(false);
     m_pEllipseToolButton->setOn(true);
     m_pTextToolAction->setOn(false);
     m_pFillToolAction->setOn(false);
     m_pEraseToolAction->setOn(false);
 }
 
 void DrawPad::setFilledEllipseTool()
 {
     if (m_pTool) {
         delete m_pTool;
     }
 
     m_pTool = new FilledEllipseTool(this, m_pDrawPadCanvas);
 
     m_pEllipseToolButton->setIconSet(m_pFilledEllipseToolAction->iconSet());
     QToolTip::add(m_pEllipseToolButton, m_pFilledEllipseToolAction->text());
 
     disconnect(m_pEllipseToolButton, SIGNAL(clicked()), 0, 0);
     connect(m_pEllipseToolButton, SIGNAL(clicked()), m_pFilledEllipseToolAction, SIGNAL(activated()));
 
     m_pLineToolButton->setOn(false);
     m_pRectangleToolButton->setOn(false);
     m_pEllipseToolButton->setOn(true);
     m_pTextToolAction->setOn(false);
     m_pFillToolAction->setOn(false);
     m_pEraseToolAction->setOn(false);
 }
 
 void DrawPad::setTextTool()
 {
     if (m_pTool) {
         delete m_pTool;
     }
 
     m_pTool = new TextTool(this, m_pDrawPadCanvas);
 
     m_pLineToolButton->setOn(false);
     m_pRectangleToolButton->setOn(false);
     m_pEllipseToolButton->setOn(false);
     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());
     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());
     painter.end();
  
     m_pBrushColorToolButton->popup()->hide();
 }
 
 void DrawPad::updateUndoRedoToolButtons()
 {
     m_pUndoAction->setEnabled(m_pDrawPadCanvas->undoEnabled());
     m_pRedoAction->setEnabled(m_pDrawPadCanvas->redoEnabled());
 }
 
 void DrawPad::updateNavigationToolButtons()
 {
     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::updateCaption()
 {
     uint pagePosition = m_pDrawPadCanvas->pagePosition();
     uint pageCount = m_pDrawPadCanvas->pageCount();
 
     setCaption(tr("DrawPad") + " - " + tr("Page") + " "
                + QString::number(pagePosition) + "/" + QString::number(pageCount));
 }
 
 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);
 
     importDialog.showMaximized();
 
     if (importDialog.exec() == QDialog::Accepted) {
         const DocLnk* docLnk = importDialog.selected();
 
         if (docLnk) {
             m_pDrawPadCanvas->importPage(docLnk->file());
             delete docLnk;
         }
     }
 }
 
 void DrawPad::exportPage()
 {
     ExportDialog exportDialog(m_pDrawPadCanvas->pagePosition(), m_pDrawPadCanvas->pageCount(), this);
 
     exportDialog.showMaximized();
 
     if (exportDialog.exec() == QDialog::Accepted) {
         m_pDrawPadCanvas->exportPage(exportDialog.selectedFromPage(), exportDialog.selectedToPage(),
                                      exportDialog.selectedName(), exportDialog.selectedFormat());
     }
 }
 
 void DrawPad::thumbnailView()
 {
     ThumbnailView thumbnailView(this, m_pDrawPadCanvas, this);
 
     thumbnailView.showMaximized();
     thumbnailView.exec();
 }
 
 void DrawPad::pageInformation()
 {
     PageInformationDialog pageInformationDialog(m_pDrawPadCanvas->currentPage());
 
     if (pageInformationDialog.exec() == QDialog::Accepted) {
         m_pDrawPadCanvas->currentPage()->setTitle(pageInformationDialog.selectedTitle());
     }
 }
+
+void DrawPad::loadConfig()
+{
+    Config config("drawpad");
+    config.setGroup("General");
+
+    m_pAntiAliasingAction->setOn(config.readBoolEntry("AntiAliasing", false));
+    m_pPenWidthSpinBox->setValue(config.readNumEntry("PenWidth", 1));
+    changePenColor(QColor(config.readEntry("PenColor", Qt::black.name())));
+    changeBrushColor(QColor(config.readEntry("BrushColor", Qt::white.name())));
+    m_pDrawPadCanvas->selectPage(config.readNumEntry("PagePosition", 1));
+}
+
+void DrawPad::saveConfig()
+{
+    Config config("drawpad");
+    config.setGroup("General");
+
+    config.writeEntry("PagePosition", (int)m_pDrawPadCanvas->pagePosition());
+    config.writeEntry("AntiAliasing", antiAliasing());
+    config.writeEntry("PenWidth", (int)m_pen.width());
+    config.writeEntry("PenColor", m_pen.color().name());
+    config.writeEntry("BrushColor", m_brush.color().name());
+}
diff --git a/noncore/graphics/drawpad/drawpad.h b/noncore/graphics/drawpad/drawpad.h
index 8e29c61..c57606c 100644
--- a/noncore/graphics/drawpad/drawpad.h
+++ b/noncore/graphics/drawpad/drawpad.h
@@ -1,106 +1,112 @@
 /***************************************************************************
  *                                                                         *
  *   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.                                   *
  *                                                                         *
  ***************************************************************************/
 
 #ifndef DRAWPAD_H
 #define DRAWPAD_H
 
 #include <qmainwindow.h>
 
 #include <qpen.h>
 
 class DrawPadCanvas;
 class Tool;
 
 class QAction;
 class QColor;
+class QSpinBox;
 class QToolButton;
 class QWidgetStack;
 
 class DrawPad : public QMainWindow
 {
     Q_OBJECT
 
 public:
     DrawPad(QWidget* parent = 0, const char* name = 0);
     ~DrawPad();
 
     Tool* tool() { return m_pTool; }
     QPen pen() { return m_pen; }
     QBrush brush() { return m_brush; }
 
     bool antiAliasing();
 
 private slots:
     void newPage();
     void clearPage();
     void deletePage();
 
     void setPointTool();
     void setLineTool();
     void setRectangleTool();
     void setFilledRectangleTool();
     void setEllipseTool();
     void setFilledEllipseTool();
     void setTextTool();
     void setFillTool();
     void setEraseTool();
 
     void changePenWidth(int value);
     void changePenColor(const QColor& color);
     void changeBrushColor(const QColor& color);
 
     void updateUndoRedoToolButtons();
     void updateNavigationToolButtons();
     void updateCaption();
 
     void deleteAll();
     void importPage();
     void exportPage();
     void thumbnailView();
     void pageInformation();
 
 private:
+    void loadConfig();
+    void saveConfig();
+
     DrawPadCanvas* m_pDrawPadCanvas;
 
     Tool* m_pTool;
     QPen m_pen;
     QBrush m_brush;
 
     QAction* m_pAntiAliasingAction;
 
     QAction* m_pUndoAction;
     QAction* m_pRedoAction;
 
     QAction* m_pFirstPageAction;
     QAction* m_pPreviousPageAction;
     QAction* m_pNextPageAction;
     QAction* m_pLastPageAction;
 
     QAction* m_pPointToolAction;
     QAction* m_pLineToolAction;
     QAction* m_pRectangleToolAction;
     QAction* m_pFilledRectangleToolAction;
     QAction* m_pEllipseToolAction;
     QAction* m_pFilledEllipseToolAction;
     QAction* m_pTextToolAction;
     QAction* m_pFillToolAction;
     QAction* m_pEraseToolAction;
 
     QToolButton* m_pLineToolButton;
     QToolButton* m_pRectangleToolButton;
     QToolButton* m_pEllipseToolButton;
     QToolButton* m_pPenColorToolButton;
     QToolButton* m_pBrushColorToolButton;
+
+    QSpinBox* m_pPenWidthSpinBox;
 };
 
 #endif // DRAWPAD_H
diff --git a/noncore/graphics/drawpad/drawpadcanvas.cpp b/noncore/graphics/drawpad/drawpadcanvas.cpp
index 5437068..05dd408 100644
--- a/noncore/graphics/drawpad/drawpadcanvas.cpp
+++ b/noncore/graphics/drawpad/drawpadcanvas.cpp
@@ -1,569 +1,582 @@
 /***************************************************************************
  *                                                                         *
  *   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 "drawpadcanvas.h"
 
 #include "drawpad.h"
 #include "page.h"
 #include "tool.h"
 
 #include <qpe/applnk.h>
 #include <qpe/filemanager.h>
 #include <qpe/mimetype.h>
 
 #include <qbuffer.h>
 #include <qimage.h>
 #include <qpainter.h>
 #include <qtextcodec.h>
 #include <qtextstream.h>
 #include <qxml.h>
 
 const int PAGE_BACKUPS = 99;
 
 class DrawPadCanvasXmlHandler: public QXmlDefaultHandler
 {
 public:
     DrawPadCanvasXmlHandler();
     ~DrawPadCanvasXmlHandler();
 
     QList<Page> pages();
 
     bool startElement(const QString& namespaceURI, const QString& localName,
                       const QString& qName, const QXmlAttributes& atts);
     bool endElement(const QString& namespaceURI, const QString& localName,
                     const QString& qName);
     bool characters(const QString& ch);
 
 private:
     enum State {
         Unknown,
         InTitle,
         InDate,
         InData
     };
 
     State m_state;
     QString m_title;
     QDateTime m_date;
     ulong m_dataLenght;
     QString m_dataFormat;
     QList<Page> m_pages;
 };
 
 DrawPadCanvasXmlHandler::DrawPadCanvasXmlHandler()
 {
     m_state = Unknown;
 }
 
 DrawPadCanvasXmlHandler::~DrawPadCanvasXmlHandler()
 {
 }
 
 QList<Page> DrawPadCanvasXmlHandler::pages()
 {
     return m_pages;
 }
 
 bool DrawPadCanvasXmlHandler::startElement(const QString& namespaceURI, const QString& localName,
                                            const QString& qName, const QXmlAttributes& atts)
 {
     Q_CONST_UNUSED(namespaceURI)
     Q_CONST_UNUSED(localName)
 
     if (qName == "image") {
         m_title = QString();
         m_date = QDateTime::currentDateTime();
     } else if (qName == "title") {
         m_state = InTitle;
     } else if (qName == "date") {
         m_state = InDate;
     } else if (qName == "data") {
         m_state = InData;
         m_dataLenght = atts.value("length").toULong();
         m_dataFormat = atts.value("format");
     }
 
     return true;
 }
 
 bool DrawPadCanvasXmlHandler::endElement(const QString& namespaceURI, const QString& localName,
                                          const QString& qName)
 {
     Q_CONST_UNUSED(namespaceURI)
     Q_CONST_UNUSED(localName)
 
     if (qName == "title") {
         m_state = Unknown;
     } else if (qName == "date") {
         m_state = Unknown;
     } else if (qName == "data") {
         m_state = Unknown;
     }
 
     return true;
 }
 
 bool DrawPadCanvasXmlHandler::characters(const QString& ch)
 {
     if (m_state == InTitle) {
         m_title = ch;
     } else if (m_state == InDate) {
         m_date = QDateTime(QDate(1970, 1, 1)).addSecs(ch.toInt());
     } else if (m_state == InData) {
         QByteArray byteArray(ch.length() / 2);
 
         for (int i = 0; i < (int)ch.length() / 2; i++) {
             char h = ch[2 * i].latin1();
             char l = ch[2 * i  + 1].latin1();
             uchar r = 0;
 
             if (h <= '9') {
                 r += h - '0';
             } else {
                 r += h - 'a' + 10;
             }
 
             r = r << 4;
 
             if (l <= '9') {
                 r += l - '0';
             } else {
                 r += l - 'a' + 10;
             }
 
             byteArray[i] = r;
         }
 
         QImage image;
         image.loadFromData((const uchar*)byteArray.data(), m_dataLenght, m_dataFormat);
 
         Page* page = new Page(m_title, image.width(), image.height());
         page->setLastModified(m_date);
         page->convertFromImage(image);
         m_pages.append(page);
     }
 
     return true;
 }
 
 DrawPadCanvas::DrawPadCanvas(DrawPad* drawPad, QWidget* parent, const char* name)
     : QScrollView(parent, name)
 {
     m_pDrawPad = drawPad;
     m_pages.setAutoDelete(true);
     m_pageBackups.setAutoDelete(true);
 
     viewport()->setBackgroundMode(QWidget::NoBackground);
 }
 
 DrawPadCanvas::~DrawPadCanvas()
 {
 }
 
 void DrawPadCanvas::load(QIODevice* ioDevice)
 {
     QTextStream textStream(ioDevice);
     textStream.setCodec(QTextCodec::codecForName("UTF-8"));
 
     QXmlInputSource xmlInputSource(textStream);
     QXmlSimpleReader xmlSimpleReader;
     DrawPadCanvasXmlHandler drawPadCanvasXmlHandler;
 
     xmlSimpleReader.setContentHandler(&drawPadCanvasXmlHandler);
     xmlSimpleReader.parse(xmlInputSource);
 
     m_pages = drawPadCanvasXmlHandler.pages();
 
     if (m_pages.isEmpty()) {
         m_pages.append(new Page("", contentsRect().size()));
         m_pages.current()->fill(Qt::white);
     }
 
     m_pageBackups.clear();
     m_pageBackups.append(new Page(*(m_pages.current())));
 
     resizeContents(m_pages.current()->width(), m_pages.current()->height());
     viewport()->update();
 
     emit pagesChanged();
     emit pageBackupsChanged();
 }
 
 void DrawPadCanvas::initialPage()
 {
     m_pages.append(new Page("", 236, 232));
     m_pages.current()->fill(Qt::white);
 
     m_pageBackups.clear();
     m_pageBackups.append(new Page(*(m_pages.current())));
 
     resizeContents(m_pages.current()->width(), m_pages.current()->height());
     viewport()->update();
 
     emit pagesChanged();
     emit pageBackupsChanged();
 }
 
 void DrawPadCanvas::save(QIODevice* ioDevice)
 {
     QTextStream textStream(ioDevice);
     textStream.setCodec(QTextCodec::codecForName("UTF-8"));
 
     textStream << "<drawpad>" << endl;
     textStream << "    <images>" << endl;
 
     QListIterator<Page> bufferIterator(m_pages);
 
     for (bufferIterator.toFirst(); bufferIterator.current() != 0; ++bufferIterator) {
         textStream << "        <image>" << endl;
         textStream << "            <title>" << bufferIterator.current()->title() << "</title>" << endl;
         
         int intDate = QDateTime(QDate(1970, 1, 1)).secsTo(bufferIterator.current()->lastModified());
         textStream << "            <date>" << intDate << "</date>" << endl;
 
         QImage image = bufferIterator.current()->convertToImage();
         QByteArray byteArray;
         QBuffer buffer(byteArray);
         QImageIO imageIO(&buffer, "PNG");
 
         buffer.open(IO_WriteOnly);
         imageIO.setImage(image);
         imageIO.write();
         buffer.close();
 
         textStream << "            <data length=\"" << byteArray.size() << "\" format=\"PNG\">";
 
         static const char hexchars[] = "0123456789abcdef";
 
         for (int i = 0; i < (int)byteArray.size(); i++ ) {
             uchar s = (uchar)byteArray[i];
             textStream << hexchars[s >> 4];
             textStream << hexchars[s & 0x0f];
         }
 
         textStream << "</data>" << endl;
         textStream << "        </image>" << endl;
     }
 
     textStream << "    </images>" << endl;
     textStream << "</drawpad>";
 }
 
 void DrawPadCanvas::importPage(const QString& fileName)
 {
     Page* importedPage = new Page();
 
     importedPage->load(fileName);
     m_pages.insert(m_pages.at() + 1, importedPage);
 
     m_pageBackups.clear();
     m_pageBackups.append(new Page(*(m_pages.current())));
 
     resizeContents(m_pages.current()->width(), m_pages.current()->height());
     viewport()->update();
 
     emit pagesChanged();
     emit pageBackupsChanged();
 }
 
 void DrawPadCanvas::exportPage(uint fromPage, uint toPage, const QString& name,const QString& format)
 {
     if (fromPage == toPage) {
         DocLnk docLnk;
         MimeType mimeType(format);
 
         docLnk.setName(name);
         docLnk.setType(mimeType.id());
 
         FileManager fileManager;
         QIODevice* ioDevice = fileManager.saveFile(docLnk);
         QImageIO imageIO(ioDevice, format);
 
         QImage image = m_pages.current()->convertToImage();
         imageIO.setImage(image);
         imageIO.write();
         delete ioDevice;
     } else {
         for (uint i = fromPage; i <= toPage; i++) {
             DocLnk docLnk;
             MimeType mimeType(format);
 
             docLnk.setName(name + QString::number(i));
             docLnk.setType(mimeType.id());
 
             FileManager fileManager;
             QIODevice* ioDevice = fileManager.saveFile(docLnk);
             QImageIO imageIO(ioDevice, format);
 
             QImage image = m_pages.at(i - 1)->convertToImage();
             imageIO.setImage(image);
             imageIO.write();
             delete ioDevice;
         }
     }
 }
 
 Page* DrawPadCanvas::currentPage()
 {
     return m_pages.current();
 }
 
 QList<Page> DrawPadCanvas::pages()
 {
     return m_pages;
 }
 
 uint DrawPadCanvas::pagePosition()
 {
     return (m_pages.at() + 1);
 }
 
 uint DrawPadCanvas::pageCount()
 {
     return m_pages.count();
 }
 
 void DrawPadCanvas::selectPage(Page* page)
 {
     m_pages.findRef(page);
     m_pageBackups.clear();
     m_pageBackups.append(new Page(*(m_pages.current())));
 
     resizeContents(m_pages.current()->width(), m_pages.current()->height());
     viewport()->update();
 
     emit pagesChanged();
     emit pageBackupsChanged();
 }
 
+void DrawPadCanvas::selectPage(uint pagePosition)
+{
+    m_pages.at(pagePosition - 1);
+    m_pageBackups.clear();
+    m_pageBackups.append(new Page(*(m_pages.current())));
+
+    resizeContents(m_pages.current()->width(), m_pages.current()->height());
+    viewport()->update();
+
+    emit pagesChanged();
+    emit pageBackupsChanged();
+}
+
 void DrawPadCanvas::backupPage()
 {
     m_pages.current()->setLastModified(QDateTime::currentDateTime());
 
     Page* currentBackup = m_pageBackups.current();
     while (m_pageBackups.last() != currentBackup) {
         m_pageBackups.removeLast();
     }
 
     while (m_pageBackups.count() >= (PAGE_BACKUPS + 1)) {
         m_pageBackups.removeFirst();
     }
 
     m_pageBackups.append(new Page(*(m_pages.current())));
 
     emit pageBackupsChanged();
 }
 
 void DrawPadCanvas::deleteAll()
 {
     m_pages.clear();
 
     m_pages.append(new Page("", contentsRect().size()));
     m_pages.current()->fill(Qt::white);
 
     m_pageBackups.clear();
     m_pageBackups.append(new Page(*(m_pages.current())));
 
     resizeContents(m_pages.current()->width(), m_pages.current()->height());
     viewport()->update();
 
     emit pagesChanged();
     emit pageBackupsChanged();
 }
 
 void DrawPadCanvas::newPage(QString title, uint width, uint height, const QColor& color)
 {
     m_pages.insert(m_pages.at() + 1, new Page(title, width, height));
     m_pages.current()->fill(color);
 
     m_pageBackups.clear();
     m_pageBackups.append(new Page(*(m_pages.current())));
 
     resizeContents(m_pages.current()->width(), m_pages.current()->height());
     viewport()->update();
 
     emit pagesChanged();
     emit pageBackupsChanged();
 }
 
 void DrawPadCanvas::clearPage()
 {
     m_pages.current()->fill(Qt::white);
 
     m_pageBackups.clear();
     m_pageBackups.append(new Page(*(m_pages.current())));
 
     resizeContents(m_pages.current()->width(), m_pages.current()->height());
     viewport()->update();
 
     emit pageBackupsChanged();
 }
 
 void DrawPadCanvas::deletePage()
 {
     m_pages.remove(m_pages.current());
 
     if (m_pages.isEmpty()) {
         m_pages.append(new Page("", contentsRect().size()));
         m_pages.current()->fill(Qt::white);
     }
 
     m_pageBackups.clear();
     m_pageBackups.append(new Page(*(m_pages.current())));
 
     resizeContents(m_pages.current()->width(), m_pages.current()->height());
     viewport()->update();
 
     emit pagesChanged();
     emit pageBackupsChanged();
 }
 
 void DrawPadCanvas::movePageUp()
 {
     int index = m_pages.at();
     Page* page = m_pages.take();
     m_pages.insert(index - 1, page);
 
     emit pagesChanged();
 }
 
 void DrawPadCanvas::movePageDown()
 {
     int index = m_pages.at();
     Page* page = m_pages.take();
     m_pages.insert(index + 1, page);
 
     emit pagesChanged();
 }
 
 bool DrawPadCanvas::undoEnabled()
 {
     return (m_pageBackups.current() != m_pageBackups.getFirst());
 }
 
 bool DrawPadCanvas::redoEnabled()
 {
     return (m_pageBackups.current() != m_pageBackups.getLast());
 }
 
 bool DrawPadCanvas::goPreviousPageEnabled()
 {
     return (m_pages.current() != m_pages.getFirst());
 }
 
 bool DrawPadCanvas::goNextPageEnabled()
 {
     return (m_pages.current() != m_pages.getLast());
 }
 
 void DrawPadCanvas::undo()
 {
     *(m_pages.current()) = *(m_pageBackups.prev());
 
     viewport()->update();
 
     emit pageBackupsChanged();
 }
 
 void DrawPadCanvas::redo()
 {
     *(m_pages.current()) = *(m_pageBackups.next());
 
     viewport()->update();
 
     emit pageBackupsChanged();
 }
 
 void DrawPadCanvas::goFirstPage()
 {
     m_pages.first();
     m_pageBackups.clear();
     m_pageBackups.append(new Page(*(m_pages.current())));
 
     resizeContents(m_pages.current()->width(), m_pages.current()->height());
     viewport()->update();
 
     emit pagesChanged();
     emit pageBackupsChanged();
 }
 
 void DrawPadCanvas::goPreviousPage()
 {
     m_pages.prev();
     m_pageBackups.clear();
     m_pageBackups.append(new Page(*(m_pages.current())));
 
     resizeContents(m_pages.current()->width(), m_pages.current()->height());
     viewport()->update();
 
     emit pagesChanged();
     emit pageBackupsChanged();
 }
 
 void DrawPadCanvas::goNextPage()
 {
     m_pages.next();
     m_pageBackups.clear();
     m_pageBackups.append(new Page(*(m_pages.current())));
 
     resizeContents(m_pages.current()->width(), m_pages.current()->height());
     viewport()->update();
 
     emit pagesChanged();
     emit pageBackupsChanged();
 }
 
 void DrawPadCanvas::goLastPage()
 {
     m_pages.last();
     m_pageBackups.clear();
     m_pageBackups.append(new Page(*(m_pages.current())));
 
     resizeContents(m_pages.current()->width(), m_pages.current()->height());
     viewport()->update();
 
     emit pagesChanged();
     emit pageBackupsChanged();
 }
 
 void DrawPadCanvas::contentsMousePressEvent(QMouseEvent* e)
 {
     m_pDrawPad->tool()->mousePressEvent(e);
 }
 
 void DrawPadCanvas::contentsMouseReleaseEvent(QMouseEvent* e)
 {
     m_pDrawPad->tool()->mouseReleaseEvent(e);
 }
 
 void DrawPadCanvas::contentsMouseMoveEvent(QMouseEvent* e)
 {
     m_pDrawPad->tool()->mouseMoveEvent(e);
 }
 
 void DrawPadCanvas::drawContents(QPainter* p, int cx, int cy, int cw, int ch)
 {
     QRect clipRect(cx, cy, cw, ch);
     QRect pixmapRect(0, 0, m_pages.current()->width(), m_pages.current()->height());
     QRect drawRect = pixmapRect.intersect(clipRect);
 
     p->drawPixmap(drawRect.topLeft(), *(m_pages.current()), drawRect);
 
     if (drawRect.right() < clipRect.right()) {
         p->fillRect(drawRect.right() + 1, cy, cw - drawRect.width(), ch, colorGroup().dark());
     }
 
     if (drawRect.bottom() < clipRect.bottom()) {
         p->fillRect(cx, drawRect.bottom() + 1, cw, ch - drawRect.height(), colorGroup().dark());
     }
 }
diff --git a/noncore/graphics/drawpad/drawpadcanvas.h b/noncore/graphics/drawpad/drawpadcanvas.h
index dcaff5c..2283e5e 100644
--- a/noncore/graphics/drawpad/drawpadcanvas.h
+++ b/noncore/graphics/drawpad/drawpadcanvas.h
@@ -1,85 +1,86 @@
 /***************************************************************************
  *                                                                         *
  *   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.                                   *
  *                                                                         *
  ***************************************************************************/
 
 #ifndef DRAWPADCANVAS_H
 #define DRAWPADCANVAS_H
 
 #include <qscrollview.h>
 
 #include <qlist.h>
 #include <qpointarray.h>
 
 class DrawPad;
 class Page;
 
 class DrawPadCanvas : public QScrollView
 { 
     Q_OBJECT
 
 public:
     DrawPadCanvas(DrawPad* drawPad, QWidget* parent = 0, const char* name = 0);
     ~DrawPadCanvas();
 
     void load(QIODevice* ioDevice);
     void initialPage();
     void save(QIODevice* ioDevice);
 
     void importPage(const QString& fileName);
     void exportPage(uint fromPage, uint toPage, const QString& name, const QString& format);
 
     bool undoEnabled();
     bool redoEnabled();
     bool goPreviousPageEnabled();
     bool goNextPageEnabled();
 
     Page* currentPage();
     QList<Page> pages();
     uint pagePosition();
     uint pageCount();
 
     void selectPage(Page* page);
+    void selectPage(uint pagePosition);
     void backupPage();
 
 public slots:
     void deleteAll();
     void newPage(QString title, uint width, uint height, const QColor& color);
     void clearPage();
     void deletePage();
     void movePageUp();
     void movePageDown();
 
     void undo();
     void redo();
 
     void goFirstPage();
     void goPreviousPage();
     void goNextPage();
     void goLastPage();
 
 signals:
     void pagesChanged();
     void pageBackupsChanged();
 
 protected:
     void contentsMousePressEvent(QMouseEvent* e);
     void contentsMouseReleaseEvent(QMouseEvent* e);
     void contentsMouseMoveEvent(QMouseEvent* e);
     void drawContents(QPainter* p, int cx, int cy, int cw, int ch);
 
 private:
     DrawPad* m_pDrawPad;
     QList<Page> m_pages;
     QList<Page> m_pageBackups;
 };
 
 #endif // DRAWPADCANVAS_H