Rename a number of libraries and executables to avoid conflicts with KDE4

1 files changed, 1976 insertions, 0 deletions

diff --git a/kviewshell/tdemultipage.cpp b/kviewshell/tdemultipage.cpp
new file mode 100644
index 00000000..b6b98855
--- /dev/null
+++ b/kviewshell/tdemultipage.cpp
@@ -0,0 +1,1976 @@
+#include <config.h>
+
+#include <kaction.h>
+#include <kapplication.h>
+#include <kdebug.h>
+#include <kfiledialog.h>
+#include <kiconloader.h>
+#include <kio/job.h>
+#include <klocale.h>
+#include <kmessagebox.h>
+#include <kprinter.h>
+#include <kstdaction.h>
+#include <tqobject.h>
+#include <tqlayout.h>
+#include <tqpaintdevicemetrics.h>
+#include <tqprogressdialog.h>
+#include <tqsplitter.h>
+#include <tqurl.h>
+#include <tqtoolbox.h>
+#include <tqvbox.h>
+
+#include "documentWidget.h"
+#include "marklist.h"
+#include "tableOfContents.h"
+#include "kprintDialogPage_pageoptions.h"
+#include "kvsprefs.h"
+#include "tdemultipage.h"
+#include "pageNumber.h"
+#include "renderedDocumentPagePrinter.h"
+#include "searchWidget.h"
+#include "textBox.h"
+#include "zoomlimits.h"
+
+
+//#define DEBUG_KMULTIPAGE
+
+KMultiPage::KMultiPage(TQWidget *parentWidget, const char *widgetName, TQObject *parent, const char *name)
+  : DCOPObject("tdemultipage"), KParts::ReadOnlyPart(parent, name)
+{
+  // For reasons which I don't understand, the initialization of the
+  // DCOPObject above does not work properly, the name is ignored. It
+  // works fine if we repeat the name here. -- Stefan Kebekus
+  // This is because of the virtual inheritance. Get rid of it (but it's BC, and this is a lib...) -- DF
+  setObjId("tdemultipage");
+
+  parentWdg = parentWidget;
+  lastCurrentPage = 0;
+  timer_id = -1;
+  searchInProgress = false;
+  
+  TQVBox* verticalBox = new TQVBox(parentWidget);
+  verticalBox->setFocusPolicy(TQ_StrongFocus);
+  setWidget(verticalBox);
+  
+  splitterWidget = new TQSplitter(verticalBox, widgetName);
+  splitterWidget->setOpaqueResize(false);
+  splitterWidget->setSizePolicy(TQSizePolicy::MinimumExpanding, TQSizePolicy::MinimumExpanding);
+  
+  // Create SideBar
+  sideBar = new TQToolBox(splitterWidget, "sidebar");
+  
+  // Create ContentsList
+  tableOfContents = new TableOfContents(sideBar);
+  sideBar->addItem(tableOfContents, TQIconSet(SmallIcon("contents")), i18n("Contents"));
+
+  connect(tableOfContents, TQT_SIGNAL(gotoPage(const Anchor&)), this, TQT_SLOT(gotoPage(const Anchor&)));
+  
+  // Create MarkList
+  _markList = new MarkList(sideBar, "marklist");
+  sideBar->addItem(_markList, TQIconSet(SmallIcon("thumbnail")), i18n("Thumbnails"));
+
+  // Restore state of the sidebar
+  sideBar->setCurrentItem(sideBar->item(KVSPrefs::sideBarItem()));
+
+  splitterWidget->setResizeMode(sideBar, TQSplitter::KeepSize);
+
+  connect(_markList, TQT_SIGNAL(selected(const PageNumber&)), this, TQT_SLOT(gotoPage(const PageNumber&)));
+
+  _scrollView = new PageView(splitterWidget, widgetName);
+
+  // Create Search Panel
+  searchWidget = new SearchWidget(verticalBox);
+  searchWidget->hide();
+  connect(searchWidget, TQT_SIGNAL(findNextText()), this, TQT_SLOT(findNextText()));
+  connect(searchWidget, TQT_SIGNAL(findPrevText()), this, TQT_SLOT(findPrevText()));
+
+  sideBar->setMinimumWidth(80);
+  sideBar->setMaximumWidth(300);
+
+  connect(_scrollView, TQT_SIGNAL(currentPageChanged(const PageNumber&)), this, TQT_SLOT(setCurrentPageNumber(const PageNumber&)));
+  connect(_scrollView, TQT_SIGNAL(viewSizeChanged(const TQSize&)), scrollView(), TQT_SLOT(calculateCurrentPageNumber()));
+  connect(_scrollView, TQT_SIGNAL(wheelEventReceived(TQWheelEvent *)), this, TQT_SLOT(wheelEvent(TQWheelEvent*)));
+
+  connect(this, TQT_SIGNAL(enableMoveTool(bool)), _scrollView, TQT_SLOT(slotEnableMoveTool(bool)));
+
+  splitterWidget->setCollapsible(sideBar, false);
+  splitterWidget->setSizes(KVSPrefs::guiLayout());
+
+  connect(searchWidget, TQT_SIGNAL(searchEnabled(bool)), this, TQT_SIGNAL(searchEnabled(bool)));
+  connect(searchWidget, TQT_SIGNAL(stopSearch()), this, TQT_SLOT(stopSearch()));
+}
+
+
+KMultiPage::~KMultiPage()
+{
+  writeSettings();
+
+  if (timer_id != -1)
+    killTimer(timer_id);
+
+  delete pageCache;
+}
+
+void KMultiPage::readSettings()
+{
+}
+
+void KMultiPage::writeSettings()
+{
+  // Save TOC layout
+  tableOfContents->writeSettings();
+
+  KVSPrefs::setGuiLayout(splitterWidget->sizes());
+  // Save state of the sidebar
+  KVSPrefs::setSideBarItem(sideBar->indexOf(sideBar->currentItem()));
+  KVSPrefs::writeConfig();
+}
+
+TQString KMultiPage::name_of_current_file()
+{
+  return m_file;
+}
+
+bool KMultiPage::is_file_loaded(const TQString& filename)
+{
+  return (filename == m_file);
+}
+
+void KMultiPage::slotSave_defaultFilename()
+{
+  slotSave();
+}
+
+void KMultiPage::slotSave()
+{
+  // Try to guess the proper ending...
+  TQString formats;
+  TQString ending;
+  int rindex = m_file.findRev(".");
+  if (rindex == -1) {
+    ending = TQString();
+    formats = TQString();
+  } else {
+    ending = m_file.mid(rindex); // e.g. ".dvi"
+    formats = fileFormats().grep(ending).join("\n");
+  }
+
+  TQString fileName = KFileDialog::getSaveFileName(TQString(), formats, 0, i18n("Save File As"));
+
+  if (fileName.isEmpty())
+    return;
+
+  // Add the ending to the filename. I hope the user likes it that
+  // way.
+  if (!ending.isEmpty() && fileName.find(ending) == -1)
+    fileName = fileName+ending;
+
+  if (TQFile(fileName).exists()) {
+    int r = KMessageBox::warningContinueCancel (0, i18n("The file %1\nexists. Shall I overwrite that file?").arg(fileName),
+				       i18n("Overwrite File"), i18n("Overwrite"));
+    if (r == KMessageBox::Cancel)
+      return;
+  }
+
+  TDEIO::Job *job = TDEIO::file_copy( KURL( m_file ), KURL( fileName ), 0600, true, false, true );
+  connect( job, TQT_SIGNAL( result( TDEIO::Job * ) ), this, TQT_SLOT( slotIOJobFinished ( TDEIO::Job * ) ) );
+
+  return;
+}
+
+
+void KMultiPage::setFile(bool)
+{
+  return;
+}
+
+
+bool KMultiPage::closeURL()
+{
+#ifdef DEBUG_KMULTIPAGE
+  kdDebug(1233) << "KMultiPage::closeURL()" << endl;
+#endif
+
+  if (renderer.isNull())
+    return false;
+  
+  // Clear navigation history.
+  document_history.clear();
+  
+  // Close the file.
+  renderer->setFile(TQString(), KURL());
+  renderer->clear();
+  
+  // Delete Page Widgets.
+  widgetList.setAutoDelete(true);
+  widgetList.resize(0);
+  widgetList.setAutoDelete(false);
+  
+  // Update ScrollView.
+  scrollView()->layoutPages();
+  enableActions(false);
+  
+  // Clear Thumbnail List.
+  markList()->clear();
+  
+  // Clear Table of Contents
+  tableOfContents->clear();
+  
+  // Clear Status Bar
+  emit setStatusBarText(TQString());
+
+  return true;
+}
+
+void KMultiPage::slotIOJobFinished ( TDEIO::Job *job )
+{
+  if ( job->error() )
+    job->showErrorDialog( 0L );
+}
+
+void KMultiPage::slotShowScrollbars(bool status)
+{
+  _scrollView->slotShowScrollbars(status);
+}
+
+void KMultiPage::slotShowSidebar(bool show)
+{
+  if (show)
+    sideBar->show();
+  else
+    sideBar->hide();
+}
+
+void KMultiPage::slotShowThumbnails(bool show)
+{
+  markList()->slotShowThumbnails(show);
+}
+
+void KMultiPage::slotSetFullPage(bool fullpage)
+{
+  _scrollView->setFullScreenMode(fullpage);
+  if (fullpage)
+    slotShowSidebar(false);
+}
+
+void KMultiPage::preferencesChanged()
+{
+  // We need to read the config options otherwise the KVSPrefs-object would
+  // not be syncronized between the kviewpart and the tdemultipage.
+  KVSPrefs::self()->readConfig();
+
+  slotShowThumbnails(KVSPrefs::showThumbnails());
+
+  // if we are in overviewmode and the number of columns or rows has changed
+  if (scrollView()->overviewMode() &&
+      (scrollView()->getNrColumns() != KVSPrefs::overviewModeColumns() ||
+       scrollView()->getNrRows() != KVSPrefs::overviewModeRows()))
+  {
+    setViewMode(KVSPrefs::EnumViewMode::Overview);
+  }
+
+  if (KVSPrefs::changeColors() && KVSPrefs::renderMode() == KVSPrefs::EnumRenderMode::Paper)
+    renderer->setAccessibleBackground(true, KVSPrefs::paperColor());
+  else
+    renderer->setAccessibleBackground(false);
+
+  renderModeChanged();
+}
+
+void KMultiPage::setViewMode(int mode)
+{
+#ifdef DEBUG_KMULTIPAGE
+  kdDebug(1233) << "KMultiPage::setViewMode(" << mode << ")" << endl;
+#endif
+  // Save the current page number because when we are changing the columns
+  // and rows in the scrollview the currently shown Page probably out of view.
+  PageNumber currentPage = currentPageNumber();
+
+  // Save viewMode for future uses of KViewShell
+  switch (mode) 
+  {
+    case KVSPrefs::EnumViewMode::SinglePage:
+      KVSPrefs::setViewMode(KVSPrefs::EnumViewMode::SinglePage);
+
+      // Don't do anything if the view mode is already set
+      if ((scrollView()->getNrColumns() == 1) && (scrollView()->getNrRows() == 1) && (scrollView()->isContinuous() == false))
+        return;
+      
+      scrollView()->setNrColumns(1);
+      scrollView()->setNrRows(1);
+      scrollView()->setContinuousViewMode(false);
+      // We scroll the view to the top, so that top and not the bottom
+      // of the visible page is shown.
+      scrollView()->scrollTop();
+      break;
+    case KVSPrefs::EnumViewMode::ContinuousFacing:
+      KVSPrefs::setViewMode(KVSPrefs::EnumViewMode::ContinuousFacing);
+
+      // Don't do anything if the view mode is already set
+      if ((scrollView()->getNrColumns() == 2) && (scrollView()->getNrRows() == 1) && (scrollView()->isContinuous() == true))
+        return;
+
+      scrollView()->setNrColumns(2);
+      scrollView()->setNrRows(1);
+      scrollView()->setContinuousViewMode(true);
+      break;
+    case KVSPrefs::EnumViewMode::Overview:
+      KVSPrefs::setViewMode(KVSPrefs::EnumViewMode::Overview);
+
+      // Don't do anything if the view mode is already set
+      if ((scrollView()->getNrColumns() == KVSPrefs::overviewModeColumns()) && (scrollView()->getNrRows() == KVSPrefs::overviewModeRows()) && (scrollView()->isContinuous() == false))
+        return;
+
+      scrollView()->setNrColumns(KVSPrefs::overviewModeColumns());
+      scrollView()->setNrRows(KVSPrefs::overviewModeRows());
+      scrollView()->setContinuousViewMode(false);
+      // We scroll the view to the top, so that top and not the bottom
+      // of the visible tableau is shown.
+      scrollView()->scrollTop();
+      break;
+    default:  //KVSPrefs::EnumViewMode::Continuous
+      KVSPrefs::setViewMode(KVSPrefs::EnumViewMode::Continuous);
+
+      // Don't do anything if the view mode is already set
+      if ((scrollView()->getNrColumns() == 1) && (scrollView()->getNrRows() == 1) && (scrollView()->isContinuous() == true))
+        return;
+      
+      scrollView()->setNrColumns(1);
+      scrollView()->setNrRows(1);
+      scrollView()->setContinuousViewMode(true);
+  }
+  generateDocumentWidgets(currentPage);
+  KVSPrefs::writeConfig();
+  emit viewModeChanged();
+}
+
+void KMultiPage::initializePageCache()
+{
+  pageCache = new DocumentPageCache();
+}
+
+DocumentWidget* KMultiPage::createDocumentWidget()
+{
+  DocumentWidget* documentWidget = new DocumentWidget(scrollView()->viewport(), scrollView(), pageCache, "singlePageWidget");
+  connect(documentWidget, TQT_SIGNAL(clearSelection()), this, TQT_SLOT(clearSelection()));
+  connect(this, TQT_SIGNAL(enableMoveTool(bool)), documentWidget, TQT_SLOT(slotEnableMoveTool(bool)));
+  return documentWidget;
+}
+
+
+void KMultiPage::generateDocumentWidgets(const PageNumber& _startPage)
+{
+  PageNumber startPage = _startPage;
+#ifdef DEBUG_KMULTIPAGE
+  kdDebug(1233) << "KMultiPage::generateDocumentWidgets(" << startPage << ")" << endl;
+#endif
+
+  // Do nothing if no document is loaded.
+  if (getRenderer().isNull() || getRenderer()->isEmpty())
+    return;
+
+  // This function is only called with an invalid pagenumber, when
+  // the file has been loaded or reloaded.
+  bool reload = !startPage.isValid();
+
+  if (reload)
+  {
+    // Find the number of the current page, for later use.
+    startPage = currentPageNumber();
+  }
+
+  // Make sure that startPage is in the permissible range.
+  if (startPage < 1)
+    startPage = 1;
+  if (startPage > numberOfPages())
+    startPage = numberOfPages();
+
+  unsigned int tableauStartPage = startPage;
+
+  // Find out how many widgets are needed, and resize the widgetList accordingly.
+  widgetList.setAutoDelete(true);
+  TQ_UINT16 oldwidgetListSize = widgetList.size();
+  if (numberOfPages() == 0)
+    widgetList.resize(0);
+  else
+  {
+    switch (KVSPrefs::viewMode())
+    {
+      case KVSPrefs::EnumViewMode::SinglePage:
+        widgetList.resize(1);
+        break;
+      case KVSPrefs::EnumViewMode::Overview:
+      {
+        // Calculate the number of pages shown in overview mode.
+        unsigned int visiblePages = KVSPrefs::overviewModeColumns() * KVSPrefs::overviewModeRows();
+        // Calculate the number of the first page in the tableau.
+        tableauStartPage = startPage - ((startPage - 1) % visiblePages);
+        // We cannot have more widgets then pages in the document.
+        visiblePages = TQMIN(visiblePages, numberOfPages() - tableauStartPage + 1);
+        if (widgetList.size() != visiblePages)
+          widgetList.resize(visiblePages);
+        break;
+      }
+      default:
+        // In KVS_Continuous and KVS_ContinuousFacing all pages in the document are shown.
+        widgetList.resize(numberOfPages());
+    }
+  }
+  bool isWidgetListResized = (widgetList.size() != oldwidgetListSize);
+  widgetList.setAutoDelete(false);
+
+  // If the widgetList is empty, there is nothing left to do.
+  if (widgetList.size() == 0) {
+    scrollView()->addChild(&widgetList);
+    return;
+  }
+
+  // Allocate DocumentWidget structures so that all entries of
+  // widgetList point to a valid DocumentWidget.
+  DocumentWidget *documentWidget;
+  for(TQ_UINT16 i=0; i<widgetList.size(); i++) {
+    documentWidget = widgetList[i];
+    if (documentWidget == 0) {
+      documentWidget = createDocumentWidget();
+
+      widgetList.insert(i, documentWidget);
+      documentWidget->show();
+
+      connect(documentWidget, TQT_SIGNAL(localLink(const TQString &)), this, TQT_SLOT(handleLocalLink(const TQString &)));
+      connect(documentWidget, TQT_SIGNAL(setStatusBarText(const TQString&)), this, TQT_SIGNAL(setStatusBarText(const TQString&)) );
+    }
+  }
+
+  // Set the page numbers for the newly allocated widgets. How this is
+  // done depends on the viewMode.
+  if (KVSPrefs::viewMode() == KVSPrefs::EnumViewMode::SinglePage) {
+    // In KVS_SinglePage mode, any number between 1 and the maximum
+    // number of pages is acceptable. If an acceptable value is found,
+    // nothing is done, and otherwise '1' is set as a default.
+    documentWidget = widgetList[0];
+    if (documentWidget != 0) { // Paranoia safety check
+      documentWidget->setPageNumber(startPage);
+      documentWidget->update();
+    } else
+      kdError(4300) << "Zero-Pointer in widgetList in KMultiPage::generateDocumentWidgets()" << endl;
+  } else {
+    // In all other modes, the widgets will be numbered continuously,
+    // starting from firstShownPage.
+    for(TQ_UINT16 i=0; i<widgetList.size(); i++) {
+      documentWidget = widgetList[i];
+      if (documentWidget != 0) // Paranoia safety check
+      {
+        if (KVSPrefs::viewMode() == KVSPrefs::EnumViewMode::Overview)
+          documentWidget->setPageNumber(i+tableauStartPage);
+        else
+          documentWidget->setPageNumber(i+1);
+      }
+      else
+        kdError(4300) << "Zero-Pointer in widgetList in KMultiPage::generateDocumentWidgets()" << endl;
+    }
+  }
+
+  // Make the changes in the widgetList known to the scrollview. so
+  // that the scrollview may update its contents.
+  scrollView()->addChild(&widgetList);
+
+  // If the number of widgets has changed, or the viewmode has been changed the widget 
+  // that displays the current page may not be visible anymore. Bring it back into focus.
+  if (isWidgetListResized || !reload)
+    gotoPage(startPage);
+}
+
+
+bool KMultiPage::gotoPage(const PageNumber& page)
+{
+  return gotoPage(page, 0, true);
+}
+
+
+bool KMultiPage::gotoPage(const PageNumber& page, int y, bool isLink)
+{
+#ifdef DEBUG_KMULTIPAGE
+  kdDebug(1233) << "KMultiPage::gotoPage()" << endl;
+#endif
+
+  if (widgetList.size() == 0) {
+    kdError(4300) << "KMultiPage::gotoPage(" << page << ", y) called, but widgetList is empty" << endl;
+    return false;
+  }
+
+  if (!page.isValid())
+  {
+    kdDebug(1223) << "KMultiPage::gotoPage(" << page << ") invalid pageNumber." << endl;
+    return false;
+  }
+
+  if (isLink)
+    document_history.add(page, y);
+
+  DocumentWidget* pageWidget;
+
+  // If we are in overview viewmode
+  if (KVSPrefs::viewMode() == KVSPrefs::EnumViewMode::Overview)
+  {
+    unsigned int visiblePages = KVSPrefs::overviewModeColumns() * KVSPrefs::overviewModeRows();
+    // Pagenumber of the first visibile Page in the current tableau
+    unsigned int firstPage = ((DocumentWidget*)widgetList[0])->getPageNumber();
+    // Pagenumber of the first page in the new tableau.
+    unsigned int tableauStartPage = page + 1 - (page % visiblePages);
+    // If these numbers arn't equal "page" is not in the current tableu.
+    if (firstPage != tableauStartPage) // widgets need to be updated
+    {
+      if ((numberOfPages() - tableauStartPage + 1 < visiblePages) || (widgetList.size() < visiblePages))
+      {
+        // resize widgetList
+        // the pages are also set correctly by "generateDocumentWidgets"
+        generateDocumentWidgets(tableauStartPage);
+      }
+      else
+      {
+        // "page" is not shown in the scrollview, so we have to switch widgets.
+        // Here we don't need to resize the widgetList.
+        for (unsigned int i = 0; i < widgetList.size(); i++)
+        {
+          pageWidget = (DocumentWidget*)(widgetList[i]);
+          if (pageWidget != 0)
+            pageWidget->setPageNumber(tableauStartPage + i);
+        }
+        scrollView()->layoutPages();
+      }
+    }
+    // move scrollview to "page".
+    // Make the widget pageWidget visible in the scrollview. Somehow this
+    // doesn't seem to trigger the signal contentsMoved in the
+    // TQScrollview, so that we better call setCurrentPage() ourselves.
+    pageWidget = (DocumentWidget*)(widgetList[page % visiblePages]);
+
+    scrollView()->moveViewportToWidget(pageWidget, y);
+
+    // Set current page number.
+    setCurrentPageNumber(page);
+
+    return true;
+  }
+  else if (widgetList.size() == 1)
+  {
+    // If the widget list contains only a single element, then either
+    // the document contains only one page, or we are in "single page"
+    // view mode. In either case, we set the page number of the single
+    // widget to 'page'
+    pageWidget = (DocumentWidget*)(widgetList[0]);
+
+    // Paranoia security check
+    if (pageWidget == 0) {
+      kdError(4300) << "KMultiPage::goto_Page() called with widgetList.size() == 1, but widgetList[0] == 0" << endl;
+      return false;
+    }
+
+    if (pageCache->sizeOfPageInPixel(currentPageNumber()) == pageCache->sizeOfPageInPixel(page))
+    {
+      // We are rendering the page before we switch the widget to the new page.
+      // To make a smooth transition. We only do this if the size of the current and new page are equal,
+      // otherwise we would have to render the page twice, if autozoom is enabled.
+      pageCache->getPage(page);
+    }
+
+    pageWidget->setPageNumber(page);
+    scrollView()->layoutPages();
+    scrollView()->moveViewportToWidget(pageWidget, y);
+  } else {
+    // There are multiple widgets, then we are either in the
+    // "Continuous" or in the "Continouous-Facing" view mode. In that
+    // case, we find the widget which is supposed to display page
+    // 'page' and move the scrollview to make it visible
+
+    // Paranoia security checks
+    if (widgetList.size() < page) {
+      kdError(4300) << "KMultiPage::goto_Page(page,y ) called with widgetList.size()=" << widgetList.size() << ", and page=" << page << endl;
+      return false;
+    }
+    pageWidget = (DocumentWidget*)(widgetList[page-1]);
+    if (pageWidget == 0) {
+      kdError(4300) << "KMultiPage::goto_Page() called with widgetList.size() > 1, but widgetList[page] == 0" << endl;
+      return false;
+    }
+
+    scrollView()->moveViewportToWidget(pageWidget, y);
+  }
+
+  if (isLink && y != 0)
+    pageWidget->flash(y);
+
+  // Set current page number.
+  setCurrentPageNumber(page);
+  return true;
+}
+
+
+void KMultiPage::handleLocalLink(const TQString &linkText)
+{
+#ifdef DEBUG_SPECIAL
+  kdDebug(4300) << "hit: local link to " << linkText << endl;
+#endif
+
+  if (renderer.isNull()) {
+    kdError(4300) << "KMultiPage::handleLocalLink( " << linkText << " ) called, but renderer==0" << endl;
+    return;
+  }
+
+  TQString locallink;
+  if (linkText[0] == '#' )
+    locallink = linkText.mid(1); // Drop the '#' at the beginning
+  else
+    locallink = linkText;
+
+  Anchor anch = renderer->findAnchor(locallink);
+
+  if (anch.isValid())
+    gotoPage(anch);
+  else {
+    if (linkText[0] != '#' ) {
+      // We could in principle use TDEIO::Netaccess::run() here, but
+      // it is perhaps not a very good idea to allow a DVI-file to
+      // specify arbitrary commands, such as "rm -rvf /". Using
+      // the kfmclient seems to be MUCH safer.
+      TQUrl DVI_Url(m_file);
+      TQUrl Link_Url(DVI_Url, linkText, true);
+
+      TQStringList args;
+      args << "openURL";
+      args << Link_Url.toString();
+      kapp->tdeinitExec("kfmclient", args);
+    }
+  }
+}
+
+void KMultiPage::setCurrentPageNumber(const PageNumber& page)
+{
+#ifdef DEBUG_KMULTIPAGE
+  kdDebug(1233) << "KMultiPage::setCurrentPageNumber()" << endl;
+#endif
+
+  if (page != currentPageNumber())
+  {
+    markList()->setCurrentPageNumber(page);
+    emit pageInfo(numberOfPages(), currentPageNumber());
+  }
+}
+
+PageNumber KMultiPage::currentPageNumber()
+{
+  return markList()->currentPageNumber();
+}
+
+void KMultiPage::doGoBack()
+{
+  HistoryItem *it = document_history.back();
+  if (it != 0)
+    gotoPage(it->page, it->ypos, false); // Do not add a history item.
+  else
+    kdDebug(4300) << "Faulty return -- bad history buffer" << endl;
+  return;
+}
+
+
+void KMultiPage::doGoForward()
+{
+  HistoryItem *it = document_history.forward();
+  if (it != 0)
+    gotoPage(it->page, it->ypos, false); // Do not add a history item.
+  else
+    kdDebug(4300) << "Faulty return -- bad history buffer" << endl;
+  return;
+}
+
+
+void KMultiPage::renderModeChanged()
+{
+  pageCache->clear();
+
+  generateDocumentWidgets();
+  scrollView()->layoutPages();
+
+  for (TQ_UINT16 i=0; i < widgetList.size(); i++)
+  {
+    DocumentWidget* documentWidget = widgetList[i];
+    if (documentWidget == 0)
+      continue;
+
+    documentWidget->update();
+  }
+
+  markList()->repaintThumbnails();
+}
+
+
+void KMultiPage::repaintAllVisibleWidgets()
+{
+#ifdef DEBUG_KMULTIPAGE
+  kdDebug(1233) << "KMultiPage::repaintAllVisibleWidgets()" << endl;
+#endif
+
+  bool everResized = false;
+
+  // Go through the list of widgets and resize them, if necessary
+  for(TQ_UINT16 i=0; i<widgetList.size(); i++)
+  {
+    DocumentWidget* documentWidget = widgetList[i];
+    if (documentWidget == 0)
+      continue;
+
+    // Resize, if necessary
+    TQSize pageSize = pageCache->sizeOfPageInPixel(documentWidget->getPageNumber());
+    if (pageSize != documentWidget->pageSize())
+    {
+      documentWidget->setPageSize(pageSize);
+      everResized = true;
+    }
+  }
+
+  // If at least one widget was resized, all widgets should be
+  // re-aligned. This will automatically update all necessary
+  // widgets.
+  if (everResized == true)
+    scrollView()->layoutPages(true);
+}
+
+
+double KMultiPage::setZoom(double zoom)
+{
+#ifdef DEBUG_KMULTIPAGE
+  kdDebug(1233) << "KMultiPage::setZoom(" << zoom << ")" << endl;
+#endif
+
+  if (zoom < ZoomLimits::MinZoom/1000.0)
+    zoom = ZoomLimits::MinZoom/1000.0;
+  if (zoom > ZoomLimits::MaxZoom/1000.0)
+    zoom = ZoomLimits::MaxZoom/1000.0;
+
+  pageCache->setResolution(TQPaintDevice::x11AppDpiX()*zoom);
+  emit zoomChanged();
+  return zoom;
+}
+
+
+void KMultiPage::print()
+{
+  // Paranoid safety checks
+  if (renderer.isNull())
+    return;
+  if (renderer->isEmpty())
+    return;
+
+  // Allocate the printer structure
+  KPrinter *printer = getPrinter();
+  if (printer == 0)
+    return;
+
+  // initialize the printer using the print dialog
+  if ( printer->setup(parentWdg, i18n("Print %1").arg(m_file.section('/', -1))) ) {    
+    // Now do the printing. 
+    TQValueList<int> pageList = printer->pageList();
+    if (pageList.isEmpty()) 
+      printer->abort();
+    else {
+      printer->setCreator("kviewshell");
+      printer->setDocName(m_file);
+      RenderedDocumentPagePrinter rdpp(printer);
+      
+      // Obtain papersize information that is required to perform
+      // the resizing and centering, if this is wanted by the user.
+      Length paperWidth, paperHeight;
+      TQPaintDeviceMetrics pdm(printer);
+      paperWidth.setLength_in_mm(pdm.widthMM());
+      paperHeight.setLength_in_mm(pdm.heightMM());
+      
+      TQValueList<int>::ConstIterator it = pageList.begin();
+      while (true) {
+	SimplePageSize paper_s(paperWidth, paperHeight);
+
+	// Printing usually takes a while. This is to keep the GUI
+	// updated.
+	tqApp->processEvents();
+	
+	TQPainter *paint = rdpp.getPainter();
+	if (paint != 0) {
+	  // Before drawing the page, we figure out the zoom-value,
+	  // taking the "page sizes and placement" options from the
+	  // printer dialog into account
+	  double factual_zoom = 1.0;
+	  
+	  // Obtain pagesize information that is required to perform the
+	  // resizing and centering, if this is wanted by the user.
+	  SimplePageSize page_s = sizeOfPage(*it);
+	  
+	  paint->save();
+
+	  // Rotate the page, if appropriate. By default, page
+	  // rotation is enabled. This is also hardcoded into
+	  // KPrintDialogPage_PageOptions.cpp
+	  if ((page_s.isPortrait() != paper_s.isPortrait()) && (printer->option( "kde-kviewshell-rotatepage" ) != "false")) {
+	    paint->rotate(-90);
+	    paint->translate(-printer->resolution()*paperHeight.getLength_in_inch(), 0.0);
+	    paper_s = paper_s.rotate90();
+	  }
+
+	  double suggested_zoom = page_s.zoomToFitInto(paper_s);
+	  
+	  // By default, "shrink page" and "expand page" are off. This
+	  // is also hardcoded into KPrintDialogPage_PageOptions.cpp
+	  if ((suggested_zoom < 1.0) && (printer->option( "kde-kviewshell-shrinkpage" ) == "true")) 
+	    factual_zoom = suggested_zoom;
+	  if ((suggested_zoom > 1.0) && (printer->option( "kde-kviewshell-expandpage" ) == "true")) 
+	    factual_zoom = suggested_zoom;
+	  
+	  Length delX, delY;
+	  // By default, "center page" is on. This is also hardcoded
+	  // into KPrintDialogPage_PageOptions.cpp
+	  if (printer->option( "kde-kviewshell-centerpage" ) != "false") {
+	    delX = (paper_s.width() - page_s.width()*factual_zoom)/2.0;
+	    delY = (paper_s.height() - page_s.height()*factual_zoom)/2.0;
+	  }
+	  
+	  // Now draw the page.
+	  rdpp.setPageNumber(*it);
+	  
+	  double resolution = factual_zoom*printer->resolution();
+	  
+	  paint->translate(resolution*delX.getLength_in_inch(), resolution*delY.getLength_in_inch());
+	  renderer->drawPage(resolution, &rdpp);
+	  paint->restore();
+	}
+	++it;
+	if ((it == pageList.end()) || (printer->aborted() == true))
+	  break;
+	
+	printer->newPage();
+      }
+      // At this point the rdpp is destructed. The last page is then
+      // printed.
+    }
+  }
+  delete printer;
+}
+
+
+void KMultiPage::setRenderer(DocumentRenderer* _renderer)
+{
+  renderer = _renderer;
+
+  // Initialize documentPageCache.
+  initializePageCache();
+  pageCache->setRenderer(renderer);
+
+  _markList->setPageCache(pageCache);
+
+  // Clear widget list.
+  widgetList.resize(0);
+
+  // Relay signals.
+  connect(renderer, TQT_SIGNAL(setStatusBarText(const TQString&)), this, TQT_SIGNAL(setStatusBarText(const TQString&)));
+  connect(pageCache, TQT_SIGNAL(paperSizeChanged()), this, TQT_SLOT(renderModeChanged()));
+  connect(pageCache, TQT_SIGNAL(textSelected(bool)), this, TQT_SIGNAL(textSelected(bool)));
+  connect(renderer, TQT_SIGNAL(documentIsChanged()), this, TQT_SLOT(renderModeChanged()));
+  connect(this, TQT_SIGNAL(zoomChanged()), this, TQT_SLOT(repaintAllVisibleWidgets()));
+}
+
+
+void KMultiPage::updateWidgetSize(const PageNumber& pageNumber)
+{
+  for(TQ_UINT16 i=0; i<widgetList.size(); i++)
+  {
+    DocumentWidget* documentWidget = widgetList[i];
+    if (documentWidget == 0)
+      continue;
+
+    if (documentWidget->getPageNumber() == pageNumber)
+    {
+      // Resize, if necessary
+      TQSize pageSize = pageCache->sizeOfPageInPixel(documentWidget->getPageNumber());
+      if (pageSize != documentWidget->pageSize())
+      {
+        documentWidget->setPageSize(pageSize);
+        scrollView()->layoutPages();
+      }
+      // We have just one widget per page.
+      break;
+    }
+  }
+
+  // Update marklist
+  markList()->updateWidgetSize(pageNumber);
+}
+
+
+PageNumber KMultiPage::widestPage() const
+{
+  Length maxWidth;
+  PageNumber pageNumber = 1;
+
+  for (int i = 1; i <= numberOfPages(); i++)
+  {
+    Length width = pageCache->sizeOfPage(i).width();
+
+    if (width > maxWidth)
+    {
+      maxWidth = width;
+      pageNumber = i;
+    }
+  }
+
+  return pageNumber;
+}
+
+double KMultiPage::zoomForWidthColumns(unsigned int viewportWidth) const
+{
+  Length maxLeftColumnWidth;
+  Length maxRightColumnWidth;
+  Length maxWidth;
+
+  PageNumber widestPageLeft;
+  PageNumber widestPageRight;
+
+  for (int i = 1; i <= numberOfPages(); i++)
+  {
+    Length width = pageCache->sizeOfPage(i).width();
+
+    if ( i % 2 == 0) // page is in left column
+    {
+      if (width > maxLeftColumnWidth)
+      {
+        maxLeftColumnWidth = width;
+        widestPageLeft = i;
+      }
+    }
+
+    if ( i % 2 == 1) // page is in right column
+    {
+      if (width > maxRightColumnWidth)
+        maxRightColumnWidth = width;
+        widestPageRight = i;
+    }
+  }
+
+  double ratio =  maxLeftColumnWidth / (maxLeftColumnWidth + maxRightColumnWidth);
+
+  // This number is the amount of space the left column should occupy in the viewport.
+  unsigned int leftTargetWidth = (unsigned int)(ratio * viewportWidth);
+
+  return pageCache->sizeOfPage(widestPageLeft).zoomForWidth(leftTargetWidth);
+}
+
+double KMultiPage::calculateFitToHeightZoomValue()
+{
+  PageNumber pageNumber = 1;
+
+  // See below, in the documentation of the method "calculatefitToWidthZoomLevel"
+  // for an explanation of the complicated calculation we are doing here.
+  int columns = scrollView()->getNrColumns();
+  int rows = scrollView()->getNrRows();
+  int continuousViewmode = scrollView()->isContinuous();
+  bool fullScreenMode = scrollView()->fullScreenMode();
+
+  if (columns == 1 && rows == 1 && !continuousViewmode) // single page mode
+  {
+    pageNumber = currentPageNumber();
+    if (!pageNumber.isValid())
+      pageNumber = 1;
+  }
+
+  int pageDistance = scrollView()->distanceBetweenPages();
+  if (columns == 1 && rows == 1 && !continuousViewmode && fullScreenMode)
+  {
+    // In Single Page Fullscreen Mode we want to fit the page to the
+    // window without a margin around it.
+    pageDistance = 0;
+  }
+
+  int targetViewportHeight = scrollView()->viewportSize(0,0).height();
+  int targetPageHeight = (targetViewportHeight - rows*pageDistance)/rows;
+  int targetPageWidth  = (int)(targetPageHeight * pageCache->sizeOfPage(pageNumber).aspectRatio() );
+  int targetViewportWidth = targetPageWidth * columns + (columns+1)*pageDistance;
+  targetViewportHeight = scrollView()->viewportSize(targetViewportWidth, targetViewportHeight).height();
+  targetPageHeight = (targetViewportHeight - rows*pageDistance)/rows;
+
+  return pageCache->sizeOfPage(pageNumber).zoomForHeight(targetPageHeight);
+}
+
+
+double KMultiPage::calculateFitToWidthZoomValue()
+{
+  PageNumber pageNumber = 1;
+
+  int columns = scrollView()->getNrColumns();
+  int rows = scrollView()->getNrRows();
+  int continuousViewmode = scrollView()->isContinuous();
+  bool fullScreenMode = scrollView()->fullScreenMode();
+
+  if (columns == 1 && rows == 1 && !continuousViewmode) // single page mode
+  {
+    // To calculate the zoom level in single page mode we need the size
+    // of the current page. When a new document is opened this function
+    // is called while the currentPageNumber is invalid. We use the size
+    // of the first page of the document in this case.
+    pageNumber = currentPageNumber();
+    if (!pageNumber.isValid())
+      pageNumber = 1;
+  }
+
+  if (columns == 1 && rows == 1 && continuousViewmode) // continuous viewmode
+  {
+    pageNumber = widestPage();
+    if (!pageNumber.isValid())
+      pageNumber = 1;
+  }
+
+  // rows should be 1 for Single Page Viewmode,
+  // the number of Pages in Continuous Viewmode
+  // and number of Pages/2 in Continuous-Facing Viewmode
+  if (continuousViewmode)
+    rows = (int)(ceil(numberOfPages() / (double)columns));
+
+  int pageDistance = scrollView()->distanceBetweenPages();
+  if (columns == 1 && rows == 1 && !continuousViewmode && fullScreenMode)
+  {
+    // In Single Page Fullscreen Mode we want to fit the page to the
+    // window without a margin around it.
+    pageDistance = 0;
+  }
+  // There is a slight complication here... if we just take the width
+  // of the viewport and scale the contents by a factor x so that it
+  // fits the viewport exactly, then, depending on chosen papersize
+  // (landscape, etc.), the contents may be higher than the viewport
+  // and the TQScrollview may or may not insert a scrollbar at the
+  // right. If the scrollbar appears, then the usable width of the
+  // viewport becomes smaller, and scaling by x does not really fit
+  // the (now smaller page) anymore.
+
+  // Calculate the width and height of the view, disregarding the
+  // possible complications with scrollbars, e.g. assuming the maximal
+  // space is available.
+
+  // width of the widget excluding possible scrollbars
+  int targetViewportWidth  = scrollView()->viewportSize(0,0).width();
+
+  // maximal width of a single page
+  int targetPageWidth = (targetViewportWidth - (columns+1) * pageDistance) / columns;
+
+  // maximal height of a single page
+  int targetPageHeight = (int)(targetPageWidth/pageCache->sizeOfPage(pageNumber).aspectRatio());
+  // FIXME: this is only correct if all pages in the document have the same height
+  int targetViewportHeight = rows * targetPageHeight + (rows+1) * pageDistance;
+
+  // Think again, this time use only the area which is really
+  // acessible (which, in case that targetWidth targetHeight don't fit
+  // the viewport, is really smaller because of the scrollbars).
+  targetViewportWidth = scrollView()->viewportSize(targetViewportWidth, targetViewportHeight).width();
+
+  if (columns == 2 && continuousViewmode) // continuous facing
+  {
+    // TODO Generalize this for more than 2 columns
+    return zoomForWidthColumns(targetViewportWidth - (columns+1) * pageDistance);
+  }
+
+  // maximal width of a single page (now the scrollbars are taken into account)
+  targetPageWidth = (targetViewportWidth - (columns+1) * pageDistance) / columns;
+
+  return pageCache->sizeOfPage(pageNumber).zoomForWidth(targetPageWidth);
+}
+
+
+void KMultiPage::prevPage()
+{
+  TQ_UINT8 cols = scrollView()->getNrColumns();
+  TQ_UINT8 rows = scrollView()->getNrRows();
+
+  PageNumber np = 1;
+  if (cols*rows < currentPageNumber())
+  {
+    np = currentPageNumber() - cols*rows;
+  }
+
+  gotoPage(np);
+}
+
+
+void KMultiPage::nextPage()
+{
+  TQ_UINT8 cols = scrollView()->getNrColumns();
+  TQ_UINT8 rows = scrollView()->getNrRows();
+
+  PageNumber np = TQMIN(currentPageNumber() + cols*rows, (TQ_UINT16)numberOfPages());
+
+  gotoPage(np);
+}
+
+
+void KMultiPage::firstPage()
+{
+  gotoPage(1);
+}
+
+
+void KMultiPage::lastPage()
+{
+  gotoPage(numberOfPages());
+}
+
+
+void KMultiPage::scroll(TQ_INT32 deltaInPixel)
+{
+  TQScrollBar* scrollBar = scrollView()->verticalScrollBar();
+  if (scrollBar == 0) {
+    kdError(4300) << "KMultiPage::scroll called without scrollBar" << endl;
+    return;
+  }
+
+  if (deltaInPixel < 0) {
+    if (scrollBar->value() == scrollBar->minValue()) {
+      if ( (currentPageNumber() == 1) || (changePageDelayTimer.isActive()) )
+        return;
+
+      if (scrollView()->isContinuous())
+        return;
+
+      changePageDelayTimer.stop();
+      prevPage();
+
+      scrollView()->setContentsPos(scrollView()->contentsX(), scrollBar->maxValue());
+      return;
+    }
+  }
+
+  if (deltaInPixel > 0) {
+    if (scrollBar->value() == scrollBar->maxValue()) {
+      if ( (currentPageNumber() == numberOfPages()) || (changePageDelayTimer.isActive()) )
+        return;
+
+      if (scrollView()->isContinuous())
+        return;
+
+      changePageDelayTimer.stop();
+      nextPage();
+
+      scrollView()->setContentsPos(scrollView()->contentsX(), 0);
+      return;
+    }
+  }
+
+  scrollBar->setValue(scrollBar->value() + deltaInPixel);
+
+  if ( (scrollBar->value() == scrollBar->maxValue()) || (scrollBar->value() == scrollBar->minValue()) )
+    changePageDelayTimer.start(200,true);
+  else
+    changePageDelayTimer.stop();
+}
+
+
+void KMultiPage::scrollUp()
+{
+  TQScrollBar* scrollBar = scrollView()->verticalScrollBar();
+  if (scrollBar == 0)
+    return;
+
+  scroll(-scrollBar->lineStep());
+}
+
+
+void KMultiPage::scrollDown()
+{
+  TQScrollBar* scrollBar = scrollView()->verticalScrollBar();
+  if (scrollBar == 0)
+    return;
+
+  scroll(scrollBar->lineStep());
+}
+
+void KMultiPage::scrollLeft()
+{
+  TQScrollBar* scrollBar = scrollView()->horizontalScrollBar();
+  if (scrollBar)
+    scrollBar->subtractLine();
+}
+
+
+void KMultiPage::scrollRight()
+{
+  TQScrollBar* scrollBar = scrollView()->horizontalScrollBar();
+  if (scrollBar)
+    scrollBar->addLine();
+}
+
+
+void KMultiPage::scrollUpPage()
+{
+  TQScrollBar* scrollBar = scrollView()->verticalScrollBar();
+  if (scrollBar)
+    scrollBar->subtractPage();
+}
+
+
+void KMultiPage::scrollDownPage()
+{
+  TQScrollBar* scrollBar = scrollView()->verticalScrollBar();
+  if (scrollBar)
+    scrollBar->addPage();
+}
+
+
+void KMultiPage::scrollLeftPage()
+{
+  TQScrollBar* scrollBar = scrollView()->horizontalScrollBar();
+  if (scrollBar)
+    scrollBar->subtractPage();
+}
+
+
+void KMultiPage::scrollRightPage()
+{
+  TQScrollBar* scrollBar = scrollView()->horizontalScrollBar();
+  if (scrollBar)
+    scrollBar->addPage();
+}
+
+
+void KMultiPage::readDown()
+{
+  PageView* sv = scrollView();
+
+  if (sv->atBottom())
+  {
+    if (sv->isContinuous())
+      return;
+
+    if (currentPageNumber() == numberOfPages())
+      return;
+
+    nextPage();
+    sv->setContentsPos(sv->contentsX(), 0);
+  }
+  else
+    sv->readDown();
+}
+
+
+void KMultiPage::readUp()
+{
+  PageView* sv = scrollView();
+
+  if (sv->atTop())
+  {
+    if (sv->isContinuous())
+      return;
+
+    if (currentPageNumber() == 1)
+      return;
+
+    prevPage();
+    sv->setContentsPos(sv->contentsX(),  sv->contentsHeight());
+  }
+  else
+    sv->readUp();
+}
+
+
+void KMultiPage::jumpToReference(const TQString& reference)
+{
+  if (renderer.isNull())
+    return;
+  
+  gotoPage(renderer->parseReference(reference));
+}
+
+
+void KMultiPage::gotoPage(const Anchor &a)
+{
+  if (!a.page.isValid() || (renderer.isNull()))
+    return;
+
+  gotoPage(a.page, (int)(a.distance_from_top.getLength_in_inch()*pageCache->getResolution() + 0.5), true);
+}
+
+
+void KMultiPage::gotoPage(const TextSelection& selection)
+{
+  if (selection.isEmpty())
+  {
+    kdError(4300) << "KMultiPage::gotoPage(...) called with empty TextSelection." << endl;
+    return;
+  }
+
+  RenderedDocumentPage* pageData = pageCache->getPage(selection.getPageNumber());
+
+  if (pageData == 0) {
+#ifdef DEBUG_DOCUMENTWIDGET
+    kdDebug(4300) << "DocumentWidget::paintEvent: no documentPage generated" << endl;
+#endif
+    return;
+  }
+
+  switch (widgetList.size())
+  {
+    case 0:
+      kdError(4300) << "KMultiPage::select() while widgetList is empty" << endl;
+      break;
+    case 1:
+      ((DocumentWidget*)widgetList[0])->select(selection);
+      break;
+    default:
+      if (widgetList.size() < currentPageNumber())
+        kdError(4300) << "KMultiPage::select() while widgetList.size()=" << widgetList.size() << "and currentPageNumber()=" << currentPageNumber() << endl;
+      else
+        ((DocumentWidget*)widgetList[selection.getPageNumber() - 1])->select(selection);
+  }
+
+  unsigned int y = pageData->textBoxList[selection.getSelectedTextStart()].box.top();
+  gotoPage(selection.getPageNumber(), y, false);
+}
+
+
+void KMultiPage::doSelectAll()
+{
+  switch( widgetList.size() ) {
+  case 0:
+    kdError(4300) << "KMultiPage::doSelectAll() while widgetList is empty" << endl;
+    break;
+  case 1:
+    ((DocumentWidget *)widgetList[0])->selectAll();
+    break;
+  default:
+    if (widgetList.size() < currentPageNumber())
+      kdError(4300) << "KMultiPage::doSelectAll() while widgetList.size()=" << widgetList.size() << "and currentPageNumber()=" << currentPageNumber() << endl;
+    else
+      ((DocumentWidget *)widgetList[currentPageNumber()-1])->selectAll();
+  }
+}
+
+
+
+void  KMultiPage::showFindTextDialog()
+{
+  if ((renderer.isNull()) || (renderer->supportsTextSearch() == false))
+    return;
+
+  searchWidget->show();
+  searchWidget->setFocus();
+}
+
+void KMultiPage::stopSearch()
+{
+  if (searchInProgress)
+  {
+    // stop the search
+    searchInProgress = false;
+  }
+  else
+    searchWidget->hide();
+}
+
+void KMultiPage::findNextText()
+{
+#ifdef KDVI_MULTIPAGE_DEBUG
+  kdDebug(4300) << "KMultiPage::findNextText() called" << endl;
+#endif
+
+  searchInProgress = true;
+
+  // Used to remember if the documentPage we use is from the cache.
+  // If not we need to delete it manually to avoid a memory leak.
+  bool cachedPage = false;
+
+  TQString searchText = searchWidget->getText();
+
+  if (searchText.isEmpty())
+  {
+    kdError(4300) << "KMultiPage::findNextText() called when search text was empty" << endl;
+    return;
+  }
+
+  bool case_sensitive = searchWidget->caseSensitive();
+
+  // Find the page and text position on the page where the search will
+  // start. If nothing is selected, we start at the beginning of the
+  // current page. Otherwise, start after the selected text.  TODO:
+  // Optimize this to get a better 'user feeling'
+  TQ_UINT16 startingPage;
+  TQ_UINT16 startingTextItem;
+
+  TextSelection userSelection = pageCache->selectedText();
+  if (userSelection.isEmpty())
+  {
+    startingPage     = currentPageNumber();
+    startingTextItem = 0;
+  }
+  else
+  {
+    startingPage     = userSelection.getPageNumber();
+    startingTextItem = userSelection.getSelectedTextEnd()+1;
+  }
+
+  TextSelection foundSelection;
+
+  RenderedDocumentPagePixmap* searchPage = 0;
+
+  for(unsigned int i = 0; i < numberOfPages(); i++)
+  {
+    unsigned int pageNumber = (i + startingPage - 1) % numberOfPages() + 1;
+
+    if (!searchInProgress)
+    {
+      // Interrupt the search
+      setStatusBarText(i18n("Search interrupted"));
+      if (!cachedPage)
+        delete searchPage;
+      return;
+    }
+
+    if (i != 0)
+    {
+      setStatusBarText(i18n("Search page %1 of %2").arg(pageNumber).arg(numberOfPages()));
+      kapp->processEvents();
+    }
+
+    // Check if we already have a rendered version of the page in the cache. As we are only interested in the
+    // text we don't care about the page size.
+    if (pageCache->isPageCached(pageNumber))
+    {
+      // If the last search page used was created locally, we need to destroy it
+      if (!cachedPage)
+        delete searchPage;
+
+      searchPage = pageCache->getPage(pageNumber);
+      cachedPage = true;
+    }
+    else
+    {
+      // If the page is not in the cache we draw a small version of it, since this is faster.
+
+      // We only create a new searchPage if we need to, otherwise reuse the existing one.
+      if (!searchPage || cachedPage)
+        searchPage = new RenderedDocumentPagePixmap();
+
+      cachedPage = false;
+
+      searchPage->resize(1,1);
+      searchPage->setPageNumber(pageNumber);
+      renderer->getText(searchPage);
+    }
+
+    // If there is no text in the current page, try the next one.
+    if (searchPage->textBoxList.size() == 0)
+      continue;
+
+    foundSelection = searchPage->find(searchText, startingTextItem, case_sensitive);
+
+    if (foundSelection.isEmpty())
+    {
+      // In the next page, start search again at the beginning.
+      startingTextItem = 0;
+      clearSelection();
+
+      if (pageNumber == numberOfPages())
+      {
+        int answ = KMessageBox::questionYesNo(scrollView(),
+                   i18n("<qt>The search string <strong>%1</strong> could not be found by the "
+                        "end of the document. Should the search be restarted from the beginning "
+                        "of the document?</qt>").arg(searchText),
+                   i18n("Text Not Found"), KStdGuiItem::cont(), KStdGuiItem::cancel());
+
+        if (answ != KMessageBox::Yes)
+        {
+          setStatusBarText(TQString());
+          searchInProgress = false;
+          if (!cachedPage)
+            delete searchPage;
+          return;
+        }
+      }
+    }
+    else
+    {
+      pageCache->selectText(foundSelection);
+      gotoPage(pageCache->selectedText());
+      setStatusBarText(TQString());
+      searchInProgress = false;
+      if (!cachedPage)
+        delete searchPage;
+      return;
+    }
+  }
+
+  KMessageBox::sorry(scrollView(), i18n("<qt>The search string <strong>%1</strong> could not be found.</qt>").arg(searchText));
+  setStatusBarText(TQString());
+  searchInProgress = false;
+  if (!cachedPage)
+    delete searchPage;
+}
+
+
+void KMultiPage::findPrevText()
+{
+#ifdef KDVI_MULTIPAGE_DEBUG
+  kdDebug(4300) << "KMultiPage::findPrevText() called" << endl;
+#endif
+
+  searchInProgress = true;
+
+  // Used to remember if the documentPage we use is from the cache.
+  // If not we need to delete it manually to avoid a memory leak.
+  bool cachedPage = false;
+
+  TQString searchText = searchWidget->getText();
+
+  if (searchText.isEmpty())
+  {
+    kdError(4300) << "KMultiPage::findPrevText() called when search text was empty" << endl;
+    return;
+  }
+
+  bool case_sensitive = searchWidget->caseSensitive();
+
+  // Find the page and text position on the page where the search will
+  // start. If nothing is selected, we start at the beginning of the
+  // current page. Otherwise, start after the selected text.  TODO:
+  // Optimize this to get a better 'user feeling'
+  unsigned int startingPage;
+  int startingTextItem;
+
+  TextSelection userSelection = pageCache->selectedText();
+  if (userSelection.isEmpty())
+  {
+    startingPage     = currentPageNumber();
+    startingTextItem = -1;
+  }
+  else
+  {
+    startingPage     = userSelection.getPageNumber();
+    startingTextItem = userSelection.getSelectedTextStart()-1;
+  }
+
+  TextSelection foundSelection;
+
+  RenderedDocumentPagePixmap* searchPage = 0;
+
+  for(unsigned int i = 0; i < numberOfPages(); i++)
+  {
+    int pageNumber = startingPage - i;
+    if (pageNumber <= 0)
+      pageNumber += numberOfPages();
+
+    if (!searchInProgress)
+    {
+      // Interrupt the search
+      setStatusBarText(i18n("Search interrupted"));
+      if (!cachedPage)
+        delete searchPage;
+      return;
+    }
+
+    if (i != 0)
+    {
+      setStatusBarText(i18n("Search page %1 of %2").arg(pageNumber).arg(numberOfPages()));
+      kapp->processEvents();
+    }
+
+    // Check if we already have a rendered version of the page in the cache. As we are only interested in the
+    // text we don't care about the page size.
+    if (pageCache->isPageCached(pageNumber))
+    {
+      // If the last search page used was created locally, we need to destroy it
+      if (!cachedPage)
+        delete searchPage;
+
+      searchPage = pageCache->getPage(pageNumber);
+      cachedPage = true;
+    }
+    else
+    {
+      // If the page is not in the cache we draw a small version of it, since this is faster.
+
+      // We only create a new searchPage if we need to, otherwise reuse the existing one.
+      if (!searchPage || cachedPage)
+        searchPage = new RenderedDocumentPagePixmap();
+
+      cachedPage = false;
+
+      searchPage->resize(1,1);
+      searchPage->setPageNumber(pageNumber);
+      renderer->getText(searchPage);
+    }
+
+    // If there is no text in the current page, try the next one.
+    if (searchPage->textBoxList.size() == 0)
+      continue;
+
+    foundSelection = searchPage->findRev(searchText, startingTextItem, case_sensitive);
+
+    if (foundSelection.isEmpty())
+    {
+      // In the next page, start search again at the beginning.
+      startingTextItem = -1;
+      clearSelection();
+
+      if (pageNumber == 1)
+      {
+        int answ = KMessageBox::questionYesNo(scrollView(),
+                  i18n("<qt>The search string <strong>%1</strong> could not be found by the "
+                        "beginning of the document. Should the search be restarted from the end "
+                        "of the document?</qt>").arg(searchText),
+                  i18n("Text Not Found"), KStdGuiItem::cont(), KStdGuiItem::cancel());
+
+        if (answ != KMessageBox::Yes)
+        {
+          setStatusBarText(TQString());
+          searchInProgress = false;
+          if (!cachedPage)
+            delete searchPage;
+          return;
+        }
+      }
+    }
+    else
+    {
+      pageCache->selectText(foundSelection);
+      gotoPage(pageCache->selectedText());
+      setStatusBarText(TQString());
+      searchInProgress = false;
+      if (!cachedPage)
+        delete searchPage;
+      return;
+    }
+  }
+
+  KMessageBox::sorry(scrollView(), i18n("<qt>The search string <strong>%1</strong> could not be found.</qt>").arg(searchText));
+  setStatusBarText(TQString());
+  searchInProgress = false;
+  if (!cachedPage)
+    delete searchPage;
+}
+
+
+void KMultiPage::clearSelection()
+{
+  PageNumber page = pageCache->selectedText().getPageNumber();
+
+  if (!page.isValid())
+    return;
+
+  // Clear selection
+  pageCache->deselectText();
+
+  // Now we need to update the widget which contained the selection
+  switch(widgetList.size())
+  {
+    case 0:
+      kdError(4300) << "KMultiPage::clearSelection() while widgetList is empty" << endl;
+      break;
+    case 1:
+      widgetList[0]->update();
+      break;
+    default:
+      for (unsigned int i = 0; i < widgetList.size(); i++)
+      {
+        DocumentWidget* pageWidget = (DocumentWidget*)widgetList[i];
+        if (pageWidget->getPageNumber() == page)
+        {
+          pageWidget->update();
+          break;
+        }
+      }
+  }
+}
+
+void KMultiPage::copyText()
+{
+  pageCache->selectedText().copyText();
+}
+
+void KMultiPage::timerEvent( TQTimerEvent * )
+{
+#ifdef KMULTIPAGE_DEBUG
+  kdDebug(4300) << "Timer Event " << endl;
+#endif
+  reload();
+}
+
+
+void KMultiPage::reload()
+{
+#ifdef KMULTIPAGE_DEBUG
+  kdDebug(4300) << "Reload file " << m_file << endl;
+#endif
+  
+  if (renderer.isNull()) {
+    kdError() << "KMultiPage::reload() called, but no renderer was set" << endl;
+    return;
+  }
+  
+  if (renderer->isValidFile(m_file)) {
+    pageCache->clear();
+    pageCache->deselectText();
+    document_history.clear();
+    emit setStatusBarText(i18n("Reloading file %1").arg(m_file));
+    TQ_INT32 pg = currentPageNumber();
+
+    killTimer(timer_id);
+    timer_id = -1;
+    bool r = renderer->setFile(m_file, m_url);
+    
+    generateDocumentWidgets();
+
+    // Set Table of Contents
+    tableOfContents->setContents(renderer->getBookmarks());
+
+    // Adjust number of widgets in the thumbnail sidebar
+    markList()->clear();
+    markList()->setNumberOfPages(numberOfPages(), KVSPrefs::showThumbnails());
+
+    setCurrentPageNumber(pg);
+    setFile(r);
+    emit setStatusBarText(TQString());
+  } else {
+    if (timer_id == -1)
+      timer_id = startTimer(1000);
+  }
+}
+
+
+bool KMultiPage::openFile()
+{
+  if (renderer.isNull()) {
+    kdError(4300) << "KMultiPage::openFile() called when no renderer was set" << endl;
+    return false;
+  }
+
+  pageCache->deselectText();
+  document_history.clear();
+  pageCache->clear();
+  emit setStatusBarText(i18n("Loading file %1").arg(m_file));
+
+  bool r = renderer->setFile(m_file, m_url);
+
+  if (r) {
+    setCurrentPageNumber(1);
+    generateDocumentWidgets();
+
+    // Set number of widgets in the thumbnail sidebar
+    markList()->clear();
+    markList()->setNumberOfPages(numberOfPages(), KVSPrefs::showThumbnails());
+    
+    TQString reference = url().ref();
+    if (!reference.isEmpty())
+      gotoPage(renderer->parseReference(reference));
+    
+    // Set Table of Contents
+    tableOfContents->setContents(renderer->getBookmarks());
+  } else
+    m_file = TQString();
+
+  
+  setFile(r);
+  
+  // Clear Statusbar
+  emit setStatusBarText(TQString());
+  return r;
+}
+
+
+bool KMultiPage::openURL(const TQString &filename, const KURL &base_url)
+{
+  m_file = filename;
+  m_url = base_url;
+
+  bool success = openFile();
+  if (success)
+    setCurrentPageNumber(1);
+
+  return success;
+}
+
+
+void KMultiPage::enableActions(bool fileLoaded)
+{
+  Q_UNUSED(fileLoaded);
+}
+
+void KMultiPage::wheelEvent(TQWheelEvent *e)
+{
+  TQScrollBar *sb = scrollView()->verticalScrollBar();
+  if (sb == 0)
+    return;
+
+  // Zoom in/out
+  if (e->state() & ControlButton)
+  {
+    if (e->delta() < 0)
+      emit zoomOut();
+    else
+      emit zoomIn();
+    return;
+  }
+
+  TQ_INT32 pxl = -(e->delta()*sb->lineStep())/60;
+  if (pxl == 0)
+  {
+    if (e->delta() > 0)
+      pxl = -1;
+    else
+      pxl = 1;
+  }
+
+  // Faster scrolling
+  if (e->state() & ShiftButton)
+    pxl *= 10;
+
+  scroll(pxl);
+}
+
+
+KPrinter *KMultiPage::getPrinter(bool enablePageSizeFeatures)
+{
+    // Allocate a new KPrinter structure, if necessary
+  KPrinter *printer = new KPrinter(true);
+  if (printer == 0) {
+    kdError(1223) << "KMultiPage::getPrinter(..): Cannot allocate new KPrinter structure" << endl;
+    return 0;
+  }
+  
+  // Allocate a new KPrintDialogPage structure and add it to the
+  // printer, if the tdemultipage implementation requests that
+  if (enablePageSizeFeatures == true) {
+    KPrintDialogPage_PageOptions *pageOptions = new KPrintDialogPage_PageOptions();
+    if (pageOptions == 0) {
+      kdError(1223) << "KMultiPage::getPrinter(..): Cannot allocate new KPrintDialogPage_PageOptions structure" << endl;
+      delete printer;
+      return 0;
+    }
+    printer->addDialogPage( pageOptions );
+  }
+  
+  // Feed the printer with useful defaults and information.
+  printer->setPageSelection( KPrinter::ApplicationSide );
+  printer->setCurrentPage( currentPageNumber() );
+  printer->setMinMax( 1, numberOfPages() );
+  printer->setFullPage( true );
+  
+  // If pages are marked, give a list of marked pages to the
+  // printer. We try to be smart and optimize the list by using ranges
+  // ("5-11") wherever possible. The user will be tankful for
+  // that. Complicated? Yeah, but that's life.
+  TQValueList<int> selectedPageNo = selectedPages();
+  if (selectedPageNo.isEmpty() == true)
+    printer->setOption( "kde-range", "" );
+  else {
+    int commaflag = 0;
+    TQString range;
+    TQValueList<int>::ConstIterator it = selectedPageNo.begin();
+    do{
+      int val = *it;
+      if (commaflag == 1)
+	range +=  TQString(", ");
+      else
+	commaflag = 1;
+      int endval = val;
+      if (it != selectedPageNo.end()) {
+	TQValueList<int>::ConstIterator jt = it;
+	jt++;
+	do{
+	  int val2 = *jt;
+	  if (val2 == endval+1)
+	    endval++;
+	  else
+	    break;
+	  jt++;
+	} while( jt != selectedPageNo.end() );
+	it = jt;
+      } else
+	it++;
+      if (endval == val)
+	range +=  TQString("%1").arg(val);
+      else
+	range +=  TQString("%1-%2").arg(val).arg(endval);
+    } while (it != selectedPageNo.end() );
+    printer->setOption( "kde-range", range );
+  }
+  
+  return printer;  
+}
+
+void KMultiPage::doExportText()
+{
+  // Generate a suggestion for a reasonable file name
+  TQString suggestedName = url().filename();
+  suggestedName = suggestedName.left(suggestedName.find(".")) + ".txt";
+
+  TQString fileName = KFileDialog::getSaveFileName(suggestedName, i18n("*.txt|Plain Text (Latin 1) (*.txt)"), scrollView(), i18n("Export File As"));
+
+  if (fileName.isEmpty())
+    return;
+
+  TQFileInfo finfo(fileName);
+  if (finfo.exists())
+  {
+    int r = KMessageBox::warningContinueCancel (scrollView(),
+                i18n("The file %1\nexists. Do you want to overwrite that file?").arg(fileName),
+                i18n("Overwrite File"), i18n("Overwrite"));
+
+    if (r == KMessageBox::Cancel)
+      return;
+  }
+
+  TQFile textFile(fileName);
+  textFile.open(IO_WriteOnly);
+  TQTextStream stream(&textFile);
+
+  TQProgressDialog progress(i18n("Exporting to text..."), i18n("Abort"), renderer->totalPages(),
+                           scrollView(), "export_text_progress", true);
+  progress.setMinimumDuration(300);
+
+  RenderedDocumentPagePixmap dummyPage;
+  dummyPage.resize(1, 1);
+
+  for(unsigned int page = 1; page <= renderer->totalPages(); page++)
+  {
+    progress.setProgress(page);
+    tqApp->processEvents();
+
+    if (progress.wasCancelled())
+      break;
+
+    dummyPage.setPageNumber(page);
+    // We gracefully ignore any errors (bad file, etc.)
+    renderer->getText(&dummyPage);
+
+    for(unsigned int i = 0; i < dummyPage.textBoxList.size(); i++)
+    {
+      // We try to detect newlines
+      if (i > 0)
+      {
+        // Like all our textalgorithmns this currently assumes left to right text.
+        // TODO: make this more generic. But we first would need to guess the corrent
+        // orientation.
+        if (dummyPage.textBoxList[i].box.top() > dummyPage.textBoxList[i-1].box.bottom() &&
+            dummyPage.textBoxList[i].box.x() < dummyPage.textBoxList[i-1].box.x())
+        {
+          stream << "\n";
+        }
+      }
+      stream << dummyPage.textBoxList[i].text;
+    }
+
+    // Send newline after each page.
+    stream << "\n";
+  }
+
+  // Switch off the progress dialog, etc.
+  progress.setProgress(renderer->totalPages());
+  return;
+}
+
+void KMultiPage::slotEnableMoveTool(bool enable)
+{
+  emit enableMoveTool(enable);
+}
+
+#include "tdemultipage.moc"