bool TreeWidgetColumnStretcher::eventFilter(QObject *obj, QEvent *ev)
{
if (obj == parent())
{
if (ev->type() == QEvent::Show)
{
QHeaderView *hv = qobject_cast<QHeaderView*>(obj);
for (int i = 0; i < hv->count(); ++i)
hv->setSectionResizeMode(i, QHeaderView::Interactive);
}
else if (ev->type() == QEvent::Hide)
{
QHeaderView *hv = qobject_cast<QHeaderView*>(obj);
for (int i = 0; i < hv->count(); ++i)
hv->setSectionResizeMode(i, i == m_columnToStretch ? QHeaderView::Stretch : QHeaderView::ResizeToContents);
}
else if (ev->type() == QEvent::Resize)
{
QHeaderView *hv = qobject_cast<QHeaderView*>(obj);
if (hv->sectionResizeMode(m_columnToStretch) == QHeaderView::Interactive)
{
QResizeEvent *re = static_cast<QResizeEvent*>(ev);
int diff = re->size().width() - re->oldSize().width() ;
hv->resizeSection(m_columnToStretch, qMax(32, hv->sectionSize(1) + diff));
}
}
}
return false;
}
bool ComboTabBar::eventFilter(QObject* obj, QEvent* ev)
{
if (m_bluredBackground && ev->type() == QEvent::Paint &&
(obj == m_leftContainer || obj == m_rightContainer ||
obj == m_mainTabBarWidget || obj == m_pinnedTabBarWidget)) {
QPaintEvent* event = static_cast<QPaintEvent*>(ev);
QPainter p(qobject_cast<QWidget*>(obj));
p.setCompositionMode(QPainter::CompositionMode_Clear);
p.fillRect(event->rect(), QColor(0, 0, 0, 0));
}
if (obj == m_mainTabBar && ev->type() == QEvent::Resize) {
QResizeEvent* event = static_cast<QResizeEvent*>(ev);
if (event->oldSize().height() != event->size().height()) {
setUpLayout();
}
}
// Handle wheel events exclusively in ComboTabBar
if (ev->type() == QEvent::Wheel) {
wheelEvent(static_cast<QWheelEvent*>(ev));
return true;
}
return QWidget::eventFilter(obj, ev);
}
void PWidget::eventResize(QObject *, QEvent *e)
{
PukeMessage pm;
widgetId wI;
QResizeEvent *re = Q_RESIZE_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] = re->size().height();
icArg[1] = re->size().width();
icArg[2] = re->oldSize().height();
icArg[3] = re->oldSize().width();
pm.cArg = (char *) icArg;
emit outputMessage(wI.fd, &pm);
delete[] icArg;
}
bool CACanvasItem::eventFilter(QObject* o, QEvent* e)
{
if (o == m_koCanvasGraphicsWidget) {
if (e->type() == QEvent::Move) {
m_shouldIgnoreGeometryChange = true;
QMoveEvent *moveEvent = static_cast<QMoveEvent*>(e);
setPos(QPointF(moveEvent->pos()));
} else if (e->type() == QEvent::Resize) {
m_shouldIgnoreGeometryChange = true;
QResizeEvent *resizeEvent = static_cast<QResizeEvent*>(e);
setWidth(resizeEvent->size().width());
setHeight(resizeEvent->size().height());
} else if (m_editable) {
return false;
} else if (e->type() == QEvent::MouseButtonPress ||
e->type() == QEvent::MouseButtonRelease ||
e->type() == QEvent::MouseMove ||
e->type() == QEvent::MouseTrackingChange) {
return true;
} else {
return false;
}
}
QTimer::singleShot(0, this, SLOT(resetShouldIgnoreGeometryChange()));
return QDeclarativeItem::eventFilter(o, e);
}
bool UIMachineViewSeamless::eventFilter(QObject *pWatched, QEvent *pEvent)
{
if (pWatched != 0 && pWatched == machineWindow())
{
switch (pEvent->type())
{
case QEvent::Resize:
{
/* Send guest-resize hint only if top window resizing to required dimension: */
QResizeEvent *pResizeEvent = static_cast<QResizeEvent*>(pEvent);
if (pResizeEvent->size() != workingArea().size())
break;
/* Recalculate max guest size: */
setMaxGuestSize();
/* And resize guest to that size: */
if (uisession()->isGuestSupportsGraphics())
QTimer::singleShot(0, this, SLOT(sltPerformGuestResize()));
break;
}
default:
break;
}
}
return UIMachineView::eventFilter(pWatched, pEvent);
}
bool Row::eventFilter(QObject * obj, QEvent * ev) {
if (obj == sideWidget && ev->type() == QEvent::MouseButtonPress) {
QMouseEvent * e = static_cast<QMouseEvent *>(ev);
mousePressed(e->x(), e->y());
}
if (obj == this && ev->type() == QEvent::MouseButtonPress) {
QMouseEvent * e = static_cast<QMouseEvent *>(ev);
mousePressed(e->x(), e->y());
}
if ((obj == this) && (ev->type() == QEvent::Paint)) {
QPaintEvent * e = static_cast<QPaintEvent *>(ev);
paint(e->rect());
}
if ((obj == this) && (ev->type() == QEvent::Resize)) {
QResizeEvent * e = static_cast<QResizeEvent *>(ev);
this->pixPerMs = (double) e->size().width() / (double) (globalStopTime - globalStartTime);
qDebug() << pixPerMs;
repaint();
}
return true;
}
bool UIMachineViewFullscreen::eventFilter(QObject *pWatched, QEvent *pEvent)
{
/* Who are we watching? */
QMainWindow *pMainDialog = machineWindowWrapper() && machineWindowWrapper()->machineWindow() ?
qobject_cast<QMainWindow*>(machineWindowWrapper()->machineWindow()) : 0;
if (pWatched != 0 && pWatched == pMainDialog)
{
switch (pEvent->type())
{
case QEvent::Resize:
{
/* Send guest-resize hint only if top window resizing to required dimension: */
QResizeEvent *pResizeEvent = static_cast<QResizeEvent*>(pEvent);
if (pResizeEvent->size() != workingArea().size())
break;
/* Set the "guest needs to resize" hint.
* This hint is acted upon when (and only when) the autoresize property is "true": */
m_fShouldWeDoResize = uisession()->isGuestSupportsGraphics();
if (m_bIsGuestAutoresizeEnabled && m_fShouldWeDoResize)
QTimer::singleShot(0, this, SLOT(sltPerformGuestResize()));
break;
}
default:
break;
}
}
return UIMachineView::eventFilter(pWatched, pEvent);
}
bool EditWidget::eventFilter(QObject *AWatched, QEvent *AEvent)
{
bool hooked = false;
if (AWatched==ui.medEditor && AEvent->type()==QEvent::KeyPress)
{
QKeyEvent *keyEvent = static_cast<QKeyEvent *>(AEvent);
emit keyEventReceived(keyEvent, hooked);
if (!hooked && keyEvent->modifiers()==Qt::CTRL && keyEvent->key()==Qt::Key_Up)
{
hooked = true;
showNextBufferedMessage();
}
else if (!hooked && keyEvent->modifiers()==Qt::CTRL && keyEvent->key() == Qt::Key_Down)
{
hooked = true;
showPrevBufferedMessage();
}
}
else if (AWatched==ui.medEditor && AEvent->type()==QEvent::ShortcutOverride)
{
hooked = true;
}
else if (AWatched==ui.medEditor && AEvent->type()==QEvent::Resize)
{
static const int rightMargin = StyleStorage::staticStorage(RSR_STORAGE_STYLESHEETS)->getStyleInt(SV_MW_EDIT_RIGHT_MARGIN);
QResizeEvent * resEvent = (QResizeEvent*)AEvent;
ui.medEditor->setLineWrapColumnOrWidth(resEvent->size().width() - rightMargin);
}
return hooked || QWidget::eventFilter(AWatched,AEvent);
}
bool InformationPanelContent::eventFilter(QObject* obj, QEvent* event)
{
switch (event->type()) {
case QEvent::Resize: {
QResizeEvent* resizeEvent = static_cast<QResizeEvent*>(event);
if (obj == m_metaDataArea->viewport()) {
// The size of the meta text area has changed. Adjust the fixed
// width in a way that no horizontal scrollbar needs to be shown.
m_metaDataWidget->setFixedWidth(resizeEvent->size().width());
} else if (obj == parent()) {
adjustWidgetSizes(resizeEvent->size().width());
}
break;
}
case QEvent::Polish:
adjustWidgetSizes(parentWidget()->width());
break;
case QEvent::FontChange:
m_metaDataWidget->setFont(QFontDatabase::systemFont(QFontDatabase::SmallestReadableFont));
break;
default:
break;
}
return QWidget::eventFilter(obj, event);
}
bool UIMachineWindowScale::event(QEvent *pEvent)
{
switch (pEvent->type())
{
case QEvent::Resize:
{
QResizeEvent *pResizeEvent = static_cast<QResizeEvent*>(pEvent);
if (!isMaximizedChecked())
{
m_normalGeometry.setSize(pResizeEvent->size());
#ifdef VBOX_WITH_DEBUGGER_GUI
/* Update debugger window position: */
updateDbgWindows();
#endif /* VBOX_WITH_DEBUGGER_GUI */
}
break;
}
case QEvent::Move:
{
if (!isMaximizedChecked())
{
m_normalGeometry.moveTo(geometry().x(), geometry().y());
#ifdef VBOX_WITH_DEBUGGER_GUI
/* Update debugger window position: */
updateDbgWindows();
#endif /* VBOX_WITH_DEBUGGER_GUI */
}
break;
}
default:
break;
}
return UIMachineWindow::event(pEvent);
}
// Extract event-specific arguments to co::Any array
void EventHub::extractArguments( QEvent* event, co::Any* args, int maxArgs )
{
QEvent::Type ev = event->type();
switch( ev )
{
case QEvent::MouseButtonDblClick:
case QEvent::MouseButtonPress:
case QEvent::MouseButtonRelease:
case QEvent::MouseMove:
{
QMouseEvent* mouseEvent = static_cast<QMouseEvent*>( event );
// extract (x and y), button, modifiers
const QPoint& pos = mouseEvent->pos();
args[0].set( pos.x() );
args[1].set( pos.y() );
args[2].set( static_cast<co::uint32>( ev == QEvent::MouseMove ?
mouseEvent->buttons() : mouseEvent->button() ) );
fillKeyboardModifiers( mouseEvent->modifiers(), args[3] );
}
break;
case QEvent::KeyPress:
case QEvent::KeyRelease:
{
QKeyEvent* keyEvent = static_cast<QKeyEvent*>( event );
fillKeyCodeString( keyEvent->key(), args[0] );
fillKeyboardModifiers( keyEvent->modifiers(), args[1] );
}
break;
case QEvent::Wheel:
{
QWheelEvent* wheelEvent = static_cast<QWheelEvent*>( event );
// extract position (x and y ), delta, modifiers
const QPoint& pos = wheelEvent->pos();
args[0].set( pos.x() );
args[1].set( pos.x() );
args[2].set( wheelEvent->delta() );
fillKeyboardModifiers( wheelEvent->modifiers(), args[3] );
}
break;
case QEvent::Resize:
{
QResizeEvent* resizeEvent = static_cast<QResizeEvent*>( event );
// extract size (width and height) and oldSize (width and height)
const QSize& size = resizeEvent->size();
const QSize& oldSize = resizeEvent->oldSize();
args[0].set( size.width() );
args[1].set( size.height() );
args[2].set( oldSize.width() );
args[3].set( oldSize.height() );
}
break;
default:
// Close, Show and Hide require no arguments
return;
}
}
bool XKPPlacementLayout::eventFilter(QObject *object, QEvent *event)
{
// if event is resize
if(event->type() == QEvent::Resize && !inSetGeometry) {
QResizeEvent *resizeEvent =
static_cast<QResizeEvent *>(event);
#ifdef DEBUG_XKPPLACEMENT
QSize esize = resizeEvent->size();
qDebug() << "eventFilter:: object " << object->objectName() << " was resized";
qDebug() << "eventFilter:: size(" << esize.width() << "," << esize.height() << ")";
#endif
// update dynamic property 'placementSize' with widget size
object->setProperty(placementSizeName, resizeEvent->size());
// update geometry in the general widget
updateGeometry();
return true;
} else
// if event is dynamic property changed & not in setGeomtry method
if(event->type() == QEvent::DynamicPropertyChange && !inSetGeometry) {
QDynamicPropertyChangeEvent *dynamicPropertyChangeEvent =
static_cast<QDynamicPropertyChangeEvent *>(event);
// if dynamic property 'placement' is changed
if(dynamicPropertyChangeEvent->propertyName() == placementName) {
#ifdef DEBUG_XKPPLACEMENT
qDebug() << "eventFilter:: propery 'placement' of object " <<
object->objectName() << " was changed";
#endif
// find object in list
for(int i = 0; i < list.size(); ++i) {
ItemWrapper *wrapper = list.at(i);
QWidget *widget = static_cast<QWidget *>(object);
if(wrapper->widget == widget) {
wrapper->position =
Placement(wrapper->widget->property(placementName).toUInt());
break;
}
}
// update geometry in the general widget
updateGeometry();
return true;
} else {
// standard event processing
return QObject::eventFilter(object, event);
}
} else {
// standard event processing
return QObject::eventFilter(object, event);
}
}
bool ToolBar::eventFilter(QObject *o, QEvent *e) {
if (e->type() == QEvent::Resize) {
QResizeEvent *ev = static_cast<QResizeEvent*>(e);
resize(ev->size().width(), height());
return false;
} else {
return _target->eventFilter(o, e);
}
}
bool Menu::eventFilter(QObject *object, QEvent *event) {
if (event->type() == QEvent::Resize) {
QResizeEvent* resizeEvent = static_cast<QResizeEvent*>(event);
setGeometry(0, 0, resizeEvent->size().width(), w_height);
emit globallyChanged();
}
return false;
}
bool MiniProgrammerUI::eventFilter(QObject *obj, QEvent *event)
{
if (event->type() != QEvent::Resize)
return QObject::eventFilter(obj, event);
QResizeEvent *e = (QResizeEvent*)event;
setVertical(e->size().width() < e->size().height());
return QObject::eventFilter(obj, event);
}
bool QwtWidgetOverlay::eventFilter( QObject* object, QEvent* event )
{
if ( object == parent() && event->type() == QEvent::Resize )
{
QResizeEvent *resizeEvent = static_cast<QResizeEvent *>( event );
resize( resizeEvent->size() );
}
return QObject::eventFilter( object, event );
}
bool WidgetHighlighter::eventFilter(QObject* watched, QEvent* event) {
if (watched != mTargetWidget || event->type() != QEvent::Resize) {
return false;
}
QResizeEvent* resizeEvent = static_cast<QResizeEvent*>(event);
resize(resizeEvent->size());
return false;
}
bool OWidgetStack::eventFilter( QObject*, QEvent* e) {
if ( e->type() == QEvent::Resize && !m_forced ) {
QResizeEvent *res = static_cast<QResizeEvent*>( e );
QSize size = res->size();
if ( size.width() >= mode_size )
switchTop();
else
switchStack();
}
return false;
}
bool ac::eventFilter( QObject *o, QEvent *e )
{
// This function makes the console emulator expanding
if ( e->type() == QEvent::Resize )
{
QResizeEvent *re = dynamic_cast< QResizeEvent * >( e );
if ( !re ) return false;
konsole->widget()->setGeometry( 0, 0, re->size().width(), re->size().height() );
}
return false;
};
//! Catches resize and child events from the parent widget
bool eventFilter(QObject * obj, QEvent * ev) {
if (obj == parent()) {
if (ev->type() == QEvent::Resize) {
QResizeEvent * rev = static_cast<QResizeEvent*>(ev);
this->resize(rev->size());
}
else if (ev->type() == QEvent::ChildAdded) {
raise();
}
}
return QWidget::eventFilter(obj, ev);
}
bool UIMachineWindowNormal::event(QEvent *pEvent)
{
switch (pEvent->type())
{
case QEvent::Resize:
{
#ifdef VBOX_WS_X11
/* Prevent handling if fake screen detected: */
if (gpDesktop->isFakeScreenDetected())
break;
#endif /* VBOX_WS_X11 */
QResizeEvent *pResizeEvent = static_cast<QResizeEvent*>(pEvent);
if (!isMaximizedChecked())
{
m_normalGeometry.setSize(pResizeEvent->size());
#ifdef VBOX_WITH_DEBUGGER_GUI
/* Update debugger window position: */
updateDbgWindows();
#endif /* VBOX_WITH_DEBUGGER_GUI */
}
emit sigGeometryChange(geometry());
break;
}
case QEvent::Move:
{
#ifdef VBOX_WS_X11
/* Prevent handling if fake screen detected: */
if (gpDesktop->isFakeScreenDetected())
break;
#endif /* VBOX_WS_X11 */
if (!isMaximizedChecked())
{
m_normalGeometry.moveTo(geometry().x(), geometry().y());
#ifdef VBOX_WITH_DEBUGGER_GUI
/* Update debugger window position: */
updateDbgWindows();
#endif /* VBOX_WITH_DEBUGGER_GUI */
}
emit sigGeometryChange(geometry());
break;
}
case QEvent::WindowActivate:
emit sigGeometryChange(geometry());
break;
default:
break;
}
return UIMachineWindow::event(pEvent);
}
bool ExtendWidget::eventFilter(QObject *o, QEvent *e)
{
Q_D(ExtendWidget);
if (o == d->target) {
if (e->type() == QEvent::Resize) {
QResizeEvent *event = static_cast<QResizeEvent *>(e);
if (event) {
QSize size = event->size();
if (size.width() != d->old_size.width()) {
emit widthChanged(size.width());
}
if (size.height() != d->old_size.height()) {
emit heightChanged(size.height());
}
if (size != d->old_size) {
emit sizeChanged(size);
}
d->old_size = size;
}
} else if (e->type() == QEvent::Move) {
QMoveEvent *event = static_cast<QMoveEvent *>(e);
if (event) {
QPoint pos = event->pos();
if (pos.x() != d->old_pos.x()) {
emit xChanged(pos.x());
}
if (pos.y() != d->old_pos.y()) {
emit yChanged(pos.y());
}
if (pos != d->old_pos) {
emit positionChanged(pos);
}
d->old_pos = pos;
}
}
}
return false;
}
bool ModalOverlay::eventFilter(QObject * obj, QEvent * ev) {
if (obj == parent()) {
if (ev->type() == QEvent::Resize) {
QResizeEvent * rev = static_cast<QResizeEvent*>(ev);
resize(rev->size());
if (!layerIsVisible)
setGeometry(0, height(), width(), height());
}
else if (ev->type() == QEvent::ChildAdded) {
raise();
}
}
return QWidget::eventFilter(obj, ev);
}
dmz::V8Value
dmz::JsModuleUiV8QtBasic::_resize_event_size (const v8::Arguments &Args) {
v8::HandleScope scope;
V8Value result = v8::Undefined ();
JsModuleUiV8QtBasic *self = _to_self (Args);
if (self) {
QResizeEvent *event = (QResizeEvent *)self->_to_qevent (Args.This ());
if (event) { result = qsize_to_v8 (event->size ()); }
}
return scope.Close (result);
}
bool windowManager::eventFilter(QObject* target, QEvent* event) {
// qDebug() << "e" << event->type();
if (event->type() == QEvent::Resize) {
QResizeEvent* resize = static_cast<QResizeEvent*>(event);
setNewSize(resize->size());
return true;
}
if (event->type() == QEvent::Move) {
setNewPosition(static_cast<QWidget*>(target)->pos());
return true;
}
return QObject::eventFilter(target, event);
}
bool GLBoxSelector::eventFilter(QObject *watched, QEvent *event)
{
if (!hidden && watched == glw) {
QResizeEvent *re; QMouseEvent *me; QPaintEvent *pe;
if ((re=dynamic_cast<QResizeEvent *>(event))) {
QSize s = re->size();
resized(s.width(), s.height());
} else if ((me=dynamic_cast<QMouseEvent *>(event))) {
if (enabled) processMouse(me);
} else if ((pe=dynamic_cast<QPaintEvent *>(event))) {
//draw();
}
}
return false; // don't filter event
}
bool Clock::eventFilter( QObject *o, QEvent *e )
{
if ( o == swFrame && e->type() == QEvent::Resize ) {
QResizeEvent *re = (QResizeEvent *)e;
delete swLayout;
if ( re->size().height() < 80 || re->size().height()*3 < re->size().width() )
swLayout = new QHBoxLayout( swFrame );
else
swLayout = new QVBoxLayout( swFrame );
swLayout->addWidget( analogStopwatch );
swLayout->addWidget( stopwatchLcd );
swLayout->activate();
}
return FALSE;
}
void TControl::OnResized(QResizeEvent event) {
int newWidth = event.size().width();
int newHeight = event.size().height();
int realWidth, realHeight;
float rate = WORLD_HEIGHT / WORLD_WIDTH;
if (newWidth * rate < newHeight) {
realWidth = newWidth;
realHeight = newWidth * rate;
} else {
realHeight = newHeight;
realWidth = newHeight / rate;
}
World->Scale = realWidth / WORLD_WIDTH;
World->OffsetX = (newWidth - realWidth) / 2;
World->OffsetY = (newHeight - realHeight) / 2;
}
bool QAquaFocusWidget::eventFilter(QObject * o, QEvent * e)
{
if((e->type() == QEvent::ChildInserted || e->type() == QEvent::ChildRemoved) &&
((QChildEvent*)e)->child() == this) {
if(e->type() == QEvent::ChildRemoved)
o->removeEventFilter(this); //once we're removed, stop listening
return TRUE; //block child events
} else if(o == d) {
switch (e->type()) {
case QEvent::PaletteChange:
setPalette(d->palette());
break;
case QEvent::Hide:
hide();
break;
case QEvent::Show:
show();
break;
case QEvent::Move: {
QPoint p(d->mapTo(parentWidget(), QPoint(0, 0)));
move(p.x() - focusOutset(), p.y() - focusOutset());
break;
}
case QEvent::Resize: {
QResizeEvent *re = (QResizeEvent*)e;
resize(re->size().width() + (focusOutset() * 2),
re->size().height() + (focusOutset() * 2));
setMask(QRegion(rect()) - focusRegion());
break;
}
case QEvent::Reparent: {
QWidget *newp = FOCUS_WIDGET_PARENT(d);
QPoint p(d->mapTo(newp, QPoint(0, 0)));
newp->installEventFilter(this);
reparent(newp, p);
raise();
break; }
default:
break;
}
} else if (QComboBox *combo = ::qt_cast<QComboBox *>(d)) {
if (combo->lineEdit() == o && e->type() == QEvent::FocusOut)
QApplication::sendEvent(combo, e);
}
return FALSE;
}
bool ComboTabBar::eventFilter(QObject* obj, QEvent* ev)
{
if (obj == m_mainTabBar && ev->type() == QEvent::Resize) {
QResizeEvent* event = static_cast<QResizeEvent*>(ev);
if (event->oldSize().height() != event->size().height()) {
setUpLayout();
}
}
// Handle wheel events exclusively in ComboTabBar
if (ev->type() == QEvent::Wheel) {
wheelEvent(static_cast<QWheelEvent*>(ev));
return true;
}
return QWidget::eventFilter(obj, ev);
}
