/************************************************************/
#define debug_path(fn, path) { \
gchar *path_string = gtk_tree_path_to_string(path); \
fn("tree path %s", path_string); \
g_free(path_string); \
}
#if 0 /* Not Used */
static gboolean
gnc_tree_view_price_get_iter_from_price (GncTreeViewPrice *view,
GNCPrice *price,
GtkTreeIter *s_iter)
{
GtkTreeModel *model, *f_model, *s_model;
GtkTreeIter iter, f_iter;
g_return_val_if_fail(GNC_IS_TREE_VIEW_PRICE(view), FALSE);
g_return_val_if_fail(price != NULL, FALSE);
g_return_val_if_fail(s_iter != NULL, FALSE);
ENTER("view %p, price %p", view, price);
/* Reach down to the real model and get an iter for this price */
s_model = gtk_tree_view_get_model(GTK_TREE_VIEW(view));
f_model = gtk_tree_model_sort_get_model(GTK_TREE_MODEL_SORT(s_model));
model = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(f_model));
if (!gnc_tree_model_price_get_iter_from_price (GNC_TREE_MODEL_PRICE(model), price, &iter))
{
LEAVE("model_get_iter_from_price failed");
return FALSE;
}
/* convert back to a sort iter */
gtk_tree_model_filter_convert_child_iter_to_iter (GTK_TREE_MODEL_FILTER(f_model),
&f_iter, &iter);
gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT(s_model),
s_iter, &f_iter);
LEAVE(" ");
return TRUE;
}
/************************************************************/
#define debug_path(fn, path) { \
gchar *path_string = gtk_tree_path_to_string(path); \
fn("tree path %s", path_string); \
g_free(path_string); \
}
#if 0 /* Not Used */
static gboolean
gnc_tree_view_commodity_get_iter_from_commodity (GncTreeViewCommodity *view,
gnc_commodity *commodity,
GtkTreeIter *s_iter)
{
GtkTreeModel *model, *f_model, *s_model;
GtkTreeIter iter, f_iter;
g_return_val_if_fail(GNC_IS_TREE_VIEW_COMMODITY(view), FALSE);
g_return_val_if_fail(commodity != NULL, FALSE);
g_return_val_if_fail(s_iter != NULL, FALSE);
ENTER("view %p, commodity %p (%s)", view, commodity, gnc_commodity_get_mnemonic(commodity));
/* Reach down to the real model and get an iter for this commodity */
s_model = gtk_tree_view_get_model(GTK_TREE_VIEW(view));
f_model = gtk_tree_model_sort_get_model(GTK_TREE_MODEL_SORT(s_model));
model = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(f_model));
if (!gnc_tree_model_commodity_get_iter_from_commodity (GNC_TREE_MODEL_COMMODITY(model), commodity, &iter))
{
LEAVE("model_get_iter_from_commodity failed");
return FALSE;
}
/* convert back to a sort iter */
gtk_tree_model_filter_convert_child_iter_to_iter (GTK_TREE_MODEL_FILTER(f_model),
&f_iter, &iter);
gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT(s_model),
s_iter, &f_iter);
LEAVE(" ");
return TRUE;
}
static gboolean
inf_gtk_browser_model_sort_browser_iter_to_tree_iter(InfGtkBrowserModel* mdl,
InfcBrowser* browser,
InfcBrowserIter* iter,
GtkTreeIter* tree_iter)
{
GtkTreeModel* child_model;
GtkTreeIter child_iter;
gboolean result;
child_model = gtk_tree_model_sort_get_model(GTK_TREE_MODEL_SORT(mdl));
result = inf_gtk_browser_model_browser_iter_to_tree_iter(
INF_GTK_BROWSER_MODEL(child_model),
browser,
iter,
&child_iter
);
if(result == TRUE)
{
gtk_tree_model_sort_convert_child_iter_to_iter(
GTK_TREE_MODEL_SORT(mdl),
tree_iter,
&child_iter
);
return TRUE;
}
else
{
return FALSE;
}
}
static void
inf_gtk_browser_model_sort_set_browser_cb(InfGtkBrowserModel* model,
GtkTreePath* path,
GtkTreeIter* iter,
InfcBrowser* browser,
gpointer user_data)
{
GtkTreeModelSort* model_sort;
GtkTreePath* own_path;
GtkTreeIter own_iter;
model_sort = GTK_TREE_MODEL_SORT(user_data);
own_path = gtk_tree_model_sort_convert_child_path_to_path(model_sort, path);
gtk_tree_model_sort_convert_child_iter_to_iter(model_sort, &own_iter, iter);
inf_gtk_browser_model_set_browser(
INF_GTK_BROWSER_MODEL(user_data),
own_path,
&own_iter,
browser
);
gtk_tree_path_free(own_path);
}
static gboolean
gnc_tree_view_owner_get_iter_from_owner (GncTreeViewOwner *view,
GncOwner *owner,
GtkTreeIter *s_iter)
{
GtkTreeModel *model, *f_model, *s_model;
GtkTreeIter iter, f_iter;
g_return_val_if_fail(GNC_IS_TREE_VIEW_OWNER(view), FALSE);
g_return_val_if_fail(owner != NULL, FALSE);
g_return_val_if_fail(s_iter != NULL, FALSE);
ENTER("view %p, owner %p (%s)", view, owner, gncOwnerGetName(owner));
/* Reach down to the real model and get an iter for this owner */
s_model = gtk_tree_view_get_model(GTK_TREE_VIEW(view));
f_model = gtk_tree_model_sort_get_model(GTK_TREE_MODEL_SORT(s_model));
model = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(f_model));
if (!gnc_tree_model_owner_get_iter_from_owner (
GNC_TREE_MODEL_OWNER(model), owner, &iter))
{
LEAVE("model_get_iter_from_owner failed");
return FALSE;
}
/* convert back to a sort iter */
gtk_tree_model_filter_convert_child_iter_to_iter (
GTK_TREE_MODEL_FILTER(f_model), &f_iter, &iter);
gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT(s_model),
s_iter, &f_iter);
LEAVE(" ");
return TRUE;
}
static void
showed_message_cb (GtrTab * tab, GtrMsg * msg, GtrMessageTable * table)
{
GtkTreePath *path;
GtkTreeSelection *selection;
GtkTreeIter iter, child_iter;
GtrMessageTablePrivate *priv;
priv = gtr_message_table_get_instance_private (table);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->treeview));
gtr_message_table_get_message_iter (priv->store, msg, &child_iter);
gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT
(priv->sort_model),
&iter, &child_iter);
gtk_tree_selection_select_iter (selection, &iter);
path = gtk_tree_model_get_path (priv->sort_model, &iter);
gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (priv->treeview),
path, NULL, TRUE, 0.5, 0.0);
gtk_tree_path_free (path);
}
/* Given a base iter get the treeview iter */
static void
key_store_get_view_iter (CryptUIKeyStore *ckstore, const GtkTreeIter *base,
GtkTreeIter *iter)
{
GtkTreeIter i;
gtk_tree_model_filter_convert_child_iter_to_iter (ckstore->priv->filter, &i, (GtkTreeIter*)base);
gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (ckstore), iter, &i);
}
static void
file_view_select_iter (AnjutaFileView* view, GtkTreeIter iter)
{
GtkTreeModelSort* model_sort;
GtkTreeIter sort_iter;
GtkTreeSelection* selection;
GtkTreePath* path;
model_sort = GTK_TREE_MODEL_SORT (gtk_tree_view_get_model (GTK_TREE_VIEW (view)));
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (view));
gtk_tree_model_sort_convert_child_iter_to_iter (model_sort, &sort_iter, &iter);
path = gtk_tree_model_get_path (GTK_TREE_MODEL (model_sort), &sort_iter);
gtk_tree_selection_select_iter (selection, &sort_iter);
gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (view), path, NULL, TRUE, 0.5, 0.0);
}
gboolean
ephy_node_view_get_iter_for_node (EphyNodeView *view,
GtkTreeIter *iter,
EphyNode *node)
{
GtkTreeIter node_iter, filter_iter;
ephy_tree_model_node_iter_from_node (EPHY_TREE_MODEL_NODE (view->priv->nodemodel), node, &node_iter);
if (!gtk_tree_model_filter_convert_child_iter_to_iter (GTK_TREE_MODEL_FILTER (view->priv->filtermodel),
&filter_iter, &node_iter))
return FALSE;
if (!gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (view->priv->sortmodel),
iter, &filter_iter))
return FALSE;
return TRUE;
}
/**
* ephy_node_view_select_node:
* @view: an #EphyNodeView
* @node: the #EphyNode in the @view to be selected
*
* Puts the selection of @view on @node.
**/
void
ephy_node_view_select_node (EphyNodeView *view,
EphyNode *node)
{
GtkTreeIter iter, iter2;
g_return_if_fail (node != NULL);
ephy_tree_model_node_iter_from_node (EPHY_TREE_MODEL_NODE (view->priv->nodemodel),
node, &iter);
gtk_tree_model_filter_convert_child_iter_to_iter (GTK_TREE_MODEL_FILTER (view->priv->filtermodel),
&iter2, &iter);
gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (view->priv->sortmodel),
&iter, &iter2);
gtk_tree_selection_select_iter (gtk_tree_view_get_selection (GTK_TREE_VIEW (view)),
&iter);
}
static void
treeview_gsettings_changed_callback (GSettings *settings, gchar *key, GtkTreeView *list)
{
GtkTreeModel *store;
gchar *curr_value;
gchar *path;
/* find value in model */
curr_value = g_settings_get_string (settings, key);
store = gtk_tree_view_get_model (list);
path = find_string_in_model (store, curr_value, COL_NAME);
/* Add a temporary item if we can't find a match
* TODO: delete this item if it is no longer selected?
*/
if (!path)
{
GtkListStore *list_store;
GtkTreeIter iter, sort_iter;
ThemeConvData *conv;
list_store = GTK_LIST_STORE (gtk_tree_model_sort_get_model (GTK_TREE_MODEL_SORT (store)));
conv = g_object_get_data (G_OBJECT(list), THEME_DATA);
gtk_list_store_insert_with_values (list_store, &iter, 0,
COL_LABEL, curr_value,
COL_NAME, curr_value,
COL_THUMBNAIL, conv->thumbnail,
-1);
/* convert the tree store iter for use with the sort model */
gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (store),
&sort_iter, &iter);
path = gtk_tree_model_get_string_from_iter (store, &sort_iter);
create_thumbnail (curr_value, conv->thumbnail, conv->data);
}
/* select the new gsettings theme in treeview */
GtkTreeSelection *selection = gtk_tree_view_get_selection (list);
GtkTreePath *treepath = gtk_tree_path_new_from_string (path);
gtk_tree_selection_select_path (selection, treepath);
gtk_tree_view_scroll_to_cell (list, treepath, NULL, FALSE, 0, 0);
gtk_tree_path_free (treepath);
}
/**
* ephy_node_view_remove:
* @view: an #EphyNodeView
*
* Remove the currently selected nodes from @view.
**/
void
ephy_node_view_remove (EphyNodeView *view)
{
EphyNodeViewPrivate *priv = view->priv;
GList *list, *l;
EphyNode *node;
GtkTreeIter iter, iter2, iter3;
GtkTreePath *path;
GtkTreeRowReference *row_ref = NULL;
GtkTreeSelection *selection;
/* Before removing we try to get a reference to the next node in the view. If that is
* not available we try with the previous one, and if that is absent too,
* we will not select anything (which equals to select the topic "All")
*/
list = ephy_node_view_get_selection (view);
if (list == NULL) return;
node = g_list_first (list)->data;
ephy_tree_model_node_iter_from_node (EPHY_TREE_MODEL_NODE (view->priv->nodemodel),
node, &iter3);
gtk_tree_model_filter_convert_child_iter_to_iter (GTK_TREE_MODEL_FILTER (view->priv->filtermodel),
&iter2, &iter3);
gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (view->priv->sortmodel),
&iter, &iter2);
iter2 = iter;
if (gtk_tree_model_iter_next (GTK_TREE_MODEL (view->priv->sortmodel), &iter))
{
path = gtk_tree_model_get_path (GTK_TREE_MODEL (view->priv->sortmodel), &iter);
row_ref = gtk_tree_row_reference_new (GTK_TREE_MODEL (view->priv->sortmodel), path);
}
else
{
path = gtk_tree_model_get_path (GTK_TREE_MODEL (view->priv->sortmodel), &iter2);
if (gtk_tree_path_prev (path))
{
row_ref = gtk_tree_row_reference_new (GTK_TREE_MODEL (view->priv->sortmodel), path);
}
}
gtk_tree_path_free (path);
/* Work around bug #346662 */
priv->changing_selection = TRUE;
for (l = list; l != NULL; l = l->next)
{
ephy_node_unref (l->data);
}
priv->changing_selection = FALSE;
g_list_free (list);
/* Fake a selection changed signal */
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (view));
g_signal_emit_by_name (selection, "changed");
/* Select the "next" node */
if (row_ref != NULL)
{
path = gtk_tree_row_reference_get_path (row_ref);
if (path != NULL)
{
gtk_tree_view_set_cursor (GTK_TREE_VIEW (view), path, NULL, FALSE);
gtk_tree_path_free (path);
}
gtk_tree_row_reference_free (row_ref);
}
}
static void
ref_count_reorder_two (void)
{
GtkTreeIter iter1, iter2, iter3, iter4, iter5;
GtkTreeIter citer1, citer2, citer3, citer4, citer5;
GtkTreeIter siter1, siter2, siter3, siter4, siter5;
GtkTreeIter sciter1, sciter2, sciter3, sciter4, sciter5;
GtkTreeModel *model;
GtkTreeModelRefCount *ref_model;
GtkTreeModel *sort_model;
GtkWidget *tree_view;
GType column_types[] = { G_TYPE_INT };
model = gtk_tree_model_ref_count_new ();
ref_model = GTK_TREE_MODEL_REF_COUNT (model);
gtk_tree_store_set_column_types (GTK_TREE_STORE (model), 1,
column_types);
gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter1, NULL, 0,
0, 30, -1);
gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter2, NULL, 1,
0, 40, -1);
gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter3, NULL, 2,
0, 10, -1);
gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter4, NULL, 3,
0, 20, -1);
gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter5, NULL, 4,
0, 60, -1);
/* Child level */
gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &citer1, &iter1, 0,
0, 30, -1);
gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &citer2, &iter1, 1,
0, 40, -1);
gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &citer3, &iter1, 2,
0, 10, -1);
gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &citer4, &iter1, 3,
0, 20, -1);
gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &citer5, &iter1, 4,
0, 60, -1);
assert_root_level_unreferenced (ref_model);
sort_model = gtk_tree_model_sort_new_with_model (model);
tree_view = gtk_tree_view_new_with_model (sort_model);
gtk_tree_view_expand_all (GTK_TREE_VIEW (tree_view));
assert_node_ref_count (ref_model, &iter1, 2);
assert_node_ref_count (ref_model, &iter2, 1);
assert_node_ref_count (ref_model, &iter3, 1);
assert_node_ref_count (ref_model, &iter4, 1);
assert_node_ref_count (ref_model, &iter5, 1);
assert_level_referenced (ref_model, 1, &iter1);
gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter1, &iter1);
gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter2, &iter2);
gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter3, &iter3);
gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter4, &iter4);
gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter5, &iter5);
gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &sciter1, &citer1);
gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &sciter2, &citer2);
gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &sciter3, &citer3);
gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &sciter4, &citer4);
gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &sciter5, &citer5);
gtk_tree_model_ref_node (GTK_TREE_MODEL (sort_model), &siter1);
gtk_tree_model_ref_node (GTK_TREE_MODEL (sort_model), &siter1);
gtk_tree_model_ref_node (GTK_TREE_MODEL (sort_model), &siter3);
gtk_tree_model_ref_node (GTK_TREE_MODEL (sort_model), &siter3);
gtk_tree_model_ref_node (GTK_TREE_MODEL (sort_model), &siter3);
gtk_tree_model_ref_node (GTK_TREE_MODEL (sort_model), &siter5);
assert_node_ref_count (ref_model, &iter1, 4);
assert_node_ref_count (ref_model, &iter2, 1);
assert_node_ref_count (ref_model, &iter3, 4);
assert_node_ref_count (ref_model, &iter4, 1);
assert_node_ref_count (ref_model, &iter5, 2);
gtk_tree_model_ref_node (GTK_TREE_MODEL (sort_model), &sciter3);
gtk_tree_model_ref_node (GTK_TREE_MODEL (sort_model), &sciter3);
gtk_tree_model_ref_node (GTK_TREE_MODEL (sort_model), &sciter5);
gtk_tree_model_ref_node (GTK_TREE_MODEL (sort_model), &sciter5);
gtk_tree_model_ref_node (GTK_TREE_MODEL (sort_model), &sciter5);
gtk_tree_model_ref_node (GTK_TREE_MODEL (sort_model), &sciter1);
assert_node_ref_count (ref_model, &citer1, 2);
assert_node_ref_count (ref_model, &citer2, 1);
assert_node_ref_count (ref_model, &citer3, 3);
assert_node_ref_count (ref_model, &citer4, 1);
assert_node_ref_count (ref_model, &citer5, 4);
/* Sort */
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort_model),
0, GTK_SORT_ASCENDING);
assert_node_ref_count (ref_model, &iter1, 4);
assert_node_ref_count (ref_model, &iter2, 1);
assert_node_ref_count (ref_model, &iter3, 4);
assert_node_ref_count (ref_model, &iter4, 1);
assert_node_ref_count (ref_model, &iter5, 2);
assert_node_ref_count (ref_model, &citer1, 2);
assert_node_ref_count (ref_model, &citer2, 1);
assert_node_ref_count (ref_model, &citer3, 3);
assert_node_ref_count (ref_model, &citer4, 1);
assert_node_ref_count (ref_model, &citer5, 4);
/* Re-translate the iters after sorting */
gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter1, &iter1);
gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter2, &iter2);
gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter3, &iter3);
gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter4, &iter4);
gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter5, &iter5);
gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &sciter1, &citer1);
gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &sciter2, &citer2);
gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &sciter3, &citer3);
gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &sciter4, &citer4);
gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &sciter5, &citer5);
gtk_tree_model_unref_node (GTK_TREE_MODEL (sort_model), &siter1);
gtk_tree_model_unref_node (GTK_TREE_MODEL (sort_model), &siter1);
gtk_tree_model_unref_node (GTK_TREE_MODEL (sort_model), &siter3);
gtk_tree_model_unref_node (GTK_TREE_MODEL (sort_model), &siter3);
gtk_tree_model_unref_node (GTK_TREE_MODEL (sort_model), &siter3);
gtk_tree_model_unref_node (GTK_TREE_MODEL (sort_model), &siter5);
assert_node_ref_count (ref_model, &iter1, 2);
assert_node_ref_count (ref_model, &iter2, 1);
assert_node_ref_count (ref_model, &iter3, 1);
assert_node_ref_count (ref_model, &iter4, 1);
assert_node_ref_count (ref_model, &iter5, 1);
gtk_tree_model_unref_node (GTK_TREE_MODEL (sort_model), &sciter3);
gtk_tree_model_unref_node (GTK_TREE_MODEL (sort_model), &sciter3);
gtk_tree_model_unref_node (GTK_TREE_MODEL (sort_model), &sciter5);
gtk_tree_model_unref_node (GTK_TREE_MODEL (sort_model), &sciter5);
gtk_tree_model_unref_node (GTK_TREE_MODEL (sort_model), &sciter5);
gtk_tree_model_unref_node (GTK_TREE_MODEL (sort_model), &sciter1);
assert_level_referenced (ref_model, 1, &iter1);
gtk_widget_destroy (tree_view);
g_object_unref (sort_model);
assert_entire_model_unreferenced (ref_model);
g_object_unref (ref_model);
}
static void
theme_set_custom_from_theme (const MateThemeMetaInfo *info, AppearanceData *data)
{
MateThemeMetaInfo *custom = data->theme_custom;
GtkIconView *icon_view = GTK_ICON_VIEW (appearance_capplet_get_widget (data, "theme_list"));
GtkTreeModel *model;
GtkTreeIter iter;
GtkTreePath *path;
if (info == custom)
return;
/* if info is not NULL, we'll copy those theme settings over */
if (info != NULL) {
g_free (custom->gtk_theme_name);
g_free (custom->icon_theme_name);
g_free (custom->marco_theme_name);
g_free (custom->gtk_color_scheme);
g_free (custom->cursor_theme_name);
g_free (custom->application_font);
custom->gtk_color_scheme = NULL;
custom->application_font = NULL;
/* these settings are guaranteed to be non-NULL */
custom->gtk_theme_name = g_strdup (info->gtk_theme_name);
custom->icon_theme_name = g_strdup (info->icon_theme_name);
custom->marco_theme_name = g_strdup (info->marco_theme_name);
custom->cursor_theme_name = g_strdup (info->cursor_theme_name);
custom->cursor_size = info->cursor_size;
/* these can be NULL */
if (info->gtk_color_scheme)
custom->gtk_color_scheme = g_strdup (info->gtk_color_scheme);
else
custom->gtk_color_scheme = get_default_string_from_key (data->client, COLOR_SCHEME_KEY);
if (info->application_font)
custom->application_font = g_strdup (info->application_font);
else
custom->application_font = get_default_string_from_key (data->client, APPLICATION_FONT_KEY);
}
/* select the custom theme */
model = gtk_icon_view_get_model (icon_view);
if (!theme_find_in_model (model, custom->name, &iter)) {
GtkTreeIter child;
gtk_list_store_insert_with_values (data->theme_store, &child, 0,
COL_LABEL, custom->readable_name,
COL_NAME, custom->name,
COL_THUMBNAIL, data->theme_icon,
-1);
gtk_tree_model_sort_convert_child_iter_to_iter (
GTK_TREE_MODEL_SORT (model), &iter, &child);
}
path = gtk_tree_model_get_path (model, &iter);
gtk_icon_view_select_path (icon_view, path);
gtk_icon_view_scroll_to_path (icon_view, path, FALSE, 0.5, 0.0);
gtk_tree_path_free (path);
/* update the theme thumbnail */
theme_thumbnail_generate (custom, data);
}
static void
file_view_select_from_iter (AnjutaFileView* view, GtkTreeIter iter)
{
AnjutaFileViewPrivate* priv = ANJUTA_FILE_VIEW_GET_PRIVATE (view);
GtkTreeModelSort* model_sort;
gboolean valid;
GtkTreeIter sort_iter;
GFile* file;
model_sort = GTK_TREE_MODEL_SORT (gtk_tree_view_get_model (GTK_TREE_VIEW (view)));
do
{
gboolean is_dummy, is_dir;
gtk_tree_model_get (GTK_TREE_MODEL (priv->model), &iter,
COLUMN_FILE, &file, COLUMN_DUMMY, &is_dummy,
COLUMN_IS_DIR, &is_dir, -1);
if (is_dummy)
break;
if (g_file_equal (priv->pending_selected_file, file))
{
file_view_select_iter (view, iter);
break;
}
else if (g_file_has_prefix (priv->pending_selected_file, file))
{
if (is_dir)
{
GtkTreePath *path = NULL;
gtk_tree_model_sort_convert_child_iter_to_iter (model_sort, &sort_iter, &iter);
path = gtk_tree_model_get_path (GTK_TREE_MODEL (model_sort), &sort_iter);
if (gtk_tree_view_row_expanded (GTK_TREE_VIEW (view), path))
{
GtkTreeIter parent = iter;
valid = gtk_tree_model_iter_children (GTK_TREE_MODEL (priv->model), &iter, &parent);
gtk_tree_path_free (path);
}
else
{
gtk_tree_view_expand_row (GTK_TREE_VIEW (view), path, FALSE);
gtk_tree_path_free (path);
break;
}
}
else
{
file_view_select_iter (view, iter);
break;
}
}
else
valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (priv->model), &iter);
g_clear_object (&file);
} while (valid);
if (file)
g_object_unref (file);
}
static void
rejilla_split_dialog_merge_clicked_cb (GtkButton *button,
RejillaSplitDialog *self)
{
RejillaSplitDialogPrivate *priv;
GtkTreeSelection *selection;
GtkTreeModel *model;
GtkTreeIter iter;
priv = REJILLA_SPLIT_DIALOG_PRIVATE (self);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->tree));
model = gtk_tree_view_get_model (GTK_TREE_VIEW (priv->tree));
if (!gtk_tree_model_get_iter_first (model, &iter))
return;
do {
guint64 end;
guint64 start;
gchar *end_str;
gchar *start_str;
GtkTreeIter next;
gchar *length_str;
GtkTreeIter child;
if (!gtk_tree_selection_iter_is_selected (selection, &iter))
continue;
next = iter;
if (!gtk_tree_model_iter_next (model, &next))
continue;
if (!gtk_tree_selection_iter_is_selected (selection, &next))
continue;
gtk_tree_model_get (model, &iter,
START_COL, &start,
-1);
gtk_tree_model_sort_convert_iter_to_child_iter (GTK_TREE_MODEL_SORT (model),
&child,
&iter);
do {
GtkTreeIter next_child;
gtk_tree_model_get (model, &next,
END_COL, &end,
-1);
gtk_tree_model_sort_convert_iter_to_child_iter (GTK_TREE_MODEL_SORT (model),
&next_child,
&next);
if (!gtk_list_store_remove (priv->model, &next_child))
break;
gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (model),
&next,
&next_child);
} while (gtk_tree_selection_iter_is_selected (selection, &next));
length_str = rejilla_units_get_time_string (end - start, TRUE, FALSE);
start_str = rejilla_units_get_time_string (start, TRUE, FALSE);
end_str = rejilla_units_get_time_string (end, TRUE, FALSE);
gtk_list_store_set (priv->model, &child,
START_COL, (gint64) start,
END_COL, (gint64) end,
LENGTH_COL, (gint64) end - start,
START_STR_COL, start_str,
END_STR_COL, end_str,
LENGTH_STR_COL, length_str,
-1);
g_free (length_str);
g_free (start_str);
g_free (end_str);
gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (model),
&iter,
&child);
} while (gtk_tree_model_iter_next (model, &iter));
if (gtk_tree_model_iter_n_children (GTK_TREE_MODEL (priv->model), NULL) == 1)
gtk_list_store_clear (priv->model);
}
static void
rejilla_split_dialog_remove_range (RejillaSplitDialog *self,
gint64 start,
gint64 end,
gint64 length)
{
RejillaSplitDialogPrivate *priv;
GtkTreeModel *model;
GtkTreeIter iter;
gchar *length_str;
gchar *start_str;
gchar *end_str;
priv = REJILLA_SPLIT_DIALOG_PRIVATE (self);
/* align on 2352 byte boundary */
if (REJILLA_DURATION_TO_BYTES (start) % 2352)
start += REJILLA_BYTES_TO_DURATION (2352 - (REJILLA_DURATION_TO_BYTES (start) % 2352));
if (REJILLA_DURATION_TO_BYTES (end) % 2352) {
end += REJILLA_BYTES_TO_DURATION (2352 - (REJILLA_DURATION_TO_BYTES (end) % 2352));
if (end > length)
end = length;
}
model = gtk_tree_view_get_model (GTK_TREE_VIEW (priv->tree));
if (!gtk_tree_model_get_iter_first (model, &iter)) {
/* nothing in the tree yet; so create two new segments:
* - 0 => start
* - end => song end
* also make sure that the track is longer than 4 sec */
if (start - priv->start < REJILLA_MIN_STREAM_LENGTH
&& !rejilla_split_dialog_size_error (self)) {
/* that's not necessarily a good solution */
start = REJILLA_MIN_STREAM_LENGTH;
if (start > end)
end = start;
}
if ((length - end) < REJILLA_MIN_STREAM_LENGTH
&& !rejilla_split_dialog_size_error (self))
end = length - REJILLA_MIN_STREAM_LENGTH;
length_str = rejilla_units_get_time_string (start - priv->start, TRUE, FALSE);
start_str = rejilla_units_get_time_string (priv->start, TRUE, FALSE);
end_str = rejilla_units_get_time_string (start, TRUE, FALSE);
gtk_list_store_append (priv->model, &iter);
gtk_list_store_set (priv->model, &iter,
START_COL, (gint64) priv->start,
END_COL, (gint64) start,
LENGTH_COL, (gint64) start - priv->start,
START_STR_COL, start_str,
END_STR_COL, end_str,
LENGTH_STR_COL, length_str,
-1);
g_free (length_str);
g_free (start_str);
g_free (end_str);
if (end == length)
return;
length_str = rejilla_units_get_time_string (length - end, TRUE, FALSE);
start_str = rejilla_units_get_time_string (end, TRUE, FALSE);
end_str = rejilla_units_get_time_string (length, TRUE, FALSE);
gtk_list_store_append (priv->model, &iter);
gtk_list_store_set (priv->model, &iter,
START_COL, end,
END_COL, length,
LENGTH_COL, (gint64) (length - end),
START_STR_COL, start_str,
END_STR_COL, end_str,
LENGTH_STR_COL, length_str,
-1);
g_free (length_str);
g_free (start_str);
g_free (end_str);
return;
}
do {
GtkTreeIter child;
gint64 track_start;
gint64 track_end;
gtk_tree_model_get (model, &iter,
START_COL, &track_start,
END_COL, &track_end,
-1);
gtk_tree_model_sort_convert_iter_to_child_iter (GTK_TREE_MODEL_SORT (model),
&child,
&iter);
if (start == track_start) {
if (start == end)
return;
if (end == track_end) {
/* suppress it */
gtk_list_store_remove (priv->model, &child);
return;
}
if (end < track_end) {
/* reduce the size but make sure the remaining
* track is > 4 sec */
if ((track_end - end) < REJILLA_MIN_STREAM_LENGTH
&& !rejilla_split_dialog_size_error (self))
end = track_end - REJILLA_MIN_STREAM_LENGTH;
start_str = rejilla_units_get_time_string (end, TRUE, FALSE);
length_str = rejilla_units_get_time_string (track_end - end, TRUE, FALSE);
gtk_list_store_set (priv->model, &child,
START_COL, end,
START_STR_COL, start_str,
LENGTH_COL, track_end - end,
LENGTH_STR_COL, length_str,
-1);
g_free (length_str);
g_free (start_str);
}
else if (!gtk_list_store_remove (priv->model, &child))
return;
}
else if (start > track_start) {
if (start > track_end)
continue;
/* reduce the size but make sure the remaining track is
* > 4 sec else change it */
if ((start - track_start) < REJILLA_MIN_STREAM_LENGTH
&& !rejilla_split_dialog_size_error (self))
start = track_start + REJILLA_MIN_STREAM_LENGTH;
start_str = rejilla_units_get_time_string (start, TRUE, FALSE);
length_str = rejilla_units_get_time_string (start - track_start, TRUE, FALSE);
gtk_list_store_set (priv->model, &child,
END_COL, start,
END_STR_COL, start_str,
LENGTH_COL, start - track_start,
LENGTH_STR_COL, length_str,
-1);
g_free (length_str);
g_free (start_str);
if (end == length)
return;
if (end == track_end)
return;
if (end > track_end)
continue;
/* create a new track with the remaining time.
* make sure the remaining track is > 4 sec */
if ((track_end - end) < REJILLA_MIN_STREAM_LENGTH
&& !rejilla_split_dialog_size_error (self))
end = track_end - REJILLA_MIN_STREAM_LENGTH;
gtk_list_store_append (priv->model, &child);
length_str = rejilla_units_get_time_string (track_end - end, TRUE, FALSE);
start_str = rejilla_units_get_time_string (end, TRUE, FALSE);
end_str = rejilla_units_get_time_string (track_end, TRUE, FALSE);
gtk_list_store_set (priv->model, &child,
START_COL, end,
END_COL, track_end,
LENGTH_COL, (gint64) (track_end - end),
START_STR_COL, start_str,
END_STR_COL, end_str,
LENGTH_STR_COL, length_str,
-1);
g_free (length_str);
g_free (start_str);
g_free (end_str);
}
else if (end > track_end) {
if (!gtk_list_store_remove (priv->model, &child))
return;
}
else if (end == track_end) {
gtk_list_store_remove (priv->model, &child);
return;
}
else {
if (end == length) {
gtk_list_store_remove (priv->model, &child);
return;
}
/* resize (make sure about the 4s) */
if ((track_end - end) < REJILLA_MIN_STREAM_LENGTH
&& !rejilla_split_dialog_size_error (self))
end = track_end - REJILLA_MIN_STREAM_LENGTH;
start_str = rejilla_units_get_time_string (end, TRUE, FALSE);
length_str = rejilla_units_get_time_string (track_end - end, TRUE, FALSE);
gtk_list_store_set (priv->model, &child,
START_COL, end,
START_STR_COL, start_str,
LENGTH_COL, track_end - end,
LENGTH_STR_COL, length_str,
-1);
g_free (length_str);
g_free (start_str);
}
gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (model),
&iter,
&child);
} while (gtk_tree_model_iter_next (model, &iter));
}
