void list_init(void)
{
GType types[COL_N];
for (int i = 0; i < HASH_FUNCS_N; i++) {
gtk_tree_view_insert_column_with_attributes(gui.treeview, -1,
hash.funcs[i].name, gtk_cell_renderer_text_new(),
"text", COL_HASH + i, NULL);
}
for (int i = 0; i < COL_N; i++) {
types[i] = G_TYPE_STRING;
GtkTreeViewColumn *col = gtk_tree_view_get_column(gui.treeview, i);
gtk_tree_view_column_set_resizable(col, true);
}
gui.liststore = gtk_list_store_newv(COL_N, types);
gui.treemodel = GTK_TREE_MODEL(gui.liststore);
gtk_tree_view_set_model(gui.treeview, gui.treemodel);
gtk_tree_selection_set_mode(gui.treeselection, GTK_SELECTION_MULTIPLE);
const GtkTargetEntry targets[] = {
{ (char *)"text/uri-list", 0, 0 }
};
gtk_drag_dest_set(GTK_WIDGET(gui.treeview), GTK_DEST_DEFAULT_ALL, targets,
G_N_ELEMENTS(targets), GDK_ACTION_COPY);
}
static GtkTreeModel *
create_searches_model(void)
{
static GType columns[c_sl_num];
GtkListStore *store;
guint i;
STATIC_ASSERT(c_sl_num == G_N_ELEMENTS(columns));
#define SET(c, x) case (c): columns[i] = (x); break
for (i = 0; i < G_N_ELEMENTS(columns); i++) {
switch (i) {
SET(c_sl_name, G_TYPE_STRING);
SET(c_sl_hit, G_TYPE_INT);
SET(c_sl_new, G_TYPE_INT);
SET(c_sl_fg, GDK_TYPE_COLOR);
SET(c_sl_bg, GDK_TYPE_COLOR);
SET(c_sl_sch, G_TYPE_POINTER);
default:
g_assert_not_reached();
}
}
#undef SET
store = gtk_list_store_newv(G_N_ELEMENTS(columns), columns);
return GTK_TREE_MODEL(store);
}
static GtkTreeModel *create_model(struct dlg_data *dlg_data)
{
GType *types;
GtkListStore *store;
GList *l;
int i;
struct db_field *f;
types = g_malloc(sizeof(GType) * dlg_data->c->active_fields);
for (l = g_list_first(dlg_data->c->fields), i = 0; l; l = l->next) {
f = (struct db_field *)l->data;
if (f->status == FIELD_ACTIVE) {
types[i] = G_TYPE_STRING;
i++;
}
}
store = gtk_list_store_newv(dlg_data->c->active_fields, types);
db_load_and_set_collection_data(dlg_data->c, store, dlg_data);
g_free(types);
return GTK_TREE_MODEL(store);
}
/* [ gui_create_list_view ]
* Convenience function for constructing a GtkTreeView from a definition
*/
GtkWidget *
gui_create_list_view (View_def *def, gint width, gint height)
{
GtkListStore *store;
GtkWidget *view;
GType *types = g_malloc0 (def->num_columns * sizeof (GType));
gint i;
/* Determine the column types */
for (i = 0; i < def->num_columns; i++) {
types[i] = def->columns[i].type;
}
store = gtk_list_store_newv (def->num_columns, types);
g_free (types);
view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
/* Create the columns from the definition */
for (i = 0; i < def->num_columns; i++) {
GtkTreeViewColumn *column;
if (def->columns[i].visible) {
column = new_treeview_text_column (i, def->columns[i].label);
gtk_tree_view_append_column (GTK_TREE_VIEW (view), column);
}
}
if (width != -1 || height != -1)
gtk_widget_set_size_request (view, width, height);
g_object_unref (G_OBJECT (store));
return view;
}
void cgraphics_listview_widget_create_columns( widget_t *widget )
{
listview_widget_t *lvw = (listview_widget_t *)widget;
GtkCellRenderer *renderer;
GType *types;
GtkTreeModel *model;
int a;
types = (GType *)malloc( sizeof(GType) * (lvw->widget.columns+1) );
for ( a = 0; a < lvw->widget.columns; a++ )
{
if ( lvw->widget.coltypes[a] == CLIST_TYPE_STRING )
types[a] = G_TYPE_STRING;
else if ( lvw->widget.coltypes[a] == CLIST_TYPE_UINT )
types[a] = G_TYPE_UINT;
else if ( lvw->widget.coltypes[a] == CLIST_TYPE_DOUBLE )
types[a] = G_TYPE_DOUBLE;
else
{
printf( "Bad error: invalid type found (%d)\n", lvw->widget.coltypes[a] );
exit( 0 );
}
}
types[a] = G_TYPE_UINT;
model = (GtkTreeModel *)gtk_list_store_newv( lvw->widget.columns + 1, types );
free( types );
gtk_tree_view_set_model( GTK_TREE_VIEW(widget->container), model );
g_object_unref( model );
for ( a = 0; a < lvw->widget.columns; a++ )
{
if ( lvw->widget.coltypes[a] == CLIST_TYPE_STRING )
{
renderer = gtk_cell_renderer_text_new( );
gtk_tree_view_insert_column_with_attributes( GTK_TREE_VIEW(widget->container),
-1, lvw->titles[a], renderer, "text", a, NULL );
}
else if ( lvw->widget.coltypes[a] == CLIST_TYPE_UINT )
{
cgcelldata *cgcd = (cgcelldata *)malloc( sizeof(cgcelldata) ); /* FIXME: free me somewhere. */
renderer = gtk_cell_renderer_toggle_new( );
gtk_tree_view_insert_column_with_attributes( GTK_TREE_VIEW(widget->container),
-1, lvw->titles[a], renderer, "active", a, NULL );
cgcd->widget = widget;
cgcd->column = a;
g_signal_connect( G_OBJECT(renderer), "toggled", G_CALLBACK(cgraphics_listview_toggled_handler), cgcd );
}
else if ( lvw->widget.coltypes[a] == CLIST_TYPE_DOUBLE )
{
renderer = gtk_cell_renderer_progress_new( );
gtk_tree_view_insert_column_with_attributes( GTK_TREE_VIEW(widget->container),
-1, lvw->titles[a], renderer, "value", a, NULL );
}
}
}
GtkListStore *
make_results_blank() {
xmlTreeModel *dummy = xml_tree_model_new();
GtkListStore *blank = gtk_list_store_newv (dummy->n_columns,dummy->column_types);
//g_free(dummy);
return blank;
}
static void
setup_data (AppData *data)
{
int i;
GtkCellRenderer *cell;
char clabel[] = "0";
GType types[17];
types[0] = G_TYPE_UINT;
for (i = 1; i < 17; i++)
types[i] = G_TYPE_UCHAR;
data->ls_data = gtk_list_store_newv (17, types);
cell = gtk_cell_renderer_text_new ();
g_object_set (cell, "family", "monospace", NULL);
gtk_tree_view_insert_column_with_data_func (data->tw_data, -1, "Address",
cell, display_hex_4,
GINT_TO_POINTER (0), NULL);
for (i = 1; i < 17; i++)
{
clabel[0] = i <= 10 ? 47 + i : 54 + i;
cell = gtk_cell_renderer_text_new ();
g_object_set (cell, "family", "monospace", NULL);
gtk_tree_view_insert_column_with_data_func (data->tw_data, -1, clabel,
cell, display_hex_1,
GINT_TO_POINTER (i), NULL);
}
gtk_tree_view_set_model (data->tw_data, GTK_TREE_MODEL (data->ls_data));
g_object_unref (data->ls_data);
}
static void
gui_gtk_datawindow_add(struct datawindow_priv *win, struct param_list *param, int count)
{
int i;
GtkCellRenderer *cell;
GtkTreeIter iter;
GType types[count];
gchar *utf8;
if (! win->treeview) {
win->treeview=gtk_tree_view_new();
gtk_tree_view_set_model (GTK_TREE_VIEW (win->treeview), NULL);
gtk_container_add(GTK_CONTAINER(win->scrolled_window), win->treeview);
gtk_widget_show_all(GTK_WIDGET(win->window));
gtk_widget_grab_focus(GTK_WIDGET(win->treeview));
/* add column names to treeview */
for(i=0;i<count;i++) {
if (param[i].name) {
cell=gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (win->treeview),-1,param[i].name,
cell,"text",i, NULL);
}
}
#if 0
g_signal_connect(G_OBJECT(win->treeview), "click-column", G_CALLBACK(click_column), NULL);
#endif
g_signal_connect(G_OBJECT(win->treeview), "row-activated", G_CALLBACK(select_row), win);
}
/* find data storage and create a new one if none is there */
if (gtk_tree_view_get_model(GTK_TREE_VIEW (win->treeview)) == NULL) {
for(i=0;i<count;i++) {
if (param[i].name && !strcmp(param[i].name, "Distance"))
types[i]=G_TYPE_INT;
else
types[i]=G_TYPE_STRING;
}
win->liststore=gtk_list_store_newv(count,types);
if (! strcmp(param[0].name, "Distance")) {
win->sortmodel=gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(win->liststore));
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (win->sortmodel), 0, GTK_SORT_ASCENDING);
gtk_tree_view_set_model (GTK_TREE_VIEW (win->treeview), GTK_TREE_MODEL(win->sortmodel));
} else
gtk_tree_view_set_model (GTK_TREE_VIEW (win->treeview), GTK_TREE_MODEL(win->liststore));
}
gtk_list_store_append(win->liststore,&iter);
/* add data to data storage */
for(i=0;i<count;i++) {
if (param[i].name && !strcmp(param[i].name, "Distance")) {
gtk_list_store_set(win->liststore,&iter,i,atoi(param[i].value),-1);
} else {
utf8=g_locale_to_utf8(param[i].value,-1,NULL,NULL,NULL);
gtk_list_store_set(win->liststore,&iter,i,utf8,-1);
}
}
}
/* TREE_TYPE_PIXBUF */
int
/******************************************************************************
* gtk_ListStoreNew(map, ncolumns, type1, ...)
******************************************************************************/
clip_GTK_LISTSTORENEW(ClipMachine * cm)
{
ClipVar * cv = _clip_spar(cm, 1);
gint ncolumns = _clip_parni(cm, 2);
ClipArrVar *cvcol = (ClipArrVar *)_clip_vptr(_clip_spar(cm, 3));
ClipVar *utypes;
GType types[ncolumns];
int i;
long d;
GtkListStore *list;
C_object *clist;
CHECKOPT(1,MAP_t);
CHECKARG(2,NUMERIC_t);
//CHECKARG2(3, NUMERIC_t, ARRAY_t);
memset(types, 0, sizeof(types));
utypes = NEW(ClipVar);
if ( _clip_parinfo(cm,3)==ARRAY_t && cvcol->count != ncolumns ) return 1;
if ( _clip_parinfo(cm,3) != UNDEF_t ) // defined column types as parameters or in array
__list_store_set_types(cm, ncolumns, types, utypes);
else { // if third parameter is empty - use column with G_TYPE_STRING type
ClipVar type;
d = ncolumns;
memset(&type, 0, sizeof(type));
type.t.type = NUMERIC_t;
type.n.d = 0;
_clip_array(cm, utypes, 1, &d);
for ( i=0, d=0; i<ncolumns; i++, d++ )
{
types[i] = G_TYPE_STRING;
_clip_aset(cm, utypes, &type, 1, &d);
}
_clip_destroy(cm, &type);
}
list = gtk_list_store_newv(ncolumns, types);
if (list)
{
clist = _list_get_cobject(cm,list);
if (!clist) clist = _register_object(cm,list,GTK_TYPE_LIST_STORE,cv,__list_store_destroy);
if (clist)
{
_clip_madd(cm, &clist->obj, HASH_UTYPES, utypes);
_clip_mclone(cm,RETPTR(cm),&clist->obj);
}
}
free(utypes);
return 0;
err:
return 1;
}
static GtkWidget *
create_tree_view(int n, n_list_store *list, int tree)
{
GType *tarray;
GtkTreeModel *lstore;
GtkWidget *tview;
GtkTreeViewColumn *col;
GtkTreeSelection *sel;
int i;
if (n < 1 || list == NULL)
return NULL;
tarray = g_malloc(sizeof(*tarray) * n);
if (tarray == NULL)
return NULL;
for (i = 0; i < n; i++) {
if (list[i].type == G_TYPE_DOUBLE || list[i].type == G_TYPE_ENUM || list[i].type == G_TYPE_PARAM) {
tarray[i] = G_TYPE_STRING;
} else {
tarray[i] = list[i].type;
}
list[i].edited_id = 0;
}
if (tree) {
lstore = GTK_TREE_MODEL(gtk_tree_store_newv(n, tarray));
} else {
lstore = GTK_TREE_MODEL(gtk_list_store_newv(n, tarray));
}
g_free(tarray);
tview = gtk_tree_view_new_with_model(lstore);
#if ! GTK_CHECK_VERSION(3, 14, 0)
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tview), TRUE);
#endif
gtk_tree_view_set_rubber_banding(GTK_TREE_VIEW(tview), TRUE);
gtk_tree_view_set_grid_lines(GTK_TREE_VIEW(tview), GTK_TREE_VIEW_GRID_LINES_VERTICAL);
sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(tview));
gtk_tree_selection_set_mode(sel, GTK_SELECTION_SINGLE);
for (i = 0; i < n; i++) {
if (list[i].visible) {
col = create_column(list, i);
gtk_tree_view_column_set_visible(col, list[i].visible);
gtk_tree_view_append_column(GTK_TREE_VIEW(tview), col);
}
}
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tview), n > 1);
return tview;
}
static GtkListStore *
create_nodes_model(void)
{
static GType columns[1];
GtkListStore *store;
columns[0] = G_TYPE_POINTER;
store = gtk_list_store_newv(G_N_ELEMENTS(columns), columns);
return store;
}
GtkTreeView *
create_stat_table(GtkWidget *scrolled_window, GtkWidget *vbox, int columns, const stat_column *headers)
{
GtkTreeView *table;
GtkListStore *store;
GtkWidget *tree;
GtkTreeViewColumn *column;
GtkTreeSelection *sel;
GtkCellRenderer *renderer;
GType *types;
int i;
if (columns <= 0)
return NULL;
types = g_malloc(columns *sizeof(GType));
for (i = 0; i < columns; i++)
types[i] = headers[i].type;
store = gtk_list_store_newv (columns, types);
g_free(types);
/* create table */
tree = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
table = GTK_TREE_VIEW(tree);
g_object_unref (G_OBJECT (store));
for (i = 0; i < columns; i++) {
renderer = gtk_cell_renderer_text_new ();
if (headers[i].align == RIGHT) {
/* right align */
g_object_set(G_OBJECT(renderer), "xalign", 1.0, NULL);
}
g_object_set(renderer, "ypad", 0, NULL);
column = gtk_tree_view_column_new_with_attributes (headers[i].title, renderer, "text",
i, NULL);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_append_column (table, column);
}
gtk_container_add(GTK_CONTAINER(scrolled_window), GTK_WIDGET (table));
gtk_box_pack_start(GTK_BOX(vbox), scrolled_window, TRUE, TRUE, 0);
/* configure TreeView */
gtk_tree_view_set_rules_hint(table, FALSE);
gtk_tree_view_set_headers_clickable(table, FALSE);
sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(table));
gtk_tree_selection_set_mode(sel, GTK_SELECTION_SINGLE);
gtk_widget_show(scrolled_window);
return table;
}
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 GtkTreeModel *
create_tree_model(const xmlNode *table)
{
const xmlNode *p = find_by_path(table, "ContainedItems");
int columns_count = table_calc_columns_count(p);
GType *_types = g_malloc_n(columns_count, sizeof(GType));
int i = columns_count;
while (i--)
_types[i] = G_TYPE_STRING;
GtkListStore *model = gtk_list_store_newv(columns_count, _types);
g_free(_types);
return GTK_TREE_MODEL(model);
}
void
data_window_add(struct data_window *win, struct param_list *param, int count)
{
int i;
GtkCellRenderer *cell;
GtkTreeIter iter;
GtkListStore *liststore;
GType types[count];
gchar *utf8;
if (! win->treeview) {
win->treeview=gtk_tree_view_new();
gtk_tree_view_set_model (GTK_TREE_VIEW (win->treeview), NULL);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(win->scrolled_window),win->treeview);
gtk_widget_show_all(GTK_WIDGET(win->window));
/* add column names to treeview */
for(i=0;i<count;i++) {
cell=gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (win->treeview),-1,param[i].name,
cell,"text",i, NULL);
}
}
/* find data storage and create a new one if none is there */
if (gtk_tree_view_get_model(GTK_TREE_VIEW (win->treeview)) == NULL) {
for(i=0;i<count;i++) types[i]=G_TYPE_STRING;
liststore=gtk_list_store_newv(count,types);
gtk_tree_view_set_model (GTK_TREE_VIEW (win->treeview), GTK_TREE_MODEL(liststore));
}
else
liststore=GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW (win->treeview)));
gtk_list_store_append(liststore,&iter);
/* add data to data storage */
for(i=0;i<count;i++) {
utf8=g_locale_to_utf8(param[i].value,-1,NULL,NULL,NULL);
gtk_list_store_set(liststore,&iter,i,utf8,-1);
}
#if 0
g_signal_connect(G_OBJECT(win->clist), "click-column", G_CALLBACK(click_column), NULL);
g_signal_connect(G_OBJECT(win->clist), "select-row", G_CALLBACK(select_row), win);
#endif
}
/**
* Called from
* org.gnome.gtk.GtkTreeModeOverride.gtk_list_store_new(String[])
* called from
* org.gnome.gtk.GtkTreeModeOverride.createListStore(Class[])
* called from
* org.gnome.gtk.ListStore.<init>(???)
*
* You should already have established Java side that ther array is bigger
* that 0 elements before calling this.
*/
JNIEXPORT jlong JNICALL
Java_org_gnome_gtk_GtkTreeModelOverride_gtk_1list_1store_1new
(
JNIEnv* env,
jclass cls,
jobjectArray _columns
)
{
GtkListStore* result;
gint num_columns;
GType* columns; // GType[]
gint i;
jstring _name;
const gchar* name;
num_columns = (gint) (*env)->GetArrayLength(env, _columns);
columns = g_newa(GType, num_columns);
for (i = 0; i < num_columns; i++) {
_name = (jstring) (*env)->GetObjectArrayElement(env, _columns, i);
name = bindings_java_getString(env, _name);
if (name == NULL) {
return 0L; // OutOfMemory already thrown
}
columns[i] = bindings_java_type_lookup(name);
if (columns[i] == G_TYPE_INVALID) {
bindings_java_throw(env, "Don't know how to map %s into a GType", name);
return 0L;
}
bindings_java_releaseString(name);
(*env)->DeleteLocalRef(env, _name);
}
// call constructor
result = gtk_list_store_newv(num_columns, columns);
// clean up of columns is automatic
// and finally
return (jlong) result;
}
void
search_stats_gui_init(void)
{
static GType types[] = {
G_TYPE_STRING,
G_TYPE_ULONG,
G_TYPE_ULONG
};
static const struct {
const int id;
const float align;
const char *title;
} cols[] = {
{ 0, 0.0, N_("Search Term") },
{ 1, 1.0, N_("This Interval") },
{ 2, 1.0, N_("Total") },
};
size_t i;
GtkTreeModel *model;
GtkTreeView *treeview;
STATIC_ASSERT(G_N_ELEMENTS(cols) == G_N_ELEMENTS(types));
treeview_search_stats =
GTK_TREE_VIEW(gui_main_window_lookup("treeview_search_stats"));
label_search_stats_count =
GTK_LABEL(gui_main_window_lookup("label_search_stats_count"));
treeview = treeview_search_stats;
/* set up the treeview to be sorted properly */
model = GTK_TREE_MODEL(gtk_list_store_newv(G_N_ELEMENTS(types), types));
gtk_tree_view_set_model(treeview, model);
store_search_stats = GTK_LIST_STORE(model);
g_object_unref(model);
for (i = 0; i < G_N_ELEMENTS(cols); i++) {
add_column(treeview, cols[i].id, cols[i].align, _(cols[i].title));
}
tree_view_restore_widths(treeview, PROP_SEARCH_STATS_COL_WIDTHS);
tree_view_set_fixed_height_mode(treeview, TRUE);
stat_hash = htable_create(HASH_KEY_STRING, 0);
main_gui_add_timer(search_stats_gui_timer);
}
/**
@brief copy a liststore or treestore
This is for when reffing is not enough e.g. need independent sorting in
attached views. Pointers to data are simply copied, so if the "source" data will
be cleared before fhe new store, then all such data must be replicated or otherwise
preserved by code elsewhere which understands what that data really is.
Officially, the new store will be unsorted, though in practice it will be the
same as the old store.
@param model treemodel of the store being copied
@param treetype TRUE for treestore, FALSE for liststore
@param newstore store for pointer to new store
@a return
*/
void e2_tree_store_copy (GtkTreeModel *model, gboolean treetype, gpointer *newstore)
{
GtkTreeIter src;
gint i, ncols = gtk_tree_model_get_n_columns (model);
gint colnums[ncols];
GType types[ncols];
GValue values[ncols];
for (i = 0; i < ncols; i++)
{
colnums[i] = i;
types[i] = gtk_tree_model_get_column_type (model, i);
memset (&values[i], 0, sizeof (GValue));
}
if (treetype)
{
GtkTreeStore *newtstore = gtk_tree_store_newv (ncols, types);
if (gtk_tree_model_get_iter_first (model, &src))
_e2_tree_copy_descendants (model, NULL, newtstore, NULL,
ncols, colnums, types, values);
*newstore = newtstore;
}
else
{
GtkListStore *newlstore = gtk_list_store_newv (ncols, types);
if (gtk_tree_model_get_iter_first (model, &src))
{
GtkTreeIter dest;
do
{
for (i = 0; i < ncols; i++)
gtk_tree_model_get_value (model, &src, i, &values[i]);
gtk_list_store_insert_with_valuesv (newlstore, &dest, -1, colnums, values, ncols);
for (i = 0; i < ncols; i++)
g_value_unset (&values[i]);
} while (gtk_tree_model_iter_next (model, &src));
}
*newstore = newlstore;
}
}
void ListBox::create(Window &parent, unsigned x, unsigned y, unsigned width, unsigned height, const char *text) {
listBox->selection = -1;
object->widget = gtk_scrolled_window_new(0, 0);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(object->widget), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(object->widget), GTK_SHADOW_ETCHED_IN);
gtk_widget_set_size_request(object->widget, width, height);
lstring list;
list.split("\t", text);
GType *v = (GType*)malloc(list.size() * sizeof(GType));
for(unsigned i = 0; i < list.size(); i++) v[i] = G_TYPE_STRING;
listBox->store = gtk_list_store_newv(list.size(), v);
free(v);
object->subWidget = gtk_tree_view_new_with_model(GTK_TREE_MODEL(listBox->store));
gtk_container_add(GTK_CONTAINER(object->widget), object->subWidget);
g_object_unref(G_OBJECT(listBox->store));
//alternate color of each row if there is more than one column
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(object->subWidget), list.size() >= 2);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(object->subWidget), false);
for(unsigned i = 0; i < list.size(); i++) {
listBox->column[i].renderer = gtk_cell_renderer_text_new();
listBox->column[i].column = gtk_tree_view_column_new_with_attributes(
list[i], listBox->column[i].renderer, "text", i, (void*)0
);
listBox->column[i].label = gtk_label_new(list[i]);
gtk_tree_view_column_set_widget(GTK_TREE_VIEW_COLUMN(listBox->column[i].column), listBox->column[i].label);
gtk_tree_view_append_column(GTK_TREE_VIEW(object->subWidget), listBox->column[i].column);
gtk_widget_show(listBox->column[i].label);
}
g_signal_connect_swapped(G_OBJECT(object->subWidget), "cursor-changed", G_CALLBACK(ListBox_change), (gpointer)this);
g_signal_connect_swapped(G_OBJECT(object->subWidget), "row-activated", G_CALLBACK(ListBox_activate), (gpointer)this);
if(parent.window->defaultFont) setFont(*parent.window->defaultFont);
gtk_fixed_put(GTK_FIXED(parent.object->formContainer), object->widget, x, y);
gtk_widget_show(object->subWidget);
gtk_widget_show(object->widget);
}
static VALUE
rg_initialize(int argc, VALUE *argv, VALUE self)
{
gint cnt;
GtkListStore* store;
GType* buf;
if (argc == 0) rb_raise(rb_eArgError, "need more than 1 class type.");
buf = ALLOCA_N(GType, argc);
for (cnt = 0; cnt < argc; cnt++) {
buf[cnt] = CLASS2GTYPE(argv[cnt]);
}
store = gtk_list_store_newv(argc, buf);
G_INITIALIZE(self, store);
return Qnil;
}
/* 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 list_init(void)
{
list.rows = 0;
int cols = COL_DIGESTS;
for (int i = 0; i < HASH_FUNCS_N; i++) {
if (!hash.funcs[i].supported)
continue;
list_priv.hash_cols[i] = cols;
cols = gtk_tree_view_insert_column_with_attributes(gui.treeview, -1,
hash.funcs[i].name, gtk_cell_renderer_text_new(),
"text", cols, NULL);
}
GType types[cols];
types[COL_STATUS] = G_TYPE_CHAR;
types[COL_ICON_NAME] = G_TYPE_STRING;
types[COL_PNAME] = G_TYPE_STRING;
types[COL_CHECK] = G_TYPE_STRING;
for (int i = COL_DIGESTS; i < cols; i++) {
types[i] = G_TYPE_STRING;
GtkTreeViewColumn *col = gtk_tree_view_get_column(gui.treeview, i);
gtk_tree_view_column_set_resizable(col, true);
gtk_tree_view_column_set_min_width(col, 10);
}
gui.liststore = gtk_list_store_newv(cols, types);
gui.treemodel = GTK_TREE_MODEL(gui.liststore);
gtk_tree_view_set_model(gui.treeview, gui.treemodel);
const GtkTargetEntry targets[] = {
{ (char *)"text/uri-list", 0, 0 }
};
gtk_drag_dest_set(GTK_WIDGET(gui.treeview), GTK_DEST_DEFAULT_ALL, targets,
G_N_ELEMENTS(targets), GDK_ACTION_COPY);
}
static GtkTreeModel *
create_and_fill_model (sqlite3_stmt* stmt)
{
GtkListStore *store;
GtkTreeIter iter;
int columns;
GType* types;
int rc;
columns = sqlite3_column_count(stmt);
types = get_column_types(stmt);
store = gtk_list_store_newv (columns, types);
while(1){
gtk_list_store_append (store, &iter);
rc = list_store_value_from_stmt(store, &iter, stmt, columns);
if(rc != SQLITE_ROW){ break; }
}
return GTK_TREE_MODEL (store);
}
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;
}
static void
tr_core_init (TrCore * core)
{
GtkListStore * store;
struct TrCorePrivate * p;
/* column types for the model used to store torrent information */
/* keep this in sync with the enum near the bottom of tr_core.h */
GType types[] = { G_TYPE_POINTER, /* collated name */
G_TYPE_POINTER, /* tr_torrent* */
G_TYPE_INT, /* torrent id */
G_TYPE_DOUBLE, /* tr_stat.pieceUploadSpeed_KBps */
G_TYPE_DOUBLE, /* tr_stat.pieceDownloadSpeed_KBps */
G_TYPE_DOUBLE, /* tr_stat.recheckProgress */
G_TYPE_BOOLEAN, /* filter.c:ACTIVITY_FILTER_ACTIVE */
G_TYPE_INT, /* tr_stat.activity */
G_TYPE_UCHAR, /* tr_stat.finished */
G_TYPE_CHAR, /* tr_priority_t */
G_TYPE_INT, /* tr_stat.queuePosition */
G_TYPE_UINT, /* build_torrent_trackers_hash () */
G_TYPE_INT, /* MC_ERROR */
G_TYPE_INT }; /* MC_ACTIVE_PEER_COUNT */
p = core->priv = G_TYPE_INSTANCE_GET_PRIVATE (core,
TR_CORE_TYPE,
struct TrCorePrivate);
/* create the model used to store torrent data */
g_assert (G_N_ELEMENTS (types) == MC_ROW_COUNT);
store = gtk_list_store_newv (MC_ROW_COUNT, types);
p->raw_model = GTK_TREE_MODEL (store);
p->sorted_model = gtk_tree_model_sort_new_with_model (p->raw_model);
p->string_chunk = g_string_chunk_new (2048);
g_object_unref (p->raw_model);
}
int destination_address(struct navit *nav)
{
GtkWidget *window2, *keyboard, *vbox, *table;
GtkWidget *label_country;
GtkWidget *label_postal, *label_city, *label_district;
GtkWidget *label_street, *label_number;
GtkWidget *hseparator1,*hseparator2;
GtkWidget *button1,*button2,*button3;
int i;
struct search_param *search=&search_param;
struct attr search_attr, country_name, *country_attr;
struct tracking *tracking;
struct country_search *cs;
struct item *item;
GtkTreeSelection* selection;
search->nav=nav;
search->ms=navit_get_mapset(nav);
search->sl=search_list_new(search->ms);
window2 = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window2),_("Enter Destination"));
vbox = gtk_vbox_new(FALSE, 0);
table = gtk_table_new(3, 8, FALSE);
search->entry_country = gtk_entry_new();
label_country = gtk_label_new(_("Country"));
search->entry_postal = gtk_entry_new();
label_postal = gtk_label_new(_("Zip Code"));
search->entry_city = gtk_entry_new();
label_city = gtk_label_new(_("City"));
search->entry_district = gtk_entry_new();
label_district = gtk_label_new(_("District/Township"));
hseparator1 = gtk_vseparator_new();
search->entry_street = gtk_entry_new();
label_street = gtk_label_new(_("Street"));
search->entry_number = gtk_entry_new();
label_number = gtk_label_new(_("Number"));
search->listbox = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (search->listbox),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
// gtk_tree_view_set_model (GTK_TREE_VIEW (search->treeview), NULL);
{
GType types[COL_COUNT+2];
for(i=0;i<COL_COUNT;i++)
types[i]=G_TYPE_STRING;
types[i++]=G_TYPE_POINTER;
types[i++]=G_TYPE_POINTER;
search->liststore=gtk_list_store_newv(COL_COUNT+2,types);
search->liststore2=gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(search->liststore));
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (search->liststore2), 0, GTK_SORT_ASCENDING);
// gtk_tree_view_set_model (GTK_TREE_VIEW (search->treeview), GTK_TREE_MODEL(search->liststore2));
search->treeview = gtk_tree_view_new_with_model(search->liststore2);
gtk_tree_view_set_search_column(GTK_TREE_VIEW (search->treeview),3);
}
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(search->listbox),search->treeview);
#if 1
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW (search->treeview));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
g_signal_connect(selection, "changed", G_CALLBACK(select_row), search);
// g_signal_connect(search->liststore, "row-activated", G_CALLBACK(select_row), search);
// g_signal_connect(search->liststore2, "row-activated", G_CALLBACK(select_row), search);
// g_signal_connect(search->treeview, "select-cursor-row", G_CALLBACK(select_row), search);
#endif
hseparator2 = gtk_vseparator_new();
button1 = gtk_button_new_with_label(_("Map"));
button2 = gtk_button_new_with_label(_("Bookmark"));
button3 = gtk_button_new_with_label(_("Destination"));
gtk_table_attach(GTK_TABLE(table), label_country, 0, 1, 0, 1, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), label_postal, 1, 2, 0, 1, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), label_city, 2, 3, 0, 1, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), search->entry_country, 0, 1, 1, 2, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), search->entry_postal, 1, 2, 1, 2, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), search->entry_city, 2, 3, 1, 2, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), label_district, 0, 1, 2, 3, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), label_street, 1, 2, 2, 3, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), label_number, 2, 3, 2, 3, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), search->entry_district, 0, 1, 3, 4, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), search->entry_street, 1, 2, 3, 4, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), search->entry_number, 2, 3, 3, 4, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), search->listbox, 0, 3, 4, 5, GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 0, 0);
gtk_table_attach(GTK_TABLE(table), button1, 0, 1, 5, 6, GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), button2, 1, 2, 5, 6, GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), button3, 2, 3, 5, 6, GTK_FILL, GTK_FILL, 0, 0);
g_signal_connect(G_OBJECT(search->entry_country), "changed", G_CALLBACK(changed), search);
g_signal_connect(G_OBJECT(search->entry_postal), "changed", G_CALLBACK(changed), search);
g_signal_connect(G_OBJECT(search->entry_city), "changed", G_CALLBACK(changed), search);
g_signal_connect(G_OBJECT(search->entry_district), "changed", G_CALLBACK(changed), search);
g_signal_connect(G_OBJECT(search->entry_street), "changed", G_CALLBACK(changed), search);
g_signal_connect(G_OBJECT(search->entry_number), "changed", G_CALLBACK(changed), search);
g_signal_connect(G_OBJECT(button1), "clicked", G_CALLBACK(button_map), search);
g_signal_connect(G_OBJECT(button2), "clicked", G_CALLBACK(button_bookmark), search);
g_signal_connect(G_OBJECT(button3), "clicked", G_CALLBACK(button_destination), search);
gtk_widget_grab_focus(search->entry_city);
gtk_box_pack_start(GTK_BOX(vbox), table, TRUE, TRUE, 0);
keyboard=gtk_socket_new();
gtk_box_pack_end(GTK_BOX(vbox), keyboard, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(window2), vbox);
gtk_widget_show_all(window2);
// gtk_socket_steal(GTK_SOCKET(keyboard), spawn_xkbd("xkbd","-geometry 200x100"));
country_attr=country_default();
tracking=navit_get_tracking(nav);
if (tracking && tracking_get_current_attr(tracking, attr_country_id, &search_attr))
country_attr=&search_attr;
cs=country_search_new(country_attr, 0);
item=country_search_get_item(cs);
if (item && item_attr_get(item, attr_country_name, &country_name))
gtk_entry_set_text(GTK_ENTRY(search->entry_country), country_name.u.str);
country_search_destroy(cs);
return 0;
}
SteadyflowFileListController* steadyflow_file_list_controller_construct (GType object_type, GtkTreeView* tree) {
SteadyflowFileListController * self = NULL;
GtkTreeView* _tmp0_;
GtkTreeView* _tmp1_;
GtkTreeView* _tmp2_;
GtkTreeSelection* _tmp3_ = NULL;
GTimer* _tmp4_;
GTimer* _tmp5_;
GtkTreeViewColumn* _tmp6_;
GtkTreeViewColumn* _tmp7_;
GtkTreeViewColumn* column;
GtkTreeViewColumn* _tmp8_;
GtkTreeViewColumn* _tmp9_;
SteadyflowUIDownloadCellRenderer* _tmp10_;
GtkCellRenderer* _tmp11_;
GtkCellRenderer* renderer;
GtkTreeViewColumn* _tmp12_;
GtkCellRenderer* _tmp13_;
GtkTreeViewColumn* _tmp14_;
GtkCellRenderer* _tmp15_;
GType* _tmp16_ = NULL;
GType* _tmp17_;
gint _tmp17__length1;
GtkListStore* _tmp18_;
GtkTreeView* _tmp19_;
GtkListStore* _tmp20_;
GtkTreeView* _tmp21_;
GtkTreeViewColumn* _tmp22_;
SteadyflowCoreIDownloadService* _tmp37_;
SteadyflowCoreIDownloadService* _tmp38_;
SteadyflowCoreIDownloadService* _tmp39_;
SteadyflowCoreIDownloadService* _tmp40_;
GtkTreeView* _tmp41_;
GtkTreeSelection* _tmp42_ = NULL;
g_return_val_if_fail (tree != NULL, NULL);
self = (SteadyflowFileListController*) g_object_new (object_type, NULL);
_tmp0_ = tree;
_tmp1_ = _g_object_ref0 (_tmp0_);
_g_object_unref0 (self->priv->tree);
self->priv->tree = _tmp1_;
_tmp2_ = tree;
_tmp3_ = gtk_tree_view_get_selection (_tmp2_);
gtk_tree_selection_set_mode (_tmp3_, GTK_SELECTION_MULTIPLE);
_tmp4_ = g_timer_new ();
_g_timer_destroy0 (self->priv->redraw_timer);
self->priv->redraw_timer = _tmp4_;
_tmp5_ = self->priv->redraw_timer;
g_timer_start (_tmp5_);
_tmp6_ = gtk_tree_view_column_new ();
_tmp7_ = g_object_ref_sink (_tmp6_);
column = _tmp7_;
_tmp8_ = column;
gtk_tree_view_column_set_expand (_tmp8_, TRUE);
_tmp9_ = column;
gtk_tree_view_column_set_clickable (_tmp9_, FALSE);
_tmp10_ = steadyflow_ui_download_cell_renderer_new ();
_tmp11_ = (GtkCellRenderer*) g_object_ref_sink (_tmp10_);
renderer = _tmp11_;
_tmp12_ = column;
_tmp13_ = renderer;
gtk_cell_layout_pack_start ((GtkCellLayout*) _tmp12_, _tmp13_, TRUE);
_tmp14_ = column;
_tmp15_ = renderer;
gtk_cell_layout_set_cell_data_func ((GtkCellLayout*) _tmp14_, _tmp15_, _steadyflow_file_list_controller_set_cell_data_gtk_cell_layout_data_func, g_object_ref (self), g_object_unref);
_tmp16_ = g_new0 (GType, 1);
_tmp16_[0] = STEADYFLOW_CORE_TYPE_IDOWNLOAD_FILE;
_tmp17_ = _tmp16_;
_tmp17__length1 = 1;
_tmp18_ = gtk_list_store_newv (1, _tmp17_);
_g_object_unref0 (self->priv->model);
self->priv->model = _tmp18_;
_tmp17_ = (g_free (_tmp17_), NULL);
_tmp19_ = tree;
_tmp20_ = self->priv->model;
gtk_tree_view_set_model (_tmp19_, (GtkTreeModel*) _tmp20_);
_tmp21_ = tree;
_tmp22_ = column;
gtk_tree_view_append_column (_tmp21_, _tmp22_);
{
SteadyflowCoreIDownloadService* _tmp23_;
SteadyflowCoreIDownloadService* _tmp24_;
GeeList* _tmp25_;
GeeList* _tmp26_;
GeeList* _file_list;
GeeList* _tmp27_;
gint _tmp28_;
gint _tmp29_;
gint _file_size;
gint _file_index;
_tmp23_ = steadyflow_services_get_download ();
_tmp24_ = _tmp23_;
_tmp25_ = steadyflow_core_idownload_service_get_files (_tmp24_);
_tmp26_ = _tmp25_;
_file_list = _tmp26_;
_tmp27_ = _file_list;
_tmp28_ = gee_collection_get_size ((GeeCollection*) _tmp27_);
_tmp29_ = _tmp28_;
_file_size = _tmp29_;
_file_index = -1;
while (TRUE) {
gint _tmp30_;
gint _tmp31_;
gint _tmp32_;
GeeList* _tmp33_;
gint _tmp34_;
gpointer _tmp35_ = NULL;
SteadyflowCoreIDownloadFile* file;
SteadyflowCoreIDownloadFile* _tmp36_;
_tmp30_ = _file_index;
_file_index = _tmp30_ + 1;
_tmp31_ = _file_index;
_tmp32_ = _file_size;
if (!(_tmp31_ < _tmp32_)) {
break;
}
_tmp33_ = _file_list;
_tmp34_ = _file_index;
_tmp35_ = gee_list_get (_tmp33_, _tmp34_);
file = (SteadyflowCoreIDownloadFile*) _tmp35_;
_tmp36_ = file;
steadyflow_file_list_controller_connect_file_signals (self, _tmp36_);
_g_object_unref0 (file);
}
_g_object_unref0 (_file_list);
}
steadyflow_file_list_controller_update_model (self);
_tmp37_ = steadyflow_services_get_download ();
_tmp38_ = _tmp37_;
g_signal_connect_object (_tmp38_, "file-added", (GCallback) ___lambda26__steadyflow_core_idownload_service_file_added, self, 0);
_tmp39_ = steadyflow_services_get_download ();
_tmp40_ = _tmp39_;
g_signal_connect_object (_tmp40_, "file-removed", (GCallback) ___lambda27__steadyflow_core_idownload_service_file_removed, self, 0);
_tmp41_ = tree;
_tmp42_ = gtk_tree_view_get_selection (_tmp41_);
g_signal_connect_object (_tmp42_, "changed", (GCallback) ___lambda28__gtk_tree_selection_changed, self, 0);
_g_object_unref0 (renderer);
_g_object_unref0 (column);
return self;
}
static void
gmdb_sql_execute_cb(GtkWidget *w, GladeXML *xml)
{
guint len;
gchar *buf;
gchar *bound_data[256];
int i;
MdbSQLColumn *sqlcol;
GtkTextBuffer *txtbuffer;
GtkTextIter start, end;
GtkWidget *textview, *combobox, *treeview;
GtkTreeModel *store;
/*GtkWidget *window;*/
GType *gtypes;
GtkTreeIter iter;
GtkTreeViewColumn *column;
long row, maxrow;
/* GdkCursor *watch, *pointer; */
/* need to figure out how to clock during the treeview recalc/redraw
window = glade_xml_get_widget(xml, "sql_window");
watch = gdk_cursor_new(GDK_WATCH);
gdk_window_set_cursor(GTK_WIDGET(window)->window, watch);
gdk_cursor_unref(watch);
*/
/* stuff this query on the history */
textview = glade_xml_get_widget(xml, "sql_textview");
combobox = glade_xml_get_widget(xml, "sql_combo");
txtbuffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
len = gtk_text_buffer_get_char_count(txtbuffer);
gtk_text_buffer_get_iter_at_offset (txtbuffer, &start, 0);
gtk_text_buffer_get_iter_at_offset (txtbuffer, &end, len);
buf = gtk_text_buffer_get_text(txtbuffer, &start, &end, FALSE);
/* add to the history */
gtk_combo_box_prepend_text(GTK_COMBO_BOX(combobox), buf);
gtk_combo_box_set_active(GTK_COMBO_BOX(combobox), 0);
/* ok now execute it */
mdb_sql_run_query(sql, buf);
if (mdb_sql_has_error(sql)) {
GtkWidget* dlg = gtk_message_dialog_new (GTK_WINDOW (gtk_widget_get_toplevel (w)),
GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_WARNING, GTK_BUTTONS_CLOSE,
"%s", mdb_sql_last_error(sql));
gtk_dialog_run (GTK_DIALOG (dlg));
gtk_widget_destroy (dlg);
mdb_sql_reset(sql);
return;
}
treeview = glade_xml_get_widget(xml, "sql_results");
gtypes = g_malloc(sizeof(GType) * sql->num_columns);
for (i=0;i<sql->num_columns;i++)
gtypes[i]=G_TYPE_STRING;
store = gtk_tree_view_get_model(GTK_TREE_VIEW(treeview));
if (store) {
while ((column = gtk_tree_view_get_column(GTK_TREE_VIEW(treeview), 0))) {
gtk_tree_view_remove_column(GTK_TREE_VIEW(treeview), column);
}
g_object_unref(store);
}
store = (GtkTreeModel*)gtk_list_store_newv(sql->num_columns, gtypes);
g_free(gtypes);
gtk_tree_view_set_model(GTK_TREE_VIEW(treeview), store);
GtkCellRenderer *renderer;
renderer = gtk_cell_renderer_text_new();
for (i=0;i<sql->num_columns;i++) {
bound_data[i] = (char *) g_malloc0(MDB_BIND_SIZE);
mdb_sql_bind_column(sql, i+1, bound_data[i], NULL);
sqlcol = g_ptr_array_index(sql->columns,i);
column = gtk_tree_view_column_new_with_attributes(sqlcol->name, renderer, "text", i, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW (treeview), column);
}
maxrow = gmdb_prefs_get_maxrows();
row = 0;
while(mdb_fetch_row(sql->cur_table) &&
(!maxrow || (row < maxrow))) {
row++;
gtk_list_store_append(GTK_LIST_STORE(store), &iter);
for (i=0;i<sql->num_columns;i++) {
gtk_list_store_set(GTK_LIST_STORE(store),
&iter, i, (gchar *) bound_data[i], -1);
}
}
/* free the memory used to bind */
for (i=0;i<sql->num_columns;i++) {
g_free(bound_data[i]);
}
mdb_sql_reset(sql);
g_free(buf);
/*
pointer = gdk_cursor_new(GDK_LEFT_PTR);
gdk_window_set_cursor(GTK_WIDGET(window)->window, pointer);
gdk_cursor_unref(pointer);
*/
}
bool change_restrictions(int vars)
{
/* Clear model */
clear_liststore(restrictions_view);
/* Create the dynamic types array */
int size = vars + 2;
GType* types = (GType*) malloc(3 * size * sizeof(GType));
if(types == NULL) {
return false;
}
/* Set type in the dynamic types array */
for(int i = 0; i < size; i++) {
types[i] = G_TYPE_INT; /* Coeffs */
types[size + i] = G_TYPE_STRING; /* Text */
types[2 * size + i] = G_TYPE_STRING; /* Signs */
}
/* Create the new model */
GtkListStore* restrictions = gtk_list_store_newv(3 * size, types);
/* Clear the previous columns */
for(int i = gtk_tree_view_get_n_columns(restrictions_view) - 1; i >= 0; i--) {
gtk_tree_view_remove_column(
restrictions_view,
gtk_tree_view_get_column(restrictions_view, i)
);
}
/* Create the new columns */
for(int i = 0; i < size; i++) {
/* Especial column for type */
if(i == (size - 2)) {
GtkCellRenderer* type = gtk_cell_renderer_text_new();
GtkTreeViewColumn* column = gtk_tree_view_column_new_with_attributes(
"", type, /* Title, renderer */
"markup", size + i,
NULL);
gtk_tree_view_append_column(restrictions_view, column);
continue;
}
/* Create sign column */
if((i != 0) && (i != size - 1)) {
GtkCellRenderer* sign = gtk_cell_renderer_text_new();
GtkTreeViewColumn* sign_c =
gtk_tree_view_column_new_with_attributes(
"", sign, /* Title, renderer */
"markup", 2 * size + i,
NULL);
gtk_tree_view_append_column(restrictions_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(restrictions_edit_started_cb),
GINT_TO_POINTER(i));
restrictions_edit_started_cb(cell, NULL, NULL, GINT_TO_POINTER(i));
if(i < size - 2) {
g_signal_connect(G_OBJECT(cell),
"edited", G_CALLBACK(restrictions_edited_cb),
GINT_TO_POINTER(i));
} else {
g_signal_connect(G_OBJECT(cell),
"edited", G_CALLBACK(num_edited_cb),
GINT_TO_POINTER(i));
}
/* Configure column */
GtkTreeViewColumn* column = gtk_tree_view_column_new_with_attributes(
"", cell, /* Title, renderer */
"markup", size + i,
NULL);
gtk_tree_view_column_set_min_width(column, 100);
gtk_tree_view_append_column(restrictions_view, column);
}
gtk_tree_view_append_column(restrictions_view, gtk_tree_view_column_new());
/* Set the new model */
gtk_tree_view_set_model(restrictions_view, GTK_TREE_MODEL(restrictions));
/* Free resources */
g_object_unref(G_OBJECT(restrictions));
free(types);
return true;
}
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;
}
