OilfieldToolsNet/ResInsight
4
0
Fork 0
mirror of https://github.com/OPM/ResInsight.git synced 2025-02-25 18:55:39 -06:00
Code Issues Packages Projects Releases Wiki Activity

Linked Views: Refactored and cleaned up more. Refactored some features.

Browse Source
This commit is contained in:
Jacob Støren
2015-09-24 14:29:13 +02:00
parent 5e0505dfe8
commit d83d9e967b
10 changed files with 131 additions and 240 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
ApplicationCode/Commands/ViewLink/RicLinkViewFeature.cpp
View File

@@ -42,24 +42,24 @@ bool RicLinkViewFeature::isCommandEnabled()
RimView* activeView = RiaApplication::instance()->activeReservoirView();
if (!activeView) return false;
RimProject* proj = RiaApplication::instance()->project();
if (!proj->findViewLinkerFromView(activeView))
RimViewController* viewController = activeView->controllingViewLink();
if(viewController)
{
RimViewLinkerCollection* viewLinkerCollection = proj->viewLinkerCollection();
if (viewLinkerCollection)
return false;
}
else
{
RimViewLinker* vLinker = RimViewLinker::viewLinkerIfMainView(activeView);
if (!vLinker)
{
RimViewLinker* viewLinker = viewLinkerCollection->viewLinker();
if (viewLinker)
{
if (viewLinker->viewLinks().size() > 0)
{
return true;
}
}
return true;
}
else
{
return false;
}
}
return false;
}
//--------------------------------------------------------------------------------------------------

60
ApplicationCode/Commands/ViewLink/RicLinkVisibleViewsFeature.cpp
View File

