static gboolean position_changed(DBusConnection *connection, DBusMessage *msg, void *user_data) { struct media_player *mp = user_data; DBusMessageIter iter; DBG("sender=%s path=%s", mp->sender, mp->path); dbus_message_iter_init(msg, &iter); set_position(mp, &iter); return TRUE; }
int xmp_next_position(xmp_context opaque) { struct context_data *ctx = (struct context_data *)opaque; struct player_data *p = &ctx->p; struct module_data *m = &ctx->m; if (ctx->state < XMP_STATE_PLAYING) return -XMP_ERROR_STATE; if (p->pos < m->mod.len) set_position(ctx, p->pos + 1, 1); return p->pos; }
static int tta_seek_sample (DB_fileinfo_t *_info, int sample) { tta_info_t *info = (tta_info_t *)_info; info->samples_to_skip = set_position (&info->tta, sample + info->startsample); if (info->samples_to_skip < 0) { fprintf (stderr, "tta: seek failed\n"); return -1; } info->currentsample = sample + info->startsample; info->remaining = 0; _info->readpos = sample / _info->fmt.samplerate; return 0; }
/** * @brief Creates a text to display with the specified alignment properties. * @param x x position of the text on the destination surface * @param y y position of the text on the destination surface * @param horizontal_alignment horizontal alignment of the text: ALIGN_LEFT, * ALIGN_CENTER or ALIGN_RIGHT * @param vertical_alignment vertical alignment of the text: ALIGN_TOP, * ALIGN_MIDDLE or ALIGN_BOTTOM */ TextSurface::TextSurface(int x, int y, TextSurface::HorizontalAlignment horizontal_alignment, TextSurface::VerticalAlignment vertical_alignment): font_id(default_font_id), horizontal_alignment(horizontal_alignment), vertical_alignment(vertical_alignment), rendering_mode(TEXT_SOLID), surface(NULL) { text = ""; set_text_color(Color::get_white()); set_background_color(Color::get_black()); set_position(x, y); }
int YARPMEIDeviceDriver::definePosition (void *cmd) { long rc = 0; SingleAxisParameters *tmp = (SingleAxisParameters *) cmd; double *pos = (double *)(tmp->parameters); rc = set_position(tmp->axis, *pos); /// this is to reset the encoder ref value. /// LATER: need to verify whether summing pos is the right thing to do. _position_zero[tmp->axis] = double(dsp_encoder (tmp->axis)) + *pos; _winding[tmp->axis] = 0; return rc; }
MarqueeView::MarqueeView() { style = 0; set_position( 0, 0, 0, 0 ); Visible = FALSE; text_size = 14.0; font_height = 2*text_size; font = &SerifTypeface; calc_margins( 0.1 ); text_color = 0xFF9f9f0f; border_color = 0xFFffffff; background_color = 0xFf202020; strcpy (class_name, "MarqueeView"); }
void dig(int **puz, int x, int y, int emp_lim, int rc_lim){ /*randomly empties positions of a completed sudoku to generate a new puzzle, according to the limits passed*/ int g = 0, v, s; srand(time(NULL)); while(g <= emp_lim){ if(puz[x][y]){ if((v = check_row(puz, x, rc_lim)) && (s = check_col(puz, y, rc_lim))){ g++; puz[x][y] = EMPTY; } } set_position(&x, &y); } return; }
score(const sf::Vector2f& position) : m_text_size(m_mult*(position.x + position.y)), m_font(), m_text() { assert(m_score_name != ""); assert(m_score == 0); set_font(); set_text_font(); set_text_size(); set_color(); textify_score(); set_origin(); set_position(position); }
int xmp_set_position(xmp_context opaque, int pos) { struct context_data *ctx = (struct context_data *)opaque; struct player_data *p = &ctx->p; struct module_data *m = &ctx->m; if (ctx->state < XMP_STATE_PLAYING) return -XMP_ERROR_STATE; if (pos >= m->mod.len) return -XMP_ERROR_INVALID; set_position(ctx, pos, 0); return p->pos; }
void uci(void) { /* printf("Entering UCI mode. Type in commands here (quit to quit, help for a list of commands)\n\n"); */ // Default state isWhitesMove=1; //set_position_startpos(); FILE *fp; fp=fopen("chess.log", "a"); fprintf(fp, "---- CHESS v0.0 ------------\n"); int keep_going = 1; char string[256]; while (keep_going == 1) { //printf( "Command: " ); fflush (stdout); int x = scanf ("%79s",string); fprintf(fp, "Received command: %s\n", string); if (strcmp(string, "quit")==0) { keep_going = 0; } else if (strcmp(string, "uci")==0) { show_uci_info(); } else if (strcmp(string, "isready")==0) { is_ready(); } else if (strcmp(string, "position")==0) { set_position(); } else if (strcmp(string, "go")==0) { go(); } else if (strcmp(string, "stop")==0) { stop(); } else if (strcmp(string, "draw")==0) { draw(); } else if (strcmp(string, "move")==0) { uci_make_move(); } else if (strcmp(string, "dumpmoves")==0) { dump_moves(); } else if (strcmp(string, "info")==0) { info(); } else if (strcmp(string, "test")==0) { run_tests(); } else { printf( "Unknown command: %s\n", string ); } } fclose(fp); }
ui::menu::menu() { set_position(window::center.x,window::center.y); fill_color=default_fillcolor; border_color=default_bordercolor; set_texture(default_texture); set_mask(default_mask); set_title("menu"); title.set_font("helvetica",18); subtitle.set_font("helvetica",12); subtitle.hide(); layout=default_layout; spacing=default_spacing; margin=default_margin; bordered=true; std::clog<<"object#"<<number<<"(menu)"<<" created.\n"; }
int main(void) { int player_x,player_y; player_x = player_y = 0; printf("player_x = %d\n",player_x); printf("player_y = %d\n",player_y); printf("°ÜÆ°\n"); set_position(&player_x,&player_y); printf("player_x = %d\n",player_x); printf("player_y = %d\n",player_y); return 0; }
void home_all(void) { if (homing_state[pivot] != homed) set_position(gripper, 10, 0.3, -0.3); home(pivot); if (homing_state[pivot] == homed) home(gripper); if (homing_state[gripper] == homed) home(elevator); // !! if (homing_state[elevator] == homed) home(mini); }
void sniper() { init_all(); // set voltage reference to 5V clear(ADMUX, REFS1); set(ADMUX, REFS0); m_disableJTAG();//allowing gpio of F pins //setting ADC prescaler set(ADCSRA,ADPS2); set(ADCSRA,ADPS1); set(ADCSRA,ADPS0); //setting pins to turn off digital circuitry set(DIDR0,ADC1D);//setting F1 set(DIDR0,ADC4D);//setting F4 set(DIDR0,ADC5D);//setting F5 set(DIDR0,ADC6D);//setting F6 set(DIDR0,ADC7D);//setting F7 set(ADCSRA, ADEN); play_state = 1; set_position(1024/2, 768/2); first = true; //state_before_game(); //state_play(); m_usb_init(); /* while(!m_usb_isconnected()); m_green(ON); */ set_left(30); set_right(100); while(1) { adc(); // m_usb_tx_string("left: "); //m_usb_tx_int(a_left); wait(1); } }
int YARPMEIDeviceDriver::definePositions (void *param) { int16 rc = 0; double *cmds = (double *) param; for(int i = 0; i < _njoints; i++) { rc = set_position(i, cmds[i]); /// this is to reset the encoder ref value. /// LATER: need to verify whether summing cmds[i] is the right thing to do. _position_zero[i] = double(dsp_encoder (i)) + cmds[i]; _winding[i] = 0; } return rc; }
ViewLogFileWindow::ViewLogFileWindow(const std::string& PathToLogFile) { set_default_size(500, 350); set_position(Gtk::WIN_POS_CENTER_ON_PARENT); set_title(_("Install log")); m_CloseButton.set_label(_("Close")); m_RefLogTextBuffer = Gtk::TextBuffer::create(); m_RefLogTextBuffer->set_text(""); m_LogTextView.set_editable(false); m_LogTextView.set_buffer(m_RefLogTextBuffer); m_LogTextView.set_wrap_mode(Gtk::WRAP_WORD); m_LogSWindow.add(m_LogTextView); m_LogSWindow.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC); m_VBox.set_border_width(12); m_VBox.pack_start(m_LogSWindow,Gtk::PACK_EXPAND_WIDGET,12); m_VBox.pack_start(m_CloseButton,Gtk::PACK_SHRINK,12); add(m_VBox); m_CloseButton.signal_clicked().connect( sigc::mem_fun(*this, &ViewLogFileWindow::onCloseClicked) ); std::ifstream LogFile(PathToLogFile.c_str()); std::string Line, FullContent; while(getline(LogFile,Line)) { FullContent += Line + "\n"; } LogFile.close(); m_RefLogTextBuffer->set_text(FullContent); show_all_children(); set_modal(true); }
// ---------------------------------------------------------------------- void JumpMovement:: init_from( Node& v, NodeMovement& nm ) throw() { set_node(v); set_position(nm.position()); if ( update_mask_[JumpMovement::X] ) pos_ = Vec( update_pos_[JumpMovement::X], pos_.y(), pos_.z() ); if ( update_mask_[JumpMovement::Y] ) pos_ = Vec( pos_.x(), update_pos_[JumpMovement::Y], pos_.z() ); if ( update_mask_[JumpMovement::Z] ) pos_ = Vec( pos_.x(), pos_.y(), update_pos_[JumpMovement::Z] ); movement_initial_boxes(); }
void Light::render(const CameraApiPtr& camera) { // if attached to target... if (m_target) { // set position based on target set_position(m_target->get_absolute_position() + m_offset_from_target); // if target is removed from parent and need to remove this light: if (m_remove_with_target && m_target->parent() == nullptr) { m_target.reset(); remove_from_parent(); return; } } Entity::render(camera); }
task main () { // resets odometry AcquireMutex(semaphore_odometry); set_position(robot_odometry, 0, 0, 0); ReleaseMutex(semaphore_odometry); // resets motor encoders hogCPU(); nMotorEncoder[motorA] = 0; nMotorEncoder[motorC] = 0; releaseCPU(); StartTask(updateOdometry); track_wall(); StopTask(updateOdometry); }
void Stats::update(){ if (po->get_height()!=currentPo){ if (po->get_height()<currentPo) po->set_height(po->get_height()+1); else po->set_height(po->get_height()-1); } if (sp->get_height()!=currentSp){ if (sp->get_height()<currentSp) sp->set_height(sp->get_height()+1); else sp->set_height(sp->get_height()-1); } if (de->get_height()!=currentDe){ if (de->get_height()<currentDe) de->set_height(de->get_height()+1); else de->set_height(de->get_height()-1); } set_position(background->get_x(),background->get_y()); }
void X11Window::map_window() { // Clear exisitng StructureNofify events. XEvent event; while(XCheckMaskEvent(handle.display, StructureNotifyMask, &event)); if (is_window_mapped) { if (!is_minimized()) { log_event("debug", "clan::X11Window::map_window(): Window already mapped."); return; } else log_event("debug", "clan::X11Window::map_window(): Mapping minimized window."); } log_event("debug", "clan::X11Window::map_window(): Mapping window..."); int result = XMapWindow(handle.display, handle.window); if ((result == BadValue) || (result == BadWindow)) throw Exception("Failed to map window."); XFlush(handle.display); do { XWindowEvent(handle.display, handle.window, StructureNotifyMask, &event); } while (event.type != MapNotify); XFlush(handle.display); is_window_mapped = true; if (fullscreen) { XSetInputFocus(handle.display, handle.window, RevertToParent, CurrentTime); XFlush(handle.display); } else { update_frame_extents(); set_position(client_area, true); } request_repaint(); }
static gboolean set_player_property(struct media_player *mp, const char *key, DBusMessageIter *entry) { DBusMessageIter var; if (dbus_message_iter_get_arg_type(entry) != DBUS_TYPE_VARIANT) return FALSE; dbus_message_iter_recurse(entry, &var); if (strcasecmp(key, "PlaybackStatus") == 0) return set_status(mp, &var); if (strcasecmp(key, "Position") == 0) return set_position(mp, &var); if (strcasecmp(key, "Metadata") == 0) return parse_player_metadata(mp, &var); if (strcasecmp(key, "Shuffle") == 0) return set_shuffle(mp, &var); if (strcasecmp(key, "LoopStatus") == 0) return set_repeat(mp, &var); if (strcasecmp(key, "CanPlay") == 0) return set_flag(mp, &var, &mp->play); if (strcasecmp(key, "CanPause") == 0) return set_flag(mp, &var, &mp->pause); if (strcasecmp(key, "CanGoNext") == 0) return set_flag(mp, &var, &mp->next); if (strcasecmp(key, "CanGoPrevious") == 0) return set_flag(mp, &var, &mp->previous); if (strcasecmp(key, "CanControl") == 0) return set_flag(mp, &var, &mp->control); DBG("%s not supported, ignoring", key); return TRUE; }
static int op1a_read_next_frame(MXFReader *reader, MXFReaderListener *listener) { MXFFile *mxfFile = reader->mxfFile; EssenceReader *essenceReader = reader->essenceReader; EssenceReaderData *data = essenceReader->data; /* set position at start of the current content package */ if (mxf_file_is_seekable(mxfFile)) { if (end_of_essence(data->index)) { return -1; } CHK_ORET(set_position(mxfFile, data->index, get_current_position(data->index))); if (end_of_essence(data->index)) { return -1; } CHK_ORET(read_content_package(reader, 0, listener)); increment_current_position(data->index); } else { if (ns_end_of_essence(&data->nsIndex)) { return -1; } CHK_ORET(ns_pos_at_next_frame(reader)); if (ns_end_of_essence(&data->nsIndex)) { return -1; } CHK_ORET(ns_read_content_package(reader, 0, listener)); data->nsIndex.currentPosition++; } return 1; }
void PbfSolver::ImposeBoundaryConstraint_() { const vec_t world_sz_dim{world_size_x_, world_size_y_, world_size_z_}; for (size_t ptc_i = 0; ptc_i < ps_->NumParticles(); ++ptc_i) { auto ptc = ps_->Get(ptc_i); auto pos = ptc.position(); auto vel = ptc.velocity(); for (int c = 0; c < 3; ++c) { if (pos[c] <= 0.0f || (pos[c] >= world_sz_dim[c] - kFloatEpsilon)) { vel[c] = 0.0f; pos[c] = std::max(0.0f, std::min(world_sz_dim[c] - kFloatEpsilon, pos[c])); } } ptc.set_position(pos); ptc.set_velocity(vel); } }
void PopupMenu::_scroll(float p_factor, const Point2 &p_over) { const float global_y = get_global_position().y; int vseparation = get_constant("vseparation"); Ref<Font> font = get_font("font"); float dy = (vseparation + font->get_height()) * 3 * p_factor; if (dy > 0 && global_y < 0) dy = MIN(dy, -global_y - 1); else if (dy < 0 && global_y + get_size().y > get_viewport_rect().size.y) dy = -MIN(-dy, global_y + get_size().y - get_viewport_rect().size.y - 1); set_position(get_position() + Vector2(0, dy)); Ref<InputEventMouseMotion> ie; ie.instance(); ie->set_position(p_over - Vector2(0, dy)); _gui_input(ie); }
frame::frame( const comma::csv::options& options, bool discardOutOfOrder, boost::optional< boost::posix_time::time_duration > maxGap, bool outputframe, bool to, bool interpolate, bool rotation_present ) : outputframe( outputframe ) , m_to( to ) , m_interpolate( interpolate ) , m_rotation( ::Eigen::Matrix3d::Identity() ) , m_istream( new comma::io::istream( options.filename, options.binary() ? comma::io::mode::binary : comma::io::mode::ascii, comma::io::mode::blocking ) ) , m_discardOutOfOrder( discardOutOfOrder ) , m_maxGap( maxGap ) , rotation_present_( rotation_present ) { m_is.reset( new comma::csv::input_stream< position_type >( *( *m_istream )(), options ) ); const position_type* p = m_is->read(); // todo: maybe not very good, move to value() if( p == NULL ) { COMMA_THROW( comma::exception, "failed to read from " << options.filename ); } m_pair.first = *p; set_position( p->value ); p = m_is->read(); // todo: maybe not very good, move to value() if( p == NULL ) { COMMA_THROW( comma::exception, "failed to read from " << options.filename ); } m_pair.second = *p; }
void xwindow_draw_string(XWindow *xw, char *text, int x, int y) { xwindow_font_load(xw); switch(xw->font->type) { case XFONT_TYPE_SOFTWARE: set_position( x11_to_view_x(x, xw), x11_to_view_y(y, xw) ); softwaretext(&x11, text, strlen(text)); break; case XFONT_TYPE_CORE: xwindow_draw_string_core(xw, text, x, y); break; case XFONT_TYPE_XFT: xwindow_draw_string_xft(xw, text, x, y); break; default: fprintf(stderr, "SAC: Unknown X11 Font Subsystem\n"); break; } }
////////////////////////////////////////////////////////////////////////// // Default constructor SelectAppUI::SelectAppUI(Manager* aManager, int type, string aStuNum, bool aBeingViewed) : aTable(3, 2, false), aLabel("Please select an application you would like to edit"), backButton("Back"), nextButton("Next"), list(2, false, Gtk::SELECTION_SINGLE) { manager = aManager; stuType = type; stuNum = aStuNum; beingViewed = aBeingViewed; set_default_size(500, 250); set_title("cuTAES"); set_modal(true); set_position(Gtk::WIN_POS_CENTER_ALWAYS); set_deletable(false); // Scrolled window settings scrolledWindow.set_border_width(5); scrolledWindow.set_policy(Gtk::POLICY_ALWAYS, Gtk::POLICY_ALWAYS); list.set_column_title(0, "Application #"); list.set_column_title(1, "Course"); fillList(); scrolledWindow.add(list); add(aTable); aTable.attach(aLabel, 0, 2, 0, 1,Gtk::FILL,Gtk::FILL,0,10); aTable.attach(scrolledWindow, 0, 2, 1, 2); aTable.attach(backButton, 0, 1, 2, 3,Gtk::FILL,Gtk::FILL,40,10); aTable.attach(nextButton, 1, 2, 2, 3,Gtk::FILL,Gtk::FILL,40,10); backButton.signal_clicked().connect( sigc::bind<Glib::ustring>( sigc::mem_fun(*this, &SelectAppUI::on_backButton), "Back") ); nextButton.signal_clicked().connect( sigc::bind<Glib::ustring>( sigc::mem_fun(*this, &SelectAppUI::on_nextButton), "Next") ); show_all_children(); //cout << "CONSTRUCT SelectAppUI" << endl; }
void third_person_cam::update(level_graph const& level, agent const& player, float_t dtime) { vec_t player_pos = level.get_agent_position(player); vec_t player_dir = level.get_agent_direction(player); orient_t player_orient = lookat_orientation(player_dir, player.up); vec_t ideal_pos = calc_ideal_position(player_pos, player_orient); orient_t ideal_orientation = calc_ideal_orientation(player_pos, player_orient); vec_t cur_pos = get_position(); // Let's try, moving proportionally to distance, such that in 1 second we would move the whole way (if happened in single step) float const cam_move = dtime * move_speed_factor; set_position(cur_pos + (ideal_pos - cur_pos) * std::min(cam_move, 1.0f)); orient_t cur_orientation = get_orientation(); float const cam_slerp = dtime * slerp_speed_factor; orient_t interpolated = cur_orientation.slerp(std::min(cam_slerp, 1.0f), ideal_orientation); set_orientation(interpolated); }
void zz_sky::update_time (bool recursive, zz_time diff_time) { float time_delta = static_cast<float>(diff_time)/ZZ_TICK_PER_SEC; // rotate angles for (unsigned int i = 0; i < num_runits; ++i) { rot_angles_current[i] += time_delta*rot_angles_delta[i]; } zz_camera * cam = znzin->get_camera(); if (cam) { set_position(cam->get_eye()); invalidate_transform(); //ZZ_LOG("sky: update() position(%f, %f, %f)\n", this->get_position().x, this->get_position().y, this->get_position().z); } // CAUTION: sky is not in the scene_octree, so you should update manually. invalidate_tm_minmax(); }