truefalse CRunner::do_init() { CCfg * l_obj = CCfgX::instance(); g_term_sns = &m_term_SNs; if (!m_pg.login_to_db()) { C_FATAL("fail to connect to database. quitting...\n"); return C_BAD; } if (!m_pg.load_term_SNs(&m_term_SNs)) { C_FATAL("fail to get term sn from db. quitting...\n"); return C_BAD; } if (l_obj->handleout()) { add_component(m_ping_container = new CPingContainer(this)); add_component(m_d2m_container = new CD2MContainer(this)); } if (l_obj->pre()) { add_component(m_position_container = new CPositionContainer(this)); add_component(m_balance_container = new CBalanceContainer(this)); add_component(m_bs_req_container = new CBsReqContainer(this)); } return C_OK; }
std::unique_ptr<nano::seq_con_info_component> nano::collect_seq_con_info (nano::node_observers & node_observers, const std::string & name) { auto composite = std::make_unique<nano::seq_con_info_composite> (name); composite->add_component (collect_seq_con_info (node_observers.blocks, "blocks")); composite->add_component (collect_seq_con_info (node_observers.wallet, "wallet")); composite->add_component (collect_seq_con_info (node_observers.vote, "vote")); composite->add_component (collect_seq_con_info (node_observers.account_balance, "account_balance")); composite->add_component (collect_seq_con_info (node_observers.endpoint, "endpoint")); composite->add_component (collect_seq_con_info (node_observers.disconnect, "disconnect")); return composite; }
std::unique_ptr<seq_con_info_component> collect_seq_con_info (work_pool & work_pool, const std::string & name) { auto composite = std::make_unique<seq_con_info_composite> (name); size_t count = 0; { std::lock_guard<std::mutex> (work_pool.mutex); count = work_pool.pending.size (); } auto sizeof_element = sizeof (decltype (work_pool.pending)::value_type); composite->add_component (std::make_unique<seq_con_info_leaf> (seq_con_info{ "pending", count, sizeof_element })); composite->add_component (collect_seq_con_info (work_pool.work_observers, "work_observers")); return composite; }
ElementLoop& BoundaryTerm::access_element_loop( const std::string& type_name ) { // ensure that the fields are present link_fields(); // get the element loop or create it if does not exist ElementLoop::Ptr loop; Common::Component::Ptr cloop = get_child_ptr( "LOOP" ); if( is_null( cloop ) ) { const std::string update_vars_type = physical_model().get_child( RDM::Tags::update_vars() ) .as_type<Physics::Variables>() .type(); loop = build_component_abstract_type_reduced< FaceLoop >( "FaceLoopT<" + type_name + "," + update_vars_type + ">" , "LOOP"); add_component(loop); } else loop = cloop->as_ptr_checked<ElementLoop>(); return *loop; }
CSolver& CModel::create_solver( const std::string& builder) { std::string solver_name = CBuilder::extract_reduced_name(builder); CSolver::Ptr solver = boost::algorithm::contains( builder, "." ) ? build_component_abstract_type< Solver::CSolver >( builder, solver_name ) : build_component_abstract_type_reduced< Solver::CSolver >( builder, solver_name ); add_component(solver); return *solver; }
Handle< common::Action > BoundaryConditions::add_constant_component_bc(const std::string& region_name, const std::string& variable_name, const Uint component_idx, const Real default_value) { MeshTerm<0, VectorField> var(variable_name, m_implementation->m_solution_tag); ConfigurableConstant<Real> value("value", "Value for constant boundary condition", default_value); boost::shared_ptr< common::Action > result = create_proto_action("BC"+region_name+variable_name, nodes_expression(m_implementation->dirichlet(var[component_idx]) = value)); add_component(result); m_implementation->configure_bc(*result, region_name); return Handle<common::Action>(result); }
void UNIFAQ::UNIFAQMixture::set_components(const std::string &identifier_type, std::vector<std::string> identifiers) { components.clear(); if (identifier_type == "name") { // Iterate over the provided names for (std::vector<std::string>::const_iterator it = identifiers.begin(); it != identifiers.end(); ++it) { // Get and add the component UNIFAQLibrary::Component c = library.get_component("name", *it); add_component(c); } } else { throw CoolProp::ValueError("Cannot understand identifier_type"); } }
CSolver& CModel::create_solver( const std::string& builder) { std::string solver_name = CBuilder::extract_reduced_name(builder); CSolver::Ptr solver = boost::algorithm::contains( builder, "." ) ? build_component_abstract_type< Solver::CSolver >( builder, solver_name ) : build_component_abstract_type_reduced< Solver::CSolver >( builder, solver_name ); add_component(solver); if(!m_implementation->m_physics.expired()) solver->configure_option_recursively(Tags::physical_model(), m_implementation->m_physics.lock()->uri()); return *solver; }
Handle<common::Action> BoundaryConditions::add_constant_bc(const std::string& region_name, const std::string& variable_name) { const VariablesDescriptor& descriptor = find_component_with_tag<VariablesDescriptor>(m_implementation->physical_model().variable_manager(), m_implementation->m_solution_tag); boost::shared_ptr< common::Action > result = descriptor.dimensionality(variable_name) == VariablesDescriptor::Dimensionalities::SCALAR ? m_implementation->create_constant_scalar_bc(region_name, variable_name) : m_implementation->create_constant_vector_bc(region_name, variable_name); add_component(result); // Append action m_implementation->configure_bc(*result, region_name); return Handle<Action>(result); }
CSolver& CModel::create_solver( const std::string& builder) { std::string solver_name = Builder::extract_reduced_name(builder); boost::shared_ptr< CSolver > solver = boost::algorithm::contains( builder, "." ) ? build_component_abstract_type< solver::CSolver >( builder, solver_name ) : build_component_abstract_type_reduced< solver::CSolver >( builder, solver_name ); add_component(solver); if(is_not_null(m_implementation->m_physics)) solver->configure_option_recursively(Tags::physical_model(), m_implementation->m_physics); return *solver; }
void LSSAction::on_regions_set() { if(m_implementation->m_updating) // avoid recursion return; m_implementation->m_lss = options().value< Handle<LSS::System> >("lss"); if(is_null(m_implementation->m_lss)) return; if(is_null(m_dictionary)) return; m_implementation->m_updating = true; // Create the LSS if the mesh is set if(!m_loop_regions.empty() && !m_implementation->m_lss->is_created()) { VariablesDescriptor& descriptor = find_component_with_tag<VariablesDescriptor>(physical_model().variable_manager(), solution_tag()); Handle< List<Uint> > gids = m_implementation->m_lss->create_component< List<Uint> >("GIDs"); Handle< List<Uint> > ranks = m_implementation->m_lss->create_component< List<Uint> >("Ranks"); Handle< List<Uint> > used_node_map = m_implementation->m_lss->create_component< List<Uint> >("used_node_map"); std::vector<Uint> node_connectivity, starting_indices; boost::shared_ptr< List<Uint> > used_nodes = build_sparsity(m_loop_regions, *m_dictionary, node_connectivity, starting_indices, *gids, *ranks, *used_node_map); add_component(used_nodes); // This comm pattern is valid only over the used nodes for the supplied regions PE::CommPattern& comm_pattern = *create_component<PE::CommPattern>("CommPattern"); comm_pattern.insert("gid",gids->array(),false); comm_pattern.setup(Handle<PE::CommWrapper>(comm_pattern.get_child("gid")),ranks->array()); CFdebug << "Creating LSS for " << starting_indices.size()-1 << " blocks with descriptor " << solution_tag() << ": " << descriptor.description() << CFendl; m_implementation->m_lss->create(comm_pattern, descriptor.size(), node_connectivity, starting_indices); CFdebug << "Finished creating LSS" << CFendl; configure_option_recursively(solver::Tags::regions(), options().option(solver::Tags::regions()).value()); configure_option_recursively("lss", m_implementation->m_lss); } // Update the regions of any owned initial conditions BOOST_FOREACH(const Handle<Component>& ic, m_created_initial_conditions) { ic->options().set(solver::Tags::regions(), options().option(solver::Tags::regions()).value()); }
void UNIFAC::UNIFACMixture::set_components(const std::string &identifier_type, std::vector<std::string> identifiers) { components.clear(); N = identifiers.size(); if (identifier_type == "name") { // Iterate over the provided names for (std::vector<std::string>::const_iterator it = identifiers.begin(); it != identifiers.end(); ++it) { // Get and add the component UNIFACLibrary::Component c = library.get_component("name", *it); add_component(c); } } else { throw CoolProp::ValueError("Cannot understand identifier_type"); } /// Calculate the parameters X and theta for the pure components, which does not depend on temperature nor molar fraction pure_data.clear(); for (std::size_t i = 0; i < N; ++i) { const UNIFACLibrary::Component &c = components[i]; ComponentData cd; double summerxq = 0; cd.group_count = 0; for (std::size_t j = 0; j < c.groups.size(); ++j) { const UNIFACLibrary::ComponentGroup &cg = c.groups[j]; double x = static_cast<double>(cg.count); double theta = static_cast<double>(cg.count*cg.group.Q_k); cd.X.insert(std::pair<int, double>(cg.group.sgi, x)); cd.theta.insert(std::pair<int, double>(cg.group.sgi, theta)); cd.group_count += cg.count; summerxq += x*cg.group.Q_k; } /// Now come back through and divide by the total # groups for this fluid for (std::map<std::size_t, double>::iterator it = cd.X.begin(); it != cd.X.end(); ++it) { it->second /= cd.group_count; //printf("X^(%d)_{%d}: %g\n", static_cast<int>(i + 1), static_cast<int>(it->first), it->second); } /// Now come back through and divide by the sum(X*Q) for this fluid for (std::map<std::size_t, double>::iterator it = cd.theta.begin(); it != cd.theta.end(); ++it) { it->second /= summerxq; //printf("theta^(%d)_{%d}: %g\n", static_cast<int>(i+1), static_cast<int>(it->first), it->second); } pure_data.push_back(cd); } }
static void component_row_activate_cb (GtkTreeView *view, GtkTreePath *path, GtkTreeViewColumn *column, gpointer null) { GtkTreeSelection *sel; GtkTreeIter iter; struct component *c; GtkTreeModel *model; sel = gtk_tree_view_get_selection (view); if (gtk_tree_selection_get_selected (sel, &model, &iter)) { gtk_tree_model_get (model, &iter, 1, &c, -1); add_component (c); } gtk_widget_destroy (component_dialog); component_dialog = NULL; choose_button = NULL; }
/** @brief The library entry point. It must have the same name for each * library fo the components loaded by the ST static component loader. * * This function fills the version, the component name and if existing also the roles * and the specific names for each role. This base function is only an explanation. * For each library it must be implemented, and it must fill data of any component * in the library * * @param stComponents pointer to an array of components descriptors.If NULL, the * function will return only the number of components contained in the library * * @return number of components contained in the library */ int omx_component_library_Setup(stLoaderComponentType **stLoader) { int i; DEBUG(DEB_LEV_FUNCTION_NAME, "In %s \n",__func__); if (stLoader == NULL) { DEBUG(DEB_LEV_FUNCTION_NAME, "Out of %s \n",__func__); return NUM_COMPONENTS; // Return Number of Components } for(i = 0; i < sizeof(stComponents) / sizeof(stComponent); i++) add_component(stLoader[i], stComponents[i].role, stComponents[i].name, stComponents[i].constructor); DEBUG(DEB_LEV_FUNCTION_NAME, "Out of %s \n",__func__); return NUM_COMPONENTS; }
RDM::BoundaryTerm& BoundaryConditions::create_boundary_condition( const std::string& type, const std::string& name, const std::vector<URI>& regions ) { boost::shared_ptr< RDM::BoundaryTerm > bterm = build_component_abstract_type<RDM::BoundaryTerm>(type,name); add_component( bterm ); // stays owned here // place link either in the weak or strong bcs if ( bterm->is_weak() ) m_weak_bcs->add_link( *bterm ); else m_strong_bcs->add_link( *bterm ); bterm->options().configure_option("regions" , regions); bterm->options().configure_option( RDM::Tags::mesh(), m_mesh); bterm->options().configure_option( RDM::Tags::solver() , m_solver); bterm->options().configure_option( RDM::Tags::physical_model() , m_physical_model); return *bterm; }
static void component_response_cb(GtkWidget *d, int response, GtkTreeSelection *sel) { GtkTreeModel *model; GtkTreeIter iter; GValue val; struct component *c; switch (response) { case AP_RESPONSE_CHOOSE: gtk_tree_selection_get_selected (sel, &model, &iter); val.g_type = 0; gtk_tree_model_get_value (model, &iter, 1, &val); c = g_value_get_pointer(&val); add_component (c); case GTK_RESPONSE_CLOSE: case GTK_RESPONSE_CANCEL: case GTK_RESPONSE_DELETE_EVENT: gtk_widget_destroy(d); component_dialog = NULL; choose_button = NULL; break; } }
CActionDirector& CActionDirector::append(const CAction::Ptr& action) { Component::Ptr existing_child = get_child_ptr(action->name()); if(is_null(existing_child)) { if(action->has_parent()) { CLink& action_link = create_component<CLink>(action->name()); action_link.link_to(action); } else { add_component(action); } on_action_added(*action); } else { // If a child with the given name existed, check that it corresponds to the supplied action CAction::Ptr existing_action = boost::dynamic_pointer_cast<CAction>(existing_child); if(is_null(existing_action)) throw ValueExists(FromHere(), "A component named " + action->name() + " already exists in " + uri().string() + ", but it is not a CAction"); if(existing_action != action) throw ValueExists(FromHere(), "An action named " + action->name() + " already exists in " + uri().string() + ", but it is different from the appended action"); } Option& actions_prop = option("ActionOrder"); std::vector<std::string> actions; actions_prop.put_value(actions); actions.push_back(action->name()); actions_prop.change_value(actions); return *this; }
// ========================================================================== // CONSTRUCTOR // ========================================================================== gm_tools_screen::gm_tools_screen() : pimpl_(std::make_shared<impl>()) { pimpl_->bestiary_page_ = std::make_shared<bestiary_page>(); pimpl_->beast_editor_ = std::make_shared<beast_editor>(); pimpl_->encounters_page_ = std::make_shared<encounters_page>(); pimpl_->encounter_editor_ = std::make_shared<encounter_editor>(); pimpl_->delete_beast_dialog_ = std::make_shared<delete_confirmation_dialog>(); pimpl_->delete_encounter_dialog_ = std::make_shared<delete_confirmation_dialog>(); pimpl_->bestiary_tab_card_ = munin::make_card(); pimpl_->bestiary_tab_card_->add_face(pimpl_->bestiary_page_, bestiary_face); pimpl_->bestiary_tab_card_->add_face(pimpl_->beast_editor_, beast_editor_face); pimpl_->bestiary_tab_card_->add_face(pimpl_->delete_beast_dialog_, delete_beast_face); pimpl_->bestiary_tab_card_->select_face(bestiary_face); pimpl_->encounter_tab_card_ = munin::make_card(); pimpl_->encounter_tab_card_->add_face(pimpl_->encounters_page_, encounters_face); pimpl_->encounter_tab_card_->add_face(pimpl_->encounter_editor_, encounter_editor_face); pimpl_->encounter_tab_card_->add_face(pimpl_->delete_encounter_dialog_, delete_encounter_face); pimpl_->encounter_tab_card_->select_face(encounters_face); pimpl_->bestiary_page_->on_edit.connect( [this](auto beast){pimpl_->on_edit_beast();}); pimpl_->bestiary_page_->on_new.connect([this]{pimpl_->on_new_beast();}); pimpl_->bestiary_page_->on_clone.connect( [this](auto beast){pimpl_->on_clone_beast();}); pimpl_->bestiary_page_->on_fight.connect(on_fight_beast); pimpl_->bestiary_page_->on_delete.connect( [this](auto beast){pimpl_->on_delete_beast();}); pimpl_->beast_editor_->on_save.connect([this]{pimpl_->on_save_beast();}); pimpl_->beast_editor_->on_revert.connect([this]{pimpl_->on_revert_beast();}); pimpl_->encounters_page_->on_new.connect([this]{pimpl_->on_new_encounter();}); pimpl_->encounters_page_->on_edit.connect( [this](auto encounter){pimpl_->on_edit_encounter();}); pimpl_->encounters_page_->on_clone.connect( [this](auto encounter){pimpl_->on_clone_encounter();}); pimpl_->encounters_page_->on_fight.connect(on_fight_encounter); pimpl_->encounters_page_->on_delete.connect( [this](auto encounter){pimpl_->on_delete_encounter();}); pimpl_->encounter_editor_->on_save.connect( [this]{pimpl_->on_save_encounter();}); pimpl_->encounter_editor_->on_revert.connect( [this]{pimpl_->on_revert_encounter();}); pimpl_->delete_beast_dialog_->on_delete_confirmation.connect( [this]{pimpl_->on_delete_beast_confirmation();}); pimpl_->delete_beast_dialog_->on_delete_rejection.connect( [this]{pimpl_->on_delete_beast_rejection();}); pimpl_->delete_encounter_dialog_->on_delete_confirmation.connect( [this]{pimpl_->on_delete_encounter_confirmation();}); pimpl_->delete_encounter_dialog_->on_delete_rejection.connect( [this]{pimpl_->on_delete_encounter_rejection();}); pimpl_->back_button_ = munin::make_button("Back"); pimpl_->back_button_->on_click.connect(on_back); pimpl_->tabbed_panel_ = munin::make_tabbed_panel(); pimpl_->tabbed_panel_->insert_tab("Bestiary", pimpl_->bestiary_tab_card_); pimpl_->tabbed_panel_->insert_tab("Encounters", pimpl_->encounter_tab_card_); auto content = get_container(); content->set_layout(munin::make_compass_layout()); content->add_component(pimpl_->tabbed_panel_, munin::COMPASS_LAYOUT_CENTRE); content->add_component( munin::view( munin::make_compass_layout(), pimpl_->back_button_, munin::COMPASS_LAYOUT_WEST, munin::make_background_fill(), munin::COMPASS_LAYOUT_CENTRE), munin::COMPASS_LAYOUT_SOUTH); }
static void handle_msg(int fd, struct msg* m) { switch (m->type) { case MSG_GET_HANDLE: { struct comp* c = (struct comp*) malloc(sizeof(struct comp)); fprintf(stderr, "ILSRV: GetHandle '%s'\n", m->cmd.get_handle.name); m->result = OMX_GetHandle(&c->real_handle, m->cmd.get_handle.name, c, &callbacks); m->cmd.get_handle.out_srv_handle = (int) c; c->client_handle = m->cmd.get_handle.in_client_handle; c->client_fd = fd; c->state = OMX_StateLoaded; strncpy(c->name, m->cmd.get_handle.name, sizeof(c->name)); c->name[sizeof(c->name)-1]=0; add_component(c); fprintf(stderr, "ILSRV: %08X [%20s] --> %s%s\n", c->real_handle, last_part(c->name), m->result == OMX_ErrorNone ? "" : "ERROR ", adm_log_err2str(m->result)); return; } case MSG_SET_PARAM:{ struct comp* c = (struct comp*) m->cmd.param.srv_handle; verify_component(c); fprintf(stderr, "ILSRV: %08X [%20s] SetParam %s\n", c->real_handle, last_part(c->name), adm_log_index2str(m->cmd.param.index)); m->result = OMX_SetParameter(c->real_handle, (OMX_INDEXTYPE) m->cmd.param.index, m->cmd.param.buf); // TODO: Protect fprintf(stderr, "ILSRV: --> %s %s\n", m->result == OMX_ErrorNone ? "" : "ERROR ", adm_log_err2str(m->result)); return; } case MSG_GET_PARAM:{ struct comp* c = (struct comp*) m->cmd.param.srv_handle; verify_component(c); fprintf(stderr, "ILSRV: %08X [%20s] GetParam %s\n", c->real_handle, last_part(c->name), adm_log_index2str(m->cmd.param.index)); m->result = OMX_GetParameter(c->real_handle, (OMX_INDEXTYPE)m->cmd.param.index, m->cmd.param.buf); // TODO: Protect fprintf(stderr, "ILSRV: --> %s %s\n", m->result == OMX_ErrorNone ? "" : "ERROR ", adm_log_err2str(m->result)); return; } case MSG_GET_CONFIG:{ struct comp* c = (struct comp*) m->cmd.param.srv_handle; verify_component(c); fprintf(stderr, "ILSRV: %08X [%20s] GetConfig %s\n", c->real_handle, last_part(c->name), adm_log_index2str(m->cmd.param.index)); m->result = OMX_GetConfig(c->real_handle, (OMX_INDEXTYPE)m->cmd.param.index, m->cmd.param.buf); // TODO: Protect fprintf(stderr, "ILSRV: --> %s %s\n", m->result == OMX_ErrorNone ? "" : "ERROR ", adm_log_err2str(m->result)); return; } case MSG_SET_CONFIG: { struct comp* c = (struct comp*) m->cmd.param.srv_handle; verify_component(c); fprintf(stderr, "ILSRV: %08X [%20s] SetConfig %s\n", c->real_handle, last_part(c->name), adm_log_index2str(m->cmd.param.index)); m->result = OMX_SetConfig(c->real_handle, (OMX_INDEXTYPE)m->cmd.param.index, m->cmd.param.buf); // TODO: Protect fprintf(stderr, "ILSRV: --> %s %s\n", m->result == OMX_ErrorNone ? "" : "ERROR ", adm_log_err2str(m->result)); return; } case MSG_FREE_HANDLE: { struct comp* c = (struct comp*) m->cmd.free_handle.srv_handle; verify_component(c); if (c->state != OMX_StateLoaded) { fprintf(stderr, "ILSRV: FreeHandle called for %X which is in wrong state (%s)\m", c->real_handle, adm_log_state2str(c->state)); error_found(); } fprintf(stderr, "ILSRV: %08X [%20s] Freehandle (internal=%X)\n", c->real_handle, last_part(c->name), c); m->result = OMX_FreeHandle(c->real_handle); fprintf(stderr, "ILSRV: --> %s %s\n", m->result == OMX_ErrorNone ? "" : "ERROR ", adm_log_err2str(m->result)); del_component(c); memset(c, 0xFE, sizeof(*c)); free(c); return; } case MSG_SEND_COMMAND: { struct comp* c = (struct comp*) m->cmd.free_handle.srv_handle; verify_component(c); if (m->cmd.command.cmd == OMX_CommandStateSet) { fprintf(stderr, "ILSRV: %08X [%20s] SendCommand StateSet %s\n", c->real_handle, last_part(c->name), adm_log_state2str((OMX_STATETYPE) m->cmd.command.nParam1)); } else { fprintf(stderr, "ILSRV: %08X [%20s] SendCommand StateSet %s 0x%X\n", c->real_handle, last_part(c->name), adm_log_cmd2str(m->cmd.command.cmd), m->cmd.command.nParam1); } m->result = OMX_SendCommand(c->real_handle, m->cmd.command.cmd, m->cmd.command.nParam1, 0); fprintf(stderr, "ILSRV: --> %s %s\n", m->result == OMX_ErrorNone ? "" : "ERROR ", adm_log_err2str(m->result)); return; } case MSG_SETUP_TUNNEL: { struct comp* c_in = (struct comp*) m->cmd.tunnel.srv_handle_in; struct comp* c_out = (struct comp*) m->cmd.tunnel.srv_handle_out; verify_component(c_in); verify_component(c_out); fprintf(stderr, "ILSRV: SetupTunnel %08X [%20s].%d --> %08X [%20s].%d\n", c_out->real_handle, last_part(c_out->name), m->cmd.tunnel.port_out, c_in->real_handle, last_part(c_in->name), m->cmd.tunnel.port_in); m->result = OMX_SetupTunnel(c_out->real_handle, m->cmd.tunnel.port_out, c_in->real_handle, m->cmd.tunnel.port_in); fprintf(stderr, "ILSRV: --> %s %s\n", m->result == OMX_ErrorNone ? "" : "ERROR ", adm_log_err2str(m->result)); return; } case MSG_GET_STATE: { struct comp* c = (struct comp*) m->cmd.get_state.in_srv_handle; verify_component(c); fprintf(stderr, "ILSRV: %08X [%20s] GetState\n", c->real_handle, last_part(c->name)); m->result = OMX_GetState(c->real_handle, &m->cmd.get_state.out_state); fprintf(stderr, "ILSRV: --> %s %s %s\n", m->result == OMX_ErrorNone ? "" : "ERROR ", adm_log_err2str(m->result), adm_log_state2str(m->cmd.get_state.out_state)); return; } case MSG_ALLOC_BUFFER: { struct comp* c = (struct comp*) m->cmd.alloc_buffer.in_srv_handle; verify_component(c); OMX_BUFFERHEADERTYPE* bufhdr; fprintf(stderr, "ILSRV: %08X [%20s] AllocBuf port=%d size=%d\n", c->real_handle, last_part(c->name), m->cmd.alloc_buffer.port, m->cmd.alloc_buffer.size); m->result = OMX_AllocateBuffer(c->real_handle, &bufhdr, m->cmd.alloc_buffer.port, (void*) m->cmd.alloc_buffer.in_client_buf_hdr, m->cmd.alloc_buffer.size); if (m->result == OMX_ErrorNone) { memcpy(&m->cmd.alloc_buffer.out_buf_hdr, bufhdr, sizeof(OMX_BUFFERHEADERTYPE)); m->cmd.alloc_buffer.out_srv_buf_hdr = (int) bufhdr; add_bufhdr(bufhdr); } fprintf(stderr, "ILSRV: --> %s %s\n", m->result == OMX_ErrorNone ? "" : "ERROR ", adm_log_err2str(m->result)); return; } case MSG_EMPTY_BUFFER: { struct comp* c = (struct comp*) m->cmd.empty_buffer.in_srv_handle; verify_component(c); OMX_BUFFERHEADERTYPE* client_bufhdr = (OMX_BUFFERHEADERTYPE*) &m->cmd.empty_buffer.in_buf_hdr; OMX_BUFFERHEADERTYPE* bufhdr = (OMX_BUFFERHEADERTYPE*) client_bufhdr->pPlatformPrivate; verify_bufhdr(bufhdr); if (bufhdr->nAllocLen <= sizeof(m->cmd.empty_buffer.in_buf)) { bufhdr->nOffset = client_bufhdr->nOffset; bufhdr->nTimeStamp = client_bufhdr->nTimeStamp; bufhdr->nFilledLen = client_bufhdr->nFilledLen; bufhdr->nFlags = client_bufhdr->nFlags; memcpy(bufhdr->pBuffer, &m->cmd.empty_buffer.in_buf, bufhdr->nAllocLen); fprintf(stderr, "ILSRV: %08X [%20s] EmptyBuffer port=%d size=%d\n", c->real_handle, last_part(c->name), bufhdr->nInputPortIndex, bufhdr->nAllocLen); m->result = OMX_EmptyThisBuffer(c->real_handle, bufhdr); fprintf(stderr, "ILSRV: --> %s %s\n", m->result == OMX_ErrorNone ? "" : "ERROR ", adm_log_err2str(m->result)); } else { assert(0); } return; } case MSG_FILL_BUFFER: { struct comp* c = (struct comp*) m->cmd.empty_buffer.in_srv_handle; verify_component(c); OMX_BUFFERHEADERTYPE* client_bufhdr = (OMX_BUFFERHEADERTYPE*) &m->cmd.fill_buffer.in_buf_hdr; OMX_BUFFERHEADERTYPE* bufhdr = (OMX_BUFFERHEADERTYPE*) client_bufhdr->pPlatformPrivate; verify_bufhdr(bufhdr); fprintf(stderr, "ILSRV: %08X [%20s] FillBuffer port=%d size=%d\n", c->real_handle, last_part(c->name), bufhdr->nOutputPortIndex, bufhdr->nAllocLen); m->result = OMX_FillThisBuffer(c->real_handle, bufhdr); fprintf(stderr, "ILSRV: --> %s %s\n", m->result == OMX_ErrorNone ? "" : "ERROR ", adm_log_err2str(m->result)); return; } case MSG_FREE_BUFFER: { struct comp* c = (struct comp*) m->cmd.empty_buffer.in_srv_handle; verify_component(c); OMX_BUFFERHEADERTYPE* bufhdr = (OMX_BUFFERHEADERTYPE*) m->cmd.free_buffer.in_srv_buf_hdr; verify_bufhdr(bufhdr); del_bufhdr(bufhdr); fprintf(stderr, "ILSRV: %08X [%20s] FreeBuffer\n", c->real_handle, last_part(c->name)); m->result = OMX_FreeBuffer(c->real_handle, m->cmd.free_buffer.in_port, bufhdr); fprintf(stderr, "ILSRV: --> %s %s\n", m->result == OMX_ErrorNone ? "" : "ERROR ", adm_log_err2str(m->result)); return; } default: fprintf(stderr, "ILSRV: Unhandled request received\n"); m->result = OMX_ErrorNotImplemented; error_found(); return; }
static gboolean press_callback(GtkWidget* widget,GdkEventButton* event,gpointer data) { double mx=event->x; double my=event->y; double width=gtk_widget_get_allocated_width(widget); double height=gtk_widget_get_allocated_height(widget); double spacing=MIN((width-2*gutter)/grid.width,(height-2*gutter)/grid.height); mx-=width/2.0; my-=height/2.0; mx=mx/spacing; my=my/spacing; mx+=grid.width/2.0; my+=grid.height/2.0; int ia,ib; double da,db; int i; ia=0;ib=0; da=db=grid.width+grid.height; for(i=0;i<grid.map.vcount;i++){ double x=grid.map.vertices[i].id%(grid.width+1); double y=(int)(grid.map.vertices[i].id/(grid.width+1)); double d=sqrt((x-mx)*(x-mx)+(y-my)*(y-my)); if(d<da){ db=da; ib=ia; da=d; ia=i; }else if(d<db){ db=d; ib=i; } } int A=MIN(grid.map.vertices[ia].id,grid.map.vertices[ib].id); int B=MAX(grid.map.vertices[ia].id,grid.map.vertices[ib].id); if(draw_state==PLACE_WIRE){ Component c; c.type=WIRE; c.A=A; c.B=B; add_component(c); } if(draw_state==PLACE_RESISTOR){ Component c; c.type=RESISTOR; c.A=A; c.B=B; c.data=calloc(1,sizeof(double)); *(double*)c.data=10; add_component(c); } if(draw_state==PLACE_BATTERY){ Component c; c.type=BATTERY; c.A=A; c.B=B; c.data=calloc(1,sizeof(double)); *(double*)c.data=5; add_component(c); }if(draw_state==DELETE){ for(i=0;i<grid.map.ccount;i++){ if((grid.map.components[i].A==A)&&(grid.map.components[i].B==B)){ remove_component(i); break; } } }if(draw_state==EDIT){ for(i=0;i<grid.map.ccount;i++){ if((grid.map.components[i].A==A)&&(grid.map.components[i].B==B)){ edit_dialog(grid.map.components+i); break; } } } calculate(); //gtk_widget_queue_draw_area(widget,0,0,width,height); gtk_widget_queue_draw(widget); return TRUE; }