void PluginManageDlg::drag_data_received_cb(GtkWidget *widget, GdkDragContext *ctx, guint x, guint y, GtkSelectionData *sd, guint info, guint t, PluginManageDlg *oPluginManageDlg) { if (gtk_selection_data_get_target(sd) == gdk_atom_intern("STARDICT_PLUGINMANAGE", FALSE) && gtk_selection_data_get_data(sd)) { GtkTreePath *path = NULL; GtkTreeViewDropPosition position; GtkTreeIter drag_iter; memcpy(&drag_iter, gtk_selection_data_get_data(sd), sizeof(drag_iter)); if (gtk_tree_view_get_dest_row_at_pos(GTK_TREE_VIEW(widget), x, y, &path, &position)) { GtkTreeIter iter; GtkTreeModel *model = GTK_TREE_MODEL(oPluginManageDlg->plugin_tree_model); gtk_tree_model_get_iter(model, &iter, path); if (gtk_tree_model_iter_has_child(model, &iter)) { gtk_drag_finish (ctx, FALSE, FALSE, t); return; } if (gtk_tree_model_iter_has_child(model, &drag_iter)) { gtk_drag_finish (ctx, FALSE, FALSE, t); return; } GtkTreeIter parent_iter; if (!gtk_tree_model_iter_parent(model, &parent_iter, &iter)) { gtk_drag_finish (ctx, FALSE, FALSE, t); return; } GtkTreeIter drag_parent_iter; if (!gtk_tree_model_iter_parent(model, &drag_parent_iter, &drag_iter)) { gtk_drag_finish (ctx, FALSE, FALSE, t); return; } char *iter_str, *drag_iter_str; iter_str = gtk_tree_model_get_string_from_iter(model, &parent_iter); drag_iter_str = gtk_tree_model_get_string_from_iter(model, &drag_parent_iter); if (strcmp(iter_str, drag_iter_str) != 0) { g_free(iter_str); g_free(drag_iter_str); gtk_drag_finish (ctx, FALSE, FALSE, t); return; } g_free(iter_str); g_free(drag_iter_str); switch (position) { case GTK_TREE_VIEW_DROP_AFTER: case GTK_TREE_VIEW_DROP_INTO_OR_AFTER: gtk_tree_store_move_after(GTK_TREE_STORE(model), &drag_iter, &iter); break; case GTK_TREE_VIEW_DROP_BEFORE: case GTK_TREE_VIEW_DROP_INTO_OR_BEFORE: gtk_tree_store_move_before(GTK_TREE_STORE(model), &drag_iter, &iter); break; default: { gtk_drag_finish (ctx, FALSE, FALSE, t); return; } } oPluginManageDlg->write_order_list(); oPluginManageDlg->order_changed_ = true; gtk_drag_finish (ctx, TRUE, FALSE, t); } } }
static gint bar_pane_keywords_dnd_motion(GtkWidget *tree_view, GdkDragContext *context, gint x, gint y, guint time, gpointer data) { GtkTreePath *tpath = NULL; GtkTreeViewDropPosition pos; gtk_tree_view_get_dest_row_at_pos(GTK_TREE_VIEW(tree_view), x, y, &tpath, &pos); if (tpath) { GtkTreeModel *model; GtkTreeIter dest_iter; model = gtk_tree_view_get_model(GTK_TREE_VIEW(tree_view)); gtk_tree_model_get_iter(model, &dest_iter, tpath); if (pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE && gtk_tree_model_iter_has_child(model, &dest_iter)) pos = GTK_TREE_VIEW_DROP_BEFORE; if (pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER && gtk_tree_model_iter_has_child(model, &dest_iter)) pos = GTK_TREE_VIEW_DROP_AFTER; } gtk_tree_view_set_drag_dest_row(GTK_TREE_VIEW(tree_view), tpath, pos); gtk_tree_path_free(tpath); if (tree_view == gtk_drag_get_source_widget(context)) gdk_drag_status(context, GDK_ACTION_MOVE, time); else gdk_drag_status(context, GDK_ACTION_COPY, time); return TRUE; }
void set_cell(GtkCellLayout *cell_layout, GtkCellRenderer *cell, GtkTreeModel *tree_model, GtkTreeIter *iter, gpointer data) { gboolean header; gchar *text; IpodInfo *info; gtk_tree_model_get(tree_model, iter, COL_POINTER, &info, -1); g_return_if_fail (info); header = gtk_tree_model_iter_has_child(tree_model, iter); if (header) { text = g_strdup(itdb_info_get_ipod_generation_string(info->ipod_generation)); } else { if (info->capacity >= 1) { /* size in GB */ text = g_strdup_printf(_("%2.0f GB %s (x%s)"), info->capacity, itdb_info_get_ipod_model_name_string(info->ipod_model), info->model_number); } else if (info->capacity > 0) { /* size in MB */ text = g_strdup_printf(_("%3.0f MB %s (x%s)"), info->capacity * 1024, itdb_info_get_ipod_model_name_string(info->ipod_model), info->model_number); } else { /* no capacity information available */ text = g_strdup_printf(_("%s (x%s)"), itdb_info_get_ipod_model_name_string(info->ipod_model), info->model_number); } } g_object_set(cell, "sensitive", !header, "text", text, NULL); g_free(text); }
void idol_subtitle_encoding_set (GtkComboBox * combo, const char *encoding) { GtkTreeModel *model; GtkTreeIter iter, iter2; gint enc_index, i; g_return_if_fail (encoding != NULL); model = gtk_combo_box_get_model (combo); enc_index = subtitle_encoding_get_index (encoding); gtk_tree_model_get_iter_first (model, &iter); do { if (!gtk_tree_model_iter_has_child (model, &iter)) continue; if (!gtk_tree_model_iter_children (model, &iter2, &iter)) continue; do { gtk_tree_model_get (model, &iter2, INDEX_COL, &i, -1); if (i == enc_index) break; } while (gtk_tree_model_iter_next (model, &iter2)); if (i == enc_index) break; } while (gtk_tree_model_iter_next (model, &iter)); gtk_combo_box_set_active_iter (combo, &iter2); }
/** @brief helper function to recursively copy a treestore @param srcmodel treemodel for store being copied @param srcparent pointer to source treeiter which has been confirmed to have child(ren) @param deststore the store to which data is being copied @param destparent pointer to destination store treeiter @param ncols no. of columns in @a model @param colnums array of column indices @param types array of GTypes corresponding to columns @param values array in which to store values being transferred @return */ static void _e2_tree_copy_descendants ( GtkTreeModel *srcmodel, GtkTreeIter *srcparent, GtkTreeStore *deststore, GtkTreeIter *destparent, gint ncols, gint colnums[], GType types[], GValue values[]) { GtkTreeIter child; if (gtk_tree_model_iter_children (srcmodel, &child, srcparent)) { gint i; GtkTreeIter dest; do { //read iter into pointers array for (i = 0; i < ncols; i++) gtk_tree_model_get_value (srcmodel, &child, i, &values[i]); #ifdef USE_GTK2_10 gtk_tree_store_insert_with_valuesv (deststore, &dest, destparent, -1, colnums, values, ncols); for (i = 0; i < ncols; i++) g_value_unset (&values[i]); #else gtk_tree_store_append (deststore, &dest, destparent); for (i = 0; i < ncols; i++) { gtk_tree_store_set_value (deststore, &dest, i, &values[i]); g_value_unset (&values[i]); } #endif if (gtk_tree_model_iter_has_child (srcmodel, &child)) _e2_tree_copy_descendants (srcmodel, &child, deststore, &dest, ncols, colnums, types, values); } while (gtk_tree_model_iter_next (srcmodel, &child)); } }
static void dspy_introspection_model_get_value (GtkTreeModel *model, GtkTreeIter *iter, gint column, GValue *value) { LOG_DEBUG (G_STRFUNC); if (column == 0) { DspyNode *node = iter->user_data; g_autofree gchar *str = NULL; g_assert (node != NULL); g_assert (DSPY_IS_NODE (node)); g_value_init (value, G_TYPE_STRING); str = _dspy_node_get_text (node); if (_dspy_node_is_group (node)) { if (gtk_tree_model_iter_has_child (model, iter)) g_value_take_string (value, g_strdup_printf ("<b>%s</b>", str)); else g_value_take_string (value, g_strdup_printf ("<span fgalpha='25000' weight='bold'>%s</span>", str)); } else g_value_take_string (value, g_steal_pointer (&str)); } }
static void set_cell (GtkCellLayout *cell_layout, GtkCellRenderer *cell, GtkTreeModel *tree_model, GtkTreeIter *iter, gpointer data) { gboolean header; gchar *text; Itdb_IpodInfo *info; gtk_tree_model_get (tree_model, iter, COL_INFO, &info, -1); g_return_if_fail (info); header = gtk_tree_model_iter_has_child (tree_model, iter); if (header) { text = g_strdup ( itdb_info_get_ipod_generation_string (info->ipod_generation)); } else { text = ipod_info_to_string (info); } g_object_set (cell, "sensitive", !header, "text", text, NULL); g_free (text); }
static void node_tree_selection_changed_cb ( LibreImpuestoWindow *libre_impuesto_window, GtkTreeSelection *selection) { GtkTreeModel *model; GtkTreeIter iter; GList *list; gchar *form; LibreImpuestoCommand *impuesto_command; list = gtk_tree_selection_get_selected_rows (selection, &model); if (list == NULL) goto exit; gtk_tree_model_get_iter (model, &iter, list->data); if (!gtk_tree_model_iter_has_child (model, &iter)) { gtk_tree_model_get (model, &iter, 2, &form, -1); impuesto_command = libre_impuesto_get_command(libre_impuesto_window_get_impuesto(libre_impuesto_window)); libre_impuesto_queue_command (impuesto_command, IMPUESTO_COMMAND_OPEN_FORM, form, FALSE); g_free (form); } exit: g_list_free (list); }
static void tree_selection_collect_data_helper(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer user_data) { collect_data_struct_t *cdata = user_data; /* Collect the data of the parent row */ tree_selection_collect_data_record(model, iter, cdata, TRUE); /* If the row is not expanded and there are any children, collect their * data as well. This is not recursive and descends only one level */ if ( gtk_tree_model_iter_has_child(model, iter) && !gtk_tree_view_row_expanded(cdata->tv, path) ) { GtkTreeIter child; gint i = 0; while (gtk_tree_model_iter_nth_child(model, &child, iter, i)) { tree_selection_collect_data_record(model, &child, cdata, FALSE); i++; } } }
static void cm_delete_all_cookies_real(CookieManagerPage *cmp) { CookieManagerPagePrivate *priv = cmp->priv; GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(priv->treeview)); GtkTreeIter iter, iter_store, child; GtkTreePath *path_first, *path; path_first = gtk_tree_path_new_first(); while (gtk_tree_model_get_iter(model, &iter, path_first)) { path = gtk_tree_model_get_path(model, &iter); while (gtk_tree_model_iter_children(model, &child, &iter)) { cm_delete_cookie(cmp, model, &child); cm_store_remove(cmp, &child); /* we retrieve again the iter at path because it got invalid by the delete operation */ gtk_tree_model_get_iter(model, &iter, path); } gtk_tree_path_free(path); /* remove/hide the parent */ gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(priv->filter), &iter_store, &iter); if (gtk_tree_model_iter_has_child(GTK_TREE_MODEL(priv->store), &iter_store)) gtk_tree_store_set(priv->store, &iter_store, COOKIE_MANAGER_COL_VISIBLE, FALSE, -1); else cm_store_remove(cmp, &iter); } /* now that we deleted all matching cookies, we reset the filter */ gtk_entry_set_text(GTK_ENTRY(priv->filter_entry), ""); cm_set_button_sensitiveness(cmp, FALSE); cm_select_path(cmp, model, path_first); gtk_tree_path_free(path_first); }
void gnc_payment_acct_tree_row_activated_cb (GtkWidget *widget, GtkTreePath *path, GtkTreeViewColumn *column, PaymentWindow *pw) { GtkTreeView *view; GtkTreeModel *model; GtkTreeIter iter; g_return_if_fail(widget); view = GTK_TREE_VIEW(widget); model = gtk_tree_view_get_model(view); if (gtk_tree_model_get_iter(model, &iter, path)) { if (gtk_tree_model_iter_has_child(model, &iter)) { /* There are children, * just expand or collapse the row. */ if (gtk_tree_view_row_expanded(view, path)) gtk_tree_view_collapse_row(view, path); else gtk_tree_view_expand_row(view, path, FALSE); } else if (gnc_payment_window_check_payment (pw)) /* It's an account without any children * If all conditions for a valid payment are met click the Ok button. */ gnc_payment_ok_cb(widget, pw); } }
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); } } }
static void repair_filenames_subdir(GtkTreeModel* model, GtkTreeIter* iterparent, GFile* dir, GtkWidget* parent_window) { GtkTreeIter iter; gboolean res; res = gtk_tree_model_iter_children(model, &iter, iterparent); while (res) { char* name; char* new_name; GFile* file; gtk_tree_model_get(model, &iter, FILE_COLUMN_NAME, &name, FILE_COLUMN_NEW_NAME, &new_name, -1); file = g_file_get_child(dir, name); res = gtk_tree_model_iter_has_child(model, &iter); if (res) { repair_filenames_subdir(model, &iter, file, parent_window); } change_filename(file, new_name, parent_window); g_free(name); g_free(new_name); res = gtk_tree_model_iter_next(model, &iter); } }
static VALUE rg_has_child_p(VALUE self) { GtkTreeIter* iter = _SELF(self); GtkTreeModel* model = (GtkTreeModel*)iter->user_data3; return CBOOL2RVAL(gtk_tree_model_iter_has_child(model, iter)); }
static void contact_list_view_expander_cell_data_func (GtkTreeViewColumn *column, GtkCellRenderer *cell, GtkTreeModel *model, GtkTreeIter *iter, EmpathyContactListView *view) { gboolean is_group; gboolean is_active; gtk_tree_model_get (model, iter, EMPATHY_CONTACT_LIST_STORE_COL_IS_GROUP, &is_group, EMPATHY_CONTACT_LIST_STORE_COL_IS_ACTIVE, &is_active, -1); if (gtk_tree_model_iter_has_child (model, iter)) { GtkTreePath *path; gboolean row_expanded; path = gtk_tree_model_get_path (model, iter); row_expanded = gtk_tree_view_row_expanded (GTK_TREE_VIEW (column->tree_view), path); gtk_tree_path_free (path); g_object_set (cell, "visible", TRUE, "expander-style", row_expanded ? GTK_EXPANDER_EXPANDED : GTK_EXPANDER_COLLAPSED, NULL); } else { g_object_set (cell, "visible", FALSE, NULL); } contact_list_view_cell_set_background (view, cell, is_group, is_active); }
gboolean on_treeview_button_release_event(GtkWidget *widget, GdkEventButton *event, gpointer user_data) { GtkTreeSelection *selection = NULL; GtkTreeModel *gmodel; GtkTreeIter selected; gchar *key = NULL; selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(widget)); if (gtk_tree_selection_get_selected(selection, &gmodel, &selected)) { gtk_tree_model_get(gmodel, &selected, 3, &key, -1); if (!gtk_tree_model_iter_has_child(gmodel, &selected) && key != NULL) { gtk_widget_set_sensitive(button_new_folder, FALSE); gtk_widget_set_sensitive(button_add_bookmark, FALSE); } else { gtk_widget_set_sensitive(button_new_folder, TRUE); gtk_widget_set_sensitive(button_add_bookmark, TRUE); } if (key) g_free(key); } return FALSE; }
/* based on Gossip function */ static void gnomegadu_contact_list_expander_cell_data_func (GtkTreeViewColumn * column, GtkCellRenderer * cell, GtkTreeModel * model, GtkTreeIter * iter, GtkTreeView * list) { if (gtk_tree_model_iter_has_child (model, iter)) { GdkColor color; GtkStyle *style; GtkTreePath *path; gboolean row_expanded; path = gtk_tree_model_get_path (model, iter); row_expanded = gtk_tree_view_row_expanded (GTK_TREE_VIEW (column->tree_view), path); gtk_tree_path_free (path); g_object_set (cell, "visible", TRUE, "expander-style", row_expanded ? GTK_EXPANDER_EXPANDED : GTK_EXPANDER_COLLAPSED, NULL); style = gtk_widget_get_style (GTK_WIDGET (list)); color = style->text_aa[GTK_STATE_INSENSITIVE]; color.red = (color.red + (style->white).red) / 2; color.green = (color.green + (style->white).green) / 2; color.blue = (color.blue + (style->white).blue) / 2; g_object_set (cell, "cell-background-gdk", &color, NULL); } else { g_object_set (cell, "visible", FALSE, NULL); } }
static void vinagre_bookmarks_tree_row_activated_cb (GtkTreeView *treeview, GtkTreePath *path, GtkTreeViewColumn *column, VinagreBookmarksTree *tree) { GtkTreeIter iter; GtkTreeModel *model; GtkWidget *toplevel; model = gtk_tree_view_get_model (treeview); gtk_tree_model_get_iter (model, &iter, path); if (gtk_tree_model_iter_has_child (model, &iter)) { if (gtk_tree_view_row_expanded (treeview, path)) gtk_tree_view_collapse_row (treeview, path); else gtk_tree_view_expand_row (treeview, path, FALSE); return; } else { toplevel = gtk_widget_get_toplevel (GTK_WIDGET (tree)); if (GTK_IS_WINDOW (toplevel)) gtk_window_activate_default (GTK_WINDOW (toplevel)); } }
/* Called when the user double clicks on a net in the left treeview. */ static void net_selection_double_click_cb (GtkTreeView * treeview, GtkTreePath * path, GtkTreeViewColumn * col, gpointer data) { GtkTreeModel *model; GtkTreeIter iter; gchar *str; LibraryMenuType *menu; model = gtk_tree_view_get_model (treeview); if (gtk_tree_model_get_iter (model, &iter, path)) { /* Expand / contract nodes with children */ if (gtk_tree_model_iter_has_child (model, &iter)) { if (gtk_tree_view_row_expanded (treeview, path)) gtk_tree_view_collapse_row (treeview, path); else gtk_tree_view_expand_row (treeview, path, FALSE); return; } /* Get the current enabled string and toggle it between "" and "*" */ gtk_tree_model_get (model, &iter, NET_ENABLED_COLUMN, &str, -1); gtk_tree_store_set (GTK_TREE_STORE (model), &iter, NET_ENABLED_COLUMN, !strcmp (str, "*") ? "" : "*", -1); /* set/clear the flag which says the net is enabled or disabled */ gtk_tree_model_get (model, &iter, NET_LIBRARY_COLUMN, &menu, -1); menu->flag = strcmp (str, "*") == 0 ? 1 : 0; g_free (str); } }
static gboolean hunt_named_node (GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data) { struct ggnfnn_task *task = (struct ggnfnn_task *)data; LibraryMenuType *net; LibraryEntryType *node; gchar *str; gint j; gboolean is_disabled; /* We only want to inspect leaf nodes in the tree */ if (gtk_tree_model_iter_has_child (model, iter)) return FALSE; gtk_tree_model_get (model, iter, NET_LIBRARY_COLUMN, &net, -1); gtk_tree_model_get (model, iter, NET_ENABLED_COLUMN, &str, -1); is_disabled = !strcmp (str, "*"); g_free (str); /* Don't check net nodes of disabled nets. */ if (task->enabled_only && is_disabled) return FALSE; /* Look for the node name in this net. */ for (j = net->EntryN, node = net->Entry; j; j--, node++) if (node->ListEntry && !strcmp (task->node_name, node->ListEntry)) { task->found_net = net; task->iter = *iter; return TRUE; } return FALSE; }
static void repair_filenames(GtkTreeModel* model, GtkWidget* parent_window) { GtkTreeIter iter; gboolean res; res = gtk_tree_model_get_iter_first(model, &iter); while (res) { GFile* file = NULL; char* new_name = NULL; gtk_tree_model_get(model, &iter, FILE_COLUMN_GFILE, &file, FILE_COLUMN_NEW_NAME, &new_name, -1); res = gtk_tree_model_iter_has_child(model, &iter); if (res) { repair_filenames_subdir(model, &iter, file, parent_window); } change_filename(file, new_name, parent_window); g_free(new_name); res = gtk_tree_model_iter_next(model, &iter); } }
static gboolean button_release_event(GtkWidget *widget, GdkEventButton *event, gpointer data) { GtkTreeSelection *selection = NULL; GtkTreeIter selected; gboolean is_selected = FALSE; gchar *caption = NULL; gchar *key = NULL; gchar *module = NULL; gchar *mod_desc = NULL; gchar *description = NULL; button_one = FALSE; selection = gtk_tree_view_get_selection(bookmark_tree); current_selection = selection; if (gtk_tree_selection_get_selected(selection, NULL, &selected)) { gtk_tree_model_get(GTK_TREE_MODEL(model), &selected, 2, &caption, 3, &key, 4, &module, 5, &mod_desc, 6, &description, -1); if (!gtk_tree_model_iter_has_child(GTK_TREE_MODEL(model), &selected) && key != NULL) { gboolean multi = (strpbrk(key, "-;,") != NULL); gtk_widget_set_sensitive(menu.in_tab, !multi); gtk_widget_set_sensitive(menu.in_dialog, !multi); gtk_widget_set_sensitive(menu.new, FALSE); gtk_widget_set_sensitive(menu.insert, FALSE); gtk_widget_set_sensitive(menu.remove, FALSE); } else {
static void on_find_in_files(G_GNUC_UNUSED GtkMenuItem *menuitem, G_GNUC_UNUSED gpointer user_data) { GtkTreeSelection *treesel; GtkTreeIter iter, parent; GtkTreeModel *model; gchar *path; treesel = gtk_tree_view_get_selection(GTK_TREE_VIEW(s_file_view)); if (!gtk_tree_selection_get_selected(treesel, &model, &iter)) return; if (!gtk_tree_model_iter_has_child(model, &iter)) { if (gtk_tree_model_iter_parent(model, &parent, &iter)) path = build_path(&parent); else path = build_path(NULL); } else path = build_path(&iter); search_show_find_in_files_dialog(path); g_free(path); }
static void selection_changed_cb (GtkTreeSelection *selection, gpointer user_data) { GtkTreeModel *model; GtkTreeIter iter; GhidDrcViolation *violation; int i; if (!gtk_tree_selection_get_selected (selection, &model, &iter)) { if (ClearFlagOnAllObjects (true, FOUNDFLAG)) { IncrementUndoSerialNumber (); Draw (); } return; } /* Check the selected node has children, if so; return. */ if (gtk_tree_model_iter_has_child (model, &iter)) return; gtk_tree_model_get (model, &iter, DRC_VIOLATION_OBJ_COL, &violation, -1); ClearFlagOnAllObjects (true, FOUNDFLAG); if (violation == NULL) return; /* Flag the objects listed against this DRC violation */ for (i = 0; i < violation->object_count; i++) { int object_id = violation->object_id_list[i]; int object_type = violation->object_type_list[i]; int found_type; void *ptr1, *ptr2, *ptr3; found_type = SearchObjectByID (PCB->Data, &ptr1, &ptr2, &ptr3, object_id, object_type); if (found_type == NO_TYPE) { Message (_("Object ID %i identified during DRC was not found. Stale DRC window?\n"), object_id); continue; } AddObjectToFlagUndoList (object_type, ptr1, ptr2, ptr3); SET_FLAG (FOUNDFLAG, (AnyObjectType *)ptr2); switch (violation->object_type_list[i]) { case LINE_TYPE: case ARC_TYPE: case POLYGON_TYPE: ChangeGroupVisibility (GetLayerNumber (PCB->Data, (LayerType *) ptr1), true, true); } DrawObject (object_type, ptr1, ptr2); } SetChangedFlag (true); IncrementUndoSerialNumber (); Draw(); }
static void row_activated_cb (GtkTreeView *view, GtkTreePath *path, GtkTreeViewColumn *column, CommoditiesDialog *cd) { GtkTreeModel *model; GtkTreeIter iter; g_return_if_fail(view); model = gtk_tree_view_get_model(view); if (gtk_tree_model_get_iter(model, &iter, path)) { if (gtk_tree_model_iter_has_child(model, &iter)) { /* There are children, so it's not a commodity. * Just expand or collapse the row. */ if (gtk_tree_view_row_expanded(view, path)) gtk_tree_view_collapse_row(view, path); else gtk_tree_view_expand_row(view, path, FALSE); } else /* It's a commodity, so click the Edit button. */ edit_clicked(cd); } }
gboolean table_check_func (GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer user_data) { gchar *description, *icon, *params; gchar *tree_path_str; gboolean has_child; gint depth; gtk_tree_model_get (model, iter, COL_DESCRIPTION, &description, COL_ICONNAME, &icon, COL_PARAMS, ¶ms, -1); tree_path_str = gtk_tree_path_to_string(path); has_child = gtk_tree_model_iter_has_child (model, iter); depth = gtk_tree_path_get_depth (path) - 1; gv.app_errno = 0; strcpy (gv.app_errno_str, ""); if (depth + 1 >= MAX_RECURSION) { g_print ("maximum menu recursion reached! -> %d\n", MAX_RECURSION); return TRUE; } if (depth > 0) { if (has_child) { /* some checks for submenus */ if (!strcmp (params, "")) { gv.app_errno = AE_EMPTY_SUBMENU; strncpy (gv.app_errno_str, tree_path_str, APP_ERRNO_STR_LEN); return TRUE; } } else { /* some checks for entries */ } } else { /* check for root node */ } g_free(tree_path_str); g_free(description); g_free(icon); g_free(params); return FALSE; }
void ctree_select_vars(gint action) { GtkTreeView *view; GtkTreeModel *model; GtkTreePath *path = path_to_drag; GtkTreeIter parent, start_iter, end_iter, iter; view = GTK_TREE_VIEW(ctree_wnd); model = gtk_tree_view_get_model(view); // select var beneath a folder gtk_tree_model_get_iter(model, &parent, path); if (gtk_tree_model_iter_has_child(model, &parent)) { GtkTreeSelection *sel; GtkTreePath *start_path, *end_path; gint n; gboolean valid; sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(ctree_wnd)); n = gtk_tree_model_iter_n_children(model, &parent); valid = gtk_tree_model_iter_children(model, &start_iter, &parent); start_path = gtk_tree_model_get_path(model, &start_iter); valid = gtk_tree_model_iter_nth_child(model, &end_iter, &parent, n - 1); if(gtk_tree_model_iter_has_child(model, &end_iter)) { n = gtk_tree_model_iter_n_children(model, &end_iter); valid = gtk_tree_model_iter_nth_child(model, &iter, &end_iter, n - 1); memcpy(&end_iter, &iter, sizeof(GtkTreeIter)); } end_path = gtk_tree_model_get_path(model, &end_iter); if (!action) gtk_tree_selection_unselect_range(sel, start_path, end_path); else { gtk_tree_selection_select_range(sel, start_path, end_path); } gtk_tree_path_free(start_path); gtk_tree_path_free(end_path); } }
static void from_cell_data_func(GtkCellLayout *cell_layout, GtkCellRenderer *cell, GtkTreeModel *tree_model, GtkTreeIter *iter, gpointer data) { g_object_set(cell, "sensitive", !gtk_tree_model_iter_has_child(tree_model, iter), NULL); }
static void is_sensitive (GtkCellLayout *cell_layout, GtkCellRenderer *cell, GtkTreeModel *tree_model, GtkTreeIter *iter, gpointer data) { gboolean sensitive; sensitive = !gtk_tree_model_iter_has_child (tree_model, iter); g_object_set (cell, "sensitive", sensitive, NULL); }
static void cell_is_sensitive(GtkCellLayout *cell_layout, GtkCellRenderer *cell, GtkTreeModel *tree_model, GtkTreeIter *iter, gpointer data) { if(gtk_tree_model_iter_has_child (tree_model, iter)) { g_object_set (cell, "sensitive", FALSE, NULL); } }