std::vector<std::unique_ptr<AbstractVisualizedData>> RenderView::removeFromInternalLists(QList<DataObject *> dataObjects)
{
std::vector<std::unique_ptr<AbstractVisualizedData>> toDelete;
for (DataObject * dataObject : dataObjects)
{
AbstractVisualizedData * rendered = m_dataObjectToVisualization.value(dataObject, nullptr);
assert(rendered);
m_dataObjectToVisualization.remove(dataObject);
auto contentsIt = findUnique(m_contents, rendered);
if (contentsIt != m_contents.end())
{
toDelete.push_back(std::move(*contentsIt));
m_contents.erase(contentsIt);
}
else
{
auto cacheIt = findUnique(m_contentCache, rendered);
if (cacheIt != m_contentCache.end())
{
toDelete.push_back(std::move(*cacheIt));
m_contentCache.erase(cacheIt);
}
}
}
resetFriendlyName();
return toDelete;
}
void DataMapping::deleteLaterFrom(View_t * view, Vector_t & vector)
{
auto ownedViewIt = findUnique(vector, view);
if (ownedViewIt == vector.end())
{
// Reentered this function while calling view->dockWidgetParent()->close();
return;
}
auto viewOwnership = std::move(*ownedViewIt);
vector.erase(ownedViewIt);
// Handle deletion in Qt event loop. If the event loop is not running anymore (application shutdown),
// deletion will be handled in ~DataMapping
viewOwnership.release()->deleteLater();
}
void RenderView::hideDataObjectsImpl(const QList<DataObject *> & dataObjects, int /*suViewIndex*/)
{
bool changed = false;
for (auto dataObject : dataObjects)
{
auto rendered = m_dataObjectToVisualization.value(dataObject);
if (!rendered)
{
continue;
}
// cached data is only accessible internally in the view, so let others know that it's gone for the moment
emit beforeDeleteVisualizations({ rendered });
// move data to cache if it isn't already invisible
auto contentsIt = findUnique(m_contents, rendered);
if (contentsIt != m_contents.end())
{
m_contentCache.push_back(std::move(*contentsIt));
m_contents.erase(contentsIt);
rendered->setVisible(false);
changed = true;
}
assert(!containsUnique(m_contents, (AbstractVisualizedData*)nullptr));
}
if (!changed)
{
return;
}
resetFriendlyName();
updateGuiForRemovedData();
implementation().renderViewContentsChanged();
emit visualizationsChanged();
render();
}
bool containsUnique(const std::vector<std::unique_ptr<T>> & vector, const T * value)
{
return findUnique(vector, value) != vector.end();
}
typename std::vector<std::unique_ptr<T>>::const_iterator findUnique(const std::vector<std::unique_ptr<T>> & vector, const T * value)
{
return findUnique(vector.cbegin(), vector.cend(), value);
}
void RenderView::showDataObjectsImpl(const QList<DataObject *> & uncheckedDataObjects, QList<DataObject *> & incompatibleObjects, unsigned int /*subViewIndex*/)
{
if (uncheckedDataObjects.isEmpty())
{
return;
}
const bool wasEmpty = m_contents.empty();
if (wasEmpty)
{
updateImplementation(uncheckedDataObjects);
}
AbstractVisualizedData * aNewObject = nullptr;
const auto && dataObjects = implementation().filterCompatibleObjects(uncheckedDataObjects, incompatibleObjects);
if (dataObjects.isEmpty())
{
return;
}
for (auto dataObject : dataObjects)
{
auto previouslyRendered = m_dataObjectToVisualization.value(dataObject);
// create new rendered representation
if (!previouslyRendered)
{
aNewObject = addDataObject(dataObject);
if (m_closingRequested) // just abort here, if we processed a close event while addDataObject()
{
return;
}
continue;
}
// reuse currently rendered / cached data
auto contensIt = findUnique(m_contents, previouslyRendered);
if (contensIt != m_contents.end())
{
continue;
}
aNewObject = previouslyRendered;
auto cacheIt = findUnique(m_contentCache, previouslyRendered);
m_contents.push_back(std::move(*cacheIt));
m_contentCache.erase(cacheIt);
previouslyRendered->setVisible(true);
}
if (aNewObject)
{
implementation().renderViewContentsChanged();
updateGuiForSelectedData(aNewObject);
emit visualizationsChanged();
}
if (aNewObject)
{
implementation().resetCamera(wasEmpty, 0);
}
resetFriendlyName();
updateTitle();
}