GtkTreeModel* refresh_cartesian_list_model(cartesianMover *cm) { const int ADDITIONAL_COLUMNS = 2; GType types[NUMBER_OF_CARTESIAN_COORDINATES + ADDITIONAL_COLUMNS]; GtkListStore *store; GtkTreeIter iter; GValue valore= {0}; g_value_init(&valore, G_TYPE_STRING); int cols[NUMBER_OF_CARTESIAN_COORDINATES + ADDITIONAL_COLUMNS]; int k,j; for (k = 0; k < NUMBER_OF_CARTESIAN_COORDINATES + ADDITIONAL_COLUMNS; k++) { types[k] = G_TYPE_STRING; cols[k] = k; } store = gtk_list_store_newv ( NUMBER_OF_CARTESIAN_COORDINATES + ADDITIONAL_COLUMNS, types); //gtk_list_store_set (store, &iter, 0, 0.0, 1, 0.1, 2, 0.2, 3, 0.3, 4, 0.4, 5, 0.5, 6, 0.6, 7, 0.7, 8, 0.8 , 9, 0.9, 10, 1.0, 11, 1.1, 12, 1.2, 13, 1.3, 14, 1.4, 15, 1.5, -1); char buffer[800]; for (j = 0; j < NUMBER_OF_STORED; j++) { gtk_list_store_append (store, &iter); for (k = 0; k < ADDITIONAL_COLUMNS; k++) { if (k == POS_SEQUENCE) sprintf(buffer, "%d", cm->SEQUENCE[j]); else sprintf(buffer, "%.1f", cm->TIMING[j]); g_value_set_string(&valore, buffer); gtk_list_store_set_value(store, &iter, cols[k], &valore); } for (k = 0; k < NUMBER_OF_CARTESIAN_COORDINATES; k++) { sprintf(buffer, "%.1f", cm->STORED_POS[j][k]); g_value_set_string(&valore, buffer); gtk_list_store_set_value(store, &iter, cols[k+ADDITIONAL_COLUMNS], &valore); } } return GTK_TREE_MODEL (store); }
static void pidgin_notify_searchresults_new_rows(PurpleConnection *gc, PurpleNotifySearchResults *results, void *data_) { PidginNotifySearchResultsData *data = data_; GtkListStore *model = data->model; GtkTreeIter iter; GdkPixbuf *pixbuf; GList *row, *column; guint n; gtk_list_store_clear(data->model); pixbuf = pidgin_create_prpl_icon(purple_connection_get_account(gc), 0.5); for (row = results->rows; row != NULL; row = row->next) { gtk_list_store_append(model, &iter); gtk_list_store_set(model, &iter, 0, pixbuf, -1); n = 1; for (column = row->data; column != NULL; column = column->next) { GValue v; v.g_type = 0; g_value_init(&v, G_TYPE_STRING); g_value_set_string(&v, column->data); gtk_list_store_set_value(model, &iter, n, &v); n++; } } if (pixbuf != NULL) g_object_unref(pixbuf); }
/**************************************************************** Source row activated *****************************************************************/ static void src_row_callback(GtkTreeView *view, GtkTreePath *path, GtkTreeViewColumn *col, gpointer data) { struct worklist_data *ptr; GtkTreeModel *src_model, *dst_model; GtkTreeIter src_it, dst_it; gint i, ncols; ptr = data; if (!gtk_widget_is_sensitive(ptr->dst_view)) { return; } src_model = GTK_TREE_MODEL(ptr->src); dst_model = GTK_TREE_MODEL(ptr->dst); gtk_tree_model_get_iter(src_model, &src_it, path); gtk_list_store_append(GTK_LIST_STORE(dst_model), &dst_it); ncols = gtk_tree_model_get_n_columns(src_model); for (i = 0; i < ncols; i++) { GValue value = { 0, }; gtk_tree_model_get_value(src_model, &src_it, i, &value); gtk_list_store_set_value(GTK_LIST_STORE(dst_model), &dst_it, i, &value); } commit_worklist(ptr); }
static int pygtk_tree_model_row_setitem(PyGtkTreeModelRow *self, Py_ssize_t column, PyObject *pyvalue) { gint n_columns; GValue value = { 0, }; if (!GTK_IS_LIST_STORE(self->model) && !GTK_IS_TREE_STORE(self->model)) { PyErr_SetString(PyExc_TypeError, "can not set cells in this tree model"); return -1; } n_columns = gtk_tree_model_get_n_columns(self->model); if (column < 0 || column >= n_columns) { PyErr_SetString(PyExc_IndexError, "column index out of range"); return -1; } g_value_init(&value, gtk_tree_model_get_column_type(self->model, column)); if (pyg_value_from_pyobject(&value, pyvalue)) { PyErr_SetString(PyExc_TypeError, "value is of wrong type for this column"); return -1; } if (GTK_IS_LIST_STORE(self->model)) gtk_list_store_set_value(GTK_LIST_STORE(self->model), &self->iter, column, &value); else if (GTK_IS_TREE_STORE(self->model)) gtk_tree_store_set_value(GTK_TREE_STORE(self->model), &self->iter, column, &value); g_value_unset(&value); return 0; }
void wxBitmapComboBox::SetItemBitmap(unsigned int n, const wxBitmap& bitmap) { if ( bitmap.IsOk() ) { if ( m_bitmapSize.x < 0 ) { m_bitmapSize.x = bitmap.GetWidth(); m_bitmapSize.y = bitmap.GetHeight(); } GtkComboBox* combobox = GTK_COMBO_BOX( m_widget ); GtkTreeModel *model = gtk_combo_box_get_model( combobox ); GtkTreeIter iter; if ( gtk_tree_model_iter_nth_child( model, &iter, NULL, n ) ) { GValue value0 = { 0, }; g_value_init( &value0, G_TYPE_OBJECT ); g_value_set_object( &value0, bitmap.GetPixbuf() ); gtk_list_store_set_value( GTK_LIST_STORE(model), &iter, m_bitmapCellIndex, &value0 ); g_value_unset( &value0 ); } } }
gboolean stk_buddytree_update(stk_client *client) { GtkTreeModel *model; GtkTreeIter iter; unsigned int uid, old_uid; char buf[64] = {0}; char *str = NULL; gboolean valid; GValue v; uid = client->stkc_uid; model = gtk_tree_view_get_model(GTK_TREE_VIEW(treeview)); for (valid = gtk_tree_model_get_iter_first(model, &iter); valid; valid = gtk_tree_model_iter_next(model, &iter)) { gtk_tree_model_get(model, &iter, STK_BUDDY_ID_COL, &str, -1); old_uid = atoi(str); g_free (str); if (uid == old_uid) { break; } } if (valid) { memset(buf, 0, sizeof(buf)); sprintf(buf, "%s", (client->stkc_state == STK_CLIENT_ONLINE)?"online":"offline"); v.g_type = 0; g_value_init(&v, G_TYPE_STRING); g_value_set_string(&v, buf); gtk_list_store_set_value(GTK_LIST_STORE(model), &iter, STK_BUDDY_STATUS_COL, &v); } return FALSE; }
void write_symbol(GtkTreeModel* model, GtkTreeIter* iter, int symbol, int size) { /* Set the next value */ GValue initi = G_VALUE_INIT; g_value_init(&initi, G_TYPE_INT); GValue inits = G_VALUE_INIT; g_value_init(&inits, G_TYPE_STRING); if(symbol == LE) { g_value_set_int(&initi, LE); g_value_set_static_string(&inits, LES); } else if(symbol == EQ) { g_value_set_int(&initi, EQ); g_value_set_static_string(&inits, EQS); } else { g_value_set_int(&initi, GE); g_value_set_static_string(&inits, GES); } gtk_list_store_set_value(GTK_LIST_STORE(model), iter, size - 2, &initi); gtk_list_store_set_value(GTK_LIST_STORE(model), iter, 2*size - 2, &inits); }
void list_store_set_oop (GtkListStore *store, GtkTreeIter *iter, int col, OOP value) { GValue gval = { 0 }; g_value_init (&gval, gtk_tree_model_get_column_type (GTK_TREE_MODEL(store), col)); g_value_fill_from_oop (&gval, value); gtk_list_store_set_value (store, iter, col, &gval); g_value_unset (&gval); }
void wxBitmapComboBox::GTKInsertComboBoxTextItem( unsigned int n, const wxString& text ) { GtkComboBox* combobox = GTK_COMBO_BOX( m_widget ); GtkTreeModel *model = gtk_combo_box_get_model( combobox ); GtkListStore *store = GTK_LIST_STORE( model ); GtkTreeIter iter; gtk_list_store_insert( store, &iter, n ); GValue value = { 0, }; g_value_init( &value, G_TYPE_STRING ); g_value_set_string( &value, wxGTK_CONV( text ) ); gtk_list_store_set_value( store, &iter, m_stringCellIndex, &value ); g_value_unset( &value ); }
void cell_edited_cb(GtkCellRendererToggle *cell_renderer, gchar* path, gpointer user_data) { /* Get reference to model */ GtkTreePath* model_path = gtk_tree_path_new_from_string(path); GtkTreeIter iter; gtk_tree_model_get_iter(GTK_TREE_MODEL(format_model), &iter, model_path); gtk_tree_path_free(model_path); GValue value = G_VALUE_INIT; g_value_init(&value, G_TYPE_BOOLEAN); g_value_set_boolean(&value, !gtk_cell_renderer_toggle_get_active(cell_renderer)); gtk_list_store_set_value(format_model, &iter, 1, &value); }
static VALUE rg_set_value(VALUE self, VALUE iter, VALUE column, VALUE value) { GType gtype = gtk_tree_model_get_column_type(RVAL2GTKTREEMODEL(self), NUM2INT(column)); GValue gval = G_VALUE_INIT; g_value_init(&gval, gtype); rbgobj_rvalue_to_gvalue(value, &gval); G_CHILD_ADD(iter, value); gtk_list_store_set_value(_SELF(self), RVAL2GTKTREEITER(iter), NUM2INT(column), &gval); g_value_unset(&gval); return self; }
/**************************************************************** Insert item to queue *****************************************************************/ static void queue_insert(struct worklist_data *ptr, bool prepend) { GtkTreeModel *model; GtkTreeIter it; GtkTreePath *path; GtkTreeModel *src_model, *dst_model; GtkTreeIter src_it, dst_it; gint i, ncols; if (!gtk_widget_is_sensitive(ptr->dst_view)) { return; } if (!gtk_tree_selection_get_selected(ptr->src_selection, &model, &it)) { return; } path = gtk_tree_model_get_path(model, &it); src_model = GTK_TREE_MODEL(ptr->src); dst_model = GTK_TREE_MODEL(ptr->dst); gtk_tree_model_get_iter(src_model, &src_it, path); if (prepend) { gtk_list_store_prepend(GTK_LIST_STORE(dst_model), &dst_it); } else { gtk_list_store_append(GTK_LIST_STORE(dst_model), &dst_it); } ncols = gtk_tree_model_get_n_columns(src_model); for (i = 0; i < ncols; i++) { GValue value = { 0, }; gtk_tree_model_get_value(src_model, &src_it, i, &value); gtk_list_store_set_value(GTK_LIST_STORE(dst_model), &dst_it, i, &value); } commit_worklist(ptr); gtk_tree_path_free(path); }
void wxChoice::SetString(unsigned int n, const wxString &text) { wxCHECK_RET( m_widget != NULL, wxT("invalid control") ); GtkComboBox* combobox = GTK_COMBO_BOX( m_widget ); wxCHECK_RET( IsValid(n), wxT("invalid index") ); GtkTreeModel *model = gtk_combo_box_get_model( combobox ); GtkTreeIter iter; if (gtk_tree_model_iter_nth_child (model, &iter, NULL, n)) { GValue value = G_VALUE_INIT; g_value_init( &value, G_TYPE_STRING ); g_value_set_string( &value, wxGTK_CONV( text ) ); gtk_list_store_set_value( GTK_LIST_STORE(model), &iter, m_stringCellIndex, &value ); g_value_unset( &value ); } InvalidateBestSize(); }
/* Create a deep copy of SRC */ GtkListStore * clone_list_store (const GtkListStore *src) { GtkTreeIter src_iter; gboolean ok; gint i; const gint n_cols = gtk_tree_model_get_n_columns (GTK_TREE_MODEL (src)); GType *types = g_malloc (sizeof (*types) * n_cols); int row = 0; GtkListStore *dest; for (i = 0 ; i < n_cols; ++i ) types[i] = gtk_tree_model_get_column_type (GTK_TREE_MODEL (src), i); dest = gtk_list_store_newv (n_cols, types); for (ok = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (src), &src_iter); ok; ok = gtk_tree_model_iter_next (GTK_TREE_MODEL (src), &src_iter)) { GtkTreeIter dest_iter; gtk_list_store_append (dest, &dest_iter); for (i = 0 ; i < n_cols; ++i ) { GValue val = {0}; gtk_tree_model_get_value (GTK_TREE_MODEL (src), &src_iter, i, &val); gtk_list_store_set_value (dest, &dest_iter, i, &val); g_value_unset (&val); } row++; } g_free (types); return dest; }
void wxComboBox::SetString(unsigned int n, const wxString &text) { wxCHECK_RET( m_widget != NULL, wxT("invalid combobox") ); #ifdef __WXGTK24__ if (!gtk_check_version(2,4,0)) { GtkComboBox* combobox = GTK_COMBO_BOX( m_widget ); wxCHECK_RET( IsValid(n), wxT("invalid index") ); GtkTreeModel *model = gtk_combo_box_get_model( combobox ); GtkTreeIter iter; if (gtk_tree_model_iter_nth_child (model, &iter, NULL, n)) { GValue value = { 0, }; g_value_init( &value, G_TYPE_STRING ); g_value_set_string( &value, wxGTK_CONV( text ) ); gtk_list_store_set_value( GTK_LIST_STORE(model), &iter, 0, &value ); g_value_unset( &value ); } } else #endif { GtkWidget *list = GTK_COMBO(m_widget)->list; GList *child = g_list_nth( GTK_LIST(list)->children, n ); if (child) { GtkBin *bin = GTK_BIN( child->data ); GtkLabel *label = GTK_LABEL( bin->child ); gtk_label_set_text(label, wxGTK_CONV(text)); } else { wxFAIL_MSG( wxT("wxComboBox: wrong index") ); } } InvalidateBestSize(); }
static void set_list_to_store(orcaList* lp, GtkTreeModel* store, GtkTreeIter* iter, handle_type type)/*{{{*/ { orcaListIter it = lp->begin(); for (int i=0; it != lp->end(); ++it, i++) { GValue value = { 0, }; if (is<TYPE_STR>(*it)) { g_value_init(&value, G_TYPE_STRING); g_value_set_string(&value, (*it).String().c_str()); } else if (is<TYPE_BOOL>(*it)) { g_value_init(&value, G_TYPE_BOOLEAN); g_value_set_boolean(&value, (*it).i()); } if (type == GUI_LIST) gtk_list_store_set_value(GTK_LIST_STORE(store), iter, i, &value); else gtk_tree_store_set_value(GTK_TREE_STORE(store), iter, i, &value); } }
/* * This could _potentially_ be replaced if we were to expose Value binding of * GBoxed types on the Java side. */ JNIEXPORT void JNICALL Java_org_gnome_gtk_GtkTreeModelOverride_gtk_1list_1store_1set_1reference ( JNIEnv *env, jclass cls, jlong _self, jlong _row, jint _column, jobject _reference ) { GtkListStore* self; GtkTreeIter* row; gint column; GValue value = { 0, }; gpointer reference; // convert parameter self self = (GtkListStore*) _self; // convert parameter iter row = (GtkTreeIter*) _row; // convert parameter column column = (gint) _column; // convert parameter reference g_value_init(&value, BINDINGS_JAVA_TYPE_REFERENCE); reference = (gpointer) _reference; g_value_set_boxed(&value, reference); // call function gtk_list_store_set_value(self, row, column, &value); // clean up g_value_unset(&value); }
GtkListStore * xml_tree_model_get_xpath_results(xmlTreeModel *xmltreemodel, gchar *xpath) { g_return_val_if_fail (XML_IS_TREE_MODEL(xmltreemodel), NULL); g_return_val_if_fail (xpath != NULL, NULL); g_return_val_if_fail (xmltreemodel->xmldoc != NULL, NULL); GtkListStore *list_store; GtkTreeIter itern, iterx; gint i, size, column; xmlXPathObjectPtr xpath_results; list_store = gtk_list_store_newv (xmltreemodel->n_columns,xmltreemodel->column_types); xpath_results = evaluate_xpath(xmltreemodel->xmldoc, xpath); size = (xpath_results) ? xpath_results->nodesetval->nodeNr : 0; for(i = 0; i < size; ++i) { xmlNodePtr record; GValue value = G_VALUE_INIT; record = xpath_results->nodesetval->nodeTab[i]; iterx.user_data = record; gtk_list_store_append (list_store, &itern); for(column = 0; column < xmltreemodel->n_columns; ++column) { xml_tree_model_get_value(GTK_TREE_MODEL(xmltreemodel), &iterx, column, &value); gtk_list_store_set_value ( list_store, &itern, column, &value ); g_value_unset(&value); } } xmlXPathFreeObject(xpath_results); return list_store; }
/* * Set a column in the map provider table to a new value and mirror the changes * in the key file. If value is NULL, restore the default value. */ void ph_config_set_map_provider(GtkTreeIter *iter, guint row, gint column, const GValue *value) { gchar *name; gchar *group; const gchar *key; g_return_if_fail(ph_config != NULL); g_return_if_fail(iter != NULL); g_return_if_fail(column >= 0 && column < PH_MAP_PROVIDER_COLUMN_COUNT); if (ph_config->map_providers == NULL) (void) ph_config_get_map_providers(); g_return_if_fail(ph_config->map_providers != NULL); gtk_tree_model_get(GTK_TREE_MODEL(ph_config->map_providers), iter, PH_MAP_PROVIDER_COLUMN_NAME, &name, -1); group = ph_config_get_map_provider_group(name); key = ph_config_get_map_provider_key(column); if (value == NULL && row < G_N_ELEMENTS(ph_config_default_map_providers)) { /* restore default value for built-in provider */ ph_map_provider_to_list_single(&ph_config_default_map_providers[row], ph_config->map_providers, iter, column); (void) g_key_file_remove_key(ph_config->key_file, group, key, NULL); } else { GValue target = { 0 }; GType target_type; target_type = gtk_tree_model_get_column_type( GTK_TREE_MODEL(ph_config->map_providers), column); g_value_init(&target, target_type); if (value == NULL) { /* restore default value for another provider */ switch (column) { case PH_MAP_PROVIDER_COLUMN_URL: g_value_set_static_string(&target, ""); break; case PH_MAP_PROVIDER_COLUMN_TILE_SIZE: g_value_set_uint(&target, 256); break; case PH_MAP_PROVIDER_COLUMN_ZOOM_MIN: g_value_set_uint(&target, 0); break; case PH_MAP_PROVIDER_COLUMN_ZOOM_MAX: g_value_set_uint(&target, 18); break; case PH_MAP_PROVIDER_COLUMN_ZOOM_DETAIL: g_value_set_uint(&target, 14); break; default: g_warn_if_reached(); } } else /* actually set to a new value */ g_value_transform(value, &target); gtk_list_store_set_value(ph_config->map_providers, iter, column, &target); ph_config_set_value(group, key, &target); g_value_unset(&target); } g_free(name); g_free(group); }
int _pygtk_tree_model_set_row(GtkTreeModel *model, GtkTreeIter *iter, PyObject *items) { gint n_columns, i; GtkTreeModel *child; GtkTreeIter citer; if (!GTK_IS_LIST_STORE(model) && !GTK_IS_TREE_STORE(model) && !GTK_IS_TREE_MODEL_SORT(model) && !GTK_IS_TREE_MODEL_FILTER(model)) { PyErr_SetString(PyExc_TypeError, "cannot set cells in this tree model"); return -1; } if (GTK_IS_TREE_MODEL_SORT(model)) { child = gtk_tree_model_sort_get_model(GTK_TREE_MODEL_SORT(model)); gtk_tree_model_sort_convert_iter_to_child_iter( GTK_TREE_MODEL_SORT(model), &citer, iter); return _pygtk_tree_model_set_row(child, &citer, items); } if (GTK_IS_TREE_MODEL_FILTER(model)) { child = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model)); gtk_tree_model_filter_convert_iter_to_child_iter( GTK_TREE_MODEL_FILTER(model), &citer, iter); return _pygtk_tree_model_set_row(child, &citer, items); } if (!PySequence_Check(items)) { PyErr_SetString(PyExc_TypeError, "expecting a sequence"); return -1; } n_columns = gtk_tree_model_get_n_columns(model); if (PySequence_Length(items) != n_columns) { PyErr_SetString(PyExc_ValueError, "row sequence has wrong length"); return -1; } for (i = 0; i < n_columns; i++) { GValue value = { 0, }; PyObject *item; item = PySequence_GetItem(items, i); if (!item) return -1; g_value_init(&value, gtk_tree_model_get_column_type(model, i)); if (pyg_value_from_pyobject(&value, item)) { Py_DECREF(item); PyErr_SetString(PyExc_TypeError, "value is of wrong type for this column"); return -1; } if (GTK_IS_LIST_STORE(model)) gtk_list_store_set_value(GTK_LIST_STORE(model), iter, i, &value); else if (GTK_IS_TREE_STORE(model)) gtk_tree_store_set_value(GTK_TREE_STORE(model), iter, i, &value); g_value_unset(&value); Py_DECREF(item); } return 0; }
void add_row(GtkToolButton* toolbutton, gpointer user_data) { /* Context data */ GtkListStore* restrictions = GTK_LIST_STORE(gtk_tree_view_get_model(restrictions_view)); int vars = gtk_spin_button_get_value_as_int(variables); GValue initi = G_VALUE_INIT; g_value_init(&initi, G_TYPE_INT); GValue inits = G_VALUE_INIT; g_value_init(&inits, G_TYPE_STRING); GtkTreeIter iter; gtk_list_store_append(restrictions, &iter); int size = vars + 2; for(int i = 0; i < vars; i++) { g_value_set_int(&initi, 1); gtk_list_store_set_value(restrictions, &iter, i, &initi); char* text = var_name(1, i, false); g_value_set_string(&inits, text); gtk_list_store_set_value(restrictions, &iter, size + i, &inits); free(text); g_value_set_string(&inits, PLUS); gtk_list_store_set_value(restrictions, &iter, 2 * size + i, &inits); } /* Set type */ g_value_set_int(&initi, GE); gtk_list_store_set_value(restrictions, &iter, size - 2, &initi); g_value_set_string(&inits, GES); gtk_list_store_set_value(restrictions, &iter, 2 * size - 2, &inits); g_value_set_string(&inits, ""); gtk_list_store_set_value(restrictions, &iter, 3 * size - 2, &inits); /* Set equality */ g_value_set_int(&initi, 0); gtk_list_store_set_value(restrictions, &iter, size - 1, &initi); char* text = num_name(0, false); g_value_set_string(&inits, text); gtk_list_store_set_value(restrictions, &iter, 2 * size - 1, &inits); free(text); g_value_set_string(&inits, ""); gtk_list_store_set_value(restrictions, &iter, 3 * size - 1, &inits); /* Select new row */ GtkTreePath* model_path = gtk_tree_model_get_path( GTK_TREE_MODEL(restrictions), &iter); gtk_tree_view_set_cursor(restrictions_view, model_path, gtk_tree_view_get_column(restrictions_view, 0), true); gtk_tree_path_free(model_path); return; }
static GtkListStore * eprop_model_data_generate_store (GladeEditorProperty * eprop) { GtkListStore *store = NULL; GladeModelData *iter_data; GNode *data_tree = NULL, *iter_node, *row_node; GArray *gtypes = g_array_new (FALSE, TRUE, sizeof (GType)); GtkTreeIter iter; gint column_num, row_num; GType index_type = G_TYPE_INT, string_type = G_TYPE_STRING, pointer_type = G_TYPE_POINTER; GladeProperty *property = glade_editor_property_get_property (eprop); glade_property_get (property, &data_tree); if (!data_tree || !data_tree->children || !data_tree->children->children) return NULL; /* Generate store with tailored column types */ g_array_append_val (gtypes, index_type); for (iter_node = data_tree->children->children; iter_node; iter_node = iter_node->next) { iter_data = iter_node->data; if (G_VALUE_TYPE (&iter_data->value) == 0) g_array_append_val (gtypes, pointer_type); else if (G_VALUE_TYPE (&iter_data->value) == GDK_TYPE_PIXBUF) g_array_append_val (gtypes, string_type); else g_array_append_val (gtypes, G_VALUE_TYPE (&iter_data->value)); } store = gtk_list_store_newv (gtypes->len, (GType *) gtypes->data); g_array_free (gtypes, TRUE); /* Now populate the store with data */ for (row_num = 0, row_node = data_tree->children; row_node; row_num++, row_node = row_node->next) { gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter, COLUMN_ROW, row_num, -1); for (column_num = NUM_COLUMNS, iter_node = row_node->children; iter_node; column_num++, iter_node = iter_node->next) { iter_data = iter_node->data; if (G_VALUE_TYPE (&iter_data->value) == 0) continue; /* Special case, show the filename in the cellrenderertext */ if (G_VALUE_TYPE (&iter_data->value) == GDK_TYPE_PIXBUF) { GObject *object = g_value_get_object (&iter_data->value); gchar *filename = NULL; if (object) filename = g_object_get_data (object, "GladeFileName"); gtk_list_store_set (store, &iter, column_num, filename, -1); } else gtk_list_store_set_value (store, &iter, column_num, &iter_data->value); } } return store; }
void writeback(GtkTreeModel* model, gchar* path, int vars, bool is_var, gchar* new_text, gpointer user_data) { int column = GPOINTER_TO_INT(user_data); DEBUG("%s at (%i, %i)\n", new_text, atoi(path), column); /* Get the coefficient */ int coeff = 0; if(!is_empty_string(new_text)) { char* end; coeff = (int) strtol(new_text, &end, 10); if(*end != '\0') { /* Conversion wasn't successful */ DEBUG("Unable to parse %s\n", new_text); return; } } /* Get reference to model */ GtkTreeIter iter; gtk_tree_model_get_iter_from_string(model, &iter, path); /* Set the model */ GValue gvali = G_VALUE_INIT; g_value_init(&gvali, G_TYPE_INT); GValue gvals = G_VALUE_INIT; g_value_init(&gvals, G_TYPE_STRING); /* Coeff */ g_value_set_int(&gvali, coeff); gtk_list_store_set_value( GTK_LIST_STORE(model), &iter, column, &gvali); g_value_unset(&gvali); /* Text */ g_value_set_string(&gvals, ""); if(!is_var) { char* text = num_name(coeff, true); g_value_set_string(&gvals, text); free(text); } else if(coeff != 0) { char* text = var_name(coeff, column, column == 0); g_value_set_string(&gvals, text); free(text); } gtk_list_store_set_value( GTK_LIST_STORE(model), &iter, vars + column, &gvals); /* Sign */ g_value_set_string(&gvals, ""); if(is_var) { if((column != 0) && (coeff != 0)) { if(coeff > 0) { g_value_set_string(&gvals, PLUS); } else { g_value_set_string(&gvals, MINUS); } } } gtk_list_store_set_value( GTK_LIST_STORE(model), &iter, 2 * vars + column, &gvals); g_value_unset(&gvals); }
int static __list_store_set(ClipMachine *cm, GtkTreeIter *iter, gint startDataParam) { C_object *cslist = _fetch_co_arg(cm); ClipArrVar *utypes; gint i; CHECKCOBJ(cslist, GTK_IS_LIST_STORE(cslist->object)); utypes = (ClipArrVar *)_clip_vptr(_clip_mget(cm, &cslist->obj, HASH_UTYPES)); for (i=startDataParam; i<=_clip_parinfo(cm, 0); i+=2) { gint column = _clip_parni(cm, i); ClipVar *val; GValue value; C_object *cobj; gchar *str; int j, n; double d; CHECKARG(i, NUMERIC_t); if (column == -1) break; column --; val = _clip_par(cm, i+1); memset(&value, 0, sizeof(value)); switch ((int)utypes->items[column].n.d) { case TREE_TYPE_NUMERIC: g_value_init(&value, G_TYPE_INT); if (val->t.type == NUMERIC_t) g_value_set_int(&value, (int)val->n.d); else { n = _clip_strtod(val->s.str.buf, &j); g_value_set_int(&value, n); } break; case TREE_TYPE_NUMERIC_FLOAT: g_value_init(&value, G_TYPE_FLOAT); if (val->t.type == NUMERIC_t) g_value_set_float(&value, val->n.d); else { d = _clip_strtod(val->s.str.buf, &j); g_value_set_float(&value, d); } break; case TREE_TYPE_STRING: str = val->s.str.buf; LOCALE_TO_UTF(str); g_value_init(&value, G_TYPE_STRING); g_value_set_string(&value, str); FREE_TEXT(str); break; case TREE_TYPE_LOGICAL: g_value_init(&value, G_TYPE_BOOLEAN); g_value_set_boolean(&value, val->l.val); break; case TREE_TYPE_PIXBUF: g_value_init(&value, GDK_TYPE_PIXBUF); cobj = _fetch_cobject(cm, val); g_value_set_object(&value, cobj->object); break; case TREE_TYPE_DATE: g_value_init(&value, G_TYPE_STRING); if (val->t.type == DATE_t) str = _clip_date_to_str(val->lv.l, cm->date_format); else str = _clip_date_to_str(_clip_str_to_date(val->s.str.buf, cm->date_format, cm->epoch), cm->date_format); g_value_set_string(&value, str); break; } gtk_list_store_set_value(GTK_LIST_STORE(cslist->object), iter, column, &value); } return 0; err: return 1; }
/**************************************************************** Create spy's tech stealing dialog *****************************************************************/ static void create_advances_list(struct player *pplayer, struct player *pvictim) { GtkWidget *sw, *label, *vbox, *view; GtkListStore *store; GtkCellRenderer *rend; GtkTreeViewColumn *col; spy_tech_shell = gtk_dialog_new_with_buttons(_("Steal Technology"), NULL, 0, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, _("_Steal"), GTK_RESPONSE_ACCEPT, NULL); setup_dialog(spy_tech_shell, toplevel); gtk_window_set_position(GTK_WINDOW(spy_tech_shell), GTK_WIN_POS_MOUSE); gtk_dialog_set_default_response(GTK_DIALOG(spy_tech_shell), GTK_RESPONSE_ACCEPT); label = gtk_frame_new(_("Select Advance to Steal")); gtk_container_add(GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(spy_tech_shell))), label); vbox = gtk_vbox_new(FALSE, 6); gtk_container_add(GTK_CONTAINER(label), vbox); store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT); view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store)); g_object_unref(store); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(view), FALSE); rend = gtk_cell_renderer_text_new(); col = gtk_tree_view_column_new_with_attributes(NULL, rend, "text", 0, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(view), col); label = g_object_new(GTK_TYPE_LABEL, "use-underline", TRUE, "mnemonic-widget", view, "label", _("_Advances:"), "xalign", 0.0, "yalign", 0.5, NULL); gtk_container_add(GTK_CONTAINER(vbox), label); sw = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw), GTK_SHADOW_ETCHED_IN); gtk_container_add(GTK_CONTAINER(sw), view); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); gtk_widget_set_size_request(sw, -1, 200); gtk_container_add(GTK_CONTAINER(vbox), sw); /* Now populate the list */ if (pvictim) { /* you don't want to know what lag can do -- Syela */ GtkTreeIter it; GValue value = { 0, }; advance_index_iterate(A_FIRST, i) { if(player_invention_state(pvictim, i)==TECH_KNOWN && (player_invention_state(pplayer, i)==TECH_UNKNOWN || player_invention_state(pplayer, i)==TECH_PREREQS_KNOWN)) { gtk_list_store_append(store, &it); g_value_init(&value, G_TYPE_STRING); g_value_set_static_string(&value, advance_name_for_player(client.conn.playing, i)); gtk_list_store_set_value(store, &it, 0, &value); g_value_unset(&value); gtk_list_store_set(store, &it, 1, i, -1); } } advance_index_iterate_end; gtk_list_store_append(store, &it); g_value_init(&value, G_TYPE_STRING); { struct astring str = ASTRING_INIT; /* TRANS: %s is a unit name, e.g., Spy */ astr_set(&str, _("At %s's Discretion"), unit_name_translation(game_unit_by_number(diplomat_id))); g_value_set_string(&value, astr_str(&str)); astr_free(&str); } gtk_list_store_set_value(store, &it, 0, &value); g_value_unset(&value); gtk_list_store_set(store, &it, 1, A_UNSET, -1); } gtk_dialog_set_response_sensitive(GTK_DIALOG(spy_tech_shell), GTK_RESPONSE_ACCEPT, FALSE); gtk_widget_show_all(gtk_dialog_get_content_area(GTK_DIALOG(spy_tech_shell))); g_signal_connect(gtk_tree_view_get_selection(GTK_TREE_VIEW(view)), "changed", G_CALLBACK(spy_advances_callback), NULL); g_signal_connect(spy_tech_shell, "response", G_CALLBACK(spy_advances_response), NULL); steal_advance = 0; gtk_tree_view_focus(GTK_TREE_VIEW(view)); }
/****************************************************************************** * gtk_ListStoreSetValue(list,path_string, ncol, val) ******************************************************************************/ int clip_GTK_LISTSTORESETVALUE(ClipMachine * cm) { C_object *cslist = _fetch_co_arg(cm); gchar *path = _clip_parc(cm, 2); gint column = _clip_parni(cm, 3); ClipVar *val = _clip_par(cm, 4);; GtkTreeIter iter; ClipArrVar *utypes; GValue value; C_object *cobj; gchar *str; int j, n; double d; CHECKARG2(1, MAP_t, NUMERIC_t);CHECKCOBJ(cslist, GTK_IS_LIST_STORE(cslist->object)); CHECKARG(2, CHARACTER_t); CHECKARG(3, NUMERIC_t); gtk_tree_model_get_iter(GTK_TREE_MODEL(GTK_LIST_STORE(cslist->object)), &iter, gtk_tree_path_new_from_string(path)); utypes = (ClipArrVar *)_clip_vptr(_clip_mget(cm, &cslist->obj, HASH_UTYPES)); column --; memset(&value, 0, sizeof(value)); switch ((int)utypes->items[column].n.d) { case TREE_TYPE_NUMERIC: g_value_init(&value, G_TYPE_INT); if (val->t.type == NUMERIC_t) g_value_set_int(&value, (int)val->n.d); else { n = _clip_strtod(val->s.str.buf, &j); g_value_set_int(&value, n); } break; case TREE_TYPE_NUMERIC_FLOAT: g_value_init(&value, G_TYPE_FLOAT); if (val->t.type == NUMERIC_t) g_value_set_float(&value, val->n.d); else { d = _clip_strtod(val->s.str.buf, &j); g_value_set_float(&value, d); } break; case TREE_TYPE_STRING: str = val->s.str.buf; LOCALE_TO_UTF(str); g_value_init(&value, G_TYPE_STRING); g_value_set_string(&value, str); FREE_TEXT(str); break; case TREE_TYPE_LOGICAL: g_value_init(&value, G_TYPE_BOOLEAN); g_value_set_boolean(&value, val->l.val); break; case TREE_TYPE_PIXBUF: g_value_init(&value, GDK_TYPE_PIXBUF); cobj = _fetch_cobject(cm, val); g_value_set_object(&value, cobj->object); break; case TREE_TYPE_DATE: g_value_init(&value, G_TYPE_STRING); if (val->t.type == DATE_t) str = _clip_date_to_str(val->lv.l, cm->date_format); else str = _clip_date_to_str(_clip_str_to_date(val->s.str.buf, cm->date_format, cm->epoch), cm->date_format); g_value_set_string(&value, str); break; } gtk_list_store_set_value(GTK_LIST_STORE(cslist->object), &iter, column, &value); return 0; err: return 1; }
bool change_function(int vars) { /* Clear model */ clear_liststore(function_view); /* Create the dynamic types array */ GType* types = (GType*) malloc(3 * vars * sizeof(GType)); if(types == NULL) { return false; } /* Set type in the dynamic types array */ for(int i = 0; i < vars; i++) { types[i] = G_TYPE_INT; /* Coeffs */ types[vars + i] = G_TYPE_STRING; /* Text */ types[2 * vars + i] = G_TYPE_STRING; /* Signs */ } /* Create and fill the new model */ GtkListStore* function = gtk_list_store_newv(3 * vars, types); GtkTreeIter iter; GValue initi = G_VALUE_INIT; g_value_init(&initi, G_TYPE_INT); GValue inits = G_VALUE_INIT; g_value_init(&inits, G_TYPE_STRING); gtk_list_store_append(function, &iter); for(int i = 0; i < vars; i++) { g_value_set_int(&initi, 1); gtk_list_store_set_value(function, &iter, i, &initi); char* text = var_name(1, i, false); g_value_set_string(&inits, text); gtk_list_store_set_value(function, &iter, vars + i, &inits); free(text); g_value_set_string(&inits, PLUS); gtk_list_store_set_value(function, &iter, 2 * vars + i, &inits); } /* Clear the previous columns */ for(int i = gtk_tree_view_get_n_columns(function_view) - 1; i >= 0; i--) { gtk_tree_view_remove_column( function_view, gtk_tree_view_get_column(function_view, i) ); } /* Create the new columns */ for(int i = 0; i < vars; i++) { /* Create sign column */ if(i > 0) { GtkCellRenderer* sign = gtk_cell_renderer_text_new(); GtkTreeViewColumn* sign_c = gtk_tree_view_column_new_with_attributes( "", sign, /* Title, renderer */ "markup", 2 * vars + i, NULL); gtk_tree_view_append_column(function_view, sign_c); } /* Create text column */ /* Create and configure cell */ GtkCellRenderer* cell = gtk_cell_renderer_spin_new(); gtk_cell_renderer_set_alignment(cell, 1.0, 0.5); g_object_set(cell, "editable", true, NULL); /* Configure callbacks */ g_signal_connect(G_OBJECT(cell), "editing-started", G_CALLBACK(function_edit_started_cb), GINT_TO_POINTER(i)); function_edit_started_cb(cell, NULL, NULL, GINT_TO_POINTER(i)); g_signal_connect(G_OBJECT(cell), "edited", G_CALLBACK(function_edited_cb), GINT_TO_POINTER(i)); /* Configure column */ GtkTreeViewColumn* column = gtk_tree_view_column_new_with_attributes( "", cell, /* Title, renderer */ "markup", vars + i, NULL); gtk_tree_view_column_set_min_width(column, 100); gtk_tree_view_append_column(function_view, column); } gtk_tree_view_append_column(function_view, gtk_tree_view_column_new()); /* Set the new model */ gtk_tree_view_set_model(function_view, GTK_TREE_MODEL(function)); /* Free resources */ g_object_unref(G_OBJECT(function)); free(types); return true; }