QtGuiEntry.qo.h

Go to the documentation of this file.

//# QtGuiEntry.qo.h: Individual interface elements for general-purpose
//#               Qt options widget (QtAutoGui).
//# Copyright (C) 2005
//# Associated Universities, Inc. Washington DC, USA.
//#
//# 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; if not, write to the Free Software Foundation,
//# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
//#
//# Correspondence concerning AIPS++ should be addressed as follows:
//#        Internet email: aips2-request@nrao.edu.
//#        Postal address: AIPS++ Project Office
//#                        National Radio Astronomy Observatory
//#                        520 Edgemont Road
//#                        Charlottesville, VA 22903-2475 USA
//#
//# $Id$

#ifndef QTGUIENTRY_H
#define QTGUIENTRY_H

#include <casa/aips.h>
#include <casa/BasicSL/String.h>
#include <casa/BasicMath/Math.h>

#include <graphics/X11/X_enter.h>
#  include <QDomDocument>
#  include <QCheckBox>
   //#dk Be careful to put ui_*.h within X_enter/exit bracket too,
   //#   because they'll have Qt includes.
   //#   E.g. <QApplication> needs the X11 definition of 'Display'
#  include "adjustmentBottom.ui.h"
#  include "sliderLabelItem.ui.h"
#  include "sliderEditorItem.ui.h"
#  include "lineEditorItem.ui.h"
#  include "comboItem.ui.h"
#  include "checkButtonItem.ui.h"
#  include "pushButtonItem.ui.h"
#  include "minMaxEditorItem.ui.h"
#  include "pairItem.ui.h"
#include <graphics/X11/X_exit.h>

#include <utility>

 
namespace casa { //# NAMESPACE CASA - BEGIN


class QtAutoGui;


//# ////////////////   QtAdjustmentBottom //////////////////////////////////

class QtAdjustmentTop : public QWidget, private Ui::AdjustmentBottom {
    Q_OBJECT
public:
    QtAdjustmentTop(QtAutoGui *parent=0, QString name="");
    void setText(QString txt) {dataName->setText(txt);}
    ~QtAdjustmentTop();
public slots:   
   void dataNameChanged(QString value); 
   void setOriginal();
   void setDefault();
   void setMemory();
   void setClear();
   void setCopy();
   void setPaste();    
   void apply();
   void load();
   void save();
   void restore();
   void close();
   
   void hideDismiss();          //#dk

private:
   QtAutoGui *parent; 
   bool blockSignal;
};


//# ///////////////////  QtSliderBase //////////////////////////////////////


// <summary>
// Base class for QtAutoGui slider interface elements.
// </summary>

// <synopsis>
// This is a base with common functionality for the two slider 'guientries':
// QtSliderEditor, which has a value edit box, and QtSliderLabel, with a
// non-editable value label.  This class is abstract; its constructor can only
// be called by a derived class.  That class should also call constructBase()
// after cxreating its interface elements, to complete construction.
// </synopsis>

class QtSliderBase : public QWidget {
  
  Q_OBJECT      //# Allows slot/signal definition.  Must only occur in
                //# implement/.../*.h files; also, makefile must include
                //# name of this file in 'mocs' section.
 
 public:
  
  // Set interface label text ('listname').
  void setLabelText(QString txt) { nameLabel_->setText(txt);  }
  
  // Internal name ('dlformat')
  QString name(){ return itemName; }

  // Set up main state (value, etc.) and external appearance of
  // this widget, according to options record (passed as a QDomElement).
  // Called via constructor, and from QtAutoGui::changeOptions().
  // Does not trigger (significant) signals; it is intended to set this
  // interface element to library's internal value (not vice versa).
  void reSet(QDomElement& ele);
 
 protected:

  // Only for use by derived classes.
  // <group>
  QtSliderBase(QWidget *parent=0) : QWidget(parent) {  }
  ~QtSliderBase() {  }
  // </group>
  
  // Derived class should call this within its constructor, after it
  // has a valid QSlider, name QLabel and menu QToolButton (usually,
  // after calling setUi()), passing them down in the parameters below.
  // ele is the QDomElement (an xml version of an option Record) used to
  // construct the derived class.
  void constructBase(QDomElement &ele,  QSlider* slider,
                     QLabel* nameLabel, QToolButton* menuBtn);

