static void
tab_panel_view_notify_icon_cb (GtkWidget* view,
GParamSpec* pspec,
MidoriExtension* extension)
{
MidoriBrowser* browser = midori_browser_get_for_widget (view);
gboolean minimized = katze_object_get_boolean (view, "minimized");
GdkPixbuf* icon = midori_view_get_icon (MIDORI_VIEW (view));
if (minimized)
{
GtkToolItem* toolitem = tab_panel_get_toolitem_for_view (view);
GtkWidget* image = gtk_tool_button_get_icon_widget (GTK_TOOL_BUTTON (toolitem));
gtk_image_set_from_pixbuf (GTK_IMAGE (image), icon);
}
else
{
GtkTreeModel* model = tab_panel_get_model_for_browser (browser);
GtkTreeIter iter;
GtkWidget* label = midori_view_get_proxy_tab_label (MIDORI_VIEW (view));
GtkStyle* style = gtk_widget_get_style (label);
if (tab_panel_get_iter_for_view (model, &iter, view))
gtk_tree_store_set (GTK_TREE_STORE (model), &iter,
3, icon,
6, &style->bg[GTK_STATE_NORMAL],
7, &style->fg[GTK_STATE_NORMAL],
-1);
}
}
static void
tab_panel_view_notify_title_cb (GtkWidget* view,
GParamSpec* pspec,
MidoriExtension* extension)
{
MidoriBrowser* browser = midori_browser_get_for_widget (view);
gboolean minimized = katze_object_get_boolean (view, "minimized");
const gchar* title = midori_view_get_display_title (MIDORI_VIEW (view));
if (minimized)
{
GtkToolItem* toolitem = tab_panel_get_toolitem_for_view (view);
gtk_tool_item_set_tooltip_text (toolitem, title);
}
else
{
GtkTreeModel* model = tab_panel_get_model_for_browser (browser);
GtkTreeIter iter;
if (tab_panel_get_iter_for_view (model, &iter, view))
{
gtk_tree_store_set (GTK_TREE_STORE (model), &iter,
4, title,
5, midori_view_get_label_ellipsize (MIDORI_VIEW (view)),
-1);
}
}
}
static void
tab_panel_browser_add_tab_cb (MidoriBrowser* browser,
GtkWidget* view,
MidoriExtension* extension)
{
GtkWidget* notebook = katze_object_get_object (browser, "notebook");
gint page = gtk_notebook_page_num (GTK_NOTEBOOK (notebook), view);
MidoriWebSettings* settings = midori_browser_get_settings (browser);
gboolean minimized = katze_object_get_boolean (view, "minimized");
GdkPixbuf* icon = midori_view_get_icon (MIDORI_VIEW (view));
const gchar* title = midori_view_get_display_title (MIDORI_VIEW (view));
GtkTreeModel* model = tab_panel_get_model_for_browser (browser);
if (minimized)
{
GtkWidget* toolbar = tab_panel_get_toolbar_for_browser (browser);
GtkWidget* image = gtk_image_new_from_pixbuf (
midori_view_get_icon (MIDORI_VIEW (view)));
GtkToolItem* toolitem = gtk_tool_button_new (image, NULL);
gtk_tool_item_set_tooltip_text (toolitem, title);
gtk_widget_show (image);
g_object_set_data (G_OBJECT (view), "tab-panel-ext-toolitem", toolitem);
gtk_widget_show (GTK_WIDGET (toolitem));
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, -1);
tab_panel_toggle_toolbook (toolbar);
g_signal_connect (toolitem, "clicked",
G_CALLBACK (tab_panel_toolitem_clicked_cb), view);
g_signal_connect (gtk_bin_get_child (GTK_BIN (toolitem)), "button-press-event",
G_CALLBACK (tab_panel_toolitem_button_press_event_cb), view);
}
else
{
GtkTreeIter iter;
gboolean buttons = katze_object_get_boolean (settings, "close-buttons-on-tabs");
gint ellipsize = midori_view_get_label_ellipsize (MIDORI_VIEW (view));
gtk_tree_store_insert_with_values (GTK_TREE_STORE (model),
&iter, NULL, page, 0, view, 1, GTK_STOCK_CLOSE, 2, buttons,
3, icon, 4, title, 5, ellipsize, 6, NULL, -1);
}
if (!g_signal_handler_find (view, G_SIGNAL_MATCH_FUNC,
g_signal_lookup ("notify", MIDORI_TYPE_VIEW), 0, NULL,
tab_panel_view_notify_minimized_cb, extension))
{
g_signal_connect (settings, "notify::close-buttons-on-tabs",
G_CALLBACK (tab_panel_settings_notify_cb), model);
g_signal_connect (view, "notify::minimized",
G_CALLBACK (tab_panel_view_notify_minimized_cb), extension);
g_signal_connect (view, "notify::icon",
G_CALLBACK (tab_panel_view_notify_icon_cb), extension);
g_signal_connect (view, "notify::title",
G_CALLBACK (tab_panel_view_notify_title_cb), extension);
}
g_object_unref (notebook);
}
/* Find position of first maximized tab of browser.
* Returns -1 if position could not determined.
*/
static gint _interface_tweak_get_browser_first_maximized_tab_position(MidoriBrowser *inBrowser, MidoriView *inIgnoreView)
{
g_return_val_if_fail(MIDORI_IS_BROWSER(inBrowser), -1);
g_return_val_if_fail(inIgnoreView==NULL || MIDORI_IS_VIEW(inIgnoreView), -1);
GList *tabs, *iter;
gint position, iterPosition;
/* Get list of browser tabs and return index of first maximized tab */
tabs=midori_browser_get_tabs(inBrowser);
position=iterPosition=-1;
for(iter=tabs; iter && position==-1; iter=iter->next)
{
MidoriView *view=MIDORI_VIEW(iter->data);
gboolean minimized;
iterPosition++;
if(view && view!=inIgnoreView)
{
minimized=FALSE;
g_object_get(view, "minimized", &minimized, NULL);
if(minimized==FALSE) position=iterPosition;
}
}
g_list_free(tabs);
return(position);
}
static void
formhistory_window_object_cleared_cb (WebKitWebView* web_view,
WebKitWebFrame* web_frame,
JSContextRef js_context,
JSObjectRef js_window,
MidoriExtension* extension)
{
const gchar* page_uri;
FormhistoryPasswordEntry* entry;
GtkWidget* view;
page_uri = webkit_web_frame_get_uri (web_frame);
if (!page_uri)
return;
if (!midori_uri_is_http (page_uri) && !g_str_has_prefix (page_uri, "file"))
return;
formhistory_setup_suggestions (web_view, js_context, extension);
entry = g_object_get_data (G_OBJECT (web_view), "FormHistoryPasswordEntry");
if (entry)
{
const gchar* message = _("Remember password on this page?");
view = midori_browser_get_current_tab (midori_app_get_browser (
midori_extension_get_app (extension)));
midori_view_add_info_bar (MIDORI_VIEW (view), GTK_MESSAGE_QUESTION, message,
G_CALLBACK (formhistory_remember_password_response), entry,
_("Remember"), GTK_RESPONSE_ACCEPT,
_("Not now"), GTK_RESPONSE_IGNORE,
_("Never for this page"), GTK_RESPONSE_CANCEL, NULL);
g_object_set_data (G_OBJECT (web_view), "FormHistoryPasswordEntry", NULL);
}
}
/* "group-minimized-tabs" has changed */
static void _interface_tweaks_on_group_minimized_tabs_changed(InterfaceTweaks *self, gboolean inValue)
{
g_return_if_fail(IS_INTERFACE_TWEAKS(self));
InterfaceTweaksPrivate *priv=self->priv;
GList *browsers, *browsersIter;
GList *tabs, *tabsIter;
MidoriBrowser *browser;
GtkNotebook *notebook;
MidoriView *view;
gboolean minimized;
/* If value changed set it and emit notification of property change */
if(priv->groupMinimizedTabs!=inValue || !priv->inited)
{
/* Change property */
priv->groupMinimizedTabs=inValue;
if(priv->inited) midori_extension_set_boolean(priv->extension, "group-minimized-tabs", priv->groupMinimizedTabs);
/* Move minimized tabs in all browsers to front if activated */
if(priv->groupMinimizedTabs)
{
browsers=midori_app_get_browsers(priv->application);
for(browsersIter=browsers; browsersIter; browsersIter=g_list_next(browsersIter))
{
browser=MIDORI_BROWSER(browsersIter->data);
if(browser)
{
notebook=NULL;
g_object_get(browser, "notebook", ¬ebook, NULL);
if(notebook)
{
tabs=midori_browser_get_tabs(MIDORI_BROWSER(browsersIter->data));
for(tabsIter=tabs; tabsIter; tabsIter=g_list_next(tabsIter))
{
view=MIDORI_VIEW(tabsIter->data);
if(view)
{
g_signal_handlers_block_by_func(view, G_CALLBACK(_interface_tweaks_on_notify_minimized_tab_for_group_tabs), self);
minimized=FALSE;
g_object_get(view, "minimized", &minimized, NULL);
if(minimized) gtk_notebook_reorder_child(GTK_NOTEBOOK(notebook), GTK_WIDGET(view), 0);
g_signal_handlers_unblock_by_func(view, G_CALLBACK(_interface_tweaks_on_notify_minimized_tab_for_group_tabs), self);
}
}
g_list_free(tabs);
g_object_unref(notebook);
}
}
}
g_list_free(browsers);
}
/* Notify about property change */
g_object_notify_by_pspec(G_OBJECT(self), InterfaceTweaksProperties[PROP_GROUP_MINIMIZED_TABS]);
}
}
static void
colorful_tabs_deactivate_cb (MidoriExtension* extension,
MidoriBrowser* browser)
{
guint i;
GtkWidget* view;
MidoriApp* app = midori_extension_get_app (extension);
g_signal_handlers_disconnect_by_func (
app, colorful_tabs_app_add_browser_cb, extension);
g_signal_handlers_disconnect_by_func (
browser, colorful_tabs_browser_add_tab_cb, extension);
g_signal_handlers_disconnect_by_func (
extension, colorful_tabs_deactivate_cb, browser);
i = 0;
while ((view = midori_browser_get_nth_tab (browser, i++)))
{
GtkWidget* label = midori_view_get_proxy_tab_label (MIDORI_VIEW (view));
gtk_event_box_set_visible_window (GTK_EVENT_BOX (label), FALSE);
gtk_widget_modify_bg (label, GTK_STATE_NORMAL, NULL);
gtk_widget_modify_bg (label, GTK_STATE_ACTIVE, NULL);
gtk_container_foreach (GTK_CONTAINER (gtk_bin_get_child (GTK_BIN (label))),
(GtkCallback) colorful_tabs_modify_fg,
NULL);
g_signal_handlers_disconnect_by_func (
view, colorful_tabs_view_notify_uri_cb, extension);
}
}
/* "hide-close-on-minimized-tabs" has changed */
static void _interface_tweaks_on_hide_close_on_minimized_tabs_changed(InterfaceTweaks *self, gboolean inValue)
{
g_return_if_fail(IS_INTERFACE_TWEAKS(self));
InterfaceTweaksPrivate *priv=self->priv;
GList *browsers, *browsersIter;
GList *tabs, *tabsIter;
/* If value changed set it and emit notification of property change */
if(priv->hideCloseOnMinimizedTabs!=inValue || !priv->inited)
{
/* Change property */
priv->hideCloseOnMinimizedTabs=inValue;
if(priv->inited) midori_extension_set_boolean(priv->extension, "hide-close-on-minimized-tabs", priv->hideCloseOnMinimizedTabs);
/* Apply new value to all tabs in all browsers */
browsers=midori_app_get_browsers(priv->application);
for(browsersIter=browsers; browsersIter; browsersIter=g_list_next(browsersIter))
{
tabs=midori_browser_get_tabs(MIDORI_BROWSER(browsersIter->data));
for(tabsIter=tabs; tabsIter; tabsIter=g_list_next(tabsIter))
{
_interface_tweaks_on_notify_minimized_tab_for_close_button(self, NULL, MIDORI_VIEW(tabsIter->data));
}
g_list_free(tabs);
}
g_list_free(browsers);
/* Notify about property change */
g_object_notify_by_pspec(G_OBJECT(self), InterfaceTweaksProperties[PROP_HIDE_CLOSE_ON_MINIMIZED_TABS]);
}
}
static void
read_mode_function_realization (GtkWidget* botton,MidoriBrowser* browser)
{
gchar* exception = NULL;
char *script=NULL;
FILE *fp;
unsigned int file_size;
gboolean result;
MidoriView* view = MIDORI_VIEW (midori_browser_get_current_tab (browser));
if((fp=fopen(midori_paths_get_res_filename("read_mode/readability.js"),"r"))!=NULL)
{
fseek(fp,0,SEEK_END);
file_size=ftell(fp);
fseek(fp,0,SEEK_SET);
script=(char *)malloc(file_size * sizeof(char)+1);
fread(script,file_size,sizeof(char),fp);
script[file_size*sizeof(char)]='\0';
fclose(fp);
}
char *insert_js = "(function(){readConvertLinksToFootnotes=false;readStyle='style-newspaper';readSize='size-medium';readMargin='margin-wide';})();";
result = midori_view_execute_script (view, insert_js, &exception);
result = midori_view_execute_script (view, script, &exception);
free(script);
script=NULL;
}
static gint
page_holder_notebook_append_view (GtkWidget* notebook)
{
GtkWidget* view;
MidoriBrowser* browser;
MidoriWebSettings *settings;
GtkWidget* label;
view = midori_view_new (NULL);
browser = midori_browser_get_for_widget (notebook);
settings = katze_object_get_object (browser, "settings");
midori_view_set_settings (MIDORI_VIEW (view), settings);
g_object_unref (settings);
gtk_widget_show (view);
label = midori_view_get_proxy_tab_label (MIDORI_VIEW (view));
return gtk_notebook_append_page (GTK_NOTEBOOK (notebook), view, label);
}
static void
night_mode_extension_browser_add_tab_cb (MidoriBrowser* browser,
GtkWidget* view,
MidoriExtension* extension)
{
night_mode_tabs_view_notify_uri_cb (MIDORI_VIEW (view), NULL, extension);
g_signal_connect (view, "notify::icon",
G_CALLBACK (night_mode_tabs_view_notify_uri_cb), extension);
}
static void
tab_panel_popup (GtkWidget* widget,
GdkEventButton* event,
GtkWidget* view)
{
GtkWidget* menu = midori_view_get_tab_menu (MIDORI_VIEW (view));
katze_widget_popup (widget, GTK_MENU (menu), event, KATZE_MENU_POSITION_CURSOR);
}
static void
statusbar_features_zoom_level_changed_cb (GtkWidget* combobox,
MidoriBrowser* browser)
{
MidoriView* view = MIDORI_VIEW (midori_browser_get_current_tab (browser));
GtkWidget* entry = gtk_bin_get_child (GTK_BIN (combobox));
const gchar* zoom_level_text = gtk_entry_get_text (GTK_ENTRY (entry));
gdouble zoom_level = g_ascii_strtod (zoom_level_text, NULL);
midori_view_set_zoom_level (view, zoom_level / 100.0);
}
static void
statusbar_features_browser_notify_tab_cb (MidoriBrowser* browser,
GParamSpec* pspec,
GtkWidget* combobox)
{
MidoriView* view = MIDORI_VIEW (midori_browser_get_current_tab (browser));
gchar* text;
if (view == NULL)
return;
text = g_strdup_printf ("%d%%", (gint)(midori_view_get_zoom_level (view) * 100));
gtk_entry_set_text (GTK_ENTRY (gtk_bin_get_child (GTK_BIN (combobox))), text);
g_free (text);
}
static void
page_holder_button_add_clicked_cb (GtkWidget* button,
GtkWidget* notebook)
{
gint n;
GtkWidget* view;
MidoriBrowser* browser;
const gchar* uri;
n = page_holder_notebook_append_view (notebook);
view = gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook), n);
browser = midori_browser_get_for_widget (notebook);
uri = midori_browser_get_current_uri (browser);
midori_view_set_uri (MIDORI_VIEW (view), uri);
}
/* A tab of a browser was reordered */
static void _interface_tweaks_on_tab_reordered(InterfaceTweaks *self,
GtkWidget *inChild,
guint inPageNumber,
gpointer inUserData)
{
g_return_if_fail(IS_INTERFACE_TWEAKS(self));
g_return_if_fail(MIDORI_IS_VIEW(inChild));
g_return_if_fail(GTK_IS_NOTEBOOK(inUserData));
InterfaceTweaksPrivate *priv=self->priv;
MidoriView *view=MIDORI_VIEW(inChild);
GtkNotebook *notebook=GTK_NOTEBOOK(inUserData);
MidoriBrowser *browser;
gboolean minimized;
gint firstMaximizedPosition;
/* Check if tab we should group minimized tabs to front */
if(!priv->groupMinimizedTabs) return;
/* Check if tab was minimized */
minimized=FALSE;
g_object_get(view, "minimized", &minimized, NULL);
/* Get browser of tab */
browser=midori_browser_get_for_widget(GTK_WIDGET(view));
if(!browser) return;
/* Find position of first maximized tab */
firstMaximizedPosition=_interface_tweak_get_browser_first_maximized_tab_position(browser, view);
/* If tab is maximized then it moves away from front and
* the position must be decreased by one to get the first maximized tab
*/
if(!minimized) firstMaximizedPosition--;
/* Reorder tab now */
if(firstMaximizedPosition<0) firstMaximizedPosition=0;
if((minimized==TRUE && inPageNumber>=firstMaximizedPosition) ||
(minimized==FALSE && inPageNumber<firstMaximizedPosition))
{
g_signal_handlers_block_by_func(view, G_CALLBACK(_interface_tweaks_on_notify_minimized_tab_for_group_tabs), self);
gtk_notebook_reorder_child(GTK_NOTEBOOK(notebook), GTK_WIDGET(view), firstMaximizedPosition);
g_signal_handlers_unblock_by_func(view, G_CALLBACK(_interface_tweaks_on_notify_minimized_tab_for_group_tabs), self);
}
}
/* Finalize this object */
static void cookie_permission_manager_finalize(GObject *inObject)
{
CookiePermissionManager *self=COOKIE_PERMISSION_MANAGER(inObject);
CookiePermissionManagerPrivate *priv=self->priv;
GList *browsers, *browser;
GList *tabs, *tab;
WebKitWebView *webkitView;
/* Dispose allocated resources */
if(priv->databaseFilename)
{
g_free(priv->databaseFilename);
priv->databaseFilename=NULL;
g_object_notify_by_pspec(inObject, CookiePermissionManagerProperties[PROP_DATABASE_FILENAME]);
}
if(priv->database)
{
sqlite3_close(priv->database);
priv->database=NULL;
g_object_notify_by_pspec(inObject, CookiePermissionManagerProperties[PROP_DATABASE]);
}
g_signal_handler_disconnect(priv->cookieJar, priv->cookieJarChangedID);
g_object_steal_data(G_OBJECT(priv->cookieJar), "cookie-permission-manager");
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);
tabs=midori_browser_get_tabs(MIDORI_BROWSER(browser->data));
for(tab=tabs; tab; tab=g_list_next(tab))
{
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);
/* Call parent's class finalize method */
G_OBJECT_CLASS(cookie_permission_manager_parent_class)->finalize(inObject);
}
/* A tab was minimized (pinned) or maximized (unpinned) - Check for grouping tabs */
static void _interface_tweaks_on_notify_minimized_tab_for_group_tabs(InterfaceTweaks *self, GParamSpec *inSpec, gpointer inUserData)
{
g_return_if_fail(IS_INTERFACE_TWEAKS(self));
g_return_if_fail(MIDORI_IS_VIEW(inUserData));
InterfaceTweaksPrivate *priv=self->priv;
MidoriView *view=MIDORI_VIEW(inUserData);
gboolean minimized;
MidoriBrowser *browser;
GtkContainer *notebook;
gint firstMaximizedPosition;
/* Check if tab was minimized */
minimized=FALSE;
g_object_get(view, "minimized", &minimized, NULL);
/* Check if tab we should group minimized tabs to front */
if(!priv->groupMinimizedTabs) return;
/* Get browser of tab */
browser=midori_browser_get_for_widget(GTK_WIDGET(view));
if(!browser) return;
/* Get notebook containing tabs of browser */
notebook=NULL;
g_object_get(browser, "notebook", ¬ebook, NULL);
if(!notebook) return;
/* Find position of first maximized tab */
firstMaximizedPosition=_interface_tweak_get_browser_first_maximized_tab_position(browser, view);
/* If tab is maximized then it moves away from front and
* the position must be decreased by one to get the first maximized tab
*/
if(!minimized) firstMaximizedPosition--;
/* Reorder tab now */
g_signal_handlers_block_by_func(view, G_CALLBACK(_interface_tweaks_on_notify_minimized_tab_for_group_tabs), self);
if(firstMaximizedPosition<0) firstMaximizedPosition=0;
gtk_notebook_reorder_child(GTK_NOTEBOOK(notebook), GTK_WIDGET(view), firstMaximizedPosition);
g_signal_handlers_unblock_by_func(view, G_CALLBACK(_interface_tweaks_on_notify_minimized_tab_for_group_tabs), self);
g_object_unref(notebook);
}
static void
night_mode_tabs_view_notify_uri_cb (MidoriView* view,
GParamSpec* pspec,
MidoriExtension* extension)
{
gchar* exception = NULL;
gchar *script=NULL;
FILE *fp;
int file_size;
gboolean result;
const gchar* uri = midori_view_get_display_uri (view);
if (!*uri)
return;
if (g_night_mode)
{
if (!midori_uri_is_blank (uri))
{
gchar* hostname = midori_uri_parse_hostname (uri, NULL);
if (hostname)
{
if((fp=fopen(midori_paths_get_res_filename("night_mode/nightingale_view_content.js"),"r"))!=NULL)
{
fseek(fp,0,SEEK_END);
file_size=ftell(fp);
fseek(fp,0,SEEK_SET);
script=(char *)malloc(file_size * sizeof(char)+1);
fread(script,file_size,sizeof(char),fp);
script[file_size*sizeof(char)]='\0';
fclose(fp);
result = midori_view_execute_script (view, script, &exception);
free(script);
script=NULL;
}
g_free (hostname);
}
}
}
else
{
GtkWidget* current_web_view = midori_view_get_web_view (MIDORI_VIEW (view));
webkit_web_view_run_javascript(WEBKIT_WEB_VIEW (current_web_view), night_mode_remove, NULL, NULL, NULL);
}
}
static void
night_mode_deactivated_cb (MidoriExtension* extension,
MidoriBrowser* browser)
{
if(night_mode_button)
gtk_widget_destroy (night_mode_button);
g_signal_handlers_disconnect_by_func (extension, night_mode_deactivated_cb, browser);
if(g_night_mode)
{
GList* children = midori_browser_get_tabs (MIDORI_BROWSER (browser));
for (; children; children = g_list_next (children))
{
GtkWidget* current_web_view = midori_view_get_web_view (MIDORI_VIEW (children->data));
webkit_web_view_run_javascript(WEBKIT_WEB_VIEW (current_web_view), night_mode_remove, NULL, NULL, NULL);
}
g_list_free (children);
g_signal_handlers_disconnect_by_func (browser, night_mode_extension_browser_add_tab_cb, NULL);
}
}
/* A tab was minimized (pinned) or maximized (unpinned) - Check for hiding close button */
static void _interface_tweaks_on_notify_minimized_tab_for_close_button(InterfaceTweaks *self, GParamSpec *inSpec, gpointer inUserData)
{
g_return_if_fail(IS_INTERFACE_TWEAKS(self));
g_return_if_fail(MIDORI_IS_VIEW(inUserData));
InterfaceTweaksPrivate *priv=self->priv;
MidoriView *view=MIDORI_VIEW(inUserData);
gboolean minimized;
MidoriSettings *settings;
gboolean hasCloseButton;
GtkWidget *closeButton;
/* Check if tab was minimized */
minimized=FALSE;
g_object_get(view, "minimized", &minimized, NULL);
/* Get Midori settings */
if(!priv->application) return;
settings=NULL;
g_object_get(priv->application, "settings", &settings, NULL);
if(!settings) return;
/* Only hide close button if tabs have close buttons */
hasCloseButton=FALSE;
g_object_get(settings, "close-buttons-on-tabs", &hasCloseButton, NULL);
if(hasCloseButton)
{
/* Find close button and show or hide it */
closeButton=_interface_tweaks_find_view_close_button(view);
if(closeButton)
{
/* Check if we should hide close button on minimized tab */
if(minimized && priv->hideCloseOnMinimizedTabs) gtk_widget_hide(closeButton);
else gtk_widget_show(closeButton);
}
}
g_object_unref(settings);
}
static void
colorful_tabs_browser_foreach_cb (GtkWidget* view,
MidoriExtension* extension)
{
colorful_tabs_view_notify_uri_cb (MIDORI_VIEW (view), NULL, extension);
}
/* Application property has changed */
static void _interface_tweaks_on_application_changed(InterfaceTweaks *self, MidoriApp *inApplication)
{
g_return_if_fail(IS_INTERFACE_TWEAKS(self));
g_return_if_fail(inApplication==NULL || MIDORI_IS_APP(inApplication));
InterfaceTweaksPrivate *priv=INTERFACE_TWEAKS(self)->priv;
GtkNotebook *notebook;
MidoriBrowser *browser;
GList *browsers, *browsersIter;
GList *tabs, *tabsIter;
WebKitWebView *webkitView;
InterfaceTweaksLocationbarLookup locationbar;
/* Release resources on current application object */
if(priv->application)
{
g_signal_handlers_disconnect_by_data(priv->application, self);
browsers=midori_app_get_browsers(priv->application);
for(browsersIter=browsers; browsersIter; browsersIter=g_list_next(browsersIter))
{
browser=MIDORI_BROWSER(browsersIter->data);
g_signal_handlers_disconnect_by_data(browser, self);
tabs=midori_browser_get_tabs(MIDORI_BROWSER(browsersIter->data));
for(tabsIter=tabs; tabsIter; tabsIter=g_list_next(tabsIter))
{
g_signal_handlers_disconnect_by_data(tabsIter->data, self);
webkitView=WEBKIT_WEB_VIEW(midori_view_get_web_view(MIDORI_VIEW(tabsIter->data)));
g_signal_handlers_disconnect_by_data(webkitView, self);
}
g_list_free(tabs);
notebook=NULL;
g_object_get(browser, "notebook", ¬ebook, NULL);
if(notebook)
{
g_signal_handlers_disconnect_by_data(notebook, self);
g_object_unref(notebook);
}
_interface_tweaks_find_browser_locationbar(browser, &locationbar);
if(locationbar.widget)
{
GtkEntry *entry=GTK_ENTRY(locationbar.widget);
GtkEntryCompletion *completion;
gulong hookID;
guint keyPressSignalID;
g_signal_handlers_disconnect_by_data(entry, self);
completion=gtk_entry_get_completion(GTK_ENTRY(entry));
if(completion)
{
g_signal_handlers_disconnect_by_data(completion, self);
gtk_entry_set_completion(entry, NULL);
}
hookID=GPOINTER_TO_SIZE(g_object_get_data(G_OBJECT(entry), "interface-tweaks-hook-id"));
if(hookID!=0)
{
keyPressSignalID=g_signal_lookup("key-press-event", GTK_TYPE_ENTRY);
g_signal_remove_emission_hook(keyPressSignalID, hookID);
hookID=0L;
g_object_set_data(G_OBJECT(entry), "interface-tweaks-hook-id", GSIZE_TO_POINTER(hookID));
}
}
}
g_list_free(browsers);
g_object_unref(priv->application);
priv->application=NULL;
}
/* Set new application object */
if(!inApplication) return;
priv->application=g_object_ref(inApplication);
/* Set up all current open browser windows */
browsers=midori_app_get_browsers(priv->application);
for(browsersIter=browsers; browsersIter; browsersIter=g_list_next(browsersIter))
{
_interface_tweaks_on_add_browser(self, MIDORI_BROWSER(browsersIter->data), priv->application);
}
g_list_free(browsers);
/* Listen to new browser windows opened */
g_signal_connect_swapped(priv->application, "add-browser", G_CALLBACK(_interface_tweaks_on_add_browser), self);
/* Notify about property change */
g_object_notify_by_pspec(G_OBJECT(self), InterfaceTweaksProperties[PROP_APPLICATION]);
}
/* We received the HTTP headers of the request and it contains cookie-managing headers */
static void _cookie_permission_manager_on_response_received(WebKitWebView *inView,
WebKitWebFrame *inFrame,
WebKitWebResource *inResource,
WebKitNetworkResponse *inResponse,
gpointer inUserData)
{
g_return_if_fail(IS_COOKIE_PERMISSION_MANAGER(inUserData));
CookiePermissionManager *self=COOKIE_PERMISSION_MANAGER(inUserData);
CookiePermissionManagerPrivate *priv=self->priv;
GSList *newCookies, *cookie;
GSList *unknownCookies=NULL, *acceptedCookies=NULL;
SoupURI *firstParty;
SoupCookieJarAcceptPolicy cookiePolicy;
gint unknownCookiesPolicy;
SoupMessage *message;
/* If policy is to deny all cookies return immediately */
cookiePolicy=soup_cookie_jar_get_accept_policy(priv->cookieJar);
if(cookiePolicy==SOUP_COOKIE_JAR_ACCEPT_NEVER) return;
/* Get SoupMessage */
message=webkit_network_response_get_message(inResponse);
if(!message || !SOUP_IS_MESSAGE(message)) return;
/* Iterate through cookies in response and check if they should be
* blocked (remove from cookies list) or accepted (added to cookie jar).
* If we could not determine what to do collect these cookies and
* ask user
*/
newCookies=soup_cookies_from_response(message);
firstParty=soup_message_get_first_party(message);
for(cookie=newCookies; cookie; cookie=cookie->next)
{
switch(_cookie_permission_manager_get_policy(self, cookie->data))
{
case COOKIE_PERMISSION_MANAGER_POLICY_BLOCK:
soup_cookie_free(cookie->data);
break;
case COOKIE_PERMISSION_MANAGER_POLICY_ACCEPT:
case COOKIE_PERMISSION_MANAGER_POLICY_ACCEPT_FOR_SESSION:
if((cookiePolicy==SOUP_COOKIE_JAR_ACCEPT_NO_THIRD_PARTY &&
firstParty!=NULL &&
firstParty->host &&
soup_cookie_domain_matches(cookie->data, firstParty->host)) ||
cookiePolicy==SOUP_COOKIE_JAR_ACCEPT_ALWAYS)
{
acceptedCookies=g_slist_prepend(acceptedCookies, cookie->data);
}
else soup_cookie_free(cookie->data);
break;
case COOKIE_PERMISSION_MANAGER_POLICY_UNDETERMINED:
default:
if((cookiePolicy==SOUP_COOKIE_JAR_ACCEPT_NO_THIRD_PARTY &&
firstParty!=NULL &&
firstParty->host &&
soup_cookie_domain_matches(cookie->data, firstParty->host)) ||
cookiePolicy==SOUP_COOKIE_JAR_ACCEPT_ALWAYS)
{
unknownCookies=g_slist_prepend(unknownCookies, cookie->data);
}
else soup_cookie_free(cookie->data);
break;
}
}
/* Prepending an item to list is the fastest method but the order of cookies
* is reversed now and may be added to cookie jar in the wrong order. So we
* need to reverse list now of both - undetermined and accepted cookies
*/
unknownCookies=g_slist_reverse(unknownCookies);
acceptedCookies=g_slist_reverse(acceptedCookies);
/* Ask user for his decision what to do with cookies whose policy is undetermined
* But only ask if there is any undetermined one
*/
if(g_slist_length(unknownCookies)>0)
{
/* Get view */
MidoriView *view;
view=MIDORI_VIEW(g_object_get_data(G_OBJECT(inView), "midori-view"));
/* Ask for user's decision */
unknownCookiesPolicy=_cookie_permission_manager_ask_for_policy(self, view, message, unknownCookies);
if(unknownCookiesPolicy==COOKIE_PERMISSION_MANAGER_POLICY_ACCEPT ||
unknownCookiesPolicy==COOKIE_PERMISSION_MANAGER_POLICY_ACCEPT_FOR_SESSION)
{
/* Add accepted undetermined cookies to cookie jar */
for(cookie=unknownCookies; cookie; cookie=cookie->next)
{
soup_cookie_jar_add_cookie(priv->cookieJar, (SoupCookie*)cookie->data);
}
}
else
{
/* Free cookies because they should be blocked */
for(cookie=unknownCookies; cookie; cookie=cookie->next)
{
soup_cookie_free((SoupCookie*)cookie->data);
}
}
}
/* Add accepted cookies to cookie jar */
for(cookie=acceptedCookies; cookie; cookie=cookie->next)
{
soup_cookie_jar_add_cookie(priv->cookieJar, (SoupCookie*)cookie->data);
}
/* Free list of cookies */
g_slist_free(unknownCookies);
g_slist_free(acceptedCookies);
g_slist_free(newCookies);
}
