Ejemplo n.º 1
0
/*!

 */
void
PlayerPainter::drawTrace( QPainter & painter,
                          const PlayerPainter::Param & ) const
{
    const Options & opt = Options::instance();

    const std::size_t first = M_main_data.dispHolder().getIndexOf( opt.playerTraceStart() );
    const std::size_t last = M_main_data.dispHolder().getIndexOf( opt.playerTraceEnd() );
    if ( first >= last )
    {
        return;
    }

    const std::vector< DispPtr > & cont = M_main_data.dispHolder().dispInfoCont();
    if ( cont.empty() )
    {
        return;
    }

    if ( opt.antiAliasing() )
    {
        painter.setRenderHint( QPainter::Antialiasing, false );
    }

    const bool line_trace = opt.lineTrace();

    const std::size_t idx = static_cast< std::size_t >( opt.selectedNumber() > 0
                                                        ? opt.selectedNumber() - 1
                                                        : 11 - opt.selectedNumber() - 1 );

    const QPen & pen = ( opt.selectedNumber() > 0
                         ? M_left_team_pen
                         : M_right_team_pen );
    QPen black_dot_pen( Qt::black );
    black_dot_pen.setStyle( Qt::DotLine );

    painter.setBrush( Qt::NoBrush );

    std::size_t i = first;
    int prev_x = opt.screenX( cont[i]->show_.player_[idx].x_ );
    int prev_y = opt.screenY( cont[i]->show_.player_[idx].y_ );
    ++i;
    for ( ; i <= last; ++i )
    {
        switch ( cont[i]->pmode_ ) {
        case rcss::rcg::PM_BeforeKickOff:
        case rcss::rcg::PM_TimeOver:
        case rcss::rcg::PM_AfterGoal_Left:
        case rcss::rcg::PM_AfterGoal_Right:
            continue;
        case rcss::rcg::PM_PlayOn:
            painter.setPen( pen );
            break;
        default:
            painter.setPen( black_dot_pen );
            break;
        }

        int ix = opt.screenX( cont[i]->show_.player_[idx].x_ );
        int iy = opt.screenY( cont[i]->show_.player_[idx].y_ );

        painter.drawLine( prev_x, prev_y, ix, iy );
        if ( ! line_trace )
        {
            painter.drawEllipse( ix - 2, iy - 2, 5, 5 );
        }
        prev_x = ix;
        prev_y = iy;
    }

    if ( opt.antiAliasing() )
    {
        painter.setRenderHint( QPainter::Antialiasing );
    }
}
Ejemplo n.º 2
0
/*!

*/
void
PlayerTracePainter::draw( QPainter & painter )
{
    const Options & opt = Options::instance();

    if ( ! opt.showPlayerTrace() )
    {
        return;
    }

    if ( opt.selectedNumber() == 0 )
    {
        return;
    }

    const ViewHolder & holder = M_main_data.viewHolder();

    int start_cycle = opt.playerTraceStart();
    int end_cycle = opt.playerTraceEnd();

    const MonitorViewCont & vc = M_main_data.viewHolder().monitorViewCont();

    if ( vc.empty() )
    {
        return;
    }

    if ( opt.playerAutoTrace() )
    {
        MonitorViewConstPtr view = M_main_data.getCurrentViewData();
        if ( ! view )
        {
            return;
        }
        start_cycle = std::max( 1, view->cycle() + opt.autoTraceStart() );
    }
    else if ( start_cycle >= end_cycle )
    {
        return;
    }

    const std::size_t first = holder.getIndexOf( start_cycle );
    const std::size_t last = ( opt.playerAutoTrace()
                               ? std::min( first + opt.autoTracePeriod(),
                                           vc.size() - 1 )
                               : holder.getIndexOf( end_cycle ) );
    if ( first >= last )
    {
        return;
    }

    if ( opt.antiAliasing() )
    {
#ifdef USE_HIGH_QUALITY_ANTIALIASING
        painter.setRenderHints( QPainter::HighQualityAntialiasing |
                                QPainter::Antialiasing,
                                false );
#else
        painter.setRenderHint( QPainter::Antialiasing, false );
#endif
    }

    const std::size_t idx = static_cast< std::size_t >
        ( opt.selectedNumber() > 0
          ? opt.selectedNumber() - 1
          : 11 - opt.selectedNumber() - 1 );
    const QPen & my_pen = ( opt.reverseSide()
                            ? ( opt.selectedNumber() > 0
                                ? DrawConfig::instance().rightTeamPen()
                                : DrawConfig::instance().leftTeamPen() )
                            : ( opt.selectedNumber() > 0
                                ? DrawConfig::instance().leftTeamPen()
                                : DrawConfig::instance().rightTeamPen() )
                            );
    QPen black_dot_pen( Qt::black );
    black_dot_pen.setStyle( Qt::DotLine );

    const bool line_trace = opt.lineTrace();

    if ( line_trace )
    {
        painter.setBrush( DrawConfig::instance().transparentBrush() );
    }
    else
    {
        painter.setBrush( Qt::gray );
    }

    //QPainterPath playon_path;
    //QPainterPath setplay_path;

    std::size_t i = first;
    QPointF prev( opt.screenXF( vc[i]->players()[idx].x() ),
                  opt.screenYF( vc[i]->players()[idx].y() ) );
    ++i;
    for ( ; i <= last; ++i )
    {
        //QPainterPath * path;
        switch ( vc[i]->playmode().mode() ) {
        case rcsc::PM_BeforeKickOff:
        case rcsc::PM_TimeOver:
        case rcsc::PM_AfterGoal_Left:
        case rcsc::PM_AfterGoal_Right:
            continue;
        case rcsc::PM_PlayOn:
            painter.setPen( my_pen );
            //path = &playon_path;
            break;
        default:
            painter.setPen( black_dot_pen );
            //path = &setplay_path;
            break;
        }

        const Player & p = vc[i]->players()[idx];
        QPointF next( opt.screenXF( p.x() ),
                      opt.screenYF( p.y() ) );
        if ( line_trace )
        {
            painter.drawLine( QLineF( prev, next ) );
            //path->moveTo( prev_x, prev_y );
            //path->lineTo( ix, iy );
        }
        else
        {
            painter.drawLine( QLineF(  prev, next ) );
            painter.drawEllipse( QRectF( next.x() - 2.0,
                                         next.y() - 2.0,
                                         4.0,
                                         4.0 ) );
            //path->moveTo( prev_x, prev_y );
            //path->lineTo( ix, iy );
            //path->addEllipse( ix, iy, 4, 4 );
        }
        prev = next;
    }

//     painter.setPen( my_pen );
//     painter.drawPath( playon_path );

//     painter.setPen( black_dot_pen );
//     painter.drawPath( setplay_path );

    if ( opt.antiAliasing() )
    {
#ifdef USE_HIGH_QUALITY_ANTIALIASING
        painter.setRenderHints( QPainter::HighQualityAntialiasing |
                                QPainter::Antialiasing,
                                true );
#else
        painter.setRenderHint( QPainter::Antialiasing, true );
#endif
    }
}