jdxbase.h

/***************************************************************************
                          jdxbase.h  -  description
                             -------------------
    begin                : Sun Jun 6 2004
    copyright            : (C) 2001 by Thies H. Jochimsen
    email                : jochimse@cns.mpg.de
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef JDXBASE_H
#define JDXBASE_H


#include <tjutils/tjutils.h>
#include <tjutils/tjlabel.h>
#include <tjutils/tjlist.h>
#include <tjutils/tjarray.h>


// some defines for Bruker-type strings
#define _BRUKER_MODE_STRING_CAP_START_ 1000
#define _BRUKER_MODE_STRING_MIN_SIZE_ 256
#define _BRUKER_MODE_STRING_CAP_FACTOR_ 3


enum compatMode {bruker,notBroken};


enum parameterMode {edit,noedit,hidden};


enum fileMode {include,compressed,exclude};





class JcampDxBlock; // Forward Declaration
class JDXfunction; // Forward Declaration
class JDXtriple; // Forward Declaration
class JDXaction;  // Forward Declaration
class JDXenum;  // Forward Declaration
class JDXfileName; // Forward Declaration
class JDXformula; // Forward Declaration
class JDXrecoIndices; // Forward Declaration



class JcampDx {
 public:
  static const char* get_compName();
};


enum scaleType {displayScale=0,xPlotScale,yPlotScaleLeft,yPlotScaleRight,n_ScaleTypes};


struct ArrayScale {

  ArrayScale() : minval(0), maxval(0) {}

  ArrayScale(const STD_string& scalelabel, const STD_string& scaleunit, float scalemin=0.0, float scalemax=0.0);

  STD_string get_label_with_unit() const;

  STD_string label;

  STD_string unit;

  float minval,maxval;
};


struct PixmapProps {

  PixmapProps() : minsize(128), maxsize(1024), autoscale(true), color(false), overlay_minval(0), overlay_maxval(0), overlay_firescale(false), overlay_rectsize(0.8f) {}


  void get_overlay_range(float& min, float& max) const;

  unsigned int minsize, maxsize;

  bool autoscale;

  bool color;


  farray overlay_map;

  float  overlay_minval, overlay_maxval;

  bool overlay_firescale;

  float overlay_rectsize;
};



struct GuiProps {
  GuiProps() : fixedsize(true) {}

  ArrayScale scale[n_ScaleTypes];

  bool fixedsize;

  PixmapProps pixmap;
};



enum parxCodeType {parx_def, parx_passval, parx_passval_head, parx_parclass_def, parx_parclass_init, parx_parclass_passval};


struct ParxEquiv {
  ParxEquiv() : factor(1.0), offset(0.0) {}

  STD_string name;

  STD_string type;

  double factor;

  double offset;

};


class JcampDxClass : public ListItem<JcampDxClass>, public virtual Labeled {

 public:

  virtual ~JcampDxClass();

  virtual STD_string print() const;

  virtual STD_ostream& print2stream(STD_ostream& os) const {return os << printvalstring();}

  friend STD_ostream& operator << (STD_ostream& s,const JcampDxClass& value) { return value.print2stream(s);}


  virtual bool parse(STD_string& parstring);

  virtual int load(const STD_string &filename);

  virtual int write(const STD_string &filename) const;


  virtual bool parsevalstring (const STD_string&) = 0;

  virtual STD_string printvalstring() const = 0;


  virtual JcampDxClass& set_compatmode(compatMode compat_mode) {compatmode=compat_mode; return *this;}

  virtual compatMode get_compatmode() const {return compatmode;}


  virtual const char* get_typeInfo() const = 0;


  virtual double get_minval() const {return 0.0;}


  virtual double get_maxval() const {return 0.0;}

  bool has_minmax() const {return get_maxval()>get_minval();}


  virtual JcampDxClass* create_copy() const = 0;



  JcampDxClass& set_userDefParameter(bool userDef) {userDefParameter=userDef; return *this;}


  bool isUserDefParameter() const {return userDefParameter;}


  const STD_string& get_description() const {return description;}

  JcampDxClass&  set_description(const STD_string& descr) {description=descr; return *this;}


  virtual svector get_alternatives() const {return svector();}


  const STD_string& get_unit() const {return unit;}

  JcampDxClass& set_unit(const STD_string& un) {unit=un; return *this;}

  
  virtual parameterMode get_parmode() const {return parmode;}

  virtual JcampDxClass& set_parmode(parameterMode parameter_mode) {parmode=parameter_mode; return *this;}

  virtual fileMode get_filemode() const {return filemode;}

  virtual JcampDxClass& set_filemode(fileMode file_mode) {filemode=file_mode; return *this;}



  virtual GuiProps get_gui_props() const {return GuiProps();}

  virtual JcampDxClass& set_gui_props(const GuiProps&) {return *this;}



  virtual STD_string get_parx_code(parxCodeType type, const ParxEquiv& equiv=ParxEquiv()) const;

  virtual ParxEquiv get_parx_equiv() const {ParxEquiv pe; pe.type=get_typeInfo(); return pe;}




  // virtual functions to emulate a dynamic cast
  virtual JcampDxBlock* cast(JcampDxBlock*) {return 0;}
  virtual int*          cast(int*)          {return 0;}
  virtual long*         cast(long*)         {return 0;}
  virtual float*        cast(float*)        {return 0;}
  virtual double*       cast(double*)       {return 0;}
  virtual bool*         cast(bool*)         {return 0;}
  virtual STD_complex*  cast(STD_complex*)  {return 0;}
  virtual JDXenum*      cast(JDXenum*)      {return 0;}
  virtual STD_string*   cast(STD_string*)   {return 0;}
  virtual JDXfileName*  cast(JDXfileName*)  {return 0;}
  virtual JDXformula*   cast(JDXformula*)   {return 0;}
  virtual JDXaction*    cast(JDXaction*)    {return 0;}
  virtual iarray*       cast(iarray*)       {return 0;}
  virtual darray*       cast(darray*)       {return 0;}
  virtual farray*       cast(farray*)       {return 0;}
  virtual carray*       cast(carray*)       {return 0;}
  virtual sarray*       cast(sarray*)       {return 0;}
  virtual JDXtriple*    cast(JDXtriple*)    {return 0;}
  virtual JDXfunction*  cast(JDXfunction*)  {return 0;}


  // with these functions it is possible to assign a unique id to each paramerer
  int set_parameter_id(int newid) {id=newid; return 0;}
  int get_parameter_id() const {return id;}

  JcampDxClass& set_cmdline_option(const STD_string& opt) {cmdline_option=opt; return *this;}
  STD_string get_cmdline_option() const {return cmdline_option;}


 protected:

  JcampDxClass();
  JcampDxClass(const JcampDxClass& jdc);
  JcampDxClass& operator = (const JcampDxClass& jdc);

  STD_string get_parx_def_string(const STD_string type, unsigned int dim) const;

 private:
  friend class JDXwidget;
  friend class JcampDxBlock;

  virtual STD_string get_jdx_prefix() const;
  virtual STD_string get_jdx_postfix() const {return "\n";}

  compatMode compatmode;
  bool userDefParameter;
  parameterMode parmode;
  fileMode filemode;

  STD_string description;
  STD_string unit;

  int id;

  STD_string cmdline_option;

};



//
//  Some interface classes which help editing parameters in a GUI

class JDXeditWidget {

 public:

  virtual void updateWidget() = 0;

  virtual ~JDXeditWidget() {} // to avoid compiler warnings
};



class JDXeditCaller {

 public:

  virtual void parameter_relations(JDXeditWidget* editwidget) = 0;

  virtual ~JDXeditCaller() {} // to avoid compiler warnings
};



#endif