/**
 * Callback called when toggle the check button to sort by method of payment
 *
 * \param cell
 * \param path_str
 * \param tree_view
 *
 * \return FALSE
 */
gboolean gsb_reconcile_sort_config_payment_toggled ( GtkCellRendererToggle *cell,
						     gchar *path_str,
						     GtkWidget *tree_view )
{
    GtkTreePath * treepath;
    GtkTreeIter iter;
    gboolean toggle;
    gint account_number;
    GtkTreeModel *model;

    model = gtk_tree_view_get_model (GTK_TREE_VIEW (tree_view));

    treepath = gtk_tree_path_new_from_string ( path_str );
    gtk_tree_model_get_iter ( GTK_TREE_MODEL (model),
			      &iter, treepath );

    gtk_tree_model_get (GTK_TREE_MODEL(model), &iter,
			RECONCILIATION_SORT_SORT_COLUMN, &toggle,
			RECONCILIATION_SORT_ACCOUNT_COLUMN, &account_number,
			-1);

    toggle ^= 1;

    /* set new value */
    gtk_tree_store_set (GTK_TREE_STORE (model), &iter,
			RECONCILIATION_SORT_SORT_COLUMN, toggle,
			-1);

    /* Set to 1 (sort by types) if toggle is selected */
    gsb_data_account_set_reconcile_sort_type ( account_number,
					       toggle );

    if (toggle)
	gtk_tree_view_expand_row ( GTK_TREE_VIEW(tree_view), treepath, FALSE );
    else
	gtk_tree_view_collapse_row ( GTK_TREE_VIEW(tree_view), treepath );

    gtk_tree_path_free ( treepath );
    gsb_file_set_modified ( TRUE );
    return FALSE;
}
Example #2
0
File: main.c Project: soreau/gtk
void
row_activated_cb (GtkTreeView       *tree_view,
                  GtkTreePath       *path,
                  GtkTreeViewColumn *column)
{
  GtkTreeIter iter;
  PangoStyle style;
  GDoDemoFunc func;
  GtkWidget *window;
  GtkTreeModel *model;

  model = gtk_tree_view_get_model (tree_view);

  gtk_tree_model_get_iter (model, &iter, path);
  gtk_tree_model_get (GTK_TREE_MODEL (model),
                      &iter,
                      FUNC_COLUMN, &func,
                      STYLE_COLUMN, &style,
                      -1);

  if (func)
    {
      gtk_tree_store_set (GTK_TREE_STORE (model),
                          &iter,
                          STYLE_COLUMN, (style == PANGO_STYLE_ITALIC ? PANGO_STYLE_NORMAL : PANGO_STYLE_ITALIC),
                          -1);
      window = (func) (gtk_widget_get_toplevel (GTK_WIDGET (tree_view)));

      if (window != NULL)
        {
          CallbackData *cbdata;

          cbdata = g_new (CallbackData, 1);
          cbdata->model = model;
          cbdata->path = gtk_tree_path_copy (path);

          g_signal_connect (window, "destroy",
                            G_CALLBACK (window_closed_cb), cbdata);
        }
    }
}
Example #3
0
/* this function will load the bookmarks
 * from bfwin->session->bmarks and parse
 * them into treestore bfwin->bookmarkstore
 *
 * this function should ALSO check all dcouments that are
 * opened (bfwin->documentlist) if they have bookmarks !!
 */
