CanvasView.h

Go to the documentation of this file.

/* -*- mode: c++ -*- */

#ifndef CanvasView_H
#define CanvasView_H

#include "FigureEditor.h"

#if QT_VERSION < 0x040000
#else
//Added by the Qt porting tool:
#include <QtGui/QMouseEvent>
#endif


#ifdef _MSC_VER
#include <msdevstudio/MSconfig.h>
#endif

#include <list>
#include <map>

#if QT_VERSION < 0x040000
class QFileDialog;
#else
class Q3FileDialog;
class Q3MainWindow;
#endif

class QActionGroup;
class QFont;
class QMainWindow;
class QAction;

namespace hippodraw {

class Inspector;
class PlotterBase;
class QtView;
class ViewBase;
class XmlController;
class NTuple;
class PickTable;
class CreateNTuple;
class QtGroupView;

class MDL_QTHIPPOPLOT_API CanvasView : public FigureEditor
{

Q_OBJECT

private:

  std::list <QAction *> m_recent_list;

  mutable std::vector < const ViewBase * > m_views; 

  mutable std::vector < const ViewBase * > m_sel_views; 

  std::map < const QtView *, PickTable * > m_table_map; 

  static XmlController * s_xml_controller;

  Inspector * m_inspector;

  static const std::string s_app_name;

  static std::string s_image_filters;

#if QT_VERSION < 0x040000
   QCanvasRectangle * m_drag_rect;
#else
   Q3CanvasRectangle * m_drag_rect;
#endif

#if QT_VERSION < 0x040000
  QFileDialog * m_image_dialog;
#else
  Q3FileDialog * m_image_dialog;
#endif

   std::vector<double> m_mouseData;

   bool fillPickedPoint(QMouseEvent * e, std::vector<double> & picked);

   void fillMouseData(const std::vector<double> & picked);

   void updatePickTable(QtView * qtview, std::vector<double> & picked);

   void setPlotZoom(const std::vector<double> & start_picked, 
                    const std::vector<double> & picked);

  int m_num_width;

  int m_num_height;

  bool m_add_selected;
  
  int m_cut_mode;

  int m_edge;

  bool m_clicked;
  
  double old_pos, old_pos_x, old_pos_y;


  std::vector<double> m_current_range;
  
  void initSettings ();

  void saveSettings () const;

  void initFitterDefault ();

  void setFitterDefault ( const std::string & name );

  void initFitterMenu ( QActionGroup * group );

  static void createImageFilters ();

  static bool isValidImageFormat ( const std::string & suffix );

#if QT_VERSION < 0x040000
  QFileDialog * createImageDialog ();
#else
  Q3FileDialog * createImageDialog ();
#endif
 
  void setChanged ( bool yes = true );

  void addView ( QtView * view, bool select );

#if QT_VERSION < 0x040000
  void placeItems ( const std::vector < QCanvasItem * > & items );
#else
  void placeItems ( const std::vector < Q3CanvasItem * > & items );
#endif

  virtual void calcDefaultSize ( QtView * view, double aspect_ratio = 0.0);

  void moveToPlotter ( const PlotterBase * plotter, QtView * view );

  void sizeAndPlace ( QtView * view );

  std::pair<double, double> moveToPlotterAt ( const PlotterBase * plotter,
                                               QtView * view,
                                               double x, double y );

  void fillSelectedWithObservers ( std::vector < const ViewBase * > & );

  PlotterBase * getRightClickedPlotter();



protected:

  virtual void contentsMouseMoveEvent ( QMouseEvent * );
  virtual void contentsMousePressEvent ( QMouseEvent * );

  virtual void controlMousePressEvent ();

  virtual void contentsMouseReleaseEvent(QMouseEvent*);

public:
 
#if QT_VERSION < 0x040000
   CanvasView ( QCanvas *, QWidget * parent = 0, 
                const char * name = 0, Qt::WFlags f = 0 );
#else
   CanvasView ( Q3Canvas *, QWidget * parent = 0, 
                const char * name = 0, Qt::WFlags f = 0 );
#endif

  void initFrom ( const std::list < ViewBase * > & views );

