TaskPropertyHandler.h

Go to the documentation of this file.

/*  Copyright (C) 2008 National Institute For Space Research (INPE) - Brazil.
 
    This file is part of the TerraLib - a Framework for building GIS enabled applications.
 
    TerraLib is free software: you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as published by
    the Free Software Foundation, either version 3 of the License,
    or (at your option) any later version.
 
    TerraLib is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    GNU Lesser General Public License for more details.
 
    You should have received a copy of the GNU Lesser General Public License
    along with TerraLib. See COPYING. If not, write to
    TerraLib Team at <terralib-team@terralib.org>.
 */
 
/*! 
  \file terralib/process/qt/TaskPropertyHandler.h
 
  \brief A handler to list task properties into a property browser
*/
 
#ifndef __TERRALIB_PROCESS_QT_INTERNAL_TASKPROPERTYHANDLER_H
#define __TERRALIB_PROCESS_QT_INTERNAL_TASKPROPERTYHANDLER_H
 
#include "../../Config.h"
 
#include "../../ParameterDescriptor.h"
 
// TerreLib Includes
#include "../../../common/AbstractFactory.h"
 
// QtPropertyBrowser
#include <QObject>
#include <QtPropertyBrowser/QtProperty>
 
// STL  Includes
#include <string>
 
namespace te
{
  namespace dt
  {
    class AbstractData;
  }
 
  namespace process
  {
    class TaskSharedPtr;
 
    namespace qt
    {
      class ProcessManager;
 
      /*!
      \class TaskPropertyHandler
 
      \brief A handler to list task properties into a property browser
 
      */
      class TEPROCESSEXPORT TaskPropertyHandler : public QObject
      {
        Q_OBJECT
 
      public:
 
        /*! \brief Default constructor. */
        TaskPropertyHandler(const std::string& taskType);
 
        /*! \brief Virtual destructor. */
        virtual ~TaskPropertyHandler();
 
        void setTask(const std::string& taskId, ProcessManager* manager);
 
        //!< Gets the type of the task
        const std::string& getType() const;
 
        virtual void setDefaultProperties(QtProperty* parent);
 
        virtual void setInputProperties(QtProperty* parent);
 
        virtual void setOutputProperties(QtProperty* parent);
 
        void valueChanged(QtProperty* p, const QVariant& qVariant);
 
      protected:
 
        void setProperty(QtProperty* parent, te::process::ParameterDescriptor::Direction dir);
 
        /*! \brief Function used to create the right property type given a param descriptor.
 
          \param paramDesc  Param descriptor used to create the property
 
          \return QtProperty object.
 
        */
        virtual QtProperty* createProperty(te::process::TaskSharedPtr task, te::process::ParameterDescriptor& paramDesc) = 0;
 
        /*! \brief Function used to get a terralib object data from a Task param.
 
          \param paramName  Parameter name
 
          \return TerraLib data object, if a valid type was founded.
 
        */
        virtual te::dt::AbstractData* getParamData(const std::string& paramName);
 
        /*! \brief Function used to set into qt property a terralib data.
 
          \param data       TerraLib object data
          \param property   Qt property object
          \param dataType   TerraLib object data type
 
        */
        virtual void setPropertyData(const te::dt::AbstractData* data, QtProperty* property, int dataType) = 0;
 
        /*! \brief Function used to create a terralib object data from a QtProperty contents (QVariant).
 
          \param paramDesc  Parameters descriptor, used to get the data type
          \param var        Qt object with data
 
          \return TerraLib data object, if a valid type was founded.
 
        */
        virtual te::dt::AbstractData* createPropertyData(te::process::ParameterDescriptor& paramDesc, const QVariant& var);
 
        QString getParameterToolTip(te::process::TaskSharedPtr task, te::process::ParameterDescriptor& paramDesc);
 
      protected:
 
        std::string m_taskType; //!< The type of the task. Used by the factory
 
        std::string m_taskId;
 
        ProcessManager* m_manager;
 
        std::map<std::string, QtProperty*> m_propertyMap; //!< A map between string property name and property objects
      };
 
      /*!
        \class TaskPropertyHandlerFactory
 
        \brief Abstract factory used to create Tasks property handlers.
      */
      class TEPROCESSEXPORT TaskPropertyHandlerFactory : public te::common::AbstractFactory < te::process::qt::TaskPropertyHandler, std::string >
      {
      public:
 
        /*!
          \brief Constructor.
 
          \param factoryKey The key that identifies the factory.
        */
        TaskPropertyHandlerFactory(const std::string& taskType);
 
        //!< Destructor
        virtual ~TaskPropertyHandlerFactory();
 
      };
 
      //!< Wrapper function used to create taks. Used to avoid C++ to create multiple instances of the factory singleton on Windows
      TEPROCESSEXPORT TaskPropertyHandler* CreateTaskPropertyHandler(const std::string& taskType, const std::string& taskId, ProcessManager* manager);
    }
  }
}
 
#endif // __TERRALIB_PROCESS_QT_INTERNAL_TASKPROPERTYHANDLER_H