@@ -125,29 +125,9 @@ void RicLinkVisibleViewsFeature::findNotLinkedVisibleViews(std::vector<RimView*>
void RicLinkVisibleViewsFeature::linkViews(std::vector<RimView*>& views)
{
RimProject* proj = RiaApplication::instance()->project();
RimViewLinker* viewLinker = NULL;
RimViewLinker* viewLinker = proj->viewLinkerCollection->viewLinker();
if (proj->viewLinkerCollection->viewLinker())
{
// We have a view linker, add not already linked views
viewLinker = proj->viewLinkerCollection->viewLinker();
for (size_t i = 0; i < views.size(); i++)
{
RimView* rimView = views[i];
if (rimView == viewLinker->masterView()) continue;
RimViewController* viewLink = new RimViewController;
viewLink->setManagedView(rimView);
viewLinker->viewLinks.push_back(viewLink);
viewLink->initAfterReadRecursively();
viewLink->updateOptionSensitivity();
viewLink->updateUiIconFromActiveState();
}
}
else
if (!viewLinker)
{
// Create a new view linker
@@ -167,35 +147,23 @@ void RicLinkVisibleViewsFeature::linkViews(std::vector<RimView*>& views)
viewLinker = new RimViewLinker;
proj->viewLinkerCollection()->viewLinker = viewLinker;
viewLinker->setMasterView(masterView);
for (size_t i = 0; i < views.size(); i++)
{
RimView* rimView = views[i];
if (rimView == masterView) continue;
RimViewController* viewLink = new RimViewController;
viewLink->setManagedView(rimView);
viewLinker->viewLinks.push_back(viewLink);
viewLink->initAfterReadRecursively();
viewLink->updateOptionSensitivity();
viewLink->updateUiIconFromActiveState();
}
viewLinker->updateUiIcon();
}
viewLinker->applyAllOperations();
for (size_t i = 0; i < views.size(); i++)
{
RimView* rimView = views[i];
if (rimView == viewLinker->masterView()) continue;
viewLinker->addDependentView(rimView);
}
viewLinker->updateUiNameAndIcon();
viewLinker->updateDependentViews();
proj->viewLinkerCollection.uiCapability()->updateConnectedEditors();
proj->updateConnectedEditors();
// Set managed view collection to selected and expanded in project tree
caf::PdmUiTreeView* projTreeView = RiuMainWindow::instance()->projectTreeView();
QModelIndex modIndex = projTreeView->findModelIndex(viewLinker);
projTreeView->treeView()->setCurrentIndex(modIndex);
RiuMainWindow::instance()->projectTreeView()->setExpanded(viewLinker, true);
projTreeView->treeView()->setExpanded(modIndex, true);
}

43
ApplicationCode/Commands/ViewLink/RicSetMasterViewFeature.cpp
View File

@@ -70,51 +70,18 @@ void RicSetMasterViewFeature::onActionTriggered(bool isChecked)
RimView* previousMasterView = viewLinker->masterView();
RimViewController* previousViewLink = RimViewLinker::viewLinkForView(activeView);
if (previousViewLink)
{
size_t indexToErase = cvf::UNDEFINED_SIZE_T;
for (size_t i = 0; i < viewLinker->viewLinks.size(); i++)
{
if (viewLinker->viewLinks()[i] == previousViewLink)
{
indexToErase = i;
}
}
if (indexToErase != cvf::UNDEFINED_SIZE_T)
{
viewLinker->viewLinks().erase(indexToErase);
}
delete previousViewLink;
}
viewLinker->removeOverrides();
viewLinker->setMasterView(activeView);
viewLinker->addDependentView(previousMasterView);
viewLinker->updateDependentViews();
if (previousMasterView)
{
RimViewController* viewLink = new RimViewController;
viewLink->setManagedView(previousMasterView);
viewLinker->viewLinks.push_back(viewLink);
viewLink->initAfterReadRecursively();
viewLink->updateOptionSensitivity();
viewLink->updateUiIconFromActiveState();
}
viewLinker->applyAllOperations();
proj->viewLinkerCollection.uiCapability()->updateConnectedEditors();
proj->updateConnectedEditors();
// Set managed view collection to selected and expanded in project tree
caf::PdmUiTreeView* projTreeView = RiuMainWindow::instance()->projectTreeView();
QModelIndex modIndex = projTreeView->findModelIndex(viewLinker);
projTreeView->treeView()->setCurrentIndex(modIndex);
projTreeView->treeView()->setExpanded(modIndex, true);
projTreeView->selectAsCurrentItem(viewLinker);
projTreeView->setExpanded(viewLinker, true);
}
//--------------------------------------------------------------------------------------------------

28
ApplicationCode/Commands/ViewLink/RicShowLinkOptionsFeature.cpp
View File

@@ -42,8 +42,9 @@ bool RicShowLinkOptionsFeature::isCommandEnabled()
RimView* activeView = RiaApplication::instance()->activeReservoirView();
if (!activeView) return false;
RimProject* proj = RiaApplication::instance()->project();
if (proj->findViewLinkerFromView(activeView))
RimViewController* viewController = activeView->controllingViewLink();
if (viewController)
{
return true;
}
@@ -59,28 +60,9 @@ void RicShowLinkOptionsFeature::onActionTriggered(bool isChecked)
RimView* activeView = RiaApplication::instance()->activeReservoirView();
if (!activeView) return;
RimProject* proj = RiaApplication::instance()->project();
RimViewLinker* viewLinker = proj->findViewLinkerFromView(activeView);
if (viewLinker)
{
if (viewLinker->masterView() == activeView)
{
RiuMainWindow::instance()->projectTreeView()->selectAsCurrentItem(viewLinker);
RimViewController* viewController = activeView->controllingViewLink();
return;
}
for (size_t i = 0; i < viewLinker->viewLinks.size(); i++)
{
RimViewController* viewLink = viewLinker->viewLinks[i];
if (viewLink->managedView() == activeView)
{
RiuMainWindow::instance()->projectTreeView()->selectAsCurrentItem(viewLink);
return;
}
}
}
RiuMainWindow::instance()->projectTreeView()->selectAsCurrentItem(viewController);
}
//--------------------------------------------------------------------------------------------------