  // Fetch numeric value of attribute of ele named attnm, into val. 
  // Does nothing if attr doesn't exist or is not valid numerically.
  void getAttr(const QDomElement& ele, QString attnm, Double& val);

 protected slots:   
   
  // slider changed by user
  virtual void slChg(int slval) { update(externalVal(slval));
                                  if ( ! onrelease_ ) emitVal( ); }
  virtual void release( )       { if (   onrelease_ ) emitVal( ); }
  
  // 'revert-to-original' selected in menu.
  virtual void setOriginal();
   
 
 signals:
  
  // Main output signal.  Main parameters of interest are item name and
  // new value.
  void itemValueChanged(QString name, QString value, int action, bool apply);
  
  // class user may wish to connect to and display these.
  void errMsg(String errmsg);   

    
 protected: 
  
  // Derived class should implement: set value text box or label (if any)
  // to (normalized) current value.  (Should not trigger class's own slots).
  virtual void updateText() = 0;
    
  
  Int round(Double val) { return ifloor(val + .5);  }
  
  // Integer values with in [0, slMax_] on the internal slider are scaled
  // to external values within [dMin_, dMax_].
  // These two routines convert between the two scalings.
  // <group>
  Double externalVal(Int sldVal) {
    return min(dMax_, (dMin_ + max(0., dIncr_*sldVal)));  }
    
  Int sliderVal(Double extVal) {
    return round(max(0., min(slMax_, (extVal-dMin_)/dIncr_)));  }
  // </group>
  
  // These two routines convert 'external' values between Double and
  // text.
  // <group>
  QString toText(Double val);
  Double toNumber(QString text, bool* ok=0);
  // </group>
  
  // Current external value, as text.
  QString textVal() { return toText(dVal_);  }
  
  // Adjusts integer slider range (slMax_) and the increment that each
  // unit on the slider represents (dIncr_), according to latest
  // increment and range request (dIncr0_,  dMin_, dMax_).
  void adjSlIncr();

  // Sets slider to latest range and value (without
  // triggering slider signals or slChg slot below). 
  void updateSlider();

  // emit current value -- widget's main output.
  void emitVal();

  // Accepts new value (if any), updates interface (without
  // retriggering any internal slots).
  // New value should already have been validated.
  void update(Double dval);

    
  // main state.  Determines the float scaling for the (necessarily int)
  // QSlider.  dVal_ is the slider's 'external' value (which may be
  // floating-point).  dMin_ and dMax_ are its 'external' range.
  // dIncr0_ is the requested 'external' slider increment ('presolution'),
  // dIncr_ is the increment actually used (normally, these will be the same).
  //
  // Internally, the slider's range will be [0, slMax_]; slMax_
  // will be a non-negative integer value.  Both of the QSlider's
  // internal increments (singleStep, pageStep) will be 1.

  Double dVal_,  dMin_, dMax_,  dIncr_, dIncr0_,  slMax_;
  
  // Whether this element emits float values (ptype 'floatrange')
  // vs. ints (ptype 'intrange').
  Bool floatrng_;

  // Should the event be generated only upon releasing the slider?
  bool onrelease_;

  // For restoring 'original' value.
  Double origVal_;
  
  // Relevant user interface elements.  Must be created by
  // derived class and passed in via constructBase().
  // <group>
  QSlider* slider_;
  QLabel* nameLabel_;
  QToolButton* menuBtn_;
  // </group>
    
  // Internal name ('dlformat').
  QString itemName;  
  
};



//# ////////////////////  QtSliderEditor ///////////////////////////////////


class QtSliderEditor : public QtSliderBase, private Ui::SliderEditorItem {
  
  Q_OBJECT      //# Allows slot/signal definition.  Must only occur in
                //# implement/.../*.h files; also, makefile must include
                //# name of this file in 'mocs' section.

 public:
  
  QtSliderEditor(QDomElement& ele, QWidget *parent=0);
  ~QtSliderEditor() {  }

 protected:

  // (not intended for use at present).
  QtSliderEditor(QWidget *parent=0): QtSliderBase(parent) { 
    setupUi(this);
    radioButton->hide();  }
  
  // Sets text box to (normalized) current value.
  // (Should not trigger class's own slots either).
  void updateText() { lineEdit->setText(textVal());  }

