Ejemplo n.º 1
0
static void
treestore_torture_recurse (GtkTreeStore *store,
                           GtkTreeIter  *root,
                           gint          depth)
{
  GtkTreeModel *model;
  gint i;
  GtkTreeIter iter;  
  
  model = GTK_TREE_MODEL (store);    

  if (depth > 2)
    return;

  ++depth;

  gtk_tree_store_append (store, &iter, root);
  
  gtk_tree_model_iter_children (model, &iter, root);
  
  i = 0;
  while (i < 100)
    {
      gtk_tree_store_append (store, &iter, root);
      ++i;
    }

  while (gtk_tree_model_iter_children (model, &iter, root))
    gtk_tree_store_remove (store, &iter);

  gtk_tree_store_append (store, &iter, root);

  /* inserts before last node in tree */
  i = 0;
  while (i < 100)
    {
      gtk_tree_store_insert_before (store, &iter, root, &iter);
      ++i;
    }

  /* inserts after the node before the last node */
  i = 0;
  while (i < 100)
    {
      gtk_tree_store_insert_after (store, &iter, root, &iter);
      ++i;
    }

  /* inserts after the last node */
  gtk_tree_store_append (store, &iter, root);
    
  i = 0;
  while (i < 100)
    {
      gtk_tree_store_insert_after (store, &iter, root, &iter);
      ++i;
    }

  /* remove everything again */
  while (gtk_tree_model_iter_children (model, &iter, root))
    gtk_tree_store_remove (store, &iter);


    /* Prepends */
  gtk_tree_store_prepend (store, &iter, root);
    
  i = 0;
  while (i < 100)
    {
      gtk_tree_store_prepend (store, &iter, root);
      ++i;
    }

  /* remove everything again */
  while (gtk_tree_model_iter_children (model, &iter, root))
    gtk_tree_store_remove (store, &iter);

  gtk_tree_store_append (store, &iter, root);
  gtk_tree_store_append (store, &iter, root);
  gtk_tree_store_append (store, &iter, root);
  gtk_tree_store_append (store, &iter, root);

  while (gtk_tree_model_iter_children (model, &iter, root))
    {
      treestore_torture_recurse (store, &iter, depth);
      gtk_tree_store_remove (store, &iter);
    }
}
Ejemplo n.º 2
0
/* 
 * key has been pressed while being in watch tree view
 */
static gboolean on_watch_key_pressed_callback(GtkWidget *widget, GdkEvent  *event, gpointer user_data)
{
	/* handling only Delete button pressing
	 * that means "delete selected rows" */
	int keyval = ((GdkEventKey*)event)->keyval;
	if (keyval != GDK_Delete)
		return FALSE;

	/* get selected rows */
	GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(wtree));
	GList *rows = gtk_tree_selection_get_selected_rows(selection, &wmodel);
	
	/* empty row path */
	GtkTreePath *empty_path = wtree_empty_path();

	/* check whether only empty row was selected */
	if (1 != gtk_tree_selection_count_selected_rows(selection) ||
	    gtk_tree_path_compare((GtkTreePath*)rows->data, empty_path))
	{
		/* path reference to select after deleteing finishes */
		GtkTreeRowReference *reference_to_select = NULL;

		/* get references to the rows */
		GList *references = NULL;
		GList *iter = rows;
		while (iter)
		{
			GtkTreePath *path = (GtkTreePath*)iter->data;

			/* move up paths to the root elements */
			while (gtk_tree_path_get_depth(path) > 1)
				gtk_tree_path_up(path);

			/* add path reference if it's not an empty row*/
			if (gtk_tree_path_compare(path, empty_path))
				references = g_list_append(references, gtk_tree_row_reference_new(wmodel, path));

			iter = iter->next;
		}

		/* iterate through references and remove */
		iter = references;
		while (iter)
		{
			GtkTreeRowReference *reference = (GtkTreeRowReference*)iter->data;
			/* check for valid reference because two or more equal
			refernces could be put in the list if several child items
			of the same node were selected and the path for the
			current reference was already deleted */
			if (gtk_tree_row_reference_valid(reference))
			{
				GtkTreePath *path = gtk_tree_row_reference_get_path(reference);

				if (!reference_to_select)
				{
					/* select upper sibling of the upper
					selected row that has unselected upper sibling */
					GtkTreePath *sibling = gtk_tree_path_copy(path);
					if(gtk_tree_path_prev(sibling))
					{
						if (!gtk_tree_selection_path_is_selected(selection, sibling))
							reference_to_select = gtk_tree_row_reference_new(gtk_tree_view_get_model(GTK_TREE_VIEW(wtree)), sibling);
					}
					else if (gtk_tree_path_next(sibling), gtk_tree_path_compare(path, sibling))
						reference_to_select = gtk_tree_row_reference_new(gtk_tree_view_get_model(GTK_TREE_VIEW(wtree)), sibling);
				}

				/* get iterator */
				GtkTreeIter titer;
				gtk_tree_model_get_iter(wmodel, &titer, path);

				/* remove from the debug session, if it's active */
				if (DBS_STOPPED == debug_state)
				{

					gchar *internal = NULL;
					gtk_tree_model_get (
						wmodel,
						&titer,
						W_INTERNAL, &internal,
						-1);

					active_module->remove_watch(internal);

					g_free(internal);
				}


				gtk_tree_store_remove(wstore, &titer);
			}
			
			iter = iter->next;
		}

		/* if all (with or without empty row) was selected - set empty row
		as a path to be selected after deleting */
		if (!reference_to_select)
			reference_to_select = gtk_tree_row_reference_new (gtk_tree_view_get_model(GTK_TREE_VIEW(wtree)), wtree_empty_path());

		/* set selection */
		gtk_tree_selection_unselect_all(selection);
		GtkTreePath *path_to_select = gtk_tree_row_reference_get_path(reference_to_select);
		gtk_tree_selection_select_path(selection, path_to_select);
		gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(widget), path_to_select, NULL, TRUE, 0.5, 0.5);
		gtk_tree_path_free(path_to_select);	

		/* free references list */
		g_list_foreach (references, (GFunc)gtk_tree_row_reference_free, NULL);
		g_list_free (references);

		config_set_debug_changed();
	}

	/* free rows list */
	g_list_foreach (rows, (GFunc)gtk_tree_path_free, NULL);
	g_list_free (rows);

	return FALSE;
}
Ejemplo n.º 3
0
int TreeViewCategories_CategoryDeleteFromDatabase(TreeViewCategories* c, GtkTreeModel* model, GtkTreeIter* iter, unsigned int row_id)
{
	TreeViewCategoriesDelete tvcd;
	MYSQL_BIND param_delete[1];
	const char* stmt_update_str = "DELETE FROM categories WHERE id = ?;\n";
	int ret = 1;
	GtkTreeIter iter_child;
	
	gchar* Name2;
	
	
	tvcd.stmt = mysql_stmt_init(c->MySQL);
	if (tvcd.stmt == NULL)
	{
		fprintf(stderr, "%s(): mysql_stmt_init() error.\n", __func__);
		ret = 0;
		goto END;
	}
	
	if (mysql_stmt_prepare(tvcd.stmt, stmt_update_str, strlen(stmt_update_str)))
	{
		fprintf(stderr, "%s(): mysql_stmt_prepare() error.\n", __func__);
		ret = 0;
		goto END;
	}
	
	memset(param_delete, 0, sizeof(param_delete));
	
	param_delete[0].buffer_type  = MYSQL_TYPE_LONG;
	param_delete[0].buffer       = (void*) &tvcd.row_id;
	param_delete[0].is_unsigned  = 1;
	
	tvcd.model = model;
	if (mysql_stmt_bind_param(tvcd.stmt, param_delete))
	{
		fprintf(stderr, "%s(): \n", __func__);
		ret = 0;
		goto END;
	}
	
	if (gtk_tree_model_iter_children(model, &iter_child, iter))
	{
		if (!TreeViewCategories_CategoryDeleteFromDatabase2(&tvcd, &iter_child))
		{
			ret = 0;
			goto END;
		}
	}
	
	gtk_tree_model_get(tvcd.model, iter,
			COL_ID_ID,    &tvcd.row_id,
			COL_ID_NAME2, &Name2,
			-1);
	g_print("%s(): %s\n", __func__, Name2);
	g_free(Name2);
	
	if (mysql_stmt_execute(tvcd.stmt))
	{
		fprintf(stderr, "%s(): \n", __func__);
		ret = 0;
		goto END;
	}
	
	gtk_tree_store_remove(GTK_TREE_STORE(tvcd.model), iter);
	
END:
	if (tvcd.stmt != NULL)
		mysql_stmt_close(tvcd.stmt);
	return ret;
}
Ejemplo n.º 4
0
static void cm_delete_item(CookieManagerPage *cmp)
{
    GtkTreeIter iter, iter_store, child;
    GtkTreeModel *model;
    GtkTreePath *path, *last_path;
    GtkTreeSelection *selection;
    GList *rows, *row;
    GList *refs = NULL;
    CookieManagerPagePrivate *priv = cmp->priv;

    selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(priv->treeview));
    rows = gtk_tree_selection_get_selected_rows(selection, &model);
    if (cm_list_length(rows) == 0)
        return;

    last_path = gtk_tree_path_copy(g_list_nth_data(rows, 0));

    /* as paths will change during delete, first create GtkTreeRowReferences for
     * all selected rows */
    row = rows;
    do
    {
        refs = g_list_append(refs, gtk_tree_row_reference_new(model, (GtkTreePath*) (row->data)));
    } while ((row = row->next) != NULL);

    row = refs;
    do
    {
        /* get iter */
        path = gtk_tree_row_reference_get_path((GtkTreeRowReference*) row->data);
        if (path == NULL)
            continue;
        gtk_tree_model_get_iter(model, &iter, path);

        if (gtk_tree_model_iter_has_child(model, &iter))
        {
            while (gtk_tree_model_iter_children(model, &child, &iter))
            {
                cm_delete_cookie(cmp, model, &child);
                cm_store_remove(cmp, &child);
                /* we retrieve again the iter at path because it got invalid by the delete operation */
                gtk_tree_model_get_iter(model, &iter, path);
            }
            /* remove/hide the parent */
            gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(priv->filter),
                    &iter_store, &iter);
            if (gtk_tree_model_iter_has_child(GTK_TREE_MODEL(priv->store), &iter_store))
                gtk_tree_store_set(priv->store, &iter_store, COOKIE_MANAGER_COL_VISIBLE, FALSE, -1);
            else
                cm_store_remove(cmp, &iter);
        }
        else
        {
            GtkTreePath *path_store, *path_model;

            gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(priv->filter),
                    &iter_store, &iter);
            path_store = gtk_tree_model_get_path(GTK_TREE_MODEL(priv->store), &iter_store);
            path_model = gtk_tree_model_get_path(model, &iter);

            cm_delete_cookie(cmp, model, &iter);
            gtk_tree_store_remove(priv->store, &iter_store);

            /* check whether the parent still has children, otherwise delete it */
            if (gtk_tree_path_up(path_store))
            {
                gtk_tree_model_get_iter(GTK_TREE_MODEL(priv->store), &iter_store, path_store);
                if (! gtk_tree_model_iter_has_child(GTK_TREE_MODEL(priv->store), &iter_store))
                    /* remove the empty parent */
                    gtk_tree_store_remove(priv->store, &iter_store);
            }
            /* now for the filter model */
            if (gtk_tree_path_up(path_model))
            {
                gtk_tree_model_get_iter(model, &iter, path_model);
                if (! gtk_tree_model_iter_has_child(model, &iter))
                {
                    gtk_tree_model_filter_convert_iter_to_child_iter(
                        GTK_TREE_MODEL_FILTER(priv->filter), &iter_store, &iter);
                    /* hide the empty parent */
                    gtk_tree_store_set(priv->store, &iter_store, COOKIE_MANAGER_COL_VISIBLE, FALSE, -1);
                }
            }
            gtk_tree_path_free(path_store);
            gtk_tree_path_free(path_model);
        }
        gtk_tree_path_free(path);
    } while ((row = row->next) != NULL);
    cm_free_selection_list(rows, (GFunc) gtk_tree_path_free);
    cm_free_selection_list(refs, (GFunc) gtk_tree_row_reference_free);

    cm_select_path(cmp, model, last_path);
    gtk_tree_path_free(last_path);
}
Ejemplo n.º 5
0
// Create a new bus from the current selection
static void create_bus_button_clicked (GtkWidget *widget, gpointer data)
  {
  int row_type = -1 ;
  bus_layout_D *dialog = (bus_layout_D *)data ;
  GList *llTreeRefs = NULL, *llItr = NULL ;
  GtkTreeStore *ts = GTK_TREE_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (dialog->tview))) ;
  GtkTreeIter itrBus, itr, itrSrc, itrSrcParent ;
  GtkTreeRowReference *refBus = NULL, *refSrcParent = NULL ;
  GtkTreePath *tp = NULL, *tpSrcParent = NULL ;

  llTreeRefs = get_selected_refs (gtk_tree_view_get_selection (GTK_TREE_VIEW (dialog->tview))) ;

  if (NULL == llTreeRefs) return ;

  if (!gtk_tree_model_get_iter (GTK_TREE_MODEL (ts), &itr,
    tp = gtk_tree_row_reference_get_path (llTreeRefs->data)))
    {
    gtk_tree_path_free (tp) ;
    return ;
    }

  gtk_tree_model_get (GTK_TREE_MODEL (ts), &itr, BUS_LAYOUT_MODEL_COLUMN_TYPE, &row_type, -1) ;

  gtk_tree_path_free (tp) ;

  gtk_tree_store_prepend (ts, &itrBus, NULL) ;
  gtk_tree_store_set (ts, &itrBus,
    BUS_LAYOUT_MODEL_COLUMN_ICON, (row_type & ROW_TYPE_INPUT) ? QCAD_STOCK_BUS_INPUT : QCAD_STOCK_BUS_OUTPUT,
    BUS_LAYOUT_MODEL_COLUMN_NAME, _("Untitled Bus"),
    BUS_LAYOUT_MODEL_COLUMN_TYPE, (row_type & ROW_TYPE_INPUT) ? ROW_TYPE_BUS_INPUT : ROW_TYPE_BUS_OUTPUT,
    BUS_LAYOUT_MODEL_COLUMN_INDEX, -1, -1) ;

  refBus = gtk_tree_row_reference_new (GTK_TREE_MODEL (ts), tp = gtk_tree_model_get_path (GTK_TREE_MODEL (ts), &itrBus)) ;
  gtk_tree_path_free (tp) ;

  for (llItr = g_list_last (llTreeRefs) ; llItr != NULL ; llItr = llItr->prev)
    {
    if (gtk_tree_model_get_iter (GTK_TREE_MODEL (ts), &itrBus, tp = gtk_tree_row_reference_get_path (refBus)))
      {
      gtk_tree_path_free (tp) ;

      gtk_tree_store_append (ts, &itr, &itrBus) ;

      if (gtk_tree_model_get_iter (GTK_TREE_MODEL (ts), &itrSrc, tp = gtk_tree_row_reference_get_path (llItr->data)))
        swap_model_iters_contents (GTK_TREE_MODEL (ts), &itrSrc, &itr) ;
      gtk_tree_path_free (tp) ;

      if (gtk_tree_model_get_iter (GTK_TREE_MODEL (ts), &itrSrc, tp = gtk_tree_row_reference_get_path (llItr->data)))
        {
        if (gtk_tree_path_get_depth (tp) > 1)
          {
          if (gtk_tree_path_up (tpSrcParent = gtk_tree_path_copy (tp)))
            refSrcParent = (1 == gtk_tree_model_path_n_children (GTK_TREE_MODEL (ts), tpSrcParent)) ?
              gtk_tree_row_reference_new (GTK_TREE_MODEL (ts), tpSrcParent) : NULL ;

          gtk_tree_path_free (tpSrcParent) ;
          }
        }
      gtk_tree_path_free (tp) ;

      gtk_tree_row_reference_free (llItr->data) ;

      // Remove cell from old location
      gtk_tree_store_remove (ts, &itrSrc) ;

      // The bus that owned the row we just moved has become empty - delete it
      if (NULL != refSrcParent)
        {
        tpSrcParent = gtk_tree_row_reference_get_path (refSrcParent) ;

        if (gtk_tree_model_get_iter (GTK_TREE_MODEL (ts), &itrSrcParent, tpSrcParent))
          gtk_tree_store_remove (ts, &itrSrcParent) ;

        gtk_tree_path_free (tpSrcParent) ;
        gtk_tree_row_reference_free (refSrcParent) ;
        refSrcParent = NULL ;
        }
      }
    else
      gtk_tree_path_free (tp) ;
    }

  gtk_tree_selection_select_path (gtk_tree_view_get_selection (GTK_TREE_VIEW (dialog->tview)), tp = gtk_tree_row_reference_get_path (refBus)) ;

  gtk_tree_path_free (tp) ;
  gtk_tree_row_reference_free (refBus) ;
  g_list_free (llTreeRefs) ;
  }
