Merge lp:~tuxator/midori/nojs into lp:midori

[Paweł Forysiuk]

Introduce extension for managing javascript execution policy per domain

[Cris Dywan (kalikiana)]

Nice stuff. Let's get this in!

review: Approve

=== added directory 'data/nojs'
=== added file 'data/nojs/nojs-statusicon-allowed.png'
 Binary files data/nojs/nojs-statusicon-allowed.png	1970-01-01 00:00:00 +0000 and data/nojs/nojs-statusicon-allowed.png	2013-07-29 19:51:25 +0000 differ
=== added file 'data/nojs/nojs-statusicon-denied.png'
 Binary files data/nojs/nojs-statusicon-denied.png	1970-01-01 00:00:00 +0000 and data/nojs/nojs-statusicon-denied.png	2013-07-29 19:51:25 +0000 differ
=== added file 'data/nojs/nojs-statusicon-mixed.png'
 Binary files data/nojs/nojs-statusicon-mixed.png	1970-01-01 00:00:00 +0000 and data/nojs/nojs-statusicon-mixed.png	2013-07-29 19:51:25 +0000 differ
=== added directory 'extensions/nojs'
=== added file 'extensions/nojs/README.md'
--- extensions/nojs/README.md	1970-01-01 00:00:00 +0000
+++ extensions/nojs/README.md	2013-07-29 19:51:25 +0000
@@ -0,0 +1,1 @@
+This is an extension for Midori web browser. With this extension you can manage which sites are allowed to execute javascript.
 
=== added file 'extensions/nojs/main.c'
--- extensions/nojs/main.c	1970-01-01 00:00:00 +0000
+++ extensions/nojs/main.c	2013-07-29 19:51:25 +0000
@@ -0,0 +1,79 @@
+/*
+ Copyright (C) 2013 Stephan Haller <[e-mail]>
+
+ 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.
+*/
+
+#include "nojs.h"
+#include "nojs-preferences.h"
+
+/* Global instance */
+NoJS		*noJS=NULL;
+
+/* This extension was activated */
+static void _nojs_on_activate(MidoriExtension *inExtension, MidoriApp *inApp, gpointer inUserData)
+{
+	g_return_if_fail(noJS==NULL);
+
+	noJS=nojs_new(inExtension, inApp);
+	nojs_set_policy_for_unknown_domain(noJS, midori_extension_get_integer(inExtension, "unknown-domain-policy"));
+	nojs_set_allow_all_sites(noJS, midori_extension_get_boolean(inExtension, "allow-all-sites"));
+	nojs_set_only_second_level_domain(noJS, midori_extension_get_boolean(inExtension, "only-second-level"));
+}
+
+/* This extension was deactivated */
+static void _nojs_on_deactivate(MidoriExtension *inExtension, gpointer inUserData)
+{
+	g_return_if_fail(noJS);
+
+	g_object_unref(noJS);
+	noJS=NULL;
+}
+
+/* Preferences of this extension should be opened */
+static void _nojs_on_preferences_response(GtkWidget* inDialog,
+											gint inResponse,
+											gpointer *inUserData)
+{
+	gtk_widget_destroy(inDialog);
+}
+
+static void _nojs_on_open_preferences(MidoriExtension *inExtension)
+{
+	g_return_if_fail(noJS);
+
+	/* Show preferences window */
+	GtkWidget* dialog;
+
+	dialog=nojs_preferences_new(noJS);
+	gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
+	g_signal_connect(dialog, "response", G_CALLBACK (_nojs_on_preferences_response), NULL);
+	gtk_widget_show_all(dialog);
+}
+
+/* Main entry for extension */
+MidoriExtension *extension_init(void)
+{
+	/* Set up extension */
+	MidoriExtension	*extension=g_object_new(MIDORI_TYPE_EXTENSION,
+												"name", _("NoJS"),
+												"description", _("Manage javascript permission per site"),
+												"version", "0.1" MIDORI_VERSION_SUFFIX,
+												"authors", "Stephan Haller <[e-mail]>",
+												NULL);
+
+	midori_extension_install_integer(extension, "unknown-domain-policy", NOJS_POLICY_BLOCK);
+	midori_extension_install_boolean(extension, "allow-all-sites", FALSE);
+	midori_extension_install_boolean(extension, "only-second-level", TRUE);
+
+	g_signal_connect(extension, "activate", G_CALLBACK(_nojs_on_activate), NULL);
+	g_signal_connect(extension, "deactivate", G_CALLBACK(_nojs_on_deactivate), NULL);
+	g_signal_connect(extension, "open-preferences", G_CALLBACK(_nojs_on_open_preferences), NULL);
+
+	return(extension);
+}
 
