Esempio n. 1
0
void PlayerWidget::mouseReleaseEvent(QMouseEvent *e) {
	if (_down == OverVolume) {
		mouseMoveEvent(e);
		Local::writeUserSettings();
	} else if (_down == OverPlayback) {
		mouseMoveEvent(e);
		SongMsgId playing;
		AudioPlayerState playingState = AudioPlayerStopped;
		int64 playingPosition = 0, playingDuration = 0;
		int32 playingFrequency = 0;
		audioPlayer()->currentState(&playing, &playingState, &playingPosition, &playingDuration, &playingFrequency);
		if (playing == _song && playingDuration) {
			_downDuration = playingDuration;
			audioPlayer()->seek(qRound(_downProgress * _downDuration));

			_showPause = true;

			a_progress = anim::fvalue(_downProgress, _downProgress);
			_a_progress.stop();
		}
		update();
	} else if (_down == OverClose && _over == OverClose) {
		stopPressed();
	}
	_down = OverNone;
}
TEST(TestMouseEventDispatcher, TestMouseButtonSimple) {
    GlfwMock mock;
    FTEngine::setup(true);
    MockMouseEventListener listener;

    auto move_delegate = Gallant::Delegate1<const FTMouseMoveEvent&>(&listener, &MockMouseEventListener::mouseMoveEvent);
    FTEngine::getEventManager()->getEventDispatcher<FTMouseEventDispatcher>()->registerDelegate(move_delegate);

    auto pressed_delegate = Gallant::Delegate1<const FTMouseButtonPressedEvent&>(&listener, &MockMouseEventListener::mouseButtonPressedEvent);
    FTEngine::getEventManager()->getEventDispatcher<FTMouseEventDispatcher>()->registerDelegate(pressed_delegate);

    auto released_delegate = Gallant::Delegate1<const FTMouseButtonReleasedEvent&>(&listener, &MockMouseEventListener::mouseButtonReleasedEvent);
    FTEngine::getEventManager()->getEventDispatcher<FTMouseEventDispatcher>()->registerDelegate(released_delegate);

    testing::InSequence s;

    EXPECT_CALL(listener, mouseMoveEvent(FTMouseMoveEvent(200, 100, 0, 0)));
    EXPECT_CALL(listener, mouseMoveEvent(FTMouseMoveEvent(240, 80, 40, -20)));
    EXPECT_CALL(listener, mouseButtonPressedEvent(FTMouseButtonPressedEvent(240, 80, GLFW_MOUSE_BUTTON_LEFT, false)));
    EXPECT_CALL(listener, mouseButtonReleasedEvent(FTMouseButtonReleasedEvent(240, 80, GLFW_MOUSE_BUTTON_LEFT, false)));

    mock.mouse_pos_callback_(nullptr, 200, 100);
    mock.mouse_pos_callback_(nullptr, 240, 80);
    mock.mouse_button_callback_(nullptr, GLFW_MOUSE_BUTTON_LEFT, GLFW_PRESS, 0);
    mock.mouse_button_callback_(nullptr, GLFW_MOUSE_BUTTON_LEFT, GLFW_RELEASE, 0);


    FTEngine::cleanup();
}
TEST(TestMouseEventDispatcher, TestEnterExitPosPurge) {
    GlfwMock mock;
    FTEngine::setup(true);
    MockMouseEventListener listener;

    auto enter_delegate = Gallant::Delegate1<const FTMouseEnterEvent&>(&listener, &MockMouseEventListener::mouseEnterEvent);
    FTEngine::getEventManager()->getEventDispatcher<FTMouseEventDispatcher>()->registerDelegate(enter_delegate);
    auto exit_delegate = Gallant::Delegate1<const FTMouseExitEvent&>(&listener, &MockMouseEventListener::mouseExitEvent);
    FTEngine::getEventManager()->getEventDispatcher<FTMouseEventDispatcher>()->registerDelegate(exit_delegate);
    auto move_delegate = Gallant::Delegate1<const FTMouseMoveEvent&>(&listener, &MockMouseEventListener::mouseMoveEvent);
    FTEngine::getEventManager()->getEventDispatcher<FTMouseEventDispatcher>()->registerDelegate(move_delegate);

    testing::InSequence s;


    EXPECT_CALL(listener, mouseMoveEvent(FTMouseMoveEvent(200, 100, 0, 0)));
    EXPECT_CALL(listener, mouseEnterEvent(testing::_));
    EXPECT_CALL(listener, mouseExitEvent(testing::_));
    EXPECT_CALL(listener, mouseMoveEvent(FTMouseMoveEvent(240, 80, 0, 0)));

    mock.mouse_pos_callback_(nullptr, 200, 100);

    mock.mouse_enter_callback_(nullptr, GL_TRUE);
    mock.mouse_enter_callback_(nullptr, GL_FALSE);

    mock.mouse_pos_callback_(nullptr, 240, 80);

    FTEngine::cleanup();
}
Esempio n. 4
0
void StrokeManager::mouseReleaseEvent(QMouseEvent *event)
{
    // flush out stroke
    if (m_strokeStarted) {
        mouseMoveEvent(event);
        mouseMoveEvent(event);
    }
    m_lastReleasePosition = getEventPosition(event);

    m_strokeStarted = false;
    enableCoalescing();
}
Esempio n. 5
0
bool SceneItem::event(QEvent* event) {
    switch (event->type()) {
    case QEvent::KeyPress:
        keyPressEvent(static_cast<QKeyEvent*>(event));
        break;
    case QEvent::KeyRelease:
        keyReleaseEvent(static_cast<QKeyEvent*>(event));
        break;
    case SceneMouseEvent::DOUBLE_CLICK_TYPE:
        mouseDoubleClickEvent(static_cast<SceneMouseEvent*>(event));
        break;
    case SceneMouseEvent::MOVE_TYPE:
        mouseMoveEvent(static_cast<SceneMouseEvent*>(event));
        break;
    case SceneMouseEvent::PRESS_TYPE:
        mousePressEvent(static_cast<SceneMouseEvent*>(event));
        break;
    case SceneMouseEvent::RELEASE_TYPE:
        mouseReleaseEvent(static_cast<SceneMouseEvent*>(event));
        break;
    case QEvent::Wheel:
        wheelEvent(static_cast<QWheelEvent*>(event));
        break;
    default:
        return false;
    }
    return true;
}
Esempio n. 6
0
void Input::DoKeyEvents()
{
	int numOfKeys;
	const Uint8* keyStates = SDL_GetKeyboardState(&numOfKeys);
	int mouse_x;
	int mouse_y;
	int mouse_relx;
	int mouse_rely;

	SDL_GetMouseState(&mouse_x, &mouse_y);
	SDL_GetRelativeMouseState(&mouse_relx, &mouse_rely);

	if(mouseMoveEvent)
	{
		mouseMoveEvent(mouse_x, mouse_y, mouse_relx, mouse_rely);
	}

	for(int i = 0; i < numOfKeys; i++)
	{
		if(keyStates[i])
		{
			//calls the function with the associated scan code
			auto it = function_map.find((SDL_Scancode)i);
			if(it != function_map.end())
			{
				it->second();
			}
		}
	}
}
TEST_F(EventHandlerTest, draggedSVGImagePositionTest)
{
    setHtmlInnerHTML(
        "<style>"
        "body { margin: 0px; }"
        "[draggable] {"
        "-webkit-user-select: none; user-select: none; -webkit-user-drag: element; }"
        "</style>"
        "<div style='width: 300px; height: 100px;'>"
        "<svg width='500' height='500'>"
        "<rect x='100' y='100' width='100px' height='100px' fill='blue' draggable='true'/>"
        "</svg>"
        "</div>");
    PlatformMouseEvent mouseDownEvent(
        IntPoint(145, 144),
        IntPoint(212, 282),
        LeftButton,
        PlatformEvent::MousePressed,
        1,
        PlatformEvent::Modifiers::LeftButtonDown,
        WTF::monotonicallyIncreasingTime());
    document().frame()->eventHandler().handleMousePressEvent(mouseDownEvent);

    PlatformMouseEvent mouseMoveEvent(
        IntPoint(618, 298),
        IntPoint(685, 436),
        LeftButton,
        PlatformEvent::MouseMoved,
        1,
        PlatformEvent::Modifiers::LeftButtonDown,
        WTF::monotonicallyIncreasingTime());
    document().frame()->eventHandler().handleMouseMoveEvent(mouseMoveEvent);

    EXPECT_EQ(IntPoint(45, 44), document().frame()->eventHandler().dragDataTransferLocationForTesting());
}
TEST_F(EventHandlerTest, draggedInlinePositionTest)
{
    setHtmlInnerHTML(
        "<style>"
        "body { margin: 0px; }"
        ".line { font-family: sans-serif; background: blue; width: 300px; height: 30px; font-size: 40px; margin-left: 250px; }"
        "</style>"
        "<div style='width: 300px; height: 100px;'>"
        "<span class='line' draggable='true'>abcd</span>"
        "</div>");
    PlatformMouseEvent mouseDownEvent(
        IntPoint(262, 29),
        IntPoint(329, 67),
        LeftButton,
        PlatformEvent::MousePressed,
        1,
        PlatformEvent::Modifiers::LeftButtonDown,
        WTF::monotonicallyIncreasingTime());
    document().frame()->eventHandler().handleMousePressEvent(mouseDownEvent);

    PlatformMouseEvent mouseMoveEvent(
        IntPoint(618, 298),
        IntPoint(685, 436),
        LeftButton,
        PlatformEvent::MouseMoved,
        1,
        PlatformEvent::Modifiers::LeftButtonDown,
        WTF::monotonicallyIncreasingTime());
    document().frame()->eventHandler().handleMouseMoveEvent(mouseMoveEvent);

    EXPECT_EQ(IntPoint(12, 29), document().frame()->eventHandler().dragDataTransferLocationForTesting());
}
Esempio n. 9
0
void CommentController::
        enableCommentAdder(bool active)
{
    tool_selector_->setCurrentTool( this, active );
    graphicsview_->setToolFocus( active );

    if (active)
    {
        comment_ = createNewComment();
        setVisible( true );

        setMouseTracking( true );
        mouseMoveEvent(new QMouseEvent(
                QEvent::MouseMove,
                mapFromGlobal(graphicsview_->mapFromGlobal( QCursor::pos())),
                Qt::NoButton,
                Qt::MouseButtons(),
                Qt::KeyboardModifiers()));
    }
    else
    {
        if (comment_)
        {
            // didn't place new comment before tool was disabled
            QGraphicsProxyWidget* proxy = comment_->getProxy();
            proxy->deleteLater();
            comment_ = 0;
            setVisible( false );
        }
    }
}
Esempio n. 10
0
bool WindowManager::eventFilter(QObject *object, QEvent *event)
{
    if (!enabled()) {
        return false;
    }

    switch (event->type())
    {
    case QEvent::MouseButtonPress:
        return mousePressEvent(object, event);
        break;
    case QEvent::MouseMove:
        if (object == _target.data()) {
            return mouseMoveEvent(object, event);
        }
        break;
    case QEvent::MouseButtonRelease:
        if (_target) {
            return mouseReleaseEvent(object, event);
        }
        break;
    default:
        break;
    }
    return false;
}
Esempio n. 11
0
void WSpinny::mousePressEvent(QMouseEvent * e)
{
    int y = e->y();
    int x = e->x();

    m_iStartMouseX = x;
    m_iStartMouseY = y;

    //don't do anything if vinyl control is active
    if (m_bVinylActive)
        return;

    if (e->button() == Qt::LeftButton || e->button() == Qt::RightButton) {
        QApplication::setOverrideCursor(QCursor(Qt::ClosedHandCursor));

        // Coordinates from center of widget
        double c_x = x - width()/2;
        double c_y = y - height()/2;
        double theta = (180.0/M_PI)*atan2(c_x, -c_y);
        m_dPrevTheta = theta;
        m_iFullRotations = calculateFullRotations(m_pPlayPos->get());
        theta += m_iFullRotations * 360.0;
        m_dInitialPos = calculatePositionFromAngle(theta) * m_pTrackSamples->get();

        m_pScratchPos->slotSet(0);
        m_pScratchToggle->slotSet(1.0);

        if (e->button() == Qt::RightButton) {
            m_pSlipEnabled->slotSet(1.0);
        }

        // Trigger a mouse move to immediately line up the vinyl with the cursor
        mouseMoveEvent(e);
    }
}
Esempio n. 12
0
void Tool::toolEvent(QEvent *event)
{
	switch((int)event->type())
	{
		case QEvent::KeyPress:
			keyPressEvent(static_cast<QKeyEvent *>(event));
			return;
		case QEvent::KeyRelease:
			keyReleaseEvent(static_cast<QKeyEvent *>(event));
			return;
		case EventCanvasMouseMove:
			mouseMoveEvent(static_cast<CanvasMouseEvent *>(event));
			return;
		case EventCanvasMousePress:
			mousePressEvent(static_cast<CanvasMouseEvent *>(event));
			return;
		case EventCanvasMouseRelease:
			mouseReleaseEvent(static_cast<CanvasMouseEvent *>(event));
			return;
		case EventCanvasMouseDoubleClick:
			mouseDoubleClickEvent(static_cast<CanvasMouseEvent *>(event));
			return;
		case EventCanvasTabletMove:
			tabletMoveEvent(static_cast<CanvasTabletEvent *>(event));
			return;
		case EventCanvasTabletPress:
			tabletPressEvent(static_cast<CanvasTabletEvent *>(event));
			return;
		case EventCanvasTabletRelease:
			tabletReleaseEvent(static_cast<CanvasTabletEvent *>(event));
			return;
		default:
			return;
	}
}
Esempio n. 13
0
RealPaintWidget::RealPaintWidget( plugin::PluginsManager *manager, QWidget *parent ):
	RPWInterface( parent ), background( 0 ),
	fixedSize( true ), size( 640, 480 ),
	selection( manager, this, QRect( QPoint( 0, 0 ), size ) ),
	inKeyPressedHandler( false ),
	currentTool( 0 ), inSelectionMode( false ), _manager(manager)
{
	GLayer* layer = new GLayer();
	layer->setVisible(true);
	layer->setObjectName(tr("Layer") + " 0");
	layers.append(layer);
	currentLayer = 0;
	currentFrame = 0;
	layers[currentLayer]->addFrameForLayer(currentFrame,false);
	emit figureSelected(currentLayer, -1);
    paintConMenu = new QMenu(this);
	propertiesAct = paintConMenu->addAction(tr("Properties..."));
	setAutoFillBackground( false );
	resize( size );

	connect( propertiesAct,SIGNAL( triggered( bool ) ), this, SLOT( onPropertiesObj() ) );
	connect( &selection, SIGNAL( changed() ), this, SLOT( update() ) );

	manager->addPlugins(this, "RealPaint");

    isMousePress = false;
    setMouseTracking(true);

    //qDebug() << getPoint();
    QPoint p(10,10);
    emit mouseMoveEvent(QWidget::mapToParent(p),p);
}
void Ut_MStatusBarView::mouseMoveWorker(QPointF moveTo)
{
    mouseMovePos = moveTo;
    mouseEvent = MouseEvent::MouseMove;
    QGraphicsSceneMouseEvent mouseMoveEvent(QEvent::GraphicsSceneMouseMove);
    m_subject->mouseMoveEvent(&mouseMoveEvent);
}
Esempio n. 15
0
bool QWSManager::event(QEvent *e)
{
    if (QObject::event(e))
        return true;

    switch (e->type()) {
    case QEvent::MouseMove:
        mouseMoveEvent((QMouseEvent*)e);
        break;

    case QEvent::MouseButtonPress:
        mousePressEvent((QMouseEvent*)e);
        break;

    case QEvent::MouseButtonRelease:
        mouseReleaseEvent((QMouseEvent*)e);
        break;

    case QEvent::MouseButtonDblClick:
        mouseDoubleClickEvent((QMouseEvent*)e);
        break;

    case QEvent::Paint:
        paintEvent((QPaintEvent*)e);
        break;

    default:
        return false;
        break;
    }

    return true;
}
Esempio n. 16
0
int MainWindow::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QMainWindow::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: update((*reinterpret_cast< QString(*)>(_a[1]))); break;
        case 1: on_tabWidget_currentChanged((*reinterpret_cast< int(*)>(_a[1]))); break;
        case 2: on_minusBTN_clicked(); break;
        case 3: on_plusBTN_clicked(); break;
        case 4: on_toolButton_clicked(); break;
        case 5: on_nextBTN_clicked(); break;
        case 6: on_prevBTN_clicked(); break;
        case 7: on_saveLayoutBTN_clicked(); break;
        case 8: on_reprocBTN_clicked(); break;
        case 9: on_whiteBTN_clicked((*reinterpret_cast< bool(*)>(_a[1]))); break;
        case 10: on_blackBTN_clicked((*reinterpret_cast< bool(*)>(_a[1]))); break;
        case 11: on_openfileBTN_clicked(); break;
        case 12: mousePressEvent((*reinterpret_cast< QMouseEvent*(*)>(_a[1]))); break;
        case 13: mouseMoveEvent((*reinterpret_cast< QMouseEvent*(*)>(_a[1]))); break;
        case 14: valueChangeRequest((*reinterpret_cast< QPoint(*)>(_a[1]))); break;
        case 15: showHelp(); break;
        default: ;
        }
        _id -= 16;
    }
    return _id;
}
void GL_insert_ball_layer_2::mousePressEvent(QMouseEvent *e) {
	// insert - without left button
	if ((is_control(e)/* || is_alt(e)*/) && e->button() == Qt::LeftButton) {
		last_x = widget->x_real(e->x());
		last_y = widget->y_real(e->y());
		state = CIRCLE;
		emit add_point_to_selection(QPointF(last_x,last_y));
	/*	if (is_alt(e)) {
			points_buffer.push_back(QPointF(x,y));
			emit add_point_to_selection(QPointF(x,y));
		}
		else
			emit point_created(x,y);*/
	}
	// spray - with middle button
	if ((is_control(e)/* || is_alt(e)*/) && e->button() == Qt::MidButton) {
		state = SPRAY;
		QSettings settings;
		min_squared_distance = settings.value("insert-point-min-squared-distance").toInt();
//		std::cout << "insert-point-min-squared-distance: " << min_squared_distance << std::endl;
		last_spray_x = last_spray_y = -1;
		mouseMoveEvent(e); // to insert the first point
	}

	if ((is_control(e)/* || is_alt(e)*/) && e->button() == Qt::RightButton) {
		last_x = widget->x_real(e->x());
		last_y = widget->y_real(e->y());
		emit ball_created(Point3D(last_x, last_y, last_radius));
	}
}
Esempio n. 18
0
bool Stack::eventFilter(QObject* watched, QEvent* event)
{
	if (event->type() == QEvent::MouseMove) {
		mouseMoveEvent(static_cast<QMouseEvent*>(event));
	}
	return QWidget::eventFilter(watched, event);
}
Esempio n. 19
0
bool Document::eventFilter(QObject* watched, QEvent* event)
{
	if (event->type() == QEvent::MouseMove) {
		mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (event->type() == QEvent::KeyPress && watched == m_text) {
		int msecs = m_time.restart();
		if (msecs < 30000) {
			m_current_time += msecs;
		}
		QKeyEvent* key_event = static_cast<QKeyEvent*>(event);

                if(key_event->key()==Qt::Key_Return)
                {
                    QTextCursor testcursor(m_text->document());
                    testcursor.setPosition(m_text->textCursor().anchor());
                    int ancblock=testcursor.blockNumber();
                    testcursor.setPosition(m_text->textCursor().position());
                    int curblock=testcursor.blockNumber();
                    if(curblock==ancblock)
                    {
                        QString uprop=testcursor.blockFormat().stringProperty(QTextFormat::UserProperty);
                        if(uprop=="ATTRIBUTION" || uprop.startsWith("DIVIDER"))
                        {
                            testcursor.insertBlock(defaultFormatForBlock(""));
                            return true;
                        }
                    }
                }


                if (!key_event->text().isEmpty())
                {
                        QTextCursor testcursor2=QTextCursor(m_text->textCursor());
                        if(testcursor2.anchor()==testcursor2.position()&&testcursor2.atBlockStart()&&testcursor2.blockFormat().stringProperty(QTextFormat::UserProperty).startsWith("DIVIDER"))
                            return true;
                        if(SmartQuotes::isEnabled()&&key_event->text()=="-")
                        {
                                QTextCursor testcursor=QTextCursor(m_text->document());
                                int ancpos=m_text->textCursor().anchor();
                                int curpos=m_text->textCursor().position();
                                testcursor.setPosition(ancpos<curpos?ancpos:curpos);
                                if(!testcursor.atBlockStart())
                                {
                                    testcursor.movePosition(QTextCursor::Left,QTextCursor::KeepAnchor);
                                    if(testcursor.selectedText()=="-")
                                    {
                                        testcursor.insertText(QString(QChar(0x2014)));
                                        m_text->textCursor().removeSelectedText();
                                        return true;
                                    }
                                }
                        }
			emit keyPressed(key_event->key());
		}
		if (SmartQuotes::isEnabled() && SmartQuotes::insert(m_text, key_event)) {
			return true;
		}
	}
	return QWidget::eventFilter(watched, event);
}
Esempio n. 20
0
bool CScreenShotView::event(QEvent *event)
{
#ifdef Q_OS_MAC
    if(event->type() == QEvent::KeyPress
            || event->type() == QEvent::KeyRelease
            || event->type() == QEvent::MouseButtonDblClick
            || event->type() == QEvent::MouseButtonPress
            || event->type() == QEvent::MouseButtonRelease
            || event->type() == QEvent::MouseMove)
    {
        C_SCREENSHOT_LOG_INFO(QString("EVENT type %1").arg(event->type()));
        if(event->type() == QEvent::MouseMove)
        {
            QMouseEvent *mouseEvent = static_cast<QMouseEvent*>(event);
            if(mouseEvent)
            {
                mouseMoveEvent(mouseEvent);
                event->accept();
                return true;
            }
        }
        if(event->type() == QEvent::MouseButtonRelease)
        {
            QMouseEvent *mouseEvent = static_cast<QMouseEvent*>(event);
            mouseReleaseEvent(mouseEvent);
            event->accept();
            return true;
        }
    }
#endif
    return QGraphicsView::event(event);
}
Esempio n. 21
0
void IntroSignup::mousePressEvent(QMouseEvent *e) {
	mouseMoveEvent(e);
	if (QRect(_phLeft, _phTop, st::introPhotoSize, st::introPhotoSize).contains(e->pos())) {
		QStringList imgExtensions(cImgExtensions());
		QString filter(qsl("Image files (*") + imgExtensions.join(qsl(" *")) + qsl(");;All files (*.*)"));

		QImage img;
		QString file;
		QByteArray remoteContent;
		if (filedialogGetOpenFile(file, remoteContent, lang(lng_choose_images), filter)) {
			if (!remoteContent.isEmpty()) {
				img = App::readImage(remoteContent);
			} else {
				if (!file.isEmpty()) {
					img = App::readImage(file);
				}
			}
		} else {
			return;
		}

		if (img.isNull() || img.width() > 10 * img.height() || img.height() > 10 * img.width()) {
			showError(lang(lng_bad_photo));
			return;
		}
		PhotoCropBox *box = new PhotoCropBox(img, PeerId(0));
		connect(box, SIGNAL(ready(const QImage &)), this, SLOT(onPhotoReady(const QImage &)));
		Ui::showLayer(box);
	}
bool QjtMouseGestureFilter::eventFilter(QObject* obj, QEvent* event)
{
    switch (event->type()) {
    case QEvent::MouseButtonPress:
        if (mouseButtonPressEvent(static_cast<QMouseEvent*>(event), obj)) {
            return true;
        }

        break;

    case QEvent::MouseButtonRelease:
        if (mouseButtonReleaseEvent(static_cast<QMouseEvent*>(event), obj)) {
            return true;
        }

        break;

    case QEvent::MouseMove:
        if (mouseMoveEvent(static_cast<QMouseEvent*>(event), obj)) {
            return true;
        }

        break;

    case QEvent::Paint:
        if (paintEvent(obj, static_cast<QPaintEvent*>(event))) {
            return true;
        }

    default:
        break;
    }

    return QObject::eventFilter(obj, event);
}
void PathStrokeRenderer::mousePressEvent(QMouseEvent *e)
{
    if (!m_fingerPointMapping.isEmpty())
        return;
    setDescriptionEnabled(false);
    m_activePoint = -1;
    qreal distance = -1;
    for (int i=0; i<m_points.size(); ++i) {
        qreal d = QLineF(e->pos(), m_points.at(i)).length();
        if ((distance < 0 && d < 8 * m_pointSize) || d < distance) {
            distance = d;
            m_activePoint = i;
        }
    }

    if (m_activePoint != -1) {
        m_wasAnimated = m_timer.isActive();
        setAnimation(false);
        mouseMoveEvent(e);
    }

    // If we're not running in small screen mode, always assume we're dragging
    m_mouseDrag = !m_smallScreen;
    m_mousePress = e->pos();
}
Esempio n. 24
0
void EventListener::onEvent(Event* e) {
    /*
        since we already checked which type we have we can safely use
        the faster static_cast (rl)
    */
    if (typeid(*e) == typeid(MouseEvent)) {
        MouseEvent* me = static_cast<MouseEvent*>(e);
        if (me->action() == MouseEvent::PRESSED)
            mousePressEvent(me);
        else if (me->action() == MouseEvent::RELEASED)
            mouseReleaseEvent(me);
        else if (me->action() == MouseEvent::MOTION)
            mouseMoveEvent(me);
        else if (me->action() == MouseEvent::DOUBLECLICK)
            mouseDoubleClickEvent(me);
        else if (me->action() == MouseEvent::WHEEL)
            wheelEvent(me);
    }
    else if (typeid(*e) == typeid(KeyEvent)) {
        keyEvent(static_cast<KeyEvent*>(e));
    }
    else if (typeid(*e) == typeid(TimeEvent)) {
        timerEvent(static_cast<TimeEvent*>(e));
    }
    else if (typeid(*e) == typeid(TouchEvent)) {
        touchEvent(static_cast<TouchEvent*>(e));
    }
}
Esempio n. 25
0
void GameWidget::mouseReleaseEvent(QMouseEvent *event)
{
    if(selection.size() < 2 or !selection.contains(getGridPos(event->x(), event->y())))
        return; //nothing selected or mouse pointer not in selection

    //backup
    oldscore = score;
    for(int x = 0; x < grid_size; x++)
        for(int y = 0; y < grid_size; y++)
            old_grid[x][y] = grid[x][y];

    foreach(Box pos, selection) {
        if(use_animations)
            old_grid[pos.x][pos.y].scale_step = num_scale_steps-1;

        grid[pos.x][pos.y] = Bubble(); //remove bubbles
    }

    score += selection.size()*selection.size();
    selection.clear();

    emit enableUndo(true);
    emit activity();

    compressBubbles();

#ifndef Q_WS_MAEMO_5
    mouseMoveEvent(event); //draw selection if there's a new set of connected bubbles
#endif
}
Esempio n. 26
0
void TimeLineWidget::mousePressEvent( QMouseEvent* event )
{
	if( event->x() < m_xOffset )
	{
		return;
	}
	if( event->button() == Qt::LeftButton  && !(event->modifiers() & Qt::ShiftModifier) )
	{
		m_action = MovePositionMarker;
		if( event->x() - m_xOffset < s_posMarkerPixmap->width() )
		{
			m_moveXOff = event->x() - m_xOffset;
		}
		else
		{
			m_moveXOff = s_posMarkerPixmap->width() / 2;
		}
	}
	else if( event->button() == Qt::LeftButton  && (event->modifiers() & Qt::ShiftModifier) )
	{
		m_action = SelectSongTCO;
		m_initalXSelect = event->x();
	}
	else if( event->button() == Qt::RightButton || event->button() == Qt::MiddleButton )
	{
        	m_moveXOff = s_posMarkerPixmap->width() / 2;
		const MidiTime t = m_begin + static_cast<int>( event->x() * MidiTime::ticksPerTact() / m_ppt );
		if( m_loopPos[0] > m_loopPos[1]  )
		{
			qSwap( m_loopPos[0], m_loopPos[1] );
		}
		if( ( event->modifiers() & Qt::ShiftModifier ) || event->button() == Qt::MiddleButton )
		{
			m_action = MoveLoopBegin;
		}
		else
		{
			m_action = MoveLoopEnd;
		}
		m_loopPos[( m_action == MoveLoopBegin ) ? 0 : 1] = t;
	}

	if( m_action == MoveLoopBegin )
	{
		delete m_hint;
		m_hint = TextFloat::displayMessage( tr( "Hint" ),
					tr( "Press <%1> to disable magnetic loop points." ).arg(UI_CTRL_KEY),
					embed::getIconPixmap( "hint" ), 0 );
	}
	else if( m_action == MoveLoopEnd )
	{
		delete m_hint;
		m_hint = TextFloat::displayMessage( tr( "Hint" ),
					tr( "Hold <Shift> to move the begin loop point; Press <%1> to disable magnetic loop points." ).arg(UI_CTRL_KEY),
					embed::getIconPixmap( "hint" ), 0 );
	}

	mouseMoveEvent( event );
}
void QGraphicsEllipseItem_QtDShell::__override_mouseMoveEvent(QGraphicsSceneMouseEvent*  event0, bool static_call)
{
    if (static_call) {
        QGraphicsItem::mouseMoveEvent((QGraphicsSceneMouseEvent* )event0);
    } else {
        mouseMoveEvent((QGraphicsSceneMouseEvent* )event0);
    }
}
void QAbstractPageSetupDialog_QtDShell::__override_mouseMoveEvent(QMouseEvent*  arg__1, bool static_call)
{
    if (static_call) {
        QWidget::mouseMoveEvent((QMouseEvent* )arg__1);
    } else {
        mouseMoveEvent((QMouseEvent* )arg__1);
    }
}
Esempio n. 29
0
void TailView::mouseReleaseEvent(QMouseEvent * event)
{
    if(event->button() == Qt::LeftButton) {
        m_leftMouseIsDown = false;
        mouseMoveEvent(event);
        onCopy(true);
    }
}
Esempio n. 30
0
void QDateEdit_QtDShell::__override_mouseMoveEvent(QMouseEvent*  event0, bool static_call)
{
    if (static_call) {
        QAbstractSpinBox::mouseMoveEvent((QMouseEvent* )event0);
    } else {
        mouseMoveEvent((QMouseEvent* )event0);
    }
}