ObserverItemModel.cpp

Go to the documentation of this file.

/*
* This file is part of ArmarX.
*
* ArmarX is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* ArmarX 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* @package    ArmarX::Gui
* @author     Kai Welke (welke@kit.edu)
* @copyright  2012 Humanoids Group, IAIM, IFA
* @license    http://www.gnu.org/licenses/gpl-2.0.txt
*             GNU General Public License
*/
 
 
#include "ObserverItemModel.h"
 
#include <ArmarXCore/core/ArmarXManager.h>
#include <ArmarXCore/core/IceGridAdmin.h>
#include <ArmarXCore/core/exceptions/local/ExpressionException.h>
#include <ArmarXCore/core/util/algorithm.h>
#include <ArmarXCore/interface/observers/ConditionHandlerInterface.h>
#include <ArmarXCore/observers/variant/DatafieldRef.h>
 
#include "widgets/properties/ChannelPropertiesWidget.h"
#include "widgets/properties/DataFieldPropertiesWidget.h"
#include "widgets/properties/ElementaryCheckPropertiesWidget.h"
 
namespace armarx
{
    ObserverItemModel::ObserverItemModel(IceManagerPtr iceManager, VariantInfoPtr info) :
        QStandardItemModel(0, 1), iceManager(iceManager), info(info)
 
    {
 
        updateObservers();
    }
 
    void
    ObserverItemModel::updateModel(const std::string& observerName,
                                   const ChannelRegistry& channels,
                                   const StringConditionCheckMap& checks)
    {
        // update data
        channelRegistry[observerName] = channels;
        availableChecks[observerName] = checks;
        //  activeConditions[observerName] = conditions;
 
        // mark all elements for deletion
        markAllForDelete(invisibleRootItem());
 
        // insert observer
        QStandardItem* observerItem = updateObserver(observerName);
 
        // update channels
        updateChannels(getChildByName(observerItem, "channels"), channels);
 
        // update checks
        updateChecks(getChildByName(observerItem, "checks"), checks);
 
        // update conditions
        //  updateConditions(observerItem->child(2), conditions);
 
        // delete not updated items
        deleteUnusedItems(observerItem);
    }
 
