/**
* HTML renderer init method
*/
static void
liferea_webkit_init (void)
{
gboolean disable_javascript, enable_plugins;
gchar *font;
guint fontSize;
g_assert (!settings);
settings = webkit_web_settings_new ();
font = webkit_get_font (&fontSize);
if (font) {
g_object_set (
settings,
"default-font-family",
font,
NULL
);
g_object_set (
settings,
"default-font-size",
fontSize,
NULL
);
g_free (font);
}
g_object_set (
settings,
"minimum-font-size",
7,
NULL
);
conf_get_bool_value (DISABLE_JAVASCRIPT, &disable_javascript);
g_object_set (
settings,
"enable-scripts",
!disable_javascript,
NULL
);
conf_get_bool_value (ENABLE_PLUGINS, &enable_plugins);
g_object_set (
settings,
"enable-plugins",
enable_plugins,
NULL
);
conf_signal_connect (
"changed::" DISABLE_JAVASCRIPT,
G_CALLBACK (liferea_webkit_disable_javascript_cb),
NULL
);
conf_signal_connect (
"changed::" ENABLE_PLUGINS,
G_CALLBACK (liferea_webkit_enable_plugins_cb),
NULL
);
}
/**
* HTML plugin init method
*/
static void
liferea_webkit_init (void)
{
gboolean disable_javascript, enable_plugins;
GConfClient *client;
g_assert (!settings);
settings = webkit_web_settings_new ();
g_object_set (
settings,
"default-font-size",
11,
NULL
);
g_object_set (
settings,
"minimum-font-size",
7,
NULL
);
conf_get_bool_value (DISABLE_JAVASCRIPT, &disable_javascript);
g_object_set (
settings,
"enable-scripts",
!disable_javascript,
NULL
);
conf_get_bool_value (ENABLE_PLUGINS, &enable_plugins);
g_object_set (
settings,
"enable-plugins",
enable_plugins,
NULL
);
client = gconf_client_get_default ();
gconf_client_notify_add (
client,
DISABLE_JAVASCRIPT,
liferea_webkit_disable_javascript_cb,
NULL, NULL, NULL
);
gconf_client_notify_add (
client,
ENABLE_PLUGINS,
liferea_webkit_enable_plugins_cb,
NULL, NULL, NULL
);
g_object_unref (client);
}
/**
* To be called whenever a node was selected and should
* replace the current itemlist.
*/
void
itemlist_load (nodePtr node)
{
itemSetPtr itemSet;
gint folder_display_mode;
gboolean folder_display_hide_read;
debug_enter ("itemlist_load");
g_return_if_fail (NULL != node);
debug1 (DEBUG_GUI, "loading item list with node \"%s\"", node_get_title (node));
g_assert (!itemlist->priv->guids);
g_assert (!itemlist->priv->filter);
/* 1. Filter check. Don't continue if folder is selected and
no folder viewing is configured. If folder viewing is enabled
set up a "unread items only" rule depending on the prefences. */
/* for folders and other heirarchic nodes do filtering */
if (IS_FOLDER (node) || node->children) {
liferea_shell_update_allitems_actions (FALSE, 0 != node->unreadCount);
conf_get_int_value (FOLDER_DISPLAY_MODE, &folder_display_mode);
if (!folder_display_mode)
return;
conf_get_bool_value (FOLDER_DISPLAY_HIDE_READ, &folder_display_hide_read);
if (folder_display_hide_read) {
itemlist->priv->filter = g_new0(struct itemSet, 1);
itemlist->priv->filter->anyMatch = TRUE;
itemset_add_rule (itemlist->priv->filter, "unread", "", TRUE);
}
} else {
void
liferea_shell_update_toolbar (void)
{
gboolean disable_toolbar;
conf_get_bool_value (DISABLE_TOOLBAR, &disable_toolbar);
if (disable_toolbar)
gtk_widget_hide (shell->priv->toolbar);
else
gtk_widget_show (shell->priv->toolbar);
}
static void
liferea_shell_save_position (void)
{
GtkWidget *pane;
gint x, y, w, h;
gboolean last_window_maximized;
/* save pane proportions */
pane = liferea_shell_lookup ("leftpane");
if (pane) {
x = gtk_paned_get_position (GTK_PANED (pane));
conf_set_int_value (LAST_VPANE_POS, x);
}
pane = liferea_shell_lookup ("normalViewPane");
if (pane) {
y = gtk_paned_get_position (GTK_PANED (pane));
conf_set_int_value (LAST_HPANE_POS, y);
}
pane = liferea_shell_lookup ("wideViewPane");
if (pane) {
y = gtk_paned_get_position (GTK_PANED (pane));
conf_set_int_value (LAST_WPANE_POS, y);
}
/* The following needs to be skipped when the window is not visible */
if (!gtk_widget_get_visible (GTK_WIDGET (shell->priv->window)))
return;
conf_get_bool_value (LAST_WINDOW_MAXIMIZED, &last_window_maximized);
if (last_window_maximized)
return;
gtk_window_get_position (shell->priv->window, &x, &y);
gtk_window_get_size (shell->priv->window, &w, &h);
if (x+w<0 || y+h<0 ||
x > gdk_screen_width () ||
y > gdk_screen_height ())
return;
debug4 (DEBUG_GUI, "Saving window size and position: %dx%d %d:%d", w, h, x, y);
/* save window position */
conf_set_int_value (LAST_WINDOW_X, x);
conf_set_int_value (LAST_WINDOW_Y, y);
/* save window size */
conf_set_int_value (LAST_WINDOW_WIDTH, w);
conf_set_int_value (LAST_WINDOW_HEIGHT, h);
}
static void
conf_proxy_reset_settings_cb (GSettings *settings,
guint cnxn_id,
gchar *key,
gpointer user_data)
{
gchar *proxyname, *proxyusername, *proxypassword;
gint proxyport;
gint proxydetectmode;
gboolean proxyuseauth;
proxyname = NULL;
proxyport = 0;
proxyusername = NULL;
proxypassword = NULL;
conf_get_int_value (PROXY_DETECT_MODE, &proxydetectmode);
switch (proxydetectmode) {
default:
case 0:
debug0 (DEBUG_CONF, "proxy auto detect is configured");
/* nothing to do, all done by libproxy inside libsoup */
break;
case 1:
debug0 (DEBUG_CONF, "proxy is disabled by user");
/* nothing to do */
break;
case 2:
debug0 (DEBUG_CONF, "manual proxy is configured");
conf_get_str_value (PROXY_HOST, &proxyname);
conf_get_int_value (PROXY_PORT, &proxyport);
conf_get_bool_value (PROXY_USEAUTH, &proxyuseauth);
if (proxyuseauth) {
conf_get_str_value (PROXY_USER, &proxyusername);
conf_get_str_value (PROXY_PASSWD, &proxypassword);
}
break;
}
debug4 (DEBUG_CONF, "Manual proxy settings are now %s:%d %s:%s", proxyname != NULL ? proxyname : "NULL", proxyport,
proxyusername != NULL ? proxyusername : "******",
proxypassword != NULL ? proxypassword : "******");
network_set_proxy (proxydetectmode, proxyname, proxyport, proxyusername, proxypassword);
}
/*
* Restore the window position from the values saved into gconf. Note
* that this does not display/present/show the mainwindow.
*/
static void
liferea_shell_restore_position (void)
{
/* load window position */
int x, y, w, h;
gboolean last_window_maximized;
conf_get_int_value (LAST_WINDOW_X, &x);
conf_get_int_value (LAST_WINDOW_Y, &y);
conf_get_int_value (LAST_WINDOW_WIDTH, &w);
conf_get_int_value (LAST_WINDOW_HEIGHT, &h);
debug4 (DEBUG_GUI, "Retrieved saved setting: size %dx%d position %d:%d", w, h, x, y);
/* Restore position only if the width and height were saved */
if (w != 0 && h != 0) {
if (x >= gdk_screen_width ())
x = gdk_screen_width () - 100;
else if (x + w < 0)
x = 100;
if (y >= gdk_screen_height ())
y = gdk_screen_height () - 100;
else if (y + w < 0)
y = 100;
debug4 (DEBUG_GUI, "Restoring to size %dx%d position %d:%d", w, h, x, y);
gtk_window_move (GTK_WINDOW (shell->priv->window), x, y);
/* load window size */
gtk_window_resize (GTK_WINDOW (shell->priv->window), w, h);
}
conf_get_bool_value (LAST_WINDOW_MAXIMIZED, &last_window_maximized);
if (last_window_maximized)
gtk_window_maximize (GTK_WINDOW (shell->priv->window));
else
gtk_window_unmaximize (GTK_WINDOW (shell->priv->window));
}
void
on_action_mark_all_read (GSimpleAction *action, GVariant *parameter, gpointer user_data)
{
nodePtr feedlist;
gboolean confirm_mark_read;
gboolean do_mark_read = TRUE;
if (!g_strcmp0 (g_action_get_name (G_ACTION (action)), "mark-all-feeds-read"))
feedlist = feedlist_get_root ();
else if (user_data)
feedlist = (nodePtr) user_data;
else
feedlist = feedlist_get_selected ();
conf_get_bool_value (CONFIRM_MARK_ALL_READ, &confirm_mark_read);
if (confirm_mark_read) {
gint result;
GtkMessageDialog *confirm_dialog = GTK_MESSAGE_DIALOG (liferea_dialog_new ("mark_read_dialog"));
GtkWidget *dont_ask_toggle = liferea_dialog_lookup (GTK_WIDGET (confirm_dialog), "dontAskAgainToggle");
const gchar *feed_title = (feedlist_get_root () == feedlist) ? _("all feeds"):node_get_title (feedlist);
gchar *primary_message = g_strdup_printf (_("Mark %s as read ?"), feed_title);
g_object_set (confirm_dialog, "text", primary_message, NULL);
g_free (primary_message);
gtk_message_dialog_format_secondary_text (confirm_dialog, _("Are you sure you want to mark all items in %s as read ?"), feed_title);
conf_bind (CONFIRM_MARK_ALL_READ, dont_ask_toggle, "active", G_SETTINGS_BIND_DEFAULT | G_SETTINGS_BIND_INVERT_BOOLEAN);
result = gtk_dialog_run (GTK_DIALOG (confirm_dialog));
if (result != GTK_RESPONSE_OK)
do_mark_read = FALSE;
gtk_widget_destroy (GTK_WIDGET (confirm_dialog));
}
if (do_mark_read)
feedlist_mark_all_read (feedlist);
}
gboolean
liferea_htmlview_handle_URL (LifereaHtmlView *htmlview, const gchar *url)
{
struct internalUriType *uriType;
gboolean browse_inside_application;
g_return_val_if_fail (htmlview, TRUE);
g_return_val_if_fail (url, TRUE);
conf_get_bool_value (BROWSE_INSIDE_APPLICATION, &browse_inside_application);
debug3 (DEBUG_GUI, "handle URL: %s %s %s",
browse_inside_application?"true":"false",
htmlview->priv->forceInternalBrowsing?"true":"false",
htmlview->priv->internal?"true":"false");
/* first catch all links with special URLs... */
if (liferea_htmlview_is_special_url (url)) {
if (htmlview->priv->internal) {
/* it is a generic item list URI type */
uriType = internalUriTypes;
while (uriType->suffix) {
if (!strncmp (url + strlen ("liferea-"), uriType->suffix, strlen (uriType->suffix))) {
gchar *nodeid, *itemnr;
nodeid = strstr (url, "://");
if (nodeid) {
nodeid += 3;
itemnr = strchr (nodeid, '-');
if (itemnr) {
itemPtr item;
*itemnr = 0;
itemnr++;
item = item_load (atol (itemnr));
if (item) {
(*uriType->func) (item);
item_unload (item);
} else {
g_warning ("Fatal: no item with id (node=%s, item=%s) found!!!", nodeid, itemnr);
}
return TRUE;
}
}
}
uriType++;
}
g_warning ("Internal error: unhandled protocol in URL \"%s\"!", url);
} else {
g_warning ("Security: Prevented external HTML document to use internal link scheme (%s)!", url);
}
return TRUE;
}
if(htmlview->priv->forceInternalBrowsing || browse_inside_application) {
/* before loading external content suppress internal link schema again */
htmlview->priv->internal = FALSE;
return FALSE;
} else {
(void)browser_launch_URL_external (url);
}
return TRUE;
}
void
liferea_shell_create (GtkApplication *app, const gchar *overrideWindowState)
{
GtkUIManager *ui_manager;
GtkAccelGroup *accel_group;
GError *error = NULL;
gboolean toggle;
gchar *id;
debug_enter ("liferea_shell_create");
g_object_new (LIFEREA_SHELL_TYPE, NULL);
shell->priv->window = GTK_WINDOW (liferea_shell_lookup ("mainwindow"));
gtk_window_set_application (GTK_WINDOW (shell->priv->window), app);
/* 1.) menu creation */
debug0 (DEBUG_GUI, "Setting up menues");
shell->priv->itemlist = itemlist_create ();
/* Prepare some toggle button states */
conf_get_bool_value (REDUCED_FEEDLIST, &toggle);
liferea_shell_feedlist_toggle_entries[0].is_active = toggle;
ui_manager = gtk_ui_manager_new ();
shell->priv->generalActions = gtk_action_group_new ("GeneralActions");
gtk_action_group_set_translation_domain (shell->priv->generalActions, PACKAGE);
gtk_action_group_add_actions (shell->priv->generalActions, liferea_shell_action_entries, G_N_ELEMENTS (liferea_shell_action_entries), shell->priv);
gtk_action_group_add_toggle_actions (shell->priv->generalActions, liferea_shell_action_toggle_entries, G_N_ELEMENTS (liferea_shell_action_toggle_entries), shell->priv);
gtk_action_group_add_radio_actions (shell->priv->generalActions, liferea_shell_view_radio_entries, G_N_ELEMENTS (liferea_shell_view_radio_entries), itemlist_get_view_mode (), (GCallback)on_view_activate, (gpointer)TRUE);
gtk_action_group_add_toggle_actions (shell->priv->generalActions, liferea_shell_feedlist_toggle_entries, G_N_ELEMENTS (liferea_shell_feedlist_toggle_entries), shell->priv);
gtk_ui_manager_insert_action_group (ui_manager, shell->priv->generalActions, 0);
shell->priv->addActions = gtk_action_group_new ("AddActions");
gtk_action_group_set_translation_domain (shell->priv->addActions, PACKAGE);
gtk_action_group_add_actions (shell->priv->addActions, liferea_shell_add_action_entries, G_N_ELEMENTS (liferea_shell_add_action_entries), shell->priv);
gtk_ui_manager_insert_action_group (ui_manager, shell->priv->addActions, 0);
shell->priv->feedActions = gtk_action_group_new ("FeedActions");
gtk_action_group_set_translation_domain (shell->priv->feedActions, PACKAGE);
gtk_action_group_add_actions (shell->priv->feedActions, liferea_shell_feed_action_entries, G_N_ELEMENTS (liferea_shell_feed_action_entries), shell->priv);
gtk_ui_manager_insert_action_group (ui_manager, shell->priv->feedActions, 0);
shell->priv->readWriteActions = gtk_action_group_new("ReadWriteActions");
gtk_action_group_set_translation_domain (shell->priv->readWriteActions, PACKAGE);
gtk_action_group_add_actions (shell->priv->readWriteActions, liferea_shell_read_write_action_entries, G_N_ELEMENTS (liferea_shell_read_write_action_entries), shell->priv);
gtk_ui_manager_insert_action_group (ui_manager, shell->priv->readWriteActions, 0);
shell->priv->itemActions = gtk_action_group_new ("ItemActions");
gtk_action_group_set_translation_domain (shell->priv->itemActions, PACKAGE);
gtk_action_group_add_actions (shell->priv->itemActions, liferea_shell_item_action_entries, G_N_ELEMENTS (liferea_shell_item_action_entries), shell->priv);
gtk_ui_manager_insert_action_group (ui_manager, shell->priv->itemActions, 0);
accel_group = gtk_ui_manager_get_accel_group (ui_manager);
gtk_window_add_accel_group (GTK_WINDOW (shell->priv->window), accel_group);
g_object_unref (accel_group);
g_signal_connect (gtk_accel_map_get (), "changed", G_CALLBACK (on_accel_change), NULL);
if (!gtk_ui_manager_add_ui_from_string (ui_manager, liferea_shell_ui_desc, -1, &error))
g_error ("building menus failed: %s", error->message);
shell->priv->menubar = gtk_ui_manager_get_widget (ui_manager, "/MainwindowMenubar");
shell->priv->toolbar = gtk_ui_manager_get_widget (ui_manager, "/maintoolbar");
/* Ensure GTK3 toolbar shadows... */
gtk_style_context_add_class (gtk_widget_get_style_context (shell->priv->toolbar), "primary-toolbar");
/* what a pain, why is there no markup for this option? */
g_object_set (G_OBJECT (gtk_ui_manager_get_widget (ui_manager, "/maintoolbar/newFeedButton")), "is_important", TRUE, NULL);
g_object_set (G_OBJECT (gtk_ui_manager_get_widget (ui_manager, "/maintoolbar/nextUnreadButton")), "is_important", TRUE, NULL);
g_object_set (G_OBJECT (gtk_ui_manager_get_widget (ui_manager, "/maintoolbar/MarkAsReadButton")), "is_important", TRUE, NULL);
g_object_set (G_OBJECT (gtk_ui_manager_get_widget (ui_manager, "/maintoolbar/UpdateAllButton")), "is_important", TRUE, NULL);
g_object_set (G_OBJECT (gtk_ui_manager_get_widget (ui_manager, "/maintoolbar/SearchButton")), "is_important", TRUE, NULL);
/* 2.) setup containers */
debug0 (DEBUG_GUI, "Setting up widget containers");
gtk_box_pack_start (GTK_BOX (liferea_shell_lookup ("vbox1")), shell->priv->toolbar, FALSE, FALSE, 0);
gtk_box_reorder_child (GTK_BOX (liferea_shell_lookup ("vbox1")), shell->priv->toolbar, 0);
gtk_box_pack_start (GTK_BOX (liferea_shell_lookup ("vbox1")), shell->priv->menubar, FALSE, FALSE, 0);
gtk_box_reorder_child (GTK_BOX (liferea_shell_lookup ("vbox1")), shell->priv->menubar, 0);
gtk_widget_show_all(GTK_WIDGET(shell->priv->toolbar));
g_signal_connect ((gpointer) liferea_shell_lookup ("itemtabs"), "key_press_event",
G_CALLBACK (on_key_press_event_null_cb), NULL);
g_signal_connect ((gpointer) liferea_shell_lookup ("itemtabs"), "key_release_event",
G_CALLBACK (on_key_press_event_null_cb), NULL);
g_signal_connect ((gpointer) liferea_shell_lookup ("itemtabs"), "scroll_event",
G_CALLBACK (on_notebook_scroll_event_null_cb), NULL);
g_signal_connect (G_OBJECT (shell->priv->window), "delete_event", G_CALLBACK(on_close), shell->priv);
g_signal_connect (G_OBJECT (shell->priv->window), "window_state_event", G_CALLBACK(on_window_state_event), shell->priv);
g_signal_connect (G_OBJECT (shell->priv->window), "key_press_event", G_CALLBACK(on_key_press_event), shell->priv);
/* 3.) setup status bar */
debug0 (DEBUG_GUI, "Setting up status bar");
shell->priv->statusbar = GTK_STATUSBAR (liferea_shell_lookup ("statusbar"));
shell->priv->statusbarLocked = FALSE;
shell->priv->statusbarLockTimer = 0;
shell->priv->statusbar_feedsinfo = gtk_label_new("");
gtk_widget_show(shell->priv->statusbar_feedsinfo);
gtk_box_pack_start (GTK_BOX (shell->priv->statusbar), shell->priv->statusbar_feedsinfo, FALSE, FALSE, 5);
/* 4.) setup tabs */
debug0 (DEBUG_GUI, "Setting up tabbed browsing");
shell->priv->tabs = browser_tabs_create (GTK_NOTEBOOK (liferea_shell_lookup ("browsertabs")));
/* 5.) setup feed list */
debug0 (DEBUG_GUI, "Setting up feed list");
shell->priv->feedlistView = GTK_TREE_VIEW (liferea_shell_lookup ("feedlist"));
feed_list_view_init (shell->priv->feedlistView);
/* 6.) setup menu sensivity */
debug0 (DEBUG_GUI, "Initialising menues");
/* On start, no item or feed is selected, so Item menu should be insensitive: */
liferea_shell_update_item_menu (FALSE);
/* necessary to prevent selection signals when filling the feed list
and setting the 2/3 pane mode view */
gtk_widget_set_sensitive (GTK_WIDGET (shell->priv->feedlistView), FALSE);
/* 7.) setup item view */
debug0 (DEBUG_GUI, "Setting up item view");
shell->priv->itemview = itemview_create (GTK_WIDGET (shell->priv->window));
/* 8.) load icons as required */
debug0 (DEBUG_GUI, "Loading icons");
icons_load ();
/* 9.) update and restore all menu elements */
liferea_shell_update_toolbar ();
liferea_shell_update_history_actions ();
liferea_shell_setup_URL_receiver ();
liferea_shell_restore_state (overrideWindowState);
gtk_widget_set_sensitive (GTK_WIDGET (shell->priv->feedlistView), TRUE);
/* 10.) After main window is realized get theme colors and set up feed
list and tray icon */
render_init_theme_colors (GTK_WIDGET (shell->priv->window));
shell->priv->feedlist = feedlist_create ();
g_signal_connect (shell->priv->feedlist, "new-items",
G_CALLBACK (liferea_shell_update_unread_stats), shell->priv->feedlist);
/* 11.) Restore latest selection */
// FIXME: Move to feed list code
if (conf_get_str_value (LAST_NODE_SELECTED, &id)) {
feed_list_view_select (node_from_id (id));
g_free (id);
}
/* 12. Setup shell plugins */
shell->priv->extensions = peas_extension_set_new (PEAS_ENGINE (liferea_plugins_engine_get_default ()),
LIFEREA_TYPE_SHELL_ACTIVATABLE, "shell", shell, NULL);
g_signal_connect (shell->priv->extensions, "extension-added", G_CALLBACK (on_extension_added), shell);
g_signal_connect (shell->priv->extensions, "extension-removed", G_CALLBACK (on_extension_removed), shell);
peas_extension_set_call (shell->priv->extensions, "activate");
/* 14. Rebuild search folders if needed */
if (searchFolderRebuild)
vfolder_foreach (vfolder_rebuild);
debug_exit ("liferea_shell_create");
}
static void
notif_libnotify_node_has_new_items (nodePtr node, gboolean enforced)
{
itemSetPtr itemSet;
GList *iter;
NotifyNotification *n;
gchar *labelSummary_p;
gint item_count = 0;
gboolean show_popup_windows;
conf_get_bool_value(SHOW_POPUP_WINDOWS, &show_popup_windows);
if (!show_popup_windows && !enforced)
return;
/* Count updated feed */
itemSet = node_get_itemset (node);
iter = itemSet->ids;
while (iter) {
itemPtr item = item_load (GPOINTER_TO_UINT (iter->data));
if (item->popupStatus && !item->readStatus)
item_count++;
item_unload (item);
iter = g_list_next (iter);
}
itemset_free (itemSet);
if (item_count == 0)
return;
labelSummary_p = g_strdup_printf (ngettext ("<b>%s</b> has <b>%d</b> update", "<b>%s</b> has <b>%d</b> updates", item_count),
node_get_title (node), item_count);
n = notify_notification_new (_("Feed Update"), labelSummary_p, "liferea", NULL);
g_free (labelSummary_p);
if (supports_append) {
notify_notification_set_hint_string(n, "append", "allow");
} else {
notify_notification_set_icon_from_pixbuf (n, node_get_icon (node));
}
notify_notification_set_timeout (n, NOTIFY_EXPIRES_DEFAULT);
if (supports_actions) {
notify_notification_add_action (n, "show_details", _("Show details"),
(NotifyActionCallback)notif_libnotify_callback_show_details,
node->id, NULL);
notify_notification_add_action (n, "open", _("Open feed"),
(NotifyActionCallback)notif_libnotify_callback_open,
node->id, NULL);
notify_notification_add_action (n, "mark_read", _("Mark all as read"),
(NotifyActionCallback)notif_libnotify_callback_mark_read,
node->id, NULL);
}
notify_notification_set_category (n, "feed");
notify_notification_attach_to_status_icon (n, ui_tray_get_status_icon ());
if (!notify_notification_show (n, NULL))
g_warning ("notif_libnotify.c - failed to send notification via libnotify");
}
void
preferences_dialog_init (PreferencesDialog *pd)
{
GtkWidget *widget, *entry;
GtkComboBox *combo;
GtkListStore *store;
GtkTreeIter treeiter;
GtkAdjustment *itemCount;
GtkTreeStore *treestore;
GtkTreeViewColumn *column;
GSList *list;
gchar *proxyport;
gchar *configuredBrowser, *name;
gboolean enabled;
static int manual;
struct browser *iter;
gint tmp, i, iSetting, proxy_port;
gboolean bSetting, show_tray_icon;
gchar *proxy_host, *proxy_user, *proxy_passwd;
gchar *browser_command;
prefdialog = pd;
pd->priv = PREFERENCES_DIALOG_GET_PRIVATE (pd);
pd->priv->dialog = liferea_dialog_new ("prefs.ui", "prefdialog");
/* Set up browser selection popup */
store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
for(i = 0, iter = browser_get_all (); iter->id != NULL; iter++, i++) {
gtk_list_store_append (store, &treeiter);
gtk_list_store_set (store, &treeiter, 0, _(iter->display), 1, i, -1);
}
manual = i;
/* This allows the user to choose their own browser by typing in the command. */
gtk_list_store_append (store, &treeiter);
gtk_list_store_set (store, &treeiter, 0, _("Manual"), 1, i, -1);
combo = GTK_COMBO_BOX (liferea_dialog_lookup (pd->priv->dialog, "browserpopup"));
gtk_combo_box_set_model (combo, GTK_TREE_MODEL (store));
ui_common_setup_combo_text (combo, 0);
g_signal_connect(G_OBJECT(combo), "changed", G_CALLBACK(on_browser_changed), pd);
/* Create location menu */
store = gtk_list_store_new (1, G_TYPE_STRING);
combo = GTK_COMBO_BOX (liferea_dialog_lookup (pd->priv->dialog, "browserlocpopup"));
gtk_combo_box_set_model (combo, GTK_TREE_MODEL (store));
ui_common_setup_combo_text (combo, 0);
g_signal_connect(G_OBJECT(combo), "changed", G_CALLBACK(on_browser_place_changed), pd);
gtk_list_store_append (store, &treeiter);
gtk_list_store_set (store, &treeiter, 0, _("Browser default"), -1);
gtk_list_store_append (store, &treeiter);
gtk_list_store_set (store, &treeiter, 0, _("Existing window"), -1);
gtk_list_store_append (store, &treeiter);
gtk_list_store_set (store, &treeiter, 0, _("New window"), -1);
gtk_list_store_append (store, &treeiter);
gtk_list_store_set (store, &treeiter, 0, _("New tab"), -1);
/* ================== panel 1 "feeds" ==================== */
/* check box for feed startup update */
conf_get_int_value (STARTUP_FEED_ACTION, &iSetting);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (liferea_dialog_lookup (pd->priv->dialog, "startupactionbtn")), (iSetting == 0));
/* cache size setting */
widget = liferea_dialog_lookup (pd->priv->dialog, "itemCountBtn");
itemCount = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (widget));
conf_get_int_value (DEFAULT_MAX_ITEMS, &iSetting);
gtk_adjustment_set_value (itemCount, iSetting);
/* set default update interval spin button and unit combo box */
ui_common_setup_combo_menu (liferea_dialog_lookup (pd->priv->dialog, "globalRefreshIntervalUnitComboBox"),
default_update_interval_unit_options,
G_CALLBACK (on_default_update_interval_unit_changed),
-1);
widget = liferea_dialog_lookup (pd->priv->dialog, "globalRefreshIntervalUnitComboBox");
conf_get_int_value (DEFAULT_UPDATE_INTERVAL, &tmp);
if (tmp % 1440 == 0) { /* days */
gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 2);
tmp /= 1440;
} else if (tmp % 60 == 0) { /* hours */
gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 1);
tmp /= 60;
} else { /* minutes */
gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 0);
}
widget = liferea_dialog_lookup (pd->priv->dialog,"globalRefreshIntervalSpinButton");
gtk_spin_button_set_value (GTK_SPIN_BUTTON (widget), tmp);
g_signal_connect (G_OBJECT (widget), "changed", G_CALLBACK (on_default_update_interval_value_changed), pd);
/* ================== panel 2 "folders" ==================== */
g_signal_connect (G_OBJECT (liferea_dialog_lookup (pd->priv->dialog, "updateAllFavicons")), "clicked", G_CALLBACK(on_updateallfavicons_clicked), pd);
conf_get_int_value (FOLDER_DISPLAY_MODE, &iSetting);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (liferea_dialog_lookup (pd->priv->dialog, "folderdisplaybtn")), iSetting?TRUE:FALSE);
conf_get_bool_value (FOLDER_DISPLAY_HIDE_READ, &bSetting);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (liferea_dialog_lookup (pd->priv->dialog, "hidereadbtn")), bSetting?TRUE:FALSE);
/* ================== panel 3 "headlines" ==================== */
conf_get_int_value (BROWSE_KEY_SETTING, &iSetting);
ui_common_setup_combo_menu (liferea_dialog_lookup (pd->priv->dialog, "skimKeyCombo"),
browser_skim_key_options,
G_CALLBACK (on_skim_key_changed),
iSetting);
conf_get_int_value (DEFAULT_VIEW_MODE, &iSetting);
ui_common_setup_combo_menu (liferea_dialog_lookup (pd->priv->dialog, "defaultViewModeCombo"),
default_view_mode_options,
G_CALLBACK (on_default_view_mode_changed),
iSetting);
/* Setup social bookmarking list */
i = 0;
conf_get_str_value (SOCIAL_BM_SITE, &name);
store = gtk_list_store_new (1, G_TYPE_STRING);
list = bookmarkSites;
while (list) {
socialSitePtr siter = list->data;
if (name && !strcmp (siter->name, name))
tmp = i;
gtk_list_store_append (store, &treeiter);
gtk_list_store_set (store, &treeiter, 0, siter->name, -1);
list = g_slist_next (list);
i++;
}
combo = GTK_COMBO_BOX (liferea_dialog_lookup (pd->priv->dialog, "socialpopup"));
g_signal_connect (G_OBJECT (combo), "changed", G_CALLBACK (on_socialsite_changed), pd);
gtk_combo_box_set_model (combo, GTK_TREE_MODEL (store));
ui_common_setup_combo_text (combo, 0);
gtk_combo_box_set_active (combo, tmp);
/* ================== panel 4 "browser" ==================== */
/* set the inside browsing flag */
widget = liferea_dialog_lookup(pd->priv->dialog, "browseinwindow");
conf_get_bool_value(BROWSE_INSIDE_APPLICATION, &bSetting);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), bSetting);
/* set the javascript-disabled flag */
widget = liferea_dialog_lookup(pd->priv->dialog, "disablejavascript");
conf_get_bool_value(DISABLE_JAVASCRIPT, &bSetting);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), bSetting);
/* set the enable Plugins flag */
widget = liferea_dialog_lookup(pd->priv->dialog, "enableplugins");
conf_get_bool_value(ENABLE_PLUGINS, &bSetting);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), bSetting);
tmp = 0;
conf_get_str_value(BROWSER_ID, &configuredBrowser);
if(!strcmp(configuredBrowser, "manual"))
tmp = manual;
else
for(i=0, iter = browser_get_all (); iter->id != NULL; iter++, i++)
if(!strcmp(configuredBrowser, iter->id))
tmp = i;
gtk_combo_box_set_active(GTK_COMBO_BOX(liferea_dialog_lookup(pd->priv->dialog, "browserpopup")), tmp);
g_free(configuredBrowser);
conf_get_int_value (BROWSER_PLACE, &iSetting);
gtk_combo_box_set_active(GTK_COMBO_BOX(liferea_dialog_lookup(pd->priv->dialog, "browserlocpopup")), iSetting);
conf_get_str_value (BROWSER_COMMAND, &browser_command);
entry = liferea_dialog_lookup(pd->priv->dialog, "browsercmd");
gtk_entry_set_text(GTK_ENTRY(entry), browser_command);
g_free (browser_command);
gtk_widget_set_sensitive (GTK_WIDGET (entry), tmp == manual);
gtk_widget_set_sensitive (liferea_dialog_lookup (pd->priv->dialog, "manuallabel"), tmp == manual);
gtk_widget_set_sensitive (liferea_dialog_lookup (pd->priv->dialog, "urlhintlabel"), tmp == manual);
/* ================== panel 4 "GUI" ================ */
widget = liferea_dialog_lookup (pd->priv->dialog, "popupwindowsoptionbtn");
conf_get_bool_value (SHOW_POPUP_WINDOWS, &bSetting);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), bSetting);
widget = liferea_dialog_lookup (pd->priv->dialog, "trayiconoptionbtn");
conf_get_bool_value (SHOW_TRAY_ICON, &show_tray_icon);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), show_tray_icon);
widget = liferea_dialog_lookup (pd->priv->dialog, "newcountintraybtn");
conf_get_bool_value (SHOW_NEW_COUNT_IN_TRAY, &bSetting);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), bSetting);
gtk_widget_set_sensitive (liferea_dialog_lookup (pd->priv->dialog, "newcountintraybtn"), show_tray_icon);
widget = liferea_dialog_lookup (pd->priv->dialog, "minimizetotraybtn");
conf_get_bool_value (DONT_MINIMIZE_TO_TRAY, &bSetting);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), bSetting);
gtk_widget_set_sensitive (liferea_dialog_lookup (pd->priv->dialog, "minimizetotraybtn"), show_tray_icon);
widget = liferea_dialog_lookup (pd->priv->dialog, "startintraybtn");
conf_get_bool_value (START_IN_TRAY, &bSetting);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), bSetting);
gtk_widget_set_sensitive (liferea_dialog_lookup (pd->priv->dialog, "startintraybtn"), show_tray_icon);
if (ui_indicator_is_visible ()) {
/*
If we use the indicator applet:
- The "show tray icon" and "minimize to tray icon" settings
are interpreted as "show indicator" and "minimize to indicator"
- The "new count in tray icon" setting doesn't make sense and
is ignored by indicator handling code
*/
gtk_widget_hide (liferea_dialog_lookup (pd->priv->dialog, "newcountintraybtn"));
gtk_button_set_label (GTK_BUTTON (liferea_dialog_lookup (pd->priv->dialog, "trayiconoptionbtn")),
_("Integrate with the messaging menu (indicator)"));
gtk_button_set_label (GTK_BUTTON (liferea_dialog_lookup (pd->priv->dialog, "minimizetotraybtn")),
_("Terminate instead of minimizing to the messaging menu"));
gtk_button_set_label (GTK_BUTTON (liferea_dialog_lookup (pd->priv->dialog, "startintraybtn")),
_("Start minimized to the messaging menu"));
}
/* tool bar settings */
widget = liferea_dialog_lookup (pd->priv->dialog, "hidetoolbarbtn");
conf_get_bool_value(DISABLE_TOOLBAR, &bSetting);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), bSetting);
/* select currently active toolbar style option */
conf_get_str_value (TOOLBAR_STYLE, &name);
for (i = 0; gui_toolbar_style_values[i] != NULL; ++i) {
if (strcmp (name, gui_toolbar_style_values[i]) == 0)
break;
}
g_free (name);
/* On invalid key value: revert to default */
if (gui_toolbar_style_values[i] == NULL)
i = 0;
/* create toolbar style menu */
ui_common_setup_combo_menu (liferea_dialog_lookup (pd->priv->dialog, "toolbarCombo"),
gui_toolbar_style_options,
G_CALLBACK (on_gui_toolbar_style_changed),
i);
/* ================= panel 5 "proxy" ======================== */
conf_get_str_value (PROXY_HOST, &proxy_host);
gtk_entry_set_text (GTK_ENTRY (liferea_dialog_lookup (pd->priv->dialog, "proxyhostentry")), proxy_host);
g_free (proxy_host);
conf_get_int_value (PROXY_PORT, &proxy_port);
proxyport = g_strdup_printf ("%d", proxy_port);
gtk_entry_set_text (GTK_ENTRY (liferea_dialog_lookup (pd->priv->dialog, "proxyportentry")), proxyport);
g_free (proxyport);
conf_get_bool_value (PROXY_USEAUTH, &enabled);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (liferea_dialog_lookup (pd->priv->dialog, "useProxyAuth")), enabled);
conf_get_str_value (PROXY_USER, &proxy_user);
gtk_entry_set_text (GTK_ENTRY (liferea_dialog_lookup (pd->priv->dialog, "proxyusernameentry")), proxy_user);
g_free (proxy_user);
conf_get_str_value (PROXY_PASSWD, &proxy_passwd);
gtk_entry_set_text (GTK_ENTRY (liferea_dialog_lookup (pd->priv->dialog, "proxypasswordentry")), proxy_passwd);
g_free (proxy_passwd);
gtk_widget_set_sensitive (GTK_WIDGET (liferea_dialog_lookup(pd->priv->dialog, "proxyauthtable")), enabled);
conf_get_int_value (PROXY_DETECT_MODE, &i);
switch (i) {
default:
case 0: /* proxy auto detect */
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (liferea_dialog_lookup (pd->priv->dialog, "proxyAutoDetectRadio")), TRUE);
enabled = FALSE;
break;
case 1: /* no proxy */
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (liferea_dialog_lookup (pd->priv->dialog, "noProxyRadio")), TRUE);
enabled = FALSE;
break;
case 2: /* manual proxy */
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (liferea_dialog_lookup (pd->priv->dialog, "manualProxyRadio")), TRUE);
enabled = TRUE;
break;
}
gtk_widget_set_sensitive (GTK_WIDGET (liferea_dialog_lookup (pd->priv->dialog, "proxybox")), enabled);
g_signal_connect (G_OBJECT (liferea_dialog_lookup (pd->priv->dialog, "proxyAutoDetectRadio")), "clicked", G_CALLBACK (on_proxyAutoDetect_clicked), pd);
g_signal_connect (G_OBJECT (liferea_dialog_lookup (pd->priv->dialog, "noProxyRadio")), "clicked", G_CALLBACK (on_noProxy_clicked), pd);
g_signal_connect (G_OBJECT (liferea_dialog_lookup (pd->priv->dialog, "manualProxyRadio")), "clicked", G_CALLBACK (on_manualProxy_clicked), pd);
g_signal_connect (G_OBJECT (liferea_dialog_lookup (pd->priv->dialog, "proxyhostentry")), "changed", G_CALLBACK (on_proxyhostentry_changed), pd);
g_signal_connect (G_OBJECT (liferea_dialog_lookup (pd->priv->dialog, "proxyportentry")), "changed", G_CALLBACK (on_proxyportentry_changed), pd);
g_signal_connect (G_OBJECT (liferea_dialog_lookup (pd->priv->dialog, "proxyusernameentry")), "changed", G_CALLBACK (on_proxyusernameentry_changed), pd);
g_signal_connect (G_OBJECT (liferea_dialog_lookup (pd->priv->dialog, "proxypasswordentry")), "changed", G_CALLBACK (on_proxypasswordentry_changed), pd);
/* ================= panel 6 "Enclosures" ======================== */
/* menu for download tool */
conf_get_int_value (DOWNLOAD_TOOL, &iSetting);
ui_common_setup_combo_menu (liferea_dialog_lookup (pd->priv->dialog, "downloadToolCombo"),
enclosure_download_tool_options,
G_CALLBACK (on_enclosure_download_tool_changed),
iSetting);
/* set up list of configured enclosure types */
treestore = gtk_tree_store_new (FTS_LEN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER);
list = (GSList *)enclosure_mime_types_get ();
while (list) {
GtkTreeIter *newIter = g_new0 (GtkTreeIter, 1);
gtk_tree_store_append (treestore, newIter, NULL);
gtk_tree_store_set (treestore, newIter,
FTS_TYPE, (NULL != ((encTypePtr)(list->data))->mime)?((encTypePtr)(list->data))->mime:((encTypePtr)(list->data))->extension,
FTS_CMD, ((encTypePtr)(list->data))->cmd,
FTS_PTR, list->data,
-1);
list = g_slist_next (list);
}
widget = liferea_dialog_lookup (pd->priv->dialog, "enc_action_view");
gtk_tree_view_set_model (GTK_TREE_VIEW (widget), GTK_TREE_MODEL (treestore));
column = gtk_tree_view_column_new_with_attributes (_("Type"), gtk_cell_renderer_text_new (), "text", FTS_TYPE, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (widget), column);
gtk_tree_view_column_set_sort_column_id (column, FTS_TYPE);
column = gtk_tree_view_column_new_with_attributes (_("Program"), gtk_cell_renderer_text_new (), "text", FTS_CMD, NULL);
gtk_tree_view_column_set_sort_column_id (column, FTS_CMD);
gtk_tree_view_append_column (GTK_TREE_VIEW(widget), column);
gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW(widget)), GTK_SELECTION_SINGLE);
/* ================= panel 7 "Plugins" ======================== */
pd->priv->plugins_box = liferea_dialog_lookup (pd->priv->dialog, "plugins_box");
g_assert (pd->priv->plugins_box != NULL);
GtkWidget *alignment;
alignment = gtk_alignment_new (0., 0., 1., 1.);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 12, 12, 12, 12);
widget = peas_gtk_plugin_manager_new (NULL);
g_assert (widget != NULL);
gtk_container_add (GTK_CONTAINER (alignment), widget);
gtk_box_pack_start (GTK_BOX (pd->priv->plugins_box), alignment, TRUE, TRUE, 0);
g_signal_connect_object (pd->priv->dialog, "destroy", G_CALLBACK (preferences_dialog_destroy_cb), pd, 0);
gtk_widget_show_all (pd->priv->dialog);
gtk_window_present (GTK_WINDOW (pd->priv->dialog));
}
static void
conf_proxy_reset_settings_cb (GSettings *settings,
guint cnxn_id,
gchar *key,
gpointer user_data)
{
gchar *proxyname, *proxyusername, *proxypassword, *tmp;
gboolean gnomeUseProxy;
guint proxyport;
gint proxydetectmode;
gboolean proxyuseauth;
xmlURIPtr uri;
proxyname = NULL;
proxyport = 0;
proxyusername = NULL;
proxypassword = NULL;
conf_get_int_value (PROXY_DETECT_MODE, &proxydetectmode);
switch (proxydetectmode) {
default:
case 0:
debug0 (DEBUG_CONF, "proxy auto detect is configured");
/* first check for a configured GNOME proxy, note: older
GNOME versions do use the boolean flag GNOME_USE_PROXY
while newer ones use the string key GNOME_PROXY_MODE */
conf_get_str_value_from_schema (proxy_settings, GNOME_PROXY_MODE, &tmp);
gnomeUseProxy = g_str_equal (tmp, "manual");
g_free (tmp);
/* first check for a configured GNOME proxy */
if (gnomeUseProxy) {
conf_get_str_value_from_schema (proxy_settings, GNOME_PROXY_HOST, &proxyname);
conf_get_int_value_from_schema (proxy_settings, GNOME_PROXY_PORT, &proxyport);
debug2 (DEBUG_CONF, "using GNOME configured proxy: \"%s\" port \"%d\"", proxyname, proxyport);
conf_get_bool_value_from_schema (proxy_settings, GNOME_PROXY_USEAUTH, &proxyuseauth);
if (proxyuseauth) {
conf_get_str_value_from_schema (proxy_settings, GNOME_PROXY_USER, &proxyusername);
conf_get_str_value_from_schema (proxy_settings, GNOME_PROXY_PASSWD, &proxypassword);
}
} else {
/* otherwise there could be a proxy specified in the environment
the following code was derived from SnowNews' setup.c */
if (g_getenv("http_proxy")) {
/* The pointer returned by getenv must not be altered.
What about mentioning this in the manpage of getenv? */
debug0 (DEBUG_CONF, "using proxy from environment");
do {
uri = xmlParseURI (BAD_CAST g_getenv ("http_proxy"));
if (uri == NULL) {
debug0 (DEBUG_CONF, "parsing URI in $http_proxy failed!");
break;
}
if (uri->server == NULL) {
debug0 (DEBUG_CONF, "could not determine proxy name from $http_proxy!");
xmlFreeURI (uri);
break;
}
proxyname = g_strdup (uri->server);
proxyport = (uri->port == 0) ? 3128 : uri->port;
if (uri->user) {
tmp = strtok (uri->user, ":");
tmp = strtok (NULL, ":");
if (tmp) {
proxyusername = g_strdup (uri->user);
proxypassword = g_strdup (tmp);
}
}
xmlFreeURI (uri);
} while (FALSE);
}
}
if (!proxyname)
debug0 (DEBUG_CONF, "no proxy GNOME of $http_proxy configuration found...");
break;
case 1:
debug0 (DEBUG_CONF, "proxy is disabled by user");
/* nothing to do */
break;
case 2:
debug0 (DEBUG_CONF, "manual proxy is configured");
conf_get_str_value (PROXY_HOST, &proxyname);
conf_get_int_value (PROXY_PORT, &proxyport);
conf_get_bool_value (PROXY_USEAUTH, &proxyuseauth);
if (proxyuseauth) {
conf_get_str_value (PROXY_USER, &proxyusername);
conf_get_str_value (PROXY_PASSWD, &proxypassword);
}
break;
}
debug4 (DEBUG_CONF, "Proxy settings are now %s:%d %s:%s", proxyname != NULL ? proxyname : "NULL", proxyport,
proxyusername != NULL ? proxyusername : "******",
proxypassword != NULL ? proxypassword : "******");
network_set_proxy (proxyname, proxyport, proxyusername, proxypassword);
}
int
main (int argc, char *argv[])
{
UniqueApp *app;
UniqueMessageData *msg;
GError *error = NULL;
GOptionContext *context;
GOptionGroup *debug;
gulong debug_flags = 0;
LifereaDBus *dbus = NULL;
const gchar *initial_state = "shown";
gchar *feed = NULL;
int initialState;
gboolean show_tray_icon, start_in_tray;
#ifdef USE_SM
gchar *opt_session_arg = NULL;
#endif
GOptionEntry entries[] = {
{ "mainwindow-state", 'w', 0, G_OPTION_ARG_STRING, &initial_state, N_("Start Liferea with its main window in STATE. STATE may be `shown', `iconified', or `hidden'"), N_("STATE") },
#ifdef USE_SM
{ "session", 0, G_OPTION_FLAG_HIDDEN, G_OPTION_ARG_STRING, &opt_session_arg, NULL, NULL },
#endif
{ "version", 'v', G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, show_version, N_("Show version information and exit"), NULL },
{ "add-feed", 'a', 0, G_OPTION_ARG_STRING, &feed, N_("Add a new subscription"), N_("uri") },
{ NULL }
};
GOptionEntry debug_entries[] = {
{ "debug-all", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, debug_entries_parse_callback, N_("Print debugging messages of all types"), NULL },
{ "debug-cache", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, debug_entries_parse_callback, N_("Print debugging messages for the cache handling"), NULL },
{ "debug-conf", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, debug_entries_parse_callback, N_("Print debugging messages for the configuration handling"), NULL },
{ "debug-db", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, debug_entries_parse_callback, N_("Print debugging messages of the database handling"), NULL },
{ "debug-gui", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, debug_entries_parse_callback, N_("Print debugging messages of all GUI functions"), NULL },
{ "debug-html", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, debug_entries_parse_callback, N_("Enables HTML rendering debugging. Each time Liferea renders HTML output it will also dump the generated HTML into ~/.liferea_1.6/output.xhtml"), NULL },
{ "debug-net", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, debug_entries_parse_callback, N_("Print debugging messages of all network activity"), NULL },
{ "debug-parsing", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, debug_entries_parse_callback, N_("Print debugging messages of all parsing functions"), NULL },
{ "debug-performance", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, debug_entries_parse_callback, N_("Print debugging messages when a function takes too long to process"), NULL },
{ "debug-trace", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, debug_entries_parse_callback, N_("Print debugging messages when entering/leaving functions"), NULL },
{ "debug-update", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, debug_entries_parse_callback, N_("Print debugging messages of the feed update processing"), NULL },
{ "debug-vfolder", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, debug_entries_parse_callback, N_("Print debugging messages of the search folder matching"), NULL },
{ "debug-verbose", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, debug_entries_parse_callback, N_("Print verbose debugging messages"), NULL },
{ NULL }
};
if (!g_thread_supported ()) g_thread_init (NULL);
#ifdef ENABLE_NLS
bindtextdomain (GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
#endif
debug = g_option_group_new ("debug",
_("Print debugging messages for the given topic"),
_("Print debugging messages for the given topic"),
&debug_flags,
NULL);
g_option_group_set_translation_domain(debug, GETTEXT_PACKAGE);
g_option_group_add_entries (debug, debug_entries);
context = g_option_context_new (NULL);
g_option_context_set_summary (context, N_("Liferea, the Linux Feed Reader"));
g_option_context_set_description (context, N_("For more information, please visit http://liferea.sourceforge.net/"));
g_option_context_add_main_entries (context, entries, GETTEXT_PACKAGE);
g_option_context_set_translation_domain(context, GETTEXT_PACKAGE);
g_option_context_add_group (context, debug);
g_option_context_add_group (context, gtk_get_option_group (FALSE));
g_option_context_parse (context, &argc, &argv, &error);
g_option_context_free (context);
if (error) {
g_print ("Error parsing options: %s\n", error->message);
}
set_debug_level (debug_flags);
/* Configuration necessary for network options, so it
has to be initialized before update_init() */
conf_init ();
#ifdef USE_DBUS
dbus_g_thread_init ();
#endif
/* We need to do the network initialization here to allow
network-manager to be setup before gtk_init() */
update_init ();
gtk_init (&argc, &argv);
/* Single instance checks */
app = unique_app_new_with_commands ("net.sourceforge.liferea", NULL,
"add_feed", COMMAND_ADD_FEED,
NULL);
if (unique_app_is_running (app)) {
g_print ("Liferea is already running\n");
unique_app_send_message (app, UNIQUE_ACTIVATE, NULL);
if (feed) {
msg = unique_message_data_new ();
unique_message_data_set_text (msg, feed, -1);
unique_app_send_message (app, COMMAND_ADD_FEED, msg);
}
return 1;
} else {
g_signal_connect (app, "message-received", G_CALLBACK (message_received_cb), NULL);
}
/* GTK theme support */
g_set_application_name (_("Liferea"));
gtk_window_set_default_icon_name ("liferea");
debug_start_measurement (DEBUG_DB);
/* order is important! */
db_init (); /* initialize sqlite */
xml_init (); /* initialize libxml2 */
#ifdef HAVE_LIBNOTIFY
notification_plugin_register (&libnotify_plugin);
#endif
social_init (); /* initialize social bookmarking */
#ifdef USE_DBUS
dbus = liferea_dbus_new ();
#else
debug0 (DEBUG_GUI, "Compiled without DBUS support.");
#endif
#ifdef USE_AVAHI
if (conf_get_bool_value (SYNC_AVAHI_ENABLED)) {
LifereaAvahiPublisher *avahiPublisher = NULL;
debug0 (DEBUG_CACHE, "Registering with AVAHI");
avahiPublisher = liferea_avahi_publisher_new ();
liferea_avahi_publisher_publish (avahiPublisher, conf_get_str_value (SYNC_AVAHI_SERVICE_NAME), 23632);
} else {
debug0 (DEBUG_CACHE, "Avahi support available, but disabled by preferences.");
}
#else
debug0 (DEBUG_CACHE, "Compiled without AVAHI support");
#endif
/* how to start liferea, command line takes precedence over preferences */
conf_get_bool_value (SHOW_TRAY_ICON, &show_tray_icon);
conf_get_bool_value (START_IN_TRAY, &start_in_tray);
if (g_str_equal(initial_state, "iconified")) {
initialState = MAINWINDOW_ICONIFIED;
} else if (g_str_equal(initial_state, "hidden") ||
(show_tray_icon && start_in_tray)) {
initialState = MAINWINDOW_HIDDEN;
} else {
initialState = MAINWINDOW_SHOWN;
}
liferea_shell_create (initialState);
g_set_prgname ("liferea");
#ifdef USE_SM
/* This must be after feedlist reading because some session
managers will tell Liferea to exit if Liferea does not
respond to SM requests within a minute or two. This starts
the main loop soon after opening the SM connection. */
session_init (BIN_DIR G_DIR_SEPARATOR_S "liferea", opt_session_arg);
session_set_cmd (NULL, initialState);
#endif
signal (SIGTERM, signal_handler);
signal (SIGINT, signal_handler);
signal (SIGHUP, signal_handler);
#ifndef G_OS_WIN32
signal (SIGBUS, fatal_signal_handler);
signal (SIGSEGV, fatal_signal_handler);
#endif
/* Note: we explicitely do not use the gdk_thread_*
locking in Liferea because it freezes the program
when running Flash applets in gtkmozembed */
runState = STATE_STARTING;
debug_end_measurement (DEBUG_DB, "startup");
if (feed)
feedlist_add_subscription (feed, NULL, NULL, 0);
gtk_main ();
g_object_unref (G_OBJECT (dbus));
return 0;
}
/* Downloads a feed specified in the request structure, returns
the downloaded data or NULL in the request structure.
If the webserver reports a permanent redirection, the
feed url will be modified and the old URL 'll be freed. The
request structure will also contain the HTTP status and the
last modified string.
*/
void
network_process_request (const updateJobPtr job)
{
SoupMessage *msg;
SoupDate *date;
gboolean do_not_track = FALSE;
g_assert (NULL != job->request);
debug1 (DEBUG_NET, "downloading %s", job->request->source);
if (job->request->postdata && (debug_level & DEBUG_VERBOSE) && (debug_level & DEBUG_NET))
debug1 (DEBUG_NET, " postdata=>>>%s<<<", job->request->postdata);
/* Prepare the SoupMessage */
msg = soup_message_new (job->request->postdata ? SOUP_METHOD_POST : SOUP_METHOD_GET,
job->request->source);
if (!msg) {
g_warning ("The request for %s could not be parsed!", job->request->source);
return;
}
/* Set the postdata for the request */
if (job->request->postdata) {
soup_message_set_request (msg,
"application/x-www-form-urlencoded",
SOUP_MEMORY_STATIC, /* libsoup won't free the postdata */
job->request->postdata,
strlen (job->request->postdata));
}
/* Set the If-Modified-Since: header */
if (job->request->updateState && update_state_get_lastmodified (job->request->updateState)) {
gchar *datestr;
date = soup_date_new_from_time_t (update_state_get_lastmodified (job->request->updateState));
datestr = soup_date_to_string (date, SOUP_DATE_HTTP);
soup_message_headers_append (msg->request_headers,
"If-Modified-Since",
datestr);
g_free (datestr);
soup_date_free (date);
}
/* Set the If-None-Match header */
if (job->request->updateState && update_state_get_etag (job->request->updateState)) {
soup_message_headers_append(msg->request_headers,
"If-None-Match",
update_state_get_etag (job->request->updateState));
}
/* Set the I-AM header */
if (job->request->updateState &&
(update_state_get_lastmodified (job->request->updateState) ||
update_state_get_etag (job->request->updateState))) {
soup_message_headers_append(msg->request_headers,
"A-IM",
"feed");
}
/* Support HTTP content negotiation */
soup_message_headers_append(msg->request_headers, "Accept", "application/atom+xml,application/xml;q=0.9,text/xml;q=0.8,*/*;q=0.7");
/* Set the authentication */
if (!job->request->authValue &&
job->request->options &&
job->request->options->username &&
job->request->options->password) {
SoupURI *uri = soup_message_get_uri (msg);
soup_uri_set_user (uri, job->request->options->username);
soup_uri_set_password (uri, job->request->options->password);
}
if (job->request->authValue) {
soup_message_headers_append (msg->request_headers, "Authorization",
job->request->authValue);
}
/* Add requested cookies */
if (job->request->updateState && job->request->updateState->cookies) {
soup_message_headers_append (msg->request_headers, "Cookie",
job->request->updateState->cookies);
soup_message_disable_feature (msg, SOUP_TYPE_COOKIE_JAR);
}
/* TODO: Right now we send the msg, and if it requires authentication and
* we didn't provide one, the petition fails and when the job is processed
* it sees it needs authentication and displays a dialog, and if credentials
* are entered, it queues a new job with auth credentials. Instead of that,
* we should probably handle authentication directly here, connecting the
* msg to a callback in case of 401 (see soup_message_add_status_code_handler())
* displaying the dialog ourselves, and requeing the msg if we get credentials */
/* Add Do Not Track header according to settings */
conf_get_bool_value (DO_NOT_TRACK, &do_not_track);
if (do_not_track)
soup_message_headers_append (msg->request_headers, "DNT", "1");
/* If the feed has "dont use a proxy" selected, use 'session2' which is non-proxy */
if (job->request->options && job->request->options->dontUseProxy)
soup_session_queue_message (session2, msg, network_process_callback, job);
else
soup_session_queue_message (session, msg, network_process_callback, job);
}
FeedListView *
feed_list_view_create (GtkTreeView *treeview)
{
GtkCellRenderer *titleRenderer, *countRenderer;
GtkCellRenderer *iconRenderer;
GtkTreeViewColumn *column, *column2;
GtkTreeSelection *select;
debug_enter ("feed_list_view_create");
/* Set up store */
g_assert (NULL == flv);
flv = FEED_LIST_VIEW (g_object_new (FEED_LIST_VIEW_TYPE, NULL));
flv->treeview = treeview;
flv->feedstore = gtk_tree_store_new (FS_LEN,
G_TYPE_STRING,
G_TYPE_ICON,
G_TYPE_POINTER,
G_TYPE_UINT,
G_TYPE_STRING);
gtk_tree_view_set_model (GTK_TREE_VIEW (flv->treeview), GTK_TREE_MODEL (flv->feedstore));
/* Prepare filter */
flv->filter = gtk_tree_model_filter_new (GTK_TREE_MODEL (flv->feedstore), NULL);
gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (flv->filter),
feed_list_view_filter_visible_function,
NULL,
NULL);
g_signal_connect (G_OBJECT (flv->feedstore), "row-changed",
G_CALLBACK (feed_list_view_row_changed_cb), flv);
/* we render the icon/state, the feed title and the unread count */
iconRenderer = gtk_cell_renderer_pixbuf_new ();
titleRenderer = gtk_cell_renderer_text_new ();
countRenderer = gtk_cell_renderer_text_new ();
gtk_cell_renderer_set_alignment (countRenderer, 1.0, 0);
column = gtk_tree_view_column_new ();
column2 = gtk_tree_view_column_new ();
gtk_tree_view_column_pack_start (column, iconRenderer, FALSE);
gtk_tree_view_column_pack_start (column, titleRenderer, TRUE);
gtk_tree_view_column_pack_end (column2, countRenderer, FALSE);
gtk_tree_view_column_add_attribute (column, iconRenderer, "gicon", FS_ICON);
gtk_tree_view_column_add_attribute (column, titleRenderer, "markup", FS_LABEL);
gtk_tree_view_column_add_attribute (column2, countRenderer, "markup", FS_COUNT);
gtk_tree_view_column_set_expand (column, TRUE);
gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_GROW_ONLY);
gtk_tree_view_column_set_sizing (column2, GTK_TREE_VIEW_COLUMN_GROW_ONLY);
gtk_tree_view_append_column (flv->treeview, column);
gtk_tree_view_append_column (flv->treeview, column2);
g_object_set (titleRenderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
g_signal_connect (G_OBJECT (flv->treeview), "row-activated", G_CALLBACK (feed_list_view_row_activated_cb), flv);
g_signal_connect (G_OBJECT (flv->treeview), "key-press-event", G_CALLBACK (feed_list_view_key_press_cb), flv);
select = gtk_tree_view_get_selection (flv->treeview);
gtk_tree_selection_set_mode (select, GTK_SELECTION_SINGLE);
g_signal_connect (G_OBJECT (select), "changed",
G_CALLBACK (feed_list_view_selection_changed_cb),
flv);
conf_get_bool_value (REDUCED_FEEDLIST, &flv->feedlist_reduced_unread);
if (flv->feedlist_reduced_unread)
feed_list_view_reduce_mode_changed (); /* before menu setup for reduced mode check box to be correct */
ui_dnd_setup_feedlist (flv->feedstore);
liferea_shell_update_feed_menu (TRUE, FALSE, FALSE);
liferea_shell_update_allitems_actions (FALSE, FALSE);
debug_exit ("feed_list_view_create");
return flv;
}