Ejemplo n.º 6
0
void
nav_tree_refresh_views (GSQLNavigation *navigation,
			GtkTreeView *tv,
			GtkTreeIter *iter)
{
	GSQL_TRACE_FUNC;

	GtkTreeModel *model;
	GtkListStore *details;
	GSQLNavigation *nav = NULL;
	GtkTreeIter child, child_fake, child_last;
	GSQLCursor *cursor;
	GSQLVariable *var;
	GSQLCursorState state;
	GSQLSession *session;
	gchar *name, key[256], *sql = NULL, *realname = NULL, *owner = NULL;
	const gchar *currentdb = NULL;
	gint id, i,n;

	
	model = gtk_tree_view_get_model(tv);
	n = gtk_tree_model_iter_n_children(model, iter);
	
	for (; n>1; n--) {
		gtk_tree_model_iter_children(model, &child, iter);
		gtk_tree_store_remove(GTK_TREE_STORE(model), &child);
	}
	
	gtk_tree_model_iter_children(model, &child_last, iter);
	
	gtk_tree_model_get (model, iter, GSQL_NAV_TREE_REALNAME, &realname,
			    -1);
	
	gtk_tree_model_get (model, iter, GSQL_NAV_TREE_SQL, &sql, -1);
	
	gtk_tree_model_get (model, iter, GSQL_NAV_TREE_OWNER, &owner, -1);
	
	session = gsql_session_get_active ();
	g_return_if_fail (GSQL_IS_SESSION(session));

	currentdb = pgsql_navigation_get_database (navigation, tv, iter);
	GSQL_DEBUG("Database: switching to [%s]", currentdb);
	pgsql_session_switch_database(session, currentdb);
	
	cursor = gsql_cursor_new (session, sql);
	
	state = gsql_cursor_open_with_bind (cursor, FALSE,
					    GSQL_CURSOR_BIND_BY_POS,
					    G_TYPE_STRING, owner,
					    -1);
	var = g_list_nth_data(cursor->var_list,0);
	
	if (state != GSQL_CURSOR_STATE_OPEN) {
		gsql_cursor_close (cursor);
		return;		
	}
	
	i = 0;
	
	while (gsql_cursor_fetch (cursor, 1) > 0) {
		i++;			

		if (var->value_type != G_TYPE_STRING) {
			GSQL_DEBUG ("The name of object should be a string "\
				    "(char *). Is the bug");
			name = N_("Incorrect data");
		} else {
			name = (gchar *) var->value;
			// make a key for a hash of details
			memset (key, 0, 256);
			g_snprintf (key, 255, "%x%s%d%s",
				    session, owner, VIEW_ID, name);
			
			details = gsql_navigation_get_details (navigation,
							       key);
			pgsql_navigation_fill_details (cursor, details);
		}
		
		gtk_tree_store_append (GTK_TREE_STORE(model), &child, iter);
		gtk_tree_store_set (GTK_TREE_STORE(model), &child,
				    GSQL_NAV_TREE_ID,		VIEW_ID,
				    GSQL_NAV_TREE_OWNER,	owner,
				    GSQL_NAV_TREE_IMAGE,GSQL_STOCK_VIEWS,
				    GSQL_NAV_TREE_NAME,		name,
				    GSQL_NAV_TREE_REALNAME, 	name,
				    GSQL_NAV_TREE_ITEM_INFO, 	NULL,
				    GSQL_NAV_TREE_SQL,			NULL,
				    GSQL_NAV_TREE_OBJECT_POPUP,
				    nav_tree_views_popup,
				    GSQL_NAV_TREE_OBJECT_HANDLER, NULL,
				    GSQL_NAV_TREE_EXPAND_HANDLER, NULL,
				    GSQL_NAV_TREE_EVENT_HANDLER, 
				    nav_tree_views_event,
				    GSQL_NAV_TREE_STRUCT, views,
				    GSQL_NAV_TREE_DETAILS, details,
				    GSQL_NAV_TREE_NUM_ITEMS, 
				    G_N_ELEMENTS(views),
				    -1);
		
		gtk_tree_store_append (GTK_TREE_STORE (model), &child_fake, 
				       &child);
		gtk_tree_store_set (GTK_TREE_STORE (model), &child_fake,
				    GSQL_NAV_TREE_ID,		-1,
				    GSQL_NAV_TREE_IMAGE,	NULL,
				    GSQL_NAV_TREE_NAME,	N_("Processing..."),
				    GSQL_NAV_TREE_REALNAME,	NULL,
				    GSQL_NAV_TREE_ITEM_INFO,	NULL,
				    GSQL_NAV_TREE_SQL,		NULL,
				    GSQL_NAV_TREE_OBJECT_POPUP,	NULL,
				    GSQL_NAV_TREE_OBJECT_HANDLER,NULL,
				    GSQL_NAV_TREE_EXPAND_HANDLER,NULL,
				    GSQL_NAV_TREE_EVENT_HANDLER,NULL,
				    GSQL_NAV_TREE_STRUCT,	NULL,
				    GSQL_NAV_TREE_NUM_ITEMS, 	NULL,
				    -1);		
	}
	
	GSQL_DEBUG ("Items fetched: [%d]", i);
	
	if (i > 0) {
		name = g_strdup_printf("%s<span weight='bold'> [%d]</span>", 
				       realname, i);
		gtk_tree_store_set (GTK_TREE_STORE(model), iter,
				    GSQL_NAV_TREE_NAME, 
				    name,
				    -1);
		g_free (name);
	}
	
	gtk_tree_store_remove(GTK_TREE_STORE(model), &child_last);
	
	gsql_cursor_close (cursor);
}
Ejemplo n.º 7
0
/* Callback to remove selected rows */
static void
remove_row (GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data)
{
    gtk_tree_store_remove (GTK_TREE_STORE (model), iter);
}
Ejemplo n.º 8
0
static gboolean
capital_animation (gpointer data)
{
  static gint insert_count = 0;
  GtkTreeModel *model = GTK_TREE_MODEL (data);
  GtkTreePath *path;
  GtkTreeIter iter, parent;

  switch (insert_count % 8)
    {
    case 0:
      gtk_tree_store_insert (GTK_TREE_STORE (model), &iter, NULL, 0);
      gtk_tree_store_set (GTK_TREE_STORE (model), 
			  &iter,
			  0, "Europe", -1);
      break;

    case 1:
      path = gtk_tree_path_new_from_indices (0, -1);
      gtk_tree_model_get_iter (model, &parent, path);
      gtk_tree_path_free (path);
      gtk_tree_store_insert (GTK_TREE_STORE (model), &iter, &parent, 0);
      gtk_tree_store_set (GTK_TREE_STORE (model), 
			  &iter,
			  0, "Berlin", -1);
      break;

    case 2:
      path = gtk_tree_path_new_from_indices (0, -1);
      gtk_tree_model_get_iter (model, &parent, path);
      gtk_tree_path_free (path);
      gtk_tree_store_insert (GTK_TREE_STORE (model), &iter, &parent, 1);
      gtk_tree_store_set (GTK_TREE_STORE (model), 
			  &iter,
			  0, "London", -1);
      break;

    case 3:
      path = gtk_tree_path_new_from_indices (0, -1);
      gtk_tree_model_get_iter (model, &parent, path);
      gtk_tree_path_free (path);
      gtk_tree_store_insert (GTK_TREE_STORE (model), &iter, &parent, 2);
      gtk_tree_store_set (GTK_TREE_STORE (model), 
			  &iter,
			  0, "Paris", -1);
      break;

    case 4:
      path = gtk_tree_path_new_from_indices (0, 2, -1);
      gtk_tree_model_get_iter (model, &iter, path);
      gtk_tree_path_free (path);
      gtk_tree_store_remove (GTK_TREE_STORE (model), &iter);
      break;

    case 5:
      path = gtk_tree_path_new_from_indices (0, 1, -1);
      gtk_tree_model_get_iter (model, &iter, path);
      gtk_tree_path_free (path);
      gtk_tree_store_remove (GTK_TREE_STORE (model), &iter);
      break;

    case 6:
      path = gtk_tree_path_new_from_indices (0, 0, -1);
      gtk_tree_model_get_iter (model, &iter, path);
      gtk_tree_path_free (path);
      gtk_tree_store_remove (GTK_TREE_STORE (model), &iter);
      break;

    case 7:
      path = gtk_tree_path_new_from_indices (0, -1);
      gtk_tree_model_get_iter (model, &iter, path);
      gtk_tree_path_free (path);
      gtk_tree_store_remove (GTK_TREE_STORE (model), &iter);
      break;

    default: ;

    }
  insert_count++;

  return TRUE;
}
Ejemplo n.º 9
0
static void
subtitle_refresh_list_row_ui(
    GtkTreeModel *tm,
    GtkTreeIter *ti,
    GhbValue *subsettings)
{
    GtkTreeIter cti;
    gboolean forced, burned, def;
    char *info_src, *info_src_2;
    char *info_dst, *info_dst_2;


    info_src_2 = NULL;
    info_dst_2 = NULL;

    forced = ghb_dict_get_bool(subsettings, "SubtitleForced");
    burned = ghb_dict_get_bool(subsettings, "SubtitleBurned");
    def = ghb_dict_get_bool(subsettings, "SubtitleDefaultTrack");
    info_src = g_strdup_printf("<small>%s</small>",
        ghb_dict_get_string(subsettings, "SubtitleTrackDescription"));
    if (ghb_dict_get_int(subsettings, "SubtitleSource") == SRTSUB)
    {
        gint offset;
        offset = ghb_dict_get_int(subsettings, "SrtOffset");
        if (offset != 0)
        {
            info_dst_2 = g_strdup_printf("Offset: %dms", offset);
        }
    }

    GString *str = g_string_new("<small>");
    g_string_append_printf(str, "%s ", burned ? "Burned Into Video" :
                                                "Passthrough");
    if (forced)
    {
        g_string_append_printf(str, "(Forced Subtitles Only)");
    }
    if (def)
    {
        g_string_append_printf(str, "(Default)");
    }
    g_string_append_printf(str, "</small>");

    info_dst = g_string_free(str, FALSE);

    gtk_tree_store_set(GTK_TREE_STORE(tm), ti,
        // These are displayed in list
        0, info_src,
        1, "-->",
        2, info_dst,
        3, "hb-edit",
        4, "hb-remove",
        5, 0.5,
        -1);

    if (info_src_2 != NULL || info_dst_2 != NULL)
    {
        if (info_src_2 == NULL)
            info_src_2 = g_strdup("");
        if (info_dst_2 == NULL)
            info_dst_2 = g_strdup("");

        if (!gtk_tree_model_iter_children(tm, &cti, ti))
        {
            gtk_tree_store_append(GTK_TREE_STORE(tm), &cti, ti);
        }
        gtk_tree_store_set(GTK_TREE_STORE(tm), &cti,
            // These are displayed in list
            0, info_src_2,
            2, info_dst_2,
            5, 0.0,
            -1);
    }
    else
    {
        if (gtk_tree_model_iter_children(tm, &cti, ti))
        {
            gtk_tree_store_remove(GTK_TREE_STORE(tm), &cti);
        }
    }

    g_free(info_src);
    g_free(info_src_2);
    g_free(info_dst);
    g_free(info_dst_2);
}
Ejemplo n.º 10
0
gboolean vdtree_populate_path_by_iter(ViewDir *vd, GtkTreeIter *iter, gboolean force, FileData *target_fd)
{
	GtkTreeModel *store;
	GList *list;
	GList *work;
	GList *old;
	time_t current_time;
	GtkTreeIter child;
	NodeData *nd;

	store = gtk_tree_view_get_model(GTK_TREE_VIEW(vd->view));
	gtk_tree_model_get(store, iter, DIR_COLUMN_POINTER, &nd, -1);

	if (!nd) return FALSE;

	current_time = time(NULL);

	if (nd->expanded)
		{
		if (!isdir(nd->fd->path))
			{
			if (vd->click_fd == nd->fd) vd->click_fd = NULL;
			if (vd->drop_fd == nd->fd) vd->drop_fd = NULL;
			gtk_tree_store_remove(GTK_TREE_STORE(store), iter);
			vdtree_node_free(nd);
			return FALSE;
			}
		if (!force && current_time - nd->last_update < 2)
			{
			DEBUG_1("Too frequent update of %s", nd->fd->path);
			return TRUE;
			}
		if (nd->fd->version == nd->version) return TRUE;
		}

	vdtree_busy_push(vd);

	filelist_read(nd->fd, NULL, &list);

	/* when hidden files are not enabled, and the user enters a hidden path,
	 * allow the tree to display that path by specifically inserting the hidden entries
	 */
	if (!options->file_filter.show_hidden_files &&
	    target_fd &&
	    strncmp(nd->fd->path, target_fd->path, strlen(nd->fd->path)) == 0)
		{
		gint n;

		n = strlen(nd->fd->path);
		if (target_fd->path[n] == G_DIR_SEPARATOR && target_fd->path[n+1] == '.')
			{
			gchar *name8;
			struct stat sbuf;

			n++;

			while (target_fd->path[n] != '\0' && target_fd->path[n] != G_DIR_SEPARATOR) n++;
			name8 = g_strndup(target_fd->path, n);

			if (stat_utf8(name8, &sbuf))
				{
				list = g_list_prepend(list, file_data_new_simple(name8));
				}

			g_free(name8);
			}
		}

	old = NULL;
	if (gtk_tree_model_iter_children(store, &child, iter))
		{
		do	{
			NodeData *cnd;

			gtk_tree_model_get(store, &child, DIR_COLUMN_POINTER, &cnd, -1);
			old = g_list_prepend(old, cnd);
			} while (gtk_tree_model_iter_next(store, &child));
		}

	work = list;
	while (work)
		{
		FileData *fd;

		fd = work->data;
		work = work->next;

		if (strcmp(fd->name, ".") == 0 || strcmp(fd->name, "..") == 0)
			{
			file_data_unref(fd);
			}
		else
			{
			NodeData *cnd;

			cnd = vdtree_find_iter_by_fd(vd, iter, fd, &child);
			if (cnd)
				{
				if (cnd->expanded && cnd->version != fd->version)
					{
					vdtree_populate_path_by_iter(vd, &child, FALSE, target_fd);
					}

				gtk_tree_store_set(GTK_TREE_STORE(store), &child, DIR_COLUMN_NAME, fd->name, -1);
				cnd->version = fd->version;
				old = g_list_remove(old, cnd);
				file_data_unref(fd);
				}
			else
				{
				vdtree_add_by_data(vd, fd, iter);
				}
			}
		}

	work = old;
	while (work)
		{
		NodeData *cnd = work->data;
		work = work->next;

		if (vd->click_fd == cnd->fd) vd->click_fd = NULL;
		if (vd->drop_fd == cnd->fd) vd->drop_fd = NULL;

		if (vdtree_find_iter_by_data(vd, iter, cnd, &child))
			{
			gtk_tree_store_remove(GTK_TREE_STORE(store), &child);
			vdtree_node_free(cnd);
			}
		}

	g_list_free(old);
	g_list_free(list);

	vdtree_busy_pop(vd);

	nd->expanded = TRUE;
	nd->last_update = current_time;

	return TRUE;
}
Ejemplo n.º 11
0
void
nav_tree_refresh_indexes (GSQLNavigation *navigation,
						 GtkTreeView *tv,
						 GtkTreeIter *iter)
{
	GSQL_TRACE_FUNC;

	GtkTreeModel *model;
	GtkListStore *detail;
	GSQLNavigation *nav = NULL;
	gchar			*sql = NULL;
	gchar			*realname = NULL;
	gchar			*owner = NULL;
	gint 		id;
	gint		i,n;
	GtkTreeIter child;
	GtkTreeIter parent;
	GtkTreeIter child_fake;
	GtkTreeIter	child_last;
	GSQLCursor *cursor;
	GSQLVariable *var, *var_t;
	GSQLSession *session;
	GSQLWorkspace *workspace;
	GSQLCursorState state;
	GtkListStore *details;
	gchar *name;
	gchar key[256];
	gchar *stock = NULL;
	gchar *tbl = "%";
	gchar *parent_realname = NULL;
	
	model = gtk_tree_view_get_model(tv);
	n = gtk_tree_model_iter_n_children(model, iter);
	
	for (; n>1; n--)
	{
		gtk_tree_model_iter_children (model, &child, iter);
		gtk_tree_store_remove (GTK_TREE_STORE(model), &child);
	}
	
	gtk_tree_model_iter_children(model, &child_last, iter);
	
	gtk_tree_model_get (model, iter,  
						GSQL_NAV_TREE_REALNAME, 
						&realname, -1);
	gtk_tree_model_get (model, iter,  
						GSQL_NAV_TREE_SQL, 
						&sql, -1);
	g_return_if_fail (sql != NULL);
	
	gtk_tree_model_get (model, iter,  
						GSQL_NAV_TREE_OWNER, 
						&owner, -1);
	
	session = gsql_session_get_active ();
	
	// get parent iter. if this iter are TABLE_ID then
	// we looking for table's constraints only.
	gtk_tree_model_iter_parent (model, &parent, iter);
	
	gtk_tree_model_get (model, &parent,  
						GSQL_NAV_TREE_ID, 
						&id, -1);
	
	gtk_tree_model_get (model, &parent,  
						GSQL_NAV_TREE_REALNAME, 
						&parent_realname, -1);

	switch (id)
	{
		case TABLE_ID:
			if (parent_realname != NULL)
			{
				tbl = parent_realname;
				sql = (gchar *) sql_oracle_table_indexes;
			}
			
			break;
			
		case CLUSTER_ID:
		
			tbl = parent_realname;
			
			if (strncmp (owner, gsql_session_get_username (session), 64))
				sql = (gchar *) sql_oracle_cluster_indexes;			
			
			break;
			
		default:
		
			if (strncmp (owner, gsql_session_get_username (session), 64))
				sql = (gchar *) sql_oracle_indexes;
			
	}

	GSQL_DEBUG ("realname:[%s]    sql:[%s]   owner:[%s]", realname, sql, owner);
	
	cursor = gsql_cursor_new (session, sql);
	state = gsql_cursor_open_with_bind (cursor,
										FALSE,
										GSQL_CURSOR_BIND_BY_NAME,
										G_TYPE_STRING, ":owner",
										G_TYPE_STRING, owner,
										G_TYPE_STRING, ":name",
										G_TYPE_STRING, tbl,
										-1);
	
	var = g_list_nth_data(cursor->var_list,0);
	
	if (state != GSQL_CURSOR_STATE_OPEN)
	{
		gsql_cursor_close (cursor);
		return;		
	}
	
	i = 0;
	
	while (gsql_cursor_fetch (cursor, 1) > 0)
	{
		i++;
		
		if (var->value_type != G_TYPE_STRING)
		{
			GSQL_DEBUG ("The name of object should be a string (char *). Is the bug");
			name = N_("Incorrect data");
		} else {
			name = (gchar *) var->value;
			// make a key for a hash of details
			memset (key, 0, 256);
			g_snprintf (key, 255, "%x%s%d%d%s",
						session, owner, id, INDEX_ID, name);
			
			details = gsql_navigation_get_details (navigation, key);
			oracle_navigation_fill_details (cursor, details);
		}
		
		gtk_tree_store_append (GTK_TREE_STORE(model), &child, iter);
		gtk_tree_store_set (GTK_TREE_STORE(model), &child,
					GSQL_NAV_TREE_ID,			INDEX_ID,
					GSQL_NAV_TREE_OWNER,		owner,
					GSQL_NAV_TREE_IMAGE,		GSQL_STOCK_INDEXES,
					GSQL_NAV_TREE_NAME,			name,
					GSQL_NAV_TREE_REALNAME, 	name,
					GSQL_NAV_TREE_ITEM_INFO, 	NULL,
					GSQL_NAV_TREE_SQL,			NULL,
					GSQL_NAV_TREE_OBJECT_POPUP, NULL,
					GSQL_NAV_TREE_OBJECT_HANDLER, NULL,
					GSQL_NAV_TREE_EXPAND_HANDLER, NULL,
					GSQL_NAV_TREE_EVENT_HANDLER, NULL,
					GSQL_NAV_TREE_STRUCT, indexes,
					GSQL_NAV_TREE_DETAILS, details,
					GSQL_NAV_TREE_NUM_ITEMS, G_N_ELEMENTS(indexes),
					-1);
	
		gtk_tree_store_append (GTK_TREE_STORE (model), &child_fake, &child);
		gtk_tree_store_set (GTK_TREE_STORE (model), &child_fake,
				GSQL_NAV_TREE_ID,				-1,
				GSQL_NAV_TREE_IMAGE,			NULL,
				GSQL_NAV_TREE_NAME,				N_("Processing..."),
				GSQL_NAV_TREE_REALNAME,			NULL,
				GSQL_NAV_TREE_ITEM_INFO,		NULL,
				GSQL_NAV_TREE_SQL,				NULL,
				GSQL_NAV_TREE_OBJECT_POPUP,		NULL,
				GSQL_NAV_TREE_OBJECT_HANDLER,	NULL,
				GSQL_NAV_TREE_EXPAND_HANDLER,	NULL,
				GSQL_NAV_TREE_EVENT_HANDLER,	NULL,
				GSQL_NAV_TREE_STRUCT,			NULL,
				GSQL_NAV_TREE_NUM_ITEMS, 		NULL,
				-1);
	}
	GSQL_DEBUG ("Items fetched: [%d]", i);
	
	if (i > 0)
	{
		name = g_strdup_printf("%s<span weight='bold'> [%d]</span>", 
												realname, i);
		gtk_tree_store_set (GTK_TREE_STORE(model), iter,
							GSQL_NAV_TREE_NAME, 
							name,
							-1);
		g_free (name);
	}
	
	gtk_tree_store_remove(GTK_TREE_STORE(model), &child_last);
	
	gsql_cursor_close (cursor);

}
Ejemplo n.º 12
0
static void
ref_count_row_ref (void)
{
  GtkTreeIter grandparent1, grandparent2, parent1, parent2;
  GtkTreeIter iter_parent1, iter_parent2;
  GtkTreeModel *model;
  GtkTreeModelRefCount *ref_model;
  GtkTreeModel *sort_model;
  GtkWidget *tree_view;
  GtkTreePath *path;
  GtkTreeRowReference *row_ref;

  model = gtk_tree_model_ref_count_new ();
  ref_model = GTK_TREE_MODEL_REF_COUNT (model);

  /* + grandparent1
   * + grandparent2
   *   + parent1
   *     + iter_parent1
   *   + parent2
   *     + iter_parent2
   *     + iter_parent2
   */

  gtk_tree_store_append (GTK_TREE_STORE (model), &grandparent1, NULL);
  gtk_tree_store_append (GTK_TREE_STORE (model), &grandparent2, NULL);
  gtk_tree_store_append (GTK_TREE_STORE (model), &parent1, &grandparent2);
  gtk_tree_store_append (GTK_TREE_STORE (model), &iter_parent1, &parent1);
  gtk_tree_store_append (GTK_TREE_STORE (model), &parent2, &grandparent2);
  gtk_tree_store_append (GTK_TREE_STORE (model), &iter_parent2, &parent2);
  gtk_tree_store_append (GTK_TREE_STORE (model), &iter_parent2, &parent2);

  sort_model = gtk_tree_model_sort_new_with_model (model);
  tree_view = gtk_tree_view_new_with_model (sort_model);

  path = gtk_tree_path_new_from_indices (1, 1, 1, -1);
  row_ref = gtk_tree_row_reference_new (sort_model, path);
  gtk_tree_path_free (path);

  assert_node_ref_count (ref_model, &grandparent1, 1);
  /* Referenced because the node is visible, its child level is built
   * and referenced by the row ref.
   */
  assert_node_ref_count (ref_model, &grandparent2, 3);
  assert_node_ref_count (ref_model, &parent1, 0);
  /* Referenced by the row ref and because its child level is built. */
  assert_node_ref_count (ref_model, &parent2, 2);
  assert_node_ref_count (ref_model, &iter_parent1, 0);
  assert_node_ref_count (ref_model, &iter_parent2, 1);

  gtk_tree_row_reference_free (row_ref);

  assert_node_ref_count (ref_model, &grandparent1, 1);
  assert_node_ref_count (ref_model, &grandparent2, 2);
  assert_node_ref_count (ref_model, &parent1, 0);
  assert_node_ref_count (ref_model, &parent2, 1);
  assert_node_ref_count (ref_model, &iter_parent1, 0);
  assert_node_ref_count (ref_model, &iter_parent2, 0);

  path = gtk_tree_path_new_from_indices (1, 1, 1, -1);
  row_ref = gtk_tree_row_reference_new (sort_model, path);
  gtk_tree_path_free (path);

  assert_node_ref_count (ref_model, &grandparent1, 1);
  /* Referenced because the node is visible, its child level is built
   * and referenced by the row ref.
   */
  assert_node_ref_count (ref_model, &grandparent2, 3);
  assert_node_ref_count (ref_model, &parent1, 0);
  /* Referenced by the row ref and because its child level is built. */
  assert_node_ref_count (ref_model, &parent2, 2);
  assert_node_ref_count (ref_model, &iter_parent1, 0);
  assert_node_ref_count (ref_model, &iter_parent2, 1);

  gtk_tree_store_remove (GTK_TREE_STORE (model), &parent2);

  assert_node_ref_count (ref_model, &grandparent1, 1);
  assert_node_ref_count (ref_model, &grandparent2, 1);
  assert_node_ref_count (ref_model, &parent1, 0);
  assert_node_ref_count (ref_model, &iter_parent1, 0);

  gtk_tree_row_reference_free (row_ref);

  assert_node_ref_count (ref_model, &grandparent1, 1);
  assert_node_ref_count (ref_model, &grandparent2, 1);
  assert_node_ref_count (ref_model, &parent1, 0);
  assert_node_ref_count (ref_model, &iter_parent1, 0);

  gtk_widget_destroy (tree_view);
  g_object_unref (sort_model);

  assert_entire_model_unreferenced (ref_model);

  g_object_unref (ref_model);
}
Ejemplo n.º 13
0
static void
ref_count_delete_row (void)
{
  GtkTreeIter grandparent1, grandparent2, parent1, parent2;
  GtkTreeIter iter_parent1, iter_parent2;
  GtkTreeModel *model;
  GtkTreeModelRefCount *ref_model;
  GtkTreeModel *sort_model;
  GtkTreePath *path;
  GtkWidget *tree_view;

  model = gtk_tree_model_ref_count_new ();
  ref_model = GTK_TREE_MODEL_REF_COUNT (model);

  /* + grandparent1
   * + grandparent2
   *   + parent1
   *     + iter_parent1
   *   + parent2
   *     + iter_parent2
   *     + iter_parent2
   */

  gtk_tree_store_append (GTK_TREE_STORE (model), &grandparent1, NULL);
  gtk_tree_store_append (GTK_TREE_STORE (model), &grandparent2, NULL);
  gtk_tree_store_append (GTK_TREE_STORE (model), &parent1, &grandparent2);
  gtk_tree_store_append (GTK_TREE_STORE (model), &iter_parent1, &parent1);
  gtk_tree_store_append (GTK_TREE_STORE (model), &parent2, &grandparent2);
  gtk_tree_store_append (GTK_TREE_STORE (model), &iter_parent2, &parent2);
  gtk_tree_store_append (GTK_TREE_STORE (model), &iter_parent2, &parent2);

  assert_entire_model_unreferenced (ref_model);

  sort_model = gtk_tree_model_sort_new_with_model (model);
  tree_view = gtk_tree_view_new_with_model (sort_model);

  assert_root_level_referenced (ref_model, 1);
  assert_node_ref_count (ref_model, &parent1, 0);
  assert_node_ref_count (ref_model, &parent2, 0);
  assert_level_unreferenced (ref_model, &parent1);
  assert_level_unreferenced (ref_model, &parent2);

  path = gtk_tree_path_new_from_indices (1, -1);
  gtk_tree_view_expand_row (GTK_TREE_VIEW (tree_view), path, TRUE);
  gtk_tree_path_free (path);

  assert_node_ref_count (ref_model, &grandparent1, 1);
  assert_node_ref_count (ref_model, &grandparent2, 2);
  assert_node_ref_count (ref_model, &parent1, 2);
  assert_node_ref_count (ref_model, &parent2, 2);
  assert_node_ref_count (ref_model, &iter_parent1, 1);
  assert_node_ref_count (ref_model, &iter_parent2, 1);

  gtk_tree_store_remove (GTK_TREE_STORE (model), &iter_parent2);

  assert_node_ref_count (ref_model, &grandparent1, 1);
  assert_node_ref_count (ref_model, &grandparent2, 2);
  assert_node_ref_count (ref_model, &parent1, 2);
  assert_level_referenced (ref_model, 1, &parent1);
  assert_node_ref_count (ref_model, &parent2, 2);
  assert_level_referenced (ref_model, 1, &parent2);

  gtk_tree_store_remove (GTK_TREE_STORE (model), &parent1);

  assert_node_ref_count (ref_model, &grandparent1, 1);
  assert_node_ref_count (ref_model, &grandparent2, 2);
  assert_node_ref_count (ref_model, &parent2, 2);
  assert_level_referenced (ref_model, 1, &parent2);

  gtk_tree_store_remove (GTK_TREE_STORE (model), &grandparent2);

  assert_node_ref_count (ref_model, &grandparent1, 1);

  gtk_tree_model_sort_clear_cache (GTK_TREE_MODEL_SORT (sort_model));

  assert_node_ref_count (ref_model, &grandparent1, 1);

  gtk_widget_destroy (tree_view);

  assert_entire_model_unreferenced (ref_model);

  g_object_unref (sort_model);
  g_object_unref (ref_model);
}
Ejemplo n.º 14
0
void
nav_tree_refresh_objects (GSQLNavigation *navigation,
						 GtkTreeView *tv,
						 GtkTreeIter *iter)
{
	GSQL_TRACE_FUNC;
	GtkTreeModel *model;
	GtkTreeIter child;
	GtkTreeIter child_fake;
	GtkTreeIter	child_last;
	gint n, id, o_id;
	gchar	   key[256];
	gchar		*sql = NULL;
	gchar		*realname = NULL;
	gchar		*name = NULL;
	gchar		*owner = NULL;
	GSQLCursor * cursor;
	GSQLCursorState state;
	GSQLSession *session;
	GSQLWorkspace *workspace;
	GSQLVariable *var;
	GtkListStore *details;
	void  *s_elements;
	guint n_elements;
	gchar *stock;

	model = gtk_tree_view_get_model(tv);
	n = gtk_tree_model_iter_n_children(model, iter);
	
	for (; n>1; n--)
	{
		gtk_tree_model_iter_children(model, &child, iter);
		gtk_tree_store_remove(GTK_TREE_STORE(model), &child);
	}
	
	gtk_tree_model_iter_children(model, &child_last, iter);
	
	gtk_tree_model_get (model, iter,  
						GSQL_NAV_TREE_REALNAME, 
						&realname, -1);
	
	gtk_tree_model_get (model, iter,  
						GSQL_NAV_TREE_SQL, 
						&sql, -1);
	
	gtk_tree_model_get (model, iter,  
						GSQL_NAV_TREE_OWNER, 
						&owner, -1);
	
	gtk_tree_model_get (model, iter,  
						GSQL_NAV_TREE_ID, 
						&id, -1);
	
	session = gsql_session_get_active ();
	
	GSQL_DEBUG ("realname:[%s]    sql:[%s]   owner:[%s]", realname, sql, owner); 
	
	switch (id)
	{
		case OBJECT_TYPES_ID:
			if (strncmp (owner, gsql_session_get_username (session), 64))
				sql = (gchar *) sql_oracle_object_types;
			
			GSQL_DEBUG ("types SQL: %s", sql);
	
			cursor = gsql_cursor_new (session, sql);
			state = gsql_cursor_open_with_bind (cursor,
												FALSE,
												GSQL_CURSOR_BIND_BY_NAME,
												G_TYPE_STRING, ":owner",
												G_TYPE_STRING, owner,
												G_TYPE_STRING, ":object_name",
												G_TYPE_STRING, "%",
												-1);
			s_elements = object_types;
			n_elements = G_N_ELEMENTS (object_types);
			stock = GSQLE_ORACLE_STOCK_OBJ_TYPES;
			
			break;
			
		case OBJECT_TYPE_BODIES_ID:
			if (strncmp (owner, gsql_session_get_username (session), 64))
				sql = (gchar *) sql_oracle_users_objects;
			
			cursor = gsql_cursor_new (session, sql);
			state = gsql_cursor_open_with_bind (cursor,
										FALSE,
										GSQL_CURSOR_BIND_BY_NAME,
										G_TYPE_STRING, ":owner",
										G_TYPE_STRING, owner,
										G_TYPE_STRING, ":object_name",
										G_TYPE_STRING, "%",
										G_TYPE_STRING, ":object_type",
										G_TYPE_STRING, "TYPE BODY",
										-1);
			s_elements = object_types;
			n_elements = G_N_ELEMENTS (object_types);
			stock = GSQLE_ORACLE_STOCK_OBJ_TYPE_BODIES;
			
			break;
			
		case COLLECTION_TYPES_ID:
			if (strncmp (owner, gsql_session_get_username (session), 64))
				sql = (gchar *) sql_oracle_collection_types;
			
			GSQL_DEBUG ("collection SQL: %s", sql);
			cursor = gsql_cursor_new (session, sql);
			state = gsql_cursor_open_with_bind (cursor,
												FALSE,
												GSQL_CURSOR_BIND_BY_NAME,
												G_TYPE_STRING, ":owner",
												G_TYPE_STRING, owner,
												G_TYPE_STRING, ":object_name",
												G_TYPE_STRING, "%",
												-1);
			s_elements = object_types;
			n_elements = G_N_ELEMENTS (object_types);
			stock = GSQLE_ORACLE_STOCK_COLLECTIONS_TYPES;
			
			break;		
	}
			
	
	if (state != GSQL_CURSOR_STATE_OPEN)
	{
		gsql_cursor_close (cursor);
		return;
	}

	var = g_list_nth_data(cursor->var_list, 0);
	
	n = 0;
	
	while (gsql_cursor_fetch (cursor, 1) > 0)
	{
		n++;
		
		if (var->value_type != G_TYPE_STRING)
		{
			GSQL_DEBUG ("The name of object should be a string (char *). Is the bug");
			name = N_("Incorrect data");
		} else {
			name = (gchar *) var->value;
			// make a key for a hash of details
			memset (key, 0, 256);
			g_snprintf (key, 255, "%x%s%d%s",
						session, owner, id, name);
			
			details = gsql_navigation_get_details (navigation, key);
			oracle_navigation_fill_details (cursor, details);
		}
		
		gtk_tree_store_append (GTK_TREE_STORE(model), &child, iter);
		gtk_tree_store_set (GTK_TREE_STORE(model), &child,
					GSQL_NAV_TREE_ID,			id,
					GSQL_NAV_TREE_OWNER,		owner,
					GSQL_NAV_TREE_IMAGE,		stock,
					GSQL_NAV_TREE_NAME,			name,
					GSQL_NAV_TREE_REALNAME, 	name,
					GSQL_NAV_TREE_ITEM_INFO, 	NULL,
					GSQL_NAV_TREE_SQL,			NULL,
					GSQL_NAV_TREE_OBJECT_POPUP, NULL,
					GSQL_NAV_TREE_OBJECT_HANDLER, NULL,
					GSQL_NAV_TREE_EXPAND_HANDLER, NULL,
					GSQL_NAV_TREE_EVENT_HANDLER, NULL,
					GSQL_NAV_TREE_STRUCT, object_types,
					GSQL_NAV_TREE_DETAILS, details,
					GSQL_NAV_TREE_NUM_ITEMS, G_N_ELEMENTS(object_types),
					-1);

		gtk_tree_store_append (GTK_TREE_STORE (model), &child_fake, &child);
		gtk_tree_store_set (GTK_TREE_STORE (model), &child_fake,
				GSQL_NAV_TREE_ID,				-1,
				GSQL_NAV_TREE_IMAGE,			NULL,
				GSQL_NAV_TREE_NAME,				N_("Processing..."),
				GSQL_NAV_TREE_REALNAME,			NULL,
				GSQL_NAV_TREE_ITEM_INFO,		NULL,
				GSQL_NAV_TREE_SQL,				NULL,
				GSQL_NAV_TREE_OBJECT_POPUP,		NULL,
				GSQL_NAV_TREE_OBJECT_HANDLER,	NULL,
				GSQL_NAV_TREE_EXPAND_HANDLER,	NULL,
				GSQL_NAV_TREE_EVENT_HANDLER,	NULL,
				GSQL_NAV_TREE_STRUCT,			NULL,
				GSQL_NAV_TREE_NUM_ITEMS, 		NULL,
				-1);
	}
	
	GSQL_DEBUG ("Items fetched: [%d]", n);
	
	if (n > 0)
	{
		name = g_strdup_printf("%s<span weight='bold'> [%d]</span>", 
												realname, n);
		gtk_tree_store_set (GTK_TREE_STORE(model), iter,
							GSQL_NAV_TREE_NAME, 
							name,
							-1);
		g_free (name);
	}
	
	gtk_tree_store_remove(GTK_TREE_STORE(model), &child_last);
	
	gsql_cursor_close (cursor);

}
Ejemplo n.º 15
0
static void
pkg_window_refresh_with_iter (PkgWindow    *window, /* IN */
                              GtkTreeModel *model,  /* IN */
                              GtkTreeIter  *iter)   /* IN */
{
	PkgWindowPrivate *priv;
	PkConnection *connection;
	GtkTreeView *treeview;
	GtkTreeIter child;
	GtkTreeIter grandchild;

	g_return_if_fail(PKG_IS_WINDOW(window));
	g_return_if_fail(GTK_IS_TREE_MODEL(model));
	g_return_if_fail(iter != NULL);

	/*
	 * All the children of this connection can stay, but their
	 * children should be removed.
	 */

	ENTRY;
	priv = window->priv;
	gtk_tree_model_get(model, iter, COLUMN_CONNECTION, &connection, -1);
	if (!connection) {
		EXIT;
	}
	/*
	 * Clear existing entries.
	 */
	pkg_window_clear_page(window);
	treeview = GTK_TREE_VIEW(priv->treeview);
	gtk_tree_selection_unselect_all(gtk_tree_view_get_selection(treeview));
	if (gtk_tree_model_iter_children(model, &child, iter)) {
		do {
			if (gtk_tree_model_iter_children(model, &grandchild, &child)) {
				while (gtk_tree_store_remove(GTK_TREE_STORE(model),
				                             &grandchild)) {
					;;
				}
			}
		} while (gtk_tree_model_iter_next(model, &child));
	}
	/*
	 * Refresh connection information.
	 */
	pk_connection_manager_get_hostname_async(
			connection, NULL,
	        pkg_window_connection_manager_get_hostname_cb,
	        window);
	pk_connection_manager_get_channels_async(
			connection, NULL,
			pkg_window_connection_manager_get_channels_cb,
			window);
	pk_connection_manager_get_plugins_async(
			connection, NULL,
			pkg_window_connection_manager_get_plugins_cb,
			window);
	pk_connection_manager_get_subscriptions_async(
			connection, NULL,
			pkg_window_connection_manager_get_subscriptions_cb,
			window);
	pk_connection_manager_get_sources_async(
			connection, NULL,
			pkg_window_connection_manager_get_sources_cb,
			window);
	EXIT;
}
Ejemplo n.º 16
0
void save_config (GtkButton *button, gpointer user_data)
{
	GtkTreeIter f_iter, h_iter;
	GValue f_value = {0};
	GValue h_value = {0};
	gchar *f_src, *f_dst, *h_val;
	gboolean delete_cond = FALSE, valid = TRUE; 
	gint i, j;
	GtkWidget *dialog;
	Widgets *widgets = (Widgets*)user_data;

	if(gtk_tree_model_get_iter_first (widgets->store, &f_iter) && gtk_tree_model_get_iter_first (widgets->store_hidden, &h_iter))
	{
		gtk_tree_model_get_iter_first (widgets->store_hidden, &h_iter);
		do
		{
			gtk_tree_model_get_value (widgets->store_hidden, &h_iter, 0, &h_value);
			gtk_tree_model_get_iter_first (widgets->store, &f_iter);
			do
			{
				gtk_tree_model_get_value (widgets->store, &f_iter, 0, &f_value);
				if(strcmp(g_value_get_string (&f_value), g_value_get_string (&h_value)) == 0)
				{
					if(!gtk_tree_store_remove (widgets->store_hidden, &h_iter))
					{
						valid = FALSE;
					}
					delete_cond = TRUE;
					g_value_unset(&f_value);
					break;
				}
				g_value_unset(&f_value);
				
				gtk_tree_model_get_value (widgets->store, &f_iter, 1, &f_value);
				if(strcmp(g_value_get_string (&f_value), g_value_get_string (&h_value)) == 0)
				{
					if(!gtk_tree_store_remove (widgets->store_hidden, &h_iter))
					{
						valid = FALSE;
					}
					delete_cond = TRUE;
					g_value_unset(&f_value);
					break;
				}
				g_value_unset(&f_value);
			}
			while (gtk_tree_model_iter_next (widgets->store, &f_iter));
			g_value_unset(&h_value);
			if(delete_cond)
			{
				delete_cond = FALSE;
			}
			else
			{
				if(!gtk_tree_model_iter_next (widgets->store_hidden, &h_iter))
				{
					valid = FALSE;
				}
			}
		}
		while (valid);
	}
	
	if(gtk_tree_model_get_iter_first (widgets->store, &f_iter))
	{
		j=0;
		do
		{
			gtk_tree_model_get_value (widgets->store, &f_iter, 0, &f_value);
			f_src = g_value_get_string (&f_value);
			for(i=0; i<size_lang; i++)
			{
				if(strcmp(f_src, dicts[i].name) == 0)
				{
					favorite[j].src_code = i;
					break;
				}
			}
			g_value_unset(&f_value);
			gtk_tree_model_get_value (widgets->store, &f_iter, 1, &f_value);
			f_dst = g_value_get_string (&f_value);
			for(i=0; i<size_lang; i++)
			{
				if(strcmp(f_dst, dicts[i].name) == 0)
				{
					favorite[j].dst_code = i;
					break;
				}
			}
			g_value_unset(&f_value);
			//g_print ("\n%s -> %s", *f_src, *f_dst);
			j++;
		}
		while(gtk_tree_model_iter_next (widgets->store, &f_iter));
	}

	for(i=0; i<sizeof(favorite)/sizeof(favorite[0]); i++)
	{
		if(favorite[i].src_code == -1)
		{
			break;
		}
		g_print("\n%d %d", favorite[i].src_code, favorite[i].dst_code);
	}

	if(gtk_tree_model_get_iter_first (widgets->store_hidden, &h_iter))
	{
		j=0;
		do
		{
			gtk_tree_model_get_value (widgets->store_hidden, &h_iter, 0, &h_value);
			h_val = g_value_get_string (&h_value);
			for(i=0; i<size_lang; i++)
			{
				if(strcmp(h_val, dicts[i].name) == 0)
				{
					h_dict[j].code = i;
					break;
				}
			}
			g_value_unset(&h_value);
			j++;
		}
		while(gtk_tree_model_iter_next (widgets->store_hidden, &h_iter));
	}

	for(i=0; i<sizeof(h_dict)/sizeof(h_dict[0]); i++)
	{
		if(h_dict[i].code == -1)
		{
			break;
		}
		g_print("\n%d", h_dict[i].code);
	}

	strcpy (shortcut[0].name, gtk_entry_get_text (widgets->entry_sn));
	strcpy (shortcut[1].name, gtk_entry_get_text (widgets->entry_wn));
	strcpy (shortcut[2].name, gtk_entry_get_text (widgets->entry_sf));
	strcpy (shortcut[3].name, gtk_entry_get_text (widgets->entry_sb));
	strcpy (shortcut[4].name, gtk_entry_get_text (widgets->log_file_entry));
	strcpy (shortcut[5].name, gtk_entry_get_text (widgets->save_freq_entry));
	

	save_config_file (conf_file, &shortcut, &favorite, &h_dict);
	exit_window (NULL, user_data);
	exit_code = 1;
}
Ejemplo n.º 17
0
/* count == 0 means this is a detailed mail notification.
 * count > 0 mean non-detailed.
 */