    QWidget*
    ObserverItemModel::getPropertiesWidget(const QModelIndex& index, QWidget* parent)
    {
        QStandardItem* item = itemFromIndex(index);
        if (!item)
        {
            ARMARX_WARNING << "Could not find widget at column " << index.column() << " and row "
                           << index.row();
            return NULL;
        }
        QVariant id = item->data(OBSERVER_ITEM_ID);
 
        QWidget* widget;
 
        switch (item->data(OBSERVER_ITEM_TYPE).toInt())
        {
            // properties for channel
            case eChannelItem:
            {
                // retrieve registry entry
                QString channelName = id.toString();
                QString observerName = item->parent()->parent()->data(OBSERVER_ITEM_ID).toString();
                ChannelRegistryEntry& entry =
                    channelRegistry[observerName.toLatin1().data()][channelName.toLatin1().data()];
 
                // create widget
                widget = new ChannelPropertiesWidget(channelName.toLatin1().data(),
                                                     observerName.toLatin1().data(),
                                                     entry.description,
                                                     parent);
                break;
            }
 
            // properties for datafields
            case eDataFieldItem:
            {
                // retrieve registry entry
                const DataFieldIdentifier dataFieldIdentifier(id.toString().toLatin1().data());
 
                ARMARX_CHECK_EXPRESSION(
                    channelRegistry.count(dataFieldIdentifier.getObserverName()))
                    << "No channel registry for name '" << dataFieldIdentifier.getObserverName()
                    << "' "
                    << "Available names:\n"
                    << getMapKeys(channelRegistry);
                ChannelRegistry& chanReg =
                    channelRegistry.at(dataFieldIdentifier.getObserverName());
 
                ARMARX_CHECK_EXPRESSION(chanReg.count(dataFieldIdentifier.getChannelName()))
                    << "Channel registry '" << dataFieldIdentifier.getObserverName()
                    << "' has no channel '" << dataFieldIdentifier.getChannelName() << "' "
                    << "Available channels:\n"
                    << getMapKeys(chanReg);
                ChannelRegistryEntry& chanRegEntry =
                    chanReg.at(dataFieldIdentifier.getChannelName());
 
                ARMARX_CHECK_EXPRESSION(
                    chanRegEntry.dataFields.count(dataFieldIdentifier.getDataFieldName()))
                    << "Channel '" << dataFieldIdentifier.getObserverName() << "."
                    << dataFieldIdentifier.getChannelName() << "' has no datafield '"
                    << dataFieldIdentifier.getDataFieldName() << "'. Available datafields:\n"
                    << getMapKeys(chanRegEntry.dataFields);
                DataFieldRegistryEntry& entry =
                    chanRegEntry.dataFields.at(dataFieldIdentifier.getDataFieldName());
 
                // create widget
                DatafieldRefPtr ref = DatafieldRefPtr::dynamicCast(entry.identifier);
                if (info &&
                    (!entry.value->data || entry.value->data->ice_id() == "::armarx::VariantData"))
                {
                    ARMARX_INFO << "Variant Factory for " << entry.typeName
                                << " is missing - trying to load lib now";
                    auto lib = info->loadLibraryOfVariant(entry.typeName);
                    if (!lib)
                    {
                        widget = new QWidget(parent);
                        break;
                    }
                    ArmarXManager::RegisterKnownObjectFactoriesWithIce(
                        iceManager->getCommunicator());
                    entry.value = ref->getDataField();
                }
                widget = new DataFieldPropertiesWidget(entry.description,
                                                       ref,
                                                       VariantPtr::dynamicCast(entry.value),
                                                       iceManager,
                                                       parent);
                break;
            }
 
            case eCheckItem:
            {
                // retrieve check
                QString checkName = id.toString();
                QString observerName = item->parent()->parent()->data(OBSERVER_ITEM_ID).toString();
                ConditionCheckBasePtr check =
                    availableChecks[observerName.toLatin1().data()][checkName.toLatin1().data()];
 
                // create widget
                widget = new ElementaryCheckPropertiesWidget(
                    check, checkName.toLatin1().data(), true, false, false, parent);
 
                break;
            }
 
                /*      case eConditionItem:
                    {
                        // retrieve check
                        int conditionIndex = id.toInt();
                        QString observerName = item->parent()->parent()->data(OBSERVER_ITEM_ID).toString();
                        ConditionCheckBasePtr condition = activeConditions[observerName.toLatin1().data()][conditionIndex];
 
                        // create widget
                        widget = new ConditionPropertiesWidget(condition, parent);
 
                        break;
                    }
 
                    case eElementaryConditionItem:
                    {
                        // retrieve check
                        int elementId = id.toInt();
                        int conditionIndex = item->parent()->data(OBSERVER_ITEM_ID).toInt();
                        QString observerName = item->parent()->parent()->parent()->data(OBSERVER_ITEM_ID).toString();
                        ConditionCheckBasePtr check = activeConditions[observerName.toLatin1().data()][conditionIndex];
                        ElementaryConditionCheckBasePtr element = check->elementaryChecks[elementId];
 
                        // create widget
                        widget = new ElementaryCheckPropertiesWidget(element, element->condition->checkName, false, true, true, parent);
 
                        break;
                    }*/
 
            default:
                widget = new QWidget(parent);
                break;
        }
 
        return widget;
    }
 
    ObserverList
    ObserverItemModel::getObservers()
    {
        ObserverList list;
 
        if (!iceManager)
        {
            return list;
        }
 
        try
        {
            ConditionHandlerInterfacePrx handler =
                iceManager->getProxy<ConditionHandlerInterfacePrx>("ConditionHandler");
 
            if (handler)
            {
                ObserverList registeredObs = handler->getObserverNames();
                list = registeredObs;
            }
        }
        catch (...)
        {
        }
 
 
        ObserverList globalList =
            iceManager->getIceGridSession()->getRegisteredObjectNames<ObserverInterfacePrx>(
                "*Observer");
        list.insert(list.end(), globalList.begin(), globalList.end());
        std::sort(list.begin(), list.end());
        ObserverList::iterator it = std::unique(list.begin(), list.end());
        list.resize(std::distance(list.begin(), it));
        return list;
    }
 
    void
    ObserverItemModel::updateObservers()
    {
        if (!iceManager)
        {
            ARMARX_WARNING_S << "No IceManager set";
            return;
        }
 
        ObserverList observerList = getObservers();
        ObserverList::iterator iter = observerList.begin();
 
        while (iter != observerList.end())
        {
            ObserverInterfacePrx proxy;
            try
            {
                proxy = iceManager->getProxy<ObserverInterfacePrx>(*iter);
                updateModel(
                    *iter,
                    proxy->getAvailableChannels(true),
                    proxy->getAvailableChecks()); //, component->getActiveConditionChecks(*iter));
            }
            catch (...)
            {
                if (proxy)
                {
                    iceManager->removeProxyFromCache(proxy);
                }
            }
 
            iter++;
        }
    }
 