39
ApplicationCode/Commands/ViewLink/RicUnLinkViewFeature.cpp
View File

@@ -39,20 +39,16 @@ bool RicUnLinkViewFeature::isCommandEnabled()
{
RimView* activeView = RiaApplication::instance()->activeReservoirView();
if (!activeView) return false;
RimProject* proj = RiaApplication::instance()->project();
RimViewLinker* viewLinker = proj->findViewLinkerFromView(activeView);
if (viewLinker)
RimViewController* viewController = activeView->controllingViewLink();
if (viewController)
{
if (viewLinker->masterView() == activeView)
{
return false;
}
return true;
}
return false;
}
//--------------------------------------------------------------------------------------------------
@@ -62,27 +58,16 @@ void RicUnLinkViewFeature::onActionTriggered(bool isChecked)
{
RimView* activeView = RiaApplication::instance()->activeReservoirView();
if (!activeView) return;
RimViewController* viewController = activeView->controllingViewLink();
caf::SelectionManager::instance()->setSelectedItem(viewController);
RimProject* proj = RiaApplication::instance()->project();
RimViewLinker* viewLinker = proj->findViewLinkerFromView(activeView);
if (viewLinker)
caf::CmdFeature* feature = caf::CmdFeatureManager::instance()->getCommandFeature("RicDeleteItemFeature");
if (feature)
{
for (size_t i = 0; i < viewLinker->viewLinks.size(); i++)
{
RimViewController* viewLink = viewLinker->viewLinks[i];
if (viewLink->managedView() == activeView)
{
caf::SelectionManager::instance()->setSelectedItem(viewLink);
feature->action()->trigger();
caf::CmdFeature* feature = caf::CmdFeatureManager::instance()->getCommandFeature("RicDeleteItemFeature");
if (feature)
{
feature->action()->trigger();
return;
}
}
}
return;
}
}

13
ApplicationCode/ProjectDataModel/RimViewLink.cpp
View File

