QtDataManager.qo.h

Go to the documentation of this file.

//# QtDataManager.qo.h: Qt implementation of viewer data manager widget.
//# 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 QTDATAMANAGER_H_
#define QTDATAMANAGER_H_
        // (Trailing underscore is not a typo -- do not remove it;
        // QtDataManager.ui.h uses the QTDATAMANAGER_H symbol).


#include <casa/aips.h>
#include <casa/BasicSL/String.h>
#include <display/QtViewer/QtLELEdit.qo.h>
#include <display/Utilities/ImageProperties.h>
#include <display/QtViewer/SlicerGen.qo.h>

#include <graphics/X11/X_enter.h>
#include <QDir>
#include <QColor>
#include <QHash>
#include <QWidget>
   //#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 <display/QtViewer/QtDataManager.ui.h>
#include <display/QtViewer/QtDataMgrMsSelect.ui.h>
#include <graphics/X11/X_exit.h>
#include <display/Utilities/Lowlevel.h>
#include <set>
#include <list>
#include <tr1/memory>

 
namespace casa { //# NAMESPACE CASA - BEGIN

class QtDisplayPanelGui;
class QtDisplayPanel;
class QtDisplayData;
template <class T> class ImageInterface;

namespace viewer {
  class Region;
}

class QtDataManager : public QWidget, private Ui::QtDataManager {
   
   Q_OBJECT

 public:
  
  typedef std::list<std::pair<QGroupBox*,QLineEdit*> > infofield_list_t;

  QtDataManager( QtDisplayPanelGui* panel=0, const char* name=0, QWidget* parent=0 );
  ~QtDataManager();
  
/*   String path() const { return dir_.path().toStdString();  } */
  
  void updateDirectory(const std::string &);

  void showTab( std::string );
 
 signals:
 
  void tableReadErrorSignal(String msg);
  

 protected:

  void showDisplayButtons(int,const QString &name=QString((const char *)0));
  void hideDisplayButtons();
  QColor getDirColor(int);
  QStringList analyseFITSImage(QString path);
  Bool isQualImg(const QString &extexpr);


  std::string guimethod_to_iamethod( const QString & );

  enum DATATYPE { UNKNOWN, IMAGE, MEASUREMENT_SET, SKY_CATALOG, RESTORE,
                  DIRECTORY, QUALIMG, CASAREGION, DS9REGION };
  enum DISPLAYTYPE { RASTER, CONTOUR, VECTOR, MARKER, SKY_CAT,
                     NEWPANEL, OLDPANEL };

  QHash<int, QString> dataType_;
  QHash<QString, int> uiDataType_;
  QHash<QString, int> displayType_;
  QHash<QString, int> uiDisplayType_;
  QVector<int>        exportTypes_;
 
  viewer::ImageProperties image_properties;
  infofield_list_t load_ifields;
/*   infofield_list_t img_ifields; */

 public slots:

  void updateDisplayDatas(QtDisplayData* qdd=0, Bool autoRegister=True);
 
 protected slots:
  
  void handle_region_update(viewer::Region*,std::string);

  void createButtonClicked();
  void clickItem(QTreeWidgetItem* item);
  void expandItem(QTreeWidgetItem* item);
  void changeItemSelection();
  void returnPressed();
  void buildDirTree( std::string newdir="" );
  void lelGotFocus_();
  void load_regions_clicked( );

  // Restore viewer state to existing panel.
  // Use the first empty panel, or if none, the first panel.
  void restoreToOld_();
  
  // Create new display panel, restore viewer state to it.
  void restoreToNew_();

  // Restore viewer state to given panel.
  void restoreTo_(QtDisplayPanel* dp);
  
  
  void showDDCreateError_(String);

  void leaveopenButtonClicked( bool checked );
  void showlelButtonClicked( bool checked );
  void showSliceButtonClicked( bool checked );
 
  void changeTabContext(int);

  void img_output_target_changed(const QString &s="");
  void img_output_target_changed(bool) { img_output_target_changed( ); }

  void region_ds9_csys_disable(bool);
  void region_output_target_changed(const QString &s="");
  void region_output_target_changed(bool) { region_output_target_changed( ); }

  void img_do_output( );
  void region_do_output( );

  void region_item_state_change(QTreeWidgetItem*,int);
  void region_selection_change( viewer::Region *rgn, bool selected );

 private:

    typedef std::map<QString,QtDisplayData*> display_data_map_t;
    display_data_map_t display_datas;
    
    typedef std::map<QTreeWidgetItem*,viewer::Region*> treeitem_map_t;
    treeitem_map_t treeitem_to_region;
    typedef std::map<viewer::Region*,QTreeWidgetItem*> region_map_t;
    region_map_t region_to_treeitem;

