/*
* 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"
/**
* @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 TQFrame
{
Q_OBJECT
TQ_OBJECT
public:
/** Constructor.
* @param parent The parent object of this widget.
* @param name The name of this widget.
*/
explicit SpinBox2(TQWidget* 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,
TQWidget* 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(). */
TQString text() const { return mSpinbox->text(); }
/** Returns the prefix for the spin box's text. */
virtual TQString prefix() const { return mSpinbox->prefix(); }
/** Returns the suffix for the spin box's text. */
virtual TQString suffix() const { return mSpinbox->suffix(); }
/** Returns the spin box's text with no prefix(), suffix() or leading or trailing whitespace. */
virtual TQString 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 TQString& 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().
*/
TQString 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(TQSpinBox::ButtonSymbols);
/** Returns the button symbols currently in use (arrows or plus/minus). */
TQSpinBox::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 TQValidator* 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 TQValidator* validator() const { return mSpinbox->validator(); }
virtual TQSize sizeHint() const;
virtual TQSize 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. */
TQRect upRect() const { return mSpinbox->upRect(); }
/** Returns the geometry of the right-hand "down" button. */
TQRect downRect() const { return mSpinbox->downRect(); }
/** Returns the geometry of the left-hand "up" button. */
TQRect up2Rect() const;
/** Returns the geometry of the left-hand "down" button. */
TQRect 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 TQString& text) { mSpinbox->setPrefix(text); }
/** Sets the suffix which is prepended to the start of the displayed text. */
virtual void setSuffix(const TQString& 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 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