summaryrefslogtreecommitdiffstats
path: root/kalarm/lib/spinbox2.h
diff options
context:
space:
mode:
authortoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
committertoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
commit460c52653ab0dcca6f19a4f492ed2c5e4e963ab0 (patch)
tree67208f7c145782a7e90b123b982ca78d88cc2c87 /kalarm/lib/spinbox2.h
downloadtdepim-460c52653ab0dcca6f19a4f492ed2c5e4e963ab0.tar.gz
tdepim-460c52653ab0dcca6f19a4f492ed2c5e4e963ab0.zip
Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.
BUG:215923 git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdepim@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da
Diffstat (limited to 'kalarm/lib/spinbox2.h')
-rw-r--r--kalarm/lib/spinbox2.h317
1 files changed, 317 insertions, 0 deletions
diff --git a/kalarm/lib/spinbox2.h b/kalarm/lib/spinbox2.h
new file mode 100644
index 000000000..772eaee70
--- /dev/null
+++ b/kalarm/lib/spinbox2.h
@@ -0,0 +1,317 @@
+/*
+ * spinbox2.h - spin box with extra pair of spin buttons (for Qt 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 <qglobal.h>
+#include <qlineedit.h>
+
+class SpinMirror;
+class ExtraSpinBox;
+#include "spinbox.h"
+
+
+/**
+ * @short Spin box with a pair of spin buttons on either side.
+ *
+ * The SpinBox2 class provides a spin box with two pairs of spin buttons, one on either side.
+ *
+ * It is designed as a base class for implementing such facilities as time spin boxes, where
+ * the hours and minutes values are separately displayed in the edit field. When the
+ * appropriate step increments are configured, the left spin arrows can then be used to
+ * change the hours value, while the right spin arrows can be used to change the minutes
+ * value.
+ *
+ * Rather than using SpinBox2 directly for time entry, use in preference TimeSpinBox or
+ * TimeEdit classes which are tailored from SpinBox2 for this purpose.
+ *
+ * Separate step increments may optionally be specified for use when the shift key is
+ * held down. Typically these would be larger than the normal steps. Then, when the user
+ * clicks the spin buttons, he/she can increment or decrement the value faster by holding
+ * the shift key down.
+ *
+ * The widget may be set as read-only. This has the same effect as disabling it, except
+ * that its appearance is unchanged.
+ *
+ * @author David Jarvie <software@astrojar.org.uk>
+ */
+class SpinBox2 : public QFrame
+{
+ Q_OBJECT
+ public:
+ /** Constructor.
+ * @param parent The parent object of this widget.
+ * @param name The name of this widget.
+ */
+ explicit SpinBox2(QWidget* parent = 0, const char* name = 0);
+ /** Constructor.
+ * @param minValue The minimum value which the spin box can have.
+ * @param maxValue The maximum value which the spin box can have.
+ * @param step The (unshifted) step interval for the right-hand spin buttons.
+ * @param step2 The (unshifted) step interval for the left-hand spin buttons.
+ * @param parent The parent object of this widget.
+ * @param name The name of this widget.
+ */
+ SpinBox2(int minValue, int maxValue, int step = 1, int step2 = 1,
+ QWidget* parent = 0, const char* name = 0);
+ /** Sets whether the spin box can be changed by the user.
+ * @param readOnly True to set the widget read-only, false to set it read-write.
+ */
+ virtual void setReadOnly(bool readOnly);
+ /** Returns true if the widget is read only. */
+ bool isReadOnly() const { return mSpinbox->isReadOnly(); }
+ /** Sets whether the spin box value text should be selected when its value is stepped. */
+ void setSelectOnStep(bool sel) { mSpinbox->setSelectOnStep(sel); }
+ /** Sets whether the spin button pairs should be reversed for a right-to-left language.
+ * The default is for them to be reversed.
+ */
+ void setReverseWithLayout(bool reverse);
+ /** Returns whether the spin button pairs will be reversed for a right-to-left language. */
+ bool reverseButtons() const { return mReverseLayout && !mReverseWithLayout; }
+
+ /** Returns the spin box's text, including any prefix() and suffix(). */
+ QString text() const { return mSpinbox->text(); }
+ /** Returns the prefix for the spin box's text. */
+ virtual QString prefix() const { return mSpinbox->prefix(); }
+ /** Returns the suffix for the spin box's text. */
+ virtual QString suffix() const { return mSpinbox->suffix(); }
+ /** Returns the spin box's text with no prefix(), suffix() or leading or trailing whitespace. */
+ virtual QString cleanText() const { return mSpinbox->cleanText(); }
+
+ /** Sets the special-value text which, if non-null, is displayed instead of a numeric
+ * value when the current value is equal to minValue().
+ */
+ virtual void setSpecialValueText(const QString& text) { mSpinbox->setSpecialValueText(text); }
+ /** Returns the special-value text which, if non-null, is displayed instead of a numeric
+ * value when the current value is equal to minValue().
+ */
+ QString specialValueText() const { return mSpinbox->specialValueText(); }
+
+ /** Sets whether it is possible to step the value from the highest value to the
+ * lowest value and vice versa.
+ */
+ virtual void setWrapping(bool on);
+ /** Returns whether it is possible to step the value from the highest value to the
+ * lowest value and vice versa.
+ */
+ bool wrapping() const { return mSpinbox->wrapping(); }
+
+ /** Set the text alignment of the widget */
+ void setAlignment(int a) { mSpinbox->setAlignment(a); }
+ /** Sets the button symbols to use (arrows or plus/minus). */
+ virtual void setButtonSymbols(QSpinBox::ButtonSymbols);
+ /** Returns the button symbols currently in use (arrows or plus/minus). */
+ QSpinBox::ButtonSymbols buttonSymbols() const { return mSpinbox->buttonSymbols(); }
+
+ /** Sets the validator to @p v. The validator controls what keyboard input is accepted
+ * when the user is editing the value field.
+ */
+ virtual void setValidator(const QValidator* v) { mSpinbox->setValidator(v); }
+ /** Returns the current validator. The validator controls what keyboard input is accepted
+ * when the user is editing the value field.
+ */
+ const QValidator* validator() const { return mSpinbox->validator(); }
+
+ virtual QSize sizeHint() const;
+ virtual QSize minimumSizeHint() const;
+
+ /** Returns the minimum value of the spin box. */
+ int minValue() const { return mMinValue; }
+ /** Returns the maximum value of the spin box. */
+ int maxValue() const { return mMaxValue; }
+ /** Sets the minimum value of the spin box. */
+ virtual void setMinValue(int val);
+ /** Sets the maximum value of the spin box. */
+ virtual void setMaxValue(int val);
+ /** Sets the minimum and maximum values of the spin box. */
+ void setRange(int minValue, int maxValue) { setMinValue(minValue); setMaxValue(maxValue); }
+ /** Returns the current value of the spin box. */
+ int value() const { return mSpinbox->value(); }
+ /** Returns the specified value clamped to the range of the spin box. */
+ int bound(int val) const;
+
+ /** Returns the geometry of the right-hand "up" button. */
+ QRect upRect() const { return mSpinbox->upRect(); }
+ /** Returns the geometry of the right-hand "down" button. */
+ QRect downRect() const { return mSpinbox->downRect(); }
+ /** Returns the geometry of the left-hand "up" button. */
+ QRect up2Rect() const;
+ /** Returns the geometry of the left-hand "down" button. */
+ QRect down2Rect() const;
+
+ /** Returns the unshifted step increment for the right-hand spin buttons,
+ * i.e. the amount by which the spin box value changes when a right-hand
+ * spin button is clicked without the shift key being pressed.
+ */
+ int lineStep() const { return mLineStep; }
+ /** Returns the shifted step increment for the right-hand spin buttons,
+ * i.e. the amount by which the spin box value changes when a right-hand
+ * spin button is clicked while the shift key is pressed.
+ */
+ int lineShiftStep() const { return mLineShiftStep; }
+ /** Returns the unshifted step increment for the left-hand spin buttons,
+ * i.e. the amount by which the spin box value changes when a left-hand
+ * spin button is clicked without the shift key being pressed.
+ */
+ int pageStep() const { return mPageStep; }
+ /** Returns the shifted step increment for the left-hand spin buttons,
+ * i.e. the amount by which the spin box value changes when a left-hand
+ * spin button is clicked while the shift key is pressed.
+ */
+ int pageShiftStep() const { return mPageShiftStep; }
+ /** Sets the unshifted step increment for the right-hand spin buttons,
+ * i.e. the amount by which the spin box value changes when a right-hand
+ * spin button is clicked without the shift key being pressed.
+ */
+ void setLineStep(int step);
+ /** Sets the unshifted step increments for the two pairs of spin buttons,
+ * i.e. the amount by which the spin box value changes when a spin button
+ * is clicked without the shift key being pressed.
+ * @param line The step increment for the right-hand spin buttons.
+ * @param page The step increment for the left-hand spin buttons.
+ */
+ void setSteps(int line, int page);
+ /** Sets the shifted step increments for the two pairs of spin buttons,
+ * i.e. the amount by which the spin box value changes when a spin button
+ * is clicked while the shift key is pressed.
+ * @param line The shift step increment for the right-hand spin buttons.
+ * @param page The shift step increment for the left-hand spin buttons.
+ */
+ void setShiftSteps(int line, int page);
+
+ /** Increments the current value by adding the unshifted step increment for
+ * the left-hand spin buttons.
+ */
+ void addPage() { addValue(mPageStep); }
+ /** Decrements the current value by subtracting the unshifted step increment for
+ * the left-hand spin buttons.
+ */
+ void subtractPage() { addValue(-mPageStep); }
+ /** Increments the current value by adding the unshifted step increment for
+ * the right-hand spin buttons.
+ */
+ void addLine() { addValue(mLineStep); }
+ /** Decrements the current value by subtracting the unshifted step increment for
+ * the right-hand spin buttons.
+ */
+ void subtractLine() { addValue(-mLineStep); }
+ /** Adjusts the current value by adding @p change. */
+ void addValue(int change) { mSpinbox->addValue(change); }
+
+ public slots:
+ /** Sets the current value to @p val. */
+ virtual void setValue(int val) { mSpinbox->setValue(val); }
+ /** Sets the prefix which is prepended to the start of the displayed text. */
+ virtual void setPrefix(const QString& text) { mSpinbox->setPrefix(text); }
+ /** Sets the suffix which is prepended to the start of the displayed text. */
+ virtual void setSuffix(const QString& text) { mSpinbox->setSuffix(text); }
+ /** Increments the current value by adding the unshifted step increment for
+ * the right-hand spin buttons.
+ */
+ virtual void stepUp() { addValue(mLineStep); }
+ /** Decrements the current value by subtracting the unshifted step increment for
+ * the right-hand spin buttons.
+ */
+ virtual void stepDown() { addValue(-mLineStep); }
+ /** Increments the current value by adding the unshifted step increment for
+ * the left-hand spin buttons.
+ */
+ virtual void pageUp() { addValue(mPageStep); }
+ /** Decrements the current value by subtracting the unshifted step increment for
+ * the left-hand spin buttons.
+ */
+ virtual void pageDown() { addValue(-mPageStep); }
+ /** Selects all the text in the spin box's editor. */
+ virtual void selectAll() { mSpinbox->selectAll(); }
+ /** Sets whether the widget is enabled. */
+ virtual void setEnabled(bool enabled);
+
+ signals:
+ /** Signal which is emitted whenever the value of the spin box changes. */
+ void valueChanged(int value);
+ /** Signal which is emitted whenever the value of the spin box changes. */
+ void valueChanged(const QString& valueText);
+
+ protected:
+ virtual QString mapValueToText(int v) { return mSpinbox->mapValToText(v); }
+ virtual int mapTextToValue(bool* ok) { return mSpinbox->mapTextToVal(ok); }
+ virtual void resizeEvent(QResizeEvent*) { arrange(); }
+ virtual void showEvent(QShowEvent*);
+ virtual void styleChange(QStyle&);
+ 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(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, const char* name = 0)
+ : SpinBox(parent, name), owner(sb2) { }
+ MainSpinBox(int minValue, int maxValue, int step, SpinBox2* sb2, QWidget* parent, const char* name = 0)
+ : SpinBox(minValue, maxValue, step, parent, name), owner(sb2) { }
+ void setAlignment(int a) { editor()->setAlignment(a); }
+ virtual QString mapValueToText(int v) { return owner->mapValueToText(v); }
+ virtual int mapTextToValue(bool* ok) { return owner->mapTextToValue(ok); }
+ QString 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
+ QFrame* mUpdown2Frame; // contains visible part of the extra pair of spin buttons
+ 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 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