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);
}
ItemView *
itemview_create (GtkWidget *window)
{
gint zoom;
/* 1. Create widgets, load preferences */
g_object_new (ITEMVIEW_TYPE, NULL);
itemview->priv->currentLayoutMode = NODE_VIEW_MODE_INVALID;
itemview->priv->itemListView = item_list_view_create (window);
itemview->priv->itemListViewContainer = gtk_widget_get_parent (GTK_WIDGET (item_list_view_get_widget (itemview->priv->itemListView)));
conf_get_int_value (LAST_ZOOMLEVEL, &zoom);
if (zoom == 0) {
zoom = 100;
conf_set_int_value (LAST_ZOOMLEVEL, zoom);
}
itemview->priv->zoom = zoom;
/* initially we pack the item list in the normal view pane,
which is later changed in itemview_set_layout() */
gtk_container_add (GTK_CONTAINER (liferea_shell_lookup ("normalViewItems")), itemview->priv->itemListViewContainer);
/* 2. Prepare HTML rendering */
htmlview_init ();
return itemview;
}
void
feed_list_view_sort_folder (nodePtr folder)
{
GtkTreeView *treeview;
treeview = GTK_TREE_VIEW (liferea_shell_lookup ("feedlist"));
/* Unset the model from the view before clearing it and rebuilding it.*/
gtk_tree_view_set_model (treeview, NULL);
folder->children = g_slist_sort (folder->children, feed_list_view_sort_folder_compare);
feed_list_view_reload_feedlist ();
/* Reduce mode didn't actually change but we need to set the
* correct model according to the setting in the same way : */
feed_list_view_reduce_mode_changed ();
feedlist_foreach (feed_list_view_restore_folder_expansion);
feedlist_schedule_save ();
}
GtkWidget *
liferea_dialog_new (const gchar *filename, gchar *name)
{
LifereaDialog *ld;
gchar *path;
GError *error = NULL;
/* FIXME: this is so hacky... We should just load the whole file as we
* did with glade, then pick the widget we're told. However GtkBuilder
* doesn't cope with multiple top-level widgets in the same .ui file
* yet (it will load all the widgets, which are a lot in liferea.ui, so
* you end with a lot of new dialogs when you open e.g. preferences),
* so we need to do this for now...
* http://bugzilla.gnome.org/show_bug.cgi?id=575714
*/
gchar *objs[] = { "adjustment1", "adjustment2", "adjustment3",
"adjustment4", "adjustment5", "adjustment6",
"liststore1", "liststore2", "liststore3",
"liststore4", "liststore5", "liststore6",
"refreshIntervalSpinButton", name, NULL };
ld = LIFEREA_DIALOG (g_object_new (LIFEREA_DIALOG_TYPE, NULL));
path = g_build_filename (PACKAGE_DATA_DIR, PACKAGE, filename?filename:"liferea.ui", NULL);
ld->priv->xml = gtk_builder_new ();
if (!gtk_builder_add_objects_from_file (ld->priv->xml, path, objs, &error)) {
g_error ("Loading %s failed : %s", path, error->message);
g_error_free(error);
}
g_free (path);
g_return_val_if_fail (ld->priv->xml != NULL, NULL);
ld->priv->dialog = GTK_WIDGET (gtk_builder_get_object (ld->priv->xml, name));
gtk_builder_connect_signals (ld->priv->xml, NULL);
g_return_val_if_fail (ld->priv->dialog != NULL, NULL);
g_object_set_data (G_OBJECT (ld->priv->dialog), "LifereaDialog", ld);
gtk_window_set_transient_for (GTK_WINDOW (ld->priv->dialog), GTK_WINDOW (liferea_shell_lookup ("mainwindow")));
g_signal_connect_object (ld->priv->dialog, "destroy", G_CALLBACK (liferea_dialog_destroy_cb), ld, 0);
return ld->priv->dialog;
}
gboolean
feed_list_node_is_expanded (const gchar *nodeId)
{
GtkTreeIter *iter;
gboolean expanded = FALSE;
if (feedlist_reduced_unread)
return FALSE;
iter = feed_list_node_to_iter (nodeId);
if (iter) {
GtkTreeView *treeview = GTK_TREE_VIEW (liferea_shell_lookup ("feedlist"));
GtkTreePath *path = gtk_tree_model_get_path (gtk_tree_view_get_model (treeview), iter);
expanded = gtk_tree_view_row_expanded (treeview, path);
gtk_tree_path_free (path);
}
return expanded;
}
void
feed_list_node_set_expansion (nodePtr folder, gboolean expanded)
{
GtkTreeIter *iter;
GtkTreePath *path;
GtkTreeView *treeview;
if (feedlist_reduced_unread)
return;
iter = feed_list_node_to_iter (folder->id);
if (!iter)
return;
treeview = GTK_TREE_VIEW (liferea_shell_lookup ("feedlist"));
path = gtk_tree_model_get_path (gtk_tree_view_get_model (treeview), iter);
if (expanded)
gtk_tree_view_expand_row (treeview, path, FALSE);
else
gtk_tree_view_collapse_row (treeview, path);
gtk_tree_path_free (path);
}
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
liferea_shell_restore_state (const gchar *overrideWindowState)
{
gchar *toolbar_style, *accels_file;
gint last_vpane_pos, last_hpane_pos, last_wpane_pos;
gint resultState;
debug0 (DEBUG_GUI, "Setting toolbar style");
toolbar_style = conf_get_toolbar_style ();
liferea_shell_set_toolbar_style (toolbar_style);
g_free (toolbar_style);
debug0 (DEBUG_GUI, "Loading accelerators");
accels_file = common_create_config_filename ("accels");
gtk_accel_map_load (accels_file);
g_free (accels_file);
debug0 (DEBUG_GUI, "Restoring window position");
liferea_shell_restore_position ();
debug0 (DEBUG_GUI, "Loading pane proportions");
conf_get_int_value (LAST_VPANE_POS, &last_vpane_pos);
if (last_vpane_pos)
gtk_paned_set_position (GTK_PANED (liferea_shell_lookup ("leftpane")), last_vpane_pos);
conf_get_int_value (LAST_HPANE_POS, &last_hpane_pos);
if (last_hpane_pos)
gtk_paned_set_position (GTK_PANED (liferea_shell_lookup ("normalViewPane")), last_hpane_pos);
conf_get_int_value (LAST_WPANE_POS, &last_wpane_pos);
if (last_wpane_pos)
gtk_paned_set_position (GTK_PANED (liferea_shell_lookup ("wideViewPane")), last_wpane_pos);
/* Apply horrible window state parameter logic:
-> overrideWindowState provides optional command line flags passed by
user or the session manager (prio 1)
-> lastState provides last shutdown preference (prio 2)
*/
/* Initialize with last saved state */
conf_get_int_value (LAST_WINDOW_STATE, &resultState);
/* Override with command line options */
if (!g_strcmp0 (overrideWindowState, "hidden"))
resultState = MAINWINDOW_HIDDEN;
if (!g_strcmp0 (overrideWindowState, "shown"))
resultState = MAINWINDOW_SHOWN;
/* And set the window to the resulting state */
switch (resultState) {
case MAINWINDOW_HIDDEN:
debug0 (DEBUG_GUI, "Restoring window state 'hidden (to tray)'");
/* Realize needed so that the window structure can be
accessed... otherwise we get a GTK warning when window is
shown by clicking on notification icon or when theme
colors are fetched. */
gtk_widget_realize (GTK_WIDGET (shell->priv->window));
gtk_widget_hide (GTK_WIDGET (shell->priv->window));
break;
case MAINWINDOW_SHOWN:
default:
/* Safe default is always to show window */
debug0 (DEBUG_GUI, "Restoring window state 'shown'");
gtk_widget_show (GTK_WIDGET (shell->priv->window));
}
}
static gboolean
ui_dnd_feed_drag_data_received (GtkTreeDragDest *drag_dest, GtkTreePath *dest, GtkSelectionData *selection_data)
{
GtkTreeIter iter, iter2, parentIter;
nodePtr node, oldParent, newParent;
gboolean result, valid, added;
gint oldPos, pos;
result = old_feed_drag_data_received (drag_dest, dest, selection_data);
if (result) {
if (gtk_tree_model_get_iter (GTK_TREE_MODEL (drag_dest), &iter, dest)) {
gtk_tree_model_get (GTK_TREE_MODEL (drag_dest), &iter, FS_PTR, &node, -1);
/* If we don't do anything, then because DnD is implemented by removal and
re-insertion, and the removed node is selected, the treeview selects
the next row after the removal, which is supremely irritating.
But setting a selection at this point is pointless, because the treeview
will reset it as soon as the DnD callback returns. Instead, we set
the cursor, which controls where treeview resets the selection later.
*/
gtk_tree_view_set_cursor(GTK_TREE_VIEW (liferea_shell_lookup ("feedlist")),
dest, NULL, FALSE);
/* remove from old parents child list */
oldParent = node->parent;
g_assert (oldParent);
oldPos = g_slist_index (oldParent->children, node);
oldParent->children = g_slist_remove (oldParent->children, node);
node_update_counters (oldParent);
if (0 == g_slist_length (oldParent->children))
feed_list_node_add_empty_node (feed_list_node_to_iter (oldParent->id));
/* and rebuild new parents child list */
if (gtk_tree_model_iter_parent (GTK_TREE_MODEL (drag_dest), &parentIter, &iter)) {
gtk_tree_model_get (GTK_TREE_MODEL (drag_dest), &parentIter, FS_PTR, &newParent, -1);
} else {
gtk_tree_model_get_iter_first (GTK_TREE_MODEL (drag_dest), &parentIter);
newParent = feedlist_get_root ();
}
/* drop old list... */
debug3 (DEBUG_GUI, "old parent is %s (%d, position=%d)", oldParent->title, g_slist_length (oldParent->children), oldPos);
debug2 (DEBUG_GUI, "new parent is %s (%d)", newParent->title, g_slist_length (newParent->children));
g_slist_free (newParent->children);
newParent->children = NULL;
node->parent = newParent;
debug0 (DEBUG_GUI, "new newParent child list:");
/* and rebuild it from the tree model */
if (feedlist_get_root() != newParent)
valid = gtk_tree_model_iter_children (GTK_TREE_MODEL (drag_dest), &iter2, &parentIter);
else
valid = gtk_tree_model_iter_children (GTK_TREE_MODEL (drag_dest), &iter2, NULL);
pos = 0;
added = FALSE;
while (valid) {
nodePtr child;
gtk_tree_model_get (GTK_TREE_MODEL (drag_dest), &iter2, FS_PTR, &child, -1);
if (child) {
/* Well this is a bit complicated... If we move a feed inside a folder
we need to skip the old insertion point (oldPos). This is easy if the
feed is added behind this position. If it is dropped before the flag
added is set once the new copy is encountered. The remaining copy
is skipped automatically when the flag is set.
*/
/* check if this is a copy of the dragged node or the original itself */
if ((newParent == oldParent) && !strcmp(node->id, child->id)) {
if ((pos == oldPos) || added) {
/* it is the original */
debug2 (DEBUG_GUI, " -> %d: skipping old insertion point %s", pos, child->title);
} else {
/* it is a copy inserted before the original */
added = TRUE;
debug2 (DEBUG_GUI, " -> %d: new insertion point of %s", pos, child->title);
newParent->children = g_slist_append (newParent->children, child);
}
} else {
/* all other nodes */
debug2 (DEBUG_GUI, " -> %d: adding %s", pos, child->title);
newParent->children = g_slist_append (newParent->children, child);
}
} else {
debug0 (DEBUG_GUI, " -> removing empty node");
/* remove possible existing "(empty)" node from newParent */
feed_list_node_remove_empty_node (&parentIter);
}
valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (drag_dest), &iter2);
pos++;
}
db_node_update (node);
node_update_counters (newParent);
feedlist_schedule_save ();
}
}
return result;
}
void
itemview_set_layout (nodeViewType newMode)
{
ItemViewPrivate *ivp = itemview->priv;
const gchar *htmlWidgetName, *ilWidgetName, *encViewVBoxName;
if (newMode == ivp->currentLayoutMode)
return;
ivp->currentLayoutMode = newMode;
liferea_shell_set_view_mode (newMode);
if (!ivp->htmlview) {
GtkWidget *renderWidget;
debug0 (DEBUG_GUI, "Creating HTML widget");
htmlview_init ();
ivp->htmlview = liferea_htmlview_new (FALSE);
liferea_htmlview_set_headline_view (ivp->htmlview);
g_signal_connect (ivp->htmlview, "statusbar-changed",
G_CALLBACK (on_important_status_message), NULL);
renderWidget = liferea_htmlview_get_widget (ivp->htmlview);
gtk_container_add (GTK_CONTAINER (liferea_shell_lookup ("normalViewHtml")), renderWidget);
gtk_widget_show (renderWidget);
/* Set initial zoom */
liferea_htmlview_set_zoom (itemview->priv->htmlview, itemview->priv->zoom/100.);
} else {
liferea_htmlview_clear (ivp->htmlview);
}
debug1 (DEBUG_GUI, "Setting item list layout mode: %d", newMode);
switch (newMode) {
case NODE_VIEW_MODE_NORMAL:
htmlWidgetName = "normalViewHtml";
ilWidgetName = "normalViewItems";
encViewVBoxName = "normalViewVBox";
break;
case NODE_VIEW_MODE_WIDE:
htmlWidgetName = "wideViewHtml";
ilWidgetName = "wideViewItems";
encViewVBoxName = "wideViewVBox";
break;
case NODE_VIEW_MODE_COMBINED:
htmlWidgetName = "combinedViewHtml";
ilWidgetName = NULL;
encViewVBoxName = NULL;
break;
default:
g_warning("fatal: illegal viewing mode!");
return;
break;
}
/* Reparenting HTML view. This avoids the overhead of new browser instances. */
g_assert (htmlWidgetName);
gtk_notebook_set_current_page (GTK_NOTEBOOK (liferea_shell_lookup ("itemtabs")), newMode);
gtk_widget_reparent (liferea_htmlview_get_widget (ivp->htmlview), liferea_shell_lookup (htmlWidgetName));
/* Recreate the item list view */
if (ivp->itemListViewContainer)
gtk_widget_destroy (ivp->itemListViewContainer);
if (ilWidgetName) {
ivp->itemListView = item_list_view_create (newMode == NODE_VIEW_MODE_WIDE);
ivp->itemListViewContainer = gtk_widget_get_parent (GTK_WIDGET (item_list_view_get_widget (ivp->itemListView)));
g_assert (ivp->itemListViewContainer);
gtk_container_add (GTK_CONTAINER (liferea_shell_lookup (ilWidgetName)), GTK_WIDGET (ivp->itemListViewContainer));
}
/* Destroy previous enclosure list. */
if (ivp->enclosureView) {
gtk_widget_destroy (enclosure_list_view_get_widget (ivp->enclosureView));
ivp->enclosureView = NULL;
}
/* Create a new enclosure list GtkTreeView. */
if (encViewVBoxName) {
ivp->enclosureView = enclosure_list_view_new ();
gtk_box_pack_end (GTK_BOX (liferea_shell_lookup (encViewVBoxName)),
enclosure_list_view_get_widget (ivp->enclosureView),
FALSE, FALSE, 0);
gtk_widget_show_all (liferea_shell_lookup (encViewVBoxName));
}
}