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

[Cris Dywan]

Introduce NoJS extension managing Javascript execution

Introduce NoJS extension managing Javascript execution

[gue5t gue5t (gue5t)]

This is a really important addition to the browser and I'm super excited to have this added. That said, it's a lot of code and so there are a lot of tiny issues which could be addressed:

Icons - it would be nice to use stock items/named icons (providing a fallback image) so that themes and users can override and theme the icons. This could be done after merging the extension.

main.c:38: the "/* Preferences of this extension should be opened */" comment above _nojs_on_preferences_response seems to go with the next function.

nojs.c:96: it looks like _nojs_closure_VOID__STRING_ENUM is a generated function by glib-genmarshal. It would be nice to do this at build-time rather than embedding generated code directly, so it's easier to change later. This isn't a critical change for now.

nojs.c:177: it seems this would leak priv->databaseFilename.

nojs.c:209: typo, "extenstion"

I'm not really qualified to comment on the SQLite calls, but nothing sticks out as wrong. However, I'm curious about nojs.c:255 and nojs.c:270. Is line 268 guaranteed to set error to NULL if no error occurs? If not, line 270 could be a double-free. It's probably clearer to set error to NULL by hand anyway after freeing the error on line 255.

nojs.c:786: I've run into this webkit behavior as well, and it really sucks. Your workaround seems as good as any. :)

nojs.c:905: I don't think soup_uri_get_host will return "", but if it does, this will read from domain[-1]. In any event, the loop here would be more clear if you used strrchr instead. Regardless, a comment to say exactly what all the looping and char-comparisons are intended to do would be good.

nojs.c:1035: typo, "domanins"

nojs-preferences.c:95: this should probably be a const gchar*, since the function neither owns its memory nor modifies its contents; this better matches the return type of sqlite3_column_text.

nojs-preferences.c:161: "extenstion" again

nojs-preferences.c:177: no need for explicit return.

nojs-preferences.c:185: typo, "toogle". Same on 207 and 223, 245, 261, 281,

nojs-preferences.c:326: it seems like doing one-item delete queries in a for loop is probably not the most efficient way to interface with the db here, but for now this is fine. An XXX or TODO comment might be worth adding.

nojs-preferences.c:373: "cookie" should be "script" or "JS". This is duplicated in a variety of places in the file.

nojs-preferences.c:607: "#ifdef GTK__3_0_VERSION" should be "#if GTK_CHECK_VERSION(3, 0, 0)". Same for other references to "GTK__3_0_VERSION".

nojs-preferences.c:630: g_strdup_printf is called with a format-string argument derived from translations without any arguments to format. The strdup/free pair can be completely removed here.

nojs-view.c:93: it might be better to use G_STRFUNC here instead of __func__. I'm not sure of the exact reason, but I would expect the former is safer w/r/t portability. Maybe this print should be hidden behind a debugging environment variable as well. Not a blocking concern.

nojs-view.c:292: typos, "seperator" and "seperate"

nojs-view.c:548: typo, "ourselve"

Throughout the code: Generally we don't require extensions to conform to the Midori coding styl...

review: Needs Fixing