static void *
pidgin_notify_add_mail(GtkTreeStore *treemodel, PurpleAccount *account, char *notification, const char *url, int count, gboolean clear, gboolean *new_data)
{
	PidginNotifyMailData *data = NULL;
	GtkTreeIter iter;
	GdkPixbuf *icon;
	gboolean new_n = TRUE;

	if (count > 0 || clear) {
		/* Allow only one non-detailed email notification for each account */
		if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(treemodel), &iter)) {
			gboolean advanced;
			do {
				advanced = FALSE;
				gtk_tree_model_get(GTK_TREE_MODEL(treemodel), &iter,
						PIDGIN_MAIL_DATA, &data, -1);
				if (data->account == account) {
					if (clear) {
#if GTK_CHECK_VERSION(2,2,0)
						advanced = gtk_tree_store_remove(treemodel, &iter);
#else
						gtk_tree_store_remove(treemodel, &iter);
						advanced = (iter.stamp == 0) ? FALSE : TRUE;
#endif
						purple_notify_close(PURPLE_NOTIFY_EMAILS, data);
						/* We're completely done if we've processed all entries */
						if (!advanced)
							return NULL;
					} else if (data->count > 0) {
						new_n = FALSE;
						g_free(data->url);
						data->url = NULL;
						mail_dialog->total_count -= data->count;
						break;
					}
				}
			} while (advanced || gtk_tree_model_iter_next(GTK_TREE_MODEL(treemodel), &iter));
		}
	}

	if (clear)
		return NULL;

	icon = pidgin_create_prpl_icon(account, PIDGIN_PRPL_ICON_MEDIUM);

	if (new_n) {
		data = g_new0(PidginNotifyMailData, 1);
		data->purple_has_handle = TRUE;
		gtk_tree_store_append(treemodel, &iter, NULL);
	}

	if (url != NULL)
		data->url = g_strdup(url);

	gtk_tree_store_set(treemodel, &iter,
								PIDGIN_MAIL_ICON, icon,
								PIDGIN_MAIL_TEXT, notification,
								PIDGIN_MAIL_DATA, data,
								-1);
	data->account = account;
	data->count = count;

	if (icon)
		g_object_unref(icon);

	if (new_data)
		*new_data = new_n;
	return data;
}
Ejemplo n.º 18
0
Archivo: reset.c Proyecto: Lamieur/Lac
int zapisz_reset_O( ROOM_INDEX_DATA *room )
{
    OBJ_INDEX_DATA *obj;
    int j, n, v;
    RESET_DATA *r, *temp;
    GtkTreeModel *model;
    GtkTreeIter iter, child;
    char buf[ MIL ], bufnum[ MIL ];

    if ( ( v = SPIN_GET_VALUE( dres.spin_prz ) ) < 0
      || !( obj = get_obj_index( v ) ) )
	return 1;

    /* zmien reset O */
    dres.reset->arg1 = SPIN_GET_VALUE( dres.spin_prz );
    dres.reset->arg2 = SPIN_GET_VALUE( dres.spin_int );
    dres.reset->arg3 = SPIN_GET_VALUE( dres.spin_pom );

    /* zwolnij wszystkie komentarze i resety P podczepione do resetu O */
    for ( r = dres.reset->next; r;  )
	if ( r->command == 'P' || r->command == '*' )
	{
	    temp = r;
	    r = r->next;
	    del_reset( temp );
	}
	else
	    break;

    temp = r; /* tutaj temp pamieta pierwszy reset spoza O */
    r = dres.reset;

    model = GTK_TREE_MODEL( dres.store_inw );

    /* teraz zapis przedmiotow w pojemniku jako resety P */
    if ( obj->item_type == ITEM_CONTAINER )
    {
	gtk_tree_model_iter_nth_child( model, &iter, NULL, 0 );
	j = gtk_tree_model_iter_n_children( model, &iter );

	for ( n = 0; n < j; n++ )
	    if ( gtk_tree_model_iter_nth_child( model, &child, &iter, n ) )
	    {
		OBJ_INDEX_DATA *o;

		gtk_tree_model_get( model, &child, KOL_WSKAZNIK, &o, -1 );

		r->next = new_reset( );
		r = r->next;
		r->command = 'P';
		r->arg1 = o->vnum;
	    }
    }
    r->next = temp;

    /* odzwierciedlenie powyzszych zmian na liscie resetow */
    strcpy( bufnum, &dres.reset->command );
    sprintf( buf, "%s -> %s", obj->short_descr, room->name );
    gtk_tree_store_set( dkra.store_res, &dres.iter,
	KOL_VNUM, bufnum,
	KOL_OPIS, _( buf ), -1 );

    model = GTK_TREE_MODEL( dkra.store_res );
    j = gtk_tree_model_iter_n_children( model, &dres.iter );
    for ( n = 0; n < j; n++ )
	if ( gtk_tree_model_iter_nth_child( model, &child, &dres.iter, 0 ) )
	    gtk_tree_store_remove( dkra.store_res, &child );

    for ( r = dres.reset->next; r && r->command == 'P'; r = r->next )
    {
	OBJ_INDEX_DATA *o = get_obj_index( r->arg1 );

	sprintf( bufnum, "%c", r->command );
	strcpy( buf, o->short_descr );

	gtk_tree_store_append( dkra.store_res, &iter, &dres.iter );
	gtk_tree_store_set( dkra.store_res, &iter,
	    KOL_WSKAZNIK, r,
	    KOL_VNUM, bufnum,
	    KOL_OPIS, _( buf ), -1 );
    }

    return 0;
}
Ejemplo n.º 19
0
/* Fill in the list with values in ks */
static void
populate_keyservers (SeahorseWidget *swidget, gchar **keyservers)
{
    GtkTreeView *treeview;
    GtkTreeStore *store;
    GtkTreeModel *model;
    GtkCellRenderer *renderer;
    GtkTreeViewColumn *column;
    GtkTreeIter iter;
    gboolean cont;
    gchar *value;
    guint i = 0;

    treeview = GTK_TREE_VIEW (seahorse_widget_get_widget (swidget, "keyservers"));
    model = gtk_tree_view_get_model (treeview);
    store = GTK_TREE_STORE (model);
    
    /* This is our first time so create a store */
    if (!model) {

        store = gtk_tree_store_new (N_COLUMNS, G_TYPE_STRING);
        model = GTK_TREE_MODEL (store);
        gtk_tree_view_set_model (treeview, model);

        /* Make the column */
        renderer = gtk_cell_renderer_text_new ();
        g_object_set (renderer, "editable", TRUE, NULL);
        g_signal_connect(renderer, "edited", G_CALLBACK (keyserver_cell_edited), store);
        column = gtk_tree_view_column_new_with_attributes (_("URL"), renderer , 
                                        "text", KEYSERVER_COLUMN, NULL);
        gtk_tree_view_append_column (treeview, column);        
    }

	/* Mark this so we can ignore events */
	g_object_set_data (G_OBJECT (model), UPDATING_MODEL, GINT_TO_POINTER (1));

	/* We try and be inteligent about updating so we don't throw
	 * away selections and stuff like that */

	if (gtk_tree_model_get_iter_first (model, &iter)) {
		do {
			gtk_tree_model_get (model, &iter, KEYSERVER_COLUMN, &value, -1);
			if (keyservers[i] != NULL && value != NULL &&
			    g_utf8_collate (keyservers[i], value) == 0) {
				cont = gtk_tree_model_iter_next (model, &iter);
				i++;
			} else {
				cont = gtk_tree_store_remove (store, &iter);
			}
			g_free (value);
		} while (cont);
	}

	/* Any remaining extra rows */
	for ( ; keyservers[i] != NULL; i++) {
		gtk_tree_store_append (store, &iter, NULL);
		gtk_tree_store_set (store, &iter, KEYSERVER_COLUMN, keyservers[i], -1);
	}

	/* Done updating */
	g_object_set_data (G_OBJECT (model), UPDATING_MODEL, NULL);
}
Ejemplo n.º 20
0
Archivo: reset.c Proyecto: Lamieur/Lac
int zapisz_reset_M( ROOM_INDEX_DATA *room )
{
    MOB_INDEX_DATA *mob;
    OBJ_INDEX_DATA *obj;
    int i, j, n, v;
    RESET_DATA *r, *temp;
    GtkTreeModel *model;
    GtkTreeIter iter, child;
    char buf[ MIL ], bufnum[ MIL ];

    /* sprawdz poprawnosc danych */
    if ( ( v = SPIN_GET_VALUE( dres.spin_mob ) ) < 0
      || !( mob = get_mob_index( v ) ) )
	return 1;

    for ( i = 0; i < MAX_WEAR; i++ )
    {
	if ( ( v = SPIN_GET_VALUE( dres.spin_ekw[ i ] ) ) < 0 )
	    continue;

	if ( !( obj = get_obj_index( v ) ) )
	    return 2;

	if( dres.wear_na_item[ i ] != obj->wear_flags
	  || ( i == WEAR_LIGHT && obj->item_type != ITEM_LIGHT ) )
	    /* przydalby sie dialog z komunikatem, dlaczego odmawia zapisu */
	    return 3;
    }

    /* zmien reset M */
    dres.reset->arg1 = SPIN_GET_VALUE( dres.spin_mob );
    dres.reset->arg2 = SPIN_GET_VALUE( dres.spin_int );
    dres.reset->arg3 = SPIN_GET_VALUE( dres.spin_pom );

    /* zwolnij wszystkie resety podczepione do resetu M */
    for ( r = dres.reset->next; r;  )
    {
	if ( r->command != 'P' && r->command != 'G'
	  && r->command != 'E' && r->command != '*' )
	    break;

	temp = r;
	r = r->next;
	del_reset( temp );
    }

    temp = r; /* tutaj temp pamieta pierwszy reset spoza M */
    r = dres.reset;

    model = GTK_TREE_MODEL( dres.store_inw );

    /* z kazdego wybranego przedmiotu zrob reset E */
    for ( i = 0; i < MAX_WEAR; i++ )
    {
	if ( ( v = SPIN_GET_VALUE( dres.spin_ekw[ i ] ) ) == -1 )
	    continue;

	r->next = new_reset( );
	r = r->next;
	r->command = 'E';
	r->arg1 = v;
	r->arg3 = i;

	iter = dres.iter_ekw[ i ];

	/* jesli przedmiot ma zawartosc, zrob z niej resety P */
	if ( iter.stamp != 0 )
	{
	    j = gtk_tree_model_iter_n_children( model, &iter );

	    for ( n = 0; n < j; n++ )
		if ( gtk_tree_model_iter_nth_child( model, &child, &iter, n ) )
		{
		    gtk_tree_model_get( model, &child, KOL_WSKAZNIK, &obj, -1 );

		    r->next = new_reset( );
		    r = r->next;
		    r->command = 'P';
		    r->arg1 = obj->vnum;
		}
	}
    }

    /* teraz zapis przedmiotow "przy sobie" jako resety G */
    gtk_tree_model_get_iter_first( model, &iter );
    j = gtk_tree_model_iter_n_children( model, &iter );

    for ( n = 0; n < j; n++ )
	if ( gtk_tree_model_iter_nth_child( model, &child, &iter, n ) )
	{
	    gtk_tree_model_get( model, &child, KOL_WSKAZNIK, &obj, -1 );

	    r->next = new_reset( );
	    r = r->next;
	    r->command = 'G';
	    r->arg1 = obj->vnum;

	    /* resety G moga byc pojemnikami, wiec jeszcze raz resety P: */
	    {
		int k, l;
		GtkTreeIter grandchild;

		l = gtk_tree_model_iter_n_children( model, &child );

		for ( k = 0; k < l; k++ )
		    if ( gtk_tree_model_iter_nth_child( model, &grandchild, &child, k ) )
		    {
			gtk_tree_model_get( model, &grandchild, KOL_WSKAZNIK, &obj, -1 );

			r->next = new_reset( );
			r = r->next;
			r->command = 'P';
			r->arg1 = obj->vnum;
		    }
	    }
	}

    r->next = temp;

    /* odzwierciedlenie powyzszych zmian na liscie resetow */
    strcpy( bufnum, &dres.reset->command );
    sprintf( buf, "%s -> %s", mob->short_descr, room->name );
    gtk_tree_store_set( dkra.store_res, &dres.iter,
	KOL_VNUM, bufnum,
	KOL_OPIS, _( buf ), -1 );

    model = GTK_TREE_MODEL( dkra.store_res );
    j = gtk_tree_model_iter_n_children( model, &dres.iter );
    for ( n = 0; n < j; n++ )
	if ( gtk_tree_model_iter_nth_child( model, &child, &dres.iter, 0 ) )
	    gtk_tree_store_remove( dkra.store_res, &child );

    for ( r = dres.reset->next; r; r = r->next )
    {
	switch ( r->command )
	{
	    case 'G':
	    case 'E':
		gtk_tree_store_append( dkra.store_res, &iter, &dres.iter );
		child = iter;
		break;
	    case 'P':
	        gtk_tree_store_append( dkra.store_res, &iter, &child );
	        break;
	    case '*':
		continue;
	    default:
		return 0;
	}

	sprintf( bufnum, "%c", r->command );
	strcpy( buf, get_obj_index( r->arg1 )->short_descr );

	gtk_tree_store_set( dkra.store_res, &iter,
	    KOL_WSKAZNIK, r,
	    KOL_VNUM, bufnum,
	    KOL_OPIS, _( buf ), -1 );
    }

    return 0;
}
/*
 * Update the tree by adding/removing entries
 * Does not change other nodes
 */
