K:/git-itom/sources/itom/itomWidgets/rangeWidget.h

/* ********************************************************************
    itom software
    URL: http://www.uni-stuttgart.de/ito
    Copyright (C) 2016, Institut fuer Technische Optik (ITO),
    Universitaet Stuttgart, Germany

    This file is part of itom and its software development toolkit (SDK).

    itom is free software; you can redistribute it and/or modify it
    under the terms of the GNU Library General Public Licence as published by
    the Free Software Foundation; either version 2 of the Licence, or (at
    your option) any later version.
   
    In addition, as a special exception, the Institut fuer Technische
    Optik (ITO) gives you certain additional rights.
    These rights are described in the ITO LGPL Exception version 1.0,
    which can be found in the file LGPL_EXCEPTION.txt in this package.

    itom 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 Licence for more details.

    You should have received a copy of the GNU Library General Public License
    along with itom. If not, see <http://www.gnu.org/licenses/>.

    This file is a port and modified version of the 
    Common framework (http://www.commontk.org)
*********************************************************************** */

#ifndef RANGEWIDGET_H
#define RANGEWIDGET_H

// Qt includes
#include <QSlider>


#include "commonWidgets.h"

class RangeSlider;
class QSpinBox;
class RangeWidgetPrivate;

namespace ito {
    class IntervalMeta; //forward declaration
}

class ITOMWIDGETS_EXPORT RangeWidget : public QWidget
{
  Q_OBJECT
  Q_PROPERTY(int singleStep READ singleStep WRITE setSingleStep)
  Q_PROPERTY(int minimum READ minimum WRITE setMinimum)
  Q_PROPERTY(int maximum READ maximum WRITE setMaximum)
  Q_PROPERTY(int minimumValue READ minimumValue WRITE setMinimumValue)
  Q_PROPERTY(int maximumValue READ maximumValue WRITE setMaximumValue)
  Q_PROPERTY(uint stepSizeValue READ stepSizeValue WRITE setStepSizeValue)
  Q_PROPERTY(uint minimumRange READ minimumRange WRITE setMinimumRange)
  Q_PROPERTY(uint maximumRange READ maximumRange WRITE setMaximumRange)
  Q_PROPERTY(uint stepSizeRange READ stepSizeRange WRITE setStepSizeRange)
  Q_PROPERTY(bool rangeIncludeLimits READ rangeIncludeLimits WRITE setRangeIncludeLimits)
  Q_PROPERTY(QString prefix READ prefix WRITE setPrefix)
  Q_PROPERTY(QString suffix READ suffix WRITE setSuffix)
  Q_PROPERTY(int tickInterval READ tickInterval WRITE setTickInterval)
  Q_PROPERTY(bool autoSpinBoxWidth READ isAutoSpinBoxWidth WRITE setAutoSpinBoxWidth)
  Q_PROPERTY(Qt::Alignment spinBoxTextAlignment READ spinBoxTextAlignment WRITE setSpinBoxTextAlignment)
  Q_PROPERTY(Qt::Alignment spinBoxAlignment READ spinBoxAlignment WRITE setSpinBoxAlignment)
  Q_PROPERTY(bool tracking READ hasTracking WRITE setTracking)
  Q_PROPERTY(bool symmetricMoves READ symmetricMoves WRITE setSymmetricMoves)

public:
  typedef QWidget Superclass;

  explicit RangeWidget(QWidget* parent = 0);
  
  virtual ~RangeWidget();

  virtual int minimum()const;
  virtual void setMinimum(int minimum);

  virtual int maximum()const;
  virtual void setMaximum(int maximum);
  virtual void setRange(int min, int max);
  virtual void range(int minimumAndMaximum[2])const;

  virtual int minimumValue()const;

  virtual int maximumValue()const;

  virtual void values(int &minValue, int &maxValue)const;

  virtual int singleStep()const;
  virtual void setSingleStep(int step);

  uint stepSizeValue() const;
  void setStepSizeValue(uint stepSize);
  
  uint minimumRange() const;
  void setMinimumRange(uint min);
  
  uint maximumRange() const;
  void setMaximumRange(uint max);
  
  uint stepSizeRange() const;
  void setStepSizeRange(uint stepSize);
  
  bool rangeIncludeLimits() const;
  void setRangeIncludeLimits(bool include);

  virtual QString prefix()const;
  virtual void setPrefix(const QString& prefix);

  virtual QString suffix()const;
  virtual void setSuffix(const QString& suffix);

  virtual int tickInterval()const;
  virtual void setTickInterval(int ti);

  virtual void setSpinBoxAlignment(Qt::Alignment alignment);
  virtual Qt::Alignment spinBoxAlignment()const;

  virtual void setSpinBoxTextAlignment(Qt::Alignment alignment);
  virtual Qt::Alignment spinBoxTextAlignment()const;

  virtual void setTracking(bool enable);
  virtual bool hasTracking()const;

  // RangeWidget siblings.
  virtual bool isAutoSpinBoxWidth()const;
  virtual void setAutoSpinBoxWidth(bool autoWidth);
  
  virtual bool symmetricMoves()const;
  virtual void setSymmetricMoves(bool symmetry);

  virtual RangeSlider* slider()const;
  virtual QSpinBox* minimumSpinBox()const;
  virtual QSpinBox* maximumSpinBox()const;

  void setLimitsFromIntervalMeta(const ito::IntervalMeta &intervalMeta);

public Q_SLOTS:
  virtual void reset();
  virtual void setMinimumValue(int value);
  virtual void setMaximumValue(int value);
  virtual void setValues(int minValue, int maxValue);

Q_SIGNALS:
  //void sliderMoved(int position);
  void minimumValueChanged(int value);
  void minimumValueIsChanging(int value);
  void maximumValueChanged(int value);
  void maximumValueIsChanging(int value);
  void valuesChanged(int minValue, int maxValue);
  void rangeChanged(int min, int max);

protected Q_SLOTS:
  virtual void startChanging();
  virtual void stopChanging();
  virtual void changeValues(int newMinValue, int newMaxValue);
  virtual void changeMinimumValue(int value);
  virtual void changeMaximumValue(int value);
  virtual void setSliderValues();
  virtual void setMinimumToMaximumSpinBox(int minimum);
  virtual void setMaximumToMinimumSpinBox(int maximum);
  virtual void onSliderRangeChanged(int min, int max);

protected:
  virtual bool eventFilter(QObject *obj, QEvent *event);

  void setSlider(RangeSlider* slider);

protected:
  QScopedPointer<RangeWidgetPrivate> d_ptr;

private:
  Q_DECLARE_PRIVATE(RangeWidget);
  Q_DISABLE_COPY(RangeWidget);

};

#endif