void bmark_reload(Tbfwin * bfwin)
{
	GList *tmplist = g_list_first(bfwin->session->bmarks);
	DEBUG_MSG("bmark_reload for bfwin %p\n",bfwin);
	if (bfwin->bmark_files != NULL)
		g_hash_table_destroy(bfwin->bmark_files);
	bfwin->bmark_files = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
	while (tmplist) {
		gchar **items = (gchar **) tmplist->data;
		if (items && count_array(items) == 6) {
			gchar *ptr;
			Tbmark *b;
			b = g_new0(Tbmark, 1);
			b->name = g_strdup(items[0]);
			b->description = g_strdup(items[1]);
			b->filepath = g_strdup(items[2]);
			b->offset = atoi(items[3]);
			b->text = g_strdup(items[4]);
			b->len = atoi(items[5]);
			b->strarr = items;
			bmark_get_iter_at_tree_position(bfwin, b);
			if (b->name && strlen(b->name)>0) {
				ptr = g_strconcat(b->name, " - ", b->text, NULL);
			} else {
				ptr = g_strdup(b->text);
			}
			gtk_tree_store_set(bfwin->bookmarkstore, &(b->iter), NAME_COLUMN, ptr, PTR_COLUMN, b,
							   -1);
			g_free(ptr);
		}
		tmplist = g_list_next(tmplist);
	}
	
	tmplist = g_list_first(bfwin->documentlist);
	while (tmplist) {
		DEBUG_MSG("bmark_reload, calling bmark_set_for_doc for doc=%p\n",tmplist->data);
		bmark_set_for_doc(DOCUMENT(tmplist->data));
		bmark_check_length(bfwin, DOCUMENT(tmplist->data));
		tmplist = g_list_next(tmplist);
	}
}
Example #4
0
static chan *
chanview_add_real (chanview *cv, char *name, void *family, void *userdata,
						 gboolean allow_closure, int tag, GdkPixbuf *icon,
						 chan *ch, chan *avoid)
{
	GtkTreeIter parent_iter;
	GtkTreeIter iter;
	gboolean has_parent = FALSE;

	if (chanview_find_parent (cv, family, &parent_iter, avoid))
	{
		chanview_insert_sorted (cv, &iter, &parent_iter, userdata);
		has_parent = TRUE;
	} else
	{
		gtk_tree_store_append (cv->store, &iter, NULL);
	}

	if (!ch)
	{
		ch = g_new0 (chan, 1);
		ch->userdata = userdata;
		ch->family = family;
		ch->cv = cv;
		ch->allow_closure = allow_closure;
		ch->tag = tag;
		ch->icon = icon;
	}
	memcpy (&(ch->iter), &iter, sizeof (iter));

	gtk_tree_store_set (cv->store, &iter, COL_NAME, name, COL_CHAN, ch,
							  COL_PIXBUF, icon, -1);

	cv->size++;
	if (!has_parent)
		ch->impl = cv->func_add (cv, ch, name, NULL);
	else
		ch->impl = cv->func_add (cv, ch, name, &parent_iter);

	return ch;
}
Example #5
0
void
search_preferences_init(void)
{
	GConfClient *client;
	GSList *list;
	GtkTreeModel *model;
	GtkTreeIter iter;

	sr = create_search_replace_instance(NULL);

	search_preferences_add_treeview(BASIC);
	
	client = gconf_client_get_default();
	gconf_client_add_dir(client, SEARCH_PREF_PATH, GCONF_CLIENT_PRELOAD_NONE, NULL);
	
	list_pref = gconf_client_get_list(client,gconf_concat_dir_and_key(SEARCH_PREF_PATH, 
	                                  "list_pref"), GCONF_VALUE_STRING, NULL);
		
	for (list = list_pref; list != NULL; list = g_slist_next(list))
		search_preferences_add_treeview(list->data);
	
	default_pref = gconf_client_get_string(client,gconf_concat_dir_and_key(SEARCH_PREF_PATH, 
	                                       "search_pref_default"), NULL);

	model = search_preferences_get_model();
	gtk_tree_model_foreach (model, on_search_preferences_setting_inactive, NULL);
	
	if (default_pref && (*default_pref != '\0') && g_ascii_strcasecmp (default_pref, BASIC))	
		search_preferences_read_setting(gconf_concat_dir_and_key(SEARCH_PREF_PATH, 
		                                default_pref));
	else
	{
		gtk_tree_model_get_iter_first(model, &iter);
		gtk_tree_store_set (GTK_TREE_STORE (model), &iter,
						    PREF_ACTIVE_COLUMN, TRUE, -1);
		search_preferences_setting_by_default();
	}
	
	search_preferences_activate_default(default_pref);
	g_free(default_pref);
}
static void sensor_config_dialog_offset_changed(GtkSpinButton *spinbutton, SensorConfigDialog *config_dialog) {
	GtkTreeModel *model;
	GtkTreePath *path;
	GtkTreeIter iter;
	gdouble value;

	value = gtk_spin_button_get_value(spinbutton);
	
	gtk_tree_selection_get_selected(config_dialog->sensors_applet->selection,
					&model,
					&iter);
	path = gtk_tree_model_get_path(GTK_TREE_MODEL(config_dialog->sensors_applet->sensors),
				       &iter);
	gtk_tree_store_set(config_dialog->sensors_applet->sensors,
			    &iter,
			    OFFSET_COLUMN, value,
			   -1);

	sensors_applet_update_sensor(config_dialog->sensors_applet, path);
	gtk_tree_path_free(path);
}
Example #7
0
static void
netlist_disable_all_cb (GtkToggleButton * button, gpointer data)
{
  GtkTreeIter iter;
  gboolean active = gtk_toggle_button_get_active (button);
  LibraryMenuType *menu;

  /* Get each net iter and change the NET_ENABLED_COLUMN to a "*" or ""
     |  to flag it as disabled or enabled based on toggle button state.
   */
  if (gtk_tree_model_get_iter_first (net_model, &iter))
    do
      {
	gtk_tree_store_set (GTK_TREE_STORE (net_model), &iter,
			    NET_ENABLED_COLUMN, active ? "*" : "", -1);
	/* set/clear the flag which says the net is enabled or disabled */
	gtk_tree_model_get (net_model, &iter, NET_LIBRARY_COLUMN, &menu, -1);
	menu->flag = active ? 0 : 1;
      }
    while (gtk_tree_model_iter_next (net_model, &iter));
}
Example #8
0
static void gglk_radio_toggled(GtkCellRendererToggle *cell, gchar *path_str,
			       gpointer user_data)
{

  GtkTreeModel *model = GTK_TREE_MODEL(user_data);
  GtkTreePath *path = gtk_tree_path_new_from_string (path_str);
  GtkTreeIter iter;

  gint *column;

  column = g_object_get_data (G_OBJECT (cell), "column");

  /* get toggled iter */
  gtk_tree_model_get_iter (model, &iter, path);

  /* toggle the item on */
  gtk_tree_store_set (GTK_TREE_STORE (model), &iter, column, TRUE, -1);

  /* clean up */
  gtk_tree_path_free (path);
}
Example #9
0
static void tree_config_update_priorities(void)
{
	GtkTreeModel *model;
	GtkTreeIter iter;
	int x=1;
	
	model = GTK_TREE_MODEL(tree_config_get_store());
	
	if (gtk_tree_model_get_iter_first(model, &iter) == FALSE)
	{
		//fprintf(stderr, "Warning: tree_config_update_priorities cannot find iter. Config tree is empty.\n");
		return;
	}
	
	do
	{
		gtk_tree_store_set(	GTK_TREE_STORE(model), &iter,
							COL_PRIORITY, x++,
							-1);
	} while (gtk_tree_model_iter_next(model, &iter) != FALSE);
}
/*! \fn gboolean CDesktopAppChooser::m_AddAppsMenuTopLevelNode(GMenuTreeDirectory *appsDir)
    \brief To create top-level(Directory) nodes.

    \param[in] appsDir.
    \return TRUE or FALSE
*/
gboolean CDesktopAppChooser::m_AddAppsMenuTopLevelNode(GMenuTreeDirectory *appsDir)
{
  GdkPixbuf *pixbuf = NULL;

  /* To get PixelBuffer of the Directory icon. */
  pixbuf = m_LoadIcon(gmenu_tree_directory_get_icon(appsDir), IMG_SIZE, TRUE ); 

  /* To set the columns' content. */
  gtk_tree_store_append(m_TreeStore, &m_TopLevelNodeIter, NULL);
  gtk_tree_store_set(m_TreeStore, &m_TopLevelNodeIter,
                     COLUMN_ICON, pixbuf,
                     COLUMN_TEXT, gmenu_tree_directory_get_name(appsDir),
                     COLUMN_NODEDATA, NULL,
                     -1);

  /* pixbuf has a referece count of "1" now, as the tree store has added its own reference. 
     So to decrease the reference count of pixbuf. */
  g_object_unref(pixbuf);

  return true;
}
Example #11
0
void tree_item___::store_add__(callback_item___* si, GdkPixbuf *pixbuf, int posi) {
	GtkTreeIter iter2;
	GtkTreePath *path;
	if(!up_.empty()) {
		path = gtk_tree_path_new_from_string (up_.c_str());
		gtk_tree_model_get_iter(model__(), &iter2, path);
		gtk_tree_path_free (path);
	}

	GtkTreeIter iter;
	gtk_tree_store_append (store_, &iter, up_.empty() ? NULL : &iter2);
	gtk_tree_store_set(store_, &iter,
			ID_COLUMN, si->id_,
			PIXBUF_COLUMN, pixbuf,
			TITLE_COLUMN, si->title_.c_str(),
			-1);

	path = gtk_tree_model_get_path (model__(), &iter);
	last_ = gtk_tree_path_to_string (path);
	gtk_tree_path_free (path);
}
Example #12
0
void
add_text_combo_item_to_cbox(GtkTreeStore *list, GtkTreeIter *iter, GtkTreeIter *parent, int column_id, int enum_id, const char *title, enum TOGGLE_TYPE type, int active)
{
  GtkTreeIter locl_iter;

  if (iter == NULL) {
    iter = &locl_iter;
  }

  gtk_tree_store_append(list, iter, parent);
  gtk_tree_store_set(list, iter,
		     OBJECT_COLUMN_TYPE_STRING, title,
		     OBJECT_COLUMN_TYPE_PIXBUF, NULL,
		     OBJECT_COLUMN_TYPE_INT, column_id,
		     OBJECT_COLUMN_TYPE_TOGGLE_VISIBLE, type != TOGGLE_NONE,
		     OBJECT_COLUMN_TYPE_TOGGLE_IS_RADIO, type == TOGGLE_RADIO,
		     OBJECT_COLUMN_TYPE_TOGGLE, active,
		     OBJECT_COLUMN_TYPE_PIXBUF_VISIBLE, FALSE,
		     OBJECT_COLUMN_TYPE_ENUM, enum_id,
		     -1);
}
Example #13
0
void TreeDict::load_model(gchar **buffer, GtkTreeIter *parent, guint32 count)
{
	GtkTreeIter iter;
	gchar *p1;
	guint32 offset, size, subentry_count;

	for (guint32 i=0; i< count; i++) {
		p1 = *buffer + strlen(*buffer) +1;
		offset = g_ntohl(get_uint32(p1));
		p1 += sizeof(guint32);
		size = g_ntohl(get_uint32(p1));
		p1 += sizeof(guint32);
		subentry_count = g_ntohl(get_uint32(p1));
		p1 += sizeof(guint32);
		gtk_tree_store_append(model, &iter, parent);
		gtk_tree_store_set(model, &iter, 0, *buffer, 1, offset, 2, size, -1);
		*buffer = p1;
		if (subentry_count)
			load_model(buffer, &iter, subentry_count);
	}
}
Example #14
0
static GtkTreeModel *create_model_for_photo(gchar *prefix_path) {
  GtkTreeStore *store = NULL;
  GtkTreeIter iter;
  GDir *dir = NULL;
  gchar path[1024] = {0};
  GError *err = NULL;

  store = gtk_tree_store_new(BM_NUM_COL, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING);

  if(! prefix_path)
    prefix_path = PHOTO_PATH;

  dir = g_dir_open(prefix_path, 0, &err);
  if(dir) {
    const gchar *name = NULL;
    while(name = g_dir_read_name(dir)) {
      //DEBUG("path name = %s\n", name);
      snprintf(path, 1024, "%s/%s", prefix_path, name);
      if(g_file_test(path, G_FILE_TEST_IS_DIR)) {
        gchar file[1024] = {0}, logo[1024] = {0};
        if(scan_photo_path(path, file, logo, NULL)) {
          GdkPixbuf *pixbuf = NULL;
          GError *err = NULL;

          DD("load pixbuf %s\n", logo);
          pixbuf = gdk_pixbuf_new_from_file_at_scale(logo, MEDIAUI_TREE_MODEL_ICON_SIZE, MEDIAUI_TREE_MODEL_ICON_SIZE, TRUE, &err);
          if(pixbuf) {
            gtk_tree_store_append(store, &iter, NULL);
            gtk_tree_store_set(store, &iter, BM_PIXBUF_COL, pixbuf, BM_TITLE_COL, name, BM_URL_COL, logo, -1);
            g_object_unref(pixbuf);
          }
        }/**g_file_test*/
      }
    } /**while(read_dir_name)*/

    g_dir_close(dir);
  }

  return GTK_TREE_MODEL(store);
}
Example #15
0
File: main.c Project: DomN86/OpenRA
void make_tree_view(void)
{
  GtkTreeIter iter;
  GtkCellRenderer * pixbuf_renderer, * text_renderer;
  GtkTreeViewColumn * icon_column, * name_column;

  tree_store = gtk_tree_store_new(N_COLUMNS, GDK_TYPE_PIXBUF, 
				  G_TYPE_STRING, G_TYPE_STRING);

  gtk_tree_store_append(tree_store, &iter, NULL);
  gtk_tree_store_set(tree_store, &iter, 
		     NAME_COLUMN, "MODS",
		     -1);

  tree = GTK_TREE_VIEW(gtk_tree_view_new_with_model(
					GTK_TREE_MODEL(tree_store)));
  g_object_set(tree, "headers-visible", FALSE, NULL);
  g_signal_connect(tree, "cursor-changed", 
		   G_CALLBACK(tree_view_selection_changed), NULL);

  pixbuf_renderer = gtk_cell_renderer_pixbuf_new();
  text_renderer = gtk_cell_renderer_text_new();

  icon_column = gtk_tree_view_column_new_with_attributes
    ("Icon", pixbuf_renderer,
     "pixbuf", ICON_COLUMN,
     NULL);

  gtk_tree_view_column_set_sizing(icon_column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);

  name_column = gtk_tree_view_column_new_with_attributes
    ("Name", text_renderer,
     "text", NAME_COLUMN,
     NULL);

  gtk_tree_view_column_set_sizing(name_column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);

  gtk_tree_view_append_column(tree, icon_column);
  gtk_tree_view_append_column(tree, name_column);
}
Example #16
0
void world_tree_app_state_changed(graph_view_handle view, uint64_t id, const char * app_name, bool running, bool terminal, const char * level)
{
  GtkTreeIter view_iter;
  GtkTreeIter app_iter;
  const char * view_name;
  GtkTreePath * path;
  char * app_name_with_status;

  if (!find_app(view, id, &view_iter, &app_iter))
  {
    log_error("removed app not found");
    return;
  }

  path = gtk_tree_model_get_path(GTK_TREE_MODEL(g_treestore), &view_iter);

  gtk_tree_model_get(GTK_TREE_MODEL(g_treestore), &view_iter, COL_NAME, &view_name, -1);

  log_info("changing app state '%s':'%s'", view_name, app_name);

  app_name_with_status = get_app_name_string(app_name, running, terminal, level);
  if (app_name_with_status == NULL)
  {
    goto free_path;
  }

  gtk_tree_view_expand_row(GTK_TREE_VIEW(g_world_tree_widget), path, false);
  gtk_tree_store_set(
    g_treestore,
    &app_iter,
    COL_NAME, app_name_with_status,
    COL_RUNNING, running,
    COL_TERMINAL, terminal,
    COL_LEVEL, level,
    -1);

  free(app_name_with_status);
free_path:
  gtk_tree_path_free(path);
}
static void
build_combo_box (GtkComboBox *box)
{
  ChamplainMapSourceFactory *factory;
  GSList *sources, *iter;
  GtkTreeStore *store;
  GtkTreeIter parent;
  GtkCellRenderer *cell;

  store = gtk_tree_store_new (N_COLS, G_TYPE_STRING, /* id */
        G_TYPE_STRING, /* name */
        -1);

  factory = champlain_map_source_factory_dup_default ();
  sources = champlain_map_source_factory_get_registered (factory);

  iter = sources;
  while (iter != NULL)
    {
      ChamplainMapSourceDesc *desc = CHAMPLAIN_MAP_SOURCE_DESC (iter->data);
      const gchar *id = champlain_map_source_desc_get_id (desc);
      const gchar *name = champlain_map_source_desc_get_name (desc);

      gtk_tree_store_append (store, &parent, NULL);
      gtk_tree_store_set (store, &parent, COL_ID, id,
          COL_NAME, name, -1);

      iter = g_slist_next (iter);
    }

  g_slist_free (sources);
  g_object_unref (factory);

  gtk_combo_box_set_model (box, GTK_TREE_MODEL (store));

  cell = gtk_cell_renderer_text_new ();
  gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (box), cell, FALSE);
  gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (box), cell,
      "text", COL_NAME, NULL);
}
Example #18
0
void
add_mark_combo_item_to_cbox(GtkTreeStore *list, GtkTreeIter *iter, GtkTreeIter *parent, int column_id, struct objlist *obj, const char *field, int id)
{
  int j, type;
  GtkTreeIter locl_iter;

  if (iter == NULL) {
    iter = &locl_iter;
  }

  type = -1;
  getobj(obj, field, id, 0, NULL, &type);


  for (j = 0; j < MARK_TYPE_NUM; j++) {
    GdkPixbuf *pixbuf;
#if GTK_CHECK_VERSION(3, 0, 0)
    pixbuf = gdk_pixbuf_get_from_surface(NgraphApp.markpix[j],
					 0, 0, MARK_PIX_SIZE, MARK_PIX_SIZE);
#else
    pixbuf = gdk_pixbuf_get_from_drawable(NULL, NgraphApp.markpix[j], NULL, 0, 0, 0, 0, -1, -1);
#endif
    if (pixbuf) {
      char buf[64];

      gtk_tree_store_append(list, iter, parent);
      snprintf(buf, sizeof(buf), "%02d ", j);
      gtk_tree_store_set(list, iter,
			 OBJECT_COLUMN_TYPE_STRING, buf,
			 OBJECT_COLUMN_TYPE_PIXBUF, pixbuf,
			 OBJECT_COLUMN_TYPE_INT, column_id,
			 OBJECT_COLUMN_TYPE_TOGGLE_VISIBLE, TRUE,
			 OBJECT_COLUMN_TYPE_TOGGLE_IS_RADIO, TRUE,
			 OBJECT_COLUMN_TYPE_TOGGLE, j == type,
			 OBJECT_COLUMN_TYPE_ENUM, j,
			 -1);
      g_object_unref(pixbuf);
    }
  }
}
Example #19
0
//funcion que aƱade un coche a la lista y guarda en fichero
static void add_car(GtkButton *widget, gpointer data)
{
	GObject **widgs;
	struct coche *c;
	GtkWidget *entry_ptr_marca;
	GtkWidget *entry_ptr_matricula;
	GtkTreeStore *store;
	GtkTreeIter iter;
	const gchar *matricula, *marca;

	widgs = (GObject **)data;
	entry_ptr_marca = (GtkWidget *)widgs[1];
	entry_ptr_matricula = (GtkWidget *)widgs[2];
	store = (GtkTreeStore *)widgs[3];

	marca = gtk_entry_get_text((GtkEntry *)entry_ptr_marca);
	matricula = gtk_entry_get_text((GtkEntry *)entry_ptr_matricula);

	c = curso_coche_alloc();
	if (c == NULL)
		return;

	curso_coche_attr_set_u32(c, CURSO_COCHE_ATTR_ID, id++);
	curso_coche_attr_set_str(c, CURSO_COCHE_ATTR_MATRICULA,	matricula);
	curso_coche_attr_set_str(c, CURSO_COCHE_ATTR_MARCA, marca);

	curso_concesionario_attr_set_coche(con, CURSO_CONCESIONARIO_ATTR_COCHE,
					   c);

	gtk_tree_store_append (store, &iter, NULL);
        gtk_tree_store_set (store, &iter,
                        0, FALSE,
                        1, id - 1,
                        2, marca,
                        3, matricula, -1);

	write_concesionario_to_file(path, con);

	gtk_widget_destroy((GtkWidget *) widgs[0]);
}
Example #20
0
static void
add_child (GtkTreeStore   *store,
           GimpHelpDomain *domain,
           GimpHelpLocale *locale,
           GtkTreeIter    *parent,
           GimpHelpItem   *item,
           gint            depth)
{
  GtkTreeIter  iter;
  GList       *list;
  gchar       *uri;

  gtk_tree_store_append (store, &iter, parent);

  gtk_tree_store_set (store, &iter,
                      0, item,
                      1, item->title,
                      -1);

  uri = g_strconcat (domain->help_uri,  "/",
                     locale->locale_id, "/",
                     item->ref,
                     NULL);

  g_hash_table_insert (uri_hash_table,
                       uri,
                       gtk_tree_iter_copy (&iter));

  if (depth + 1 == GIMP_HELP_BROWSER_INDEX_MAX_DEPTH)
    return;

  item->children = g_list_sort (item->children, help_item_compare);

  for (list = item->children; list; list = g_list_next (list))
    {
      GimpHelpItem *item = list->data;

      add_child (store, domain, locale, &iter, item, depth + 1);
    }
}
Example #21
0
G_MODULE_EXPORT void
on_edit_activate2(GtkMenuItem *menuitem, gpointer user_data)
{
	INFO *info;
	EDITOR *editor = (EDITOR *)user_data;
	GtkWidget *tree = GTK_WIDGET(editor->treeview);
	gint test;
	GS_DIALOG *d;

	info = _get_info(tree);

	d = gui_new_dialog();
#ifdef HAVE_GTK_310
	d->stock_icon = "dialog-question";
#else
	d->stock_icon = GTK_STOCK_DIALOG_QUESTION;
#endif
	d->title = _("Prayer List/Journal Item");
	d->label_top = _("New name");
	d->label1 = _("Name: ");
	d->text1 = g_strdup(info->local_name);
	d->ok = TRUE;
	d->cancel = TRUE;

	test = gui_gs_dialog(d);
	if (test == GS_OK) {
		main_treekey_set_local_name(info->book,
					    d->text1, info->offset);
		gtk_tree_store_set(GTK_TREE_STORE(info->model),
				   &info->iter,
				   COL_CAPTION, (gchar *)d->text1, -1);
	}

	g_free(info->book);
	g_free(info->local_name);
	g_free(info->offset);
	g_free(info);
	g_free(d->text1);
	g_free(d);
}
Example #22
0
void UzblTreeTab::UpdateTablist()
{
    int i = 0;
    
    for(GList* l = uzblinstances; l != NULL; l = g_list_next(l)) {
        GtkTreeIter iter;
        char str[1024];
        memset(str, 0, 1024);
        
        //UzblInstance* uz = (UzblInstance*)g_list_nth(uzblinstances, i)->data;
        UzblInstance* uz = (UzblInstance*)l->data;
        //uz->SetNum(i);
        
        GtkTreeRowReference* r = uz->GetRowRef();
        GtkTreePath* p = gtk_tree_row_reference_get_path(r);
        gtk_tree_model_get_iter(GTK_TREE_MODEL(tabmodel), &iter, p);
        
        sprintf(str, "%d: %s", i++, uz->GetTitle());
        gtk_tree_store_set(GTK_TREE_STORE(tabmodel), &iter,
                       0, str, -1);
    }
}
Example #23
0
static void
item_list_view_add_item_to_tree_store (ItemListView *ilv, GtkTreeStore *itemstore, itemPtr item)
{
	gint		state = 0;
	nodePtr		node;
	GtkTreeIter	*iter;
	GtkTreeIter	old_iter;
	gboolean	exists;
		
	if (item->flagStatus)
		state += 2;
	if (!item->readStatus)
		state += 1;
		
	node = node_from_id (item->nodeId);
	if(!node)
		return;	/* comment items do cause this... maybe filtering them earlier would be a good idea... */
		
	exists = item_list_view_id_to_iter (ilv, item->id, &old_iter);
	iter = &old_iter;
	
	if (!exists) 
	{
		iter = g_new0 (GtkTreeIter, 1);
		gtk_tree_store_prepend (itemstore, iter, NULL);
		g_hash_table_insert (ilv->priv->item_id_to_iter, GUINT_TO_POINTER (item->id), (gpointer)iter);
	}

	gtk_tree_store_set (itemstore, iter,
		                       IS_TIME, (guint64)item->time,
		                       IS_NR, item->id,
				       IS_PARENT, node,
		                       IS_FAVICON, node->icon,
		                       IS_ENCICON, item->hasEnclosure?icon_get (ICON_ENCLOSURE):NULL,
				       IS_ENCLOSURE, item->hasEnclosure,
				       IS_SOURCE, node,
				       IS_STATE, state,
		                       -1);		                       
}
Example #24
0
static void tree_config_clear_current(void)
{
	GtkTreeModel *model;
	GtkTreeIter iter;
	
	model = GTK_TREE_MODEL(tree_config_get_store());
	if (gtk_tree_model_get_iter_first(model, &iter) == FALSE)
	{
		//fprintf(stderr, "Warning: cannot find iter. Config tree is empty.\n");
		return;
	}
	
	while (1)
	{
		gtk_tree_store_set(	GTK_TREE_STORE(model), &iter,
							COL_CURRENT, " ",
							-1);
		if (gtk_tree_model_iter_next(model, &iter) == FALSE)
			break;
	}
	
}
Example #25
0
//funcion para rellenar la lista con los coches del concesionario
void append_coches(GtkTreeStore *store, struct concesionario *con)
{
	GtkTreeIter iter;
	struct coche *c;
	int i;
	int numcoches = curso_concesionario_attr_get_u32(con,
			CURSO_CONCESIONARIO_ATTR_NUM_COCHES);

	for (i = 0; i < numcoches; i++) {
		c = curso_concesionario_attr_get_coche(con,
			CURSO_CONCESIONARIO_ATTR_COCHE, i);

		gtk_tree_store_append (store, &iter, NULL);
		gtk_tree_store_set (store, &iter,
                        0, FALSE,
                        1, c->id,
                        2, c->marca,
                        3, c->matricula, -1);
	}

	id = c->id + 1;
}
Example #26
0
void
vol_store_voladj(GtkTreeStore * store, GtkTreeIter * iter, float voladj) {

	if (!gtk_tree_store_iter_is_valid(store, iter)) {
		return;
	}

	if (store == music_store) { /* music store */
		track_data_t * data;
		gtk_tree_model_get(GTK_TREE_MODEL(music_store), iter, MS_COL_DATA, &data, -1);
		data->volume = voladj;
		music_store_mark_changed(iter);

	} else { /* playlist */
		playlist_data_t * data;
		char str[32];
		voladj2str(voladj, str);
		gtk_tree_model_get(GTK_TREE_MODEL(store), iter, PL_COL_DATA, &data, -1);
		data->voladj = voladj;
		gtk_tree_store_set(store, iter, PL_COL_VADJ, str, -1);
	}
}
Example #27
0
void country_table_populate_combobox(GtkComboBox *country_combobox)
{
	int i = 0;
	GtkTreeStore * new_store = NULL;
	GtkTreeIter iter;
	GtkCellRenderer *renderer = NULL;

	country_table_populate();
	new_store = gtk_tree_store_new(2, G_TYPE_STRING, G_TYPE_STRING);

	for (i=0; i<NUMBER_OF_COUNTRIES; i++) {
		gtk_tree_store_append (new_store, &iter, NULL);
		gtk_tree_store_set (new_store, &iter, 0, country_table[i].name, 1, country_table[i].code, -1);
	}

	gtk_combo_box_set_model (GTK_COMBO_BOX(country_combobox), GTK_TREE_MODEL (new_store));

	renderer = gtk_cell_renderer_text_new ();
	gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (country_combobox), renderer, FALSE);
	gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (country_combobox), renderer, "text", 0);
	
}
Example #28
0
/**
 * cryptui_key_store_set_selected_key:
 * @ckstore: a libcryptui key store
 * @view: a GtkTreeView
 * @selkey: a libcryptui key
 *
 * Marks the given key as selected
 */
