void groupMarkers(Wt::WTreeTable *markerTree)
{
Wt::WTreeNode *parent;
Wt::WTreeNode *newNode;
std::set<Wt::WTreeNode*> unSortedselectedNodes =markerTree->tree()->selectedNodes();
std::vector<Wt::WTreeNode*> selectedNodes ( unSortedselectedNodes.begin(), unSortedselectedNodes.end());
std::sort(selectedNodes.begin(),selectedNodes.end(), fragmentAbeforeB);
std::vector< Wt::WTreeNode*> siblings;
Wt::WTreeNode *firstNode = *selectedNodes.begin();
if(firstNode == markerTree->tree()->treeRoot())
{
return;
}
parent = firstNode->parentNode();
newNode = MyTreeTableNode::addNode(0 ,"Group" ,-1,-1);
siblings = parent->childNodes();
int index = std::find(siblings.begin(), siblings.end(), firstNode) - siblings.begin();
parent->insertChildNode(index, newNode);
for(auto node:selectedNodes)
{
parent->removeChildNode(node);
newNode->addChildNode(node);
}
}
void SegmentationWindow::OnUpdateMenuSegmentationSplitNodeAddSubgroup(wxUpdateUIEvent& e)
{
e.Enable(false);
// Check that the selection is available.
if(!m_model->selection()) return;
// Check that we're in the process of splitting a node.
PartitionView::NodeSplitManager_Ptr nodeSplitManager = m_view->node_split_manager();
PFNodeID splitNode = nodeSplitManager->split_node();
if(splitNode == PFNodeID::invalid()) return;
// Check that we're viewing the layer containing the split children, and that all the selected nodes are in this layer.
int viewLayer = m_view->camera()->slice_location().layer;
if(viewLayer != splitNode.layer() - 1) return;
int mergeLayer = m_model->selection()->merge_layer(viewLayer);
if(mergeLayer != viewLayer) return;
// Check that all the selected nodes are as-yet-unallocated children of the split node.
std::set<PFNodeID> selectedNodes(m_model->selection()->view_at_layer_cbegin(mergeLayer), m_model->selection()->view_at_layer_cend(mergeLayer));
const std::set<PFNodeID>& unallocatedChildren = nodeSplitManager->unallocated_children();
if(!std::includes(unallocatedChildren.begin(), unallocatedChildren.end(), selectedNodes.begin(), selectedNodes.end())) return;
// Check that the selected nodes are connected.
std::set<int> selectedNodeIndices;
for(std::set<PFNodeID>::const_iterator it=selectedNodes.begin(), iend=selectedNodes.end(); it!=iend; ++it)
{
selectedNodeIndices.insert(it->index());
}
e.Enable(m_model->volume_ipf()->are_connected(selectedNodeIndices, splitNode.layer() - 1));
}
QList<QgsLayerTreeLayer*> QgsLayerTreeView::selectedLayerNodes() const
{
QList<QgsLayerTreeLayer*> layerNodes;
foreach ( QgsLayerTreeNode* node, selectedNodes() )
{
if ( QgsLayerTree::isLayer( node ) )
layerNodes << QgsLayerTree::toLayer( node );
}
return layerNodes;
}
void GraphScene::save(bool){
auto selected_nodes = selectedNodes();
for(auto node : selected_nodes){
auto proxy = dynamic_cast<aq::DataStreamProxy*>(node->nodeDataModel());
if(proxy){
QString filename =
QFileDialog::getSaveFileName(nullptr,
tr("Open Flow Scene"),
QDir::homePath(),
tr("Flow Scene Files (*.json)"));
std::ofstream ofs(filename.toStdString());
aq::JSONOutputArchive ar(ofs, aq::JSONOutputArchive::Options(), *vm, *sm);
auto ds_nodes = proxy->m_obj->getAllNodes();
std::map<std::string, cv::Vec2f> node_position_map;
for(auto node_itr = this->_nodes.begin(); node_itr != this->_nodes.end(); ++node_itr){
if(auto node_proxy = dynamic_cast<aq::NodeProxy*>(node_itr->second->nodeDataModel())){
for(const auto& node : ds_nodes){
if(node_proxy->m_obj == node){
QtNodes::NodeGraphicsObject& ngo = node_itr->second->nodeGraphicsObject();
node_position_map[node->getTreeName()] = cv::Vec2f(ngo.pos().x(), ngo.pos().y());
continue;
}
}
continue;
}
if(auto fg_proxy = dynamic_cast<aq::FrameGrabberProxy*>(node_itr->second->nodeDataModel())){
for (const auto& node : ds_nodes) {
if (fg_proxy->m_obj == node) {
QtNodes::NodeGraphicsObject& ngo = node_itr->second->nodeGraphicsObject();
node_position_map[node->getTreeName()] = cv::Vec2f(ngo.pos().x(), ngo.pos().y());
continue;
}
}
continue;
}
}
ar(cereal::make_nvp("ui_node_positions", node_position_map));
std::vector<rcc::shared_ptr<aq::IDataStream>> dsvec;
dsvec.push_back(proxy->m_obj);
aq::IDataStream::save(ar, dsvec);
return;
}
}
}
void joinSelectedFragments(Wt::WTreeTable *markerTree)
{
long prevStop = -2; //To check for contiguous fragments. Fragment times are never negative, but -1 is used to signify groups
std::string newname ="";
std::set<Wt::WTreeNode*> unSortedselectedNodes =markerTree->tree()->selectedNodes();
std::vector<Wt::WTreeNode*> selectedNodes ( unSortedselectedNodes.begin(), unSortedselectedNodes.end());
std::sort(selectedNodes.begin(),selectedNodes.end(), fragmentAbeforeB);
for (auto node:selectedNodes) {
//tree returns a tree with tree nodes. We need treetable nodes!
MyTreeTableNode *fragmentTTN = dynamic_cast<MyTreeTableNode*>(node);
long start = fragmentTTN->startWidget->time();
long stop = fragmentTTN->stopWidget->time();
if (prevStop !=-2)
{
if (prevStop != start)
{
return; //Not contiguous
}
}
prevStop = stop;
newname +=" "+ fragmentTTN->text.narrow();
}
//Change the first node
MyTreeTableNode *firstNode = dynamic_cast<MyTreeTableNode*>(*selectedNodes.begin());
std::string str = newname;
str.erase(std::remove(str.begin(), str.end(), ' '), str.end()); //This removes whitespace
if(str.length()>1)
{
firstNode->editWidget->setText(newname);
}
firstNode->stopWidget->setTime(prevStop);
bool first=true;
//Dwlete all others
for (auto node:selectedNodes)
{
if (not first)
{
node->parentNode()->removeChildNode(node);
}
first = false;
}
}
void ungroupMarkers(Wt::WTreeTable *markerTree)
{
std::vector< Wt::WTreeNode*> siblings;
Wt::WTreeNode *parent;
Wt::WTreeNode *grandparent;
std::vector< Wt::WTreeNode*> uncles; //My parents siblings
int index = 0;
std::set<Wt::WTreeNode*> unSortedselectedNodes = markerTree->tree()->selectedNodes();
std::vector<Wt::WTreeNode*> selectedNodes ( unSortedselectedNodes.begin(), unSortedselectedNodes.end());
std::sort(selectedNodes.begin(),selectedNodes.end(), fragmentAbeforeB);
Wt::WTreeNode *firstNode = *selectedNodes.begin();
Wt::WTreeNode *lastNode = *selectedNodes.rbegin(); //Note, the reverse of the beginning is not the end
parent = firstNode->parentNode();
if(parent == markerTree->tree()->treeRoot())
{
return;
}
siblings = parent->childNodes();
if(firstNode != siblings.front() and lastNode != siblings.back())
{
return;
}
grandparent = parent->parentNode();
uncles = grandparent->childNodes();
index = std::find(uncles.begin(), uncles.end(), parent) - uncles.begin();
if (firstNode == siblings.front() and lastNode != siblings.back())
{
index--;
}
for (auto node:selectedNodes)
{
parent->removeChildNode(node);
index++;
grandparent->insertChildNode(index,node);
}
}
void DesignDocumentController::copySelected()
{
QScopedPointer<Model> model(Model::create("QtQuick.Rectangle", 1, 0, this->model()));
model->setFileUrl(d->model->fileUrl());
model->changeImports(d->model->imports(), QList<Import>());
Q_ASSERT(model);
DesignDocumentControllerView view;
d->model->attachView(&view);
if (view.selectedModelNodes().isEmpty())
return;
QList<ModelNode> selectedNodes(view.selectedModelNodes());
foreach (const ModelNode &node, selectedNodes) {
foreach (const ModelNode &node2, selectedNodes) {
if (node.isAncestorOf(node2))
selectedNodes.removeAll(node2);
}
}
/******************************************************************************
* Inserts the given modifier into the modification pipeline of the
* selected scene nodes.
******************************************************************************/
void ModificationListModel::applyModifier(Modifier* modifier)
{
// Get the selected stack entry. The new modifier is inserted just behind it.
ModificationListItem* currentItem = selectedItem();
// On the next list update, the new modifier should be selected.
_nextToSelectObject = modifier;
if(currentItem) {
if(dynamic_object_cast<Modifier>(currentItem->object())) {
for(ModifierApplication* modApp : currentItem->modifierApplications()) {
PipelineObject* pipelineObj = modApp->pipelineObject();
OVITO_CHECK_OBJECT_POINTER(pipelineObj);
pipelineObj->insertModifier(modifier, pipelineObj->modifierApplications().indexOf(modApp) + 1);
}
return;
}
else if(dynamic_object_cast<PipelineObject>(currentItem->object())) {
PipelineObject* pipelineObj = static_object_cast<PipelineObject>(currentItem->object());
OVITO_CHECK_OBJECT_POINTER(pipelineObj);
pipelineObj->insertModifier(modifier, 0);
return;
}
else if(dynamic_object_cast<DataObject>(currentItem->object())) {
if(PipelineObject* pipelineObj = hiddenPipelineObject()) {
pipelineObj->insertModifier(modifier, 0);
return;
}
}
}
// Apply modifier to each selected node.
for(ObjectNode* objNode : selectedNodes()) {
objNode->applyModifier(modifier);
}
}
