ldrbase.h

/***************************************************************************
                          ldrbase.h  -  description
                             -------------------
    begin                : Sun Jun 6 2004
    copyright            : (C) 2000-2021 by Thies H. Jochimsen
    email                : thies@jochimsen.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 LDRBASE_H
#define LDRBASE_H
 
 
#include <tjutils/tjutils.h>
#include <tjutils/tjlabel.h>
#include <tjutils/tjlist.h>
#include <tjutils/tjarray.h>
 
#include <odinpara/ldrser.h>
 
 
 
 
enum parameterMode {edit,noedit,hidden};
 
 
enum fileMode {include,compressed,exclude};
 
 
 
 
 
class LDRblock; // Forward Declaration
class LDRfunction; // Forward Declaration
class LDRtriple; // Forward Declaration
class LDRaction;  // Forward Declaration
class LDRenum;  // Forward Declaration
class LDRfileName; // Forward Declaration
class LDRformula; // Forward Declaration
class LDRrecoIndices; // Forward Declaration
 
 
 
class LDRcomp {
 public:
  static const char* get_compName();
};
 
 
enum scaleType {displayScale=0,xPlotScale,yPlotScaleLeft,yPlotScaleRight,n_ScaleTypes};
 
 
struct ArrayScale {
 
  ArrayScale() : minval(0), maxval(0), enable(true) {}
 
  ArrayScale(const STD_string& scalelabel, const STD_string& scaleunit, float scalemin=0.0, float scalemax=0.0, bool enablescale=true);
 
  STD_string get_label_with_unit() const;
 
  STD_string label;
 
  STD_string unit;
 
  float minval,maxval;
 
  bool enable;
};
 
 
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 JcampDxProps {
 
  JcampDxProps(bool user_defined_parameter=true,
               const STD_string& parx_name="", double parx_assign_factor=1.0, double parx_assign_offset=0.0)
    : userdef_parameter(user_defined_parameter),
      parx_equiv_name(parx_name), parx_equiv_factor(parx_assign_factor), parx_equiv_offset(parx_assign_offset) {}
 
  bool userdef_parameter;
 
  STD_string parx_equiv_name;
 
  double parx_equiv_factor;
 
  double parx_equiv_offset;
 
};
 
 
 
 
 
class LDRbase : public ListItem<LDRbase>, public virtual Labeled {
 
 public:
 
  virtual ~LDRbase();
 
  virtual STD_string print(const LDRserBase& serializer=LDRserJDX()) const;
 
  virtual STD_ostream& print2stream(STD_ostream& os, const LDRserBase& serializer) const;
 
  friend STD_ostream& operator << (STD_ostream& s, const LDRbase& value) { return value.print2stream(s,LDRserJDX());}
 
 
  virtual int write(const STD_string &filename, const LDRserBase& serializer=LDRserJDX()) const;
 
  virtual STD_string printvalstring(const LDRserBase* ser=0) const = 0;
 
 
 
  virtual bool parse(STD_string& parstring, const LDRserBase& serializer=LDRserJDX());
 
  virtual int load(const STD_string &filename, const LDRserBase& serializer=LDRserJDX());
 
 
  virtual bool parsevalstring(const STD_string&, const LDRserBase* ser=0) = 0;
 
 
 
 
 
  virtual STD_string get_typeInfo(bool parx_equivtype=false) 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 LDRbase* create_copy() const = 0;
 
 
  const STD_string& get_description() const {return description;}
 
  LDRbase&  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;}
 
  LDRbase& set_unit(const STD_string& un) {unit=un; return *this;}
 
  
  virtual parameterMode get_parmode() const {return parmode;}
 
  virtual LDRbase& set_parmode(parameterMode parameter_mode) {parmode=parameter_mode; return *this;}
 
  virtual fileMode get_filemode() const {return filemode;}
 
  virtual LDRbase& set_filemode(fileMode file_mode) {filemode=file_mode; return *this;}
 
 
 
  virtual GuiProps get_gui_props() const {return GuiProps();}
 
  virtual LDRbase& set_gui_props(const GuiProps&) {return *this;}
 
 
 
  virtual STD_string get_parx_code(parxCodeType type) const;
 
 
  JcampDxProps get_jdx_props() const {return jdx_props;}
 
  LDRbase& set_jdx_props(const JcampDxProps& jp) {jdx_props=jp; return *this;}
 
 
 
  // virtual functions to emulate a dynamic cast
  virtual LDRblock*     cast(LDRblock*)     {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 LDRenum*      cast(LDRenum*)      {return 0;}
  virtual STD_string*   cast(STD_string*)   {return 0;}
  virtual LDRfileName*  cast(LDRfileName*)  {return 0;}
  virtual LDRformula*   cast(LDRformula*)   {return 0;}
  virtual LDRaction*    cast(LDRaction*)    {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 LDRtriple*    cast(LDRtriple*)    {return 0;}
  virtual LDRfunction*  cast(LDRfunction*)  {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;}
 
  LDRbase& set_cmdline_option(const STD_string& opt) {cmdline_option=opt; return *this;}
  STD_string get_cmdline_option() const {return cmdline_option;}
 
 
 protected:
 
  LDRbase();
  LDRbase(const LDRbase& ldr);
  LDRbase& operator = (const LDRbase& ldr);
 
  STD_string get_parx_def_string(const STD_string type, unsigned int dim) const;
 
 
 
 private:
  friend class LDRwidget;
  friend class LDRblock;
 
  JcampDxProps jdx_props;
 
 
  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 LDReditWidget {
 
 public:
 
  virtual void updateWidget() = 0;
 
  virtual ~LDReditWidget() {} // to avoid compiler warnings
};
 
 
 
class LDReditCaller {
 
 public:
 
  virtual void parameter_relations(LDReditWidget* editwidget) = 0;
 
  virtual ~LDReditCaller() {} // to avoid compiler warnings
};
 
 
 
#endif