1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
|
// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
#include "qwasmlocalfileaccess_p.h"
#include <private/qstdweb_p.h>
#include <emscripten.h>
#include <emscripten/bind.h>
#include <emscripten/html5.h>
#include <emscripten/val.h>
#include <QtCore/qregularexpression.h>
QT_BEGIN_NAMESPACE
using namespace Qt::Literals::StringLiterals;
namespace QWasmLocalFileAccess {
void readFiles(const qstdweb::FileList &fileList,
const std::function<char *(uint64_t size, const std::string name)> &acceptFile,
const std::function<void ()> &fileDataReady)
{
auto readFile = std::make_shared<std::function<void(int)>>();
*readFile = [=](int fileIndex) mutable {
// Stop when all files have been processed
if (fileIndex >= fileList.length()) {
readFile.reset();
return;
}
const qstdweb::File file = fileList[fileIndex];
// Ask caller if the file should be accepted
char *buffer = acceptFile(file.size(), file.name());
if (buffer == nullptr) {
(*readFile)(fileIndex + 1);
return;
}
// Read file data into caller-provided buffer
file.stream(buffer, [=]() {
fileDataReady();
(*readFile)(fileIndex + 1);
});
};
(*readFile)(0);
}
std::string acceptListFromQtFormat(const std::string &qtAcceptList)
{
// copy of qt_make_filter_list() from qfiledialog.cpp
auto make_filter_list = [](const QString &filter) -> QStringList
{
if (filter.isEmpty())
return QStringList();
QString sep(";;"_L1);
if (!filter.contains(sep) && filter.contains(u'\n'))
sep = u'\n';
return filter.split(sep);
};
const QStringList fileFilter = make_filter_list(QString::fromStdString(qtAcceptList));
QStringList transformed;
for (const auto &element : fileFilter) {
// Accepts either a string in format:
// GROUP3
// or in this format:
// GROUP1 (GROUP2)
// Group 1 is treated as the description, whereas group 2 or 3 are treated as the filter
// list.
static QRegularExpression regex(
QString(QStringLiteral("(?:([^(]*)\\(([^()]+)\\)[^)]*)|([^()]+)")));
static QRegularExpression wordCharacterRegex(QString(QStringLiteral("\\w")));
const auto match = regex.match(element);
if (!match.hasMatch())
continue;
constexpr size_t FilterListFromParensIndex = 2;
constexpr size_t PlainFilterListIndex = 3;
QString filterList = match.captured(match.hasCaptured(FilterListFromParensIndex)
? FilterListFromParensIndex
: PlainFilterListIndex);
for (auto singleExtension : filterList.split(QStringLiteral(" "), Qt::SkipEmptyParts)) {
// Checks for a filter that matches everything:
// Any number of asterisks or any number of asterisks with a '.' between them.
// The web filter does not support wildcards.
static QRegularExpression qtAcceptAllRegex(QRegularExpression::anchoredPattern(
QString(QStringLiteral("[*]+|[*]+\\.[*]+"))));
if (qtAcceptAllRegex.match(singleExtension).hasMatch())
continue;
// Checks for correctness. The web filter only allows filename extensions and does not
// filter the actual filenames, therefore we check whether the filter provided only
// filters for the extension.
static QRegularExpression qtFilenameMatcherRegex(QRegularExpression::anchoredPattern(
QString(QStringLiteral("(\\*?)(\\.[^*]+)"))));
auto extensionMatch = qtFilenameMatcherRegex.match(singleExtension);
if (extensionMatch.hasMatch())
transformed.append(extensionMatch.captured(2));
}
}
return transformed.join(QStringLiteral(",")).toStdString();
}
typedef std::function<void (const qstdweb::FileList &fileList)> OpenFileDialogCallback;
void openFileDialog(const std::string &accept, FileSelectMode fileSelectMode,
const OpenFileDialogCallback &filesSelected)
{
// Create file input html element which will display a native file dialog
// and call back to our onchange handler once the user has selected
// one or more files.
emscripten::val document = emscripten::val::global("document");
emscripten::val input = document.call<emscripten::val>("createElement", std::string("input"));
input.set("type", "file");
input.set("style", "display:none");
input.set("accept", acceptListFromQtFormat(accept));
input.set("multiple", emscripten::val(fileSelectMode == MultipleFiles));
// Note: there is no event in case the user cancels the file dialog.
static std::unique_ptr<qstdweb::EventCallback> changeEvent;
auto callback = [=](emscripten::val) { filesSelected(qstdweb::FileList(input["files"])); };
changeEvent.reset(new qstdweb::EventCallback(input, "change", callback));
// Activate file input
emscripten::val body = document["body"];
body.call<void>("appendChild", input);
input.call<void>("click");
body.call<void>("removeChild", input);
}
void openFiles(const std::string &accept, FileSelectMode fileSelectMode,
const std::function<void (int fileCount)> &fileDialogClosed,
const std::function<char *(uint64_t size, const std::string name)> &acceptFile,
const std::function<void()> &fileDataReady)
{
openFileDialog(accept, fileSelectMode, [=](const qstdweb::FileList &files) {
fileDialogClosed(files.length());
readFiles(files, acceptFile, fileDataReady);
});
}
void openFile(const std::string &accept,
const std::function<void (bool fileSelected)> &fileDialogClosed,
const std::function<char *(uint64_t size, const std::string name)> &acceptFile,
const std::function<void()> &fileDataReady)
{
auto fileDialogClosedWithInt = [=](int fileCount) { fileDialogClosed(fileCount != 0); };
openFiles(accept, FileSelectMode::SingleFile, fileDialogClosedWithInt, acceptFile, fileDataReady);
}
void saveFile(const char *content, size_t size, const std::string &fileNameHint)
{
// Save a file by creating programmatically clicking a download
// link to an object url to a Blob containing a copy of the file
// content. The copy is made so that the passed in content buffer
// can be released as soon as this function returns.
qstdweb::Blob contentBlob = qstdweb::Blob::copyFrom(content, size);
emscripten::val document = emscripten::val::global("document");
emscripten::val window = emscripten::val::global("window");
emscripten::val contentUrl = window["URL"].call<emscripten::val>("createObjectURL", contentBlob.val());
emscripten::val contentLink = document.call<emscripten::val>("createElement", std::string("a"));
contentLink.set("href", contentUrl);
contentLink.set("download", fileNameHint);
contentLink.set("style", "display:none");
emscripten::val body = document["body"];
body.call<void>("appendChild", contentLink);
contentLink.call<void>("click");
body.call<void>("removeChild", contentLink);
window["URL"].call<emscripten::val>("revokeObjectURL", contentUrl);
}
} // namespace QWasmLocalFileAccess
QT_END_NAMESPACE
|