static void update_tree(struct menu *src, GtkTreeIter * dst)
{
	struct menu *child1;
	GtkTreeIter iter, tmp;
	GtkTreeIter *child2 = &iter;
	gboolean valid;
	GtkTreeIter *sibling;
	struct symbol *sym;
	struct property *prop;
	struct menu *menu1, *menu2;

	if (src == &rootmenu)
		indent = 1;

	valid = gtk_tree_model_iter_children(model2, child2, dst);
	for (child1 = src->list; child1; child1 = child1->next) {

		prop = child1->prompt;
		sym = child1->sym;

	      reparse:
		menu1 = child1;
		if (valid)
			gtk_tree_model_get(model2, child2, COL_MENU,
					   &menu2, -1);
		else
			menu2 = NULL;	// force adding of a first child

#ifdef DEBUG
		printf("%*c%s | %s\n", indent, ' ',
		       menu1 ? menu_get_prompt(menu1) : "nil",
		       menu2 ? menu_get_prompt(menu2) : "nil");
#endif

		if (!menu_is_visible(child1) && !show_all) {	// remove node
			if (gtktree_iter_find_node(dst, menu1) != NULL) {
				memcpy(&tmp, child2, sizeof(GtkTreeIter));
				valid = gtk_tree_model_iter_next(model2,
								 child2);
				gtk_tree_store_remove(tree2, &tmp);
				if (!valid)
					return;	// next parent
				else
					goto reparse;	// next child
			} else
				continue;
		}

		if (menu1 != menu2) {
			if (gtktree_iter_find_node(dst, menu1) == NULL) {	// add node
				if (!valid && !menu2)
					sibling = NULL;
				else
					sibling = child2;
				gtk_tree_store_insert_before(tree2,
							     child2,
							     dst, sibling);
				set_node(child2, menu1, fill_row(menu1));
				if (menu2 == NULL)
					valid = TRUE;
			} else {	// remove node
				memcpy(&tmp, child2, sizeof(GtkTreeIter));
				valid = gtk_tree_model_iter_next(model2,
								 child2);
				gtk_tree_store_remove(tree2, &tmp);
				if (!valid)
					return;	// next parent
				else
					goto reparse;	// next child
			}
		} else if (sym && (sym->flags & SYMBOL_CHANGED)) {
			set_node(child2, menu1, fill_row(menu1));
		}

		indent++;
		update_tree(child1, child2);
		indent--;

		valid = gtk_tree_model_iter_next(model2, child2);
	}
}
Ejemplo n.º 22
0
/**
 * Build data storage by querying the X server for all input devices.
 * Can be called multiple times, in which case it'll clean out and re-fill
 * update the tree store.
 */
