Speed problem dragging points

[mastupristi]

I use xubuntu 16.04 with official qt pakages: qt 5.5.1, qwt 6.1.2.
The hw is an Intel i7 970, nVidia 460, 12gb RAM

Best regards
Max

[Uwe]

Sounds like a powerful system - all I can imagine, that might explain the video is when your X11 is totally misconfigured.

Uwe

[mastupristi]

My computer is six years old, not a recent one, but it is still quite powerfull.
I'll take a look to x11 config. Until now I trust ubuntu to configure automagically X.
Anyway, the itemeditor example is fast enough also in full screen mode, and zoomed to have bigger items.

Best regards
Max

[mastupristi]

I spent some time investigating X11 config, I installed the new nVidia proprietary driver, I have tested the performance with x11perf. Nothing seems wrong. But the event_filter example was still slow.

So I decide to have a deeper look to itemeditor example to make event_filter use overlay.

The result is here:
ev-filt-overlay.tar.gz
It is definitely improvable, as coding style, as class usage, but it is fast enough also in fullscreen.
Can I have your opinion about it?

I also have a question on itemeditor example.

about eventFilter method in Editor class:

bool Editor::eventFilter( QObject* object, QEvent* event )
{
    QwtPlot *plot = qobject_cast<QwtPlot *>( parent() );
    if ( plot && object == plot->canvas() )
    {
        switch( event->type() )
        {
            case QEvent::MouseButtonPress:
            {
                const QMouseEvent* mouseEvent =
                    dynamic_cast<QMouseEvent* >( event );
 
                if ( d_overlay == NULL && 
                    mouseEvent->button() == Qt::LeftButton  )
                {
                    const bool accepted = pressed( mouseEvent->pos() );
                    if ( accepted )
                    {
                        d_overlay = new Overlay( plot->canvas(), this );
 
                        d_overlay->updateOverlay();
                        d_overlay->show();
                    }
                }
 
                break;
            }
            case QEvent::MouseMove:
            {
                if ( d_overlay )
                {
                    const QMouseEvent* mouseEvent =
                        dynamic_cast< QMouseEvent* >( event );
 
                    const bool accepted = moved( mouseEvent->pos() );
                    if ( accepted )
                        d_overlay->updateOverlay();
                }
 
                break;
            }
            case QEvent::MouseButtonRelease:
            {
                const QMouseEvent* mouseEvent =
                    static_cast<QMouseEvent* >( event );
 
                if ( d_overlay && mouseEvent->button() == Qt::LeftButton )
                {
                    released( mouseEvent->pos() );
 
                    delete d_overlay;
                    d_overlay = NULL;
                }
 
                break;
            }
            default:
                break;
        }
 
        return false;
    }
 
    return QObject::eventFilter( object, event );
}

bool Editor::eventFilter( QObject* object, QEvent* event )
{
    QwtPlot *plot = qobject_cast<QwtPlot *>( parent() );
    if ( plot && object == plot->canvas() )
    {
        switch( event->type() )
        {
            case QEvent::MouseButtonPress:
            {
                const QMouseEvent* mouseEvent =
                    dynamic_cast<QMouseEvent* >( event );

                if ( d_overlay == NULL && 
                    mouseEvent->button() == Qt::LeftButton  )
                {
                    const bool accepted = pressed( mouseEvent->pos() );
                    if ( accepted )
                    {
                        d_overlay = new Overlay( plot->canvas(), this );

                        d_overlay->updateOverlay();
                        d_overlay->show();
                    }
                }

                break;
            }
            case QEvent::MouseMove:
            {
                if ( d_overlay )
                {
                    const QMouseEvent* mouseEvent =
                        dynamic_cast< QMouseEvent* >( event );

                    const bool accepted = moved( mouseEvent->pos() );
                    if ( accepted )
                        d_overlay->updateOverlay();
                }

                break;
            }
            case QEvent::MouseButtonRelease:
            {
                const QMouseEvent* mouseEvent =
                    static_cast<QMouseEvent* >( event );

                if ( d_overlay && mouseEvent->button() == Qt::LeftButton )
                {
                    released( mouseEvent->pos() );

                    delete d_overlay;
                    d_overlay = NULL;
                }

                break;
            }
            default:
                break;
        }

        return false;
    }

    return QObject::eventFilter( object, event );
}

To copy to clipboard, switch view to plain text mode 

For every event in the switch, it return false (line 61). But in the QT documentation about QObject::eventFilter there is:

In your reimplementation of this function, if you want to filter the event out, i.e. stop it being handled further, return true; otherwise return false.

In this case why return false instead of true, since the events are handled?

best regards
Max

[Uwe]

There are 2 differences between what happens in the itemeditor and the event_filter example.

a) In the itemeditor example the content of the plot remains unchanged. So when the item is dragged the content can be restored from a pixmap cache without having to do a replot.
b) Depending on the Mask parameter, the pixels written to the graphics stack might be limited to the pixels, that are really changing.

As the event_filter has almost no content, the effect of a) should be no factor - for heavy plots it would be significant. So in your case I would expect, that b) is what you are suffering from.

In case of remote desktops it is obvious, that pushing a fullscreen image ( width * height * 4 ) over the network is slower than a smaller one. Here it might be worth to go back to Qt4 ( graphic system native ), what is much faster for vector graphics. But as you are not using a remote desktop it means, that flushing a RGB buffer is a horrible bottleneck - something that will hit you in many other situations as well.

Uwe