=== added file 'extensions/nojs/nojs-preferences.c'
--- extensions/nojs/nojs-preferences.c	1970-01-01 00:00:00 +0000
+++ extensions/nojs/nojs-preferences.c	2013-07-29 19:51:25 +0000
@@ -0,0 +1,746 @@
+/*
+ Copyright (C) 2013 Stephan Haller <[e-mail]>
+
+ 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.
+*/
+
+#include "nojs-preferences.h"
+
+/* Define this class in GObject system */
+G_DEFINE_TYPE(NoJSPreferences,
+				nojs_preferences,
+				GTK_TYPE_DIALOG)
+
+/* Properties */
+enum
+{
+	PROP_0,
+
+	PROP_MANAGER,
+
+	PROP_LAST
+};
+
+static GParamSpec* NoJSPreferencesProperties[PROP_LAST]={ 0, };
+
+/* Private structure - access only by public API if needed */
+#define NOJS_PREFERENCES_GET_PRIVATE(obj) \
+	(G_TYPE_INSTANCE_GET_PRIVATE((obj), TYPE_NOJS_PREFERENCES, NoJSPreferencesPrivate))
+
+struct _NoJSPreferencesPrivate
+{
+	/* Extension related */
+	NoJS					*manager;
+	sqlite3					*database;
+
+	/* Dialog related */
+	GtkWidget				*contentArea;
+	GtkListStore			*listStore;
+	GtkWidget				*list;
+	GtkTreeSelection		*listSelection;
+	GtkWidget				*deleteButton;
+	GtkWidget				*deleteAllButton;
+	GtkWidget				*allowAllSitesCheckbox;
+	GtkWidget				*blockUnknownDomainsCheckbox;
+	GtkWidget				*checkSecondLevelOnlyCheckbox;
+
+	gint					signalAllowAllSitesToggledID;
+	gint					signalBlockUnknownDomainsToggledID;
+	gint					signalCheckSecondLevelOnlyToggledID;
+
+	gint					signalManagerChangedDatabaseID;
+	gint					signalManagerChangedAllowAllSitesID;
+	gint					signalManagerChangedUnknownDomainPolicyID;
+	gint					signalManagerChangedCheckSecondLevelID;
+};
+
+enum
+{
+	DOMAIN_COLUMN,
+	POLICY_COLUMN,
+	N_COLUMN
+};
+
+
+/* IMPLEMENTATION: Private variables and methods */
+
+/* Fill domain list with stored policies */
+static void _nojs_preferences_fill(NoJSPreferences *self)
+{
+	NoJSPreferencesPrivate	*priv=self->priv;
+	gint					success;
+	sqlite3_stmt			*statement=NULL;
+
+	/* Clear tree/list view */
+	gtk_list_store_clear(priv->listStore);
+
+	/* If no database is present return here */
+	if(!priv->database) return;
+
+	/* Fill list store with policies from database */
+	success=sqlite3_prepare_v2(priv->database,
+								"SELECT site, value FROM policies;",
+								-1,
+								&statement,
+								NULL);
+	if(statement && success==SQLITE_OK)
+	{
+		gchar		*domain;
+		gint		policy;
+		gchar		*policyName;
+		GtkTreeIter	iter;
+
+		while(sqlite3_step(statement)==SQLITE_ROW)
+		{
+			/* Get values */
+			domain=(gchar*)sqlite3_column_text(statement, 0);
+			policy=sqlite3_column_int(statement, 1);
+
+			switch(policy)
+			{
+				case NOJS_POLICY_ACCEPT:
+					policyName=_("Accept");
+					break;
+
+				case NOJS_POLICY_ACCEPT_TEMPORARILY:
+					policyName=_("Accept for session");
+					break;
+
+				case NOJS_POLICY_BLOCK:
+					policyName=_("Block");
+					break;
+
+				default:
+					policyName=NULL;
+					break;
+			}
+
+			if(policyName)
+			{
+				gtk_list_store_append(priv->listStore, &iter);
+				gtk_list_store_set(priv->listStore,
+									&iter,
+									DOMAIN_COLUMN, domain,
+									POLICY_COLUMN, policyName,
+									-1);
+			}
+		}
+	}
+		else g_warning(_("SQL fails: %s"), sqlite3_errmsg(priv->database));
+
+	sqlite3_finalize(statement);
+}
+
+/* Database instance in manager changed */
+static void _nojs_preferences_on_manager_database_changed(NoJSPreferences *self,
+															GParamSpec *inSpec,
+															gpointer inUserData)
+{
+	NoJSPreferencesPrivate	*priv=self->priv;
+	NoJS					*manager=NOJS(inUserData);
+	gchar					*databaseFile;
+
+	/* Close connection to any open database */
+	if(priv->database) sqlite3_close(priv->database);
+	priv->database=NULL;
+
+	/* Get pointer to new database and open database */
+	g_object_get(manager, "database-filename", &databaseFile, NULL);
+	if(databaseFile)
+	{
+		gint				success;
+
+		success=sqlite3_open(databaseFile, &priv->database);
+		if(success!=SQLITE_OK)
+		{
+			g_warning(_("Could not open database of extension: %s"), sqlite3_errmsg(priv->database));
+
+			if(priv->database) sqlite3_close(priv->database);
+			priv->database=NULL;
+		}
+
+		g_free(databaseFile);
+	}
+
+	/* Fill list with new database */
+	_nojs_preferences_fill(self);
+
+	/* Set up availability of management buttons */
+	gtk_widget_set_sensitive(priv->deleteAllButton, priv->database!=NULL);
+	gtk_widget_set_sensitive(priv->list, priv->database!=NULL);
+
+	return;
+}
+
+/* Allow-all-sites changed in check-box or manager */
+static void _nojs_preferences_on_allow_all_sites_changed(NoJSPreferences *self,
+																gpointer *inUserData)
+{
+	NoJSPreferencesPrivate	*priv=self->priv;
+	gboolean				state;
+
+	/* Get toggle state of widget (but block signal for manager) and set in manager */
+	g_signal_handler_block(priv->manager, priv->signalManagerChangedAllowAllSitesID);
+
+	state=gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(priv->allowAllSitesCheckbox));
+	nojs_set_allow_all_sites(priv->manager, state);
+
+	g_signal_handler_unblock(priv->manager, priv->signalManagerChangedAllowAllSitesID);
+}
+
+static void _nojs_preferences_on_manager_allow_all_sites_changed(NoJSPreferences *self,
+																	GParamSpec *inSpec,
+																	gpointer inUserData)
+{
+	NoJSPreferencesPrivate	*priv=self->priv;
+	NoJS					*manager=NOJS(inUserData);
+	gboolean				state;
+
+	/* Get new value from manager */
+	state=nojs_get_allow_all_sites(manager);
+
+	/* Set toggle in widget (but block signal for toggle) */
+	g_signal_handler_block(priv->allowAllSitesCheckbox, priv->signalAllowAllSitesToggledID);
+
+	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->allowAllSitesCheckbox), state);
+
+	g_signal_handler_unblock(priv->allowAllSitesCheckbox, priv->signalAllowAllSitesToggledID);
+}
+
+/* Block-unknown-domains changed in check-box or manager */
+static void _nojs_preferences_on_block_unknown_domains_changed(NoJSPreferences *self,
+																gpointer *inUserData)
+{
+	NoJSPreferencesPrivate	*priv=self->priv;
+	gboolean				state;
+	NoJSPolicy				policy;
+
+	/* Get toggle state of widget (but block signal for manager) and set in manager */
+	g_signal_handler_block(priv->manager, priv->signalManagerChangedUnknownDomainPolicyID);
+
+	state=gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(priv->blockUnknownDomainsCheckbox));
+	policy=(state ? NOJS_POLICY_BLOCK : NOJS_POLICY_ACCEPT);
+	nojs_set_policy_for_unknown_domain(priv->manager, policy);
+
+	g_signal_handler_unblock(priv->manager, priv->signalManagerChangedUnknownDomainPolicyID);
+}
+
+static void _nojs_preferences_on_manager_unknown_domain_policy_changed(NoJSPreferences *self,
+																		GParamSpec *inSpec,
+																		gpointer inUserData)
+{
+	NoJSPreferencesPrivate	*priv=self->priv;
+	NoJS					*manager=NOJS(inUserData);
+	NoJSPolicy				policy;
+	gboolean				state;
+
+	/* Get new value from manager */
+	policy=nojs_get_policy_for_unknown_domain(manager);
+
+	/* Set toggle in widget (but block signal for toggle) */
+	g_signal_handler_block(priv->blockUnknownDomainsCheckbox, priv->signalBlockUnknownDomainsToggledID);
+
+	state=(policy==NOJS_POLICY_BLOCK ? TRUE : FALSE);
+	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->blockUnknownDomainsCheckbox), state);
+
+	g_signal_handler_unblock(priv->blockUnknownDomainsCheckbox, priv->signalBlockUnknownDomainsToggledID);
+}
+
+/* Only-second-level changed in check-box or manager */
+static void _nojs_preferences_on_check_second_level_only_changed(NoJSPreferences *self,
+																	gpointer *inUserData)
+{
+	NoJSPreferencesPrivate	*priv=self->priv;
+	gboolean				state;
+
+	/* Get toggle state of widget (but block signal for manager) and set in manager */
+	g_signal_handler_block(priv->manager, priv->signalManagerChangedCheckSecondLevelID);
+
+	state=gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(priv->checkSecondLevelOnlyCheckbox));
+	nojs_set_only_second_level_domain(priv->manager, state);
+
+	g_signal_handler_unblock(priv->manager, priv->signalManagerChangedCheckSecondLevelID);
+}
+
+static void _nojs_preferences_on_manager_only_second_level_changed(NoJSPreferences *self,
+																	GParamSpec *inSpec,
+																	gpointer inUserData)
+{
+	NoJSPreferencesPrivate	*priv=self->priv;
+	NoJS					*manager=NOJS(inUserData);
+	gboolean				state;
+
+	/* Get new value from manager */
+	state=nojs_get_only_second_level_domain(manager);
+
+	/* Set toggle in widget (but block signal for toggle) */
+	g_signal_handler_block(priv->checkSecondLevelOnlyCheckbox, priv->signalCheckSecondLevelOnlyToggledID);
+
+	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->checkSecondLevelOnlyCheckbox), state);
+
+	g_signal_handler_unblock(priv->checkSecondLevelOnlyCheckbox, priv->signalCheckSecondLevelOnlyToggledID);
+}
+
+/* Selection in list changed */
+void _nojs_preferences_changed_selection(NoJSPreferences *self,
+											GtkTreeSelection *inSelection)
+{
+	gboolean	selected=(gtk_tree_selection_count_selected_rows(inSelection)>0 ? TRUE: FALSE);
+
+	gtk_widget_set_sensitive(self->priv->deleteButton, selected);
+}
+
+/* Delete button was clicked on selection */
+void _nojs_preferences_on_delete_selection(NoJSPreferences *self,
+											GtkButton *inButton)
+{
+	NoJSPreferencesPrivate	*priv=self->priv;
+	GList					*rows, *row, *refs=NULL;
+	GtkTreeRowReference		*ref;
+	GtkTreeModel			*model=GTK_TREE_MODEL(priv->listStore);
+	GtkTreeIter				iter;
+	GtkTreePath				*path;
+	gchar					*domain;
+	gchar					*sql;
+	gint					success;
+	gchar					*error;
+
+	/* Get selected rows in list and create a row reference because
+	 * we will modify the model while iterating through selected rows
+	 */
+	rows=gtk_tree_selection_get_selected_rows(priv->listSelection, &model);
+	for(row=rows; row; row=row->next)
+	{
+		ref=gtk_tree_row_reference_new(model, (GtkTreePath*)row->data);
+		refs=g_list_prepend(refs, ref);
+	}
+	g_list_foreach(rows,(GFunc)gtk_tree_path_free, NULL);
+	g_list_free(rows);
+
+	/* Delete each selected row by its reference */
+	for(row=refs; row; row=row->next)
+	{
+		/* Get domain from selected row */
+		path=gtk_tree_row_reference_get_path((GtkTreeRowReference*)row->data);
+		gtk_tree_model_get_iter(model, &iter, path);
+		gtk_tree_model_get(model, &iter, DOMAIN_COLUMN, &domain, -1);
+
+		/* Delete domain from database */
+		sql=sqlite3_mprintf("DELETE FROM policies WHERE site='%q';", domain);
+		success=sqlite3_exec(priv->database,
+								sql,
+								NULL,
+								NULL,
+								&error);
+		if(success!=SQLITE_OK || error)
+		{
+			if(error)
+			{
+				g_critical(_("Failed to execute database statement: %s"), error);
+				sqlite3_free(error);
+			}
+				else g_critical(_("Failed to execute database statement: %s"), sqlite3_errmsg(priv->database));
+		}
+		sqlite3_free(sql);
+
+		/* Delete row from model */
+		gtk_list_store_remove(priv->listStore, &iter);
+	}
+	g_list_foreach(refs,(GFunc)gtk_tree_row_reference_free, NULL);
+	g_list_free(refs);
+}
+
+/* Delete all button was clicked */
+void _nojs_preferences_on_delete_all(NoJSPreferences *self,
+										GtkButton *inButton)
+{
+	NoJSPreferencesPrivate	*priv=self->priv;
+	gint					success;
+	gchar					*error=NULL;
+	GtkWidget				*dialog;
+	gint					dialogResponse;
+
+	/* Ask user if he really wants to delete all permissions */
+	dialog=gtk_message_dialog_new(GTK_WINDOW(self),
+									GTK_DIALOG_MODAL,
+									GTK_MESSAGE_QUESTION,
+									GTK_BUTTONS_YES_NO,
+									_("Do you really want to delete all JavaScript permissions?"));
+
+	gtk_window_set_title(GTK_WINDOW(dialog), _("Delete all JavaScript permissions?"));
+	gtk_window_set_icon_name(GTK_WINDOW(dialog), GTK_STOCK_PROPERTIES);
+
+	gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dialog),
+												_("This action will delete all JavaScript permissions. "
+												  "You will be asked for permissions again for each web site visited."));
+
+	dialogResponse=gtk_dialog_run(GTK_DIALOG(dialog));
+	gtk_widget_destroy(dialog);
+
+	if(dialogResponse==GTK_RESPONSE_NO) return;
+
+	/* Delete all permission */
+	success=sqlite3_exec(priv->database,
+							"DELETE FROM policies;",
+							NULL,
+							NULL,
+							&error);
+
+	if(success!=SQLITE_OK || error)
+	{
+		if(error)
+		{
+			g_critical(_("Failed to execute database statement: %s"), error);
+			sqlite3_free(error);
+		}
+	}
+
+	/* Re-setup list */
+	_nojs_preferences_fill(self);
+}
+
+/* Sorting callbacks */
+static gint _nojs_preferences_sort_string_callback(GtkTreeModel *inModel,
+													GtkTreeIter *inLeft,
+													GtkTreeIter *inRight,
+													gpointer inUserData)
+{
+	gchar		*left, *right;
+	gint		column=GPOINTER_TO_INT(inUserData);
+	gint		result;
+
+	gtk_tree_model_get(inModel, inLeft, column, &left, -1);
+	gtk_tree_model_get(inModel, inRight, column, &right, -1);
+
+	result=g_strcmp0(left, right);
+
+	g_free(left);
+	g_free(right);
+
+	return(result);
+}
+
+/* IMPLEMENTATION: GObject */
+
+/* Finalize this object */
+static void nojs_preferences_finalize(GObject *inObject)
+{
+	NoJSPreferencesPrivate	*priv=NOJS_PREFERENCES(inObject)->priv;
+
+	/* Dispose allocated resources */
+	if(priv->database) sqlite3_close(priv->database);
+	priv->database=NULL;
+
+	if(priv->manager)
+	{
+		if(priv->signalManagerChangedDatabaseID) g_signal_handler_disconnect(priv->manager, priv->signalManagerChangedDatabaseID);
+		priv->signalManagerChangedDatabaseID=0;
+
+		if(priv->signalManagerChangedAllowAllSitesID) g_signal_handler_disconnect(priv->manager, priv->signalManagerChangedAllowAllSitesID);
+		priv->signalManagerChangedAllowAllSitesID=0;
+
+		if(priv->signalManagerChangedUnknownDomainPolicyID) g_signal_handler_disconnect(priv->manager, priv->signalManagerChangedUnknownDomainPolicyID);
+		priv->signalManagerChangedUnknownDomainPolicyID=0;
+
+		if(priv->signalManagerChangedCheckSecondLevelID) g_signal_handler_disconnect(priv->manager, priv->signalManagerChangedCheckSecondLevelID);
+		priv->signalManagerChangedCheckSecondLevelID=0;
+
+		g_object_unref(priv->manager);
+		priv->manager=NULL;
+	}
+
+	/* Call parent's class finalize method */
+	G_OBJECT_CLASS(nojs_preferences_parent_class)->finalize(inObject);
+}
+
+/* Set/get properties */
+static void nojs_preferences_set_property(GObject *inObject,
+											guint inPropID,
+											const GValue *inValue,
+											GParamSpec *inSpec)
+{
+	NoJSPreferences			*self=NOJS_PREFERENCES(inObject);
+	NoJSPreferencesPrivate	*priv=self->priv;
+	GObject					*manager;
+
+	switch(inPropID)
+	{
+		/* Construct-only properties */
+		case PROP_MANAGER:
+			/* Release old manager if available and disconnect signals */
+			if(priv->manager)
+			{
+				if(priv->signalManagerChangedDatabaseID) g_signal_handler_disconnect(priv->manager, priv->signalManagerChangedDatabaseID);
+				priv->signalManagerChangedDatabaseID=0;
+
+				if(priv->signalManagerChangedAllowAllSitesID) g_signal_handler_disconnect(priv->manager, priv->signalManagerChangedAllowAllSitesID);
+				priv->signalManagerChangedAllowAllSitesID=0;
+
+				if(priv->signalManagerChangedUnknownDomainPolicyID) g_signal_handler_disconnect(priv->manager, priv->signalManagerChangedUnknownDomainPolicyID);
+				priv->signalManagerChangedUnknownDomainPolicyID=0;
+
+				if(priv->signalManagerChangedCheckSecondLevelID) g_signal_handler_disconnect(priv->manager, priv->signalManagerChangedCheckSecondLevelID);
+				priv->signalManagerChangedCheckSecondLevelID=0;
+
+				g_object_unref(priv->manager);
+				priv->manager=NULL;
+			}
+
+			/* Set new JavaScript permission manager and
+			 * listen to changes in database property
+			 */
+			manager=g_value_get_object(inValue);
+			if(manager)
+			{
+				priv->manager=g_object_ref(manager);
+
+				priv->signalManagerChangedDatabaseID=
+					g_signal_connect_swapped(priv->manager,
+												"notify::database-filename",
+												G_CALLBACK(_nojs_preferences_on_manager_database_changed),
+												self);
+				_nojs_preferences_on_manager_database_changed(self, NULL, priv->manager);
+
+				priv->signalManagerChangedAllowAllSitesID=
+					g_signal_connect_swapped(priv->manager,
+												"notify::allow-all-sites",
+												G_CALLBACK(_nojs_preferences_on_manager_allow_all_sites_changed),
+												self);
+				_nojs_preferences_on_manager_allow_all_sites_changed(self, NULL, priv->manager);
+
+				priv->signalManagerChangedUnknownDomainPolicyID=
+					g_signal_connect_swapped(priv->manager,
+												"notify::unknown-domain-policy",
+												G_CALLBACK(_nojs_preferences_on_manager_unknown_domain_policy_changed),
+												self);
+				_nojs_preferences_on_manager_unknown_domain_policy_changed(self, NULL, priv->manager);
+
+				priv->signalManagerChangedCheckSecondLevelID=
+					g_signal_connect_swapped(priv->manager,
+												"notify::only-second-level",
+												G_CALLBACK(_nojs_preferences_on_manager_only_second_level_changed),
+												self);
+				_nojs_preferences_on_manager_only_second_level_changed(self, NULL, priv->manager);
+			}
+			break;
+
+		default:
+			G_OBJECT_WARN_INVALID_PROPERTY_ID(inObject, inPropID, inSpec);
+			break;
+	}
+}
+
+static void nojs_preferences_get_property(GObject *inObject,
+											guint inPropID,
+											GValue *outValue,
+											GParamSpec *inSpec)
+{
+	NoJSPreferences	*self=NOJS_PREFERENCES(inObject);
+
+	switch(inPropID)
+	{
+		case PROP_MANAGER:
+			g_value_set_object(outValue, self->priv->manager);
+			break;
+
+		default:
+			G_OBJECT_WARN_INVALID_PROPERTY_ID(inObject, inPropID, inSpec);
+			break;
+	}
+}
+
+/* Class initialization
+ * Override functions in parent classes and define properties and signals
+ */
+static void nojs_preferences_class_init(NoJSPreferencesClass *klass)
+{
+	GObjectClass		*gobjectClass=G_OBJECT_CLASS(klass);
+
+	/* Override functions */
+	gobjectClass->finalize=nojs_preferences_finalize;
+	gobjectClass->set_property=nojs_preferences_set_property;
+	gobjectClass->get_property=nojs_preferences_get_property;
+
+	/* Set up private structure */
+	g_type_class_add_private(klass, sizeof(NoJSPreferencesPrivate));
+
+	/* Define properties */
+	NoJSPreferencesProperties[PROP_MANAGER]=
+		g_param_spec_object("manager",
+								_("Manager instance"),
+								_("Instance to global NoJS manager"),
+								TYPE_NOJS,
+								G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
+
+	g_object_class_install_properties(gobjectClass, PROP_LAST, NoJSPreferencesProperties);
+}
+
+/* Object initialization
+ * Create private structure and set up default values
+ */
+static void nojs_preferences_init(NoJSPreferences *self)
+{
+	NoJSPreferencesPrivate		*priv;
+	GtkTreeSortable				*sortableList;
+	GtkCellRenderer				*renderer;
+	GtkTreeViewColumn			*column;
+	GtkWidget					*widget;
+	gchar						*dialogTitle;
+	GtkWidget					*scrolled;
+	GtkWidget					*vbox;
+	GtkWidget					*hbox;
+	gint						width, height;
+
+	priv=self->priv=NOJS_PREFERENCES_GET_PRIVATE(self);
+
+	/* Set up default values */
+	priv->manager=NULL;
+
+	/* Get content area to add gui controls to */
+	priv->contentArea=gtk_dialog_get_content_area(GTK_DIALOG(self));
+#if GTK_CHECK_VERSION (3, 0, 0)
+	vbox=gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
+	gtk_box_set_homogeneous(GTK_BOX(vbox), FALSE);
+#else
+	vbox=gtk_vbox_new(FALSE, 0);
+#endif
+
+	/* Set up dialog */
+	dialogTitle=_("Configure NoJS");
+
+	gtk_window_set_title(GTK_WINDOW(self), dialogTitle);
+	gtk_window_set_icon_name(GTK_WINDOW(self), GTK_STOCK_PROPERTIES);
+
+	sokoke_widget_get_text_size(GTK_WIDGET(self), "M", &width, &height);
+	gtk_window_set_default_size(GTK_WINDOW(self), width*52, -1);
+
+	widget=sokoke_xfce_header_new(gtk_window_get_icon_name(GTK_WINDOW(self)), dialogTitle);
+	if(widget) gtk_box_pack_start(GTK_BOX(priv->contentArea), widget, FALSE, FALSE, 0);
+
+	gtk_dialog_add_button(GTK_DIALOG(self), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE);
+
+	/* Set up description */
+	widget=gtk_label_new(NULL);
+	gtk_label_set_markup(GTK_LABEL(widget),
+            _("Below is a list of all web sites and the policy set for them. "
+							"You can delete policies by marking the entries and clicking on <i>Delete</i>."));
+	gtk_label_set_line_wrap(GTK_LABEL(widget), TRUE);
+	gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, FALSE, 4);
+
+	/* Set up domain list */
+	priv->listStore=gtk_list_store_new(N_COLUMN,
+										G_TYPE_STRING,	/* DOMAIN_COLUMN */
+										G_TYPE_STRING	/* POLICY_COLUMN */);
+
+	sortableList=GTK_TREE_SORTABLE(priv->listStore);
+	gtk_tree_sortable_set_sort_func(sortableList,
+										DOMAIN_COLUMN,
+										(GtkTreeIterCompareFunc)_nojs_preferences_sort_string_callback,
+										GINT_TO_POINTER(DOMAIN_COLUMN),
+										NULL);
+	gtk_tree_sortable_set_sort_func(sortableList,
+										POLICY_COLUMN,
+										(GtkTreeIterCompareFunc)_nojs_preferences_sort_string_callback,
+										GINT_TO_POINTER(POLICY_COLUMN),
+										NULL);
+	gtk_tree_sortable_set_sort_column_id(sortableList, DOMAIN_COLUMN, GTK_SORT_ASCENDING);
+
+	/* Set up domain list view */
+	priv->list=gtk_tree_view_new_with_model(GTK_TREE_MODEL(priv->listStore));
+
+#if !GTK_CHECK_VERSION (3, 0, 0)
+	gtk_widget_set_size_request(priv->list, -1, 300);
+#endif
+
+	priv->listSelection=gtk_tree_view_get_selection(GTK_TREE_VIEW(priv->list));
+	gtk_tree_selection_set_mode(priv->listSelection, GTK_SELECTION_MULTIPLE);
+	g_signal_connect_swapped(priv->listSelection, "changed", G_CALLBACK(_nojs_preferences_changed_selection), self);
+
+	renderer=gtk_cell_renderer_text_new();
+	column=gtk_tree_view_column_new_with_attributes(_("Domain"),
+													renderer,
+													"text", DOMAIN_COLUMN,
+													NULL);
+	gtk_tree_view_column_set_sort_column_id(column, DOMAIN_COLUMN);
+	gtk_tree_view_append_column(GTK_TREE_VIEW(priv->list), column);
+
+	renderer=gtk_cell_renderer_text_new();
+	column=gtk_tree_view_column_new_with_attributes(_("Policy"),
+													renderer,
+													"text", POLICY_COLUMN,
+													NULL);
+	gtk_tree_view_column_set_sort_column_id(column, POLICY_COLUMN);
+	gtk_tree_view_append_column(GTK_TREE_VIEW(priv->list), column);
+
+	scrolled=gtk_scrolled_window_new(NULL, NULL);
+#if GTK_CHECK_VERSION (3, 0, 0)
+	gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(scrolled), height*10);
+#endif
+	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
+	gtk_container_add(GTK_CONTAINER(scrolled), priv->list);
+	gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
+	gtk_box_pack_start(GTK_BOX(vbox), scrolled, TRUE, TRUE, 5);
+
+	/* Set up JavaScript domain list management buttons */
+#if GTK_CHECK_VERSION (3, 0, 0)
+	hbox=gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
+	gtk_box_set_homogeneous(GTK_BOX(hbox), FALSE);
+#else
+	hbox=gtk_hbox_new(FALSE, 0);
+#endif
+
+	priv->deleteButton=gtk_button_new_from_stock(GTK_STOCK_DELETE);
+	gtk_widget_set_sensitive(priv->deleteButton, FALSE);
+	gtk_container_add(GTK_CONTAINER(hbox), priv->deleteButton);
+	g_signal_connect_swapped(priv->deleteButton, "clicked", G_CALLBACK(_nojs_preferences_on_delete_selection), self);
+
+	priv->deleteAllButton=gtk_button_new_with_mnemonic(_("Delete _all"));
+	gtk_button_set_image(GTK_BUTTON(priv->deleteAllButton), gtk_image_new_from_stock(GTK_STOCK_DELETE, GTK_ICON_SIZE_BUTTON));
+	gtk_widget_set_sensitive(priv->deleteAllButton, FALSE);
+	gtk_container_add(GTK_CONTAINER(hbox), priv->deleteAllButton);
+	g_signal_connect_swapped(priv->deleteAllButton, "clicked", G_CALLBACK(_nojs_preferences_on_delete_all), self);
+
+	gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 5);
+
+	/* Add "allow-all-sites" checkbox */
+	priv->allowAllSitesCheckbox=gtk_check_button_new_with_mnemonic(_("A_llow scripts at all sites"));
+	priv->signalAllowAllSitesToggledID=g_signal_connect_swapped(priv->allowAllSitesCheckbox,
+																"toggled",
+																G_CALLBACK(_nojs_preferences_on_allow_all_sites_changed),
+																self);
+	gtk_box_pack_start(GTK_BOX(vbox), priv->allowAllSitesCheckbox, TRUE, TRUE, 5);
+
+	/* Add "block-unknown-domains" checkbox */
+	priv->blockUnknownDomainsCheckbox=gtk_check_button_new_with_mnemonic(_("Bloc_k scripts at unknown domains by default"));
+	priv->signalBlockUnknownDomainsToggledID=g_signal_connect_swapped(priv->blockUnknownDomainsCheckbox,
+																		"toggled",
+																		G_CALLBACK(_nojs_preferences_on_block_unknown_domains_changed),
+																		self);
+	gtk_box_pack_start(GTK_BOX(vbox), priv->blockUnknownDomainsCheckbox, TRUE, TRUE, 5);
+
+	/* Add "check-second-level-only" checkbox */
+	priv->checkSecondLevelOnlyCheckbox=gtk_check_button_new_with_mnemonic(_("S_et permissions on second-level domain"));
+	priv->signalCheckSecondLevelOnlyToggledID=g_signal_connect_swapped(priv->checkSecondLevelOnlyCheckbox,
+																		"toggled",
+																		G_CALLBACK(_nojs_preferences_on_check_second_level_only_changed),
+																		self);
+	gtk_box_pack_start(GTK_BOX(vbox), priv->checkSecondLevelOnlyCheckbox, TRUE, TRUE, 5);
+
+	/* Finalize setup of content area */
+	gtk_container_add(GTK_CONTAINER(priv->contentArea), vbox);
+}
+
+/* Implementation: Public API */
+
+/* Create new object */
+GtkWidget* nojs_preferences_new(NoJS *inManager)
+{
+	return(g_object_new(TYPE_NOJS_PREFERENCES,
+							"manager", inManager,
+							NULL));
+}
 
