bool QWinRTServices::openDocument(const QUrl &url) { if (!(m_fileFactory && m_launcher)) return QPlatformServices::openDocument(url); const QString pathString = QDir::toNativeSeparators(url.toLocalFile()); HSTRING_HEADER header; HSTRING path; WindowsCreateStringReference((const wchar_t*)pathString.utf16(), pathString.length(), &header, &path); IAsyncOperation<StorageFile*> *fileOp; m_fileFactory->GetFileFromPathAsync(path, &fileOp); if (!fileOp) return false; IStorageFile *file = nullptr; while (fileOp->GetResults(&file) == E_ILLEGAL_METHOD_CALL) QCoreApplication::processEvents(); fileOp->Release(); if (!file) return false; IAsyncOperation<bool> *launchOp; m_launcher->LaunchFileAsync(file, &launchOp); if (!launchOp) return false; boolean result = false; while (launchOp->GetResults(&result) == E_ILLEGAL_METHOD_CALL) QCoreApplication::processEvents(); launchOp->Release(); return result; }
bool QWinRTServices::openUrl(const QUrl &url) { if (!(m_uriFactory && m_launcher)) return QPlatformServices::openUrl(url); IUriRuntimeClass *uri; QString urlString = url.toString(); HSTRING uriString; HSTRING_HEADER header; WindowsCreateStringReference((const wchar_t*)urlString.utf16(), urlString.length(), &header, &uriString); m_uriFactory->CreateUri(uriString, &uri); if (!uri) return false; IAsyncOperation<bool> *launchOp; m_launcher->LaunchUriAsync(uri, &launchOp); uri->Release(); if (!launchOp) return false; boolean result = false; while (launchOp->GetResults(&result) == E_ILLEGAL_METHOD_CALL) QCoreApplication::processEvents(); launchOp->Release(); return result; }
HRESULT CopyFilesToClipboard(std::list<std::wstring> FileNameList, BOOL bMove,IDataObject **pClipboardDataObject) { FORMATETC ftc[2]; STGMEDIUM stg[2]; HRESULT hr; BuildHDropList(&ftc[0],&stg[0],FileNameList); ftc[1].cfFormat = (CLIPFORMAT)RegisterClipboardFormat(CFSTR_PREFERREDDROPEFFECT); ftc[1].ptd = NULL; ftc[1].dwAspect = DVASPECT_CONTENT; ftc[1].lindex = -1; ftc[1].tymed = TYMED_HGLOBAL; HGLOBAL hglb = GlobalAlloc(GMEM_MOVEABLE,sizeof(DWORD)); DWORD *pdwCopyEffect = static_cast<DWORD *>(GlobalLock(hglb)); if(bMove) *pdwCopyEffect = DROPEFFECT_MOVE; else *pdwCopyEffect = DROPEFFECT_COPY; GlobalUnlock(hglb); stg[1].pUnkForRelease = 0; stg[1].hGlobal = hglb; stg[1].tymed = TYMED_HGLOBAL; hr = CreateDataObject(ftc,stg,pClipboardDataObject,2); IAsyncOperation *pAsyncOperation = NULL; (*pClipboardDataObject)->QueryInterface(IID_IAsyncOperation,(void **)&pAsyncOperation); pAsyncOperation->SetAsyncMode(TRUE); pAsyncOperation->Release(); if(SUCCEEDED(hr)) { hr = OleSetClipboard(*pClipboardDataObject); } return hr; }
QT_BEGIN_NAMESPACE void QDnsLookupRunnable::query(const int requestType, const QByteArray &requestName, const QHostAddress &nameserver, QDnsLookupReply *reply) { // TODO: Add nameserver support for winRT if (!nameserver.isNull()) qWarning() << "Ignoring nameserver as its currently not supported on WinRT"; // TODO: is there any way to do "proper" dns lookup? if (requestType != QDnsLookup::A && requestType != QDnsLookup::AAAA && requestType != QDnsLookup::ANY) { reply->error = QDnsLookup::InvalidRequestError; reply->errorString = QLatin1String("WinRT only supports IPv4 and IPv6 requests"); return; } QString aceHostname = QUrl::fromAce(requestName); if (aceHostname.isEmpty()) { reply->error = QDnsLookup::InvalidRequestError; reply->errorString = requestName.isEmpty() ? tr("No hostname given") : tr("Invalid hostname"); return; } IHostNameFactory *hostnameFactory; HStringReference classId(RuntimeClass_Windows_Networking_HostName); if (FAILED(GetActivationFactory(classId.Get(), &hostnameFactory))) { reply->error = QDnsLookup::ResolverError; reply->errorString = QLatin1String("Could not obtain hostname factory"); return; } IHostName *host; HStringReference hostNameRef((const wchar_t*)aceHostname.utf16()); hostnameFactory->CreateHostName(hostNameRef.Get(), &host); hostnameFactory->Release(); IDatagramSocketStatics *datagramSocketStatics; GetActivationFactory(HString::MakeReference(RuntimeClass_Windows_Networking_Sockets_DatagramSocket).Get(), &datagramSocketStatics); IAsyncOperation<IVectorView<EndpointPair*> *> *op; HSTRING proto; WindowsCreateString(L"0", 1, &proto); datagramSocketStatics->GetEndpointPairsAsync(host, proto, &op); datagramSocketStatics->Release(); host->Release(); IVectorView<EndpointPair*> *endpointPairs = 0; HRESULT hr = op->GetResults(&endpointPairs); int waitCount = 0; while (hr == E_ILLEGAL_METHOD_CALL) { WaitForSingleObjectEx(GetCurrentThread(), 50, FALSE); hr = op->GetResults(&endpointPairs); if (++waitCount > 1200) // Wait for 1 minute max return; } op->Release(); if (!endpointPairs) return; unsigned int size; endpointPairs->get_Size(&size); for (unsigned int i = 0; i < size; ++i) { IEndpointPair *endpointpair; endpointPairs->GetAt(i, &endpointpair); IHostName *remoteHost; endpointpair->get_RemoteHostName(&remoteHost); endpointpair->Release(); HostNameType type; remoteHost->get_Type(&type); if (type == HostNameType_Bluetooth || type == HostNameType_DomainName || (requestType != QDnsLookup::ANY && ((type == HostNameType_Ipv4 && requestType == QDnsLookup::AAAA) || (type == HostNameType_Ipv6 && requestType == QDnsLookup::A)))) continue; HSTRING name; remoteHost->get_CanonicalName(&name); remoteHost->Release(); UINT32 length; PCWSTR rawString = WindowsGetStringRawBuffer(name, &length); QDnsHostAddressRecord record; record.d->name = aceHostname; record.d->value = QHostAddress(QString::fromWCharArray(rawString, length)); reply->hostAddressRecords.append(record); } }
void CDropHandler::CopyDroppedFilesInternal(IBufferManager *pbm, list<PastedFile_t> *pPastedFileList,BOOL bCopy,BOOL bRenameOnCollision) { HANDLE hThread; TCHAR *szFileNameList = NULL; DWORD dwBufferSize; pbm->QueryBufferSize(&dwBufferSize); if(dwBufferSize > 1) { szFileNameList = (TCHAR *)malloc(dwBufferSize * sizeof(TCHAR)); if(szFileNameList != NULL) { pbm->QueryBuffer(szFileNameList,dwBufferSize); PastedFilesInfo_t *ppfi = NULL; ppfi = (PastedFilesInfo_t *)malloc(sizeof(PastedFilesInfo_t)); if(ppfi != NULL) { TCHAR *pszDestDirectory = NULL; pszDestDirectory = (TCHAR *)malloc((MAX_PATH + 1) * sizeof(TCHAR)); if(pszDestDirectory != NULL) { StringCchCopy(pszDestDirectory,MAX_PATH,m_szDestDirectory); pszDestDirectory[lstrlen(pszDestDirectory) + 1] = '\0'; ppfi->shfo.hwnd = m_hwndDrop; ppfi->shfo.wFunc = bCopy == TRUE ? FO_COPY : FO_MOVE; ppfi->shfo.pFrom = szFileNameList; ppfi->shfo.pTo = pszDestDirectory; ppfi->shfo.fFlags = (bRenameOnCollision == TRUE ? FOF_RENAMEONCOLLISION : 0)|FOF_WANTMAPPINGHANDLE; ppfi->pDropFilesCallback = m_pDropFilesCallback; ppfi->pPastedFileList = new list<PastedFile_t>(*pPastedFileList); ppfi->dwEffect = bCopy == TRUE ? DROPEFFECT_COPY : DROPEFFECT_MOVE; ppfi->pt.x = m_ptl.x; ppfi->pt.y = m_ptl.y; ppfi->pFrom = szFileNameList; ppfi->pTo = pszDestDirectory; ppfi->pDropHandler = this; ppfi->m_hDrop = m_hwndDrop; IAsyncOperation *pao = NULL; BOOL bAsyncSupported = FALSE; HRESULT hr; /* Does the drop source support asynchronous copy? */ hr = m_pDataObject->QueryInterface(IID_IAsyncOperation,(void **)&pao); if(hr == S_OK) { pao->GetAsyncMode(&bAsyncSupported); if(!bAsyncSupported) { pao->Release(); } } if(bAsyncSupported) { pao->StartOperation(NULL); ppfi->pao = pao; /* The copy operation is going to occur on a background thread, which means that we can't release this object until the background thread has completed. Use reference counting to ensure this condition is met. */ AddRef(); /* The drop source needs to be notified of the status of the copy once it has finished. This notification however, needs to occur on the thread that the object was created in. Therefore, we'll subclass the drop window, so that we can send it a private user message once the drop has finished. */ SetWindowSubclass(m_hwndDrop,DropWindowSubclass,SUBCLASS_ID,NULL); /* Create a new thread, which we'll use to copy the dropped files. */ hThread = CreateThread(NULL,0,CopyDroppedFilesInternalAsyncStub,ppfi,0,NULL); CloseHandle(hThread); } else { /* Copy the files within this thread. */ CopyDroppedFilesInternalAsync(ppfi); free((void *)ppfi); } } else { free(szFileNameList); } } } } }