GUIComponents.h

Go to the documentation of this file.

/********************************************************************
**                Image Component Library (ICL)                    **
**                                                                 **
** Copyright (C) 2006-2013 CITEC, University of Bielefeld          **
**                         Neuroinformatics Group                  **
** Website: www.iclcv.org and                                      **
**          http://opensource.cit-ec.de/projects/icl               **
**                                                                 **
** File   : ICLQt/src/ICLQt/GUIComponents.h                        **
** Module : ICLQt                                                  **
** Authors: Christof Elbrechter                                    **
**                                                                 **
**                                                                 **
** GNU LESSER GENERAL PUBLIC LICENSE                               **
** This file may be used under the terms of the GNU Lesser General **
** Public License version 3.0 as published by the                  **
**                                                                 **
** Free Software Foundation and appearing in the file LICENSE.GPL  **
** included in the packaging of this file.  Please review the      **
** following information to ensure the license requirements will   **
** be met: http://www.gnu.org/licenses/lgpl-3.0.txt                **
**                                                                 **
** The development of this software was supported by the           **
** Excellence Cluster EXC 277 Cognitive Interaction Technology.    **
** The Excellence Cluster EXC 277 is a grant of the Deutsche       **
** Forschungsgemeinschaft (DFG) in the context of the German       **
** Excellence Initiative.                                          **
**                                                                 **
********************************************************************/

#pragma once

#include <ICLQt/GUIComponentWithOutput.h>
#include <ICLUtils/Any.h>

namespace icl{  
  namespace utils{
    class Configurable;
  }
  namespace qt{

    struct Button : public GUIComponentWithOutput{
      private:
      static std::string form_args(const std::string &text, const std::string &toggledText, bool initiallyToggled){
        if(!toggledText.length()){
          return text;
        }
        std::ostringstream str;
        str << text << ',';
        if(initiallyToggled) str << '!';
        str << toggledText;
        return str.str();
      }
      public:
      Button(const std::string &text, const std::string &toggledText="", bool initiallyToggled=false):
      GUIComponentWithOutput(toggledText.length() ? "togglebutton" : "button",form_args(text,toggledText,initiallyToggled)){}
    };
      

    struct ButtonGroup : public GUIComponentWithOutput{
      ButtonGroup(const std::string &commaSepTexts):
      GUIComponentWithOutput("buttongroup",commaSepTexts){}
    };
  

    struct CheckBox : public GUIComponentWithOutput{
      CheckBox(const std::string &label, bool checked=false):
      GUIComponentWithOutput("checkbox",label+','+(checked ? "checked":"unchecked")){}
    };
      

    struct Label : public GUIComponent{
      Label(const std::string &text=""):GUIComponent("label",text){}
    };
  

    struct Slider : public GUIComponentWithOutput{
      Slider(int min=0, int max=100, int curr=50, bool vertical=false):
      GUIComponentWithOutput("slider",form_args_4(min,max,curr,vertical?"vertical":"horizontal")){}
  
      Slider(const utils::Range32f &r, int curr, bool vertical=false):
      GUIComponentWithOutput("slider",form_args_4(r.minVal,r.maxVal,curr,vertical?"vertical":"horizontal")){}
    };
  

    struct FSlider : public GUIComponentWithOutput{
      FSlider(float min=0, float max=1, float curr=0.5, bool vertical=false):
      GUIComponentWithOutput("fslider",form_args_4(min,max,curr,vertical?"vertical":"horizontal")){}
      
      FSlider(const utils::Range32f &r, float curr=0.5, bool vertical=false):
      GUIComponentWithOutput("fslider",form_args_4(r.minVal,r.maxVal,curr,vertical?"vertical":"horizontal")){}
    };
  

    struct Int : public GUIComponentWithOutput{
      Int(int min=0, int max=100, int curr=50):
      GUIComponentWithOutput("int",form_args_3(min, max, curr)){}
    };
  

    struct Float : public GUIComponentWithOutput{
      Float(float min=0, float max=1, float curr=0.5):
      GUIComponentWithOutput("float",form_args_3(min, max, curr)){}
    };
  

    struct String : public GUIComponent{
      String(const std::string &initText, int maxLen=100):GUIComponent("string",initText+','+utils::str(maxLen)){}
    };
  

    struct Disp : public GUIComponent{
      Disp(int nxCells, int nyCells):
      GUIComponent("disp",utils::str(nxCells)+','+utils::str(nyCells)){}
    };
  

    struct Image : public GUIComponent{
      Image():GUIComponent("image"){}
    };
  

