GUI.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/GUI.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 <string>
#include <vector>
#include <ICLUtils/SmartPtr.h>
#include <ICLUtils/Function.h>
#include <ICLQt/DataStore.h>
#include <ICLQt/GUIComponents.h>
#include <QtGui/QLayout>
#include <QtGui/QWidget>
#include <QtGui/QApplication>

class QLayout;
namespace icl{
  namespace qt{
  
    class GUIWidget;
    class ProxyLayout;
    class GUIDefinition;


    class GUI{
      private:

      virtual GUI &operator<<(const std::string &definition);
  
      protected:
      GUI(const std::string &definition, QWidget *parent);
  
  
      public:
      typedef utils::Function<GUIWidget*,const GUIDefinition&> CreatorFunction;
      

      static void register_widget_type(const std::string &tag, CreatorFunction f);
      
      static const int CELLW = 20;
      static const int CELLH = 20;
      
      GUI(QWidget *parent=0);
      
      GUI(const GUIComponent &component, QWidget *parent=0);
      
      GUI(const GUI &gui,QWidget *parent=0);
  
      GUI &operator=(const GUI &other);
  
      virtual ~GUI();
  
      virtual GUI &operator<<(const GUIComponent &component);
      

      virtual GUI &operator<<(const GUI &g);
      
      template<class T>
      inline T &allocValue(const std::string &id, const T&val=T()){
        return m_oDataStore.allocValue<T>(id,val);
      }
  
      template<class T>
      inline void release(const std::string &id){
        m_oDataStore.release<T>(id);
      }
      
      template<class T> 
      T &get(const std::string &id, bool typeCheck=true){
        return m_oDataStore.getValue<T>(id,typeCheck);
      }
  
      DataStore::Data operator[](const std::string &key){
        return m_oDataStore.operator[](key);
      }
      
      template<class T>
      std::vector<T> collect(const std::vector<std::string> &keys){
        return m_oDataStore.collect<T>(keys);
      }
      
      virtual bool isVisible() const;
      
      virtual void create();
  
      virtual void show();
      
      virtual void hide();
      
      virtual void switchVisibility();
      
      inline GUIWidget *getRootWidget(){
        return m_poWidget;
      }
      
      inline void lockData() {
        m_oDataStore.lock();
      }
      inline void unlockData() {
        m_oDataStore.unlock();
      }
      void waitForCreation();
  
      const DataStore &getDataStore() const { return m_oDataStore; }
      

      typedef utils::Function<void> Callback;
      

      typedef utils::Function<void,const std::string&> ComplexCallback;
      
      

      void registerCallback(const Callback &cb, const std::string &handleNamesList, char listDelim=',');
      

      void registerCallback(const ComplexCallback &cb, const std::string &handleNamesList, char listDelim=',');
  
      void removeCallbacks(const std::string &handleNamesList, char listDelim=',');
  

      inline bool isDummy() const { return m_sDefinition == "" || m_sDefinition == "dummy"; }
      
      bool hasBeenCreated() const;
  
      protected:
      virtual std::string createDefinition() const { return m_sDefinition; }
  
      private:
  
      void create(QLayout *parentLayout,ProxyLayout *proxy, QWidget *parentWidget, DataStore *ds);
  
      std::string m_sDefinition;
      std::vector<GUI*> m_children;
      GUIWidget *m_poWidget;
      DataStore m_oDataStore;
      bool m_bCreated;
      QWidget *m_poParent;
    };
  } // namespace qt
}