knuminput.h

/*
 * 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 <tdelibs_export.h>
 
class TQLabel;
class TQSlider;
class TQLineEdit;
class TQLayout;
class TQValidator;
 
class KIntSpinBox;
 
/* ------------------------------------------------------------------------ */

class TDEUI_EXPORT KNumInput : public TQWidget
{
    TQ_OBJECT
    
    TQ_PROPERTY( TQString label READ label WRITE setLabel )
public:
    KNumInput(TQWidget* parent=0, const char* name=0);

    KNumInput(KNumInput* below, TQWidget* parent=0, const char* name=0);
    ~KNumInput();

    virtual void setLabel(const TQString & label, int a = AlignLeft | AlignTop);

    TQString label() const;

    bool showSlider() const { return m_slider; }

    void setSteps(int minor, int major);

    TQSizePolicy sizePolicy() const;

    virtual TQSize sizeHint() const;
 
protected:
    void layout(bool deep);

    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_alignment;
 
private:
    void init();
 
protected:
    virtual void virtual_hook( int id, void* data );
private:
    class KNumInputPrivate;
    KNumInputPrivate *d;
};
 
/* ------------------------------------------------------------------------ */

 
class TDEUI_EXPORT KIntNumInput : public KNumInput
{
    TQ_OBJECT
    
    TQ_PROPERTY( int value READ value WRITE setValue )
    TQ_PROPERTY( int minValue READ minValue WRITE setMinValue )
    TQ_PROPERTY( int maxValue READ maxValue WRITE setMaxValue )
    TQ_PROPERTY( int referencePoint READ referencePoint WRITE setReferencePoint )
    TQ_PROPERTY( double relativeValue READ relativeValue WRITE setRelativeValue )
    TQ_PROPERTY( TQString suffix READ suffix WRITE setSuffix )
    TQ_PROPERTY( TQString prefix READ prefix WRITE setPrefix )
    TQ_PROPERTY( TQString specialValueText READ specialValueText WRITE setSpecialValueText )
 
public:
    KIntNumInput(TQWidget *parent=0, const char *name=0);
    KIntNumInput(int value, TQWidget* parent=0, int base = 10, const char *name=0);

    KIntNumInput(KNumInput* below, int value, TQWidget* parent=0, int base = 10, const char *name=0);

    virtual ~KIntNumInput();

    int value() const;

    double relativeValue() const;

    int referencePoint() const;

    TQString suffix() const;
    TQString prefix() const;
    TQString specialValueText() const;

    void setRange(int min, int max, int step=1, bool slider=true);
    void setMinValue(int min);
    int minValue() const;
    void setMaxValue(int max);
    int maxValue() const;

    void setSpecialValueText(const TQString& text);
 
    virtual void setLabel(const TQString & label, int a = AlignLeft | AlignTop);

    virtual TQSize minimumSizeHint() const;
 
public slots:
    void setValue(int);

    void setRelativeValue(double);

    void setReferencePoint(int);

    void setSuffix(const TQString &suffix);

    void setPrefix(const TQString &prefix);

    void setEditFocus( bool mark = true );
 
signals:
    void valueChanged(int);

    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;

 
class TDEUI_EXPORT KDoubleNumInput : public KNumInput
{
    TQ_OBJECT
    
    TQ_PROPERTY( double value READ value WRITE setValue )
    TQ_PROPERTY( double minValue READ minValue WRITE setMinValue )
    TQ_PROPERTY( double maxValue READ maxValue WRITE setMaxValue )
    TQ_PROPERTY( TQString suffix READ suffix WRITE setSuffix )
    TQ_PROPERTY( TQString prefix READ prefix WRITE setPrefix )
    TQ_PROPERTY( TQString specialValueText READ specialValueText WRITE setSpecialValueText )
    TQ_PROPERTY( int precision READ precision WRITE setPrecision )
    TQ_PROPERTY( double referencePoint READ referencePoint WRITE setReferencePoint )
    TQ_PROPERTY( double relativeValue READ relativeValue  WRITE setRelativeValue )
 
public:
    KDoubleNumInput(TQWidget *parent=0, const char *name=0);

