mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
485 lines
14 KiB
C++
485 lines
14 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#include "nsMetroFilePicker.h"
|
|
#include "nsComponentManagerUtils.h"
|
|
#include "nsNetUtil.h"
|
|
#include "nsAutoPtr.h"
|
|
#include "MetroUtils.h"
|
|
|
|
#include <windows.ui.viewmanagement.h>
|
|
#include <windows.storage.search.h>
|
|
|
|
using namespace ABI::Windows::Foundation;
|
|
using namespace ABI::Windows::Foundation::Collections;
|
|
using namespace ABI::Windows::Storage;
|
|
using namespace ABI::Windows::Storage::Pickers;
|
|
using namespace ABI::Windows::Storage::Streams;
|
|
using namespace ABI::Windows::UI;
|
|
using namespace ABI::Windows::UI::ViewManagement;
|
|
using namespace Microsoft::WRL;
|
|
using namespace Microsoft::WRL::Wrappers;
|
|
using namespace mozilla::widget::winrt;
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// nsIFilePicker
|
|
|
|
nsMetroFilePicker::nsMetroFilePicker()
|
|
{
|
|
}
|
|
|
|
nsMetroFilePicker::~nsMetroFilePicker()
|
|
{
|
|
}
|
|
|
|
NS_IMPL_ISUPPORTS1(nsMetroFilePicker, nsIFilePicker)
|
|
|
|
NS_IMETHODIMP
|
|
nsMetroFilePicker::Init(nsIDOMWindow *parent, const nsAString& title, int16_t mode)
|
|
{
|
|
mMode = mode;
|
|
HRESULT hr;
|
|
switch(mMode) {
|
|
case nsIFilePicker::modeOpen:
|
|
case nsIFilePicker::modeOpenMultiple:
|
|
hr = ActivateGenericInstance(RuntimeClass_Windows_Storage_Pickers_FileOpenPicker, mFileOpenPicker);
|
|
AssertRetHRESULT(hr, NS_ERROR_UNEXPECTED);
|
|
return NS_OK;
|
|
case nsIFilePicker::modeSave:
|
|
hr = ActivateGenericInstance(RuntimeClass_Windows_Storage_Pickers_FileSavePicker, mFileSavePicker);
|
|
AssertRetHRESULT(hr, NS_ERROR_UNEXPECTED);
|
|
return NS_OK;
|
|
default:
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsMetroFilePicker::Show(int16_t *aReturnVal)
|
|
{
|
|
// Metro file picker only offers an async variant which calls back to the
|
|
// UI thread, which is the main thread. We therefore can't call it
|
|
// synchronously from the main thread.
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
HRESULT nsMetroFilePicker::OnPickSingleFile(IAsyncOperation<StorageFile*>* aFile,
|
|
AsyncStatus aStatus)
|
|
{
|
|
if (aStatus != ABI::Windows::Foundation::AsyncStatus::Completed) {
|
|
if (mCallback)
|
|
mCallback->Done(nsIFilePicker::returnCancel);
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT hr;
|
|
ComPtr<IStorageFile> file;
|
|
hr = aFile->GetResults(file.GetAddressOf());
|
|
// When the user cancels hr == S_OK and file is NULL
|
|
if (FAILED(hr) || !file) {
|
|
if (mCallback)
|
|
mCallback->Done(nsIFilePicker::returnCancel);
|
|
return S_OK;
|
|
}
|
|
ComPtr<IStorageItem> storageItem;
|
|
hr = file.As(&storageItem);
|
|
if (FAILED(hr)) {
|
|
if (mCallback)
|
|
mCallback->Done(nsIFilePicker::returnCancel);
|
|
return S_OK;
|
|
}
|
|
|
|
HSTRING path;
|
|
if (FAILED(storageItem->get_Path(&path))) {
|
|
if (mCallback)
|
|
mCallback->Done(nsIFilePicker::returnCancel);
|
|
return S_OK;
|
|
}
|
|
WindowsDuplicateString(path, mFilePath.GetAddressOf());
|
|
WindowsDeleteString(path);
|
|
|
|
if (mCallback) {
|
|
mCallback->Done(nsIFilePicker::returnOK);
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT nsMetroFilePicker::OnPickMultipleFiles(IAsyncOperation<IVectorView<StorageFile*>*>* aFileList,
|
|
AsyncStatus aStatus)
|
|
{
|
|
if (aStatus != ABI::Windows::Foundation::AsyncStatus::Completed) {
|
|
if (mCallback)
|
|
mCallback->Done(nsIFilePicker::returnCancel);
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT hr;
|
|
ComPtr<IVectorView<StorageFile*>> view;
|
|
hr = aFileList->GetResults(view.GetAddressOf());
|
|
if (FAILED(hr)) {
|
|
if (mCallback)
|
|
mCallback->Done(nsIFilePicker::returnCancel);
|
|
return S_OK;
|
|
}
|
|
|
|
unsigned int length;
|
|
view->get_Size(&length);
|
|
for (unsigned int idx = 0; idx < length; idx++) {
|
|
ComPtr<IStorageFile> file;
|
|
hr = view->GetAt(idx, file.GetAddressOf());
|
|
if (FAILED(hr)) {
|
|
continue;
|
|
}
|
|
|
|
ComPtr<IStorageItem> storageItem;
|
|
hr = file.As(&storageItem);
|
|
if (FAILED(hr)) {
|
|
continue;
|
|
}
|
|
|
|
HSTRING path;
|
|
if (SUCCEEDED(storageItem->get_Path(&path))) {
|
|
nsCOMPtr<nsILocalFile> file =
|
|
do_CreateInstance("@mozilla.org/file/local;1");
|
|
unsigned int tmp;
|
|
if (NS_SUCCEEDED(file->InitWithPath(
|
|
nsAutoString(WindowsGetStringRawBuffer(path, &tmp))))) {
|
|
mFiles.AppendObject(file);
|
|
}
|
|
}
|
|
WindowsDeleteString(path);
|
|
}
|
|
|
|
if (mCallback) {
|
|
mCallback->Done(nsIFilePicker::returnOK);
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsMetroFilePicker::Open(nsIFilePickerShownCallback *aCallback)
|
|
{
|
|
HRESULT hr;
|
|
// Capture a reference to the callback which we'll also pass into the
|
|
// closure to ensure it's not freed.
|
|
mCallback = aCallback;
|
|
|
|
// The filepicker cannot open when in snapped view, try to unsnapp
|
|
// before showing the filepicker.
|
|
ApplicationViewState viewState;
|
|
MetroUtils::GetViewState(viewState);
|
|
if (viewState == ApplicationViewState::ApplicationViewState_Snapped) {
|
|
bool unsnapped = SUCCEEDED(MetroUtils::TryUnsnap());
|
|
NS_ENSURE_TRUE(unsnapped, NS_ERROR_FAILURE);
|
|
}
|
|
|
|
switch(mMode) {
|
|
case nsIFilePicker::modeOpen: {
|
|
NS_ENSURE_ARG_POINTER(mFileOpenPicker);
|
|
|
|
// Initiate the file picker operation
|
|
ComPtr<IAsyncOperation<StorageFile*>> asyncOperation;
|
|
hr = mFileOpenPicker->PickSingleFileAsync(asyncOperation.GetAddressOf());
|
|
AssertRetHRESULT(hr, NS_ERROR_FAILURE);
|
|
|
|
// Subscribe to the completed event
|
|
ComPtr<IAsyncOperationCompletedHandler<StorageFile*>>
|
|
completedHandler(Callback<IAsyncOperationCompletedHandler<StorageFile*>>(
|
|
this, &nsMetroFilePicker::OnPickSingleFile));
|
|
hr = asyncOperation->put_Completed(completedHandler.Get());
|
|
AssertRetHRESULT(hr, NS_ERROR_UNEXPECTED);
|
|
break;
|
|
}
|
|
|
|
case nsIFilePicker::modeOpenMultiple: {
|
|
NS_ENSURE_ARG_POINTER(mFileOpenPicker);
|
|
|
|
typedef IVectorView<StorageFile*> StorageTemplate;
|
|
typedef IAsyncOperation<StorageTemplate*> AsyncCallbackTemplate;
|
|
typedef IAsyncOperationCompletedHandler<StorageTemplate*> HandlerTemplate;
|
|
|
|
// Initiate the file picker operation
|
|
ComPtr<AsyncCallbackTemplate> asyncOperation;
|
|
hr = mFileOpenPicker->PickMultipleFilesAsync(asyncOperation.GetAddressOf());
|
|
AssertRetHRESULT(hr, NS_ERROR_FAILURE);
|
|
|
|
// Subscribe to the completed event
|
|
ComPtr<HandlerTemplate> completedHandler(Callback<HandlerTemplate>(
|
|
this, &nsMetroFilePicker::OnPickMultipleFiles));
|
|
hr = asyncOperation->put_Completed(completedHandler.Get());
|
|
AssertRetHRESULT(hr, NS_ERROR_UNEXPECTED);
|
|
break;
|
|
}
|
|
|
|
case nsIFilePicker::modeSave: {
|
|
NS_ENSURE_ARG_POINTER(mFileSavePicker);
|
|
|
|
// Set the default file name
|
|
mFileSavePicker->put_SuggestedFileName(HStringReference(mDefaultFilename.BeginReading()).Get());
|
|
|
|
// Set the default file extension
|
|
if (mDefaultExtension.Length() > 0) {
|
|
nsAutoString defaultFileExtension(mDefaultExtension);
|
|
|
|
// Touch up the extansion format platform hands us.
|
|
if (defaultFileExtension[0] == L'*') {
|
|
defaultFileExtension.Cut(0, 1);
|
|
} else if (defaultFileExtension[0] != L'.') {
|
|
defaultFileExtension.Insert(L".", 0);
|
|
}
|
|
|
|
// Sometimes the default file extension is not passed in correctly,
|
|
// so we purposfully ignore failures here.
|
|
HString ext;
|
|
ext.Set(defaultFileExtension.BeginReading());
|
|
hr = mFileSavePicker->put_DefaultFileExtension(ext.Get());
|
|
NS_ASSERTION(SUCCEEDED(hr), "put_DefaultFileExtension failed, bad format for extension?");
|
|
|
|
// Due to a bug in the WinRT file picker, the first file extension in the
|
|
// list is always used when saving a file. So we explicitly make sure the
|
|
// default extension is the first one in the list here.
|
|
if (mFirstTitle.Get()) {
|
|
ComPtr<IMap<HSTRING, IVector<HSTRING>*>> map;
|
|
mFileSavePicker->get_FileTypeChoices(map.GetAddressOf());
|
|
if (map) {
|
|
boolean found = false;
|
|
unsigned int index;
|
|
map->HasKey(mFirstTitle.Get(), &found);
|
|
if (found) {
|
|
ComPtr<IVector<HSTRING>> list;
|
|
if (SUCCEEDED(map->Lookup(mFirstTitle.Get(), list.GetAddressOf()))) {
|
|
HString ext;
|
|
ext.Set(defaultFileExtension.get());
|
|
found = false;
|
|
list->IndexOf(HStringReference(defaultFileExtension.get()).Get(), &index, &found);
|
|
if (found) {
|
|
list->RemoveAt(index);
|
|
list->InsertAt(0, HStringReference(defaultFileExtension.get()).Get());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Dispatch the async show operation
|
|
ComPtr<IAsyncOperation<StorageFile*>> asyncOperation;
|
|
hr = mFileSavePicker->PickSaveFileAsync(asyncOperation.GetAddressOf());
|
|
AssertRetHRESULT(hr, NS_ERROR_FAILURE);
|
|
|
|
// Subscribe to the completed event
|
|
ComPtr<IAsyncOperationCompletedHandler<StorageFile*>>
|
|
completedHandler(Callback<IAsyncOperationCompletedHandler<StorageFile*>>(
|
|
this, &nsMetroFilePicker::OnPickSingleFile));
|
|
hr = asyncOperation->put_Completed(completedHandler.Get());
|
|
AssertRetHRESULT(hr, NS_ERROR_UNEXPECTED);
|
|
break;
|
|
}
|
|
|
|
case modeGetFolder:
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
|
|
default:
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsMetroFilePicker::GetFile(nsIFile **aFile)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aFile);
|
|
*aFile = nullptr;
|
|
|
|
if (WindowsIsStringEmpty(mFilePath.Get()))
|
|
return NS_OK;
|
|
|
|
nsCOMPtr<nsILocalFile> file(do_CreateInstance("@mozilla.org/file/local;1"));
|
|
NS_ENSURE_TRUE(file, NS_ERROR_FAILURE);
|
|
unsigned int length;
|
|
file->InitWithPath(nsAutoString(mFilePath.GetRawBuffer(&length)));
|
|
NS_ADDREF(*aFile = file);
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsMetroFilePicker::GetFileURL(nsIURI **aFileURL)
|
|
{
|
|
*aFileURL = nullptr;
|
|
nsCOMPtr<nsIFile> file;
|
|
nsresult rv = GetFile(getter_AddRefs(file));
|
|
if (!file)
|
|
return rv;
|
|
|
|
return NS_NewFileURI(aFileURL, file);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsMetroFilePicker::GetFiles(nsISimpleEnumerator **aFiles)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aFiles);
|
|
return NS_NewArrayEnumerator(aFiles, mFiles);
|
|
}
|
|
|
|
// Set the filter index
|
|
NS_IMETHODIMP
|
|
nsMetroFilePicker::GetFilterIndex(int32_t *aFilterIndex)
|
|
{
|
|
// No associated concept with a Metro file picker
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsMetroFilePicker::SetFilterIndex(int32_t aFilterIndex)
|
|
{
|
|
// No associated concept with a Metro file picker
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
// AFACT, it's up to use to supply the implementation of a vector list.
|
|
class MozHStringVector : public RuntimeClass<IVector<HSTRING>> {
|
|
InspectableClass(L"MozHStringVector", TrustLevel::BaseTrust)
|
|
~MozHStringVector() {
|
|
Clear();
|
|
}
|
|
|
|
// See IVector_impl in windows.foundation.collections.h
|
|
public:
|
|
STDMETHOD(GetAt)(unsigned aIndex, HSTRING* aString) {
|
|
if (aIndex >= mList.Length()) {
|
|
return E_INVALIDARG;
|
|
}
|
|
return WindowsDuplicateString(mList[aIndex], aString);
|
|
}
|
|
|
|
STDMETHOD(get_Size)(unsigned int* aLength) {
|
|
if (!aLength) {
|
|
return E_INVALIDARG;
|
|
}
|
|
*aLength = mList.Length();
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHOD(Append)(HSTRING aString) {
|
|
HSTRING str;
|
|
if (FAILED(WindowsDuplicateString(aString, &str))) {
|
|
return E_INVALIDARG;
|
|
}
|
|
mList.AppendElement(str);
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHOD(Clear)() {
|
|
int length = mList.Length();
|
|
for (int idx = 0; idx < length; idx++)
|
|
WindowsDeleteString(mList[idx]);
|
|
mList.Clear();
|
|
return S_OK;
|
|
}
|
|
|
|
// interfaces picker code doesn't seem to need
|
|
STDMETHOD(GetView)(IVectorView<HSTRING> **aView) { return E_NOTIMPL; }
|
|
STDMETHOD(IndexOf)(HSTRING aValue, unsigned *aIndex, boolean *found) { return E_NOTIMPL; }
|
|
STDMETHOD(SetAt)(unsigned aIndex, HSTRING aString) { return E_NOTIMPL; }
|
|
STDMETHOD(InsertAt)(unsigned aIndex, HSTRING aString) { return E_NOTIMPL; }
|
|
STDMETHOD(RemoveAt)(unsigned aIndex) { return E_NOTIMPL; }
|
|
STDMETHOD(RemoveAtEnd)() { return E_NOTIMPL; }
|
|
|
|
private:
|
|
nsTArray<HSTRING> mList;
|
|
};
|
|
|
|
nsresult
|
|
nsMetroFilePicker::ParseFiltersIntoVector(ComPtr<IVector<HSTRING>>& aVector,
|
|
const nsAString& aFilter,
|
|
bool aAllowAll)
|
|
{
|
|
const PRUnichar *beg = aFilter.BeginReading();
|
|
const PRUnichar *end = aFilter.EndReading();
|
|
for (const PRUnichar *cur = beg, *fileTypeStart = beg; cur <= end; ++cur) {
|
|
// Start of a a filetype, example: *.png
|
|
if (cur == end || PRUnichar(' ') == *cur) {
|
|
int32_t startPos = fileTypeStart - beg;
|
|
int32_t endPos = cur - fileTypeStart - (cur == end ? 0 : 1);
|
|
const nsAString& fileType = Substring(aFilter,
|
|
startPos,
|
|
endPos);
|
|
// There is no way to say show all files in Metro save file picker, so
|
|
// just use .data if * or *.* is specified.
|
|
if (fileType.IsEmpty() ||
|
|
fileType.Equals(L"*") ||
|
|
fileType.Equals(L"*.*")) {
|
|
HString str;
|
|
if (aAllowAll) {
|
|
str.Set(L"*");
|
|
aVector->Append(str.Get());
|
|
} else {
|
|
str.Set(L".data");
|
|
aVector->Append(str.Get());
|
|
}
|
|
} else {
|
|
nsAutoString filter(fileType);
|
|
if (filter[0] == L'*') {
|
|
filter.Cut(0, 1);
|
|
} else if (filter[0] != L'.') {
|
|
filter.Insert(L".", 0);
|
|
}
|
|
HString str;
|
|
str.Set(filter.BeginReading());
|
|
aVector->Append(str.Get());
|
|
}
|
|
|
|
fileTypeStart = cur + 1;
|
|
}
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsMetroFilePicker::AppendFilter(const nsAString& aTitle,
|
|
const nsAString& aFilter)
|
|
{
|
|
HRESULT hr;
|
|
switch(mMode) {
|
|
case nsIFilePicker::modeOpen:
|
|
case nsIFilePicker::modeOpenMultiple: {
|
|
NS_ENSURE_ARG_POINTER(mFileOpenPicker);
|
|
ComPtr<IVector<HSTRING>> list;
|
|
mFileOpenPicker->get_FileTypeFilter(list.GetAddressOf());
|
|
nsresult rv = ParseFiltersIntoVector(list, aFilter, true);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
}
|
|
|
|
case nsIFilePicker::modeSave: {
|
|
NS_ENSURE_ARG_POINTER(mFileSavePicker);
|
|
|
|
ComPtr<IMap<HSTRING,IVector<HSTRING>*>> map;
|
|
hr = mFileSavePicker->get_FileTypeChoices(map.GetAddressOf());
|
|
AssertRetHRESULT(hr, NS_ERROR_FAILURE);
|
|
|
|
HString key;
|
|
key.Set(aTitle.BeginReading());
|
|
|
|
ComPtr<IVector<HSTRING>> saveTypes;
|
|
saveTypes = Make<MozHStringVector>();
|
|
nsresult rv = ParseFiltersIntoVector(saveTypes, aFilter, false);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
if (WindowsIsStringEmpty(mFirstTitle.Get())) {
|
|
mFirstTitle.Set(key.Get());
|
|
}
|
|
|
|
boolean replaced;
|
|
map->Insert(key.Get(), saveTypes.Get(), &replaced);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|