bool
ConfigDelegateBase::editorEvent ( QEvent* event, QAbstractItemModel* model, const QStyleOptionViewItem& option, const QModelIndex& index )
{
QStyleOptionViewItemV4 viewOpt( option );
initStyleOption( &viewOpt, index );
if( event->type() == QEvent::MouseButtonRelease || event->type() == QEvent::MouseButtonDblClick ) {
m_configPressed = QModelIndex();
QMouseEvent* me = static_cast< QMouseEvent* >( event );
if( me->button() != Qt::LeftButton || !checkRectForIndex( option, index ).contains( me->pos() ) )
return false;
// eat the double click events inside the check rect
if( event->type() == QEvent::MouseButtonDblClick ) {
return true;
}
Qt::CheckState curState = static_cast< Qt::CheckState >( index.data( Qt::CheckStateRole ).toInt() );
Qt::CheckState newState = curState == Qt::Checked ? Qt::Unchecked : Qt::Checked;
return model->setData( index, newState, Qt::CheckStateRole );
} else if( event->type() == QEvent::MouseButtonPress ) {
QMouseEvent* me = static_cast< QMouseEvent* >( event );
if( me->button() == Qt::LeftButton && configRectForIndex( option, index ).contains( me->pos() ) ) {
m_configPressed = index;
emit configPressed( index );
return true;
}
}
return QStyledItemDelegate::editorEvent( event, model, option, index );
}
bool SymbolView::viewportEvent(QEvent *event)
{
if (event != NULL)
{
if (event->type() == QEvent::ToolTip)
{
QHelpEvent *helpEvent = static_cast<QHelpEvent *>(event);
QListWidgetItem* it = itemAt(helpEvent->pos());
if (it != NULL)
{
event->accept();
QString tipText = it->text();
QToolTip::showText(helpEvent->globalPos(), tipText, this);
return true;
}
}
else if (event->type() == QEvent::MouseButtonPress)
{
QMouseEvent *mouseEvent = static_cast<QMouseEvent *>(event);
if (mouseEvent->button() == Qt::RightButton)
return true;
}
else if (event->type() == QEvent::MouseButtonRelease)
{
QMouseEvent *mouseEvent = static_cast<QMouseEvent *>(event);
if (mouseEvent->button() == Qt::RightButton)
{
emit customContextMenuRequested(mouseEvent->pos());
return true;
}
}
}
return QListWidget::viewportEvent(event);
}
bool Human::eventFilter( QObject * watched, QEvent * event )
{
chessVisialization::Display* disp = dynamic_cast<chessVisialization::Display*>( watched );
QMouseEvent* mouseEvent = dynamic_cast< QMouseEvent* >( event );
if ( mouseEvent )
{
if ( mouseEvent->type() == QEvent::MouseButtonPress )
{
if ( mouseEvent->button() == Qt::LeftButton )
{
emit signalCellPressed( _cellOverCursor.first, _cellOverCursor.second );
//disp->boardChanged();
return true;
}
}
else if ( mouseEvent->type() == QEvent::MouseMove )
{
if ( mouseEvent->button() == Qt::NoButton )
{
//! Update cursor's position
QRect r( 0, 0, disp->displayImage().width(), disp->displayImage().height() );
QPoint p = mouseEvent->pos();
if ( r.contains( p ) )
{
_cellOverCursor.first = p.x() / ( r.width() / HORIZONTAL_SIZE );
_cellOverCursor.second = p.y() / ( r.height() / VERTICAL_SIZE );
emit signalEventFiltered();
return true;
}
}
}
}
return false;
}
bool TimeSlider::event(QEvent* e)
{
// LogDialog::debug(tr("TimeSlider::event(): %1").arg(e->type()));
if( e->type() == QEvent::MouseButtonPress
|| e->type() == QEvent::MouseButtonDblClick )
{
QMouseEvent* event = static_cast<QMouseEvent*>(e);
if( event->button() == Qt::RightButton )
return false;
else
if( event->button() == Qt::LeftButton ) {
if( pointOutsideHandle(event->pos()) ) {
QMouseEvent mevent(QEvent::MouseButtonPress,
event->pos(),
Qt::MidButton, Qt::MidButton, Qt::NoModifier);
return QSlider::event(&mevent);
}
}
}
else
if( e->type() == QEvent::MouseMove ) {
if( !isSliderDown() )
return true;
}
bool b = QSlider::event(e);
// LogDialog::debug(tr("%1").arg(b));
return b;
}
//
// eventFilter - filter events looking for a rightclick
//
// On a right mouseclick we call the addButton method since I can't get
// the popup menu working
//
bool
MyEdit::eventFilter(QObject *o, QEvent *e)
{
switch (e->type())
{
case QEvent::MouseButtonPress:
{
QMouseEvent *m = (QMouseEvent *) e;
if (m->button() == 1) // left click
{
}
if (m->button() == 2) // right click
{
// pass on to the dialog owning us
return parent()->eventFilter(o, e);
}
}
break;
case QEvent::MouseButtonRelease:
case QEvent::MouseButtonDblClick:
case QEvent::MouseMove:
default:
break;
}
return FALSE;
} // end eventFilter
//
// eventFilter - filter events looking for a rightclick
//
// On a right mouseclick we call the addButton method since I can't get
// the popup menu working
//
bool
MyEdit::eventFilter(QObject *o, QEvent *e)
{
switch (e->type())
{
case QEvent::MouseButtonPress:
{
QMouseEvent *m = (QMouseEvent *) e;
if (m->button() == 1) // left click
{
}
if (m->button() == 2) // right click
{
// pass on to the dialog owning us
return parent()->eventFilter(o, e);
}
}
break;
case QEvent::MouseButtonRelease:
case QEvent::MouseButtonDblClick:
case QEvent::MouseMove:
default:
break;
}
// the parent widget may have it's own event filter, pass the call on
return QMultiLineEdit::eventFilter(o, e);
} // end eventFilter
void Interactor2DNavigate::UpdateCursor( QEvent* event, QWidget* wnd )
{
if ( wnd->hasFocus() )
{
if ( event->type() == QEvent::MouseButtonPress ||
event->type() == QEvent::MouseButtonRelease ||
event->type() == QEvent::MouseMove)
{
QMouseEvent* e = ( QMouseEvent* )event;
if ( e->button() == Qt::MidButton || e->button() == Qt::RightButton ||
( ( e->modifiers() & CONTROL_MODIFIER) && (e->modifiers() & Qt::ShiftModifier) ) )
{
Interactor2D::UpdateCursor( event, wnd );
}
else
{
// set own cursor
wnd->setCursor( QCursor() );
}
}
}
else
{
Interactor2D::UpdateCursor( event, wnd );
}
}
bool BookmarkWidget::eventFilter(QObject *object, QEvent *e)
{
if ((object == this) || (object == treeView->viewport())) {
QModelIndex index = treeView->currentIndex();
if (e->type() == QEvent::KeyPress) {
QKeyEvent *ke = static_cast<QKeyEvent*>(e);
if (index.isValid() && searchField->text().isEmpty()) {
const QModelIndex &src = filterBookmarkModel->mapToSource(index);
if (ke->key() == Qt::Key_F2) {
QStandardItem *item =
bookmarkManager->treeBookmarkModel()->itemFromIndex(src);
if (item) {
item->setEditable(true);
treeView->edit(index);
item->setEditable(false);
}
} else if (ke->key() == Qt::Key_Delete) {
bookmarkManager->removeBookmarkItem(treeView, src);
}
}
switch (ke->key()) {
default: break;
case Qt::Key_Up: {
case Qt::Key_Down:
treeView->subclassKeyPressEvent(ke);
} break;
case Qt::Key_Enter: {
case Qt::Key_Return:
index = treeView->selectionModel()->currentIndex();
if (index.isValid()) {
QString data = index.data(Qt::UserRole + 10).toString();
if (!data.isEmpty() && data != QLatin1String("Folder"))
emit requestShowLink(data);
}
} break;
case Qt::Key_Escape: {
emit escapePressed();
} break;
}
} else if (e->type() == QEvent::MouseButtonRelease) {
if (index.isValid()) {
QMouseEvent *me = static_cast<QMouseEvent*>(e);
bool controlPressed = me->modifiers() & Qt::ControlModifier;
if(((me->button() == Qt::LeftButton) && controlPressed)
|| (me->button() == Qt::MidButton)) {
QString data = index.data(Qt::UserRole + 10).toString();
if (!data.isEmpty() && data != QLatin1String("Folder"))
{
//CentralWidget::instance()->setSourceInNewTab(data);
emit requestShowLinkInNewTab(data);
}
}
}
}
}
return QWidget::eventFilter(object, e);
}
bool RKConsole::eventFilter (QObject *, QEvent *e) {
if (e->type () == QEvent::KeyPress) {
QKeyEvent *k = (QKeyEvent *)e;
return handleKeyPress (k);
} else if (e->type () == QEvent::MouseButtonPress){
QMouseEvent *m = (QMouseEvent *)e;
if (m->button() == Qt::RightButton) {
doPopupMenu (m->globalPos ());
return (true);
}
return (false);
} else if (e->type () == QEvent::MouseButtonRelease){
QMouseEvent *m = (QMouseEvent *)e;
if (m->button() == Qt::MidButton) {
QClipboard *cb = QApplication::clipboard ();
submitBatch (cb->text (QClipboard::Selection));
return (true);
} /* else if (m->button () == Qt::LeftButton) {
// prevent cursor from leaving last line
uint para=0; uint p=0;
view->cursorPosition (¶, &p);
if (para != doc->numLines () - 1) {
int y = view->y ();
view->setCursorPosition (doc->numLines() -1, p);
int y2 = view->y ();
qDebug ("%d, %d", y, y2);
view->scroll (0, y - y2);
}
} */ // not good, yet: always jumps to bottom of view
return (false);
} else {
return false;
}
}
//
// eventFilter - filter events looking for a rightclick
//
// On a right mouseclick we call the addButton method since I can't get
// the popup menu working
//
bool
MsgDialog::eventFilter(QObject *o, QEvent *e)
{
switch (e->type())
{
case QEvent::MouseButtonPress:
{
QMouseEvent *m = (QMouseEvent *) e;
if (m->button() == 1) // left click
{
}
if (m->button() == 2) // right click
{
m_pMenu->popup(m->globalPos());
return TRUE; // don't process event any further
}
}
break;
case QEvent::MouseButtonRelease:
case QEvent::MouseButtonDblClick:
case QEvent::MouseMove:
default:
break;
}
return QWidget::eventFilter(o, e);
} // end eventFilter
bool
EventEater::eventFilter(QObject *, QEvent *ev)
{
if(!m_container)
return false;
// When the user click the empty part of tab bar, only MouseReleaseEvent is sent,
// we need to simulate the Press event
if(ev->type() == QEvent::MouseButtonRelease && m_widget->inherits("QTabWidget"))
{
QMouseEvent *mev = static_cast<QMouseEvent*>(ev);
if(mev->button() == LeftButton)
{
QMouseEvent *myev = new QMouseEvent(QEvent::MouseButtonPress, mev->pos(), mev->button(), mev->state());
m_container->eventFilter(m_widget, myev);
delete myev;
//return true;
}
}
// else if(ev->type() == QEvent::ChildInserted) {
// widget's children have changed, we need to reinstall filter
// installRecursiveEventFilter(m_widget, this);
// }
return m_container->eventFilter(m_widget, ev);
}
bool LapsusPanelButton::eventFilter( QObject* obj, QEvent* e )
{
if (e->type() == QEvent::MouseButtonPress)
{
QMouseEvent *qme = static_cast<QMouseEvent*>(e);
if (qme->button() == Qt::RightButton)
{
emit rightButtonPressed();
return true;
}
if (!_isValid || !_hasDBus)
return true;
if (qme->button() == Qt::LeftButton && _vals.size() > 0)
{
QStringList::Iterator it = _vals.find(_curVal);
QString nVal;
if (it != _vals.end()) ++it;
if (it == _vals.end())
nVal = *(_vals.begin());
else
nVal = *it;
_dbus->setFeature(_featureId, nVal);
}
}
return QWidget::eventFilter(obj,e);
}
bool caMessageButton::eventFilter(QObject *obj, QEvent *event)
{
if (event->type() == QEvent::Enter) {
if(!_AccessW) {
QApplication::setOverrideCursor(QCursor(Qt::ForbiddenCursor));
} else {
QApplication::restoreOverrideCursor();
}
} else if(event->type() == QEvent::Leave) {
QApplication::restoreOverrideCursor();
} else if(event->type() == QEvent::MouseButtonPress) {
QMouseEvent *me = static_cast<QMouseEvent *>(event);
if (me->button()==Qt::LeftButton) {
if(_AccessW) buttonhandle(0);
}
} else if(event->type() == QEvent::MouseButtonRelease) {
QMouseEvent *me = static_cast<QMouseEvent *>(event);
if (me->button()==Qt::LeftButton) {
if(_AccessW) buttonhandle(1);
}
// intercept space key, so that no keyboard spacebar will trigger when button has focus
} else if(event->type() == QEvent::KeyPress || event->type() == QEvent::KeyRelease) {
QKeyEvent *me = static_cast<QKeyEvent *>(event);
if(me->key() == Qt::Key_Space) {
return true;
}
}
return QObject::eventFilter(obj, event);
}
void caPolyLine::mousePressEvent(QMouseEvent *event)
{
if(!inEditor) {
if(event->type() == QEvent::MouseButtonPress) {
QMouseEvent *ev = event;
#if QT_VERSION< QT_VERSION_CHECK(4, 8, 0)
if(ev->button() == Qt::MidButton) {
#else
if(ev->button() == Qt::MiddleButton) {
#endif
QWidget::mousePressEvent(event);
}
}
return;
}
// start move
actualPosition = QPointF(event->pos().x(),event->pos().y());
if (event->button() == Qt::LeftButton) {
mouseMove = true;
// add first point if empty
if(thisXYpairs.size() == 0) {
thisXYpairs.append(QString::number(event->pos().x()));
thisXYpairs.append(",");
thisXYpairs.append(QString::number(event->pos().y()));
}
// remove last point
} else
if(event->button() == Qt::RightButton) {
int pos = thisXYpairs.lastIndexOf(";");
int len = thisXYpairs.count();
if(pos > 0) thisXYpairs.chop(len-pos);
else thisXYpairs.clear(); // get rid of last point
}
XYpairs = thisXYpairs;
update();
}
void caPolyLine::mouseReleaseEvent(QMouseEvent *event)
{
if(!inEditor) return;
mouseMove = false;
// add point
if (event->button() == Qt::LeftButton) {
thisXYpairs.append(";");
thisXYpairs.append(QString::number(event->pos().x()));
thisXYpairs.append(",");
thisXYpairs.append(QString::number(event->pos().y()));
}
XYpairs = thisXYpairs;
}
void caPolyLine::setHide(bool hide)
{
thisHide = hide;
repaint();
}
bool FramelessMove::eventFilter(QObject *obj, QEvent *ev)
{
if (obj == _monitor)
{
switch(ev->type())
{
case QEvent::MouseButtonPress:
{
QMouseEvent* event = (QMouseEvent*)ev;
if(event->button() == Qt::LeftButton)
{
_offsetPos = event->globalPos();
emit Pressed(_offsetPos);
lButtonPress = true;
}
break;
}
case QEvent::MouseButtonRelease:
{
QMouseEvent* event = (QMouseEvent*)ev;
if(event->button() == Qt::LeftButton && lButtonPress)
{
lButtonPress = false;
emit Release(event->globalPos());
}
break;
}
case QEvent::MouseMove:
{
if(lButtonPress)
{
QMouseEvent* event = (QMouseEvent*)ev;
QPoint newPos = event->globalPos() - _offsetPos;
emit Offset(newPos);
if(_target)
_target->move(_target->pos() + newPos);
_offsetPos = event->globalPos();
}
break;
}
default:
break;
}
}
return false;
}
PlatformMouseEvent::PlatformMouseEvent(QInputEvent* event, int clickCount)
{
m_timestamp = WTF::currentTime();
QMouseEvent* me = 0;
switch (event->type()) {
case QEvent::MouseMove:
m_eventType = MouseEventMoved;
me = static_cast<QMouseEvent *>(event);
break;
case QEvent::MouseButtonDblClick:
case QEvent::MouseButtonPress:
m_eventType = MouseEventPressed;
me = static_cast<QMouseEvent *>(event);
break;
case QEvent::MouseButtonRelease:
m_eventType = MouseEventReleased;
me = static_cast<QMouseEvent *>(event);
break;
#ifndef QT_NO_CONTEXTMENU
case QEvent::ContextMenu: {
m_eventType = MouseEventPressed;
QContextMenuEvent* ce = static_cast<QContextMenuEvent*>(event);
m_position = IntPoint(ce->pos());
m_globalPosition = IntPoint(ce->globalPos());
m_button = RightButton;
break;
}
#endif // QT_NO_CONTEXTMENU
default:
m_eventType = MouseEventMoved;
}
if (me) {
m_position = IntPoint(me->pos());
m_globalPosition = IntPoint(me->globalPos());
if (me->button() == Qt::LeftButton || (me->buttons() & Qt::LeftButton))
m_button = LeftButton;
else if (me->button() == Qt::RightButton || (me->buttons() & Qt::RightButton))
m_button = RightButton;
else if (me->button() == Qt::MidButton || (me->buttons() & Qt::MidButton))
m_button = MiddleButton;
else
m_button = NoButton;
}
m_clickCount = clickCount;
m_shiftKey = (event->modifiers() & Qt::ShiftModifier);
m_ctrlKey = (event->modifiers() & Qt::ControlModifier);
m_altKey = (event->modifiers() & Qt::AltModifier);
m_metaKey = (event->modifiers() & Qt::MetaModifier);
}
bool ShortcutsPlugin::eventFilter(QObject *o, QEvent *e)
{
unsigned button = 0;
QMouseEvent *me = NULL;
if (e->type() == QEvent::MouseButtonPress){
me = static_cast<QMouseEvent*>(e);
switch (me->button()){
case Qt::LeftButton:
button = 1;
break;
case Qt::RightButton:
button = 2;
break;
case Qt::MidButton:
button = 3;
break;
default:
break;
}
}
if (e->type() == QEvent::MouseButtonDblClick){
me = static_cast<QMouseEvent*>(e);
switch (me->button()){
case Qt::LeftButton:
button = 4;
break;
case Qt::RightButton:
button = 5;
break;
case Qt::MidButton:
button = 6;
break;
default:
break;
}
}
if (me){
button |= me->modifiers();
MAP_CMDS::iterator it = mouseCmds.find(button);
if (it != mouseCmds.end()){
CommandDef *cmd = &it->second;
EventMenuGet e(cmd);
e.process();
QMenu *popup = e.menu();
if (popup){
popup->popup(me->globalPos());
return true;
}
}
}
return QObject::eventFilter(o, e);
}
bool TSController::eventFilter(QObject *obj, QEvent *e)
{
//qDebug()<<"TSController::eventFilter";
//qDebug()<<"eventFilter";
QMouseEvent *evt;
if(e->type() == QEvent::MouseButtonPress)
evt = static_cast<QMouseEvent*>(e);
if(obj == ui->backPatientProfileButton && evt->button()==Qt::LeftButton)
{
if(currentAction == CreatePatientProfileAction){
ui->mainBox->setCurrentIndex(0);
patientsModel->setFilter("");
patientsModel->select();
}
if(currentAction == NoAction){
ui->mainBox->setCurrentIndex(2);
patientsModel->setFilter("");
patientsModel->select();
}
ui->horizontalScrollBar->setEnabled(false);
}
if(obj == ui->backPatientListButton && evt->button()==Qt::LeftButton)
{
ui->mainBox->setCurrentIndex(0);
patientsModel->setFilter("");
patientsModel->select();
ui->horizontalScrollBar->setEnabled(false);
}
if(obj == ui->backCallibrateButton && evt->button()==Qt::LeftButton)
{
ui->mainBox->setCurrentIndex(3);
curveBuffer->clean();
}
if(obj == ui->backExamButton && evt->button()==Qt::LeftButton)
{
if(!openUser){
ui->mainBox->setCurrentIndex(4);
ui->managmentSpaser->setGeometry(QRect(0,0,2,2));
ui->managmentBox->setVisible(false);
}
else{
qDebug()<<examinationsModel->filter();
ui->mainBox->setCurrentIndex(3);
ui->managmentSpaser->setGeometry(QRect(0,0,2,2));
ui->managmentBox->setVisible(false);
}
curveBuffer->clean();
}
//curveBuffer->clean();
return QObject::eventFilter(obj,e);
}
bool QVistaHelper::eventFilter(QObject *obj, QEvent *event)
{
if (obj != wizard)
return QObject::eventFilter(obj, event);
if (event->type() == QEvent::MouseMove) {
QMouseEvent *mouseEvent = static_cast<QMouseEvent*>(event);
long result;
MSG msg;
msg.message = WM_NCHITTEST;
msg.wParam = 0;
msg.lParam = MAKELPARAM(mouseEvent->globalX(), mouseEvent->globalY());
msg.hwnd = wizardHWND();
winEvent(&msg, &result);
msg.wParam = result;
msg.message = WM_NCMOUSEMOVE;
winEvent(&msg, &result);
} else if (event->type() == QEvent::MouseButtonPress) {
QMouseEvent *mouseEvent = static_cast<QMouseEvent*>(event);
if (mouseEvent->button() == Qt::LeftButton) {
long result;
MSG msg;
msg.message = WM_NCHITTEST;
msg.wParam = 0;
msg.lParam = MAKELPARAM(mouseEvent->globalX(), mouseEvent->globalY());
msg.hwnd = wizardHWND();
winEvent(&msg, &result);
msg.wParam = result;
msg.message = WM_NCLBUTTONDOWN;
winEvent(&msg, &result);
}
} else if (event->type() == QEvent::MouseButtonRelease) {
QMouseEvent *mouseEvent = static_cast<QMouseEvent*>(event);
if (mouseEvent->button() == Qt::LeftButton) {
long result;
MSG msg;
msg.message = WM_NCHITTEST;
msg.wParam = 0;
msg.lParam = MAKELPARAM(mouseEvent->globalX(), mouseEvent->globalY());
msg.hwnd = wizardHWND();
winEvent(&msg, &result);
msg.wParam = result;
msg.message = WM_NCLBUTTONUP;
winEvent(&msg, &result);
}
}
return false;
}
bool ShortcutsPlugin::eventFilter(QObject *o, QEvent *e)
{
unsigned button = 0;
QMouseEvent *me = NULL;
if (e->type() == QEvent::MouseButtonPress){
me = static_cast<QMouseEvent*>(e);
switch (me->button()){
case Qt::LeftButton:
button = 1;
break;
case Qt::RightButton:
button = 2;
break;
case Qt::MidButton:
button = 3;
break;
default:
break;
}
}
if (e->type() == QEvent::MouseButtonDblClick){
me = static_cast<QMouseEvent*>(e);
switch (me->button()){
case Qt::LeftButton:
button = 4;
break;
case Qt::RightButton:
button = 5;
break;
case Qt::MidButton:
button = 6;
break;
default:
break;
}
}
if (me){
button |= me->state() & (Qt::AltModifier | Qt::ControlModifier | Qt::ShiftModifier);
MAP_CMDS::iterator it = mouseCmds.find(button);
if (it != mouseCmds.end()){
const CommandDef &cmd = (*it).second;
Event e(EventGetMenu, (void*)&cmd);
Q3PopupMenu *popup = (Q3PopupMenu*)(e.process());
if (popup){
popup->popup(me->globalPos());
return true;
}
}
}
return QObject::eventFilter(o, e);
}
bool ProgressManagerPrivate::eventFilter(QObject *obj, QEvent *event)
{
if (obj == m_statusBarWidget && event->type() == QEvent::Enter) {
m_hovered = true;
updateVisibility();
} else if (obj == m_statusBarWidget && event->type() == QEvent::Leave) {
m_hovered = false;
// give the progress view the chance to get the mouse enter event
updateVisibilityWithDelay();
} else if (obj == m_statusBarWidget && event->type() == QEvent::MouseButtonPress
&& !m_taskList.isEmpty()) {
QMouseEvent *me = static_cast<QMouseEvent *>(event);
if (me->button() == Qt::LeftButton && !me->modifiers()) {
FutureProgress *progress = m_currentStatusDetailsProgress;
if (!progress)
progress = m_taskList.last();
// don't send signal directly from an event filter, event filters should
// do as little a possible
QTimer::singleShot(0, progress, &FutureProgress::clicked);
event->accept();
return true;
}
}
return false;
}
bool EditorTab::eventFilter(QObject *obj, QEvent *event)
{
if (obj != tabBar()) {
return QObject::eventFilter(obj, event);
}
if (event->type() != QEvent::MouseButtonPress) {
return QObject::eventFilter(obj, event);
}
// compute the tab number
QMouseEvent *mouseEvent = static_cast<QMouseEvent *>(event);
QPoint position = mouseEvent->pos();
int c = tabBar()->count();
int clickedItem = -1;
for (int i=0; i<c; i++) {
if ( tabBar()->tabRect(i).contains( position ) ) {
clickedItem = i;
break;
}
}
if (clickedItem == -1) {
return QObject::eventFilter(obj, event);
}
if (mouseEvent->button() == Qt::RightButton) {
this->setCurrentIndex(clickedItem);
QPoint point = mapToGlobal(position);
context->popup(point);
return true;
}
return QObject::eventFilter(obj, event);
}
bool ContentWindow::eventFilter(QObject *o, QEvent *e)
{
if (m_contentWidget && o == m_contentWidget->viewport()
&& e->type() == QEvent::MouseButtonRelease) {
QMouseEvent *me = static_cast<QMouseEvent*>(e);
QItemSelectionModel *sm = m_contentWidget->selectionModel();
if (!me || !sm)
return QWidget::eventFilter(o, e);
Qt::MouseButtons button = me->button();
const QModelIndex &index = m_contentWidget->indexAt(me->pos());
if (index.isValid() && sm->isSelected(index)) {
if ((button == Qt::LeftButton && (me->modifiers() & Qt::ControlModifier))
|| (button == Qt::MidButton)) {
QHelpContentModel *contentModel =
qobject_cast<QHelpContentModel*>(m_contentWidget->model());
if (contentModel) {
QHelpContentItem *itm = contentModel->contentItemAt(index);
if (itm && HelpViewer::canOpenPage(itm->url().path()))
OpenPagesManager::instance().createPage(itm->url());
}
} else if (button == Qt::LeftButton) {
itemClicked(index);
}
}
}
return QWidget::eventFilter(o, e);
}
void PreviewPlot2D::plotMouseReleased( const QMouseEvent& e)
{
#if 0
if(e.button()==Qt::LeftButton)
{
switch(zoomMode)
{
case NO_ZOOM:
break;
case ELL_ZOOM:
case REC_ZOOM:
onZoomRec(e);
break;
case H_ZOOM:
pPlot->removeMarker(zoomMarkerKey);
onHZoom(e);
break;
case V_ZOOM:
pPlot->removeMarker(zoomMarkerKey);
onVZoom(e);
break;
}
pPlot->replot();
}
#endif
}
bool SuggestionWidget::eventFilter(QObject* object, QEvent* event) {
if (object != ui_->name) {
return QWidget::eventFilter(object, event);
}
QFont font(ui_->name->font());
switch (event->type()) {
case QEvent::Enter:
font.setUnderline(true);
ui_->name->setFont(font);
break;
case QEvent::Leave:
font.setUnderline(false);
ui_->name->setFont(font);
break;
case QEvent::MouseButtonRelease: {
QMouseEvent* e = static_cast<QMouseEvent*>(event);
if (e->button() == Qt::LeftButton) {
QString text = ui_->name->text();
text.replace(QRegExp("\\W"), " ");
emit SuggestionClicked(text.simplified());
}
break;
}
default:
return false;
}
return true;
}
//
// eventFilter - filter events looking for a rightclick
//
// on a right mouseclick we edit the button
//
bool
MyButton::eventFilter(QObject *o, QEvent *e)
{
switch (e->type())
{
case QEvent::MouseButtonPress:
{
QMouseEvent *m = (QMouseEvent *) e;
if (m->button() == 2) // right click
{
// pass on to the dialog owning us
return m_pOwner->eventFilter(o, e);
}
}
case QEvent::Enter:
emit setButton(this, TRUE);
break;
case QEvent::Leave:
emit setButton(this, FALSE);
break;
default:
break;
}
return QCheckBox::eventFilter(o, e);
} // end eventFilter
bool AppInit::eventFilter(QObject *obj, QEvent *evt)
{
QWidget *w = (QWidget *)obj;
if (!w->property("CanMove").toBool()) {
return QObject::eventFilter(obj, evt);
}
QMouseEvent *event = static_cast<QMouseEvent *>(evt);
if (event->type() == QEvent::MouseButtonPress) {
if (event->button() == Qt::LeftButton) {
mousePressed = true;
mousePoint = event->globalPos() - w->pos();
return true;
}
} else if (event->type() == QEvent::MouseButtonRelease) {
mousePressed = false;
return true;
} else if (event->type() == QEvent::MouseMove) {
if (mousePressed && (event->buttons() && Qt::LeftButton)) {
w->move(event->globalPos() - mousePoint);
return true;
}
}
return QObject::eventFilter(obj, evt);
}
bool eventFilter(QObject* obj, QEvent* event) override
{
// check input
if (event->type() != QEvent::MouseButtonDblClick)
return false;
QMouseEvent* mouseEvent = static_cast<QMouseEvent*>(event);
if (mouseEvent->button() != Qt::LeftButton)
return false;
QSplitterHandle* splitterHandle = qobject_cast<QSplitterHandle*>(obj);
if (!splitterHandle)
return false;
QSplitter* splitter = splitterHandle->splitter();
if (!splitter || splitter->count() < 2)
return false;
// change splitter sizes to make description panel occupy ideal height
QWidget* bottomWidget = splitter->widget(1);
QList<int> sizes = splitter->sizes();
if (sizes.size() != 2)
return false;
sizes[0] += sizes[1];
sizes[1] = bottomWidget->heightForWidth(bottomWidget->size().width());
sizes[0] -= qMax(sizes[1], 0);
splitter->setSizes(sizes);
return true;
}
bool NotificationDialog::eventFilter(QObject *object, QEvent *event)
{
if (event->type() == QEvent::MouseButtonPress)
{
QMouseEvent *mouseEvent = static_cast<QMouseEvent*>(event);
if (mouseEvent && mouseEvent->button() == Qt::LeftButton)
{
if (object == m_closeLabel)
{
m_notification->markIgnored();
m_animation->stop();
close();
return true;
}
else
{
m_notification->markClicked();
m_animation->stop();
close();
}
}
}
return QWidget::eventFilter(object, event);
}
bool XdgMenuWidget::event(QEvent* event)
{
Q_D(XdgMenuWidget);
if (event->type() == QEvent::Show)
{
if (d->mNeedBuild)
d->buildMenu();
}
else if (event->type() == QEvent::MouseButtonPress)
{
QMouseEvent *e = static_cast<QMouseEvent*>(event);
if (e->button() == Qt::LeftButton)
d->mDragStartPosition = e->pos();
}
else if (event->type() == QEvent::MouseMove)
{
QMouseEvent *e = static_cast<QMouseEvent*>(event);
d->mouseMoveEvent(e);
}
return QMenu::event(event);
}