static GtkTreeStore* query_devices(GDeviceSetup* gds)
{
    GtkTreeStore *treestore;
    GtkTreeModel *model;
    GtkTreeIter iter, child;
    XIDeviceInfo *devices, *dev;
    int ndevices;
    int i, j;
    int icontype;
    GdkPixbuf *icon;
    int valid, child_valid;
    int id, masterid;

    if (!gds->treeview)
    {
        treestore = gtk_tree_store_new(NUM_COLS,
                                       G_TYPE_UINT, /* deviceid*/
                                       G_TYPE_STRING, /* name */
                                       G_TYPE_UINT,
                                       GDK_TYPE_PIXBUF,
                                       G_TYPE_UINT
                                       );
        model = GTK_TREE_MODEL(treestore);
    } else
    {
        model = gtk_tree_view_get_model(gds->treeview);
        treestore = GTK_TREE_STORE(model);
    }

    gds->generation++;
    devices = XIQueryDevice(gds->dpy, XIAllDevices, &ndevices);

    /* First, run through all master device and append them to the tree store
     */
    for (i = 0; i < ndevices; i++)
    {
        dev = &devices[i];

        if (dev->use != XIMasterPointer && dev->use != XIMasterKeyboard)
            continue;

        valid = gtk_tree_model_get_iter_first(model, &iter);
        g_debug("MD %d: %s", dev->deviceid,  dev->name);

        while(valid) {
            gtk_tree_model_get(model, &iter, COL_ID, &id, -1);
            if (id == dev->deviceid)
            {
                gtk_tree_store_set(treestore, &iter,
                                   COL_GENERATION, gds->generation, -1);
                valid = 0xFF;
                break;
            }
            valid = gtk_tree_model_iter_next(model, &iter);
        }

        if (valid != 0xFF) /* new MD */
        {
            icontype = (dev->use == XIMasterPointer) ? ICON_MOUSE : ICON_KEYBOARD;
            icon = load_icon(icontype);

            gtk_tree_store_append(treestore, &iter, NULL);
            gtk_tree_store_set(treestore, &iter,
                               COL_ID, dev->deviceid,
                               COL_NAME, dev->name,
                               COL_USE, dev->use,
                               COL_ICON, icon,
                               COL_GENERATION, gds->generation,
                               -1);
            g_object_unref(icon);
        }
    }

    /* search for Floating fake master device */
    valid = gtk_tree_model_get_iter_first(model, &iter);
    while(valid)
    {
        gtk_tree_model_get(model, &iter, COL_ID, &id, -1);
        if (id == ID_FLOATING)
            break;

        valid = gtk_tree_model_iter_next(model, &iter);
    }

    if (!valid)
    {
        /* Attach a fake master device for "Floating" */
        icon = load_icon(ICON_FLOATING);
        gtk_tree_store_append(treestore, &iter, NULL);
        gtk_tree_store_set(treestore, &iter,
                COL_ID, ID_FLOATING,
                COL_NAME, "Floating",
                COL_USE, ID_FLOATING,
                COL_ICON, icon,
                COL_GENERATION, gds->generation,
                -1);
        g_object_unref(icon);
    } else {
        GtkTreeIter prev;
        GtkTreeIter pos = iter; /* current position of Floating */

        /* always move Floating fake device to end of list */
        while(valid)
        {
            prev = iter;
            valid = gtk_tree_model_iter_next(model, &iter);
        }

        gtk_tree_store_move_after(treestore, &pos, &prev);

        /* update generation too */
        gtk_tree_store_set(treestore, &pos,
                           COL_GENERATION, gds->generation, -1);
    }


    /* now that we added all MDs, run through again and add SDs to the
     * respective MD */
    for (i = 0; i < ndevices; i++)
    {
        dev = &devices[i];

        if (dev->use == XIMasterPointer || dev->use == XIMasterKeyboard)
   	  continue;

        g_debug("SD %d: %s", dev->deviceid, dev->name);

	valid = gtk_tree_model_get_iter_first(model, &iter);
	while(valid) {
	  gtk_tree_model_get(model, &iter, COL_ID, &masterid, -1);
	  if(dev->attachment == masterid || (dev->use == XIFloatingSlave && masterid == ID_FLOATING))
	    {
	      /* found master, check if we're already attached to it in
	       * the tree model */
	      child_valid = gtk_tree_model_iter_children(model, &child, &iter);
	      while (child_valid)
		{
		  gtk_tree_model_get(model, &child, COL_ID, &id);

		  if (id == dev->deviceid)
		    {
		      gtk_tree_store_set(treestore, &child,
					 COL_GENERATION, gds->generation, -1);
		      child_valid = 0xFF;
		      break;
		    }

		  child_valid = gtk_tree_model_iter_next(model, &child);
		}

	      /* new slave device, attach */
	      if (child_valid != 0xFF)
		{
		  gtk_tree_store_append(treestore, &child, &iter);
		  gtk_tree_store_set(treestore, &child,
				     COL_ID, dev->deviceid,
				     COL_NAME, dev->name,
				     COL_USE, dev->use,
				     COL_GENERATION, gds->generation,
				     -1);
		}
	      break;
	    }

	  valid = gtk_tree_model_iter_next(model, &iter);
	}
    }

    XIFreeDeviceInfo(devices);

    /* clean tree store of anything that doesn't have the current
       server generation */

    valid = gtk_tree_model_get_iter_first(model, &iter);
    while(valid)
    {
        int gen;

        child_valid = gtk_tree_model_iter_children(model, &child, &iter);
        while(child_valid)
        {
            gtk_tree_model_get(model, &child, COL_GENERATION, &gen, -1);
            if (gen < gds->generation)
                child_valid = gtk_tree_store_remove(treestore, &child);
            else
                child_valid = gtk_tree_model_iter_next(model, &child);
        }

        gtk_tree_model_get(model, &iter, COL_GENERATION, &gen, -1);
        if (gen < gds->generation)
            valid = gtk_tree_store_remove(treestore, &iter);
        else
            valid = gtk_tree_model_iter_next(model, &iter);
    }

    return treestore;
}
Ejemplo n.º 23
0
void
nav_tree_refresh_synonyms (GSQLNavigation *navigation,
						 GtkTreeView *tv,
						 GtkTreeIter *iter)
{
	GSQL_TRACE_FUNC;

	GtkTreeModel *model;
	GtkListStore *detail;
	GSQLNavigation *nav = NULL;
	gchar			*sql = NULL;
	gchar			*realname = NULL;
	gchar			*owner = NULL;
	gint 		id;
	gint		i,n;
	GtkTreeIter child;
	GtkTreeIter child_fake;
	GtkTreeIter	child_last;
	GSQLCursor *cursor;
	GSQLCursorState state;
	GSQLVariable *var;
	GSQLSession *session;
	GtkListStore *details;
	gchar *name;
	gchar key[256];

	
	model = gtk_tree_view_get_model(tv);
	n = gtk_tree_model_iter_n_children(model, iter);
	
	for (; n>1; n--)
	{
		gtk_tree_model_iter_children(model, &child, iter);
		gtk_tree_store_remove(GTK_TREE_STORE(model), &child);
	}
	
	gtk_tree_model_iter_children(model, &child_last, iter);
	
	gtk_tree_model_get (model, iter,  
						GSQL_NAV_TREE_REALNAME, 
						&realname, -1);
	gtk_tree_model_get (model, iter,  
						GSQL_NAV_TREE_SQL, 
						&sql, -1);
	g_return_if_fail (sql != NULL);
	
	gtk_tree_model_get (model, iter,  
						GSQL_NAV_TREE_OWNER, 
						&owner, -1);
	
	session = gsql_session_get_active ();
	
	if (strncmp (owner, gsql_session_get_username (session), 64))
		sql = (gchar *)  sql_oracle_synonyms;
	
	cursor = gsql_cursor_new (session, sql);
	
	state = gsql_cursor_open_with_bind (cursor,
										FALSE,
										GSQL_CURSOR_BIND_BY_NAME,
										G_TYPE_STRING, ":owner",
										G_TYPE_STRING, owner,
										G_TYPE_STRING, ":name",
										G_TYPE_STRING, "%",
										-1);
	
	var = g_list_nth_data(cursor->var_list,0);
	
	if (state != GSQL_CURSOR_STATE_OPEN)
	{
		gsql_cursor_close (cursor);
		return;		
	}
	
	i = 0;
	
	while (gsql_cursor_fetch (cursor, 1) > 0)			
	{
		i++;	

		if (var->value_type != G_TYPE_STRING)
		{
			GSQL_DEBUG ("The name of object should be a string (char *). Is the bug");
			name = N_("Incorrect data");
		} else {
			name = (gchar *) var->value;
			// make a key for a hash of details
			memset (key, 0, 256);
			g_snprintf (key, 255, "%x%s%d%s",
				   session, owner, SYNONYM_ID, name);
			
			details = gsql_navigation_get_details (navigation, key);
			oracle_navigation_fill_details (cursor, details);
		}
		
		gtk_tree_store_append (GTK_TREE_STORE(model), &child, iter);
		gtk_tree_store_set (GTK_TREE_STORE(model), &child,
					GSQL_NAV_TREE_ID,			SYNONYM_ID,
					GSQL_NAV_TREE_OWNER,		owner,
					GSQL_NAV_TREE_IMAGE,		GSQLE_ORACLE_STOCK_SYNONYMS,
					GSQL_NAV_TREE_NAME,			name,
					GSQL_NAV_TREE_REALNAME, 	name,
					GSQL_NAV_TREE_ITEM_INFO, 	NULL,
					GSQL_NAV_TREE_SQL,			NULL,
					GSQL_NAV_TREE_OBJECT_POPUP, NULL,
					GSQL_NAV_TREE_OBJECT_HANDLER, NULL,
					GSQL_NAV_TREE_EXPAND_HANDLER, NULL,
					GSQL_NAV_TREE_EVENT_HANDLER, NULL,
					GSQL_NAV_TREE_STRUCT, synonyms,
					GSQL_NAV_TREE_DETAILS, details,
					GSQL_NAV_TREE_NUM_ITEMS, G_N_ELEMENTS(synonyms),
					-1);

		gtk_tree_store_append (GTK_TREE_STORE (model), &child_fake, &child);
		gtk_tree_store_set (GTK_TREE_STORE (model), &child_fake,
				GSQL_NAV_TREE_ID,				-1,
				GSQL_NAV_TREE_IMAGE,			NULL,
				GSQL_NAV_TREE_NAME,				N_("Processing..."),
				GSQL_NAV_TREE_REALNAME,			NULL,
				GSQL_NAV_TREE_ITEM_INFO,		NULL,
				GSQL_NAV_TREE_SQL,				NULL,
				GSQL_NAV_TREE_OBJECT_POPUP,		NULL,
				GSQL_NAV_TREE_OBJECT_HANDLER,	NULL,
				GSQL_NAV_TREE_EXPAND_HANDLER,	NULL,
				GSQL_NAV_TREE_EVENT_HANDLER,	NULL,
				GSQL_NAV_TREE_STRUCT,			NULL,
				GSQL_NAV_TREE_NUM_ITEMS, 		NULL,
				-1);
	}
	
	GSQL_DEBUG ("Items fetched: [%d]", i);
	
	if (i > 0)
	{
		name = g_strdup_printf("%s<span weight='bold'> [%d]</span>", 
												realname, i);
		gtk_tree_store_set (GTK_TREE_STORE(model), iter,
							GSQL_NAV_TREE_NAME, 
							name,
							-1);
		g_free (name);
	}
	
	gtk_tree_store_remove(GTK_TREE_STORE(model), &child_last);
	
	gsql_cursor_close (cursor);
}
Ejemplo n.º 24
0
void
nav_tree_refresh_indexes (GSQLNavigation *navigation,
						 GtkTreeView *tv,
						 GtkTreeIter *iter)
{
	GSQL_TRACE_FUNC;

	GtkTreeModel *model;
	GtkListStore *detail;
	GSQLNavigation *nav = NULL;
	gchar			*sql = NULL;
	gchar			*realname = NULL;
	gchar			*owner = NULL;
	gint 		id;
	gint		i,n;
	GtkTreeIter child;
	GtkTreeIter parent;
	GtkTreeIter child_fake;
	GtkTreeIter	child_last;
	GSQLCursor *cursor;
	GSQLVariable *var, *var_t, *tmp = NULL;
	GSQLSession *session;
	GSQLWorkspace *workspace;
	GSQLCursorState state;
	GtkListStore *details;
	gchar *name;
	gchar *key;
	guint length = 0;
	gchar *stock = NULL;
	gchar *tbl = "%";
	gchar *parent_name = NULL;
	
	model = gtk_tree_view_get_model(tv);
	n = gtk_tree_model_iter_n_children(model, iter);
	
	for (; n>1; n--)
	{
		gtk_tree_model_iter_children (model, &child, iter);
		gtk_tree_store_remove (GTK_TREE_STORE(model), &child);
	}
	
	gtk_tree_model_iter_children(model, &child_last, iter);
	
	gtk_tree_model_get (model, iter,  
						GSQL_NAV_TREE_REALNAME, 
						&realname, -1);
	gtk_tree_model_get (model, iter,  
						GSQL_NAV_TREE_SQL, 
						&sql, -1);
	g_return_if_fail (sql != NULL);
	
	gtk_tree_model_get (model, iter,  
						GSQL_NAV_TREE_OWNER, 
						&owner, -1);
	
	session = gsql_session_get_active ();
	
	// get parent iter. if this iter are TABLE_ID then
	// we looking for table's constraints only.
	gtk_tree_model_iter_parent (model, &parent, iter);
	
	gtk_tree_model_get (model, &parent,  
						GSQL_NAV_TREE_ID, 
						&id, -1);
	
	gtk_tree_model_get (model, &parent,  
						GSQL_NAV_TREE_NAME, 
						&parent_name, -1);

	if ((id == TABLE_ID) && (parent_name != NULL))
		tbl = parent_name;
	GSQL_DEBUG ("realname:[%s]    sql:[%s]   owner:[%s]", realname, sql, owner);
	
	cursor = gsql_cursor_new (session, sql);
	state = gsql_cursor_open_with_bind (cursor,
										FALSE,
										GSQL_CURSOR_BIND_BY_POS,
										G_TYPE_STRING, tbl,
										-1);
	
	var = g_list_nth_data(cursor->var_list,0);
	var_t = g_list_nth_data(cursor->var_list,1);
	
	if (state != GSQL_CURSOR_STATE_OPEN)
	{
		gsql_cursor_close (cursor);
		return;		
	}
	
	i = 0;
	
	while (gsql_cursor_fetch (cursor, 1) > 0)
	{
		i++;
		
		if (var->value_type != G_TYPE_STRING)
		{
			GSQL_DEBUG ("The name of object should be a string (char *). Is the bug");
			name = N_("Incorrect data");
		} else {
			if (var->raw_to_value)
			{
				tmp = g_malloc0(sizeof(GSQLVariable));
				memcpy(tmp, var, sizeof(GSQLVariable));
				var->raw_to_value (tmp);
			}
			name = (gchar *) var->value;
			// make a key for a hash of details
			length = g_snprintf (NULL,0, "%x%s%d%s",
				   session, (gchar *) tmp->value, INDEX_ID, (gchar *) tmp->value);
			key = g_malloc0(length);
			memset (key, 0, length);
			g_snprintf (key, length - 1, "%x%s%d%s",
				   session, (gchar *) tmp->value, INDEX_ID, (gchar *) tmp->value);
			
			details = gsql_navigation_get_details (navigation, key);
			firebird_navigation_fill_details (cursor, details);
		}
		
		gtk_tree_store_append (GTK_TREE_STORE(model), &child, iter);
		gtk_tree_store_set (GTK_TREE_STORE(model), &child,
					GSQL_NAV_TREE_ID,			INDEX_ID,
					GSQL_NAV_TREE_OWNER,		owner,
					GSQL_NAV_TREE_IMAGE,		GSQL_STOCK_INDEXES,
					GSQL_NAV_TREE_NAME,			name,
					GSQL_NAV_TREE_REALNAME, 	(gchar *) tmp->value,
					GSQL_NAV_TREE_ITEM_INFO, 	NULL,
					GSQL_NAV_TREE_SQL,			NULL,
					GSQL_NAV_TREE_OBJECT_POPUP, NULL,
					GSQL_NAV_TREE_OBJECT_HANDLER, NULL,
					GSQL_NAV_TREE_EXPAND_HANDLER, NULL,
					GSQL_NAV_TREE_EVENT_HANDLER, NULL,
					GSQL_NAV_TREE_STRUCT, indexes,
					GSQL_NAV_TREE_DETAILS, details,
					GSQL_NAV_TREE_NUM_ITEMS, G_N_ELEMENTS(indexes),
					-1);
	
		gtk_tree_store_append (GTK_TREE_STORE (model), &child_fake, &child);
		gtk_tree_store_set (GTK_TREE_STORE (model), &child_fake,
				GSQL_NAV_TREE_ID,				-1,
				GSQL_NAV_TREE_IMAGE,			NULL,
				GSQL_NAV_TREE_NAME,				N_("Processing..."),
				GSQL_NAV_TREE_REALNAME,			NULL,
				GSQL_NAV_TREE_ITEM_INFO,		NULL,
				GSQL_NAV_TREE_SQL,				NULL,
				GSQL_NAV_TREE_OBJECT_POPUP,		NULL,
				GSQL_NAV_TREE_OBJECT_HANDLER,	NULL,
				GSQL_NAV_TREE_EXPAND_HANDLER,	NULL,
				GSQL_NAV_TREE_EVENT_HANDLER,	NULL,
				GSQL_NAV_TREE_STRUCT,			NULL,
				GSQL_NAV_TREE_NUM_ITEMS, 		NULL,
				-1);
		g_free (key);
		if (tmp) g_free(tmp);
	}
	GSQL_DEBUG ("Items fetched: [%d]", i);
	
	if (i > 0)
	{
		name = g_strdup_printf("%s<span weight='bold'> [%d]</span>", 
												realname, i);
		gtk_tree_store_set (GTK_TREE_STORE(model), iter,
							GSQL_NAV_TREE_NAME, 
							name,
							-1);
		g_free (name);
	}
	
	gtk_tree_store_remove(GTK_TREE_STORE(model), &child_last);
	
	gsql_cursor_close (cursor);

}
Ejemplo n.º 25
0
// start helpers
static void swap_buses (GtkTreeModel *tm, GtkTreeSelection *sel, bus_layout_D *dialog, GtkTreePath *tpSrc, GtkTreePath *tpDst)
  {
  int Nix ;
  GtkTreeIter itr ;
  SWAP_BUSES_STRUCT src, dst ;
  SWAP_BUSES_STRUCT *min = NULL, *max = NULL ;
  EXP_ARRAY *ar_bSelSrc = NULL, *ar_bSelDst = NULL ;
  gboolean bDstExpanded = TRUE ;

  if (!gtk_tree_model_get_iter (tm, &(src.itr), tpSrc)) return ;
  src.tp = gtk_tree_path_copy (tpSrc) ;
  src.icChildren = gtk_tree_model_iter_n_children (tm, &(src.itr)) ;

  if (!gtk_tree_model_get_iter (tm, &(dst.itr), tpDst))
    {
    gtk_tree_path_free (src.tp) ;
    return ;
    }
  dst.tp = gtk_tree_path_copy (tpDst) ;
  dst.icChildren = gtk_tree_model_iter_n_children (tm, &(dst.itr)) ;

  if (dst.icChildren < src.icChildren)
    {
    min = &dst ;
    max = &src ;
    }
  else
    {
    min = &src ;
    max = &dst ;
    }

  bDstExpanded = gtk_tree_view_row_expanded (gtk_tree_selection_get_tree_view (sel), dst.tp) ;

  g_signal_handlers_block_matched (G_OBJECT (sel), G_SIGNAL_MATCH_FUNC, 0, 0, NULL, (gpointer)tree_view_selection_changed, NULL) ;

  for (Nix = 0 ; Nix < max->icChildren - min->icChildren ; Nix++)
    gtk_tree_store_append (GTK_TREE_STORE (tm), &itr, &(min->itr)) ;

  gtk_tree_path_down (src.tp) ;
  gtk_tree_path_down (dst.tp) ;

  ar_bSelSrc = exp_array_new (sizeof (gboolean), 1) ;
  ar_bSelDst = exp_array_new (sizeof (gboolean), 1) ;
  exp_array_1d_insert_vals (ar_bSelSrc, NULL, max->icChildren, 0) ;
  exp_array_1d_insert_vals (ar_bSelDst, NULL, max->icChildren, 0) ;

  for (Nix = 0 ; Nix < max->icChildren ; Nix++)
    {
    exp_array_index_1d (ar_bSelSrc, gboolean, Nix) =
      gtk_tree_selection_path_is_selected (sel, src.tp) ;
    exp_array_index_1d (ar_bSelDst, gboolean, Nix) =
      gtk_tree_selection_path_is_selected (sel, dst.tp) ;

    gtk_tree_path_next (src.tp) ;
    gtk_tree_path_next (dst.tp) ;
    }

  if (!gtk_tree_path_up (src.tp)) goto swap_buses_quit ;
  if (!gtk_tree_path_up (dst.tp)) goto swap_buses_quit ;
  gtk_tree_path_down (src.tp) ;
  gtk_tree_path_down (dst.tp) ;

  for (Nix = 0 ; Nix < max->icChildren ; Nix++)
    {
    if (exp_array_index_1d (ar_bSelDst, gboolean, Nix))
      gtk_tree_view_expand_to_path (gtk_tree_selection_get_tree_view (sel), src.tp) ;

    if (exp_array_index_1d (ar_bSelSrc, gboolean, Nix))
      gtk_tree_view_expand_to_path (gtk_tree_selection_get_tree_view (sel), dst.tp) ;

    gtk_tree_path_next (src.tp) ;
    gtk_tree_path_next (dst.tp) ;
    }

  if (!gtk_tree_path_up (src.tp)) goto swap_buses_quit ;
  if (!gtk_tree_path_up (dst.tp)) goto swap_buses_quit ;
  gtk_tree_path_down (src.tp) ;
  gtk_tree_path_down (dst.tp) ;

  for (Nix = 0 ; Nix < max->icChildren ; Nix++)
    {
    swap_model_paths_contents (tm, src.tp, dst.tp) ;
    gtk_tree_path_next (src.tp) ;
    gtk_tree_path_next (dst.tp) ;
    }

  if (!gtk_tree_path_up (src.tp)) goto swap_buses_quit ;
  if (!gtk_tree_path_up (dst.tp)) goto swap_buses_quit ;
  gtk_tree_path_down (src.tp) ;
  gtk_tree_path_down (dst.tp) ;

  for (Nix = 0 ; Nix < max->icChildren ; Nix++)
    {
    GTK_TREE_SELECTION_SET_PATH_SELECTED (sel, src.tp, exp_array_index_1d (ar_bSelDst, gboolean, Nix)) ;
    GTK_TREE_SELECTION_SET_PATH_SELECTED (sel, dst.tp, exp_array_index_1d (ar_bSelSrc, gboolean, Nix)) ;
    gtk_tree_path_next (src.tp) ;
    gtk_tree_path_next (dst.tp) ;
    }

  if (!gtk_tree_path_up (src.tp)) goto swap_buses_quit ;
  if (!gtk_tree_path_up (dst.tp)) goto swap_buses_quit ;

  swap_model_paths_contents (tm, src.tp, dst.tp) ;

  gtk_tree_path_down (src.tp) ;
  gtk_tree_path_down (dst.tp) ;

  for (Nix = 0 ; Nix < min->icChildren ; Nix++)
    gtk_tree_path_next (max->tp) ;
  if (gtk_tree_model_get_iter (tm, &itr, max->tp))
    while (gtk_tree_store_remove (GTK_TREE_STORE (tm), &itr)) ;

  if (!bDstExpanded)
    {
    for (Nix = 0 ; Nix < ar_bSelDst->icUsed ; Nix++)
      if (exp_array_index_1d (ar_bSelDst, gboolean, Nix))
        break ;

    if (Nix == ar_bSelDst->icUsed)
      if (gtk_tree_path_up (src.tp))
        gtk_tree_view_collapse_row (gtk_tree_selection_get_tree_view (sel), src.tp) ;
    }

swap_buses_quit:

  exp_array_free (ar_bSelSrc) ;
  exp_array_free (ar_bSelDst) ;
  gtk_tree_path_free (src.tp) ;
  gtk_tree_path_free (dst.tp) ;
  g_signal_handlers_unblock_matched (G_OBJECT (sel), G_SIGNAL_MATCH_FUNC, 0, 0, NULL, (gpointer)tree_view_selection_changed, NULL) ;
  tree_view_selection_changed (sel, dialog) ;
  }
