DrawPad: libopie -> libopie2

9 files changed, 19 insertions, 19 deletions

diff --git a/noncore/graphics/drawpad/config.in b/noncore/graphics/drawpad/config.in
index 290a642..3ed03a4 100644
--- a/noncore/graphics/drawpad/config.in
+++ b/noncore/graphics/drawpad/config.in
@@ -1,4 +1,4 @@
   config DRAWPAD
     boolean "opie-drawpad (take simple notes or draw images)"
     default "y"
-    depends ( LIBQPE || LIBQPE-X11 ) && LIBOPIE
+    depends ( LIBQPE || LIBQPE-X11 ) && LIBOPIE2CORE && LIBOPIE2UI && LIBQTAUX
diff --git a/noncore/graphics/drawpad/drawpad.cpp b/noncore/graphics/drawpad/drawpad.cpp
index 9f0e27f..55b23cc 100644
--- a/noncore/graphics/drawpad/drawpad.cpp
+++ b/noncore/graphics/drawpad/drawpad.cpp
@@ -1,663 +1,663 @@
 /***************************************************************************
  *                                                                         *
  *   DrawPad - a drawing program for Opie Environment                      *
  *                                                                         *
  *   (C) 2002 by S. Prud'homme <prudhomme@laposte.net>                     *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 
 #include "drawpad.h"
 
 #include "drawpadcanvas.h"
 #include "ellipsetool.h"
 #include "erasetool.h"
 #include "exportdialog.h"
 #include "filledellipsetool.h"
 #include "filledrectangletool.h"
 #include "filltool.h"
 #include "importdialog.h"
 #include "linetool.h"
 #include "newpagedialog.h"
 #include "page.h"
 #include "pageinformationdialog.h"
 #include "pointtool.h"
 #include "rectangletool.h"
 #include "texttool.h"
 #include "thumbnailview.h"
 
-#include <opie/colordialog.h>
-#include <opie/colorpopupmenu.h>
+#include <opie2/qcolordialog.h>
+#include <opie2/ocolorpopupmenu.h>
 
 #include <qpe/applnk.h>
 #include <qpe/config.h>
 #include <qpe/qpetoolbar.h>
 #include <qpe/resource.h>
 #include <qpe/qpeapplication.h>
 
 #include <qmenubar.h>
 #include <qaction.h>
 #include <qfile.h>
 #include <qmessagebox.h>
 #include <qspinbox.h>
 #include <qtoolbutton.h>
 #include <qtooltip.h>
 #include <qwhatsthis.h>
 
-DrawPad::DrawPad(QWidget* parent, const char* name,  WFlags fl )
+DrawPad::DrawPad(QWidget* parent, const char* name,  WFlags /*fl*/ )
     : QMainWindow(parent, name, WStyle_ContextHelp)
 {
     // init members
 
     m_pDrawPadCanvas = new DrawPadCanvas(this, this);
 
     connect(m_pDrawPadCanvas, SIGNAL(pagesChanged()), this, SLOT(updateView()));
 
     setCentralWidget(m_pDrawPadCanvas);
 
     // init menu
 
     setToolBarsMovable(false);
 
     QToolBar* menuToolBar = new QToolBar(this);
     QMenuBar* menuBar = new QMenuBar(menuToolBar);
 
     QPopupMenu* toolsPopupMenu = new QPopupMenu(menuBar);
 
     QAction* deleteAllAction = new QAction(tr("Delete All"), QString::null, 0, this);
     connect(deleteAllAction, SIGNAL(activated()), this, SLOT(deleteAll()));
     deleteAllAction->addTo(toolsPopupMenu);
 
     toolsPopupMenu->insertSeparator();
 
     QAction* importPageAction = new QAction(tr("Import"), tr("Import..."), 0, this);
     connect(importPageAction, SIGNAL(activated()), this, SLOT(importPage()));
     importPageAction->addTo(toolsPopupMenu);
 
     QAction* exportPageAction = new QAction(tr("Export"), tr("Export..."), 0, this);
     connect(exportPageAction, SIGNAL(activated()), this, SLOT(exportPage()));
     exportPageAction->addTo(toolsPopupMenu);
 
     toolsPopupMenu->insertSeparator();
 
     QAction* thumbnailViewAction = new QAction(tr("Thumbnail View"), tr("Thumbnail View..."), 0, this);
     connect(thumbnailViewAction, SIGNAL(activated()), this, SLOT(thumbnailView()));
     thumbnailViewAction->addTo(toolsPopupMenu);
 
     QAction* pageInformationAction = new QAction(tr("Page Information"), tr("Page Information..."), 0, this);
     connect(pageInformationAction, SIGNAL(activated()), this, SLOT(pageInformation()));
     pageInformationAction->addTo(toolsPopupMenu);
 
     toolsPopupMenu->insertSeparator();
 
     m_pAntiAliasingAction = new QAction(tr("Anti-Aliasing"), QString::null, 0, this);
     m_pAntiAliasingAction->setToggleAction(true);
     m_pAntiAliasingAction->addTo(toolsPopupMenu);
 
     menuBar->insertItem(tr("Tools"), toolsPopupMenu);
 
     // init page toolbar
 
     QToolBar* pageToolBar = new QToolBar(this);
 
     QAction* newPageAction = new QAction(tr("New Page"), Resource::loadPixmap("new"), QString::null, 0, this);
     connect(newPageAction, SIGNAL(activated()), this, SLOT(newPage()));
     newPageAction->addTo(pageToolBar);
     newPageAction->setWhatsThis( tr( "Click here to add a new sheet." ) );
 
     QAction* clearPageAction = new QAction(tr("Clear Page"), Resource::loadPixmap("drawpad/clear"), QString::null, 0, this);
     connect(clearPageAction, SIGNAL(activated()), this, SLOT(clearPage()));
     clearPageAction->addTo(pageToolBar);
     clearPageAction->setWhatsThis( tr( "Click here to erase the current sheet." ) );
 
     QAction* deletePageAction = new QAction(tr("Delete Page"), Resource::loadPixmap("trash"), QString::null, 0, this);
     connect(deletePageAction, SIGNAL(activated()), this, SLOT(deletePage()));
     deletePageAction->addTo(pageToolBar);
     deletePageAction->setWhatsThis( tr( "Click here to remove the current sheet." ) );
 
     QToolBar* emptyToolBar = new QToolBar(this);
     emptyToolBar->setHorizontalStretchable(true);
 
     // init navigation toolbar
 
     QToolBar* navigationToolBar = new QToolBar(this);
 
     m_pUndoAction = new QAction(tr("Undo"), Resource::loadIconSet("undo"), QString::null, 0, this);
     connect(m_pUndoAction, SIGNAL(activated()), m_pDrawPadCanvas, SLOT(undo()));
     m_pUndoAction->addTo(navigationToolBar);
     m_pUndoAction->setWhatsThis( tr( "Click here to undo the last action." ) );
 
     m_pRedoAction = new QAction(tr("Redo"), Resource::loadIconSet("redo"), QString::null, 0, this);
     connect(m_pRedoAction, SIGNAL(activated()), m_pDrawPadCanvas, SLOT(redo()));
     m_pRedoAction->addTo(navigationToolBar);
     m_pRedoAction->setWhatsThis( tr( "Click here to re-perform the last action." ) );
 
     m_pFirstPageAction = new QAction(tr("First Page"), Resource::loadIconSet("fastback"), QString::null, 0, this);
     connect(m_pFirstPageAction, SIGNAL(activated()), m_pDrawPadCanvas, SLOT(goFirstPage()));
     m_pFirstPageAction->addTo(navigationToolBar);
     m_pFirstPageAction->setWhatsThis( tr( "Click here to view the first page." ) );
 
     m_pPreviousPageAction = new QAction(tr("Previous Page"), Resource::loadIconSet("back"), QString::null, 0, this);
     connect(m_pPreviousPageAction, SIGNAL(activated()), m_pDrawPadCanvas, SLOT(goPreviousPage()));
     m_pPreviousPageAction->addTo(navigationToolBar);
     m_pPreviousPageAction->setWhatsThis( tr( "Click here to view the previous page." ) );
 
     m_pNextPageAction = new QAction(tr("Next Page"), Resource::loadIconSet("forward"), QString::null, 0, this);
     connect(m_pNextPageAction, SIGNAL(activated()), m_pDrawPadCanvas, SLOT(goNextPage()));
     m_pNextPageAction->addTo(navigationToolBar);
     m_pNextPageAction->setWhatsThis( tr( "Click here to view the next page." ) );
 
     m_pLastPageAction = new QAction(tr("Last Page"), Resource::loadIconSet("fastforward"), QString::null, 0, this);
     connect(m_pLastPageAction, SIGNAL(activated()), m_pDrawPadCanvas, SLOT(goLastPage()));
     m_pLastPageAction->addTo(navigationToolBar);
     m_pLastPageAction->setWhatsThis( tr( "Click here to view the last page." ) );
 
     // init draw mode toolbar
 
     QToolBar* drawModeToolBar = new QToolBar(this);
 
     m_pLineToolButton = new QToolButton(drawModeToolBar);
     m_pLineToolButton->setToggleButton(true);
     QWhatsThis::add( m_pLineToolButton, tr( "Click here to select one of the available tools to draw lines." ) );
 
 
     QPopupMenu* linePopupMenu = new QPopupMenu(m_pLineToolButton);
 
     m_pPointToolAction = new QAction(tr("Draw Point"), Resource::loadPixmap("drawpad/point"), "", 0, this);
     connect(m_pPointToolAction, SIGNAL(activated()), this, SLOT(setPointTool()));
     m_pPointToolAction->addTo(linePopupMenu);
 
     m_pLineToolAction = new QAction(tr("Draw Line"), Resource::loadPixmap("drawpad/line"), "", 0, this);
     connect(m_pLineToolAction, SIGNAL(activated()), this, SLOT(setLineTool()));
     m_pLineToolAction->addTo(linePopupMenu);
 
     m_pLineToolButton->setPopup(linePopupMenu);
     m_pLineToolButton->setPopupDelay(0);
 
     m_pRectangleToolButton = new QToolButton(drawModeToolBar);
     m_pRectangleToolButton->setToggleButton(true);
     QWhatsThis::add( m_pRectangleToolButton, tr( "Click here to select one of the available tools to draw rectangles." ) );
 
     QPopupMenu* rectanglePopupMenu = new QPopupMenu(m_pRectangleToolButton);
 
     m_pRectangleToolAction = new QAction(tr("Draw Rectangle"), Resource::loadPixmap("drawpad/rectangle"), "", 0, this);
     connect(m_pRectangleToolAction, SIGNAL(activated()), this, SLOT(setRectangleTool()));
     m_pRectangleToolAction->addTo(rectanglePopupMenu);
 
     m_pFilledRectangleToolAction = new QAction(tr("Draw Filled Rectangle"), Resource::loadPixmap("drawpad/filledrectangle"), "", 0, this);
     connect(m_pFilledRectangleToolAction, SIGNAL(activated()), this, SLOT(setFilledRectangleTool()));
     m_pFilledRectangleToolAction->addTo(rectanglePopupMenu);
 
     m_pRectangleToolButton->setPopup(rectanglePopupMenu);
     m_pRectangleToolButton->setPopupDelay(0);
 
     m_pEllipseToolButton = new QToolButton(drawModeToolBar);
     m_pEllipseToolButton->setToggleButton(true);
     QWhatsThis::add( m_pEllipseToolButton, tr( "Click here to select one of the available tools to draw ellipses." ) );
 
     QPopupMenu* ellipsePopupMenu = new QPopupMenu(m_pEllipseToolButton);
 
     m_pEllipseToolAction = new QAction(tr("Draw Ellipse"), Resource::loadPixmap("drawpad/ellipse"), "", 0, this);
     connect(m_pEllipseToolAction, SIGNAL(activated()), this, SLOT(setEllipseTool()));
     m_pEllipseToolAction->addTo(ellipsePopupMenu);
 
     m_pFilledEllipseToolAction = new QAction(tr("Draw Filled Ellipse"), Resource::loadPixmap("drawpad/filledellipse"), "", 0, this);
     connect(m_pFilledEllipseToolAction, SIGNAL(activated()), this, SLOT(setFilledEllipseTool()));
     m_pFilledEllipseToolAction->addTo(ellipsePopupMenu);
 
     m_pEllipseToolButton->setPopup(ellipsePopupMenu);
     m_pEllipseToolButton->setPopupDelay(0);
 
     m_pTextToolAction = new QAction(tr("Insert Text"), Resource::loadPixmap("drawpad/text"), QString::null, 0, this);
     m_pTextToolAction->setToggleAction(true);
     connect(m_pTextToolAction, SIGNAL(activated()), this, SLOT(setTextTool()));
     m_pTextToolAction->addTo(drawModeToolBar);
     m_pTextToolAction->setWhatsThis( tr( "Click here to select the text drawing tool." ) );
 
     m_pFillToolAction = new QAction(tr("Fill Region"), Resource::loadPixmap("drawpad/fill"), QString::null, 0, this);
     m_pFillToolAction->setToggleAction(true);
     connect(m_pFillToolAction, SIGNAL(activated()), this, SLOT(setFillTool()));
     m_pFillToolAction->addTo(drawModeToolBar);
     m_pFillToolAction->setWhatsThis( tr( "Click here to select the fill tool." ) );
 
     m_pEraseToolAction = new QAction(tr("Erase Point"), Resource::loadPixmap("drawpad/erase"), QString::null, 0, this);
     m_pEraseToolAction->setToggleAction(true);
     connect(m_pEraseToolAction, SIGNAL(activated()), this, SLOT(setEraseTool()));
     m_pEraseToolAction->addTo(drawModeToolBar);
     m_pEraseToolAction->setWhatsThis( tr( "Click here to select the eraser tool." ) );
 
     m_pTool = 0;
     setRectangleTool();
     setEllipseTool();
     setPointTool();
 
     emptyToolBar = new QToolBar(this);
     emptyToolBar->setHorizontalStretchable(true);
     emptyToolBar->addSeparator();
 
     // init draw parameters toolbar
 
     QToolBar* drawParametersToolBar = new QToolBar(this);
 
     m_pPenWidthSpinBox = new QSpinBox(1, 9, 1, drawParametersToolBar);
     connect(m_pPenWidthSpinBox, SIGNAL(valueChanged(int)), this, SLOT(changePenWidth(int)));
 
     QToolTip::add(m_pPenWidthSpinBox, tr("Pen Width"));
     m_pPenWidthSpinBox->setValue(1);
     m_pPenWidthSpinBox->setFocusPolicy(QWidget::NoFocus);
     QWhatsThis::add( m_pPenWidthSpinBox, tr( "Click here to select the width of the drawing pen." ) );
 
     m_pPenColorToolButton = new QToolButton(drawParametersToolBar);
     m_pPenColorToolButton->setPixmap(Resource::loadPixmap("drawpad/pencolor"));
     QWhatsThis::add( m_pPenColorToolButton, tr( "Click here to select the color used when drawing." ) );
 
-    OColorPopupMenu* penColorPopupMenu = new OColorPopupMenu(Qt::black, m_pPenColorToolButton);
+    Opie::OColorPopupMenu* penColorPopupMenu = new Opie::OColorPopupMenu(Qt::black, m_pPenColorToolButton);
     connect(penColorPopupMenu, SIGNAL(colorSelected(const QColor&)), this, SLOT(changePenColor(const QColor&)));
 
     QToolTip::add(m_pPenColorToolButton, tr("Pen Color"));
     m_pPenColorToolButton->setPopup(penColorPopupMenu);
     m_pPenColorToolButton->setPopupDelay(0);
 
     changePenColor(Qt::black);
 
     m_pBrushColorToolButton = new QToolButton(drawParametersToolBar);
     m_pBrushColorToolButton->setPixmap(Resource::loadPixmap("drawpad/brushcolor"));
     QWhatsThis::add( m_pBrushColorToolButton, tr( "Click here to select the color used when filling in areas." ) );
 
-    OColorPopupMenu* brushColorPopupMenu = new OColorPopupMenu(Qt::white, m_pBrushColorToolButton);
+    Opie::OColorPopupMenu* brushColorPopupMenu = new Opie::OColorPopupMenu(Qt::white, m_pBrushColorToolButton);
     connect(brushColorPopupMenu, SIGNAL(colorSelected(const QColor&)), this, SLOT(changeBrushColor(const QColor&)));
 
     QToolTip::add(m_pBrushColorToolButton, tr("Fill Color"));
     m_pBrushColorToolButton->setPopup(brushColorPopupMenu);
     m_pBrushColorToolButton->setPopupDelay(0);
 
     changeBrushColor(Qt::white);
 
     finishStartup();
 }
 
 
 void DrawPad::finishStartup()
 {
     // init pages
 
     QFile file(Global::applicationFileName("drawpad", "drawpad.xml"));
 
     if (file.open(IO_ReadOnly)) {
         m_pDrawPadCanvas->load(&file);
         file.close();
     } else {
         m_pDrawPadCanvas->initialPage();
     }
 
     loadConfig();
 
 }
 
 DrawPad::~DrawPad()
 {
     saveConfig();
 
     QFile file(Global::applicationFileName("drawpad", "drawpad.xml"));
 
     if (file.open(IO_WriteOnly)) {
         m_pDrawPadCanvas->save(&file);
         file.close();
     }
 }
 
 bool DrawPad::antiAliasing()
 {
     return (m_pAntiAliasingAction->isOn());
 }
 
 void DrawPad::newPage()
 {
     QRect rect = m_pDrawPadCanvas->contentsRect();
 
     NewPageDialog newPageDialog(rect.width(), rect.height(), m_pen.color(), m_brush.color(), this);
 
     if (newPageDialog.exec() == QDialog::Accepted) {
         m_pDrawPadCanvas->newPage(newPageDialog.selectedTitle(), newPageDialog.selectedWidth(),
                                   newPageDialog.selectedHeight(), newPageDialog.selectedColor());
     }
 }
 
 void DrawPad::clearPage()
 {
     QMessageBox messageBox(tr("Clear Page"), tr("Do you want to clear\nthe current page?"),
                            QMessageBox::Information, QMessageBox::Yes,
                            QMessageBox::No | QMessageBox::Escape | QMessageBox::Default,
                            QMessageBox::NoButton, this);
 
     messageBox.setButtonText(QMessageBox::Yes, tr("Yes"));
     messageBox.setButtonText(QMessageBox::No, tr("No"));
 
     if (messageBox.exec() == QMessageBox::Yes) {
         m_pDrawPadCanvas->clearPage();
     }
 }
 
 void DrawPad::deletePage()
 {
     QMessageBox messageBox(tr("Delete Page"), tr("Do you want to delete\nthe current page?"),
                            QMessageBox::Information, QMessageBox::Yes,
                            QMessageBox::No | QMessageBox::Escape | QMessageBox::Default,
                            QMessageBox::NoButton, this);
 
     messageBox.setButtonText(QMessageBox::Yes, tr("Yes"));
     messageBox.setButtonText(QMessageBox::No, tr("No"));
 
     if (messageBox.exec() == QMessageBox::Yes) {
         m_pDrawPadCanvas->deletePage();
     }
 }
 
 void DrawPad::setPointTool()
 {
     if (m_pTool) {
         delete m_pTool;
     }
 
     m_pTool = new PointTool(this, m_pDrawPadCanvas);
 
     m_pLineToolButton->setIconSet(m_pPointToolAction->iconSet());
     QToolTip::add(m_pLineToolButton, m_pPointToolAction->text());
 
     disconnect(m_pLineToolButton, SIGNAL(clicked()), 0, 0);
     connect(m_pLineToolButton, SIGNAL(clicked()), m_pPointToolAction, SIGNAL(activated()));
 
     m_pLineToolButton->setOn(true);
     m_pRectangleToolButton->setOn(false);
     m_pEllipseToolButton->setOn(false);
     m_pTextToolAction->setOn(false);
     m_pFillToolAction->setOn(false);
     m_pEraseToolAction->setOn(false);
 }
 
 void DrawPad::setLineTool()
 {
     if (m_pTool) {
         delete m_pTool;
     }
 
     m_pTool = new LineTool(this, m_pDrawPadCanvas);
 
     m_pLineToolButton->setIconSet(m_pLineToolAction->iconSet());
     QToolTip::add(m_pLineToolButton, m_pLineToolAction->text());
 
     disconnect(m_pLineToolButton, SIGNAL(clicked()), 0, 0);
     connect(m_pLineToolButton, SIGNAL(clicked()), m_pLineToolAction, SIGNAL(activated()));
 
     m_pLineToolButton->setOn(true);
     m_pRectangleToolButton->setOn(false);
     m_pEllipseToolButton->setOn(false);
     m_pTextToolAction->setOn(false);
     m_pFillToolAction->setOn(false);
     m_pEraseToolAction->setOn(false);
 }
 
 void DrawPad::setRectangleTool()
 {
     if (m_pTool) {
         delete m_pTool;
     }
 
     m_pTool = new RectangleTool(this, m_pDrawPadCanvas);
 
     m_pRectangleToolButton->setIconSet(m_pRectangleToolAction->iconSet());
     QToolTip::add(m_pRectangleToolButton, m_pRectangleToolAction->text());
 
     disconnect(m_pRectangleToolButton, SIGNAL(clicked()), 0, 0);
     connect(m_pRectangleToolButton, SIGNAL(clicked()), m_pRectangleToolAction, SIGNAL(activated()));
 
     m_pLineToolButton->setOn(false);
     m_pRectangleToolButton->setOn(true);
     m_pEllipseToolButton->setOn(false);
     m_pTextToolAction->setOn(false);
     m_pFillToolAction->setOn(false);
     m_pEraseToolAction->setOn(false);
 }
 
 void DrawPad::setFilledRectangleTool()
 {
     if (m_pTool) {
         delete m_pTool;
     }
 
     m_pTool = new FilledRectangleTool(this, m_pDrawPadCanvas);
 
     m_pRectangleToolButton->setIconSet(m_pFilledRectangleToolAction->iconSet());
     QToolTip::add(m_pRectangleToolButton, m_pFilledRectangleToolAction->text());
 
     disconnect(m_pRectangleToolButton, SIGNAL(clicked()), 0, 0);
     connect(m_pRectangleToolButton, SIGNAL(clicked()), m_pFilledRectangleToolAction, SIGNAL(activated()));
 
     m_pLineToolButton->setOn(false);
     m_pRectangleToolButton->setOn(true);
     m_pEllipseToolButton->setOn(false);
     m_pTextToolAction->setOn(false);
     m_pFillToolAction->setOn(false);
     m_pEraseToolAction->setOn(false);
 }
 
 void DrawPad::setEllipseTool()
 {
     if (m_pTool) {
         delete m_pTool;
     }
 
     m_pTool = new EllipseTool(this, m_pDrawPadCanvas);
 
     m_pEllipseToolButton->setIconSet(m_pEllipseToolAction->iconSet());
     QToolTip::add(m_pEllipseToolButton, m_pEllipseToolAction->text());
 
     disconnect(m_pEllipseToolButton, SIGNAL(clicked()), 0, 0);
     connect(m_pEllipseToolButton, SIGNAL(clicked()), m_pEllipseToolAction, SIGNAL(activated()));
 
     m_pLineToolButton->setOn(false);
     m_pRectangleToolButton->setOn(false);
     m_pEllipseToolButton->setOn(true);
     m_pTextToolAction->setOn(false);
     m_pFillToolAction->setOn(false);
     m_pEraseToolAction->setOn(false);
 }
 
 void DrawPad::setFilledEllipseTool()
 {
     if (m_pTool) {
         delete m_pTool;
     }
 
     m_pTool = new FilledEllipseTool(this, m_pDrawPadCanvas);
 
     m_pEllipseToolButton->setIconSet(m_pFilledEllipseToolAction->iconSet());
     QToolTip::add(m_pEllipseToolButton, m_pFilledEllipseToolAction->text());
 
     disconnect(m_pEllipseToolButton, SIGNAL(clicked()), 0, 0);
     connect(m_pEllipseToolButton, SIGNAL(clicked()), m_pFilledEllipseToolAction, SIGNAL(activated()));
 
     m_pLineToolButton->setOn(false);
     m_pRectangleToolButton->setOn(false);
     m_pEllipseToolButton->setOn(true);
     m_pTextToolAction->setOn(false);
     m_pFillToolAction->setOn(false);
     m_pEraseToolAction->setOn(false);
 }
 
 void DrawPad::setTextTool()
 {
     if (m_pTool) {
         delete m_pTool;
     }
 
     m_pTool = new TextTool(this, m_pDrawPadCanvas);
 
     m_pLineToolButton->setOn(false);
     m_pRectangleToolButton->setOn(false);
     m_pEllipseToolButton->setOn(false);
     m_pTextToolAction->setOn(true);
     m_pFillToolAction->setOn(false);
     m_pEraseToolAction->setOn(false);
 }
 
 void DrawPad::setFillTool()
 {
     if (m_pTool) {
         delete m_pTool;
     }
 
     m_pTool = new FillTool(this, m_pDrawPadCanvas);
 
     m_pLineToolButton->setOn(false);
     m_pRectangleToolButton->setOn(false);
     m_pEllipseToolButton->setOn(false);
     m_pTextToolAction->setOn(false);
     m_pFillToolAction->setOn(true);
     m_pEraseToolAction->setOn(false);
 }
 
 void DrawPad::setEraseTool()
 {
     if (m_pTool) {
         delete m_pTool;
     }
 
     m_pTool = new EraseTool(this, m_pDrawPadCanvas);
 
     m_pLineToolButton->setOn(false);
     m_pRectangleToolButton->setOn(false);
     m_pEllipseToolButton->setOn(false);
     m_pTextToolAction->setOn(false);
     m_pFillToolAction->setOn(false);
     m_pEraseToolAction->setOn(true);
 }
 
 void DrawPad::changePenWidth(int value)
 {
     m_pen.setWidth(value);
 }
 
 void DrawPad::changePenColor(const QColor& color)
 {
     m_pen.setColor(color);
 
     QPainter painter;
     painter.begin(m_pPenColorToolButton->pixmap());
     painter.fillRect(QRect(0, 12, 14, 2), m_pen.color());
     painter.end();
 
     m_pPenColorToolButton->popup()->hide();
 }
 
 void DrawPad::changeBrushColor(const QColor& color)
 {
     m_brush = QBrush(color);
 
     QPainter painter;
     painter.begin(m_pBrushColorToolButton->pixmap());
     painter.fillRect(QRect(0, 12, 14, 2), m_brush.color());
     painter.end();
 
     m_pBrushColorToolButton->popup()->hide();
 }
 
 void DrawPad::updateView()
 {
     uint pagePosition = m_pDrawPadCanvas->pagePosition();
     uint pageCount = m_pDrawPadCanvas->pageCount();
 
     setCaption( tr( "DrawPad - Page %1/%2" ).arg( pagePosition ).arg( pageCount ) );
 
     m_pUndoAction->setEnabled(m_pDrawPadCanvas->currentPage()->undoEnabled());
     m_pRedoAction->setEnabled(m_pDrawPadCanvas->currentPage()->redoEnabled());
 
     m_pFirstPageAction->setEnabled(m_pDrawPadCanvas->goPreviousPageEnabled());
     m_pPreviousPageAction->setEnabled(m_pDrawPadCanvas->goPreviousPageEnabled());
     m_pNextPageAction->setEnabled(m_pDrawPadCanvas->goNextPageEnabled());
     m_pLastPageAction->setEnabled(m_pDrawPadCanvas->goNextPageEnabled());
 }
 
 void DrawPad::deleteAll()
 {
     QMessageBox messageBox(tr("Delete All"), tr("Do you want to delete\nall the pages?"),
                            QMessageBox::Information, QMessageBox::Yes,
                            QMessageBox::No | QMessageBox::Escape | QMessageBox::Default,
                            QMessageBox::NoButton, this);
 
     messageBox.setButtonText(QMessageBox::Yes, tr("Yes"));
     messageBox.setButtonText(QMessageBox::No, tr("No"));
 
     if (messageBox.exec() == QMessageBox::Yes) {
         m_pDrawPadCanvas->deleteAll();
     }
 }
 
 void DrawPad::importPage()
 {
     ImportDialog importDialog(this);
 
     if ( QPEApplication::execDialog( &importDialog ) == QDialog::Accepted ) {
         const DocLnk* docLnk = importDialog.selected();
 
         if (docLnk) {
             m_pDrawPadCanvas->importPage(docLnk->file());
             delete docLnk;
         }
     }
 }
 
 void DrawPad::exportPage()
 {
     ExportDialog exportDialog(m_pDrawPadCanvas->pagePosition(), m_pDrawPadCanvas->pageCount(), this);
 
     if ( QPEApplication::execDialog( &exportDialog ) == QDialog::Accepted ) {
         m_pDrawPadCanvas->exportPage(exportDialog.selectedFromPage(), exportDialog.selectedToPage(),
                                      exportDialog.selectedName(), exportDialog.selectedFormat());
     }
 }
 
 void DrawPad::thumbnailView()
 {
     ThumbnailView thumbnailView(this, m_pDrawPadCanvas, this);
 
     QPEApplication::showWidget( &thumbnailView );
     thumbnailView.exec();
 }
 
 void DrawPad::pageInformation()
 {
     PageInformationDialog pageInformationDialog(m_pDrawPadCanvas->currentPage());
 
     if (pageInformationDialog.exec() == QDialog::Accepted) {
         m_pDrawPadCanvas->currentPage()->setTitle(pageInformationDialog.selectedTitle());
     }
 }
 
 void DrawPad::loadConfig()
 {
     Config config("drawpad");
     config.setGroup("General");
 
     m_pAntiAliasingAction->setOn(config.readBoolEntry("AntiAliasing", false));
     m_pPenWidthSpinBox->setValue(config.readNumEntry("PenWidth", 1));
     changePenColor(QColor(config.readEntry("PenColor", Qt::black.name())));
     changeBrushColor(QColor(config.readEntry("BrushColor", Qt::white.name())));
     m_pDrawPadCanvas->selectPage(config.readNumEntry("PagePosition", 1));
 }
 
 void DrawPad::saveConfig()
 {
     Config config("drawpad");
     config.setGroup("General");
 
     config.writeEntry("PagePosition", (int)m_pDrawPadCanvas->pagePosition());
     config.writeEntry("AntiAliasing", antiAliasing());
     config.writeEntry("PenWidth", (int)m_pen.width());
     config.writeEntry("PenColor", m_pen.color().name());
     config.writeEntry("BrushColor", m_brush.color().name());
 }
