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