void PWidget::eventMouse(QObject *, QEvent *e)
{
PukeMessage pm;
widgetId wI;
QMouseEvent *me = Q_MOUSE_EVENT(e);
wI = widgetIden();
pm.iCommand = - e->type() - 1020; // 1020 offset for events
pm.iWinId = wI.iWinId;
pm.iArg = 0;
// special cArg handling
pm.iTextSize = 4*sizeof(int);
int *icArg = new int[4];
icArg[0] = me->x();
icArg[1] = me->y();
icArg[2] = me->button();
icArg[3] = me->state();
pm.cArg = (char *) icArg;
emit outputMessage(wI.fd, &pm);
delete[] icArg;
}
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 PanelPopupButton::eventFilter(QObject *, QEvent *e)
{
if (e->type() == QEvent::MouseMove)
{
QMouseEvent *me = static_cast<QMouseEvent *>(e);
if (rect().contains(mapFromGlobal(me->globalPos())) &&
((me->state() & ControlButton) != 0 ||
(me->state() & ShiftButton) != 0))
{
PanelButton::mouseMoveEvent(me);
return true;
}
}
else if (e->type() == QEvent::MouseButtonPress ||
e->type() == QEvent::MouseButtonDblClick)
{
QMouseEvent *me = static_cast<QMouseEvent *>(e);
if (rect().contains(mapFromGlobal(me->globalPos())))
{
m_pressedDuringPopup = true;
return true;
}
}
else if (e->type() == QEvent::MouseButtonRelease)
{
QMouseEvent *me = static_cast<QMouseEvent *>(e);
if (rect().contains(mapFromGlobal(me->globalPos())))
{
if (m_pressedDuringPopup && m_popup)
{
m_popup->hide();
}
return true;
}
}
return false;
}
bool MainWindow::eventFilter(QObject *o, QEvent *e)
{
#ifdef WIN32
if (o->inherits("QSizeGrip")){
QSizeGrip *grip = static_cast<QSizeGrip*>(o);
QMouseEvent *me;
switch (e->type()){
case QEvent::MouseButtonPress:
me = static_cast<QMouseEvent*>(e);
p = me->globalPos();
s = grip->topLevelWidget()->size();
return true;
case QEvent::MouseMove:
me = static_cast<QMouseEvent*>(e);
if (me->state() != LeftButton)
break;
QWidget *tlw = grip->topLevelWidget();
QRect rc = tlw->geometry();
if (tlw->testWState(WState_ConfigPending))
break;
QPoint np(me->globalPos());
int w = np.x() - p.x() + s.width();
int h = np.y() - p.y() + s.height();
if ( w < 1 )
w = 1;
if ( h < 1 )
h = 1;
QSize ms(tlw->minimumSizeHint());
ms = ms.expandedTo(minimumSize());
if (w < ms.width())
w = ms.width();
if (h < ms.height())
h = ms.height();
if (!(GetWindowLongA(tlw->winId(), GWL_EXSTYLE) & WS_EX_APPWINDOW)){
int dc = GetSystemMetrics(SM_CYCAPTION);
int ds = GetSystemMetrics(SM_CYSMCAPTION);
tlw->setGeometry(rc.left(), rc.top() + dc - ds, w, h);
}else{
tlw->resize(w, h);
}
MSG msg;
while (PeekMessage(&msg, winId(), WM_MOUSEMOVE, WM_MOUSEMOVE, PM_REMOVE));
return true;
}
}
if (e->type() == QEvent::ChildInserted){
QChildEvent *ce = static_cast<QChildEvent*>(e);
if (ce->child()->inherits("QSizeGrip"))
ce->child()->installEventFilter(this);
}
#endif
if (e->type() == QEvent::ChildRemoved){
QChildEvent *ce = static_cast<QChildEvent*>(e);
list<QWidget*>::iterator it;
for (it = statusWidgets.begin(); it != statusWidgets.end(); ++it){
if (*it == ce->child()){
statusWidgets.erase(it);
break;
}
}
if (statusWidgets.size() == 0){
statusBar()->hide();
setGrip();
}
}
return QMainWindow::eventFilter(o, e);
}
bool QDragManager::eventFilter( QObject *o, QEvent *e )
{
if ( !o->isWidgetType() )
return FALSE;
switch( e->type() ) {
case QEvent::KeyPress:
case QEvent::KeyRelease:
{
QKeyEvent *ke = ((QKeyEvent*)e);
if ( ke->key() == Key_Escape && e->type() == QEvent::KeyPress ) {
cancel();
qApp->removeEventFilter( this );
dragSource = 0;
} else {
updateMode(ke->stateAfter());
updateCursor();
}
return TRUE; // Eat all key events
}
case QEvent::MouseButtonPress:
case QEvent::MouseMove:
{
QMouseEvent *me = (QMouseEvent *)e;
if ( me->state() & ( QMouseEvent::LeftButton | QMouseEvent::MidButton | QMouseEvent::RightButton ) ) {
QWidget *cw = QApplication::widgetAt( me->globalPos(), TRUE );
// Fix for when we move mouse on to the deco widget
if ( qt_qws_dnd_deco && cw == qt_qws_dnd_deco )
cw = dropWidget;
if ( dropWidget != cw ) {
if ( dropWidget ) {
QDragLeaveEvent dle;
QApplication::sendEvent( dropWidget, &dle );
willDrop = FALSE;
updateCursor();
restoreCursor = TRUE;
dropWidget = NULL;
}
if ( cw && cw->acceptDrops() ) {
dropWidget = cw;
QDragEnterEvent dee( me->pos() );
QApplication::sendEvent( dropWidget, &dee );
willDrop = dee.isAccepted();
updateCursor();
restoreCursor = TRUE;
}
} else if ( cw ) {
QDragMoveEvent dme( me->pos() );
QApplication::sendEvent( cw, &dme );
updatePixmap();
}
}
return TRUE; // Eat all mouse events
}
case QEvent::MouseButtonRelease:
{
qApp->removeEventFilter( this );
if ( qt_qws_dnd_deco )
delete qt_qws_dnd_deco;
qt_qws_dnd_deco = 0;
if ( restoreCursor ) {
willDrop = FALSE;
myRestoreOverrideCursor();
restoreCursor = FALSE;
}
if ( dropWidget ) {
QMouseEvent *me = (QMouseEvent *)e;
QDropEvent de( me->pos() );
QApplication::sendEvent( dropWidget, &de );
dropWidget = NULL;
}
return TRUE; // Eat all mouse events
}
default:
break;
}
return FALSE;
}
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
Container::eventFilter(QObject *s, QEvent *e)
{
// kdDebug() << e->type() << endl;
switch(e->type())
{
case QEvent::MouseButtonPress:
{
m_insertBegin = QPoint(-1, -1);
m_mousePressEventReceived = true;
kdDebug() << "QEvent::MouseButtonPress sender object = " << s->name()
<< "of type " << s->className() << endl;
kdDebug() << "QEvent::MouseButtonPress this = " << name() << endl;
m_moving = static_cast<QWidget*>(s);
QMouseEvent *mev = static_cast<QMouseEvent*>(e);
m_grab = QPoint(mev->x(), mev->y());
// we are drawing a connection
if(FormManager::self()->isCreatingConnection()) {
drawConnection(mev);
return true;
}
if(((mev->state() == ControlButton) || (mev->state() == ShiftButton))
&& (!FormManager::self()->isInserting())) // multiple selection mode
{
if(m_form->selectedWidgets()->findRef(m_moving) != -1) // widget is already selected
{
if(m_form->selectedWidgets()->count() > 1) // we remove it from selection
unSelectWidget(m_moving);
else // the widget is the only selected, so it means we want to copy it
{
//m_copyRect = m_moving->geometry();
m_state = CopyingWidget;
if(m_form->formWidget())
m_form->formWidget()->initBuffer();
}
}
else // the widget is not yet selected, we add it
setSelectedWidget(m_moving, true, (mev->button() == RightButton));
}
else if((m_form->selectedWidgets()->count() > 1))//&& (!m_form->manager()->isInserting())) // more than one widget selected
{
if(m_form->selectedWidgets()->findRef(m_moving) == -1) // widget is not selected, it becomes the only selected widget
setSelectedWidget(m_moving, false, (mev->button() == RightButton));
// If the widget is already selected, we do nothing (to ease widget moving, etc.)
}
else// if(!m_form->manager()->isInserting())
setSelectedWidget(m_moving, false, (mev->button() == RightButton));
// we are inserting a widget or drawing a selection rect in the form
if((/*s == m_container &&*/ FormManager::self()->isInserting()) || ((s == m_container) && !m_toplevel))
{
int tmpx,tmpy;
if(!FormManager::self()->snapWidgetsToGrid() || (mev->state() == (LeftButton|ControlButton|AltButton)))
{
tmpx = mev->x();
tmpy = mev->y();
}
else
{
int gridX = m_form->gridSize();
int gridY = m_form->gridSize();
tmpx = int( (float)mev->x() / ((float)gridX) + 0.5 ); // snap to grid
tmpx *= gridX;
tmpy = int( (float)mev->y() / ((float)gridY) + 0.5 );
tmpy *= gridX;
}
m_insertBegin = (static_cast<QWidget*>(s))->mapTo(m_container, QPoint(tmpx, tmpy));
if(m_form->formWidget())
m_form->formWidget()->initBuffer();
if(!FormManager::self()->isInserting())
m_state = DrawingSelectionRect;
}
else {
if(s->inherits("QTabWidget")) // to allow changing page by clicking tab
return false;
}
if (m_objectForMouseReleaseEvent) {
const bool res = handleMouseReleaseEvent(m_objectForMouseReleaseEvent, &m_mouseReleaseEvent);
m_objectForMouseReleaseEvent = 0;
return res;
}
return true;
}
case QEvent::MouseButtonRelease:
{
QMouseEvent *mev = static_cast<QMouseEvent*>(e);
if (!m_mousePressEventReceived) {
m_mouseReleaseEvent = *mev;
m_objectForMouseReleaseEvent = s;
return true;
}
m_mousePressEventReceived = false;
m_objectForMouseReleaseEvent = 0;
return handleMouseReleaseEvent(s, mev);
}
case QEvent::MouseMove:
{
QMouseEvent *mev = static_cast<QMouseEvent*>(e);
if(m_insertBegin!=QPoint(-1,-1) && FormManager::self()->isInserting() && ((mev->state() == LeftButton) || (mev->state() == (LeftButton|ControlButton)) ||
(mev->state() == (LeftButton|ControlButton|AltButton)) || (mev->state() == (LeftButton|ShiftButton)) ) )
// draw the insert rect
{
drawInsertRect(mev, s);
return true;
}
// Creating a connection, we highlight sender and receiver, and we draw a link between them
else if(FormManager::self()->isCreatingConnection() && !FormManager::self()->createdConnection()->sender().isNull())
{
ObjectTreeItem *tree = m_form->objectTree()->lookup(FormManager::self()->createdConnection()->sender());
if(!tree || !tree->widget())
return true;
if(m_form->formWidget() && (tree->widget() != s))
m_form->formWidget()->highlightWidgets(tree->widget(), static_cast<QWidget*>(s));
}
else if(m_insertBegin!=QPoint(-1,-1) && s == m_container && !m_toplevel && (mev->state() != ControlButton) && !FormManager::self()->isCreatingConnection()) // draw the selection rect
{
if((mev->state() != LeftButton) || /*m_inlineEditing*/ m_state == InlineEditing)
return true;
int topx = (m_insertBegin.x() < mev->x()) ? m_insertBegin.x() : mev->x();
int topy = (m_insertBegin.y() < mev->y()) ? m_insertBegin.y() : mev->y();
int botx = (m_insertBegin.x() > mev->x()) ? m_insertBegin.x() : mev->x();
int boty = (m_insertBegin.y() > mev->y()) ? m_insertBegin.y() : mev->y();
QRect r = QRect(QPoint(topx, topy), QPoint(botx, boty));
m_insertRect = r;
if(m_form->formWidget())
m_form->formWidget()->drawRect(r, 1);
m_state = DoingNothing;
return true;
}
else if(mev->state() == (LeftButton|ControlButton)) // draw the insert rect for the copied widget
{
if(s == m_container)// || (m_form->selectedWidgets()->count() > 1))
return true;
drawCopiedWidgetRect(mev);
return true;
}
else if( ( (mev->state() == Qt::LeftButton) || (mev->state() == (LeftButton|ControlButton|AltButton)) )
&& !FormManager::self()->isInserting() && (m_state != CopyingWidget)) // we are dragging the widget(s) to move it
{
if(!m_toplevel && m_moving == m_container) // no effect for form
return false;
if((!m_moving) || (!m_moving->parentWidget()))// || (m_moving->parentWidget()->inherits("QWidgetStack")))
return true;
moveSelectedWidgetsBy(mev->x() - m_grab.x(), mev->y() - m_grab.y());
m_state = MovingWidget;
}
return true; // eat
}
case QEvent::Paint: // Draw the dotted background
{
if(s != m_container)
return false;
int gridX = m_form->gridSize();
int gridY = m_form->gridSize();
QPainter p(m_container);
p.setPen(QPen(white, 2));
p.setRasterOp(XorROP);
int cols = m_container->width() / gridX;
int rows = m_container->height() / gridY;
for(int rowcursor = 1; rowcursor <= rows; ++rowcursor)
{
for(int colcursor = 1; colcursor <= cols; ++colcursor)
{
p.drawPoint(-1 + colcursor *gridX, -1 + rowcursor *gridY);
}
}
return false;
}
case QEvent::Resize: // we are resizing a widget, so we set m_move to true -> the layout will be reloaded when releasing mouse
{
if(m_form->interactiveMode())
m_state = MovingWidget;
break;
}
//case QEvent::AccelOverride:
case QEvent::KeyPress:
{
QKeyEvent *kev = static_cast<QKeyEvent*>(e);
if(kev->key() == Key_F2) // pressing F2 == double-clicking
{
m_state = InlineEditing;
QWidget *w;
// try to find the widget which was clicked last and should be edited
if(m_form->selectedWidgets()->count() == 1)
w = m_form->selectedWidgets()->first();
else if(m_form->selectedWidgets()->findRef(m_moving) != -1)
w = m_moving;
else
w = m_form->selectedWidgets()->last();
m_form->library()->startEditing(w->className(), w, this);
}
else if(kev->key() == Key_Escape)
{
if(FormManager::self()->isCreatingConnection())
FormManager::self()->stopCreatingConnection();
else if(FormManager::self()->isInserting())
FormManager::self()->stopInsert();
return true;
}
else if((kev->key() == Key_Control) && (m_state == MovingWidget))
{
if(!m_moving)
return true;
// we simulate a mouse move event to update screen
QMouseEvent *mev = new QMouseEvent(QEvent::MouseMove, m_moving->mapFromGlobal(QCursor::pos()), NoButton,
LeftButton|ControlButton );
eventFilter(m_moving, mev);
delete mev;
}
else if(kev->key() == FormManager::self()->contextMenuKey())
{
FormManager::self()->createContextMenu(static_cast<QWidget*>(s), this, false);
return true;
}
else if (kev->key() == Key_Delete)
{
FormManager::self()->deleteWidget();
return true;
}
// directional buttons move the widget
else if(kev->key() == Key_Left){ // move the widget of gridX to the left
moveSelectedWidgetsBy(-form()->gridSize(), 0);
return true;
}
else if(kev->key() == Key_Right){ // move the widget of gridX to the right
moveSelectedWidgetsBy(form()->gridSize(), 0);
return true;
}
else if(kev->key() == Key_Up){ // move the widget of gridY to the top
moveSelectedWidgetsBy(0, - form()->gridSize());
return true;
}
else if(kev->key() == Key_Down){ // move the widget of gridX to the bottom
moveSelectedWidgetsBy(0, form()->gridSize());
return true;
}
else if((kev->key() == Key_Tab) || (kev->key() == Key_BackTab)){
ObjectTreeItem *item = form()->objectTree()->lookup(form()->selectedWidgets()->first()->name());
if(!item || !item->parent())
return true;
ObjectTreeList *list = item->parent()->children();
if(list->count() == 1)
return true;
int index = list->findRef(item);
if(kev->key() == Key_BackTab){
if(index == 0) // go back to the last item
index = list->count() - 1;
else
index = index - 1;
}
else {
if(index == int(list->count() - 1)) // go back to the first item
index = 0;
else
index = index + 1;
}
ObjectTreeItem *nextItem = list->at(index);
if(nextItem && nextItem->widget())
form()->setSelectedWidget(nextItem->widget(), false);
}
return true;
}
case QEvent::KeyRelease:
{
QKeyEvent *kev = static_cast<QKeyEvent*>(e);
if((kev->key() == Key_Control) && (m_state == CopyingWidget)) {
// cancel copying
//m_copyRect = QRect();
if(m_form->formWidget())
m_form->formWidget()->clearForm();
}
return true;
}
case QEvent::MouseButtonDblClick: // editing
{
kdDebug() << "Container: Mouse dbl click for widget " << s->name() << endl;
QWidget *w = static_cast<QWidget*>(s);
if(!w)
return false;
//m_inlineEditing = true;
m_state = InlineEditing;
m_form->library()->startEditing(w->className(), w, this);
return true;
}
case QEvent::ContextMenu:
case QEvent::Enter:
case QEvent::Leave:
case QEvent::FocusIn:
case QEvent::FocusOut:
// case QEvent::DragEnter:
// case QEvent::DragMove:
// case QEvent::DragLeave:
return true; // eat them
default:
return false; // let the widget do the rest ...
}
return false;
}
bool EditorBrowser::eventFilter( QObject *o, QEvent *e )
{
if (
#if (QT_VERSION) < 0x030200
o->parent()->inherits("Editor") || o->inherits("Editor")
#else
::qt_cast<Editor*>(o->parent()) || ::qt_cast<Editor*>(o)
#endif
) {
QMouseEvent *me;
QKeyEvent *ke;
switch ( e->type() ) {
case QEvent::MouseMove:
me = (QMouseEvent*)e;
if ( ( me->state() & ControlButton ) == ControlButton ) {
curEditor->viewport()->setCursor( pointingHandCursor );
QTextCursor c( curEditor->document() );
curEditor->placeCursor( curEditor->viewportToContents( me->pos() ), &c );
QTextCursor from, to;
if ( oldHighlightedParag ) {
oldHighlightedParag->setEndState( -1 );
oldHighlightedParag->format();
oldHighlightedParag = 0;
}
if ( findCursor( c, from, to ) && from.paragraph() == to.paragraph() ) {
// avoid collision with other selections
for ( int i = 0; i < curEditor->document()->numSelections(); ++i )
curEditor->document()->removeSelection( i );
from.paragraph()->setFormat( from.index(), to.index() - from.index() + 1, highlightedFormat, FALSE );
lastWord = from.paragraph()->string()->toString().mid( from.index(), to.index() - from.index() + 1 );
oldHighlightedParag = from.paragraph();
} else {
lastWord = "";
}
curEditor->repaintChanged();
return TRUE;
}
break;
case QEvent::MouseButtonPress: {
bool killEvent = !lastWord.isEmpty();
if ( !lastWord.isEmpty() )
showHelp( lastWord );
lastWord = "";
curEditor->viewport()->setCursor( ibeamCursor );
if ( oldHighlightedParag ) {
oldHighlightedParag->setEndState( -1 );
oldHighlightedParag->format();
curEditor->repaintChanged();
oldHighlightedParag = 0;
}
if ( killEvent )
return TRUE;
} break;
case QEvent::KeyRelease:
lastWord = "";
ke = (QKeyEvent*)e;
if ( ke->key() == Key_Control ) {
curEditor->viewport()->setCursor( ibeamCursor );
if ( oldHighlightedParag ) {
oldHighlightedParag->setEndState( -1 );
oldHighlightedParag->format();
curEditor->repaintChanged();
oldHighlightedParag = 0;
}
}
default:
break;
}
}
return FALSE;
}
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;
}
/**
* Event delegation
*
* @param e The event to be identified and processed
*
*/
bool SelectTool::processEvent(QEvent* e)
{
KivioCanvas* canvas = view()->canvasWidget();
QMouseEvent *m;
switch (e->type())
{
case QEvent::MouseButtonDblClick:
m = (QMouseEvent *)e;
if( m->button() == LeftButton ) {
leftDoubleClick(m->pos());
}
canvas->setFocus();
return true;
break;
case QEvent::MouseButtonPress:
m = (QMouseEvent *)e;
if( m->button() == RightButton ) {
showPopupMenu(m->globalPos());
} else if( m->button() == LeftButton ) {
if(m->state() & ControlButton) {
m_controlKey = true;
} else {
m_controlKey = false;
}
mousePress( m->pos() );
}
canvas->setFocus();
return true;
break;
case QEvent::MouseButtonRelease:
mouseRelease( ((QMouseEvent *)e)->pos() );
canvas->setFocus();
return true;
break;
case QEvent::MouseMove:
mouseMove( static_cast<QMouseEvent*>(e));
return true;
break;
case QEvent::KeyPress:
if((static_cast<QKeyEvent*>(e)->key() >= Key_Left) && (static_cast<QKeyEvent*>(e)->key() <= Key_Down)) {
keyPress(static_cast<QKeyEvent*>(e));
return true;
}
break;
default:
break;
}
return false;
}
/*! Reimplementation of the \c QObject function. Always returns \p false (meaning event is \e not
handled and should be forwarded to the \p qglviewer).
When EventRecorder isRecording(), the following \c QEvent::type are recorded in an internal data
structure: \c KeyPress, \c KeyRelease, \c MouseButtonPress, \c MouseButtonRelease, \c
MouseButtonDblClick, \c MouseMove, \c Wheel and \c Timer (used by QGLViewer::animate()). Does
nothing when isRecording() is \c false.
You may overload this method to filter other \c QEvent::type (your implementation should probably
call this function).
Other specific events can be recorded using recordFrameState() and recordCustomEvent(). */
bool EventRecorder::eventFilter(QObject *, QEvent *e)
{
if (isRecording())
{
bool record = true;
switch (e->type())
{
case QEvent::KeyPress:
case QEvent::KeyRelease:
{
QKeyEvent* ke = (QKeyEvent*)(e);
eventRecords_[eventIndex_].event.keyEvent = new QKeyEvent(e->type(), ke->key(), ke->ascii(), int(ke->state()));
break;
}
case QEvent::MouseButtonPress:
case QEvent::MouseButtonRelease:
case QEvent::MouseButtonDblClick:
case QEvent::MouseMove:
{
QMouseEvent* me = (QMouseEvent*)(e);
eventRecords_[eventIndex_].event.mouseEvent = new QMouseEvent(e->type(), me->pos(), int(me->button()), int(me->state()));
break;
}
case QEvent::Wheel:
{
QWheelEvent* we = (QWheelEvent*)(e);
eventRecords_[eventIndex_].event.wheelEvent = new QWheelEvent(we->pos(), we->delta(), int(we->state()));
break;
}
case QEvent::Timer:
{
eventRecords_[eventIndex_].event.keyEvent = NULL; // or any other pointer
break;
}
default:
record = false;
break;
}
if (record)
{
eventRecords_[eventIndex_].type = e->type();
eventRecords_[eventIndex_].time = time_.elapsed();
eventIndex_++;
}
}
return false;
}
/******************************************************************************
* Receives events destined for the spin widget or for the edit field.
*/
bool SpinBox::eventFilter(QObject* obj, QEvent* e)
{
if (obj == editor())
{
if (e->type() == QEvent::KeyPress)
{
// Up and down arrow keys step the value
QKeyEvent* ke = (QKeyEvent*)e;
int key = ke->key();
if (key == Qt::Key_Up || key == Qt::Key_Down)
{
if (mReadOnly)
return true; // discard up/down arrow keys
int step;
if ((ke->state() & (Qt::ShiftButton | Qt::AltButton)) == Qt::ShiftButton)
{
// Shift stepping
int val = value();
if (key == Qt::Key_Up)
step = mLineShiftStep - val % mLineShiftStep;
else
step = - ((val + mLineShiftStep - 1) % mLineShiftStep + 1);
}
else
step = (key == Qt::Key_Up) ? mLineStep : -mLineStep;
addValue(step, false);
return true;
}
}
#if KDE_IS_VERSION(3,1,90)
else if (e->type() == QEvent::Leave)
{
if (mEdited)
interpretText();
}
#endif
}
else
{
int etype = e->type(); // avoid switch compile warnings
switch (etype)
{
case QEvent::MouseButtonPress:
case QEvent::MouseButtonDblClick:
{
QMouseEvent* me = (QMouseEvent*)e;
if (me->button() == Qt::LeftButton)
{
// It's a left button press. Set normal or shift stepping as appropriate.
if (mReadOnly)
return true; // discard the event
mCurrentButton = whichButton(me->pos());
if (mCurrentButton == NO_BUTTON)
return true;
bool shift = (me->state() & (Qt::ShiftButton | Qt::AltButton)) == Qt::ShiftButton;
if (setShiftStepping(shift))
return true; // hide the event from the spin widget
return false; // forward event to the destination widget
}
break;
}
case QEvent::MouseButtonRelease:
{
QMouseEvent* me = (QMouseEvent*)e;
if (me->button() == Qt::LeftButton && mShiftMouse)
{
setShiftStepping(false); // cancel shift stepping
return false; // forward event to the destination widget
}
break;
}
case QEvent::MouseMove:
{
QMouseEvent* me = (QMouseEvent*)e;
if (me->state() & Qt::LeftButton)
{
// The left button is down. Track which spin button it's in.
if (mReadOnly)
return true; // discard the event
int newButton = whichButton(me->pos());
if (newButton != mCurrentButton)
{
// The mouse has moved to a new spin button.
// Set normal or shift stepping as appropriate.
mCurrentButton = newButton;
bool shift = (me->state() & (Qt::ShiftButton | Qt::AltButton)) == Qt::ShiftButton;
if (setShiftStepping(shift))
return true; // hide the event from the spin widget
}
return false; // forward event to the destination widget
}
break;
}
case QEvent::KeyPress:
case QEvent::KeyRelease:
case QEvent::AccelOverride: // this is needed to receive Shift presses!
{
QKeyEvent* ke = (QKeyEvent*)e;
int key = ke->key();
int state = ke->state();
if ((state & Qt::LeftButton)
&& (key == Qt::Key_Shift || key == Qt::Key_Alt))
{
// The left mouse button is down, and the Shift or Alt key has changed
if (mReadOnly)
return true; // discard the event
state ^= (key == Qt::Key_Shift) ? Qt::ShiftButton : Qt::AltButton; // new state
bool shift = (state & (Qt::ShiftButton | Qt::AltButton)) == Qt::ShiftButton;
if (!shift && mShiftMouse || shift && !mShiftMouse)
{
// The effective shift state has changed.
// Set normal or shift stepping as appropriate.
if (setShiftStepping(shift))
return true; // hide the event from the spin widget
}
}
break;
}
}
}
return QSpinBox::eventFilter(obj, e);
}
