static VALUE
rg_operator_treeiter_eql(VALUE self, VALUE other)
{
gint i, num1, num2;
GtkTreeIter* iter1 = _SELF(self);
GtkTreeIter* iter2;
GtkTreeModel* model1;
GtkTreeModel* model2;
GtkTreePath* path1;
GtkTreePath* path2;
if (!rb_obj_is_kind_of(other, GTYPE2CLASS(GTK_TYPE_TREE_ITER)))
return Qfalse;
iter2 = _SELF(other);
model1 = (GtkTreeModel*)iter1->user_data3;
model2 = (GtkTreeModel*)iter2->user_data3;
if (model1 != model2) return Qfalse;
num1 = gtk_tree_model_get_n_columns(model1);
num2 = gtk_tree_model_get_n_columns(model2);
if (num1 != num2) return Qfalse;
path1 = gtk_tree_model_get_path(model1, iter1);
path2 = gtk_tree_model_get_path(model2, iter2);
if (gtk_tree_path_compare(path1, path2) != 0) {
gtk_tree_path_free(path1);
gtk_tree_path_free(path2);
return Qfalse;
} else {
gtk_tree_path_free(path1);
gtk_tree_path_free(path2);
}
for (i = 0; i < num1; i++){
GValue gval1 = G_VALUE_INIT;
GValue gval2 = G_VALUE_INIT;
VALUE ret1, ret2;
gtk_tree_model_get_value(model1, iter1, i, &gval1);
gtk_tree_model_get_value(model2, iter2, i, &gval2);
ret1 = GVAL2RVAL(&gval1);
ret2 = GVAL2RVAL(&gval2);
g_value_unset(&gval1);
g_value_unset(&gval2);
if (rb_equal(ret1, ret2) == Qfalse)
return Qfalse;
}
return Qtrue;
}
/****************************************************************
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;
}
/**
@brief create a list of selected rows in @a treeview
This is recursive, to handle descendants of any selected row, too
@param treeview the treeview to be processed
@return the list of arrays, or NULL if nothing is selected
*/
GList *e2_tree_copy (GtkTreeView *treeview)
{
GList *rowscopied = NULL;
GtkTreeSelection *sel = gtk_tree_view_get_selection (treeview);
if (gtk_tree_selection_count_selected_rows (sel) > 0)
{
GtkTreeModel *model;
GList *rowpath;
GList *selpaths = gtk_tree_selection_get_selected_rows (sel, &model);
gint columns = gtk_tree_model_get_n_columns (model);
//copy the selected rows and their descendants
for (rowpath = selpaths; rowpath != NULL; rowpath = rowpath->next)
{
GtkTreeIter iter;
if (gtk_tree_model_get_iter (model, &iter, (GtkTreePath *) rowpath->data))
_e2_tree_copy_branch (model, &iter, columns, &rowscopied);
gtk_tree_path_free ((GtkTreePath *) rowpath->data);
}
g_list_free (selpaths);
printd (DEBUG, "copied %d rows", g_list_length (rowscopied));
}
return rowscopied;
}
static void
searchresults_callback_wrapper_cb(GtkWidget *widget, PidginNotifySearchResultsButtonData *bd)
{
PidginNotifySearchResultsData *data = bd->data;
GtkTreeSelection *selection;
GtkTreeModel *model;
GtkTreeIter iter;
PurpleNotifySearchButton *button;
GList *row = NULL;
gchar *str;
int i;
g_return_if_fail(data != NULL);
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(data->treeview));
if (gtk_tree_selection_get_selected(selection, &model, &iter))
{
for (i = 1; i < gtk_tree_model_get_n_columns(GTK_TREE_MODEL(model)); i++) {
gtk_tree_model_get(GTK_TREE_MODEL(model), &iter, i, &str, -1);
row = g_list_append(row, str);
}
}
button = bd->button;
button->callback(purple_account_get_connection(data->account), row, data->user_data);
g_list_foreach(row, (GFunc)g_free, NULL);
g_list_free(row);
}
void print_tree_selection(GtkTreeModel *model,
GtkTreePath *path,
GtkTreeIter *iter,
gpointer data)
{
gint columns = gtk_tree_model_get_n_columns(model);
// Print the path of the selection
g_printf("\t%s", gtk_tree_path_to_string(path));
// Print all the text columns
for (gint i = 0; i < columns; ++i) {
GValue value = {0};
GValue str_value = {0};
gtk_tree_model_get_value(model, iter, i, &value);
g_value_init(&str_value, G_TYPE_STRING);
if (g_value_type_transformable(G_VALUE_TYPE(&value), G_TYPE_STRING)) {
g_value_transform(&value, &str_value);
g_printf("\t%s", g_value_get_string(&str_value));
}
g_value_unset(&value);
}
}
static void zenity_forms_dialog_get_selected (GtkTreeModel *model, GtkTreePath *path_buf, GtkTreeIter *iter, GtkTreeView *tree_view)
{
gint n_columns = 0;
gint i = 0;
GValue value = {0, };
n_columns = gtk_tree_model_get_n_columns (model);
for (i = 0; i < n_columns; i++) {
gtk_tree_model_get_value (model, iter, i, &value);
selected = g_slist_append (selected, g_value_dup_string (&value));
g_value_unset (&value);
}
}
static G_CONST_RETURN gchar*
gail_combo_box_get_name (AtkObject *obj)
{
GtkWidget *widget;
GtkComboBox *combo_box;
GailComboBox *gail_combo_box;
GtkTreeIter iter;
G_CONST_RETURN gchar *name;
GtkTreeModel *model;
gint n_columns;
gint i;
g_return_val_if_fail (GAIL_IS_COMBO_BOX (obj), NULL);
name = ATK_OBJECT_CLASS (gail_combo_box_parent_class)->get_name (obj);
if (name)
return name;
widget = GTK_ACCESSIBLE (obj)->widget;
if (widget == NULL)
/*
* State is defunct
*/
return NULL;
combo_box = GTK_COMBO_BOX (widget);
gail_combo_box = GAIL_COMBO_BOX (obj);
if (gtk_combo_box_get_active_iter (combo_box, &iter))
{
model = gtk_combo_box_get_model (combo_box);
n_columns = gtk_tree_model_get_n_columns (model);
for (i = 0; i < n_columns; i++)
{
GValue value = { 0, };
gtk_tree_model_get_value (model, &iter, i, &value);
if (G_VALUE_HOLDS_STRING (&value))
{
if (gail_combo_box->name) g_free (gail_combo_box->name);
gail_combo_box->name = g_strdup ((gchar *)
g_value_get_string (&value));
g_value_unset (&value);
break;
}
else
g_value_unset (&value);
}
}
return gail_combo_box->name;
}
static PyObject *
pygtk_tree_model_row_getitem(PyGtkTreeModelRow *self, Py_ssize_t column)
{
gint n_columns;
GValue value = { 0, };
PyObject *ret;
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 NULL;
}
gtk_tree_model_get_value(self->model, &self->iter, column, &value);
ret = pyg_value_as_pyobject(&value, TRUE);
g_value_unset(&value);
return ret;
}
static const gchar *
gtk_combo_box_accessible_get_name (AtkObject *obj)
{
GtkWidget *widget;
GtkComboBox *combo_box;
GtkComboBoxAccessible *accessible;
GtkTreeIter iter;
const gchar *name;
GtkTreeModel *model;
gint n_columns;
gint i;
name = ATK_OBJECT_CLASS (_gtk_combo_box_accessible_parent_class)->get_name (obj);
if (name)
return name;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj));
if (widget == NULL)
return NULL;
combo_box = GTK_COMBO_BOX (widget);
accessible = GTK_COMBO_BOX_ACCESSIBLE (obj);
if (gtk_combo_box_get_active_iter (combo_box, &iter))
{
model = gtk_combo_box_get_model (combo_box);
n_columns = gtk_tree_model_get_n_columns (model);
for (i = 0; i < n_columns; i++)
{
GValue value = G_VALUE_INIT;
gtk_tree_model_get_value (model, &iter, i, &value);
if (G_VALUE_HOLDS_STRING (&value))
{
g_free (accessible->name);
accessible->name = g_strdup (g_value_get_string (&value));
g_value_unset (&value);
break;
}
else
g_value_unset (&value);
}
}
return accessible->name;
}
/* Process each row for a GtkTreeModel */
static gboolean
output_foreach (GtkTreeModel * model, GtkTreePath * path,
GtkTreeIter * iter, gpointer data)
{
gint columns;
gint j;
GType type;
GString *result = (GString *) data;
columns = gtk_tree_model_get_n_columns (model);
/* Get values from each colum */
for (j = 0; j < columns; j++) {
GValue value = G_VALUE_INIT;
gchar *svalue;
gint ivalue;
type = gtk_tree_model_get_column_type (model, j);
switch (type) {
case G_TYPE_INT:
gtk_tree_model_get_value (model, iter, j, &value);
ivalue = g_value_get_int (&value);
g_value_unset (&value);
g_string_append_printf (result, "%d", ivalue);
break;
case G_TYPE_STRING:
gtk_tree_model_get_value (model, iter, j, &value);
svalue = g_value_dup_string (&value);
g_value_unset (&value);
g_string_append_printf (result, "%s", svalue);
g_free (svalue);
break;
}
if (j == columns - 1) {
g_string_append_printf (result, "\n");
} else {
g_string_append_printf (result, "\t");
}
}
return FALSE;
}
/****************************************************************
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);
}
/**
@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;
}
}
/* 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;
}
static void swap_model_iters_contents (GtkTreeModel *tm, GtkTreeIter *itrSrc, GtkTreeIter *itrDst)
{
GValue valSrc = {0, }, valDst = {0, } ;
int Nix = 0, icCols = -1 ;
GtkTreeStore *ts = GTK_TREE_STORE (tm) ;
if (NULL == tm || NULL == itrSrc || NULL == itrDst) return ;
icCols = gtk_tree_model_get_n_columns (tm) ;
for (Nix = 0 ; Nix < icCols ; Nix++)
{
gtk_tree_model_get_value (tm, itrSrc, Nix, &valSrc) ;
gtk_tree_model_get_value (tm, itrDst, Nix, &valDst) ;
gtk_tree_store_set_value (ts, itrSrc, Nix, &valDst) ;
gtk_tree_store_set_value (ts, itrDst, Nix, &valSrc) ;
g_value_unset (&valSrc) ;
g_value_unset (&valDst) ;
}
}
static void
select_row(GtkTreeView *tree, GtkTreePath *path, GtkTreeViewColumn *column, struct datawindow_priv *win)
{
char *cols[20];
GtkTreeIter iter;
GtkTreeModel *model;
int i;
dbg(0,"win=%p\n", win);
model=gtk_tree_view_get_model(tree);
gtk_tree_model_get_iter(model, &iter, path);
for (i=0;i<gtk_tree_model_get_n_columns(model);i++) {
gtk_tree_model_get_value(model, &iter, i, &value);
cols[i]=g_strdup_value_contents(&value)+1;
cols[i][strlen(cols[i])-1]='\0';
g_value_unset(&value);
}
callback_call_1(win->click, cols);
}
orcaData orcaGtkIter::operator()(orcaVM* vm, int n)/*{{{*/
{
if (n > 0) {
orcaList* lp = castobj<orcaList>(vm->get_param(0));
if (lp == NULL) {
throw orcaException(vm, "orca.type", "list type is required");
}
set_list_to_store(lp, m_gp->store, &m_iter, m_type);
return lp;
}
else {
orcaList* lp = new orcaList();
int width = gtk_tree_model_get_n_columns(m_gp->store);
for (int i=0; i<width; i++) {
GValue value = { 0, };
gtk_tree_model_get_value(m_gp->store, &m_iter, i, &value);
GType t = value.g_type;
if (t == G_TYPE_STRING) {
char* cp = (char*)g_value_get_string(&value);
if (cp == NULL) cp = (char*)"";
lp->push_back(cp);
}
else if (t == G_TYPE_BOOLEAN) {
bool r = g_value_get_boolean(&value);
lp->push_back(r);
}
else {
lp->push_back(NIL);
}
g_value_unset(&value);
}
return lp;
}
}
static VALUE
rg_reorder(VALUE self, VALUE rbparent, VALUE rbnew_order)
{
GtkTreeStore *store = _SELF(self);
GtkTreeIter *parent = RVAL2GTKTREEITER(rbparent);
gint columns = gtk_tree_model_get_n_columns(GTK_TREE_MODEL(store));
long n;
gint *new_order = RVAL2GINTS(rbnew_order, n);
if (n != columns) {
g_free(new_order);
rb_raise(rb_eArgError,
"new order array must contain same number of elements as the number of columns in the store: %ld != %d",
n, columns);
}
gtk_tree_store_reorder(store, parent, new_order);
g_free(new_order);
return self;
}
static VALUE
rg_rows_reordered(VALUE self, VALUE rbpath, VALUE rbiter, VALUE rbnew_order)
{
GtkTreeModel *proxy = _SELF(self);
GtkTreePath *path = RVAL2GTKTREEPATH(rbpath);
GtkTreeIter *iter = RVAL2GTKTREEITER(rbiter);
gint columns = gtk_tree_model_get_n_columns(proxy);
long n;
gint *new_order = RVAL2GINTS(rbnew_order, n);
if (n != columns) {
g_free(new_order);
rb_raise(rb_eArgError,
"new order array must contain same number of elements as the number of columns in the store: %ld != %d",
n, columns);
}
gtk_tree_model_rows_reordered(proxy, path, iter, new_order);
g_free(new_order);
return self;
}
/**
@brief try to find tree iter in @a model, at or after @a iter, which contains string @a search
This is a wrapper for the real search function. It performs several checks
The scan traverses @a model checking each iter and any children, depth-first
@param model treemodel to be interrogated
@param column index of the column in @a model to scan
@param search the string to be searched for
@param iter pointer to treeiter for model interrogation (start and match)
@param with_children TRUE if matched iter must have child(ren)
@return TRUE if the string was found
*/
gboolean e2_tree_find_iter_from_str (GtkTreeModel *model, gint column,
const gchar *search, GtkTreeIter *iter, gboolean with_children)
{
if (model == NULL)
return FALSE;
gint num_columns = gtk_tree_model_get_n_columns (model);
if (column > (num_columns - 1))
{
printd (WARN, "bad call of e2_tree_find_iter_from_str");
printd (WARN, "requesting column %d of %d columns", column + 1, num_columns);
return FALSE;
}
if (gtk_tree_model_get_column_type (model, column) != G_TYPE_STRING)
{
printd (WARN, "bad call of e2_tree_find_iter_from_str");
printd (WARN, "column %d is not of type string", column + 1);
return FALSE;
}
if (gtk_tree_model_get_iter_first (model, iter))
return e2_tree_find_iter_from_str_simple (model, column, search,
iter, with_children);
return FALSE;
}
orcaData orcaGtk::ex_get_data(orcaVM* vm, int n)/*{{{*/
{
if (n < 1) vm->need_param();
orcaData key = vm->get_param(0);
if (type == GUI_LIST || type == GUI_TREE) {
if (is<TYPE_INT>(key)) {
int nth = key.Integer();
GtkTreeIter iter;
gtk_tree_model_get_iter_first(store, &iter);
for (int i=0; i<nth; i++) {
if (!gtk_tree_model_iter_next(store, &iter))
throw orcaException(vm, "orca.index", "out of index");
}
orcaList* lp = new orcaList();
int width = gtk_tree_model_get_n_columns(store);
for (int i=0; i<width; i++) {
GValue value = { 0, };
gtk_tree_model_get_value(store, &iter, i, &value);
GType t = value.g_type;
if (t == G_TYPE_STRING) {
char* cp = (char*)g_value_get_string(&value);
if (cp == NULL) cp = (char*)"";
lp->push_back(cp);
}
else if (t == G_TYPE_BOOLEAN) {
bool r = g_value_get_boolean(&value);
lp->push_back(r);
}
else {
lp->push_back(NIL);
}
g_value_unset(&value);
}
return lp;
}
string str = key.String();
if (str == "begin") {
orcaGtkIter* bp = new orcaGtkIter();
bp->m_gp = this;
gtk_tree_model_get_iter_first(store, &bp->m_iter);
if (type == GUI_LIST)
bp->m_type = GUI_LIST;
else
bp->m_type = GUI_TREE;
return bp;
}
else if (type == GUI_TREE && str == "branch") {
orcaTuple* path = castobj<orcaTuple>(vm->get_param(1));
if (path == NULL) {
return NIL;
}
orcaGtkIter* bp = new orcaGtkIter();
bp->m_gp = this;
bp->m_type = GUI_TREE;
GtkTreeIter iter;
GtkTreeIter parent;
for (int i=0; i<path->size(); i++) {
if (i==0) {
gtk_tree_model_get_iter_first(store, &iter);
for (int j=0; j<path->at(0).Integer(); j++) {
if (!gtk_tree_model_iter_next(store, &iter))
throw orcaException(vm, "orca.index", "out of index");
}
parent = iter;
bp->m_iter = iter;
continue;
}
if (!gtk_tree_model_iter_nth_child(store, &iter, &parent, path->at(i).Integer()))
throw orcaException(vm, "orca.index", "out of index");
parent = iter;
bp->m_iter = iter;
}
return bp;
}
}
else if (type == GUI_ENTRY) {
if (key.String() == "text") {
char* p = gtk_editable_get_chars(GTK_EDITABLE(handle), 0, -1);
return p;
}
}
else if (type == GUI_TEXT) {
if (key.String() == "text") {
GtkTextIter start_iter, end_iter;
GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(handle));
gtk_text_buffer_get_start_iter(buffer, &start_iter);
gtk_text_buffer_get_end_iter(buffer, &end_iter);
char* p = gtk_text_buffer_get_text(buffer, &start_iter, &end_iter, FALSE);
return p;
}
}
return NIL;
}
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;
}
/* callbacks */
static void
gmdb_sql_write_rslt_cb(GtkWidget *w, GladeXML *xml)
{
gchar *file_path;
GladeXML *sql_xml;
GtkWidget *filesel, *dlg;
FILE *outfile;
int i;
int need_headers = 0;
int need_quote = 0;
gchar delimiter[11];
gchar quotechar;
gchar lineterm[5];
gchar *str, *buf;
int rows=0, n_columns;
GtkWidget *treeview;
GtkTreeViewColumn *col;
GList *glist;
GtkTreeStore *store;
GtkTreeIter iter;
GValue value = { 0, };
filesel = glade_xml_get_widget (xml, "export_dialog");
sql_xml = g_object_get_data(G_OBJECT(filesel), "sql_xml");
printf("sql_xml %lu\n",sql_xml);
gmdb_export_get_delimiter(xml, delimiter, 10);
gmdb_export_get_lineterm(xml, lineterm, 5);
need_quote = gmdb_export_get_quote(xml);
quotechar = gmdb_export_get_quotechar(xml);
need_headers = gmdb_export_get_headers(xml);
file_path = gmdb_export_get_filepath(xml);
if ((outfile=fopen(file_path, "w"))==NULL) {
dlg = gtk_message_dialog_new (GTK_WINDOW (gtk_widget_get_toplevel (w)),
GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_WARNING, GTK_BUTTONS_CLOSE,
_("Unable to open file."));
gtk_dialog_run (GTK_DIALOG (dlg));
gtk_widget_destroy (dlg);
return;
}
treeview = glade_xml_get_widget (sql_xml, "sql_results");
glist = gtk_tree_view_get_columns(GTK_TREE_VIEW(treeview));
i = 0;
if (need_headers) {
while (col = g_list_nth_data(glist, i)) {
gchar *title;
if (i>0) fputs(delimiter, outfile);
title = g_strdup(gtk_tree_view_column_get_title(col));
gmdb_print_quote(outfile, need_quote, quotechar,
delimiter, title);
fputs(title, outfile);
gmdb_print_quote(outfile, need_quote, quotechar,
delimiter, title);
g_free(title);
i++;
}
fputs(lineterm, outfile);
g_list_free(glist);
}
store = (GtkTreeStore *) gtk_tree_view_get_model(GTK_TREE_VIEW(treeview));
gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store), &iter);
rows=0;
g_value_init (&value, G_TYPE_STRING);
do {
rows++;
n_columns = gtk_tree_model_get_n_columns(GTK_TREE_MODEL(store));
for (i=0; i < n_columns; i++) {
if (i>0) fputs(delimiter, outfile);
gtk_tree_model_get_value(GTK_TREE_MODEL(store),
&iter, i, &value);
str = (gchar *) g_value_get_string(&value);
gmdb_print_quote(outfile, need_quote, quotechar, delimiter, str);
fputs(str, outfile);
gmdb_print_quote(outfile, need_quote, quotechar, delimiter, str);
g_value_unset(&value);
}
fputs(lineterm, outfile);
} while (gtk_tree_model_iter_next(GTK_TREE_MODEL(store), &iter));
fclose(outfile);
gtk_widget_destroy(filesel);
dlg = gtk_message_dialog_new (GTK_WINDOW (gtk_widget_get_toplevel (w)),
GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_WARNING, GTK_BUTTONS_CLOSE,
_("%d rows successfully exported."), rows);
gtk_dialog_run (GTK_DIALOG (dlg));
gtk_widget_destroy (dlg);
}
/**
* gconf_bridge_bind_string_list_store
* @bridge: A #GConfBridge
* @key: A GConf key to be bound
* @list_store: A #GtkListStore
*
* On calling this function single string column #GtkListStore @list_store
* will be kept synchronized with the GConf string list value pointed to by
* @key. On calling this function @list_store will be populated with the
* strings specified by the value of @key.
*
* Return value: The ID of the new binding.
**/
guint
gconf_bridge_bind_string_list_store (GConfBridge *bridge,
const char *key,
GtkListStore *list_store)
{
GtkTreeModel *tree_model;
gboolean have_one_column, is_string_column;
ListStoreBinding *binding;
GConfValue *val;
g_return_val_if_fail (bridge != NULL, 0);
g_return_val_if_fail (key != NULL, 0);
g_return_val_if_fail (GTK_IS_LIST_STORE (list_store), 0);
/* Check list store suitability */
tree_model = GTK_TREE_MODEL (list_store);
have_one_column = (gtk_tree_model_get_n_columns (tree_model) == 1);
is_string_column = (gtk_tree_model_get_column_type
(tree_model, 0) == G_TYPE_STRING);
if (G_UNLIKELY (!have_one_column || !is_string_column)) {
g_warning ("gconf_bridge_bind_string_list_store: Only "
"GtkListStores with exactly one string column are "
"supported.");
return 0;
}
/* Create new binding. */
binding = g_new (ListStoreBinding, 1);
binding->type = BINDING_LIST_STORE;
binding->id = new_id ();
binding->key = g_strdup (key);
binding->val_changes = NULL;
binding->list_store = list_store;
binding->sync_idle_id = 0;
/* Watch GConf key */
binding->val_notify_id =
gconf_client_notify_add (bridge->client, key,
list_store_binding_pref_changed,
binding, NULL, NULL);
/* Connect to ListStore change notifications */
binding->row_inserted_id =
g_signal_connect_swapped (list_store, "row-inserted",
G_CALLBACK
(list_store_binding_store_changed_cb),
binding);
binding->row_changed_id =
g_signal_connect_swapped (list_store, "row-inserted",
G_CALLBACK
(list_store_binding_store_changed_cb),
binding);
binding->row_deleted_id =
g_signal_connect_swapped (list_store, "row-inserted",
G_CALLBACK
(list_store_binding_store_changed_cb),
binding);
binding->rows_reordered_id =
g_signal_connect_swapped (list_store, "row-inserted",
G_CALLBACK
(list_store_binding_store_changed_cb),
binding);
/* Sync object to value from GConf, if set */
val = gconf_client_get (bridge->client, key, NULL);
if (val) {
list_store_binding_sync_pref_to_store (binding, val);
gconf_value_free (val);
}
/* Handle case where watched object gets destroyed */
g_object_weak_ref (G_OBJECT (list_store),
list_store_binding_store_destroyed, binding);
/* Insert binding */
g_hash_table_insert (bridge->bindings,
GUINT_TO_POINTER (binding->id), binding);
/* Done */
return binding->id;
}
static Py_ssize_t
pygtk_tree_model_row_length(PyGtkTreeModelRow *self)
{
return gtk_tree_model_get_n_columns(self->model);
}
static gint
gsslrtma_get_n_columns(GtkTreeModel *tree_model)
{
return gtk_tree_model_get_n_columns(GTK_TREE_MODEL(GNC_SX_SLR_TREE_MODEL_ADAPTER(tree_model)->real));
}
static gboolean
on_data_view_edited( PgmDataView *view, gint row, gint column, gchar *new_text, gpointer data )
{
PgmTableView *table_view = PGM_TABLE_VIEW( data );
GtkTreePath *path;
GtkTreeIter iter;
GValue value = {0};
GValue tmp_value = {0};
/*gchar *text;*/
gint col;
gchar *column_name;
GString *query_str;
gboolean need_and = FALSE;
PgmQuery *query;
GType column_type;
/*if( new_text[ 0 ] == 0 )
return FALSE;*/
g_value_init( &tmp_value, G_TYPE_STRING );
path = gtk_tree_path_new();
gtk_tree_path_append_index( path, row );
gtk_tree_model_get_iter( table_view->data_store, &iter, path );
gtk_tree_model_get_value( table_view->data_store, &iter, column, &value );
g_value_transform( &value, &tmp_value );
/*text = g_strdup_value_contents( &value );*/
if( g_strcmp0( g_value_get_string( &tmp_value ), new_text ) == 0 )
{
/*g_free( text );*/
return FALSE;
}
column_name = pgm_data_store_get_column_title( PGM_DATA_STORE( table_view->data_store ), column );
column_type = gtk_tree_model_get_column_type( table_view->data_store, column );
query_str = g_string_new( NULL );
if( pgm_table_view_is_string_type( column_type ) && new_text[ 0 ] != 0 )
{
g_string_printf( query_str, "update %s.%s set %s = '%s' where ",
table_view->schema_name,
table_view->table_name,
column_name,
new_text );
}
else
{
g_string_printf( query_str, "update %s.%s set %s = %s where ",
table_view->schema_name,
table_view->table_name,
column_name,
new_text && new_text[0] != 0 ? new_text : "null" );
}
for( col = 0; col < gtk_tree_model_get_n_columns( table_view->data_store ); col++ )
{
GValue tmp_val = {0};
GValue tmp_str_val = {0};
const gchar *tmp_val_str;
/*if( col == column )
continue;*/
if( need_and )
g_string_append( query_str, " and " );
g_value_init( &tmp_str_val, G_TYPE_STRING );
gtk_tree_model_get_value( table_view->data_store, &iter, col, &tmp_val );
/*tmp_val_str = g_strdup_value_contents( &tmp_val );*/
g_value_transform( &tmp_val, &tmp_str_val );
tmp_val_str = g_value_get_string( &tmp_str_val );
column_name = pgm_data_store_get_column_title( PGM_DATA_STORE( table_view->data_store ), col );
g_string_append( query_str, column_name );
column_type = gtk_tree_model_get_column_type( table_view->data_store, col );
if( g_strcmp0( tmp_val_str, "#<!-NULL->#" ) == 0 )
{
g_string_append( query_str, " is null " );
}
else
{
g_string_append( query_str, " = " );
if( pgm_table_view_is_string_type( column_type ) )
g_string_append( query_str, "'" );
g_string_append( query_str, tmp_val_str );
if( pgm_table_view_is_string_type( column_type ) )
g_string_append( query_str, "'" );
}
need_and = TRUE;
/*g_free( tmp_val_str );*/
}
g_debug( "update query = %s", query_str->str );
query = pgm_query_new( PGM_DATA_STORE( table_view->data_store )->query->database );
pgm_query_exec( query, "%s", query_str->str );
g_string_free( query_str, TRUE );
gtk_tree_path_free( path );
/*g_free( text );*/
pgm_data_store_update( PGM_DATA_STORE( table_view->data_store ) );
/*pgm_query_reexec( table_view->query );*/
return TRUE;
}
static GtkWidget *
attribute_editor (GObject *object,
GParamSpec *spec,
GtkInspectorPropEditor *editor)
{
gpointer layout;
GtkCellArea *area;
GtkTreeModel *model = NULL;
gint col = -1;
GtkWidget *label;
GtkWidget *button;
GtkWidget *vbox;
GtkWidget *box;
GtkWidget *combo;
gchar *text;
gint i;
gboolean sensitive;
GtkCellRenderer *renderer;
GtkListStore *store;
GtkTreeIter iter;
layout = g_object_get_data (object, "gtk-inspector-cell-layout");
if (GTK_IS_CELL_LAYOUT (layout))
{
area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (layout));
col = gtk_cell_area_attribute_get_column (area,
GTK_CELL_RENDERER (object),
editor->priv->name);
model = gtk_cell_layout_get_model (GTK_CELL_LAYOUT (layout));
}
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
label = gtk_label_new (_("Attribute mapping"));
gtk_widget_set_margin_top (label, 10);
gtk_container_add (GTK_CONTAINER (vbox), label);
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
gtk_container_add (GTK_CONTAINER (box), gtk_label_new (_("Model:")));
text = g_strdup_printf (_("%p (%s)"), model, g_type_name (G_TYPE_FROM_INSTANCE (model)));
gtk_container_add (GTK_CONTAINER (box), gtk_label_new (text));
g_free (text);
button = gtk_button_new_with_label (_("Properties"));
g_object_set_data (G_OBJECT (button), "model", model);
g_signal_connect (button, "clicked", G_CALLBACK (model_properties), editor);
gtk_container_add (GTK_CONTAINER (box), button);
gtk_container_add (GTK_CONTAINER (vbox), box);
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
gtk_container_add (GTK_CONTAINER (box), gtk_label_new (_("Column:")));
store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_BOOLEAN);
combo = gtk_combo_box_new_with_model (GTK_TREE_MODEL (store));
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), renderer, FALSE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo), renderer,
"text", 0,
"sensitive", 1,
NULL);
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter, 0, _("None"), 1, TRUE, -1);
for (i = 0; i < gtk_tree_model_get_n_columns (model); i++)
{
text = g_strdup_printf ("%d", i);
sensitive = g_value_type_transformable (gtk_tree_model_get_column_type (model, i),
spec->value_type);
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter, 0, text, 1, sensitive, -1);
g_free (text);
}
gtk_combo_box_set_active (GTK_COMBO_BOX (combo), col + 1);
attribute_mapping_changed (GTK_COMBO_BOX (combo), editor);
g_signal_connect (combo, "changed",
G_CALLBACK (attribute_mapping_changed), editor);
gtk_container_add (GTK_CONTAINER (box), combo);
gtk_container_add (GTK_CONTAINER (vbox), box);
gtk_widget_show_all (vbox);
return vbox;
}
static G_CONST_RETURN gchar*
gail_item_get_name (AtkObject *obj)
{
G_CONST_RETURN gchar* name;
g_return_val_if_fail (GAIL_IS_ITEM (obj), NULL);
name = ATK_OBJECT_CLASS (parent_class)->get_name (obj);
if (name == NULL)
{
/*
* Get the label child
*/
GtkWidget *widget;
GtkWidget *label;
widget = GTK_ACCESSIBLE (obj)->widget;
if (widget == NULL)
/*
* State is defunct
*/
return NULL;
label = get_label_from_container (widget);
if (GTK_IS_LABEL (label))
return gtk_label_get_text (GTK_LABEL(label));
/*
* If we have a menu item in a menu attached to a GtkOptionMenu
* the label of the selected item is detached from the menu item
*/
else if (GTK_IS_MENU_ITEM (widget))
{
GtkWidget *parent;
GtkWidget *attach;
GList *list;
AtkObject *parent_obj;
gint index;
parent = gtk_widget_get_parent (widget);
if (GTK_IS_MENU (parent))
{
attach = gtk_menu_get_attach_widget (GTK_MENU (parent));
if (GTK_IS_OPTION_MENU (attach))
{
label = get_label_from_container (attach);
if (GTK_IS_LABEL (label))
return gtk_label_get_text (GTK_LABEL(label));
}
list = gtk_container_get_children (GTK_CONTAINER (parent));
index = g_list_index (list, widget);
if (index < 0 || index > g_list_length (list))
{
g_list_free (list);
return NULL;
}
g_list_free (list);
parent_obj = atk_object_get_parent (gtk_widget_get_accessible (parent));
if (GTK_IS_ACCESSIBLE (parent_obj))
{
parent = GTK_ACCESSIBLE (parent_obj)->widget;
if (GTK_IS_COMBO_BOX (parent))
{
GtkTreeModel *model;
GtkTreeIter iter;
GailItem *item;
gint n_columns, i;
model = gtk_combo_box_get_model (GTK_COMBO_BOX (parent));
item = GAIL_ITEM (obj);
if (gtk_tree_model_iter_nth_child (model, &iter, NULL, index))
{
n_columns = gtk_tree_model_get_n_columns (model);
for (i = 0; i < n_columns; i++)
{
GValue value = { 0, };
gtk_tree_model_get_value (model, &iter, i, &value);
if (G_VALUE_HOLDS_STRING (&value))
{
g_free (item->text);
item->text = (gchar *) g_value_dup_string (&value);
g_value_unset (&value);
break;
}
}
}
name = item->text;
}
}
}
}
}
return name;
}
///startet die Umwandlung/sortierung von odt zu pdf
void button_work_clicked(GtkWidget *widget, gpointer data){
GError *error=NULL;
GPtrArray *unoconv_argv=NULL;
GPid unoconv_pid=0;
//prüfen ob überhaupt Daten im Model verfügbar sind
if (!gtk_tree_model_get_n_columns(gtk_tree_view_get_model(gui_get_gtk_tree_viewer()))){
return;
}
//tmp-Ordner anlegen
gchar *tmp = g_dir_make_tmp("odt2pdf-gtk_XXXXXX",&error);
if (error!=NULL){
g_warning("%s",error->message);
g_error_free(error);
error = NULL;
}
//temp_verzeichnis verfügbar machen
temp_dir_save(g_strdup(tmp));
//DEBUG
g_print("%s\n",temp_dir_get());
//Pfad für unoconv erstellen...
unoconv_argv = g_ptr_array_new ();
//function zum aufräumen übergeben
g_ptr_array_set_free_func(unoconv_argv,ptr_array_clean);
//ptr_array füllen
fill_g_ptr_array(unoconv_argv,"unoconv");
fill_g_ptr_array(unoconv_argv,"-f");
fill_g_ptr_array(unoconv_argv,"pdf");
fill_g_ptr_array(unoconv_argv,"-o");
g_ptr_array_add(unoconv_argv,(gpointer)temp_dir_get_strdub());
//wird für jedes Elemt in der Liststore ausgeführt
gtk_tree_model_foreach(gtk_tree_view_get_model(gui_get_gtk_tree_viewer()),treemodel_ausgabe_unoconv,(gpointer)unoconv_argv);
//abschließende NULL anhängen
g_ptr_array_add(unoconv_argv,(gpointer)NULL);
//startet den Converter und wartet bis er fertig ist
//g_print("%s\n",unoconv_cmd->str);
g_spawn_async_with_pipes (NULL,
(gchar**)unoconv_argv->pdata,
NULL,
G_SPAWN_SEARCH_PATH|G_SPAWN_DO_NOT_REAP_CHILD,
NULL,
NULL,
&unoconv_pid,
NULL,
NULL,
NULL,
&error);
if (error!=NULL){
g_warning("%s",error->message);
g_error_free(error);
error = NULL;
}
//g_child_watch einrichten, um über Programmende informiert zu werden
g_child_watch_add(unoconv_pid,unoconv_child_watch_func,NULL);
//strings freigeben
g_ptr_array_free (unoconv_argv,TRUE);
g_free(tmp);
//Buttons ausgrauen
interface_ausgrauen(FALSE);
}
