ComArray<BYTE> GetSha1Hash(BYTE const* data, size_t dataSize)
{
// Look up WinRT activation factories.
ComPtr<ICryptographicBufferStatics> bufferStatics;
ThrowIfFailed(GetActivationFactory(Wrappers::HStringReference(RuntimeClass_Windows_Security_Cryptography_CryptographicBuffer).Get(), &bufferStatics));
ComPtr<IHashAlgorithmNamesStatics> algorithmNames;
ThrowIfFailed(GetActivationFactory(Wrappers::HStringReference(RuntimeClass_Windows_Security_Cryptography_Core_HashAlgorithmNames).Get(), &algorithmNames));
ComPtr<IHashAlgorithmProviderStatics> algorithmStatics;
ThrowIfFailed(GetActivationFactory(Wrappers::HStringReference(RuntimeClass_Windows_Security_Cryptography_Core_HashAlgorithmProvider).Get(), &algorithmStatics));
// Convert the input data to an IBuffer.
ComPtr<IBuffer> dataBuffer;
ThrowIfFailed(bufferStatics->CreateFromByteArray(static_cast<UINT32>(dataSize), const_cast<BYTE*>(data), &dataBuffer));
// Look up the name of the SHA1 hashing algorithm.
WinString sha1Name;
ThrowIfFailed(algorithmNames->get_Sha1(sha1Name.GetAddressOf()));
// Instantiate the hashing algorithm.
ComPtr<IHashAlgorithmProvider> algorithm;
ThrowIfFailed(algorithmStatics->OpenAlgorithm(sha1Name, &algorithm));
// Hash our data.
ComPtr<IBuffer> resultBuffer;
ThrowIfFailed(algorithm->HashData(dataBuffer.Get(), &resultBuffer));
// Convert IBuffer -> ComArray.
ComArray<BYTE> result;
ThrowIfFailed(bufferStatics->CopyToByteArray(resultBuffer.Get(), result.GetAddressOfSize(), result.GetAddressOfData()));
return result;
}
//---------------------------------------------------------------------------
HRESULT Get_Folder(HStringReference Folder_Name, ComPtr<IStorageFolder> &Folder)
{
//Try to access folder directly
ComPtr<IStorageFolderStatics> Storage;
if (SUCCEEDED(GetActivationFactory(HString::MakeReference(RuntimeClass_Windows_Storage_StorageFolder).Get(), &Storage)) && Storage)
{
ComPtr<IAsyncOperation<StorageFolder*> > Async_GetFolder;
if (SUCCEEDED(Storage->GetFolderFromPathAsync(Folder_Name.Get(), &Async_GetFolder)) &&
SUCCEEDED(Await(Async_GetFolder)) &&
SUCCEEDED(Async_GetFolder->GetResults(&Folder)) &&
Folder)
return S_OK;
}
//Try to access folder by sha256 hashed path in future access list
ComPtr<IBuffer> Path_Buffer;
ComPtr<IBuffer> Hash_Buffer;
ComPtr<ICryptographicBufferStatics> Cryptographic_Buffer_Statics;
ComPtr<IHashAlgorithmProviderStatics> Hash_Provider_Statics;
ComPtr<IHashAlgorithmProvider> Hash_Provider;
UINT32 Buffer_Lenght = 0;
UINT32 Hash_Lenght = 0;
HString Path_Hash;
if (SUCCEEDED(GetActivationFactory(HString::MakeReference(RuntimeClass_Windows_Security_Cryptography_CryptographicBuffer).Get(), &Cryptographic_Buffer_Statics)) &&
Cryptographic_Buffer_Statics &&
SUCCEEDED(Cryptographic_Buffer_Statics->ConvertStringToBinary(Folder_Name.Get(), BinaryStringEncoding_Utf16LE, &Path_Buffer)) &&
Path_Buffer &&
SUCCEEDED(GetActivationFactory(HString::MakeReference(RuntimeClass_Windows_Security_Cryptography_Core_HashAlgorithmProvider).Get(), &Hash_Provider_Statics)) &&
Hash_Provider_Statics &&
SUCCEEDED(Hash_Provider_Statics->OpenAlgorithm(HString::MakeReference(L"SHA256").Get(), &Hash_Provider)) &&
Hash_Provider &&
SUCCEEDED(Hash_Provider->HashData(*Path_Buffer.GetAddressOf(), &Hash_Buffer)) &&
Hash_Buffer &&
SUCCEEDED(Hash_Buffer->get_Length(&Buffer_Lenght)) &&
Buffer_Lenght &&
SUCCEEDED(Hash_Provider->get_HashLength(&Hash_Lenght)) &&
Hash_Lenght &&
Buffer_Lenght == Hash_Lenght &&
SUCCEEDED(Cryptographic_Buffer_Statics->EncodeToBase64String(*Hash_Buffer.GetAddressOf(), Path_Hash.GetAddressOf())))
{
ComPtr<IStorageApplicationPermissionsStatics> Permissions_Manager;
if (SUCCEEDED(GetActivationFactory(HString::MakeReference(RuntimeClass_Windows_Storage_AccessCache_StorageApplicationPermissions).Get(), &Permissions_Manager)) && Permissions_Manager)
{
ComPtr<IStorageItemAccessList> FutureAccess_List;
ComPtr<IAsyncOperation<StorageFolder*> > Async_GetFolder_FutureAccess;
if (SUCCEEDED(Permissions_Manager->get_FutureAccessList(&FutureAccess_List)) &&
FutureAccess_List &&
SUCCEEDED(FutureAccess_List->GetFolderAsync(Folder_Name.Get(), &Async_GetFolder_FutureAccess)) &&
Await(Async_GetFolder_FutureAccess) &&
SUCCEEDED(Async_GetFolder_FutureAccess->GetResults(&Folder)) &&
Folder)
return S_OK;
}
}
return E_FAIL;
}
void
FrameworkView::SetupContracts()
{
LogFunction();
HRESULT hr;
// Add support for the share charm to indicate that we share data to other apps
ComPtr<IDataTransferManagerStatics> transStatics;
hr = GetActivationFactory(HStringReference(RuntimeClass_Windows_ApplicationModel_DataTransfer_DataTransferManager).Get(),
transStatics.GetAddressOf());
AssertHRESULT(hr);
ComPtr<IDataTransferManager> trans;
AssertHRESULT(transStatics->GetForCurrentView(trans.GetAddressOf()));
trans->add_DataRequested(Callback<__FITypedEventHandler_2_Windows__CApplicationModel__CDataTransfer__CDataTransferManager_Windows__CApplicationModel__CDataTransfer__CDataRequestedEventArgs_t>(
this, &FrameworkView::OnDataShareRequested).Get(), &mDataTransferRequested);
// Add support for the search charm to indicate that you can search using our app.
ComPtr<ISearchPaneStatics> searchStatics;
hr = GetActivationFactory(HStringReference(RuntimeClass_Windows_ApplicationModel_Search_SearchPane).Get(),
searchStatics.GetAddressOf());
AssertHRESULT(hr);
ComPtr<ISearchPane> searchPane;
AssertHRESULT(searchStatics->GetForCurrentView(searchPane.GetAddressOf()));
searchPane->add_QuerySubmitted(Callback<__FITypedEventHandler_2_Windows__CApplicationModel__CSearch__CSearchPane_Windows__CApplicationModel__CSearch__CSearchPaneQuerySubmittedEventArgs_t>(
this, &FrameworkView::OnSearchQuerySubmitted).Get(), &mSearchQuerySubmitted);
// Add support for the devices play to charm
ComPtr<IPlayToManagerStatics> playToStatics;
hr = GetActivationFactory(HStringReference(RuntimeClass_Windows_Media_PlayTo_PlayToManager).Get(),
playToStatics.GetAddressOf());
AssertHRESULT(hr);
ComPtr<IPlayToManager> playTo;
AssertHRESULT(playToStatics->GetForCurrentView(playTo.GetAddressOf()));
playTo->add_SourceRequested(Callback<__FITypedEventHandler_2_Windows__CMedia__CPlayTo__CPlayToManager_Windows__CMedia__CPlayTo__CPlayToSourceRequestedEventArgs_t>(
this, &FrameworkView::OnPlayToSourceRequested).Get(), &mPlayToRequested);
// Add support for the settings charm
ComPtr<ISettingsPaneStatics> settingsPaneStatics;
hr = GetActivationFactory(HStringReference(RuntimeClass_Windows_UI_ApplicationSettings_SettingsPane).Get(),
settingsPaneStatics.GetAddressOf());
AssertHRESULT(hr);
ComPtr<ISettingsPane> settingsPane;
AssertHRESULT(settingsPaneStatics->GetForCurrentView(settingsPane.GetAddressOf()));
settingsPane->add_CommandsRequested(Callback<__FITypedEventHandler_2_Windows__CUI__CApplicationSettings__CSettingsPane_Windows__CUI__CApplicationSettings__CSettingsPaneCommandsRequestedEventArgs_t>(
this, &FrameworkView::OnSettingsCommandsRequested).Get(), &mSettingsPane);
// Add support for the settings print charm
ComPtr<IPrintManagerStatic> printStatics;
hr = GetActivationFactory(HStringReference(RuntimeClass_Windows_Graphics_Printing_PrintManager).Get(),
printStatics.GetAddressOf());
AssertHRESULT(hr);
ComPtr<IPrintManager> printManager;
AssertHRESULT(printStatics->GetForCurrentView(printManager.GetAddressOf()));
printManager->add_PrintTaskRequested(Callback<__FITypedEventHandler_2_Windows__CGraphics__CPrinting__CPrintManager_Windows__CGraphics__CPrinting__CPrintTaskRequestedEventArgs_t>(
this, &FrameworkView::OnPrintTaskRequested).Get(), &mPrintManager);
}
bool Trim11::registerForRendererTrimRequest()
{
#if defined(ANGLE_ENABLE_WINDOWS_STORE)
ICoreApplication *coreApplication = nullptr;
HRESULT result = GetActivationFactory(
HStringReference(RuntimeClass_Windows_ApplicationModel_Core_CoreApplication).Get(),
&coreApplication);
if (SUCCEEDED(result))
{
auto suspendHandler = Callback<IEventHandler<SuspendingEventArgs *>>(
[this](IInspectable *, ISuspendingEventArgs *) -> HRESULT {
trim();
return S_OK;
});
result =
coreApplication->add_Suspending(suspendHandler.Get(), &mApplicationSuspendedEventToken);
}
SafeRelease(coreApplication);
if (FAILED(result))
{
return false;
}
#endif
return true;
}
// Called by MetroApp
void
FrameworkView::Shutdown()
{
LogFunction();
mShuttingDown = true;
if (mWindow && mWindowVisibilityChanged.value) {
mWindow->remove_VisibilityChanged(mWindowVisibilityChanged);
mWindow->remove_Activated(mWindowActivated);
mWindow->remove_Closed(mWindowClosed);
mWindow->remove_SizeChanged(mWindowSizeChanged);
mWindow->remove_AutomationProviderRequested(mAutomationProviderRequested);
}
ComPtr<ABI::Windows::Graphics::Display::IDisplayPropertiesStatics> dispProps;
if (mDisplayPropertiesChanged.value &&
SUCCEEDED(GetActivationFactory(HStringReference(RuntimeClass_Windows_Graphics_Display_DisplayProperties).Get(), dispProps.GetAddressOf()))) {
dispProps->remove_LogicalDpiChanged(mDisplayPropertiesChanged);
}
ComPtr<ABI::Windows::UI::ViewManagement::IInputPaneStatics> inputStatic;
if (mSoftKeyboardHidden.value &&
SUCCEEDED(GetActivationFactory(HStringReference(RuntimeClass_Windows_UI_ViewManagement_InputPane).Get(), inputStatic.GetAddressOf()))) {
ComPtr<ABI::Windows::UI::ViewManagement::IInputPane> inputPane;
if (SUCCEEDED(inputStatic->GetForCurrentView(inputPane.GetAddressOf()))) {
inputPane->remove_Hiding(mSoftKeyboardHidden);
inputPane->remove_Showing(mSoftKeyboardShown);
}
}
if (mAutomationProvider) {
ComPtr<IUIABridge> provider;
mAutomationProvider.As(&provider);
if (provider) {
provider->Disconnect();
}
}
mAutomationProvider = nullptr;
mMetroInput = nullptr;
delete sSettingsArray;
sSettingsArray = nullptr;
mWidget = nullptr;
mMetroApp = nullptr;
mWindow = nullptr;
}
void
FrameworkView::UpdateLogicalDPI()
{
ComPtr<ABI::Windows::Graphics::Display::IDisplayPropertiesStatics> dispProps;
HRESULT hr = GetActivationFactory(HStringReference(RuntimeClass_Windows_Graphics_Display_DisplayProperties).Get(),
dispProps.GetAddressOf());
AssertHRESULT(hr);
FLOAT value;
AssertHRESULT(dispProps->get_LogicalDpi(&value));
SetDpi(value);
}
// Request a shutdown of the application
void
MetroApp::CoreExit()
{
HRESULT hr;
ComPtr<ICoreApplicationExit> coreExit;
HStringReference className(RuntimeClass_Windows_ApplicationModel_Core_CoreApplication);
hr = GetActivationFactory(className.Get(), coreExit.GetAddressOf());
NS_ASSERTION(SUCCEEDED(hr), "Activation of ICoreApplicationExit");
if (SUCCEEDED(hr)) {
coreExit->Exit();
}
}
void
FrameworkView::SetCursor(CoreCursorType aCursorType, DWORD aCustomId)
{
if (mShuttingDown) {
return;
}
NS_ASSERTION(mWindow, "SetWindow must be called before SetCursor!");
ComPtr<ABI::Windows::UI::Core::ICoreCursorFactory> factory;
AssertHRESULT(GetActivationFactory(HStringReference(RuntimeClass_Windows_UI_Core_CoreCursor).Get(), factory.GetAddressOf()));
ComPtr<ABI::Windows::UI::Core::ICoreCursor> cursor;
AssertHRESULT(factory->CreateCursor(aCursorType, aCustomId, cursor.GetAddressOf()));
mWindow->put_PointerCursor(cursor.Get());
}
//---------------------------------------------------------------------------
HRESULT Add_Item_To_FUA(HStringReference Path, ComPtr<IStorageItem> &Item)
{
ComPtr<IBuffer> Path_Buffer;
ComPtr<IBuffer> Hash_Buffer;
ComPtr<ICryptographicBufferStatics> Cryptographic_Buffer_Statics;
ComPtr<IHashAlgorithmProviderStatics> Hash_Provider_Statics;
ComPtr<IHashAlgorithmProvider> Hash_Provider;
UINT32 Buffer_Lenght = 0;
UINT32 Hash_Lenght = 0;
HString Path_Hash;
if (SUCCEEDED(GetActivationFactory(HString::MakeReference(RuntimeClass_Windows_Security_Cryptography_CryptographicBuffer).Get(), &Cryptographic_Buffer_Statics)) &&
Cryptographic_Buffer_Statics &&
SUCCEEDED(Cryptographic_Buffer_Statics->ConvertStringToBinary(Path.Get(), BinaryStringEncoding_Utf16LE, &Path_Buffer)) &&
Path_Buffer &&
SUCCEEDED(GetActivationFactory(HString::MakeReference(RuntimeClass_Windows_Security_Cryptography_Core_HashAlgorithmProvider).Get(), &Hash_Provider_Statics)) &&
Hash_Provider_Statics &&
SUCCEEDED(Hash_Provider_Statics->OpenAlgorithm(HString::MakeReference(L"SHA256").Get(), &Hash_Provider)) &&
Hash_Provider &&
SUCCEEDED(Hash_Provider->HashData(*Path_Buffer.GetAddressOf(), &Hash_Buffer)) &&
Hash_Buffer &&
SUCCEEDED(Hash_Buffer->get_Length(&Buffer_Lenght)) &&
Buffer_Lenght &&
SUCCEEDED(Hash_Provider->get_HashLength(&Hash_Lenght)) &&
Hash_Lenght &&
Buffer_Lenght == Hash_Lenght &&
SUCCEEDED(Cryptographic_Buffer_Statics->EncodeToBase64String(*Hash_Buffer.GetAddressOf(), Path_Hash.GetAddressOf())))
{
ComPtr<IStorageApplicationPermissionsStatics> Permissions_Manager;
ComPtr<IStorageItemAccessList> FutureAccess_List;
if (SUCCEEDED(GetActivationFactory(HString::MakeReference(RuntimeClass_Windows_Storage_AccessCache_StorageApplicationPermissions).Get(), &Permissions_Manager)) &&
Permissions_Manager &&
SUCCEEDED(Permissions_Manager->get_FutureAccessList(&FutureAccess_List)) &&
FutureAccess_List)
return FutureAccess_List->AddOrReplace(Path_Hash.Get(), *Item.GetAddressOf(), HString::MakeReference(L"").Get());
}
return E_FAIL;
}
void
FrameworkView::AddEventHandlers() {
NS_ASSERTION(mWindow, "SetWindow must be called before AddEventHandlers!");
NS_ASSERTION(mWidget, "SetWidget must be called before AddEventHAndlers!");
mMetroInput = Make<MetroInput>(mWidget.Get(),
mWindow.Get());
mWindow->add_VisibilityChanged(Callback<__FITypedEventHandler_2_Windows__CUI__CCore__CCoreWindow_Windows__CUI__CCore__CVisibilityChangedEventArgs>(
this, &FrameworkView::OnWindowVisibilityChanged).Get(), &mWindowVisibilityChanged);
mWindow->add_Activated(Callback<__FITypedEventHandler_2_Windows__CUI__CCore__CCoreWindow_Windows__CUI__CCore__CWindowActivatedEventArgs_t>(
this, &FrameworkView::OnWindowActivated).Get(), &mWindowActivated);
mWindow->add_Closed(Callback<__FITypedEventHandler_2_Windows__CUI__CCore__CCoreWindow_Windows__CUI__CCore__CCoreWindowEventArgs_t>(
this, &FrameworkView::OnWindowClosed).Get(), &mWindowClosed);
mWindow->add_SizeChanged(Callback<__FITypedEventHandler_2_Windows__CUI__CCore__CCoreWindow_Windows__CUI__CCore__CWindowSizeChangedEventArgs_t>(
this, &FrameworkView::OnWindowSizeChanged).Get(), &mWindowSizeChanged);
mWindow->add_AutomationProviderRequested(Callback<__FITypedEventHandler_2_Windows__CUI__CCore__CCoreWindow_Windows__CUI__CCore__CAutomationProviderRequestedEventArgs_t>(
this, &FrameworkView::OnAutomationProviderRequested).Get(), &mAutomationProviderRequested);
HRESULT hr;
ComPtr<ABI::Windows::Graphics::Display::IDisplayPropertiesStatics> dispProps;
if (SUCCEEDED(GetActivationFactory(HStringReference(RuntimeClass_Windows_Graphics_Display_DisplayProperties).Get(), dispProps.GetAddressOf()))) {
hr = dispProps->add_LogicalDpiChanged(Callback<ABI::Windows::Graphics::Display::IDisplayPropertiesEventHandler, FrameworkView>(
this, &FrameworkView::OnLogicalDpiChanged).Get(), &mDisplayPropertiesChanged);
LogHRESULT(hr);
}
ComPtr<ABI::Windows::UI::ViewManagement::IInputPaneStatics> inputStatic;
if (SUCCEEDED(hr = GetActivationFactory(HStringReference(RuntimeClass_Windows_UI_ViewManagement_InputPane).Get(), inputStatic.GetAddressOf()))) {
ComPtr<ABI::Windows::UI::ViewManagement::IInputPane> inputPane;
if (SUCCEEDED(inputStatic->GetForCurrentView(inputPane.GetAddressOf()))) {
inputPane->add_Hiding(Callback<__FITypedEventHandler_2_Windows__CUI__CViewManagement__CInputPane_Windows__CUI__CViewManagement__CInputPaneVisibilityEventArgs_t>(
this, &FrameworkView::OnSoftkeyboardHidden).Get(), &mSoftKeyboardHidden);
inputPane->add_Showing(Callback<__FITypedEventHandler_2_Windows__CUI__CViewManagement__CInputPane_Windows__CUI__CViewManagement__CInputPaneVisibilityEventArgs_t>(
this, &FrameworkView::OnSoftkeyboardShown).Get(), &mSoftKeyboardShown);
}
}
}
void
FrameworkView::AddSetting(ISettingsPaneCommandsRequestedEventArgs* aArgs,
uint32_t aId, HString& aSettingName)
{
HRESULT hr;
ComPtr<ABI::Windows::UI::ApplicationSettings::ISettingsPaneCommandsRequest> request;
AssertHRESULT(aArgs->get_Request(request.GetAddressOf()));
// ApplicationCommands - vector that holds SettingsCommand to be invoked
ComPtr<IVector<ABI::Windows::UI::ApplicationSettings::SettingsCommand*>> list;
AssertHRESULT(request->get_ApplicationCommands(list.GetAddressOf()));
ComPtr<IUICommand> command;
ComPtr<ISettingsCommandFactory> factory;
hr = GetActivationFactory(HStringReference(RuntimeClass_Windows_UI_ApplicationSettings_SettingsCommand).Get(),
factory.GetAddressOf());
AssertHRESULT(hr);
// Create the IInspectable string property that identifies this command
ComPtr<IInspectable> prop;
ComPtr<IPropertyValueStatics> propStatics;
hr = GetActivationFactory(HStringReference(RuntimeClass_Windows_Foundation_PropertyValue).Get(),
propStatics.GetAddressOf());
AssertHRESULT(hr);
hr = propStatics->CreateUInt32(aId, prop.GetAddressOf());
AssertHRESULT(hr);
// Create the command
hr = factory->CreateSettingsCommand(prop.Get(), aSettingName.Get(),
Callback<ABI::Windows::UI::Popups::IUICommandInvokedHandler>(
this, &FrameworkView::OnSettingsCommandInvoked).Get(), command.GetAddressOf());
AssertHRESULT(hr);
// Add it to the list
hr = list->Append(command.Get());
AssertHRESULT(hr);
}
static float GetLogicalDpi()
{
ComPtr<ABI::Windows::Graphics::Display::IDisplayPropertiesStatics> displayProperties;
if (SUCCEEDED(GetActivationFactory(HStringReference(RuntimeClass_Windows_Graphics_Display_DisplayProperties).Get(), displayProperties.GetAddressOf())))
{
float dpi = 96.0f;
if (SUCCEEDED(displayProperties->get_LogicalDpi(&dpi)))
{
return dpi;
}
}
// Return 96 dpi as a default if display properties cannot be obtained.
return 96.0f;
}
void Trim11::unregisterForRendererTrimRequest()
{
#if defined(ANGLE_ENABLE_WINDOWS_STORE)
if (mApplicationSuspendedEventToken.value != 0)
{
ICoreApplication *coreApplication = nullptr;
if (SUCCEEDED(GetActivationFactory(
HStringReference(RuntimeClass_Windows_ApplicationModel_Core_CoreApplication).Get(),
&coreApplication)))
{
coreApplication->remove_Suspending(mApplicationSuspendedEventToken);
}
mApplicationSuspendedEventToken.value = 0;
SafeRelease(coreApplication);
}
#endif
}
bool CoreWindowNativeWindow::initialize(EGLNativeWindowType window, IPropertySet *propertySet)
{
mOrientationChangedEventToken.value = 0;
ComPtr<IPropertySet> props = propertySet;
ComPtr<IInspectable> win = window;
SIZE swapChainSize = {};
bool swapChainSizeSpecified = false;
HRESULT result = S_OK;
// IPropertySet is an optional parameter and can be null.
// If one is specified, cache as an IMap and read the properties
// used for initial host initialization.
if (propertySet)
{
result = props.As(&mPropertyMap);
if (SUCCEEDED(result))
{
// The EGLRenderSurfaceSizeProperty is optional and may be missing. The IPropertySet
// was prevalidated to contain the EGLNativeWindowType before being passed to
// this host.
result = GetOptionalSizePropertyValue(mPropertyMap, EGLRenderSurfaceSizeProperty, &swapChainSize, &swapChainSizeSpecified);
}
}
if (SUCCEEDED(result))
{
result = win.As(&mCoreWindow);
}
if (SUCCEEDED(result))
{
// If a swapchain size is specfied, then the automatic resize
// behaviors implemented by the host should be disabled. The swapchain
// will be still be scaled when being rendered to fit the bounds
// of the host.
// Scaling of the swapchain output occurs automatically because if
// the scaling mode setting DXGI_SCALING_STRETCH on the swapchain.
if (swapChainSizeSpecified)
{
mClientRect = { 0, 0, swapChainSize.cx, swapChainSize.cy };
mSupportsSwapChainResize = false;
}
else
{
result = GetCoreWindowSizeInPixels(mCoreWindow, &mClientRect);
}
}
if (SUCCEEDED(result))
{
ComPtr<ABI::Windows::Graphics::Display::IDisplayInformationStatics> displayInformation;
result = GetActivationFactory(HStringReference(RuntimeClass_Windows_Graphics_Display_DisplayInformation).Get(), &displayInformation);
if (SUCCEEDED(result))
{
result = displayInformation->GetForCurrentView(&mDisplayInformation);
}
}
if (SUCCEEDED(result))
{
mNewClientRect = mClientRect;
mClientRectChanged = false;
return registerForSizeChangeEvents();
}
return false;
}
// Get the activation factory for the IThreadPoolStatics interface.
ComPtr<IThreadPoolStatics> threadPool;
HRESULT hr = GetActivationFactory(HStringReference(RuntimeClass_Windows_System_Threading_ThreadPool).Get(), &threadPool);
if (FAILED(hr))
{
return PrintError(__LINE__, hr);
}
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;
}