Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.

BUG:215923


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdegraphics@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 593 insertions, 0 deletions

diff --git a/kviewshell/pageView.cpp b/kviewshell/pageView.cpp
new file mode 100644
index 00000000..c7813280
--- /dev/null
+++ b/kviewshell/pageView.cpp
@@ -0,0 +1,593 @@
+/* This file is part of the KDE project
+   Copyright (C) 2001 Wilco Greven <[email protected]>
+   Copyright (C) 2002-2004 Stefan Kebekus <[email protected]>
+   Copyright (C) 2004-2005 Wilfried Huss <[email protected]>
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public
+   License as published by the Free Software Foundation; either
+   version 2 of the License, or (at your option) any later version.
+
+   This library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Library General Public License for more details.
+
+   You should have received a copy of the GNU Library General Public License
+   along with this library; see the file COPYING.LIB.  If not, write to
+   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.
+*/
+
+#include <config.h>
+
+#include <kdebug.h>
+#include <qcursor.h>
+#include <qpainter.h>
+#include <qrect.h>
+#include <math.h>
+
+#include "pageView.h"
+#include "pageNumber.h"
+
+PageView::PageView( QWidget* parent, const char* name )
+  : QScrollView( parent, name, WStaticContents | WNoAutoErase)
+{
+  moveTool = true;
+
+  widgetList = 0;
+  viewport()->setFocusPolicy(QWidget::StrongFocus);
+
+  setResizePolicy(QScrollView::Manual);
+
+  setVScrollBarMode(QScrollView::Auto);
+  setHScrollBarMode(QScrollView::Auto);
+
+  viewport()->setBackgroundMode(Qt::NoBackground);
+
+  setResizePolicy(Manual);
+  setDragAutoScroll(false);
+
+  enableClipper(true);
+  nrCols = 1;
+  nrRows = 1;
+  continuousViewmode = true;
+  fullScreen = false;
+
+  connect(this, SIGNAL(contentsMoving(int, int)), this, SLOT(calculateCurrentPageNumber(int, int)));
+}
+
+
+void PageView::addChild( QPtrVector<DocumentWidget> *wdgList )
+{
+  if( wdgList == 0 ) {
+    kdError(1223) << "PageView::addChild(...) called with invalid arguments" << endl;
+    return;
+  }
+
+  widgetList = wdgList;
+  layoutPages();
+}
+
+
+bool PageView::atTop() const
+{
+  return verticalScrollBar()->value() == verticalScrollBar()->minValue();
+}
+
+
+bool PageView::atBottom() const 
+{
+  return verticalScrollBar()->value() == verticalScrollBar()->maxValue();
+}
+
+
+bool PageView::readUp()
+{
+  if( atTop() )
+    return false;
+  else {
+    // Coordinate of the top of the viewport
+    int top = contentsY();
+
+    DocumentWidget* widget = 0;
+    // Find the widget(s) that intersect the top of the viewport
+    // TODO: It would be better to use a binary search.
+    for(Q_UINT16 i=0; i<widgetList->size(); i++)
+    {
+      widget = widgetList->at(i);
+      if (childY(widget) < top && childY(widget) + widget->height() > top)
+      {
+        // Draw scrollguide
+        widget->drawScrollGuide(top - childY(widget));
+      }
+    }
+
+    int newValue = QMAX( verticalScrollBar()->value() - (int)(height() * 0.9),
+                         verticalScrollBar()->minValue() );
+    verticalScrollBar()->setValue( newValue );
+    return true;
+  }
+}
+
+
+bool PageView::readDown()
+{
+  if( atBottom() )
+    return false;
+  else {
+    // Coordinate of the bottom of the viewport
+    int bottom = contentsY() + visibleHeight();
+
+    DocumentWidget* widget = 0;
+    // Find the widget(s) that intersect the bottom of the viewport
+    // TODO: It would be better to use a binary search.
+    for(Q_UINT16 i=0; i<widgetList->size(); i++)
+    {
+      widget = widgetList->at(i);
+      if (childY(widget) < bottom && childY(widget) + widget->height() > bottom)
+      {
+        // Draw scrollguide
+        widget->drawScrollGuide(bottom - childY(widget));
+      }
+    }
+
+    int newValue = QMIN( verticalScrollBar()->value() + (int)(height() * 0.9),
+                         verticalScrollBar()->maxValue() );
+    verticalScrollBar()->setValue( newValue );
+
+    return true;
+  }
+}
+
+
+void PageView::scrollRight()
+{
+  horizontalScrollBar()->addLine();
+}
+
+void PageView::scrollLeft()
+{
+  horizontalScrollBar()->subtractLine();
+}
+
+void PageView::scrollDown()
+{
+  verticalScrollBar()->addLine();
+}
+
+void PageView::scrollUp()
+{
+  verticalScrollBar()->subtractLine();
+}
+
+void PageView::scrollBottom()
+{
+  verticalScrollBar()->setValue( verticalScrollBar()->maxValue() );
+}
+
+void PageView::scrollTop()
+{
+  verticalScrollBar()->setValue( verticalScrollBar()->minValue() );
+}
+
+void PageView::keyPressEvent( QKeyEvent* e )
+{
+  switch ( e->key() ) {
+    case Key_Up:
+      scrollUp();
+      break;
+    case Key_Down:
+      scrollDown();
+      break;
+    case Key_Left:
+      scrollLeft();
+      break;
+    case Key_Right:
+      scrollRight();
+      break;
+    default:
+      e->ignore();
+      return;
+  }
+  e->accept();
+}
+
+void PageView::contentsMousePressEvent( QMouseEvent* e )
+{
+  if (e->button() == LeftButton)
+  {
+    if (moveTool)
+    {
+      setCursor(Qt::SizeAllCursor);
+      dragGrabPos = e->globalPos();
+    }
+    else
+    {
+      // we are in selection mode
+    }
+  }
+  else
+  {
+    setCursor(Qt::arrowCursor);
+  }
+}
+
+void PageView::contentsMouseReleaseEvent( QMouseEvent* )
+{
+  setCursor(Qt::arrowCursor);
+}
+
+void PageView::contentsMouseMoveEvent( QMouseEvent* e )
+{
+  QPoint newPos = e->globalPos();
+
+  if (e->state() == LeftButton && moveTool)
+  {
+    QPoint delta = dragGrabPos - newPos;
+    scrollBy(delta.x(), delta.y());
+  }
+  dragGrabPos = newPos;
+}
+
+void PageView::viewportResizeEvent( QResizeEvent* e )
+{
+  QScrollView::viewportResizeEvent( e );
+
+  if (!widgetList)
+    return;
+
+  layoutPages();
+
+  emit viewSizeChanged( viewport()->size() );
+}
+
+void PageView::setNrColumns( Q_UINT8 cols )
+{
+  nrCols = cols;
+}
+
+void PageView::setNrRows( Q_UINT8 rows )
+{
+  nrRows = rows;
+}
+
+void PageView::setContinuousViewMode(bool continuous)
+{
+  continuousViewmode = continuous;
+}
+
+bool PageView::singlePageFullScreenMode()
+{
+  return (nrCols == 1 && nrRows == 1 && !continuousViewmode && fullScreen);
+}
+
+void PageView::slotShowScrollbars(bool status)
+{
+  if (status == true) {
+    setVScrollBarMode(QScrollView::Auto);
+    setHScrollBarMode(QScrollView::Auto);
+  } else {
+    setVScrollBarMode(QScrollView::AlwaysOff);
+    setHScrollBarMode(QScrollView::AlwaysOff);
+  }
+}
+
+void PageView::setFullScreenMode(bool fullScreen)
+{
+  this -> fullScreen = fullScreen;
+  if (fullScreen == true) 
+  {
+    setVScrollBarMode(QScrollView::AlwaysOff);
+    setHScrollBarMode(QScrollView::AlwaysOff);
+    oldFrameStyle = frameStyle();
+    setFrameStyle(QFrame::NoFrame);
+    backgroundColor = viewport()->paletteBackgroundColor();
+    if (singlePageFullScreenMode())
+    {
+      viewport()->setPaletteBackgroundColor( Qt::black ) ;
+    }
+  }
+  else
+  {
+    viewport()->setPaletteBackgroundColor( backgroundColor ) ;
+    setFrameStyle(oldFrameStyle);
+  }
+}
+
+void PageView::layoutPages(bool zoomChanged)
+{
+  // Paranoid safety check
+  if (widgetList == 0)
+    return;
+
+  // If there are no widgets, e.g. because the last widget has been
+  // removed, the matter is easy: set the contents size to 0. If there
+  // are no widgets because previously existing widgets were removed
+  // (we detect that by looking at the contentsWidth and -Height).
+  if (widgetList->isEmpty()) {
+    if ((contentsWidth() != 0) || (contentsHeight() != 0)) {
+      QScrollView::resizeContents(0,0);
+    }
+    return;
+  }
+
+  // Ok, now we are in a situation where we do have some widgets that
+  // shall be centered.
+  int distance = distanceBetweenWidgets;
+  if (singlePageFullScreenMode())
+  {
+    // In single page fullscreen mode we don't want a margin around the pages
+    distance = 0;
+  }
+
+  QMemArray<Q_UINT32> colWidth(nrCols);
+  for(Q_UINT8 i=0; i<colWidth.size(); i++)
+    colWidth[i] = 0;
+
+  Q_UINT16 numRows;
+  if(nrCols <= 2)
+  {
+    numRows = (widgetList->size()+2*nrCols-2) / nrCols;
+  }
+  else
+  {
+    numRows = (Q_INT16)ceil(((double)widgetList->size()) / nrCols);
+  }
+
+  QMemArray<Q_UINT32> rowHeight(numRows);
+  for(Q_UINT16 i=0; i<rowHeight.size(); i++)
+    rowHeight[i] = 0;
+
+  // Now find the widths and heights of the columns
+  for(Q_UINT16 i=0; i<widgetList->size(); i++) 
+  {
+    Q_UINT8 col;
+    Q_UINT16 row;
+
+    if (nrCols == 2) {
+      // In two-column display, start with the right column
+      col = (i+1+nrCols) % nrCols;
+      row = (i+1+nrCols) / nrCols - 1;
+    } else {
+      col = (i+nrCols) % nrCols;
+      row = (i+nrCols) / nrCols - 1;
+    }
+
+    colWidth[col] = QMAX(colWidth[col], (Q_UINT32)widgetList->at(i)->pageSize().width());
+    rowHeight[row] = QMAX(rowHeight[row], (Q_UINT32)widgetList->at(i)->pageSize().height());
+  }
+
+  // Calculate the total width and height of the display
+  Q_UINT32 totalHeight = 0;
+  for(Q_UINT16 i=0; i<rowHeight.size(); i++)
+    totalHeight += rowHeight[i];
+
+  totalHeight += (numRows+1)*distance;
+  Q_UINT32 totalWidth = 0;
+  for(Q_UINT8 i=0; i<colWidth.size(); i++)
+    totalWidth += colWidth[i];
+
+  totalWidth += (nrCols+1)*distance;
+  QSize newViewportSize = viewportSize( totalWidth, totalHeight );
+  Q_UINT32 centeringLeft = 0;
+  if( (Q_UINT32)newViewportSize.width() > totalWidth )
+    centeringLeft = ( newViewportSize.width() - totalWidth )/2;
+  Q_UINT32 centeringTop = 0;
+  if( (Q_UINT32)newViewportSize.height() > totalHeight )
+    centeringTop = ( newViewportSize.height() - totalHeight)/2;
+
+  // Resize the viewport
+  if (((Q_UINT32)contentsWidth() != totalWidth) || ((Q_UINT32)contentsHeight() != totalHeight))
+  {
+    // Calculate the point in the coordinates of the contents which is currently at the center of the viewport.
+    QPoint midPoint = QPoint(visibleWidth() / 2 + contentsX(), visibleHeight() / 2 + contentsY()); 
+    double midPointRatioX = (double)(midPoint.x()) / contentsWidth();
+    double midPointRatioY = (double)(midPoint.y()) / contentsHeight();
+
+    resizeContents(totalWidth,totalHeight);
+
+    // If the zoom changed recenter the former midPoint
+    if (zoomChanged)
+      center((int)(contentsWidth() * midPointRatioX), (int)(contentsHeight() * midPointRatioY));
+  }
+
+  // Finally, calculate the left and top coordinates of each row and
+  // column, respectively
+  QMemArray<Q_UINT32> colLeft(nrCols);
+  colLeft[0] = distance;
+  for(Q_UINT8 i=1; i<colLeft.size(); i++)
+    colLeft[i] = colLeft[i-1]+colWidth[i-1]+distance;
+
+  QMemArray<Q_UINT32> rowTop(numRows);
+  rowTop[0] = distance;
+  for(Q_UINT16 i=1; i<rowTop.size(); i++)
+    rowTop[i] = rowTop[i-1]+rowHeight[i-1]+distance;
+
+  for(Q_UINT16 i=0; i<widgetList->size(); i++) 
+  {
+    Q_UINT8 col;
+    Q_UINT16 row;
+    if (nrCols == 2)
+    {
+      // In two column-mode start with the right column.
+      col = (i+nrCols-1) % nrCols;
+      row = (i+nrCols-1) / nrCols;
+    }
+    else
+    {
+      col = (i+nrCols) % nrCols;
+      row = i / nrCols;
+    }
+    if (nrCols == 2)
+    {
+      // in 2-column mode right justify the first column, and leftjustify the second column
+      int width = widgetList->at(i)->width();
+      int left;
+      if (col == 0)
+        left = centeringLeft + colLeft[col] + colWidth[col]-width + distance/2;
+      else
+        left = centeringLeft + colLeft[col];
+      moveChild( widgetList->at(i), left, centeringTop+rowTop[row]);
+    }
+    else
+    {
+      // in single column and overview mode center the widgets
+      int widgetWidth = widgetList->at(i)->width();
+      int left = centeringLeft + colLeft[col] + ((int)colWidth[col]-widgetWidth)/2;
+      moveChild(widgetList->at(i), left, centeringTop+rowTop[row]);
+    }
+  }
+  calculateCurrentPageNumber();
+}
+
+
+void PageView::contentsWheelEvent ( QWheelEvent * e )
+{
+  emit(wheelEventReceived(e));
+}
+
+
+void PageView::moveViewportToWidget(QWidget* widget, int y)
+{
+  int verticalPos = 0;
+  int verticalPosTop = 0;
+
+  if (y != 0)
+  {
+    verticalPosTop = childY(widget) +  y - visibleHeight()/2;
+    verticalPos = childY(widget) +  y;
+  }
+  else
+  {
+    verticalPos = childY(widget) - distanceBetweenWidgets;
+    verticalPosTop = verticalPos;
+  }
+
+  if (nrCols == 1)
+  {
+    // In single column viewmodes, we change the vertical position only, to make it
+    // easier to work with high zoomlevels where not the whole pagewidth is visible.
+    // TODO: Smarter algorithm also for continuous facing viewmode.
+    int top = (int)(contentsY() + 0.1 * visibleHeight());
+    int bottom = (int)(contentsY() + 0.9 * visibleHeight());
+
+    // Move the viewport if the target is currently not visible, or lies at the edge
+    // of the viewport. If y = 0 always move the top of the targetpage to the top edge
+    // of the viewport.
+    if (verticalPos < top || verticalPos > bottom || y == 0)
+    {
+      setContentsPos(contentsX(), verticalPosTop);
+    }
+  }
+  else
+  {
+    setContentsPos(childX(widget) - distanceBetweenWidgets, verticalPosTop);
+  }
+}
+
+
+void PageView::viewportPaintEvent(QPaintEvent* e)
+{
+  // Region from which rectangles occupied by child widgets will by substracted.
+  QRegion backgroundArea(e->rect());
+
+  if (widgetList != 0)
+  {
+    for (unsigned int i = 0; i < widgetList->count(); i++)
+    {
+      DocumentWidget* item = widgetList->at(i);
+
+      // Check if the Widget needs to be updated.
+      if (!item->geometry().intersects(e->rect()))
+        continue;
+
+      QRect widgetGeometry = item->geometry();
+
+      // Draw the widget.
+      if (e->rect().intersects(widgetGeometry))
+      {
+        QRect widgetRect = e->rect().intersect(widgetGeometry);
+        widgetRect.moveBy(-widgetGeometry.left(), -widgetGeometry.top());
+
+        item->update(widgetRect);
+      }
+
+      // Substract the painted area.
+      backgroundArea -= widgetGeometry.intersect(e->rect());
+    }
+  }
+
+  // Paint the background.
+  QPainter p(viewport());
+
+  QMemArray<QRect> backgroundRects = backgroundArea.rects();
+
+  for (unsigned int i = 0; i < backgroundRects.count(); i++)
+    p.fillRect(backgroundRects[i], colorGroup().mid());
+}
+
+
+void PageView::calculateCurrentPageNumber(int x, int y)
+{
+  // Safety check
+  if (widgetList == 0)
+    return;
+
+  QRect viewportRect(x, y, visibleWidth(), visibleHeight());
+
+  //kdDebug() << "viewportRect(" << viewportRect.x() << ", " << viewportRect.y() << ", "
+  //          << viewportRect.width() << ", " << viewportRect.height() << ")" << endl;
+
+  int maxVisiblePixels = 0;
+  DocumentWidget* _currentWidget = 0;
+
+  for (Q_UINT16 i = 0; i < widgetList->size(); i++)
+  {
+    DocumentWidget* documentWidget = widgetList->at(i);
+    // Safety check
+    if (documentWidget == 0)
+      continue;
+
+    // Check if the Widget is visible
+    int cx = childX(documentWidget);
+    int cy = childY(documentWidget);
+    QRect widgetRect(cx, cy, documentWidget->width(), documentWidget->height());
+    bool isVisible = widgetRect.intersects(viewportRect);
+
+    if (!isVisible)
+      continue;
+
+    // Calculate the number of visible pixels of the widget
+    QRect visibleRect = widgetRect.intersect(viewportRect);
+    int visiblePixels = visibleRect.width() * visibleRect.height();
+
+    //kdDebug() << visiblePixels << " pixels are visible of page " << documentWidget->getPageNumber() << endl;
+
+    // If a bigger part of this widget as of the previous widgets is visible make it the current widget.
+    if (maxVisiblePixels < visiblePixels)
+    {
+      maxVisiblePixels = visiblePixels;
+      _currentWidget = documentWidget;
+    }
+  }
+
+  // No page is visible
+  if (_currentWidget == 0)
+    return;
+
+  // Return the number of the current page
+  emit currentPageChanged(_currentWidget->getPageNumber());
+}
+
+void PageView::calculateCurrentPageNumber()
+{
+  calculateCurrentPageNumber(contentsX(), contentsY());
+}
+
+void PageView::slotEnableMoveTool(bool enable)
+{
+  moveTool = enable;
+}
+
+#include "pageView.moc"