path: root/kviewshell/kmultipage.cpp

#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 "kmultipage.h"
#include "pageNumber.h"
#include "renderedDocumentPagePrinter.h"
#include "searchWidget.h"
#include "textBox.h"
#include "zoomlimits.h"


//#define DEBUG_KMULTIPAGE

KMultiPage::KMultiPage(TQWidget *tqparentWidget, const char *widgetName, TQObject *tqparent, const char *name)
  : DCOPObject("kmultipage"), KParts::ReadOnlyPart(tqparent, 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("kmultipage");

  tqparentWdg = tqparentWidget;
  lastCurrentPage = 0;
  timer_id = -1;
  searchInProgress = false;
  
  TQVBox* verticalBox = new TQVBox(tqparentWidget);
  verticalBox->setFocusPolicy(TQ_StrongFocus);
  setWidget(verticalBox);
  
  splitterWidget = new TQSplitter(verticalBox, widgetName);
  splitterWidget->setOpaqueResize(false);
  splitterWidget->tqsetSizePolicy(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 tqlayout
  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.tqfindRev(".");
  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.tqfind(ending) == -1)
    fileName = fileName+ending;

  if (TQFile(fileName).exists()) {
    int r = KMessageBox::warningContinueCancel (0, i18n("The file %1\nexists. Shall I overwrite that file?").tqarg(fileName),
				       i18n("Overwrite File"), i18n("Overwrite"));
    if (r == KMessageBox::Cancel)
      return;
  }

  KIO::Job *job = KIO::file_copy( KURL( m_file ), KURL( fileName ), 0600, true, false, true );
  connect( job, TQT_SIGNAL( result( KIO::Job * ) ), this, TQT_SLOT( slotIOJobFinished ( KIO::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()->tqlayoutPages();
  enableActions(false);
  
  // Clear Thumbnail List.
  markList()->clear();
  
  // Clear Table of Contents
  tableOfContents->clear();
  
  // Clear tqStatus Bar
  emit setStatusBarText(TQString());

  return true;
}

void KMultiPage::slotIOJobFinished ( KIO::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 kmultipage.
  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()->tqlayoutPages();
      }
    }
    // 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()->tqlayoutPages();
    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 KIO::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->kdeinitExec("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()->tqlayoutPages();

  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()->tqlayoutPages(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(tqparentWdg, i18n("Print %1").tqarg(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()->tqlayoutPages();
      }
      // 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").tqarg(pageNumber).tqarg(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->tqfind(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>").tqarg(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>").tqarg(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").tqarg(pageNumber).tqarg(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->tqfindRev(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>").tqarg(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>").tqarg(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").tqarg(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").tqarg(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 kmultipage 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").tqarg(val);
      else
	range +=  TQString("%1-%2").tqarg(val).tqarg(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.tqfind(".")) + ".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?").tqarg(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 "kmultipage.moc"