debian/midori
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
midori/extensions/addons.c
Paweł Forysiuk b26df3af22 Remove unused kind_name variable in addons_uri_install
2010-11-10 00:34:31 +01:00

1785 lines
58 KiB
C
Raw Blame History

/*
Copyright (C) 2008 Christian Dywan <christian@twotoasts.de>
Copyright (C) 2008-2010 Arno Renevier <arno@renevier.net>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
See the file COPYING for the full license text.
*/
/* This extensions add support for user addons: userscripts and userstyles */
#include <midori/midori.h>
#include <midori/sokoke.h>
#include <glib.h>
#include <glib/gstdio.h>
#include "config.h"
#if HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifndef X_OK
#define X_OK 1
#endif
typedef enum
{
ADDON_NONE,
ADDONS_USER_SCRIPTS,
ADDONS_USER_STYLES
} AddonsKind;
#define ADDONS_TYPE \
(addons_get_type ())
#define ADDONS(obj) \
(G_TYPE_CHECK_INSTANCE_CAST ((obj), ADDONS_TYPE, Addons))
#define ADDONS_CLASS(klass) \
(G_TYPE_CHECK_CLASS_CAST ((klass), ADDONS_TYPE, AddonsClass))
#define IS_ADDONS(obj) \
(G_TYPE_CHECK_INSTANCE_TYPE ((obj), ADDONS_TYPE))
#define IS_ADDONS_CLASS(klass) \
(G_TYPE_CHECK_CLASS_TYPE ((klass), ADDONS_TYPE))
#define ADDONS_GET_CLASS(obj) \
(G_TYPE_INSTANCE_GET_CLASS ((obj), ADDONS_TYPE, AddonsClass))
typedef struct _Addons Addons;
typedef struct _AddonsClass AddonsClass;
struct _AddonsClass
{
GtkVBoxClass parent_class;
};
struct _Addons
{
GtkVBox parent_instance;
GtkWidget* toolbar;
GtkWidget* treeview;
AddonsKind kind;
};
static void
addons_iface_init (MidoriViewableIface* iface);
G_DEFINE_TYPE_WITH_CODE (Addons, addons, GTK_TYPE_VBOX,
G_IMPLEMENT_INTERFACE (MIDORI_TYPE_VIEWABLE,
addons_iface_init));
struct AddonElement
{
gchar* fullpath;
gchar* displayname;
gchar* description;
gchar* script_content;
gboolean enabled;
gboolean broken;
GSList* includes;
GSList* excludes;
};
struct AddonsList
{
GtkListStore* liststore;
GSList* elements;
};
static void
addons_install_response (GtkInfoBar* infobar,
gint response_id,
MidoriView* view)
{
if (response_id == GTK_RESPONSE_ACCEPT)
{
MidoriBrowser* browser;
const gchar* uri;
browser = midori_browser_get_for_widget (GTK_WIDGET (infobar));
uri = midori_view_get_display_uri (view);
if (uri && *uri)
{
gchar** split_uri;
gchar* path, *filename, *hostname, *dest_path, *temp_uri;
const gchar* folder;
WebKitNetworkRequest* request;
WebKitDownload* download;
split_uri = g_strsplit (uri, "/", -1);
hostname = split_uri[2];
temp_uri = NULL;
filename = NULL;
folder = NULL;
if (!g_strcmp0 (hostname, "userscripts.org"))
{
gchar* script_id;
const gchar* js_script;
WebKitWebView* web_view;
WebKitWebFrame* web_frame;
web_view = WEBKIT_WEB_VIEW (midori_view_get_web_view (view));
web_frame = webkit_web_view_get_main_frame (web_view);
js_script = "document.getElementById('heading').childNodes[3].childNodes[1].innerHTML";
if (WEBKIT_IS_WEB_FRAME (web_frame))
{
JSContextRef js_context = webkit_web_frame_get_global_context (web_frame);
gchar* value = sokoke_js_script_eval (js_context, js_script, NULL);
if (value && *value)
filename = g_strdup_printf ("%s.user.js", value);
g_free (value);
}
folder = "scripts";
script_id = split_uri[5];
/* rewrite uri to get source js */
temp_uri = g_strdup_printf ("http://%s/scripts/source/%s.user.js",
hostname, script_id);
uri = temp_uri;
}
else if (!g_strcmp0 (hostname, "userstyles.org"))
{
gchar* subpage;
folder = "styles";
if (g_str_has_suffix (uri, "/"))
subpage = split_uri[6];
else
subpage = split_uri[5];
if (!subpage)
{
gchar* style_id;
const gchar* js_script;
WebKitWebView* web_view;
WebKitWebFrame* web_frame;
web_view = WEBKIT_WEB_VIEW (midori_view_get_web_view (view));
web_frame = webkit_web_view_get_main_frame (web_view);
js_script = "document.getElementById('stylish-description').innerHTML;";
if (WEBKIT_IS_WEB_FRAME (web_frame))
{
JSContextRef js_context = webkit_web_frame_get_global_context (web_frame);
gchar* value = sokoke_js_script_eval (js_context, js_script, NULL);
if (value && *value)
filename = g_strdup_printf ("%s.css", value);
g_free (value);
}
/* rewrite uri to get css */
style_id = split_uri[4];
temp_uri = g_strdup_printf ("http://%s/styles/%s.css", hostname, style_id);
uri = temp_uri;
}
}
if (g_str_has_suffix (uri, ".user.js"))
folder = "scripts";
else if (g_str_has_suffix (uri, ".user.css"))
folder = "styles";
if (!filename)
filename = g_path_get_basename (uri);
path = g_build_path (G_DIR_SEPARATOR_S, g_get_user_data_dir (),
PACKAGE_NAME, folder, filename, NULL);
request = webkit_network_request_new (uri);
download = webkit_download_new (request);
g_object_unref (request);
dest_path = g_filename_to_uri (path, NULL, NULL);
webkit_download_set_destination_uri (download, dest_path);
webkit_download_start (download);
g_free (filename);
g_free (path);
g_free (temp_uri);
g_free (dest_path);
g_strfreev (split_uri);
}
}
gtk_widget_destroy (GTK_WIDGET (infobar));
}
static void
addons_uri_install (MidoriBrowser* browser,
MidoriView* view,
AddonsKind kind)
{
const gchar* message;
const gchar* button_text;
if (kind == ADDONS_USER_SCRIPTS)
{
/* i18n: An infobar shows up when viewing a script on userscripts.org */
message = _("This page appears to contain a user script. Do you wish to install it?");
button_text = _("_Install user script");
}
else if (kind == ADDONS_USER_STYLES)
{
/* i18n: An infobar shows up when viewing a style on userstyles.org */
message = _("This page appears to contain a user style. Do you wish to install it?");
button_text = _("_Install user style");
}
else
g_assert_not_reached ();
midori_view_add_info_bar (view, GTK_MESSAGE_QUESTION, message,
G_CALLBACK (addons_install_response), view,
button_text, GTK_RESPONSE_ACCEPT,
_("Don't install"), GTK_RESPONSE_CANCEL, NULL);
}
static void
addons_notify_load_status_cb (MidoriBrowser* browser,
GParamSpec* pspec,
MidoriExtension* extension)
{
const gchar* uri = midori_browser_get_current_uri (browser);
if (uri && *uri)
{
/* FIXME: addons_notify_load_status_cb should pass MidoriView* pointer */
GtkWidget* view = midori_browser_get_current_tab (browser);
if (midori_view_get_load_status (MIDORI_VIEW (view)) == MIDORI_LOAD_FINISHED)
{
/* casual sites goes by uri suffix */
if (g_str_has_suffix (uri, ".user.js"))
addons_uri_install (browser, MIDORI_VIEW (view), ADDONS_USER_SCRIPTS);
else if (g_str_has_suffix (uri, ".user.css"))
addons_uri_install (browser, MIDORI_VIEW (view), ADDONS_USER_STYLES);
else if (g_str_has_prefix (uri, "http://userscripts.org/scripts/"))
{
gchar** split_uri = g_strsplit (uri, "/", -1);
gchar* subpage = split_uri[4];
/* userscripts.org script main (with desc) and "source view" pages */
if (!g_strcmp0 (subpage, "show") || !g_strcmp0 (subpage, "review"))
addons_uri_install (browser, MIDORI_VIEW (view), ADDONS_USER_SCRIPTS);
g_strfreev (split_uri);
}
else if (g_str_has_prefix (uri, "http://userstyles.org/styles/"))
{
gchar** split_uri = g_strsplit (uri, "/", -1);
gchar* subpage;
if (g_str_has_suffix (uri, "/"))
subpage = split_uri[6];
else
subpage = split_uri[5];
/* userstyles.org style main page with style description */
if (!subpage)
addons_uri_install (browser, MIDORI_VIEW (view), ADDONS_USER_STYLES);
g_strfreev (split_uri);
}
}
}
}
static void
midori_addons_button_add_clicked_cb (GtkToolItem* toolitem,
Addons* addons)
{
gchar* addons_type;
gchar* path;
GtkWidget* dialog;
GtkFileFilter* filter;
if (addons->kind == ADDONS_USER_SCRIPTS)
{
addons_type = g_strdup ("userscripts");
path = g_build_path (G_DIR_SEPARATOR_S, g_get_user_data_dir (),
PACKAGE_NAME, "scripts", NULL);
}
else if (addons->kind == ADDONS_USER_STYLES)
{
addons_type = g_strdup ("userstyles");
path = g_build_path (G_DIR_SEPARATOR_S, g_get_user_data_dir (),
PACKAGE_NAME, "styles", NULL);
}
else
g_assert_not_reached ();
dialog = gtk_file_chooser_dialog_new (_("Choose file"),
GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (addons))),
GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL);
gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (dialog), TRUE);
filter = gtk_file_filter_new ();
if (addons->kind == ADDONS_USER_SCRIPTS)
{
gtk_file_filter_set_name (filter, _("Userscripts"));
gtk_file_filter_add_pattern (filter, "*.js");
}
else if (addons->kind == ADDONS_USER_STYLES)
{
gtk_file_filter_set_name (filter, _("Userstyles"));
gtk_file_filter_add_pattern (filter, "*.css");
}
else
g_assert_not_reached ();
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
{
GSList* files;
if (!g_file_test (path, G_FILE_TEST_EXISTS))
katze_mkdir_with_parents (path, 0700);
#if !GTK_CHECK_VERSION (2, 14, 0)
files = gtk_file_chooser_get_filenames (GTK_FILE_CHOOSER (dialog));
#else
files = gtk_file_chooser_get_files (GTK_FILE_CHOOSER (dialog));
#endif
while (files)
{
GFile* src_file;
GError* error = NULL;
#if !GTK_CHECK_VERSION (2, 14, 0)
src_file = g_file_new_for_path (files);
#else
src_file = files->data;
#endif
if (G_IS_FILE (src_file))
{
GFile* dest_file;
gchar* dest_file_path;
dest_file_path = g_build_path (G_DIR_SEPARATOR_S, path,
g_file_get_basename (src_file), NULL);
dest_file = g_file_new_for_path (dest_file_path);
g_file_copy (src_file, dest_file,
G_FILE_COPY_OVERWRITE | G_FILE_COPY_BACKUP,
NULL, NULL, NULL, &error);
if (error)
{
GtkWidget* msg_box;
msg_box = gtk_message_dialog_new (
GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (addons))),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_OK,
"%s", error->message);
gtk_window_set_title (GTK_WINDOW (msg_box), _("Error"));
gtk_dialog_run (GTK_DIALOG (msg_box));
gtk_widget_destroy (msg_box);
g_error_free (error);
}
g_object_unref (src_file);
g_object_unref (dest_file);
g_free (dest_file_path);
}
files = g_slist_next (files);
}
g_slist_free (files);
}
g_free (addons_type);
g_free (path);
gtk_widget_destroy (dialog);
}
static void
midori_addons_button_delete_clicked_cb (GtkWidget* toolitem,
Addons* addons)
{
GtkTreeModel* model;
GtkTreeIter iter;
if (katze_tree_view_get_selected_iter (GTK_TREE_VIEW (addons->treeview),
&model, &iter))
{
struct AddonElement* element;
gint delete_response;
GtkWidget* dialog;
gtk_tree_model_get (model, &iter, 0, &element, -1);
dialog = gtk_message_dialog_new (
GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (addons))),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_QUESTION,
GTK_BUTTONS_CANCEL,
_("Do you want to delete '%s'?"),
element->displayname);
gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_DELETE, GTK_RESPONSE_YES);
gtk_window_set_title (GTK_WINDOW (dialog),
addons->kind == ADDONS_USER_SCRIPTS
? _("Delete user script")
: _("Delete user style"));
gtk_message_dialog_format_secondary_markup (
GTK_MESSAGE_DIALOG (dialog),
_("The file <b>%s</b> will be permanently deleted."),
element->fullpath);
delete_response = gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (GTK_WIDGET (dialog));
if (delete_response == GTK_RESPONSE_YES)
{
GError* error = NULL;
GFile* file;
gboolean result;
file = g_file_new_for_path (element->fullpath);
result = g_file_delete (file, NULL, &error);
if (!result && error)
{
GtkWidget* msg_box;
msg_box = gtk_message_dialog_new (
GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (addons))),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_OK,
"%s", error->message);
gtk_window_set_title (GTK_WINDOW (msg_box), _("Error"));
gtk_dialog_run (GTK_DIALOG (msg_box));
gtk_widget_destroy (msg_box);
g_error_free (error);
}
if (result)
gtk_list_store_remove (GTK_LIST_STORE (model), &iter);
g_object_unref (file);
}
}
}
static void
midori_addons_open_in_editor_clicked_cb (GtkWidget* toolitem,
Addons* addons)
{
GtkTreeModel* model;
GtkTreeIter iter;
if (katze_tree_view_get_selected_iter (GTK_TREE_VIEW (addons->treeview),
&model, &iter))
{
struct AddonElement* element;
MidoriWebSettings* settings;
MidoriBrowser* browser;
gchar* text_editor;
browser = midori_browser_get_for_widget (GTK_WIDGET (addons->treeview));
settings = midori_browser_get_settings (browser);
gtk_tree_model_get (model, &iter, 0, &element, -1);
g_object_get (settings, "text-editor", &text_editor, NULL);
if (text_editor && *text_editor)
sokoke_spawn_program (text_editor, element->fullpath);
else
{
gchar* element_uri = g_filename_to_uri (element->fullpath, NULL, NULL);
sokoke_show_uri (NULL, element_uri,
gtk_get_current_event_time (), NULL);
g_free (element_uri);
}
g_free (text_editor);
}
}
static void
midori_addons_open_target_folder_clicked_cb (GtkWidget* toolitem,
Addons* addons)
{
GtkTreeModel* model;
GtkTreeIter iter;
gchar* folder;
gchar* folder_uri;
if (katze_tree_view_get_selected_iter (GTK_TREE_VIEW (addons->treeview),
&model, &iter))
{
struct AddonElement* element;
gtk_tree_model_get (model, &iter, 0, &element, -1);
folder = g_path_get_dirname (element->fullpath);
}
else
folder = g_build_path (G_DIR_SEPARATOR_S, g_get_user_data_dir (),
PACKAGE_NAME,
addons->kind == ADDONS_USER_SCRIPTS
? "scripts" : "styles", NULL);
folder_uri = g_filename_to_uri (folder, NULL, NULL);
g_free (folder);
sokoke_show_uri (gtk_widget_get_screen (GTK_WIDGET (addons->treeview)),
folder_uri, gtk_get_current_event_time (), NULL);
g_free (folder_uri);
}
static void
midori_addons_popup_item (GtkMenu* menu,
const gchar* stock_id,
const gchar* label,
struct AddonElement* element,
gpointer callback,
Addons* addons)
{
GtkWidget* menuitem;
menuitem = gtk_image_menu_item_new_from_stock (stock_id, NULL);
if (label)
gtk_label_set_text_with_mnemonic (GTK_LABEL (gtk_bin_get_child (
GTK_BIN (menuitem))), label);
if (!strcmp (stock_id, GTK_STOCK_EDIT))
gtk_widget_set_sensitive (menuitem, element->fullpath !=NULL);
else if (strcmp (stock_id, GTK_STOCK_DELETE))
gtk_widget_set_sensitive (menuitem, element->fullpath !=NULL);
g_object_set_data (G_OBJECT (menuitem), "AddonElement", &element);
g_signal_connect (menuitem, "activate", G_CALLBACK(callback), addons);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
}
static void
midori_addons_popup (GtkWidget* widget,
GdkEventButton* event,
struct AddonElement* element,
Addons* addons)
{
GtkWidget* menu;
menu = gtk_menu_new ();
midori_addons_popup_item (GTK_MENU (menu), GTK_STOCK_EDIT, _("Open in Text Editor"),
element, midori_addons_open_in_editor_clicked_cb, addons);
midori_addons_popup_item (GTK_MENU (menu), GTK_STOCK_OPEN, _("Open Target Folder"),
element, midori_addons_open_target_folder_clicked_cb, addons);
midori_addons_popup_item (GTK_MENU (menu), GTK_STOCK_DELETE, NULL,
element, midori_addons_button_delete_clicked_cb, addons);
katze_widget_popup (widget, GTK_MENU (menu), event, KATZE_MENU_POSITION_CURSOR);
}
static gboolean
midori_addons_popup_menu_cb (GtkWidget *widget,
Addons* addons)
{
GtkTreeModel* model;
GtkTreeIter iter;
if (katze_tree_view_get_selected_iter (GTK_TREE_VIEW (widget), &model, &iter))
{
struct AddonElement* element;
gtk_tree_model_get (model, &iter, 0, &element, -1);
midori_addons_popup (widget, NULL, element, addons);
return TRUE;
}
return FALSE;
}
static gboolean
midori_addons_button_release_event_cb (GtkWidget* widget,
GdkEventButton* event,
Addons* addons)
{
GtkTreeModel* model;
GtkTreeIter iter;
if (event->button != 3)
return FALSE;
if (katze_tree_view_get_selected_iter (GTK_TREE_VIEW (widget), &model, &iter))
{
struct AddonElement* element;
gtk_tree_model_get (model, &iter, 0, &element, -1);
midori_addons_popup (widget, NULL, element, addons);
return TRUE;
}
return FALSE;
}
GtkWidget*
addons_get_toolbar (MidoriViewable* viewable)
{
GtkWidget* toolbar;
GtkToolItem* toolitem;
g_return_val_if_fail (IS_ADDONS (viewable), NULL);
if (!ADDONS (viewable)->toolbar)
{
toolbar = gtk_toolbar_new ();
gtk_toolbar_set_icon_size (GTK_TOOLBAR (toolbar), GTK_ICON_SIZE_BUTTON);
toolitem = gtk_tool_item_new ();
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, -1);
gtk_widget_show (GTK_WIDGET (toolitem));
/* add button */
toolitem = gtk_tool_button_new_from_stock (GTK_STOCK_ADD);
gtk_tool_item_set_is_important (toolitem, TRUE);
g_signal_connect (toolitem, "clicked",
G_CALLBACK (midori_addons_button_add_clicked_cb), viewable);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, -1);
gtk_widget_set_tooltip_text (GTK_WIDGET (toolitem), _("Add new addon"));
gtk_widget_show (GTK_WIDGET (toolitem));
/* Text editor button */
toolitem = gtk_tool_button_new_from_stock (GTK_STOCK_EDIT);
g_signal_connect (toolitem, "clicked",
G_CALLBACK (midori_addons_open_in_editor_clicked_cb), viewable);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, -1);
gtk_widget_set_tooltip_text (GTK_WIDGET (toolitem),
_("Open in Text Editor"));
gtk_widget_show (GTK_WIDGET (toolitem));
/* Target folder button */
toolitem = gtk_tool_button_new_from_stock (GTK_STOCK_DIRECTORY);
g_signal_connect (toolitem, "clicked",
G_CALLBACK (midori_addons_open_target_folder_clicked_cb), viewable);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, -1);
gtk_widget_set_tooltip_text (GTK_WIDGET (toolitem),
_("Open Target Folder"));
gtk_widget_show (GTK_WIDGET (toolitem));
/* Delete button */
toolitem = gtk_tool_button_new_from_stock (GTK_STOCK_DELETE);
g_signal_connect (toolitem, "clicked",
G_CALLBACK (midori_addons_button_delete_clicked_cb), viewable);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, -1);
gtk_widget_set_tooltip_text (GTK_WIDGET (toolitem),
_("Open target folder for selected addon"));
gtk_widget_set_tooltip_text (GTK_WIDGET (toolitem), _("Remove selected addon"));
gtk_widget_show (GTK_WIDGET (toolitem));
ADDONS (viewable)->toolbar = toolbar;
g_signal_connect (toolbar, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&ADDONS (viewable)->toolbar);
}
return ADDONS (viewable)->toolbar;
}
static const gchar*
addons_get_label (MidoriViewable* viewable)
{
Addons* addons = ADDONS (viewable);
if (addons->kind == ADDONS_USER_SCRIPTS)
return _("Userscripts");
else if (addons->kind == ADDONS_USER_STYLES)
return _("Userstyles");
return NULL;
}
static const gchar*
addons_get_stock_id (MidoriViewable* viewable)
{
Addons* addons = ADDONS (viewable);
if (addons->kind == ADDONS_USER_SCRIPTS)
return STOCK_SCRIPT;
else if (addons->kind == ADDONS_USER_STYLES)
return STOCK_STYLE;
return NULL;
}
static void
addons_iface_init (MidoriViewableIface* iface)
{
iface->get_stock_id = addons_get_stock_id;
iface->get_label = addons_get_label;
iface->get_toolbar = addons_get_toolbar;
}
static void
addons_free_elements (GSList* elements)
{
struct AddonElement* element;
while (elements)
{
element = elements->data;
g_free (element->fullpath);
g_free (element->displayname);
g_free (element->description);
g_free (element->script_content);
g_slist_free (element->includes);
g_slist_free (element->excludes);
g_slice_free (struct AddonElement, element);
elements = g_slist_next (elements);
}
}
static void
addons_class_init (AddonsClass* class)
{
}
static void
addons_treeview_render_tick_cb (GtkTreeViewColumn* column,
GtkCellRenderer* renderer,
GtkTreeModel* model,
GtkTreeIter* iter,
GtkWidget* treeview)
{
struct AddonElement *element;
gtk_tree_model_get (model, iter, 0, &element, -1);
g_object_set (renderer,
"active", element->enabled,
"sensitive", !element->broken,
NULL);
}
static void
addons_cell_renderer_toggled_cb (GtkCellRendererToggle* renderer,
const gchar* path,
Addons* addons)
{
GtkTreeModel* model;
GtkTreeIter iter;
model = gtk_tree_view_get_model (GTK_TREE_VIEW (addons->treeview));
if (gtk_tree_model_get_iter_from_string (model, &iter, path))
{
struct AddonElement *element;
GtkTreePath* tree_path;
gtk_tree_model_get (model, &iter, 0, &element, -1);
element->enabled = !element->enabled;
/* After enabling or disabling an element, the tree view
is not updated automatically; we need to notify tree model
in order to take the modification into account */
tree_path = gtk_tree_path_new_from_string (path);
gtk_tree_model_row_changed (model, tree_path, &iter);
gtk_tree_path_free (tree_path);
}
}
static void
addons_treeview_render_text_cb (GtkTreeViewColumn* column,
GtkCellRenderer* renderer,
GtkTreeModel* model,
GtkTreeIter* iter,
GtkWidget* treeview)
{
struct AddonElement *element;
gtk_tree_model_get (model, iter, 0, &element, -1);
g_object_set (renderer, "text", element->displayname, NULL);
if (!element->enabled)
g_object_set (renderer, "sensitive", false, NULL);
else
g_object_set (renderer, "sensitive", true, NULL);
}
static void
addons_treeview_row_activated_cb (GtkTreeView* treeview,
GtkTreePath* path,
GtkTreeViewColumn* column,
Addons* addons)
{
GtkTreeModel* model = gtk_tree_view_get_model (treeview);
GtkTreeIter iter;
if (gtk_tree_model_get_iter (model, &iter, path))
{
struct AddonElement *element;
gtk_tree_model_get (model, &iter, 0, &element, -1);
element->enabled = !element->enabled;
/* After enabling or disabling an element, the tree view
is not updated automatically; we need to notify tree model
in order to take the modification into account */
gtk_tree_model_row_changed (model, path, &iter);
}
}
static GSList*
addons_get_directories (AddonsKind kind)
{
gchar* folder_name;
GSList* directories;
const char* const* datadirs;
gchar* path;
g_assert (kind == ADDONS_USER_SCRIPTS || kind == ADDONS_USER_STYLES);
directories = NULL;
if (kind == ADDONS_USER_SCRIPTS)
folder_name = g_strdup ("scripts");
else if (kind == ADDONS_USER_STYLES)
folder_name = g_strdup ("styles");
else
g_assert_not_reached ();
path = g_build_path (G_DIR_SEPARATOR_S, g_get_user_data_dir (),
PACKAGE_NAME, folder_name, NULL);
if (g_access (path, X_OK) == 0)
directories = g_slist_prepend (directories, path);
else
g_free (path);
datadirs = g_get_system_data_dirs ();
while (*datadirs)
{
path = g_build_path (G_DIR_SEPARATOR_S, *datadirs,
PACKAGE_NAME, folder_name, NULL);
if (g_access (path, X_OK) == 0)
directories = g_slist_prepend (directories, path);
else
g_free (path);
datadirs++;
}
g_free (folder_name);
return directories;
}
static GSList*
addons_get_files (AddonsKind kind)
{
GSList* files;
GDir* addon_dir;
GSList* directories;
const gchar* filename;
gchar* dirname;
gchar* fullname;
gchar* file_extension;
g_assert (kind == ADDONS_USER_SCRIPTS || kind == ADDONS_USER_STYLES);
if (kind == ADDONS_USER_SCRIPTS)
file_extension = g_strdup (".js");
else if (kind == ADDONS_USER_STYLES)
file_extension = g_strdup (".css");
files = NULL;
directories = addons_get_directories (kind);
while (directories)
{
dirname = directories->data;
if ((addon_dir = g_dir_open (dirname, 0, NULL)))
{
while ((filename = g_dir_read_name (addon_dir)))
{
if (g_str_has_suffix (filename, file_extension))
{
fullname = g_build_filename (dirname, filename, NULL);
files = g_slist_prepend (files, fullname);
}
}
g_dir_close (addon_dir);
}
g_free (dirname);
directories = g_slist_next (directories);
}
g_free (file_extension);
g_slist_free (directories);
return files;
}
static gboolean
js_metadata_from_file (const gchar* filename,
GSList** includes,
GSList** excludes,
gchar** name,
gchar** description)
{
GIOChannel* channel;
gboolean found_meta;
gchar* line;
gchar* rest_of_line;
if (!g_file_test (filename, G_FILE_TEST_IS_REGULAR | G_FILE_TEST_IS_SYMLINK))
return FALSE;
channel = g_io_channel_new_file (filename, "r", 0);
if (!channel)
return FALSE;
found_meta = FALSE;
while (g_io_channel_read_line (channel, &line, NULL, NULL, NULL)
== G_IO_STATUS_NORMAL)
{
if (g_str_has_prefix (line, "// ==UserScript=="))
found_meta = TRUE;
else if (found_meta)
{
if (g_str_has_prefix (line, "// ==/UserScript=="))
found_meta = FALSE;
else if (g_str_has_prefix (line, "// @require ") ||
g_str_has_prefix (line, "// @resource "))
{
/* We don't support these, so abort here */
g_free (line);
g_io_channel_shutdown (channel, false, 0);
g_slist_free (*includes);
g_slist_free (*excludes);
*includes = NULL;
*excludes = NULL;
return FALSE;
}
else if (includes && g_str_has_prefix (line, "// @include "))
{
rest_of_line = g_strdup (line + strlen ("// @include "));
rest_of_line = g_strstrip (rest_of_line);
*includes = g_slist_prepend (*includes, rest_of_line);
}
else if (excludes && g_str_has_prefix (line, "// @exclude "))
{
rest_of_line = g_strdup (line + strlen ("// @exclude "));
rest_of_line = g_strstrip (rest_of_line);
*excludes = g_slist_prepend (*excludes, rest_of_line);
}
else if (name && g_str_has_prefix (line, "// @name "))
{
rest_of_line = g_strdup (line + strlen ("// @name "));
rest_of_line = g_strstrip (rest_of_line);
*name = rest_of_line;
}
else if (description && g_str_has_prefix (line, "// @description "))
{
rest_of_line = g_strdup (line + strlen ("// @description "));
rest_of_line = g_strstrip (rest_of_line);
*description = rest_of_line;
}
}
g_free (line);
}
g_io_channel_shutdown (channel, false, 0);
g_io_channel_unref (channel);
return TRUE;
}
static gboolean
css_metadata_from_file (const gchar* filename,
GSList** includes,
GSList** excludes)
{
GIOChannel* channel;
gchar* line;
gchar* rest_of_line;
gboolean line_has_meta;
if (!g_file_test (filename, G_FILE_TEST_IS_REGULAR | G_FILE_TEST_IS_SYMLINK))
return FALSE;
channel = g_io_channel_new_file (filename, "r", 0);
if (!channel)
return FALSE;
line_has_meta = FALSE;
while (g_io_channel_read_line (channel, &line, NULL, NULL, NULL)
== G_IO_STATUS_NORMAL)
{
if (g_str_has_prefix (line, "@-moz-document") || line_has_meta)
{ /* FIXME: We merely look for includes. We should honor blocks. */
if (includes)
{
gchar** parts;
guint i;
if (g_str_has_prefix (line, "@-moz-document"))
rest_of_line = g_strdup (line + strlen ("@-moz-document"));
else
rest_of_line = g_strdup (line);
rest_of_line = g_strstrip (rest_of_line);
parts = g_strsplit (rest_of_line, " ", 0);
i = 0;
while (parts[i] && (*parts[i] != '\0' && *parts[i] != '{'))
{
gchar* value = NULL;
if (g_str_has_prefix (parts[i], "url-prefix("))
value = g_strdup (parts[i] + strlen ("url-prefix("));
else if (g_str_has_prefix (parts[i], "domain("))
value = g_strdup (parts[i] + strlen ("domain("));
else if (g_str_has_prefix (parts[i], "url("))
value = g_strdup (parts[i] + strlen ("url("));
if (value)
{
guint begin, end;
gchar* domain;
line_has_meta = TRUE;
begin = value[0] == '"' || value[0] == '\'' ? 1 : 0;
end = 1;
while (value[end] != '\0' && value[end] != ')')
++end;
domain = g_strndup (value + begin, end - begin * 2);
if (!strncmp ("http", domain, 4))
*includes = g_slist_prepend (*includes, domain);
else
{
*includes = g_slist_prepend (*includes,
g_strdup_printf ("http://*%s/*", domain));
g_free (domain);
}
g_free (value);
}
i++;
}
g_strfreev (parts);
}
line_has_meta = g_str_has_suffix (rest_of_line, "{") ? FALSE : TRUE;
}
g_free (line);
}
g_io_channel_shutdown (channel, false, 0);
g_io_channel_unref (channel);
return TRUE;
}
static gboolean
addons_get_element_content (gchar* file_path,
AddonsKind kind,
gchar** content)
{
gchar* file_content;
guint meta;
guint i, n;
g_assert (kind == ADDONS_USER_SCRIPTS || kind == ADDONS_USER_STYLES);
if (g_file_get_contents (file_path, &file_content, NULL, NULL))
{
if (kind == ADDONS_USER_SCRIPTS)
{
*content = g_strdup_printf (
"window.addEventListener ('DOMContentLoaded',"
"function () { %s }, true);", file_content);
}
else if (kind == ADDONS_USER_STYLES)
{
meta = 0;
n = strlen (file_content);
for (i = 0; i < n; i++)
{
/* Replace line breaks with spaces */
if (file_content[i] == '\n' || file_content[i] == '\r')
file_content[i] = ' ';
/* Change all single quotes to double quotes */
if (file_content[i] == '\'')
file_content[i] = '\"';
/* Turn metadata we inspected earlier into comments */
if (!meta && file_content[i] == '@')
{
file_content[i] = '/';
meta++;
}
else if (meta == 1
&& (file_content[i] == '-' || file_content[i] == 'n'))
{
file_content[i] = '*';
meta++;
}
else if (meta == 2 && file_content[i] == '{')
{
file_content[i - 1] = '*';
file_content[i] = '/';
meta++;
}
else if (meta == 3 && file_content[i] == '{')
meta++;
else if (meta == 4 && file_content[i] == '}')
meta--;
else if (meta == 3 && file_content[i] == '}')
{
file_content[i] = ' ';
meta = 0;
}
}
*content = g_strdup_printf (
"window.addEventListener ('DOMContentLoaded',"
"function () {"
"var mystyle = document.createElement(\"style\");"
"mystyle.setAttribute(\"type\", \"text/css\");"
"mystyle.appendChild(document.createTextNode('%s'));"
"var head = document.getElementsByTagName(\"head\")[0];"
"if (head) head.appendChild(mystyle);"
"else document.documentElement.insertBefore"
"(mystyle, document.documentElement.firstChild);"
"}, true);",
file_content);
}
g_free (file_content);
if (*content)
return TRUE;
}
return FALSE;
}
static void
addons_update_elements (MidoriExtension* extension,
AddonsKind kind)
{
GSList* addon_files;
gchar* name;
gchar* fullpath;
struct AddonElement* element;
struct AddonsList* addons_list;
GSList* elements = NULL;
GtkListStore* liststore = NULL;
GtkTreeIter iter;
gchar* config_file;
GKeyFile* keyfile;
if (kind == ADDONS_USER_SCRIPTS)
addons_list = g_object_get_data (G_OBJECT (extension), "scripts-list");
else if (kind == ADDONS_USER_STYLES)
addons_list = g_object_get_data (G_OBJECT (extension), "styles-list");
else
g_assert_not_reached ();
if (addons_list)
{
liststore = addons_list->liststore;
elements = addons_list->elements;
}
if (elements)
addons_free_elements (elements);
if (liststore)
gtk_list_store_clear (liststore);
else
liststore = gtk_list_store_new (4, G_TYPE_POINTER,
G_TYPE_INT,
G_TYPE_STRING,
G_TYPE_STRING);
keyfile = g_key_file_new ();
config_file = g_build_filename (midori_extension_get_config_dir (extension),
"addons", NULL);
g_key_file_load_from_file (keyfile, config_file, G_KEY_FILE_NONE, NULL);
addon_files = addons_get_files (kind);
elements = NULL;
while (addon_files)
{
gchar* filename;
gchar* tooltip;
fullpath = addon_files->data;
element = g_slice_new (struct AddonElement);
element->displayname = g_filename_display_basename (fullpath);
element->fullpath = fullpath;
element->enabled = TRUE;
element->broken = FALSE;
element->includes = NULL;
element->excludes = NULL;
element->description = NULL;
element->script_content = NULL;
if (kind == ADDONS_USER_SCRIPTS)
{
name = NULL;
if (!js_metadata_from_file (fullpath,
&element->includes, &element->excludes,
&name, &element->description))
element->broken = TRUE;
if (name)
katze_assign (element->displayname, name);
if (!element->broken)
if (!addons_get_element_content (fullpath, kind,
&(element->script_content)))
element->broken = TRUE;
if (g_key_file_get_integer (keyfile, "scripts", fullpath, NULL) & 1)
element->enabled = FALSE;
}
else if (kind == ADDONS_USER_STYLES)
{
if (!css_metadata_from_file (fullpath,
&element->includes,
&element->excludes))
element->broken = TRUE;
if (!element->broken)
if (!addons_get_element_content (fullpath, kind,
&(element->script_content)))
element->broken = TRUE;
if (g_key_file_get_integer (keyfile, "styles", fullpath, NULL) & 1)
element->enabled = FALSE;
}
filename = g_path_get_basename (element->fullpath);
if (element->description)
{
tooltip = g_strdup_printf ("%s\n\n%s",
filename, element->description);
g_free (filename);
}
else
tooltip = filename;
gtk_list_store_append (liststore, &iter);
gtk_list_store_set (liststore, &iter,
0, element, 1, 0, 2, element->fullpath,
3, tooltip, -1);
g_free (tooltip);
addon_files = g_slist_next (addon_files);
elements = g_slist_prepend (elements, element);
}
g_free (config_file);
g_key_file_free (keyfile);
g_slice_free (struct AddonsList, addons_list);
addons_list = g_slice_new (struct AddonsList);
addons_list->elements = elements;
addons_list->liststore = liststore;
if (kind == ADDONS_USER_SCRIPTS)
g_object_set_data (G_OBJECT (extension), "scripts-list", addons_list);
else if (kind == ADDONS_USER_STYLES)
g_object_set_data (G_OBJECT (extension), "styles-list", addons_list);
}
static void
addons_init (Addons* addons)
{
GtkTreeViewColumn* column;
GtkCellRenderer* renderer_text;
GtkCellRenderer* renderer_toggle;
addons->treeview = gtk_tree_view_new ();
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (addons->treeview), FALSE);
column = gtk_tree_view_column_new ();
renderer_toggle = gtk_cell_renderer_toggle_new ();
gtk_tree_view_column_pack_start (column, renderer_toggle, FALSE);
gtk_tree_view_column_set_cell_data_func (column, renderer_toggle,
(GtkTreeCellDataFunc)addons_treeview_render_tick_cb,
addons->treeview, NULL);
g_signal_connect (renderer_toggle, "toggled",
G_CALLBACK (addons_cell_renderer_toggled_cb), addons);
gtk_tree_view_append_column (GTK_TREE_VIEW (addons->treeview), column);
column = gtk_tree_view_column_new ();
renderer_text = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, renderer_text, FALSE);
gtk_tree_view_column_set_cell_data_func (column, renderer_text,
(GtkTreeCellDataFunc)addons_treeview_render_text_cb,
addons->treeview, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (addons->treeview), column);
gtk_tree_view_set_tooltip_column (GTK_TREE_VIEW (addons->treeview), 3);
g_signal_connect (addons->treeview, "row-activated",
G_CALLBACK (addons_treeview_row_activated_cb),
addons);
g_signal_connect (addons->treeview, "button-release-event",
G_CALLBACK (midori_addons_button_release_event_cb),
addons);
g_signal_connect (addons->treeview, "popup-menu",
G_CALLBACK (midori_addons_popup_menu_cb),
addons);
gtk_widget_show (addons->treeview);
gtk_box_pack_start (GTK_BOX (addons), addons->treeview, TRUE, TRUE, 0);
}
static gchar*
addons_convert_to_simple_regexp (const gchar* pattern)
{
guint len;
gchar* dest;
guint pos;
guint i;
gchar c;
len = strlen (pattern);
dest = g_malloc0 (len * 2 + 1);
dest[0] = '^';
pos = 1;
for (i = 0; i < len; i++)
{
c = pattern[i];
switch (c)
{
case '*':
dest[pos] = '.';
dest[pos + 1] = c;
pos++;
pos++;
break;
case '.' :
case '?' :
case '^' :
case '$' :
case '+' :
case '{' :
case '[' :
case '|' :
case '(' :
case ')' :
case ']' :
case '\\' :
dest[pos] = '\\';
dest[pos + 1] = c;
pos++;
pos++;
break;
case ' ' :
break;
default:
dest[pos] = pattern[i];
pos ++;
}
}
return dest;
}
static gboolean
addons_may_run (const gchar* uri,
GSList** includes,
GSList** excludes)
{
gboolean match;
GSList* list;
if (*includes)
match = FALSE;
else
match = TRUE;
list = *includes;
while (list)
{
gchar* re = addons_convert_to_simple_regexp (list->data);
gboolean matched = g_regex_match_simple (re, uri, 0, 0);
g_free (re);
if (matched)
{
match = TRUE;
break;
}
list = g_slist_next (list);
}
if (!match)
return FALSE;
list = *excludes;
while (list)
{
gchar* re = addons_convert_to_simple_regexp (list->data);
gboolean matched = g_regex_match_simple (re, uri, 0, 0);
g_free (re);
if (matched)
{
match = FALSE;
break;
}
list = g_slist_next (list);
}
return match;
}
static gboolean
addons_skip_element (struct AddonElement* element,
gchar* uri)
{
if (!element->enabled || element->broken)
return TRUE;
if (element->includes || element->excludes)
if (!addons_may_run (uri, &element->includes, &element->excludes))
return TRUE;
return FALSE;
}
static void
addons_context_ready_cb (WebKitWebView* web_view,
WebKitWebFrame* web_frame,
JSContextRef js_context,
JSObjectRef js_window,
MidoriExtension* extension)
{
gchar* uri;
GSList* scripts, *styles;
struct AddonElement* script, *style;
struct AddonsList* scripts_list, *styles_list;
uri = katze_object_get_string (web_view, "uri");
/* Don't run scripts or styles on blank or special pages */
if (!(uri && *uri && strncmp (uri, "about:", 6)))
{
g_free (uri);
return;
}
scripts_list = g_object_get_data (G_OBJECT (extension), "scripts-list");
scripts = scripts_list->elements;
while (scripts)
{
script = scripts->data;
if (addons_skip_element (script, uri))
{
scripts = g_slist_next (scripts);
continue;
}
if (script->script_content)
webkit_web_view_execute_script (web_view, script->script_content);
scripts = g_slist_next (scripts);
}
styles_list = g_object_get_data (G_OBJECT (extension), "styles-list");
styles = styles_list->elements;
while (styles)
{
style = styles->data;
if (addons_skip_element (style, uri))
{
styles = g_slist_next (styles);
continue;
}
if (style->script_content)
webkit_web_view_execute_script (web_view, style->script_content);
styles = g_slist_next (styles);
}
g_free (uri);
}
static void
addons_add_tab_cb (MidoriBrowser* browser,
MidoriView* view,
MidoriExtension* extension)
{
GtkWidget* web_view = midori_view_get_web_view (view);
g_signal_connect (web_view, "window-object-cleared",
G_CALLBACK (addons_context_ready_cb), extension);
}
static void
addons_add_tab_foreach_cb (MidoriView* view,
MidoriBrowser* browser,
MidoriExtension* extension)
{
addons_add_tab_cb (browser, view, extension);
}
static void
addons_deactivate_tabs (MidoriView* view,
MidoriExtension* extension)
{
GtkWidget* web_view = midori_view_get_web_view (view);
g_signal_handlers_disconnect_by_func (
web_view, addons_context_ready_cb, extension);
}
static void
addons_browser_destroy (MidoriBrowser* browser,
MidoriExtension* extension)
{
GtkWidget* scripts, *styles;
midori_browser_foreach (browser, (GtkCallback)addons_deactivate_tabs, extension);
g_signal_handlers_disconnect_by_func (browser, addons_add_tab_cb, extension);
scripts = (GtkWidget*)g_object_get_data (G_OBJECT (browser), "scripts-addons");
gtk_widget_destroy (scripts);
styles = (GtkWidget*)g_object_get_data (G_OBJECT (browser), "styles-addons");
gtk_widget_destroy (styles);
}
GtkWidget*
addons_new (AddonsKind kind, MidoriExtension* extension)
{
GtkWidget* addons;
GtkListStore* liststore;
struct AddonsList* list;
addons = g_object_new (ADDONS_TYPE, NULL);
ADDONS (addons)->kind = kind;
if (kind == ADDONS_USER_SCRIPTS)
list = g_object_get_data (G_OBJECT (extension), "scripts-list");
else if (kind == ADDONS_USER_STYLES)
list = g_object_get_data (G_OBJECT (extension), "styles-list");
else
g_assert_not_reached ();
liststore = list->liststore;
gtk_tree_view_set_model (GTK_TREE_VIEW (ADDONS(addons)->treeview),
GTK_TREE_MODEL (liststore));
gtk_widget_queue_draw (GTK_WIDGET (ADDONS(addons)->treeview));
return addons;
}
static void
addons_app_add_browser_cb (MidoriApp* app,
MidoriBrowser* browser,
MidoriExtension* extension)
{
GtkWidget* panel;
GtkWidget* scripts, *styles;
midori_browser_foreach (browser,
(GtkCallback)addons_add_tab_foreach_cb, extension);
g_signal_connect (browser, "add-tab",
G_CALLBACK (addons_add_tab_cb), extension);
g_signal_connect (browser, "notify::load-status",
G_CALLBACK (addons_notify_load_status_cb), extension);
panel = katze_object_get_object (browser, "panel");
scripts = addons_new (ADDONS_USER_SCRIPTS, extension);
gtk_widget_show (scripts);
midori_panel_append_page (MIDORI_PANEL (panel), MIDORI_VIEWABLE (scripts));
g_object_set_data (G_OBJECT (browser), "scripts-addons", scripts);
styles = addons_new (ADDONS_USER_STYLES, extension);
gtk_widget_show (styles);
midori_panel_append_page (MIDORI_PANEL (panel), MIDORI_VIEWABLE (styles));
g_object_set_data (G_OBJECT (browser), "styles-addons", styles);
g_object_unref (panel);
}
static void
addons_save_settings (MidoriApp* app,
MidoriExtension* extension)
{
struct AddonsList* scripts_list, *styles_list;
struct AddonElement* script, *style;
GSList* scripts, *styles;
GKeyFile* keyfile;
const gchar* config_dir;
gchar* config_file;
GError* error = NULL;
keyfile = g_key_file_new ();
/* scripts */
scripts_list = g_object_get_data (G_OBJECT (extension), "scripts-list");
scripts = scripts_list->elements;
while (scripts)
{
script = scripts->data;
if (!script->enabled)
g_key_file_set_integer (keyfile, "scripts", script->fullpath, 1);
scripts = g_slist_next (scripts);
}
/* styles */
styles_list = g_object_get_data (G_OBJECT (extension), "styles-list");
styles = styles_list->elements;
while (styles)
{
style = styles->data;
if (!style->enabled)
g_key_file_set_integer (keyfile, "styles", style->fullpath, 1);
styles = g_slist_next (styles);
}
config_dir = midori_extension_get_config_dir (extension);
config_file = g_build_filename (config_dir, "addons", NULL);
katze_mkdir_with_parents (config_dir, 0700);
sokoke_key_file_save_to_file (keyfile, config_file, &error);
if (error)
{
g_warning (_("The configuration of the extension '%s' couldn't be saved: %s\n"),
_("User addons"), error->message);
g_error_free (error);
}
g_free (config_file);
g_key_file_free (keyfile);
}
static void
addons_disable_monitors (MidoriExtension* extension)
{
GSList* monitors;
monitors = g_object_get_data (G_OBJECT (extension), "monitors");
if (!monitors)
return;
g_slist_foreach (monitors, (GFunc)g_file_monitor_cancel, NULL);
g_slist_free (monitors);
g_object_set_data (G_OBJECT (extension), "monitors", NULL);
}
static void
addons_deactivate_cb (MidoriExtension* extension,
MidoriApp* app)
{
KatzeArray* browsers;
MidoriBrowser* browser;
GSource* source;
addons_disable_monitors (extension);
addons_save_settings (NULL, extension);
browsers = katze_object_get_object (app, "browsers");
KATZE_ARRAY_FOREACH_ITEM (browser, browsers)
addons_browser_destroy (browser, extension);
source = g_object_get_data (G_OBJECT (extension), "monitor-timer");
if (source && !g_source_is_destroyed (source))
g_source_destroy (source);
g_signal_handlers_disconnect_by_func (
app, addons_app_add_browser_cb, extension);
g_signal_handlers_disconnect_by_func (
app, addons_save_settings, extension);
g_signal_handlers_disconnect_by_func (
extension, addons_deactivate_cb, app);
g_object_unref (browsers);
}
static gboolean
addons_reset_all_elements_cb (MidoriExtension* extension)
{
addons_save_settings (NULL, extension);
addons_update_elements (extension, ADDONS_USER_STYLES);
addons_update_elements (extension, ADDONS_USER_SCRIPTS);
g_object_set_data (G_OBJECT (extension), "monitor-timer", NULL);
return FALSE;
}
static void
addons_directory_monitor_changed (GFileMonitor* monitor,
GFile* child,
GFile* other_file,
GFileMonitorEvent flags,
MidoriExtension* extension)
{
char* basename;
GSource* source;
basename = g_file_get_basename (child);
if (g_str_has_prefix (basename, ".") ||
g_str_has_suffix (basename, "~")) /* Hidden or temporary files */
return;
/* We receive a lot of change events, so we use a timeout to trigger
elements update only once */
source = g_object_get_data (G_OBJECT (extension), "monitor-timer");
if (source && !g_source_is_destroyed (source))
g_source_destroy (source);
source = g_timeout_source_new_seconds (1);
g_source_set_callback (source, (GSourceFunc)addons_reset_all_elements_cb,
extension, NULL);
g_source_attach (source, NULL);
g_object_set_data (G_OBJECT (extension), "monitor-timer", source);
g_source_unref (source);
}
static void
addons_monitor_directories (MidoriExtension* extension,
AddonsKind kind)
{
GSList* directories;
GError* error;
GSList* monitors;
GFileMonitor* monitor;
GFile* directory;
g_assert (kind == ADDONS_USER_SCRIPTS || kind == ADDONS_USER_STYLES);
monitors = g_object_get_data (G_OBJECT (extension), "monitors");
directories = addons_get_directories (kind);
while (directories)
{
directory = g_file_new_for_path (directories->data);
directories = g_slist_next (directories);
error = NULL;
monitor = g_file_monitor_directory (directory,
G_FILE_MONITOR_NONE,
NULL, &error);
if (monitor)
{
g_signal_connect (monitor, "changed",
G_CALLBACK (addons_directory_monitor_changed), extension);
monitors = g_slist_prepend (monitors, monitor);
}
else
{
g_warning (_("Can't monitor folder '%s': %s"),
g_file_get_parse_name (directory), error->message);
g_error_free (error);
}
g_object_unref (directory);
}
g_object_set_data (G_OBJECT (extension), "monitors", monitors);
g_slist_free (directories);
}
static void
addons_activate_cb (MidoriExtension* extension,
MidoriApp* app)
{
KatzeArray* browsers;
MidoriBrowser* browser;
browsers = katze_object_get_object (app, "browsers");
addons_update_elements (extension, ADDONS_USER_STYLES);
addons_monitor_directories (extension, ADDONS_USER_STYLES);
addons_update_elements (extension, ADDONS_USER_SCRIPTS);
addons_monitor_directories (extension, ADDONS_USER_SCRIPTS);
KATZE_ARRAY_FOREACH_ITEM (browser, browsers)
addons_app_add_browser_cb (app, browser, extension);
g_object_unref (browsers);
g_signal_connect (app, "add-browser",
G_CALLBACK (addons_app_add_browser_cb), extension);
g_signal_connect (app, "quit",
G_CALLBACK (addons_save_settings), extension);
g_signal_connect (extension, "deactivate",
G_CALLBACK (addons_deactivate_cb), app);
}
MidoriExtension*
extension_init (void)
{
MidoriExtension* extension = g_object_new (MIDORI_TYPE_EXTENSION,
"name", _("User addons"),
"description", _("Support for userscripts and userstyles"),
"version", "0.1",
"authors", "Arno Renevier <arno@renevier.net>",
NULL);
g_signal_connect (extension, "activate",
G_CALLBACK (addons_activate_cb), NULL);
return extension;
}
Reference in a new issue View git blame Copy permalink