Ejemplo n.º 26
0
/* 
 * watch expression has been changed
 */
static void on_watch_changed(GtkCellRendererText *renderer, gchar *path, gchar *new_text, gpointer user_data)
{
	/* get iterator to the changed row */
	GtkTreeIter  iter;
	GtkTreePath *tree_path = gtk_tree_path_new_from_string (path);
	gtk_tree_model_get_iter (
		 gtk_tree_view_get_model(GTK_TREE_VIEW(wtree)),
		 &iter,
		 tree_path);
	
	/* get oldvalue */
	gchar* oldvalue;
	gtk_tree_model_get (
		wmodel,
		&iter,
		W_NAME, &oldvalue,
       -1);
	gchar *internal = NULL;
		gtk_tree_model_get (
		wmodel,
		&iter,
		W_INTERNAL, &internal,
		-1);

	/* check if it is empty row */
	gboolean is_empty_row = !gtk_tree_path_compare (tree_path, wtree_empty_path());

   	gchar *striped = g_strstrip(g_strdup(new_text));
	if (!strlen(striped) &&
		!is_empty_row &&
		dialogs_show_question(_("Delete variable?")))
	{
		/* if new value is empty string on non-empty row
		 * offer to delete watch */
		gtk_tree_store_remove(wstore, &iter);
		if (DBS_STOPPED == debug_state)
			active_module->remove_watch(internal);

		config_set_debug_changed();
	}
	else if (strcmp(oldvalue, striped))
    {
		/* new value is non empty */

		/* insert new row if changing was the last empty row */
		GtkTreeIter newiter;
		if (is_empty_row)
			gtk_tree_store_insert_before(wstore, &newiter, NULL, &iter);
		
		/* set expression */
		variable_set_name_only(wstore, is_empty_row ? &newiter : &iter, striped);

		/* if debug is active - remove old watch and add new one */
		if (DBS_STOPPED == debug_state)
		{
			active_module->remove_watch(internal);
			variable *newvar = active_module->add_watch(striped);
			change_watch(GTK_TREE_VIEW(wtree), is_empty_row ? &newiter : &iter, newvar);
		}
		
		/* if new watch has been added - set selection to the new created row */
		if (is_empty_row)
		{
			GtkTreePath *_path = gtk_tree_model_get_path(wmodel, &newiter);
			GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(wtree));
			gtk_tree_selection_unselect_all(selection);
			gtk_tree_selection_select_path(selection, _path);
			gtk_tree_path_free(_path);
		}

		config_set_debug_changed();
	}
	
	/* free resources */
	gtk_tree_path_free(tree_path);
	g_free(oldvalue);
	g_free(internal);
	g_free(striped);
}