static void qSignalDumperCallback(QObject *caller, int method_index, void **argv)
{
Q_ASSERT(caller);
Q_ASSERT(argv);
Q_UNUSED(argv);
const QMetaObject *mo = caller->metaObject();
Q_ASSERT(mo);
QMetaMethod member = mo->method(method_index);
Q_ASSERT(member.signature());
if (QTest::ignoreClasses() && QTest::ignoreClasses()->contains(mo->className())) {
++QTest::ignoreLevel;
return;
}
QByteArray str;
str.fill(' ', QTest::iLevel++ * QTest::IndentSpacesCount);
str += "Signal: ";
str += mo->className();
str += '(';
QString objname = caller->objectName();
str += objname.toLocal8Bit();
if (!objname.isEmpty())
str += ' ';
str += QByteArray::number(quintptr(caller), 16);
str += ") ";
str += QTest::memberName(member);
str += " (";
QList<QByteArray> args = member.parameterTypes();
for (int i = 0; i < args.count(); ++i) {
const QByteArray &arg = args.at(i);
int typeId = QMetaType::type(args.at(i).constData());
if (arg.endsWith('*') || arg.endsWith('&')) {
str += '(';
str += arg;
str += ')';
if (arg.endsWith('&'))
str += '@';
quintptr addr = quintptr(*reinterpret_cast<void **>(argv[i + 1]));
str.append(QByteArray::number(addr, 16));
} else if (typeId != QMetaType::Void) {
str.append(arg)
.append('(')
.append(QVariant(typeId, argv[i + 1]).toString().toLocal8Bit())
.append(')');
}
str.append(", ");
}
if (str.endsWith(", "))
str.chop(2);
str.append(')');
qPrintMessage(str);
}
static void qSignalDumperCallbackSlot(QObject *caller, int method_index, void **argv)
{
Q_ASSERT(caller);
Q_ASSERT(argv);
Q_UNUSED(argv);
const QMetaObject *mo = caller->metaObject();
Q_ASSERT(mo);
QMetaMethod member = mo->method(method_index);
if (!member.signature())
return;
if (QTest::ignoreLevel ||
(QTest::ignoreClasses() && QTest::ignoreClasses()->contains(mo->className())))
return;
QByteArray str;
str.fill(' ', QTest::iLevel * QTest::IndentSpacesCount);
str += "Slot: ";
str += mo->className();
str += '(';
QString objname = caller->objectName();
str += objname.toLocal8Bit();
if (!objname.isEmpty())
str += ' ';
str += QByteArray::number(quintptr(caller), 16);
str += ") ";
str += member.signature();
qPrintMessage(str);
}
QModelIndex SidebarModel::parent(const QModelIndex &index) const
{
if(!index.isValid() || index.internalId()==0)
return QModelIndex();
return createIndex(index.internalId()-1, index.column(), quintptr(0));
}
int HistoryMenuModel::rowCount(const QModelIndex &parent) const
{
if (parent.column() > 0)
return 0;
if (!parent.isValid()) {
int folders = sourceModel()->rowCount();
int bumpedItems = bumpedRows();
if (bumpedItems <= MOVEDROWS
&& bumpedItems == sourceModel()->rowCount(sourceModel()->index(0, 0)))
--folders;
return bumpedItems + folders;
}
if (parent.internalId() == quintptr(-1)) {
if (parent.row() < bumpedRows())
return 0;
}
QModelIndex idx = mapToSource(parent);
int defaultCount = sourceModel()->rowCount(idx);
if (idx == sourceModel()->index(0, 0))
return defaultCount - bumpedRows();
return defaultCount;
}
bool QFontEngineQPF2::verifyHeader(const uchar *data, int size)
{
VERIFY(quintptr(data) % Q_ALIGNOF(Header) == 0);
VERIFY(size >= int(sizeof(Header)));
const Header *header = reinterpret_cast<const Header *>(data);
if (header->magic[0] != 'Q'
|| header->magic[1] != 'P'
|| header->magic[2] != 'F'
|| header->magic[3] != '2')
return false;
VERIFY(header->majorVersion <= CurrentMajorVersion);
const quint16 dataSize = qFromBigEndian<quint16>(header->dataSize);
VERIFY(size >= int(sizeof(Header)) + dataSize);
const uchar *tagPtr = data + sizeof(Header);
const uchar *tagEndPtr = tagPtr + dataSize;
while (tagPtr < tagEndPtr - 3) {
tagPtr = verifyTag(tagPtr, tagEndPtr);
VERIFY(tagPtr);
}
VERIFY(tagPtr <= tagEndPtr);
return true;
}
QVariant TableModel::data(const QModelIndex &index, int role) const {
if(!dataSafe)
return QVariant();
if(!index.isValid() || index.column() >= columnCount()) return QVariant();
if(role == ExpandedColumnIndexRole) {
if(!expandedColumns.contains(index.row()))
return quintptr(-1);
return expandedColumns.value(index.row());
}
if(role == EditorTypeRole) // used by TableCell to know to use the popup editor
return metadata.columnTypes[index.column()].toLower().contains("text") ? SJCellEditLongText : SJCellEditDefault;
if(role == FilterColumnRole)
return where.column;
if(role == FilterOperationRole)
return where.operation;
if(role == FilterValueRole)
return where.value;
if(role == ForeignKeyRole)
return QVariant::fromValue<ForeignKey>(metadata.foreignKeys[index.column()]);
return SqlModel::data(index, role);
}
Die::Die()
: m_hasValue(false),m_displayStatus(false),m_highlighted(true),m_base(1)
{
uint seed = quintptr(this) + QDateTime::currentDateTime().toMSecsSinceEpoch();
qsrand(seed);
}
Q_STATIC_TEMPLATE_FUNCTION inline void qt_memrotate90_tiled(const SRC *src, int w, int h,
int sstride,
DST *dest, int dstride)
{
sstride /= sizeof(SRC);
dstride /= sizeof(DST);
const int pack = sizeof(quint32) / sizeof(DST);
const int unaligned =
qMin(uint((quintptr(dest) & (sizeof(quint32)-1)) / sizeof(DST)), uint(h));
const int restX = w % tileSize;
const int restY = (h - unaligned) % tileSize;
const int unoptimizedY = restY % pack;
const int numTilesX = w / tileSize + (restX > 0);
const int numTilesY = (h - unaligned) / tileSize + (restY >= pack);
for (int tx = 0; tx < numTilesX; ++tx) {
const int startx = w - tx * tileSize - 1;
const int stopx = qMax(startx - tileSize, 0);
if (unaligned) {
for (int x = startx; x >= stopx; --x) {
DST *d = dest + (w - x - 1) * dstride;
for (int y = 0; y < unaligned; ++y) {
*d++ = qt_colorConvert<DST,SRC>(src[y * sstride + x], 0);
}
}
}
for (int ty = 0; ty < numTilesY; ++ty) {
const int starty = ty * tileSize + unaligned;
const int stopy = qMin(starty + tileSize, h - unoptimizedY);
for (int x = startx; x >= stopx; --x) {
quint32 *d = reinterpret_cast<quint32*>(dest + (w - x - 1) * dstride + starty);
for (int y = starty; y < stopy; y += pack) {
quint32 c = qt_colorConvert<DST,SRC>(src[y * sstride + x], 0);
for (int i = 1; i < pack; ++i) {
const int shift = (sizeof(int) * 8 / pack * i);
const DST color = qt_colorConvert<DST,SRC>(src[(y + i) * sstride + x], 0);
c |= color << shift;
}
*d++ = c;
}
}
}
if (unoptimizedY) {
const int starty = h - unoptimizedY;
for (int x = startx; x >= stopx; --x) {
DST *d = dest + (w - x - 1) * dstride + starty;
for (int y = starty; y < h; ++y) {
*d++ = qt_colorConvert<DST,SRC>(src[y * sstride + x], 0);
}
}
}
}
}
QString QHelpGlobal::uniquifyConnectionName(const QString &name, void *pointer)
{
static QMutex mutex;
QMutexLocker locker(&mutex);
static QHash<QString,quint16> idHash;
return QString::fromLatin1("%1-%2-%3").
arg(name).arg(quintptr(pointer)).arg(++idHash[name]);
}
QEventDispatcherWin32Private::~QEventDispatcherWin32Private()
{
if (internalHwnd)
DestroyWindow(internalHwnd);
QString className = QLatin1String("QEventDispatcherWin32_Internal_Widget")
+ QString::number(quintptr(qt_internal_proc));
UnregisterClass((wchar_t*)className.utf16(), qWinAppInst());
}
void ModuleProperties::init(QScriptValue objectWithProperties, const void *ptr,
const QString &type)
{
QScriptEngine * const engine = objectWithProperties.engine();
objectWithProperties.setProperty(QLatin1String("moduleProperties"),
engine->newFunction(ModuleProperties::js_moduleProperties, 2));
objectWithProperties.setProperty(QLatin1String("moduleProperty"),
engine->newFunction(ModuleProperties::js_moduleProperty, 2));
objectWithProperties.setProperty(ptrKey(), engine->toScriptValue(quintptr(ptr)));
objectWithProperties.setProperty(typeKey(), type);
}
QMimeData *DomModel::mimeData(const QModelIndexList &indexes) const
{
QByteArray encodedData;
QDataStream stream(&encodedData, QIODevice::WriteOnly);
foreach (QModelIndex index, indexes) {
if (index.isValid())
stream << quintptr(index.internalPointer());
}
QMimeData *mimeData = new QMimeData();
mimeData->setData("text/plain", encodedData);
return mimeData;
}
QString QHelpGlobal::uniquifyConnectionName(const QString &name, void *pointer)
{
static int counter = 0;
static QMutex mutex;
QMutexLocker locker(&mutex);
if (++counter > 1000)
counter = 0;
return QString::fromLatin1("%1-%2-%3").
arg(name).arg(quintptr(pointer)).arg(counter);
}
QT_BEGIN_NAMESPACE
static inline bool isRecursive(QMutexData *d)
{
quintptr u = quintptr(d);
if (Q_LIKELY(u <= 0x3))
return false;
#ifdef QT_LINUX_FUTEX
Q_ASSERT(d->recursive);
return true;
#else
return d->recursive;
#endif
}
QDataStream &operator<<(QDataStream &stream, const QEasingCurve &easing)
{
stream << quint8(easing.d_ptr->type);
stream << quint64(quintptr(easing.d_ptr->func));
bool hasConfig = easing.d_ptr->config;
stream << hasConfig;
if (hasConfig) {
stream << easing.d_ptr->config->_p;
stream << easing.d_ptr->config->_a;
stream << easing.d_ptr->config->_o;
}
return stream;
}
bool QExternalTestPrivate::createTemporaryDirectory()
{
QDir temp = QDir::temp();
QString subdir = QString::fromLatin1("qexternaltest-%1-%2-%3")
.arg(QDateTime::currentDateTime().toString(QLatin1String("yyyyMMddhhmmss")))
.arg(quintptr(this), 0, 16)
.arg(qrand());
if (!temp.mkdir(subdir))
return false;
if (!temp.cd(subdir))
return false;
temporaryDir = temp.absolutePath();
return true;
}
QModelIndex SidebarModel::index(int row, int column, const QModelIndex &parent) const
{
// The model tree has two levels:
// Sections
// Section specific pages
// The leaf item ID is the section number (section row() + 1)
if(parent.isValid()) {
if(parent.internalId()==0)
return createIndex(row, column, parent.row()+1);
} else {
return createIndex(row, column, quintptr(0));
}
return QModelIndex();
}
/*!
Destroys the mutex.
\warning Destroying a locked mutex may result in undefined behavior.
*/
QMutex::~QMutex()
{
QMutexData *d = d_ptr.load();
if (quintptr(d) > 0x3 && d->recursive) {
delete static_cast<QRecursiveMutexPrivate *>(d);
} else if (d) {
#ifndef Q_OS_LINUX
if (d != dummyLocked() && static_cast<QMutexPrivate *>(d)->possiblyUnlocked.load()
&& tryLock()) {
unlock();
return;
}
#endif
qWarning("QMutex: destroying locked mutex");
}
}
/*!
Creates a QJsonDocument that uses the first \a size bytes from
\a data. It assumes \a data contains a binary encoded JSON document.
The created document does not take ownership of \a data and the caller
has to guarantee that \a data will not be deleted or modified as long as
any QJsonDocument, QJsonObject or QJsonArray still references the data.
\a data has to be aligned to a 4 byte boundary.
\a validation decides whether the data is checked for validity before being used.
By default the data is validated. If the \a data is not valid, the method returns
a null document.
Returns a QJsonDocument representing the data.
\sa rawData(), fromBinaryData(), isNull(), DataValidation
*/
QJsonDocument QJsonDocument::fromRawData(const char *data, int size, DataValidation validation)
{
if (quintptr(data) & 3) {
qWarning() <<"QJsonDocument::fromRawData: data has to have 4 byte alignment";
return QJsonDocument();
}
QJsonPrivate::Data *d = new QJsonPrivate::Data((char *)data, size);
d->ownsData = false;
if (validation != BypassValidation && !d->valid()) {
delete d;
return QJsonDocument();
}
return QJsonDocument(d);
}
QModelIndex HistoryMenuModel::mapToSource(const QModelIndex &proxyIndex) const
{
if (!proxyIndex.isValid())
return QModelIndex();
if (proxyIndex.internalId() == quintptr(-1)) {
int bumpedItems = bumpedRows();
if (proxyIndex.row() < bumpedItems)
return m_treeModel->index(proxyIndex.row(), proxyIndex.column(), m_treeModel->index(0, 0));
if (bumpedItems <= MOVEDROWS && bumpedItems == sourceModel()->rowCount(m_treeModel->index(0, 0)))
--bumpedItems;
return m_treeModel->index(proxyIndex.row() - bumpedItems, proxyIndex.column());
}
QModelIndex historyIndex = m_treeModel->sourceModel()->index(proxyIndex.internalId(), proxyIndex.column());
QModelIndex treeIndex = m_treeModel->mapFromSource(historyIndex);
return treeIndex;
}
void SidebarModel::setSessionList(const QJsonArray &sessions)
{
//qDebug() << "setSessionList" << sessions;
QStringList ids;
for(const QJsonValue &v : sessions) {
const QJsonObject o = v.toObject();
QString id = o["alias"].toString();
if(id.isEmpty())
id = o["id"].toString();
ids << id;
}
// Remove missing sessions
QMutableListIterator<PageFactory*> i(m_sessions);
const QModelIndex section = createIndex(1, 0, quintptr(0));
int row=0;
while(i.hasNext()) {
PageFactory *pf = i.next();
if(!ids.contains(pf->title())) {
qDebug() << "removing" << row;
beginRemoveRows(section, row, row);
delete pf;
i.remove();
endRemoveRows();
} else {
ids.removeAll(pf->title());
++row;
}
}
// Append new sessions
if(!ids.isEmpty()) {
row=m_sessions.size();
qDebug() << "adding" << ids.size();
beginInsertRows(section, row, row+ids.size()-1);
for(const QString &id : ids) {
m_sessions << new SessionPageFactory(id);
}
endInsertRows();
}
}
QMimeData* FeedsModel::mimeData(const QModelIndexList& indexes) const {
auto* mime_data = new QMimeData();
QByteArray encoded_data;
QDataStream stream(&encoded_data, QIODevice::WriteOnly);
foreach (const QModelIndex& index, indexes) {
if (index.column() != 0) {
continue;
}
RootItem* item_for_index = itemForIndex(index);
if (item_for_index->kind() != RootItemKind::Root) {
stream << quintptr(item_for_index);
}
}
mime_data->setData(QSL(MIME_TYPE_ITEM_POINTER), encoded_data);
return mime_data;
}
QModelIndex HistoryMenuModel::index(int row, int column, const QModelIndex &parent) const
{
if (row < 0
|| column < 0 || column >= columnCount(parent)
|| parent.column() > 0)
return QModelIndex();
if (!parent.isValid())
return createIndex(row, column, quintptr(-1));
QModelIndex treeIndexParent = mapToSource(parent);
int bumpedItems = 0;
if (treeIndexParent == m_treeModel->index(0, 0))
bumpedItems = bumpedRows();
QModelIndex treeIndex = m_treeModel->index(row + bumpedItems, column, treeIndexParent);
QModelIndex historyIndex = m_treeModel->mapToSource(treeIndex);
int historyRow = historyIndex.row();
if (historyRow == -1)
historyRow = treeIndex.row();
return createIndex(row, column, historyRow);
}
void QSoundEffectPrivate::decoderReady()
{
if (m_waveDecoder->size() >= PA_SCACHE_ENTRY_SIZE_MAX) {
m_waveDecoder->deleteLater();
qWarning("QSoundEffect(pulseaudio): Attempting to load to large a sample");
return;
}
if (m_name.isNull())
m_name = QString(QLatin1String("QtPulseSample-%1-%2")).arg(::getpid()).arg(quintptr(this)).toUtf8();
pa_sample_spec spec = audioFormatToSampleSpec(m_waveDecoder->audioFormat());
daemon()->lock();
pa_stream *stream = pa_stream_new(daemon()->context(), m_name.constData(), &spec, 0);
pa_stream_set_state_callback(stream, stream_state_callback, this);
pa_stream_set_write_callback(stream, stream_write_callback, this);
pa_stream_connect_upload(stream, (size_t)m_waveDecoder->size());
m_pulseStream = stream;
daemon()->unlock();
}
void *QXcbNativeInterface::nativeResourceForScreen(const QByteArray &resource, QScreen *screen)
{
void *result = 0;
const QXcbScreen *xcbScreen = static_cast<QXcbScreen *>(screen->handle());
switch (resourceType(resource)) {
case Display:
#ifdef XCB_USE_XLIB
result = xcbScreen->connection()->xlib_display();
#endif
break;
case AppTime:
result = appTime(xcbScreen);
break;
case AppUserTime:
result = appUserTime(xcbScreen);
break;
case ScreenHintStyle:
result = reinterpret_cast<void *>(xcbScreen->hintStyle() + 1);
break;
case ScreenSubpixelType:
result = reinterpret_cast<void *>(xcbScreen->subpixelType() + 1);
break;
case ScreenAntialiasingEnabled:
result = reinterpret_cast<void *>(xcbScreen->antialiasingEnabled() + 1);
break;
case TrayWindow:
if (QXcbSystemTrayTracker *s = systemTrayTracker(screen))
result = (void *)quintptr(s->trayWindow());
break;
case GetTimestamp:
result = getTimestamp(xcbScreen);
break;
case NoFontHinting:
result = xcbScreen->noFontHinting() ? this : 0; //qboolptr...
break;
default:
break;
}
return result;
}
static inline QMutexData *dummyFutexValue()
{
return reinterpret_cast<QMutexData *>(quintptr(3));
}
QEventDispatcherWin32Private::~QEventDispatcherWin32Private()
{
wakeUpNotifier.setEnabled(false);
CloseHandle(wakeUpNotifier.handle());
if (internalHwnd)
DestroyWindow(internalHwnd);
QByteArray className = "QEventDispatcherWin32_Internal_Widget" + QByteArray::number(quintptr(qt_internal_proc));
#if !defined(Q_OS_WINCE)
UnregisterClassA(className.constData(), qWinAppInst());
#else
UnregisterClassW(reinterpret_cast<const wchar_t *> (QString::fromLatin1(className.constData()).utf16()), qWinAppInst());
#endif
}
QByteArray QWindowsContext::comErrorString(HRESULT hr)
{
QByteArray result = QByteArrayLiteral("COM error 0x")
+ QByteArray::number(quintptr(hr), 16) + ' ';
switch (hr) {
case S_OK:
result += QByteArrayLiteral("S_OK");
break;
case S_FALSE:
result += QByteArrayLiteral("S_FALSE");
break;
case E_UNEXPECTED:
result += QByteArrayLiteral("E_UNEXPECTED");
break;
case CO_E_ALREADYINITIALIZED:
result += QByteArrayLiteral("CO_E_ALREADYINITIALIZED");
break;
case CO_E_NOTINITIALIZED:
result += QByteArrayLiteral("CO_E_NOTINITIALIZED");
break;
case RPC_E_CHANGED_MODE:
result += QByteArrayLiteral("RPC_E_CHANGED_MODE");
break;
case OLE_E_WRONGCOMPOBJ:
result += QByteArrayLiteral("OLE_E_WRONGCOMPOBJ");
break;
case CO_E_NOT_SUPPORTED:
result += QByteArrayLiteral("CO_E_NOT_SUPPORTED");
break;
case E_NOTIMPL:
result += QByteArrayLiteral("E_NOTIMPL");
break;
case E_INVALIDARG:
result += QByteArrayLiteral("E_INVALIDARG");
break;
case E_NOINTERFACE:
result += QByteArrayLiteral("E_NOINTERFACE");
break;
case E_POINTER:
result += QByteArrayLiteral("E_POINTER");
break;
case E_HANDLE:
result += QByteArrayLiteral("E_HANDLE");
break;
case E_ABORT:
result += QByteArrayLiteral("E_ABORT");
break;
case E_FAIL:
result += QByteArrayLiteral("E_FAIL");
break;
case RPC_E_WRONG_THREAD:
result += QByteArrayLiteral("RPC_E_WRONG_THREAD");
break;
case RPC_E_THREAD_NOT_INIT:
result += QByteArrayLiteral("RPC_E_THREAD_NOT_INIT");
break;
default:
break;
}
#ifndef Q_OS_WINCE
_com_error error(hr);
result += QByteArrayLiteral(" (");
result += errorMessageFromComError(error);
result += ')';
#endif // !Q_OS_WINCE
return result;
}
easing curve and returns a reference to the stream.
\sa {Format of the QDataStream Operators}
*/
QDataStream &operator>>(QDataStream &stream, QEasingCurve &easing)
{
QEasingCurve::Type type;
quint8 int_type;
stream >> int_type;
type = static_cast<QEasingCurve::Type>(int_type);
easing.setType(type);
quint64 ptr_func;
stream >> ptr_func;
easing.d_ptr->func = QEasingCurve::EasingFunction(quintptr(ptr_func));
bool hasConfig;
stream >> hasConfig;
if (hasConfig) {
QEasingCurveFunction *config = curveToFunctionObject(type);
stream >> config->_p;
stream >> config->_a;
stream >> config->_o;
easing.d_ptr->config = config;
}
return stream;
}
#endif // QT_NO_DATASTREAM
QT_END_NAMESPACE
void *QXcbNativeInterface::getTimestamp(const QXcbScreen *screen)
{
return reinterpret_cast<void *>(quintptr(screen->connection()->getTimestamp()));
}
