void set_parent(viewport::control& Viewport, k3d::inode& Parent) { m_set_parent = false; m_document_state.clear_cursor_signal().emit(); k3d::imatrix_source* const matrix_source = dynamic_cast<k3d::imatrix_source*>(&Parent); return_if_fail(matrix_source); const k3d::matrix4 parent_compensation = k3d::inverse(k3d::node_to_world_matrix(Parent)); k3d::ipipeline::dependencies_t dependencies; k3d::record_state_change_set changeset(m_document_state.document(), _("Set Parent"), K3D_CHANGE_SET_CONTEXT); // Note - we enumerate over a *copy* of the set of document nodes, since we're adding nodes as we go ... const k3d::nodes_t nodes = m_document_state.document().nodes().collection(); for(k3d::nodes_t::const_iterator node = nodes.begin(); node != nodes.end(); ++node) { // Ensure we don't try to parent an object to itself ... if(&Parent == *node) continue; if(!selection::state(m_document_state.document()).is_selected(**node)) continue; const transform_history_t history = parent_to_node_history(**node); if(!history.empty()) { if(k3d::imatrix_sink* const matrix_sink = dynamic_cast<k3d::imatrix_sink*>(history.front())) { const transform_modifier modifier = create_transform_modifier(m_document_state.document(), k3d::classes::FrozenMatrix(), "Parent Compensation"); if(modifier) { k3d::property::set_internal_value(*modifier.node, "matrix", parent_compensation); dependencies.insert(std::make_pair(&matrix_sink->matrix_sink_input(), &modifier.source->matrix_source_output())); dependencies.insert(std::make_pair(&modifier.sink->matrix_sink_input(), &matrix_source->matrix_source_output())); } } } if(k3d::iparentable* const parentable = dynamic_cast<k3d::iparentable*>(*node)) { if(k3d::iwritable_property* const writable_parent = dynamic_cast<k3d::iwritable_property*>(&parentable->parent())) writable_parent->property_set_value(&Parent); } } selection::state(m_document_state.document()).deselect_all(); selection::state(m_document_state.document()).select(Parent); m_document_state.document().pipeline().set_dependencies(dependencies); }
Area& operator=(const Area& area) { id(area.id()); version(area.version()); changeset(area.changeset()); timestamp(area.timestamp()); endtime(area.endtime()); uid(area.uid()); user(area.user()); visible(area.visible()); tags(area.tags()); m_node_list = area.m_node_list; m_relation_member_list = area.m_relation_member_list; m_geos_geometry = dynamic_cast<geos::geom::MultiPolygon*>(area.m_geos_geometry->clone()); return *this; }
bool RealTrafficIPC::sendChangeset( const Disturbances& newElements, const Disturbances& removedElements ) { Disturbances newClonedElements; Disturbances removedClonedElements; clone( newElements, newClonedElements ); clone( removedElements, removedClonedElements ); DisturbanceChangeset changeset( newClonedElements, removedClonedElements ); // create the packet DisturbanceChangesetRequestPacket* packet = new DisturbanceChangesetRequestPacket( Packet::PacketID( 0 ), m_moduleCom.getNextRequestID(), changeset ); uint32 mapID = MAX_UINT32; if ( ! newElements.empty() ) { mapID = newElements.front()->getMapID(); } else if ( ! removedElements.empty() ) { mapID = removedElements.front()->getMapID(); } packet->setMapID( mapID ); // send the packet and get the packet container as a return. auto_ptr<PacketContainer> cont( m_moduleCom. putRequest( packet, MODULE_TYPE_TRAFFIC ) ); DisturbanceChangesetReplyPacket* answer; if ( getValidPacket( answer, cont.get() ) ) { if( answer && answer->getStatus() == StringTable::OK ) { mc2dbg4 << "[RTIPC] send change set OK" << endl; return true; } else { if ( answer->getUpdateStatus() == StringTable::NOTOK ) { mc2log << warn << "[RTIPC] Failed to update new DisturbanceElements." << endl; } if ( answer->getRemoveStatus() == StringTable::NOTOK ) { mc2log << warn << "[RTIPC] Failed to remove old DisturbanceElements." << endl; } } } return false; }
void flushchanges(void) { int a, b, c, d, at; int i, j; if(nchanges == 0) return; for(i=0; i<nchanges; ){ j = changeset(i); a = changes[i].a-Lines; b = changes[j-1].b+Lines; c = changes[i].c-Lines; d = changes[j-1].d+Lines; if(a < 1) a = 1; if(c < 1) c = 1; if(b > len[0]) b = len[0]; if(d > len[1]) d = len[1]; if(mode == 'a'){ a = 1; b = len[0]; c = 1; d = len[1]; j = nchanges; } Bprint(&stdout, "%s:", file1); range(a, b, ","); Bprint(&stdout, " - "); Bprint(&stdout, "%s:", file2); range(c, d, ","); Bputc(&stdout, '\n'); at = a; for(; i<j; i++){ fetch(ixold, at, changes[i].a-1, input[0], " "); fetch(ixold, changes[i].a, changes[i].b, input[0], "- "); fetch(ixnew, changes[i].c, changes[i].d, input[1], "+ "); at = changes[i].b+1; } fetch(ixold, at, b, input[0], " "); } nchanges = 0; }
/** * Set named attribute. * @param attr Name of the attribute (must be one of "id", "version", "changeset", "timestamp", "uid", "user", "visible") * @param value Value of the attribute */ void set_attribute(const char* attr, const char* value) { if (!strcmp(attr, "id")) { id(value); } else if (!strcmp(attr, "version")) { version(value); } else if (!strcmp(attr, "changeset")) { changeset(value); } else if (!strcmp(attr, "timestamp")) { timestamp(value); } else if (!strcmp(attr, "uid")) { uid(value); } else if (!strcmp(attr, "user")) { user(value); } else if (!strcmp(attr, "visible")) { visible(value); } }
/// Modify transformation inode* modify_transformation(idocument& Document, inode& Object, iplugin_factory* Modifier) { return_val_if_fail(Modifier, 0); // Get the upstream and downstream properties ... imatrix_sink* const downstream_sink = dynamic_cast<imatrix_sink*>(&Object); return_val_if_fail(downstream_sink, 0); iproperty& downstream_input = downstream_sink->matrix_sink_input(); iproperty* const upstream_output = Document.pipeline().dependency(downstream_input); inode* modifier = 0; // This block is recorded for undo purposes ... { record_state_change_set changeset(Document, string_cast(boost::format(_("Add Modifier %1%")) % Modifier->name()), K3D_CHANGE_SET_CONTEXT); // Create our modifier object ... modifier = plugin::create<inode>(*Modifier, Document, unique_name(Document.nodes(), Modifier->name())); return_val_if_fail(modifier, 0); // Get its input and output properties ... imatrix_sink* const modifier_sink = dynamic_cast<imatrix_sink*>(modifier); return_val_if_fail(modifier_sink, 0); imatrix_source* const modifier_source = dynamic_cast<imatrix_source*>(modifier); return_val_if_fail(modifier_source, 0); // Insert the modifier into the DAG ... ipipeline::dependencies_t dependencies; if(upstream_output) dependencies.insert(std::make_pair(&modifier_sink->matrix_sink_input(), upstream_output)); dependencies.insert(std::make_pair(&downstream_input, &modifier_source->matrix_source_output())); Document.pipeline().set_dependencies(dependencies); } return modifier; }
v8::Handle<v8::Value> js_changeset() const { return v8::Number::New(changeset()); }
void modify_selected_meshes(document_state& DocumentState, iplugin_factory* Modifier) { return_if_fail(Modifier); idocument& document = DocumentState.document(); if (Modifier->implements(typeid(imulti_mesh_sink))) { // Mesh modifier taking multiple inputs uint_t count = 0; ipipeline::dependencies_t dependencies; const nodes_t selected_nodes = selection::state(DocumentState.document()).selected_nodes(); // Create the node inode* multi_sink = pipeline::create_node(document, *Modifier); record_state_change_set changeset(document, string_cast(boost::format(_("Add Modifier %1%")) % Modifier->name()), K3D_CHANGE_SET_CONTEXT); nodes_t nodes_to_delete; for(nodes_t::const_iterator node = selected_nodes.begin(); node != selected_nodes.end(); ++node) { imesh_sink* const mesh_sink = dynamic_cast<imesh_sink*>(*node); if(!mesh_sink) continue; imatrix_sink* const matrix_sink = dynamic_cast<imatrix_sink*>(*node); iproperty* source_mesh = document.pipeline().dependency(mesh_sink->mesh_sink_input()); if (!source_mesh) continue; if (matrix_sink) // Insert a transform node { iproperty* const source_transformation = document.pipeline().dependency(matrix_sink->matrix_sink_input()); if (source_transformation) { inode* transform_points = plugin::create<inode>("TransformPoints", document, unique_name(document.nodes(), "TransformPoints")); return_if_fail(transform_points); imatrix_sink* transform_points_matrix_sink = dynamic_cast<imatrix_sink*>(transform_points); return_if_fail(transform_points_matrix_sink); imesh_sink* transform_points_mesh_sink = dynamic_cast<imesh_sink*>(transform_points); return_if_fail(transform_points_mesh_sink); dependencies.insert(std::make_pair(&transform_points_matrix_sink->matrix_sink_input(), source_transformation)); dependencies.insert(std::make_pair(&transform_points_mesh_sink->mesh_sink_input(), source_mesh)); imesh_source* transform_points_mesh_source = dynamic_cast<imesh_source*>(transform_points); return_if_fail(transform_points_mesh_source); source_mesh = &transform_points_mesh_source->mesh_source_output(); imesh_selection_sink* selection_sink = dynamic_cast<imesh_selection_sink*>(transform_points); return_if_fail(selection_sink); property::set_internal_value(selection_sink->mesh_selection_sink_input(), k3d::geometry::selection::create(1.0)); } } ++count; // Create a new user property std::stringstream name, label; name << "input_mesh" << count; label << "Input Mesh " << count; iproperty* sink = property::get(*multi_sink, name.str()); if (!sink) sink = property::create<mesh*>(*multi_sink, name.str(), label.str(), "", static_cast<mesh*>(0)); // Store the connection dependencies.insert(std::make_pair(sink, source_mesh)); // Delete the input node nodes_to_delete.push_back(*node); } document.pipeline().set_dependencies(dependencies); delete_nodes(document, nodes_to_delete); // Give nodes a chance to initialize their property values based on their inputs, if any ... if(ireset_properties* const reset_properties = dynamic_cast<ireset_properties*>(multi_sink)) reset_properties->reset_properties(); panel::mediator(DocumentState.document()).set_focus(*multi_sink); } else { // Normal mesh modifier nodes_t new_modifiers; const nodes_t selected_nodes = selection::state(DocumentState.document()).selected_nodes(); for(nodes_t::const_iterator node = selected_nodes.begin(); node != selected_nodes.end(); ++node) { new_modifiers.push_back(modify_mesh(DocumentState, **node, Modifier)); assert_warning(new_modifiers.back()); } // Show the new modifier properties if only one was processed if(selected_nodes.size() == 1) { panel::mediator(DocumentState.document()).set_focus(*new_modifiers.front()); } else // otherwise connect all parameter properties to the first node and show that one { iproperty_collection* first_property_collection = dynamic_cast<iproperty_collection*>(new_modifiers.front()); if (first_property_collection) { // Get the in-and output property names, to exclude them from the connections imesh_sink* const modifier_sink = dynamic_cast<imesh_sink*>(new_modifiers.front()); return_if_fail(modifier_sink); imesh_source* const modifier_source = dynamic_cast<imesh_source*>(new_modifiers.front()); return_if_fail(modifier_source); const std::string sink_name = modifier_sink->mesh_sink_input().property_name(); const std::string source_name = modifier_source->mesh_source_output().property_name(); ipipeline::dependencies_t dependencies; const iproperty_collection::properties_t& first_properties = first_property_collection->properties(); nodes_t::iterator modifier = new_modifiers.begin(); ++modifier; for (modifier; modifier != new_modifiers.end(); ++modifier) { iproperty_collection* property_collection = dynamic_cast<iproperty_collection*>(*modifier); return_if_fail(property_collection); const iproperty_collection::properties_t& properties = property_collection->properties(); iproperty_collection::properties_t::const_iterator property = properties.begin(); for (iproperty_collection::properties_t::const_iterator first_property = first_properties.begin(); first_property != first_properties.end(); ++first_property) { return_if_fail(property != properties.end()); return_if_fail((*property)->property_name() == (*first_property)->property_name()); if ((*property)->property_name() == sink_name || (*property)->property_name() == source_name || (*property)->property_name() == "name") { ++property; continue; } dependencies.insert(std::make_pair(*property, *first_property)); ++property; } } document.pipeline().set_dependencies(dependencies); panel::mediator(DocumentState.document()).set_focus(*new_modifiers.front()); } } } }
/// Modify mesh inode* modify_mesh(document_state& DocumentState, inode& Node, iplugin_factory* Modifier) { return_val_if_fail(Modifier, 0); idocument& document = DocumentState.document(); // Get the upstream and downstream properties ... imesh_sink* const downstream_sink = dynamic_cast<imesh_sink*>(&Node); return_val_if_fail(downstream_sink, 0); iproperty& downstream_input = downstream_sink->mesh_sink_input(); iproperty* const upstream_output = document.pipeline().dependency(downstream_input); return_val_if_fail(upstream_output, 0); inode* modifier = 0; // This block is recorded for undo purposes ... { record_state_change_set changeset(document, string_cast(boost::format(_("Add Modifier %1%")) % Modifier->name()), K3D_CHANGE_SET_CONTEXT); // Create our modifier object ... modifier = plugin::create<inode>(*Modifier, document, unique_name(document.nodes(), Modifier->name())); return_val_if_fail(modifier, 0); // Get its input and output properties ... imesh_sink* const modifier_sink = dynamic_cast<imesh_sink*>(modifier); return_val_if_fail(modifier_sink, 0); imesh_source* const modifier_source = dynamic_cast<imesh_source*>(modifier); // Insert the modifier into the pipeline ... ipipeline::dependencies_t dependencies; dependencies.insert(std::make_pair(&modifier_sink->mesh_sink_input(), upstream_output)); if(modifier_source) dependencies.insert(std::make_pair(&downstream_input, &modifier_source->mesh_source_output())); document.pipeline().set_dependencies(dependencies); // If the modifier is a mesh selection sink, set its selection state ... imesh_selection_sink* const modifier_mesh_selection_sink = dynamic_cast<imesh_selection_sink*>(modifier); imesh_selection_sink* const downstream_mesh_selection_sink = dynamic_cast<imesh_selection_sink*>(&Node); if(modifier_mesh_selection_sink && downstream_mesh_selection_sink) { if(selection::NODE == selection::state(DocumentState.document()).current_mode()) { property::set_internal_value( modifier_mesh_selection_sink->mesh_selection_sink_input(), geometry::selection::create(1)); } else { property::set_internal_value( modifier_mesh_selection_sink->mesh_selection_sink_input(), downstream_mesh_selection_sink->mesh_selection_sink_input().property_internal_value()); } property::set_internal_value( downstream_mesh_selection_sink->mesh_selection_sink_input(), k3d::selection::set()); } } // Give nodes a chance to initialize their property values based on their inputs, if any ... if(ireset_properties* const reset_properties = dynamic_cast<ireset_properties*>(modifier)) reset_properties->reset_properties(); return modifier; }