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); }