bool QSharedMemoryPrivate::create(int size)
{
QString function = QLatin1String("QSharedMemory::create");
if (nativeKey.isEmpty()) {
error = QSharedMemory::KeyError;
errorString = QSharedMemory::tr("%1: key error").arg(function);
return false;
}
// Create the file mapping.
#if defined(Q_OS_WINPHONE)
Q_UNIMPLEMENTED();
Q_UNUSED(size)
hand = 0;
#elif defined(Q_OS_WINRT)
hand = CreateFileMappingFromApp(INVALID_HANDLE_VALUE, 0, PAGE_READWRITE, size, (PCWSTR)nativeKey.utf16());
#else
hand = CreateFileMapping(INVALID_HANDLE_VALUE, 0, PAGE_READWRITE, 0, size, (wchar_t*)nativeKey.utf16());
#endif
setErrorString(function);
// hand is valid when it already exists unlike unix so explicitly check
if (error == QSharedMemory::AlreadyExists || !hand)
return false;
return true;
}
bool QSharedMemoryPrivate::attach(QSharedMemory::AccessMode mode)
{
// Grab a pointer to the memory block
int permissions = (mode == QSharedMemory::ReadOnly ? FILE_MAP_READ : FILE_MAP_ALL_ACCESS);
#if defined(Q_OS_WINPHONE)
Q_UNIMPLEMENTED();
Q_UNUSED(mode)
memory = 0;
#elif defined(Q_OS_WINRT)
memory = (void *)MapViewOfFileFromApp(handle(), permissions, 0, 0);
#else
memory = (void *)MapViewOfFile(handle(), permissions, 0, 0, 0);
#endif
if (0 == memory) {
setErrorString(QLatin1String("QSharedMemory::attach"));
cleanHandle();
return false;
}
// Grab the size of the memory we have been given (a multiple of 4K on windows)
MEMORY_BASIC_INFORMATION info;
if (!VirtualQuery(memory, &info, sizeof(info))) {
// Windows doesn't set an error code on this one,
// it should only be a kernel memory error.
error = QSharedMemory::UnknownError;
errorString = QSharedMemory::tr("%1: size query failed").arg(QLatin1String("QSharedMemory::attach: "));
return false;
}
size = info.RegionSize;
return true;
}
bool QFSFileEnginePrivate::unmap(uchar *ptr)
{
#ifndef Q_OS_WINPHONE
Q_Q(QFSFileEngine);
if (!maps.contains(ptr)) {
q->setError(QFile::PermissionsError, qt_error_string(ERROR_ACCESS_DENIED));
return false;
}
uchar *start = ptr - maps[ptr];
if (!UnmapViewOfFile(start)) {
q->setError(QFile::PermissionsError, qt_error_string());
return false;
}
maps.remove(ptr);
if (maps.isEmpty()) {
::CloseHandle(mapHandle);
mapHandle = NULL;
}
return true;
#else // !Q_OS_WINPHONE
Q_UNUSED(ptr);
Q_UNIMPLEMENTED();
return false;
#endif // Q_OS_WINPHONE
}
HANDLE QSharedMemoryPrivate::handle()
{
if (!hand) {
QString function = QLatin1String("QSharedMemory::handle");
if (nativeKey.isEmpty()) {
error = QSharedMemory::KeyError;
errorString = QSharedMemory::tr("%1: unable to make key").arg(function);
return 0;
}
#if defined(Q_OS_WINPHONE)
Q_UNIMPLEMENTED();
hand = 0;
#elif defined(Q_OS_WINRT)
hand = CreateFileMappingFromApp(INVALID_HANDLE_VALUE, 0, PAGE_READWRITE, 0, (PCWSTR)nativeKey.utf16());
#elif defined(Q_OS_WINCE)
// This works for opening a mapping too, but always opens it with read/write access in
// attach as it seems.
hand = CreateFileMapping(INVALID_HANDLE_VALUE, 0, PAGE_READWRITE, 0, 0, (wchar_t*)nativeKey.utf16());
#else
hand = OpenFileMapping(FILE_MAP_ALL_ACCESS, false, (wchar_t*)nativeKey.utf16());
#endif
if (!hand) {
setErrorString(function);
return 0;
}
}
return hand;
}
void VlcWidgetSeekProgress::setSliderWidget(QWidget *slider,
bool updateSlider)
{
Q_UNUSED(slider)
Q_UNUSED(updateSlider)
#if QT_VERSION >= 0x050000
Q_UNIMPLEMENTED();
#endif
Q_ASSERT(!"VlcWidgetSeekProgress::setSliderWidget() - Changing the slider widget is not allowed.");
}
void QWinThumbnailToolBarPrivate::initToolbar()
{
#if !defined(_MSC_VER) || _MSC_VER >= 1600
if (!pTbList || !window)
return;
THUMBBUTTON buttons[windowsLimitedThumbbarSize];
initButtons(buttons);
HRESULT hresult = pTbList->ThumbBarAddButtons(reinterpret_cast<HWND>(window->winId()), windowsLimitedThumbbarSize, buttons);
if (FAILED(hresult))
qWarning() << msgComFailed("ThumbBarAddButtons", hresult);
#else
// ITaskbarList3::ThumbBarAddButtons() has a different signature in SDK 6.X
Q_UNIMPLEMENTED();
#endif
}
bool QSharedMemoryPrivate::detach()
{
// umap memory
#if defined(Q_OS_WINPHONE)
Q_UNIMPLEMENTED();
return false;
#else
if (!UnmapViewOfFile(memory)) {
setErrorString(QLatin1String("QSharedMemory::detach"));
return false;
}
#endif
memory = 0;
size = 0;
// close handle
return cleanHandle();
}
void DocuWindow::print()
{
#ifdef QT_NO_PRINTER
Q_UNIMPLEMENTED();
#else
QPrinter printer;
if (printer.printerName().isEmpty()) {
statusBar()->showMessage(tr("No printer installed"), 2000);
return;
}
QPrintDialog printDialog(&printer, this);
if (!printDialog.exec()) {
statusBar()->showMessage(tr("Printing aborted"), 2000);
return;
}
browser->document()->print(&printer);
#endif
}
void DeviceInterface::DisconnectProfile(const QString &uuid, const QDBusMessage &msg)
{
if (!uuids().contains(uuid)) {
QDBusMessage error = msg.createErrorReply(QStringLiteral("org.bluez.Error.DoesNotExist"), QStringLiteral("Profile UUID not supported"));
QDBusConnection::sessionBus().send(error);
return;
}
if (!m_connectedUuids.contains(uuid)) {
QDBusMessage error = msg.createErrorReply(QStringLiteral("org.bluez.Error.NotConnected"), QStringLiteral("Profile not connected"));
QDBusConnection::sessionBus().send(error);
return;
}
if (uuid == MediaPlayerUuid) {
disconnectMediaPlayer();
} else {
Q_UNIMPLEMENTED();
}
Object::changeProperty(QStringLiteral("Connected"), false);
}
void DeviceInterface::Pair()
{
Q_UNIMPLEMENTED();
}
bool exec() override
{
Q_UNIMPLEMENTED();
// m_reply->exec();
return isSuccessful();
}
QStringList QWindowsFontDatabaseFT::addApplicationFont(const QByteArray &fontData, const QString &fileName)
{
const QStringList result = QPlatformFontDatabase::addApplicationFont(fontData, fileName);
Q_UNIMPLEMENTED();
return result;
}
QString QSslCertificate::toText() const
{
Q_UNIMPLEMENTED();
return QString();
}
Qt::HANDLE QSslCertificate::handle() const
{
Q_UNIMPLEMENTED();
return 0;
}
bool QFSFileEngine::link(const QString &newName)
{
#if !defined(Q_OS_WINCE) && !defined(Q_OS_WINRT)
#if !defined(QT_NO_LIBRARY)
bool ret = false;
QString linkName = newName;
//### assume that they add .lnk
IShellLink *psl;
bool neededCoInit = false;
HRESULT hres = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, IID_IShellLink, (void **)&psl);
if (hres == CO_E_NOTINITIALIZED) { // COM was not initialized
neededCoInit = true;
CoInitialize(NULL);
hres = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, IID_IShellLink, (void **)&psl);
}
if (SUCCEEDED(hres)) {
hres = psl->SetPath((wchar_t *)fileName(AbsoluteName).replace(QLatin1Char('/'), QLatin1Char('\\')).utf16());
if (SUCCEEDED(hres)) {
hres = psl->SetWorkingDirectory((wchar_t *)fileName(AbsolutePathName).replace(QLatin1Char('/'), QLatin1Char('\\')).utf16());
if (SUCCEEDED(hres)) {
IPersistFile *ppf;
hres = psl->QueryInterface(IID_IPersistFile, (void **)&ppf);
if (SUCCEEDED(hres)) {
hres = ppf->Save((wchar_t*)linkName.utf16(), TRUE);
if (SUCCEEDED(hres))
ret = true;
ppf->Release();
}
}
}
psl->Release();
}
if (!ret)
setError(QFile::RenameError, qt_error_string());
if (neededCoInit)
CoUninitialize();
return ret;
#else
Q_UNUSED(newName);
return false;
#endif // QT_NO_LIBRARY
#elif defined(Q_OS_WINCE) && !defined(QT_NO_WINCE_SHELLSDK)
QString linkName = newName;
linkName.replace(QLatin1Char('/'), QLatin1Char('\\'));
if (!linkName.endsWith(QLatin1String(".lnk")))
linkName += QLatin1String(".lnk");
QString orgName = fileName(AbsoluteName).replace(QLatin1Char('/'), QLatin1Char('\\'));
// Need to append on our own
orgName.prepend(QLatin1Char('"'));
orgName.append(QLatin1Char('"'));
bool ret = SUCCEEDED(SHCreateShortcut((wchar_t*)linkName.utf16(), (wchar_t*)orgName.utf16()));
if (!ret)
setError(QFile::RenameError, qt_error_string());
return ret;
#else // Q_OS_WINCE && !QT_NO_WINCE_SHELLSDK
Q_UNUSED(newName);
Q_UNIMPLEMENTED();
return false;
#endif // Q_OS_WINRT
}
uchar *QFSFileEnginePrivate::map(qint64 offset, qint64 size,
QFile::MemoryMapFlags flags)
{
#ifndef Q_OS_WINPHONE
Q_Q(QFSFileEngine);
Q_UNUSED(flags);
if (openMode == QFile::NotOpen) {
q->setError(QFile::PermissionsError, qt_error_string(ERROR_ACCESS_DENIED));
return 0;
}
if (offset == 0 && size == 0) {
q->setError(QFile::UnspecifiedError, qt_error_string(ERROR_INVALID_PARAMETER));
return 0;
}
// check/setup args to map
DWORD access = 0;
if (flags & QFileDevice::MapPrivateOption) {
#ifdef FILE_MAP_COPY
access = FILE_MAP_COPY;
#else
q->setError(QFile::UnspecifiedError, "MapPrivateOption unsupported");
return 0;
#endif
} else if (openMode & QIODevice::WriteOnly) {
access = FILE_MAP_WRITE;
} else if (openMode & QIODevice::ReadOnly) {
access = FILE_MAP_READ;
}
if (mapHandle == NULL) {
// get handle to the file
HANDLE handle = fileHandle;
#ifndef Q_OS_WINCE
if (handle == INVALID_HANDLE_VALUE && fh)
handle = (HANDLE)::_get_osfhandle(QT_FILENO(fh));
#endif
#ifdef Q_USE_DEPRECATED_MAP_API
nativeClose();
// handle automatically closed by kernel with mapHandle (below).
handle = ::CreateFileForMapping((const wchar_t*)fileEntry.nativeFilePath().utf16(),
GENERIC_READ | (openMode & QIODevice::WriteOnly ? GENERIC_WRITE : 0),
0,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL);
// Since this is a special case, we check if the return value was NULL and if so
// we change it to INVALID_HANDLE_VALUE to follow the logic inside this function.
if(0 == handle)
handle = INVALID_HANDLE_VALUE;
#endif
if (handle == INVALID_HANDLE_VALUE) {
q->setError(QFile::PermissionsError, qt_error_string(ERROR_ACCESS_DENIED));
return 0;
}
// first create the file mapping handle
DWORD protection = (openMode & QIODevice::WriteOnly) ? PAGE_READWRITE : PAGE_READONLY;
#ifndef Q_OS_WINRT
mapHandle = ::CreateFileMapping(handle, 0, protection, 0, 0, 0);
#else
mapHandle = ::CreateFileMappingFromApp(handle, 0, protection, 0, 0);
#endif
if (mapHandle == NULL) {
q->setError(QFile::PermissionsError, qt_error_string());
#ifdef Q_USE_DEPRECATED_MAP_API
::CloseHandle(handle);
#endif
return 0;
}
}
DWORD offsetHi = offset >> 32;
DWORD offsetLo = offset & Q_UINT64_C(0xffffffff);
SYSTEM_INFO sysinfo;
#ifndef Q_OS_WINRT
::GetSystemInfo(&sysinfo);
#else
::GetNativeSystemInfo(&sysinfo);
#endif
DWORD mask = sysinfo.dwAllocationGranularity - 1;
DWORD extra = offset & mask;
if (extra)
offsetLo &= ~mask;
// attempt to create the map
#ifndef Q_OS_WINRT
LPVOID mapAddress = ::MapViewOfFile(mapHandle, access,
offsetHi, offsetLo, size + extra);
#else
LPVOID mapAddress = ::MapViewOfFileFromApp(mapHandle, access,
(ULONG64(offsetHi) << 32) + offsetLo, size + extra);
#endif
if (mapAddress) {
uchar *address = extra + static_cast<uchar*>(mapAddress);
maps[address] = extra;
return address;
}
switch(GetLastError()) {
case ERROR_ACCESS_DENIED:
q->setError(QFile::PermissionsError, qt_error_string());
break;
case ERROR_INVALID_PARAMETER:
// size are out of bounds
default:
q->setError(QFile::UnspecifiedError, qt_error_string());
}
::CloseHandle(mapHandle);
mapHandle = NULL;
#else // !Q_OS_WINPHONE
Q_UNUSED(offset);
Q_UNUSED(size);
Q_UNUSED(flags);
Q_UNIMPLEMENTED();
#endif // Q_OS_WINPHONE
return 0;
}
void QSystemSemaphorePrivate::setErrorString(const QString &function)
{
Q_UNUSED(function);
Q_UNIMPLEMENTED();
}
void DeviceInterface::CancelPairing()
{
Q_UNIMPLEMENTED();
}
key_t QSystemSemaphorePrivate::handle(QSystemSemaphore::AccessMode mode)
{
Q_UNUSED(mode);
Q_UNIMPLEMENTED();
return -1;
}
bool QSystemSemaphorePrivate::modifySemaphore(int count)
{
Q_UNUSED(count);
Q_UNIMPLEMENTED();
return false;
}
void QSystemSemaphorePrivate::cleanHandle()
{
Q_UNIMPLEMENTED();
}
