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);
}
}
