bool Reproductor::eventFilter(QObject *obj, QEvent *event)
{
Q_UNUSED(obj);
if (event->type() == QEvent::MouseMove)
{
QMouseEvent *mouseEvent = static_cast<QMouseEvent*>(event);
mouseEvent->accept();
if (Value == "Si")
{
ui->widget->show();
Reproductor::setCursor(Qt::ArrowCursor);
Contador->start(2000);
}
}
if (event->type() == QEvent::KeyRelease)
{
QKeyEvent* keyEvent = static_cast<QKeyEvent*>(event);
if (keyEvent->key() == Qt::Key_F1)
{
ayuda = new Ayuda(this);
ayuda->show();
ayuda->Valor(tr("VideoDrake"));
return true;
}
}
return false;
}
/* eventFilter is an event filter for misc GUI events. Right now it is used
to dsiplay a popup menu when a user right-clicks on the fill value edit box
*/
bool MapEdit::eventFilter( QObject* object, QEvent* event )
{
if( (object == fillEdit) && (event->type() == QEvent::MouseButtonPress ) )
{
QMouseEvent* mouseEvent = (QMouseEvent*)event;
if( mouseEvent->button() == Qt::RightButton )
{
mouseEvent->accept();
/*
QPopupMenu* estimatePopup = new QPopupMenu( this, "estimatePopup" );
estimatePopup->insertItem( "Estimate Value", fillButton, SLOT( animateClick() ) );
estimatePopup->exec( mouseEvent->globalPos() );
delete estimatePopup;
*/
return true;
}
else
{
return QScrollArea::eventFilter( object, event );
}
}
return QScrollArea::eventFilter( object, event );
}
bool KisToolProxy::forwardEvent(ActionState state, KisTool::ToolAction action, QEvent *event, QEvent *originalEvent, QTabletEvent *lastTabletEvent, const QPoint &canvasOriginWorkaround)
{
bool retval = true;
QTabletEvent *tabletEvent = dynamic_cast<QTabletEvent*>(event);
QTouchEvent *touchEvent = dynamic_cast<QTouchEvent*>(event);
QMouseEvent *mouseEvent = dynamic_cast<QMouseEvent*>(event);
if (tabletEvent) {
QPointF docPoint = tabletToDocument(tabletEvent->hiResGlobalPos(), canvasOriginWorkaround);
tabletEvent->accept();
this->tabletEvent(tabletEvent, docPoint);
forwardToTool(state, action, tabletEvent, docPoint);
retval = tabletEvent->isAccepted();
} else if (touchEvent) {
if (state == END && touchEvent->type() != QEvent::TouchEnd) {
//Fake a touch end if we are "upgrading" a single-touch gesture to a multi-touch gesture.
QTouchEvent fakeEvent(QEvent::TouchEnd, touchEvent->deviceType(), touchEvent->modifiers(), touchEvent->touchPointStates(), touchEvent->touchPoints());
this->touchEvent(&fakeEvent);
} else {
this->touchEvent(touchEvent);
}
} else if (mouseEvent) {
if (lastTabletEvent) {
QPointF docPoint = tabletToDocument(lastTabletEvent->hiResGlobalPos(), canvasOriginWorkaround);
lastTabletEvent->accept();
this->tabletEvent(lastTabletEvent, docPoint);
forwardToTool(state, action, lastTabletEvent, docPoint);
retval = lastTabletEvent->isAccepted();
} else {
QPointF docPoint = widgetToDocument(mouseEvent->posF());
mouseEvent->accept();
if (mouseEvent->type() == QEvent::MouseButtonPress) {
mousePressEvent(mouseEvent, docPoint);
} else if (mouseEvent->type() == QEvent::MouseButtonDblClick) {
mouseDoubleClickEvent(mouseEvent, docPoint);
} else if (mouseEvent->type() == QEvent::MouseButtonRelease) {
mouseReleaseEvent(mouseEvent, docPoint);
} else if (mouseEvent->type() == QEvent::MouseMove) {
mouseMoveEvent(mouseEvent, docPoint);
}
forwardToTool(state, action, originalEvent, docPoint);
retval = mouseEvent->isAccepted();
}
} else if(event->type() == QEvent::KeyPress) {
QKeyEvent* kevent = static_cast<QKeyEvent*>(event);
keyPressEvent(kevent);
} else if(event->type() == QEvent::KeyRelease) {
QKeyEvent* kevent = static_cast<QKeyEvent*>(event);
keyReleaseEvent(kevent);
}
return retval;
}
bool NameItemDelegate::editorEvent(QEvent *event, QAbstractItemModel *, const QStyleOptionViewItem &, const QModelIndex &)
{
if (event->type() == QEvent::MouseButtonRelease) {
QMouseEvent *mouseEvent = static_cast<QMouseEvent *>(event);
if (mouseEvent->button() == Qt::RightButton) {
m_TreeModel->openContextMenu(mouseEvent->globalPos());
mouseEvent->accept();
return true;
}
}
return false;
}
bool KisInputManager::Private::EventEater::eventFilter(QObject* target, QEvent* event )
{
if ((hungry && (event->type() == QEvent::MouseMove ||
event->type() == QEvent::MouseButtonPress ||
event->type() == QEvent::MouseButtonRelease))
// || (peckish && (event->type() == QEvent::MouseButtonPress))
)
{
// Chow down
if (KisTabletDebugger::instance()->debugEnabled()) {
QString pre = QString("[BLOCKED]");
QMouseEvent *ev = static_cast<QMouseEvent*>(event);
dbgTablet << KisTabletDebugger::instance()->eventToString(*ev,pre);
}
peckish = false;
return true;
}
else if ((event->type() == QEvent::MouseButtonPress) /* Need to scrutinize */ &&
(!savedEvent)) /* Otherwise we enter a loop repeatedly storing the same event */
{
QMouseEvent *mouseEvent = static_cast<QMouseEvent*>(event);
// Pocket the event and decide what to do with it later
// savedEvent = *(static_cast<QMouseEvent*>(event));
savedEvent = new QMouseEvent(QEvent::MouseButtonPress,
mouseEvent->pos(),
mouseEvent->windowPos(),
mouseEvent->screenPos(),
mouseEvent->button(),
mouseEvent->buttons(),
mouseEvent->modifiers());
savedTarget = target;
mouseEvent->accept();
return true;
}
return false; // All clear - let this one through!
}
bool MapUserInteraction::eventFilter(QObject *obj, QEvent *event)
{
Q_UNUSED(obj);
Q_D(MapUserInteraction);
Q_ASSERT(d->map);
MapHelper *helper = d->map->helper();
// qDebug() << "Event" << event->type() << helper;
if (!helper)
return false;
switch (event->type()) {
case QEvent::MouseButtonPress: {
QMouseEvent *e = static_cast<QMouseEvent*>(event);
if (helper->mouseDown(e))
e->accept();
break;
}
case QEvent::MouseButtonRelease: {
QMouseEvent *e = static_cast<QMouseEvent*>(event);
if (helper->mouseUp(e))
e->accept();
break;
}
case QEvent::MouseMove: {
QMouseEvent *e = static_cast<QMouseEvent*>(event);
if (helper->mouseMove(e))
e->accept();
break;
}
case QEvent::Wheel: {
QWheelEvent *e = static_cast<QWheelEvent*>(event);
if (helper->wheelEvent(e))
e->accept();
break;
}
case QEvent::KeyPress: {
QKeyEvent *e = static_cast<QKeyEvent*>(event);
if (helper->keyPress(e))
e->accept();
break;
}
case QEvent::KeyRelease: {
QKeyEvent *e = static_cast<QKeyEvent*>(event);
if (helper->keyRelease(e))
e->accept();
break;
}
case QEvent::Gesture: {
#if 0
static bool even = false;
even = !even; // ХЗ почему, но ТАП-ХОЛД срабатывает дважды. Чётные срабатывание откидываем
if (even)
helper->gesture(static_cast<QGestureEvent *>(event));
#endif
break;
#if 0
if (QGesture *swipe = ge->gesture(Qt::SwipeGesture)) {
LogD("GE") << "SwipeGesture";
static_cast<QSwipeGesture *>(swipe);
}
if (QGesture *pan = ge->gesture(Qt::PanGesture)) {
static_cast<QPanGesture *>(pan);
LogD("GE") << "PanGesture";
}
#endif
}
case QEvent::TouchBegin:
{
QTouchEvent *e = static_cast<QTouchEvent *>(event);
if (helper->touch(e))
e->accept();
QList<QTouchEvent::TouchPoint> pts = e->touchPoints();
if (pts.size() == 1) {
QRectF r = pts.first().sceneRect();
r.moveCenter(r.center() - d->map->position());
}
break;
}
case QEvent::TouchEnd:
{
QTouchEvent *e = static_cast<QTouchEvent *>(event);
if (helper->touch(e))
e->accept();
QList<QTouchEvent::TouchPoint> pts = e->touchPoints();
if (pts.size() == 1) {
QRectF r = pts.first().sceneRect();
r.moveCenter(r.center() - d->map->position());
}
break;
}
case QEvent::TouchUpdate:
{
QTouchEvent *e = static_cast<QTouchEvent *>(event);
if (helper->touch(e))
e->accept();
break;
}
default:
return false;
break;
} // switch (event->type())
return true;
}
bool KKbdAccessExtensions::eventFilter( QObject *o, QEvent *e )
{
if ( e->type() == QEvent::KeyPress ) {
// TODO: This permits only a single-key shortcut. For example, Alt+S,R would not work.
// If user configures a multi-key shortcut, it is undefined what will happen here.
// It would be better to handle these as KShortcut activate() signals, but the problem
// is that once a QDockWindow is undocked and has focus, the KShortcut activate() signals
// don't fire anymore.
KShortcut fwdSc = d->fwdAction->shortcut();
KShortcut revSc = d->revAction->shortcut();
KShortcut accessKeysSc = d->accessKeysAction->shortcut();
QKeyEvent* kev = dynamic_cast<QKeyEvent *>(e);
KKey k = KKey(kev);
KShortcut sc = KShortcut(k);
// kdDebug() << "KKbdAccessExtensions::eventFilter: Key press " << sc << endl;
if (!d->accessKeyLabels) {
if (sc == fwdSc) {
nextHandle();
return true;
}
if (sc == revSc) {
prevHandle();
return true;
}
}
if (d->panel) {
if (k == KKey(Key_Escape))
exitSizing();
else
resizePanelFromKey(kev->key(), kev->state());
// Eat the key.
return true;
}
if (sc == accessKeysSc && !d->panel) {
if (d->accessKeyLabels) {
delete d->accessKeyLabels;
d->accessKeyLabels = 0;
} else
displayAccessKeys();
return true;
}
if (d->accessKeyLabels) {
if (k == KKey(Key_Escape)) {
delete d->accessKeyLabels;
d->accessKeyLabels = 0;
} else
handleAccessKey(kev);
return true;
}
return false;
}
else if (d->icon->isActive && e->type() == QEvent::MouseButtonPress) {
exitSizing();
return true;
}
else if (d->accessKeyLabels && e->type() == QEvent::MouseButtonPress) {
delete d->accessKeyLabels;
d->accessKeyLabels = 0;
return true;
}
/* else if (e->type() == QEvent::MouseMove && d->icon->isActive) {
// Lock mouse cursor down.
showIcon();
dynamic_cast<QMouseEvent *>(e)->accept();
return true;
}*/
else if (e->type() == QEvent::MouseMove && d->icon->isActive && d->panel) {
// Resize according to mouse movement.
QMouseEvent* me = dynamic_cast<QMouseEvent *>(e);
QSize s = d->icon->delta();
int dx = s.width();
int dy = s.height();
resizePanel(dx, dy, me->state());
me->accept();
showIcon();
return true;
}
else if (e->type() == QEvent::Resize && d->panel && o == d->panel) {
// TODO: This doesn't always work.
showIcon();
}
return false;
}
bool KuickShow::eventFilter( QObject *o, QEvent *e )
{
if ( m_delayedRepeatItem ) // we probably need to install an eventFilter over
{
return true; // kapp, to make it really safe
}
bool ret = false;
int eventType = e->type();
QKeyEvent *k = 0L;
if ( eventType == QEvent::KeyPress )
k = static_cast<QKeyEvent *>( e );
if ( k ) {
if ( KStdAccel::quit().contains( KKey( k ) ) ) {
saveSettings();
deleteAllViewers();
FileCache::shutdown();
::exit(0);
}
else if ( KStdAccel::help().contains( KKey( k ) ) ) {
appHelpActivated();
return true;
}
}
ImageWindow *window = dynamic_cast<ImageWindow*>( o );
if ( window ) {
// The XWindow used to display Imlib's image is being resized when
// switching images, causing enter- and leaveevents for this
// ImageWindow, leading to the cursor being unhidden. So we simply
// don't pass those events to KCursor to prevent that.
if ( eventType != QEvent::Leave && eventType != QEvent::Enter )
KCursor::autoHideEventFilter( o, e );
m_viewer = window;
QString img;
KFileItem *item = 0L; // the image to be shown
KFileItem *item_next = 0L; // the image to be cached
if ( k ) { // keypress
ret = true;
int key = k->key();
// Key_Shift shouldn't load the browser in nobrowser mode, it
// is used for zooming in the imagewindow
// Key_Alt shouldn't either - otherwise Alt+F4 doesn't work, the
// F4 gets eaten (by NetAccess' modal dialog maybe?)
if ( !fileWidget )
{
if ( key != Key_Escape && key != Key_Shift && key != Key_Alt )
{
KuickFile *file = m_viewer->currentFile();
// QFileInfo fi( m_viewer->filename() );
// start.setPath( fi.dirPath( true ) );
initGUI( file->url().upURL() );
// the fileBrowser will list the start-directory
// asynchronously so we can't immediately continue. There
// is no current-item and no next-item (actually no item
// at all). So we tell the browser the initial
// current-item and wait for it to tell us when it's ready.
// Then we will replay this KeyEvent.
delayedRepeatEvent( m_viewer, k );
// OK, once again, we have a problem with the now async and
// sync KDirLister :( If the startDir is already cached by
// KDirLister, we won't ever get that finished() signal
// because it is emitted before we can connect(). So if
// our dirlister has a rootFileItem, we assume the
// directory is read already and simply call
// slotReplayEvent() without the need for the finished()
// signal.
// see slotAdvanceImage() for similar code
if ( fileWidget->dirLister()->isFinished() )
{
if ( fileWidget->dirLister()->rootItem() )
{
fileWidget->setCurrentItem( file->url().fileName() );
QTimer::singleShot( 0, this, SLOT( slotReplayEvent()));
}
else // finished, but no root-item -- probably an error, kill repeat-item!
{
abortDelayedEvent();
}
}
else // not finished yet
{
fileWidget->setInitialItem( file->url().fileName() );
connect( fileWidget, SIGNAL( finished() ),
SLOT( slotReplayEvent() ));
}
return true;
}
return KMainWindow::eventFilter( o, e );
}
// we definitely have a fileWidget here!
KKey kkey( k );
if ( key == Key_Home || KStdAccel::home().contains( kkey ) )
{
item = fileWidget->gotoFirstImage();
item_next = fileWidget->getNext( false );
}
else if ( key == Key_End || KStdAccel::end().contains( kkey ) )
{
item = fileWidget->gotoLastImage();
item_next = fileWidget->getPrevious( false );
}
else if ( fileWidget->actionCollection()->action("delete")->shortcut().contains( key ))
{
kdDebug() << "WOW, deletion happens here!" << endl;
// KFileItem *cur = fileWidget->getCurrentItem( false );
(void) fileWidget->getCurrentItem( false );
item = fileWidget->getNext( false ); // don't move
if ( !item )
item = fileWidget->getPrevious( false );
KFileItem it( KFileItem::Unknown, KFileItem::Unknown,
m_viewer->url() );
KFileItemList list;
list.append( &it );
if ( fileWidget->del(list, window,
(k->state() & ShiftButton) == 0) == 0L )
return true; // aborted deletion
// ### check failure asynchronously and restore old item?
fileWidget->setCurrentItem( item );
}
else if ( m_toggleBrowserAction->shortcut().contains( key ) )
{
toggleBrowser();
return true; // don't pass keyEvent
}
else
ret = false;
if ( FileWidget::isImage( item ) ) {
// QString filename;
// KIO::NetAccess::download(item->url(), filename, this);
m_viewer->showNextImage( item->url() );
if ( kdata->preloadImage && item_next ) { // preload next image
if ( FileWidget::isImage( item_next ) )
m_viewer->cacheImage( item_next->url() );
}
ret = true; // don't pass keyEvent
}
} // keyPressEvent on ImageWindow
// doubleclick closes image window
// and shows browser when last window closed via doubleclick
else if ( eventType == QEvent::MouseButtonDblClick )
{
QMouseEvent *ev = static_cast<QMouseEvent*>( e );
if ( ev->button() == LeftButton )
{
if ( s_viewers.count() == 1 )
{
if ( !fileWidget )
{
// KURL start;
// QFileInfo fi( window->filename() );
// start.setPath( fi.dirPath( true ) );
initGUI( window->currentFile()->url().fileName() );
}
show();
raise();
}
window->close( true );
ev->accept();
ret = true;
}
}
} // isA ImageWindow
if ( ret )
return true;
return KMainWindow::eventFilter( o, e );
}
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);
}
