spinbox2.h

/*
 *  spinbox2.h  -  spin box with extra pair of spin buttons (for TQt 3)
 *  Program:  kalarm
 *  Copyright © 2001-2007 by David Jarvie <software@astrojar.org.uk>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program 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 General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License along
 *  with this program; if not, write to the Free Software Foundation, Inc.,
 *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */
 
#ifndef SPINBOX2_H
#define SPINBOX2_H
 
#include <tqglobal.h>
#include <tqlineedit.h>
 
class SpinMirror;
class ExtraSpinBox;
#include "spinbox.h"
 
 
class SpinBox2 : public TQFrame
{
        TQ_OBJECT
  
    public:
        explicit SpinBox2(TQWidget* parent = 0, const char* name = 0);
        SpinBox2(int minValue, int maxValue, int step = 1, int step2 = 1,
                 TQWidget* parent = 0, const char* name = 0);
        virtual void        setReadOnly(bool readOnly);
        bool                isReadOnly() const          { return mSpinbox->isReadOnly(); }
        void                setSelectOnStep(bool sel)   { mSpinbox->setSelectOnStep(sel); }
        void                setReverseWithLayout(bool reverse);
        bool                reverseButtons() const      { return mReverseLayout  &&  !mReverseWithLayout; }
 
        TQString             text() const                { return mSpinbox->text(); }
        virtual TQString     prefix() const              { return mSpinbox->prefix(); }
        virtual TQString     suffix() const              { return mSpinbox->suffix(); }
        virtual TQString     cleanText() const           { return mSpinbox->cleanText(); }
 
        virtual void        setSpecialValueText(const TQString& text)  { mSpinbox->setSpecialValueText(text); }
        TQString             specialValueText() const    { return mSpinbox->specialValueText(); }
 
        virtual void        setWrapping(bool on);
        bool                wrapping() const            { return mSpinbox->wrapping(); }
 
        void                setAlignment(int a)         { mSpinbox->setAlignment(a); }
        virtual void        setButtonSymbols(TQSpinBox::ButtonSymbols);
        TQSpinBox::ButtonSymbols buttonSymbols() const   { return mSpinbox->buttonSymbols(); }
 
        virtual void        setValidator(const TQValidator* v)  { mSpinbox->setValidator(v); }
        const TQValidator*   validator() const           { return mSpinbox->validator(); }
 
        virtual TQSize       sizeHint() const;
        virtual TQSize       minimumSizeHint() const;
 
        int                 minValue() const            { return mMinValue; }
        int                 maxValue() const            { return mMaxValue; }
        virtual void        setMinValue(int val);
        virtual void        setMaxValue(int val);
        void                setRange(int minValue, int maxValue)   { setMinValue(minValue);  setMaxValue(maxValue); }
        int                 value() const               { return mSpinbox->value(); }
        int                 bound(int val) const;
 
        TQRect               upRect() const              { return mSpinbox->upRect(); }
        TQRect               downRect() const            { return mSpinbox->downRect(); }
        TQRect               up2Rect() const;
        TQRect               down2Rect() const;
 
        int                 lineStep() const            { return mLineStep; }
        int                 lineShiftStep() const       { return mLineShiftStep; }
        int                 pageStep() const            { return mPageStep; }
        int                 pageShiftStep() const       { return mPageShiftStep; }
        void                setLineStep(int step);
        void                setSteps(int line, int page);
        void                setShiftSteps(int line, int page);
 
        void                addPage()                   { addValue(mPageStep); }
        void                subtractPage()              { addValue(-mPageStep); }
        void                addLine()                   { addValue(mLineStep); }
        void                subtractLine()              { addValue(-mLineStep); }
        void                addValue(int change)        { mSpinbox->addValue(change); }
 
    public slots:
        virtual void        setValue(int val)           { mSpinbox->setValue(val); }
        virtual void        setPrefix(const TQString& text)  { mSpinbox->setPrefix(text); }
        virtual void        setSuffix(const TQString& text)  { mSpinbox->setSuffix(text); }
        virtual void        stepUp()                    { addValue(mLineStep); }
        virtual void        stepDown()                  { addValue(-mLineStep); }
        virtual void        pageUp()                    { addValue(mPageStep); }
        virtual void        pageDown()                  { addValue(-mPageStep); }
        virtual void        selectAll()                 { mSpinbox->selectAll(); }
        virtual void        setEnabled(bool enabled);
 
    signals:
        void                valueChanged(int value);
        void                valueChanged(const TQString& valueText);
 
    protected:
        virtual TQString     mapValueToText(int v)         { return mSpinbox->mapValToText(v); }
        virtual int         mapTextToValue(bool* ok)      { return mSpinbox->mapTextToVal(ok); }
        virtual void        resizeEvent(TQResizeEvent*)    { arrange(); }
        virtual void        showEvent(TQShowEvent*);
        virtual void        styleChange(TQStyle&);
        virtual void        getMetrics() const;
 
        mutable int      wUpdown2;        // width of second spin widget
        mutable int      xUpdown2;        // x offset of visible area in 'mUpdown2'
        mutable int      xSpinbox;        // x offset of visible area in 'mSpinbox'
        mutable int      wGap;            // gap between mUpdown2Frame and mSpinboxFrame
 
    protected slots:
        virtual void        valueChange();
        virtual void        stepPage(int);
 
    private slots:
        void                updateMirror();
 
    private:
        void                init();
        void                arrange();
        int                 whichButton(TQObject* spinWidget, const TQPoint&);
        void                setShiftStepping(bool on);
 
        // Visible spin box class.
        // Declared here to allow use of mSpinBox in inline methods.
        class MainSpinBox : public SpinBox
        {
            public:
                MainSpinBox(SpinBox2* sb2, TQWidget* parent, const char* name = 0)
                                : SpinBox(parent, name), owner(sb2) { }
                MainSpinBox(int minValue, int maxValue, int step, SpinBox2* sb2, TQWidget* parent, const char* name = 0)
                                : SpinBox(minValue, maxValue, step, parent, name), owner(sb2) { }
                void            setAlignment(int a)       { editor()->setAlignment(a); }
                virtual TQString mapValueToText(int v)     { return owner->mapValueToText(v); }
                virtual int     mapTextToValue(bool* ok)  { return owner->mapTextToValue(ok); }
                TQString         mapValToText(int v)       { return SpinBox::mapValueToText(v); }
                int             mapTextToVal(bool* ok)    { return SpinBox::mapTextToValue(ok); }
                virtual int     shiftStepAdjustment(int oldValue, int shiftStep);
            private:
                SpinBox2* owner;   // owner SpinBox2
        };
 
        enum { NO_BUTTON = -1, UP, DOWN, UP2, DOWN2 };
 
        static int       mReverseLayout;  // widgets are mirrored right to left
        TQFrame*          mUpdown2Frame;   // contains visible part of the extra pair of spin buttons
        TQFrame*          mSpinboxFrame;   // contains the main spin box
        ExtraSpinBox*    mUpdown2;        // the extra pair of spin buttons
        MainSpinBox*     mSpinbox;        // the visible spin box
        SpinMirror*      mSpinMirror;     // image of the extra pair of spin buttons
        int              mMinValue;
        int              mMaxValue;
        int              mLineStep;           // right button increment
        int              mLineShiftStep;      // right button increment with shift pressed
        int              mPageStep;           // left button increment
        int              mPageShiftStep;      // left button increment with shift pressed
        bool             mReverseWithLayout;  // reverse button positions if reverse layout (default = true)
 
    friend class MainSpinBox;
};
 
#endif // SPINBOX2_H