void BitcoinGUI::changeEvent(QEvent *e)
{
QMainWindow::changeEvent(e);
#ifndef Q_OS_MAC // Ignored on Mac
if(e->type() == QEvent::WindowStateChange)
{
if(clientModel && clientModel->getOptionsModel()->getMinimizeToTray())
{
QWindowStateChangeEvent *wsevt = static_cast<QWindowStateChangeEvent*>(e);
if(!(wsevt->oldState() & Qt::WindowMinimized) && isMinimized())
{
QTimer::singleShot(0, this, SLOT(hide()));
e->ignore();
}
}
}
#endif
}
bool WindowEventFilter::eventFilter(QObject *watched, QEvent *event)
{
if (watched != mpWindow)
return false;
if (event->type() == QEvent::WindowStateChange) {
QWindowStateChangeEvent *e = static_cast<QWindowStateChangeEvent*>(event);
mpWindow->updateGeometry();
if (mpWindow->windowState().testFlag(Qt::WindowFullScreen) || e->oldState().testFlag(Qt::WindowFullScreen)) {
emit fullscreenChanged();
}
return false;
}
if (event->type() == QEvent::MouseButtonPress) {
QMouseEvent *me = static_cast<QMouseEvent*>(event);
Qt::MouseButton mbt = me->button();
if (mbt == Qt::LeftButton) {
gMousePos = me->globalPos();
iMousePos = me->pos();
}
return false;
}
if (event->type() == QEvent::MouseButtonRelease) {
QMouseEvent *me = static_cast<QMouseEvent*>(event);
Qt::MouseButton mbt = me->button();
if (mbt != Qt::LeftButton)
return false;
iMousePos = QPoint();
gMousePos = QPoint();
return false;
}
if (event->type() == QEvent::MouseMove) {
if (iMousePos.isNull() || gMousePos.isNull())
return false;
QMouseEvent *me = static_cast<QMouseEvent*>(event);
int x = mpWindow->pos().x();
int y = mpWindow->pos().y();
int dx = me->globalPos().x() - gMousePos.x();
int dy = me->globalPos().y() - gMousePos.y();
gMousePos = me->globalPos();
mpWindow->move(x + dx, y + dy);
return false;
}
return false;
}
void MainWindow::changeEvent(QEvent* event) {
if (event->type() == QEvent::WindowStateChange) {
QWindowStateChangeEvent* stateChangeEvent = static_cast<QWindowStateChangeEvent*>(event);
if ((stateChangeEvent->oldState() == Qt::WindowNoState ||
stateChangeEvent->oldState() == Qt::WindowMaximized) &&
windowState() == Qt::WindowMinimized) {
emit windowShown(false);
} else {
emit windowShown(true);
}
} else if (event->type() == QEvent::ActivationChange) {
if (isActiveWindow()) {
emit windowShown(true);
} else {
emit windowShown(false);
}
}
QMainWindow::changeEvent(event);
}
void KviMainWindow::changeEvent(QEvent * e)
{
#ifndef COMPILE_ON_MAC
// For Qt5 this should be used to minimize to tray
if(
(e->type() == QEvent::WindowStateChange) && (windowState() & Qt::WindowMinimized) && KVI_OPTION_BOOL(KviOption_boolMinimizeInTray) && e->spontaneous())
{
if(!trayIcon())
{
executeInternalCommand(KVI_INTERNALCOMMAND_TRAYICON_SHOW);
}
if(trayIcon())
{
QWindowStateChangeEvent * ev = (QWindowStateChangeEvent *)e;
KVI_OPTION_BOOL(KviOption_boolFrameIsMaximized) = ev->oldState() & Qt::WindowMaximized;
QTimer::singleShot(0, this, SLOT(hide()));
}
return;
}
#endif
if(e->type() == QEvent::ActivationChange)
{
//WINDOW (DE)ACTIVATION
// if we have just been activated by the WM
// then update the active window task bar item
// It will then reset its highlight state
// and hopefully make the dock widget work correctly
// in this case.
// This will also trigger the OnWindowActivated event :)
if(isActiveWindow())
{
if(g_pActiveWindow)
windowActivated(g_pActiveWindow, true);
}
else
{
if(g_pActiveWindow)
g_pActiveWindow->lostUserFocus();
}
}
KviTalMainWindow::changeEvent(e);
}
//______________________________________________________________________________
void VxtRootCanvas::changeEvent(QEvent * e)
{
if (e->type() == QEvent ::WindowStateChange) {
QWindowStateChangeEvent * event = static_cast< QWindowStateChangeEvent * >( e );
if (( event->oldState() & Qt::WindowMaximized ) ||
( event->oldState() & Qt::WindowMinimized ) ||
( event->oldState() == Qt::WindowNoState &&
this->windowState() == Qt::WindowMaximized )) {
if (canvas->getCanvas()) {
//TLine *l=new TLine(canvas->getCanvas()->GetUxmin(),100.0,canvas->getCanvas()->GetUxmax(),100.0);
//TLine *l=new TLine(-DBL_MAX,100.0,-DBL_MAX,100.0);
//l->SetLineColor(kRed);
//l->Draw();
canvas->getCanvas()->Resize();
canvas->getCanvas()->Update();
}
}
}
}
bool QtGameEngine::eventFilter(QObject *object, QEvent *event) {
// http://doc.trolltech.com/4.7/qevent.html#QEvent
if (event->type() == QEvent::ActivationChange) {
if (m_paused) m_paused = false; else m_paused = true;
qDebug() << "ActivationChangeFiltered: paused ==" << m_paused;
if (!m_pauseResumeDisabled) {
if (m_paused) pause(); else resume();
} else {
qDebug() << "Ignoring paused/resume since textintputdialog is on.";
}
return false;
}
#ifdef MY_OS_MEEGO
else if (event->type() == QEvent::WindowStateChange )
{
QWindowStateChangeEvent *change = static_cast<QWindowStateChangeEvent *>(event);
Qt::WindowStates current = windowState();
Qt::WindowStates old = change->oldState();
//qDebug() << "widget is minimized in eventFilter?" << isMinimized();
// did minimized flag change?
if ((current ^ old) & Qt::WindowMinimized) {
if (current & Qt::WindowMinimized) {
// In MeeGo, the gl surface is somehow broken by the QMeegoGraphicsSystem.
// This is why we must kill the timer, to prevent errors resulting gl painting.
//qDebug() << "HIDING";
killTimer(timerid);
timerid = 0;
}
}
return false;
}
#endif
else {
// Standard event processing
return QObject::eventFilter(object, event);
}
return false;
}
void MainWindow::changeEvent(QEvent* event) {
if (event->type() == QEvent::WindowStateChange) {
QWindowStateChangeEvent* stateChangeEvent = static_cast<QWindowStateChangeEvent*>(event);
if ((stateChangeEvent->oldState() == Qt::WindowNoState ||
stateChangeEvent->oldState() == Qt::WindowMaximized) &&
windowState() == Qt::WindowMinimized) {
emit windowShown(false);
} else {
emit windowShown(true);
}
if (isFullScreen() != Menu::getInstance()->isOptionChecked(MenuOption::Fullscreen)) {
Menu::getInstance()->setIsOptionChecked(MenuOption::Fullscreen, isFullScreen());
}
} else if (event->type() == QEvent::ActivationChange) {
if (isActiveWindow()) {
emit windowShown(true);
} else {
emit windowShown(false);
}
}
QMainWindow::changeEvent(event);
}
void UIMachineWindowFullscreen::changeEvent(QEvent *pEvent)
{
switch (pEvent->type())
{
case QEvent::WindowStateChange:
{
/* Watch for window state changes: */
QWindowStateChangeEvent *pChangeEvent = static_cast<QWindowStateChangeEvent*>(pEvent);
LogRel2(("GUI: UIMachineWindowFullscreen::changeEvent: Window state changed from %d to %d\n",
(int)pChangeEvent->oldState(), (int)windowState()));
if ( windowState() == Qt::WindowMinimized
&& pChangeEvent->oldState() == Qt::WindowNoState
&& !m_fIsMinimized)
{
/* Mark window minimized, isMinimized() is not enough due to Qt5vsX11 fight: */
LogRel2(("GUI: UIMachineWindowFullscreen::changeEvent: Window minimized\n"));
m_fIsMinimized = true;
}
else
if ( windowState() == Qt::WindowNoState
&& pChangeEvent->oldState() == Qt::WindowMinimized
&& m_fIsMinimized)
{
/* Mark window restored, and do manual restoring with showInNecessaryMode(): */
LogRel2(("GUI: UIMachineWindowFullscreen::changeEvent: Window restored\n"));
m_fIsMinimized = false;
showInNecessaryMode();
}
break;
}
default:
break;
}
/* Call to base-class: */
UIMachineWindow::changeEvent(pEvent);
}
void NMainWindow::changeEvent(QEvent *event)
{
QWidget::changeEvent(event);
emit focusChanged(isActiveWindow());
if (windowFlags() & Qt::FramelessWindowHint) {
setAttribute(Qt::WA_Hover, true);
return;
}
if (event->type() == QEvent::WindowStateChange) {
QWindowStateChangeEvent *stateEvent = static_cast<QWindowStateChangeEvent *>(event);
if (stateEvent->oldState() == Qt::WindowNoState && isMaximized()) {
if (!m_unmaximizedSize.isValid()) {
m_unmaximizedPos = pos();
m_unmaximizedSize = size();
}
} else if (!isMaximized() && !isMinimized() && !m_isFullScreen) {
m_unmaximizedSize = QSize();
m_unmaximizedPos = QPoint();
}
}
}
// For multitouch - controls
bool QtGameEngine::event(QEvent *event)
{
switch (event->type()) {
case QEvent::TouchBegin:
case QEvent::TouchUpdate:
case QEvent::TouchEnd:
{
touchEventsEnabled = true;
QList<QTouchEvent::TouchPoint> touchPoints = static_cast<QTouchEvent *>(event)->touchPoints();
foreach (const QTouchEvent::TouchPoint &touchPoint, touchPoints) {
int ind = touchPoint.id();
switch (touchPoint.state()) {
case Qt::TouchPointPressed:
{
QPoint p = touchPoint.pos().toPoint();
runningGame->mouseEvent( MOUSE_DOWN, p.x(), p.y(), ind );
continue;
}
case Qt::TouchPointMoved:
{
QPoint p = touchPoint.pos().toPoint();
runningGame->mouseEvent( MOUSE_MOVE, p.x(), p.y(), ind );
continue;
}
case Qt::TouchPointReleased:
{
QPoint p = touchPoint.pos().toPoint();
runningGame->mouseEvent( MOUSE_UP, p.x(), p.y(), ind );
continue;
}
default:
case Qt::TouchPointStationary:
{
// The touch point did NOT move
continue;
}
}
}
event->accept();
break;
}
#ifdef MY_OS_MEEGO
case QEvent::WindowStateChange :
{
QWindowStateChangeEvent *change = static_cast<QWindowStateChangeEvent *>(event);
Qt::WindowStates current = windowState();
Qt::WindowStates old = change->oldState();
// did minimized flag change?
if ((current ^ old) & Qt::WindowMinimized) {
if (current & Qt::WindowMinimized) {
}
else {
// In MeeGo, we need to re-create the EGL here.
createEGLUtils();
}
//qDebug() << "WindowStateChange : " << m_paused << bool(m_updatesDisabled);
}
event->accept();
break;
}
#endif
default:
return QWidget::event(event);
}
void QtMainWindowControl::changeEvent(QEvent* event)
{
if (!controller->shell)
return QMainWindow::changeEvent(event);
typedef IShellListener::Events::ShellEventType::ListenerList ListenerList;
ShellEvent::Pointer shellEvent(new ShellEvent(Shell::Pointer(controller->shell)));
switch (event->type())
{
case QEvent::ActivationChange:
{
if (isActiveWindow())
{
ListenerList activatedListeners(controller->shellEvents.shellActivated.GetListeners());
for (ListenerList::iterator listener = activatedListeners.begin();
listener != activatedListeners.end(); ++listener)
{
(*listener)->Execute(shellEvent);
if (!shellEvent->doit) {
event->accept();
return;
}
}
}
else
{
ListenerList deactivatedListeners(controller->shellEvents.shellDeactivated.GetListeners());
for (ListenerList::iterator listener = deactivatedListeners.begin();
listener != deactivatedListeners.end(); ++listener)
{
(*listener)->Execute(shellEvent);
if (!shellEvent->doit) {
event->accept();
return;
}
}
}
}
break;
case QEvent::WindowStateChange:
{
QWindowStateChangeEvent* stateEvent = dynamic_cast<QWindowStateChangeEvent*>(event);
Qt::WindowStates oldState = stateEvent->oldState();
if (this->isMinimized() && !(oldState & Qt::WindowMinimized))
{
ListenerList iconifiedListeners(controller->shellEvents.shellIconified.GetListeners());
for (ListenerList::iterator listener = iconifiedListeners.begin();
listener != iconifiedListeners.end(); ++listener)
{
(*listener)->Execute(shellEvent);
if (!shellEvent->doit) {
event->accept();
return;
}
}
}
else if (oldState & Qt::WindowMinimized && !this->isMinimized())
{
ListenerList deiconifiedListeners(controller->shellEvents.shellDeiconified.GetListeners());
for (ListenerList::iterator listener = deiconifiedListeners.begin();
listener != deiconifiedListeners.end(); ++listener)
{
(*listener)->Execute(shellEvent);
if (!shellEvent->doit) return;
}
}
}
break;
default:
break;
}
QMainWindow::changeEvent(event);
}
void CWinMain::changeEvent( QEvent* e )
{
QMainWindow::changeEvent( e );
switch ( e->type() )
{
case QEvent::LanguageChange:
ui->retranslateUi( this );
switch ( quazaaSettings.WinMain.ActiveTab )
{
case 0:
ui->actionHome->setChecked( true );
break;
case 1:
ui->actionLibrary->setChecked( true );
break;
case 2:
ui->actionMedia->setChecked( true );
break;
case 3:
ui->actionSearch->setChecked( true );
break;
case 4:
ui->actionTransfers->setChecked( true );
break;
case 5:
ui->actionSecurity->setChecked( true );
break;
case 6:
ui->actionActivity->setChecked( true );
break;
case 7:
ui->actionChat->setChecked( true );
break;
case 8:
ui->actionHostCache->setChecked( true );
break;
case 9:
ui->actionDiscovery->setChecked( true );
break;
case 10:
ui->actionScheduler->setChecked( true );
break;
case 11:
ui->actionGraph->setChecked( true );
break;
case 12:
ui->actionPacketDump->setChecked( true );
break;
case 13:
ui->actionSearchMonitor->setChecked( true );
break;
case 14:
ui->actionHitMonitor->setChecked( true );
break;
default:
ui->actionHome->setChecked( true );
break;
}
break;
case QEvent::WindowStateChange:
{
QWindowStateChangeEvent* event = ( QWindowStateChangeEvent* )e;
// make sure we only do this for minimize events
if ( ( event->oldState() != Qt::WindowMinimized ) && isMinimized() && quazaaSettings.System.MinimizeToTray )
{
QTimer::singleShot( 0, this, SLOT( hide() ) );
e->ignore();
}
}
default:
break;
}
}