=== added file 'extensions/nojs/nojs-preferences.h'
--- extensions/nojs/nojs-preferences.h	1970-01-01 00:00:00 +0000
+++ extensions/nojs/nojs-preferences.h	2013-07-29 19:51:25 +0000
@@ -0,0 +1,55 @@
+/*
+ Copyright (C) 2013 Stephan Haller <[e-mail]>
+
+ 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.
+*/
+
+#ifndef __NOJS_PREFERENCES__
+#define __NOJS_PREFERENCES__
+
+#include "config.h"
+#include <midori/midori.h>
+
+#include "nojs.h"
+
+G_BEGIN_DECLS
+
+#define TYPE_NOJS_PREFERENCES				(nojs_preferences_get_type())
+#define NOJS_PREFERENCES(obj)				(G_TYPE_CHECK_INSTANCE_CAST((obj), TYPE_NOJS_PREFERENCES, NoJSPreferences))
+#define IS_NOJS_PREFERENCES(obj)			(G_TYPE_CHECK_INSTANCE_TYPE((obj), TYPE_NOJS_PREFERENCES))
+#define NOJS_PREFERENCES_CLASS(klass)		(G_TYPE_CHECK_CLASS_CAST((klass), TYPE_NOJS_PREFERENCES, NoJSPreferencesClass))
+#define IS_NOJS_PREFERENCES_CLASS(klass)	(G_TYPE_CHECK_CLASS_TYPE((klass), TYPE_NOJS_PREFERENCES))
+#define NOJS_PREFERENCES_GET_CLASS(obj)		(G_TYPE_INSTANCE_GET_CLASS((obj), TYPE_NOJS_PREFERENCES, NoJSPreferencesClass))
+
+typedef struct _NoJSPreferences				NoJSPreferences;
+typedef struct _NoJSPreferencesClass		NoJSPreferencesClass;
+typedef struct _NoJSPreferencesPrivate		NoJSPreferencesPrivate;
+
+struct _NoJSPreferences
+{
+	/* Parent instance */
+	GtkDialog				parent_instance;
+
+	/* Private structure */
+	NoJSPreferencesPrivate	*priv;
+};
+
+struct _NoJSPreferencesClass
+{
+	/* Parent class */
+	GtkDialogClass			parent_class;
+};
+
+/* Public API */
+GType nojs_preferences_get_type(void);
+
+GtkWidget* nojs_preferences_new(NoJS *inManager);
+
+G_END_DECLS
+
+#endif /* __NOJS_PREFERENCES__ */
 
