Actually move the kde files that were renamed in the last commit

1 files changed, 962 insertions, 0 deletions

diff --git a/tdeui/knuminput.h b/tdeui/knuminput.h
new file mode 100644
index 000000000..dd43092ef
--- /dev/null
+++ b/tdeui/knuminput.h
@@ -0,0 +1,962 @@
+/*
+ * knuminput.h
+ *
+ *  Copyright (c) 1997 Patrick Dowler <dowler@morgul.fsh.uvic.ca>
+ *  Copyright (c) 2000 Dirk A. Mueller <mueller@kde.org>
+ *  Copyright (c) 2002 Marc Mutz <mutz@kde.org>
+ *
+ *  Requires the Qt widget libraries, available at no cost at
+ *  http://www.troll.no/
+ *
+ *  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.
+ */
+
+#ifndef K_NUMINPUT_H
+#define K_NUMINPUT_H
+
+#include <tqwidget.h>
+#include <tqspinbox.h>
+#include <kdelibs_export.h>
+
+class TQLabel;
+class TQSlider;
+class TQLineEdit;
+class TQLayout;
+class TQValidator;
+
+class KIntSpinBox;
+
+/* ------------------------------------------------------------------------ */
+
+/**
+ * You need to inherit from this class if you want to implement K*NumInput
+ * for a different variable type
+ *
+ */
+class KDEUI_EXPORT KNumInput : public TQWidget
+{
+    Q_OBJECT
+    TQ_OBJECT
+    Q_PROPERTY( TQString label READ label WRITE setLabel )
+public:
+    /**
+     * Default constructor
+     * @param parent If parent is 0, the new widget becomes a top-level window. If parent is another widget, this widget becomes a child window inside parent. The new widget is deleted when its parent is deleted.
+     * @param name The name is sent to the TQObject constructor.
+     */
+    KNumInput(TQWidget* parent=0, const char* name=0);
+
+    /**
+     * @param below A pointer to another KNumInput.
+     * @param parent parent widget
+     * @param name name of the widget
+     */
+    KNumInput(KNumInput* below, TQWidget* parent=0, const char* name=0);
+    ~KNumInput();
+
+    /**
+     * Sets the text and tqalignment of the main description label.
+     *
+     * @param label The text of the label.
+     *              Use TQString::null to remove an existing one.
+     *
+     * @param a one of @p AlignLeft, @p AlignHCenter, YAlignRight and
+     *          @p AlignTop, @p AlignVCenter, @p AlignBottom.
+     *          default is @p AlignLeft | @p AlignTop.
+     *
+     * The vertical tqalignment flags have special meaning with this
+     * widget:
+     *
+     *     @li @p AlignTop     The label is placed above the edit/slider
+     *     @li @p AlignVCenter The label is placed left beside the edit
+     *     @li @p AlignBottom  The label is placed below the edit/slider
+     *
+     */
+    virtual void setLabel(const TQString & label, int a = AlignLeft | AlignTop);
+
+    /**
+     * @return the text of the label.
+     */
+    TQString label() const;
+
+    /**
+     * @return if the num input has a slider.
+     * @since 3.1
+     */
+    bool showSlider() const { return m_slider; }
+
+    /**
+     * Sets the spacing of tickmarks for the slider.
+     *
+     * @param minor Minor tickmark separation.
+     * @param major Major tickmark separation.
+     */
+    void setSteps(int minor, int major);
+
+    /**
+     * Specifies that this widget may stretch horizontally, but is
+     * fixed vertically (like TQSpinBox itself).
+     */
+    TQSizePolicy sizePolicy() const;
+
+    /**
+     * Returns a size which fits the contents of the control.
+     *
+     * @return the preferred size necessary to show the control
+     */
+    virtual TQSize tqsizeHint() const;
+
+protected:
+    /**
+     * Call this function whenever you change something in the geometry
+     * of your KNumInput child.
+     *
+     */
+    void layout(bool deep);
+
+    /**
+     * You need to overwrite this method and implement your layout
+     * calculations there.
+     *
+     * See KIntNumInput::doLayout and KDoubleNumInput::doLayout implementation
+     * for details.
+     *
+     */
+    virtual void doLayout() = 0;
+
+    KNumInput* m_prev, *m_next;
+    int m_colw1, m_colw2;
+
+    TQLabel*  m_label;
+    TQSlider* m_slider;
+    TQSize    m_sizeSlider, m_sizeLabel;
+
+    int      m_tqalignment;
+
+private:
+    void init();
+
+protected:
+    virtual void virtual_hook( int id, void* data );
+private:
+    class KNumInputPrivate;
+    KNumInputPrivate *d;
+};
+
+/* ------------------------------------------------------------------------ */
+
+/**
+ * @short An input widget for integer numbers, consisting of a spinbox and a slider.
+ *
+ * KIntNumInput combines a TQSpinBox and optionally a QSlider
+ * with a label to make an easy to use control for setting some integer
+ * parameter. This is especially nice for configuration dialogs,
+ * which can have many such combinated controls.
+ *
+ * The slider is created only when the user specifies a range
+ * for the control using the setRange function with the slider
+ * parameter set to "true".
+ *
+ * A special feature of KIntNumInput, designed specifically for
+ * the situation when there are several KIntNumInputs in a column,
+ * is that you can specify what portion of the control is taken by the
+ * TQSpinBox (the remaining portion is used by the slider). This makes
+ * it very simple to have all the sliders in a column be the same size.
+ *
+ * It uses KIntValidator validator class. KIntNumInput enforces the
+ * value to be in the given range, and can display it in any base
+ * between 2 and 36.
+ *
+ * \image html kintnuminput.png "KDE Int Number Input Spinbox"
+ *
+ * @version $Id$
+ */
+
+class KDEUI_EXPORT KIntNumInput : public KNumInput
+{
+    Q_OBJECT
+    TQ_OBJECT
+    Q_PROPERTY( int value READ value WRITE setValue )
+    Q_PROPERTY( int minValue READ minValue WRITE setMinValue )
+    Q_PROPERTY( int maxValue READ maxValue WRITE setMaxValue )
+    Q_PROPERTY( int referencePoint READ referencePoint WRITE setReferencePoint )
+    Q_PROPERTY( double relativeValue READ relativeValue WRITE setRelativeValue )
+    Q_PROPERTY( TQString suffix READ suffix WRITE setSuffix )
+    Q_PROPERTY( TQString prefix READ prefix WRITE setPrefix )
+    Q_PROPERTY( TQString specialValueText READ specialValueText WRITE setSpecialValueText )
+
+public:
+    /**
+     * Constructs an input control for integer values
+     * with base 10 and initial value 0.
+     */
+    KIntNumInput(TQWidget *parent=0, const char *name=0);
+    /**
+     * Constructor
+     * It constructs a TQSpinBox that allows the input of integer numbers
+     * in the range of -INT_MAX to +INT_MAX. To set a descriptive label,
+     * use setLabel(). To enforce the value being in a range and optionally to
+     * attach a slider to it, use setRange().
+     *
+     * @param value  initial value for the control
+     * @param base   numeric base used for display
+     * @param parent parent QWidget
+     * @param name   internal name for this widget
+     */
+    KIntNumInput(int value, TQWidget* parent=0, int base = 10, const char *name=0);
+
+    /**
+     * Constructor
+     *
+     * the difference to the one above is the "below" parameter. It tells
+     * this instance that it is visually put below some other KNumInput widget.
+     * Note that these two KNumInput's need not to have the same parent widget
+     * or be in the same layout group.
+     * The effect is that it'll adjust it's layout in correspondence
+     * with the layout of the other KNumInput's (you can build an arbitrary long
+     * chain).
+     *
+     * @param below  append KIntNumInput to the KNumInput chain
+     * @param value  initial value for the control
+     * @param base   numeric base used for display
+     * @param parent parent QWidget
+     * @param name   internal name for this widget
+     */
+    KIntNumInput(KNumInput* below, int value, TQWidget* parent=0, int base = 10, const char *name=0);
+
+    /**
+     * Destructor
+     *
+     *
+     */
+    virtual ~KIntNumInput();
+
+    /**
+     * @return the current value.
+     */
+    int value() const;
+
+    /**
+     * @return the curent value in units of the referencePoint.
+     * @since 3.1
+     */
+    double relativeValue() const;
+
+    /**
+     * @return the current reference point
+     * @since 3.1
+     */
+    int referencePoint() const;
+
+    /**
+     * @return the suffix displayed behind the value.
+     * @see setSuffix()
+     */
+    TQString suffix() const;
+    /**
+     * @return the prefix displayed in front of the value.
+     * @see setPrefix()
+     */
+    TQString prefix() const;
+    /**
+     * @return the string displayed for a special value.
+     * @see setSpecialValueText()
+     */
+    TQString specialValueText() const;
+
+    /**
+     * @param min  minimum value
+     * @param max  maximum value
+     * @param step step size for the QSlider
+     * @param slider whether the slider is created or not
+     */
+    void setRange(int min, int max, int step=1, bool slider=true);
+    /**
+     * Sets the minimum value.
+     */
+    void setMinValue(int min);
+    /**
+     * @return the minimum value.
+     */
+    int minValue() const;
+    /**
+     * Sets the maximum value.
+     */
+    void setMaxValue(int max);
+    /**
+     * @return the maximum value.
+     */
+    int maxValue() const;
+
+    /**
+     * Sets the special value text. If set, the SpinBox will display
+     * this text instead of the numeric value whenever the current
+     * value is equal to minVal(). Typically this is used for indicating
+     * that the choice has a special (default) meaning.
+     */
+    void setSpecialValueText(const TQString& text);
+
+    virtual void setLabel(const TQString & label, int a = AlignLeft | AlignTop);
+
+    /**
+     * This method returns the minimum size necessary to display the
+     * control. The minimum size is enough to show all the labels
+     * in the current font (font change may tqinvalidate the return value).
+     *
+     * @return the minimum size necessary to show the control
+     */
+    virtual TQSize tqminimumSizeHint() const;
+
+public slots:
+    /**
+     * Sets the value of the control.
+     */
+    void setValue(int);
+
+    /**
+     * Sets the value in units of the referencePoint
+     * @since 3.1
+     */
+    void setRelativeValue(double);
+
+    /**
+     * Sets the reference point for relativeValue.
+     * @since 3.1
+     */
+    void setReferencePoint(int);
+
+    /**
+     * Sets the suffix to @p suffix.
+     * Use TQString::null to disable this feature.
+     * Formatting has to be provided (e.g. a space separator between the
+     * prepended @p value and the suffix's text has to be provided
+     * as the first character in the suffix).
+     *
+     * @see TQSpinBox::setSuffix(), #setPrefix()
+     */
+    void setSuffix(const TQString &suffix);
+
+    /**
+     * Sets the prefix to @p prefix.
+     * Use TQString::null to disable this feature.
+     * Formatting has to be provided (see above).
+     *
+     * @see TQSpinBox::setPrefix(), #setSuffix()
+     */
+    void setPrefix(const TQString &prefix);
+
+    /**
+     * sets focus to the edit widget and marks all text in if mark == true
+     *
+     */
+    void setEditFocus( bool mark = true );
+
+signals:
+    /**
+     * Emitted every time the value changes (by calling setValue() or
+     * by user interaction).
+     */
+    void valueChanged(int);
+
+    /**
+     * Emitted whenever valueChanged is. Contains the change
+     * relative to the referencePoint.
+     * @since 3.1
+     */
+    void relativeValueChanged(double);
+
+private slots:
+    void spinValueChanged(int);
+    void slotEmitRelativeValueChanged(int);
+
+protected:
+    virtual void doLayout();
+    void resizeEvent ( TQResizeEvent * );
+
+    KIntSpinBox* m_spin;
+    TQSize        m_sizeSpin;
+
+private:
+    void init(int value, int _base);
+
+protected:
+    virtual void virtual_hook( int id, void* data );
+private:
+    class KIntNumInputPrivate;
+    KIntNumInputPrivate *d;
+};
+
+
+/* ------------------------------------------------------------------------ */
+
+class KDoubleLine;
+
+/**
+ * @short An input control for real numbers, consisting of a spinbox and a slider.
+ *
+ * KDoubleNumInput combines a TQSpinBox and optionally a QSlider
+ * with a label to make an easy to use control for setting some float
+ * parameter. This is especially nice for configuration dialogs,
+ * which can have many such combinated controls.
+ *
+ * The slider is created only when the user specifies a range
+ * for the control using the setRange function with the slider
+ * parameter set to "true".
+ *
+ * A special feature of KDoubleNumInput, designed specifically for
+ * the situation when there are several instances in a column,
+ * is that you can specify what portion of the control is taken by the
+ * TQSpinBox (the remaining portion is used by the slider). This makes
+ * it very simple to have all the sliders in a column be the same size.
+ *
+ * It uses the KDoubleValidator validator class. KDoubleNumInput
+ * enforces the value to be in the given range, but see the class
+ * documentation of KDoubleSpinBox for the tricky
+ * interrelationship of precision and values. All of what is said
+ * there applies here, too.
+ *
+ * @see KIntNumInput, KDoubleSpinBox
+ */
+
+class KDEUI_EXPORT KDoubleNumInput : public KNumInput
+{
+    Q_OBJECT
+    TQ_OBJECT
+    Q_PROPERTY( double value READ value WRITE setValue )
+    Q_PROPERTY( double minValue READ minValue WRITE setMinValue )
+    Q_PROPERTY( double maxValue READ maxValue WRITE setMaxValue )
+    Q_PROPERTY( TQString suffix READ suffix WRITE setSuffix )
+    Q_PROPERTY( TQString prefix READ prefix WRITE setPrefix )
+    Q_PROPERTY( TQString specialValueText READ specialValueText WRITE setSpecialValueText )
+    Q_PROPERTY( int precision READ precision WRITE setPrecision )
+    Q_PROPERTY( double referencePoint READ referencePoint WRITE setReferencePoint )
+    Q_PROPERTY( double relativeValue READ relativeValue  WRITE setRelativeValue )
+
+public:
+    /**
+     * Constructs an input control for double values
+     * with initial value 0.00.
+     */
+    KDoubleNumInput(TQWidget *parent=0, const char *name=0);
+
+    /**
+     * @deprecated (value is rounded to a multiple of 1/100)
+     * Constructor
+     *
+     * @param value  initial value for the control
+     * @param parent parent QWidget
+     * @param name   internal name for this widget
+     */
+    KDoubleNumInput(double value, TQWidget *parent=0, const char *name=0) KDE_DEPRECATED;
+
+    /**
+     * Constructor
+     *
+     * @param lower lower boundary value
+     * @param upper upper boundary value
+     * @param value  initial value for the control
+     * @param step   step size to use for up/down arrow clicks
+     * @param precision number of digits after the decimal point
+     * @param parent parent QWidget
+     * @param name   internal name for this widget
+     * @since 3.1
+     */
+    KDoubleNumInput(double lower, double upper, double value, double step=0.01,
+		    int precision=2, TQWidget *parent=0, const char *name=0);
+
+    /**
+     * destructor
+     */
+    virtual ~KDoubleNumInput();
+
+    /**
+     * @deprecated (rounds @p value to a multiple of 1/100)
+     * Constructor
+     *
+     * puts it visually below other KNumInput
+     *
+     * @param  below
+     * @param  value  initial value for the control
+     * @param  parent parent QWidget
+     * @param  name   internal name for this widget
+     **/
+    KDoubleNumInput(KNumInput* below, double value, TQWidget* parent=0, const char* name=0) KDE_DEPRECATED;
+
+    /**
+     * Constructor
+     *
+     * the difference here is the "below" parameter. It tells this
+     * instance that it is visually put below some other KNumInput
+     * widget.  Note that these two KNumInput's need not to have the
+     * same parent widget or be in the same layout group.  The effect
+     * is that it'll adjust it's layout in correspondence with the
+     * layout of the other KNumInput's (you can build an arbitrary long
+     * chain).
+     *
+     * @param below  append KDoubleNumInput to the KDoubleNumInput chain
+     * @param lower lower boundary value
+     * @param upper upper boundary value
+     * @param value  initial value for the control
+     * @param step   step size to use for up/down arrow clicks
+     * @param precision number of digits after the decimal point
+     * @param parent parent QWidget
+     * @param name   internal name for this widget
+     * @since 3.1
+     */
+    KDoubleNumInput(KNumInput* below,
+		    double lower, double upper, double value, double step=0.02,
+		    int precision=2, TQWidget *parent=0, const char *name=0);
+
+    /**
+     * @return the current value.
+     */
+    double value() const;
+
+    /**
+     * @return the suffix.
+     * @see setSuffix()
+     */
+    TQString suffix() const;
+
+    /**
+     * @return the prefix.
+     * @see setPrefix()
+     */
+    TQString prefix() const;
+
+    /**
+     * @return the precision.
+     * @see setPrecision()
+     */
+    int precision() const;
+
+    /**
+     * @return the string displayed for a special value.
+     * @see setSpecialValueText()
+     */
+    TQString specialValueText() const { return m_specialvalue; }
+
+     /**
+     * @param min  minimum value
+     * @param max  maximum value
+     * @param step step size for the QSlider
+     * @param slider whether the slider is created or not
+     */
+    void setRange(double min, double max, double step=1, bool slider=true);
+    /**
+     * Sets the minimum value.
+     */
+    void setMinValue(double min);
+    /**
+     * @return the minimum value.
+     */
+    double minValue() const;
+    /**
+     * Sets the maximum value.
+     */
+    void setMaxValue(double max);
+    /**
+     * @return the maximum value.
+     */
+    double maxValue() const;
+
+    /**
+     * Specifies the number of digits to use.
+     */
+    void setPrecision(int precision);
+
+    /**
+     * @return the reference point for relativeValue calculation
+     * @since 3.1
+     */
+    double referencePoint() const;
+
+    /**
+     * @return the current value in units of referencePoint.
+     * @since 3.1
+     */
+    double relativeValue() const;
+
+    /**
+     * Sets the special value text. If set, the spin box will display
+     * this text instead of the numeric value whenever the current
+     * value is equal to minVal(). Typically this is used for indicating
+     * that the choice has a special (default) meaning.
+     */
+    void setSpecialValueText(const TQString& text);
+
+    virtual void setLabel(const TQString & label, int a = AlignLeft | AlignTop);
+    virtual TQSize tqminimumSizeHint() const;
+    virtual bool eventFilter(TQObject*, TQEvent*);
+
+public slots:
+    /**
+     * Sets the value of the control.
+     */
+    void setValue(double);
+
+    /**
+     * Sets the value in units of referencePoint.
+     * @since 3.1
+     */
+    void setRelativeValue(double);
+
+    /**
+     * Sets the reference Point to @p ref. It @p ref == 0, emitting of
+     * relativeValueChanged is blocked and relativeValue
+     * just returns 0.
+     * @since 3.1
+     */
+    void setReferencePoint(double ref);
+
+    /**
+     * Sets the suffix to be displayed to @p suffix. Use TQString::null to disable
+     * this feature. Note that the suffix is attached to the value without any
+     * spacing. So if you prefer to display a space separator, set suffix
+     * to something like " cm".
+     * @see setSuffix()
+     */
+    void setSuffix(const TQString &suffix);
+
+    /**
+     * Sets the prefix to be displayed to @p prefix. Use TQString::null to disable
+     * this feature. Note that the prefix is attached to the value without any
+     * spacing.
+     * @see setPrefix()
+     */
+    void setPrefix(const TQString &prefix);
+
+signals:
+    /**
+     * Emitted every time the value changes (by calling setValue() or
+     * by user interaction).
+     */
+    void valueChanged(double);
+    /**
+     * This is an overloaded member function, provided for
+     * convenience. It essentially behaves like the above function.
+     *
+     * Contains the value in units of referencePoint.
+     * @since 3.1
+     */
+    void relativeValueChanged(double);
+
+private slots:
+    void sliderMoved(int);
+    void slotEmitRelativeValueChanged(double);
+
+protected:
+    virtual void doLayout();
+    void resizeEvent ( TQResizeEvent * );
+
+    virtual void resetEditBox();
+
+    // ### no longer used, remove when BIC allowed
+    KDoubleLine*   edit;
+
+    bool     m_range;
+    double   m_lower, m_upper, m_step;
+    // ### end no longer used
+
+    TQSize    m_sizeEdit;
+
+    friend class KDoubleLine;
+private:
+    void init(double value, double lower, double upper,
+	      double step, int precision);
+    double mapSliderToSpin(int) const;
+    void updateLegacyMembers();
+    // ### no longer used, remove when BIC allowed:
+    TQString  m_specialvalue, m_prefix, m_suffix;
+    double   m_value;
+    short    m_precision;
+    // ### end remove when BIC allowed
+
+protected:
+    virtual void virtual_hook( int id, void* data );
+private:
+    class KDoubleNumInputPrivate;
+    KDoubleNumInputPrivate *d;
+};
+
+
+/* ------------------------------------------------------------------------ */
+
+/**
+ *  @short A TQSpinBox with support for arbitrary base numbers.
+ *
+ *  A TQSpinBox with support for arbitrary base numbers
+ *  (e.g. hexadecimal).
+ *
+ *  The class provides an easy interface to use other
+ *  numeric systems than the decimal.
+ */
+class KDEUI_EXPORT KIntSpinBox : public TQSpinBox
+{
+    Q_OBJECT
+    TQ_OBJECT
+    Q_PROPERTY( int base READ base WRITE setBase )
+
+public:
+
+    /**
+     *  Constructor.
+     *
+     *  Constructs a widget with an integer inputline with a little scrollbar
+     *  and a slider, with minimal value 0, maximal value 99, step 1, base 10
+     *  and initial value 0.
+     */
+    KIntSpinBox( TQWidget *parent=0, const char *name=0);
+
+    /**
+     *  Constructor.
+     *
+     *  Constructs a widget with an integer inputline with a little scrollbar
+     *  and a slider.
+     *
+     *  @param lower  The lowest valid value.
+     *  @param upper  The greatest valid value.
+     *  @param step   The step size of the scrollbar.
+     *  @param value  The actual value.
+     *  @param base   The base of the used number system.
+     *  @param parent The parent of the widget.
+     *  @param name   The Name of the widget.
+     */
+    KIntSpinBox(int lower, int upper, int step, int value, int base = 10,
+                TQWidget* parent = 0, const char* name = 0);
+
+    /**
+     *  Destructor.
+     */
+    virtual ~KIntSpinBox();
+
+    /**
+     * Sets the base in which the numbers in the spin box are represented.
+     */
+    void setBase(int base);
+    /**
+     * @return the base in which numbers in the spin box are represented.
+     */
+    int base() const;
+    /**
+     * sets focus and optionally marks all text
+     *
+     */
+    void setEditFocus(bool mark);
+
+protected:
+
+    /**
+     *  Overloaded the method in QSpinBox
+     *  to make use of the base given in the constructor.
+     */
+    virtual TQString mapValueToText(int);
+
+    /**
+     *  Overloaded the method in QSpinBox
+     *  to make use of the base given in the constructor.
+     */
+    virtual int mapTextToValue(bool*);
+
+private:
+    int val_base;
+protected:
+    virtual void virtual_hook( int id, void* data );
+private:
+    class KIntSpinBoxPrivate;
+    KIntSpinBoxPrivate *d;
+};
+
+
+/* --------------------------------------------------------------------------- */
+
+/**
+   @short A spin box for fractional numbers.
+
+   This class provides a spin box for fractional numbers.
+
+   \image html kdoublespinbox.png "KDE Fractional Number Spinbox"
+
+   See below for code examples on how to use this class.
+
+   \b Parameters \n
+
+   To make successful use of KDoubleSpinBox, you need to understand the
+   relationship between precision and available range.
+
+   @li precision: The number of digits after the decimal point.
+   @li maxValue/minValue: upper and lower bounds of the valid range
+   @li lineStep: the size of the step that is made when the user hits
+                 the up or down buttons
+
+   Since we work with fixed-point numbers internally, the maximum
+   precision is a function of the valid range and vice versa. More
+   precisely, the following relationships hold:
+   \code
+   max( abs(minValue()), abs(maxValue() ) <= INT_MAX/10^precision
+   maxPrecision = floor( log10( INT_MAX/max(abs(minValue()),abs(maxValue())) ) )
+   \endcode
+
+   Since the value, bounds and lineStep are rounded to the current
+   precision, you may find that the order of setting these
+   parameters matters. As an example, the following are @em not equivalent (try
+   it!):
+
+   \code
+   // sets precision,
+   // then min/max value (rounded to precision and clipped to obtainable range if needed)
+   // then value and lineStep
+   KDoubleSpinBox * spin = new KDoubleSpinBox( 0, 9.999, 0.001, 4.321, 3, this );
+
+   // sets minValue to 0; maxValue to 10.00(!); value to 4.32(!) and only then
+   // increases the precision - too late, since e.g. value has already been rounded...
+   KDoubleSpinBox * spin = new KDoubleSpinBox( this );
+   spin->setMinValue( 0 );
+   spin->setMaxValue( 9.999 );
+   spin->setValue( 4.321 );
+   spin->setPrecision( 3 );
+   \endcode
+
+   @author Marc Mutz <mutz@kde.org>
+   @version $Id$
+   @since 3.1
+**/
+
+class KDEUI_EXPORT KDoubleSpinBox : public TQSpinBox {
+  Q_OBJECT
+  TQ_OBJECT
+  Q_PROPERTY( bool acceptLocalizedNumbers READ acceptLocalizedNumbers WRITE setAcceptLocalizedNumbers )
+  Q_OVERRIDE( double maxValue READ maxValue WRITE setMaxValue )
+  Q_OVERRIDE( double minValue READ minValue WRITE setMinValue )
+  Q_OVERRIDE( double lineStep READ lineStep WRITE setLineStep )
+  Q_OVERRIDE( double value READ value WRITE setValue )
+  Q_PROPERTY( int precision READ precision WRITE setPrecision )
+
+public:
+  /** Constructs a KDoubleSpinBox with parent @p parent and
+      default values for range and value (whatever QRangeControl
+      uses) and precision (2). */
+  KDoubleSpinBox( TQWidget * parent=0, const char * name=0 );
+
+  /** Constructs a KDoubleSpinBox with parent @p parent, range
+      [ @p lower, @p upper ], lineStep @p step, precision @p
+      precision and initial value @p value. */
+  KDoubleSpinBox( double lower, double upper, double step, double value,
+		  int precision=2, TQWidget * parent=0, const char * name=0 );
+
+  virtual ~KDoubleSpinBox();
+
+  /** @return whether the spinbox uses localized numbers */
+  bool acceptLocalizedNumbers() const;
+
+  /** Sets whether to use and accept localized numbers as returned by
+      KLocale::formatNumber() */
+  virtual void setAcceptLocalizedNumbers( bool accept );
+
+  /** Sets a new range for the spin box values. Note that @p lower, @p
+      upper and @p step are rounded to @p precision decimal points
+      first. */
+  void setRange( double lower, double upper, double step=0.01, int precision=2 );
+
+  /** @return the current number of digits displayed to the right of the
+      decimal point. */
+  int precision() const;
+
+  /** Equivalent to setPrecision( @p precision, @p false ); Needed
+      since Qt's tqmoc doesn't ignore trailing parameters with default
+      args when searching for a property setter method. */
+  void setPrecision( int precision );
+
+  /** Sets the precision (number of digits to the right of the decimal point). Note
+      that there is a tradeoff between the precision used and the available range of
+      values. See the class documentation above for more information on this.
+
+      @param precision the new precision to use
+
+      @param force if true, disables checking of bounds violations that can
+             arise if you increase the precision so much that the
+             minimum and maximum values can't be represented
+             anymore. Disabling is useful if you were going to disable range
+             control in any case.
+  **/
+  virtual void setPrecision( int precision, bool force );
+
+  /** @return the current value */
+  double value() const;
+
+  /** @return the current lower bound */
+  double minValue() const;
+
+  /** Sets the lower bound of the range to @p value, subject to the
+      contraints that @p value is first rounded to the current
+      precision and then clipped to the maximum range interval that can
+      be handled at that precision.
+      @see maxValue, minValue, setMaxValue, setRange
+  */
+  void setMinValue( double value );
+
+  /** @return the current upper bound */
+  double maxValue() const;
+
+  /** Sets the upper bound of the range to @p value, subject to the
+      contraints that @p value is first rounded to the current
+      precision and then clipped to the maximum range interval
+      that can be handled at that precision.
+      @see minValue, maxValue, setMinValue, setRange
+  */
+  void setMaxValue( double value );
+
+  /** @return the current step size */
+  double lineStep() const;
+
+  /** Sets the step size for clicking the up/down buttons to @p step,
+      subject to the constraints that @p step is first rounded to the
+      current precision and then clipped to the meaningful interval
+      [ 1, @p maxValue() - @p minValue() ]. */
+  void setLineStep( double step );
+
+  /** Overridden to ignore any setValidator() calls. */
+  void setValidator( const TQValidator * );
+
+signals:
+  /** Emitted whenever TQSpinBox::valueChanged( int ) is emitted. */
+  void valueChanged( double value );
+
+public slots:
+  /** Sets the current value to @p value, subject to the constraints
+      that @p value is first rounded to the current precision and then
+      clipped to the interval [ @p minValue() , @p maxValue() ]. */
+  virtual void setValue( double value );
+
+protected:
+  virtual TQString mapValueToText(int);
+  virtual int mapTextToValue(bool*);
+
+protected slots:
+  void slotValueChanged( int value );
+
+protected:
+ virtual void virtual_hook( int id, void* data );
+private:
+  typedef TQSpinBox base;
+  void updateValidator();
+  int maxPrecision() const;
+
+  class Private;
+  Private * d;
+};
+
+#endif // K_NUMINPUT_H