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;
}
Exemple #2
0
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;
}
Exemple #3
0
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;
}
Exemple #4
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;
}
Exemple #6
0
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");			
}
Exemple #7
0
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);
		
	}
Exemple #9
0
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;
}
Exemple #10
0
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);
}
Exemple #11
0
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";
}
Exemple #12
0
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);
	}
Exemple #14
0
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);
}
Exemple #17
0
    // ----------------------------------------------------------------------
    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();
    }
Exemple #18
0
	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);
}
Exemple #20
0
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());
}
Exemple #21
0
	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();
	}
Exemple #22
0
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;
}
Exemple #24
0
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);
  }
}
Exemple #25
0
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);
}
Exemple #26
0
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;
}
Exemple #27
0
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;
  }
}
Exemple #28
0
//////////////////////////////////////////////////////////////////////////
// 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;
}
Exemple #29
0
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);
}
Exemple #30
0
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();
}