=== added file 'extensions/nojs/nojs-view.c'
--- extensions/nojs/nojs-view.c	1970-01-01 00:00:00 +0000
+++ extensions/nojs/nojs-view.c	2013-07-29 19:51:25 +0000
@@ -0,0 +1,804 @@
+/*
+ Copyright (C) 2013 Stephan Haller <[e-mail]>
+
+ 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.
+*/
+
+#include "nojs-view.h"
+#include "nojs-preferences.h"
+
+/* Define this class in GObject system */
+G_DEFINE_TYPE(NoJSView,
+				nojs_view,
+				G_TYPE_OBJECT)
+
+/* Properties */
+enum
+{
+	PROP_0,
+
+	PROP_MANAGER,
+	PROP_BROWSER,
+	PROP_VIEW,
+	PROP_MENU_ICON_STATE,
+
+	PROP_LAST
+};
+
+static GParamSpec* NoJSViewProperties[PROP_LAST]={ 0, };
+
+/* Private structure - access only by public API if needed */
+#define NOJS_VIEW_GET_PRIVATE(obj) \
+	(G_TYPE_INSTANCE_GET_PRIVATE((obj), TYPE_NOJS_VIEW, NoJSViewPrivate))
+
+struct _NoJSViewPrivate
+{
+	/* Extension related */
+	NoJS				*manager;
+	MidoriBrowser		*browser;
+	MidoriView			*view;
+
+	GtkWidget			*menu;
+	gboolean			menuPolicyWasChanged;
+	NoJSMenuIconState	menuIconState;
+
+	GSList				*resourceURIs;
+};
+
+/* IMPLEMENTATION: Private variables and methods */
+
+/* Preferences of this extension should be opened */
+static void _nojs_view_on_preferences_response(GtkWidget* inDialog,
+												gint inResponse,
+												gpointer *inUserData)
+{
+	gtk_widget_destroy(inDialog);
+}
+
+static void _nojs_view_on_open_preferences(NoJSView *self, gpointer inUserData)
+{
+	g_return_if_fail(NOJS_IS_VIEW(self));
+
+	NoJSViewPrivate		*priv=self->priv;
+
+	/* Show preferences window */
+	GtkWidget* dialog;
+
+	dialog=nojs_preferences_new(priv->manager);
+	gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
+	g_signal_connect(dialog, "response", G_CALLBACK (_nojs_view_on_preferences_response), self);
+	gtk_widget_show_all(dialog);
+}
+
+/* Selection was done in menu */
+static void _nojs_view_on_menu_selection_done(NoJSView *self, gpointer inUserData)
+{
+	g_return_if_fail(NOJS_IS_VIEW(self));
+
+	NoJSViewPrivate		*priv=self->priv;
+
+	/* Check if any policy was changed and reload page */
+	if(priv->menuPolicyWasChanged!=FALSE)
+	{
+		/* Reset flag that any policy was changed */
+		priv->menuPolicyWasChanged=FALSE;
+
+		/* Reload page */
+		midori_view_reload(priv->view, FALSE);
+g_message("%s: Reloading page %s as policy has changed", __func__, midori_view_get_display_uri(priv->view));
+	}
+}
+
+/* Destroy menu */
+static void _nojs_view_destroy_menu(NoJSView *self)
+{
+	g_return_if_fail(NOJS_IS_VIEW(self));
+	g_return_if_fail(self->priv->menu!=NULL);
+
+	NoJSViewPrivate		*priv=self->priv;
+
+	/* Empty menu and list of domains added to menu */
+	gtk_widget_destroy(priv->menu);
+	priv->menu=NULL;
+
+	/* Reset menu icon to default state */
+	priv->menuIconState=NOJS_MENU_ICON_STATE_UNDETERMINED;
+	g_object_notify_by_pspec(G_OBJECT(self), NoJSViewProperties[PROP_MENU_ICON_STATE]);
+}
+
+/* Create empty menu */
+static void _nojs_view_create_empty_menu(NoJSView *self)
+{
+	g_return_if_fail(NOJS_IS_VIEW(self));
+	g_return_if_fail(self->priv->menu==NULL);
+
+	NoJSViewPrivate		*priv=self->priv;
+	GtkWidget			*item;
+
+	/* Create new menu and set up default items */
+	priv->menu=gtk_menu_new();
+
+	item=gtk_image_menu_item_new_from_stock(GTK_STOCK_PREFERENCES, NULL);
+	g_signal_connect_swapped(item, "activate", G_CALLBACK(_nojs_view_on_open_preferences), self);
+	gtk_menu_shell_prepend(GTK_MENU_SHELL(priv->menu), item);
+	gtk_widget_show_all(item);
+
+	/* Reset flag that any policy was changed */
+	priv->menuPolicyWasChanged=FALSE;
+
+	/* Reset menu icon to default state */
+	priv->menuIconState=NOJS_MENU_ICON_STATE_UNDETERMINED;
+	g_object_notify_by_pspec(G_OBJECT(self), NoJSViewProperties[PROP_MENU_ICON_STATE]);
+
+	/* Connect signal to menu */
+	g_signal_connect_swapped(priv->menu, "selection-done", G_CALLBACK(_nojs_view_on_menu_selection_done), self);
+}
+
+/* Change visibility state of menu item for a domain depending on policy */
+static gboolean _nojs_view_menu_item_change_policy(NoJSView *self, const gchar *inDomain, NoJSPolicy inPolicy)
+{
+	g_return_val_if_fail(NOJS_IS_VIEW(self), FALSE);
+	g_return_val_if_fail(inDomain, FALSE);
+
+	NoJSViewPrivate		*priv=self->priv;
+	GList				*items, *iter;
+	gboolean			updated;
+
+	/* Handle accept-for-session like accept when showing or hiding menu items */
+	if(inPolicy==NOJS_POLICY_ACCEPT_TEMPORARILY) inPolicy=NOJS_POLICY_ACCEPT;
+
+	/* Update menu items */
+	updated=FALSE;
+	items=gtk_container_get_children(GTK_CONTAINER(priv->menu));
+	for(iter=items; iter; iter=iter->next)
+	{
+		/* Only check and update menu items (not separators and so on) */
+		if(GTK_IS_MENU_ITEM(iter->data))
+		{
+			GtkMenuItem		*item=GTK_MENU_ITEM(iter->data);
+			const gchar		*itemDomain;
+			NoJSPolicy		itemPolicy;
+
+			itemDomain=(const gchar*)g_object_get_data(G_OBJECT(item), "domain");
+			itemPolicy=GPOINTER_TO_INT(g_object_get_data(G_OBJECT(item), "policy"));
+
+			/* Handle accept-for-session like accept when showing or hiding menu items */
+			if(itemPolicy==NOJS_POLICY_ACCEPT_TEMPORARILY) itemPolicy=NOJS_POLICY_ACCEPT;
+
+			/* If menu item has "domain"-data update its visibility state
+			 * depending on matching policy
+			 */
+			if(g_strcmp0(itemDomain, inDomain)==0)
+			{
+				if(itemPolicy==inPolicy) gtk_widget_hide(GTK_WIDGET(item));
+					else gtk_widget_show_all(GTK_WIDGET(item));
+
+				/* Set flag that at least one menu item was updated */
+				updated=TRUE;
+			}
+		}
+	}
+	g_list_free(items);
+
+	/* Return flag indicating if at least one menu item was updated */
+	return(updated);
+}
+
+/* A menu item was selected */
+static void _nojs_view_on_menu_item_activate(NoJSView *self, gpointer inUserData)
+{
+	g_return_if_fail(NOJS_IS_VIEW(self));
+	g_return_if_fail(GTK_IS_MENU_ITEM(inUserData));
+
+	NoJSViewPrivate			*priv=self->priv;
+	GtkMenuItem				*item=GTK_MENU_ITEM(inUserData);
+	const gchar				*domain;
+	NoJSPolicy				policy;
+
+	/* Get domain and policy to set */
+	domain=(const gchar*)g_object_get_data(G_OBJECT(item), "domain");
+	policy=GPOINTER_TO_INT(g_object_get_data(G_OBJECT(item), "policy"));
+	g_return_if_fail(domain);
+	g_return_if_fail(policy>=NOJS_POLICY_ACCEPT && policy<=NOJS_POLICY_BLOCK);
+
+	/* Set policy for domain and update menu items */
+	_nojs_view_menu_item_change_policy(self, domain, policy);
+	nojs_set_policy(priv->manager, domain, policy);
+
+	/* Set flag that a policy was changed */
+	priv->menuPolicyWasChanged=TRUE;
+}
+
+/* Add site to menu */
+static void _nojs_view_add_site_to_menu(NoJSView *self, const gchar *inDomain, NoJSPolicy inPolicy)
+{
+	g_return_if_fail(NOJS_IS_VIEW(self));
+	g_return_if_fail(inDomain);
+
+	NoJSViewPrivate		*priv=self->priv;
+	GtkWidget			*item;
+	gchar				*itemLabel;
+	GtkWidget			*itemImage;
+	static gint			INSERT_POSITION=1;
+	NoJSMenuIconState	newMenuIconState;
+
+	/* Create menu object if not available */
+	if(!priv->menu) _nojs_view_create_empty_menu(self);
+
+	/* Check if domain was already added to menu. If it exists just update it. */
+	if(_nojs_view_menu_item_change_policy(self, inDomain, inPolicy)==TRUE) return;
+
+	/* Add menu item(s) for domain */
+	itemLabel=g_strdup_printf(_("Deny %s"), inDomain);
+	item=gtk_image_menu_item_new_with_label(itemLabel);
+	itemImage=gtk_image_new_from_stock (GTK_STOCK_NO, GTK_ICON_SIZE_MENU);
+	gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), itemImage);
+	gtk_image_menu_item_set_always_show_image(GTK_IMAGE_MENU_ITEM(item), TRUE);
+	gtk_menu_shell_insert(GTK_MENU_SHELL(priv->menu), item, INSERT_POSITION);
+	if(inPolicy!=NOJS_POLICY_BLOCK) gtk_widget_show_all(item);
+	g_object_set_data_full(G_OBJECT(item), "domain", g_strdup(inDomain), (GDestroyNotify)g_free);
+	g_object_set_data(G_OBJECT(item), "policy", GINT_TO_POINTER(NOJS_POLICY_BLOCK));
+	g_signal_connect_swapped(item, "activate", G_CALLBACK(_nojs_view_on_menu_item_activate), self);
+	g_free(itemLabel);
+
+	itemLabel=g_strdup_printf(_("Allow %s"), inDomain);
+	item=gtk_image_menu_item_new_with_label(itemLabel);
+	itemImage=gtk_image_new_from_stock (GTK_STOCK_YES, GTK_ICON_SIZE_MENU);
+	gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), itemImage);
+	gtk_image_menu_item_set_always_show_image(GTK_IMAGE_MENU_ITEM(item), TRUE);
+	gtk_menu_shell_insert(GTK_MENU_SHELL(priv->menu), item, INSERT_POSITION);
+	if(inPolicy!=NOJS_POLICY_ACCEPT && inPolicy!=NOJS_POLICY_ACCEPT_TEMPORARILY) gtk_widget_show_all(item);
+	g_object_set_data_full(G_OBJECT(item), "domain", g_strdup(inDomain), (GDestroyNotify)g_free);
+	g_object_set_data(G_OBJECT(item), "policy", GINT_TO_POINTER(NOJS_POLICY_ACCEPT));
+	g_signal_connect_swapped(item, "activate", G_CALLBACK(_nojs_view_on_menu_item_activate), self);
+	g_free(itemLabel);
+
+	itemLabel=g_strdup_printf(_("Allow %s this session"), inDomain);
+	item=gtk_image_menu_item_new_with_label(itemLabel);
+	itemImage=gtk_image_new_from_stock (GTK_STOCK_OK, GTK_ICON_SIZE_MENU);
+	gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), itemImage);
+	gtk_image_menu_item_set_always_show_image(GTK_IMAGE_MENU_ITEM(item), TRUE);
+	gtk_menu_shell_insert(GTK_MENU_SHELL(priv->menu), item, INSERT_POSITION);
+	if(inPolicy!=NOJS_POLICY_ACCEPT && inPolicy!=NOJS_POLICY_ACCEPT_TEMPORARILY) gtk_widget_show_all(item);
+	g_object_set_data_full(G_OBJECT(item), "domain", g_strdup(inDomain), (GDestroyNotify)g_free);
+	g_object_set_data(G_OBJECT(item), "policy", GINT_TO_POINTER(NOJS_POLICY_ACCEPT_TEMPORARILY));
+	g_signal_connect_swapped(item, "activate", G_CALLBACK(_nojs_view_on_menu_item_activate), self);
+	g_free(itemLabel);
+
+	/* Add seperator to seperate actions for this domain from the other domains */
+	item=gtk_separator_menu_item_new();
+	gtk_menu_shell_insert(GTK_MENU_SHELL(priv->menu), item, INSERT_POSITION);
+	gtk_widget_show_all(item);
+
+	/* Determine state of status icon */
+	if(priv->menuIconState!=NOJS_MENU_ICON_STATE_MIXED)
+	{
+		switch(inPolicy)
+		{
+			case NOJS_POLICY_ACCEPT:
+			case NOJS_POLICY_ACCEPT_TEMPORARILY:
+				newMenuIconState=NOJS_MENU_ICON_STATE_ALLOWED;
+				break;
+
+			case NOJS_POLICY_BLOCK:
+				newMenuIconState=NOJS_MENU_ICON_STATE_DENIED;
+				break;
+
+			default:
+				newMenuIconState=NOJS_MENU_ICON_STATE_MIXED;
+				break;
+		}
+
+		if(priv->menuIconState==NOJS_MENU_ICON_STATE_UNDETERMINED ||
+			priv->menuIconState!=newMenuIconState)
+		{
+			priv->menuIconState=newMenuIconState;
+			g_object_notify_by_pspec(G_OBJECT(self), NoJSViewProperties[PROP_MENU_ICON_STATE]);
+		}
+	}
+}
+
+/* Status of loading a site has changed */
+static void _nojs_view_on_load_status_changed(NoJSView *self, GParamSpec *inSpec, gpointer inUserData)
+{
+	g_return_if_fail(NOJS_IS_VIEW(self));
+	g_return_if_fail(WEBKIT_IS_WEB_VIEW(inUserData));
+
+	NoJSViewPrivate			*priv=self->priv;
+	WebKitWebView			*webkitView=WEBKIT_WEB_VIEW(inUserData);
+	WebKitWebSettings		*settings=webkit_web_view_get_settings(webkitView);
+	WebKitLoadStatus		status;
+	SoupURI					*uri;
+
+	/* Get URI of document loading/loaded */
+	uri=soup_uri_new(webkit_web_view_get_uri(webkitView));
+
+	/* Check load status */ 
+	status=webkit_web_view_get_load_status(webkitView);
+
+	/* Check if a view was emptied, e.g. for a new document going to be loaded soon */
+	if(status==WEBKIT_LOAD_PROVISIONAL)
+	{
+		/* Create a new empty menu */
+		_nojs_view_destroy_menu(self);
+		_nojs_view_create_empty_menu(self);
+
+		/* Free list of resource URIs, that's the list of URIs for all resources
+		 * of a page
+		 */
+		if(priv->resourceURIs)
+		{
+			g_slist_free_full(priv->resourceURIs, (GDestroyNotify)g_free);
+			priv->resourceURIs=NULL;
+		}
+	}
+
+	/* Check if document loading is going to start. Do not check special pages. */
+	if(status==WEBKIT_LOAD_COMMITTED &&
+		uri &&
+		uri->scheme &&
+		g_strcmp0(uri->scheme, "about")!=0)
+	{
+		/* Check if domain is black-listed or white-listed and enable or
+		 * disable javascript accordingly. But if settings match already
+		 * the state it should get do not set it again to avoid reloads of page.
+		 */
+		gchar				*domain;
+		NoJSPolicy			policy;
+		gboolean			currentScriptsEnabled;
+		gboolean			newScriptsEnabled;
+
+		domain=nojs_get_domain(priv->manager, uri);
+		policy=nojs_get_policy(priv->manager, domain);
+		if(policy==NOJS_POLICY_UNDETERMINED)
+		{
+			policy=nojs_get_policy_for_unknown_domain(priv->manager);
+			// TODO: Show nick_name of policy (enum) to use in warning
+			g_warning("Got invalid policy. Using default policy for unknown domains.");
+		}
+
+		newScriptsEnabled=(policy==NOJS_POLICY_BLOCK ? FALSE : TRUE);
+		g_object_get(G_OBJECT(settings), "enable-scripts", &currentScriptsEnabled, NULL);
+
+		if(newScriptsEnabled!=currentScriptsEnabled)
+		{
+			g_object_set(G_OBJECT(settings), "enable-scripts", newScriptsEnabled, NULL);
+			// TODO: Set uri also to ensure this uri is going to be reloaded
+		}
+
+		_nojs_view_add_site_to_menu(self, domain, policy);
+		if(domain) g_free(domain);
+	}
+
+	/* Free allocated resources */
+	if(uri) soup_uri_free(uri);
+}
+
+/* A request is going to sent */
+static void _nojs_view_on_resource_request_starting(NoJSView *self,
+														WebKitWebFrame *inFrame,
+														WebKitWebResource *inResource,
+														WebKitNetworkRequest *inRequest,
+														WebKitNetworkResponse *inResponse,
+														gpointer inUserData)
+{
+	g_return_if_fail(NOJS_IS_VIEW(self));
+
+	NoJSViewPrivate			*priv=self->priv;
+	SoupMessage				*message;
+	SoupURI					*uri;
+	gchar					*uriText;
+
+	/* Remember resource URIs requesting */
+	message=(inRequest ? webkit_network_request_get_message(inRequest) : NULL);
+	if(message)
+	{
+		uri=soup_message_get_uri(message);
+		if(uri)
+		{
+			uriText=soup_uri_to_string(uri, FALSE);
+			priv->resourceURIs=g_slist_prepend(priv->resourceURIs, uriText);
+		}
+	}
+
+	message=(inResponse ? webkit_network_response_get_message(inResponse) : NULL);
+	if(message)
+	{
+		uri=soup_message_get_uri(message);
+		if(uri)
+		{
+			uriText=soup_uri_to_string(uri, FALSE);
+			priv->resourceURIs=g_slist_prepend(priv->resourceURIs, uriText);
+		}
+	}
+}
+
+/* A policy has changed */
+static void _nojs_view_on_policy_changed(NoJSView *self, gchar *inDomain, gpointer inUserData)
+{
+	g_return_if_fail(NOJS_IS_VIEW(self));
+	g_return_if_fail(inDomain);
+
+	NoJSViewPrivate		*priv=self->priv;
+	GList				*items, *iter;
+	gboolean			reloaded;
+
+	/* Check if the policy of a domain has changed this view has referenced resources to */
+	reloaded=FALSE;
+	items=gtk_container_get_children(GTK_CONTAINER(priv->menu));
+	for(iter=items; reloaded==FALSE && iter; iter=iter->next)
+	{
+		if(GTK_IS_MENU_ITEM(iter->data))
+		{
+			const gchar		*itemDomain;
+
+			/* Check if domain matches menu item */
+			itemDomain=(const gchar*)g_object_get_data(G_OBJECT(iter->data), "domain");
+			if(g_strcmp0(itemDomain, inDomain)==0)
+			{
+				/* Found domain in our menu so reload page */
+				midori_view_reload(priv->view, FALSE);
+				reloaded=TRUE;
+			}
+		}
+	}
+	g_list_free(items);
+}
+
+/* A javascript URI is going to loaded or blocked */
+static void _nojs_view_on_uri_load_policy_status(NoJSView *self, gchar *inURI, NoJSPolicy inPolicy, gpointer inUserData)
+{
+	g_return_if_fail(NOJS_IS_VIEW(self));
+
+	NoJSViewPrivate		*priv=self->priv;
+	GSList				*iter;
+	gchar				*checkURI;
+
+	/* Check if uri (accepted or blocked) might be one of ours */
+	for(iter=priv->resourceURIs; iter; iter=iter->next)
+	{
+		checkURI=(gchar*)iter->data;
+		if(g_strcmp0(checkURI, inURI)==0)
+		{
+			SoupURI		*uri;
+			gchar		*domain;
+
+			uri=soup_uri_new(inURI);
+			domain=nojs_get_domain(priv->manager, uri);
+			if(domain)
+			{
+				_nojs_view_add_site_to_menu(self, domain, inPolicy);
+				g_free(domain);
+			}
+
+			soup_uri_free(uri);
+			break;
+		}
+	}
+}
+
+/* Property "view" has changed */
+static void _nojs_view_on_view_changed(NoJSView *self, MidoriView *inView)
+{
+	NoJSViewPrivate		*priv=self->priv;
+	WebKitWebView		*webkitView;
+
+	/* Disconnect signal on old view */
+	if(priv->view)
+	{
+		webkitView=WEBKIT_WEB_VIEW(midori_view_get_web_view(priv->view));
+		g_signal_handlers_disconnect_by_data(webkitView, self);
+		g_object_set_data(G_OBJECT(priv->view), "nojs-view-instance", NULL);
+		g_object_unref(priv->view);
+		priv->view=NULL;
+	}
+
+	/* Set new view if valid pointer */
+	if(!inView) return;
+
+	priv->view=g_object_ref(inView);
+	g_object_set_data(G_OBJECT(priv->view), "nojs-view-instance", self);
+
+	/* Listen to changes of load-status in view */
+	webkitView=WEBKIT_WEB_VIEW(midori_view_get_web_view(priv->view));
+	g_signal_connect_swapped(webkitView, "notify::load-status", G_CALLBACK(_nojs_view_on_load_status_changed), self);
+	g_signal_connect_swapped(webkitView, "resource-request-starting", G_CALLBACK(_nojs_view_on_resource_request_starting), self);
+
+	/* Create empty menu */
+	_nojs_view_destroy_menu(self);
+	_nojs_view_create_empty_menu(self);
+
+	/* Release list of resource URIs */
+	if(priv->resourceURIs)
+	{
+		g_slist_free_full(priv->resourceURIs, (GDestroyNotify)g_free);
+		priv->resourceURIs=NULL;
+	}
+}
+
+/* This extension is going to be deactivated */
+static void _nojs_view_on_extension_deactivated(NoJSView *self, MidoriExtension *inExtension)
+{
+	g_return_if_fail(NOJS_IS_VIEW(self));
+
+	/* Dispose allocated resources by unreferencing ourselve */
+	g_object_unref(self);
+}
+
+/* Property "manager" has changed */
+static void _nojs_view_on_manager_changed(NoJSView *self, NoJS *inNoJS)
+{
+	g_return_if_fail(NOJS_IS_VIEW(self));
+	g_return_if_fail(!inNoJS || IS_NOJS(inNoJS));
+
+	NoJSViewPrivate		*priv=self->priv;
+	MidoriExtension		*extension;
+
+	/* Release reference to old manager and clean up */
+	if(priv->manager)
+	{
+		g_object_get(priv->manager, "extension", &extension, NULL);
+		g_signal_handlers_disconnect_by_data(extension, self);
+		g_object_unref(extension);
+
+		g_signal_handlers_disconnect_by_data(priv->manager, self);
+		g_object_unref(priv->manager);
+		priv->manager=NULL;
+	}
+
+	/* Set new view if valid pointer */
+	if(!inNoJS) return;
+
+	priv->manager=g_object_ref(inNoJS);
+
+	/* Connect signals to manager */
+	g_signal_connect_swapped(priv->manager, "uri-load-policy-status", G_CALLBACK(_nojs_view_on_uri_load_policy_status), self);
+	g_signal_connect_swapped(priv->manager, "policy-changed", G_CALLBACK(_nojs_view_on_policy_changed), self);
+
+	/* Connect signal to get noticed when extension is going to be deactivated
+	 * to release all references to GObjects
+	 */
+	g_object_get(priv->manager, "extension", &extension, NULL);
+	g_signal_connect_swapped(extension, "deactivate", G_CALLBACK(_nojs_view_on_extension_deactivated), self);
+	g_object_unref(extension);
+}
+
+/* IMPLEMENTATION: GObject */
+
+/* Finalize this object */
+static void nojs_view_finalize(GObject *inObject)
+{
+	NoJSView				*self=NOJS_VIEW(inObject);
+	NoJSViewPrivate			*priv=self->priv;
+
+	/* Dispose allocated resources */
+	if(priv->manager)
+	{
+		MidoriExtension		*extension;
+
+		g_object_get(priv->manager, "extension", &extension, NULL);
+		g_signal_handlers_disconnect_by_data(extension, self);
+		g_object_unref(extension);
+
+		g_signal_handlers_disconnect_by_data(priv->manager, self);
+		g_object_unref(priv->manager);
+		priv->manager=NULL;
+	}
+
+	if(priv->browser)
+	{
+		g_object_unref(priv->browser);
+		priv->browser=NULL;
+	}
+
+	if(priv->view)
+	{
+		_nojs_view_on_view_changed(self, NULL);
+	}
+
+	if(priv->menu)
+	{
+		gtk_widget_destroy(priv->menu);
+		priv->menu=NULL;
+	}
+
+	if(priv->resourceURIs)
+	{
+		g_slist_free_full(priv->resourceURIs, (GDestroyNotify)g_free);
+		priv->resourceURIs=NULL;
+	}
+
+	/* Call parent's class finalize method */
+	G_OBJECT_CLASS(nojs_view_parent_class)->finalize(inObject);
+}
+
+/* Set/get properties */
+static void nojs_view_set_property(GObject *inObject,
+									guint inPropID,
+									const GValue *inValue,
+									GParamSpec *inSpec)
+{
+	NoJSView		*self=NOJS_VIEW(inObject);
+
+	switch(inPropID)
+	{
+		/* Construct-only properties */
+		case PROP_MANAGER:
+			_nojs_view_on_manager_changed(self, NOJS(g_value_get_object(inValue)));
+			break;
+
+		case PROP_BROWSER:
+			if(self->priv->browser) g_object_unref(self->priv->browser);
+			self->priv->browser=g_object_ref(g_value_get_object(inValue));
+			break;
+
+		case PROP_VIEW:
+			_nojs_view_on_view_changed(self, MIDORI_VIEW(g_value_get_object(inValue)));
+			break;
+
+		default:
+			G_OBJECT_WARN_INVALID_PROPERTY_ID(inObject, inPropID, inSpec);
+			break;
+	}
+}
+
+static void nojs_view_get_property(GObject *inObject,
+									guint inPropID,
+									GValue *outValue,
+									GParamSpec *inSpec)
+{
+	NoJSView		*self=NOJS_VIEW(inObject);
+
+	switch(inPropID)
+	{
+		case PROP_MANAGER:
+			g_value_set_object(outValue, self->priv->manager);
+			break;
+
+		case PROP_BROWSER:
+			g_value_set_object(outValue, self->priv->browser);
+			break;
+
+		case PROP_VIEW:
+			g_value_set_object(outValue, self->priv->view);
+			break;
+
+		case PROP_MENU_ICON_STATE:
+			g_value_set_enum(outValue, self->priv->menuIconState);
+			break;
+
+		default:
+			G_OBJECT_WARN_INVALID_PROPERTY_ID(inObject, inPropID, inSpec);
+			break;
+	}
+}
+
+/* Class initialization
+ * Override functions in parent classes and define properties and signals
+ */
+static void nojs_view_class_init(NoJSViewClass *klass)
+{
+	GObjectClass		*gobjectClass=G_OBJECT_CLASS(klass);
+
+	/* Override functions */
+	gobjectClass->finalize=nojs_view_finalize;
+	gobjectClass->set_property=nojs_view_set_property;
+	gobjectClass->get_property=nojs_view_get_property;
+
+	/* Set up private structure */
+	g_type_class_add_private(klass, sizeof(NoJSViewPrivate));
+
+	/* Define properties */
+	NoJSViewProperties[PROP_MANAGER]=
+		g_param_spec_object("manager",
+								_("Manager instance"),
+								_("Instance to global NoJS manager"),
+								TYPE_NOJS,
+								G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
+
+	NoJSViewProperties[PROP_BROWSER]=
+		g_param_spec_object("browser",
+								_("Browser window"),
+								_("The Midori browser instance this view belongs to"),
+								MIDORI_TYPE_BROWSER,
+								G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
+
+	NoJSViewProperties[PROP_VIEW]=
+		g_param_spec_object("view",
+								_("View"),
+								_("The Midori view instance this view belongs to"),
+								MIDORI_TYPE_VIEW,
+								G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
+
+	NoJSViewProperties[PROP_MENU_ICON_STATE]=
+		g_param_spec_enum("menu-icon-state",
+								_("Menu icon state"),
+								_("State of menu icon to show in status bar"),
+								NOJS_TYPE_MENU_ICON_STATE,
+								NOJS_MENU_ICON_STATE_UNDETERMINED,
+								G_PARAM_READABLE);
+
+	g_object_class_install_properties(gobjectClass, PROP_LAST, NoJSViewProperties);
+}
+
+/* Object initialization
+ * Create private structure and set up default values
+ */
+static void nojs_view_init(NoJSView *self)
+{
+	NoJSViewPrivate		*priv;
+
+	priv=self->priv=NOJS_VIEW_GET_PRIVATE(self);
+
+	/* Set up default values */
+	priv->manager=NULL;
+	priv->browser=NULL;
+	priv->view=NULL;
+
+	priv->menu=NULL;
+	priv->menuPolicyWasChanged=FALSE;
+	priv->menuIconState=NOJS_MENU_ICON_STATE_UNDETERMINED;
+
+	priv->resourceURIs=NULL;
+
+	/* Create empty menu */
+	_nojs_view_create_empty_menu(self);
+}
+
+/* Implementation: Public API */
+
+/* Create new object */
+NoJSView* nojs_view_new(NoJS *inNoJS, MidoriBrowser *inBrowser, MidoriView *inView)
+{
+	return(g_object_new(TYPE_NOJS_VIEW,
+							"manager", inNoJS,
+							"browser", inBrowser,
+							"view", inView,
+							NULL));
+}
+
+/* Get menu widget for this view */
+GtkMenu* nojs_view_get_menu(NoJSView *self)
+{
+	g_return_val_if_fail(NOJS_IS_VIEW(self), NULL);
+
+	return(GTK_MENU(self->priv->menu));
+}
+
+/* Get image used for menu icon in status bar */
+NoJSMenuIconState nojs_view_get_menu_icon_state(NoJSView *self)
+{
+	g_return_val_if_fail(NOJS_IS_VIEW(self), NOJS_MENU_ICON_STATE_UNDETERMINED);
+
+	return(self->priv->menuIconState);
+}
+
+/************************************************************************************/
+
+/* Implementation: Enumeration */
+GType nojs_menu_icon_state_get_type(void)
+{
+	static volatile gsize	g_define_type_id__volatile=0;
+
+	if(g_once_init_enter(&g_define_type_id__volatile))
+	{
+		static const GEnumValue values[]=
+		{
+			{ NOJS_MENU_ICON_STATE_UNDETERMINED, "NOJS_MENU_ICON_STATE_UNDETERMINED", N_("Undetermined") },
+			{ NOJS_MENU_ICON_STATE_ALLOWED, "NOJS_MENU_ICON_STATE_ALLOWED", N_("Allowed") },
+			{ NOJS_MENU_ICON_STATE_MIXED, "NOJS_MENU_ICON_STATE_MIXED", N_("Mixed") },
+			{ NOJS_MENU_ICON_STATE_DENIED, "NOJS_MENU_ICON_STATE_DENIED", N_("Denied") },
+			{ 0, NULL, NULL }
+		};
+
+		GType	g_define_type_id=g_enum_register_static(g_intern_static_string("NoJSMenuIconState"), values);
+		g_once_init_leave(&g_define_type_id__volatile, g_define_type_id);
+	}
+
+	return(g_define_type_id__volatile);
+}
 
=== added file 'extensions/nojs/nojs-view.h'
--- extensions/nojs/nojs-view.h	1970-01-01 00:00:00 +0000
+++ extensions/nojs/nojs-view.h	2013-07-29 19:51:25 +0000
@@ -0,0 +1,71 @@
+/*
+ Copyright (C) 2013 Stephan Haller <[e-mail]>
+
+ 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.
+*/
+
+#ifndef __NOJS_VIEW__
+#define __NOJS_VIEW__
+
+#include "config.h"
+#include "nojs.h"
+#include <midori/midori.h>
+
+G_BEGIN_DECLS
+
+/* NoJS view enums */
+typedef enum
+{
+	NOJS_MENU_ICON_STATE_UNDETERMINED,
+	NOJS_MENU_ICON_STATE_ALLOWED,
+	NOJS_MENU_ICON_STATE_MIXED,
+	NOJS_MENU_ICON_STATE_DENIED
+} NoJSMenuIconState;
+
+/* NoJS view object */
+#define TYPE_NOJS_VIEW				(nojs_view_get_type())
+#define NOJS_VIEW(obj)				(G_TYPE_CHECK_INSTANCE_CAST((obj), TYPE_NOJS_VIEW, NoJSView))
+#define NOJS_IS_VIEW(obj)			(G_TYPE_CHECK_INSTANCE_TYPE((obj), TYPE_NOJS_VIEW))
+#define NOJS_VIEW_CLASS(klass)		(G_TYPE_CHECK_CLASS_CAST((klass), TYPE_NOJS_VIEW, NoJSViewClass))
+#define NOJS_IS_VIEW_CLASS(klass)	(G_TYPE_CHECK_CLASS_TYPE((klass), TYPE_NOJS_VIEW))
+#define NOJS_VIEW_GET_CLASS(obj)	(G_TYPE_INSTANCE_GET_CLASS((obj), TYPE_NOJS_VIEW, NoJSViewClass))
+
+typedef struct _NoJSView			NoJSView;
+typedef struct _NoJSViewClass		NoJSViewClass;
+typedef struct _NoJSViewPrivate		NoJSViewPrivate;
+
+struct _NoJSView
+{
+	/* Parent instance */
+	GObject				parent_instance;
+
+	/* Private structure */
+	NoJSViewPrivate		*priv;
+};
+
+struct _NoJSViewClass
+{
+	/* Parent class */
+	GObjectClass		parent_class;
+};
+
+/* Public API */
+GType nojs_view_get_type(void);
+
+NoJSView* nojs_view_new(NoJS *inNoJS, MidoriBrowser *inBrowser, MidoriView *inView);
+
+GtkMenu* nojs_view_get_menu(NoJSView *self);
+NoJSMenuIconState nojs_view_get_menu_icon_state(NoJSView *self);
+
+/* Enumeration */
+GType nojs_menu_icon_state_get_type(void) G_GNUC_CONST;
+#define NOJS_TYPE_MENU_ICON_STATE	(nojs_menu_icon_state_get_type())
+
+G_END_DECLS
+
+#endif /* __NOJS_VIEW__ */
 
=== added file 'extensions/nojs/nojs.c'
--- extensions/nojs/nojs.c	1970-01-01 00:00:00 +0000
+++ extensions/nojs/nojs.c	2013-07-29 19:51:25 +0000
@@ -0,0 +1,1069 @@
+/*
+ Copyright (C) 2013 Stephan Haller <[e-mail]>
+
+ 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.
+*/
+
+#include "nojs.h"
+#include "nojs-view.h"
+
+#include <errno.h>
+
+/* Define this class in GObject system */
+G_DEFINE_TYPE(NoJS,
+				nojs,
+				G_TYPE_OBJECT)
+
+/* Properties */
+enum
+{
+	PROP_0,
+
+	PROP_EXTENSION,
+	PROP_APPLICATION,
+
+	PROP_DATABASE,
+	PROP_DATABASE_FILENAME,
+	PROP_ALLOW_ALL_SITES,
+	PROP_ONLY_SECOND_LEVEL,
+	PROP_UNKNOWN_DOMAIN_POLICY,
+
+	PROP_LAST
+};
+
+static GParamSpec* NoJSProperties[PROP_LAST]={ 0, };
+
+/* Signals */
+enum
+{
+	URI_LOAD_POLICY_STATUS,
+	POLICY_CHANGED,
+
+	SIGNAL_LAST
+};
+
+static guint NoJSSignals[SIGNAL_LAST]={ 0, };
+
+/* Private structure - access only by public API if needed */
+#define NOJS_GET_PRIVATE(obj) \
+	(G_TYPE_INSTANCE_GET_PRIVATE((obj), TYPE_NOJS, NoJSPrivate))
+
+struct _NoJSPrivate
+{
+	/* Extension related */
+	MidoriExtension					*extension;
+	MidoriApp						*application;
+	sqlite3							*database;
+	gchar							*databaseFilename;
+	gboolean						allowAllSites;
+	gboolean						checkOnlySecondLevel;
+	NoJSPolicy						unknownDomainPolicy;
+
+	guint							requestStartedSignalID;
+};
+
+/* Taken from http://www.w3.org/html/wg/drafts/html/master/scripting-1.html#scriptingLanguages
+ * A list of javascript mime types
+ */
+static const gchar*				javascriptTypes[]=	{
+														"application/ecmascript",
+														"application/javascript",
+														"application/x-ecmascript",
+														"application/x-javascript",
+														"text/ecmascript",
+														"text/javascript",
+														"text/javascript1.0",
+														"text/javascript1.1",
+														"text/javascript1.2",
+														"text/javascript1.3",
+														"text/javascript1.4",
+														"text/javascript1.5",
+														"text/jscript",
+														"text/livescript",
+														"text/x-ecmascript",
+														"text/x-javascript",
+														NULL
+													};
+
+/* IMPLEMENTATION: Private variables and methods */
+
+/* Closure for: void (*closure)(NoJS *self, gchar *inURI, NoJSPolicy inPolicy) */
+static void _nojs_closure_VOID__STRING_ENUM(GClosure *inClosure,
+											GValue *ioReturnValue G_GNUC_UNUSED,
+											guint inNumberValues,
+											const GValue *inValues,
+											gpointer inInvocationHint G_GNUC_UNUSED,
+											gpointer inMarshalData)
+{
+	typedef void (*GMarshalFunc_VOID__STRING_ENUM)(gpointer inObject, gpointer inArg1, gint inArg2, gpointer inUserData);
+
+	register GMarshalFunc_VOID__STRING_ENUM		callback;
+	register GCClosure							*closure=(GCClosure*)inClosure;
+	register gpointer							object, userData;
+
+	g_return_if_fail(inNumberValues==3);
+
+	if(G_CCLOSURE_SWAP_DATA(inClosure))
+	{
+		object=inClosure->data;
+		userData=g_value_peek_pointer(inValues+0);
+	}
+		else
+		{
+			object=g_value_peek_pointer(inValues+0);
+			userData=inClosure->data;
+		}
+
+	callback=(GMarshalFunc_VOID__STRING_ENUM)(inMarshalData ? inMarshalData : closure->callback);
+
+	callback(object,
+				(gchar*)g_value_get_string(inValues+1),
+				g_value_get_enum(inValues+2),
+				userData);
+}
+
+/* Show common error dialog */
+static void _nojs_error(NoJS *self, const gchar *inReason)
+{
+	g_return_if_fail(IS_NOJS(self));
+	g_return_if_fail(inReason);
+
+	GtkWidget		*dialog;
+
+	/* Show confirmation dialog for undetermined cookies */
+	dialog=gtk_message_dialog_new(NULL,
+									GTK_DIALOG_MODAL,
+									GTK_MESSAGE_ERROR,
+									GTK_BUTTONS_OK,
+									_("A fatal error occurred which prevents "
+									  "the NoJS extension to continue. "
+									  "You should disable it."));
+
+	gtk_window_set_title(GTK_WINDOW(dialog), _("Error in NoJS extension"));
+	gtk_window_set_icon_name(GTK_WINDOW (dialog), "midori");
+
+	gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dialog),
+												"%s:\n%s",
+												_("Reason"),
+												inReason);
+
+	gtk_dialog_run(GTK_DIALOG(dialog));
+
+	/* Free up allocated resources */
+	gtk_widget_destroy(dialog);
+}
+
+/* Open database containing policies for javascript sites.
+ * Create database and setup table structure if it does not exist yet.
+ */
+static void _nojs_open_database(NoJS *self)
+{
+	g_return_if_fail(IS_NOJS(self));
+
+	NoJSPrivate		*priv=self->priv;
+	const gchar		*configDir;
+	gchar			*sql;
+	gchar			*error=NULL;
+	gint			success;
+
+	/* Close any open database */
+	if(priv->database)
+	{
+		priv->databaseFilename=NULL;
+
+		sqlite3_close(priv->database);
+		priv->database=NULL;
+
+		g_object_notify_by_pspec(G_OBJECT(self), NoJSProperties[PROP_DATABASE]);
+		g_object_notify_by_pspec(G_OBJECT(self), NoJSProperties[PROP_DATABASE_FILENAME]);
+	}
+
+	/* Build path to database file */
+	configDir=midori_extension_get_config_dir(priv->extension);
+	if(!configDir)
+	{
+		g_warning(_("Could not get path to configuration of extension: path is NULL"));
+
+		_nojs_error(self, _("Could not get path to configuration of extension."));
+		return;
+	}
+	
+	if(katze_mkdir_with_parents(configDir, 0700))
+	{
+		g_warning(_("Could not create configuration folder for extension: %s"), g_strerror(errno));
+
+		_nojs_error(self, _("Could not create configuration folder for extension."));
+		return;
+	}
+
+	/* Open database */
+	priv->databaseFilename=g_build_filename(configDir, NOJS_DATABASE, NULL);
+	success=sqlite3_open(priv->databaseFilename, &priv->database);
+	if(success!=SQLITE_OK)
+	{
+		g_warning(_("Could not open database of extension: %s"), sqlite3_errmsg(priv->database));
+
+		g_free(priv->databaseFilename);
+		priv->databaseFilename=NULL;
+
+		if(priv->database) sqlite3_close(priv->database);
+		priv->database=NULL;
+
+		_nojs_error(self, _("Could not open database of extension."));
+		return;
+	}
+
+	/* Create table structure if it does not exist */
+	success=sqlite3_exec(priv->database,
+							"CREATE TABLE IF NOT EXISTS "
+							"policies(site text, value integer);",
+							NULL,
+							NULL,
+							&error);
+
+	if(success==SQLITE_OK)
+	{
+		success=sqlite3_exec(priv->database,
+								"CREATE UNIQUE INDEX IF NOT EXISTS "
+								"site ON policies (site);",
+								NULL,
+								NULL,
+								&error);
+	}
+
+	if(success==SQLITE_OK)
+	{
+		success=sqlite3_exec(priv->database,
+								"PRAGMA journal_mode=TRUNCATE;",
+								NULL,
+								NULL,
+								&error);
+	}
+
+	if(success!=SQLITE_OK || error)
+	{
+		_nojs_error(self, _("Could not set up database structure of extension."));
+
+		if(error)
+		{
+			g_critical(_("Failed to execute database statement: %s"), error);
+			sqlite3_free(error);
+		}
+
+		g_free(priv->databaseFilename);
+		priv->databaseFilename=NULL;
+
+		sqlite3_close(priv->database);
+		priv->database=NULL;
+		return;
+	}
+
+	/* Delete all temporarily allowed sites */
+	sql=sqlite3_mprintf("DELETE FROM policies WHERE value=%d;", NOJS_POLICY_ACCEPT_TEMPORARILY);
+	success=sqlite3_exec(priv->database, sql, NULL, NULL, &error);
+	if(success!=SQLITE_OK) g_warning(_("SQL fails: %s"), error);
+	if(error) sqlite3_free(error);
+	sqlite3_free(sql);
+
+	g_object_notify_by_pspec(G_OBJECT(self), NoJSProperties[PROP_DATABASE]);
+	g_object_notify_by_pspec(G_OBJECT(self), NoJSProperties[PROP_DATABASE_FILENAME]);
+}
+
+/* A request through libsoup is going to start and http headers must be
+ * checked for content type
+ */
+static void _nojs_on_got_headers(NoJS *self, gpointer inUserData)
+{
+	g_return_if_fail(IS_NOJS(self));
+	g_return_if_fail(SOUP_IS_MESSAGE(inUserData));
+
+	NoJSPrivate				*priv=self->priv;
+	SoupMessage				*message=SOUP_MESSAGE(inUserData);
+	SoupSession				*session=webkit_get_default_session();
+	SoupMessageHeaders		*headers;
+	SoupMessageBody			*body;
+	const gchar				*contentType;
+	SoupURI					*uri;
+	gchar					*uriText;
+	gchar					*domain;
+	NoJSPolicy				policy;
+	gboolean				isJS;
+	const gchar				**iter;
+
+	/* Get headers from message to retrieve content type */
+	g_object_get(message, "response-headers", &headers, NULL);
+	if(!headers)
+	{
+		g_warning("Could not get headers from message to check for javascript.");
+		return;
+	}
+
+	/* Get content type of uri and check if it is a javascript resource */
+	contentType=soup_message_headers_get_content_type(headers, NULL);
+
+	isJS=FALSE;
+	iter=javascriptTypes;
+	while(*iter && !isJS)
+	{
+		isJS=(g_strcmp0(contentType, *iter)==0);
+		iter++;
+	}
+
+	if(!isJS) return;
+
+	/* The document being loaded is javascript so get URI from message,
+	 * get policy for domain of URI and emit signal
+	 */
+	uri=soup_message_get_uri(message);
+
+	domain=nojs_get_domain(self, uri);
+	g_return_if_fail(domain);
+
+	policy=nojs_get_policy(self, domain);
+	if(policy==NOJS_POLICY_UNDETERMINED)
+	{
+		g_warning("Got invalid policy. Using default policy for unknown domains.");
+		policy=priv->unknownDomainPolicy;
+	}
+
+	uriText=soup_uri_to_string(uri, FALSE);
+
+	g_signal_emit(self, NoJSSignals[URI_LOAD_POLICY_STATUS], 0, uriText, policy==NOJS_POLICY_UNDETERMINED ? NOJS_POLICY_BLOCK : policy);
+
+	g_free(uriText);
+	g_free(domain);
+
+	/* Return here if policy is any type of accept */
+	if(policy!=NOJS_POLICY_UNDETERMINED && policy!=NOJS_POLICY_BLOCK) return;
+
+	/* Cancel this message */
+	soup_session_cancel_message(session, message, SOUP_STATUS_CANCELLED);
+
+	/* Discard any load data */
+	g_object_get(message, "response-body", &body, NULL);
+	if(body) soup_message_body_truncate(body);
+}
+
+static void _nojs_on_request_started(NoJS *self,
+										SoupMessage *inMessage,
+										SoupSocket *inSocket,
+										gpointer inUserData)
+{
+	g_return_if_fail(IS_NOJS(self));
+	g_return_if_fail(SOUP_IS_MESSAGE(inMessage));
+
+	/* Connect to "got-headers" to cancel loading javascript documents early */
+	g_signal_connect_swapped(inMessage, "got-headers", G_CALLBACK(_nojs_on_got_headers), self);
+}
+
+/* The icon in statusbar was clicked */
+static void _nojs_on_statusbar_icon_clicked(MidoriBrowser *inBrowser, gpointer inUserData)
+{
+	g_return_if_fail(MIDORI_IS_BROWSER(inBrowser));
+
+	MidoriView		*activeView;
+	NoJSView		*view;
+	GtkMenu			*menu;
+
+	/* Get current active midori view */
+	activeView=MIDORI_VIEW(midori_browser_get_current_tab(inBrowser));
+	g_return_if_fail(MIDORI_IS_VIEW(activeView));
+
+	/* Get NoJS view of current active midori view */
+	view=NOJS_VIEW(g_object_get_data(G_OBJECT(activeView), "nojs-view-instance"));
+	g_return_if_fail(NOJS_IS_VIEW(view));
+
+	/* Get menu of current view */
+	menu=nojs_view_get_menu(view);
+	g_return_if_fail(menu);
+
+	/* Show menu */
+	gtk_menu_popup(menu, NULL, NULL, NULL, NULL, 0, gtk_get_current_event_time());
+}
+
+gchar* nojs_get_icon_path (const gchar* icon)
+{
+    gchar* res_dir = midori_paths_get_res_filename ("");
+    return g_build_filename (res_dir, "nojs", icon, NULL);
+}
+
+/* Menu icon of a view has changed */
+static void _nojs_on_menu_icon_changed(MidoriBrowser *inBrowser, GParamSpec *inSpec, gpointer inUserData)
+{
+	g_return_if_fail(MIDORI_IS_BROWSER(inBrowser));
+	g_return_if_fail(NOJS_IS_VIEW(inUserData));
+
+	NoJSView			*view=NOJS_VIEW(inUserData);
+	NoJSMenuIconState	menuIconState;
+	GtkWidget			*statusbarIcon;
+	GtkWidget			*buttonImage;
+	gchar				*imageFilename;
+
+	/* Get icon in status bar of this browser */
+	statusbarIcon=GTK_WIDGET(g_object_get_data(G_OBJECT(inBrowser), "nojs-statusicon"));
+	g_return_if_fail(GTK_IS_WIDGET(statusbarIcon));
+
+	/* Get menu icon state of view */
+	menuIconState=nojs_view_get_menu_icon_state(view);
+
+	/* Create image for statusbar button */
+	imageFilename=NULL;
+	switch(menuIconState)
+	{
+		case NOJS_MENU_ICON_STATE_ALLOWED:
+			imageFilename=nojs_get_icon_path("nojs-statusicon-allowed.png");
+			break;
+
+		case NOJS_MENU_ICON_STATE_MIXED:
+			imageFilename=nojs_get_icon_path("nojs-statusicon-mixed.png");
+			break;
+
+		case NOJS_MENU_ICON_STATE_DENIED:
+		case NOJS_MENU_ICON_STATE_UNDETERMINED:
+			imageFilename=nojs_get_icon_path("nojs-statusicon-denied.png");
+			break;
+	}
+
+	buttonImage=gtk_image_new_from_file(imageFilename);
+	g_free(imageFilename);
+
+	/* Set image at statusbar button */
+	gtk_button_set_image(GTK_BUTTON(statusbarIcon), buttonImage);
+}
+
+/* A tab in browser was activated */
+static void _nojs_on_switch_tab(NoJS *self, MidoriView *inOldView, MidoriView *inNewView, gpointer inUserData)
+{
+	g_return_if_fail(IS_NOJS(self));
+	g_return_if_fail(MIDORI_IS_BROWSER(inUserData));
+
+	MidoriBrowser		*browser=MIDORI_BROWSER(inUserData);
+	NoJSView			*view;
+
+	/* Disconnect signal handlers from old view */
+	if(inOldView)
+	{
+		/* Get NoJS view of old view */
+		view=(NoJSView*)g_object_get_data(G_OBJECT(inOldView), "nojs-view-instance");
+		g_return_if_fail(NOJS_IS_VIEW(view));
+
+		/* Disconnect signal handlers */
+		g_signal_handlers_disconnect_by_func(view, G_CALLBACK(_nojs_on_menu_icon_changed), browser);
+	}
+
+	/* Get NoJS view of new view */
+	view=(NoJSView*)g_object_get_data(G_OBJECT(inNewView), "nojs-view-instance");
+	g_return_if_fail(NOJS_IS_VIEW(view));
+
+	/* Connect signals */
+	g_signal_connect_swapped(view, "notify::menu-icon-state", G_CALLBACK(_nojs_on_menu_icon_changed), browser);
+
+	/* Update menu icon*/
+	_nojs_on_menu_icon_changed(browser, NULL, view);
+}
+
+/* A tab of a browser was removed */
+static void _nojs_on_remove_tab(NoJS *self, MidoriView *inView, gpointer inUserData)
+{
+	g_return_if_fail(IS_NOJS(self));
+
+	NoJSView		*view;
+
+	/* Get NoJS view of current active midori view */
+	view=NOJS_VIEW(g_object_get_data(G_OBJECT(inView), "nojs-view-instance"));
+	g_return_if_fail(NOJS_IS_VIEW(view));
+
+	g_object_unref(view);
+}
+
+/* A tab of a browser was added */
+static void _nojs_on_add_tab(NoJS *self, MidoriView *inView, gpointer inUserData)
+{
+	g_return_if_fail(IS_NOJS(self));
+	g_return_if_fail(MIDORI_IS_BROWSER(inUserData));
+
+	/* Create nojs view and add to tab */
+	MidoriBrowser	*browser=MIDORI_BROWSER(inUserData);
+
+	nojs_view_new(self, browser, inView);
+}
+
+/* A browser window was added */
+static void _nojs_on_add_browser(NoJS *self, MidoriBrowser *inBrowser, gpointer inUserData)
+{
+	g_return_if_fail(IS_NOJS(self));
+	g_return_if_fail(MIDORI_IS_BROWSER(inBrowser));
+
+	GList			*tabs, *iter;
+	GtkWidget		*statusbar;
+	GtkWidget		*statusbarIcon;
+	MidoriView		*view;
+	NoJSView		*nojsView;
+
+	/* Set up all current available tabs in browser */
+	tabs=midori_browser_get_tabs(inBrowser);
+	for(iter=tabs; iter; iter=g_list_next(iter)) _nojs_on_add_tab(self, iter->data, inBrowser);
+	g_list_free(tabs);
+
+	/* Add status bar icon to browser */
+	g_object_get(inBrowser, "statusbar", &statusbar, NULL);
+	if(statusbar)
+	{
+		/* Create and set up status icon */
+		statusbarIcon=gtk_button_new();
+		gtk_button_set_relief(GTK_BUTTON(statusbarIcon), GTK_RELIEF_NONE);
+		gtk_widget_show_all(statusbarIcon);
+		gtk_box_pack_end(GTK_BOX(statusbar), statusbarIcon, FALSE, FALSE, 0);
+		g_object_set_data_full(G_OBJECT(inBrowser), "nojs-statusicon", g_object_ref(statusbarIcon), (GDestroyNotify)gtk_widget_destroy);
+
+		/* Connect signals */
+		g_signal_connect_swapped(statusbarIcon, "clicked", G_CALLBACK(_nojs_on_statusbar_icon_clicked), inBrowser);
+
+		/* Release our reference to statusbar and status icon */
+		g_object_unref(statusbarIcon);
+		g_object_unref(statusbar);
+
+		/* Update menu icon*/
+		view=MIDORI_VIEW(midori_browser_get_current_tab(inBrowser));
+		if(view)
+		{
+			nojsView=(NoJSView*)g_object_get_data(G_OBJECT(view), "nojs-view-instance");
+			if(nojsView) _nojs_on_menu_icon_changed(inBrowser, NULL, nojsView);
+		}
+	}
+
+	/* Listen to new tabs opened in browser */
+	g_signal_connect_swapped(inBrowser, "add-tab", G_CALLBACK(_nojs_on_add_tab), self);
+	g_signal_connect_swapped(inBrowser, "switch-tab", G_CALLBACK(_nojs_on_switch_tab), self);
+	g_signal_connect_swapped(inBrowser, "remove-tab", G_CALLBACK(_nojs_on_remove_tab), self);
+}
+
+/* Application property has changed */
+static void _nojs_on_application_changed(NoJS *self)
+{
+	g_return_if_fail(IS_NOJS(self));
+
+	NoJSPrivate		*priv=NOJS(self)->priv;
+	GList			*browsers, *iter;
+
+	/* Set up all current open browser windows */
+	browsers=midori_app_get_browsers(priv->application);
+	for(iter=browsers; iter; iter=g_list_next(iter)) _nojs_on_add_browser(self, MIDORI_BROWSER(iter->data), priv->application);
+	g_list_free(browsers);
+
+	/* Listen to new browser windows opened */
+	g_signal_connect_swapped(priv->application, "add-browser", G_CALLBACK(_nojs_on_add_browser), self);
+
+	/* Notify about property change */
+	g_object_notify_by_pspec(G_OBJECT(self), NoJSProperties[PROP_APPLICATION]);
+}
+
+/* IMPLEMENTATION: GObject */
+
+/* Finalize this object */
+static void nojs_finalize(GObject *inObject)
+{
+	NoJS			*self=NOJS(inObject);
+	NoJSPrivate		*priv=self->priv;
+	GList			*browsers, *browser;
+	GList			*tabs, *tab;
+	WebKitWebView	*webkitView;
+	SoupSession		*session;
+
+	/* Dispose allocated resources */
+	session=webkit_get_default_session();
+	g_signal_handlers_disconnect_by_data(session, self);
+
+	if(priv->databaseFilename)
+	{
+		g_free(priv->databaseFilename);
+		priv->databaseFilename=NULL;
+	}
+
+	if(priv->database)
+	{
+		sqlite3_close(priv->database);
+		priv->database=NULL;
+	}
+
+	if(priv->application)
+	{
+		g_signal_handlers_disconnect_by_data(priv->application, self);
+
+		browsers=midori_app_get_browsers(priv->application);
+		for(browser=browsers; browser; browser=g_list_next(browser))
+		{
+			g_signal_handlers_disconnect_by_data(browser->data, self);
+			g_object_set_data(G_OBJECT(browser->data), "nojs-statusicon", NULL);
+
+			tabs=midori_browser_get_tabs(MIDORI_BROWSER(browser->data));
+			for(tab=tabs; tab; tab=g_list_next(tab))
+			{
+				g_signal_handlers_disconnect_by_data(tab->data, self);
+
+				webkitView=WEBKIT_WEB_VIEW(midori_view_get_web_view(MIDORI_VIEW(tab->data)));
+				g_signal_handlers_disconnect_by_data(webkitView, self);
+			}
+			g_list_free(tabs);
+		}
+		g_list_free(browsers);
+
+		priv->application=NULL;
+	}
+
+	/* Call parent's class finalize method */
+	G_OBJECT_CLASS(nojs_parent_class)->finalize(inObject);
+}
+
+/* Set/get properties */
+static void nojs_set_property(GObject *inObject,
+								guint inPropID,
+								const GValue *inValue,
+								GParamSpec *inSpec)
+{
+	NoJS		*self=NOJS(inObject);
+	
+	switch(inPropID)
+	{
+		/* Construct-only properties */
+		case PROP_EXTENSION:
+			self->priv->extension=g_value_get_object(inValue);
+			_nojs_open_database(self);
+			break;
+
+		case PROP_APPLICATION:
+			self->priv->application=g_value_get_object(inValue);
+			_nojs_on_application_changed(self);
+			break;
+
+		case PROP_ALLOW_ALL_SITES:
+			self->priv->allowAllSites=g_value_get_boolean(inValue);
+			g_object_notify_by_pspec(G_OBJECT(self), NoJSProperties[PROP_ALLOW_ALL_SITES]);
+			break;
+
+		case PROP_ONLY_SECOND_LEVEL:
+			self->priv->checkOnlySecondLevel=g_value_get_boolean(inValue);
+			g_object_notify_by_pspec(G_OBJECT(self), NoJSProperties[PROP_ONLY_SECOND_LEVEL]);
+			break;
+
+		case PROP_UNKNOWN_DOMAIN_POLICY:
+			self->priv->unknownDomainPolicy=g_value_get_enum(inValue);
+			g_object_notify_by_pspec(G_OBJECT(self), NoJSProperties[PROP_UNKNOWN_DOMAIN_POLICY]);
+			break;
+
+		default:
+			G_OBJECT_WARN_INVALID_PROPERTY_ID(inObject, inPropID, inSpec);
+			break;
+	}
+}
+
+static void nojs_get_property(GObject *inObject,
+								guint inPropID,
+								GValue *outValue,
+								GParamSpec *inSpec)
+{
+	NoJS		*self=NOJS(inObject);
+
+	switch(inPropID)
+	{
+		case PROP_EXTENSION:
+			g_value_set_object(outValue, self->priv->extension);
+			break;
+
+		case PROP_APPLICATION:
+			g_value_set_object(outValue, self->priv->application);
+			break;
+
+		case PROP_DATABASE:
+			g_value_set_pointer(outValue, self->priv->database);
+			break;
+
+		case PROP_DATABASE_FILENAME:
+			g_value_set_string(outValue, self->priv->databaseFilename);
+			break;
+
+		case PROP_ALLOW_ALL_SITES:
+			g_value_set_boolean(outValue, self->priv->allowAllSites);
+			break;
+
+		case PROP_ONLY_SECOND_LEVEL:
+			g_value_set_boolean(outValue, self->priv->checkOnlySecondLevel);
+			break;
+
+		case PROP_UNKNOWN_DOMAIN_POLICY:
+			g_value_set_enum(outValue, self->priv->unknownDomainPolicy);
+			break;
+
+		default:
+			G_OBJECT_WARN_INVALID_PROPERTY_ID(inObject, inPropID, inSpec);
+			break;
+	}
+}
+
+/* Class initialization
+ * Override functions in parent classes and define properties and signals
+ */
+static void nojs_class_init(NoJSClass *klass)
+{
+	GObjectClass		*gobjectClass=G_OBJECT_CLASS(klass);
+
+	/* Override functions */
+	gobjectClass->finalize=nojs_finalize;
+	gobjectClass->set_property=nojs_set_property;
+	gobjectClass->get_property=nojs_get_property;
+
+	/* Set up private structure */
+	g_type_class_add_private(klass, sizeof(NoJSPrivate));
+
+	/* Define properties */
+	NoJSProperties[PROP_EXTENSION]=
+		g_param_spec_object("extension",
+								_("Extension instance"),
+								_("The Midori extension instance for this extension"),
+								MIDORI_TYPE_EXTENSION,
+								G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
+
+	NoJSProperties[PROP_APPLICATION]=
+		g_param_spec_object("application",
+								_("Application instance"),
+								_("The Midori application instance this extension belongs to"),
+								MIDORI_TYPE_APP,
+								G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
+
+	NoJSProperties[PROP_DATABASE]=
+		g_param_spec_pointer("database",
+								_("Database instance"),
+								_("Pointer to sqlite database instance used by this extension"),
+								G_PARAM_READABLE);
+
+	NoJSProperties[PROP_DATABASE_FILENAME]=
+		g_param_spec_string("database-filename",
+								_("Database path"),
+								_("Path to sqlite database instance used by this extension"),
+								NULL,
+								G_PARAM_READABLE);
+
+	NoJSProperties[PROP_ALLOW_ALL_SITES]=
+		g_param_spec_boolean("allow-all-sites",
+								_("Allow all sites"),
+								_("If true this extension will not check policy for each site but allow them."),
+								FALSE,
+								G_PARAM_READWRITE | G_PARAM_CONSTRUCT);
+
+	NoJSProperties[PROP_ONLY_SECOND_LEVEL]=
+		g_param_spec_boolean("only-second-level",
+								_("Only second level"),
+								_("If true this extension will reduce each domain to its second-level (www.example.org will reduced to example.org)"),
+								TRUE,
+								G_PARAM_READWRITE | G_PARAM_CONSTRUCT);
+
+	NoJSProperties[PROP_UNKNOWN_DOMAIN_POLICY]=
+		g_param_spec_enum("unknown-domain-policy",
+								_("Unknown domain policy"),
+								_("Policy to use for unknown domains."),
+								NOJS_TYPE_POLICY,
+								NOJS_POLICY_BLOCK,
+								G_PARAM_READWRITE | G_PARAM_CONSTRUCT);
+
+	g_object_class_install_properties(gobjectClass, PROP_LAST, NoJSProperties);
+
+	/* Define signals */
+
+	/* Why does this signal exist?
+	 * 
+	 * The problem I faced when developing this extension was
+	 * that I needed to cancel a SoupMessage as soon as possible
+	 * (when http headers were received).
+	 * I tried to connect to signal "resource-response-received"
+	 * of WebKitWebView but the SoupMessage instance was not
+	 * exactly the same which were sent or received by SoupSession.
+	 * So I could not cancel the SoupMessage or better: I cancelled
+	 * a SoupMessage which is not be handled so it had no effect.
+	 * The body of SoupMessage was still being loaded and javascript
+	 * was executed. I think the problem is that webkit-gtk creates
+	 * a copy of the real SoupMessage which is going to be sent and
+	 * received.
+	 * 
+	 * So I decided to connect to signal "got-headers" of every
+	 * SoupMessage sent by the default SoupSession which I notice
+	 * by connecting to signal "request-started" of SoupSession. Each
+	 * NoJSView connects to signal "resource-request-starting" of
+	 * WebKitWebView to remember each URI going to be loaded. When
+	 * a SoupMessage hits "got-headers" and is a javascript resource
+	 * I can cancel the message immediately and clear the body which
+	 * causes webkit-gtk to copy a empty body if it does at all as the
+	 * SoupMessage was cancelled. Then I emit this signal
+	 * "uri-load-policy-status" to notify each view but the cancellation.
+	 * (It also notifies all views if it is going to load to keep the
+	 * menu in right state.) Each view will check if it _could_ be a
+	 * resource itself requested and will update its menu accordingly.
+	 * It might happen that a request will match two views because only
+	 * the URI will be checked by the view because I cannot determine
+	 * to which view the SoupMessage belongs to. But it doesn't matter
+	 * because if a javascript resource was denied or allowed in one view
+	 * it is likely be denied or allowed in other views too ;)
+	 */
+	NoJSSignals[URI_LOAD_POLICY_STATUS]=
+		g_signal_new("uri-load-policy-status",
+						G_TYPE_FROM_CLASS(klass),
+						G_SIGNAL_RUN_LAST,
+						G_STRUCT_OFFSET(NoJSClass, uri_load_policy_status),
+						NULL,
+						NULL,
+						_nojs_closure_VOID__STRING_ENUM,
+						G_TYPE_NONE,
+						2,
+						G_TYPE_STRING,
+						NOJS_TYPE_POLICY);
+
+	NoJSSignals[POLICY_CHANGED]=
+		g_signal_new("policy-changed",
+						G_TYPE_FROM_CLASS(klass),
+						G_SIGNAL_RUN_LAST,
+						G_STRUCT_OFFSET(NoJSClass, policy_changed),
+						NULL,
+						NULL,
+						g_cclosure_marshal_VOID__STRING,
+						G_TYPE_NONE,
+						1,
+						G_TYPE_STRING);
+}
+
+/* Object initialization
+ * Create private structure and set up default values
+ */
+
+static void nojs_init(NoJS *self)
+{
+	NoJSPrivate		*priv;
+	SoupSession		*session;
+
+	priv=self->priv=NOJS_GET_PRIVATE(self);
+
+	/* Set up default values */
+	priv->database=NULL;
+	priv->databaseFilename=NULL;
+	priv->allowAllSites=FALSE;
+	priv->checkOnlySecondLevel=TRUE;
+	priv->unknownDomainPolicy=NOJS_POLICY_BLOCK;
+
+	/* Connect to signals on session to be able to cancel messages
+	 * loading javascript documents
+	 */
+	session=webkit_get_default_session();
+	g_signal_connect_swapped(session, "request-started", G_CALLBACK(_nojs_on_request_started), self);
+}
+
+/* Implementation: Public API */
+
+/* Create new object */
+NoJS* nojs_new(MidoriExtension *inExtension, MidoriApp *inApp)
+{
+	return(g_object_new(TYPE_NOJS,
+							"extension", inExtension,
+							"application", inApp,
+							NULL));
+}
+
+/* Retrieves domain from uri depending on preferences (e.g. only second level domain) */
+gchar* nojs_get_domain(NoJS *self, SoupURI *inURI)
+{
+	g_return_val_if_fail(IS_NOJS(self), NULL);
+	g_return_val_if_fail(inURI, NULL);
+
+	NoJSPrivate			*priv=self->priv;
+	const gchar			*realDomain;
+	gchar				*asciiDomain, *domain;
+	gchar				*finalDomain;
+
+	/* Get domain of site to lookup */
+	realDomain=soup_uri_get_host(inURI);
+
+	domain=asciiDomain=g_hostname_to_ascii(realDomain);
+
+	if(priv->checkOnlySecondLevel)
+	{
+		/* Only get second level domain if host is not an IP address */
+		if(!g_hostname_is_ip_address(asciiDomain))
+		{
+			gint		numberDots=0;
+
+			domain=asciiDomain+strlen(asciiDomain)-1;
+			while(domain>=asciiDomain && numberDots<2)
+			{
+				if(*domain=='.') numberDots++;
+				domain--;
+			}
+			domain++;
+			if(*domain=='.') domain++;
+		}
+	}
+
+	/* Create copy for return value */
+	if(strlen(domain)>0) finalDomain=g_strdup(domain);
+		else finalDomain=NULL;
+
+	/* Free allocated resources */
+	g_free(asciiDomain);
+
+	/* Return domain */
+	return(finalDomain);
+}
+
+/* Get/set policy for javascript from site */
+gint nojs_get_policy(NoJS *self, const gchar *inDomain)
+{
+	g_return_val_if_fail(IS_NOJS(self), NOJS_POLICY_UNDETERMINED);
+	g_return_val_if_fail(inDomain, NOJS_POLICY_UNDETERMINED);
+
+	NoJSPrivate			*priv=self->priv;
+	sqlite3_stmt		*statement=NULL;
+	gint				error;
+	gint				policy=NOJS_POLICY_UNDETERMINED;
+
+	/* Check to allow all sites */
+	if(priv->allowAllSites) return(NOJS_POLICY_ACCEPT);
+
+	/* Check for open database */
+	g_return_val_if_fail(priv->database, policy);
+
+	/* Lookup policy for site in database */
+	error=sqlite3_prepare_v2(priv->database,
+								"SELECT site, value FROM policies WHERE site LIKE ? LIMIT 1;",
+								-1,
+								&statement,
+								NULL);
+	if(statement && error==SQLITE_OK) error=sqlite3_bind_text(statement, 1, inDomain, -1, NULL);
+	if(statement && error==SQLITE_OK)
+	{
+		if(sqlite3_step(statement)==SQLITE_ROW) policy=sqlite3_column_int(statement, 1);
+	}
+		else g_warning(_("SQL fails: %s"), sqlite3_errmsg(priv->database));
+
+	sqlite3_finalize(statement);
+
+	/* If we have not found a policy for the domain then it is an unknown domain.
+	 * Get default policy for unknown domains.
+	 */
+	if(policy==NOJS_POLICY_UNDETERMINED) policy=priv->unknownDomainPolicy;
+
+	return(policy);
+}
+
+void nojs_set_policy(NoJS *self, const gchar *inDomain, NoJSPolicy inPolicy)
+{
+	g_return_if_fail(IS_NOJS(self));
+	g_return_if_fail(inDomain);
+	g_return_if_fail(inPolicy>=NOJS_POLICY_ACCEPT && inPolicy<=NOJS_POLICY_BLOCK);
+
+	NoJSPrivate			*priv=self->priv;
+	gchar				*sql;
+	gchar				*error=NULL;
+	gint				success;
+
+	/* Check for open database */
+	g_return_if_fail(priv->database);
+
+	/* Update policy in database */
+	sql=sqlite3_mprintf("INSERT OR REPLACE INTO policies (site, value) VALUES ('%q', %d);",
+							inDomain,
+							inPolicy);
+	success=sqlite3_exec(priv->database, sql, NULL, NULL, &error);
+	if(success!=SQLITE_OK) g_warning(_("SQL fails: %s"), error);
+	if(error) sqlite3_free(error);
+	sqlite3_free(sql);
+
+	/* Emit signal to notify about policy change */
+	if(success==SQLITE_OK) g_signal_emit(self, NoJSSignals[POLICY_CHANGED], 0, inDomain);
+}
+
+/* Get/set default policy for unknown domains */
+NoJSPolicy nojs_get_policy_for_unknown_domain(NoJS *self)
+{
+	g_return_val_if_fail(IS_NOJS(self), NOJS_POLICY_UNDETERMINED);
+
+	return(self->priv->unknownDomainPolicy);
+}
+
+void nojs_set_policy_for_unknown_domain(NoJS *self, NoJSPolicy inPolicy)
+{
+	g_return_if_fail(IS_NOJS(self));
+	g_return_if_fail(inPolicy>=NOJS_POLICY_ACCEPT && inPolicy<=NOJS_POLICY_BLOCK);
+
+	if(self->priv->unknownDomainPolicy!=inPolicy)
+	{
+		self->priv->unknownDomainPolicy=inPolicy;
+		midori_extension_set_integer(self->priv->extension, "unknown-domain-policy", inPolicy);
+		g_object_notify_by_pspec(G_OBJECT(self), NoJSProperties[PROP_UNKNOWN_DOMAIN_POLICY]);
+	}
+}
+
+/* Get/set flag to allow javascript at all sites */
+gboolean nojs_get_allow_all_sites(NoJS *self)
+{
+	g_return_val_if_fail(IS_NOJS(self), TRUE);
+
+	return(self->priv->allowAllSites);
+}
+
+void nojs_set_allow_all_sites(NoJS *self, gboolean inAllow)
+{
+	g_return_if_fail(IS_NOJS(self));
+
+	if(self->priv->allowAllSites!=inAllow)
+	{
+		self->priv->allowAllSites=inAllow;
+		midori_extension_set_boolean(self->priv->extension, "allow-all-sites", inAllow);
+		g_object_notify_by_pspec(G_OBJECT(self), NoJSProperties[PROP_ALLOW_ALL_SITES]);
+	}
+}
+
+/* Get/set flag to check for second-level domains only */
+gboolean nojs_get_only_second_level_domain(NoJS *self)
+{
+	g_return_val_if_fail(IS_NOJS(self), TRUE);
+
+	return(self->priv->checkOnlySecondLevel);
+}
+
+void nojs_set_only_second_level_domain(NoJS *self, gboolean inOnlySecondLevel)
+{
+	g_return_if_fail(IS_NOJS(self));
+
+	if(self->priv->checkOnlySecondLevel!=inOnlySecondLevel)
+	{
+		self->priv->checkOnlySecondLevel=inOnlySecondLevel;
+		midori_extension_set_boolean(self->priv->extension, "only-second-level", inOnlySecondLevel);
+		g_object_notify_by_pspec(G_OBJECT(self), NoJSProperties[PROP_ONLY_SECOND_LEVEL]);
+	}
+}
+
+/************************************************************************************/
+
+/* Implementation: Enumeration */
+GType nojs_policy_get_type(void)
+{
+	static volatile gsize	g_define_type_id__volatile=0;
+
+	if(g_once_init_enter(&g_define_type_id__volatile))
+	{
+		static const GEnumValue values[]=
+		{
+			{ NOJS_POLICY_UNDETERMINED, "NOJS_POLICY_UNDETERMINED", N_("Undetermined") },
+			{ NOJS_POLICY_ACCEPT, "NOJS_POLICY_ACCEPT", N_("Accept") },
+			{ NOJS_POLICY_ACCEPT_TEMPORARILY, "NOJS_POLICY_ACCEPT_TEMPORARILY", N_("Accept temporarily") },
+			{ NOJS_POLICY_BLOCK, "NOJS_POLICY_BLOCK", N_("Block") },
+			{ 0, NULL, NULL }
+		};
+
+		GType	g_define_type_id=g_enum_register_static(g_intern_static_string("NoJSPolicy"), values);
+		g_once_init_leave(&g_define_type_id__volatile, g_define_type_id);
+	}
+
+	return(g_define_type_id__volatile);
+}
 
=== added file 'extensions/nojs/nojs.h'
--- extensions/nojs/nojs.h	1970-01-01 00:00:00 +0000
+++ extensions/nojs/nojs.h	2013-07-29 19:51:25 +0000
@@ -0,0 +1,89 @@
+/*
+ Copyright (C) 2013 Stephan Haller <[e-mail]>
+
+ 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.
+*/
+
+#ifndef __NOJS__
+#define __NOJS__
+
+#include "config.h"
+#include <midori/midori.h>
+
+#define NOJS_DATABASE	"nojs.db"
+
+G_BEGIN_DECLS
+
+/* NoJS manager enums */
+typedef enum
+{
+	NOJS_POLICY_UNDETERMINED,
+	NOJS_POLICY_ACCEPT,
+	NOJS_POLICY_ACCEPT_TEMPORARILY,
+	NOJS_POLICY_BLOCK
+} NoJSPolicy;
+
+/* NoJS manager object */
+#define TYPE_NOJS				(nojs_get_type())
+#define NOJS(obj)				(G_TYPE_CHECK_INSTANCE_CAST((obj), TYPE_NOJS, NoJS))
+#define IS_NOJS(obj)			(G_TYPE_CHECK_INSTANCE_TYPE((obj), TYPE_NOJS))
+#define NOJS_CLASS(klass)		(G_TYPE_CHECK_CLASS_CAST((klass), TYPE_NOJS, NoJSClass))
+#define IS_NOJS_CLASS(klass)	(G_TYPE_CHECK_CLASS_TYPE((klass), TYPE_NOJS))
+#define NOJS_GET_CLASS(obj)		(G_TYPE_INSTANCE_GET_CLASS((obj), TYPE_NOJS, NoJSClass))
+
+typedef struct _NoJS			NoJS;
+typedef struct _NoJSClass		NoJSClass;
+typedef struct _NoJSPrivate		NoJSPrivate;
+
+struct _NoJS
+{
+	/* Parent instance */
+	GObject			parent_instance;
+
+	/* Private structure */
+	NoJSPrivate		*priv;
+};
+
+struct _NoJSClass
+{
+	/* Parent class */
+	GObjectClass	parent_class;
+
+	/* Virtual functions */
+	void (*uri_load_policy_status)(NoJS *self, gchar *inURI, NoJSPolicy inPolicy);
+	void (*policy_changed)(NoJS *self, gchar *inDomain);
+};
+
+/* Public API */
+GType nojs_get_type(void);
+
+NoJS* nojs_new(MidoriExtension *inExtension, MidoriApp *inApp);
+
+gchar* nojs_get_domain(NoJS *self, SoupURI *inURI);
+
+gint nojs_get_policy(NoJS *self, const gchar *inDomain);
+void nojs_set_policy(NoJS *self, const gchar *inDomain, NoJSPolicy inPolicy);
+
+NoJSPolicy nojs_get_policy_for_unknown_domain(NoJS *self);
+void nojs_set_policy_for_unknown_domain(NoJS *self, NoJSPolicy inPolicy);
+
+gboolean nojs_get_allow_all_sites(NoJS *self);
+void nojs_set_allow_all_sites(NoJS *self, gboolean inAllow);
+
+gboolean nojs_get_only_second_level_domain(NoJS *self);
+void nojs_set_only_second_level_domain(NoJS *self, gboolean inOnlySecondLevel);
+
+gchar* nojs_get_icon_path (const gchar* icon);
+
+/* Enumeration */
+GType nojs_policy_get_type(void) G_GNUC_CONST;
+#define NOJS_TYPE_POLICY	(nojs_policy_get_type())
+
+G_END_DECLS
+
+#endif /* __NOJS__ */
 
=== modified file 'po/POTFILES.in'
--- po/POTFILES.in	2013-07-29 19:10:25 +0000
+++ po/POTFILES.in	2013-07-29 19:51:25 +0000
@@ -51,6 +51,9 @@
 extensions/formhistory/formhistory.c
 extensions/formhistory/formhistory-gdom-frontend.c
 extensions/history-list.vala
+extensions/nojs/nojs-preferences.c
+extensions/nojs/nojs-view.c
+extensions/nojs/nojs.c
 extensions/mouse-gestures.c
 extensions/shortcuts.c
 extensions/status-clock.c