Working version of new page and clear page in thumbnail view

6 files changed, 75 insertions, 23 deletions

diff --git a/noncore/graphics/drawpad/drawpad.cpp b/noncore/graphics/drawpad/drawpad.cpp
index 58c0d09..ef55268 100644
--- a/noncore/graphics/drawpad/drawpad.cpp
+++ b/noncore/graphics/drawpad/drawpad.cpp
@@ -1,144 +1,145 @@
 /***************************************************************************
  *                                                                         *
  *   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 "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/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);
 
     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()), m_pDrawPadCanvas, SLOT(newPage()));
+    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);
 
@@ -223,96 +224,108 @@ DrawPad::DrawPad(QWidget* parent, const char* name)
     penWidthSpinBox->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();
     }
 }
 
 DrawPad::~DrawPad()
 {
     QFile file(Global::applicationFileName("drawpad", "drawpad.xml"));
 
     if (file.open(IO_WriteOnly)) {
         m_pDrawPadCanvas->save(&file);
         file.close();
     }
 }
 
+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.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);
@@ -530,53 +543,53 @@ void DrawPad::updateCaption()
                + 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(m_pDrawPadCanvas, this);
+    ThumbnailView thumbnailView(this, m_pDrawPadCanvas, this);
 
     thumbnailView.showMaximized();
     thumbnailView.exec();
 }
diff --git a/noncore/graphics/drawpad/drawpad.h b/noncore/graphics/drawpad/drawpad.h
index 01061b4..9a821f6 100644
--- a/noncore/graphics/drawpad/drawpad.h
+++ b/noncore/graphics/drawpad/drawpad.h
@@ -1,89 +1,90 @@
 /***************************************************************************
  *                                                                         *
  *   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 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; }
 
 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();
 
 private:
     DrawPadCanvas* m_pDrawPadCanvas;
 
     Tool* m_pTool;
     QPen m_pen;
     QBrush m_brush;
 
     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;
diff --git a/noncore/graphics/drawpad/drawpadcanvas.cpp b/noncore/graphics/drawpad/drawpadcanvas.cpp
index 0a1e9a5..c23ee34 100644
--- a/noncore/graphics/drawpad/drawpadcanvas.cpp
+++ b/noncore/graphics/drawpad/drawpadcanvas.cpp
@@ -1,65 +1,64 @@
 /***************************************************************************
  *                                                                         *
  *   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 "newpagedialog.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>
 
 #include <zlib.h>
 
 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,
         InData
     };
 
     State m_state;
     ulong m_dataLenght;
     QString m_dataFormat;
     QList<Page> m_pages;
 };
 
 DrawPadCanvasXmlHandler::DrawPadCanvasXmlHandler()
 {
     m_state = Unknown;
 }
 
 DrawPadCanvasXmlHandler::~DrawPadCanvasXmlHandler()
@@ -328,124 +327,122 @@ uint DrawPadCanvas::pageCount()
 }
 
 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::backupPage()
 {
     QPixmap* currentBackup = m_pageBackups.current();
     while (m_pageBackups.last() != currentBackup) {
         m_pageBackups.removeLast();
     }
 
     while (m_pageBackups.count() >= (5 + 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()
+void DrawPadCanvas::newPage(uint width, uint height, const QColor& color)
 {
-    QRect rect = contentsRect();
+    m_pages.insert(m_pages.at() + 1, new Page(width, height));
+    m_pages.current()->fill(color);
 
-    NewPageDialog newPageDialog(rect.width(), rect.height(), m_pDrawPad->pen().color(),
-                                m_pDrawPad->brush().color(), this);
-
-    if (newPageDialog.exec() == QDialog::Accepted) {
-        m_pages.insert(m_pages.at() + 1, new Page(newPageDialog.selectedWidth(),
-                                                  newPageDialog.selectedHeight()));
-        m_pages.current()->fill(newPageDialog.selectedColor());
-
-        m_pageBackups.clear();
-        m_pageBackups.append(new Page(*(m_pages.current())));
+    m_pageBackups.clear();
+    m_pageBackups.append(new Page(*(m_pages.current())));
 
-        resizeContents(m_pages.current()->width(), m_pages.current()->height());
-        viewport()->update();
+    resizeContents(m_pages.current()->width(), m_pages.current()->height());
+    viewport()->update();
 
-        emit pagesChanged();
-        emit pageBackupsChanged();
-    }
+    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();
 }
 
 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();
diff --git a/noncore/graphics/drawpad/drawpadcanvas.h b/noncore/graphics/drawpad/drawpadcanvas.h
index cf2d904..d74d425 100644
--- a/noncore/graphics/drawpad/drawpadcanvas.h
+++ b/noncore/graphics/drawpad/drawpadcanvas.h
@@ -7,77 +7,77 @@
  *   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 backupPage();
 
 public slots:
     void deleteAll();
-    void newPage();
+    void newPage(uint width, uint height, const QColor& color);
     void clearPage();
     void deletePage();
 
     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/thumbnailview.cpp b/noncore/graphics/drawpad/thumbnailview.cpp
index 476b7b9..08e106d 100644
--- a/noncore/graphics/drawpad/thumbnailview.cpp
+++ b/noncore/graphics/drawpad/thumbnailview.cpp
@@ -1,64 +1,66 @@
 /***************************************************************************
  *                                                                         *
  *   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/resource.h>
 
 #include <qapplication.h>
 #include <qheader.h>
 #include <qimage.h>
 #include <qlayout.h>
 #include <qmessagebox.h>
 #include <qtoolbutton.h>
 
 PageListViewItem::PageListViewItem(Page* page, QListView* parent)
     : QListViewItem(parent)
 {
     m_pPage = page;
 
     QImage image = m_pPage->convertToImage();
 
     int previewWidth = 64;
     int previewHeight = 64;
 
     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 previewImage = image.smoothScale((int)(image.width() * scale) , (int)(image.height() * scale));
 
     QPixmap previewPixmap;
     previewPixmap.convertFromImage(previewImage);
 
     QPixmap pixmap(64, 64);
 
     pixmap.fill(listView()->colorGroup().mid());
     bitBlt(&pixmap, (pixmap.width() - previewPixmap.width()) / 2,
            (pixmap.height() - previewPixmap.height()) / 2, &previewPixmap);
 
     setPixmap(0, pixmap);
 }
 
 PageListViewItem::~PageListViewItem()
@@ -98,139 +100,173 @@ void PageListView::updateView()
         QListIterator<Page> it(pageList);
 
         for (; it.current(); ++it) {
             new PageListViewItem(it.current(), this);
         }
         
         setSorting(0, false);
         select(m_pDrawPadCanvas->currentPage());
     }
 }
 
 void PageListView::resizeEvent(QResizeEvent* e)
 {
     Q_UNUSED(e);
 
     setColumnWidth(1, contentsRect().width() - columnWidth(0) - verticalScrollBar()->width());
 }
 
 void PageListView::select(Page* page)
 {
     PageListViewItem* item = (PageListViewItem*)firstChild();
 
     while (item) {
         if (item->page() == page) {
             setSelected(item, true);
             ensureItemVisible(item);
             break;
         }
 
         item = (PageListViewItem*)(item->nextSibling());
     }
 }
 
 Page* PageListView::selected() const
 {
     Page* page;
 
     PageListViewItem* item = (PageListViewItem*)selectedItem();
 
     if (item) {
         page = item->page();
     } else {
         page = NULL;
     }
 
     return page;
 }
 
-ThumbnailView::ThumbnailView(DrawPadCanvas* drawPadCanvas, QWidget* parent, const char* name)
+ThumbnailView::ThumbnailView(DrawPad* drawPad, DrawPadCanvas* drawPadCanvas, QWidget* parent, const char* name)
     : QWidget(parent, name, Qt::WType_Modal | Qt::WType_TopLevel)
 {
     inLoop = false;
+
+    m_pDrawPad = drawPad;
     m_pDrawPadCanvas = drawPadCanvas;
 
     setCaption(tr("Thumbnail"));
 
     QToolButton* newPageButton = new QToolButton(this);
     newPageButton->setIconSet(Resource::loadIconSet("new"));
     newPageButton->setAutoRaise(true);
+    connect(newPageButton, SIGNAL(clicked()), this, SLOT(newPage()));
 
     QToolButton* clearPageButton = new QToolButton(this);
     clearPageButton->setIconSet(Resource::loadIconSet("drawpad/clear"));
     clearPageButton->setAutoRaise(true);
+    connect(clearPageButton, SIGNAL(clicked()), this, SLOT(clearPage()));
 
     QToolButton* deletePageButton = new QToolButton(this);
     deletePageButton->setIconSet(Resource::loadIconSet("trash"));
     deletePageButton->setAutoRaise(true);
     connect(deletePageButton, SIGNAL(clicked()), this, SLOT(deletePage()));
 
     QToolButton* movePageUpButton = new QToolButton(this);
     movePageUpButton->setIconSet(Resource::loadIconSet("up"));
     movePageUpButton->setAutoRaise(true);
 
     QToolButton* movePageDownButton = new QToolButton(this);
     movePageDownButton->setIconSet(Resource::loadIconSet("down"));
     movePageDownButton->setAutoRaise(true);
 
     m_pPageListView = new PageListView(m_pDrawPadCanvas, this);
     connect(m_pPageListView, SIGNAL(selectionChanged()), this, SLOT(changePage()));
 
     QVBoxLayout* mainLayout = new QVBoxLayout(this, 4, 4);
     QHBoxLayout* buttonLayout = new QHBoxLayout(0);
 
     buttonLayout->addWidget(newPageButton);
     buttonLayout->addWidget(clearPageButton);
     buttonLayout->addWidget(deletePageButton);
     buttonLayout->addStretch();
     buttonLayout->addWidget(movePageUpButton);
     buttonLayout->addWidget(movePageDownButton);
 
     mainLayout->addLayout(buttonLayout);
     mainLayout->addWidget(m_pPageListView);
 }
 
 ThumbnailView::~ThumbnailView()
 {
     hide();
 }
 
 void ThumbnailView::hide()
 {
     QWidget::hide();
 
     if (inLoop) {
         inLoop = false;
         qApp->exit_loop();
     }
 }
 
 void ThumbnailView::exec()
 {
     show();
 
     if (!inLoop) {
         inLoop = true;
         qApp->enter_loop();
     }
 }
 
+void ThumbnailView::newPage()
+{
+    QRect rect = m_pDrawPadCanvas->contentsRect();
+
+    NewPageDialog newPageDialog(rect.width(), rect.height(), m_pDrawPad->pen().color(),
+                                m_pDrawPad->brush().color(), this);
+
+    if (newPageDialog.exec() == QDialog::Accepted) {
+        m_pDrawPadCanvas->newPage(newPageDialog.selectedWidth(), newPageDialog.selectedHeight(),
+                                  newPageDialog.selectedColor());
+        m_pPageListView->updateView();
+    }
+}
+
+void ThumbnailView::clearPage()
+{
+    QMessageBox messageBox(tr("Clear Page"), tr("Do you want to clear\nthe selected 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();
+        m_pPageListView->updateView();
+    }
+}
+
 void ThumbnailView::deletePage()
 {
     QMessageBox messageBox(tr("Delete Page"), tr("Do you want to delete\nthe selected 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();
         m_pPageListView->updateView();
     }
 }
 
 void ThumbnailView::changePage()
 {
     m_pDrawPadCanvas->selectPage(m_pPageListView->selected());
 }
diff --git a/noncore/graphics/drawpad/thumbnailview.h b/noncore/graphics/drawpad/thumbnailview.h
index 9417655..1fdb168 100644
--- a/noncore/graphics/drawpad/thumbnailview.h
+++ b/noncore/graphics/drawpad/thumbnailview.h
@@ -1,75 +1,80 @@
 /***************************************************************************
  *                                                                         *
  *   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 THUMBNAILVIEW_H
 #define THUMBNAILVIEW_H
 
 #include <qwidget.h>
 #include <qlistview.h>
 
+class DrawPad;
 class DrawPadCanvas;
 class Page;
 
 class PageListViewItem : public QListViewItem
 {
 public:
     PageListViewItem(Page* page, QListView* parent);
     ~PageListViewItem();
 
     Page* page() const;
 
 private:
     Page* m_pPage;
 };
 
 class PageListView : public QListView
 {
 public:
     PageListView(DrawPadCanvas* drawPadCanvas, QWidget* parent = 0, const char* name = 0);
     ~PageListView();
 
     void updateView();
 
     void select(Page* page);
     Page* selected() const;
 
 protected:
     void resizeEvent(QResizeEvent* e);
 
 private:
     DrawPadCanvas* m_pDrawPadCanvas;
 };
 
 class ThumbnailView : public QWidget
 {
     Q_OBJECT
 
 public:
-    ThumbnailView(DrawPadCanvas* drawPadCanvas, QWidget* parent = 0, const char* name = 0);
+    ThumbnailView(DrawPad* drawPad, DrawPadCanvas* drawPadCanvas, QWidget* parent = 0, const char* name = 0);
     ~ThumbnailView();
     
     void hide();
     void exec();
 
 public slots:
+    void newPage();
+    void clearPage();
     void deletePage();
     void changePage();
 
 private:
     bool inLoop;
+
+    DrawPad* m_pDrawPad;
     DrawPadCanvas* m_pDrawPadCanvas;
 
     PageListView* m_pPageListView;
 };
 
 #endif // THUMBNAILVIEW_H