WebKitFileChooserRequest.cpp [plain text]
#include "config.h"
#include "WebKitFileChooserRequest.h"
#include "APIArray.h"
#include "APIOpenPanelParameters.h"
#include "APIString.h"
#include "WebKitFileChooserRequestPrivate.h"
#include "WebOpenPanelResultListenerProxy.h"
#include <WebCore/FileSystem.h>
#include <WebCore/URL.h>
#include <glib/gi18n-lib.h>
#include <wtf/glib/GRefPtr.h>
#include <wtf/glib/GUniquePtr.h>
#include <wtf/glib/WTFGType.h>
#include <wtf/text/CString.h>
using namespace WebKit;
using namespace WebCore;
struct _WebKitFileChooserRequestPrivate {
RefPtr<API::OpenPanelParameters> parameters;
RefPtr<WebOpenPanelResultListenerProxy> listener;
#if PLATFORM(GTK)
GRefPtr<GtkFileFilter> filter;
#endif
GRefPtr<GPtrArray> mimeTypes;
GRefPtr<GPtrArray> selectedFiles;
bool handledRequest;
};
WEBKIT_DEFINE_TYPE(WebKitFileChooserRequest, webkit_file_chooser_request, G_TYPE_OBJECT)
enum {
PROP_0,
#if PLATFORM(GTK)
PROP_FILTER,
#endif
PROP_MIME_TYPES,
PROP_SELECT_MULTIPLE,
PROP_SELECTED_FILES,
};
static void webkitFileChooserRequestDispose(GObject* object)
{
WebKitFileChooserRequest* request = WEBKIT_FILE_CHOOSER_REQUEST(object);
if (!request->priv->handledRequest)
webkit_file_chooser_request_cancel(request);
G_OBJECT_CLASS(webkit_file_chooser_request_parent_class)->dispose(object);
}
static void webkitFileChooserRequestGetProperty(GObject* object, guint propId, GValue* value, GParamSpec* paramSpec)
{
WebKitFileChooserRequest* request = WEBKIT_FILE_CHOOSER_REQUEST(object);
switch (propId) {
#if PLATFORM(GTK)
case PROP_FILTER:
g_value_set_object(value, webkit_file_chooser_request_get_mime_types_filter(request));
break;
#endif
case PROP_MIME_TYPES:
g_value_set_boxed(value, webkit_file_chooser_request_get_mime_types(request));
break;
case PROP_SELECT_MULTIPLE:
g_value_set_boolean(value, webkit_file_chooser_request_get_select_multiple(request));
break;
case PROP_SELECTED_FILES:
g_value_set_boxed(value, webkit_file_chooser_request_get_selected_files(request));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, propId, paramSpec);
break;
}
}
static void webkit_file_chooser_request_class_init(WebKitFileChooserRequestClass* requestClass)
{
GObjectClass* objectClass = G_OBJECT_CLASS(requestClass);
objectClass->dispose = webkitFileChooserRequestDispose;
objectClass->get_property = webkitFileChooserRequestGetProperty;
#if PLATFORM(GTK)
g_object_class_install_property(objectClass,
PROP_FILTER,
g_param_spec_object("filter",
_("MIME types filter"),
_("The filter currently associated with the request"),
GTK_TYPE_FILE_FILTER,
WEBKIT_PARAM_READABLE));
#endif
g_object_class_install_property(objectClass,
PROP_MIME_TYPES,
g_param_spec_boxed("mime-types",
_("MIME types"),
_("The list of MIME types associated with the request"),
G_TYPE_STRV,
WEBKIT_PARAM_READABLE));
g_object_class_install_property(objectClass,
PROP_SELECT_MULTIPLE,
g_param_spec_boolean("select-multiple",
_("Select multiple files"),
_("Whether the file chooser should allow selecting multiple files"),
FALSE,
WEBKIT_PARAM_READABLE));
g_object_class_install_property(objectClass,
PROP_SELECTED_FILES,
g_param_spec_boxed("selected-files",
_("Selected files"),
_("The list of selected files associated with the request"),
G_TYPE_STRV,
WEBKIT_PARAM_READABLE));
}
WebKitFileChooserRequest* webkitFileChooserRequestCreate(API::OpenPanelParameters* parameters, WebOpenPanelResultListenerProxy* listener)
{
WebKitFileChooserRequest* request = WEBKIT_FILE_CHOOSER_REQUEST(g_object_new(WEBKIT_TYPE_FILE_CHOOSER_REQUEST, NULL));
request->priv->parameters = parameters;
request->priv->listener = listener;
return request;
}
const gchar* const* webkit_file_chooser_request_get_mime_types(WebKitFileChooserRequest* request)
{
g_return_val_if_fail(WEBKIT_IS_FILE_CHOOSER_REQUEST(request), 0);
if (request->priv->mimeTypes)
return reinterpret_cast<gchar**>(request->priv->mimeTypes->pdata);
Ref<API::Array> mimeTypes = request->priv->parameters->acceptMIMETypes();
size_t numOfMimeTypes = mimeTypes->size();
if (!numOfMimeTypes)
return 0;
request->priv->mimeTypes = adoptGRef(g_ptr_array_new_with_free_func(g_free));
for (size_t i = 0; i < numOfMimeTypes; ++i) {
API::String* webMimeType = static_cast<API::String*>(mimeTypes->at(i));
String mimeTypeString = webMimeType->string();
if (mimeTypeString.isEmpty())
continue;
g_ptr_array_add(request->priv->mimeTypes.get(), g_strdup(mimeTypeString.utf8().data()));
}
g_ptr_array_add(request->priv->mimeTypes.get(), 0);
return reinterpret_cast<gchar**>(request->priv->mimeTypes->pdata);
}
#if PLATFORM(GTK)
GtkFileFilter* webkit_file_chooser_request_get_mime_types_filter(WebKitFileChooserRequest* request)
{
g_return_val_if_fail(WEBKIT_IS_FILE_CHOOSER_REQUEST(request), 0);
if (request->priv->filter)
return request->priv->filter.get();
Ref<API::Array> mimeTypes = request->priv->parameters->acceptMIMETypes();
size_t numOfMimeTypes = mimeTypes->size();
if (!numOfMimeTypes)
return 0;
request->priv->filter = gtk_file_filter_new();
for (size_t i = 0; i < numOfMimeTypes; ++i) {
API::String* webMimeType = static_cast<API::String*>(mimeTypes->at(i));
String mimeTypeString = webMimeType->string();
if (mimeTypeString.isEmpty())
continue;
gtk_file_filter_add_mime_type(request->priv->filter.get(), mimeTypeString.utf8().data());
}
return request->priv->filter.get();
}
#endif // PLATFORM(GTK)
gboolean webkit_file_chooser_request_get_select_multiple(WebKitFileChooserRequest* request)
{
g_return_val_if_fail(WEBKIT_IS_FILE_CHOOSER_REQUEST(request), FALSE);
return request->priv->parameters->allowMultipleFiles();
}
void webkit_file_chooser_request_select_files(WebKitFileChooserRequest* request, const gchar* const* files)
{
g_return_if_fail(WEBKIT_IS_FILE_CHOOSER_REQUEST(request));
g_return_if_fail(files);
GRefPtr<GPtrArray> selectedFiles = adoptGRef(g_ptr_array_new_with_free_func(g_free));
Vector<String> chosenFiles;
for (int i = 0; files[i]; i++) {
chosenFiles.append(WebCore::decodeURLEscapeSequences(String::fromUTF8(files[i])));
g_ptr_array_add(selectedFiles.get(), g_strdup(files[i]));
}
g_ptr_array_add(selectedFiles.get(), nullptr);
request->priv->listener->chooseFiles(chosenFiles);
request->priv->selectedFiles = selectedFiles;
request->priv->handledRequest = true;
}
const gchar* const* webkit_file_chooser_request_get_selected_files(WebKitFileChooserRequest* request)
{
g_return_val_if_fail(WEBKIT_IS_FILE_CHOOSER_REQUEST(request), 0);
if (request->priv->selectedFiles)
return reinterpret_cast<gchar**>(request->priv->selectedFiles->pdata);
RefPtr<API::Array> selectedFileNames = request->priv->parameters->selectedFileNames();
size_t numOfFiles = selectedFileNames->size();
if (!numOfFiles)
return 0;
request->priv->selectedFiles = adoptGRef(g_ptr_array_new_with_free_func(g_free));
for (size_t i = 0; i < numOfFiles; ++i) {
API::String* webFileName = static_cast<API::String*>(selectedFileNames->at(i));
if (webFileName->stringView().isEmpty())
continue;
CString filename = FileSystem::fileSystemRepresentation(webFileName->string());
g_ptr_array_add(request->priv->selectedFiles.get(), g_strdup(filename.data()));
}
g_ptr_array_add(request->priv->selectedFiles.get(), 0);
return reinterpret_cast<gchar**>(request->priv->selectedFiles->pdata);
}
void webkit_file_chooser_request_cancel(WebKitFileChooserRequest* request)
{
g_return_if_fail(WEBKIT_IS_FILE_CHOOSER_REQUEST(request));
request->priv->listener->cancel();
request->priv->handledRequest = true;
}