    struct Draw : public GUIComponent{

      Draw(const utils::Size &defaultViewPortsize=utils::Size::VGA):
      GUIComponent("draw",str(defaultViewPortsize)){}
    };
  

    struct Draw3D : public GUIComponent{

      Draw3D(const utils::Size &defaultViewPortsize=utils::Size::VGA):
      GUIComponent("draw3D",str(defaultViewPortsize)){}
    };
  

    struct Plot : public GUIComponent{
      private:
      static std::string form_args(const utils::Range32f xRange, 
                                   const utils::Range32f yRange, bool useOpenGL,
                                   const std::string &xLabel,  const std::string &yLabel){
        std::ostringstream str;
        str << xRange.minVal << ',' << xRange.maxVal << ',' << yRange.minVal << ',' << yRange.maxVal << ','
            << (useOpenGL ? "gl" : "noGL");
        if(xLabel.length()){
          str << ',' << xLabel;
          if(xLabel.length()){
            str << ',' << yLabel;
          }
        }
        return str.str();
      }
  
      public:

      Plot(const utils::Range32f xRange=utils::Range32f(0,0),
           const utils::Range32f yRange=utils::Range32f(0,0),
           bool useOpenGL=false,
           const std::string &xLabel="",
           const std::string &yLabel=""): 
      GUIComponent("plot",form_args(xRange,xRange, useOpenGL, xLabel, yLabel)){}
  

      Plot(float minX, float maxX=0, float minY=0, float maxY=0,
           bool useOpenGL=false,
           const std::string &xLabel="",
           const std::string &yLabel=""): 
      GUIComponent("plot",form_args(utils::Range32f(minX,maxX),utils::Range32f(minY,maxY), useOpenGL, xLabel, yLabel)){}
    };



      

    struct Combo : public GUIComponent{
      private:
      static std::string form_args(const std::string &entries, int initialIndex){
        if(!initialIndex) return entries;
        std::vector<std::string> ls = utils::tok(entries,",");
        if(initialIndex < 0 || initialIndex >= (int)ls.size()){
          throw utils::ICLException("Combo::Combo(entries,initialIndex): initialIndex is invalid");
        }
        ls[initialIndex] = '!' + ls[initialIndex];
        return utils::cat(ls,",");
      }
      public:
      Combo(const std::string &commaSepEntries, int initialIndex=0):
      GUIComponent("combo",form_args(commaSepEntries,initialIndex)){}
    };
      

    struct Spinner : public GUIComponentWithOutput{
      Spinner(int min, int max, int curr):
      GUIComponentWithOutput("spinner",form_args_3(min,max,curr)){}
    };
      
  

    struct Fps : public GUIComponent{
      Fps(int timeWindowSize=10):
      GUIComponent("fps",utils::str(timeWindowSize)){}
    };
      

    struct CamCfg : public GUIComponent{
      private:
      static inline std::string form_args(const std::string &a, const std::string &b){
        std::ostringstream str;
        if(a.length()){
          str << a;
          if(b.length()){
            str << ',' << b;
          }
        }
        return str.str();
      }
      public:
      CamCfg(const std::string &deviceTypeHint="", const std::string &deviceIDHint=""):GUIComponent("camcfg",form_args(deviceTypeHint,deviceIDHint)){}
    };
  

    struct Prop : public GUIComponent{
      Prop(const std::string &configurableID):GUIComponent("prop",configurableID){}
      
      Prop(const utils::Configurable *cfg) throw (utils::ICLException) : GUIComponent("prop","@pointer@:"+utils::Any::ptr(cfg)){
        ICLASSERT_THROW(cfg, utils::ICLException("GUIComponent Prop(NULL-Pointer) cannot be created!"));
      }

      Prop(const utils::Configurable &cfg):GUIComponent("prop","@pointer@:"+utils::Any::ptr(&cfg)){}
    };
  

    struct ColorSelect : public GUIComponentWithOutput{

      ColorSelect(int r, int g, int b, int a=-1):GUIComponentWithOutput("color",a>=0 ? form_args_4(r,g,b,a) : form_args_3(r,g,b)){}
    };
      

    struct Ps : public GUIComponent{
      Ps(int updatePFS=10):GUIComponent("ps",utils::str(updatePFS)){}
    };
  
    struct Dummy : public GUIComponent{
      Dummy():GUIComponent(""){}
    };
      
    struct Show : public GUIComponent{
      Show():GUIComponent("!show"){};
    };
  
    struct Create : public GUIComponent{
      Create():GUIComponent("!create"){};
    };
  
  } // namespace qt
}