explicit QHttpConnectionPrivate(QHttpConnection* q) : HttpParser(HTTP_REQUEST), q_ptr(q) {
QObject::connect(q_func(), &QHttpConnection::disconnected, [this](){
// if socket drops and http_parser can not call messageComplete, dispatch the ilastRequest
onDispatchRequest();
isocket.release();
if ( ilastRequest )
ilastRequest->deleteLater();
if ( ilastResponse )
ilastResponse->deleteLater();
q_func()->deleteLater();
});
QHTTP_LINE_DEEPLOG
}
void QGraphicsSceneIndexPrivate::init()
{
if (!scene)
return;
QObject::connect(scene, SIGNAL(sceneRectChanged(QRectF)),
q_func(), SLOT(updateSceneRect(QRectF)));
}
void QextSerialPortPrivate::setDataBits(DataBitsType dataBits, bool update)
{
switch(dataBits) {
case DATA_5:
if (Settings.StopBits==STOP_2) {
QESP_WARNING("QextSerialPort: 5 Data bits cannot be used with 2 stop bits.");
}
else {
Settings.DataBits=dataBits;
settingsDirtyFlags |= DFE_DataBits;
}
break;
case DATA_6:
#ifdef Q_OS_WIN
if (Settings.StopBits==STOP_1_5) {
QESP_WARNING("QextSerialPort: 6 Data bits cannot be used with 1.5 stop bits.");
}
else
#endif
{
Settings.DataBits=dataBits;
settingsDirtyFlags |= DFE_DataBits;
}
break;
case DATA_7:
#ifdef Q_OS_WIN
if (Settings.StopBits==STOP_1_5) {
QESP_WARNING("QextSerialPort: 7 Data bits cannot be used with 1.5 stop bits.");
}
else
#endif
{
Settings.DataBits=dataBits;
settingsDirtyFlags |= DFE_DataBits;
}
break;
case DATA_8:
#ifdef Q_OS_WIN
if (Settings.StopBits==STOP_1_5) {
QESP_WARNING("QextSerialPort: 8 Data bits cannot be used with 1.5 stop bits.");
}
else
#endif
{
Settings.DataBits=dataBits;
settingsDirtyFlags |= DFE_DataBits;
}
break;
default:
QESP_WARNING()<<"QextSerialPort does not support Data bits:"<<dataBits;
}
if (update && q_func()->isOpen())
updatePortSettings();
}
QModbusResponse QModbusServerPrivate::processWriteMultipleRegistersRequest(
const QModbusRequest &request)
{
CHECK_SIZE_LESS_THAN(request);
quint16 address, numberOfRegisters;
quint8 byteCount;
request.decodeData(&address, &numberOfRegisters, &byteCount);
// byte count does not match number of data bytes following or register count
if ((byteCount != (request.dataSize() - 5 )) || (byteCount != (numberOfRegisters * 2))) {
return QModbusExceptionResponse(request.functionCode(),
QModbusExceptionResponse::IllegalDataValue);
}
if ((numberOfRegisters < 0x0001) || (numberOfRegisters > 0x007B)) {
return QModbusExceptionResponse(request.functionCode(),
QModbusExceptionResponse::IllegalDataValue);
}
// Get the requested range out of the registers.
QModbusDataUnit registers(QModbusDataUnit::HoldingRegisters, address, numberOfRegisters);
if (!q_func()->data(®isters)) {
return QModbusExceptionResponse(request.functionCode(),
QModbusExceptionResponse::IllegalDataAddress);
}
const QByteArray pduData = request.data().remove(0,5);
QDataStream stream(pduData);
QVector<quint16> values;
quint16 tmp;
for (int i = 0; i < numberOfRegisters; i++) {
stream >> tmp;
values.append(tmp);
}
registers.setValues(values);
if (!q_func()->setData(registers)) {
return QModbusExceptionResponse(request.functionCode(),
QModbusExceptionResponse::ServerDeviceFailure);
}
return QModbusResponse(request.functionCode(), address, numberOfRegisters);
}
void QMediaImageViewerPrivate::_q_mediaStatusChanged(QMediaImageViewer::MediaStatus status)
{
switch (status) {
case QMediaImageViewer::NoMedia:
case QMediaImageViewer::LoadingMedia:
emit q_func()->mediaStatusChanged(status);
break;
case QMediaImageViewer::LoadedMedia:
if (state == QMediaImageViewer::PlayingState) {
time.start();
timer.start(qMax(0, timeout), q_func());
q_func()->addPropertyWatch("elapsedTime");
}
emit q_func()->mediaStatusChanged(status);
emit q_func()->elapsedTimeChanged(0);
break;
case QMediaImageViewer::InvalidMedia:
emit q_func()->mediaStatusChanged(status);
if (state == QMediaImageViewer::PlayingState) {
playlist->next();
if (playlist->currentIndex() < 0)
emit q_func()->stateChanged(state = QMediaImageViewer::StoppedState);
}
break;
}
}
void QGalleryTrackerResultSetPrivate::syncUpdate(
const int rIndex, const int rCount, const int iIndex, const int iCount)
{
bool itemChanged = false;
if (currentIndex >= iCache.cutoff && currentIndex < iCache.cutoff + iCount) {
currentRow = iCache.values.constBegin() + (currentIndex * tableWidth);
itemChanged = true;
}
rCache.offset = rIndex + rCount;
iCache.cutoff = iIndex + iCount;
emit q_func()->metaDataChanged(iIndex, iCount, propertyKeys);
if (itemChanged)
emit q_func()->currentItemChanged();
}
void QMediaImageViewerPrivate::_q_playlistMediaChanged(const QMediaContent &content)
{
media = content;
pauseTime = 0;
viewerControl->showMedia(media);
emit q_func()->mediaChanged(media);
}
void BLocalDocumentDriverPrivate::saveOperationFinished()
{
SaveResultFutureWatcher *watcher = dynamic_cast<SaveResultFutureWatcher *>(sender());
if (!watcher)
return;
SaveResult res = watcher->result();
delete watcher;
q_func()->emitSavingFinished(res.operation, res.success);
}
void BLocalDocumentDriverPrivate::loadOperationFinished()
{
LoadResultFutureWatcher *watcher = dynamic_cast<LoadResultFutureWatcher *>(sender());
if (!watcher)
return;
LoadResult res = watcher->result();
delete watcher;
q_func()->emitLoadingFinished(res.operation, res.success, res.text);
}
bool QScriptDebuggerBackendPrivate::event(QEvent *e)
{
if (e->type() == QEvent::User+1) {
QScriptDebuggerEventEvent *de = static_cast<QScriptDebuggerEventEvent*>(e);
q_func()->event(de->event());
return true;
}
return false;
}
void PlasmaShellSurfaceInterface::Private::panelAutoHideShowCallback(wl_client *client, wl_resource *resource)
{
auto s = cast<Private>(resource);
Q_ASSERT(client == *s->client);
if (s->m_role != Role::Panel || s->m_panelBehavior != PanelBehavior::AutoHide) {
wl_resource_post_error(s->resource, ORG_KDE_PLASMA_SURFACE_ERROR_PANEL_NOT_AUTO_HIDE, "Not an auto hide panel");
return;
}
emit s->q_func()->panelAutoHideShowRequested();
}
QModbusResponse QModbusServerPrivate::processMaskWriteRegisterRequest(const QModbusRequest &request)
{
CHECK_SIZE_EQUALS(request);
quint16 address, andMask, orMask;
request.decodeData(&address, &andMask, &orMask);
quint16 reg;
if (!q_func()->data(QModbusDataUnit::HoldingRegisters, address, ®)) {
return QModbusExceptionResponse(request.functionCode(),
QModbusExceptionResponse::IllegalDataAddress);
}
const quint16 result = (reg & andMask) | (orMask & (~ andMask));
if (!q_func()->setData(QModbusDataUnit::HoldingRegisters, address, result)) {
return QModbusExceptionResponse(request.functionCode(),
QModbusExceptionResponse::ServerDeviceFailure);
}
return QModbusResponse(request.functionCode(), request.data());
}
void QGalleryTrackerResultSetPrivate::insertItems(
const int rIndex, const int iIndex, const int count)
{
rCache.offset = rIndex;
iCache.cutoff = iIndex + count;
rowCount += count;
emit q_func()->itemsInserted(iIndex, count);
}
bool prepareDeviceResource() {
gc = XCreateGC(display, q_func().winId(), 0, 0);
if (!gc) {
available = false;
qCritical("Create GC failed!");
return false;
}
XSetBackground(display, gc, BlackPixel(display, DefaultScreen(display)));
return true;
}
void QKeySequenceWidgetPrivate::init(const QKeySequence keySeq, const QString noneStr)
{
Q_Q(QKeySequenceWidget);
Q_UNUSED(q);
layout = new QHBoxLayout(q_func());
layout->setMargin(0);
layout->setSpacing(1);
clearButton = new QToolButton(q_func());
clearButton->setText("x");
layout->addWidget(clearButton);
shortcutButton = new QShortcutButton(this, q_func());
if (noneStr.isNull() == true)
{
noneSequenceText = "...";
}
else
{
noneSequenceText = noneStr;
}
q_ptr->clearKeySequence();
currentSequence = keySeq;
shortcutButton->setFocusPolicy(Qt::StrongFocus);
layout->addWidget(shortcutButton);
showClearButton = QKeySequenceWidget::ShowRight;
clearButton->setIcon(QIcon::fromTheme("dialog-cancel", QIcon(":/icons/dialog-cancel.png")));
// unfocused clear button afyer created (small hack)
clearButton->setFocusPolicy(Qt::NoFocus);
// update ui
updateDisplayShortcut();
updateView();
}
inline bool QFilePrivate::ensureFlushed() const
{
// This function ensures that the write buffer has been flushed (const
// because certain const functions need to call it.
if (lastWasWrite) {
const_cast<QFilePrivate *>(this)->lastWasWrite = false;
if (!const_cast<QFile *>(q_func())->flush())
return false;
}
return true;
}
QModbusResponse QModbusServerPrivate::processGetCommEventCounterRequest(const QModbusRequest &request)
{
CHECK_SIZE_EQUALS(request);
const QVariant tmp = q_func()->value(QModbusServer::DeviceBusy);
if (tmp.isNull() || (!tmp.isValid())) {
return QModbusExceptionResponse(request.functionCode(),
QModbusExceptionResponse::ServerDeviceFailure);
}
const quint16 deviceBusy = tmp.value<quint16>();
return QModbusResponse(request.functionCode(), deviceBusy, m_counters[Counter::CommEvent]);
}
bool BTranslatorPrivate::install()
{
if (installed)
return true;
if (!loaded && !q_func()->load())
return false;
foreach (QTranslator *t, translators)
QCoreApplication::installTranslator(t);
installed = true;
return true;
}
void QextSerialPortPrivate::setPortSettings(const PortSettings &settings, bool update)
{
setBaudRate(settings.BaudRate, false);
setDataBits(settings.DataBits, false);
setStopBits(settings.StopBits, false);
setParity(settings.Parity, false);
setFlowControl(settings.FlowControl, false);
setTimeout(settings.Timeout_Millisec, false);
settingsDirtyFlags = DFE_ALL;
if (update && q_func()->isOpen())
updatePortSettings();
}
/*!
\internal
*/
bool QFileDevicePrivate::putCharHelper(char c)
{
#ifdef QT_NO_QOBJECT
return QIODevicePrivate::putCharHelper(c);
#else
// Cutoff for code that doesn't only touch the buffer.
int writeBufferSize = writeBuffer.size();
if ((openMode & QIODevice::Unbuffered) || writeBufferSize + 1 >= QFILE_WRITEBUFFER_SIZE
#ifdef Q_OS_WIN
|| ((openMode & QIODevice::Text) && c == '\n' && writeBufferSize + 2 >= QFILE_WRITEBUFFER_SIZE)
#endif
) {
return QIODevicePrivate::putCharHelper(c);
}
if (!(openMode & QIODevice::WriteOnly)) {
if (openMode == QIODevice::NotOpen)
qWarning("QIODevice::putChar: Closed device");
else
qWarning("QIODevice::putChar: ReadOnly device");
return false;
}
// Make sure the device is positioned correctly.
const bool sequential = isSequential();
if (pos != devicePos && !sequential && !q_func()->seek(pos))
return false;
lastWasWrite = true;
int len = 1;
#ifdef Q_OS_WIN
if ((openMode & QIODevice::Text) && c == '\n') {
++len;
*writeBuffer.reserve(1) = '\r';
}
#endif
// Write to buffer.
*writeBuffer.reserve(1) = c;
if (!sequential) {
pos += len;
devicePos += len;
if (!buffer.isEmpty())
buffer.skip(len);
}
return true;
#endif
}
inline void updateDefaultSize()
{
QRectF bounds;
if (elemId.isEmpty()) {
bounds = QRectF(QPointF(0, 0), renderer->defaultSize());
} else {
bounds = renderer->boundsOnElement(elemId);
}
if (boundingRect.size() != bounds.size()) {
q_func()->prepareGeometryChange();
boundingRect.setSize(bounds.size());
}
}
QQmlPropertyCache *QJSEnginePrivate::createCache(const QMetaObject *mo)
{
if (!mo->superClass()) {
QQmlPropertyCache *rv = new QQmlPropertyCache(QV8Engine::getV4(q_func()), mo);
propertyCache.insert(mo, rv);
return rv;
} else {
QQmlPropertyCache *super = cache(mo->superClass());
QQmlPropertyCache *rv = super->copyAndAppend(mo);
propertyCache.insert(mo, rv);
return rv;
}
}
/*!
* \internal
*
* Called by _q_setParentHelper on the main thread.
*/
void QNodePrivate::_q_removeChild(QNode *childNode)
{
Q_ASSERT(childNode);
Q_ASSERT_X(childNode->parent() == q_func(), Q_FUNC_INFO, "not a child of this node");
QNodePrivate::get(childNode)->m_parentId = QNodeId();
// We notify the backend that we lost a child
if (m_changeArbiter != nullptr) {
const auto change = QPropertyNodeRemovedChangePtr::create(m_id, childNode);
change->setPropertyName("children");
notifyObservers(change);
}
}
QList<QtHistoryState*> QtStatePrivate::historyStates() const
{
QList<QtHistoryState*> result;
QList<QObject*>::const_iterator it;
#ifdef QT_STATEMACHINE_SOLUTION
const QObjectList &children = q_func()->children();
#endif
for (it = children.constBegin(); it != children.constEnd(); ++it) {
QtHistoryState *h = qobject_cast<QtHistoryState*>(*it);
if (h)
result.append(h);
}
return result;
}
QList<QtStateAction*> QtActionStatePrivate::exitActions() const
{
QList<QtStateAction*> result;
QList<QObject*>::const_iterator it;
#ifdef QT_STATEMACHINE_SOLUTION
const QObjectList &children = q_func()->children();
#endif
for (it = children.constBegin(); it != children.constEnd(); ++it) {
QtStateAction *act = qobject_cast<QtStateAction*>(*it);
if (act && (QtStateActionPrivate::get(act)->when == QtStateActionPrivate::ExecuteOnExit))
result.append(act);
}
return result;
}
bool QDeclarativeGestureAreaPrivate::gestureEvent(QGestureEvent *event)
{
bool accept = true;
for (Bindings::Iterator it = bindings.begin(); it != bindings.end(); ++it) {
if ((gesture = event->gesture(it.key()))) {
QDeclarativeExpression *expr = it.value();
expr->evaluate();
if (expr->hasError())
qmlInfo(q_func()) << expr->error();
event->setAccepted(true); // XXX only if value returns true?
}
}
return accept;
}
QList<QtAbstractTransition*> QtStatePrivate::transitions() const
{
QList<QtAbstractTransition*> result;
QList<QObject*>::const_iterator it;
#ifdef QT_STATEMACHINE_SOLUTION
const QObjectList &children = q_func()->children();
#endif
for (it = children.constBegin(); it != children.constEnd(); ++it) {
QtAbstractTransition *t = qobject_cast<QtAbstractTransition*>(*it);
if (t)
result.append(t);
}
return result;
}
QMenu *QLabelPrivate::createStandardContextMenu(const QPoint &pos)
{
QString linkToCopy;
QPoint p;
if (control && isRichText) {
p = layoutPoint(pos);
linkToCopy = control->document()->documentLayout()->anchorAt(p);
}
if (linkToCopy.isEmpty() && !control)
return 0;
return control->createStandardContextMenu(p, q_func());
}
void createSocket(qintptr sokDesc, TBackend bend) {
isocket.ibackendType = bend;
if ( bend == ETcpSocket ) {
QTcpSocket* sok = new QTcpSocket( q_func() );
isocket.itcpSocket = sok;
sok->setSocketDescriptor(sokDesc);
QObject::connect(sok, &QTcpSocket::readyRead, [this](){
onReadyRead();
});
QObject::connect(sok, &QTcpSocket::bytesWritten, [this](){
if ( isocket.itcpSocket->bytesToWrite() == 0 && ilastResponse )
emit ilastResponse->allBytesWritten();
});
QObject::connect(sok, &QTcpSocket::disconnected,
q_func(), &QHttpConnection::disconnected,
Qt::QueuedConnection);
} else if ( bend == ELocalSocket ) {
QLocalSocket* sok = new QLocalSocket( q_func() );
isocket.ilocalSocket = sok;
sok->setSocketDescriptor(sokDesc);
QObject::connect(sok, &QLocalSocket::readyRead, [this](){
onReadyRead();
});
QObject::connect(sok, &QLocalSocket::bytesWritten, [this](){
if ( isocket.ilocalSocket->bytesToWrite() == 0 && ilastResponse )
emit ilastResponse->allBytesWritten();
});
QObject::connect(sok, &QLocalSocket::disconnected,
q_func(), &QHttpConnection::disconnected,
Qt::QueuedConnection);
}
}
void QScriptDebuggerLocalsWidgetPrivate::_q_onCompletionTaskFinished()
{
Q_Q(QScriptDebuggerLocalsWidget);
QScriptCompletionTaskInterface *task = 0;
task = qobject_cast<QScriptCompletionTaskInterface*>(q_func()->sender());
if (!completingEditor) {
task->deleteLater();
return;
}
if (task->resultCount() == 1) {
// do the completion right away
QString completion = task->resultAt(0);
completion.append(task->appendix());
QString tmp = completingEditor->text();
tmp.remove(task->position(), task->length());
tmp.insert(task->position(), completion);
completingEditor->setText(tmp);
completingEditor = 0;
} else if (task->resultCount() > 1) {
// popup completion
if (!completer) {
completer = new QCompleter(q);
completer->setCompletionMode(QCompleter::PopupCompletion);
completer->setCaseSensitivity(Qt::CaseSensitive);
completer->setWrapAround(false);
QObject::connect(completer, SIGNAL(activated(const QString &)), q, SLOT(_q_insertCompletion(const QString &)));
}
QStringListModel *model = qobject_cast<QStringListModel*>(completer->model());
if (!model) {
model = new QStringListModel(q);
completer->setModel(model);
}
QStringList strings;
for (int i = 0; i < task->resultCount(); ++i)
strings.append(task->resultAt(i));
model->setStringList(strings);
QString prefix = completingEditor->text().mid(task->position(), task->length());
completer->setCompletionPrefix(prefix);
completingEditor->setCompleter(completer);
// we want to handle the insertion ourselves
QObject::disconnect(completer, 0, completingEditor, 0);
completer->complete();
}
task->deleteLater();
}