    KDoubleNumInput(double value, TQWidget *parent=0, const char *name=0) TDE_DEPRECATED;

    KDoubleNumInput(double lower, double upper, double value, double step=0.01,
            int precision=2, TQWidget *parent=0, const char *name=0);

    virtual ~KDoubleNumInput();

    KDoubleNumInput(KNumInput* below, double value, TQWidget* parent=0, const char* name=0) TDE_DEPRECATED;

    KDoubleNumInput(KNumInput* below,
            double lower, double upper, double value, double step=0.02,
            int precision=2, TQWidget *parent=0, const char *name=0);

    double value() const;

    TQString suffix() const;

    TQString prefix() const;

    int precision() const;

    TQString specialValueText() const { return m_specialvalue; }

    void setRange(double min, double max, double step=1, bool slider=true);
    void setMinValue(double min);
    double minValue() const;
    void setMaxValue(double max);
    double maxValue() const;

    void setPrecision(int precision);

    double referencePoint() const;

    double relativeValue() const;

    void setSpecialValueText(const TQString& text);
 
    virtual void setLabel(const TQString & label, int a = AlignLeft | AlignTop);
    virtual TQSize minimumSizeHint() const;
    virtual bool eventFilter(TQObject*, TQEvent*);
 
public slots:
    void setValue(double);

    void setRelativeValue(double);

    void setReferencePoint(double ref);

    void setSuffix(const TQString &suffix);

    void setPrefix(const TQString &prefix);
 
signals:
    void valueChanged(double);
    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;
};
 
 
/* ------------------------------------------------------------------------ */

class TDEUI_EXPORT KIntSpinBox : public TQSpinBox
{
    TQ_OBJECT
    
    TQ_PROPERTY( int base READ base WRITE setBase )
 
public:

    KIntSpinBox( TQWidget *parent=0, const char *name=0);

    KIntSpinBox(int lower, int upper, int step, int value, int base = 10,
                TQWidget* parent = 0, const char* name = 0);

    virtual ~KIntSpinBox();

    void setBase(int base);
    int base() const;
    void setEditFocus(bool mark);
 
protected:

    virtual TQString mapValueToText(int);

    virtual int mapTextToValue(bool*);
 
private:
    int val_base;
protected:
    virtual void virtual_hook( int id, void* data );
private:
    class KIntSpinBoxPrivate;
    KIntSpinBoxPrivate *d;
};
 
 
/* --------------------------------------------------------------------------- */

 
class TDEUI_EXPORT KDoubleSpinBox : public TQSpinBox {
  TQ_OBJECT
  
  TQ_PROPERTY( bool acceptLocalizedNumbers READ acceptLocalizedNumbers WRITE setAcceptLocalizedNumbers )
  TQ_OVERRIDE( double maxValue READ maxValue WRITE setMaxValue )
  TQ_OVERRIDE( double minValue READ minValue WRITE setMinValue )
  TQ_OVERRIDE( double lineStep READ lineStep WRITE setLineStep )
  TQ_OVERRIDE( double value READ value WRITE setValue )
  TQ_PROPERTY( int precision READ precision WRITE setPrecision )
 
public:
  KDoubleSpinBox( TQWidget * parent=0, const char * name=0 );

  KDoubleSpinBox( double lower, double upper, double step, double value,
          int precision=2, TQWidget * parent=0, const char * name=0 );
 
  virtual ~KDoubleSpinBox();

  bool acceptLocalizedNumbers() const;

  virtual void setAcceptLocalizedNumbers( bool accept );

  void setRange( double lower, double upper, double step=0.01, int precision=2 );

  int precision() const;

  void setPrecision( int precision );

  virtual void setPrecision( int precision, bool force );

  double value() const;

  double minValue() const;

  void setMinValue( double value );

  double maxValue() const;

  void setMaxValue( double value );

  double lineStep() const;

  void setLineStep( double step );

  void setValidator( const TQValidator * );
 
signals:
  void valueChanged( double value );
 
public slots:
  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