KoRuler.h

/* This file is part of the KDE project
   Copyright (C) 1998, 1999 Reginald Stadlbauer <reggie@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.
*/
 
// Description: Ruler (header)
 
/******************************************************************/
 
#ifndef koRuler_h
#define koRuler_h
 
#include <tqframe.h>
#include <tqpixmap.h>
 
#include <tdemacros.h>
#include <koffice_export.h>
#include <KoGlobal.h>
#include <KoTabChooser.h>
#include <KoUnit.h>
 
class KoPageLayout;
class TQPainter;
 
enum KoTabulators { T_LEFT = 0, T_CENTER = 1, T_RIGHT = 2, T_DEC_PNT = 3, T_INVALID = -1 };
enum KoTabulatorFilling { TF_BLANK = 0, TF_DOTS = 1, TF_LINE = 2, TF_DASH = 3, TF_DASH_DOT = 4, TF_DASH_DOT_DOT = 5};

struct KoTabulator {
    double ptPos;
    KoTabulators type;
    KoTabulatorFilling filling;
    double ptWidth;
    TQChar alignChar;
 
    bool operator==( const KoTabulator & t ) const {
        return TQABS( ptPos - t.ptPos ) < 1E-4 && type == t.type &&
               filling == t.filling && TQABS( ptWidth - t.ptWidth ) < 1E-4;
    }
    bool operator!=( const KoTabulator & t ) const {
        return !operator==(t);
    }
    // Operators used for sorting
    bool operator < ( const KoTabulator & t ) const {
        return ptPos < t.ptPos;
    }
    bool operator <= ( const KoTabulator & t ) const {
        return ptPos <= t.ptPos;
    }
    bool operator > ( const KoTabulator & t ) const {
        return ptPos > t.ptPos;
    }
};
 
typedef TQValueList<KoTabulator> KoTabulatorList;
 
class KoRulerPrivate;

class KOFFICEUI_EXPORT KoRuler : public TQFrame
{
    TQ_OBJECT
  
    friend class KoRulerPrivate; // for the Action enum
public:
    static const int F_TABS;
    static const int F_INDENTS;
    static const int F_HELPLINES;
    static const int F_NORESIZE;

    KoRuler( TQWidget *_parent,  TQWidget *_canvas, TQt::Orientation _orientation,
             const KoPageLayout& _layout, int _flags, KoUnit::Unit _unit,
             KoTabChooser *_tabChooser = 0L );
    ~KoRuler();

    void setUnit( const TQString& unit ) TDE_DEPRECATED ;
    void setUnit( KoUnit::Unit unit );

    void setZoom( const double& zoom=1.0 );
    const double& zoom() const { return m_zoom; }

    void setPageLayout( const KoPageLayout& _layout );

    void showMousePos( bool _showMPos );
    void setMousePos( int mx, int my );

    void setOffset( int _diffx, int _diffy );

    void setLeftIndent( double _left )
    { i_left = makeIntern( _left ); update(); }

    void setFirstIndent( double _first )
    { i_first = makeIntern( _first ); update(); }

    void setRightIndent( double _right );

    void setDirection( bool rtl );

    void setTabList( const KoTabulatorList & tabList );

    void setFrameStartEnd( int _frameStart, int _frameEnd );

    void setReadWrite( bool _readWrite );

    void changeFlags(int _flags);

    void setGridSize(double newGridSize) { gridSize=newGridSize; }

    int flags() const;

    bool doubleClickedIndent() const;

    void setPageLayoutMenuItemEnabled(bool b);

    virtual TQSize minimumSizeHint() const;

    virtual TQSize sizeHint() const;
 
signals:
    void newPageLayout( const KoPageLayout & );
    void newLeftIndent( double );
    void newFirstIndent( double );
    void newRightIndent( double );
    void openPageLayoutDia();
    void doubleClicked();
    void doubleClicked( double ptPos );
 
    void tabListChanged( const KoTabulatorList & );
    void unitChanged( KoUnit::Unit );
 
    void addGuide(const TQPoint &, bool, int );
    void moveGuide( const TQPoint &, bool, int );
    void addHelpline(const TQPoint &, bool );
    void moveHelpLines( const TQPoint &, bool );
 
protected:
    enum Action {A_NONE, A_BR_LEFT, A_BR_RIGHT, A_BR_TOP, A_BR_BOTTOM,
                 A_LEFT_INDENT, A_FIRST_INDENT, A_TAB, A_RIGHT_INDENT,
                 A_HELPLINES };
 
    void drawContents( TQPainter *_painter )
    { orientation == TQt::Horizontal ? drawHorizontal( _painter ) : drawVertical( _painter ); }
 
    void drawHorizontal( TQPainter *_painter );
    void drawVertical( TQPainter *_painter );
    void drawTabs( TQPainter &_painter );
 
    void mousePressEvent( TQMouseEvent *e );
    void mouseReleaseEvent( TQMouseEvent *e );
    void mouseMoveEvent( TQMouseEvent *e );
    void mouseDoubleClickEvent( TQMouseEvent* );
    void resizeEvent( TQResizeEvent *e );
    void handleDoubleClick();
 
    double makeIntern( double _v );
    double zoomIt(const double &value) const;
    int zoomIt(const int &value) const;
    unsigned int zoomIt(const unsigned int &value) const;
    double unZoomIt(const double &value) const;
    int unZoomIt(const int &value) const;
    unsigned int unZoomIt(const unsigned int &value) const;
    void setupMenu();
    void uncheckMenu();
    void searchTab(int mx);
    void drawLine(int oldX, int newX);
 
private:
    double applyRtlAndZoom( double value ) const;
    double unZoomItRtl( int pixValue ) const;
    double lineDistance() const;
    bool willRemoveTab( int y ) const;
 
    KoRulerPrivate *d;
 
    TQt::Orientation orientation;
    int diffx, diffy;
    double i_left, i_first;
    TQPixmap buffer;
    double m_zoom, m_1_zoom;
    KoUnit::Unit m_unit;
    bool hasToDelete;
    bool showMPos;
    bool m_bFrameStartSet;
    bool m_bReadWrite;
    int mposX, mposY;
    int frameStart;
 
    double gridSize;
 
protected slots:
    void slotMenuActivated( int i );
    void pageLayoutDia() { emit doubleClicked()/*openPageLayoutDia()*/; }
    void rbRemoveTab();
 
};
 
inline double KoRuler::zoomIt(const double &value) const {
    if (m_zoom==1.0)
        return value;
    return m_zoom*value;
}
 
inline int KoRuler::zoomIt(const int &value) const {
    if (m_zoom==1.0)
        return value;
    return tqRound(m_zoom*value);
}
 
inline unsigned int KoRuler::zoomIt(const unsigned int &value) const {
    if (m_zoom==1.0)
        return value;
    return static_cast<unsigned int>(tqRound(m_zoom*value));
}
 
inline double KoRuler::unZoomIt(const double &value) const {
    if(m_zoom==1.0)
        return value;
    return value*m_1_zoom;
}
 
inline int KoRuler::unZoomIt(const int &value) const {
    if(m_zoom==1.0)
        return value;
    return tqRound(value*m_1_zoom);
}
 
inline unsigned int KoRuler::unZoomIt(const unsigned int &value) const {
    if(m_zoom==1.0)
        return value;
    return static_cast<unsigned int>(tqRound(value*m_1_zoom));
}
 
#endif