=== 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-05-22 23:07:26 +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-05-22 23:07:26 +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-menu-accept.png'
Binary files extensions/nojs/nojs-menu-accept.png	1970-01-01 00:00:00 +0000 and extensions/nojs/nojs-menu-accept.png	2013-05-22 23:07:26 +0000 differ
=== added file 'extensions/nojs/nojs-menu-deny.png'
Binary files extensions/nojs/nojs-menu-deny.png	1970-01-01 00:00:00 +0000 and extensions/nojs/nojs-menu-deny.png	2013-05-22 23:07:26 +0000 differ
=== added file 'extensions/nojs/nojs-menu-temporary.png'
Binary files extensions/nojs/nojs-menu-temporary.png	1970-01-01 00:00:00 +0000 and extensions/nojs/nojs-menu-temporary.png	2013-05-22 23:07:26 +0000 differ
=== 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-05-22 23:07:26 +0000
@@ -0,0 +1,748 @@
+/*
+ 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 extenstion: %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 toogle 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 toogle 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 toogle 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 toogle 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 toogle 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 toogle 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 cookie permissions?"));
+
+	gtk_window_set_title(GTK_WINDOW(dialog), _("Delete all cookie 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 cookie 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 cookie 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						*text;
+	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));
+#ifdef GTK__3_0_VERSION
+	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);
+	text=g_strdup_printf(_("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_markup(GTK_LABEL(widget), text);
+	g_free(text);
+	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));
+
+#ifndef GTK__3_0_VERSION
+	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);
+#ifdef GTK__3_0_VERSION
+	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 cookie domain list management buttons */
+#ifdef GTK__3_0_VERSION
+	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-05-22 23:07:26 +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-statusicon-allowed.png'
Binary files extensions/nojs/nojs-statusicon-allowed.png	1970-01-01 00:00:00 +0000 and extensions/nojs/nojs-statusicon-allowed.png	2013-05-22 23:07:26 +0000 differ
=== added file 'extensions/nojs/nojs-statusicon-denied.png'
Binary files extensions/nojs/nojs-statusicon-denied.png	1970-01-01 00:00:00 +0000 and extensions/nojs/nojs-statusicon-denied.png	2013-05-22 23:07:26 +0000 differ
=== added file 'extensions/nojs/nojs-statusicon-mixed.png'
Binary files extensions/nojs/nojs-statusicon-mixed.png	1970-01-01 00:00:00 +0000 and extensions/nojs/nojs-statusicon-mixed.png	2013-05-22 23:07:26 +0000 differ
=== 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-05-22 23:07:26 +0000
@@ -0,0 +1,823 @@
+/*
+ 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;
+	gchar				*itemImageFile;
+	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);
+#ifdef ALTERNATE_DATADIR
+	itemImageFile=g_build_filename(ALTERNATE_DATADIR, "nojs-menu-deny.png", NULL);
+#else
+	itemImageFile=g_build_filename(MDATADIR, PACKAGE_NAME, "nojs", "nojs-menu-deny.png", NULL);
+#endif
+	itemImage=gtk_image_new_from_file(itemImageFile);
+	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);
+	g_free(itemImageFile);
+
+	itemLabel=g_strdup_printf(_("Allow %s"), inDomain);
+	item=gtk_image_menu_item_new_with_label(itemLabel);
+#ifdef ALTERNATE_DATADIR
+	itemImageFile=g_build_filename(ALTERNATE_DATADIR, "nojs-menu-accept.png", NULL);
+#else
+	itemImageFile=g_build_filename(MDATADIR, PACKAGE_NAME, "nojs", "nojs-menu-accept.png", NULL);
+#endif
+	itemImage=gtk_image_new_from_file(itemImageFile);
+	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);
+	g_free(itemImageFile);
+
+	itemLabel=g_strdup_printf(_("Allow %s this session"), inDomain);
+	item=gtk_image_menu_item_new_with_label(itemLabel);
+#ifdef ALTERNATE_DATADIR
+	itemImageFile=g_build_filename(ALTERNATE_DATADIR, "nojs-menu-temporary.png", NULL);
+#else
+	itemImageFile=g_build_filename(MDATADIR, PACKAGE_NAME, "nojs", "nojs-menu-temporary.png", NULL);
+#endif
+	itemImage=gtk_image_new_from_file(itemImageFile);
+	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);
+	g_free(itemImageFile);
+
+	/* 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_POLICY_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-05-22 23:07:26 +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-05-22 23:07:26 +0000
@@ -0,0 +1,1078 @@
+/*
+ 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 extenstion: %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());
+}
+
+/* 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)
+	{
+#ifdef ALTERNATE_DATADIR
+		case NOJS_MENU_ICON_STATE_ALLOWED:
+			imageFilename=g_build_filename(ALTERNATE_DATADIR, "nojs-statusicon-allowed.png", NULL);
+			break;
+
+		case NOJS_MENU_ICON_STATE_MIXED:
+			imageFilename=g_build_filename(ALTERNATE_DATADIR, "nojs-statusicon-mixed.png", NULL);
+			break;
+
+		case NOJS_MENU_ICON_STATE_DENIED:
+		case NOJS_MENU_ICON_STATE_UNDETERMINED:
+			imageFilename=g_build_filename(ALTERNATE_DATADIR, "nojs-statusicon-denied.png", NULL);
+			break;
+#else
+		case NOJS_MENU_ICON_STATE_ALLOWED:
+			imageFilename=g_build_filename(MDATADIR, PACKAGE_NAME, "nojs", "nojs-statusicon-allowed.png", NULL);
+			break;
+
+		case NOJS_MENU_ICON_STATE_MIXED:
+			imageFilename=g_build_filename(MDATADIR, PACKAGE_NAME, "nojs", "nojs-statusicon-mixed.png", NULL);
+			break;
+
+		case NOJS_MENU_ICON_STATE_DENIED:
+		case NOJS_MENU_ICON_STATE_UNDETERMINED:
+			imageFilename=g_build_filename(MDATADIR, PACKAGE_NAME, "nojs", "nojs-statusicon-denied.png", NULL);
+			break;
+#endif
+	}
+
+	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 domanins 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-05-22 23:07:26 +0000
@@ -0,0 +1,87 @@
+/*
+ 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);
+
+/* Enumeration */
+GType nojs_policy_get_type(void) G_GNUC_CONST;
+#define NOJS_TYPE_POLICY	(nojs_policy_get_type())
+
+G_END_DECLS
+
+#endif /* __NOJS__ */