Пример #1
0
void ViewerDialog::tickEvent()
{
    const QModelIndex& i2 = viewer->getModel().getNextItem(viewer->getCurrentRow());
    if(isSlide && i2.isValid()) {
        nextEvent();

        QTimer::singleShot(3000, this, SLOT(tickEvent()));
    } else {
        aSlide->setText("&Start slide show");
        aSlide->setStatusTip("Start slide show");
        aSlide->setIcon(QIcon(":/res/resources/play.png"));
        isSlide = false;
    }
}
Пример #2
0
void ViewerDialog::slideEvent() {
    if(!isSlide) {
        aSlide->setText("&Stop slide show");
        aSlide->setStatusTip("Stop slide show");
        aSlide->setIcon(QIcon(":/res/resources/stop.png"));
        isSlide = true;

        QTimer::singleShot(3000, this, SLOT(tickEvent()));
    } else {
        aSlide->setText("&Start slide show");
        aSlide->setStatusTip("Start slide show");
        aSlide->setIcon(QIcon(":/res/resources/play.png"));
        isSlide = false;
    }
}
Пример #3
0
void Sdl2Application::mainLoop() {
    #ifndef CORRADE_TARGET_EMSCRIPTEN
    const UnsignedInt timeBefore = _minimalLoopPeriod ? SDL_GetTicks() : 0;
    #endif

    SDL_Event event;
    while(SDL_PollEvent(&event)) {
        switch(event.type) {
            case SDL_WINDOWEVENT:
                switch(event.window.event) {
                    case SDL_WINDOWEVENT_RESIZED: {
                        #ifndef CORRADE_TARGET_IOS
                        viewportEvent({event.window.data1, event.window.data2});
                        #else
                        /* On iOS the window event is in points and not pixels,
                           but we need pixels to call glViewport() properly */
                        Vector2i drawableSize;
                        SDL_GL_GetDrawableSize(_window, &drawableSize.x(), &drawableSize.y());
                        viewportEvent(drawableSize);
                        #endif
                        _flags |= Flag::Redraw;
                    } break;
                    case SDL_WINDOWEVENT_EXPOSED:
                        _flags |= Flag::Redraw;
                        break;
                } break;

            case SDL_KEYDOWN:
            case SDL_KEYUP: {
                KeyEvent e(static_cast<KeyEvent::Key>(event.key.keysym.sym), fixedModifiers(event.key.keysym.mod));
                event.type == SDL_KEYDOWN ? keyPressEvent(e) : keyReleaseEvent(e);
            } break;

            case SDL_MOUSEBUTTONDOWN:
            case SDL_MOUSEBUTTONUP: {
                MouseEvent e(static_cast<MouseEvent::Button>(event.button.button), {event.button.x, event.button.y});
                event.type == SDL_MOUSEBUTTONDOWN ? mousePressEvent(e) : mouseReleaseEvent(e);
            } break;

            case SDL_MOUSEWHEEL:
                if(event.wheel.y != 0) {
                    MouseEvent e(event.wheel.y > 0 ? MouseEvent::Button::WheelUp : MouseEvent::Button::WheelDown, {event.wheel.x, event.wheel.y});
                    mousePressEvent(e);
                } break;

            case SDL_MOUSEMOTION: {
                MouseMoveEvent e({event.motion.x, event.motion.y}, {event.motion.xrel, event.motion.yrel}, static_cast<MouseMoveEvent::Button>(event.motion.state));
                mouseMoveEvent(e);
                break;
            }

            case SDL_QUIT:
                #ifndef CORRADE_TARGET_EMSCRIPTEN
                _flags |= Flag::Exit;
                #else
                emscripten_cancel_main_loop();
                #endif
                return;
        }
    }

    /* Tick event */
    if(!(_flags & Flag::NoTickEvent)) tickEvent();

    /* Draw event */
    if(_flags & Flag::Redraw) {
        _flags &= ~Flag::Redraw;
        drawEvent();

        #ifndef CORRADE_TARGET_EMSCRIPTEN
        /* If VSync is not enabled, delay to prevent CPU hogging (if set) */
        if(!(_flags & Flag::VSyncEnabled) && _minimalLoopPeriod) {
            const UnsignedInt loopTime = SDL_GetTicks() - timeBefore;
            if(loopTime < _minimalLoopPeriod)
                SDL_Delay(_minimalLoopPeriod - loopTime);
        }
        #endif

        return;
    }

    #ifndef CORRADE_TARGET_EMSCRIPTEN
    /* If not drawing anything, delay to prevent CPU hogging (if set) */
    if(_minimalLoopPeriod) {
        const UnsignedInt loopTime = SDL_GetTicks() - timeBefore;
        if(loopTime < _minimalLoopPeriod)
            SDL_Delay(_minimalLoopPeriod - loopTime);
    }

    /* Then, if the tick event doesn't need to be called periodically, wait
       indefinitely for next input event */
    if(_flags & Flag::NoTickEvent) SDL_WaitEvent(nullptr);
    #endif
}