    struct validation_msg {
        enum output_format_t { FITS, CASA, CRTF, DS9 };
        enum valid_t { VALID, INVALID, WARN };
        validation_msg( const QString &s, output_format_t f, valid_t v, const QString &m ) : path(s), output_format(f), valid(v), msg(m) { }
        validation_msg( const validation_msg &o ) : path(o.path), output_format(o.output_format), valid(o.valid), msg(o.msg) { }
        validation_msg( ) : path(/* QString::Null */), output_format(CASA), valid(INVALID), msg(/* QString::Null */) { fprintf( stderr, "HERE<3>:::: " ); }
        validation_msg operator=(const validation_msg &o ) { path = o.path; output_format = o.output_format; valid = o.valid; msg = o.msg; return *this; }
        QString canonical_path( const QString & );
        QString path;
        output_format_t output_format;
        valid_t valid;
        QString msg;
    };

    validation_msg output_validation( const QString &, const QString &, validation_msg::output_format_t ) const;

    class tab_state {
        public:
            typedef void (QtDataManager::*notify_func_t)( const std::string &, tab_state & );
            tab_state( ) : dir_entry_(0), tree_(0), dir_(new QDir), notify_func_(0),
                                                info_frame_(0), info_fields_(0), dtree_(0),
                                                output_name_line_(0), error_func_(0) {
                dir_->setFilter( QDir::AllDirs | QDir::Files);
                dir_->setSorting(QDir::Name);
            }
            tab_state( const tab_state &o ) : filtered_types_(o.filtered_types_), dir_entry_(o.dir_entry_),
                                                tree_(o.tree_), dir_(o.dir_), notify_func_(o.notify_func_),
                                                info_frame_(o.info_frame_), info_fields_(o.info_fields_),
                                                dtree_(o.dtree_), output_name_line_(o.output_name_line_),
                                                error_func_(o.error_func_) { }
            tab_state( QLineEdit *le, QTreeWidget *t, std::set<int> s, QFrame *info_frame=0,
                       infofield_list_t *info_fields=0, notify_func_t f=0,
                       QTreeWidget *d=0, QLineEdit *on=0, notify_func_t oerr=0 ) :
                                                filtered_types_(s), dir_entry_(le), tree_(t), dir_(new QDir),
                                                notify_func_(f), info_frame_(info_frame), info_fields_(info_fields),
                                                dtree_(d), output_name_line_(on), error_func_(oerr) {
                dir_->setFilter( QDir::AllDirs | QDir::Files);
                dir_->setSorting(QDir::Name);
            }
            const std::set<int> &filter( ) const { return filtered_types_; }
            void updateDir( ) { if ( dir_entry_ ) { dir_entry_->setText(dir_->currentPath( )); } }

            void notify( QtDataManager *mgr, const std::string &s ) {
                if ( notify_func_ ) (mgr->*notify_func_)(s,*this);
            }
            void notifyErr( QtDataManager *mgr, const std::string &s ) {
                if ( error_func_ ) (mgr->*error_func_)(s,*this);
            }

            QTreeWidget *tree( ) { return tree_; }
            QFrame *infoFrame( ) { return info_frame_; }
            infofield_list_t *infoFields( ) { return info_fields_; }
            
            QTreeWidget *dtree( ) { return dtree_; }
            QLineEdit *outFileLine( ) { return output_name_line_; }

            std::tr1::shared_ptr<QDir> dir( ) { return dir_; }
            QLineEdit *dirline( ) { return dir_entry_; }
            std::string dirStr( ) const { return dir_entry_->text( ).toStdString( ); }
        private:
            std::set<int> filtered_types_;
            QLineEdit *dir_entry_;
            QTreeWidget *tree_;
            std::tr1::shared_ptr<QDir> dir_;
            notify_func_t notify_func_;
            QFrame *info_frame_;
            infofield_list_t *info_fields_;

            QTreeWidget *dtree_;
            QLineEdit *output_name_line_;
            notify_func_t error_func_;

  };
  
  void update_regrid_options( );
  void update_slice_options( int ddtp,const QString &name );
  void fill_image_info( const std::string &/*path*/ );

  QWidget *parent_;
  QtDisplayPanelGui* panel_;
  Ui::QtDataMgrMsSelect *ms_selection;

  // avoid setting the export type more than once
  QString last_image_extension_tweak_string;
  QString last_region_extension_tweak_string;

  // connection to rc file
  Casarc &rc;

  typedef std::map<int,tab_state> tab_info_map_t;
  tab_info_map_t tab_info;
  void init_tab_info( );

  void load_tab_notify( const std::string &value, tab_state & );

  void update_dd_list( tab_state &ts );
  void image_tab_notify( const std::string &value, tab_state & );
  void image_tab_error( const std::string &value, tab_state & );

  void update_region_list( tab_state &ts );
  void region_tab_notify( const std::string &value, tab_state & );
  void region_tab_error( const std::string &value, tab_state & );

  bool export_to_fits(ImageInterface<Float> *img, std::string outFile);
  bool export_to_casa(ImageInterface<Float> *img, String outFile);
  void getSpectralCoordFlags(const ImageInterface<Float>* img, Bool &preferVelocity, Bool &opticalVelocity, Bool &preferWavelength, Bool &preferAirWavelength);

  viewer::SlicerGen *slice_gen;

};



} //# NAMESPACE CASA - END

#endif