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.
 */
 
 #include "SheetPrint_p.h"
 
 #include "PrintSettings.h"
 #include "Region.h"
 #include "RowColumnFormat.h"
 #include "RowFormatStorage.h"
 #include "Sheet.h"
 
 using namespace Calligra::Sheets;
 
 void SheetPrint::Private::calculateHorizontalPageParameters(int _column)
 {
     // Zoom the print width ONCE here, instead for each column width.
     const double printWidth = m_settings->printWidth() / m_settings->zoom();
 
     float offset = 0.0;
 
     //Are these the edges of the print range?
     const QRect printRange = m_settings->printRegion().lastRange();
 #if 0
     if (_column == printRange.left() || _column == printRange.right()) {
         if (_column > m_maxCheckedNewPageX)
             m_maxCheckedNewPageX = _column;
         return;
     }
 
     //We don't check beyond the print range
     if (_column < printRange.left() || _column > printRange.right()) {
         if (_column > m_maxCheckedNewPageX)
             m_maxCheckedNewPageX = _column;
         if (_column > printRange.right()) {
             if (m_lnewPageListX.last().endItem() == 0)
                 m_lnewPageListX.last().setEndItem(printRange.right());
         }
         return;
     }
 #endif
 
     // Check if the pre-calculated width matches the repeated columns setting.
     const bool repetitions = m_settings->repeatedColumns().first != 0;
     if (repetitions != (m_dPrintRepeatColumnsWidth == 0.0)) {
         // Existing column repetitions, but their pre-calculated width is zero?
         // Must be the first run. Or the other way around? Seem to be orphaned.
         // Either way, seems they do not match. Calculate them!
         updateRepeatedColumnsWidth();
     }
 
     // The end of the last item (zero, if list is empty).
     const int end = m_lnewPageListX.empty() ? 0 : m_lnewPageListX.last().endItem();
 
     //If _column is greater than the last entry, we need to calculate the result
     if (_column > end &&
             _column > m_maxCheckedNewPageX) { //this columns hasn't been calculated before
         int startCol = end + 1;
         int col = startCol;
         double x = m_pSheet->columnFormat(col)->width();
 
         // Add a new page.
         m_lnewPageListX.append(PrintNewPageEntry(startCol));
 
         //Add repeated column width, when necessary
         const QPair<int, int> repeatedColumns = m_settings->repeatedColumns();
         if (col > repeatedColumns.first) {
             x += m_dPrintRepeatColumnsWidth;
             offset = m_dPrintRepeatColumnsWidth;
         }
         debugSheets << "startCol:" << startCol << "col:" << col << "x:" << x
                  << "offset:" << offset << repeatedColumns;
 
         while ((col <= _column) && (col < printRange.right())) {
             debugSheets << "loop:" << "startCol:" << startCol << "col:" << col
                      << "x:" << x << "offset:" << offset;
             // end of page?
             if (x > printWidth || m_pSheet->columnFormat(col)->hasPageBreak()) {
                 //Now store into the previous entry the enditem and the width
                 m_lnewPageListX.last().setEndItem(col - 1);
                 m_lnewPageListX.last().setSize(x - m_pSheet->columnFormat(col)->width());
                 m_lnewPageListX.last().setOffset(offset);
 
                 //start a new page
                 m_lnewPageListX.append(PrintNewPageEntry(col));
                 startCol = col;
                 x = m_pSheet->columnFormat(col)->width();
                 if (col >= repeatedColumns.first) {
                     debugSheets << "col >= repeatedColumns.first:" << col << repeatedColumns.first;
                     x += m_dPrintRepeatColumnsWidth;
                     offset = m_dPrintRepeatColumnsWidth;
                 }
             }
             col++;
             x += m_pSheet->columnFormat(col)->width();
         }
 
         // Iterate to the end of the page.
         while (m_lnewPageListX.last().endItem() == 0) {
             debugSheets << "loop to end" << "col:" << col << "x:" << x << "offset:" << offset
                         << "m_maxCheckedNewPageX:" << m_maxCheckedNewPageX;
             if (x > printWidth || m_pSheet->columnFormat(col)->hasPageBreak()) {
                 // Now store into the previous entry the enditem and the width
                 m_lnewPageListX.last().setEndItem(col - 1);
                 m_lnewPageListX.last().setSize(x - m_pSheet->columnFormat(col)->width());
                 m_lnewPageListX.last().setOffset(offset);
 
                 if (col - 1 > m_maxCheckedNewPageX) {
                     m_maxCheckedNewPageX = col - 1;
                 }
                 return;
             }
             ++col;
             x += m_pSheet->columnFormat(col)->width();
         }
     }
 
     debugSheets << "m_maxCheckedNewPageX:" << m_maxCheckedNewPageX;
     if (_column > m_maxCheckedNewPageX) {
         m_maxCheckedNewPageX = _column;
         m_lnewPageListX.last().setEndItem(_column);
     }
 }
 
 void SheetPrint::Private::calculateVerticalPageParameters(int _row)
 {
     // Zoom the print height ONCE here, instead for each row height.
     const double printHeight = m_settings->printHeight() / m_settings->zoom();
 
     float offset = 0.0;
 
     //Are these the edges of the print range?
     const QRect printRange = m_settings->printRegion().lastRange();
 #if 0
     if (_row == printRange.top() || _row == printRange.bottom()) {
         if (_row > m_maxCheckedNewPageY)
             m_maxCheckedNewPageY = _row;
         return;
     }
 
     //beyond the print range it's always false
     if (_row < printRange.top() || _row > printRange.bottom()) {
         if (_row > m_maxCheckedNewPageY)
             m_maxCheckedNewPageY = _row;
         if (_row > printRange.bottom()) {
             if (m_lnewPageListY.last().endItem() == 0)
                 m_lnewPageListY.last().setEndItem(printRange.bottom());
         }
         return;
     }
 #endif
 
     // Check if the pre-calculated height matches the repeated rows setting.
     const bool repetitions = m_settings->repeatedRows().first != 0;
     if (repetitions != (m_dPrintRepeatRowsHeight == 0.0)) {
         // Existing row repetitions, but their pre-calculated height is zero?
         // Must be the first run. Or the other way around? Seem to be orphaned.
         // Either way, seems they do not match. Calculate them!
         updateRepeatedRowsHeight();
     }
 
     // The end of the last item (zero, if list is empty).
     const int end = m_lnewPageListY.empty() ? 0 : m_lnewPageListY.last().endItem();
 
     //If _column is greater than the last entry, we need to calculate the result
     if (_row > end &&
             _row > m_maxCheckedNewPageY) { //this columns hasn't been calculated before
         int startRow = end + 1;
         int row = startRow;
         double y = m_pSheet->rowFormats()->rowHeight(row);
 
         // Add a new page.
         m_lnewPageListY.append(PrintNewPageEntry(startRow));
 
         //Add repeated row height, when necessary
         const QPair<int, int> repeatedRows = m_settings->repeatedRows();
         if (row > repeatedRows.first) {
             y += m_dPrintRepeatRowsHeight;
             offset = m_dPrintRepeatRowsHeight;
         }
 
         while ((row <= _row) && (row < printRange.bottom())) {
             // end of page?
             if (y > printHeight || m_pSheet->rowFormats()->hasPageBreak(row)) {
                 //Now store into the previous entry the enditem and the width
                 m_lnewPageListY.last().setEndItem(row - 1);
                 m_lnewPageListY.last().setSize(y - m_pSheet->rowFormats()->rowHeight(row));
                 m_lnewPageListY.last().setOffset(offset);
 
                 //start a new page
                 m_lnewPageListY.append(PrintNewPageEntry(row));
                 startRow = row;
                 y = m_pSheet->rowFormats()->rowHeight(row);
                 if (row >= repeatedRows.first) {
                     y += m_dPrintRepeatRowsHeight;
                     offset = m_dPrintRepeatRowsHeight;
                 }
             }
             row++;
             y += m_pSheet->rowFormats()->rowHeight(row);
         }
 
         // Iterate to the end of the page.
         while (m_lnewPageListY.last().endItem() == 0) {
             if (y > printHeight || m_pSheet->rowFormats()->hasPageBreak(row)) {
                 // Now store into the previous entry the enditem and the width
                 m_lnewPageListY.last().setEndItem(row - 1);
                 m_lnewPageListY.last().setSize(y - m_pSheet->rowFormats()->rowHeight(row));
                 m_lnewPageListY.last().setOffset(offset);
 
                 if (row - 1 > m_maxCheckedNewPageY) {
                     m_maxCheckedNewPageY = row - 1;
                 }
                 return;
             }
             ++row;
             y += m_pSheet->rowFormats()->rowHeight(row);
         }
     }
 
     if (_row > m_maxCheckedNewPageY) {
         m_maxCheckedNewPageY = _row;
         m_lnewPageListY.last().setEndItem(_row);
     }
 }
 
 void SheetPrint::Private::calculateZoomForPageLimitX()
 {
     debugSheets << "Calculating zoom for X limit";
     const int horizontalPageLimit = m_settings->pageLimits().width();
     if (horizontalPageLimit == 0)
         return;
 
     const double origZoom = m_settings->zoom();
 
     if (m_settings->zoom() < 1.0) {
         q->updateHorizontalPageParameters(0);   // clear all parameters
         m_settings->setZoom(1.0);
     }
 
     QRect printRange = m_pSheet->usedArea(true);
     calculateHorizontalPageParameters(printRange.right());
     int currentPages = m_lnewPageListX.count();
 
     if (currentPages <= horizontalPageLimit)
         return;
 
     //calculating a factor for scaling the zoom down makes it lots faster
     double factor = (double)horizontalPageLimit / (double)currentPages +
                     1 - (double)currentPages / ((double)currentPages + 1); //add possible error;
     debugSheets << "Calculated factor for scaling m_settings->zoom():" << factor;
     m_settings->setZoom(m_settings->zoom()*factor);
 
     debugSheets << "New exact zoom:" << m_settings->zoom();
 
     if (m_settings->zoom() < 0.01)
         m_settings->setZoom(0.01);
     if (m_settings->zoom() > 1.0)
         m_settings->setZoom(1.0);
 
     m_settings->setZoom((((int)(m_settings->zoom()*100 + 0.5)) / 100.0));
 
     debugSheets << "New rounded zoom:" << m_settings->zoom();
 
     q->updateHorizontalPageParameters(0);   // clear all parameters
     calculateHorizontalPageParameters(printRange.right());
     currentPages = m_lnewPageListX.count();
 
     debugSheets << "Number of pages with this zoom:" << currentPages;
 
     while ((currentPages > horizontalPageLimit) && (m_settings->zoom() > 0.01)) {
         m_settings->setZoom(m_settings->zoom() - 0.01);
         q->updateHorizontalPageParameters(0);   // clear all parameters
         calculateHorizontalPageParameters(printRange.right());
         currentPages = m_lnewPageListX.count();
         debugSheets << "Looping -0.01; current zoom:" << m_settings->zoom();
     }
 
     if (m_settings->zoom() < origZoom) {
         // Trigger an update of the vertical page parameters.
         q->updateVerticalPageParameters(0); // clear all parameters
         calculateVerticalPageParameters(printRange.bottom());
     } else
         m_settings->setZoom(origZoom);
 }
 
 void SheetPrint::Private::calculateZoomForPageLimitY()
 {
     debugSheets << "Calculating zoom for Y limit";
     const int verticalPageLimit = m_settings->pageLimits().height();
     if (verticalPageLimit == 0)
         return;
 
     const double origZoom = m_settings->zoom();
 
     if (m_settings->zoom() < 1.0) {
         q->updateVerticalPageParameters(0);   // clear all parameters
         m_settings->setZoom(1.0);
     }
 
     QRect printRange = m_pSheet->usedArea(true);
     calculateVerticalPageParameters(printRange.bottom());
     int currentPages = m_lnewPageListY.count();
 
     if (currentPages <= verticalPageLimit)
         return;
 
     double factor = (double)verticalPageLimit / (double)currentPages +
                     1 - (double)currentPages / ((double)currentPages + 1); //add possible error
     debugSheets << "Calculated factor for scaling m_settings->zoom():" << factor;
     m_settings->setZoom(m_settings->zoom()*factor);
 
     debugSheets << "New exact zoom:" << m_settings->zoom();
 
     if (m_settings->zoom() < 0.01)
         m_settings->setZoom(0.01);
     if (m_settings->zoom() > 1.0)
         m_settings->setZoom(1.0);
 
     m_settings->setZoom((((int)(m_settings->zoom()*100 + 0.5)) / 100.0));
 
     debugSheets << "New rounded zoom:" << m_settings->zoom();
 
     q->updateVerticalPageParameters(0);   // clear all parameters
     calculateVerticalPageParameters(printRange.bottom());
     currentPages = m_lnewPageListY.count();
 
     debugSheets << "Number of pages with this zoom:" << currentPages;
 
     while ((currentPages > verticalPageLimit) && (m_settings->zoom() > 0.01)) {
         m_settings->setZoom(m_settings->zoom() - 0.01);
         q->updateVerticalPageParameters(0);   // clear all parameters
         calculateVerticalPageParameters(printRange.bottom());
         currentPages = m_lnewPageListY.count();
         debugSheets << "Looping -0.01; current zoom:" << m_settings->zoom();
     }
 
     if (m_settings->zoom() < origZoom) {
         // Trigger an update of the horizontal page parameters.
         q->updateHorizontalPageParameters(0); // clear all parameters
         calculateHorizontalPageParameters(printRange.right());
     } else
         m_settings->setZoom(origZoom);
 }
 
 void SheetPrint::Private::updateRepeatedColumnsWidth()
 {
     m_dPrintRepeatColumnsWidth = 0.0;
     const QPair<int, int> repeatedColumns = m_settings->repeatedColumns();
     if (repeatedColumns.first != 0) {
         for (int i = repeatedColumns.first; i <= repeatedColumns.second; i++) {
             m_dPrintRepeatColumnsWidth += m_pSheet->columnFormat(i)->width();
         }
     }
 }
 
 void SheetPrint::Private::updateRepeatedRowsHeight()
 {
     m_dPrintRepeatRowsHeight = 0.0;
     const QPair<int, int> repeatedRows = m_settings->repeatedRows();
     if (repeatedRows.first != 0) {
         m_dPrintRepeatRowsHeight += m_pSheet->rowFormats()->totalRowHeight(repeatedRows.first, repeatedRows.second);
     }
 }
 
 bool PrintNewPageEntry::operator==(PrintNewPageEntry const & entry) const
 {
     return m_iStartItem == entry.m_iStartItem;
 }