//______________________________________________
void ScrollBarData::hoverMoveEvent( QObject* object, QEvent* event )
{
// try cast object to scrollbar
QScrollBar* scrollBar( qobject_cast<QScrollBar*>( object ) );
if( !scrollBar || scrollBar->isSliderDown() ) return;
// retrieve scrollbar option
QStyleOptionSlider opt( qt_qscrollbarStyleOption( scrollBar ) );
// cast event
QHoverEvent *hoverEvent = static_cast<QHoverEvent*>(event);
QStyle::SubControl hoverControl = scrollBar->style()->hitTestComplexControl(QStyle::CC_ScrollBar, &opt, hoverEvent->pos(), scrollBar);
// update hover state
updateAddLineArrow( hoverControl );
updateSubLineArrow( hoverControl );
// store position
_position = hoverEvent->pos();
}
bool FramelessResize::eventFilter(QObject *obj, QEvent *ev)
{
if(obj == _monitor)
{
switch(ev->type())
{
case QEvent::HoverMove:
{
QHoverEvent* e = (QHoverEvent*)ev;
SetCursor(GetDirection(e->pos()));
DragResize(ev);
break;
}
case QEvent::MouseButtonPress:
{
QMouseEvent* e = (QMouseEvent*)ev;
_pressDirection = GetDirection(e->pos());
break;
}
case QEvent::MouseButtonRelease:
{
_pressDirection = NONE;
break;
}
default:
break;
}
}
return QObject::eventFilter(obj, ev);
}
bool SpinBox2::eventFilter(QObject* obj, QEvent* e)
{
bool updateButtons = false;
if (obj == mSpinbox)
{
//if (e->type() != QEvent::Paint) qCDebug(KALARM_LOG)<<e->type();
switch (e->type())
{
case QEvent::Enter:
case QEvent::Leave:
QApplication::postEvent(mUpdown2, new QEvent(e->type()));
updateButtons = true;
break;
case QEvent::HoverEnter:
{
QHoverEvent* he = (QHoverEvent*)e;
QApplication::postEvent(mUpdown2, new QHoverEvent(e->type(), QPoint(1, he->pos().y()), he->oldPos()));
updateButtons = true;
break;
}
case QEvent::HoverLeave:
{
QHoverEvent* he = (QHoverEvent*)e;
QApplication::postEvent(mUpdown2, new QHoverEvent(e->type(), he->pos(), QPoint(1, he->oldPos().y())));
updateButtons = true;
break;
}
case QEvent::FocusIn:
case QEvent::FocusOut:
{
QFocusEvent* fe = (QFocusEvent*)e;
QApplication::postEvent(mUpdown2, new QFocusEvent(e->type(), fe->reason()));
updateButtons = true;
break;
}
default:
break;
}
}
else if (obj == mUpdown2)
{
switch (e->type())
{
case QEvent::Enter:
case QEvent::Leave:
case QEvent::HoverEnter:
case QEvent::HoverLeave:
case QEvent::EnabledChange:
updateButtons = true;
break;
default:
break;
}
}
if (updateButtons)
QTimer::singleShot(0, this, &SpinBox2::updateMirrorButtons);
return false;
}
bool HoverMoveFilter::eventFilter(QObject *obj, QEvent *event)
{
if (event->type() == QEvent::HoverMove) {
QHoverEvent *mouseHoverEvent = static_cast<QHoverEvent *>(event);
MainFrame* frame = static_cast<MainFrame *>(obj);
frame->mouseMove(mouseHoverEvent->pos(), mouseHoverEvent->oldPos());
}
return QObject::eventFilter(obj, event);
}
bool ListView::viewportEvent(QEvent *event)
{
if (event->type() == QEvent::HoverEnter || event->type() == QEvent::HoverMove) {
QHoverEvent *hoverEvent = static_cast<QHoverEvent*>(event);
m_hoverItem = indexAt(hoverEvent->pos());
} else if (event->type() == QEvent::HoverLeave) {
m_hoverItem = QModelIndex();
}
return QListView::viewportEvent(event);
}
bool FolderView::eventFilter(QObject* watched, QEvent* event) {
// NOTE: Instead of simply filtering the drag and drop events of the child view in
// the event filter, we overrided each event handler virtual methods in
// both QListView and QTreeView and added some childXXXEvent() callbacks.
// We did this because of a design flaw of Qt.
// All QAbstractScrollArea derived widgets, including QAbstractItemView
// contains an internal child widget, which is called a viewport.
// The events actually comes from the child viewport, not the parent view itself.
// Qt redirects the events of viewport to the viewportEvent() method of
// QAbstractScrollArea and let the parent widget handle the events.
// Qt implemented this using a event filter installed on the child viewport widget.
// That means, when we try to install an event filter on the viewport,
// there is already a filter installed by Qt which will be called before ours.
// So we can never intercept the event handling of QAbstractItemView by using a filter.
// That's why we override respective virtual methods for different events.
if(view && watched == view->viewport()) {
switch(event->type()) {
case QEvent::HoverMove:
// activate items on single click
if(style()->styleHint(QStyle::SH_ItemView_ActivateItemOnSingleClick)) {
QHoverEvent* hoverEvent = static_cast<QHoverEvent*>(event);
QModelIndex index = view->indexAt(hoverEvent->pos()); // find out the hovered item
if(index.isValid()) { // change the cursor to a hand when hovering on an item
setCursor(Qt::PointingHandCursor);
if(!selectionModel()->hasSelection())
selectionModel()->setCurrentIndex(index, QItemSelectionModel::Current);
}
else
setCursor(Qt::ArrowCursor);
// turn on auto-selection for hovered item when single click mode is used.
if(autoSelectionDelay_ > 0 && model_) {
if(!autoSelectionTimer_) {
autoSelectionTimer_ = new QTimer(this);
connect(autoSelectionTimer_, SIGNAL(timeout()), SLOT(onAutoSelectionTimeout()));
lastAutoSelectionIndex_ = QModelIndex();
}
autoSelectionTimer_->start(autoSelectionDelay_);
}
break;
}
case QEvent::HoverLeave:
if(style()->styleHint(QStyle::SH_ItemView_ActivateItemOnSingleClick))
setCursor(Qt::ArrowCursor);
break;
}
}
return QObject::eventFilter(watched, event);
}
//______________________________________________
void DialData::hoverMoveEvent( QObject* object, QEvent* event )
{
// try cast object to dial
QDial* scrollBar( qobject_cast<QDial*>( object ) );
if( !scrollBar || scrollBar->isSliderDown() ) return;
// cast event
QHoverEvent *hoverEvent = static_cast<QHoverEvent*>(event);
// store position
_position = hoverEvent->pos();
// trigger animation if position match handle rect
updateState( _handleRect.contains( _position ) );
}
bool VVidPBView::event(QEvent *e)
{
//VDC_DEBUG("%s Event Type %d\n", __FUNCTION__, e->type());
if(e->type() == QEvent::HideToParent )
//|| e->type() == QEvent::WindowDeactivate)
{
m_pVideo->OffAllFocus();
}
if(e->type() == QEvent::WindowActivate)
{
m_pVideo->ResizeAllVideo();
}
QHoverEvent *event = static_cast<QHoverEvent*> (e);
if (event == NULL)
{
return true;
}
if(e->type() == QEvent::HoverMove)
{
QPoint posView = mapToGlobal(QPoint(0,0));
QPoint posEvent = event->pos();
//VDC_DEBUG( "%s View (%d, %d) Event (%d, %d)\n",
// __FUNCTION__, posView.x(), posView.y(),
// posEvent.x(), posEvent.y());
//m_pVideo->OffAllFocus();
m_lastHoverTime = time(NULL);
}
if(e->type() == QEvent::HoverLeave)
{
QPoint posView = mapToGlobal(QPoint(0,0));
QPoint posEvent = event->pos();
#if 0
VDC_DEBUG( "%s Leave View (%d, %d) Event (%d, %d)\n",
__FUNCTION__, posView.x(), posView.y(),
posEvent.x(), posEvent.y());
#endif
}
return QWidget::event(e);
}
static PyObject *meth_QHoverEvent_pos(PyObject *sipSelf, PyObject *sipArgs)
{
PyObject *sipParseErr = NULL;
{
QHoverEvent *sipCpp;
if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QHoverEvent, &sipCpp))
{
QPoint *sipRes;
Py_BEGIN_ALLOW_THREADS
sipRes = new QPoint(sipCpp->pos());
Py_END_ALLOW_THREADS
return sipConvertFromNewType(sipRes,sipType_QPoint,NULL);
}
}
void FramelessResize::DragResize(QEvent *ev)
{
QHoverEvent* e = (QHoverEvent*)ev;
QMargins offset;
if(_pressDirection & LEFT)
offset.setLeft((e->oldPos() - e->pos()).x());
if(_pressDirection & RIGHT)
offset.setRight((e->pos() - e->oldPos() ).x());
if(_pressDirection & TOP)
offset.setTop((e->oldPos() - e->pos()).y());
if(_pressDirection & BOTTOM)
offset.setBottom((e->pos() - e->oldPos() ).y());
emit OffsetGeometry(offset);
}
bool MainWindow::eventFilter(QObject *obj, QEvent *event)
{
if( event->type() == QEvent::HoverMove)
{
QHoverEvent* hover = static_cast<QHoverEvent*>(event);
QString strPos = tr("viewport x:%1 y:%2")
.arg(hover->pos().x())
.arg(hover->pos().y());
emit updatePosText(strPos);
// qDebug() << strPos;
m_glViewer->update();
m_glViewer->winposToViewpos(hover->pos());
return true;
}
return QMainWindow::eventFilter(obj, event);
}
bool PanelSeeker::event(QEvent *e)
{
if(e->type() == QEvent::HoverMove || e->type() == QEvent::HoverEnter )
{
QHoverEvent* he = static_cast<QHoverEvent*>(e);
if( knobRect.contains(he->pos()) )
{
setState(Hovered, true);
}
else
{
setState(Hovered, false);
}
}
if(e->type() == QEvent::HoverLeave)
{
setState(Hovered, false);
}
return QAbstractSlider::event(e);
}
bool DDateTable::event(QEvent *ev)
{
switch (ev->type())
{
case QEvent::HoverMove:
{
QHoverEvent *e = static_cast<QHoverEvent *>(ev);
const int row = e->pos().y() * d->numWeekRows / height();
int col;
if (layoutDirection() == Qt::RightToLeft)
{
col = d->numDayColumns - (e->pos().x() * d->numDayColumns / width()) - 1;
}
else
{
col = e->pos().x() * d->numDayColumns / width();
}
const int pos = row < 1 ? -1 : (d->numDayColumns * (row - 1)) + col;
if (pos != d->hoveredPos)
{
d->hoveredPos = pos;
update();
}
break;
}
case QEvent::HoverLeave:
if (d->hoveredPos != -1)
{
d->hoveredPos = -1;
update();
}
break;
default:
break;
}
return QWidget::event(ev);
}
bool MayaModule::eventFilter(QObject *, QEvent *e)
{
if(e->type()==QEvent::HoverMove)
{
QHoverEvent * ev = reinterpret_cast<QHoverEvent *>(e);
int x = ev->pos().x();
//if(x > this->width()-6 && _b_reducida)
// emit showBusqueda();
if(x < this->width()-300 && !_b_reducida)
emit hideBusqueda();
}
else if(e->type() == QEvent::KeyRelease)
{
QKeyEvent * ev = reinterpret_cast<QKeyEvent *>(e);
if(ev->key() == Qt::Key_Escape)
return true;
}
return false;
}
/******************************************************************************
* Pass on to the main spinbox events which are needed to activate mouseover and
* other graphic effects when the mouse cursor enters and leaves the widget.
*/
bool SpinMirror::event(QEvent* e)
{
//qCDebug(KALARM_LOG)<<e->type();
QHoverEvent *he = Q_NULLPTR;
switch (e->type())
{
case QEvent::Leave:
if (mMainSpinbox->rect().contains(mMainSpinbox->mapFromGlobal(QCursor::pos())))
break;
// fall through to QEvent::Enter
case QEvent::Enter:
QApplication::postEvent(mMainSpinbox, new QEvent(e->type()));
break;
case QEvent::HoverLeave:
he = (QHoverEvent*)e;
if (mMainSpinbox->rect().contains(mMainSpinbox->mapFromGlobal(QCursor::pos())))
break;
// fall through to QEvent::HoverEnter
case QEvent::HoverEnter:
he = (QHoverEvent*)e;
QApplication::postEvent(mMainSpinbox, new QHoverEvent(e->type(), he->pos(), he->oldPos()));
break;
case QEvent::HoverMove:
he = (QHoverEvent*)e;
break;
case QEvent::FocusIn:
mMainSpinbox->setFocus();
break;
default:
break;
}
if (he)
{
QApplication::postEvent(mSpinbox, new QHoverEvent(e->type(), spinboxPoint(he->pos()), spinboxPoint(he->oldPos())));
setButtons();
}
return QGraphicsView::event(e);
}
/*! \reimp */
bool QToolBar::event(QEvent *event)
{
Q_D(QToolBar);
switch (event->type()) {
case QEvent::Timer:
if (d->waitForPopupTimer.timerId() == static_cast<QTimerEvent*>(event)->timerId()) {
QWidget *w = QApplication::activePopupWidget();
if (!waitForPopup(this, w)) {
d->waitForPopupTimer.stop();
if (!this->underMouse())
d->layout->setExpanded(false);
}
}
break;
case QEvent::Hide:
if (!isHidden())
break;
// fallthrough intended
case QEvent::Show:
d->toggleViewAction->setChecked(event->type() == QEvent::Show);
emit visibilityChanged(event->type() == QEvent::Show);
#if defined(Q_WS_MAC)
if (toolbarInUnifiedToolBar(this)) {
// I can static_cast because I did the qobject_cast in the if above, therefore
// we must have a QMainWindowLayout here.
QMainWindowLayout *mwLayout = static_cast<QMainWindowLayout *>(parentWidget()->layout());
mwLayout->fixSizeInUnifiedToolbar(this);
mwLayout->syncUnifiedToolbarVisibility();
}
# if !defined(QT_MAC_USE_COCOA)
// Fall through
case QEvent::LayoutRequest: {
// There's currently no way to invalidate the size and let
// HIToolbar know about it. This forces a re-check.
int earlyResult = -1;
if (QMainWindow *mainWindow = qobject_cast<QMainWindow *>(parentWidget())) {
bool needUpdate = true;
if (event->type() == QEvent::LayoutRequest) {
QSize oldSizeHint = sizeHint();
earlyResult = QWidget::event(event) ? 1 : 0;
needUpdate = oldSizeHint != sizeHint();
}
if (needUpdate) {
OSWindowRef windowRef = qt_mac_window_for(mainWindow);
if (toolbarInUnifiedToolBar(this)
&& macWindowToolbarIsVisible(windowRef)) {
DisableScreenUpdates();
macWindowToolbarShow(this, false);
macWindowToolbarShow(this, true);
EnableScreenUpdates();
}
}
if (earlyResult != -1)
return earlyResult;
}
}
# endif // !QT_MAC_USE_COCOA
#endif // Q_WS_MAC
break;
case QEvent::ParentChange:
d->layout->checkUsePopupMenu();
#if defined(Q_WS_MAC)
if (parentWidget() && parentWidget()->isWindow())
qt_mac_updateToolBarButtonHint(parentWidget());
#endif
break;
case QEvent::MouseButtonPress: {
if (d->mousePressEvent(static_cast<QMouseEvent*>(event)))
return true;
break;
}
case QEvent::MouseButtonRelease:
if (d->mouseReleaseEvent(static_cast<QMouseEvent*>(event)))
return true;
break;
case QEvent::HoverEnter:
case QEvent::HoverLeave:
// there's nothing special to do here and we don't want to update the whole widget
return true;
case QEvent::HoverMove: {
#ifndef QT_NO_CURSOR
QHoverEvent *e = static_cast<QHoverEvent*>(event);
QStyleOptionToolBar opt;
initStyleOption(&opt);
if (style()->subElementRect(QStyle::SE_ToolBarHandle, &opt, this).contains(e->pos()))
setCursor(Qt::SizeAllCursor);
else
unsetCursor();
#endif
break;
}
case QEvent::MouseMove:
if (d->mouseMoveEvent(static_cast<QMouseEvent*>(event)))
return true;
break;
#ifdef Q_WS_WINCE
case QEvent::ContextMenu:
{
QContextMenuEvent* contextMenuEvent = static_cast<QContextMenuEvent*>(event);
QWidget* child = childAt(contextMenuEvent->pos());
QAbstractButton* button = qobject_cast<QAbstractButton*>(child);
if (button)
button->setDown(false);
}
break;
#endif
case QEvent::Leave:
if (d->state != 0 && d->state->dragging) {
#ifdef Q_OS_WIN
// This is a workaround for loosing the mouse on Vista.
QPoint pos = QCursor::pos();
QMouseEvent fake(QEvent::MouseMove, mapFromGlobal(pos), pos, Qt::NoButton,
QApplication::mouseButtons(), QApplication::keyboardModifiers());
d->mouseMoveEvent(&fake);
#endif
} else {
if (!d->layout->expanded)
break;
QWidget *w = QApplication::activePopupWidget();
if (waitForPopup(this, w)) {
d->waitForPopupTimer.start(POPUP_TIMER_INTERVAL, this);
break;
}
d->waitForPopupTimer.stop();
d->layout->setExpanded(false);
break;
}
default:
break;
}
return QWidget::event(event);
}
bool TabWidget::eventFilter(QObject *obj, QEvent *event)
{
if (obj==tabBar())
{
// this code handles the tab movement
if (event->type() == QEvent::Leave)
{
QPoint point = cross->mapToGlobal( QPoint(0, 0) );
QRect rect(point.x(), point.y(), cross->width(), cross->height() );
if ( !rect.contains( QCursor::pos() ) )
cross->hide();
}
else if (event->type() == QEvent::HoverMove && m_closeButtonInTabs )
{
QHoverEvent *mouseEvent = static_cast<QHoverEvent *>(event);
mousePos = mouseEvent->pos();
for (int i=0; i<tabBar()->count(); i++)
{
if ( tabBar()->tabRect(i).contains( mouseEvent->pos() ) )
{
m_clickedItem= i;
break;
}
}
cross->setGeometry(tabBar()->tabRect(m_clickedItem).x()+tabBar()->tabRect(m_clickedItem).width()-cross->width()-5,
//tabBar()->height()-(tabBar()->tabRect(m_clickedItem).height()/2),
5,
cross->width(),
cross->height());
cross->show();
}
else if (event->type() == QEvent::MouseButtonRelease )
{
qApp->restoreOverrideCursor();
}
else if (event->type() == QEvent::MouseButtonPress )
{
QMouseEvent *mouseEvent = static_cast<QMouseEvent *>(event);
for (int i=0; i<tabBar()->count(); i++)
{
if ( tabBar()->tabRect(i).contains( mouseEvent->pos() ) )
{
m_clickedItem = i;
break;
}
}
if ( mouseEvent->button() == Qt::LeftButton )
qApp->setOverrideCursor( Qt::OpenHandCursor );
if ( mouseEvent->button() == Qt::RightButton )
{
QMenu *menu = new QMenu(this);
connect(menu->addAction(QIcon(":/images/cross.png"), tr("Close Tab")), SIGNAL(triggered()), this, SLOT(slotCloseTab()) );
connect(menu->addAction(QIcon(":/images/fileclose.png"), tr("Close Other Tabs")), SIGNAL(triggered()), this, SLOT(slotCloseOtherTab()) );
connect(menu->addAction(QIcon(":/images/fileclose.png"), tr("Close All Tabs")), SIGNAL(triggered()), this, SLOT(slotCloseAllTab()) );
menu->exec(mouseEvent->globalPos());
delete menu;
}
}
else if (event->type() == QEvent::MouseMove )
{
QMouseEvent *mouseEvent = static_cast<QMouseEvent *>(event);
for (int i=0; i<tabBar()->count(); i++)
{
if ( tabBar()->tabRect(i).contains( mouseEvent->pos() ) )
{
if ( swapTabs(i, m_clickedItem) )
{
setCurrentWidget(widget(i));
update();
int x;
if ( !tabBar()->tabRect(i).contains( mouseEvent->pos() ) )
{
if ( tabBar()->tabRect(m_clickedItem).x() < tabBar()->tabRect(i).x() )
x = tabBar()->tabRect(i).x();
else
x = tabBar()->tabRect(i).x()+(tabBar()->tabRect(i).width()-(qAbs(tabBar()->tabRect(i).width()-tabBar()->tabRect(m_clickedItem).width())));
QPoint point = QPoint(
x,
mouseEvent->pos().y()
);
point = widget(i)->mapToGlobal( point );
m_clickedItem = i;
QCursor::setPos ( point.x(), QCursor::pos().y() );
}
m_clickedItem = i;
break;
}
}
}
}
}
return QTabWidget::eventFilter( obj, event);
}
bool TabTreeView::viewportEvent(QEvent *event)
{
switch (event->type()) {
case QEvent::MouseButtonPress: {
QMouseEvent *me = static_cast<QMouseEvent*>(event);
const QModelIndex index = indexAt(me->pos());
updateIndex(index);
WebTab *tab = index.data(TabModel::WebTabRole).value<WebTab*>();
if (me->buttons() == Qt::MiddleButton && tab) {
tab->closeTab();
}
if (me->buttons() != Qt::LeftButton) {
m_pressedIndex = QModelIndex();
m_pressedButton = NoButton;
break;
}
m_pressedIndex = index;
m_pressedButton = buttonAt(me->pos(), m_pressedIndex);
if (m_pressedIndex.isValid()) {
if (m_pressedButton == ExpandButton) {
if (isExpanded(m_pressedIndex)) {
collapse(m_pressedIndex);
} else {
expand(m_pressedIndex);
}
} else if (m_pressedButton == NoButton && tab) {
tab->makeCurrentTab();
}
}
if (m_pressedButton == CloseButton) {
me->accept();
return true;
}
break;
}
case QEvent::MouseMove: {
QMouseEvent *me = static_cast<QMouseEvent*>(event);
if (m_pressedButton == CloseButton) {
me->accept();
return true;
}
break;
}
case QEvent::MouseButtonRelease: {
QMouseEvent *me = static_cast<QMouseEvent*>(event);
if (me->buttons() != Qt::NoButton) {
break;
}
const QModelIndex index = indexAt(me->pos());
updateIndex(index);
if (m_pressedIndex != index) {
break;
}
DelegateButton button = buttonAt(me->pos(), index);
if (m_pressedButton == button) {
if (m_pressedButton == ExpandButton) {
me->accept();
return true;
}
WebTab *tab = index.data(TabModel::WebTabRole).value<WebTab*>();
if (tab) {
if (m_pressedButton == CloseButton) {
tab->closeTab();
} else if (m_pressedButton == AudioButton) {
tab->toggleMuted();
}
}
}
if (m_pressedButton == CloseButton) {
me->accept();
return true;
}
break;
}
case QEvent::HoverEnter:
case QEvent::HoverLeave:
case QEvent::HoverMove: {
QHoverEvent *he = static_cast<QHoverEvent*>(event);
updateIndex(m_hoveredIndex);
m_hoveredIndex = indexAt(he->pos());
updateIndex(m_hoveredIndex);
break;
}
case QEvent::ToolTip: {
QHelpEvent *he = static_cast<QHelpEvent*>(event);
const QModelIndex index = indexAt(he->pos());
DelegateButton button = buttonAt(he->pos(), index);
if (button == AudioButton) {
const bool muted = index.data(TabModel::AudioMutedRole).toBool();
QToolTip::showText(he->globalPos(), muted ? tr("Unmute Tab") : tr("Mute Tab"), this, visualRect(index));
he->accept();
return true;
} else if (button == CloseButton) {
QToolTip::showText(he->globalPos(), tr("Close Tab"), this, visualRect(index));
he->accept();
return true;
} else if (button == NoButton) {
QToolTip::showText(he->globalPos(), index.data().toString(), this, visualRect(index));
he->accept();
return true;
}
break;
}
case QEvent::ContextMenu: {
QContextMenuEvent *ce = static_cast<QContextMenuEvent*>(event);
const QModelIndex index = indexAt(ce->pos());
WebTab *tab = index.data(TabModel::WebTabRole).value<WebTab*>();
const int tabIndex = tab ? tab->tabIndex() : -1;
TabContextMenu::Options options = TabContextMenu::VerticalTabs | TabContextMenu::ShowDetachTabAction;
if (m_tabsInOrder) {
options |= TabContextMenu::ShowCloseOtherTabsActions;
}
TabContextMenu menu(tabIndex, m_window, options);
addMenuActions(&menu, index);
menu.exec(ce->globalPos());
break;
}
default:
break;
}
return QTreeView::viewportEvent(event);
}
bool FolderView::eventFilter(QObject* watched, QEvent* event) {
// NOTE: Instead of simply filtering the drag and drop events of the child view in
// the event filter, we overrided each event handler virtual methods in
// both QListView and QTreeView and added some childXXXEvent() callbacks.
// We did this because of a design flaw of Qt.
// All QAbstractScrollArea derived widgets, including QAbstractItemView
// contains an internal child widget, which is called a viewport.
// The events actually comes from the child viewport, not the parent view itself.
// Qt redirects the events of viewport to the viewportEvent() method of
// QAbstractScrollArea and let the parent widget handle the events.
// Qt implemented this using a event filter installed on the child viewport widget.
// That means, when we try to install an event filter on the viewport,
// there is already a filter installed by Qt which will be called before ours.
// So we can never intercept the event handling of QAbstractItemView by using a filter.
// That's why we override respective virtual methods for different events.
if(view && watched == view->viewport()) {
switch(event->type()) {
case QEvent::HoverMove:
// activate items on single click
if(style()->styleHint(QStyle::SH_ItemView_ActivateItemOnSingleClick)) {
QHoverEvent* hoverEvent = static_cast<QHoverEvent*>(event);
QModelIndex index = view->indexAt(hoverEvent->pos()); // find out the hovered item
if(index.isValid()) { // change the cursor to a hand when hovering on an item
setCursor(Qt::PointingHandCursor);
if(!selectionModel()->hasSelection())
selectionModel()->setCurrentIndex(index, QItemSelectionModel::Current);
}
else
setCursor(Qt::ArrowCursor);
// turn on auto-selection for hovered item when single click mode is used.
if(autoSelectionDelay_ > 0 && model_) {
if(!autoSelectionTimer_) {
autoSelectionTimer_ = new QTimer(this);
connect(autoSelectionTimer_, &QTimer::timeout, this, &FolderView::onAutoSelectionTimeout);
lastAutoSelectionIndex_ = QModelIndex();
}
autoSelectionTimer_->start(autoSelectionDelay_);
}
break;
}
case QEvent::HoverLeave:
if(style()->styleHint(QStyle::SH_ItemView_ActivateItemOnSingleClick))
setCursor(Qt::ArrowCursor);
break;
case QEvent::Wheel:
// This is to fix #85: Scrolling doesn't work in compact view
// Actually, I think it's the bug of Qt, not ours.
// When in compact mode, only the horizontal scroll bar is used and the vertical one is hidden.
// So, when a user scroll his mouse wheel, it's reasonable to scroll the horizontal scollbar.
// Qt does not implement such a simple feature, unfortunately.
// We do it by forwarding the scroll event in the viewport to the horizontal scrollbar.
// FIXME: if someday Qt supports this, we have to disable the workaround.
if(mode == CompactMode) {
QScrollBar* scroll = view->horizontalScrollBar();
if(scroll) {
QApplication::sendEvent(scroll, event);
return true;
}
}
break;
}
}
return QObject::eventFilter(watched, event);
}
bool QtEvent::eventFilter(QObject *target, QEvent *event)
{
int type = event->type();
void *func = m_hash.value(type);
if (func != 0) {
int accept = event->isAccepted() ? 1 : 0;
switch(type) {
case QEvent::Create:
case QEvent::Close:
case QEvent::Show:
case QEvent::Hide:
case QEvent::Enter:
case QEvent::Leave: {
base_event ev = {accept};
drv_callback(func,&ev,0,0,0);
event->setAccepted(ev.accept != 0);
break;
}
case QEvent::FocusIn:
case QEvent::FocusOut: {
QFocusEvent *e = (QFocusEvent*)event;
focus_event ev = {accept,e->reason()};
drv_callback(func,&ev,0,0,0);
event->setAccepted(ev.accept != 0);
break;
}
case QEvent::Timer: {
QTimerEvent *e = (QTimerEvent*)event;
timer_event ev = {accept,e->timerId()};
drv_callback(func,&ev,0,0,0);
event->setAccepted(ev.accept != 0);
break;
}
case QEvent::HoverEnter:
case QEvent::HoverLeave:
case QEvent::HoverMove: {
QHoverEvent *e = (QHoverEvent*)event;
const QPoint &pt = e->pos();
const QPoint &opt = e->oldPos();
hover_event ev = {accept,pt.x(),pt.y(),opt.x(),opt.y()};
drv_callback(func,&ev,0,0,0);
event->setAccepted(ev.accept != 0);
break;
}
case QEvent::KeyPress:
case QEvent::KeyRelease: {
QKeyEvent *e = (QKeyEvent*)event;
string_head sh;
drvSetString(&sh,e->text());
key_event ev = {accept,e->modifiers(),e->count(),e->isAutoRepeat()?1:0,e->key(),e->nativeModifiers(),e->nativeScanCode(),e->nativeVirtualKey(),&sh};
drv_callback(func,&ev,0,0,0);
event->setAccepted(ev.accept != 0);
break;
}
case QEvent::MouseButtonPress:
case QEvent::MouseButtonRelease:
case QEvent::MouseButtonDblClick:
case QEvent::MouseMove: {
QMouseEvent *e = (QMouseEvent*)event;
const QPoint &gpt = e->globalPos();
const QPoint &pt = e->pos();
mouse_event ev = {accept,e->modifiers(),e->button(),e->buttons(),gpt.x(),gpt.y(),pt.x(),pt.y()};
drv_callback(func,&ev,0,0,0);
event->setAccepted(ev.accept != 0);
break;
}
case QEvent::Move: {
QMoveEvent *e = (QMoveEvent*)event;
const QPoint &pt = e->pos();
const QPoint &opt = e->oldPos();
move_event ev = {accept,pt.x(),pt.y(),opt.x(),opt.y()};
drv_callback(func,&ev,0,0,0);
event->setAccepted(ev.accept != 0);
break;
}
case QEvent::Resize: {
QResizeEvent *e = (QResizeEvent*)event;
const QSize &sz = e->size();
const QSize &osz = e->oldSize();
resize_event ev = {accept,sz.width(),sz.height(),osz.width(),osz.height()};
drv_callback(func,&ev,0,0,0);
event->setAccepted(ev.accept != 0);
break;
}
case QEvent::Paint: {
QPaintEvent *e = (QPaintEvent*)event;
const QRect &rc = e->rect();
paint_event ev = {accept,rc.x(),rc.y(),rc.width(),rc.height()};
drv_callback(func,&ev,0,0,0);
event->setAccepted(ev.accept != 0);
break;
}
default: {
return QObject::eventFilter(target,event);
}
}
return true;
}
return QObject::eventFilter(target,event);
}
/*! \reimp */
bool QToolBar::event(QEvent *event)
{
Q_D(QToolBar);
switch (event->type()) {
case QEvent::Timer:
if (d->waitForPopupTimer.timerId() == static_cast<QTimerEvent*>(event)->timerId()) {
QWidget *w = QApplication::activePopupWidget();
if (!waitForPopup(this, w)) {
d->waitForPopupTimer.stop();
if (!this->underMouse())
d->layout->setExpanded(false);
}
}
break;
case QEvent::Hide:
if (!isHidden())
break;
// fallthrough intended
case QEvent::Show:
d->toggleViewAction->setChecked(event->type() == QEvent::Show);
#ifdef Q_OS_OSX
enableMacToolBar(this, event->type() == QEvent::Show);
#endif
emit visibilityChanged(event->type() == QEvent::Show);
break;
case QEvent::ParentChange:
d->layout->checkUsePopupMenu();
break;
case QEvent::MouseButtonPress: {
if (d->mousePressEvent(static_cast<QMouseEvent*>(event)))
return true;
break;
}
case QEvent::MouseButtonRelease:
if (d->mouseReleaseEvent(static_cast<QMouseEvent*>(event)))
return true;
break;
case QEvent::HoverEnter:
case QEvent::HoverLeave:
// there's nothing special to do here and we don't want to update the whole widget
return true;
case QEvent::HoverMove: {
#ifndef QT_NO_CURSOR
QHoverEvent *e = static_cast<QHoverEvent*>(event);
QStyleOptionToolBar opt;
initStyleOption(&opt);
if (style()->subElementRect(QStyle::SE_ToolBarHandle, &opt, this).contains(e->pos()))
setCursor(Qt::SizeAllCursor);
else
unsetCursor();
#endif
break;
}
case QEvent::MouseMove:
if (d->mouseMoveEvent(static_cast<QMouseEvent*>(event)))
return true;
break;
#ifdef Q_OS_WINCE
case QEvent::ContextMenu:
{
QContextMenuEvent* contextMenuEvent = static_cast<QContextMenuEvent*>(event);
QWidget* child = childAt(contextMenuEvent->pos());
QAbstractButton* button = qobject_cast<QAbstractButton*>(child);
if (button)
button->setDown(false);
}
break;
#endif
case QEvent::Leave:
if (d->state != 0 && d->state->dragging) {
#ifdef Q_OS_WIN
// This is a workaround for loosing the mouse on Vista.
QPoint pos = QCursor::pos();
QMouseEvent fake(QEvent::MouseMove, mapFromGlobal(pos), pos, Qt::NoButton,
QApplication::mouseButtons(), QApplication::keyboardModifiers());
d->mouseMoveEvent(&fake);
#endif
} else {
if (!d->layout->expanded)
break;
QWidget *w = QApplication::activePopupWidget();
if (waitForPopup(this, w)) {
d->waitForPopupTimer.start(POPUP_TIMER_INTERVAL, this);
break;
}
d->waitForPopupTimer.stop();
d->layout->setExpanded(false);
break;
}
default:
break;
}
return QWidget::event(event);
}
