KoZoomHandler.h

/* This file is part of the KDE project
   Copyright (C) 2001-2005 David Faure <faure@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.
*/
 
#ifndef kozoomhandler_h
#define kozoomhandler_h
 
#include <KoRect.h>
#include <koffice_export.h>
#include <KoZoomMode.h>

class KOFFICEUI_EXPORT KoZoomHandler
{
public:
    KoZoomHandler();
    virtual ~KoZoomHandler() {}

    virtual void setZoomAndResolution( int zoom, int dpiX, int dpiY );

    double zoomedResolutionX() const { return m_zoomedResolutionX; }
    double zoomedResolutionY() const { return m_zoomedResolutionY; }
 
    double resolutionX() const { return m_resolutionX; }
    double resolutionY() const { return m_resolutionY; }

    double zoomFactorX() const { return m_zoomedResolutionX / m_resolutionX; }
    double zoomFactorY() const { return m_zoomedResolutionY / m_resolutionY; }
 

    void setResolution( double resolutionX, double resolutionY );

    virtual void setZoomedResolution( double zoomedResolutionX, double zoomedResolutionY );

    void setZoom( int zoom );
    void setZoomMode( KoZoomMode::Mode zoomMode ) { m_zoomMode = zoomMode; }
    int zoom() const { return m_zoom; }
    KoZoomMode::Mode zoomMode() const { return m_zoomMode; }
    
    // Input: pt. Output: pixels. Resolution and zoom are applied.
    int zoomItX( double z ) const {
        return tqRound( m_zoomedResolutionX * z );
    }
    int zoomItY( double z ) const {
        return tqRound( m_zoomedResolutionY * z );
    }
 
    TQPoint zoomPoint( const KoPoint & p ) const {
        return TQPoint( zoomItX( p.x() ), zoomItY( p.y() ) );
    }
    TQRect zoomRect( const KoRect & r ) const {
        TQRect _r;
        _r.setCoords( zoomItX( r.left() ),  zoomItY( r.top() ),
                      zoomItX( r.right() ), zoomItY( r.bottom() ) );
        return _r;
    }
    TQSize zoomSize( const KoSize & s ) const {
        return TQSize( zoomItX( s.width() ), zoomItY( s.height() ) );
    }
 
    // Input: pixels. Output: pt.
    double unzoomItX( int x ) const {
        return static_cast<double>( x ) / m_zoomedResolutionX;
    }
    double unzoomItY( int y ) const {
        return static_cast<double>( y ) / m_zoomedResolutionY;
    }
    KoPoint unzoomPoint( const TQPoint & p ) const {
        return KoPoint( unzoomItX( p.x() ), unzoomItY( p.y() ) );
    }
    KoRect unzoomRect( const TQRect & r ) const {
        KoRect _r;
        _r.setCoords( unzoomItX( r.left() ),  unzoomItY( r.top() ),
                      unzoomItX( r.right() ), unzoomItY( r.bottom() ) );
        return _r;
    }
 
 
protected:
    int m_zoom;
    KoZoomMode::Mode m_zoomMode;
    
    double m_resolutionX;
    double m_resolutionY;
    double m_zoomedResolutionX;
    double m_zoomedResolutionY;
};
 
#endif