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