void
cryptui_key_store_set_selected_key (CryptUIKeyStore *ckstore, GtkTreeView *view,
                                    const gchar *selkey)
{
    GtkTreeModel* model = GTK_TREE_MODEL (ckstore->priv->store);
    GtkTreeSelection *sel;
    GtkTreeIter iter, sel_iter;
    const gchar *key;
    gboolean have;

    g_return_if_fail (CRYPTUI_IS_KEY_STORE (ckstore));
    g_return_if_fail (GTK_IS_TREE_VIEW (view));

    sel = gtk_tree_view_get_selection (view);

    /* Go through all rows and select deselect as necessary */
    if (gtk_tree_model_get_iter_first (model, &iter)) {
        do {

            /* Is this row in our selection? */
            gtk_tree_model_get (model, &iter, CRYPTUI_KEY_STORE_KEY, &key, -1);
            have = (key && strcmp (selkey, key) == 0) ? TRUE : FALSE;

            if (ckstore->priv->use_checks) {
                /* Using checks so change data store */
                gtk_tree_store_set (ckstore->priv->store, &iter, CRYPTUI_KEY_STORE_CHECK, have, -1);
            } else {
                key_store_get_view_iter (ckstore, &iter, &sel_iter);

                /* Using normal selection */
                if (have)
                    gtk_tree_selection_select_iter (sel, &sel_iter);
                else
                    gtk_tree_selection_unselect_iter (sel, &sel_iter);
            }

        } while (gtk_tree_model_iter_next (model, &iter));
    }
}
static gboolean
contact_list_store_update_list_mode_foreach (GtkTreeModel           *model,
					     GtkTreePath            *path,
					     GtkTreeIter            *iter,
					     EmpathyContactListStore *store)
{
	EmpathyContactListStorePriv *priv;
	gboolean                    show_avatar = FALSE;

	priv = GET_PRIV (store);

	if (priv->show_avatars && !priv->is_compact) {
		show_avatar = TRUE;
	}

	gtk_tree_store_set (GTK_TREE_STORE (store), iter,
			    EMPATHY_CONTACT_LIST_STORE_COL_PIXBUF_AVATAR_VISIBLE, show_avatar,
			    EMPATHY_CONTACT_LIST_STORE_COL_STATUS_VISIBLE, !priv->is_compact,
			    -1);

	return FALSE;
}
Example #30
0
static void gui_list_tree_toggled_callback (GtkCellRendererToggle *cell, gchar *path_str, gpointer data, bool list)/*{{{*/
{
	signal_t* p = (signal_t*)data;
	orcaObject* fun = p->fun;
	GtkTreeModel *model = p->tree;
	orcaGtk *owner = p->owner;

	GtkTreeIter  iter;
	GtkTreePath *path = gtk_tree_path_new_from_string (path_str);
	gboolean fixed;

	/* get toggled iter */
	gtk_tree_model_get_iter (model, &iter, path);
	gtk_tree_model_get (model, &iter, 0, &fixed, -1);

	/* do something with the value */
	fixed ^= 1;

	/* set new value */
	if (list)
		gtk_list_store_set (GTK_LIST_STORE (model), &iter, 0, fixed, -1);
	else 
		gtk_tree_store_set (GTK_TREE_STORE (model), &iter, 0, fixed, -1);

	/* clean up */
	gtk_tree_path_free (path);

	orcaGtkIter* ip = new orcaGtkIter();
	ip->m_gp = owner;
	ip->m_iter = iter;
	ip->m_type = list ? GUI_LIST : GUI_TREE;

	orcaVM* vm = get_current_vm();
	vm->m_stack->push((orcaObject*)fun);
	vm->push_param(fixed?true:false);
	vm->push_param(ip);
	vm->call(2);
	vm->m_stack->pop();
}