Changing page order now works in thumbnail view

4 files changed, 65 insertions, 9 deletions

diff --git a/noncore/graphics/drawpad/drawpadcanvas.cpp b/noncore/graphics/drawpad/drawpadcanvas.cpp
index c23ee34..bcb6877 100644
--- a/noncore/graphics/drawpad/drawpadcanvas.cpp
+++ b/noncore/graphics/drawpad/drawpadcanvas.cpp
@@ -1,542 +1,560 @@
 /***************************************************************************
  *                                                                         *
  *   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>
 
 #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()
 {
 }
 
 QList<Page> DrawPadCanvasXmlHandler::pages()
 {
     return m_pages;
 }
 
 bool DrawPadCanvasXmlHandler::startElement(const QString& namespaceURI, const QString& localName,
                                            const QString& qName, const QXmlAttributes& atts)
 {
     Q_CONST_UNUSED(namespaceURI)
     Q_CONST_UNUSED(localName)
 
     if (qName.compare("data") == 0) {
         m_state = InData;
         m_dataLenght = atts.value("length").toULong();
         m_dataFormat = atts.value("format");
 
         if (m_dataFormat.isEmpty()) {
             m_dataFormat = "XPM";
         }
     }
 
     return true;
 }
 
 bool DrawPadCanvasXmlHandler::endElement(const QString& namespaceURI, const QString& localName,
                                          const QString& qName)
 {
     Q_CONST_UNUSED(namespaceURI)
     Q_CONST_UNUSED(localName)
 
     if (qName.compare("data") == 0) {
         m_state = Unknown;
     }
 
     return true;
 }
 
 bool DrawPadCanvasXmlHandler::characters(const QString& ch) 
 {
     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;
 
         if (m_dataFormat == "XPM") {
             if (m_dataLenght < ch.length() * 5) {
                 m_dataLenght = ch.length() * 5;
             }
 
             QByteArray byteArrayUnzipped(m_dataLenght);
             ::uncompress((uchar*)byteArrayUnzipped.data(), &m_dataLenght, (uchar*)byteArray.data(), byteArray.size());
 
             image.loadFromData((const uchar*)byteArrayUnzipped.data(), m_dataLenght, m_dataFormat);
         } else {
             image.loadFromData((const uchar*)byteArray.data(), m_dataLenght, m_dataFormat);
         }
 
         Page* page = new Page(image.width(), image.height());
         page->convertFromImage(image);
         m_pages.append(page);
     }
 
     return true;
 }
 
 DrawPadCanvas::DrawPadCanvas(DrawPad* drawPad, QWidget* parent, const char* name)
     : QScrollView(parent, name)
 {
     m_pDrawPad = drawPad;
     m_pages.setAutoDelete(true);
     m_pageBackups.setAutoDelete(true);
 
     viewport()->setBackgroundMode(QWidget::NoBackground);
 }
 
 DrawPadCanvas::~DrawPadCanvas()
 {
 }
 
 void DrawPadCanvas::load(QIODevice* ioDevice)
 {
     QTextStream textStream(ioDevice);
     textStream.setCodec(QTextCodec::codecForName("UTF-8"));
 
     QXmlInputSource xmlInputSource(textStream);
     QXmlSimpleReader xmlSimpleReader;
     DrawPadCanvasXmlHandler drawPadCanvasXmlHandler;
 
     xmlSimpleReader.setContentHandler(&drawPadCanvasXmlHandler);
     xmlSimpleReader.parse(xmlInputSource);
 
     m_pages = drawPadCanvasXmlHandler.pages();
 
     if (m_pages.isEmpty()) {
         m_pages.append(new Page(contentsRect().size()));
         m_pages.current()->fill(Qt::white);
     }
 
     m_pageBackups.clear();
     m_pageBackups.append(new Page(*(m_pages.current())));
 
     resizeContents(m_pages.current()->width(), m_pages.current()->height());
     viewport()->update();
 
     emit pagesChanged();
     emit pageBackupsChanged();
 }
 
 void DrawPadCanvas::initialPage()
 {
     m_pages.append(new Page(236, 232));
     m_pages.current()->fill(Qt::white);
 
     m_pageBackups.clear();
     m_pageBackups.append(new Page(*(m_pages.current())));
 
     resizeContents(m_pages.current()->width(), m_pages.current()->height());
     viewport()->update();
 
     emit pagesChanged();
     emit pageBackupsChanged();
 }
 
 void DrawPadCanvas::save(QIODevice* ioDevice)
 {
     QTextStream textStream(ioDevice);
     textStream.setCodec(QTextCodec::codecForName("UTF-8"));
 
     textStream << "<drawpad>" << endl;
     textStream << "    <images>" << endl;
 
     QListIterator<Page> bufferIterator(m_pages);
 
     for (bufferIterator.toFirst(); bufferIterator.current() != 0; ++bufferIterator) {
         textStream << "        <image>" << endl;
 
         QImage image = bufferIterator.current()->convertToImage();
         QByteArray byteArray;
         QBuffer buffer(byteArray);
         QImageIO imageIO(&buffer, "PNG");
 
         buffer.open(IO_WriteOnly);
         imageIO.setImage(image);
         imageIO.write();
         buffer.close();
 
         textStream << "            <data length=\"" << byteArray.size() << "\" format=\"PNG\">";
 
         static const char hexchars[] = "0123456789abcdef";
 
         for (int i = 0; i < (int)byteArray.size(); i++ ) {
             uchar s = (uchar)byteArray[i];
             textStream << hexchars[s >> 4];
             textStream << hexchars[s & 0x0f];
         }
 
         textStream << "</data>" << endl;
         textStream << "        </image>" << endl;
     }
 
     textStream << "    </images>" << endl;
     textStream << "</drawpad>";
 }
 
 void DrawPadCanvas::importPage(const QString& fileName)
 {
     Page* importedPage = new Page();
 
     importedPage->load(fileName);
     m_pages.insert(m_pages.at() + 1, importedPage);
 
     m_pageBackups.clear();
     m_pageBackups.append(new Page(*(m_pages.current())));
 
     resizeContents(m_pages.current()->width(), m_pages.current()->height());
     viewport()->update();
 
     emit pagesChanged();
     emit pageBackupsChanged();
 }
 
 void DrawPadCanvas::exportPage(uint fromPage, uint toPage, const QString& name,const QString& format)
 {
     if (fromPage == toPage) {
         DocLnk docLnk;
         MimeType mimeType(format);
 
         docLnk.setName(name);
         docLnk.setType(mimeType.id());
 
         FileManager fileManager;
         QIODevice* ioDevice = fileManager.saveFile(docLnk);
         QImageIO imageIO(ioDevice, format);
 
         QImage image = m_pages.current()->convertToImage();
         imageIO.setImage(image);
         imageIO.write();
         delete ioDevice;
     } else {
         for (uint i = fromPage; i <= toPage; i++) {
             DocLnk docLnk;
             MimeType mimeType(format);
 
             docLnk.setName(name + QString::number(i));
             docLnk.setType(mimeType.id());
 
             FileManager fileManager;
             QIODevice* ioDevice = fileManager.saveFile(docLnk);
             QImageIO imageIO(ioDevice, format);
 
             QImage image = m_pages.at(i - 1)->convertToImage();
             imageIO.setImage(image);
             imageIO.write();
             delete ioDevice;
         }
     }
 }
 
 Page* DrawPadCanvas::currentPage()
 {
     return m_pages.current();
 }
 
 QList<Page> DrawPadCanvas::pages()
 {
     return m_pages;
 }
 
 uint DrawPadCanvas::pagePosition()
 {
     return (m_pages.at() + 1);
 }
 
 uint DrawPadCanvas::pageCount()
 {
     return m_pages.count();
 }
 
 void DrawPadCanvas::selectPage(Page* page)
 {
     m_pages.findRef(page);
     m_pageBackups.clear();
     m_pageBackups.append(new Page(*(m_pages.current())));
 
     resizeContents(m_pages.current()->width(), m_pages.current()->height());
     viewport()->update();
 
     emit pagesChanged();
     emit pageBackupsChanged();
 }
 
 void DrawPadCanvas::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(uint width, uint height, const QColor& color)
 {
     m_pages.insert(m_pages.at() + 1, new Page(width, height));
     m_pages.current()->fill(color);
 
     m_pageBackups.clear();
     m_pageBackups.append(new Page(*(m_pages.current())));
 
     resizeContents(m_pages.current()->width(), m_pages.current()->height());
     viewport()->update();
 
     emit pagesChanged();
     emit pageBackupsChanged();
 }
 
 void DrawPadCanvas::clearPage()
 {
     m_pages.current()->fill(Qt::white);
 
     m_pageBackups.clear();
     m_pageBackups.append(new Page(*(m_pages.current())));
 
     resizeContents(m_pages.current()->width(), m_pages.current()->height());
     viewport()->update();
 
     emit pageBackupsChanged();
 }
 
 void DrawPadCanvas::deletePage()
 {
     m_pages.remove(m_pages.current());
 
     if (m_pages.isEmpty()) {
         m_pages.append(new Page(contentsRect().size()));
         m_pages.current()->fill(Qt::white);
     }
 
     m_pageBackups.clear();
     m_pageBackups.append(new Page(*(m_pages.current())));
 
     resizeContents(m_pages.current()->width(), m_pages.current()->height());
     viewport()->update();
 
     emit pagesChanged();
     emit pageBackupsChanged();
 }
 
+void DrawPadCanvas::movePageUp()
+{
+    int index = m_pages.at();
+    Page* page = m_pages.take();
+    m_pages.insert(index - 1, page);
+
+    emit pagesChanged();
+}
+
+void DrawPadCanvas::movePageDown()
+{
+    int index = m_pages.at();
+    Page* page = m_pages.take();
+    m_pages.insert(index + 1, page);
+
+    emit pagesChanged();
+}
+
 bool DrawPadCanvas::undoEnabled()
 {
     return (m_pageBackups.current() != m_pageBackups.getFirst());
 }
 
 bool DrawPadCanvas::redoEnabled()
 {
     return (m_pageBackups.current() != m_pageBackups.getLast());
 }
 
 bool DrawPadCanvas::goPreviousPageEnabled()
 {
     return (m_pages.current() != m_pages.getFirst());
 }
 
 bool DrawPadCanvas::goNextPageEnabled()
 {
     return (m_pages.current() != m_pages.getLast());
 }
 
 void DrawPadCanvas::undo()
 {
     *(m_pages.current()) = *(m_pageBackups.prev());
 
     viewport()->update();
 
     emit pageBackupsChanged();
 }
 
 void DrawPadCanvas::redo()
 {
     *(m_pages.current()) = *(m_pageBackups.next());
 
     viewport()->update();
 
     emit pageBackupsChanged();
 }
 
 void DrawPadCanvas::goFirstPage()
 {
     m_pages.first();
     m_pageBackups.clear();
     m_pageBackups.append(new Page(*(m_pages.current())));
 
     resizeContents(m_pages.current()->width(), m_pages.current()->height());
     viewport()->update();
 
     emit pagesChanged();
     emit pageBackupsChanged();
 }
 
 void DrawPadCanvas::goPreviousPage()
 {
     m_pages.prev();
     m_pageBackups.clear();
     m_pageBackups.append(new Page(*(m_pages.current())));
 
     resizeContents(m_pages.current()->width(), m_pages.current()->height());
     viewport()->update();
 
     emit pagesChanged();
     emit pageBackupsChanged();
 }
 
 void DrawPadCanvas::goNextPage()
 {
     m_pages.next();
     m_pageBackups.clear();
     m_pageBackups.append(new Page(*(m_pages.current())));
 
     resizeContents(m_pages.current()->width(), m_pages.current()->height());
     viewport()->update();
 
     emit pagesChanged();
     emit pageBackupsChanged();
 }
 
 void DrawPadCanvas::goLastPage()
 {
     m_pages.last();
     m_pageBackups.clear();
     m_pageBackups.append(new Page(*(m_pages.current())));
 
     resizeContents(m_pages.current()->width(), m_pages.current()->height());
     viewport()->update();
 
     emit pagesChanged();
     emit pageBackupsChanged();
 }
 
 void DrawPadCanvas::contentsMousePressEvent(QMouseEvent* e)
 {
     m_pDrawPad->tool()->mousePressEvent(e);
 }
 
 void DrawPadCanvas::contentsMouseReleaseEvent(QMouseEvent* e)
 {
     m_pDrawPad->tool()->mouseReleaseEvent(e);
 }
 
 void DrawPadCanvas::contentsMouseMoveEvent(QMouseEvent* e)
 {
     m_pDrawPad->tool()->mouseMoveEvent(e);
 }
 
 void DrawPadCanvas::drawContents(QPainter* p, int cx, int cy, int cw, int ch)
 {
     QRect clipRect(cx, cy, cw, ch);
     QRect pixmapRect(0, 0, m_pages.current()->width(), m_pages.current()->height());
     QRect drawRect = pixmapRect.intersect(clipRect);
 
     p->drawPixmap(drawRect.topLeft(), *(m_pages.current()), drawRect);
 
     if (drawRect.right() < clipRect.right()) {
         p->fillRect(drawRect.right() + 1, cy, cw - drawRect.width(), ch, colorGroup().dark());
     }
 
     if (drawRect.bottom() < clipRect.bottom()) {
         p->fillRect(cx, drawRect.bottom() + 1, cw, ch - drawRect.height(), colorGroup().dark());
     }
 }
diff --git a/noncore/graphics/drawpad/drawpadcanvas.h b/noncore/graphics/drawpad/drawpadcanvas.h
index d74d425..39cf752 100644
--- a/noncore/graphics/drawpad/drawpadcanvas.h
+++ b/noncore/graphics/drawpad/drawpadcanvas.h
@@ -1,83 +1,85 @@
 /***************************************************************************
  *                                                                         *
  *   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 backupPage();
 
 public slots:
     void deleteAll();
     void newPage(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/thumbnailview.cpp b/noncore/graphics/drawpad/thumbnailview.cpp
index 0c7934e..428e008 100644
--- a/noncore/graphics/drawpad/thumbnailview.cpp
+++ b/noncore/graphics/drawpad/thumbnailview.cpp
@@ -1,272 +1,299 @@
 /***************************************************************************
  *                                                                         *
  *   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()
 {
 }
 
 Page* PageListViewItem::page() const
 {
     return m_pPage;
 }
 
 PageListView::PageListView(DrawPadCanvas* drawPadCanvas, QWidget* parent, const char* name)
     : QListView(parent, name)
 {
     m_pDrawPadCanvas = drawPadCanvas;
 
     header()->hide();
     setVScrollBarMode(QScrollView::AlwaysOn);
     setAllColumnsShowFocus(true);
 
     addColumn(tr("Thumbnail"));
     addColumn(tr("Information"));
 
     updateView();
 }
 
 PageListView::~PageListView()
 {
 }
 
 void PageListView::updateView()
 {
     clear();
 
     if (m_pDrawPadCanvas) {
         QList<Page> pageList = m_pDrawPadCanvas->pages();
         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(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("DrawPad - Thumbnail View"));
 
     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);
+    m_pMovePageUpButton = new QToolButton(this);
+    m_pMovePageUpButton->setIconSet(Resource::loadIconSet("up"));
+    m_pMovePageUpButton->setAutoRaise(true);
+    connect(m_pMovePageUpButton, SIGNAL(clicked()), this, SLOT(movePageUp()));
 
-    QToolButton* movePageDownButton = new QToolButton(this);
-    movePageDownButton->setIconSet(Resource::loadIconSet("down"));
-    movePageDownButton->setAutoRaise(true);
+    m_pMovePageDownButton = new QToolButton(this);
+    m_pMovePageDownButton->setIconSet(Resource::loadIconSet("down"));
+    m_pMovePageDownButton->setAutoRaise(true);
+    connect(m_pMovePageDownButton, SIGNAL(clicked()), this, SLOT(movePageDown()));
 
     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);
+    buttonLayout->addWidget(m_pMovePageUpButton);
+    buttonLayout->addWidget(m_pMovePageDownButton);
 
     mainLayout->addLayout(buttonLayout);
     mainLayout->addWidget(m_pPageListView);
+
+    updateView();
 }
 
 ThumbnailView::~ThumbnailView()
 {
     hide();
 }
 
+void ThumbnailView::updateView()
+{
+    m_pMovePageUpButton->setEnabled(m_pDrawPadCanvas->goPreviousPageEnabled());
+    m_pMovePageDownButton->setEnabled(m_pDrawPadCanvas->goNextPageEnabled());
+}
+
 void ThumbnailView::hide()
 {
     QWidget::hide();
 
     if (inLoop) {
         inLoop = false;
         qApp->exit_loop();
     }
 }
 
 void ThumbnailView::exec()
 {
     show();
 
     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();
+        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();
+        updateView();
     }
 }
 
+void ThumbnailView::movePageUp()
+{
+    m_pDrawPadCanvas->movePageUp();
+    m_pPageListView->updateView();
+    updateView();
+}
+
+void ThumbnailView::movePageDown()
+{
+    m_pDrawPadCanvas->movePageDown();
+    m_pPageListView->updateView();
+    updateView();
+}
+
 void ThumbnailView::changePage()
 {
     m_pDrawPadCanvas->selectPage(m_pPageListView->selected());
+    updateView();
 }
diff --git a/noncore/graphics/drawpad/thumbnailview.h b/noncore/graphics/drawpad/thumbnailview.h
index 1fdb168..eb748fa 100644
--- a/noncore/graphics/drawpad/thumbnailview.h
+++ b/noncore/graphics/drawpad/thumbnailview.h
@@ -1,80 +1,89 @@
 /***************************************************************************
  *                                                                         *
  *   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 QToolButton;
+
 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(DrawPad* drawPad, DrawPadCanvas* drawPadCanvas, QWidget* parent = 0, const char* name = 0);
     ~ThumbnailView();
-    
+
+    void updateView();
+
     void hide();
     void exec();
 
 public slots:
     void newPage();
     void clearPage();
     void deletePage();
+    void movePageUp();
+    void movePageDown();
     void changePage();
 
 private:
     bool inLoop;
 
     DrawPad* m_pDrawPad;
     DrawPadCanvas* m_pDrawPadCanvas;
 
+    QToolButton* m_pMovePageUpButton;
+    QToolButton* m_pMovePageDownButton;
+
     PageListView* m_pPageListView;
 };
 
 #endif // THUMBNAILVIEW_H