@@ -147,7 +147,7 @@ void RimViewController::fieldChangedByUi(const caf::PdmFieldHandle* changedField
{
if (changedField == &isActive)
{
updateUiIconFromActiveState();
updateDisplayNameAndIcon();
if (syncCamera()) doSyncCamera();
if (syncTimeStep()) doSyncTimeStep();
if (syncCellResult()) doSyncCellResult();
@@ -228,7 +228,6 @@ void RimViewController::fieldChangedByUi(const caf::PdmFieldHandle* changedField
updateOptionSensitivity();
updateDisplayNameAndIcon();
updateUiIconFromActiveState();
name.uiCapability()->updateConnectedEditors();
}
@@ -246,7 +245,6 @@ void RimViewController::initAfterRead()
{
configureOverrides();
updateDisplayNameAndIcon();
updateUiIconFromActiveState();
updateOptionSensitivity();
}
@@ -458,20 +456,13 @@ void RimViewController::removeOverrides()
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimViewController::updateUiIconFromActiveState()
{
RimViewLinker::applyIconEnabledState(this, m_originalIcon, !isActive());
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimViewController::updateDisplayNameAndIcon()
{
RimViewLinker::findNameAndIconFromView(&name.v(), &m_originalIcon, managedView());
RimViewLinker::applyIconEnabledState(this, m_originalIcon, !isActive());
}
//--------------------------------------------------------------------------------------------------

1
ApplicationCode/ProjectDataModel/RimViewLink.h
View File

@@ -68,7 +68,6 @@ public:
void updateOptionSensitivity();
void removeOverrides();
void updateUiIconFromActiveState();
void updateDisplayNameAndIcon();
protected:

116
ApplicationCode/ProjectDataModel/RimViewLinker.cpp
View File

@@ -188,37 +188,18 @@ void RimViewLinker::updateCellResult()
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimViewLinker::updateRangeFilters()
{
if (!isActive()) return;
this->scheduleGeometryRegenForDepViews(RANGE_FILTERED);
this->scheduleGeometryRegenForDepViews(RANGE_FILTERED_INACTIVE);
this->scheduleCreateDisplayModelAndRedrawForDependentViews();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimViewLinker::updatePropertyFilters()
void RimViewLinker::updateOverrides()
{
if (!isActive()) return;
this->scheduleGeometryRegenForDepViews(PROPERTY_FILTERED);
this->scheduleCreateDisplayModelAndRedrawForDependentViews();
}
bool isViewlinkerActive = this->isActive();
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimViewLinker::configureOverrides()
{
for (size_t i = 0; i < viewLinks.size(); i++)
{
RimViewController* viewLink = viewLinks[i];
if (viewLink->isActive)
if (isViewlinkerActive && viewLink->isActive)
{
viewLink->configureOverrides();
}
@@ -229,6 +210,20 @@ void RimViewLinker::configureOverrides()
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimViewLinker::removeOverrides()
{
for (size_t i = 0; i < viewLinks.size(); i++)
{
if (viewLinks[i]->managedView())
{
viewLinks[i]->removeOverrides();
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -253,14 +248,13 @@ void RimViewLinker::allViewsForCameraSync(RimView* source, std::vector<RimView*>
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimViewLinker::applyAllOperations()
void RimViewLinker::updateDependentViews()
{
configureOverrides();
updateOverrides();
updateCellResult();
updateTimeStep(m_masterView, m_masterView->currentTimeStep());
updateRangeFilters();
updatePropertyFilters();
updateScaleZ(m_masterView, m_masterView->scaleZ());
updateCamera(m_masterView);
}
@@ -288,10 +282,20 @@ QString RimViewLinker::displayNameForView(RimView* view)
//--------------------------------------------------------------------------------------------------
void RimViewLinker::setMasterView(RimView* view)
{
RimViewController* previousViewLink = RimViewLinker::viewLinkForView(view);
// Remove the view as dependent view
if (previousViewLink)
{
this->viewLinks.removeChildObject(previousViewLink);
delete previousViewLink;
}
this->removeOverrides();
m_masterView = view;
setNameAndIcon();
updateUiIcon();
updateUiNameAndIcon();
}
//--------------------------------------------------------------------------------------------------
@@ -323,8 +327,7 @@ void RimViewLinker::allViews(std::vector<RimView*>& views)
//--------------------------------------------------------------------------------------------------
void RimViewLinker::initAfterRead()
{
setNameAndIcon();
updateUiIcon();
updateUiNameAndIcon();
}
//--------------------------------------------------------------------------------------------------
@@ -384,20 +387,14 @@ void RimViewLinker::applyIconEnabledState(caf::PdmObject* obj, const QIcon& icon
obj->setUiIcon(newIcon);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimViewLinker::updateUiIcon()
{
RimViewLinker::applyIconEnabledState(this, m_originalIcon, false);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimViewLinker::setNameAndIcon()
void RimViewLinker::updateUiNameAndIcon()
{
RimViewLinker::findNameAndIconFromView(&m_name.v(), &m_originalIcon, m_masterView);
RimViewLinker::applyIconEnabledState(this, m_originalIcon, false);
}
//--------------------------------------------------------------------------------------------------
@@ -448,19 +445,6 @@ void RimViewLinker::scheduleCreateDisplayModelAndRedrawForDependentViews()
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimViewLinker::removeOverrides()
{
for (size_t i = 0; i < viewLinks.size(); i++)
{
if (viewLinks[i]->managedView())
{
viewLinks[i]->removeOverrides();
}
}
}
//--------------------------------------------------------------------------------------------------
///
@@ -559,7 +543,7 @@ void RimViewLinker::updateCamera(RimView* sourceView)
if (!isActive()) return;
RimViewController* viewLink = RimViewLinker::viewLinkForView(sourceView);
RimViewController* viewLink = sourceView->controllingViewLink();
if (viewLink)
{
if ((!viewLink->isActive() || !viewLink->syncCamera()))
@@ -679,3 +663,31 @@ bool RimViewLinker::isBoundingBoxesOverlappingOrClose(const cvf::BoundingBox& so
return false;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimViewLinker::addDependentView(RimView* view)
{
CVF_ASSERT(view && view != m_masterView);
RimViewController* viewLink = new RimViewController;
this->viewLinks.push_back(viewLink);
viewLink->setManagedView(view);
viewLink->initAfterReadRecursively();
viewLink->updateOptionSensitivity();
viewLink->updateDisplayNameAndIcon();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimViewLinker::addViewControllers(caf::PdmUiTreeOrdering& uiTreeOrdering)
{
for (size_t j = 0; j < viewLinks.size(); j++)
{
uiTreeOrdering.add(viewLinks()[j]);
}
}

24
ApplicationCode/ProjectDataModel/RimViewLinker.h
View File

@@ -52,26 +52,23 @@ public:
void setMasterView(RimView* view);
RimView* masterView();
caf::PdmChildArrayField<RimViewController*> viewLinks;
void applyAllOperations();
void removeOverrides();
void addDependentView(RimView* view);
void updateDependentViews();
void updateCamera(RimView* sourceView);
void updateTimeStep(RimView* sourceView, int timeStep);
void updateScaleZ(RimView* sourceView, double scaleZ);
void updateCellResult();
void updateRangeFilters();
void updatePropertyFilters();
void scheduleGeometryRegenForDepViews(RivCellSetEnum geometryType);
void scheduleCreateDisplayModelAndRedrawForDependentViews();
void allViews(std::vector<RimView*>& views);
void updateUiIcon();
void setNameAndIcon();
void updateUiNameAndIcon();
void addViewControllers(caf::PdmUiTreeOrdering& uiTreeOrdering);
static void applyIconEnabledState(caf::PdmObject* obj, const QIcon& icon, bool disable);
static void findNameAndIconFromView(QString* name, QIcon* icon, RimView* view);
@@ -90,13 +87,16 @@ protected:
private:
void allViewsForCameraSync(RimView* source, std::vector<RimView*>& views);
void configureOverrides();
void updateOverrides();
void removeOverrides();
bool isActive();
static bool isBoundingBoxesOverlappingOrClose(const cvf::BoundingBox& sourceBB, const cvf::BoundingBox& destBB);
private:
caf::PdmPtrField<RimView*> m_masterView;
caf::PdmField<QString> m_name;
QIcon m_originalIcon;
caf::PdmChildArrayField<RimViewController*> viewLinks;
caf::PdmPtrField<RimView*> m_masterView;
caf::PdmField<QString> m_name;
QIcon m_originalIcon;
};

19
ApplicationCode/ProjectDataModel/RimViewLinkerCollection.cpp
View File

@@ -59,10 +59,7 @@ void RimViewLinkerCollection::defineUiTreeOrdering(caf::PdmUiTreeOrdering& uiTre
if (childObject)
{
uiTreeOrdering.add(childObject);
for (size_t j = 0; j < childObject->viewLinks.size(); j++)
{
uiTreeOrdering.add(childObject->viewLinks()[j]);
}
childObject->addViewControllers(uiTreeOrdering);
}
uiTreeOrdering.setForgetRemainingFields(true);
@@ -75,19 +72,9 @@ void RimViewLinkerCollection::fieldChangedByUi(const caf::PdmFieldHandle* change
{
if (&isActive == changedField)
{
if (isActive)
if (viewLinker())
{
if (viewLinker())
{
viewLinker()->applyAllOperations();
}
}
else
{
if (viewLinker())
{
viewLinker()->removeOverrides();
}
viewLinker()->updateDependentViews();
}
}