spinbox2.h

Go to the documentation of this file.

/*
 *  spinbox2.h  -  spin box with extra pair of spin buttons
 *  Program:  kalarm
 *  Copyright © 2001-2008 by David Jarvie <djarvie@kde.org>
 *
 *  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 "spinbox.h"

#include <QFrame>
class QShowEvent;
class QResizeEvent;
class SpinMirror;
class ExtraSpinBox;


class SpinBox2 : public QFrame
{
        Q_OBJECT
    public:
        explicit SpinBox2(QWidget* parent = 0);
        SpinBox2(int minValue, int maxValue, int pageStep = 1, QWidget* parent = 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 mRightToLeft  &&  !mReverseWithLayout; }

        QString          text() const                { return mSpinbox->text(); }
        QString          prefix() const              { return mSpinbox->prefix(); }
        QString          suffix() const              { return mSpinbox->suffix(); }
        void             setPrefix(const QString& text)  { mSpinbox->setPrefix(text); }
        void             setSuffix(const QString& text)  { mSpinbox->setSuffix(text); }
        QString          cleanText() const           { return mSpinbox->cleanText(); }

        void             setSpecialValueText(const QString& text)  { mSpinbox->setSpecialValueText(text); }
        QString          specialValueText() const    { return mSpinbox->specialValueText(); }

        void             setWrapping(bool on);
        bool             wrapping() const            { return mSpinbox->wrapping(); }

        void             setAlignment(Qt::Alignment a) { mSpinbox->setAlignment(a); }
        void             setButtonSymbols(QSpinBox::ButtonSymbols);
        QSpinBox::ButtonSymbols buttonSymbols() const   { return mSpinbox->buttonSymbols(); }

        virtual QValidator::State validate(QString&, int& /*pos*/) const  { return QValidator::Acceptable; }

        virtual QSize    sizeHint() const;
        virtual QSize    minimumSizeHint() const;

        int              minimum() const             { return mMinValue; }
        int              maximum() const             { return mMaxValue; }
        virtual void     setMinimum(int val);
        virtual void     setMaximum(int val);
        void             setRange(int minValue, int maxValue)   { setMinimum(minValue);  setMaximum(maxValue); }
        int              value() const               { return mSpinbox->value(); }
        int              bound(int val) const;

        QRect            upRect() const              { return mSpinbox->upRect(); }
        QRect            downRect() const            { return mSpinbox->downRect(); }
        QRect            up2Rect() const;
        QRect            down2Rect() const;

        int              singleStep() const          { return mSingleStep; }
        int              singleShiftStep() const     { return mSingleShiftStep; }
        int              pageStep() const            { return mPageStep; }
        int              pageShiftStep() const       { return mPageShiftStep; }
        void             setSingleStep(int step);
        void             setSteps(int line, int page);
        void             setShiftSteps(int line, int page);

        void             addPage()                   { addValue(mPageStep); }
        void             subtractPage()              { addValue(-mPageStep); }
        void             addSingle()                 { addValue(mSingleStep); }
        void             subtractSingle()            { addValue(-mSingleStep); }
        void             addValue(int change)        { mSpinbox->addValue(change); }
        virtual void     stepBy(int increment)       { addValue(increment); }

    public slots:
        void             setValue(int val)           { mSpinbox->setValue(val); }
        virtual void     pageUp()                    { addValue(mPageStep); }
        virtual void     pageDown()                  { addValue(-mPageStep); }
        void             selectAll()                 { mSpinbox->selectAll(); }
        virtual void     setEnabled(bool enabled);

    signals:
        void             valueChanged(int value);
        void             valueChanged(const QString& valueText);

    protected:
        virtual QString  textFromValue(int v) const    { return mSpinbox->textFromVal(v); }
        virtual int      valueFromText(const QString& t) const  { return mSpinbox->valFromText(t); }
        virtual void     paintEvent(QPaintEvent*);
        virtual void     showEvent(QShowEvent*);
        virtual void     styleChange(QStyle&);
        virtual void     getMetrics() const;

        mutable int      wUpdown2;        // width of second spin widget
        mutable int      wSpinboxHide;    // width at left of 'mSpinbox' hidden by second spin widget
        mutable QPoint   mButtonPos;      // position of buttons inside mirror widget

    protected slots:
        virtual void     valueChange();
        virtual void     stepPage(int);

    private slots:
        void             updateMirrorButtons();
        void             updateMirrorFrame();
        void             paintTimer();

    private:
        void             init();
        void             arrange();
        void             updateMirror();
        bool             eventFilter(QObject*, QEvent*);
        void             spinboxResized(QResizeEvent*);
        void             setUpdown2Size();
        int              whichButton(QObject* spinWidget, const QPoint&);
        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, QWidget* parent)
                                : SpinBox(parent), owner(sb2) { }
                MainSpinBox(int minValue, int maxValue, SpinBox2* sb2, QWidget* parent)
                                : SpinBox(minValue, maxValue, parent), owner(sb2) { }
                virtual QString textFromValue(int v) const  { return owner->textFromValue(v); }
                virtual int     valueFromText(const QString& t) const
                                                            { return owner->valueFromText(t); }
                QString         textFromVal(int v) const    { return SpinBox::textFromValue(v); }
                int             valFromText(const QString& t) const
                                                            { return SpinBox::valueFromText(t); }
                virtual int     shiftStepAdjustment(int oldValue, int shiftStep);
                virtual QValidator::State validate(QString& text, int& pos) const
                                                            { return owner->validate(text, pos); }
            protected:
                virtual void    resizeEvent(QResizeEvent* e) { owner->spinboxResized(e); SpinBox::resizeEvent(e); }
            private:
                SpinBox2* owner;   // owner SpinBox2
        };

        enum { NO_BUTTON = -1, UP, DOWN, UP2, DOWN2 };

        static int       mRightToLeft;    // widgets are mirrored right to left
        QFrame*          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              mSingleStep;         // right button increment
        int              mSingleShiftStep;    // 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

// vim: et sw=4: