void ResourceBrowserWidget::slotCurrentPIMOClassChanged( const QModelIndex& current, const QModelIndex& )
{
    if ( current.isValid() ) {
        Nepomuk2::Types::Class type = current.data( Nepomuk2::Utils::ClassModel::TypeRole ).value<Nepomuk2::Types::Class>();
        kDebug() << "Selection changed:" << type.label();
        setSelectedClass(type);
    }
}
ResourceBrowserWidget::ResourceBrowserWidget( QWidget* parent )
    : QWidget( parent )
{
    setupUi( this );

    m_pimoView->header()->hide();
    m_pimoView->setSelectionMode( QAbstractItemView::SingleSelection );

    m_pimoModel = new Nepomuk2::Utils::ClassModel( m_pimoView );
    m_pimoModel->addRootClass( Nepomuk2::Vocabulary::PIMO::Thing() );
    m_pimoSortModel = new KRecursiveFilterProxyModel( m_pimoView );
    m_pimoSortModel->setSourceModel( m_pimoModel );
    m_pimoSortModel->setSortCaseSensitivity( Qt::CaseInsensitive );
    m_pimoSortModel->setDynamicSortFilter( true );
    m_pimoView->setModel( m_pimoSortModel );
    m_pimoView->setContextMenuPolicy( Qt::CustomContextMenu );
    m_pimoView->setSortingEnabled( true );
    m_pimoView->sortByColumn( 0, Qt::AscendingOrder );
    m_pimoView->setDragEnabled(true);
    m_pimoView->setAcceptDrops(true);
    m_pimoView->setDropIndicatorShown(true);

    m_classFilter->setProxy( m_pimoSortModel );

    m_baseClassCombo->addItem( i18nc( "@item:inlistbox Referring to all RDF classes in the Nepomuk PIMO ontology", "PIMO Classes" ), QVariant( Nepomuk2::Vocabulary::PIMO::Thing() ) );
    m_baseClassCombo->addItem( i18nc( "@item:inlistbox Referring to all RDF classes in the Nepomuk db", "All Classes" ), QVariant( Soprano::Vocabulary::RDFS::Resource() ) );

    connect( m_pimoView, SIGNAL(customContextMenuRequested(QPoint)),
             this, SLOT(slotPIMOViewContextMenu(QPoint)) );
    connect( m_pimoView->selectionModel(), SIGNAL(currentChanged(QModelIndex,QModelIndex)),
             this, SLOT(slotCurrentPIMOClassChanged(QModelIndex,QModelIndex)) );
    connect( m_resourceView, SIGNAL(selectionChanged(QList<Nepomuk2::Resource>)),
             this, SIGNAL(resourcesSelected(QList<Nepomuk2::Resource>)) );
    connect( m_baseClassCombo, SIGNAL(activated(int)),
             this, SLOT(slotBaseClassChanged(int)) );
    connect( m_resourceView, SIGNAL(resourceActivated(Nepomuk2::Resource)),
             this, SIGNAL(resourceActivated(Nepomuk2::Resource)) );
    connect( m_resourceView, SIGNAL(resourceTypeActivated(Nepomuk2::Types::Class)),
             this, SLOT(setSelectedClass(Nepomuk2::Types::Class)) );
}
void SpatialDomainWidget::refresh()
{
  // -------- prepare classes list --------

  QStringList OriginalClassesList = openfluid::tools::toQStringList(m_Domain.getClassNames());

  QStringList ClassesList;

  // get display order for classes from project config file
  QVariant TmpList =
      openfluid::base::ProjectManager::instance()->getConfigValue("builder.spatial.unitsclasses","order");

  if (!TmpList.isValid())
  {
    openfluid::base::ProjectManager::instance()->setConfigValue("builder.spatial.unitsclasses","order",
                                                                OriginalClassesList);
    ClassesList = OriginalClassesList;
  }
  else
  {
    ClassesList = TmpList.toStringList();

    // find classes in project config file that are not in original dataset
    QStringList ClassesToRemove;
    for (int i=0; i< ClassesList.size();i++)
    {
      if (!OriginalClassesList.contains(ClassesList[i]))
        ClassesToRemove.append(ClassesList[i]);
    }

    // remove them from classes to display
    for (int i=0; i< ClassesToRemove.size();i++)
      ClassesList.removeAll(ClassesToRemove[i]);

    // remove classes from original list if they exists in classes to display
    for (int i=0; i< ClassesList.size();i++)
    {
      if (OriginalClassesList.contains(ClassesList[i]))
        OriginalClassesList.removeAll(ClassesList[i]);
    }

    // add original dataset classes that are not already in the classes to display
    for (int i=0; i< OriginalClassesList.size();i++)
    {
      if (!ClassesList.contains(OriginalClassesList[i]))
        ClassesList.append(OriginalClassesList[i]);
    }

    openfluid::base::ProjectManager::instance()->setConfigValue("builder.spatial.unitsclasses","order",ClassesList);
  }


  // -------- display classes widgets ---------

  // remove classes from display that does not exist anymore

  QVBoxLayout* Layout = dynamic_cast<QVBoxLayout*>(ui->UnitsClassAreaContents->layout());

  // search for classes to remove from layout
  QList<int> ItemsToRemove;

  for (int j=0;j<Layout->count();j++)
  {
    if (Layout->itemAt(j)->widget() != NULL)
    {

      UnitsClassWidget* ClassW = dynamic_cast<UnitsClassWidget*>(Layout->itemAt(j)->widget());

      if (!ClassesList.contains(ClassW->getClassName()))
      {
        if (ClassW->getClassName() == m_ActiveClass)
          m_ActiveClass = "";

        ItemsToRemove.append(j);
      }
    }
  }

  // effectively remove classes from layout
  QListIterator<int> itTR(ItemsToRemove);
  itTR.toBack();
  while (itTR.hasPrevious())
    Layout->takeAt(itTR.previous())->widget()->deleteLater();


  // Add of new classes to layout
  for (int i = 0; i<ClassesList.size(); i++)
  {
    bool AlreadyExist = false;

    // searching for already existing unit class in class list
    for (int j=0;j<Layout->count();j++)
    {
      if (j!=Layout->count()-1)
      {
        UnitsClassWidget* ClassW = dynamic_cast<UnitsClassWidget*>(Layout->itemAt(j)->widget());

        if (ClassW->getClassName() == ClassesList[i])
          AlreadyExist = true;
      }
    }

    // Add if it does not already exist
    if (!AlreadyExist)
    {
      UnitsClassWidget* ClassW =
          new UnitsClassWidget(ClassesList[i],
                               m_Datastore.getItems(ClassesList[i].toStdString(),
                                                    openfluid::core::UnstructuredValue::GeoVectorValue),
                               ui->UnitsClassAreaContents);

      dynamic_cast<QVBoxLayout*>(ui->UnitsClassAreaContents->layout())->insertWidget(Layout->count()-1,ClassW);
      connect(ClassW,SIGNAL(selectionRequested(QString)),this,SLOT(setSelectedClass(QString)));
      connect(ClassW,SIGNAL(styleChanged(QString)),this,SLOT(refreshMap()));
      connect(ClassW,SIGNAL(upClicked(QString)),this,SLOT(moveUnitsClassUp(QString)));
      connect(ClassW,SIGNAL(downClicked(QString)),this,SLOT(moveUnitsClassDown(QString)));
      connect(ClassW,SIGNAL(removeClicked(QString)),this,SLOT(removeUnitsClass(QString)));
    }
  }


  if (m_ActiveClass.isEmpty())
  {
    // active class is not defined, pick the first units class if any
    if (Layout->count()>1)
      setSelectedClass(dynamic_cast<UnitsClassWidget*>(Layout->itemAt(0)->widget())->getClassName());
    else
      setActiveClass("");
  }
  else
  {
    setSelectedClass(m_ActiveClass);
  }

  refreshMap();
}