HRESULT QNativeSocketEnginePrivate::handleNewDatagram(IDatagramSocket *socket, IDatagramSocketMessageReceivedEventArgs *args) { Q_Q(QNativeSocketEngine); Q_UNUSED(socket); WinRtDatagram datagram; QHostAddress returnAddress; ComPtr<IHostName> remoteHost; HRESULT hr = args->get_RemoteAddress(&remoteHost); RETURN_OK_IF_FAILED("Could not obtain remote host"); HString remoteHostString; remoteHost->get_CanonicalName(remoteHostString.GetAddressOf()); RETURN_OK_IF_FAILED("Could not obtain remote host's canonical name"); returnAddress.setAddress(qt_QStringFromHString(remoteHostString)); datagram.address = returnAddress; HString remotePort; hr = args->get_RemotePort(remotePort.GetAddressOf()); RETURN_OK_IF_FAILED("Could not obtain remote port"); datagram.port = qt_QStringFromHString(remotePort).toInt(); ComPtr<IDataReader> reader; hr = args->GetDataReader(&reader); RETURN_OK_IF_FAILED("Could not obtain data reader"); quint32 length; hr = reader->get_UnconsumedBufferLength(&length); RETURN_OK_IF_FAILED("Could not obtain unconsumed buffer length"); datagram.data.resize(length); hr = reader->ReadBytes(length, reinterpret_cast<BYTE *>(datagram.data.data())); RETURN_OK_IF_FAILED("Could not read datagram"); pendingDatagrams.append(datagram); emit q->readReady(); return S_OK; }
void FrameworkView::LaunchActivated(ComPtr<ILaunchActivatedEventArgs>& aArgs, bool aStartup) { if (!aArgs) return; HString data; AssertHRESULT(aArgs->get_Arguments(data.GetAddressOf())); if (WindowsIsStringEmpty(data.Get())) return; // If we're being launched from a secondary tile then we have a 2nd command line param of -url // and a third of the secondary tile. We want it in sActivationURI so that browser.js will // load it in without showing the start UI. int argc; unsigned int length; LPWSTR* argv = CommandLineToArgvW(data.GetRawBuffer(&length), &argc); if (aStartup && argc == 2 && !wcsicmp(argv[0], L"-url")) { WindowsCreateString(argv[1], wcslen(argv[1]), &sActivationURI); } else { // Some other command line or this is not a startup. // If it is startup we process it later when XPCOM is initialilzed. mActivationCommandLine = data.GetRawBuffer(&length); if (!aStartup) { ProcessLaunchArguments(); } } }
HRESULT ezUwpApplication::OnActivated(ICoreApplicationView* view, IActivatedEventArgs* args) { view->remove_Activated(m_activateRegistrationToken); ActivationKind activationKind; EZ_SUCCEED_OR_RETURN(args->get_Kind(&activationKind)); if (activationKind == ActivationKind_Launch) { ComPtr<ILaunchActivatedEventArgs> launchArgs; EZ_SUCCEED_OR_RETURN(args->QueryInterface(launchArgs.GetAddressOf())); HString argHString; EZ_SUCCEED_OR_RETURN(launchArgs->get_Arguments(argHString.GetAddressOf())); ezDynamicArray<const char*> argv; ezCommandLineUtils::SplitCommandLineString(ezStringUtf8(argHString).GetData(), true, m_commandLineArgs, argv); m_application->SetCommandLineArguments(argv.GetCount(), argv.GetData()); } // Activate main window together with the application! ComPtr<ABI::Windows::UI::Core::ICoreWindow> pCoreWindow; EZ_SUCCEED_OR_RETURN(view->get_CoreWindow(pCoreWindow.GetAddressOf())); EZ_SUCCEED_OR_RETURN(pCoreWindow->Activate()); return S_OK; }
HRESULT FrameworkView::OnSearchQuerySubmitted(ISearchPane* aPane, ISearchPaneQuerySubmittedEventArgs* aArgs) { LogFunction(); HString aQuery; aArgs->get_QueryText(aQuery.GetAddressOf()); PerformURILoadOrSearch(aQuery); return S_OK; }
static QString deviceDescription(IDeviceInformation *device) { HRESULT hr; HString name; hr = device->get_Name(name.GetAddressOf()); Q_ASSERT_SUCCEEDED(hr); quint32 length; const wchar_t *buffer = name.GetRawBuffer(&length); return QString::fromWCharArray(buffer, length); }
HRESULT onDeviceRemoved(IDeviceWatcher *, IDeviceInformationUpdate *device) { HRESULT hr; HString id; hr = device->get_Id(id.GetAddressOf()); Q_ASSERT_SUCCEEDED(hr); HString name; hr = device->get_Id(name.GetAddressOf()); Q_ASSERT_SUCCEEDED(hr); quint32 nameLength; const wchar_t *nameString = name.GetRawBuffer(&nameLength); const int index = deviceIndex.take(QString::fromWCharArray(nameString, nameLength)); if (index >= 0) devices.remove(index); foreach (QWinRTVideoDeviceSelectorControl *watcher, watchers) emit watcher->devicesChanged(); return S_OK; }
QT_USE_NAMESPACE static QString deviceName(IDeviceInformation *device) { HRESULT hr; HString id; hr = device->get_Id(id.GetAddressOf()); Q_ASSERT_SUCCEEDED(hr); quint32 length; const wchar_t *buffer = id.GetRawBuffer(&length); return QString::fromWCharArray(buffer, length); }
QString QHostInfo::localHostName() { ComPtr<INetworkInformationStatics> statics; GetActivationFactory(HString::MakeReference(RuntimeClass_Windows_Networking_Connectivity_NetworkInformation).Get(), &statics); ComPtr<IVectorView<HostName *>> hostNames; statics->GetHostNames(&hostNames); if (!hostNames) return QString(); unsigned int size; hostNames->get_Size(&size); if (size == 0) return QString(); for (unsigned int i = 0; i < size; ++i) { ComPtr<IHostName> hostName; hostNames->GetAt(i, &hostName); HostNameType type; hostName->get_Type(&type); if (type != HostNameType_DomainName) continue; HString name; hostName->get_CanonicalName(name.GetAddressOf()); UINT32 length; PCWSTR rawString = name.GetRawBuffer(&length); return QString::fromWCharArray(rawString, length); } ComPtr<IHostName> firstHost; hostNames->GetAt(0, &firstHost); HString name; firstHost->get_CanonicalName(name.GetAddressOf()); UINT32 length; PCWSTR rawString = name.GetRawBuffer(&length); return QString::fromWCharArray(rawString, length); }
std::wstring uri_resolve( std::wstring const&url, std::wstring const&relative ) { if ( url.empty() ) return relative; ComPtr<IUriRuntimeClassFactory> uriFactory; auto hr = GetActivationFactory( HStringReference( RuntimeClass_Windows_Foundation_Uri ).Get(), &uriFactory ); ComPtr<IUriRuntimeClass> uri, v; if (ok(hr)) hr = uriFactory->CreateUri( HStringReference( url.c_str() ).Get(), uri.ReleaseAndGetAddressOf() ); if (ok(hr)) hr = uri->CombineUri( HStringReference( relative.c_str() ).Get(), v.ReleaseAndGetAddressOf()); HString urx; if (ok(hr)) hr = v->get_AbsoluteUri( urx.GetAddressOf() ); return ok(hr)?std::wstring( urx.GetRawBuffer( nullptr ) ) : relative; }
HRESULT GetExeModulePath(LPWSTR lpstrPath,HMODULE hModule) { #if (WINAPI_FAMILY == WINAPI_FAMILY_DESKTOP_APP) WCHAR szBuffer[MAX_PATH] = {}; DWORD dwResult = GetModuleFileNameW(hModule,szBuffer,MAX_PATH); if (dwResult == 0) return HRESULT_FROM_WIN32(GetLastError()); auto p = wcsrchr(szBuffer,L'\\'); if (p) *p = NULL; wcscpy_s(lpstrPath,MAX_PATH,szBuffer); return S_OK; #else ComPtr<ABI::Windows::ApplicationModel::IPackageStatics> pPkgMethods; HRESULT hr = RoGetActivationFactory(HStringReference(RuntimeClass_Windows_ApplicationModel_Package).Get(), IID_PPV_ARGS(pPkgMethods.GetAddressOf())); if (FAILED(hr)) return hr; ComPtr<ABI::Windows::ApplicationModel::IPackage> pPackage; hr = pPkgMethods->get_Current(pPackage.GetAddressOf()); if (FAILED(hr)) return hr; ComPtr<ABI::Windows::Storage::IStorageFolder> pFolder; hr = pPackage->get_InstalledLocation(pFolder.GetAddressOf()); if (FAILED(hr)) return hr; ComPtr<ABI::Windows::Storage::IStorageItem> pFolderItem; hr = pFolder.As(&pFolderItem); if (FAILED(hr)) return hr; HString hstrPath; hr = pFolderItem->get_Path(hstrPath.GetAddressOf()); if (FAILED(hr)) return hr; wcscpy_s(lpstrPath,MAX_PATH,hstrPath.GetRawBuffer(nullptr)); return S_OK; #endif }
QString UrlFromFileArgs(IInspectable *args) { ComPtr<IFileActivatedEventArgs> fileArgs; COM_ENSURE(args->QueryInterface(fileArgs.GetAddressOf()), QString()); ComPtr<IVectorView<IStorageItem*>> files; COM_ENSURE(fileArgs->get_Files(&files), QString()); ComPtr<IStorageItem> item; COM_ENSURE(files->GetAt(0, &item), QString()); HString path; COM_ENSURE(item->get_Path(path.GetAddressOf()), QString()); quint32 pathLen; const wchar_t *pathStr = path.GetRawBuffer(&pathLen); const QString filePath = QString::fromWCharArray(pathStr, pathLen); qDebug() << "file path: " << filePath; item->AddRef(); //ensure we can access it later. TODO: how to release? return QString::fromLatin1("winrt:@%1:%2").arg((qint64)(qptrdiff)item.Get()).arg(filePath); }
void FrameworkView::FileActivated(ComPtr<IFileActivatedEventArgs>& aArgs, bool aStartup) { if (!aArgs) return; ComPtr<IVectorView<ABI::Windows::Storage::IStorageItem*>> list; AssertHRESULT(aArgs->get_Files(list.GetAddressOf())); ComPtr<ABI::Windows::Storage::IStorageItem> item; AssertHRESULT(list->GetAt(0, item.GetAddressOf())); HString filePath; AssertHRESULT(item->get_Path(filePath.GetAddressOf())); if (aStartup) { WindowsDuplicateString(filePath.Get(), &sActivationURI); } else { PerformURILoad(filePath); } }
void FrameworkView::ProcessActivationArgs(IActivatedEventArgs* aArgs, bool aStartup) { ActivationKind kind; if (!aArgs || FAILED(aArgs->get_Kind(&kind))) return; ComPtr<IActivatedEventArgs> args(aArgs); if (kind == ActivationKind::ActivationKind_Protocol) { WinUtils::Log("Activation argument kind: Protocol"); ComPtr<IProtocolActivatedEventArgs> protoArgs; AssertHRESULT(args.As(&protoArgs)); ComPtr<IUriRuntimeClass> uri; AssertHRESULT(protoArgs->get_Uri(uri.GetAddressOf())); if (!uri) return; HString data; AssertHRESULT(uri->get_AbsoluteUri(data.GetAddressOf())); if (WindowsIsStringEmpty(data.Get())) return; if (aStartup) { WindowsDuplicateString(data.Get(), &sActivationURI); } else { PerformURILoad(data); } } else if (kind == ActivationKind::ActivationKind_Search) { WinUtils::Log("Activation argument kind: Search"); ComPtr<ISearchActivatedEventArgs> searchArgs; args.As(&searchArgs); SearchActivated(searchArgs, aStartup); } else if (kind == ActivationKind::ActivationKind_File) { WinUtils::Log("Activation argument kind: File"); ComPtr<IFileActivatedEventArgs> fileArgs; args.As(&fileArgs); FileActivated(fileArgs, aStartup); } else if (kind == ActivationKind::ActivationKind_Launch) { WinUtils::Log("Activation argument kind: Launch"); ComPtr<ILaunchActivatedEventArgs> launchArgs; args.As(&launchArgs); LaunchActivated(launchArgs, aStartup); } }
void FrameworkView::SearchActivated(ComPtr<ISearchActivatedEventArgs>& aArgs, bool aStartup) { if (!aArgs) return; HString data; AssertHRESULT(aArgs->get_QueryText(data.GetAddressOf())); if (WindowsIsStringEmpty(data.Get())) return; unsigned int length; WinUtils::LogW(L"SearchActivated text=%s", data.GetRawBuffer(&length)); if (aStartup) { WindowsDuplicateString(data.Get(), &sActivationURI); } else { PerformURILoadOrSearch(data); } }
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; } ComPtr<IHostNameFactory> hostnameFactory; HRESULT hr = RoGetActivationFactory(HString::MakeReference(RuntimeClass_Windows_Networking_HostName).Get(), IID_PPV_ARGS(&hostnameFactory)); if (FAILED(hr)) { reply->error = QDnsLookup::ResolverError; reply->errorString = QLatin1String("Could not obtain hostname factory"); return; } ComPtr<IHostName> host; HStringReference hostNameRef((const wchar_t*)aceHostname.utf16()); hostnameFactory->CreateHostName(hostNameRef.Get(), &host); ComPtr<IDatagramSocketStatics> datagramSocketStatics; GetActivationFactory(HString::MakeReference(RuntimeClass_Windows_Networking_Sockets_DatagramSocket).Get(), &datagramSocketStatics); ComPtr<IAsyncOperation<IVectorView<EndpointPair *> *>> op; datagramSocketStatics->GetEndpointPairsAsync(host.Get(), HString::MakeReference(L"0").Get(), &op); ComPtr<IVectorView<EndpointPair *>> endpointPairs; 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; } if (!endpointPairs) return; unsigned int size; endpointPairs->get_Size(&size); // endpoint pairs might contain duplicates so we temporarily store addresses in a QSet QSet<QHostAddress> addresses; for (unsigned int i = 0; i < size; ++i) { ComPtr<IEndpointPair> endpointpair; endpointPairs->GetAt(i, &endpointpair); ComPtr<IHostName> remoteHost; endpointpair->get_RemoteHostName(&remoteHost); 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.GetAddressOf()); UINT32 length; PCWSTR rawString = name.GetRawBuffer(&length); addresses.insert(QHostAddress(QString::fromWCharArray(rawString, length))); } foreach (const QHostAddress &address, addresses) { QDnsHostAddressRecord record; record.d->name = aceHostname; record.d->value = address; reply->hostAddressRecords.append(record); }
std::vector<AudioEngine::RendererDetail> AudioEngine::GetRendererDetails() { std::vector<RendererDetail> list; #if defined(WINAPI_FAMILY) && WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP LPCWSTR id = GetDefaultAudioRenderId( Default ); if ( !id ) return list; RendererDetail device; device.deviceId = id; device.description = L"Default"; CoTaskMemFree( (LPVOID)id ); #elif defined(_XBOX_ONE) using namespace Microsoft::WRL; using namespace Microsoft::WRL::Wrappers; using namespace ABI::Windows::Media::Devices; Microsoft::WRL::ComPtr<IMediaDeviceStatics> mdStatics; HRESULT hr = ABI::Windows::Foundation::GetActivationFactory( HStringReference(RuntimeClass_Windows_Media_Devices_MediaDevice).Get(), &mdStatics ); ThrowIfFailed( hr ); HString id; hr = mdStatics->GetDefaultAudioRenderId( AudioDeviceRole_Default, id.GetAddressOf() ); ThrowIfFailed( hr ); RendererDetail device; device.deviceId = id.GetRawBuffer( nullptr ); device.description = L"Default"; list.emplace_back( device ); #elif (_WIN32_WINNT >= _WIN32_WINNT_WIN8) #if defined(__cplusplus_winrt) // Enumerating with WinRT using C++/CX (Windows Store apps) using Windows::Devices::Enumeration::DeviceClass; using Windows::Devices::Enumeration::DeviceInformation; using Windows::Devices::Enumeration::DeviceInformationCollection; auto operation = DeviceInformation::FindAllAsync(DeviceClass::AudioRender); while (operation->Status != Windows::Foundation::AsyncStatus::Completed) ; DeviceInformationCollection^ devices = operation->GetResults(); for (unsigned i = 0; i < devices->Size; ++i) { using Windows::Devices::Enumeration::DeviceInformation; DeviceInformation^ d = devices->GetAt(i); RendererDetail device; device.deviceId = d->Id->Data(); device.description = d->Name->Data(); list.emplace_back(device); } #else // Enumerating with WinRT using WRL (Win32 desktop app for Windows 8.x) using namespace Microsoft::WRL; using namespace Microsoft::WRL::Wrappers; using namespace ABI::Windows::Foundation; using namespace ABI::Windows::Foundation::Collections; using namespace ABI::Windows::Devices::Enumeration; RoInitializeWrapper initialize(RO_INIT_MULTITHREADED); HRESULT hr = initialize; ThrowIfFailed( hr ); Microsoft::WRL::ComPtr<IDeviceInformationStatics> diFactory; hr = ABI::Windows::Foundation::GetActivationFactory( HStringReference(RuntimeClass_Windows_Devices_Enumeration_DeviceInformation).Get(), &diFactory ); ThrowIfFailed( hr ); Event findCompleted( CreateEventEx( nullptr, nullptr, CREATE_EVENT_MANUAL_RESET, WRITE_OWNER | EVENT_ALL_ACCESS ) ); if ( !findCompleted.IsValid() ) throw std::exception( "CreateEventEx" ); auto callback = Callback<IAsyncOperationCompletedHandler<DeviceInformationCollection*>>( [&findCompleted,list]( IAsyncOperation<DeviceInformationCollection*>* aDevices, AsyncStatus status ) -> HRESULT { UNREFERENCED_PARAMETER(aDevices); UNREFERENCED_PARAMETER(status); SetEvent( findCompleted.Get() ); return S_OK; }); ComPtr<IAsyncOperation<DeviceInformationCollection*>> operation; hr = diFactory->FindAllAsyncDeviceClass( DeviceClass_AudioRender, operation.GetAddressOf() ); ThrowIfFailed( hr ); operation->put_Completed( callback.Get() ); (void)WaitForSingleObjectEx( findCompleted.Get(), INFINITE, FALSE ); ComPtr<IVectorView<DeviceInformation*>> devices; operation->GetResults( devices.GetAddressOf() ); unsigned int count = 0; hr = devices->get_Size( &count ); ThrowIfFailed( hr ); if ( !count ) return list; for( unsigned int j = 0; j < count; ++j ) { ComPtr<IDeviceInformation> deviceInfo; hr = devices->GetAt( j, deviceInfo.GetAddressOf() ); if ( SUCCEEDED(hr) ) { HString id; deviceInfo->get_Id( id.GetAddressOf() ); HString name; deviceInfo->get_Name( name.GetAddressOf() ); RendererDetail device; device.deviceId = id.GetRawBuffer( nullptr ); device.description = name.GetRawBuffer( nullptr ); list.emplace_back( device ); } } #endif #else // _WIN32_WINNT < _WIN32_WINNT_WIN8 // Enumerating with XAudio 2.7 ComPtr<IXAudio2> pXAudio2; HRESULT hr = XAudio2Create( pXAudio2.GetAddressOf() ); if ( FAILED(hr) ) { DebugTrace( "ERROR: XAudio 2.7 not found (have you called CoInitialize?)\n"); throw std::exception( "XAudio2Create" ); } UINT32 count = 0; hr = pXAudio2->GetDeviceCount( &count ); ThrowIfFailed(hr); if ( !count ) return list; list.reserve( count ); for( UINT32 j = 0; j < count; ++j ) { XAUDIO2_DEVICE_DETAILS details; hr = pXAudio2->GetDeviceDetails( j, &details ); if ( SUCCEEDED(hr) ) { RendererDetail device; device.deviceId = details.DeviceID; device.description = details.DisplayName; list.emplace_back( device ); } } #endif return list; }
bool QNativeSocketEnginePrivate::fetchConnectionParameters() { localPort = 0; localAddress.clear(); peerPort = 0; peerAddress.clear(); if (socketType == QAbstractSocket::TcpSocket) { ComPtr<IHostName> hostName; HString tmpHString; ComPtr<IStreamSocketInformation> info; if (FAILED(tcpSocket()->get_Information(&info))) { qWarning("QNativeSocketEnginePrivate::fetchConnectionParameters: Could not obtain socket info"); return false; } info->get_LocalAddress(&hostName); if (hostName) { hostName->get_CanonicalName(tmpHString.GetAddressOf()); localAddress.setAddress(qt_QStringFromHString(tmpHString)); info->get_LocalPort(tmpHString.GetAddressOf()); localPort = qt_QStringFromHString(tmpHString).toInt(); } if (!localPort && tcpListener) { ComPtr<IStreamSocketListenerInformation> listenerInfo = 0; tcpListener->get_Information(&listenerInfo); listenerInfo->get_LocalPort(tmpHString.GetAddressOf()); localPort = qt_QStringFromHString(tmpHString).toInt(); localAddress == QHostAddress::Any; } info->get_RemoteAddress(&hostName); if (hostName) { hostName->get_CanonicalName(tmpHString.GetAddressOf()); peerAddress.setAddress(qt_QStringFromHString(tmpHString)); info->get_RemotePort(tmpHString.GetAddressOf()); peerPort = qt_QStringFromHString(tmpHString).toInt(); } } else if (socketType == QAbstractSocket::UdpSocket) { ComPtr<IHostName> hostName; HString tmpHString; ComPtr<IDatagramSocketInformation> info; if (FAILED(udpSocket()->get_Information(&info))) { qWarning("QNativeSocketEnginePrivate::fetchConnectionParameters: Could not obtain socket information"); return false; } info->get_LocalAddress(&hostName); if (hostName) { hostName->get_CanonicalName(tmpHString.GetAddressOf()); localAddress.setAddress(qt_QStringFromHString(tmpHString)); info->get_LocalPort(tmpHString.GetAddressOf()); localPort = qt_QStringFromHString(tmpHString).toInt(); } info->get_RemoteAddress(&hostName); if (hostName) { hostName->get_CanonicalName(tmpHString.GetAddressOf()); peerAddress.setAddress(qt_QStringFromHString(tmpHString)); info->get_RemotePort(tmpHString.GetAddressOf()); peerPort = qt_QStringFromHString(tmpHString).toInt(); } } return true; }
QVariant QSystemLocalePrivate::uiLanguages() { if (QSysInfo::windowsVersion() >= QSysInfo::WV_VISTA) { typedef BOOL (WINAPI *GetUserPreferredUILanguagesFunc) ( DWORD dwFlags, PULONG pulNumLanguages, PWSTR pwszLanguagesBuffer, PULONG pcchLanguagesBuffer); static GetUserPreferredUILanguagesFunc GetUserPreferredUILanguages_ptr = 0; #ifndef Q_OS_WINRT if (!GetUserPreferredUILanguages_ptr) { QSystemLibrary lib(QLatin1String("kernel32")); if (lib.load()) GetUserPreferredUILanguages_ptr = (GetUserPreferredUILanguagesFunc)lib.resolve("GetUserPreferredUILanguages"); } #endif // !Q_OS_WINRT if (GetUserPreferredUILanguages_ptr) { unsigned long cnt = 0; QVarLengthArray<wchar_t, 64> buf(64); unsigned long size = buf.size(); if (!GetUserPreferredUILanguages_ptr(MUI_LANGUAGE_NAME, &cnt, buf.data(), &size)) { size = 0; if (GetLastError() == ERROR_INSUFFICIENT_BUFFER && GetUserPreferredUILanguages_ptr(MUI_LANGUAGE_NAME, &cnt, NULL, &size)) { buf.resize(size); if (!GetUserPreferredUILanguages_ptr(MUI_LANGUAGE_NAME, &cnt, buf.data(), &size)) return QStringList(); } } QStringList result; result.reserve(cnt); const wchar_t *str = buf.constData(); for (; cnt > 0; --cnt) { QString s = QString::fromWCharArray(str); if (s.isEmpty()) break; // something is wrong result.append(s); str += s.size()+1; } return result; } } #ifndef Q_OS_WINRT // old Windows before Vista return QStringList(QString::fromLatin1(winLangCodeToIsoName(GetUserDefaultUILanguage()))); #else // !Q_OS_WINRT QStringList result; ComPtr<ABI::Windows::Globalization::IApplicationLanguagesStatics> appLanguagesStatics; if (FAILED(GetActivationFactory(HString::MakeReference(RuntimeClass_Windows_Globalization_ApplicationLanguages).Get(), &appLanguagesStatics))) { qWarning("Could not obtain ApplicationLanguagesStatic"); return QStringList(); } ComPtr<ABI::Windows::Foundation::Collections::IVectorView<HSTRING> > languageList; // Languages is a ranked list of "long names" (e.g. en-US) of preferred languages, which matches // languages from the manifest with languages from the user's system. HRESULT hr = appLanguagesStatics->get_Languages(&languageList); Q_ASSERT_SUCCEEDED(hr); unsigned int size; hr = languageList->get_Size(&size); Q_ASSERT_SUCCEEDED(hr); result.reserve(size); for (unsigned int i = 0; i < size; ++i) { HString language; hr = languageList->GetAt(i, language.GetAddressOf()); Q_ASSERT_SUCCEEDED(hr); UINT32 length; PCWSTR rawString = language.GetRawBuffer(&length); result << QString::fromWCharArray(rawString, length); } // ManifestLanguages covers all languages given in the manifest and uses short names (like "en"). hr = appLanguagesStatics->get_ManifestLanguages(&languageList); Q_ASSERT_SUCCEEDED(hr); hr = languageList->get_Size(&size); Q_ASSERT_SUCCEEDED(hr); for (unsigned int i = 0; i < size; ++i) { HString language; hr = languageList->GetAt(i, language.GetAddressOf()); Q_ASSERT_SUCCEEDED(hr); UINT32 length; PCWSTR rawString = language.GetRawBuffer(&length); const QString qLanguage = QString::fromWCharArray(rawString, length); bool found = false; // Since ApplicationLanguages:::Languages uses long names, we compare the "pre-dash" part of // the language and filter it out, if it is already covered by a more specialized form. foreach (const QString &lang, result) { int dashIndex = lang.indexOf('-'); // There will not be any long name after the first short name was found, so we can stop. if (dashIndex == -1) break; if (lang.leftRef(dashIndex) == qLanguage) { found = true; break; } } if (!found) result << qLanguage; }
static QList<QNetworkInterfacePrivate *> interfaceListing() { QList<QNetworkInterfacePrivate *> interfaces; QList<HostNameInfo> hostList; ComPtr<INetworkInformationStatics> hostNameStatics; GetActivationFactory(HString::MakeReference(RuntimeClass_Windows_Networking_Connectivity_NetworkInformation).Get(), &hostNameStatics); ComPtr<IVectorView<HostName *>> hostNames; hostNameStatics->GetHostNames(&hostNames); if (!hostNames) return interfaces; unsigned int hostNameCount; hostNames->get_Size(&hostNameCount); for (unsigned i = 0; i < hostNameCount; ++i) { HostNameInfo hostInfo; ComPtr<IHostName> hostName; hostNames->GetAt(i, &hostName); HostNameType type; hostName->get_Type(&type); if (type == HostNameType_DomainName) continue; ComPtr<IIPInformation> ipInformation; hostName->get_IPInformation(&ipInformation); ComPtr<INetworkAdapter> currentAdapter; ipInformation->get_NetworkAdapter(¤tAdapter); currentAdapter->get_NetworkAdapterId(&hostInfo.adapterId); ComPtr<IReference<unsigned char>> prefixLengthReference; ipInformation->get_PrefixLength(&prefixLengthReference); prefixLengthReference->get_Value(&hostInfo.prefixLength); // invalid prefixes if ((type == HostNameType_Ipv4 && hostInfo.prefixLength > 32) || (type == HostNameType_Ipv6 && hostInfo.prefixLength > 128)) continue; HString name; hostName->get_CanonicalName(name.GetAddressOf()); UINT32 length; PCWSTR rawString = name.GetRawBuffer(&length); hostInfo.address = QString::fromWCharArray(rawString, length); hostList << hostInfo; } INetworkInformationStatics *networkInfoStatics; GetActivationFactory(HString::MakeReference(RuntimeClass_Windows_Networking_Connectivity_NetworkInformation).Get(), &networkInfoStatics); ComPtr<IVectorView<ConnectionProfile *>> connectionProfiles; networkInfoStatics->GetConnectionProfiles(&connectionProfiles); if (!connectionProfiles) return interfaces; unsigned int size; connectionProfiles->get_Size(&size); for (unsigned int i = 0; i < size; ++i) { QNetworkInterfacePrivate *iface = new QNetworkInterfacePrivate; interfaces << iface; ComPtr<IConnectionProfile> profile; connectionProfiles->GetAt(i, &profile); NetworkConnectivityLevel connectivityLevel; profile->GetNetworkConnectivityLevel(&connectivityLevel); if (connectivityLevel != NetworkConnectivityLevel_None) iface->flags = QNetworkInterface::IsUp | QNetworkInterface::IsRunning; ComPtr<INetworkAdapter> adapter; profile->get_NetworkAdapter(&adapter); UINT32 type; adapter->get_IanaInterfaceType(&type); if (type == 23) iface->flags |= QNetworkInterface::IsPointToPoint; GUID id; adapter->get_NetworkAdapterId(&id); OLECHAR adapterName[39]={0}; StringFromGUID2(id, adapterName, 39); iface->name = QString::fromWCharArray(adapterName); // According to http://stackoverflow.com/questions/12936193/how-unique-is-the-ethernet-network-adapter-id-in-winrt-it-is-derived-from-the-m // obtaining the MAC address using WinRT API is impossible // iface->hardwareAddress = ? for (int i = 0; i < hostList.length(); ++i) { const HostNameInfo hostInfo = hostList.at(i); if (id != hostInfo.adapterId) continue; QNetworkAddressEntry entry; entry.setIp(QHostAddress(hostInfo.address)); entry.setPrefixLength(hostInfo.prefixLength); iface->addressEntries << entry; hostList.takeAt(i); --i; } } return interfaces; }
QT_BEGIN_NAMESPACE //#define QHOSTINFO_DEBUG QHostInfo QHostInfoAgent::fromName(const QString &hostName) { QHostInfo results; QHostAddress address; if (address.setAddress(hostName)) { // Reverse lookup // TODO: is there a replacement for getnameinfo for winrt? Q_UNIMPLEMENTED(); return results; } QByteArray aceHostname = QUrl::toAce(hostName); results.setHostName(hostName); if (aceHostname.isEmpty()) { results.setError(QHostInfo::HostNotFound); results.setErrorString(hostName.isEmpty() ? tr("No host name given") : tr("Invalid hostname")); return results; } ComPtr<IHostNameFactory> hostnameFactory; HRESULT hr = RoGetActivationFactory(HString::MakeReference(RuntimeClass_Windows_Networking_HostName).Get(), IID_PPV_ARGS(&hostnameFactory)); Q_ASSERT_X(SUCCEEDED(hr), Q_FUNC_INFO, qPrintable(qt_error_string(hr))); ComPtr<IHostName> host; HStringReference hostNameRef((const wchar_t*)hostName.utf16()); hostnameFactory->CreateHostName(hostNameRef.Get(), &host); ComPtr<IDatagramSocketStatics> datagramSocketStatics; GetActivationFactory(HString::MakeReference(RuntimeClass_Windows_Networking_Sockets_DatagramSocket).Get(), &datagramSocketStatics); ComPtr<IAsyncOperation<IVectorView<EndpointPair *> *>> op; datagramSocketStatics->GetEndpointPairsAsync(host.Get(), HString::MakeReference(L"0").Get(), &op); ComPtr<IVectorView<EndpointPair *>> endpointPairs; 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 results; } if (!endpointPairs) return results; unsigned int size; endpointPairs->get_Size(&size); QList<QHostAddress> addresses; for (unsigned int i = 0; i < size; ++i) { ComPtr<IEndpointPair> endpointpair; endpointPairs->GetAt(i, &endpointpair); ComPtr<IHostName> remoteHost; endpointpair->get_RemoteHostName(&remoteHost); if (!remoteHost) continue; HostNameType type; remoteHost->get_Type(&type); if (type == HostNameType_DomainName) continue; HString name; remoteHost->get_CanonicalName(name.GetAddressOf()); UINT32 length; PCWSTR rawString = name.GetRawBuffer(&length); QHostAddress addr; addr.setAddress(QString::fromWCharArray(rawString, length)); if (!addresses.contains(addr)) addresses.append(addr); } results.setAddresses(addresses); return results; }
HRESULT FrameworkView::OnDataShareRequested(IDataTransferManager* aDTM, IDataRequestedEventArgs* aArg) { // Only share pages that contain a title and a URI nsCOMPtr<nsIMetroUIUtils> metroUIUtils = do_CreateInstance("@mozilla.org/metro-ui-utils;1"); if (!metroUIUtils) return E_FAIL; nsString url, title; nsresult rv = metroUIUtils->GetCurrentPageURI(url); nsresult rv2 = metroUIUtils->GetCurrentPageTitle(title); if (NS_FAILED(rv) || NS_FAILED(rv2)) { return E_FAIL; } // Get the package to share HRESULT hr; ComPtr<IDataRequest> request; AssertRetHRESULT(hr = aArg->get_Request(request.GetAddressOf()), hr); ComPtr<IDataPackage> dataPackage; AssertRetHRESULT(hr = request->get_Data(dataPackage.GetAddressOf()), hr); ComPtr<IDataPackagePropertySet> props; AssertRetHRESULT(hr = dataPackage->get_Properties(props.GetAddressOf()), hr); // Only add a URI to the package when there is no selected content. // This is because most programs treat URIs as highest priority to generate // their own preview, but we only want the selected content to show up. bool hasSelectedContent = false; metroUIUtils->GetHasSelectedContent(&hasSelectedContent); if (!hasSelectedContent) { ComPtr<IUriRuntimeClass> uri; AssertRetHRESULT(hr = MetroUtils::CreateUri(HStringReference(url.BeginReading()).Get(), uri), hr); // If there is no selection, then we don't support sharing for sites that // are not HTTP, HTTPS, FTP, and FILE. HString schemeHString; uri->get_SchemeName(schemeHString.GetAddressOf()); unsigned int length; LPCWSTR scheme = schemeHString.GetRawBuffer(&length); if (!scheme || wcscmp(scheme, L"http") && wcscmp(scheme, L"https") && wcscmp(scheme, L"ftp") && wcscmp(scheme, L"file")) { return S_OK; } AssertRetHRESULT(hr = dataPackage->SetUri(uri.Get()), hr); } // Add whatever content metroUIUtils wants us to for the text sharing nsString shareText; if (NS_SUCCEEDED(metroUIUtils->GetShareText(shareText)) && shareText.Length()) { AssertRetHRESULT(hr = dataPackage->SetText(HStringReference(shareText.BeginReading()).Get()) ,hr); } // Add whatever content metroUIUtils wants us to for the HTML sharing nsString shareHTML; if (NS_SUCCEEDED(metroUIUtils->GetShareHTML(shareHTML)) && shareHTML.Length()) { // The sharing format needs some special headers, so pass it through Windows ComPtr<IHtmlFormatHelperStatics> htmlFormatHelper; hr = GetActivationFactory(HStringReference(RuntimeClass_Windows_ApplicationModel_DataTransfer_HtmlFormatHelper).Get(), htmlFormatHelper.GetAddressOf()); AssertRetHRESULT(hr, hr); HSTRING fixedHTML; htmlFormatHelper->CreateHtmlFormat(HStringReference(shareHTML.BeginReading()).Get(), &fixedHTML); // And now add the fixed HTML to the data package AssertRetHRESULT(hr = dataPackage->SetHtmlFormat(fixedHTML), hr); } // Obtain the brand name nsCOMPtr<nsIStringBundleService> bundleService = do_GetService(NS_STRINGBUNDLE_CONTRACTID); NS_ENSURE_TRUE(bundleService, E_FAIL); nsCOMPtr<nsIStringBundle> brandBundle; nsString brandName; bundleService->CreateBundle("chrome://branding/locale/brand.properties", getter_AddRefs(brandBundle)); NS_ENSURE_TRUE(brandBundle, E_FAIL); if(brandBundle) { brandBundle->GetStringFromName(MOZ_UTF16("brandFullName"), getter_Copies(brandName)); } // Set these properties at the end. Otherwise users can get a // "There was a problem with the data package" error when there // is simply nothing to share. props->put_ApplicationName(HStringReference(brandName.BeginReading()).Get()); if (title.Length()) { props->put_Title(HStringReference(title.BeginReading()).Get()); } else { props->put_Title(HStringReference(brandName.BeginReading()).Get()); } props->put_Description(HStringReference(url.BeginReading()).Get()); return S_OK; }
// Draws the scene. void Game::Render() { // Don't try to render anything before the first Update. if (m_timer.GetFrameCount() == 0) { return; } // Prepare the command list to render a new frame. m_deviceResources->Prepare(); Clear(); auto commandList = m_deviceResources->GetCommandList(); PIXBeginEvent(commandList, PIX_COLOR_DEFAULT, L"Render"); // Set the descriptor heaps ID3D12DescriptorHeap* heaps[] = { m_resourceDescriptors->Heap(), m_states->Heap() }; commandList->SetDescriptorHeaps(_countof(heaps), heaps); auto t = static_cast<float>(m_timer.GetTotalSeconds()); // Cube 1 XMMATRIX world = XMMatrixRotationY(t) * XMMatrixTranslation(1.5f, -2.1f, (dist / 2.f) + dist * sin(t)); m_effect->SetWorld(world); m_effect->SetTexture(m_resourceDescriptors->GetGpuHandle(Descriptors::Earth), m_states->LinearClamp()); m_effect->Apply(commandList); m_cube->Draw(commandList); // Cube 2 world = XMMatrixRotationY(-t) * XMMatrixTranslation(1.5f, 0, (dist / 2.f) + dist * sin(t)); m_effect->SetWorld(world); m_effect->SetTexture(m_resourceDescriptors->GetGpuHandle(Descriptors::Windows95_sRGB), m_states->LinearClamp()); m_effect->Apply(commandList); m_cube->Draw(commandList); // Cube 3 world = XMMatrixRotationY(t) * XMMatrixTranslation(1.5f, 2.1f, (dist / 2.f) + dist * sin(t)); m_effect->SetWorld(world); m_effect->SetTexture(m_resourceDescriptors->GetGpuHandle(Descriptors::Windows95), m_states->LinearClamp()); m_effect->Apply(commandList); m_cube->Draw(commandList); // Cube 4 world = XMMatrixRotationY(-t) * XMMatrixTranslation(-1.5f, -2.1f, (dist / 2.f) + dist * sin(t)); m_effect->SetWorld(world); m_effect->SetTexture(m_resourceDescriptors->GetGpuHandle(Descriptors::Earth_Imm), m_states->LinearClamp()); m_effect->Apply(commandList); m_cube->Draw(commandList); // Cube 5 world = XMMatrixRotationY(t) * XMMatrixTranslation(-1.5f, 0, (dist / 2.f) + dist * sin(t)); m_effect->SetWorld(world); m_effect->SetTexture(m_resourceDescriptors->GetGpuHandle(Descriptors::DirectXLogo_BC1), m_states->LinearClamp()); m_effect->Apply(commandList); m_cube->Draw(commandList); // Cube 6 world = XMMatrixRotationY(-t) * XMMatrixTranslation(-1.5f, 2.1f, (dist / 2.f) + dist * sin(t)); m_effect->SetWorld(world); m_effect->SetTexture(m_resourceDescriptors->GetGpuHandle(Descriptors::DirectXLogo), m_states->LinearClamp()); m_effect->Apply(commandList); m_cube->Draw(commandList); PIXEndEvent(commandList); if (m_frame == 10) { m_screenshot = m_deviceResources->GetRenderTarget(); } // Show the new frame. PIXBeginEvent(m_deviceResources->GetCommandQueue(), PIX_COLOR_DEFAULT, L"Present"); m_deviceResources->Present(); m_graphicsMemory->Commit(m_deviceResources->GetCommandQueue()); PIXEndEvent(m_deviceResources->GetCommandQueue()); if (m_screenshot) { // We take the shot here to cope with lost device OutputDebugStringA("******** SCREENSHOT TEST BEGIN *************\n"); bool success = true; #if defined(_XBOX_ONE) && defined(_TITLE) const wchar_t sspath[MAX_PATH] = L"T:\\"; #elif defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_APP) wchar_t sspath[MAX_PATH] = {}; using namespace Microsoft::WRL; using namespace Microsoft::WRL::Wrappers; using namespace ABI::Windows::Foundation; ComPtr<ABI::Windows::Storage::IApplicationDataStatics> appStatics; DX::ThrowIfFailed(GetActivationFactory(HStringReference(RuntimeClass_Windows_Storage_ApplicationData).Get(), appStatics.GetAddressOf())); ComPtr<ABI::Windows::Storage::IApplicationData> appData; DX::ThrowIfFailed(appStatics->get_Current(appData.GetAddressOf())); // Temporary folder { ComPtr<ABI::Windows::Storage::IStorageFolder> folder; DX::ThrowIfFailed(appData->get_TemporaryFolder(folder.GetAddressOf())); ComPtr<ABI::Windows::Storage::IStorageItem> item; DX::ThrowIfFailed(folder.As(&item)); HString folderName; DX::ThrowIfFailed(item->get_Path(folderName.GetAddressOf())); unsigned int len; PCWSTR szPath = folderName.GetRawBuffer(&len); if (wcscpy_s(sspath, MAX_PATH, szPath) > 0 || wcscat_s(sspath, L"\\") > 0) { throw std::exception("TemporaryFolder"); } } #else const wchar_t sspath[MAX_PATH] = L"."; #endif OutputDebugStringA("Output path: "); OutputDebugStringW(sspath); OutputDebugStringA("\n"); wchar_t sspng[MAX_PATH] = {}; wchar_t ssjpg[MAX_PATH] = {}; wchar_t ssbmp[MAX_PATH] = {}; wchar_t sstif[MAX_PATH] = {}; wchar_t ssdds[MAX_PATH] = {}; swprintf_s(sspng, L"%ls\\SCREENSHOT.PNG", sspath); swprintf_s(ssjpg, L"%ls\\SCREENSHOT.JPG", sspath); swprintf_s(ssbmp, L"%ls\\SCREENSHOT.BMP", sspath); swprintf_s(sstif, L"%ls\\SCREENSHOT.TIF", sspath); swprintf_s(ssdds, L"%ls\\SCREENSHOT.DDS", sspath); DeleteFileW(sspng); DeleteFileW(ssjpg); DeleteFileW(ssbmp); DeleteFileW(sstif); DeleteFileW(ssdds); HRESULT hr = SaveWICTextureToFile(m_deviceResources->GetCommandQueue(), m_screenshot.Get(), GUID_ContainerFormatPng, sspng, D3D12_RESOURCE_STATE_PRESENT, D3D12_RESOURCE_STATE_PRESENT, &GUID_WICPixelFormat32bppBGRA); if (FAILED(hr)) { char buff[128] = {}; sprintf_s(buff, "ERROR: SaveWICTextureToFile (PNG) failed %08X\n", hr); OutputDebugStringA(buff); success = false; } else if (GetFileAttributesW(sspng) != INVALID_FILE_ATTRIBUTES) { OutputDebugStringA("Wrote SCREENSHOT.PNG\n"); } else { OutputDebugStringA("ERROR: Missing SCREENSHOT.PNG!\n"); success = false; } hr = SaveWICTextureToFile(m_deviceResources->GetCommandQueue(), m_screenshot.Get(), GUID_ContainerFormatJpeg, ssjpg, D3D12_RESOURCE_STATE_PRESENT, D3D12_RESOURCE_STATE_PRESENT); if (FAILED(hr)) { char buff[128] = {}; sprintf_s(buff, "ERROR: SaveWICTextureToFile (JPG) failed %08X\n", hr); OutputDebugStringA(buff); success = false; } else if (GetFileAttributesW(ssjpg) != INVALID_FILE_ATTRIBUTES) { OutputDebugStringA("Wrote SCREENSHOT.JPG\n"); } else { OutputDebugStringA("ERROR: Missing SCREENSHOT.JPG!\n"); success = false; } hr = SaveWICTextureToFile(m_deviceResources->GetCommandQueue(), m_screenshot.Get(), GUID_ContainerFormatBmp, ssbmp, D3D12_RESOURCE_STATE_PRESENT, D3D12_RESOURCE_STATE_PRESENT, &GUID_WICPixelFormat16bppBGR565); if (FAILED(hr)) { char buff[128] = {}; sprintf_s(buff, "ERROR: SaveWICTextureToFile (BMP) failed %08X\n", hr); OutputDebugStringA(buff); success = false; } else if (GetFileAttributesW(ssbmp) != INVALID_FILE_ATTRIBUTES) { OutputDebugStringA("Wrote SCREENSHOT.BMP\n"); } else { OutputDebugStringA("ERROR: Missing SCREENSHOT.BMP!\n"); success = false; } hr = SaveWICTextureToFile(m_deviceResources->GetCommandQueue(), m_screenshot.Get(), GUID_ContainerFormatTiff, sstif, D3D12_RESOURCE_STATE_PRESENT, D3D12_RESOURCE_STATE_PRESENT, nullptr, [&](IPropertyBag2* props) { PROPBAG2 options[2] = { 0, 0 }; options[0].pstrName = const_cast<wchar_t*>(L"CompressionQuality"); options[1].pstrName = const_cast<wchar_t*>(L"TiffCompressionMethod"); VARIANT varValues[2]; varValues[0].vt = VT_R4; varValues[0].fltVal = 0.75f; varValues[1].vt = VT_UI1; varValues[1].bVal = WICTiffCompressionNone; (void)props->Write(2, options, varValues); }); if (FAILED(hr)) { char buff[128] = {}; sprintf_s(buff, "ERROR: SaveWICTextureToFile (TIFF) failed %08X\n", hr); OutputDebugStringA(buff); success = false; } else if (GetFileAttributesW(sstif) != INVALID_FILE_ATTRIBUTES) { OutputDebugStringA("Wrote SCREENSHOT.TIF\n"); } else { OutputDebugStringA("ERROR: Missing SCREENSHOT.TIF!\n"); success = false; } hr = SaveDDSTextureToFile(m_deviceResources->GetCommandQueue(), m_screenshot.Get(), ssdds, D3D12_RESOURCE_STATE_PRESENT, D3D12_RESOURCE_STATE_PRESENT); if (FAILED(hr)) { char buff[128] = {}; sprintf_s(buff, "ERROR: SaveWICTextureToFile (DDS) failed %08X\n", hr); OutputDebugStringA(buff); success = false; } else if (GetFileAttributesW(ssdds) != INVALID_FILE_ATTRIBUTES) { OutputDebugStringA("Wrote SCREENSHOT.DDS\n"); } else { OutputDebugStringA("ERROR: Missing SCREENSHOT.DDS!\n"); success = false; } // TODO - pass in D3D12_HEAP_TYPE_READBACK resource // ScreenGrab of an MSAA resource is tested elsewhere OutputDebugStringA(success ? "Passed\n" : "Failed\n"); OutputDebugStringA("********* SCREENSHOT TEST END **************\n"); m_screenshot.Reset(); } }