    QStandardItem*
    ObserverItemModel::updateObserver(std::string observerName)
    {
        // create observer item
        QStandardItem* observerItem = new QStandardItem(QString(observerName.c_str()));
        observerItem->setData(QVariant(eObserverItem), OBSERVER_ITEM_TYPE);
        observerItem->setData(QVariant(observerName.c_str()), OBSERVER_ITEM_ID);
        observerItem = updateOrInsertItem(invisibleRootItem(), observerItem);
 
        // add channels
        QStandardItem* channelsItem = new QStandardItem(QString("channels"));
        channelsItem->setData(QVariant(eChannelsItem), OBSERVER_ITEM_TYPE);
        channelsItem->setData(QVariant("channels"), OBSERVER_ITEM_ID);
        updateOrInsertItem(observerItem, channelsItem);
 
        // add checks
        QStandardItem* checksItem = new QStandardItem(QString("checks"));
        checksItem->setData(QVariant(eChecksItem), OBSERVER_ITEM_TYPE);
        checksItem->setData(QVariant("checks"), OBSERVER_ITEM_ID);
        updateOrInsertItem(observerItem, checksItem);
 
        // add conditions
        /*  QStandardItem *conditionsItem = new QStandardItem( QString("conditions") );
            conditionsItem->setData(QVariant(eConditionsItem), OBSERVER_ITEM_TYPE);
            conditionsItem->setData(QVariant("conditions"), OBSERVER_ITEM_ID);
            updateOrInsertItem(observerItem, conditionsItem);*/
 
        return observerItem;
    }
 
    void
    ObserverItemModel::updateChannels(QStandardItem* channelsItem, const ChannelRegistry& channels)
    {
        if (!channelsItem)
        {
            return;
        }
 
        // loop through channelsobser
        ChannelRegistry::const_iterator iterChannels = channels.begin();
 
        while (iterChannels != channels.end())
        {
            // create item for channels
            QStandardItem* channelItem =
                new QStandardItem(QString(iterChannels->second.name.c_str()));
 
            channelItem->setData(QVariant(eChannelItem), OBSERVER_ITEM_TYPE);
            channelItem->setData(QVariant(iterChannels->second.name.c_str()), OBSERVER_ITEM_ID);
 
            // insert channel's item
            channelItem = updateOrInsertItem(channelsItem, channelItem);
 
            // loop through datafields
            DataFieldRegistry::const_iterator iterDataFields =
                iterChannels->second.dataFields.begin();
 
            while (iterDataFields != iterChannels->second.dataFields.end())
            {
                // create new  datafield item
                std::string datafieldName =
                    iterDataFields->second.identifier->channelRef->observerName + "." +
                    iterDataFields->second.identifier->channelRef->channelName + "." +
                    iterDataFields->second.identifier->datafieldName;
                QStandardItem* dataFieldItem = new QStandardItem(
                    QString(iterDataFields->second.identifier->datafieldName.c_str()));
                dataFieldItem->setData(QVariant(eDataFieldItem), OBSERVER_ITEM_TYPE);
                dataFieldItem->setData(QVariant(datafieldName.c_str()), OBSERVER_ITEM_ID);
 
                // insert item
                updateOrInsertItem(channelItem, dataFieldItem);
                iterDataFields++;
            }
 
            iterChannels++;
        }
    }
 
    void
    ObserverItemModel::updateChecks(QStandardItem* checksItem,
                                    const StringConditionCheckMap& checks)
    {
        if (!checksItem)
        {
            return;
        }
 
        StringConditionCheckMap::const_iterator iterChecks = checks.begin();
 
        while (iterChecks != checks.end())
        {
            QStandardItem* checkItem = new QStandardItem(QString(iterChecks->first.c_str()));
            checkItem->setData(QVariant(eCheckItem), OBSERVER_ITEM_TYPE);
            checkItem->setData(QVariant(iterChecks->first.c_str()), OBSERVER_ITEM_ID);
 
            updateOrInsertItem(checksItem, checkItem);
 
            iterChecks++;
        }
    }
 
