kspread_sheetprint.h

/* This file is part of the KDE project
   Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>,
   2003 Philipp Mller <philipp.mueller@gmx.de>
 
   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.
*/
 
#ifndef __kspread_sheetprint_h__
#define __kspread_sheetprint_h__
 
#include <tqobject.h>
 
#include <koffice_export.h>
#include <KoUnit.h>
 
class KoGenStyles;
 
namespace KSpread
{
class Doc;
class Selection;
class PrintNewPageEntry;
class PrintObject;
 
class KSPREAD_EXPORT SheetPrint : public TQObject
{
    TQ_OBJECT
  
 
public:
 
    SheetPrint( Sheet *sheet );
    ~SheetPrint();
 
    TQString saveOasisSheetStyleLayout( KoGenStyles &mainStyles );
 
    bool print( TQPainter &painter, KPrinter *_printer );
 
    float prinsheetWidth()const { return m_paperWidth - m_leftBorder - m_rightBorder; }
 
    float prinsheetWidthPts()const { return MM_TO_POINT( prinsheetWidth() / m_dZoom ); }
 
    float prinsheetHeight()const { return m_paperHeight - m_topBorder - m_bottomBorder; }
 
    float prinsheetHeightPts()const { return MM_TO_POINT( prinsheetHeight() / m_dZoom ); }
 
    float paperHeight()const { return m_paperHeight; }
    float paperHeightPts()const { return MM_TO_POINT( m_paperHeight / m_dZoom ); }
    float paperWidth()const { return m_paperWidth; }
    float paperWidthPts()const { return MM_TO_POINT( m_paperWidth / m_dZoom ); }
 
    void setPaperHeight(float _val) { m_paperHeight=_val; }
    void setPaperWidth(float _val) { m_paperWidth=_val; }
 
    float leftBorder()const { return m_leftBorder; }
    float leftBorderPts()const { return MM_TO_POINT( m_leftBorder / m_dZoom ); }
    float rightBorder()const { return m_rightBorder; }
    float rightBorderPts()const { return MM_TO_POINT( m_rightBorder / m_dZoom ); }
    float topBorder()const { return m_topBorder; }
    float topBorderPts()const { return MM_TO_POINT( m_topBorder / m_dZoom ); }
    float bottomBorder()const { return m_bottomBorder; }
    float bottomBorderPts()const { return MM_TO_POINT( m_bottomBorder / m_dZoom ); }
 
    KoOrientation orientation()const { return m_orientation; }
    const char* orientationString() const;
 
    KoFormat paperFormat()const { return m_paperFormat; }
    TQString paperFormatString()const;
 
    void setPaperFormat(KoFormat _format) {m_paperFormat=_format;}
 
    void setPaperOrientation(KoOrientation _orient);
 
    KoPageLayout paperLayout() const;
 
    void setPaperLayout( float _leftBorder, float _topBorder, float _rightBorder, float _bottomBoder,
                         KoFormat _paper, KoOrientation orientation );
    void setPaperLayout( float _leftBorder, float _topBorder, float _rightBorder, float _bottomBoder,
                         const TQString& _paper, const TQString& _orientation );
 
    TQString headLeft( int _p, const TQString &_t  )const { if ( m_headLeft.isNull() ) return "";
    return completeHeading( m_headLeft, _p, _t ); }
    TQString headMid( int _p, const TQString &_t )const { if ( m_headMid.isNull() ) return "";
    return completeHeading( m_headMid, _p, _t ); }
    TQString headRight( int _p, const TQString &_t )const { if ( m_headRight.isNull() ) return "";
    return completeHeading( m_headRight, _p, _t ); }
    TQString footLeft( int _p, const TQString &_t )const { if ( m_footLeft.isNull() ) return "";
    return completeHeading( m_footLeft, _p, _t ); }
    TQString footMid( int _p, const TQString &_t )const { if ( m_footMid.isNull() ) return "";
    return completeHeading( m_footMid, _p, _t ); }
    TQString footRight( int _p, const TQString &_t )const { if ( m_footRight.isNull() ) return "";
    return completeHeading( m_footRight, _p, _t ); }
 
    TQString headLeft()const { if ( m_headLeft.isNull() ) return ""; return m_headLeft; }
    TQString headMid()const { if ( m_headMid.isNull() ) return ""; return m_headMid; }
    TQString headRight()const { if ( m_headRight.isNull() ) return ""; return m_headRight; }
    TQString footLeft()const { if ( m_footLeft.isNull() ) return ""; return m_footLeft; }
    TQString footMid()const { if ( m_footMid.isNull() ) return ""; return m_footMid; }
    TQString footRight()const { if ( m_footRight.isNull() ) return ""; return m_footRight; }
 
    TQRect printRange() const { return m_printRange; }
    void setPrintRange( const TQRect &_printRange );
 
    int pageLimitX() const { return m_iPageLimitX; }
 
    int pageLimitY() const { return m_iPageLimitY; }
 
    void setPageLimitX( int pages );
 
    void setPageLimitY( int pages );
 
    void calculateZoomForPageLimitX();
 
    void calculateZoomForPageLimitY();
 
    TQPair<int, int> printRepeatColumns() const { return m_printRepeatColumns; }
    void setPrintRepeatColumns( TQPair<int, int> _printRepeatColumns );
 
    TQPair<int, int> printRepeatRows() const { return m_printRepeatRows; }
    void setPrintRepeatRows( TQPair<int, int> _printRepeatRows );
 
    bool isOnNewPageX( int _column );
 
    void updateNewPageX( int _column );
 
    bool isOnNewPageY( int _row );
 
    void updateNewPageY( int _row );
 
