static void treestore_torture_recurse (GtkTreeStore *store, GtkTreeIter *root, gint depth) { GtkTreeModel *model; gint i; GtkTreeIter iter; model = GTK_TREE_MODEL (store); if (depth > 2) return; ++depth; gtk_tree_store_append (store, &iter, root); gtk_tree_model_iter_children (model, &iter, root); i = 0; while (i < 100) { gtk_tree_store_append (store, &iter, root); ++i; } while (gtk_tree_model_iter_children (model, &iter, root)) gtk_tree_store_remove (store, &iter); gtk_tree_store_append (store, &iter, root); /* inserts before last node in tree */ i = 0; while (i < 100) { gtk_tree_store_insert_before (store, &iter, root, &iter); ++i; } /* inserts after the node before the last node */ i = 0; while (i < 100) { gtk_tree_store_insert_after (store, &iter, root, &iter); ++i; } /* inserts after the last node */ gtk_tree_store_append (store, &iter, root); i = 0; while (i < 100) { gtk_tree_store_insert_after (store, &iter, root, &iter); ++i; } /* remove everything again */ while (gtk_tree_model_iter_children (model, &iter, root)) gtk_tree_store_remove (store, &iter); /* Prepends */ gtk_tree_store_prepend (store, &iter, root); i = 0; while (i < 100) { gtk_tree_store_prepend (store, &iter, root); ++i; } /* remove everything again */ while (gtk_tree_model_iter_children (model, &iter, root)) gtk_tree_store_remove (store, &iter); gtk_tree_store_append (store, &iter, root); gtk_tree_store_append (store, &iter, root); gtk_tree_store_append (store, &iter, root); gtk_tree_store_append (store, &iter, root); while (gtk_tree_model_iter_children (model, &iter, root)) { treestore_torture_recurse (store, &iter, depth); gtk_tree_store_remove (store, &iter); } }
/* * key has been pressed while being in watch tree view */ static gboolean on_watch_key_pressed_callback(GtkWidget *widget, GdkEvent *event, gpointer user_data) { /* handling only Delete button pressing * that means "delete selected rows" */ int keyval = ((GdkEventKey*)event)->keyval; if (keyval != GDK_Delete) return FALSE; /* get selected rows */ GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(wtree)); GList *rows = gtk_tree_selection_get_selected_rows(selection, &wmodel); /* empty row path */ GtkTreePath *empty_path = wtree_empty_path(); /* check whether only empty row was selected */ if (1 != gtk_tree_selection_count_selected_rows(selection) || gtk_tree_path_compare((GtkTreePath*)rows->data, empty_path)) { /* path reference to select after deleteing finishes */ GtkTreeRowReference *reference_to_select = NULL; /* get references to the rows */ GList *references = NULL; GList *iter = rows; while (iter) { GtkTreePath *path = (GtkTreePath*)iter->data; /* move up paths to the root elements */ while (gtk_tree_path_get_depth(path) > 1) gtk_tree_path_up(path); /* add path reference if it's not an empty row*/ if (gtk_tree_path_compare(path, empty_path)) references = g_list_append(references, gtk_tree_row_reference_new(wmodel, path)); iter = iter->next; } /* iterate through references and remove */ iter = references; while (iter) { GtkTreeRowReference *reference = (GtkTreeRowReference*)iter->data; /* check for valid reference because two or more equal refernces could be put in the list if several child items of the same node were selected and the path for the current reference was already deleted */ if (gtk_tree_row_reference_valid(reference)) { GtkTreePath *path = gtk_tree_row_reference_get_path(reference); if (!reference_to_select) { /* select upper sibling of the upper selected row that has unselected upper sibling */ GtkTreePath *sibling = gtk_tree_path_copy(path); if(gtk_tree_path_prev(sibling)) { if (!gtk_tree_selection_path_is_selected(selection, sibling)) reference_to_select = gtk_tree_row_reference_new(gtk_tree_view_get_model(GTK_TREE_VIEW(wtree)), sibling); } else if (gtk_tree_path_next(sibling), gtk_tree_path_compare(path, sibling)) reference_to_select = gtk_tree_row_reference_new(gtk_tree_view_get_model(GTK_TREE_VIEW(wtree)), sibling); } /* get iterator */ GtkTreeIter titer; gtk_tree_model_get_iter(wmodel, &titer, path); /* remove from the debug session, if it's active */ if (DBS_STOPPED == debug_state) { gchar *internal = NULL; gtk_tree_model_get ( wmodel, &titer, W_INTERNAL, &internal, -1); active_module->remove_watch(internal); g_free(internal); } gtk_tree_store_remove(wstore, &titer); } iter = iter->next; } /* if all (with or without empty row) was selected - set empty row as a path to be selected after deleting */ if (!reference_to_select) reference_to_select = gtk_tree_row_reference_new (gtk_tree_view_get_model(GTK_TREE_VIEW(wtree)), wtree_empty_path()); /* set selection */ gtk_tree_selection_unselect_all(selection); GtkTreePath *path_to_select = gtk_tree_row_reference_get_path(reference_to_select); gtk_tree_selection_select_path(selection, path_to_select); gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(widget), path_to_select, NULL, TRUE, 0.5, 0.5); gtk_tree_path_free(path_to_select); /* free references list */ g_list_foreach (references, (GFunc)gtk_tree_row_reference_free, NULL); g_list_free (references); config_set_debug_changed(); } /* free rows list */ g_list_foreach (rows, (GFunc)gtk_tree_path_free, NULL); g_list_free (rows); return FALSE; }
int TreeViewCategories_CategoryDeleteFromDatabase(TreeViewCategories* c, GtkTreeModel* model, GtkTreeIter* iter, unsigned int row_id) { TreeViewCategoriesDelete tvcd; MYSQL_BIND param_delete[1]; const char* stmt_update_str = "DELETE FROM categories WHERE id = ?;\n"; int ret = 1; GtkTreeIter iter_child; gchar* Name2; tvcd.stmt = mysql_stmt_init(c->MySQL); if (tvcd.stmt == NULL) { fprintf(stderr, "%s(): mysql_stmt_init() error.\n", __func__); ret = 0; goto END; } if (mysql_stmt_prepare(tvcd.stmt, stmt_update_str, strlen(stmt_update_str))) { fprintf(stderr, "%s(): mysql_stmt_prepare() error.\n", __func__); ret = 0; goto END; } memset(param_delete, 0, sizeof(param_delete)); param_delete[0].buffer_type = MYSQL_TYPE_LONG; param_delete[0].buffer = (void*) &tvcd.row_id; param_delete[0].is_unsigned = 1; tvcd.model = model; if (mysql_stmt_bind_param(tvcd.stmt, param_delete)) { fprintf(stderr, "%s(): \n", __func__); ret = 0; goto END; } if (gtk_tree_model_iter_children(model, &iter_child, iter)) { if (!TreeViewCategories_CategoryDeleteFromDatabase2(&tvcd, &iter_child)) { ret = 0; goto END; } } gtk_tree_model_get(tvcd.model, iter, COL_ID_ID, &tvcd.row_id, COL_ID_NAME2, &Name2, -1); g_print("%s(): %s\n", __func__, Name2); g_free(Name2); if (mysql_stmt_execute(tvcd.stmt)) { fprintf(stderr, "%s(): \n", __func__); ret = 0; goto END; } gtk_tree_store_remove(GTK_TREE_STORE(tvcd.model), iter); END: if (tvcd.stmt != NULL) mysql_stmt_close(tvcd.stmt); return ret; }
static void cm_delete_item(CookieManagerPage *cmp) { GtkTreeIter iter, iter_store, child; GtkTreeModel *model; GtkTreePath *path, *last_path; GtkTreeSelection *selection; GList *rows, *row; GList *refs = NULL; CookieManagerPagePrivate *priv = cmp->priv; selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(priv->treeview)); rows = gtk_tree_selection_get_selected_rows(selection, &model); if (cm_list_length(rows) == 0) return; last_path = gtk_tree_path_copy(g_list_nth_data(rows, 0)); /* as paths will change during delete, first create GtkTreeRowReferences for * all selected rows */ row = rows; do { refs = g_list_append(refs, gtk_tree_row_reference_new(model, (GtkTreePath*) (row->data))); } while ((row = row->next) != NULL); row = refs; do { /* get iter */ path = gtk_tree_row_reference_get_path((GtkTreeRowReference*) row->data); if (path == NULL) continue; gtk_tree_model_get_iter(model, &iter, path); if (gtk_tree_model_iter_has_child(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); } /* 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); } else { GtkTreePath *path_store, *path_model; gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(priv->filter), &iter_store, &iter); path_store = gtk_tree_model_get_path(GTK_TREE_MODEL(priv->store), &iter_store); path_model = gtk_tree_model_get_path(model, &iter); cm_delete_cookie(cmp, model, &iter); gtk_tree_store_remove(priv->store, &iter_store); /* check whether the parent still has children, otherwise delete it */ if (gtk_tree_path_up(path_store)) { gtk_tree_model_get_iter(GTK_TREE_MODEL(priv->store), &iter_store, path_store); if (! gtk_tree_model_iter_has_child(GTK_TREE_MODEL(priv->store), &iter_store)) /* remove the empty parent */ gtk_tree_store_remove(priv->store, &iter_store); } /* now for the filter model */ if (gtk_tree_path_up(path_model)) { gtk_tree_model_get_iter(model, &iter, path_model); if (! gtk_tree_model_iter_has_child(model, &iter)) { gtk_tree_model_filter_convert_iter_to_child_iter( GTK_TREE_MODEL_FILTER(priv->filter), &iter_store, &iter); /* hide the empty parent */ gtk_tree_store_set(priv->store, &iter_store, COOKIE_MANAGER_COL_VISIBLE, FALSE, -1); } } gtk_tree_path_free(path_store); gtk_tree_path_free(path_model); } gtk_tree_path_free(path); } while ((row = row->next) != NULL); cm_free_selection_list(rows, (GFunc) gtk_tree_path_free); cm_free_selection_list(refs, (GFunc) gtk_tree_row_reference_free); cm_select_path(cmp, model, last_path); gtk_tree_path_free(last_path); }
// Create a new bus from the current selection static void create_bus_button_clicked (GtkWidget *widget, gpointer data) { int row_type = -1 ; bus_layout_D *dialog = (bus_layout_D *)data ; GList *llTreeRefs = NULL, *llItr = NULL ; GtkTreeStore *ts = GTK_TREE_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (dialog->tview))) ; GtkTreeIter itrBus, itr, itrSrc, itrSrcParent ; GtkTreeRowReference *refBus = NULL, *refSrcParent = NULL ; GtkTreePath *tp = NULL, *tpSrcParent = NULL ; llTreeRefs = get_selected_refs (gtk_tree_view_get_selection (GTK_TREE_VIEW (dialog->tview))) ; if (NULL == llTreeRefs) return ; if (!gtk_tree_model_get_iter (GTK_TREE_MODEL (ts), &itr, tp = gtk_tree_row_reference_get_path (llTreeRefs->data))) { gtk_tree_path_free (tp) ; return ; } gtk_tree_model_get (GTK_TREE_MODEL (ts), &itr, BUS_LAYOUT_MODEL_COLUMN_TYPE, &row_type, -1) ; gtk_tree_path_free (tp) ; gtk_tree_store_prepend (ts, &itrBus, NULL) ; gtk_tree_store_set (ts, &itrBus, BUS_LAYOUT_MODEL_COLUMN_ICON, (row_type & ROW_TYPE_INPUT) ? QCAD_STOCK_BUS_INPUT : QCAD_STOCK_BUS_OUTPUT, BUS_LAYOUT_MODEL_COLUMN_NAME, _("Untitled Bus"), BUS_LAYOUT_MODEL_COLUMN_TYPE, (row_type & ROW_TYPE_INPUT) ? ROW_TYPE_BUS_INPUT : ROW_TYPE_BUS_OUTPUT, BUS_LAYOUT_MODEL_COLUMN_INDEX, -1, -1) ; refBus = gtk_tree_row_reference_new (GTK_TREE_MODEL (ts), tp = gtk_tree_model_get_path (GTK_TREE_MODEL (ts), &itrBus)) ; gtk_tree_path_free (tp) ; for (llItr = g_list_last (llTreeRefs) ; llItr != NULL ; llItr = llItr->prev) { if (gtk_tree_model_get_iter (GTK_TREE_MODEL (ts), &itrBus, tp = gtk_tree_row_reference_get_path (refBus))) { gtk_tree_path_free (tp) ; gtk_tree_store_append (ts, &itr, &itrBus) ; if (gtk_tree_model_get_iter (GTK_TREE_MODEL (ts), &itrSrc, tp = gtk_tree_row_reference_get_path (llItr->data))) swap_model_iters_contents (GTK_TREE_MODEL (ts), &itrSrc, &itr) ; gtk_tree_path_free (tp) ; if (gtk_tree_model_get_iter (GTK_TREE_MODEL (ts), &itrSrc, tp = gtk_tree_row_reference_get_path (llItr->data))) { if (gtk_tree_path_get_depth (tp) > 1) { if (gtk_tree_path_up (tpSrcParent = gtk_tree_path_copy (tp))) refSrcParent = (1 == gtk_tree_model_path_n_children (GTK_TREE_MODEL (ts), tpSrcParent)) ? gtk_tree_row_reference_new (GTK_TREE_MODEL (ts), tpSrcParent) : NULL ; gtk_tree_path_free (tpSrcParent) ; } } gtk_tree_path_free (tp) ; gtk_tree_row_reference_free (llItr->data) ; // Remove cell from old location gtk_tree_store_remove (ts, &itrSrc) ; // The bus that owned the row we just moved has become empty - delete it if (NULL != refSrcParent) { tpSrcParent = gtk_tree_row_reference_get_path (refSrcParent) ; if (gtk_tree_model_get_iter (GTK_TREE_MODEL (ts), &itrSrcParent, tpSrcParent)) gtk_tree_store_remove (ts, &itrSrcParent) ; gtk_tree_path_free (tpSrcParent) ; gtk_tree_row_reference_free (refSrcParent) ; refSrcParent = NULL ; } } else gtk_tree_path_free (tp) ; } gtk_tree_selection_select_path (gtk_tree_view_get_selection (GTK_TREE_VIEW (dialog->tview)), tp = gtk_tree_row_reference_get_path (refBus)) ; gtk_tree_path_free (tp) ; gtk_tree_row_reference_free (refBus) ; g_list_free (llTreeRefs) ; }
void nav_tree_refresh_views (GSQLNavigation *navigation, GtkTreeView *tv, GtkTreeIter *iter) { GSQL_TRACE_FUNC; GtkTreeModel *model; GtkListStore *details; GSQLNavigation *nav = NULL; GtkTreeIter child, child_fake, child_last; GSQLCursor *cursor; GSQLVariable *var; GSQLCursorState state; GSQLSession *session; gchar *name, key[256], *sql = NULL, *realname = NULL, *owner = NULL; const gchar *currentdb = NULL; gint id, i,n; model = gtk_tree_view_get_model(tv); n = gtk_tree_model_iter_n_children(model, iter); for (; n>1; n--) { gtk_tree_model_iter_children(model, &child, iter); gtk_tree_store_remove(GTK_TREE_STORE(model), &child); } gtk_tree_model_iter_children(model, &child_last, iter); gtk_tree_model_get (model, iter, GSQL_NAV_TREE_REALNAME, &realname, -1); gtk_tree_model_get (model, iter, GSQL_NAV_TREE_SQL, &sql, -1); gtk_tree_model_get (model, iter, GSQL_NAV_TREE_OWNER, &owner, -1); session = gsql_session_get_active (); g_return_if_fail (GSQL_IS_SESSION(session)); currentdb = pgsql_navigation_get_database (navigation, tv, iter); GSQL_DEBUG("Database: switching to [%s]", currentdb); pgsql_session_switch_database(session, currentdb); cursor = gsql_cursor_new (session, sql); state = gsql_cursor_open_with_bind (cursor, FALSE, GSQL_CURSOR_BIND_BY_POS, G_TYPE_STRING, owner, -1); var = g_list_nth_data(cursor->var_list,0); if (state != GSQL_CURSOR_STATE_OPEN) { gsql_cursor_close (cursor); return; } i = 0; while (gsql_cursor_fetch (cursor, 1) > 0) { i++; if (var->value_type != G_TYPE_STRING) { GSQL_DEBUG ("The name of object should be a string "\ "(char *). Is the bug"); name = N_("Incorrect data"); } else { name = (gchar *) var->value; // make a key for a hash of details memset (key, 0, 256); g_snprintf (key, 255, "%x%s%d%s", session, owner, VIEW_ID, name); details = gsql_navigation_get_details (navigation, key); pgsql_navigation_fill_details (cursor, details); } gtk_tree_store_append (GTK_TREE_STORE(model), &child, iter); gtk_tree_store_set (GTK_TREE_STORE(model), &child, GSQL_NAV_TREE_ID, VIEW_ID, GSQL_NAV_TREE_OWNER, owner, GSQL_NAV_TREE_IMAGE,GSQL_STOCK_VIEWS, GSQL_NAV_TREE_NAME, name, GSQL_NAV_TREE_REALNAME, name, GSQL_NAV_TREE_ITEM_INFO, NULL, GSQL_NAV_TREE_SQL, NULL, GSQL_NAV_TREE_OBJECT_POPUP, nav_tree_views_popup, GSQL_NAV_TREE_OBJECT_HANDLER, NULL, GSQL_NAV_TREE_EXPAND_HANDLER, NULL, GSQL_NAV_TREE_EVENT_HANDLER, nav_tree_views_event, GSQL_NAV_TREE_STRUCT, views, GSQL_NAV_TREE_DETAILS, details, GSQL_NAV_TREE_NUM_ITEMS, G_N_ELEMENTS(views), -1); gtk_tree_store_append (GTK_TREE_STORE (model), &child_fake, &child); gtk_tree_store_set (GTK_TREE_STORE (model), &child_fake, GSQL_NAV_TREE_ID, -1, GSQL_NAV_TREE_IMAGE, NULL, GSQL_NAV_TREE_NAME, N_("Processing..."), GSQL_NAV_TREE_REALNAME, NULL, GSQL_NAV_TREE_ITEM_INFO, NULL, GSQL_NAV_TREE_SQL, NULL, GSQL_NAV_TREE_OBJECT_POPUP, NULL, GSQL_NAV_TREE_OBJECT_HANDLER,NULL, GSQL_NAV_TREE_EXPAND_HANDLER,NULL, GSQL_NAV_TREE_EVENT_HANDLER,NULL, GSQL_NAV_TREE_STRUCT, NULL, GSQL_NAV_TREE_NUM_ITEMS, NULL, -1); } GSQL_DEBUG ("Items fetched: [%d]", i); if (i > 0) { name = g_strdup_printf("%s<span weight='bold'> [%d]</span>", realname, i); gtk_tree_store_set (GTK_TREE_STORE(model), iter, GSQL_NAV_TREE_NAME, name, -1); g_free (name); } gtk_tree_store_remove(GTK_TREE_STORE(model), &child_last); gsql_cursor_close (cursor); }
/* Callback to remove selected rows */ static void remove_row (GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data) { gtk_tree_store_remove (GTK_TREE_STORE (model), iter); }
static gboolean capital_animation (gpointer data) { static gint insert_count = 0; GtkTreeModel *model = GTK_TREE_MODEL (data); GtkTreePath *path; GtkTreeIter iter, parent; switch (insert_count % 8) { case 0: gtk_tree_store_insert (GTK_TREE_STORE (model), &iter, NULL, 0); gtk_tree_store_set (GTK_TREE_STORE (model), &iter, 0, "Europe", -1); break; case 1: path = gtk_tree_path_new_from_indices (0, -1); gtk_tree_model_get_iter (model, &parent, path); gtk_tree_path_free (path); gtk_tree_store_insert (GTK_TREE_STORE (model), &iter, &parent, 0); gtk_tree_store_set (GTK_TREE_STORE (model), &iter, 0, "Berlin", -1); break; case 2: path = gtk_tree_path_new_from_indices (0, -1); gtk_tree_model_get_iter (model, &parent, path); gtk_tree_path_free (path); gtk_tree_store_insert (GTK_TREE_STORE (model), &iter, &parent, 1); gtk_tree_store_set (GTK_TREE_STORE (model), &iter, 0, "London", -1); break; case 3: path = gtk_tree_path_new_from_indices (0, -1); gtk_tree_model_get_iter (model, &parent, path); gtk_tree_path_free (path); gtk_tree_store_insert (GTK_TREE_STORE (model), &iter, &parent, 2); gtk_tree_store_set (GTK_TREE_STORE (model), &iter, 0, "Paris", -1); break; case 4: path = gtk_tree_path_new_from_indices (0, 2, -1); gtk_tree_model_get_iter (model, &iter, path); gtk_tree_path_free (path); gtk_tree_store_remove (GTK_TREE_STORE (model), &iter); break; case 5: path = gtk_tree_path_new_from_indices (0, 1, -1); gtk_tree_model_get_iter (model, &iter, path); gtk_tree_path_free (path); gtk_tree_store_remove (GTK_TREE_STORE (model), &iter); break; case 6: path = gtk_tree_path_new_from_indices (0, 0, -1); gtk_tree_model_get_iter (model, &iter, path); gtk_tree_path_free (path); gtk_tree_store_remove (GTK_TREE_STORE (model), &iter); break; case 7: path = gtk_tree_path_new_from_indices (0, -1); gtk_tree_model_get_iter (model, &iter, path); gtk_tree_path_free (path); gtk_tree_store_remove (GTK_TREE_STORE (model), &iter); break; default: ; } insert_count++; return TRUE; }
static void subtitle_refresh_list_row_ui( GtkTreeModel *tm, GtkTreeIter *ti, GhbValue *subsettings) { GtkTreeIter cti; gboolean forced, burned, def; char *info_src, *info_src_2; char *info_dst, *info_dst_2; info_src_2 = NULL; info_dst_2 = NULL; forced = ghb_dict_get_bool(subsettings, "SubtitleForced"); burned = ghb_dict_get_bool(subsettings, "SubtitleBurned"); def = ghb_dict_get_bool(subsettings, "SubtitleDefaultTrack"); info_src = g_strdup_printf("<small>%s</small>", ghb_dict_get_string(subsettings, "SubtitleTrackDescription")); if (ghb_dict_get_int(subsettings, "SubtitleSource") == SRTSUB) { gint offset; offset = ghb_dict_get_int(subsettings, "SrtOffset"); if (offset != 0) { info_dst_2 = g_strdup_printf("Offset: %dms", offset); } } GString *str = g_string_new("<small>"); g_string_append_printf(str, "%s ", burned ? "Burned Into Video" : "Passthrough"); if (forced) { g_string_append_printf(str, "(Forced Subtitles Only)"); } if (def) { g_string_append_printf(str, "(Default)"); } g_string_append_printf(str, "</small>"); info_dst = g_string_free(str, FALSE); gtk_tree_store_set(GTK_TREE_STORE(tm), ti, // These are displayed in list 0, info_src, 1, "-->", 2, info_dst, 3, "hb-edit", 4, "hb-remove", 5, 0.5, -1); if (info_src_2 != NULL || info_dst_2 != NULL) { if (info_src_2 == NULL) info_src_2 = g_strdup(""); if (info_dst_2 == NULL) info_dst_2 = g_strdup(""); if (!gtk_tree_model_iter_children(tm, &cti, ti)) { gtk_tree_store_append(GTK_TREE_STORE(tm), &cti, ti); } gtk_tree_store_set(GTK_TREE_STORE(tm), &cti, // These are displayed in list 0, info_src_2, 2, info_dst_2, 5, 0.0, -1); } else { if (gtk_tree_model_iter_children(tm, &cti, ti)) { gtk_tree_store_remove(GTK_TREE_STORE(tm), &cti); } } g_free(info_src); g_free(info_src_2); g_free(info_dst); g_free(info_dst_2); }
gboolean vdtree_populate_path_by_iter(ViewDir *vd, GtkTreeIter *iter, gboolean force, FileData *target_fd) { GtkTreeModel *store; GList *list; GList *work; GList *old; time_t current_time; GtkTreeIter child; NodeData *nd; store = gtk_tree_view_get_model(GTK_TREE_VIEW(vd->view)); gtk_tree_model_get(store, iter, DIR_COLUMN_POINTER, &nd, -1); if (!nd) return FALSE; current_time = time(NULL); if (nd->expanded) { if (!isdir(nd->fd->path)) { if (vd->click_fd == nd->fd) vd->click_fd = NULL; if (vd->drop_fd == nd->fd) vd->drop_fd = NULL; gtk_tree_store_remove(GTK_TREE_STORE(store), iter); vdtree_node_free(nd); return FALSE; } if (!force && current_time - nd->last_update < 2) { DEBUG_1("Too frequent update of %s", nd->fd->path); return TRUE; } if (nd->fd->version == nd->version) return TRUE; } vdtree_busy_push(vd); filelist_read(nd->fd, NULL, &list); /* when hidden files are not enabled, and the user enters a hidden path, * allow the tree to display that path by specifically inserting the hidden entries */ if (!options->file_filter.show_hidden_files && target_fd && strncmp(nd->fd->path, target_fd->path, strlen(nd->fd->path)) == 0) { gint n; n = strlen(nd->fd->path); if (target_fd->path[n] == G_DIR_SEPARATOR && target_fd->path[n+1] == '.') { gchar *name8; struct stat sbuf; n++; while (target_fd->path[n] != '\0' && target_fd->path[n] != G_DIR_SEPARATOR) n++; name8 = g_strndup(target_fd->path, n); if (stat_utf8(name8, &sbuf)) { list = g_list_prepend(list, file_data_new_simple(name8)); } g_free(name8); } } old = NULL; if (gtk_tree_model_iter_children(store, &child, iter)) { do { NodeData *cnd; gtk_tree_model_get(store, &child, DIR_COLUMN_POINTER, &cnd, -1); old = g_list_prepend(old, cnd); } while (gtk_tree_model_iter_next(store, &child)); } work = list; while (work) { FileData *fd; fd = work->data; work = work->next; if (strcmp(fd->name, ".") == 0 || strcmp(fd->name, "..") == 0) { file_data_unref(fd); } else { NodeData *cnd; cnd = vdtree_find_iter_by_fd(vd, iter, fd, &child); if (cnd) { if (cnd->expanded && cnd->version != fd->version) { vdtree_populate_path_by_iter(vd, &child, FALSE, target_fd); } gtk_tree_store_set(GTK_TREE_STORE(store), &child, DIR_COLUMN_NAME, fd->name, -1); cnd->version = fd->version; old = g_list_remove(old, cnd); file_data_unref(fd); } else { vdtree_add_by_data(vd, fd, iter); } } } work = old; while (work) { NodeData *cnd = work->data; work = work->next; if (vd->click_fd == cnd->fd) vd->click_fd = NULL; if (vd->drop_fd == cnd->fd) vd->drop_fd = NULL; if (vdtree_find_iter_by_data(vd, iter, cnd, &child)) { gtk_tree_store_remove(GTK_TREE_STORE(store), &child); vdtree_node_free(cnd); } } g_list_free(old); g_list_free(list); vdtree_busy_pop(vd); nd->expanded = TRUE; nd->last_update = current_time; return TRUE; }
void nav_tree_refresh_indexes (GSQLNavigation *navigation, GtkTreeView *tv, GtkTreeIter *iter) { GSQL_TRACE_FUNC; GtkTreeModel *model; GtkListStore *detail; GSQLNavigation *nav = NULL; gchar *sql = NULL; gchar *realname = NULL; gchar *owner = NULL; gint id; gint i,n; GtkTreeIter child; GtkTreeIter parent; GtkTreeIter child_fake; GtkTreeIter child_last; GSQLCursor *cursor; GSQLVariable *var, *var_t; GSQLSession *session; GSQLWorkspace *workspace; GSQLCursorState state; GtkListStore *details; gchar *name; gchar key[256]; gchar *stock = NULL; gchar *tbl = "%"; gchar *parent_realname = NULL; model = gtk_tree_view_get_model(tv); n = gtk_tree_model_iter_n_children(model, iter); for (; n>1; n--) { gtk_tree_model_iter_children (model, &child, iter); gtk_tree_store_remove (GTK_TREE_STORE(model), &child); } gtk_tree_model_iter_children(model, &child_last, iter); gtk_tree_model_get (model, iter, GSQL_NAV_TREE_REALNAME, &realname, -1); gtk_tree_model_get (model, iter, GSQL_NAV_TREE_SQL, &sql, -1); g_return_if_fail (sql != NULL); gtk_tree_model_get (model, iter, GSQL_NAV_TREE_OWNER, &owner, -1); session = gsql_session_get_active (); // get parent iter. if this iter are TABLE_ID then // we looking for table's constraints only. gtk_tree_model_iter_parent (model, &parent, iter); gtk_tree_model_get (model, &parent, GSQL_NAV_TREE_ID, &id, -1); gtk_tree_model_get (model, &parent, GSQL_NAV_TREE_REALNAME, &parent_realname, -1); switch (id) { case TABLE_ID: if (parent_realname != NULL) { tbl = parent_realname; sql = (gchar *) sql_oracle_table_indexes; } break; case CLUSTER_ID: tbl = parent_realname; if (strncmp (owner, gsql_session_get_username (session), 64)) sql = (gchar *) sql_oracle_cluster_indexes; break; default: if (strncmp (owner, gsql_session_get_username (session), 64)) sql = (gchar *) sql_oracle_indexes; } GSQL_DEBUG ("realname:[%s] sql:[%s] owner:[%s]", realname, sql, owner); cursor = gsql_cursor_new (session, sql); state = gsql_cursor_open_with_bind (cursor, FALSE, GSQL_CURSOR_BIND_BY_NAME, G_TYPE_STRING, ":owner", G_TYPE_STRING, owner, G_TYPE_STRING, ":name", G_TYPE_STRING, tbl, -1); var = g_list_nth_data(cursor->var_list,0); if (state != GSQL_CURSOR_STATE_OPEN) { gsql_cursor_close (cursor); return; } i = 0; while (gsql_cursor_fetch (cursor, 1) > 0) { i++; if (var->value_type != G_TYPE_STRING) { GSQL_DEBUG ("The name of object should be a string (char *). Is the bug"); name = N_("Incorrect data"); } else { name = (gchar *) var->value; // make a key for a hash of details memset (key, 0, 256); g_snprintf (key, 255, "%x%s%d%d%s", session, owner, id, INDEX_ID, name); details = gsql_navigation_get_details (navigation, key); oracle_navigation_fill_details (cursor, details); } gtk_tree_store_append (GTK_TREE_STORE(model), &child, iter); gtk_tree_store_set (GTK_TREE_STORE(model), &child, GSQL_NAV_TREE_ID, INDEX_ID, GSQL_NAV_TREE_OWNER, owner, GSQL_NAV_TREE_IMAGE, GSQL_STOCK_INDEXES, GSQL_NAV_TREE_NAME, name, GSQL_NAV_TREE_REALNAME, name, GSQL_NAV_TREE_ITEM_INFO, NULL, GSQL_NAV_TREE_SQL, NULL, GSQL_NAV_TREE_OBJECT_POPUP, NULL, GSQL_NAV_TREE_OBJECT_HANDLER, NULL, GSQL_NAV_TREE_EXPAND_HANDLER, NULL, GSQL_NAV_TREE_EVENT_HANDLER, NULL, GSQL_NAV_TREE_STRUCT, indexes, GSQL_NAV_TREE_DETAILS, details, GSQL_NAV_TREE_NUM_ITEMS, G_N_ELEMENTS(indexes), -1); gtk_tree_store_append (GTK_TREE_STORE (model), &child_fake, &child); gtk_tree_store_set (GTK_TREE_STORE (model), &child_fake, GSQL_NAV_TREE_ID, -1, GSQL_NAV_TREE_IMAGE, NULL, GSQL_NAV_TREE_NAME, N_("Processing..."), GSQL_NAV_TREE_REALNAME, NULL, GSQL_NAV_TREE_ITEM_INFO, NULL, GSQL_NAV_TREE_SQL, NULL, GSQL_NAV_TREE_OBJECT_POPUP, NULL, GSQL_NAV_TREE_OBJECT_HANDLER, NULL, GSQL_NAV_TREE_EXPAND_HANDLER, NULL, GSQL_NAV_TREE_EVENT_HANDLER, NULL, GSQL_NAV_TREE_STRUCT, NULL, GSQL_NAV_TREE_NUM_ITEMS, NULL, -1); } GSQL_DEBUG ("Items fetched: [%d]", i); if (i > 0) { name = g_strdup_printf("%s<span weight='bold'> [%d]</span>", realname, i); gtk_tree_store_set (GTK_TREE_STORE(model), iter, GSQL_NAV_TREE_NAME, name, -1); g_free (name); } gtk_tree_store_remove(GTK_TREE_STORE(model), &child_last); gsql_cursor_close (cursor); }
static void ref_count_row_ref (void) { GtkTreeIter grandparent1, grandparent2, parent1, parent2; GtkTreeIter iter_parent1, iter_parent2; GtkTreeModel *model; GtkTreeModelRefCount *ref_model; GtkTreeModel *sort_model; GtkWidget *tree_view; GtkTreePath *path; GtkTreeRowReference *row_ref; model = gtk_tree_model_ref_count_new (); ref_model = GTK_TREE_MODEL_REF_COUNT (model); /* + grandparent1 * + grandparent2 * + parent1 * + iter_parent1 * + parent2 * + iter_parent2 * + iter_parent2 */ gtk_tree_store_append (GTK_TREE_STORE (model), &grandparent1, NULL); gtk_tree_store_append (GTK_TREE_STORE (model), &grandparent2, NULL); gtk_tree_store_append (GTK_TREE_STORE (model), &parent1, &grandparent2); gtk_tree_store_append (GTK_TREE_STORE (model), &iter_parent1, &parent1); gtk_tree_store_append (GTK_TREE_STORE (model), &parent2, &grandparent2); gtk_tree_store_append (GTK_TREE_STORE (model), &iter_parent2, &parent2); gtk_tree_store_append (GTK_TREE_STORE (model), &iter_parent2, &parent2); sort_model = gtk_tree_model_sort_new_with_model (model); tree_view = gtk_tree_view_new_with_model (sort_model); path = gtk_tree_path_new_from_indices (1, 1, 1, -1); row_ref = gtk_tree_row_reference_new (sort_model, path); gtk_tree_path_free (path); assert_node_ref_count (ref_model, &grandparent1, 1); /* Referenced because the node is visible, its child level is built * and referenced by the row ref. */ assert_node_ref_count (ref_model, &grandparent2, 3); assert_node_ref_count (ref_model, &parent1, 0); /* Referenced by the row ref and because its child level is built. */ assert_node_ref_count (ref_model, &parent2, 2); assert_node_ref_count (ref_model, &iter_parent1, 0); assert_node_ref_count (ref_model, &iter_parent2, 1); gtk_tree_row_reference_free (row_ref); assert_node_ref_count (ref_model, &grandparent1, 1); assert_node_ref_count (ref_model, &grandparent2, 2); assert_node_ref_count (ref_model, &parent1, 0); assert_node_ref_count (ref_model, &parent2, 1); assert_node_ref_count (ref_model, &iter_parent1, 0); assert_node_ref_count (ref_model, &iter_parent2, 0); path = gtk_tree_path_new_from_indices (1, 1, 1, -1); row_ref = gtk_tree_row_reference_new (sort_model, path); gtk_tree_path_free (path); assert_node_ref_count (ref_model, &grandparent1, 1); /* Referenced because the node is visible, its child level is built * and referenced by the row ref. */ assert_node_ref_count (ref_model, &grandparent2, 3); assert_node_ref_count (ref_model, &parent1, 0); /* Referenced by the row ref and because its child level is built. */ assert_node_ref_count (ref_model, &parent2, 2); assert_node_ref_count (ref_model, &iter_parent1, 0); assert_node_ref_count (ref_model, &iter_parent2, 1); gtk_tree_store_remove (GTK_TREE_STORE (model), &parent2); assert_node_ref_count (ref_model, &grandparent1, 1); assert_node_ref_count (ref_model, &grandparent2, 1); assert_node_ref_count (ref_model, &parent1, 0); assert_node_ref_count (ref_model, &iter_parent1, 0); gtk_tree_row_reference_free (row_ref); assert_node_ref_count (ref_model, &grandparent1, 1); assert_node_ref_count (ref_model, &grandparent2, 1); assert_node_ref_count (ref_model, &parent1, 0); assert_node_ref_count (ref_model, &iter_parent1, 0); gtk_widget_destroy (tree_view); g_object_unref (sort_model); assert_entire_model_unreferenced (ref_model); g_object_unref (ref_model); }
static void ref_count_delete_row (void) { GtkTreeIter grandparent1, grandparent2, parent1, parent2; GtkTreeIter iter_parent1, iter_parent2; GtkTreeModel *model; GtkTreeModelRefCount *ref_model; GtkTreeModel *sort_model; GtkTreePath *path; GtkWidget *tree_view; model = gtk_tree_model_ref_count_new (); ref_model = GTK_TREE_MODEL_REF_COUNT (model); /* + grandparent1 * + grandparent2 * + parent1 * + iter_parent1 * + parent2 * + iter_parent2 * + iter_parent2 */ gtk_tree_store_append (GTK_TREE_STORE (model), &grandparent1, NULL); gtk_tree_store_append (GTK_TREE_STORE (model), &grandparent2, NULL); gtk_tree_store_append (GTK_TREE_STORE (model), &parent1, &grandparent2); gtk_tree_store_append (GTK_TREE_STORE (model), &iter_parent1, &parent1); gtk_tree_store_append (GTK_TREE_STORE (model), &parent2, &grandparent2); gtk_tree_store_append (GTK_TREE_STORE (model), &iter_parent2, &parent2); gtk_tree_store_append (GTK_TREE_STORE (model), &iter_parent2, &parent2); assert_entire_model_unreferenced (ref_model); sort_model = gtk_tree_model_sort_new_with_model (model); tree_view = gtk_tree_view_new_with_model (sort_model); assert_root_level_referenced (ref_model, 1); assert_node_ref_count (ref_model, &parent1, 0); assert_node_ref_count (ref_model, &parent2, 0); assert_level_unreferenced (ref_model, &parent1); assert_level_unreferenced (ref_model, &parent2); path = gtk_tree_path_new_from_indices (1, -1); gtk_tree_view_expand_row (GTK_TREE_VIEW (tree_view), path, TRUE); gtk_tree_path_free (path); assert_node_ref_count (ref_model, &grandparent1, 1); assert_node_ref_count (ref_model, &grandparent2, 2); assert_node_ref_count (ref_model, &parent1, 2); assert_node_ref_count (ref_model, &parent2, 2); assert_node_ref_count (ref_model, &iter_parent1, 1); assert_node_ref_count (ref_model, &iter_parent2, 1); gtk_tree_store_remove (GTK_TREE_STORE (model), &iter_parent2); assert_node_ref_count (ref_model, &grandparent1, 1); assert_node_ref_count (ref_model, &grandparent2, 2); assert_node_ref_count (ref_model, &parent1, 2); assert_level_referenced (ref_model, 1, &parent1); assert_node_ref_count (ref_model, &parent2, 2); assert_level_referenced (ref_model, 1, &parent2); gtk_tree_store_remove (GTK_TREE_STORE (model), &parent1); assert_node_ref_count (ref_model, &grandparent1, 1); assert_node_ref_count (ref_model, &grandparent2, 2); assert_node_ref_count (ref_model, &parent2, 2); assert_level_referenced (ref_model, 1, &parent2); gtk_tree_store_remove (GTK_TREE_STORE (model), &grandparent2); assert_node_ref_count (ref_model, &grandparent1, 1); gtk_tree_model_sort_clear_cache (GTK_TREE_MODEL_SORT (sort_model)); assert_node_ref_count (ref_model, &grandparent1, 1); gtk_widget_destroy (tree_view); assert_entire_model_unreferenced (ref_model); g_object_unref (sort_model); g_object_unref (ref_model); }
void nav_tree_refresh_objects (GSQLNavigation *navigation, GtkTreeView *tv, GtkTreeIter *iter) { GSQL_TRACE_FUNC; GtkTreeModel *model; GtkTreeIter child; GtkTreeIter child_fake; GtkTreeIter child_last; gint n, id, o_id; gchar key[256]; gchar *sql = NULL; gchar *realname = NULL; gchar *name = NULL; gchar *owner = NULL; GSQLCursor * cursor; GSQLCursorState state; GSQLSession *session; GSQLWorkspace *workspace; GSQLVariable *var; GtkListStore *details; void *s_elements; guint n_elements; gchar *stock; model = gtk_tree_view_get_model(tv); n = gtk_tree_model_iter_n_children(model, iter); for (; n>1; n--) { gtk_tree_model_iter_children(model, &child, iter); gtk_tree_store_remove(GTK_TREE_STORE(model), &child); } gtk_tree_model_iter_children(model, &child_last, iter); gtk_tree_model_get (model, iter, GSQL_NAV_TREE_REALNAME, &realname, -1); gtk_tree_model_get (model, iter, GSQL_NAV_TREE_SQL, &sql, -1); gtk_tree_model_get (model, iter, GSQL_NAV_TREE_OWNER, &owner, -1); gtk_tree_model_get (model, iter, GSQL_NAV_TREE_ID, &id, -1); session = gsql_session_get_active (); GSQL_DEBUG ("realname:[%s] sql:[%s] owner:[%s]", realname, sql, owner); switch (id) { case OBJECT_TYPES_ID: if (strncmp (owner, gsql_session_get_username (session), 64)) sql = (gchar *) sql_oracle_object_types; GSQL_DEBUG ("types SQL: %s", sql); cursor = gsql_cursor_new (session, sql); state = gsql_cursor_open_with_bind (cursor, FALSE, GSQL_CURSOR_BIND_BY_NAME, G_TYPE_STRING, ":owner", G_TYPE_STRING, owner, G_TYPE_STRING, ":object_name", G_TYPE_STRING, "%", -1); s_elements = object_types; n_elements = G_N_ELEMENTS (object_types); stock = GSQLE_ORACLE_STOCK_OBJ_TYPES; break; case OBJECT_TYPE_BODIES_ID: if (strncmp (owner, gsql_session_get_username (session), 64)) sql = (gchar *) sql_oracle_users_objects; cursor = gsql_cursor_new (session, sql); state = gsql_cursor_open_with_bind (cursor, FALSE, GSQL_CURSOR_BIND_BY_NAME, G_TYPE_STRING, ":owner", G_TYPE_STRING, owner, G_TYPE_STRING, ":object_name", G_TYPE_STRING, "%", G_TYPE_STRING, ":object_type", G_TYPE_STRING, "TYPE BODY", -1); s_elements = object_types; n_elements = G_N_ELEMENTS (object_types); stock = GSQLE_ORACLE_STOCK_OBJ_TYPE_BODIES; break; case COLLECTION_TYPES_ID: if (strncmp (owner, gsql_session_get_username (session), 64)) sql = (gchar *) sql_oracle_collection_types; GSQL_DEBUG ("collection SQL: %s", sql); cursor = gsql_cursor_new (session, sql); state = gsql_cursor_open_with_bind (cursor, FALSE, GSQL_CURSOR_BIND_BY_NAME, G_TYPE_STRING, ":owner", G_TYPE_STRING, owner, G_TYPE_STRING, ":object_name", G_TYPE_STRING, "%", -1); s_elements = object_types; n_elements = G_N_ELEMENTS (object_types); stock = GSQLE_ORACLE_STOCK_COLLECTIONS_TYPES; break; } if (state != GSQL_CURSOR_STATE_OPEN) { gsql_cursor_close (cursor); return; } var = g_list_nth_data(cursor->var_list, 0); n = 0; while (gsql_cursor_fetch (cursor, 1) > 0) { n++; if (var->value_type != G_TYPE_STRING) { GSQL_DEBUG ("The name of object should be a string (char *). Is the bug"); name = N_("Incorrect data"); } else { name = (gchar *) var->value; // make a key for a hash of details memset (key, 0, 256); g_snprintf (key, 255, "%x%s%d%s", session, owner, id, name); details = gsql_navigation_get_details (navigation, key); oracle_navigation_fill_details (cursor, details); } gtk_tree_store_append (GTK_TREE_STORE(model), &child, iter); gtk_tree_store_set (GTK_TREE_STORE(model), &child, GSQL_NAV_TREE_ID, id, GSQL_NAV_TREE_OWNER, owner, GSQL_NAV_TREE_IMAGE, stock, GSQL_NAV_TREE_NAME, name, GSQL_NAV_TREE_REALNAME, name, GSQL_NAV_TREE_ITEM_INFO, NULL, GSQL_NAV_TREE_SQL, NULL, GSQL_NAV_TREE_OBJECT_POPUP, NULL, GSQL_NAV_TREE_OBJECT_HANDLER, NULL, GSQL_NAV_TREE_EXPAND_HANDLER, NULL, GSQL_NAV_TREE_EVENT_HANDLER, NULL, GSQL_NAV_TREE_STRUCT, object_types, GSQL_NAV_TREE_DETAILS, details, GSQL_NAV_TREE_NUM_ITEMS, G_N_ELEMENTS(object_types), -1); gtk_tree_store_append (GTK_TREE_STORE (model), &child_fake, &child); gtk_tree_store_set (GTK_TREE_STORE (model), &child_fake, GSQL_NAV_TREE_ID, -1, GSQL_NAV_TREE_IMAGE, NULL, GSQL_NAV_TREE_NAME, N_("Processing..."), GSQL_NAV_TREE_REALNAME, NULL, GSQL_NAV_TREE_ITEM_INFO, NULL, GSQL_NAV_TREE_SQL, NULL, GSQL_NAV_TREE_OBJECT_POPUP, NULL, GSQL_NAV_TREE_OBJECT_HANDLER, NULL, GSQL_NAV_TREE_EXPAND_HANDLER, NULL, GSQL_NAV_TREE_EVENT_HANDLER, NULL, GSQL_NAV_TREE_STRUCT, NULL, GSQL_NAV_TREE_NUM_ITEMS, NULL, -1); } GSQL_DEBUG ("Items fetched: [%d]", n); if (n > 0) { name = g_strdup_printf("%s<span weight='bold'> [%d]</span>", realname, n); gtk_tree_store_set (GTK_TREE_STORE(model), iter, GSQL_NAV_TREE_NAME, name, -1); g_free (name); } gtk_tree_store_remove(GTK_TREE_STORE(model), &child_last); gsql_cursor_close (cursor); }
static void pkg_window_refresh_with_iter (PkgWindow *window, /* IN */ GtkTreeModel *model, /* IN */ GtkTreeIter *iter) /* IN */ { PkgWindowPrivate *priv; PkConnection *connection; GtkTreeView *treeview; GtkTreeIter child; GtkTreeIter grandchild; g_return_if_fail(PKG_IS_WINDOW(window)); g_return_if_fail(GTK_IS_TREE_MODEL(model)); g_return_if_fail(iter != NULL); /* * All the children of this connection can stay, but their * children should be removed. */ ENTRY; priv = window->priv; gtk_tree_model_get(model, iter, COLUMN_CONNECTION, &connection, -1); if (!connection) { EXIT; } /* * Clear existing entries. */ pkg_window_clear_page(window); treeview = GTK_TREE_VIEW(priv->treeview); gtk_tree_selection_unselect_all(gtk_tree_view_get_selection(treeview)); if (gtk_tree_model_iter_children(model, &child, iter)) { do { if (gtk_tree_model_iter_children(model, &grandchild, &child)) { while (gtk_tree_store_remove(GTK_TREE_STORE(model), &grandchild)) { ;; } } } while (gtk_tree_model_iter_next(model, &child)); } /* * Refresh connection information. */ pk_connection_manager_get_hostname_async( connection, NULL, pkg_window_connection_manager_get_hostname_cb, window); pk_connection_manager_get_channels_async( connection, NULL, pkg_window_connection_manager_get_channels_cb, window); pk_connection_manager_get_plugins_async( connection, NULL, pkg_window_connection_manager_get_plugins_cb, window); pk_connection_manager_get_subscriptions_async( connection, NULL, pkg_window_connection_manager_get_subscriptions_cb, window); pk_connection_manager_get_sources_async( connection, NULL, pkg_window_connection_manager_get_sources_cb, window); EXIT; }
void save_config (GtkButton *button, gpointer user_data) { GtkTreeIter f_iter, h_iter; GValue f_value = {0}; GValue h_value = {0}; gchar *f_src, *f_dst, *h_val; gboolean delete_cond = FALSE, valid = TRUE; gint i, j; GtkWidget *dialog; Widgets *widgets = (Widgets*)user_data; if(gtk_tree_model_get_iter_first (widgets->store, &f_iter) && gtk_tree_model_get_iter_first (widgets->store_hidden, &h_iter)) { gtk_tree_model_get_iter_first (widgets->store_hidden, &h_iter); do { gtk_tree_model_get_value (widgets->store_hidden, &h_iter, 0, &h_value); gtk_tree_model_get_iter_first (widgets->store, &f_iter); do { gtk_tree_model_get_value (widgets->store, &f_iter, 0, &f_value); if(strcmp(g_value_get_string (&f_value), g_value_get_string (&h_value)) == 0) { if(!gtk_tree_store_remove (widgets->store_hidden, &h_iter)) { valid = FALSE; } delete_cond = TRUE; g_value_unset(&f_value); break; } g_value_unset(&f_value); gtk_tree_model_get_value (widgets->store, &f_iter, 1, &f_value); if(strcmp(g_value_get_string (&f_value), g_value_get_string (&h_value)) == 0) { if(!gtk_tree_store_remove (widgets->store_hidden, &h_iter)) { valid = FALSE; } delete_cond = TRUE; g_value_unset(&f_value); break; } g_value_unset(&f_value); } while (gtk_tree_model_iter_next (widgets->store, &f_iter)); g_value_unset(&h_value); if(delete_cond) { delete_cond = FALSE; } else { if(!gtk_tree_model_iter_next (widgets->store_hidden, &h_iter)) { valid = FALSE; } } } while (valid); } if(gtk_tree_model_get_iter_first (widgets->store, &f_iter)) { j=0; do { gtk_tree_model_get_value (widgets->store, &f_iter, 0, &f_value); f_src = g_value_get_string (&f_value); for(i=0; i<size_lang; i++) { if(strcmp(f_src, dicts[i].name) == 0) { favorite[j].src_code = i; break; } } g_value_unset(&f_value); gtk_tree_model_get_value (widgets->store, &f_iter, 1, &f_value); f_dst = g_value_get_string (&f_value); for(i=0; i<size_lang; i++) { if(strcmp(f_dst, dicts[i].name) == 0) { favorite[j].dst_code = i; break; } } g_value_unset(&f_value); //g_print ("\n%s -> %s", *f_src, *f_dst); j++; } while(gtk_tree_model_iter_next (widgets->store, &f_iter)); } for(i=0; i<sizeof(favorite)/sizeof(favorite[0]); i++) { if(favorite[i].src_code == -1) { break; } g_print("\n%d %d", favorite[i].src_code, favorite[i].dst_code); } if(gtk_tree_model_get_iter_first (widgets->store_hidden, &h_iter)) { j=0; do { gtk_tree_model_get_value (widgets->store_hidden, &h_iter, 0, &h_value); h_val = g_value_get_string (&h_value); for(i=0; i<size_lang; i++) { if(strcmp(h_val, dicts[i].name) == 0) { h_dict[j].code = i; break; } } g_value_unset(&h_value); j++; } while(gtk_tree_model_iter_next (widgets->store_hidden, &h_iter)); } for(i=0; i<sizeof(h_dict)/sizeof(h_dict[0]); i++) { if(h_dict[i].code == -1) { break; } g_print("\n%d", h_dict[i].code); } strcpy (shortcut[0].name, gtk_entry_get_text (widgets->entry_sn)); strcpy (shortcut[1].name, gtk_entry_get_text (widgets->entry_wn)); strcpy (shortcut[2].name, gtk_entry_get_text (widgets->entry_sf)); strcpy (shortcut[3].name, gtk_entry_get_text (widgets->entry_sb)); strcpy (shortcut[4].name, gtk_entry_get_text (widgets->log_file_entry)); strcpy (shortcut[5].name, gtk_entry_get_text (widgets->save_freq_entry)); save_config_file (conf_file, &shortcut, &favorite, &h_dict); exit_window (NULL, user_data); exit_code = 1; }
/* count == 0 means this is a detailed mail notification. * count > 0 mean non-detailed. */ static void * pidgin_notify_add_mail(GtkTreeStore *treemodel, PurpleAccount *account, char *notification, const char *url, int count, gboolean clear, gboolean *new_data) { PidginNotifyMailData *data = NULL; GtkTreeIter iter; GdkPixbuf *icon; gboolean new_n = TRUE; if (count > 0 || clear) { /* Allow only one non-detailed email notification for each account */ if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(treemodel), &iter)) { gboolean advanced; do { advanced = FALSE; gtk_tree_model_get(GTK_TREE_MODEL(treemodel), &iter, PIDGIN_MAIL_DATA, &data, -1); if (data->account == account) { if (clear) { #if GTK_CHECK_VERSION(2,2,0) advanced = gtk_tree_store_remove(treemodel, &iter); #else gtk_tree_store_remove(treemodel, &iter); advanced = (iter.stamp == 0) ? FALSE : TRUE; #endif purple_notify_close(PURPLE_NOTIFY_EMAILS, data); /* We're completely done if we've processed all entries */ if (!advanced) return NULL; } else if (data->count > 0) { new_n = FALSE; g_free(data->url); data->url = NULL; mail_dialog->total_count -= data->count; break; } } } while (advanced || gtk_tree_model_iter_next(GTK_TREE_MODEL(treemodel), &iter)); } } if (clear) return NULL; icon = pidgin_create_prpl_icon(account, PIDGIN_PRPL_ICON_MEDIUM); if (new_n) { data = g_new0(PidginNotifyMailData, 1); data->purple_has_handle = TRUE; gtk_tree_store_append(treemodel, &iter, NULL); } if (url != NULL) data->url = g_strdup(url); gtk_tree_store_set(treemodel, &iter, PIDGIN_MAIL_ICON, icon, PIDGIN_MAIL_TEXT, notification, PIDGIN_MAIL_DATA, data, -1); data->account = account; data->count = count; if (icon) g_object_unref(icon); if (new_data) *new_data = new_n; return data; }
int zapisz_reset_O( ROOM_INDEX_DATA *room ) { OBJ_INDEX_DATA *obj; int j, n, v; RESET_DATA *r, *temp; GtkTreeModel *model; GtkTreeIter iter, child; char buf[ MIL ], bufnum[ MIL ]; if ( ( v = SPIN_GET_VALUE( dres.spin_prz ) ) < 0 || !( obj = get_obj_index( v ) ) ) return 1; /* zmien reset O */ dres.reset->arg1 = SPIN_GET_VALUE( dres.spin_prz ); dres.reset->arg2 = SPIN_GET_VALUE( dres.spin_int ); dres.reset->arg3 = SPIN_GET_VALUE( dres.spin_pom ); /* zwolnij wszystkie komentarze i resety P podczepione do resetu O */ for ( r = dres.reset->next; r; ) if ( r->command == 'P' || r->command == '*' ) { temp = r; r = r->next; del_reset( temp ); } else break; temp = r; /* tutaj temp pamieta pierwszy reset spoza O */ r = dres.reset; model = GTK_TREE_MODEL( dres.store_inw ); /* teraz zapis przedmiotow w pojemniku jako resety P */ if ( obj->item_type == ITEM_CONTAINER ) { gtk_tree_model_iter_nth_child( model, &iter, NULL, 0 ); j = gtk_tree_model_iter_n_children( model, &iter ); for ( n = 0; n < j; n++ ) if ( gtk_tree_model_iter_nth_child( model, &child, &iter, n ) ) { OBJ_INDEX_DATA *o; gtk_tree_model_get( model, &child, KOL_WSKAZNIK, &o, -1 ); r->next = new_reset( ); r = r->next; r->command = 'P'; r->arg1 = o->vnum; } } r->next = temp; /* odzwierciedlenie powyzszych zmian na liscie resetow */ strcpy( bufnum, &dres.reset->command ); sprintf( buf, "%s -> %s", obj->short_descr, room->name ); gtk_tree_store_set( dkra.store_res, &dres.iter, KOL_VNUM, bufnum, KOL_OPIS, _( buf ), -1 ); model = GTK_TREE_MODEL( dkra.store_res ); j = gtk_tree_model_iter_n_children( model, &dres.iter ); for ( n = 0; n < j; n++ ) if ( gtk_tree_model_iter_nth_child( model, &child, &dres.iter, 0 ) ) gtk_tree_store_remove( dkra.store_res, &child ); for ( r = dres.reset->next; r && r->command == 'P'; r = r->next ) { OBJ_INDEX_DATA *o = get_obj_index( r->arg1 ); sprintf( bufnum, "%c", r->command ); strcpy( buf, o->short_descr ); gtk_tree_store_append( dkra.store_res, &iter, &dres.iter ); gtk_tree_store_set( dkra.store_res, &iter, KOL_WSKAZNIK, r, KOL_VNUM, bufnum, KOL_OPIS, _( buf ), -1 ); } return 0; }
/* Fill in the list with values in ks */ static void populate_keyservers (SeahorseWidget *swidget, gchar **keyservers) { GtkTreeView *treeview; GtkTreeStore *store; GtkTreeModel *model; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkTreeIter iter; gboolean cont; gchar *value; guint i = 0; treeview = GTK_TREE_VIEW (seahorse_widget_get_widget (swidget, "keyservers")); model = gtk_tree_view_get_model (treeview); store = GTK_TREE_STORE (model); /* This is our first time so create a store */ if (!model) { store = gtk_tree_store_new (N_COLUMNS, G_TYPE_STRING); model = GTK_TREE_MODEL (store); gtk_tree_view_set_model (treeview, model); /* Make the column */ renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "editable", TRUE, NULL); g_signal_connect(renderer, "edited", G_CALLBACK (keyserver_cell_edited), store); column = gtk_tree_view_column_new_with_attributes (_("URL"), renderer , "text", KEYSERVER_COLUMN, NULL); gtk_tree_view_append_column (treeview, column); } /* Mark this so we can ignore events */ g_object_set_data (G_OBJECT (model), UPDATING_MODEL, GINT_TO_POINTER (1)); /* We try and be inteligent about updating so we don't throw * away selections and stuff like that */ if (gtk_tree_model_get_iter_first (model, &iter)) { do { gtk_tree_model_get (model, &iter, KEYSERVER_COLUMN, &value, -1); if (keyservers[i] != NULL && value != NULL && g_utf8_collate (keyservers[i], value) == 0) { cont = gtk_tree_model_iter_next (model, &iter); i++; } else { cont = gtk_tree_store_remove (store, &iter); } g_free (value); } while (cont); } /* Any remaining extra rows */ for ( ; keyservers[i] != NULL; i++) { gtk_tree_store_append (store, &iter, NULL); gtk_tree_store_set (store, &iter, KEYSERVER_COLUMN, keyservers[i], -1); } /* Done updating */ g_object_set_data (G_OBJECT (model), UPDATING_MODEL, NULL); }
int zapisz_reset_M( ROOM_INDEX_DATA *room ) { MOB_INDEX_DATA *mob; OBJ_INDEX_DATA *obj; int i, j, n, v; RESET_DATA *r, *temp; GtkTreeModel *model; GtkTreeIter iter, child; char buf[ MIL ], bufnum[ MIL ]; /* sprawdz poprawnosc danych */ if ( ( v = SPIN_GET_VALUE( dres.spin_mob ) ) < 0 || !( mob = get_mob_index( v ) ) ) return 1; for ( i = 0; i < MAX_WEAR; i++ ) { if ( ( v = SPIN_GET_VALUE( dres.spin_ekw[ i ] ) ) < 0 ) continue; if ( !( obj = get_obj_index( v ) ) ) return 2; if( dres.wear_na_item[ i ] != obj->wear_flags || ( i == WEAR_LIGHT && obj->item_type != ITEM_LIGHT ) ) /* przydalby sie dialog z komunikatem, dlaczego odmawia zapisu */ return 3; } /* zmien reset M */ dres.reset->arg1 = SPIN_GET_VALUE( dres.spin_mob ); dres.reset->arg2 = SPIN_GET_VALUE( dres.spin_int ); dres.reset->arg3 = SPIN_GET_VALUE( dres.spin_pom ); /* zwolnij wszystkie resety podczepione do resetu M */ for ( r = dres.reset->next; r; ) { if ( r->command != 'P' && r->command != 'G' && r->command != 'E' && r->command != '*' ) break; temp = r; r = r->next; del_reset( temp ); } temp = r; /* tutaj temp pamieta pierwszy reset spoza M */ r = dres.reset; model = GTK_TREE_MODEL( dres.store_inw ); /* z kazdego wybranego przedmiotu zrob reset E */ for ( i = 0; i < MAX_WEAR; i++ ) { if ( ( v = SPIN_GET_VALUE( dres.spin_ekw[ i ] ) ) == -1 ) continue; r->next = new_reset( ); r = r->next; r->command = 'E'; r->arg1 = v; r->arg3 = i; iter = dres.iter_ekw[ i ]; /* jesli przedmiot ma zawartosc, zrob z niej resety P */ if ( iter.stamp != 0 ) { j = gtk_tree_model_iter_n_children( model, &iter ); for ( n = 0; n < j; n++ ) if ( gtk_tree_model_iter_nth_child( model, &child, &iter, n ) ) { gtk_tree_model_get( model, &child, KOL_WSKAZNIK, &obj, -1 ); r->next = new_reset( ); r = r->next; r->command = 'P'; r->arg1 = obj->vnum; } } } /* teraz zapis przedmiotow "przy sobie" jako resety G */ gtk_tree_model_get_iter_first( model, &iter ); j = gtk_tree_model_iter_n_children( model, &iter ); for ( n = 0; n < j; n++ ) if ( gtk_tree_model_iter_nth_child( model, &child, &iter, n ) ) { gtk_tree_model_get( model, &child, KOL_WSKAZNIK, &obj, -1 ); r->next = new_reset( ); r = r->next; r->command = 'G'; r->arg1 = obj->vnum; /* resety G moga byc pojemnikami, wiec jeszcze raz resety P: */ { int k, l; GtkTreeIter grandchild; l = gtk_tree_model_iter_n_children( model, &child ); for ( k = 0; k < l; k++ ) if ( gtk_tree_model_iter_nth_child( model, &grandchild, &child, k ) ) { gtk_tree_model_get( model, &grandchild, KOL_WSKAZNIK, &obj, -1 ); r->next = new_reset( ); r = r->next; r->command = 'P'; r->arg1 = obj->vnum; } } } r->next = temp; /* odzwierciedlenie powyzszych zmian na liscie resetow */ strcpy( bufnum, &dres.reset->command ); sprintf( buf, "%s -> %s", mob->short_descr, room->name ); gtk_tree_store_set( dkra.store_res, &dres.iter, KOL_VNUM, bufnum, KOL_OPIS, _( buf ), -1 ); model = GTK_TREE_MODEL( dkra.store_res ); j = gtk_tree_model_iter_n_children( model, &dres.iter ); for ( n = 0; n < j; n++ ) if ( gtk_tree_model_iter_nth_child( model, &child, &dres.iter, 0 ) ) gtk_tree_store_remove( dkra.store_res, &child ); for ( r = dres.reset->next; r; r = r->next ) { switch ( r->command ) { case 'G': case 'E': gtk_tree_store_append( dkra.store_res, &iter, &dres.iter ); child = iter; break; case 'P': gtk_tree_store_append( dkra.store_res, &iter, &child ); break; case '*': continue; default: return 0; } sprintf( bufnum, "%c", r->command ); strcpy( buf, get_obj_index( r->arg1 )->short_descr ); gtk_tree_store_set( dkra.store_res, &iter, KOL_WSKAZNIK, r, KOL_VNUM, bufnum, KOL_OPIS, _( buf ), -1 ); } return 0; }
/* * Update the tree by adding/removing entries * Does not change other nodes */ static void update_tree(struct menu *src, GtkTreeIter * dst) { struct menu *child1; GtkTreeIter iter, tmp; GtkTreeIter *child2 = &iter; gboolean valid; GtkTreeIter *sibling; struct symbol *sym; struct property *prop; struct menu *menu1, *menu2; if (src == &rootmenu) indent = 1; valid = gtk_tree_model_iter_children(model2, child2, dst); for (child1 = src->list; child1; child1 = child1->next) { prop = child1->prompt; sym = child1->sym; reparse: menu1 = child1; if (valid) gtk_tree_model_get(model2, child2, COL_MENU, &menu2, -1); else menu2 = NULL; // force adding of a first child #ifdef DEBUG printf("%*c%s | %s\n", indent, ' ', menu1 ? menu_get_prompt(menu1) : "nil", menu2 ? menu_get_prompt(menu2) : "nil"); #endif if (!menu_is_visible(child1) && !show_all) { // remove node if (gtktree_iter_find_node(dst, menu1) != NULL) { memcpy(&tmp, child2, sizeof(GtkTreeIter)); valid = gtk_tree_model_iter_next(model2, child2); gtk_tree_store_remove(tree2, &tmp); if (!valid) return; // next parent else goto reparse; // next child } else continue; } if (menu1 != menu2) { if (gtktree_iter_find_node(dst, menu1) == NULL) { // add node if (!valid && !menu2) sibling = NULL; else sibling = child2; gtk_tree_store_insert_before(tree2, child2, dst, sibling); set_node(child2, menu1, fill_row(menu1)); if (menu2 == NULL) valid = TRUE; } else { // remove node memcpy(&tmp, child2, sizeof(GtkTreeIter)); valid = gtk_tree_model_iter_next(model2, child2); gtk_tree_store_remove(tree2, &tmp); if (!valid) return; // next parent else goto reparse; // next child } } else if (sym && (sym->flags & SYMBOL_CHANGED)) { set_node(child2, menu1, fill_row(menu1)); } indent++; update_tree(child1, child2); indent--; valid = gtk_tree_model_iter_next(model2, child2); } }
/** * Build data storage by querying the X server for all input devices. * Can be called multiple times, in which case it'll clean out and re-fill * update the tree store. */ static GtkTreeStore* query_devices(GDeviceSetup* gds) { GtkTreeStore *treestore; GtkTreeModel *model; GtkTreeIter iter, child; XIDeviceInfo *devices, *dev; int ndevices; int i, j; int icontype; GdkPixbuf *icon; int valid, child_valid; int id, masterid; if (!gds->treeview) { treestore = gtk_tree_store_new(NUM_COLS, G_TYPE_UINT, /* deviceid*/ G_TYPE_STRING, /* name */ G_TYPE_UINT, GDK_TYPE_PIXBUF, G_TYPE_UINT ); model = GTK_TREE_MODEL(treestore); } else { model = gtk_tree_view_get_model(gds->treeview); treestore = GTK_TREE_STORE(model); } gds->generation++; devices = XIQueryDevice(gds->dpy, XIAllDevices, &ndevices); /* First, run through all master device and append them to the tree store */ for (i = 0; i < ndevices; i++) { dev = &devices[i]; if (dev->use != XIMasterPointer && dev->use != XIMasterKeyboard) continue; valid = gtk_tree_model_get_iter_first(model, &iter); g_debug("MD %d: %s", dev->deviceid, dev->name); while(valid) { gtk_tree_model_get(model, &iter, COL_ID, &id, -1); if (id == dev->deviceid) { gtk_tree_store_set(treestore, &iter, COL_GENERATION, gds->generation, -1); valid = 0xFF; break; } valid = gtk_tree_model_iter_next(model, &iter); } if (valid != 0xFF) /* new MD */ { icontype = (dev->use == XIMasterPointer) ? ICON_MOUSE : ICON_KEYBOARD; icon = load_icon(icontype); gtk_tree_store_append(treestore, &iter, NULL); gtk_tree_store_set(treestore, &iter, COL_ID, dev->deviceid, COL_NAME, dev->name, COL_USE, dev->use, COL_ICON, icon, COL_GENERATION, gds->generation, -1); g_object_unref(icon); } } /* search for Floating fake master device */ valid = gtk_tree_model_get_iter_first(model, &iter); while(valid) { gtk_tree_model_get(model, &iter, COL_ID, &id, -1); if (id == ID_FLOATING) break; valid = gtk_tree_model_iter_next(model, &iter); } if (!valid) { /* Attach a fake master device for "Floating" */ icon = load_icon(ICON_FLOATING); gtk_tree_store_append(treestore, &iter, NULL); gtk_tree_store_set(treestore, &iter, COL_ID, ID_FLOATING, COL_NAME, "Floating", COL_USE, ID_FLOATING, COL_ICON, icon, COL_GENERATION, gds->generation, -1); g_object_unref(icon); } else { GtkTreeIter prev; GtkTreeIter pos = iter; /* current position of Floating */ /* always move Floating fake device to end of list */ while(valid) { prev = iter; valid = gtk_tree_model_iter_next(model, &iter); } gtk_tree_store_move_after(treestore, &pos, &prev); /* update generation too */ gtk_tree_store_set(treestore, &pos, COL_GENERATION, gds->generation, -1); } /* now that we added all MDs, run through again and add SDs to the * respective MD */ for (i = 0; i < ndevices; i++) { dev = &devices[i]; if (dev->use == XIMasterPointer || dev->use == XIMasterKeyboard) continue; g_debug("SD %d: %s", dev->deviceid, dev->name); valid = gtk_tree_model_get_iter_first(model, &iter); while(valid) { gtk_tree_model_get(model, &iter, COL_ID, &masterid, -1); if(dev->attachment == masterid || (dev->use == XIFloatingSlave && masterid == ID_FLOATING)) { /* found master, check if we're already attached to it in * the tree model */ child_valid = gtk_tree_model_iter_children(model, &child, &iter); while (child_valid) { gtk_tree_model_get(model, &child, COL_ID, &id); if (id == dev->deviceid) { gtk_tree_store_set(treestore, &child, COL_GENERATION, gds->generation, -1); child_valid = 0xFF; break; } child_valid = gtk_tree_model_iter_next(model, &child); } /* new slave device, attach */ if (child_valid != 0xFF) { gtk_tree_store_append(treestore, &child, &iter); gtk_tree_store_set(treestore, &child, COL_ID, dev->deviceid, COL_NAME, dev->name, COL_USE, dev->use, COL_GENERATION, gds->generation, -1); } break; } valid = gtk_tree_model_iter_next(model, &iter); } } XIFreeDeviceInfo(devices); /* clean tree store of anything that doesn't have the current server generation */ valid = gtk_tree_model_get_iter_first(model, &iter); while(valid) { int gen; child_valid = gtk_tree_model_iter_children(model, &child, &iter); while(child_valid) { gtk_tree_model_get(model, &child, COL_GENERATION, &gen, -1); if (gen < gds->generation) child_valid = gtk_tree_store_remove(treestore, &child); else child_valid = gtk_tree_model_iter_next(model, &child); } gtk_tree_model_get(model, &iter, COL_GENERATION, &gen, -1); if (gen < gds->generation) valid = gtk_tree_store_remove(treestore, &iter); else valid = gtk_tree_model_iter_next(model, &iter); } return treestore; }
void nav_tree_refresh_synonyms (GSQLNavigation *navigation, GtkTreeView *tv, GtkTreeIter *iter) { GSQL_TRACE_FUNC; GtkTreeModel *model; GtkListStore *detail; GSQLNavigation *nav = NULL; gchar *sql = NULL; gchar *realname = NULL; gchar *owner = NULL; gint id; gint i,n; GtkTreeIter child; GtkTreeIter child_fake; GtkTreeIter child_last; GSQLCursor *cursor; GSQLCursorState state; GSQLVariable *var; GSQLSession *session; GtkListStore *details; gchar *name; gchar key[256]; model = gtk_tree_view_get_model(tv); n = gtk_tree_model_iter_n_children(model, iter); for (; n>1; n--) { gtk_tree_model_iter_children(model, &child, iter); gtk_tree_store_remove(GTK_TREE_STORE(model), &child); } gtk_tree_model_iter_children(model, &child_last, iter); gtk_tree_model_get (model, iter, GSQL_NAV_TREE_REALNAME, &realname, -1); gtk_tree_model_get (model, iter, GSQL_NAV_TREE_SQL, &sql, -1); g_return_if_fail (sql != NULL); gtk_tree_model_get (model, iter, GSQL_NAV_TREE_OWNER, &owner, -1); session = gsql_session_get_active (); if (strncmp (owner, gsql_session_get_username (session), 64)) sql = (gchar *) sql_oracle_synonyms; cursor = gsql_cursor_new (session, sql); state = gsql_cursor_open_with_bind (cursor, FALSE, GSQL_CURSOR_BIND_BY_NAME, G_TYPE_STRING, ":owner", G_TYPE_STRING, owner, G_TYPE_STRING, ":name", G_TYPE_STRING, "%", -1); var = g_list_nth_data(cursor->var_list,0); if (state != GSQL_CURSOR_STATE_OPEN) { gsql_cursor_close (cursor); return; } i = 0; while (gsql_cursor_fetch (cursor, 1) > 0) { i++; if (var->value_type != G_TYPE_STRING) { GSQL_DEBUG ("The name of object should be a string (char *). Is the bug"); name = N_("Incorrect data"); } else { name = (gchar *) var->value; // make a key for a hash of details memset (key, 0, 256); g_snprintf (key, 255, "%x%s%d%s", session, owner, SYNONYM_ID, name); details = gsql_navigation_get_details (navigation, key); oracle_navigation_fill_details (cursor, details); } gtk_tree_store_append (GTK_TREE_STORE(model), &child, iter); gtk_tree_store_set (GTK_TREE_STORE(model), &child, GSQL_NAV_TREE_ID, SYNONYM_ID, GSQL_NAV_TREE_OWNER, owner, GSQL_NAV_TREE_IMAGE, GSQLE_ORACLE_STOCK_SYNONYMS, GSQL_NAV_TREE_NAME, name, GSQL_NAV_TREE_REALNAME, name, GSQL_NAV_TREE_ITEM_INFO, NULL, GSQL_NAV_TREE_SQL, NULL, GSQL_NAV_TREE_OBJECT_POPUP, NULL, GSQL_NAV_TREE_OBJECT_HANDLER, NULL, GSQL_NAV_TREE_EXPAND_HANDLER, NULL, GSQL_NAV_TREE_EVENT_HANDLER, NULL, GSQL_NAV_TREE_STRUCT, synonyms, GSQL_NAV_TREE_DETAILS, details, GSQL_NAV_TREE_NUM_ITEMS, G_N_ELEMENTS(synonyms), -1); gtk_tree_store_append (GTK_TREE_STORE (model), &child_fake, &child); gtk_tree_store_set (GTK_TREE_STORE (model), &child_fake, GSQL_NAV_TREE_ID, -1, GSQL_NAV_TREE_IMAGE, NULL, GSQL_NAV_TREE_NAME, N_("Processing..."), GSQL_NAV_TREE_REALNAME, NULL, GSQL_NAV_TREE_ITEM_INFO, NULL, GSQL_NAV_TREE_SQL, NULL, GSQL_NAV_TREE_OBJECT_POPUP, NULL, GSQL_NAV_TREE_OBJECT_HANDLER, NULL, GSQL_NAV_TREE_EXPAND_HANDLER, NULL, GSQL_NAV_TREE_EVENT_HANDLER, NULL, GSQL_NAV_TREE_STRUCT, NULL, GSQL_NAV_TREE_NUM_ITEMS, NULL, -1); } GSQL_DEBUG ("Items fetched: [%d]", i); if (i > 0) { name = g_strdup_printf("%s<span weight='bold'> [%d]</span>", realname, i); gtk_tree_store_set (GTK_TREE_STORE(model), iter, GSQL_NAV_TREE_NAME, name, -1); g_free (name); } gtk_tree_store_remove(GTK_TREE_STORE(model), &child_last); gsql_cursor_close (cursor); }
void nav_tree_refresh_indexes (GSQLNavigation *navigation, GtkTreeView *tv, GtkTreeIter *iter) { GSQL_TRACE_FUNC; GtkTreeModel *model; GtkListStore *detail; GSQLNavigation *nav = NULL; gchar *sql = NULL; gchar *realname = NULL; gchar *owner = NULL; gint id; gint i,n; GtkTreeIter child; GtkTreeIter parent; GtkTreeIter child_fake; GtkTreeIter child_last; GSQLCursor *cursor; GSQLVariable *var, *var_t, *tmp = NULL; GSQLSession *session; GSQLWorkspace *workspace; GSQLCursorState state; GtkListStore *details; gchar *name; gchar *key; guint length = 0; gchar *stock = NULL; gchar *tbl = "%"; gchar *parent_name = NULL; model = gtk_tree_view_get_model(tv); n = gtk_tree_model_iter_n_children(model, iter); for (; n>1; n--) { gtk_tree_model_iter_children (model, &child, iter); gtk_tree_store_remove (GTK_TREE_STORE(model), &child); } gtk_tree_model_iter_children(model, &child_last, iter); gtk_tree_model_get (model, iter, GSQL_NAV_TREE_REALNAME, &realname, -1); gtk_tree_model_get (model, iter, GSQL_NAV_TREE_SQL, &sql, -1); g_return_if_fail (sql != NULL); gtk_tree_model_get (model, iter, GSQL_NAV_TREE_OWNER, &owner, -1); session = gsql_session_get_active (); // get parent iter. if this iter are TABLE_ID then // we looking for table's constraints only. gtk_tree_model_iter_parent (model, &parent, iter); gtk_tree_model_get (model, &parent, GSQL_NAV_TREE_ID, &id, -1); gtk_tree_model_get (model, &parent, GSQL_NAV_TREE_NAME, &parent_name, -1); if ((id == TABLE_ID) && (parent_name != NULL)) tbl = parent_name; GSQL_DEBUG ("realname:[%s] sql:[%s] owner:[%s]", realname, sql, owner); cursor = gsql_cursor_new (session, sql); state = gsql_cursor_open_with_bind (cursor, FALSE, GSQL_CURSOR_BIND_BY_POS, G_TYPE_STRING, tbl, -1); var = g_list_nth_data(cursor->var_list,0); var_t = g_list_nth_data(cursor->var_list,1); if (state != GSQL_CURSOR_STATE_OPEN) { gsql_cursor_close (cursor); return; } i = 0; while (gsql_cursor_fetch (cursor, 1) > 0) { i++; if (var->value_type != G_TYPE_STRING) { GSQL_DEBUG ("The name of object should be a string (char *). Is the bug"); name = N_("Incorrect data"); } else { if (var->raw_to_value) { tmp = g_malloc0(sizeof(GSQLVariable)); memcpy(tmp, var, sizeof(GSQLVariable)); var->raw_to_value (tmp); } name = (gchar *) var->value; // make a key for a hash of details length = g_snprintf (NULL,0, "%x%s%d%s", session, (gchar *) tmp->value, INDEX_ID, (gchar *) tmp->value); key = g_malloc0(length); memset (key, 0, length); g_snprintf (key, length - 1, "%x%s%d%s", session, (gchar *) tmp->value, INDEX_ID, (gchar *) tmp->value); details = gsql_navigation_get_details (navigation, key); firebird_navigation_fill_details (cursor, details); } gtk_tree_store_append (GTK_TREE_STORE(model), &child, iter); gtk_tree_store_set (GTK_TREE_STORE(model), &child, GSQL_NAV_TREE_ID, INDEX_ID, GSQL_NAV_TREE_OWNER, owner, GSQL_NAV_TREE_IMAGE, GSQL_STOCK_INDEXES, GSQL_NAV_TREE_NAME, name, GSQL_NAV_TREE_REALNAME, (gchar *) tmp->value, GSQL_NAV_TREE_ITEM_INFO, NULL, GSQL_NAV_TREE_SQL, NULL, GSQL_NAV_TREE_OBJECT_POPUP, NULL, GSQL_NAV_TREE_OBJECT_HANDLER, NULL, GSQL_NAV_TREE_EXPAND_HANDLER, NULL, GSQL_NAV_TREE_EVENT_HANDLER, NULL, GSQL_NAV_TREE_STRUCT, indexes, GSQL_NAV_TREE_DETAILS, details, GSQL_NAV_TREE_NUM_ITEMS, G_N_ELEMENTS(indexes), -1); gtk_tree_store_append (GTK_TREE_STORE (model), &child_fake, &child); gtk_tree_store_set (GTK_TREE_STORE (model), &child_fake, GSQL_NAV_TREE_ID, -1, GSQL_NAV_TREE_IMAGE, NULL, GSQL_NAV_TREE_NAME, N_("Processing..."), GSQL_NAV_TREE_REALNAME, NULL, GSQL_NAV_TREE_ITEM_INFO, NULL, GSQL_NAV_TREE_SQL, NULL, GSQL_NAV_TREE_OBJECT_POPUP, NULL, GSQL_NAV_TREE_OBJECT_HANDLER, NULL, GSQL_NAV_TREE_EXPAND_HANDLER, NULL, GSQL_NAV_TREE_EVENT_HANDLER, NULL, GSQL_NAV_TREE_STRUCT, NULL, GSQL_NAV_TREE_NUM_ITEMS, NULL, -1); g_free (key); if (tmp) g_free(tmp); } GSQL_DEBUG ("Items fetched: [%d]", i); if (i > 0) { name = g_strdup_printf("%s<span weight='bold'> [%d]</span>", realname, i); gtk_tree_store_set (GTK_TREE_STORE(model), iter, GSQL_NAV_TREE_NAME, name, -1); g_free (name); } gtk_tree_store_remove(GTK_TREE_STORE(model), &child_last); gsql_cursor_close (cursor); }
// start helpers static void swap_buses (GtkTreeModel *tm, GtkTreeSelection *sel, bus_layout_D *dialog, GtkTreePath *tpSrc, GtkTreePath *tpDst) { int Nix ; GtkTreeIter itr ; SWAP_BUSES_STRUCT src, dst ; SWAP_BUSES_STRUCT *min = NULL, *max = NULL ; EXP_ARRAY *ar_bSelSrc = NULL, *ar_bSelDst = NULL ; gboolean bDstExpanded = TRUE ; if (!gtk_tree_model_get_iter (tm, &(src.itr), tpSrc)) return ; src.tp = gtk_tree_path_copy (tpSrc) ; src.icChildren = gtk_tree_model_iter_n_children (tm, &(src.itr)) ; if (!gtk_tree_model_get_iter (tm, &(dst.itr), tpDst)) { gtk_tree_path_free (src.tp) ; return ; } dst.tp = gtk_tree_path_copy (tpDst) ; dst.icChildren = gtk_tree_model_iter_n_children (tm, &(dst.itr)) ; if (dst.icChildren < src.icChildren) { min = &dst ; max = &src ; } else { min = &src ; max = &dst ; } bDstExpanded = gtk_tree_view_row_expanded (gtk_tree_selection_get_tree_view (sel), dst.tp) ; g_signal_handlers_block_matched (G_OBJECT (sel), G_SIGNAL_MATCH_FUNC, 0, 0, NULL, (gpointer)tree_view_selection_changed, NULL) ; for (Nix = 0 ; Nix < max->icChildren - min->icChildren ; Nix++) gtk_tree_store_append (GTK_TREE_STORE (tm), &itr, &(min->itr)) ; gtk_tree_path_down (src.tp) ; gtk_tree_path_down (dst.tp) ; ar_bSelSrc = exp_array_new (sizeof (gboolean), 1) ; ar_bSelDst = exp_array_new (sizeof (gboolean), 1) ; exp_array_1d_insert_vals (ar_bSelSrc, NULL, max->icChildren, 0) ; exp_array_1d_insert_vals (ar_bSelDst, NULL, max->icChildren, 0) ; for (Nix = 0 ; Nix < max->icChildren ; Nix++) { exp_array_index_1d (ar_bSelSrc, gboolean, Nix) = gtk_tree_selection_path_is_selected (sel, src.tp) ; exp_array_index_1d (ar_bSelDst, gboolean, Nix) = gtk_tree_selection_path_is_selected (sel, dst.tp) ; gtk_tree_path_next (src.tp) ; gtk_tree_path_next (dst.tp) ; } if (!gtk_tree_path_up (src.tp)) goto swap_buses_quit ; if (!gtk_tree_path_up (dst.tp)) goto swap_buses_quit ; gtk_tree_path_down (src.tp) ; gtk_tree_path_down (dst.tp) ; for (Nix = 0 ; Nix < max->icChildren ; Nix++) { if (exp_array_index_1d (ar_bSelDst, gboolean, Nix)) gtk_tree_view_expand_to_path (gtk_tree_selection_get_tree_view (sel), src.tp) ; if (exp_array_index_1d (ar_bSelSrc, gboolean, Nix)) gtk_tree_view_expand_to_path (gtk_tree_selection_get_tree_view (sel), dst.tp) ; gtk_tree_path_next (src.tp) ; gtk_tree_path_next (dst.tp) ; } if (!gtk_tree_path_up (src.tp)) goto swap_buses_quit ; if (!gtk_tree_path_up (dst.tp)) goto swap_buses_quit ; gtk_tree_path_down (src.tp) ; gtk_tree_path_down (dst.tp) ; for (Nix = 0 ; Nix < max->icChildren ; Nix++) { swap_model_paths_contents (tm, src.tp, dst.tp) ; gtk_tree_path_next (src.tp) ; gtk_tree_path_next (dst.tp) ; } if (!gtk_tree_path_up (src.tp)) goto swap_buses_quit ; if (!gtk_tree_path_up (dst.tp)) goto swap_buses_quit ; gtk_tree_path_down (src.tp) ; gtk_tree_path_down (dst.tp) ; for (Nix = 0 ; Nix < max->icChildren ; Nix++) { GTK_TREE_SELECTION_SET_PATH_SELECTED (sel, src.tp, exp_array_index_1d (ar_bSelDst, gboolean, Nix)) ; GTK_TREE_SELECTION_SET_PATH_SELECTED (sel, dst.tp, exp_array_index_1d (ar_bSelSrc, gboolean, Nix)) ; gtk_tree_path_next (src.tp) ; gtk_tree_path_next (dst.tp) ; } if (!gtk_tree_path_up (src.tp)) goto swap_buses_quit ; if (!gtk_tree_path_up (dst.tp)) goto swap_buses_quit ; swap_model_paths_contents (tm, src.tp, dst.tp) ; gtk_tree_path_down (src.tp) ; gtk_tree_path_down (dst.tp) ; for (Nix = 0 ; Nix < min->icChildren ; Nix++) gtk_tree_path_next (max->tp) ; if (gtk_tree_model_get_iter (tm, &itr, max->tp)) while (gtk_tree_store_remove (GTK_TREE_STORE (tm), &itr)) ; if (!bDstExpanded) { for (Nix = 0 ; Nix < ar_bSelDst->icUsed ; Nix++) if (exp_array_index_1d (ar_bSelDst, gboolean, Nix)) break ; if (Nix == ar_bSelDst->icUsed) if (gtk_tree_path_up (src.tp)) gtk_tree_view_collapse_row (gtk_tree_selection_get_tree_view (sel), src.tp) ; } swap_buses_quit: exp_array_free (ar_bSelSrc) ; exp_array_free (ar_bSelDst) ; gtk_tree_path_free (src.tp) ; gtk_tree_path_free (dst.tp) ; g_signal_handlers_unblock_matched (G_OBJECT (sel), G_SIGNAL_MATCH_FUNC, 0, 0, NULL, (gpointer)tree_view_selection_changed, NULL) ; tree_view_selection_changed (sel, dialog) ; }
/* * watch expression has been changed */ static void on_watch_changed(GtkCellRendererText *renderer, gchar *path, gchar *new_text, gpointer user_data) { /* get iterator to the changed row */ GtkTreeIter iter; GtkTreePath *tree_path = gtk_tree_path_new_from_string (path); gtk_tree_model_get_iter ( gtk_tree_view_get_model(GTK_TREE_VIEW(wtree)), &iter, tree_path); /* get oldvalue */ gchar* oldvalue; gtk_tree_model_get ( wmodel, &iter, W_NAME, &oldvalue, -1); gchar *internal = NULL; gtk_tree_model_get ( wmodel, &iter, W_INTERNAL, &internal, -1); /* check if it is empty row */ gboolean is_empty_row = !gtk_tree_path_compare (tree_path, wtree_empty_path()); gchar *striped = g_strstrip(g_strdup(new_text)); if (!strlen(striped) && !is_empty_row && dialogs_show_question(_("Delete variable?"))) { /* if new value is empty string on non-empty row * offer to delete watch */ gtk_tree_store_remove(wstore, &iter); if (DBS_STOPPED == debug_state) active_module->remove_watch(internal); config_set_debug_changed(); } else if (strcmp(oldvalue, striped)) { /* new value is non empty */ /* insert new row if changing was the last empty row */ GtkTreeIter newiter; if (is_empty_row) gtk_tree_store_insert_before(wstore, &newiter, NULL, &iter); /* set expression */ variable_set_name_only(wstore, is_empty_row ? &newiter : &iter, striped); /* if debug is active - remove old watch and add new one */ if (DBS_STOPPED == debug_state) { active_module->remove_watch(internal); variable *newvar = active_module->add_watch(striped); change_watch(GTK_TREE_VIEW(wtree), is_empty_row ? &newiter : &iter, newvar); } /* if new watch has been added - set selection to the new created row */ if (is_empty_row) { GtkTreePath *_path = gtk_tree_model_get_path(wmodel, &newiter); GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(wtree)); gtk_tree_selection_unselect_all(selection); gtk_tree_selection_select_path(selection, _path); gtk_tree_path_free(_path); } config_set_debug_changed(); } /* free resources */ gtk_tree_path_free(tree_path); g_free(oldvalue); g_free(internal); g_free(striped); }