  // main validation/update routine for changes to text version of value.
  // strval is the candidate text, which is still to be validated/normalized.
  void textChg(QString strval);
   
 protected slots:   
   
  //# text edited by user
  virtual void edited()      { textChg(lineEdit->text());  }
  
  //# // Triggered when 'revert-to-original' selected in menu
  //# virtual void setOriginal() { textChg(toText(origVal_));  }
  //#   //# (This version _will expand slider limits, if necessary).
  
};



//# ///////////////////////  QtSliderLabel /////////////////////////////////


class QtSliderLabel : public QtSliderBase, private Ui::SliderLabelItem {
  
  Q_OBJECT      //# Allows slot/signal definition.  Must only occur in
                //# implement/.../*.h files; also, makefile must include
                //# name of this file in 'mocs' section.

 public:
  
  QtSliderLabel(QDomElement& ele, QWidget *parent=0);
  ~QtSliderLabel() {  }

 protected:

  // (not intended for use at present).
  QtSliderLabel(QWidget *parent=0): QtSliderBase(parent) { setupUi(this);  }
  
  // Sets value label to (normalized) current value.
  void updateText();
   
};




//# ////////////////////////  QtMinMaxEditor ///////////////////////////////

class QtMinMaxEditor : public QWidget, private Ui::MinMaxEditorItem {
    Q_OBJECT
public:
     QtMinMaxEditor(QWidget *parent=0);
     QtMinMaxEditor(QDomElement &ele, QWidget *parent=0);
    ~QtMinMaxEditor();
    bool validate(QString value);
    void setLabelText(QString txt) {nameLabel->setText(txt);}
    QString name(){ return itemName; } 
    void reSet(QString);
public slots:  
   void display2(); 
   void display2(int value);  
   void display2(QString value);
   void setOriginal();
   void setDefault();
   void setCopy();
   void setPaste();
   void setHistogram();   
signals:
   void itemValueChanged(QString name, QString value, int action, bool apply);
private:
   QString itemName;  
   double scale;
   bool blockSignal;
   QString orig;
};


//# ////////////////////////  QtLineEditor  ////////////////////////////////

class QtLineEditor : public QWidget, private Ui::LineEditorItem {
    Q_OBJECT
public:
     QtLineEditor(QWidget *parent=0);
     QtLineEditor(QDomElement &ele, QWidget *parent=0);
    ~QtLineEditor();
    Bool validate(QString value);
    void setLabelText(QString txt) {nameLabel->setText(txt);}
    QString name(){ return itemName; } 
    void reSet(QString);
public slots:   
   void validateAndEmit(QString value);    
   void editingFinished();
   void setOriginal();
   void setDefault();
   void setCopy();
   void setPaste();   
signals:
   void itemValueChanged(QString name, QString value, int action, bool apply);
private:
   QString ptype;
   QString itemName;  
   QString origValue;
   bool blockSignal;
};


//# ////////////////////////   QtCombo  ////////////////////////////////////

class QtCombo : public QWidget, private Ui::ComboItem {
    Q_OBJECT
public:
     QtCombo(QWidget *parent=0);
     QtCombo(QDomElement &ele, QWidget *parent=0);
    ~QtCombo();
    void setLabelText(QString txt) {nameLabel->setText(txt);}
    QString name(){ return itemName; } 
    void reSet(QString);
public slots:   
   void setOriginal();
   void setDefault();
   void setCopy();
   void setPaste();    
signals:
   void itemValueChanged(QString name, QString value, int action, bool apply);
protected slots:   
   void emitValue(); 
private:
   QString itemName;     
   bool blockSignal;
   QString orig;
};


//# ////////////////////////   QtBoolean  //////////////////////////////////

class QtBool : public QWidget, private Ui::ComboItem {
    Q_OBJECT
public:
     QtBool(QWidget *parent=0);
     QtBool(QDomElement &ele, QWidget *parent=0);
    ~QtBool();
    void setLabelText(QString txt) {nameLabel->setText(txt);}
    QString name(){ return itemName; } 
    void reSet(QString);
public slots:   
   void setOriginal();
   void setDefault();
   void setCopy();
   void setPaste();    
signals:
   void itemValueChanged(QString name, QString value, int action, bool apply);
protected slots:   
   void emitValue(); 
private:
   QString itemName;     
   bool blockSignal;
   QString orig;
};


//# ////////////////////////  QtPushButton  ////////////////////////////////

class QtPushButton : public QWidget, private Ui::PushButtonItem {
    Q_OBJECT
public:
     QtPushButton(QWidget *parent=0);
     QtPushButton(QDomElement &ele, QWidget *parent=0);
    ~QtPushButton();
    void setLabelText(QString txt) {nameLabel->setText(txt);}
    QString name(){ return itemName; } 
    void reSet(QString);
signals:
   void itemValueChanged(QString name, QString value, int action, bool apply);
protected slots:   
   void emitValue(); 
private:
   QString itemName;     
   bool blockSignal;
};


//# ////////////////////////  QtCheck  /////////////////////////////////////

class QtCheck : public QWidget, private Ui::CheckItem {
    Q_OBJECT
public:
     QtCheck(QWidget *parent=0);
     QtCheck(QDomElement &ele, QWidget *parent=0);
    ~QtCheck();
    void setLabelText(QString txt) {nameLabel->setText(txt);}
    QString name(){ return itemName; } 
    // [Re]sets state of checkboxes and internal record of that,
    // without emitting itemValueChanged.
    void reSet(QString);
    
public slots:   
   void setOriginal();
   void setDefault();
   void setCopy();
   void setPaste();     
signals:
   void itemValueChanged(QString name, QString value, int action, bool apply);
protected slots:   
   void checkboxChanged(int newState);
   void emitValue(); 
   void reSet(QStringList);
   void reSet();
private:
   QList<QCheckBox*> checkboxes_;        //# all checkboxes
   QStringList allopts_;                //# Names of all checkboxes
   QStringList opts_;           //# Names of currently checked boxes
   QStringList orig_;           //# Names of boxes checked originally
   QString itemName;     
};


//# //////////////////////QtRegion//////////////////////////////////////////

class QtRegionEditor : public QWidget, private Ui::LineEditorItem {
    Q_OBJECT
public:
     QtRegionEditor(QWidget *parent=0);
     QtRegionEditor(QDomElement &ele, QWidget *parent=0);
    ~QtRegionEditor();
    bool validate(QString value);
    void setLabelText(QString txt) {nameLabel->setText(txt);}
    QString name(){ return itemName; } 
    void reSet(QString);
public slots:   
   void display2(QString value);    
   void editingFinished();
   void setOriginal();
   void setDefault();
   void fromImg();
   void createRegion();
    void unset();
   void setCopy();
   void setPaste();
signals:
   void itemValueChanged(QString name, QString value, int action, bool apply);
   
private:
   QString ptype;
   QString itemName;  
   QString iamunset;
   bool blockSignal;
};


//# ////////////////////// QtPair ///////////////////////////////////////////

class QtPairEditor : public QWidget, private Ui::PairItem {
    Q_OBJECT  
    
public:
    QtPairEditor(QDomElement& ele, QWidget* parent = NULL);
    
    ~QtPairEditor();
    
    void reSet(QString value);
    
signals:
    void itemValueChanged(QString name, QString value, int action, bool apply);
    
protected slots:
    void editingFinished();
    
    void setOriginal();
    
private:
    QString itemName;
    bool isDouble;
    QAbstractSpinBox* val1, *val2;
    std::pair<int, int> origVal1;
    std::pair<double, double> origVal2;
    
    std::pair<int, int> readIntPair(QString value);
    
    std::pair<double, double> readDoublePair(QString value);
};


//# ///////////////////// QtNumber ////////////////////////////////////////

// can use PairItem because it's just a frame
class QtNumberEditor : public QWidget, private Ui::PairItem {
    Q_OBJECT
    
public:
    QtNumberEditor(QDomElement& ele, QWidget* parent = NULL);
    
    ~QtNumberEditor();
    
    void reSet(QString value);
    
signals:
    void itemValueChanged(QString name, QString value, int action, bool apply);
    
protected slots:
    void editingFinished();
    
    void setOriginal();
    
private:
    QString itemName;
    bool isDouble;
    QAbstractSpinBox* val;
    int origVal1;
    double origVal2;
};


} //# NAMESPACE CASA - END



#endif