  void initFromFile ( const std::string & filename );

  void initFitterSettings ( QActionGroup * group);

  void initRecentFiles ( QActionGroup * ag );

#if QT_VERSION < 0x040000
  void initDockWindows ( QMainWindow * mw );
#else
  void initDockWindows ( Q3MainWindow * mw );
#endif

  void addRecentFile (const QString & filename, QActionGroup * ag );

  void setFitterDefault ( const QString & name );

  void copySelectedToPasteboard ();

  void copyFromPasteboard ();

  void addFromPasteboard ();

  void deleteSelected ( bool paste );

  void pasteViews ( const std::list < ViewBase * > & views );

  void restoreFromSelectCopy ();

  void setCurrentRange();

  std::vector<double>& getCurrentRange() ;

  void setInspector ( Inspector * inspector );

  Inspector * getInspector ();

  void notifyObservers ();

  PlotterBase * selectedPlotter () const;

  std::vector < PlotterBase * > getSelectedPlotters () const;

  void addPlotDisplay ( PlotterBase * plotter, bool select);

#if QT_VERSION < 0x040000
  void autosaveSettings ( QMainWindow * mw);
#else
  void autosaveSettings ( Q3MainWindow * mw);
#endif
public:

  void addTextDisplay ( PlotterBase * plotter, 
                        const std::string & s, 
                        const std::string & text = std::string () );

   std::pair<double, double> addTextDisplayAt ( PlotterBase * plotter,
                                                const std::string & type,
                                                const std::string & text,
                                                double xrel, double yrel);


  void addFuncDisplay ( PlotterBase * plotter, const std::string & s );

  void removeDisplay ( PlotterBase * plotter );

  const std::vector < const ViewBase * > & selectedViews () const;

  const std::vector < const ViewBase * > & views () const;

  void fillPlotterList ( std::vector < PlotterBase * > & plotter_list );

  QtView * getViewFor ( const PlotterBase * plotter ) const;

  void previousView ();

  virtual void print ();

  virtual void print ( const std::string & filename );

  void reTile ();

  void reTilePage ();

  void setIntervalEnabled ( bool yes = true );

  void removeSelected ();

  void hideSelected ();

  void saveSelectedImages ();

   void saveSelectedImages ( const std::string & filename );

  void savePlotAsEps ( const PlotterBase * plotter,
                       const std::string & filename ) const;

  void savePlotAsFits ( const PlotterBase * plotter,
                        const std::string & filename ) const;

  void saveAs ( const std::string & filename ) const;

  static void saveAs ( const std::vector < const ViewBase * > & views,
                       const std::string & filename );

  static void saveAs ( const std::vector < PlotterBase * > & plotters,
                       const std::string & filename );

  void exportTextTuple ( const std::string & suffix );

  void showInspector ();

  void viewShowPickTable();

   const std::vector<double> & mouseEventData();

  void setPlotMatrix ( unsigned int columns, unsigned int rows );

  void createNTuple();

  void setup ();
  
 
  void setFonts( const QFont & font );
    
  void helpAbout ();

  const std::string & applicationName () const;

  void setAddedSelected ( bool yes );

  void setCutMode ( int mode );

  NTuple * getPickTable ();

  NTuple * getPickTable ( const PlotterBase * plotter );

  void groupView ();

  void ungroupView ();

private:

  bool existingFileWarning ( const std::string & filename );

  void invalidImageFormatError ( const std::string & filename );

  void saveSelectedAsEps ( const std::string & filename );


  void saveSelectedAsFits ( const std::string & filename );
public:
  void showFitsError () const;
private:

  void setVisibleNonViews ( bool visible );

  void saveSelectedImages ( const std::string & filename, 
                            bool check_existing );
  
  static void toLower ( std::string & upper );

public slots: 

  void addPlotDisplay ( PlotterBase * plotter );

  void clear ();

  void savePlotAsImage ( const PlotterBase * plotter,
                         const std::string & filename );

  void swapOrientation ();

  static QtView * wrapPlotter ( PlotterBase * plotter );

};

} // namespace hippodraw

#endif // CanvasView_H