    /*
    void ObserverItemModel::updateConditions(QStandardItem* conditionsItem, const ConditionCheckMap& conditions)
    {
        ConditionCheckMap::const_iterator iterConditions = conditions.begin();
        while(iterConditions != conditions.end())
        {
            // update condition
            QString name = QString("%1").arg(iterConditions->second->info.identifier.uniqueId);
 
            QStandardItem* conditionItem = new QStandardItem( name );
            conditionItem->setData(QVariant(eConditionItem), OBSERVER_ITEM_TYPE);
            conditionItem->setData(QVariant(name), OBSERVER_ITEM_ID);
 
            conditionItem = updateOrInsertItem(conditionsItem, conditionItem);
 
            // loop through elementary conditions
            IntElementaryConditionCheckMap::iterator iterElements = iterConditions->second->elementaryChecks.begin();
 
            while (iterElements != iterConditions->second->elementaryChecks.end())
            {
                // update elementary condition
                QStandardItem* elementItem = new QStandardItem(iterElements->second->condition->checkName.c_str());
                elementItem->setData(QVariant(eElementaryConditionItem), OBSERVER_ITEM_TYPE);
                elementItem->setData(QVariant(iterElements->first), OBSERVER_ITEM_ID);
 
                updateOrInsertItem(conditionItem, elementItem);
 
                iterElements++;
            }
 
            iterConditions++;
        }
    }
    */
    QStandardItem*
    ObserverItemModel::updateOrInsertItem(QStandardItem* parent, QStandardItem* insert)
    {
        // loop through childs and compare data
        for (int r = 0; r < parent->rowCount(); r++)
        {
            QStandardItem* item = parent->child(r);
 
            if (item->data(OBSERVER_ITEM_ID) == insert->data(OBSERVER_ITEM_ID))
            {
                delete insert;
                item->setData(QVariant(false), OBSERVER_ITEM_DELETE);
                return item;
            }
        }
 
        parent->appendRow(insert);
 
        insert->setData(QVariant(false), OBSERVER_ITEM_DELETE);
        return insert;
    }
 
    QStandardItem*
    ObserverItemModel::getChildByName(QStandardItem* item, const QString& name)
    {
        for (int r = 0; r < item->rowCount(); r++)
        {
            if (item->child(r)->data(OBSERVER_ITEM_ID).toString() == name)
            {
                return item->child(r);
            }
        }
 
        return 0;
    }
 
    // mark all elements for deletion
    void
    ObserverItemModel::markAllForDelete(QStandardItem* observerItem)
    {
        int nCount = 0;
        std::list<QStandardItem*> markList;
        markList.push_back(observerItem);
 
        while (markList.size() > 0)
        {
            QStandardItem* current = markList.front();
            markList.pop_front();
            current->setData(QVariant(true), OBSERVER_ITEM_DELETE);
            nCount++;
 
            if (current->hasChildren())
            {
                for (int r = 0; r < current->rowCount(); r++)
                {
                    markList.push_back(current->child(r));
                }
            }
        }
    }
 
    void
    ObserverItemModel::deleteUnusedItems(QStandardItem* observerItem)
    {
        std::list<QStandardItem*> searchList;
        std::vector<int> removeRows;
 
        searchList.push_back(observerItem);
 
        while (searchList.size() > 0)
        {
            QStandardItem* current = searchList.back();
            searchList.pop_back();
 
            if (!current)
            {
                continue;
            }
 
            //        ARMARX_INFO_S << "CurrentItem: " << current->data(OBSERVER_ITEM_ID).toString().toStdString() << " num: " << current->rowCount();
            if (current->hasChildren())
            {
                removeRows.clear();
 
                for (int r = 0; r < current->rowCount(); r++)
                {
                    if (current->child(r)->data(OBSERVER_ITEM_DELETE).toBool())
                    {
                        //                    ARMARX_INFO_S << "Removing row: " << current->child(r)->data(OBSERVER_ITEM_ID).toString().toStdString();
                        removeRows.push_back(r);
                    }
                    else
                    {
                        //                    ARMARX_INFO_S << "Insert row: " << current->child(r)->data(OBSERVER_ITEM_ID).toString().toStdString();
                        searchList.push_back(current->child(r));
                    }
                }
 
                // remove unused rows
                std::vector<int>::reverse_iterator iter = removeRows.rbegin();
 
                while (iter != removeRows.rend())
                {
                    current->removeRow(*iter);
                    iter++;
                }
            }
        }
    }
} // namespace armarx