    void updateNewPageListX( int _col );
 
    void updateNewPageListY( int _row );
 
    void replaceHeadFootLineMacro ( TQString &_text, const TQString &_search, const TQString &_replace );
    TQString localizeHeadFootLine ( const TQString &_text );
    TQString delocalizeHeadFootLine ( const TQString &_text );
 
    KoHeadFoot headFootLine() const;
 
    void setHeadFootLine( const TQString &_headl, const TQString &_headm, const TQString &_headr,
                          const TQString &_footl, const TQString &_footm, const TQString &_footr );
 
    bool printGrid() const { return m_bPrintGrid; }
 
    void setPrintGrid( bool _printGrid );
 
    bool printObjects() const { return m_bPrintObjects; }
 
    void setPrintObjects( bool _printObjects );
 
    bool printCharts() const { return m_bPrintCharts; }
 
    void setPrintCharts( bool _printCharts );
 
    bool printGraphics() const { return m_bPrintGraphics; }
 
    void setPrintGraphics( bool _printGraphics );
 
    bool printCommentIndicator() const { return m_bPrintCommentIndicator; }
 
    void setPrintCommentIndicator( bool _printCommentIndicator );
 
    bool printFormulaIndicator() const { return m_bPrintFormulaIndicator; }
 
    void setPrintFormulaIndicator( bool _printFormulaIndicator );
 
    void updatePrintRepeatColumnsWidth();
 
    void updatePrintRepeatRowsHeight();
 
    void definePrintRange(Selection* selectionInfo);
    void resetPrintRange();
 
    void insertColumn( int col, int nbCol );
    void removeColumn( int col, int nbCol );
    void insertRow( int row, int nbRow );
    void removeRow( int row, int nbRow );
 
    void setZoom( double _zoom, bool checkPageLimit = true );
 
    double zoom() const { return m_dZoom; }
 
    bool pageNeedsPrinting( TQRect& page_range );
 
signals:
    void sig_updateView( Sheet *_sheet );
 
private:
 
    Sheet * m_pSheet;
    Doc * m_pDoc;
 
    void printPage( TQPainter &_painter, const TQRect& page_range,
                    const KoRect& view, const KoPoint _childOffset );
 
    void printRect( TQPainter &painter, const KoPoint& topLeft,
                    const TQRect& printRect, const KoRect& view,
                    TQRegion &clipRegion );
 
    void printHeaderFooter( TQPainter &painter, int pageNo );
 
    void calcPaperSize();
 
    TQValueList<PrintNewPageEntry>::iterator findNewPageColumn( int col );
 
    TQValueList<PrintNewPageEntry>::iterator findNewPageRow( int row );
 
    TQString completeHeading( const TQString &_data, int _page, const TQString &_sheet ) const ;
 
    TQRect cellsPrintRange();
 
    int pagesX( const TQRect& cellsPrintRange );
 
    int pagesY( const TQRect& cellsPrintRange );
 
    KoOrientation m_orientation;
    KoFormat m_paperFormat;
    float m_paperWidth;
    float m_paperHeight;
    float m_leftBorder;
    float m_rightBorder;
    float m_topBorder;
    float m_bottomBorder;
 
    TQString m_headLeft;
    TQString m_headRight;
    TQString m_headMid;
    TQString m_footLeft;
    TQString m_footRight;
    TQString m_footMid;
 
    uint m_uprintPages;
 
    TQRect m_printRange;
 
    TQPair<int, int> m_printRepeatColumns;
 
    TQPair<int, int> m_printRepeatRows;
 
    bool m_bPrintGrid;
 
    bool m_bPrintObjects;
 
    bool m_bPrintCharts;
 
    bool m_bPrintGraphics;
 
    bool m_bPrintFormulaIndicator;
 
    bool m_bPrintCommentIndicator;
 
    double m_dPrintRepeatColumnsWidth;
    double m_dPrintRepeatRowsHeight;
 
     TQValueList<PrintNewPageEntry> m_lnewPageListX;
 
     TQValueList<PrintNewPageEntry> m_lnewPageListY;
 
     int m_maxCheckedNewPageX;
 
     int m_maxCheckedNewPageY;
 
    double m_dZoom;
 
    int m_iPageLimitX;
    int m_iPageLimitY;
 
    TQValueList<PrintObject*> m_printObjects;
};
 
 
class PrintNewPageEntry
{
public:
    PrintNewPageEntry() :
        m_iStartItem( 0 ), m_iEndItem( 0 ), m_dSize( 0 ),
        m_dOffset( 0 ){}
 
    PrintNewPageEntry( int startItem, int endItem = 0, double size = 0,
                              double offset = 0 ) :
        m_iStartItem( startItem ), m_iEndItem( endItem ), m_dSize( size ),
        m_dOffset( offset ) {}
 
    int startItem() const { return m_iStartItem; }
    void setStartItem( int startItem ) { m_iStartItem = startItem; }
 
    int endItem() const { return m_iEndItem; }
    void setEndItem( int endItem ) { m_iEndItem = endItem; }
 
    double size() const { return m_dSize; }
    void setSize( double size ) { m_dSize = size; }
 
    double offset() const { return m_dOffset; }
    void setOffset( double offset ) { m_dOffset = offset; }
 
    bool operator==( PrintNewPageEntry const & entry ) const;
 
 
private:
    int m_iStartItem;
    int m_iEndItem;
    double m_dSize;
    double m_dOffset;
};
 
class PrintObject
{
  public:
    PrintObject() : obj(0), p(0) {}
 
    EmbeddedObject *obj;
    TQPixmap *p;
};
 
} // namespace KSpread
 
#endif