bool QEventDispatcherWin32::event(QEvent *e)
{
Q_D(QEventDispatcherWin32);
if (e->type() == QEvent::ZeroTimerEvent) {
QZeroTimerEvent *zte = static_cast<QZeroTimerEvent*>(e);
WinTimerInfo *t = d->timerDict.value(zte->timerId());
if (t) {
t->inTimerEvent = true;
QTimerEvent te(zte->timerId());
QCoreApplication::sendEvent(t->obj, &te);
t = d->timerDict.value(zte->timerId());
if (t) {
if (t->interval == 0 && t->inTimerEvent) {
// post the next zero timer event as long as the timer was not restarted
QCoreApplication::postEvent(this, new QZeroTimerEvent(zte->timerId()));
}
t->inTimerEvent = false;
}
}
return true;
} else if (e->type() == QEvent::Timer) {
QTimerEvent *te = static_cast<QTimerEvent*>(e);
d->sendTimerEvent(te->timerId());
}
return QAbstractEventDispatcher::event(e);
}
bool QSpotifyAudioThreadWorker::event(QEvent *e)
{
// Ignore timer events to have less log trashing
if(e->type() != QEvent::Timer)
qDebug() << "QSpotifyAudioThreadWorker::event" << e->type();
if (e->type() == StreamingStartedEventType) {
QMutexLocker lock(&g_mutex);
QSpotifyStreamingStartedEvent *ev = static_cast<QSpotifyStreamingStartedEvent *>(e);
startStreaming(ev->channels(), ev->sampleRate());
e->accept();
return true;
} else if (e->type() == ResumeEventType) {
QMutexLocker lock(&g_mutex);
if (m_audioOutput) {
m_audioOutput->resume();
m_audioTimerID = startTimer(AUDIOSTREAM_UPDATE_INTERVAL);
}
e->accept();
return true;
} else if (e->type() == SuspendEventType) {
QMutexLocker lock(&g_mutex);
if (m_audioOutput) {
killTimer(m_audioTimerID);
m_audioOutput->suspend();
}
e->accept();
return true;
} else if (e->type() == AudioStopEventType) {
QMutexLocker lock(&g_mutex);
killTimer(m_audioTimerID);
g_buffer.close();
if (m_audioOutput) {
m_audioOutput->stop();
m_audioOutput->deleteLater();
m_audioOutput = nullptr;
m_iodevice = nullptr;
}
e->accept();
return true;
} else if (e->type() == ResetBufferEventType) {
QMutexLocker lock(&g_mutex);
if (m_audioOutput) {
killTimer(m_audioTimerID);
m_audioOutput->reset();
g_buffer.reset();
startAudioOutput();
}
e->accept();
return true;
} else if (e->type() == QEvent::Timer) {
QTimerEvent *te = static_cast<QTimerEvent *>(e);
if (te->timerId() == m_audioTimerID) {
updateAudioBuffer();
e->accept();
return true;
}
}
return QObject::event(e);
}
bool ChatLayer::event(QEvent *ev)
{
if (ev->type() == QEvent::Timer) {
QTimerEvent *timerEvent = static_cast<QTimerEvent*>(ev);
if (timerEvent->timerId() == d_func()->alertTimer.timerId()) {
d_func()->alertTimer.stop();
alert(false);
return true;
}
}
return QObject::event(ev);
}
bool AudioMixer::event(QEvent *event)
{
switch (event->type()){
case QEvent::Timer:{
QTimerEvent *timerEvent = static_cast<QTimerEvent *>(event);
if (timerEvent->timerId() == m_fadeTimer)
updateFade();
break; }
default:
break;
}
return MediaNode::event(event);
}
bool VolumeFaderEffect::event(QEvent *event)
{
switch (event->type()){
case QEvent::Timer:
{
QTimerEvent *timerEvent = static_cast<QTimerEvent *>(event);
if (timerEvent->timerId() == m_fadeTimer)
updateFade();
break;
}
default:
break;
}
return QObject::event(event);
}
bool TorcPlayer::HandleEvent(QEvent *Event)
{
int type = Event->type();
if (QEvent::Timer == type)
{
QTimerEvent* timer = static_cast<QTimerEvent*>(Event);
if (timer)
{
int id = timer->timerId();
if (id == m_refreshTimer)
{
static QSizeF dummy;
Refresh(TorcCoreUtils::GetMicrosecondCount(), dummy, false);
return true;
}
else if (id == m_nextDecoderStartTimer)
{
DestroyNextDecoder();
return true;
}
else if (id == m_oldDecoderStopTimer)
{
LOG(VB_GENERAL, LOG_ERR, "Decoder failed to stop - killing");
DestroyOldDecoder();
return true;
}
else if (id == m_pauseTimer)
{
LOG(VB_GENERAL, LOG_INFO, "Waited 1 second for player to pause");
return true;
}
else if (id == m_playTimer)
{
LOG(VB_GENERAL, LOG_INFO, "Waited 1 second for player to start playing");
return true;
}
else if (id == m_stopTimer)
{
LOG(VB_GENERAL, LOG_INFO, "Waited 1 second for player to stop");
return true;
}
}
}
return false;
}
void PWidget::eventTimer(QObject *, QEvent *e)
{
PukeMessage pm;
widgetId wI;
QTimerEvent *et = Q_TIMER_EVENT(e);
wI = widgetIden();
pm.iCommand = PUKE_WIDGET_EVENT_TIMER;
pm.iWinId = wI.iWinId;
pm.iArg = et->timerId();
pm.cArg = 0;
emit outputMessage(wI.fd, &pm);
}
bool KTreeWidget::event(QEvent *e)
{
Q_D(KTreeWidget);
if(e->type() == QEvent::Timer)
{
QTimerEvent *te = (QTimerEvent*)e;
quint32 tid = te->timerId();
if(tid == d->m_layoutTimer.timerId())
{
d->m_layoutTimer.stop();
d->doLayout();
}
else if(tid == d->m_areaResizeTimer.timerId())
{
d->m_areaResizeTimer.stop();
d->resetAreas();
}
else if(tid == d->m_makeListTimer.timerId())
{
d->m_makeListTimer.stop();
d->makeList();
}
}
else if(e->type() == QEvent::GraphicsSceneResize)
{
/*触发Areas的调整*/
d->m_areaResizeTimer.start(0, this);
}
else if(e->type() == QEvent::GraphicsSceneMousePress)
{
d->doMousePress((QGraphicsSceneMouseEvent*)e);
}
else if(e->type() == QEvent::GraphicsSceneMouseRelease)
{
d->doMouseRelease((QGraphicsSceneMouseEvent*)e);
}
else if(e->type() == QEvent::GraphicsSceneMouseDoubleClick)
{
d->doMouseDbClick((QGraphicsSceneMouseEvent*)e);
}
else if(e->type() == QEvent::GraphicsSceneWheel)
{
d->doMouseWheel((QGraphicsSceneWheelEvent*)e);
}
return __super::event(e);
}
/* \internal
Event handler reimplementation. Calls doCleanup() when the timer
fires.
*/
bool QSharedDoubleBufferCleaner::event( QEvent *e )
{
if ( e->type() != QEvent::Timer )
return FALSE;
QTimerEvent *event = (QTimerEvent *) e;
if ( event->timerId() == timer_id ) {
doCleanup();
stop();
}
#ifdef QT_CHECK_STATE
else {
qWarning( "QSharedDoubleBufferCleaner::event: invalid timer event received." );
return FALSE;
}
#endif // QT_CHECK_STATE
return TRUE;
}
bool TorcCECDevice::event(QEvent *Event)
{
if (Event->type() == TorcEvent::TorcEventType)
{
// close the device when suspending etc and restart on wake
TorcEvent* torcevent = dynamic_cast<TorcEvent*>(Event);
if (torcevent)
{
int event = torcevent->GetEvent();
switch (event)
{
case Torc::Suspending:
case Torc::ShuttingDown:
case Torc::Hibernating:
case Torc::Restarting:
if (m_priv)
m_priv->Close(false, true);
return true;
case Torc::WokeUp:
if (m_priv)
m_priv->Open();
return true;
default:
break;
}
}
}
else if (Event->type() == QEvent::Timer && m_retryTimer)
{
QTimerEvent *timerevent = static_cast<QTimerEvent*>(Event);
if (timerevent && (timerevent->timerId() == m_retryTimer))
{
killTimer(m_retryTimer);
m_retryTimer = 0;
Open();
return true;
}
}
return QObject::event(Event);
}
bool QSGWindowsRenderLoop::event(QEvent *event)
{
switch (event->type()) {
case QEvent::Timer: {
QTimerEvent *te = static_cast<QTimerEvent *>(event);
if (te->timerId() == m_animationTimer) {
RLDEBUG("event : animation tick while nothing is showing");
m_animationDriver->advance();
} else if (te->timerId() == m_updateTimer) {
RLDEBUG("event : update");
killTimer(m_updateTimer);
m_updateTimer = 0;
render();
}
return true; }
default:
break;
}
return QObject::event(event);
}
bool QSpotifySession::event(QEvent *e)
{
if (e->type() == NotifyMainThreadEventType) {
qDebug() << "Process spotify event";
processSpotifyEvents();
e->accept();
return true;
} else if (e->type() == QEvent::Timer) {
qDebug() << "Timer, start spotify events";
QTimerEvent *te = static_cast<QTimerEvent *>(e);
if (te->timerId() == m_timerID) {
processSpotifyEvents();
e->accept();
return true;
}
} else if (e->type() == ConnectionErrorEventType) {
qDebug() << "Connection error";
QSpotifyConnectionErrorEvent *ev = static_cast<QSpotifyConnectionErrorEvent *>(e);
setConnectionError(ConnectionError(ev->error()), QString::fromUtf8(sp_error_message(ev->error())));
e->accept();
return true;
} else if (e->type() == MetaDataEventType) {
qDebug() << "Meta data";
emit metadataUpdated();
e->accept();
return true;
} else if (e->type() == EndOfTrackEventType) {
qDebug() << "End track";
m_trackChangedAutomatically = true;
playNext();
e->accept();
return true;
} else if (e->type() == StopEventType) {
qDebug() << "Stop";
stop();
e->accept();
return true;
} else if (e->type() == TrackProgressEventType) {
qDebug() << "Track progress";
if(!m_isPlaying) {
e->accept();
return true;
}
// Track progressed
QSpotifyTrackProgressEvent *ev = static_cast<QSpotifyTrackProgressEvent *>(e);
int currentTrackPositionDelta = ev->delta();
if (m_previousTrackRemaining > 0) {
// We're still playing the previous back from our buffer
int fromPreviousTrack = qMin(currentTrackPositionDelta, m_previousTrackRemaining);
currentTrackPositionDelta -= fromPreviousTrack;
m_previousTrackRemaining -= fromPreviousTrack;
}
m_currentTrackPosition += currentTrackPositionDelta;
m_currentTrackPlayedDuration += currentTrackPositionDelta;
emit currentTrackPositionChanged();
e->accept();
return true;
} else if (e->type() == SendImageRequestEventType) {
qDebug() << "Send image request";
QSpotifyRequestImageEvent *ev = static_cast<QSpotifyRequestImageEvent *>(e);
sendImageRequest(ev->imageId());
e->accept();
return true;
} else if (e->type() == ReceiveImageRequestEventType) {
qDebug() << "Receive image request";
QSpotifyReceiveImageEvent *ev = static_cast<QSpotifyReceiveImageEvent *>(e);
receiveImageResponse(ev->image());
e->accept();
return true;
} else if (e->type() == PlayTokenLostEventType) {
qDebug() << "Play token lost";
emit playTokenLost();
pause();
e->accept();
return true;
} else if (e->type() == LoggedInEventType) {
qDebug() << "Logged in 1";
onLoggedIn();
e->accept();
return true;
} else if (e->type() == LoggedOutEventType) {
qDebug() << "Logged out";
onLoggedOut();
e->accept();
return true;
} else if (e->type() == OfflineErrorEventType) {
qDebug() << "Offline error";
QSpotifyOfflineErrorEvent *ev = static_cast<QSpotifyOfflineErrorEvent *>(e);
m_offlineErrorMessage = QString::fromUtf8(sp_error_message(ev->error()));
emit offlineErrorMessageChanged();
e->accept();
return true;
} else if (e->type() == ScrobbleLoginErrorEventType) {
qDebug() << "Scrobble login error";
m_lfmLoggedIn = false;
emit lfmLoggedInChanged();
emit lfmLoginError();
e->accept();
return true;
} else if (e->type() == ConnectionStateUpdateEventType) {
qDebug() << "Connectionstate update event";
setConnectionStatus(ConnectionStatus(sp_session_connectionstate(m_sp_session)));
if (m_offlineMode && m_connectionStatus == LoggedIn) {
setConnectionRules(m_connectionRules | AllowNetwork);
setConnectionRules(m_connectionRules & ~AllowNetwork);
}
e->accept();
return true;
}
return QObject::event(e);
}
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);
}
bool DragProxy::eventFilter(QObject* obj, QEvent* event)
{
QEvent::Type eventType = event->type();
if (eventType == QEvent::MouseMove)
{
QMouseEvent* mouseEvent = (QMouseEvent*)event;
QPoint curPosLocal = mouseEvent->pos();
qDebug() << curPosLocal << "curPosLocal";
DragProxy::WidgetRegion regionType = HitTest(curPosLocal);
// QPoint curPosGlobal = m_proxyWidget->mapToGlobal(curPosLocal);
QPoint curPosGlobal = mouseEvent->globalPos();
qDebug() << curPosGlobal << "curPosGlobal";
if (!m_mousePressed) // 鼠标未按下
{
switch (regionType)
{
case Top:
case Bottom:
m_proxyWidget->setCursor(Qt::SizeVerCursor);
break;
case TopRight:
case LeftBottom:
m_proxyWidget->setCursor(Qt::SizeBDiagCursor);
break;
case Right:
case Left:
m_proxyWidget->setCursor(Qt::SizeHorCursor);
break;
case RightBottom:
case LeftTop:
m_proxyWidget->setCursor(Qt::SizeFDiagCursor);
break;
default:
m_proxyWidget->setCursor(Qt::ArrowCursor);
break;
}
StartCursorTimer();
}
else // 鼠标已按下
{
QRect geo = m_proxyWidget->geometry();
if (m_regionPressed == Inner)
{
//m_proxyWidget->move(m_originGeo.topLeft() + curPosGlobal - m_originPosGlobal);
// m_proxyWidget->move(curPosGlobal-(m_originPosGlobal - m_originGeo.topLeft()));
}
else if (m_regionPressed == Top)
{
m_proxyWidget->setCursor(Qt::SizeVerCursor);
int dY = curPosGlobal.y() - m_originPosGlobal.y();
UpdateGeometry(m_originGeo.x(), m_originGeo.y() + dY, m_originGeo.width(), m_originGeo.height() - dY);
}
else if (m_regionPressed == TopRight)
{
m_proxyWidget->setCursor(Qt::SizeBDiagCursor);
QPoint dXY = curPosGlobal - m_originPosGlobal;
UpdateGeometry(m_originGeo.x(), m_originGeo.y() + dXY.y(), m_originGeo.width() + dXY.x(), m_originGeo.height() - dXY.y());
}
else if (m_regionPressed == Right)
{
m_proxyWidget->setCursor(Qt::SizeHorCursor);
int dX = curPosGlobal.x() - m_originPosGlobal.x();
UpdateGeometry(m_originGeo.x(), m_originGeo.y(), m_originGeo.width() + dX, m_originGeo.height());
}
else if (m_regionPressed == RightBottom)
{
m_proxyWidget->setCursor(Qt::SizeFDiagCursor);
QPoint dXY = curPosGlobal - m_originPosGlobal;
UpdateGeometry(m_originGeo.x(), m_originGeo.y(), m_originGeo.width() + dXY.x(), m_originGeo.height() + dXY.y());
}
else if (m_regionPressed == Bottom)
{
m_proxyWidget->setCursor(Qt::SizeVerCursor);
int dY = curPosGlobal.y() - m_originPosGlobal.y();
UpdateGeometry(m_originGeo.x(), m_originGeo.y(), m_originGeo.width(), m_originGeo.height() + dY);
}
else if (m_regionPressed == LeftBottom)
{
m_proxyWidget->setCursor(Qt::SizeBDiagCursor);
QPoint dXY = curPosGlobal - m_originPosGlobal;
UpdateGeometry(m_originGeo.x() + dXY.x(), m_originGeo.y(), m_originGeo.width() - dXY.x(), m_originGeo.height() + dXY.y());
}
else if (m_regionPressed == Left)
{
m_proxyWidget->setCursor(Qt::SizeHorCursor);
int dX = curPosGlobal.x() - m_originPosGlobal.x();
UpdateGeometry(m_originGeo.x() + dX, m_originGeo.y(), m_originGeo.width() - dX, m_originGeo.height());
}
else if (m_regionPressed == LeftTop)
{
m_proxyWidget->setCursor(Qt::SizeFDiagCursor);
QPoint dXY = curPosGlobal - m_originPosGlobal;
UpdateGeometry(m_originGeo.x() + dXY.x(), m_originGeo.y() + dXY.y(), m_originGeo.width() - dXY.x(), m_originGeo.height() - dXY.y());
}
}
}
else if (eventType == QEvent::MouseButtonPress)
{
QMouseEvent* mouseEvent = (QMouseEvent*)event;
if (mouseEvent->button() == Qt::LeftButton)
{
m_mousePressed = true;
QPoint curPos = mouseEvent->pos();
m_regionPressed = HitTest(curPos);
//m_originPosGlobal = m_proxyWidget->mapToGlobal(curPos);
m_originPosGlobal = mouseEvent->globalPos();
qDebug() << m_originPosGlobal << "zj";
m_originGeo = m_proxyWidget->frameGeometry();
StopCursorTimer();
}
}
else if (eventType == QEvent::MouseButtonRelease)
{
m_mousePressed = false;
m_regionPressed = Unknown;
m_proxyWidget->setCursor(Qt::ArrowCursor);
}
else if (eventType == QEvent::Resize)
{
MakeRegions();
}
else if (eventType == QEvent::Leave)
{
m_proxyWidget->setCursor(Qt::ArrowCursor);
StopCursorTimer();
}
else if (eventType == QEvent::Timer)
{
QTimerEvent* timerEvent = (QTimerEvent*)event;
if (timerEvent->timerId() == m_cursorTimerId)
{
if (m_regions[Inner].contains(m_proxyWidget->mapFromGlobal(QCursor::pos())))
{
m_proxyWidget->setCursor(Qt::ArrowCursor);
StopCursorTimer();
}
}
}
return QObject::eventFilter(obj, event);
}
bool QClipboard::event(QEvent *e)
{
if (e->type() == QEvent::Timer) {
QTimerEvent *te = (QTimerEvent *) e;
if (waiting_for_data) // should never happen
return false;
if (te->timerId() == timer_id) {
killTimer(timer_id);
timer_id = 0;
timer_event_clear = true;
if (selection_watcher) // clear selection
selectionData()->clear();
if (clipboard_watcher) // clear clipboard
clipboardData()->clear();
timer_event_clear = false;
return true;
} else if (te->timerId() == pending_timer_id) {
// I hate klipper
killTimer(pending_timer_id);
pending_timer_id = 0;
if (pending_clipboard_changed) {
pending_clipboard_changed = false;
clipboardData()->clear();
emitChanged(QClipboard::Clipboard);
}
if (pending_selection_changed) {
pending_selection_changed = false;
selectionData()->clear();
emitChanged(QClipboard::Selection);
}
return true;
} else if (te->timerId() == incr_timer_id) {
killTimer(incr_timer_id);
incr_timer_id = 0;
qt_xclb_incr_timeout();
return true;
} else {
return QObject::event(e);
}
} else if (e->type() != QEvent::Clipboard) {
return QObject::event(e);
}
XEvent *xevent = (XEvent *)(((QClipboardEvent *)e)->data());
Display *dpy = X11->display;
if (!xevent) {
// That means application exits and we need to give clipboard
// content to the clipboard manager.
// First we check if there is a clipboard manager.
if (XGetSelectionOwner(X11->display, ATOM(CLIPBOARD_MANAGER)) == XNone
|| !owner)
return true;
Window ownerId = owner->internalWinId();
Q_ASSERT(ownerId);
// we delete the property so the manager saves all TARGETS.
XDeleteProperty(X11->display, ownerId, ATOM(_QT_SELECTION));
XConvertSelection(X11->display, ATOM(CLIPBOARD_MANAGER), ATOM(SAVE_TARGETS),
ATOM(_QT_SELECTION), ownerId, X11->time);
XSync(dpy, false);
XEvent event;
// waiting until the clipboard manager fetches the content.
if (!X11->clipboardWaitForEvent(ownerId, SelectionNotify, &event, 10000)) {
qWarning("QClipboard: Unable to receive an event from the "
"clipboard manager in a reasonable time");
}
return true;
}
switch (xevent->type) {
case SelectionClear:
// new selection owner
if (xevent->xselectionclear.selection == XA_PRIMARY) {
QClipboardData *d = selectionData();
// ignore the event if it was generated before we gained selection ownership
if (d->timestamp != CurrentTime && xevent->xselectionclear.time <= d->timestamp)
break;
DEBUG("QClipboard: new selection owner 0x%lx at time %lx (ours %lx)",
XGetSelectionOwner(dpy, XA_PRIMARY),
xevent->xselectionclear.time, d->timestamp);
if (! waiting_for_data) {
d->clear();
emitChanged(QClipboard::Selection);
} else {
pending_selection_changed = true;
if (! pending_timer_id)
pending_timer_id = QApplication::clipboard()->startTimer(0);
}
} else if (xevent->xselectionclear.selection == ATOM(CLIPBOARD)) {
QClipboardData *d = clipboardData();
// ignore the event if it was generated before we gained selection ownership
if (d->timestamp != CurrentTime && xevent->xselectionclear.time <= d->timestamp)
break;
DEBUG("QClipboard: new clipboard owner 0x%lx at time %lx (%lx)",
XGetSelectionOwner(dpy, ATOM(CLIPBOARD)),
xevent->xselectionclear.time, d->timestamp);
if (! waiting_for_data) {
d->clear();
emitChanged(QClipboard::Clipboard);
} else {
pending_clipboard_changed = true;
if (! pending_timer_id)
pending_timer_id = QApplication::clipboard()->startTimer(0);
}
} else {
qWarning("QClipboard: Unknown SelectionClear event received");
return false;
}
break;
case SelectionNotify:
/*
Something has delivered data to us, but this was not caught
by QClipboardWatcher::getDataInFormat()
Just skip the event to prevent Bad Things (tm) from
happening later on...
*/
break;
case SelectionRequest:
{
// someone wants our data
XSelectionRequestEvent *req = &xevent->xselectionrequest;
if (requestor && req->requestor == requestor->internalWinId())
break;
XEvent event;
event.xselection.type = SelectionNotify;
event.xselection.display = req->display;
event.xselection.requestor = req->requestor;
event.xselection.selection = req->selection;
event.xselection.target = req->target;
event.xselection.property = XNone;
event.xselection.time = req->time;
DEBUG("QClipboard: SelectionRequest from %lx\n"
" selection 0x%lx (%s) target 0x%lx (%s)",
req->requestor,
req->selection,
X11->xdndAtomToString(req->selection).data(),
req->target,
X11->xdndAtomToString(req->target).data());
QClipboardData *d;
if (req->selection == XA_PRIMARY) {
d = selectionData();
} else if (req->selection == ATOM(CLIPBOARD)) {
d = clipboardData();
} else {
qWarning("QClipboard: Unknown selection '%lx'", req->selection);
XSendEvent(dpy, req->requestor, False, NoEventMask, &event);
break;
}
if (! d->source()) {
qWarning("QClipboard: Cannot transfer data, no data available");
XSendEvent(dpy, req->requestor, False, NoEventMask, &event);
break;
}
DEBUG("QClipboard: SelectionRequest at time %lx (ours %lx)",
req->time, d->timestamp);
if (d->timestamp == CurrentTime // we don't own the selection anymore
|| (req->time != CurrentTime && req->time < d->timestamp)) {
DEBUG("QClipboard: SelectionRequest too old");
XSendEvent(dpy, req->requestor, False, NoEventMask, &event);
break;
}
Atom xa_targets = ATOM(TARGETS);
Atom xa_multiple = ATOM(MULTIPLE);
Atom xa_timestamp = ATOM(TIMESTAMP);
struct AtomPair { Atom target; Atom property; } *multi = 0;
Atom multi_type = XNone;
int multi_format = 0;
int nmulti = 0;
int imulti = -1;
bool multi_writeback = false;
if (req->target == xa_multiple) {
QByteArray multi_data;
if (req->property == XNone
|| !X11->clipboardReadProperty(req->requestor, req->property, false, &multi_data,
0, &multi_type, &multi_format)
|| multi_format != 32) {
// MULTIPLE property not formatted correctly
XSendEvent(dpy, req->requestor, False, NoEventMask, &event);
break;
}
nmulti = multi_data.size()/sizeof(*multi);
multi = new AtomPair[nmulti];
memcpy(multi,multi_data.data(),multi_data.size());
imulti = 0;
}
for (; imulti < nmulti; ++imulti) {
Atom target;
Atom property;
if (multi) {
target = multi[imulti].target;
property = multi[imulti].property;
} else {
target = req->target;
property = req->property;
if (property == XNone) // obsolete client
property = target;
}
Atom ret = XNone;
if (target == XNone || property == XNone) {
;
} else if (target == xa_timestamp) {
if (d->timestamp != CurrentTime) {
XChangeProperty(dpy, req->requestor, property, XA_INTEGER, 32,
PropModeReplace, (uchar *) &d->timestamp, 1);
ret = property;
} else {
qWarning("QClipboard: Invalid data timestamp");
}
} else if (target == xa_targets) {
ret = send_targets_selection(d, req->requestor, property);
} else {
ret = send_selection(d, target, req->requestor, property);
}
if (nmulti > 0) {
if (ret == XNone) {
multi[imulti].property = XNone;
multi_writeback = true;
}
} else {
event.xselection.property = ret;
break;
}
}
if (nmulti > 0) {
if (multi_writeback) {
// according to ICCCM 2.6.2 says to put None back
// into the original property on the requestor window
XChangeProperty(dpy, req->requestor, req->property, multi_type, 32,
PropModeReplace, (uchar *) multi, nmulti * 2);
}
delete [] multi;
event.xselection.property = req->property;
}
// send selection notify to requestor
XSendEvent(dpy, req->requestor, False, NoEventMask, &event);
DEBUG("QClipboard: SelectionNotify to 0x%lx\n"
" property 0x%lx (%s)",
req->requestor, event.xselection.property,
X11->xdndAtomToString(event.xselection.property).data());
}
break;
}
return true;
}
bool UIDirect3D9Window::event(QEvent *Event)
{
int type = Event->type();
if (type == QEvent::KeyPress || type == QEvent::KeyRelease)
{
QKeyEvent *keyevent = static_cast<QKeyEvent*>(Event);
if (keyevent)
{
keyevent->accept();
UIWidget* focuswidget = m_theme ? m_theme->GetFocusWidget() : NULL;
if (focuswidget && focuswidget->Type() == UITextEditor::kUITextEditorType)
{
UITextEditor *texteditor = static_cast<UITextEditor*>(focuswidget);
if (texteditor && texteditor->HandleTextInput(keyevent))
return true;
}
int action = GetActionFromKey(keyevent);
if (action && focuswidget)
{
if (focuswidget->HandleAction(action))
return true;
}
switch (action)
{
case Torc::Escape:
close();
return true;
case Torc::Suspend:
gPower->Suspend();
return true;
case Torc::DisableStudioLevels:
SetStudioLevels(false);
break;
case Torc::EnableStudioLevels:
SetStudioLevels(true);
break;
case Torc::ToggleStudioLevels:
SetStudioLevels(!m_studioLevels);
break;
default: break;
}
}
}
else if (type == QEvent::Timer)
{
QTimerEvent *timerevent = dynamic_cast<QTimerEvent*>(Event);
if (timerevent && timerevent->timerId() == m_mainTimer)
{
MainLoop();
return true;
}
}
else if (type == QEvent::Paint)
{
return true;
}
return QWidget::event(Event);
}