diff --git a/noncore/graphics/drawpad/drawpad.h b/noncore/graphics/drawpad/drawpad.h
index 48d5225..8ba6e58 100644
--- a/noncore/graphics/drawpad/drawpad.h
+++ b/noncore/graphics/drawpad/drawpad.h
@@ -1,113 +1,112 @@
 /***************************************************************************
  *                                                                         *
  *   DrawPad - a drawing program for Opie Environment                      *
  *                                                                         *
  *   (C) 2002 by S. Prud'homme <prudhomme@laposte.net>                     *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 
 #ifndef DRAWPAD_H
 #define DRAWPAD_H
 
 #include <qmainwindow.h>
-
 #include <qpen.h>
 
 class DrawPadCanvas;
 class Tool;
 
 class QAction;
 class QColor;
 class QSpinBox;
 class QToolButton;
 class QWidgetStack;
 
 class DrawPad : public QMainWindow
 {
     Q_OBJECT
 
 public:
     DrawPad(QWidget* parent = 0, const char* name = 0, WFlags fl = 0);
     ~DrawPad();
 
     static QString appName() { return QString::fromLatin1("drawpad"); }
 
     Tool* tool() { return m_pTool; }
     QPen pen() { return m_pen; }
     QBrush brush() { return m_brush; }
 
     bool antiAliasing();
     void finishStartup();
 
 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 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/drawpad.pro b/noncore/graphics/drawpad/drawpad.pro
index 30b2199..5e6ca6b 100644
--- a/noncore/graphics/drawpad/drawpad.pro
+++ b/noncore/graphics/drawpad/drawpad.pro
@@ -1,47 +1,47 @@
 CONFIG		= qt warn_on release quick-app
 HEADERS		= drawpad.h \
 		  drawpadcanvas.h \
 		  ellipsetool.h \
 		  erasetool.h \
 		  exportdialog.h \
 		  filltool.h \
 		  filledellipsetool.h \
 		  filledrectangletool.h \
 		  importdialog.h \
 		  linetool.h \
 		  newpagedialog.h \
 		  page.h \
 		  pageinformationdialog.h \
 		  pointtool.h \
 		  rectangletool.h \
 		  shapetool.h \
 		  texttool.h \
 		  thumbnailview.h \
 		  tool.h
 SOURCES		= drawpad.cpp \
 		  drawpadcanvas.cpp \
 		  ellipsetool.cpp \
 		  erasetool.cpp \
 		  exportdialog.cpp \
 		  filltool.cpp \
 		  filledellipsetool.cpp \
 		  filledrectangletool.cpp \
 		  importdialog.cpp \
 		  linetool.cpp \
 		  main.cpp \
 		  newpagedialog.cpp \
 		  page.cpp \
 		  pageinformationdialog.cpp \
 		  pointtool.cpp \
 		  rectangletool.cpp \
 		  shapetool.cpp \
 		  texttool.cpp \
 		  thumbnailview.cpp \
 		  tool.cpp
 INCLUDEPATH	+= $(OPIEDIR)/include
 DEPENDPATH	+= $(OPIEDIR)/include
-LIBS		+= -lqpe -lopie
+LIBS		+= -lqpe -lopiecore2 -lopieui2 -lqtaux2
 
 TARGET		= drawpad
 
 include ( $(OPIEDIR)/include.pro )
diff --git a/noncore/graphics/drawpad/exportdialog.cpp b/noncore/graphics/drawpad/exportdialog.cpp
index d63f428..169acef 100644
--- a/noncore/graphics/drawpad/exportdialog.cpp
+++ b/noncore/graphics/drawpad/exportdialog.cpp
@@ -1,175 +1,175 @@
 /***************************************************************************
  *                                                                         *
  *   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 "exportdialog.h"
 
-#include <opie/ofileselector.h>
+#include <opie2/ofileselector.h>
 
 #include <qbuttongroup.h>
 #include <qcombobox.h>
 #include <qimage.h>
 #include <qlabel.h>
 #include <qlayout.h>
 #include <qlineedit.h>
 #include <qradiobutton.h>
 #include <qspinbox.h>
 
 #include <stdlib.h>
 
 ExportDialog::ExportDialog(uint pageAt, uint pageCount, QWidget* parent, const char* name)
     : QDialog(parent, name, true)
 {
     setCaption(tr("DrawPad - Export"));
 
     m_pageAt = pageAt;
     m_pageCount = pageCount;
 
     QButtonGroup* selectionButtonGroup = new QButtonGroup(0, Qt::Vertical, tr("Page Selection"), this);
     connect(selectionButtonGroup, SIGNAL(pressed(int)), this, SLOT(selectionChanged(int)));
 
     QRadioButton* selectAllRadioButton = new QRadioButton(tr("All"), selectionButtonGroup);
     QRadioButton* selectCurrentRadioButton = new QRadioButton(tr("Current"), selectionButtonGroup);
     QRadioButton* selectRangeRadioButton = new QRadioButton(tr("Range"), selectionButtonGroup);
 
     QLabel* toLabel = new QLabel(tr("To:"), selectionButtonGroup);
 
     m_pFromPageSpinBox = new QSpinBox(1, m_pageCount, 1, selectionButtonGroup);
     connect(m_pFromPageSpinBox, SIGNAL(valueChanged(int)), this, SLOT(fromPageChanged(int)));
 
     m_pToPageSpinBox = new QSpinBox(1, m_pageCount, 1, selectionButtonGroup);
     connect(m_pToPageSpinBox, SIGNAL(valueChanged(int)), this, SLOT(toPageChanged(int)));
 
     selectionButtonGroup->setButton(1);
     selectionChanged(1);
 
     m_pFromPageSpinBox->setValue(pageAt);
     m_pToPageSpinBox->setValue(pageAt);
 
     QGroupBox* exportGroupBox = new QGroupBox(0, Qt::Vertical, tr("Export As"), this);
 
     QLabel* nameLabel = new QLabel(tr("Name:"), exportGroupBox);
     QLabel* formatLabel = new QLabel(tr("Format:"), exportGroupBox);
 
     m_pNameLineEdit = new QLineEdit(exportGroupBox);
 
     m_pFormatComboBox = new QComboBox(exportGroupBox);
     m_pFormatComboBox->insertStrList(QImageIO::outputFormats());
 
     MimeTypes types; types.insert( tr("All Images"), "image/*" );
-    OFileSelector* fileSelector = new OFileSelector(this, OFileSelector::FileSelector,
-						   OFileSelector::Normal,
+    Opie::OFileSelector* fileSelector = new Opie::OFileSelector(this, Opie::OFileSelector::FileSelector,
+						   Opie::OFileSelector::Normal,
 						   QString::null, QString::null,
 						   types );
     fileSelector->setNameVisible( false );
 
     QVBoxLayout* mainLayout = new QVBoxLayout(this, 4, 4);
     selectionButtonGroup->layout()->setSpacing(4);
     exportGroupBox->layout()->setSpacing(4);
     QGridLayout* selectionLayout = new QGridLayout(selectionButtonGroup->layout(), 2, 2);
     QHBoxLayout* rangeLayout = new QHBoxLayout();
     QGridLayout* exportLayout = new QGridLayout(exportGroupBox->layout(), 2, 2);
 
     selectionLayout->addWidget(selectAllRadioButton, 0, 0);
     selectionLayout->addWidget(selectCurrentRadioButton, 1, 0);
     selectionLayout->addWidget(selectRangeRadioButton, 0, 1);
     selectionLayout->addLayout(rangeLayout, 1, 1);
 
     rangeLayout->addWidget(m_pFromPageSpinBox);
     rangeLayout->addWidget(toLabel);
     rangeLayout->addWidget(m_pToPageSpinBox);
 
     exportLayout->addWidget(nameLabel, 0, 0);
     exportLayout->addWidget(formatLabel, 1, 0);
 
     exportLayout->addWidget(m_pNameLineEdit, 0, 1);
     exportLayout->addWidget(m_pFormatComboBox, 1, 1);
 
     exportLayout->setColStretch(1, 1);
 
     mainLayout->addWidget(selectionButtonGroup);
     mainLayout->addWidget(exportGroupBox);
     mainLayout->addWidget(fileSelector);
 
     m_pNameLineEdit->setFocus();
 }
 
 ExportDialog::~ExportDialog()
 {
 }
 
 uint ExportDialog::selectedFromPage()
 {
     return (m_pFromPageSpinBox->value());
 }
 
 uint ExportDialog::selectedToPage()
 {
     return (m_pToPageSpinBox->value());
 }
 
 QString ExportDialog::selectedName()
 {
     return (m_pNameLineEdit->text());
 }
 
 QString ExportDialog::selectedFormat()
 {
     return (m_pFormatComboBox->currentText());
 }
 
 void ExportDialog::accept()
 {
     if (!(m_pNameLineEdit->text().isEmpty())) {
         QDialog::accept();
     }
 }
 
 void ExportDialog::selectionChanged(int id)
 {
     switch (id) {
         case 0:
             m_pFromPageSpinBox->setValue(1);
             m_pToPageSpinBox->setValue(m_pageCount);
 
             m_pFromPageSpinBox->setEnabled(false);
             m_pToPageSpinBox->setEnabled(false);
             break;
         case 1:
             m_pFromPageSpinBox->setValue(m_pageAt);
             m_pToPageSpinBox->setValue(m_pageAt);
 
             m_pFromPageSpinBox->setEnabled(false);
             m_pToPageSpinBox->setEnabled(false);
             break;
         case 2:
             m_pFromPageSpinBox->setEnabled(true);
             m_pToPageSpinBox->setEnabled(true);
             break;
         default:
             break;
     }
 }
 
 void ExportDialog::fromPageChanged(int value)
 {
     if (m_pToPageSpinBox->value() < value) {
         m_pToPageSpinBox->setValue(value);
     }
 }
 
 void ExportDialog::toPageChanged(int value)
 {
     if (m_pFromPageSpinBox->value() > value) {
         m_pFromPageSpinBox->setValue(value);
     }
 }
diff --git a/noncore/graphics/drawpad/importdialog.cpp b/noncore/graphics/drawpad/importdialog.cpp
index ce2e7ee..4fc0a0e 100644
--- a/noncore/graphics/drawpad/importdialog.cpp
+++ b/noncore/graphics/drawpad/importdialog.cpp
@@ -1,116 +1,116 @@
 /***************************************************************************
  *                                                                         *
  *   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 "importdialog.h"
 
-#include <opie/ofileselector.h>
+#include <qpe/mimetype.h>
 
 #include <qcheckbox.h>
 #include <qimage.h>
 #include <qlabel.h>
 #include <qlayout.h>
 #include <qpushbutton.h>
 
 ImportDialog::ImportDialog(QWidget* parent, const char* name)
     : QDialog(parent, name, true)
 {
     setCaption(tr("DrawPad - Import"));
 
     MimeTypes types; types.insert( tr("All images"),"image/*" );
-    m_pFileSelector = new OFileSelector(this,
-				        OFileSelector::FileSelector,
-					OFileSelector::Normal,
+    m_pFileSelector = new Opie::OFileSelector(this,
+				    Opie::OFileSelector::FileSelector,
+					Opie::OFileSelector::Normal,
 					QString::null,
 					QString::null, types );
     m_pFileSelector->setNameVisible( false );
     connect(m_pFileSelector, SIGNAL(fileSelected(const DocLnk&)), this, SLOT(fileChanged()));
 
     m_pPreviewLabel = new QLabel(this);
     m_pPreviewLabel->setFrameStyle(QFrame::Panel | QFrame::Sunken);
     m_pPreviewLabel->setAlignment(Qt::AlignHCenter | Qt::AlignVCenter);
     m_pPreviewLabel->setFixedSize(114, 114);
     m_pPreviewLabel->setBackgroundMode(QWidget::PaletteMid);
 
     m_pAutomaticPreviewCheckBox = new QCheckBox(tr("Automatic preview"), this);
     m_pAutomaticPreviewCheckBox->setChecked(true);
 
     QPushButton* previewPushButton = new QPushButton(tr("Preview"), this);
     connect(previewPushButton, SIGNAL(clicked()), this, SLOT(preview()));
 
     QVBoxLayout* mainLayout = new QVBoxLayout(this, 4, 4);
     QHBoxLayout* previewLayout = new QHBoxLayout(4);
     QVBoxLayout* previewSecondLayout = new QVBoxLayout(4);
 
     previewSecondLayout->addWidget(m_pAutomaticPreviewCheckBox);
     previewSecondLayout->addWidget(previewPushButton);
     previewSecondLayout->addStretch();
 
     previewLayout->addWidget(m_pPreviewLabel);
     previewLayout->addLayout(previewSecondLayout);
 
     mainLayout->addWidget(m_pFileSelector);
     mainLayout->addLayout(previewLayout);
 
     preview();
 }
 
 ImportDialog::~ImportDialog()
 {
 }
 
 const DocLnk* ImportDialog::selected()
 {
     // FIXME change from pointer to reference -zecke
     DocLnk *lnk = new DocLnk( m_pFileSelector->selectedDocument() );
     return lnk;
 }
 
 void ImportDialog::fileChanged()
 {
     if (m_pAutomaticPreviewCheckBox->isChecked()) {
         preview();
     }
 }
 
 void ImportDialog::preview()
 {
     const DocLnk* docLnk = selected();
 
     if (docLnk) {
         QImage image(docLnk->file());
 
         int previewWidth = m_pPreviewLabel->contentsRect().width();
         int previewHeight = m_pPreviewLabel->contentsRect().height();
 
         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);
 
         m_pPreviewLabel->setPixmap(previewPixmap);
 
         delete docLnk;
     }
 }
diff --git a/noncore/graphics/drawpad/importdialog.h b/noncore/graphics/drawpad/importdialog.h
index ed655a5..16227d2 100644
--- a/noncore/graphics/drawpad/importdialog.h
+++ b/noncore/graphics/drawpad/importdialog.h
@@ -1,45 +1,46 @@
 /***************************************************************************
  *                                                                         *
  *   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 IMPORTDIALOG_H
 #define IMPORTDIALOG_H
 
+#include <opie2/ofileselector.h>
+
 #include <qdialog.h>
 
 class DocLnk;
-class OFileSelector;
 
 class QCheckBox;
 class QLabel;
 
 class ImportDialog : public QDialog
 { 
     Q_OBJECT
 
 public:
     ImportDialog(QWidget* parent = 0, const char* name = 0);
     ~ImportDialog();
 
     const DocLnk* selected();
 
 private slots:
     void fileChanged();
     void preview();
 
 private:
-    OFileSelector* m_pFileSelector;
+    Opie::OFileSelector* m_pFileSelector;
     QLabel* m_pPreviewLabel;
     QCheckBox* m_pAutomaticPreviewCheckBox;
 };
 
 #endif // IMPORTDIALOG_H
diff --git a/noncore/graphics/drawpad/main.cpp b/noncore/graphics/drawpad/main.cpp
index c87cc0f..a6c666b 100644
--- a/noncore/graphics/drawpad/main.cpp
+++ b/noncore/graphics/drawpad/main.cpp
@@ -1,18 +1,18 @@
 /***************************************************************************
  *                                                                         *
  *   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 <opie/oapplicationfactory.h>
+#include <opie2/oapplicationfactory.h>
 
 OPIE_EXPORT_APP( OApplicationFactory<DrawPad> )
diff --git a/noncore/graphics/drawpad/opie-drawpad.control b/noncore/graphics/drawpad/opie-drawpad.control
index f0aa0b4..2a403f9 100644
--- a/noncore/graphics/drawpad/opie-drawpad.control
+++ b/noncore/graphics/drawpad/opie-drawpad.control
@@ -1,12 +1,12 @@
 Package: opie-drawpad
 Files: plugins/application/libdrawpad.so* bin/drawpad apps/1Pim/drawpad.desktop pics/drawpad
 Priority: optional
 Section: opie/pim
 Maintainer: Sébastien Prud'homme <prudhomme@laposte.net>
 Architecture: arm
-Depends: task-opie-minimal, libopie1
+Depends: task-opie-minimal, libopiecore2, libopieui2, libqtaux2
 Description: A note taking program with basic draw tools
  DrawPad is an easy note taking program for Zaurus.  It can also
  be used to draw simple images. DrawPad was developed for the Opie
  project, an alternative to the standard Zaurus environment.
 Version: $QPE_VERSION$EXTRAVERSION