File indexing completed on 2024-04-28 16:21:31

 /* This file is part of the KDE project
    Copyright 2007, 2009 Stefan Nikolaus <stefan.nikolaus@kdemail.net>
    Copyright 2005 Raphael Langerhorst <raphael.langerhorst@kdemail.net>
    Copyright 2003 Philipp Müller <philipp.mueller@gmx.de>
    Copyright 1998, 1999 Torben Weis <weis@kde.org>
 
    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.
 */
 
 // Local
 #include "SheetPrint.h"
 #include "SheetPrint_p.h"
 
 #include "HeaderFooter.h"
 #include "PrintSettings.h"
 #include "calligra_sheets_limits.h"
 #include "Region.h"
 #include "Sheet.h"
 #include "SheetsDebug.h"
 
 using namespace Calligra::Sheets;
 
 SheetPrint::SheetPrint(Sheet *sheet)
         : d(new Private(this))
 {
     d->m_pSheet = sheet;
 
     d->m_settings = new PrintSettings();
     d->m_headerFooter = new HeaderFooter(sheet);
 
     d->m_maxCheckedNewPageX = 0;
     d->m_maxCheckedNewPageY = 0;
     d->m_dPrintRepeatColumnsWidth = 0.0;
     d->m_dPrintRepeatRowsHeight = 0.0;
 }
 
 SheetPrint::SheetPrint(const SheetPrint &other)
         : d(new Private(this))
 {
     d->m_pSheet = other.d->m_pSheet;
 
     d->m_settings = new PrintSettings(*other.d->m_settings);
     d->m_headerFooter = new HeaderFooter(*other.d->m_headerFooter);
 
     d->m_maxCheckedNewPageX = other.d->m_maxCheckedNewPageX;
     d->m_maxCheckedNewPageY = other.d->m_maxCheckedNewPageY;
     d->m_dPrintRepeatColumnsWidth = other.d->m_dPrintRepeatColumnsWidth;
     d->m_dPrintRepeatRowsHeight = other.d->m_dPrintRepeatRowsHeight;
     d->m_lnewPageListX = other.d->m_lnewPageListX;
     d->m_lnewPageListY = other.d->m_lnewPageListY;
 }
 
 SheetPrint::~SheetPrint()
 {
     delete d->m_headerFooter;
     delete d->m_settings;
     delete d;
 }
 
 PrintSettings *SheetPrint::settings() const
 {
     return d->m_settings;
 }
 
 void SheetPrint::setSettings(const PrintSettings &settings, bool force)
 {
     // Relayout forced?
     if (force) {
         *d->m_settings = settings;
         d->updateRepeatedColumnsWidth();
         d->updateRepeatedRowsHeight();
         const QSize pageLimits = settings.pageLimits();
         const QSize usedArea = d->m_pSheet->usedArea(true).size();
         if (pageLimits.width() > 0) {
             d->calculateZoomForPageLimitX();
         } else {
             updateHorizontalPageParameters(0);
             d->calculateHorizontalPageParameters(usedArea.width());
         }
         if (pageLimits.height() > 0) {
             d->calculateZoomForPageLimitY();
         } else {
             updateVerticalPageParameters(0);
             d->calculateVerticalPageParameters(usedArea.height());
         }
         return;
     }
 
     const KoPageLayout oldPageLayout = d->m_settings->pageLayout();
     const KoPageLayout pageLayout = settings.pageLayout();
     const QRect oldPrintRange = d->m_settings->printRegion().lastRange();
     const QRect printRange = settings.printRegion().lastRange();
     const QSize oldPageLimits = d->m_settings->pageLimits();
     const QSize pageLimits = settings.pageLimits();
     const QPair<int, int> oldRepeatedColumns = d->m_settings->repeatedColumns();
     const QPair<int, int> repeatedColumns = settings.repeatedColumns();
     const QPair<int, int> oldRepeatedRows = d->m_settings->repeatedRows();
     const QPair<int, int> repeatedRows = settings.repeatedRows();
 
     const bool pageWidthChanged = oldPageLayout.width != pageLayout.width;
     const bool pageHeightChanged = oldPageLayout.height != pageLayout.height;
     const bool horizontalLimitChanged = oldPageLimits.width() != pageLimits.width();
     const bool verticalLimitChanged = oldPageLimits.height() != pageLimits.height();
     const bool repeatedColumnsChanged = oldRepeatedColumns != repeatedColumns;
     const bool repeatedRowsChanged = oldRepeatedRows != repeatedRows;
     const bool zoomChanged = d->m_settings->zoom() != settings.zoom();
 
     *d->m_settings = settings;
 
     // The starting column/row for the page parameter updates.
     int column = KS_colMax + 1;
     int row = KS_rowMax + 1;
 
     // The print range.
     if (oldPrintRange.left() != printRange.left()) {
         column = qMin(oldPrintRange.left(), printRange.left());
     }
     if (oldPrintRange.top() != printRange.top()) {
         row = qMin(oldPrintRange.top(), printRange.top());
     }
 
     // The zoom.
     if (zoomChanged) {
         column = 0;
         row = 0;
     }
 
     // The page limits.
     if (horizontalLimitChanged && pageLimits.width() <= 0) {
         column = 0;
     }
     if (verticalLimitChanged && pageLimits.height() <= 0) {
         row = 0;
     }
 
     // The page dimensions.
     if (pageWidthChanged) {
         column = 0;
     }
     if (pageHeightChanged) {
         row = 0;
     }
 
     // The column/row repetitions.
     if (repeatedColumnsChanged) {
         d->updateRepeatedColumnsWidth();
         column = qMin(column, oldRepeatedColumns.first);
         column = qMin(column, repeatedColumns.first);
     }
     if (repeatedRowsChanged) {
         d->updateRepeatedRowsHeight();
         row = qMin(row, oldRepeatedRows.first);
         row = qMin(row, repeatedRows.first);
     }
 
     // Update the page parameters.
     // If page limits are set to non-zero, call the special methods.
     if (horizontalLimitChanged && pageLimits.width() > 0) {
         d->calculateZoomForPageLimitX();
     } else if (column <= KS_colMax) {
         updateHorizontalPageParameters(column);
     }
     if (verticalLimitChanged && pageLimits.height() > 0) {
         d->calculateZoomForPageLimitY();
     } else if (row <= KS_rowMax) {
         updateVerticalPageParameters(row);
     }
 }
 
 HeaderFooter *SheetPrint::headerFooter() const
 {
     return d->m_headerFooter;
 }
 
 bool SheetPrint::isColumnOnNewPage(int _column)
 {
     if (_column > d->m_maxCheckedNewPageX)
         d->calculateHorizontalPageParameters(_column);
 
     //Are these the edges of the print range?
     const QRect printRange = d->m_settings->printRegion().lastRange();
     if (_column == printRange.left() || _column == printRange.right()) {
         return true;
     }
 
     //beyond the print range it's always false
     if (_column < printRange.left() || _column > printRange.right()) {
         return false;
     }
 
     //Now check if we find the column already in the list
     if (d->m_lnewPageListX.indexOf(PrintNewPageEntry(_column)) != -1) {
         if (_column > d->m_maxCheckedNewPageX)
             d->m_maxCheckedNewPageX = _column;
         return true;
     }
     return false;
 }
 
 
 
 bool SheetPrint::isRowOnNewPage(int _row)
 {
     if (_row > d->m_maxCheckedNewPageY)
         d->calculateVerticalPageParameters(_row);
 
     //Are these the edges of the print range?
     const QRect printRange = d->m_settings->printRegion().lastRange();
     if (_row == printRange.top() || _row == printRange.bottom()) {
         return true;
     }
 
     //beyond the print range it's always false
     if (_row < printRange.top() || _row > printRange.bottom()) {
         return false;
     }
 
     //Now check if we find the row already in the list
     if (d->m_lnewPageListY.indexOf(PrintNewPageEntry(_row)) != -1) {
         if (_row > d->m_maxCheckedNewPageY)
             d->m_maxCheckedNewPageY = _row;
         return true;
     }
 
     return false;
 }
 
 void SheetPrint::updateHorizontalPageParameters(int _col)
 {
     //If the new range is after the first entry, we need to delete the whole list
     const QRect printRange = d->m_settings->printRegion().lastRange();
     if (d->m_lnewPageListX.isEmpty() || d->m_lnewPageListX.first().startItem() != printRange.left() || _col == 0) {
         d->m_lnewPageListX.clear();
         d->m_maxCheckedNewPageX = 0;
         d->updateRepeatedColumnsWidth();
         return;
     }
 
     if (_col <= d->m_lnewPageListX.last().endItem()) {
         // Find the page entry for this column
         int index = d->m_lnewPageListX.count() - 1;
         while (_col < d->m_lnewPageListX[index].startItem()) {
             --index;
         }
 
         //Remove later pages
         while (index != d->m_lnewPageListX.count())
             d->m_lnewPageListX.removeAt(index);
 
         d->m_maxCheckedNewPageX = d->m_lnewPageListX.isEmpty() ? 0 : d->m_lnewPageListX.last().endItem();
     }
 
     // The column is not beyond the repeated columns?
     if (_col <= d->m_settings->repeatedColumns().second) {
         d->updateRepeatedColumnsWidth();
     }
 }
 
 void SheetPrint::updateVerticalPageParameters(int _row)
 {
     //If the new range is after the first entry, we need to delete the whole list
     const QRect printRange = d->m_settings->printRegion().lastRange();
     if (d->m_lnewPageListY.isEmpty() || d->m_lnewPageListY.first().startItem() != printRange.top() || _row == 0) {
         d->m_lnewPageListY.clear();
         d->m_maxCheckedNewPageY = 0;
         d->updateRepeatedRowsHeight();
         return;
     }
 
     if (_row <= d->m_lnewPageListY.last().endItem()) {
         // Find the page entry for this row
         int index = d->m_lnewPageListY.count() - 1;
         while (_row < d->m_lnewPageListY[index].startItem()) {
             --index;
         }
 
         //Remove later pages
         while (index != d->m_lnewPageListY.count())
             d->m_lnewPageListY.removeAt(index);
 
         d->m_maxCheckedNewPageY = d->m_lnewPageListY.isEmpty() ? 0 : d->m_lnewPageListY.last().endItem();
     }
 
     // The row is not beyond the repeated rows?
     if (_row <= d->m_settings->repeatedRows().second) {
         d->updateRepeatedRowsHeight();
     }
 }
 
 void SheetPrint::insertColumn(int col, int nbCol)
 {
     //update print range, when it has been defined
     const QRect printRange = d->m_settings->printRegion().lastRange();
     if (printRange != QRect(QPoint(1, 1), QPoint(KS_colMax, KS_rowMax))) {
         int left = printRange.left();
         int right = printRange.right();
 
         for (int i = 0; i < nbCol; i++) {
             if (left >= col) left++;
             if (right >= col) right++;
         }
         //Validity checks
         if (left > KS_colMax) left = KS_colMax;
         if (right > KS_colMax) right = KS_colMax;
         const Region region(QRect(QPoint(left, printRange.top()),
                                   QPoint(right, printRange.bottom())), d->m_pSheet);
         // Trigger an update by setting it indirectly.
         PrintSettings settings = *d->m_settings;
         settings.setPrintRegion(region);
         setSettings(settings);
     }
 }
 
 void SheetPrint::insertRow(int row, int nbRow)
 {
     //update print range, when it has been defined
     const QRect printRange = d->m_settings->printRegion().lastRange();
     if (printRange != QRect(QPoint(1, 1), QPoint(KS_colMax, KS_rowMax))) {
         int top = printRange.top();
         int bottom = printRange.bottom();
 
         for (int i = 0; i < nbRow; i++) {
             if (top >= row) top++;
             if (bottom >= row) bottom++;
         }
         //Validity checks
         if (top > KS_rowMax) top = KS_rowMax;
         if (bottom > KS_rowMax) bottom = KS_rowMax;
         const Region region(QRect(QPoint(printRange.left(), top),
                                   QPoint(printRange.right(), bottom)), d->m_pSheet);
         // Trigger an update by setting it indirectly.
         PrintSettings settings = *d->m_settings;
         settings.setPrintRegion(region);
         setSettings(settings);
     }
 }
 
 void SheetPrint::removeColumn(int col, int nbCol)
 {
     PrintSettings settings = *d->m_settings;
     //update print range, when it has been defined
     const QRect printRange = d->m_settings->printRegion().lastRange();
     if (printRange != QRect(QPoint(1, 1), QPoint(KS_colMax, KS_rowMax))) {
         int left = printRange.left();
         int right = printRange.right();
 
         for (int i = 0; i < nbCol; i++) {
             if (left > col) left--;
             if (right >= col) right--;
         }
         //Validity checks
         if (left < 1) left = 1;
         if (right < 1) right = 1;
         const Region region(QRect(QPoint(left, printRange.top()),
                                   QPoint(right, printRange.bottom())), d->m_pSheet);
         settings.setPrintRegion(region);
     }
 
     //update repeat columns, when it has been defined
     const QPair<int, int> repeatedColumns = d->m_settings->repeatedColumns();
     if (repeatedColumns.first != 0) {
         int left = repeatedColumns.first;
         int right = repeatedColumns.second;
 
         for (int i = 0; i < nbCol; i++) {
             if (left > col) left--;
             if (right >= col) right--;
         }
         //Validity checks
         if (left < 1) left = 1;
         if (right < 1) right = 1;
         settings.setRepeatedColumns(qMakePair(left, right));
     }
     // Trigger an update by setting them indirectly.
     setSettings(settings);
 }
 
 void SheetPrint::removeRow(int row, int nbRow)
 {
     PrintSettings settings = *d->m_settings;
     //update print range, when it has been defined
     const QRect printRange = d->m_settings->printRegion().lastRange();
     if (printRange != QRect(QPoint(1, 1), QPoint(KS_colMax, KS_rowMax))) {
         int top = printRange.top();
         int bottom = printRange.bottom();
 
         for (int i = 0; i < nbRow; i++) {
             if (top > row) top--;
             if (bottom >= row) bottom--;
         }
         //Validity checks
         if (top < 1) top = 1;
         if (bottom < 1) bottom = 1;
         const Region region(QRect(QPoint(printRange.left(), top),
                                   QPoint(printRange.right(), bottom)), d->m_pSheet);
         settings.setPrintRegion(region);
     }
 
     //update repeat rows, when it has been defined
     const QPair<int, int> repeatedRows = d->m_settings->repeatedRows();
     if (repeatedRows.first != 0) {
         int top = repeatedRows.first;
         int bottom = repeatedRows.second;
 
         for (int i = 0; i < nbRow; i++) {
             if (top > row) top--;
             if (bottom >= row) bottom--;
         }
         //Validity checks
         if (top < 1) top = 1;
         if (bottom < 1) bottom = 1;
         settings.setRepeatedRows(qMakePair(top, bottom));
     }
     // Trigger an update by setting them indirectly.
     setSettings(settings);
 }
 
 int SheetPrint::pageCount() const
 {
     return d->m_lnewPageListX.count() * d->m_lnewPageListY.count();
 }
 
 QRect SheetPrint::cellRange(int page) const
 {
     if (d->m_lnewPageListX.isEmpty() || d->m_lnewPageListY.isEmpty()) {
         return QRect();
     }
     if (page - 1 > pageCount()) {
         return QRect();
     }
     debugSheets << "page:" << page << "of" << pageCount();
 
     int horizontalIndex = 0;
     int verticalIndex = 0;
     if (d->m_settings->pageOrder() == PrintSettings::LeftToRight) {
         horizontalIndex = (page - 1) % d->m_lnewPageListX.count();
         verticalIndex = (page - 1) / d->m_lnewPageListX.count();
     } else {
         horizontalIndex = (page - 1) / d->m_lnewPageListY.count();
         verticalIndex = (page - 1) % d->m_lnewPageListY.count();
     }
     debugSheets << "horizontal:" << horizontalIndex + 1 << "of" << d->m_lnewPageListX.count();
     debugSheets << "vertical:" << verticalIndex + 1 << "of" << d->m_lnewPageListY.count();
 
     const PrintNewPageEntry horizontalParameters = d->m_lnewPageListX[horizontalIndex];
     const PrintNewPageEntry verticalParameters = d->m_lnewPageListY[verticalIndex];
 
     QRect cellRange;
     cellRange.setLeft(horizontalParameters.startItem());
     cellRange.setRight(horizontalParameters.endItem());
     cellRange.setTop(verticalParameters.startItem());
     cellRange.setBottom(verticalParameters.endItem());
     return cellRange;
 }
 
 QRectF SheetPrint::documentArea(int page) const
 {
     if (d->m_lnewPageListX.isEmpty() || d->m_lnewPageListY.isEmpty()) {
         return QRectF();
     }
     if (page - 1 > pageCount()) {
         return QRectF();
     }
 
     int horizontalIndex = 0;
     int verticalIndex = 0;
     if (d->m_settings->pageOrder() == PrintSettings::LeftToRight) {
         horizontalIndex = (page - 1) % d->m_lnewPageListX.count();
         verticalIndex = (page - 1) / d->m_lnewPageListX.count();
     } else {
         horizontalIndex = (page - 1) / d->m_lnewPageListY.count();
         verticalIndex = (page - 1) % d->m_lnewPageListY.count();
     }
 
     const PrintNewPageEntry horizontalParameters = d->m_lnewPageListX[horizontalIndex];
     const PrintNewPageEntry verticalParameters = d->m_lnewPageListY[verticalIndex];
 
     QRectF documentArea;
     documentArea.setLeft(horizontalParameters.offset());
     documentArea.setWidth(horizontalParameters.size());
     documentArea.setTop(verticalParameters.offset());
     documentArea.setHeight(verticalParameters.size());
     return documentArea;
 }
 
 void SheetPrint::operator=(const SheetPrint & other)
 {
     d->m_pSheet = other.d->m_pSheet;
 
     *d->m_settings = *other.d->m_settings;
     *d->m_headerFooter = *other.d->m_headerFooter;
 
     d->m_maxCheckedNewPageX = other.d->m_maxCheckedNewPageX;
     d->m_maxCheckedNewPageY = other.d->m_maxCheckedNewPageY;
     d->m_dPrintRepeatColumnsWidth = other.d->m_dPrintRepeatColumnsWidth;
     d->m_dPrintRepeatRowsHeight = other.d->m_dPrintRepeatRowsHeight;
     d->m_lnewPageListX = other.d->m_lnewPageListX;
     d->m_lnewPageListY = other.d->m_lnewPageListY;
 }