/* "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
night_mode_function_realization (GtkWidget* botton,
MidoriBrowser* browser)
{
gtk_widget_destroy (night_mode_image);
if(!g_night_mode)
{
night_mode_image = gtk_image_new_from_file(midori_paths_get_res_filename("night_mode/19-2.png"));
gtk_container_add(GTK_CONTAINER(night_mode_button), night_mode_image);
gtk_widget_show(night_mode_image);
g_night_mode = true;
}
else
{
night_mode_image = gtk_image_new_from_file(midori_paths_get_res_filename("night_mode/19.png"));
gtk_container_add(GTK_CONTAINER(night_mode_button), night_mode_image);
gtk_widget_show(night_mode_image);
g_night_mode = false;
}
GList* children;
children = midori_browser_get_tabs (MIDORI_BROWSER (browser));
for (; children; children = g_list_next (children))
night_mode_extension_browser_add_tab_cb (browser, children->data, NULL);
g_list_free (children);
if(g_night_mode)
g_signal_connect (browser, "add-tab",G_CALLBACK (night_mode_extension_browser_add_tab_cb), NULL);
else
g_signal_handlers_disconnect_by_func (browser, night_mode_extension_browser_add_tab_cb, NULL);
}
/* "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]);
}
}
/* 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_deactivate_cb (MidoriExtension* extension,
MidoriBrowser* browser)
{
MidoriApp* app = midori_extension_get_app (extension);
FormHistoryPriv* priv = g_object_get_data (G_OBJECT (extension), "priv");
GtkActionGroup* action_group = midori_browser_get_action_group (browser);
GtkAction* action;
g_signal_handlers_disconnect_by_func (
browser, formhistory_add_tab_cb, extension);
g_signal_handlers_disconnect_by_func (
extension, formhistory_deactivate_cb, browser);
g_signal_handlers_disconnect_by_func (
app, formhistory_app_add_browser_cb, extension);
GList* tabs = midori_browser_get_tabs (browser);
for (; tabs; tabs = g_list_next (tabs))
formhistory_deactivate_tab (tabs->data, extension);
g_list_free (tabs);
g_object_set_data (G_OBJECT (browser), "FormHistoryExtension", NULL);
action = gtk_action_group_get_action (action_group, "FormHistoryToggleState");
if (action != NULL)
{
gtk_action_group_remove_action (action_group, action);
g_object_unref (action);
}
formhistory_private_destroy (priv);
}
static void
formhistory_app_add_browser_cb (MidoriApp* app,
MidoriBrowser* browser,
MidoriExtension* extension)
{
GtkAccelGroup* acg = gtk_accel_group_new ();
GtkActionGroup* action_group = midori_browser_get_action_group (browser);
GtkAction* action = gtk_action_new ("FormHistoryToggleState",
_("Toggle form history state"),
_("Activate or deactivate form history for the current tab."), NULL);
gtk_window_add_accel_group (GTK_WINDOW (browser), acg);
g_object_set_data (G_OBJECT (browser), "FormHistoryExtension", extension);
g_signal_connect (action, "activate",
G_CALLBACK (formhistory_toggle_state_cb), browser);
gtk_action_group_add_action_with_accel (action_group, action, "<Ctrl><Shift>F");
gtk_action_set_accel_group (action, acg);
gtk_action_connect_accelerator (action);
if (midori_extension_get_boolean (extension, "always-load"))
{
GList* tabs = midori_browser_get_tabs (browser);
for (; tabs; tabs = g_list_next (tabs))
formhistory_add_tab_cb (browser, tabs->data, extension);
g_list_free (tabs);
g_signal_connect (browser, "add-tab",
G_CALLBACK (formhistory_add_tab_cb), extension);
}
g_signal_connect (extension, "deactivate",
G_CALLBACK (formhistory_deactivate_cb), browser);
}
/* 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 browser window was added */
static void _cookie_permission_manager_on_add_browser(CookiePermissionManager *self,
MidoriBrowser *inBrowser,
gpointer inUserData)
{
GList *tabs, *iter;
/* Set up all current available tabs in browser */
tabs=midori_browser_get_tabs(inBrowser);
for(iter=tabs; iter; iter=g_list_next(iter))
{
_cookie_permission_manager_on_add_tab(self, iter->data, inBrowser);
}
g_list_free(tabs);
/* Listen to new tabs opened in browser and existing ones closed */
g_signal_connect_swapped(inBrowser, "add-tab", G_CALLBACK(_cookie_permission_manager_on_add_tab), self);
}
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);
}
}
static void
formhistory_preferences_response_cb (GtkWidget* dialog,
gint response_id,
MidoriExtension* extension)
{
GtkWidget* checkbox;
gboolean old_state;
gboolean new_state;
MidoriApp* app;
KatzeArray* browsers;
MidoriBrowser* browser;
if (response_id == GTK_RESPONSE_APPLY)
{
checkbox = g_object_get_data (G_OBJECT (dialog), "always-load-checkbox");
new_state = !gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (checkbox));
old_state = midori_extension_get_boolean (extension, "always-load");
if (old_state != new_state)
{
midori_extension_set_boolean (extension, "always-load", new_state);
app = midori_extension_get_app (extension);
browsers = katze_object_get_object (app, "browsers");
KATZE_ARRAY_FOREACH_ITEM (browser, browsers)
{
GList* tabs = midori_browser_get_tabs (browser);
for (; tabs; tabs = g_list_next (tabs))
formhistory_deactivate_tab (tabs->data, extension);
g_signal_handlers_disconnect_by_func (
browser, formhistory_add_tab_cb, extension);
if (new_state)
{
for (; tabs; tabs = g_list_next (tabs))
formhistory_add_tab_cb (browser, tabs->data, extension);
g_signal_connect (browser, "add-tab",
G_CALLBACK (formhistory_add_tab_cb), extension);
}
g_list_free (tabs);
}
/* 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]);
}
/* A browser window was added */
static void _interface_tweaks_on_add_browser(InterfaceTweaks *self, MidoriBrowser *inBrowser, gpointer inUserData)
{
g_return_if_fail(IS_INTERFACE_TWEAKS(self));
g_return_if_fail(MIDORI_IS_BROWSER(inBrowser));
InterfaceTweaksPrivate *priv=self->priv;
GtkNotebook *notebook;
GList *tabs, *iter;
InterfaceTweaksLocationbarLookup locationbar;
GtkEntryCompletion *completion;
guint keyPressSignalID;
gulong hookID;
/* Set up all current available tabs in browser */
tabs=midori_browser_get_tabs(inBrowser);
for(iter=tabs; iter; iter=g_list_next(iter))
{
_interface_tweaks_on_add_tab(self, iter->data, inBrowser);
}
g_list_free(tabs);
/* Listen to new tabs opened in browser */
g_signal_connect_swapped(inBrowser, "add-tab", G_CALLBACK(_interface_tweaks_on_add_tab), self);
notebook=NULL;
g_object_get(inBrowser, "notebook", ¬ebook, NULL);
if(notebook)
{
g_signal_connect_swapped(notebook, "page-added", G_CALLBACK(_interface_tweaks_on_tab_reordered), self);
g_signal_connect_swapped(notebook, "page-reordered", G_CALLBACK(_interface_tweaks_on_tab_reordered), self);
g_object_unref(notebook);
}
/* Listen to locationbar signals */
_interface_tweaks_find_browser_locationbar(inBrowser, &locationbar);
if(locationbar.widget)
{
/* Add completion to location entry and setup signals */
completion=gtk_entry_completion_new();
gtk_entry_completion_set_inline_completion(completion, TRUE);
gtk_entry_completion_set_inline_selection(completion, FALSE);
gtk_entry_completion_set_popup_completion(completion, FALSE);
gtk_entry_completion_set_model(completion, GTK_TREE_MODEL(priv->completionModel));
gtk_entry_completion_set_text_column(completion, 0);
gtk_entry_set_completion(GTK_ENTRY(locationbar.widget), completion);
g_signal_connect_swapped(completion, "insert-prefix", G_CALLBACK(_interface_tweaks_on_insert_prefix), self);
g_object_unref(completion);
/* Add emission handler to entry if it does not exist to ensure that
* our "key-press-event" handler gets called first
*/
hookID=GPOINTER_TO_SIZE(g_object_get_data(G_OBJECT(locationbar.widget), "interface-tweaks-hook-id"));
if(hookID==0)
{
keyPressSignalID=g_signal_lookup("key-press-event", GTK_TYPE_ENTRY);
hookID=g_signal_add_emission_hook(keyPressSignalID, 0, _interface_tweaks_on_key_press_event, locationbar.widget, NULL);
g_object_set_data(G_OBJECT(locationbar.widget), "interface-tweaks-hook-id", GSIZE_TO_POINTER(hookID)) ;
}
/* Add signal to recognize widget destruction to release emission hook */
g_signal_connect_swapped(locationbar.widget, "destroy", G_CALLBACK(_interface_tweaks_on_destroyed), self);
}
}
