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

class QLayout;
namespace icl{
  namespace qt{

    class GUIWidget;
    class ProxyLayout;
    class GUIDefinition;

    class ICLQt_API 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;

      static inline GUI create_gui_from_string(const std::string &definition, QWidget *parent){
        return GUI(definition, parent);
      }

      std::string createXMLDescription() const;

      protected:
      virtual std::string createDefinition() const { return m_sDefinition; }

      private:

      static void to_string_recursive(const GUI *gui, std::ostream &str, int level);

      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
}