Undo/redo reimplemented

13 files changed, 169 insertions, 187 deletions

diff --git a/noncore/graphics/drawpad/drawpad.cpp b/noncore/graphics/drawpad/drawpad.cpp
index 4eb47a5..b0a414e 100644
--- a/noncore/graphics/drawpad/drawpad.cpp
+++ b/noncore/graphics/drawpad/drawpad.cpp
@@ -10,99 +10,97 @@
  *   (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()));
+    connect(m_pDrawPadCanvas, SIGNAL(pagesChanged()), this, SLOT(updateView()));
 
     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);
 
@@ -497,117 +495,111 @@ void DrawPad::setFillTool()
     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()
+void DrawPad::updateView()
 {
     uint pagePosition = m_pDrawPadCanvas->pagePosition();
     uint pageCount = m_pDrawPadCanvas->pageCount();
 
     setCaption(tr("DrawPad") + " - " + tr("Page") + " "
                + QString::number(pagePosition) + "/" + QString::number(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);
 
     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);
diff --git a/noncore/graphics/drawpad/drawpad.h b/noncore/graphics/drawpad/drawpad.h
index c57606c..7306228 100644
--- a/noncore/graphics/drawpad/drawpad.h
+++ b/noncore/graphics/drawpad/drawpad.h
@@ -14,99 +14,97 @@
 #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 updateView();
 
     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 05dd408..025bebb 100644
--- a/noncore/graphics/drawpad/drawpadcanvas.cpp
+++ b/noncore/graphics/drawpad/drawpadcanvas.cpp
@@ -1,80 +1,78 @@
 /***************************************************************************
  *                                                                         *
  *   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)
@@ -104,479 +102,409 @@ bool DrawPadCanvasXmlHandler::endElement(const QString& namespaceURI, const QStr
 
     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);
+        page->pixmap()->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_pages.current()->pixmap()->fill(Qt::white);
     }
 
-    m_pageBackups.clear();
-    m_pageBackups.append(new Page(*(m_pages.current())));
-
-    resizeContents(m_pages.current()->width(), m_pages.current()->height());
+    resizeContents(m_pages.current()->pixmap()->width(), m_pages.current()->pixmap()->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())));
+    m_pages.current()->pixmap()->fill(Qt::white);
 
-    resizeContents(m_pages.current()->width(), m_pages.current()->height());
+    resizeContents(m_pages.current()->pixmap()->width(), m_pages.current()->pixmap()->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();
+        QImage image = bufferIterator.current()->pixmap()->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);
+    importedPage->pixmap()->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());
+    resizeContents(m_pages.current()->pixmap()->width(), m_pages.current()->pixmap()->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();
+        QImage image = m_pages.current()->pixmap()->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();
+            QImage image = m_pages.at(i - 1)->pixmap()->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());
+    resizeContents(m_pages.current()->pixmap()->width(), m_pages.current()->pixmap()->height());
     viewport()->update();
 
     emit pagesChanged();
-    emit pageBackupsChanged();
 }
 
-void DrawPadCanvas::selectPage(uint pagePosition)
+void DrawPadCanvas::backupPage()
 {
-    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();
+    m_pages.current()->backup();
 
     emit pagesChanged();
-    emit pageBackupsChanged();
 }
 
-void DrawPadCanvas::backupPage()
+void DrawPadCanvas::selectPage(uint pagePosition)
 {
-    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_pages.at(pagePosition - 1);
 
-    m_pageBackups.append(new Page(*(m_pages.current())));
+    resizeContents(m_pages.current()->pixmap()->width(), m_pages.current()->pixmap()->height());
+    viewport()->update();
 
-    emit pageBackupsChanged();
+    emit pagesChanged();
 }
 
 void DrawPadCanvas::deleteAll()
 {
     m_pages.clear();
 
     m_pages.append(new Page("", contentsRect().size()));
-    m_pages.current()->fill(Qt::white);
+    m_pages.current()->pixmap()->fill(Qt::white);
 
-    m_pageBackups.clear();
-    m_pageBackups.append(new Page(*(m_pages.current())));
-
-    resizeContents(m_pages.current()->width(), m_pages.current()->height());
+    resizeContents(m_pages.current()->pixmap()->width(), m_pages.current()->pixmap()->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())));
+    m_pages.current()->pixmap()->fill(color);
 
-    resizeContents(m_pages.current()->width(), m_pages.current()->height());
+    resizeContents(m_pages.current()->pixmap()->width(), m_pages.current()->pixmap()->height());
     viewport()->update();
 
     emit pagesChanged();
-    emit pageBackupsChanged();
 }
 
 void DrawPadCanvas::clearPage()
 {
-    m_pages.current()->fill(Qt::white);
+    m_pages.current()->pixmap()->fill(Qt::white);
 
-    m_pageBackups.clear();
-    m_pageBackups.append(new Page(*(m_pages.current())));
-
-    resizeContents(m_pages.current()->width(), m_pages.current()->height());
+    resizeContents(m_pages.current()->pixmap()->width(), m_pages.current()->pixmap()->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_pages.current()->pixmap()->fill(Qt::white);
     }
 
-    m_pageBackups.clear();
-    m_pageBackups.append(new Page(*(m_pages.current())));
-
-    resizeContents(m_pages.current()->width(), m_pages.current()->height());
+    resizeContents(m_pages.current()->pixmap()->width(), m_pages.current()->pixmap()->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());
+    m_pages.current()->undo();
 
     viewport()->update();
 
-    emit pageBackupsChanged();
+    emit pagesChanged();
 }
 
 void DrawPadCanvas::redo()
 {
-    *(m_pages.current()) = *(m_pageBackups.next());
+    m_pages.current()->redo();
 
     viewport()->update();
 
-    emit pageBackupsChanged();
+    emit pagesChanged();
 }
 
 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());
+    resizeContents(m_pages.current()->pixmap()->width(), m_pages.current()->pixmap()->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());
+    resizeContents(m_pages.current()->pixmap()->width(), m_pages.current()->pixmap()->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());
+    resizeContents(m_pages.current()->pixmap()->width(), m_pages.current()->pixmap()->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());
+    resizeContents(m_pages.current()->pixmap()->width(), m_pages.current()->pixmap()->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 pixmapRect(0, 0, m_pages.current()->pixmap()->width(), m_pages.current()->pixmap()->height());
     QRect drawRect = pixmapRect.intersect(clipRect);
 
-    p->drawPixmap(drawRect.topLeft(), *(m_pages.current()), drawRect);
+    p->drawPixmap(drawRect.topLeft(), *(m_pages.current()->pixmap()), 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 2283e5e..80a2a7e 100644
--- a/noncore/graphics/drawpad/drawpadcanvas.h
+++ b/noncore/graphics/drawpad/drawpadcanvas.h
@@ -1,86 +1,82 @@
 /***************************************************************************
  *                                                                         *
  *   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
diff --git a/noncore/graphics/drawpad/erasetool.cpp b/noncore/graphics/drawpad/erasetool.cpp
index f77e038..2326da5 100644
--- a/noncore/graphics/drawpad/erasetool.cpp
+++ b/noncore/graphics/drawpad/erasetool.cpp
@@ -1,76 +1,76 @@
 /***************************************************************************
  *                                                                         *
  *   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 "erasetool.h"
 
 #include "drawpad.h"
 #include "drawpadcanvas.h"
 #include "page.h"
 
 #include <qpainter.h>
 
 EraseTool::EraseTool(DrawPad* drawPad, DrawPadCanvas* drawPadCanvas)
     : Tool(drawPad, drawPadCanvas)
 {
     m_mousePressed = false;
     m_polyline.resize(3);
 }
 
 EraseTool::~EraseTool()
 {
 }
 
 void EraseTool::mousePressEvent(QMouseEvent* e)
 {
+    m_pDrawPadCanvas->backupPage();
+
     m_mousePressed = true;
     m_polyline[2] = m_polyline[1] = m_polyline[0] = e->pos();
 }
 
 void EraseTool::mouseReleaseEvent(QMouseEvent* e)
 {
     Q_UNUSED(e)
 
     m_mousePressed = false;
-
-    m_pDrawPadCanvas->backupPage();
 }
 
 void EraseTool::mouseMoveEvent(QMouseEvent* e)
 {
     if (m_mousePressed) {
         QPainter painter;
         QPen pen(Qt::white, m_pDrawPad->pen().width());
-        painter.begin(m_pDrawPadCanvas->currentPage());
+        painter.begin(m_pDrawPadCanvas->currentPage()->pixmap());
         painter.setPen(pen);
         m_polyline[2] = m_polyline[1];
         m_polyline[1] = m_polyline[0];
         m_polyline[0] = e->pos();
         painter.drawPolyline(m_polyline);
         painter.end();
 
         QRect r = m_polyline.boundingRect();
         r = r.normalize();
         r.setLeft(r.left() - m_pDrawPad->pen().width());
         r.setTop(r.top() - m_pDrawPad->pen().width());
         r.setRight(r.right() + m_pDrawPad->pen().width());
         r.setBottom(r.bottom() + m_pDrawPad->pen().width());
 
         QRect viewportRect(m_pDrawPadCanvas->contentsToViewport(r.topLeft()),
                            m_pDrawPadCanvas->contentsToViewport(r.bottomRight()));
 
         bitBlt(m_pDrawPadCanvas->viewport(), viewportRect.x(), viewportRect.y(),
-               m_pDrawPadCanvas->currentPage(), r.x(), r.y(), r.width(), r.height());
+               m_pDrawPadCanvas->currentPage()->pixmap(), r.x(), r.y(), r.width(), r.height());
 
         m_pDrawPadCanvas->viewport()->update(viewportRect);
     }
 }
diff --git a/noncore/graphics/drawpad/filltool.cpp b/noncore/graphics/drawpad/filltool.cpp
index 0177e1c..2a39d04 100644
--- a/noncore/graphics/drawpad/filltool.cpp
+++ b/noncore/graphics/drawpad/filltool.cpp
@@ -1,160 +1,160 @@
 /***************************************************************************
  *                                                                         *
  *   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 "filltool.h"
 
 #include "drawpad.h"
 #include "drawpadcanvas.h"
 #include "page.h"
 
 #include <qimage.h>
 
 const int FILL_THRESHOLD = 65536;
 
 FillTool::FillTool(DrawPad* drawPad, DrawPadCanvas* drawPadCanvas)
     : Tool(drawPad, drawPadCanvas)
 {
 }
 
 FillTool::~FillTool()
 {
 }
 
 void FillTool::mousePressEvent(QMouseEvent* e)
 {
     int x = e->x();
     int y = e->y();
 
-    m_image = m_pDrawPadCanvas->currentPage()->convertToImage();
+    m_image = m_pDrawPadCanvas->currentPage()->pixmap()->convertToImage();
     m_fillRgb = m_pDrawPad->brush().color().rgb();
     m_oldRgb = m_image.pixel(x, y);
 
     if (m_oldRgb != m_fillRgb) {
+        m_pDrawPadCanvas->backupPage();
+
         if (m_pDrawPad->antiAliasing()) {
             m_mask.create(m_image.width(), m_image.height(), 8, 2);
             m_mask.fill(0);
 
             fillMaskLine(x, y);
 
             for (int i = 0; i < m_image.width(); i++) {
                 for (int j = 0; j < m_image.height(); j++) {
                     if (m_mask.pixelIndex(i, j) == 1) {
                         setInterpolatedPixel(i, j);
                     }
                 }
             }
 
         } else {
             fillLine(x, y);
         }
 
-        m_pDrawPadCanvas->currentPage()->convertFromImage(m_image);
+        m_pDrawPadCanvas->currentPage()->pixmap()->convertFromImage(m_image);
         m_pDrawPadCanvas->viewport()->update();
-
-        m_pDrawPadCanvas->backupPage();
     }
 }
 
 void FillTool::mouseReleaseEvent(QMouseEvent* e)
 {
     Q_UNUSED(e)
 }
 
 void FillTool::mouseMoveEvent(QMouseEvent* e)
 {
     Q_UNUSED(e)
 }
 
 void FillTool::fillLine(int x, int y)
 {
     if ((x >= 0) && (x < m_image.width()) && (y >= 0) && (y < m_image.height())) {
         if (m_image.pixel(x, y) == m_oldRgb) {
             int x1, x2;
 
             x1 = x - 1;
             x2 = x + 1;
 
             while ((x1 >= 0) && (m_image.pixel(x1, y) == m_oldRgb)) {
                 x1--;
             }
 
             while ((x2 < m_image.width()) && (m_image.pixel(x2, y) == m_oldRgb)) {
                 x2++;
             }
 
             for (int i = x1 + 1; i < x2; i++) {
                 m_image.setPixel(i, y, m_fillRgb);
             }
 
             for (int i = x1 + 1; i < x2; i++) {
                 fillLine(i, y - 1);
             }
 
             for (int i = x1 + 1; i < x2; i++) {
                 fillLine(i, y + 1);
             }
         }
     }
 }
 
 void FillTool::fillMaskLine(int x, int y)
 {
     if ((x >= 0) && (x < m_image.width()) && (y >= 0) && (y < m_image.height())) {
         if (m_mask.pixelIndex(x, y) == 0) {
-                if (rgbDistance(m_image.pixel(x, y), m_oldRgb) < FILL_THRESHOLD) {
-                int x1, x2;
+            if (rgbDistance(m_image.pixel(x, y), m_oldRgb) < FILL_THRESHOLD) {
+            int x1, x2;
 
-                x1 = x - 1;
-                x2 = x + 1;
+            x1 = x - 1;
+            x2 = x + 1;
 
-                while ((x1 >= 0) && (rgbDistance(m_image.pixel(x1, y), m_oldRgb) < FILL_THRESHOLD)) {
-                    x1--;
-                }
+            while ((x1 >= 0) && (rgbDistance(m_image.pixel(x1, y), m_oldRgb) < FILL_THRESHOLD)) {
+                x1--;
+            }
 
-                while ((x2 < m_image.width()) && (rgbDistance(m_image.pixel(x2, y), m_oldRgb) < FILL_THRESHOLD)) {
-                    x2++;
-                }
+            while ((x2 < m_image.width()) && (rgbDistance(m_image.pixel(x2, y), m_oldRgb) < FILL_THRESHOLD)) {
+                x2++;
+            }
 
-                for (int i = x1 + 1; i < x2; i++) {
-                    m_mask.setPixel(i, y, 1);
-                }
+            for (int i = x1 + 1; i < x2; i++) {
+                m_mask.setPixel(i, y, 1);
+            }
 
-                for (int i = x1 + 1; i < x2; i++) {
-                    fillMaskLine(i, y - 1);
-                }
+            for (int i = x1 + 1; i < x2; i++) {
+                fillMaskLine(i, y - 1);
+            }
 
-                for (int i = x1 + 1; i < x2; i++) {
-                    fillMaskLine(i, y + 1);
-                }
+            for (int i = x1 + 1; i < x2; i++) {
+                fillMaskLine(i, y + 1);
+            }
             }
         }
     }
 }
 
 void FillTool::setInterpolatedPixel(int x, int y)
 {
     int fillRed = QMIN(QMAX(qRed(m_fillRgb) + qRed(m_image.pixel(x, y)) - qRed(m_oldRgb), 0), 255);
     int fillGreen = QMIN(QMAX(qGreen(m_fillRgb) + qGreen(m_image.pixel(x, y)) - qGreen(m_oldRgb), 0), 255);
     int fillBlue = QMIN(QMAX(qBlue(m_fillRgb) + qBlue(m_image.pixel(x, y)) - qBlue(m_oldRgb), 0), 255);
 
     m_image.setPixel(x, y, qRgb(fillRed, fillGreen, fillBlue));
 }
 
 int FillTool::rgbDistance(QRgb rgb1, QRgb rgb2)
 {
     int redDistance = qRed(rgb2) - qRed(rgb1);
     int greenDistance = qGreen(rgb2) - qGreen(rgb1);
     int blueDistance = qBlue(rgb2) - qBlue(rgb1);
 
     return (redDistance * redDistance + greenDistance * greenDistance + blueDistance * blueDistance);
 }
diff --git a/noncore/graphics/drawpad/page.cpp b/noncore/graphics/drawpad/page.cpp
index 601d1c3..fbf3d01 100644
--- a/noncore/graphics/drawpad/page.cpp
+++ b/noncore/graphics/drawpad/page.cpp
@@ -1,59 +1,113 @@
 /***************************************************************************
  *                                                                         *
  *   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 "page.h"
 
+const int PAGE_BACKUPS = 99;
+
 Page::Page()
-    : QPixmap()
 {
+    m_title = "";
     m_lastModified = QDateTime::currentDateTime();
+    m_pPixmap = new QPixmap();
+
+    m_backHistory.setAutoDelete(true);
+    m_forwardHistory.setAutoDelete(true);
 }
 
 Page::Page(QString title, int w, int h)
-    : QPixmap(w, h)
 {
     m_title = title;
     m_lastModified = QDateTime::currentDateTime();
+    m_pPixmap = new QPixmap(w, h);
+
+    m_backHistory.setAutoDelete(true);
+    m_forwardHistory.setAutoDelete(true);
 }
 
 Page::Page(QString title, const QSize& size)
-    : QPixmap(size)
 {
     m_title = title;
     m_lastModified = QDateTime::currentDateTime();
+    m_pPixmap = new QPixmap(size);
+
+    m_backHistory.setAutoDelete(true);
+    m_forwardHistory.setAutoDelete(true);
 }
 
 Page::~Page()
 {
+    delete m_pPixmap;
 }
 
 QString Page::title() const
 {
     return m_title;
 }
 
 QDateTime Page::lastModified() const
 {
     return m_lastModified;
 }
 
+QPixmap* Page::pixmap() const
+
+{
+    return m_pPixmap;
+}
+
 void Page::setTitle(QString title)
 {
     m_title = title;
 }
 
 void Page::setLastModified(QDateTime lastModified)
 {
     m_lastModified = lastModified;
 }
 
+bool Page::undoEnabled()
+{
+    return (!m_backHistory.isEmpty());
+}
+
+bool Page::redoEnabled()
+{
+    return (!m_forwardHistory.isEmpty());
+}
+
+void Page::backup()
+{
+    setLastModified(QDateTime::currentDateTime());
+
+    while (m_backHistory.count() >= (PAGE_BACKUPS + 1)) {
+        m_backHistory.removeFirst();
+    }
+
+    m_backHistory.append(new QPixmap(*m_pPixmap));
+    m_forwardHistory.clear();
+}
+
+void Page::undo()
+{
+    m_forwardHistory.append(new QPixmap(*m_pPixmap));
+    m_pPixmap = new QPixmap(*(m_backHistory.last()));
+    m_backHistory.removeLast();
+}
+
+void Page::redo()
+{
+    m_backHistory.append(new QPixmap(*m_pPixmap));
+    m_pPixmap = new QPixmap(*(m_forwardHistory.last()));
+    m_forwardHistory.removeLast();
+}
diff --git a/noncore/graphics/drawpad/page.h b/noncore/graphics/drawpad/page.h
index 20a37b5..8ce7bc9 100644
--- a/noncore/graphics/drawpad/page.h
+++ b/noncore/graphics/drawpad/page.h
@@ -1,41 +1,55 @@
 /***************************************************************************
  *                                                                         *
  *   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 PAGE_H
 #define PAGE_H
 
-#include <qpixmap.h>
+#include <qobject.h>
 
 #include <qdatetime.h>
+#include <qlist.h>
+#include <qpixmap.h>
 
-class Page : public QPixmap
+class Page : public QObject
 {
 public:
     Page();
     Page(QString title, int w, int h);
     Page(QString title, const QSize& size);
 
     ~Page();
-    
+
     QString title() const;
     QDateTime lastModified() const;
+    QPixmap* pixmap() const;
 
     void setTitle(QString title);
     void setLastModified(QDateTime lastModified);
 
+    bool undoEnabled();
+    bool redoEnabled();
+
+    void backup();
+    void undo();
+    void redo();
+
 private:
     QString m_title;
     QDateTime m_lastModified;
+    QPixmap* m_pPixmap;
+
+    QList<QPixmap> m_backHistory;
+    QList<QPixmap> m_forwardHistory;
 };
 
 #endif // PAGE_H
diff --git a/noncore/graphics/drawpad/pageinformationdialog.cpp b/noncore/graphics/drawpad/pageinformationdialog.cpp
index c0d055e..cb14d73 100644
--- a/noncore/graphics/drawpad/pageinformationdialog.cpp
+++ b/noncore/graphics/drawpad/pageinformationdialog.cpp
@@ -1,97 +1,97 @@
 /***************************************************************************
  *                                                                         *
  *   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 "pageinformationdialog.h"
 
 #include "page.h"
 
 #include <qpe/config.h>
 #include <qpe/timestring.h>
 
 #include <qgroupbox.h>
 #include <qlabel.h>
 #include <qlayout.h>
 #include <qlineedit.h>
 
 PageInformationDialog::PageInformationDialog(Page* page, QWidget* parent, const char* name)
     : QDialog(parent, name, true)
 {
     m_pPage = page;
 
     setCaption(tr("Page Information"));
 
     QGroupBox* generalGroupBox = new QGroupBox(0, Qt::Vertical, tr("General"), this);
 
     QLabel* titleLabel = new QLabel(tr("Title:"), generalGroupBox);
 
     m_pTitleLineEdit = new QLineEdit(generalGroupBox);
     m_pTitleLineEdit->setText(page->title());
     
     QLabel* dateLabel = new QLabel(tr("Date:"), generalGroupBox);
     QLabel* dateValueLabel = new QLabel(dateTimeString(m_pPage->lastModified()), generalGroupBox);
 
     QGroupBox* sizeGroupBox = new QGroupBox(0, Qt::Vertical, tr("Size"), this);
 
     QLabel* widthLabel = new QLabel(tr("Width:"), sizeGroupBox);
-    QLabel* widthValueLabel = new QLabel(QString::number(m_pPage->width()), sizeGroupBox);
+    QLabel* widthValueLabel = new QLabel(QString::number(m_pPage->pixmap()->width()), sizeGroupBox);
 
     QLabel* heightLabel = new QLabel(tr("Height:"), sizeGroupBox);
-    QLabel* heightValueLabel = new QLabel(QString::number(m_pPage->height()), sizeGroupBox);
+    QLabel* heightValueLabel = new QLabel(QString::number(m_pPage->pixmap()->height()), sizeGroupBox);
 
     QVBoxLayout* mainLayout = new QVBoxLayout(this, 4, 4);
     generalGroupBox->layout()->setSpacing(4);
     sizeGroupBox->layout()->setSpacing(4);
     QGridLayout* generalLayout = new QGridLayout(generalGroupBox->layout(), 2, 2);
     QGridLayout* sizeLayout = new QGridLayout(sizeGroupBox->layout(), 2, 2);
 
     generalLayout->addWidget(titleLabel, 0, 0);
     generalLayout->addWidget(m_pTitleLineEdit, 0, 1);
     generalLayout->addWidget(dateLabel, 1, 0);
     generalLayout->addWidget(dateValueLabel, 1, 1);
     
     generalLayout->setColStretch(1, 1);
 
     sizeLayout->addWidget(widthLabel, 0, 0);
     sizeLayout->addWidget(widthValueLabel, 0, 1);
     sizeLayout->addWidget(heightLabel, 1, 0);
     sizeLayout->addWidget(heightValueLabel, 1, 1);
 
     sizeLayout->setColStretch(1, 1);
 
     mainLayout->addWidget(generalGroupBox);
     mainLayout->addWidget(sizeGroupBox);
 }
 
 PageInformationDialog::~PageInformationDialog()
 {
 }
 
 QString PageInformationDialog::selectedTitle()
 {
     return (m_pTitleLineEdit->text());
 }
 
 QString PageInformationDialog::dateTimeString(QDateTime dateTime)
 {
     QString result;
 
     Config config("qpe");
     config.setGroup("Date");
 
     QChar separator = config.readEntry("Separator", "/")[0];
     DateFormat::Order shortOrder = (DateFormat::Order)config .readNumEntry("ShortOrder", DateFormat::DayMonthYear);
 
     for (int i = 0; i < 3; i++) {
         switch((shortOrder >> (i * 3)) & 0x0007) {
             case 0x0001:
                 result += QString().sprintf("%02d", dateTime.date().day());
diff --git a/noncore/graphics/drawpad/pointtool.cpp b/noncore/graphics/drawpad/pointtool.cpp
index a4f846e..b9b52bc 100644
--- a/noncore/graphics/drawpad/pointtool.cpp
+++ b/noncore/graphics/drawpad/pointtool.cpp
@@ -1,111 +1,111 @@
 /***************************************************************************
  *                                                                         *
  *   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 "pointtool.h"
 
 #include "drawpad.h"
 #include "drawpadcanvas.h"
 #include "page.h"
 
 #include <qimage.h>
 #include <qpainter.h>
 
 PointTool::PointTool(DrawPad* drawPad, DrawPadCanvas* drawPadCanvas)
     : Tool(drawPad, drawPadCanvas)
 {
     m_mousePressed = false;
     m_polyline.resize(3);
 }
 
 PointTool::~PointTool()
 {
 }
 
 void PointTool::mousePressEvent(QMouseEvent* e)
 {
+    m_pDrawPadCanvas->backupPage();
+
     m_mousePressed = true;
     m_polyline[2] = m_polyline[1] = m_polyline[0] = e->pos();
 }
 
 void PointTool::mouseReleaseEvent(QMouseEvent* e)
 {
     Q_UNUSED(e)
 
     m_mousePressed = false;
-
-    m_pDrawPadCanvas->backupPage();
 }
 
 void PointTool::mouseMoveEvent(QMouseEvent* e)
 {
     if (m_mousePressed) {
         m_polyline[2] = m_polyline[1];
         m_polyline[1] = m_polyline[0];
         m_polyline[0] = e->pos();
 
         QRect r = m_polyline.boundingRect();
         r = r.normalize();
         r.setLeft(r.left() - m_pDrawPad->pen().width());
         r.setTop(r.top() - m_pDrawPad->pen().width());
         r.setRight(r.right() + m_pDrawPad->pen().width());
         r.setBottom(r.bottom() + m_pDrawPad->pen().width());
 
         QPainter painter;
-        painter.begin(m_pDrawPadCanvas->currentPage());
+        painter.begin(m_pDrawPadCanvas->currentPage()->pixmap());
 
         if (m_pDrawPad->antiAliasing()) {
             QPixmap areaPixmap(r.width(), r.height());
             bitBlt(&areaPixmap, QPoint(0, 0), painter.device(), r);
 
             QImage areaImage = areaPixmap.convertToImage();
             QImage bigAreaImage = areaImage.smoothScale(areaImage.width() * 3, areaImage.height() * 3);
 
             QPixmap bigAreaPixmap;
             bigAreaPixmap.convertFromImage(bigAreaImage);
 
             QPen bigAreaPen = m_pDrawPad->pen();
             bigAreaPen.setWidth(bigAreaPen.width() * 3);
 
             QPainter bigAreaPainter;
             bigAreaPainter.begin(&bigAreaPixmap);
             bigAreaPainter.setPen(bigAreaPen);
 
             QPointArray bigAreaPolyline(3);
             bigAreaPolyline.setPoint(0, (m_polyline[0].x() - r.x()) * 3 + 1, (m_polyline[0].y() - r.y()) * 3 + 1);
             bigAreaPolyline.setPoint(1, (m_polyline[1].x() - r.x()) * 3 + 1, (m_polyline[1].y() - r.y()) * 3 + 1);
             bigAreaPolyline.setPoint(2, (m_polyline[2].x() - r.x()) * 3 + 1, (m_polyline[2].y() - r.y()) * 3 + 1);
 
             bigAreaPainter.drawPolyline(bigAreaPolyline);
             bigAreaPainter.end();
 
             bigAreaImage = bigAreaPixmap.convertToImage();
             areaImage = bigAreaImage.smoothScale(bigAreaImage.width() / 3, bigAreaImage.height() / 3);
             areaPixmap.convertFromImage(areaImage);
 
             painter.drawPixmap(r.x(), r.y(), areaPixmap);
         } else {
             painter.setPen(m_pDrawPad->pen());
             painter.drawPolyline(m_polyline);
         }
 
         painter.end();
 
         QRect viewportRect(m_pDrawPadCanvas->contentsToViewport(r.topLeft()),
                            m_pDrawPadCanvas->contentsToViewport(r.bottomRight()));
 
         bitBlt(m_pDrawPadCanvas->viewport(), viewportRect.x(), viewportRect.y(),
-               m_pDrawPadCanvas->currentPage(), r.x(), r.y(), r.width(), r.height());
+               m_pDrawPadCanvas->currentPage()->pixmap(), r.x(), r.y(), r.width(), r.height());
 
         m_pDrawPadCanvas->viewport()->update(viewportRect);
     }
 }
diff --git a/noncore/graphics/drawpad/shapetool.cpp b/noncore/graphics/drawpad/shapetool.cpp
index 8870a78..22e3dd6 100644
--- a/noncore/graphics/drawpad/shapetool.cpp
+++ b/noncore/graphics/drawpad/shapetool.cpp
@@ -1,94 +1,94 @@
 /***************************************************************************
  *                                                                         *
  *   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 "shapetool.h"
 
 #include "drawpad.h"
 #include "drawpadcanvas.h"
 #include "page.h"
 
 #include <qpainter.h>
 
 ShapeTool::ShapeTool(DrawPad* drawPad, DrawPadCanvas* drawPadCanvas)
     : Tool(drawPad, drawPadCanvas)
 {
     m_mousePressed = false;
     m_polyline.resize(3);
 }
 
 ShapeTool::~ShapeTool()
 {
 }
 
 void ShapeTool::mousePressEvent(QMouseEvent* e)
 {
+    m_pDrawPadCanvas->backupPage();
+
     m_mousePressed = true;
     m_polyline[2] = m_polyline[1] = m_polyline[0] = e->pos();
 }
 
 void ShapeTool::mouseReleaseEvent(QMouseEvent* e)
 {
     Q_UNUSED(e)
 
     QPainter painter;
-    painter.begin(m_pDrawPadCanvas->currentPage());
+    painter.begin(m_pDrawPadCanvas->currentPage()->pixmap());
     drawFinalShape(painter);
     painter.end();
 
     QRect r = m_polyline.boundingRect();
     r = r.normalize();
     r.setLeft(r.left() - m_pDrawPad->pen().width());
     r.setTop(r.top() - m_pDrawPad->pen().width());
     r.setRight(r.right() + m_pDrawPad->pen().width());
     r.setBottom(r.bottom() + m_pDrawPad->pen().width());
 
     QRect viewportRect(m_pDrawPadCanvas->contentsToViewport(r.topLeft()),
                        m_pDrawPadCanvas->contentsToViewport(r.bottomRight()));
 
     bitBlt(m_pDrawPadCanvas->viewport(), viewportRect.x(), viewportRect.y(),
-           m_pDrawPadCanvas->currentPage(), r.x(), r.y(), r.width(), r.height());
+           m_pDrawPadCanvas->currentPage()->pixmap(), r.x(), r.y(), r.width(), r.height());
 
     m_pDrawPadCanvas->viewport()->update(viewportRect);
 
     m_mousePressed = false;
-
-    m_pDrawPadCanvas->backupPage();
 }
 
 void ShapeTool::mouseMoveEvent(QMouseEvent* e)
 {
     if (m_mousePressed) {
         m_polyline[0] = e->pos();
         QPainter painter;
-        painter.begin(m_pDrawPadCanvas->currentPage());
+        painter.begin(m_pDrawPadCanvas->currentPage()->pixmap());
         drawTemporaryShape(painter);
         painter.end();
 
         QRect r = m_polyline.boundingRect();
         r = r.normalize();
         r.setLeft(r.left() - m_pDrawPad->pen().width());
         r.setTop(r.top() - m_pDrawPad->pen().width());
         r.setRight(r.right() + m_pDrawPad->pen().width());
         r.setBottom(r.bottom() + m_pDrawPad->pen().width());
 
         QRect viewportRect(m_pDrawPadCanvas->contentsToViewport(r.topLeft()),
                            m_pDrawPadCanvas->contentsToViewport(r.bottomRight()));
 
         bitBlt(m_pDrawPadCanvas->viewport(), viewportRect.x(), viewportRect.y(),
-               m_pDrawPadCanvas->currentPage(), r.x(), r.y(), r.width(), r.height());
+               m_pDrawPadCanvas->currentPage()->pixmap(), r.x(), r.y(), r.width(), r.height());
 
         m_pDrawPadCanvas->viewport()->update(viewportRect);
 
         m_polyline[1] = m_polyline[0];
     }
 }
diff --git a/noncore/graphics/drawpad/texttool.cpp b/noncore/graphics/drawpad/texttool.cpp
index 34c8a76..9037abd 100644
--- a/noncore/graphics/drawpad/texttool.cpp
+++ b/noncore/graphics/drawpad/texttool.cpp
@@ -11,69 +11,69 @@
  *                                                                         *
  ***************************************************************************/
 
 #include "texttool.h"
 
 #include "drawpad.h"
 #include "drawpadcanvas.h"
 #include "page.h"
 
 #include <qlayout.h>
 #include <qlineedit.h>
 #include <qpainter.h>
 
 TextToolDialog::TextToolDialog(QWidget* parent, const char* name)
     : QDialog(parent, name, true)
 {
     setCaption(tr("Insert Text"));
 
     m_pLineEdit = new QLineEdit(this);
 
     QVBoxLayout* mainLayout = new QVBoxLayout(this, 4, 4);
 
     mainLayout->addWidget(m_pLineEdit);
 }
 
 TextToolDialog::~TextToolDialog()
 {
 }
 
 QString TextToolDialog::text()
 {
     return m_pLineEdit->text();
 }
 
 TextTool::TextTool(DrawPad* drawPad, DrawPadCanvas* drawPadCanvas)
     : Tool(drawPad, drawPadCanvas)
 {
 }
 
 TextTool::~TextTool()
 {
 }
 
 void TextTool::mousePressEvent(QMouseEvent* e)
 {
     TextToolDialog textToolDialog(m_pDrawPad);
 
     if (textToolDialog.exec() == QDialog::Accepted && !textToolDialog.text().isEmpty()) {
+        m_pDrawPadCanvas->backupPage();
+
         QPainter painter;
-        painter.begin(m_pDrawPadCanvas->currentPage());
+        painter.begin(m_pDrawPadCanvas->currentPage()->pixmap());
         painter.setPen(m_pDrawPad->pen());
         painter.drawText(e->x(), e->y(), textToolDialog.text());
         painter.end();
 
         m_pDrawPadCanvas->viewport()->update();
-
-        m_pDrawPadCanvas->backupPage();
     }
 }
 
 void TextTool::mouseReleaseEvent(QMouseEvent* e)
 {
     Q_UNUSED(e)
 }
 
 void TextTool::mouseMoveEvent(QMouseEvent* e)
 {
     Q_UNUSED(e)
 }
diff --git a/noncore/graphics/drawpad/thumbnailview.cpp b/noncore/graphics/drawpad/thumbnailview.cpp
index 14092bf..9b08ca2 100644
--- a/noncore/graphics/drawpad/thumbnailview.cpp
+++ b/noncore/graphics/drawpad/thumbnailview.cpp
@@ -1,109 +1,109 @@
 /***************************************************************************
  *                                                                         *
  *   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 <qpe/config.h>
 #include <qpe/resource.h>
 #include <qpe/timestring.h>
 
 #include <qapplication.h>
 #include <qimage.h>
 #include <qlayout.h>
 #include <qmessagebox.h>
 #include <qtoolbutton.h>
 
 #define THUMBNAIL_SIZE 48
 
 PageListBoxItem::PageListBoxItem(Page* page, QListBox* parent)
     : QListBoxItem(parent)
 {
     m_pPage = page;
 
-    QImage image = m_pPage->convertToImage();
+    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:") + " " + m_pPage->title();
-    m_dimensionText = QObject::tr("Dimension:") + " " + QString::number(m_pPage->width())
-                      + "x" + QString::number(m_pPage->height());
+    m_dimensionText = QObject::tr("Dimension:") + " " + QString::number(m_pPage->pixmap()->width())
+                      + "x" + QString::number(m_pPage->pixmap()->height());
     m_dateText = QObject::tr("Date:") + " " + 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);
     } else if (baseColor != Qt::black) {
         m_alternateColor = baseColor.light(115);
     } else {
         m_alternateColor = QColor(32, 32, 32);
     }
 }
 
 PageListBoxItem::~PageListBoxItem()
 {
 }
 
 int PageListBoxItem::height(const QListBox*) const
 {
     return QMAX(THUMBNAIL_SIZE + 4, QApplication::globalStrut().height());
 }
 
 int PageListBoxItem::width(const QListBox* lb) const
 {
     QFontMetrics fontMetrics = lb->fontMetrics();
     int maxtextLength = QMAX(fontMetrics.width(m_titleText),
                              QMAX(fontMetrics.width(m_dimensionText),
                                   fontMetrics.width(m_dateText)));
 
     return QMAX(THUMBNAIL_SIZE + maxtextLength + 8, QApplication::globalStrut().width());
 }
 
 void PageListBoxItem::paint(QPainter *painter)
 {
     QRect itemRect = listBox()->itemRect(this);
 
     if (!selected() && (listBox()->index(this) % 2)) {
         painter->fillRect(0, 0, itemRect.width(), itemRect.height(), m_alternateColor);
     }
 
     painter->drawPixmap(2 + (THUMBNAIL_SIZE - m_thumbnail.width()) / 2,
                         2 + (THUMBNAIL_SIZE - m_thumbnail.height()) / 2,
                         m_thumbnail);
 
     QFont standardFont = painter->font();
     QFont boldFont = painter->font();