static void changed(GtkTreeSelection *treeselection, gpointer user_data) {
GtkWidget *list = static_cast<GtkWidget *>(user_data);
list_priv_t *priv = static_cast<list_priv_t *>(g_object_get_data(G_OBJECT(list), "priv"));
GtkTreeModel *model;
GtkTreeIter iter;
bool selected = list_get_selected(list, &model, &iter);
/* scroll to selected entry if exactly one is selected */
if(selected) {
/* check if the entry isn't already visible */
GtkTreePath *start = nullptr, *end = nullptr;
tree_path_guard path(gtk_tree_model_get_path(model, &iter));
gtk_tree_view_get_visible_range(priv->view, &start, &end);
tree_path_guard sguard(start), eguard(end);
/* check if path is before start of visible area or behin end of it */
if((sguard && (gtk_tree_path_compare(path.get(), sguard.get())) < 0) ||
(eguard && (gtk_tree_path_compare(path.get(), eguard.get()) > 0)))
gtk_tree_view_scroll_to_cell(priv->view, path.get(), nullptr, TRUE, 0.5, 0.5);
}
/* the change event handler is overridden */
priv->change(treeselection, priv->callback_context);
}
/* sort using merge sort */
static void
gbf_project_model_sort (GtkTreeModel *model,
GtkTreePath *begin,
GtkTreePath *end,
GtkTreeIterCompareFunc compare_func,
gpointer user_data)
{
GtkTreePath *half;
gint depth;
/* Empty list are sorted */
if (gtk_tree_path_compare (begin, end) >= 0)
{
return;
}
/* Split the list in two */
half = gtk_tree_path_copy (begin);
gtk_tree_path_up (half);
gtk_tree_path_append_index (half, (gtk_tree_path_get_indices_with_depth (begin, &depth)[depth -1] +
gtk_tree_path_get_indices_with_depth (end, &depth)[depth - 1]) / 2);
/* List with a single element are sorted too */
if (gtk_tree_path_compare (begin, half) < 0)
{
gbf_project_model_sort (model, begin, half, compare_func, user_data);
gbf_project_model_sort (model, half, end, compare_func, user_data);
gbf_project_model_merge (model, begin, half, end, compare_func, user_data);
}
gtk_tree_path_free (half);
}
void
gbf_project_model_move_target_shortcut (GbfProjectModel *model,
GtkTreeIter *iter,
GbfTreeData *shortcut,
GtkTreePath *before_path)
{
AnjutaProjectNode *node;
GtkTreeIter sibling;
GtkTreePath *root_path;
GtkTreePath *src_path;
AnjutaProjectNode *parent;
if (!shortcut)
return;
root_path = gbf_project_model_get_project_root (model);
/* check before_path */
if (!before_path ||
gtk_tree_path_get_depth (before_path) > 1)
{
/* Missing destination path, use root path */
before_path = root_path;
}
else if (gtk_tree_path_compare (before_path, root_path) > 0)
{
/* Destination path outside shortcut are, remove shortcut */
gbf_project_model_remove (model, iter);
gtk_tree_path_free (root_path);
return;
}
/* get the tree iter for the row before which to insert the shortcut */
if (!gtk_tree_model_get_iter (GTK_TREE_MODEL (model), &sibling, before_path)) {
gtk_tree_path_free (root_path);
return;
}
src_path = gtk_tree_model_get_path (GTK_TREE_MODEL (model), iter);
if (gtk_tree_path_compare (src_path, before_path) != 0)
{
gtk_tree_store_remove (GTK_TREE_STORE (model), iter);
gtk_tree_store_insert_before (GTK_TREE_STORE (model), iter, NULL, &sibling);
gtk_tree_store_set (GTK_TREE_STORE (model), iter,
GBF_PROJECT_MODEL_COLUMN_DATA, shortcut,
-1);
/* add sources */
parent = gbf_tree_data_get_node (shortcut->shortcut);
for (node = anjuta_project_node_first_child (parent); node; node = anjuta_project_node_next_sibling (node))
gbf_project_model_add_node (model, node, iter);
}
gtk_tree_path_free (src_path);
gtk_tree_path_free (root_path);
}
static gboolean
contact_list_view_drag_motion (GtkWidget *widget,
GdkDragContext *context,
gint x,
gint y,
guint time)
{
static DragMotionData *dm = NULL;
GtkTreePath *path;
gboolean is_row;
gboolean is_different = FALSE;
gboolean cleanup = TRUE;
is_row = gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (widget),
x,
y,
&path,
NULL,
NULL,
NULL);
cleanup &= (!dm);
if (is_row) {
cleanup &= (dm && gtk_tree_path_compare (dm->path, path) != 0);
is_different = (!dm || (dm && gtk_tree_path_compare (dm->path, path) != 0));
} else {
cleanup &= FALSE;
}
if (!is_different && !cleanup) {
return TRUE;
}
if (dm) {
gtk_tree_path_free (dm->path);
if (dm->timeout_id) {
g_source_remove (dm->timeout_id);
}
g_free (dm);
dm = NULL;
}
if (!gtk_tree_view_row_expanded (GTK_TREE_VIEW (widget), path)) {
dm = g_new0 (DragMotionData, 1);
dm->view = EMPATHY_CONTACT_LIST_VIEW (widget);
dm->path = gtk_tree_path_copy (path);
dm->timeout_id = g_timeout_add_seconds (1,
(GSourceFunc) contact_list_view_drag_motion_cb,
dm);
}
return TRUE;
}
/* FIXME: is there a better implementation possible? */
static gboolean
is_iter_active (GtkComboBox *combo,
GtkTreeIter *iter)
{
GtkTreeModel *model;
GtkTreeIter active_iter;
GtkTreePath *active_path;
GtkTreePath *path;
gboolean ret;
model = gtk_combo_box_get_model (combo);
g_assert (model != NULL);
path = gtk_tree_model_get_path (model, iter);
g_assert (path != NULL);
if (!gtk_combo_box_get_active_iter (combo, &active_iter)) {
gtk_tree_path_free (path);
return FALSE;
}
active_path = gtk_tree_model_get_path (model, &active_iter);
g_assert (active_path != NULL);
ret = (gtk_tree_path_compare (path, active_path) == 0);
gtk_tree_path_free (path);
gtk_tree_path_free (active_path);
return ret;
}
static GtkTreePath *get_next_bus (GtkTreeModel *tm, GtkTreePath *tpSelBus)
{
int row_type ;
int icRootChildren = -1 ;
GtkTreePath *tp = NULL ;
int idxChild = 0 ;
GtkTreeIter itr ;
if (1 != gtk_tree_path_get_depth (tpSelBus))
return NULL ;
icRootChildren = gtk_tree_model_iter_n_children (tm, NULL) ;
tp = gtk_tree_path_new_first () ;
while (gtk_tree_path_compare (tp, tpSelBus) <= 0 && idxChild < icRootChildren)
{
gtk_tree_model_get_iter (tm, &itr, tp) ;
gtk_tree_path_next (tp) ;
idxChild++ ;
}
while (idxChild < icRootChildren)
{
gtk_tree_model_get_iter (tm, &itr, tp) ;
gtk_tree_model_get (tm, &itr, BUS_LAYOUT_MODEL_COLUMN_TYPE, &row_type, -1) ;
if (ROW_TYPE_BUS & row_type)
return tp ;
if (++idxChild < icRootChildren)
gtk_tree_path_next (tp) ;
}
gtk_tree_path_free (tp) ;
return NULL ;
}
static void
check_expand_timer (NautilusTreeViewDragDest *dest,
GtkTreePath *drop_path,
GtkTreePath *old_drop_path)
{
GtkTreeModel *model;
GtkTreeIter drop_iter;
model = gtk_tree_view_get_model (dest->details->tree_view);
if (drop_path == NULL ||
(old_drop_path != NULL && gtk_tree_path_compare (old_drop_path, drop_path) != 0)) {
remove_expand_timer (dest);
}
if (dest->details->expand_id == 0 &&
drop_path != NULL) {
gtk_tree_model_get_iter (model, &drop_iter, drop_path);
if (gtk_tree_model_iter_has_child (model, &drop_iter)) {
dest->details->expand_id =
g_timeout_add_seconds (HOVER_EXPAND_TIMEOUT,
expand_timeout,
dest->details->tree_view);
}
}
}
/* is the user looking at the latest messages? */
static gboolean
is_pinned_to_new (struct MsgData * data)
{
gboolean pinned_to_new = FALSE;
if (data->view == NULL)
{
pinned_to_new = TRUE;
}
else
{
GtkTreePath * last_visible;
if (gtk_tree_view_get_visible_range (data->view, NULL, &last_visible))
{
GtkTreeIter iter;
const int row_count = gtk_tree_model_iter_n_children (data->sort, NULL);
if (gtk_tree_model_iter_nth_child (data->sort, &iter, NULL, row_count-1))
{
GtkTreePath * last_row = gtk_tree_model_get_path (data->sort, &iter);
pinned_to_new = !gtk_tree_path_compare (last_visible, last_row);
gtk_tree_path_free (last_row);
}
gtk_tree_path_free (last_visible);
}
}
return pinned_to_new;
}
void
gd_main_view_generic_set_rubberband_range (GdMainViewGeneric *self,
GtkTreePath *start,
GtkTreePath *end)
{
RubberbandInfo *info;
info = get_rubber_band_info (self);
if (start == NULL || end == NULL)
{
g_clear_pointer (&info->rubberband_start,
gtk_tree_path_free);
g_clear_pointer (&info->rubberband_end,
gtk_tree_path_free);
}
else
{
if (gtk_tree_path_compare (start, end) < 0)
{
info->rubberband_start = gtk_tree_path_copy (start);
info->rubberband_end = gtk_tree_path_copy (end);
}
else
{
info->rubberband_start = gtk_tree_path_copy (end);
info->rubberband_end = gtk_tree_path_copy (start);
}
}
gtk_widget_queue_draw (GTK_WIDGET (self));
}
static void
gimp_scale_combo_box_mru_add (GimpScaleComboBox *combo_box,
GtkTreeIter *iter)
{
GtkTreeModel *model = gtk_combo_box_get_model (GTK_COMBO_BOX (combo_box));
GtkTreePath *path = gtk_tree_model_get_path (model, iter);
GList *list;
gboolean found;
for (list = combo_box->mru, found = FALSE; list && !found; list = list->next)
{
GtkTreePath *this = gtk_tree_row_reference_get_path (list->data);
if (gtk_tree_path_compare (this, path) == 0)
{
if (list->prev)
{
combo_box->mru = g_list_remove_link (combo_box->mru, list);
combo_box->mru = g_list_concat (list, combo_box->mru);
}
found = TRUE;
}
gtk_tree_path_free (this);
}
if (! found)
combo_box->mru = g_list_prepend (combo_box->mru,
gtk_tree_row_reference_new (model, path));
gtk_tree_path_free (path);
}
static void renderer_toggled(GtkCellRendererToggle * cell,
gchar * path_string, gpointer user_data)
{
GtkTreePath *path, *sel_path = NULL;
GtkTreeIter iter, sel_iter;
GtkTreeSelection *sel;
struct menu *menu;
path = gtk_tree_path_new_from_string(path_string);
if (!gtk_tree_model_get_iter(model2, &iter, path))
return;
sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree2_w));
if (gtk_tree_selection_get_selected(sel, NULL, &sel_iter))
sel_path = gtk_tree_model_get_path(model2, &sel_iter);
if (!sel_path)
goto out1;
if (gtk_tree_path_compare(path, sel_path))
goto out2;
gtk_tree_model_get(model2, &iter, COL_MENU, &menu, -1);
toggle_sym_value(menu);
out2:
gtk_tree_path_free(sel_path);
out1:
gtk_tree_path_free(path);
}
/*
* env tree view value editing cancelled (Escape pressed)
*/
static void on_value_editing_cancelled(GtkCellRenderer *renderer, gpointer user_data)
{
/* check whether escape was pressed when editing
new variable value cell */
GtkTreePath *empty_path = gtk_tree_row_reference_get_path(empty_row);
if(!gtk_tree_path_compare(being_edited_value, empty_path))
{
/* if so - clear name sell */
GtkTreeIter iter;
gtk_tree_model_get_iter(model, &iter, being_edited_value);
gtk_list_store_set (
store,
&iter,
NAME, "",
-1);
entering_new_var = FALSE;
}
g_object_set (renderer_value, "editable", FALSE, NULL);
gtk_tree_path_free(being_edited_value);
gtk_tree_path_free(empty_path);
}
/*
* env tree view value changed hadler
*/
static void on_value_changed(GtkCellRendererText *renderer, gchar *path, gchar *new_text, gpointer user_data)
{
GtkTreeIter iter;
GtkTreePath *tree_path = gtk_tree_path_new_from_string (path);
gboolean empty = !gtk_tree_path_compare(tree_path, gtk_tree_row_reference_get_path(empty_row));
gboolean res = gtk_tree_model_get_iter (
model,
&iter,
tree_path);
gchar *striped = g_strstrip(g_strdup(new_text));
if (!strlen(striped))
{
/* if new value is empty string, if it's a new row - do nothig
otheerwise - offer to delete a variable */
if (empty)
gtk_list_store_set(store, &iter, NAME, "", -1);
else
{
if (dialogs_show_question(_("Delete variable?")))
{
delete_selected_rows();
gtk_widget_grab_focus(envtree);
}
}
}
else
{
/* if old variable - change value, otherwise - add another empty row below */
gchar* oldvalue;
gtk_tree_model_get (
model,
&iter,
VALUE, &oldvalue,
-1);
if (strcmp(oldvalue, striped))
{
gtk_list_store_set(store, &iter, VALUE, striped, -1);
if (empty)
add_empty_row();
g_object_set (renderer_value, "editable", FALSE, NULL);
}
g_free(oldvalue);
}
if (empty)
entering_new_var = FALSE;
gtk_tree_path_free(tree_path);
g_free(striped);
gtk_tree_path_free(being_edited_value);
}
/*
* text has been dragged into the watch tree view
*/
static void on_watch_dragged_callback(GtkWidget *wgt, GdkDragContext *context, int x, int y,
GtkSelectionData *seldata, guint info, guint _time,
gpointer userdata)
{
/* string that is dragged */
gchar *expression = (gchar*)seldata->data;
GtkTreePath *path = NULL;
GtkTreeViewDropPosition pos;
GtkTreePath *empty_path;
GtkTreeIter newvar;
/* lookup for where the text has been dropped */
gtk_tree_view_get_dest_row_at_pos(GTK_TREE_VIEW(wtree), x, y, &path, &pos);
/* if dropped into last row - insert before it */
empty_path = wtree_empty_path();
if (!gtk_tree_path_compare(empty_path, path))
pos = GTK_TREE_VIEW_DROP_BEFORE;
gtk_tree_path_free(empty_path);
/* if dropped into children area - insert before parent */
if (gtk_tree_path_get_depth(path) > 1)
{
while (gtk_tree_path_get_depth(path) > 1)
gtk_tree_path_up(path);
pos = GTK_TREE_VIEW_DROP_BEFORE;
}
/* insert new row */
if (path)
{
GtkTreeIter sibling;
gtk_tree_model_get_iter(wmodel, &sibling, path);
if (GTK_TREE_VIEW_DROP_BEFORE == pos || GTK_TREE_VIEW_DROP_INTO_OR_BEFORE == pos)
gtk_tree_store_insert_before(wstore, &newvar, NULL, &sibling);
else
gtk_tree_store_insert_after(wstore, &newvar, NULL, &sibling);
}
else
{
GtkTreeIter empty;
wtree_empty_row(&empty);
gtk_tree_store_insert_before(wstore, &newvar, NULL, &empty);
}
/* if debugger is active (in stopped condition) - add to run-time watch list
* if not - just set new expession in the tree view */
if (DBS_STOPPED == debug_state)
{
variable *var = active_module->add_watch(expression);
change_watch(GTK_TREE_VIEW(wtree), &newvar, var);
}
else
variable_set_name_only(wstore, &newvar, expression);
config_set_debug_changed();
}
gboolean keyword_compare(GtkTreeModel *keyword_tree, GtkTreeIter *a, GtkTreeIter *b)
{
GtkTreePath *pa = gtk_tree_model_get_path(keyword_tree, a);
GtkTreePath *pb = gtk_tree_model_get_path(keyword_tree, b);
gint ret = gtk_tree_path_compare(pa, pb);
gtk_tree_path_free(pa);
gtk_tree_path_free(pb);
return ret;
}
static void
filename_cell_data_func (GtkTreeViewColumn *column,
GtkCellRenderer *renderer,
GtkTreeModel *model,
GtkTreeIter *iter,
FMListView *view)
{
char *text;
char *color;
GdkRGBA rgba;
GtkTreePath *path, *hover_path;
PangoUnderline underline;
gtk_tree_model_get (model, iter,
FM_LIST_MODEL_FILENAME, &text,
-1);
gtk_tree_model_get (model, iter,
FM_LIST_MODEL_COLOR, &color,
-1);
if (color != NULL) {
gdk_rgba_parse (&rgba, color);
//rgba.alpha = 0.85;
}
/*if (color) {
GList *lrenderers = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT(column));
GList *l;
for (l=lrenderers; l != NULL; l=l->next)
g_object_set(l->data, "cell-background", color, NULL);
g_list_free (lrenderers);
}
g_free (color);*/
underline = PANGO_UNDERLINE_NONE;
if (exo_tree_view_get_single_click (EXO_TREE_VIEW (view->tree))) {
path = gtk_tree_model_get_path (model, iter);
hover_path = exo_tree_view_get_hover_path (EXO_TREE_VIEW (view->tree));
if (hover_path == NULL || gtk_tree_path_compare (path, hover_path)) {
underline = PANGO_UNDERLINE_NONE;
} else {
underline = PANGO_UNDERLINE_SINGLE;
}
gtk_tree_path_free (path);
}
g_object_set (G_OBJECT (renderer),
"text", text,
"underline", underline,
//"cell-background", color,
"cell-background-rgba", &rgba,
NULL);
g_free (text);
}
static VALUE
rg_operator_treepath_equal(VALUE self, VALUE other)
{
if (!RVAL2CBOOL(rb_funcall(CLASS_OF(self), id_equal, 1, CLASS_OF(other)))) {
return Qfalse;
}
return CBOOL2RVAL(gtk_tree_path_compare(_SELF(self), _SELF(other)) == 0);
}
static void mimeview_selection_changed(GtkTreeSelection *selection,
MimeView *mimeview)
{
GtkTreeModel *model = GTK_TREE_MODEL(mimeview->store);
GtkTreeIter iter;
GtkTreePath *path;
MimeInfo *partinfo;
if (!gtk_tree_selection_get_selected(selection, NULL, &iter)) {
if (mimeview->opened) {
gtk_tree_path_free(mimeview->opened);
mimeview->opened = NULL;
}
return;
}
path = gtk_tree_model_get_path(model, &iter);
if (mimeview->opened &&
gtk_tree_path_compare(mimeview->opened, path) == 0) {
gtk_tree_path_free(path);
return;
}
gtk_tree_path_free(mimeview->opened);
mimeview->opened = path;
path = NULL;
gtk_tree_model_get(model, &iter, COL_MIME_INFO, &partinfo, -1);
if (!partinfo)
return;
switch (partinfo->mime_type) {
case MIME_TEXT:
case MIME_TEXT_HTML:
case MIME_MESSAGE_RFC822:
case MIME_MULTIPART:
mimeview_show_message_part(mimeview, partinfo);
break;
case MIME_IMAGE:
if (prefs_common.inline_image) {
mimeview_show_image_part(mimeview, partinfo);
break;
}
/* FALLTHROUGH */
default:
mimeview_change_view_type(mimeview, MIMEVIEW_TEXT);
#if USE_GPGME
if (rfc2015_is_signature_part(partinfo))
mimeview_show_signature_part(mimeview, partinfo);
else
#endif
mimeview_show_mime_part(mimeview, partinfo);
break;
}
}
/*
* Handles same tree row click to open frame position
*/
static gboolean on_msgwin_button_press(GtkWidget *widget, GdkEventButton *event, gpointer user_data)
{
if (event->type == GDK_BUTTON_PRESS)
{
GtkTreePath *pressed_path = NULL;
if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(tree), (int)event->x, (int)event->y, &pressed_path, NULL, NULL, NULL))
{
if (2 == gtk_tree_path_get_depth(pressed_path))
{
GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
GList *rows = gtk_tree_selection_get_selected_rows(selection, &model);
GtkTreePath *selected_path = (GtkTreePath*)rows->data;
if (!gtk_tree_path_compare(pressed_path, selected_path))
{
GtkTreeIter iter;
gtk_tree_model_get_iter (
model,
&iter,
pressed_path);
gboolean have_source;
gtk_tree_model_get (
model,
&iter,
S_HAVE_SOURCE, &have_source,
-1);
/* check if file name is not empty and we have source files for the frame */
if (have_source)
{
gchar *file;
gint line;
gtk_tree_model_get (
model,
&iter,
S_FILEPATH, &file,
S_LINE, &line,
-1);
callback(file, line);
g_free(file);
}
}
g_list_foreach (rows, (GFunc) gtk_tree_path_free, NULL);
g_list_free (rows);
}
gtk_tree_path_free(pressed_path);
}
}
return FALSE;
}
/*#
@method compare GtkTreePath
@brief Compares two paths.
@param b A GtkTreePath to compare with.
@return The relative positions of a and b
If a appears before b in a tree, then -1 is returned.
If b appears before a, then 1 is returned.
If the two nodes are equal, then 0 is returned.
*/
FALCON_FUNC TreePath::compare( VMARG )
{
Item* i_b = vm->param( 0 );
#ifndef NO_PARAMETER_CHECK
if ( !i_b || !i_b->isObject() || !IS_DERIVED( i_b, GtkTreePath ) )
throw_inv_params( "GtkTreePath" );
#endif
GtkTreePath* b = GET_TREEPATH( *i_b );
MYSELF;
vm->retval( gtk_tree_path_compare( self->getTreePath(), b ) );
}
/*
* env tree view name changed hadler
*/
static void on_name_changed(GtkCellRendererText *renderer, gchar *path, gchar *new_text, gpointer user_data)
{
GtkTreeIter iter;
GtkTreePath *tree_path = gtk_tree_path_new_from_string (path);
GtkTreePath *empty_path = gtk_tree_row_reference_get_path(empty_row);
gboolean empty = !gtk_tree_path_compare(tree_path, empty_path);
gtk_tree_model_get_iter (
model,
&iter,
tree_path);
gchar* oldvalue;
gtk_tree_model_get (
model,
&iter,
NAME, &oldvalue,
-1);
gchar *striped = g_strstrip(g_strdup(new_text));
if (!strlen(striped))
{
/* if name is empty - offer to delete variable */
if (!empty && dialogs_show_question(_("Delete variable?")))
{
delete_selected_rows();
config_set_debug_changed();
gtk_widget_grab_focus(tree);
}
}
else if (strcmp(oldvalue, striped))
{
gtk_list_store_set(store, &iter, NAME, striped, -1);
if (empty)
{
/* if it was a new row - move cursor to a value cell */
entering_new_var = TRUE;
gtk_tree_view_set_cursor_on_cell(GTK_TREE_VIEW(tree), tree_path, column_value, renderer_value, TRUE);
}
if (!empty)
{
config_set_debug_changed();
}
}
gtk_tree_path_free(tree_path);
gtk_tree_path_free(empty_path);
g_free(oldvalue);
g_free(striped);
}
static void
rows_reordered_cb (GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer new_order, RBDisplayPageMenu *menu)
{
GtkTreePath *root;
root = get_root_path (menu);
if (root != NULL) {
if (gtk_tree_path_compare (path, root) == 0)
rebuild_menu (menu);
gtk_tree_path_free (root);
}
}
static VALUE
rg_operator_treeiter_eql(VALUE self, VALUE other)
{
gint i, num1, num2;
GtkTreeIter* iter1 = _SELF(self);
GtkTreeIter* iter2;
GtkTreeModel* model1;
GtkTreeModel* model2;
GtkTreePath* path1;
GtkTreePath* path2;
if (!rb_obj_is_kind_of(other, GTYPE2CLASS(GTK_TYPE_TREE_ITER)))
return Qfalse;
iter2 = _SELF(other);
model1 = (GtkTreeModel*)iter1->user_data3;
model2 = (GtkTreeModel*)iter2->user_data3;
if (model1 != model2) return Qfalse;
num1 = gtk_tree_model_get_n_columns(model1);
num2 = gtk_tree_model_get_n_columns(model2);
if (num1 != num2) return Qfalse;
path1 = gtk_tree_model_get_path(model1, iter1);
path2 = gtk_tree_model_get_path(model2, iter2);
if (gtk_tree_path_compare(path1, path2) != 0) {
gtk_tree_path_free(path1);
gtk_tree_path_free(path2);
return Qfalse;
} else {
gtk_tree_path_free(path1);
gtk_tree_path_free(path2);
}
for (i = 0; i < num1; i++){
GValue gval1 = G_VALUE_INIT;
GValue gval2 = G_VALUE_INIT;
VALUE ret1, ret2;
gtk_tree_model_get_value(model1, iter1, i, &gval1);
gtk_tree_model_get_value(model2, iter2, i, &gval2);
ret1 = GVAL2RVAL(&gval1);
ret2 = GVAL2RVAL(&gval2);
g_value_unset(&gval1);
g_value_unset(&gval2);
if (rb_equal(ret1, ret2) == Qfalse)
return Qfalse;
}
return Qtrue;
}
static void
libre_impuesto_sync_selection(LibreImpuesto * impuesto, const gchar * args)
{
GtkWindow * impuesto_window = libre_impuesto_get_active_window(impuesto);
GtkWidget * notebook, * switcher;
GtkWidget * page_child, * tree_view;
GtkTreeSelection * selection;
GtkTreeIter selected;
GtkTreePath * page_path, * tree_path;
GtkWidget * page_tree_view;
notebook = g_object_get_data ( G_OBJECT(impuesto_window), "notebook");
switcher = g_object_get_data ( G_OBJECT(impuesto_window), "switcher");
page_child = gtk_notebook_get_nth_page (GTK_NOTEBOOK(notebook),
gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook) ));
page_path = g_object_get_data ( G_OBJECT(page_child), "path" );
page_tree_view = g_object_get_data ( G_OBJECT(page_child), "tree-view" );
tree_view = gtk_stack_get_visible_child(gtk_stack_switcher_get_stack (GTK_STACK_SWITCHER(switcher)));
tree_view = gtk_bin_get_child(GTK_BIN(tree_view));
selection = gtk_tree_view_get_selection ( GTK_TREE_VIEW(tree_view) );
gtk_tree_selection_get_selected (selection, NULL, &selected);
if (page_path == NULL || page_tree_view == NULL ) {
gtk_tree_selection_unselect_all( selection );
return;
}
if ( gtk_tree_selection_count_selected_rows(selection) > 0 ) {
tree_path = gtk_tree_model_get_path (gtk_tree_view_get_model(GTK_TREE_VIEW(tree_view)), &selected);
if ( gtk_tree_path_compare( page_path, tree_path ) != 0 ) {
tree_view = g_object_get_data ( G_OBJECT(page_child), "tree-view" );
selection = gtk_tree_view_get_selection ( GTK_TREE_VIEW(tree_view) );
gtk_tree_selection_select_path ( selection, page_path );
tree_view = gtk_widget_get_parent ( GTK_WIDGET(tree_view) );
gtk_stack_set_visible_child (gtk_stack_switcher_get_stack (GTK_STACK_SWITCHER(switcher)), tree_view );
}
gtk_tree_path_free(tree_path);
}
else {
tree_view = g_object_get_data ( G_OBJECT(page_child), "tree-view" );
selection = gtk_tree_view_get_selection ( GTK_TREE_VIEW(tree_view) );
gtk_tree_selection_select_path ( selection, page_path );
tree_view = gtk_widget_get_parent ( GTK_WIDGET(tree_view) );
gtk_stack_set_visible_child (gtk_stack_switcher_get_stack (GTK_STACK_SWITCHER(switcher)), tree_view );
}
}
/**
* callback called when toggle a radio button of an archive
* we want only 1 toggle, so erase the others before
*
* \param renderer
* \param path
* \param assistant
*
* \return FALSE
* */
static gboolean gsb_assistant_archive_export_toggled ( GtkCellRendererToggle *renderer,
gchar *path_string,
GtkWidget *assistant )
{
GtkTreeIter iter;
gboolean value;
GtkTreePath *path;
GtkTreePath *path_clicked;
GtkTreeModel *model;
gboolean selected = FALSE;
model = gtk_tree_view_get_model (GTK_TREE_VIEW (archive_export_treeview));
path_clicked = gtk_tree_path_new_from_string (path_string);
path = gtk_tree_path_new_first ();
while (gtk_tree_model_get_iter ( GTK_TREE_MODEL (model),
&iter,
path ))
{
/* if we are on the clicked path, we invert the value,
* else, we set the value to 0 */
if (gtk_tree_path_compare (path, path_clicked))
/* the 2 path are different */
value = 0;
else
{
/* the paths are equal */
gtk_tree_model_get ( GTK_TREE_MODEL (model),
&iter,
ARCHIVES_EXPORT_SELECT_COLUMN, &value,
-1 );
value = !value;
/* we will unsensitive the next button only if something chosen */
if (value)
selected = TRUE;
}
gtk_list_store_set ( GTK_LIST_STORE (model),
&iter,
ARCHIVES_EXPORT_SELECT_COLUMN, value,
-1 );
gtk_tree_path_next (path);
}
gtk_tree_path_free (path);
gtk_tree_path_free (path_clicked);
gsb_assistant_sensitive_button_next (assistant, selected);
return FALSE;
}
static gboolean topmost_selected(GtkTreeModel *model, GtkTreeIter *iter, gboolean first)
{
GtkTreePath *path, *first_path;
gboolean ret, is_first;
first_path = gtk_tree_path_new_first();
path = gtk_tree_model_get_path(model, iter);
is_first = gtk_tree_path_compare(first_path, path) == 0;
ret = gtk_tree_path_get_depth(path) == 1 && ((is_first && first) || (!is_first && !first));
gtk_tree_path_free(first_path);
gtk_tree_path_free(path);
return ret;
}
static gboolean tree_keypress(GtkTreeView *t, GdkEventKey *event, GtkWidget *entry)
{
if(event->keyval == GDK_Return) {
submit();
gtk_dialog_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
}
if(event->keyval == GDK_Up) {
GtkTreePath *current;
gtk_tree_view_get_cursor(t, ¤t, NULL);
if(gtk_tree_path_compare(current,first) == 0) {
gtk_widget_grab_focus(entry);
}
}
return FALSE;
}
gboolean vdtree_set_fd(ViewDir *vd, FileData *dir_fd)
{
FileData *fd;
GtkTreeIter iter;
if (!dir_fd) return FALSE;
if (vd->dir_fd == dir_fd) return TRUE;
file_data_unref(vd->dir_fd);
vd->dir_fd = file_data_ref(dir_fd);;
fd = vdtree_populate_path(vd, vd->dir_fd, TRUE, FALSE);
if (!fd) return FALSE;
if (vd_find_row(vd, fd, &iter))
{
GtkTreeModel *store;
GtkTreePath *tpath, *old_tpath;
GtkTreeSelection *selection;
store = gtk_tree_view_get_model(GTK_TREE_VIEW(vd->view));
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(vd->view));
/* hack, such that selection is only allowed to be changed from here */
selection_is_ok = TRUE;
gtk_tree_selection_select_iter(selection, &iter);
selection_is_ok = FALSE;
gtk_tree_view_get_cursor(GTK_TREE_VIEW(vd->view), &old_tpath, NULL);
tpath = gtk_tree_model_get_path(store, &iter);
if (!old_tpath || gtk_tree_path_compare(tpath, old_tpath) != 0)
{
/* setting the cursor scrolls the view; do not do that unless it is necessary */
gtk_tree_view_set_cursor(GTK_TREE_VIEW(vd->view), tpath, NULL, FALSE);
/* gtk_tree_view_set_cursor scrolls the window itself, but it sometimes
does not work (switch from dir_list to dir_tree) */
tree_view_row_make_visible(GTK_TREE_VIEW(vd->view), &iter, TRUE);
}
gtk_tree_path_free(tpath);
gtk_tree_path_free(old_tpath);
}
return TRUE;
}
gboolean utils_files_charmap_active_toggled ( GtkCellRendererToggle *cell,
gchar *path_str,
gpointer model )
{
GtkWidget *dialog;
GtkTreePath *path = gtk_tree_path_new_from_string ( path_str );
GtkTreePath *tmp_path;
GtkTreeIter iter;
gchar *enc;
gboolean toggle_item;
/* on commence par initialiser les données */
dialog = g_object_get_data ( G_OBJECT ( model ), "dialog" );
gtk_dialog_set_response_sensitive ( GTK_DIALOG ( dialog ), GTK_RESPONSE_OK, FALSE );
tmp_path = gtk_tree_path_new_first ( );
gtk_tree_model_get_iter_first ( GTK_TREE_MODEL ( model ), &iter );
do
{
gtk_tree_model_get ( GTK_TREE_MODEL ( model ), &iter,
IMPORT_CHARMAP_SELECTED, &toggle_item,
IMPORT_CHARMAP_ENCODING, &enc, -1 );
tmp_path = gtk_tree_model_get_path ( GTK_TREE_MODEL ( model ), &iter );
if ( gtk_tree_path_compare ( path, tmp_path ) == 0 )
{
gtk_list_store_set ( GTK_LIST_STORE ( model ), &iter,
IMPORT_CHARMAP_SELECTED, !toggle_item, -1 );
if ( toggle_item == 0 )
{
GOCharmapSel *cs;
cs = g_object_get_data ( G_OBJECT ( dialog ), "charset_cs" );
go_charmap_sel_set_encoding (cs, enc);
g_object_set_data ( G_OBJECT ( dialog ), "charset", enc );
gtk_dialog_set_response_sensitive ( GTK_DIALOG ( dialog ),
GTK_RESPONSE_OK, TRUE );
}
}
else
gtk_list_store_set ( GTK_LIST_STORE ( model ), &iter,
IMPORT_CHARMAP_SELECTED, FALSE, -1 );
}
while ( gtk_tree_model_iter_next ( GTK_TREE_MODEL ( model ), &iter ) );
return FALSE;
}
gboolean on_dnd_dest_query_info(FmDndDest* dd, int x, int y,
GdkDragAction* action, FmPlacesView* view)
{
GtkTreeViewDropPosition pos;
GtkTreePath* tp = NULL;
GtkTreeViewColumn* col;
if(gtk_tree_view_get_dest_row_at_pos((GtkTreeView*)view, x, y, &tp, &pos))
{
/* FIXME: this is inefficient. we should record the index of separator instead. */
if(pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE || pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER)
{
}
else
{
GtkTreePath* sep = gtk_tree_model_get_path(GTK_TREE_MODEL(model), &sep_it);
if(gtk_tree_path_compare(sep, tp) < 0) /* tp is after sep */
{
*action = GDK_ACTION_LINK;
}
else
{
*action = 0;
gtk_tree_path_free(tp);
tp = NULL;
}
gtk_tree_path_free(sep);
}
}
else
{
tp = gtk_tree_path_new_from_indices(gtk_tree_model_iter_n_children(GTK_TREE_MODEL(model), NULL)-1, -1);
pos = GTK_TREE_VIEW_DROP_AFTER;
*action = GDK_ACTION_LINK;
}
gtk_tree_view_set_drag_dest_row((GtkTreeView*)view, tp, pos);
fm_dnd_dest_set_dest_file(view->dnd_dest, NULL);
if(view->dest_row)
gtk_tree_path_free(view->dest_row);
view->dest_row = tp;
view->dest_pos = pos;
return TRUE;
}