`mouse press event` C++ Examples

void TimelineView::mousePressEvent(QMouseEvent *event)
{
  if (HandPress(event) || PlayheadPress(event)) {
    // Let the parent handle this
    return;
  }

  if (dragMode() != GetDefaultDragMode()) {
    TimelineViewBase::mousePressEvent(event);
    return;
  }

  TimelineViewMouseEvent timeline_event = CreateMouseEvent(event);

  emit MousePressed(&timeline_event);
} 

void GateHandlesArea::mousePressEvent(QMouseEvent *event)
{
	PlotLineHandle *child = static_cast<PlotLineHandle*>
						(childAt(event->pos()));
	if (child) {
		child->raise();
		selectedItem = child;

		PlotGateHandle *handle = static_cast<PlotGateHandle*>(child);

		if(handle->reachedLimit())
			/*if the handle reached the limit update the hotspot so we can still change the bar position */
			hotspot = event->pos() - QPoint(handle->getCurrentPos(),handle->y());
		else{
			hotspot = event->pos() - child->pos();
		}
		child->setGrabbed(true);
	} 

bool ESEventAddPolygon::mousePressEvent(QGraphicsSceneMouseEvent *event) {
	if (event -> button() == Qt::LeftButton) {
		if(!m_running) m_running = true;
		QPointF pos = m_scene->snapToGrid(event -> scenePos());

		//create new polygon
		if (!m_polygon) {
			m_polygon = new PartPolygon(m_editor);
			m_scene -> addItem(m_polygon);
			m_polygon -> addPoint(pos);
		}

		m_polygon -> addPoint(pos);
		return true;
	}
	return false;
} 

void TimelineWidget::mousePressEvent(QMouseEvent* evt)
{
    Q_UNUSED(evt);
    mousePos = evt->pos();
    clickPos = mousePos;

    if(evt->button() == Qt::LeftButton)
        leftButtonDown = true;
    if(evt->button() == Qt::MiddleButton)
        middleButtonDown = true;
    if(evt->button() == Qt::RightButton)
        rightButtonDown = true;

    if(evt->button() == Qt::LeftButton)
    {
        dragging = true;
        animWidgetData->cursorPosInSeconds = posToTime(evt->x());
    }
} 

bool ESEventAddEllipse::mousePressEvent(QGraphicsSceneMouseEvent *event) {
	if (event -> button() == Qt::LeftButton) {
		if(!m_running) m_running = true;
		QPointF pos = m_scene->snapToGrid(event -> scenePos());

			//create new ellpise
		if (!m_ellipse) {
			m_ellipse = new PartEllipse(m_editor);
			m_scene -> addItem(m_ellipse);
			m_ellipse -> setPos(pos);
			m_origin = m_new_pos = pos;
			return true;
		}

			//Add ellipse to scene
		m_ellipse -> setRect(m_ellipse -> rect().normalized());
		m_scene -> undoStack().push(new AddPartCommand(QObject::tr("Ellipse"), m_scene, m_ellipse));

			//Set m_ellipse to nullptr for create new ellipse at next mouse press
		m_ellipse = nullptr;

		return true;
	}
	return false;
} 

virtual void mousePressEvent(QMouseEvent* event)
  {
      unsigned int button = 0;
      switch (event->button()){
      case Qt::LeftButton:
          button = 1;
          break;
      case Qt::MiddleButton:
          button = 2;
          break;
      case Qt::RightButton:
          button = 3;
          break;
      default:
          break;
      }
      this->getEventQueue()->mouseButtonPress(event->x()*m_scale, event->y()*m_scale, button);
  } 

void MapScene::mousePressEvent(QGraphicsSceneMouseEvent *event)
{
    if(event->button() == Qt::MouseButton::LeftButton)
    {
        QList<QGraphicsItem*> clicked = items(event->scenePos(), Qt::IntersectsItemShape, Qt::DescendingOrder, views().first()->transform());
        foreach(QGraphicsItem* item, clicked)
        {
            SystemShape *sys = qgraphicsitem_cast<SystemShape *>(item);
            if(sys && sys->name().endsWith(":system"))
            {
                qDebug() << "SvgMapView::mousePressEvent - " << sys->name() << " clicked.";
                emit systemClicked(sys->name().left(sys->name().length()-7));
                return QGraphicsScene::mousePressEvent(event);
            }
            else
            {
                qDebug() << "SvgMapView::mousePressEvent - Not a system" << event->scenePos();
                if(item)
                    qDebug() << item->boundingRect();
            }
        } 

void
FlatButton::mousePressEvent(QMouseEvent *event)
{
        if (ui::RippleStyle::NoRipple != ripple_style_) {
                QPoint pos;
                qreal radiusEndValue;

                if (ui::RippleStyle::CenteredRipple == ripple_style_) {
                        pos = rect().center();
                } else {
                        pos = event->pos();
                }

                if (use_fixed_ripple_radius_) {
                        radiusEndValue = fixed_ripple_radius_;
                } else { 

void TTKClickedSlider::mousePressEvent(QMouseEvent *event)
{
    QSlider::mousePressEvent(event);
    if(event->button() == Qt::LeftButton)
    {
        m_mousePress = true;

        double pos;
        if(orientation() == Qt::Horizontal)
        {
            pos = event->pos().x()*1.0 / width();
            m_value = pos * (maximum() - minimum()) + minimum();
        }
        else
        {
            pos = event->pos().y()*1.0 / height();
            m_value = maximum() - pos * (maximum() - minimum());
        }
    } 

void DownloadAbstractMoveResizeWidget::mousePressEvent(QMouseEvent *event)
{
    QWidget::mousePressEvent(event);

    m_struct.m_pressedSize = size();
    m_struct.m_isPressBorder = false;
    setFocus();

    if(event->button() == Qt::LeftButton)
    {
        m_struct.m_windowPos = pos();
        if(QRect(DISTANCE + 1, DISTANCE + 1, width() - (DISTANCE + 1)*2,
                 height() - (DISTANCE + 1)*2).contains(event->pos()))
        {
            m_struct.m_mousePos = event->globalPos();
            m_struct.m_mouseLeftPress = true;
        }
        else
        {
            m_struct.m_isPressBorder = true;
        }
    } 

void DownloadClickedSlider::mousePressEvent(QMouseEvent *event)
{
    QSlider::mousePressEvent(event);
    if(event->button() == Qt::LeftButton)
    {
        m_mousePress = true;

        double pos;
        if(orientation() == Qt::Horizontal)
        {
            pos = event->pos().x()*1.0 / width();
            m_value = pos * (maximum() - minimum()) + minimum();
        }
        else
        {
            pos = event->pos().y()*1.0 / height();
            m_value = maximum() - pos * (maximum() - minimum());
        }
    } 

void GraphicsScene::mousePressEvent(QGraphicsSceneMouseEvent *mouseEvent) {
  mousePoint = mouseEvent->scenePos();
  MouseX = mouseEvent->scenePos().x();
  MouseY = mouseEvent->scenePos().y();
  mousePoints.append(mouseEvent->scenePos());

  CoordinateNumber++;
  // if (CoordinateNumber == 1) {

  bool isItem = false;
  for (auto item : items()) {
    if (item == mRubberband) {
      isItem = true;
      break;
    }
  }
  if (isItem)
    removeItem(mRubberband);
  else 

void CustomPage::mousePressEvent(QMouseEvent *event) {
  if (!hideRect) {
    QList<QPoint> points;
    points << mRect.topLeft() << mRect.topRight() << mRect.bottomLeft()
           << mRect.bottomRight();

    QPoint p = event->pos();

    for (int i = 0; i < points.length(); i++) {
      QPoint point = points.at(i);
      QPainterPath path;
      path.addEllipse(point, mRadius, mRadius);
      if (path.contains(p)) {
        mPosition = (Position)i;
        emit onClicked(mPosition);
        break;
      }
    }
  }
  QWizardPage::mousePressEvent(event);
} 

void RubberBand::mousePressEvent(QMouseEvent *event) {
  if (event->buttons() != Qt::LeftButton)
    return;
  if (rubberBand.isVisible()) {
    // Anuluje zaznaczenie jeśli jest aktywne.
    rubberBand.hide();
    return;
  }

  auto posItem = RelativeClippedCoordinates(event->globalPos());

  origin = CoordinatesItemToGlobal(pixmapItem, posItem);
  selectionRect.setTopLeft(posItem);

  rubberBand.setGeometry(QRect(origin, QSize()));
  rubberBand.show();
} 

void TTKMoveResizeWidget::mousePressEvent(QMouseEvent *event)
{
    QWidget::mousePressEvent(event);

    m_struct.m_pressedSize = size();
    m_struct.m_isPressBorder = false;
    setFocus();

    if(event->button() == Qt::LeftButton)
    {
        m_struct.m_windowPos = pos();
        if(QRect(DISTANCE + 1, DISTANCE + 1, width() - (DISTANCE + 1)*2,
                 height() - (DISTANCE + 1)*2).contains(event->pos()))
        {
            m_struct.m_mousePos = event->globalPos();
            m_struct.m_mouseLeftPress = true;
        }
        else
        {
            m_struct.m_isPressBorder = true;
        }
    } 

void GLWidget::mousePressEvent(QMouseEvent *event) {
  // QPixmap pixmap = QPixmap::fromImage(grabFrameBuffer(1));
  QPixmap pixmap = renderPixmap();
  QByteArray itemData;
  QDataStream dataStream(&itemData, QIODevice::WriteOnly);
  dataStream << pixmap << QPoint(event->pos());

  QMimeData *mimeData = new QMimeData;
  mimeData->setData("application/x-dnditemdata", itemData);

  QDrag *drag = new QDrag(this);
  drag->setMimeData(mimeData);
  drag->setPixmap(pixmap);
  drag->setHotSpot(event->pos());
  drag->exec(Qt::CopyAction);
} 

void OCRAbstractMoveResizeWidget::mousePressEvent(QMouseEvent *event)
{
    QWidget::mousePressEvent(event);

    m_struct.m_pressedSize = size();
    m_struct.m_isPressBorder = false;
    setFocus();

    if(event->button() == Qt::LeftButton)
    {
        m_struct.m_windowPos = pos();
        if(QRect(DISTANCE + 1, DISTANCE + 1, width() - (DISTANCE + 1)*2,
                 height() - (DISTANCE + 1)*2).contains(event->pos()))
        {
            m_struct.m_mousePos = event->globalPos();
            m_struct.m_mouseLeftPress = true;
        }
        else
        {
            m_struct.m_isPressBorder = true;
        }
    } 

void Viewer2d::mousePressEvent(QMouseEvent *ev)
{
	setFocus();
	m_lastPos = ev->pos();
	m_buttons = ev->buttons();
	try
	{
		m_currentEventHandle->mousePressEvent(ev);
	} catch (std::exception e)
	{
		std::cout << e.what() << std::endl;
	} catch (...)
	{
		std::cout << "unknown error" << std::endl;
	}
	updateGL();
} 

void OrbitGLWidget::mousePressEvent(QMouseEvent* event) {
  if (m_OrbitPanel) {
    if (event->buttons() == Qt::LeftButton) {
      m_OrbitPanel->LeftDown(event->x(), event->y());
    }

    if (event->buttons() == Qt::RightButton) {
      m_OrbitPanel->RightDown(event->x(), event->y());
    }

    if (event->buttons() == Qt::MiddleButton) {
      m_OrbitPanel->MiddleDown(event->x(), event->y());
    }
  }

  update();
} 

void QwtWheel::mousePressEvent( QMouseEvent *event )
{
    stopFlying();

    d_data->isScrolling = wheelRect().contains( event->pos() );

    if ( d_data->isScrolling )
    {
        d_data->time.start();
        d_data->speed = 0.0;
        d_data->mouseValue = valueAt( event->pos() );
        d_data->mouseOffset = d_data->mouseValue - d_data->value;
        d_data->pendingValueChanged = false;

        Q_EMIT wheelPressed();
    }
} 

void ScatterplotCanvas::mousePressEvent(QMouseEvent *event)
     {
      utils::secureLog(_logger,"Mouse clicked...",_verbose);
      if(event->button() == Qt::LeftButton){
        _selection_first_point = event->pos();
        _selection_second_point = event->pos();
        _selection_in_progress = true;

        emit sgnLeftButtonPressed(getMousePositionInSpace(event->pos()));
      }
      if(event->button() == Qt::RightButton){
        emit sgnRightButtonPressed(getMousePositionInSpace(event->pos()));
      }
      if(event->button() == Qt::MiddleButton){
        updateGL();
      }
     } 

void Cylinder3dEventHandle::mousePressEvent(QMouseEvent *ev)
{
	Abstract3dEventHandle::mousePressEvent(ev);
	if (m_viewer->buttons() == Qt::LeftButton)
	{
		int sid = m_viewer->fboRenderedIndex(ev->pos());
		m_viewer->setHoverTrackBallAxis(sid);
		if (sid >= Viewer3d::TrackBallIndex_X && sid <= Viewer3d::TrackBallIndex_Z && m_pickInfo.piece)
		{
			m_viewer->setActiveTrackBallAxis(sid);
			m_cylinderAxisMouseClick = m_pickInfo.piece->transformInfo().cylinderTransform().axis;
			m_cylinderRadiusMouseClick = m_pickInfo.piece->transformInfo().cylinderTransform().radius;
		}
		else
			pick(ev->pos());
	} 

void CstmGroupButton::mousePressEvent(QMouseEvent *event)
{
    QPoint point = event->pos();
    for(int buttonID = 0 ; buttonID < buttonCount; ++ buttonID)
    {
        if((point.y() > (centerY - buttonHeight/2)) && (point.y() <  (centerY - buttonHeight/2 + buttonHeight)))
        {
            if((point.x() > buttonID * buttonWidth) && (point.x() < (buttonID + 1 ) * buttonWidth))
            {
                currentSelected = buttonID;
                emit signal_valueChanged(buttonID);
                break;
            }
        }
    }
    this->update();
} 

void QSchematicsScene::mousePressEvent(QGraphicsSceneMouseEvent *event)
{
	m_lastOrig = event->scenePos();

	switch(m_recentOperation) {
		case SCHEMATICS_OPERATION_DRAG:
			if(m_dragging) return;
			m_dragging = true;
			foreach(QSchematicsPart *p, m_parts) {
				if(p->contains(m_lastOrig)||p->isSelected()) {
					if(!p->isSelected()) {
						foreach(QSchematicsPart *m, m_parts) {
							m->setSelected(false);
						}
					}
					p->setSelected(true);
					p->setDragMode(true);
					p->setCursor(QCursor(Qt::ClosedHandCursor));
				}
			}
			break;
	}
} 

void LabeledSection::mousePressEvent(QMouseEvent* pEvent)
{
   if (pEvent != NULL)
   {
      const QPoint& pos = pEvent->pos();
      if (mpSectionWidget != NULL)
      {
         QPoint labelPos = mpExpandLabel->pos();
         int labelWidth = mpExpandLabel->width();
         int labelHeight = mpExpandLabel->height();

         QRect labelRect(labelPos.x(), labelPos.y(), labelWidth, labelHeight);
         if (labelRect.contains(pos) == true)
         {
            mpSectionWidget->setVisible(mpSectionWidget->isHidden());
         }
      }
   }

   QWidget::mousePressEvent(pEvent);
} 

void QwtAbstractSlider::mousePressEvent( QMouseEvent *event )
{
    if ( isReadOnly() )
    {
        event->ignore();
        return;
    }

    if ( !d_data->isValid || lowerBound() == upperBound() )
        return;

    d_data->isScrolling = isScrollPosition( event->pos() );

    if ( d_data->isScrolling )
    {
        d_data->pendingValueChanged = false;

        Q_EMIT sliderPressed();
    }
} 

void label_img::mousePressEvent(QMouseEvent *ev)
{
    std::cout<< "clicked"<< std::endl;

    setMousePosition(ev->x(), ev->y());

    if(ev->button() == Qt::RightButton)
    {
        removeFocusedObjectBox(m_relative_mouse_pos_in_ui);
        showImage();
    }
    else if 

void DiagramEventAddText::mousePressEvent(QGraphicsSceneMouseEvent *event)
{
    if (event->button() == Qt::LeftButton)
    {
        IndependentTextItem *text = new IndependentTextItem();
        m_diagram -> undoStack().push(new AddItemCommand<IndependentTextItem *>(text, m_diagram, event->scenePos()));
        text->setTextInteractionFlags(Qt::TextEditorInteraction);
        text->setFocus(Qt::MouseFocusReason);
        emit finish();
		event->setAccepted(true);
    }
} 

bool ESEventAddRect::mousePressEvent(QGraphicsSceneMouseEvent *event)
{
	if (event -> button() == Qt::LeftButton)
	{
		if(!m_running) m_running = true;
		QPointF pos = m_scene->snapToGrid(event -> scenePos());

			//create new rectangle, pos isn't define,
			//so m_rect.pos = 0,0 , that mean event.scenePos is in same coordinate of item
			//we don't need to map point for m_rect
		if (!m_rect)
		{
			m_rect = new PartRectangle(m_editor);
			m_scene -> addItem(m_rect);
			m_rect -> setRect(QRectF(pos, pos));
			return true;
		}

			//Add rectangle to scene
		m_rect  -> setRect(m_rect -> rect().normalized());
		m_scene -> undoStack().push(new AddPartCommand(QObject::tr("Rectangle"), m_scene, m_rect));

			//Set m_rect to nullptr for create new rectangle at next mouse press
		m_rect = nullptr;

		return true;
	}
	return false;
} 

bool ESEventAddLine::mousePressEvent(QGraphicsSceneMouseEvent *event) {

	if (event -> button() == Qt::LeftButton) {

		if (! m_running) m_running = true;
		QPointF pos = m_scene -> snapToGrid(event -> scenePos());

		//Create new line
		if (!m_line) {
			m_line = new PartLine(m_editor);
			m_scene -> addItem(m_line);
			m_line->setLine(QLineF(pos, pos));
			return true;
		}

		//Add new line to scene
		m_scene -> undoStack().push(new AddPartCommand(QObject::tr("ligne"), m_scene, m_line));

		//Set m_line to nullptr for create new line at next mouse press
		m_line = nullptr;

		return true;
	}

	return false;
} 

void QetGraphicsItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
{
	if (event->button() == Qt::LeftButton)
	{
		m_first_move = true;
		if (event->modifiers() & Qt::ControlModifier) {
			setSelected(!isSelected());
		}
	}

	QGraphicsItem::mousePressEvent(event);
} 

void About::mousePressEvent(QMouseEvent *event)
{
    if (event->buttons() & Qt::LeftButton)
    {
        m_bMoveDrag = true;
        m_DragPosition = event->globalPos() - this->pos();
    }

    QWidget::mousePressEvent(event);
} 

void CustomSlider::mousePressEvent(QMouseEvent *ev)
{
    //注意应先调用父类的鼠标点击处理事件，这样可以不影响拖动的情况
    QSlider::mousePressEvent(ev);
    //获取鼠标的位置，这里并不能直接从ev中取值（因为如果是拖动的话，鼠标开始点击的位置没有意义了）
    double pos = ev->pos().x() / (double)width();
    setValue(pos * (maximum() - minimum()) + minimum());

    emit SigCustomSliderValueChanged();
} 

void ft::FaceWidgetScene::mousePressEvent(QGraphicsSceneMouseEvent *pEvent)
{
	if(pEvent->button() != Qt::LeftButton)
	{
        pEvent->accept();
        return;
    }
    QGraphicsScene::mousePressEvent(pEvent);
} 

void CFloatingWidgetTitleBar::mousePressEvent(QMouseEvent *ev)
{
	if (ev->button() == Qt::LeftButton)
	{
		d->DragState = DraggingFloatingWidget;
		d->FloatingWidget->startDragging(ev->pos(), d->FloatingWidget->size(),
		    this);
		return;
	}
	Super::mousePressEvent(ev);
} 

void QWaitDialog::mousePressEvent(QMouseEvent *event) {

    if (event->buttons() == Qt::LeftButton) {
        _m_is_mouse_press = true;
    }

    _m_move_point = event->globalPos() - this->pos();

    return QDialog::mouseMoveEvent(event);
} 

void BoardWidget::mousePressEvent(QMouseEvent* event) {
  mouse_pos_ = transformToViewport().map(event->pos());
  int pick = hitTest(mouse_pos_);

  if (paused_) {
    // exit edit mode?
    if (pick == -1) {
      exitEditMode();
      emit sigResume();
    }
  } else { 

void SceneUi::mousePressEvent(const QPointF& pos, QMouseEvent* event) {
  const auto x = float(pos.x());
  const auto y = float(pos.y());

  if ((event->buttons() & Qt::LeftButton) != 0) {
    scene_->addBalloon(x, y, 0.8f);
  }

  if ((event->buttons() & Qt::RightButton) != 0) {
    scene_->addBox(x, y, 0.5f, 2.0f);
  }
} 

void Smpl3dEventHandle::mousePressEvent(QMouseEvent *ev)
{
	Abstract3dEventHandle::mousePressEvent(ev);
	m_pickInfo.mesh = nullptr;
	if (m_viewer->buttons() == Qt::LeftButton)
	{
		pick(ev->pos());

		auto manager = m_viewer->getManager();
		if (manager && manager->bodySmplManager())
		{
			manager->bodySmplManager()->selectAction(selectIdToColor(pickInfo().renderId), Renderable::MOUSE_L_PRESS, 0);
		} // end if manager
	} // end if initial_location and left button
} 

void Translate3dEventHandle::mousePressEvent(QMouseEvent *ev)
{
	Abstract3dEventHandle::mousePressEvent(ev);
	if (m_viewer->buttons() == Qt::LeftButton)
	{
		int sid = m_viewer->fboRenderedIndex(ev->pos());
		m_viewer->setHoverTrackBallAxis(sid);
		if (sid >= Viewer3d::TrackBallIndex_X && sid <= Viewer3d::TrackBallIndex_Z)
			m_viewer->setActiveTrackBallAxis(sid);
	} // end if initial_location and left button
} 

void Transform2dPatternEventHandle::mousePressEvent(QMouseEvent *ev)
{
	Abstract2dEventHandle::mousePressEvent(ev);

	auto manager = m_viewer->getManager();
	if (manager == nullptr)
		return;

	// handle selection for all buttons
	if (ev->buttons() != Qt::MidButton)
	{
		pick(ev->pos());
		if (pickInfo().renderId == 0)
			m_viewer->beginDragBox(ev->pos());
	}

	// translation start positon
	ldp::Float3 p3(ev->x(), m_viewer->height() - 1 - ev->y(), 1);
	p3 = m_viewer->camera().getWorldCoords(p3);
	m_translateStart = ldp::Float2(p3[0], p3[1]);

	// rotation center postion
	ldp::Float2 bMin = FLT_MAX, bMax = -FLT_MAX;
	for (size_t iPiece = 0; iPiece < manager->numClothPieces(); iPiece++)
	{
		auto piece = manager->clothPiece(iPiece);
		auto& panel = piece->graphPanel();
		if (pickInfo().renderId == panel.getId() || panel.isSelected())
		{
			for (int k = 0; k < 3; k++)
			{
				bMin[k] = std::min(bMin[k], panel.bound()[0][k]);
				bMax[k] = std::max(bMax[k], panel.bound()[1][k]);
			}
		}
	} // end for iPiece
	m_rotateCenter = (bMin + bMax) / 2.f;
} 

void Select3dEventHandle::mousePressEvent(QMouseEvent *ev)
{
	Abstract3dEventHandle::mousePressEvent(ev);
	m_pickInfo.mesh = nullptr;
	if (m_viewer->buttons() == Qt::LeftButton)
	{
		pick(ev->pos());

		auto manager = m_viewer->getManager();
		if (manager && m_pickInfo.mesh && ev->modifiers() == Qt::CTRL)
		{
			ldp::DragInfo info;
			info.selected_cloth = m_pickInfo.mesh;
			int vpos = 0;
			for (int i = 0; i < 3; i++)
			if (m_pickInfo.pickInnerCoords[i] > m_pickInfo.pickInnerCoords[vpos])
				vpos = i;
			info.selected_vert_id = m_pickInfo.mesh->face_list[m_pickInfo.faceId].vertex_index[vpos];
			printf("drag vert: local=%d, global=%d\n", info.selected_vert_id,
				manager->pieceVertId2GlobalVertId(m_pickInfo.mesh, info.selected_vert_id));
			auto v = info.selected_cloth->vertex_list[info.selected_vert_id];
			ldp::Float3	p, q;
			getSelectionRay(ev->pos(), p, q);
			auto dir = (q - p).normalize();
			auto diff = v - p;
			auto dist = diff.dot(dir);
			info.target = p + dist*dir;
			manager->dragBegin(info);
		} // end if manager
	} // end if initial_location and left button
} 

void Edit2dPatternEventHandle::mousePressEvent(QMouseEvent *ev)
{
	Abstract2dEventHandle::mousePressEvent(ev);

	if (ev->buttons() == Qt::LeftButton)
	{
		pick(ev->pos());
		if (pickInfo().renderId == 0)
			m_viewer->beginDragBox(ev->pos());
	} // end if left button
} 

void AddCurve2dEventHandle::mousePressEvent(QMouseEvent *ev)
{
	Abstract2dEventHandle::mousePressEvent(ev);
	
	if (ev->buttons() == Qt::LeftButton)
	{
		pick(ev->pos());
	} // end if left button
} 

void Loop2dEventHandle::mousePressEvent(QMouseEvent *ev)
{
	Abstract2dEventHandle::mousePressEvent(ev);

	if (ev->buttons() == Qt::LeftButton)
	{
		pick(ev->pos());
		if (pickInfo().renderId == 0)
			m_viewer->beginDragBox(ev->pos());
	} // end if left button
} 

void ElementSimpleListWidget::mousePressEvent(QMouseEvent *event) {

    if (event->button() == Qt::LeftButton) {
        startPos = event->pos();
    }

    QListWidget::mousePressEvent(event);
} 

void FancyTabBar::mousePressEvent(QMouseEvent *event) {
  if (event->button() == Qt::LeftButton) {
    qint32 ret = getTabIndexByPoint(event->x(), event->y());

    // If non of the tabs is clicked dont change the curent activeIndex.
    if (ret != -1)
      activeIndex = ret;

    update();

    emit activeIndexChanged(activeIndex);
  }
  QWidget::mouseReleaseEvent(event);
} 

void CacheView::mousePressEvent(QMouseEvent* event) {
    // If we press on a cache data block, get the address stored for that block and emit a signal indicating that the
    // address was selected through the cache
    for (const auto& item : items(event->pos())) {
        if (auto* textItem = dynamic_cast<QGraphicsSimpleTextItem*>(item)) {
            const QVariant data = textItem->data(Qt::UserRole);
            if (data.isValid()) {
                emit cacheAddressSelected(data.toUInt());
                break;
            }
        }
    }
    QGraphicsView::mousePressEvent(event);
} 

void FileView::mousePressEvent(QMouseEvent *event)
{
    QListWidget::mousePressEvent(event);

    if(event->button() == Qt::RightButton){
        emit rightClick(event->pos());
    }
} 

void HandlesArea::mousePressEvent(QMouseEvent *event)
{
	PlotLineHandle *child = static_cast<PlotLineHandle*>
						(childAt(event->pos()));

	if (child) {
		child->raise();
		selectedItem = child;
		hotspot = event->pos() - child->pos();
		child->setGrabbed(true);
	}
} 

void PlotLineHandle::mousePressEvent(QMouseEvent *event)
{
	QWidget *parent = static_cast<QWidget *>(this->parent());

	setCursor(Qt::ClosedHandCursor);
	parent->raise();

	QWidget::mousePressEvent(event);
} 

void AssetGridItem::mousePressEvent(QMouseEvent *event) {
	if (event->button() == Qt::LeftButton && !event->modifiers().testFlag(Qt::ShiftModifier)) {
		emit singleClicked(this);
	}

	if (event->button() == Qt::LeftButton && event->modifiers().testFlag(Qt::ShiftModifier)) {
		emit specialClicked(this);
	}

	if (event->button() == Qt::RightButton) {
		emit contextClicked(this);
	}
} 

void AssetViewGrid::mousePressEvent(QMouseEvent *event)
{
	if (event->button() == Qt::LeftButton) {
		emit selectedTile(new AssetGridItem(QJsonObject(), QImage(), QJsonObject(), QJsonObject()));
	}

	if (event->button() == Qt::RightButton) {
		emit contextSelected(new AssetGridItem(QJsonObject(), QImage(), QJsonObject(), QJsonObject()));
	}
} 

void AssetViewer::mousePressEvent(QMouseEvent *e)
{
    prevMousePos = e->localPos();

    if (camController != nullptr) {
        //if (e->button() != Qt::MiddleButton) // disable MMB
        camController->onMouseDown(e->button());
    }
} 

virtual void mousePressEvent(QMouseEvent *event)
    {
        if(event->button()==Qt::LeftButton)
        {
            const PlayListItem *curItem = GlobalObjects::playlist->setCurrentItem(path);
            if (curItem)
            {
                GlobalObjects::danmuPool->reset();
                GlobalObjects::danmuRender->cleanup();
                GlobalObjects::mpvplayer->setMedia(curItem->path);
            }
        }
        QWidget::mousePressEvent(event);
    } 

void InteractiveImage::mousePressEvent(QMouseEvent* event)
{
  selection_origin_ = event->pos();
  rubber_band_->setGeometry(QRect{selection_origin_, QSize{}});
  rubber_band_->show();
  setCursor(Qt::CrossCursor);

  emit mousePressSignal(event);
} 

void TDAbstractButton::mousePressEvent(QMouseEvent *e)
{
    //在可用状态下才触发
    if(this->isEnabled()){
        //旧的鼠标相对于本窗体的位置
        if(move_enable){
            old_pos = e->pos();
            is_press = true;
        }
    }
} 

void TDToolbar::mousePressEvent(QMouseEvent *e)
{
    //如果按钮可以触发，才进行触发调用
    if(mouseChangeEnable){
        TDCheckbox::mousePressEvent(e);
    }

} 

void TTKSplitItemLabel::mousePressEvent(QMouseEvent *event)
{
    QLabel::mousePressEvent(event);
    if(event->button() == Qt::LeftButton && !m_currentString.isEmpty())
    {
        emit changed(m_currentString);
    }
} 

void DeselectableListView::mousePressEvent(QMouseEvent *event)
{
    QListView::mousePressEvent(event);
    QModelIndex index = indexAt(event->pos());
    if (!index.isValid()) {
        clearSelection();
        selectionModel()->setCurrentIndex({}, QItemSelectionModel::Select);
    }
}