Пример #1
0
// Применение изменений по вращении колеса мыши
void QWheelZoomSvc::applyWheel(QEvent *event,bool ax,bool ay)
{
    // приводим тип QEvent к QWheelEvent
    QWheelEvent *wEvent = static_cast<QWheelEvent *>(event);
    // если вращается вертикальное колесо мыши
    if (wEvent->orientation() == Qt::Vertical)
    {
        // определяем угол поворота колеса мыши
        // (значение 120 соответствует углу поворота 15°)
        int wd = wEvent->delta();
        // вычисляем масштабирующий множитель
        // (во сколько раз будет увеличен/уменьшен график)
        double kw = sfact*wd/120;
        if (wd != 0)    // если колесо вращалось, то
        {
            // фиксируем исходные границы графика (если этого еще не было сделано)
            zoom->fixBounds();
            // получаем указатель на график
            QwtPlot *plt = zoom->plot();
            if (ax) // если задано масштабирование по горизонтали
            {
                // получаем карту основной горизонтальной шкалы
                QwtScaleMap sm = plt->canvasMap(zoom->masterH());
                // определяем центр отображаемого на шкале x интервала
                double mx = (sm.s1()+sm.s2())/2;
                // и полуширину интервала
                double dx = (sm.s2()-sm.s1())/2;
                // в зависимости от знака угла поворота колеса мыши
                // уменьшаем полуширину отображаемых интервалов в kw раз
                if (wd > 0) dx /= kw;
                // или увеличиваем полуширину отображаемых интервалов в -kw раз
                else dx *= -kw;
                // устанавливаем новые левую и правую границы шкалы для оси x
                // (центр изображаемой части графика остается на месте,
                // а границы удаляются от центра, т.о. изображение графика уменьшается)
                zoom->isb_x->set(mx-dx,mx+dx);
            }
            if (ay) // если задано масштабирование по вертикали
            {
                // получаем карту основной вертикальной шкалы
                QwtScaleMap sm = plt->canvasMap(zoom->masterV());
                // определяем центр отображаемого на шкале y интервала
                double my = (sm.s1()+sm.s2())/2;
                // и полуширину интервала
                double dy = (sm.s2()-sm.s1())/2;
                // в зависимости от знака угла поворота колеса мыши
                // уменьшаем полуширину отображаемых интервалов в kw раз
                if (wd > 0) dy /= kw;
                // увеличиваем полуширину отображаемых интервалов в -kw раз
                else dy *= -kw;
                // устанавливаем новые нижнюю и верхнюю границы вертикальной шкалы
                // (центр изображаемой части графика остается на месте,
                // а границы удаляются от центра, т.о. изображение графика уменьшается)
                zoom->isb_y->set(my-dy,my+dy);
            }
            // перестраиваем график (синхронно с остальными)
            plt->replot();
        }
    }
}
Пример #2
0
/*!
  Expand the selected rectangle to minZoomSize() and zoom in
  if accepted.

  \param ok If true, complete the selection and emit selected signals
            otherwise discard the selection.

  \sa accept(), minZoomSize()
  \return True if the selection has been accepted, false otherwise
*/
bool QwtPlotZoomer::end( bool ok )
{
    ok = QwtPlotPicker::end( ok );
    if ( !ok )
        return false;

    QwtPlot *plot = QwtPlotZoomer::plot();
    if ( !plot )
        return false;

    const QPolygon &pa = selection();
    if ( pa.count() < 2 )
        return false;

    QRect rect = QRect( pa.first(), pa.last() );
    rect = rect.normalized();

    const QwtScaleMap xMap = plot->canvasMap( xAxis() );
    const QwtScaleMap yMap = plot->canvasMap( yAxis() );

    QRectF zoomRect = QwtScaleMap::invTransform( xMap, yMap, rect ).normalized();

    zoomRect = qwtExpandedZoomRect( zoomRect, minZoomSize(),
        xMap.transformation(), yMap.transformation() );

    zoom( zoomRect );

    return true;
}
static void renderItem( QPainter *painter,
    QwtPlotAbstractSeriesItem *seriesItem, int from, int to )
{
    QwtPlot *plot = seriesItem->plot();

    const QwtScaleMap xMap = plot->canvasMap( seriesItem->xAxis() );
    const QwtScaleMap yMap = plot->canvasMap( seriesItem->yAxis() );

    painter->setRenderHint( QPainter::Antialiasing,
        seriesItem->testRenderHint( QwtPlotItem::RenderAntialiased ) );
    seriesItem->drawSeries( painter, xMap, yMap,
        plot->canvas()->contentsRect(), from, to );
}
Пример #4
0
static inline void renderItem( 
    QPainter *painter, const QRect &canvasRect,
    QwtPlotAbstractSeriesItem *seriesItem, int from, int to )
{
    // A minor performance improvement is possible
    // with caching the maps. TODO ...

    QwtPlot *plot = seriesItem->plot();
    const QwtScaleMap xMap = plot->canvasMap( seriesItem->xAxis() );
    const QwtScaleMap yMap = plot->canvasMap( seriesItem->yAxis() );

    painter->setRenderHint( QPainter::Antialiasing,
        seriesItem->testRenderHint( QwtPlotItem::RenderAntialiased ) );
    seriesItem->drawSeries( painter, xMap, yMap, canvasRect, from, to );
}
Пример #5
0
/*!
   Adjust the enabled axes according to dx/dy

   \param dx Pixel offset in x direction
   \param dy Pixel offset in y direction

   \sa QwtPanner::panned()
*/
void QwtPlotPanner::moveCanvas( int dx, int dy )
{
    if ( dx == 0 && dy == 0 )
        return;

    QwtPlot *plot = this->plot();
    if ( plot == NULL )
        return;

    const bool doAutoReplot = plot->autoReplot();
    plot->setAutoReplot( false );

    for ( int axisPos = 0; axisPos < QwtAxis::PosCount; axisPos++ )
    {
        const int axesCount = plot->axesCount( axisPos );
        for ( int i = 0; i < axesCount; i++ )
        {
            const QwtAxisId axisId( axisPos, i );

            if ( !isAxisEnabled( axisId ) )
                continue;

            const QwtScaleMap map = plot->canvasMap( axisId );

            const double p1 = map.transform( plot->axisScaleDiv( axisId ).lowerBound() );
            const double p2 = map.transform( plot->axisScaleDiv( axisId ).upperBound() );

            double d1, d2;
            if ( QwtAxis::isXAxis( axisPos ) )
            {
                d1 = map.invTransform( p1 - dx );
                d2 = map.invTransform( p2 - dx );
            }
            else
            {
                d1 = map.invTransform( p1 - dy );
                d2 = map.invTransform( p2 - dy );
            }

            plot->setAxisScale( axisId, d1, d2 );
        }
    }

    plot->setAutoReplot( doAutoReplot );
    plot->replot();
}
Пример #6
0
/*!
   Adjust the enabled axes according to dx/dy

   \param dx Pixel offset in x direction
   \param dy Pixel offset in y direction

   \sa QwtPanner::panned()
*/
void QwtPlotPanner::moveCanvas(int dx, int dy)
{
    if ( dx == 0 && dy == 0 )
        return;

    QwtPlot *plot = QwtPlotPanner::plot();
    if ( plot == NULL )
        return;
    
    const bool doAutoReplot = plot->autoReplot();
    plot->setAutoReplot(false);

    for ( int axis = 0; axis < QwtPlot::axisCnt; axis++ )
    {
        if ( !d_data->isAxisEnabled[axis] )
            continue;

        const QwtScaleMap map = plot->canvasMap(axis);

        const int i1 = map.transform(plot->axisScaleDiv(axis)->lowerBound());
        const int i2 = map.transform(plot->axisScaleDiv(axis)->upperBound());

        double d1, d2;
        if ( axis == QwtPlot::xBottom || axis == QwtPlot::xTop )
        {
            d1 = map.invTransform(i1 - dx);
            d2 = map.invTransform(i2 - dx);
        }
        else
        {
            d1 = map.invTransform(i1 - dy);
            d2 = map.invTransform(i2 - dy);
        }

        plot->setAxisScale(axis, d1, d2);
    }

    plot->setAutoReplot(doAutoReplot);
    plot->replot();
}
Пример #7
0
// Обработчик нажатия на кнопку мыши над шкалой
// (включение изменения масштаба шкалы)
void QAxisZoomSvc::startAxisZoom(QMouseEvent *mEvent,int ax)
{
    // фиксируем исходные границы графика (если этого еще не было сделано)
    zoom->fixBounds();
    // если в данный момент еще не включен ни один из режимов
    if (zoom->regim() == QwtChartZoom::ctNone)
    {
        // если нажата левая кнопка мыши, то
        // включаем один из режимов масштабирования
        if (mEvent->button() == Qt::LeftButton)
        {
            // получаем указатели на
            QwtPlot *plt = zoom->plot();                // график
            QwtScaleWidget *sw = plt->axisWidget(ax);   // виджет шкалы
            // получаем карту основной горизонтальной шкалы
            QwtScaleMap sm = plt->canvasMap(zoom->masterH());
            // для того чтобы фиксировать начальные левую и правую границы
            scb_xl = sm.s1(); scb_xr = sm.s2(); scb_wx = sm.sDist();
            // аналогично получаем карту основной вертикальной шкалы
            sm = plt->canvasMap(zoom->masterV());
            // для того чтобы фиксировать начальные нижнюю и верхнюю границы
            scb_yb = sm.s1(); scb_yt = sm.s2(); scb_hy = sm.sDist();
            // определяем (для удобства) геометрию
            QRect gc = plt->canvas()->geometry();   // канвы графика
            QRect gw = sw->geometry();              // и виджета шкалы
            // текущее левое смещение графика (в пикселах относительно канвы)
            scb_pxl = plt->transform(zoom->masterH(),scb_xl);
            // текущая ширина графика (в пикселах)
            scb_pw = plt->transform(zoom->masterH(),scb_xr) - scb_pxl;
            // текущее левое смещение графика
            // (в пикселах относительно виджета шкалы)
            sab_pxl = scb_pxl + gc.x() - gw.x();
            // текущее верхнее смещение графика (в пикселах относительно канвы)
            scb_pyt = plt->transform(zoom->masterV(),scb_yt);
            // текущая высота графика (в пикселах)
            scb_ph = plt->transform(zoom->masterV(),scb_yb) - scb_pyt;
            // текущее верхнее смещение графика
            // (в пикселах относительно виджета шкалы)
            sab_pyt = scb_pyt + gc.y() - gw.y();
            // запоминаем текущее положение курсора относительно канвы
            // (за вычетом смещений графика)
            scp_x = mEvent->pos().x() - sab_pxl;
            scp_y = mEvent->pos().y() - sab_pyt;
            // если масштабируется горизонтальная шкала
            if (ax == QwtPlot::xBottom ||
                ax == QwtPlot::xTop)
            {
                // если левая граница меньше правой,
                if (scb_wx > 0)
                    // если ширина канвы больше минимума,
                    if (scb_pw > 36)
                    {
                        // в зависимости от положения курсора
                        // (правее или левее середины шкалы)
                        // включаем соответствующий режим - изменение
                        if (scp_x >= floor((float)(scb_pw/2)))
                            zoom->setRegim(QwtChartZoom::ctAxisHR);     // правой границы
                        else zoom->setRegim(QwtChartZoom::ctAxisHL);    // или левой
                    }
            }
            else    // иначе (масштабируется вертикальная шкала)
            {
                // если нижняя граница меньше верхней,
                if (scb_hy > 0)
                    // если высота канвы больше минимума,
                    if (scb_ph > 18)
                    {
                        // в зависимости от положения курсора
                        // (ниже или выше середины шкалы)
                        // включаем соответствующий режим - изменение
                        if (scp_y >= floor((float)(scb_ph/2)))
                            zoom->setRegim(QwtChartZoom::ctAxisVB);     // нижней границы
                        else zoom->setRegim(QwtChartZoom::ctAxisVT);    // или верхней
                    }
            }
            // если один из режимов был включен
            if (zoom->regim() != QwtChartZoom::ctNone)
            {
                // запоминаем текущий курсор
                tCursor = sw->cursor();
                // устанавливаем курсор PointingHand
                sw->setCursor(Qt::PointingHandCursor);
                // если легкий режим и включена индикация, то
                if (light && indiAxZ)
                {
                    // создаем виджет, индицирующий масштабирование шкалы
                    zwid = new QWidget(plt->axisWidget(ax));
                    // назначаем ему цвет
                    zwid->setStyleSheet(QString(
                        "background-color:rgb(%1,%2,%3);").arg(
                        awClr.red()).arg(awClr.green()).arg(awClr.blue()));
                    // и прорисовываем
                    showZoomWidget(mEvent->pos(),ax);
                }
            }
        }
    }
}
Пример #8
0
void PlotMagnifier::rescale( double factor, AxisMode axis )
{
    factor = qAbs( 1.0/factor );

    QwtPlot* plt = plot();
    if ( plt == nullptr || factor == 1.0 ){
        return;
    }

    bool doReplot = false;

    const bool autoReplot = plt->autoReplot();
    plt->setAutoReplot( false );

    const int axis_list[2] = {QwtPlot::xBottom, QwtPlot::yLeft};
    QRectF new_rect;

    for ( int i = 0; i <2; i++ )
    {
        double temp_factor = factor;
        if( i==1 && axis == X_AXIS)
        {
            temp_factor = 1.0;
        }
        if( i==0 && axis == Y_AXIS)
        {
            temp_factor = 1.0;
        }

        int axisId = axis_list[i];

        if ( isAxisEnabled( axisId ) )
        {
            const QwtScaleMap scaleMap = plt->canvasMap( axisId );

            double v1 = scaleMap.s1();
            double v2 = scaleMap.s2();
            double center = _mouse_position.x();

            if( axisId == QwtPlot::yLeft){
                center = _mouse_position.y();
            }

            if ( scaleMap.transformation() )
            {
                // the coordinate system of the paint device is always linear
                v1 = scaleMap.transform( v1 ); // scaleMap.p1()
                v2 = scaleMap.transform( v2 ); // scaleMap.p2()
            }

            const double width = ( v2 - v1 );
            const double ratio = (v2-center)/ (width);

            v1 = center - width*temp_factor*(1-ratio);
            v2 = center + width*temp_factor*(ratio);

            if( v1 > v2 ) std::swap( v1, v2 );

            if ( scaleMap.transformation() )
            {
                v1 = scaleMap.invTransform( v1 );
                v2 = scaleMap.invTransform( v2 );
            }

            if( v1 < _lower_bounds[axisId]) v1 = _lower_bounds[axisId];
            if( v2 > _upper_bounds[axisId]) v2 = _upper_bounds[axisId];

            plt->setAxisScale( axisId, v1, v2 );

            if( axisId == QwtPlot::xBottom)
            {
                new_rect.setLeft(  v1 );
                new_rect.setRight( v2 );
            }
            else{
                new_rect.setBottom( v1 );
                new_rect.setTop( v2 );
            }

            doReplot = true;
        }
    }

    plt->setAutoReplot( autoReplot );

    if ( doReplot ){
        emit rescaled( new_rect );
    }
}