コード例 #1
0
ファイル: gtr-message-table.c プロジェクト: GNOME/gtranslator
/**
 * gtr_message_table_populate:
 * @table: a #GtrMessageTable
 * @container: a list of #GtrMsg
 *
 * Populates the #GtrMessageTable with the list of #GtrMsg and
 * sort them.
 */
void
gtr_message_table_populate (GtrMessageTable * table, GtrMessageContainer * container)
{
  GtrMessageTablePrivate *priv;

  g_return_if_fail (table != NULL);
  g_return_if_fail (container != NULL);

  priv = gtr_message_table_get_instance_private (table);

  if (priv->store)
    {
      gtk_tree_view_set_model (GTK_TREE_VIEW (priv->treeview), NULL);
      g_object_unref (priv->sort_model);
      g_object_unref (priv->store);
    }

  priv->store = gtr_message_table_model_new (container);
  priv->sort_model =
    gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL (priv->store));

  gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE
                                           (priv->sort_model),
                                           NULL, NULL, NULL);
  gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (priv->sort_model),
                                   GTR_MESSAGE_TABLE_MODEL_STATUS_COLUMN,
                                   model_compare_by_status, NULL, NULL);

  gtr_message_table_sort_by (table, priv->sort_status);
  gtk_tree_view_set_model (GTK_TREE_VIEW (priv->treeview),
                           priv->sort_model);
}
コード例 #2
0
ファイル: contents.c プロジェクト: DeforaOS/Surfer
static void _new_contents(Helper * helper)
{
	GtkWidget * widget;
	GtkTreeModel * model;
	GtkCellRenderer * renderer;
	GtkTreeViewColumn * column;

	widget = gtk_scrolled_window_new(NULL, NULL);
	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(widget),
			GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
	model = gtk_tree_model_filter_new(GTK_TREE_MODEL(helper->store), NULL);
	gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(model),
			_helper_filter_contents, NULL, NULL);
	model = gtk_tree_model_sort_new_with_model(model);
	helper->contents = gtk_tree_view_new_with_model(model);
	gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(helper->contents),
			FALSE);
	gtk_tree_view_set_search_column(GTK_TREE_VIEW(helper->contents),
			HSC_CONTENTS_PACKAGE);
	renderer = gtk_cell_renderer_pixbuf_new();
	column = gtk_tree_view_column_new_with_attributes(NULL, renderer,
			"pixbuf", HSC_ICON, NULL);
	gtk_tree_view_append_column(GTK_TREE_VIEW(helper->contents), column);
	renderer = gtk_cell_renderer_text_new();
	column = gtk_tree_view_column_new_with_attributes(_("Package"),
			renderer, "text", HSC_CONTENTS_PACKAGE, NULL);
	gtk_tree_view_column_set_sort_column_id(column, HSC_CONTENTS_PACKAGE);
	gtk_tree_view_append_column(GTK_TREE_VIEW(helper->contents), column);
	gtk_tree_view_column_clicked(column);
	g_signal_connect(helper->contents, "row-activated", G_CALLBACK(
				_helper_on_contents_row_activated), helper);
	gtk_container_add(GTK_CONTAINER(widget), helper->contents);
	gtk_notebook_append_page(GTK_NOTEBOOK(helper->notebook), widget,
			gtk_label_new(_("Contents")));
}
コード例 #3
0
ファイル: sortmodel.c プロジェクト: Pfiver/gtk
static void
ref_count_single_level (void)
{
  GtkTreeIter iter;
  GtkTreeModel *model;
  GtkTreeModelRefCount *ref_model;
  GtkTreeModel *sort_model;
  GtkWidget *tree_view;

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

  gtk_tree_store_append (GTK_TREE_STORE (model), &iter, NULL);
  gtk_tree_store_append (GTK_TREE_STORE (model), &iter, NULL);
  gtk_tree_store_append (GTK_TREE_STORE (model), &iter, NULL);
  gtk_tree_store_append (GTK_TREE_STORE (model), &iter, NULL);
  gtk_tree_store_append (GTK_TREE_STORE (model), &iter, NULL);

  assert_root_level_unreferenced (ref_model);

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

  assert_entire_model_referenced (ref_model, 1);

  gtk_widget_destroy (tree_view);

  assert_entire_model_unreferenced (ref_model);

  g_object_unref (sort_model);
  g_object_unref (ref_model);
}
コード例 #4
0
ファイル: ModelSelector.cpp プロジェクト: chrisglass/ufoai
	// Helper function to create the TreeView
	GtkWidget* ModelSelector::createTreeView ()
	{
		loadDirectory(MODELS_FOLDER);

		GtkTreeModel *model = gtk_tree_model_filter_new(GTK_TREE_MODEL(_treeStore), NULL);
		GtkTreeModel *modelSorted = gtk_tree_model_sort_new_with_model(model);

		GtkWidget* treeView = gtk_tree_view_new_with_model(GTK_TREE_MODEL(modelSorted));
		// Single column, containing model pathname
		GtkTreeViewColumn* col = gtk_tree_view_column_new();
		gtk_tree_view_column_set_title(col, _("Value"));
		gtk_tree_view_column_set_spacing(col, 3);

		GtkCellRenderer* pixRenderer = gtk_cell_renderer_pixbuf_new();
		gtk_tree_view_column_pack_start(col, pixRenderer, FALSE);
		gtk_tree_view_column_set_attributes(col, pixRenderer, "pixbuf", IMAGE_COLUMN, NULL);

		GtkCellRenderer* rend = gtk_cell_renderer_text_new();
		gtk_tree_view_column_pack_start(col, rend, FALSE);
		gtk_tree_view_column_set_attributes(col, rend, "text", NAME_COLUMN, NULL);

		gtk_tree_view_append_column(GTK_TREE_VIEW(treeView), col);
		gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeView), FALSE);

		gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(modelSorted), NAME_COLUMN, GTK_SORT_ASCENDING);

		// Pack treeview into a scrolled window and return

		_selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeView));
		g_signal_connect(G_OBJECT(_selection), "changed", G_CALLBACK(callbackSelChanged), this);

		// Pack treeview into a scrolled window and frame, and return

		return gtkutil::ScrolledFrame(treeView);
	}
コード例 #5
0
/**
 * gtr_message_table_populate:
 * @table: a #GtrMessageTable
 * @container: a list of #GtrMsg
 *
 * Populates the #GtrMessageTable with the list of #GtrMsg and
 * sort them.
 */
void
gtr_message_table_populate (GtrMessageTable * table, GtrMessageContainer * container)
{
  g_return_if_fail (table != NULL);
  g_return_if_fail (container != NULL);

  if (table->priv->store)
    {
      gtk_tree_view_set_model (GTK_TREE_VIEW (table->priv->treeview), NULL);
      g_object_unref (table->priv->sort_model);
      g_object_unref (table->priv->store);
    }

  table->priv->store = gtr_message_table_model_new (container);
  table->priv->sort_model =
    gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL (table->priv->store));

  gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE
                                        (table->priv->sort_model),
                                        GTR_MESSAGE_TABLE_MODEL_ID_COLUMN,
                                        GTK_SORT_ASCENDING);

  gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE
                                           (table->priv->sort_model),
                                           NULL, NULL, NULL);

  gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (table->priv->sort_model),
                                   GTR_MESSAGE_TABLE_MODEL_STATUS_COLUMN,
                                   model_compare_by_status, NULL, NULL);

  gtk_tree_view_set_model (GTK_TREE_VIEW (table->priv->treeview),
                           table->priv->sort_model);
}
コード例 #6
0
// Callbacks:
void SludgeProjectManager::on_treeview_realize(GtkTreeView *theTreeView, whichTreeview whichOne)
{
	GtkTreeModel *sortModel;
	GtkCellRenderer *renderer;
	GtkTreeViewColumn *column;
	char caption[100];

	switch (whichOne) {
		case FILE_TREEVIEW:
			filesListStore = gtk_list_store_new(1, G_TYPE_STRING);
			sortModel = gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(filesListStore));
			sprintf(caption, "Files in project");

			filesSelection = gtk_tree_view_get_selection(theTreeView);
			gtk_tree_selection_set_mode(filesSelection, GTK_SELECTION_MULTIPLE);
			g_signal_connect(G_OBJECT (filesSelection), "changed",
						      G_CALLBACK (on_files_tree_selection_changed_cb),
						      NULL);
			break;
		case RESOURCE_TREEVIEW:
			resourcesListStore = gtk_list_store_new(1, G_TYPE_STRING);
			sortModel = gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(resourcesListStore));
			sprintf(caption, "Resources used by selected scripts");
			break;
		case ERROR_TREEVIEW:
			errorsListStore = gtk_list_store_new(ERRORS_N_COLUMNS, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING);
			sortModel = gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(errorsListStore));
			sprintf(caption, "Compiler errors");
			break;
		default:
			break;
	}

	gtk_tree_view_set_model(theTreeView, sortModel);

//  Sorting lists alphabetically is commented out,
//	because the order is important in some cases:
//	gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE (sortModel),
//		                                    0, GTK_SORT_ASCENDING);

	renderer = gtk_cell_renderer_text_new();
	column = gtk_tree_view_column_new_with_attributes(caption,
		                                               renderer,
		                                               "text", 0,
		                                               NULL);
	gtk_tree_view_append_column(theTreeView, column);
}
コード例 #7
0
ファイル: remmina_main.c プロジェクト: BillTheBest/Remmina
static void remmina_main_load_files(RemminaMain *remminamain, gboolean refresh)
{
	GtkTreeModel *filter;
	GtkTreeModel *sort;
	gint n;
	gchar buf[200];
	guint context_id;

	if (refresh)
	{
		remmina_main_save_expanded_group(remminamain);
	}

	switch (remmina_pref.view_file_mode)
	{

		case REMMINA_VIEW_FILE_TREE:
			gtk_tree_view_column_set_visible(remminamain->priv->group_column, FALSE);
			remminamain->priv->file_model = GTK_TREE_MODEL(
					gtk_tree_store_new(N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
							G_TYPE_STRING, G_TYPE_STRING));
			remmina_main_load_file_tree_group(GTK_TREE_STORE(remminamain->priv->file_model));
			n = remmina_file_manager_iterate(remmina_main_load_file_tree_callback, remminamain);
			break;

		case REMMINA_VIEW_FILE_LIST:
		default:
			gtk_tree_view_column_set_visible(remminamain->priv->group_column, TRUE);
			remminamain->priv->file_model = GTK_TREE_MODEL(
					gtk_list_store_new(N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
							G_TYPE_STRING, G_TYPE_STRING));
			n = remmina_file_manager_iterate(remmina_main_load_file_list_callback, remminamain);
			break;
	}

	filter = gtk_tree_model_filter_new(remminamain->priv->file_model, NULL);
	gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(filter),
			(GtkTreeModelFilterVisibleFunc) remmina_main_filter_visible_func, remminamain, NULL);
	remminamain->priv->file_model_filter = filter;

	sort = gtk_tree_model_sort_new_with_model(filter);
	remminamain->priv->file_model_sort = sort;

	gtk_tree_view_set_model(GTK_TREE_VIEW(remminamain->priv->file_list), sort);
	gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(sort), remmina_pref.main_sort_column_id,
			remmina_pref.main_sort_order);
	g_signal_connect(G_OBJECT(sort), "sort-column-changed", G_CALLBACK(remmina_main_file_model_on_sort), remminamain);
	remmina_main_expand_group(remminamain);

	if (remminamain->priv->selected_filename)
	{
		remmina_main_select_file(remminamain, remminamain->priv->selected_filename);
	}

	g_snprintf(buf, 200, ngettext("Total %i item.", "Total %i items.", n), n);
	context_id = gtk_statusbar_get_context_id(GTK_STATUSBAR(remminamain->priv->statusbar), "status");
	gtk_statusbar_pop(GTK_STATUSBAR(remminamain->priv->statusbar), context_id);
	gtk_statusbar_push(GTK_STATUSBAR(remminamain->priv->statusbar), context_id, buf);
}
コード例 #8
0
ファイル: datawindow.c プロジェクト: justinzane/navit
static void
gui_gtk_datawindow_add(struct datawindow_priv *win, struct param_list *param, int count)
{
	int i;
	GtkCellRenderer *cell;
	GtkTreeIter iter;
	GType types[count];
	gchar *utf8;

	if (! win->treeview) {
		win->treeview=gtk_tree_view_new();
		gtk_tree_view_set_model (GTK_TREE_VIEW (win->treeview), NULL);
		gtk_container_add(GTK_CONTAINER(win->scrolled_window), win->treeview);
		gtk_widget_show_all(GTK_WIDGET(win->window));
		gtk_widget_grab_focus(GTK_WIDGET(win->treeview));
		
		/* add column names to treeview */
		for(i=0;i<count;i++) {
			if (param[i].name) {
				cell=gtk_cell_renderer_text_new();
				gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (win->treeview),-1,param[i].name,
					cell,"text",i, NULL);
			}
		}
#if 0
		g_signal_connect(G_OBJECT(win->treeview), "click-column", G_CALLBACK(click_column), NULL);
#endif
		g_signal_connect(G_OBJECT(win->treeview), "row-activated", G_CALLBACK(select_row), win);
	}

	/* find data storage and create a new one if none is there */
	if (gtk_tree_view_get_model(GTK_TREE_VIEW (win->treeview)) == NULL) {
		for(i=0;i<count;i++) {
			if (param[i].name && !strcmp(param[i].name, "Distance")) 
				types[i]=G_TYPE_INT;
			else
				types[i]=G_TYPE_STRING;
		}
	    	win->liststore=gtk_list_store_newv(count,types);
		if (! strcmp(param[0].name, "Distance")) {
			win->sortmodel=gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(win->liststore));
			gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (win->sortmodel), 0, GTK_SORT_ASCENDING);
			gtk_tree_view_set_model (GTK_TREE_VIEW (win->treeview), GTK_TREE_MODEL(win->sortmodel));
		} else 
			gtk_tree_view_set_model (GTK_TREE_VIEW (win->treeview), GTK_TREE_MODEL(win->liststore));
	}

	gtk_list_store_append(win->liststore,&iter);

	/* add data to data storage */
	for(i=0;i<count;i++) {
		if (param[i].name && !strcmp(param[i].name, "Distance")) {
			gtk_list_store_set(win->liststore,&iter,i,atoi(param[i].value),-1);
		} else {
			utf8=g_locale_to_utf8(param[i].value,-1,NULL,NULL,NULL);
			gtk_list_store_set(win->liststore,&iter,i,utf8,-1);
		}
	}
}
コード例 #9
0
ファイル: file-view.c プロジェクト: kyoushuu/anjuta
static void
file_view_init (AnjutaFileView *object)
{
	GtkCellRenderer* renderer_pixbuf;
	GtkCellRenderer* renderer_display;
	GtkTreeViewColumn* column;
	GtkTreeSelection* selection;
	GtkTreeModel* sort_model;
	
	AnjutaFileViewPrivate* priv = ANJUTA_FILE_VIEW_GET_PRIVATE (object);
	
	priv->current_selection = NULL;
	
	priv->model = file_model_new (GTK_TREE_VIEW(object), NULL);
	g_signal_connect_object (priv->model, "directory-expanded",
							 G_CALLBACK (file_view_directory_expanded), object, 0);

	sort_model = gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(priv->model));
	
	gtk_tree_view_set_model (GTK_TREE_VIEW(object), sort_model);
	/* set_model takes a reference so we can release the reference we got when
	 * the sort_model was created. */
	g_object_unref (sort_model);
	gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE(sort_model),
											 file_view_sort_model,
											 NULL,
											 NULL);
	
	renderer_pixbuf = gtk_cell_renderer_pixbuf_new ();
	renderer_display = gtk_cell_renderer_text_new ();
	column = gtk_tree_view_column_new ();
	gtk_tree_view_column_set_title (column, _("Filename"));
	gtk_tree_view_column_pack_start (column, renderer_pixbuf, FALSE);
	gtk_tree_view_column_pack_start (column, renderer_display, FALSE);
	gtk_tree_view_column_set_cell_data_func(column,
	                                        renderer_pixbuf,
	                                        file_view_render_pixbuf_with_emblem,
	                                        object, NULL);
	gtk_tree_view_column_set_attributes (column, renderer_display,
										 "markup", COLUMN_DISPLAY, 
										 NULL);
	gtk_tree_view_append_column (GTK_TREE_VIEW (object), column);
	
	selection =
		gtk_tree_view_get_selection (GTK_TREE_VIEW (object));
	g_signal_connect (selection, "changed",
					  G_CALLBACK (file_view_selection_changed), object);

	/* DND */
	gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW(object),
	                                        GDK_BUTTON1_MASK,
	                                        uri_targets,
	                                        1,
	                                        GDK_ACTION_MOVE);

	/* Typeahead search */
	gtk_tree_view_set_search_column (GTK_TREE_VIEW (object), COLUMN_FILENAME);
}
コード例 #10
0
static void create_rollout_list(int n, char asz[][40], GtkWidget **View, GtkListStore **List, gboolean cubeful)
{
	int i;
	GtkTreeModel *sort_model;
	static const char *aszTitle[N_ROLLOUT_COLS] = {
		NULL,
		N_("Rank"),
		N_("Trials"),
		N_("Win"),
		N_("Win (g)"),
		N_("Win (bg)"),
		N_("Lose (g)"),
		N_("Lose (bg)"),
		N_("Cubeless"),
		N_("Cubeful"),
		N_("Std dev"),
		N_("JSDs")
	};
	char *aszTemp[N_ROLLOUT_COLS];

	for (i = 0; i < N_ROLLOUT_COLS; i++)
		aszTemp[i] = aszTitle[i] ? gettext(aszTitle[i]) : "";

	*List = gtk_list_store_new(N_ROLLOUT_COLS,
			G_TYPE_STRING,
			G_TYPE_INT,
			G_TYPE_INT,
			G_TYPE_STRING,
			G_TYPE_STRING,
			G_TYPE_STRING,
			G_TYPE_STRING,
			G_TYPE_STRING,
			G_TYPE_STRING,
			G_TYPE_STRING,
			G_TYPE_STRING,
			G_TYPE_STRING,
			G_TYPE_STRING);

	for (i = 0; i < n; i++) {
		GtkTreeIter iter;
		gtk_list_store_append(*List, &iter);
		gtk_list_store_set(*List, &iter, TITLE_C, asz[i], RANK_C, i, TRIALS_C, 0, -1);
	}
	sort_model = gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL(*List));
	*View = gtk_tree_view_new_with_model(GTK_TREE_MODEL(sort_model));

	for (i=0; i < N_ROLLOUT_COLS; i++) {
		GtkCellRenderer *renderer;
		GtkTreeViewColumn *column;
		if (i == CFUL_C && ! cubeful)
			continue;
		renderer = gtk_cell_renderer_text_new();
		column = gtk_tree_view_column_new_with_attributes(aszTemp[i], renderer, "text", i, NULL);
		gtk_tree_view_append_column(GTK_TREE_VIEW(*View), column);
		gtk_tree_view_column_set_sort_column_id(column, i);
	}
	gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort_model), RANK_C, GTK_SORT_ASCENDING);
}
コード例 #11
0
ファイル: diagram_tree_model.c プロジェクト: brunetton/dia
static GtkTreeModel *
wrap_as_sortable_model (GtkTreeModel *model)
{
  GtkTreeModel *sort_model = gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL (model));
  
  gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (sort_model), NAME_COLUMN, name_sort_func, model, NULL);
  gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (sort_model), OBJECT_COLUMN, type_sort_func, model, NULL);
  
  return sort_model;
}
コード例 #12
0
ファイル: pidgin.c プロジェクト: DavidParkin/caja-extensions
static GtkWidget *
get_contacts_widget (NstPlugin *plugin)
{
	GtkWidget *cb;
	GtkCellRenderer *renderer;
	GtkTreeStore *store;
	GtkTreeModel *model;
	GtkTreeIter *iter, *iter2;

	iter = g_malloc (sizeof(GtkTreeIter));
	iter2 = g_malloc (sizeof(GtkTreeIter));
	store = gtk_tree_store_new (NUM_COLS, GDK_TYPE_PIXBUF, G_TYPE_STRING);
	add_pidgin_contacts_to_model (store, iter, iter2);
	model = gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL (store));
	gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (model), COL_ALIAS,
					      GTK_SORT_ASCENDING);
	cb = gtk_combo_box_new_with_model (model);

	renderer = gtk_cell_renderer_pixbuf_new ();
	gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (cb),
				    renderer,
				    FALSE);
	gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (cb),
					renderer,
					"pixbuf", COL_ICON,
					NULL);
	gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (cb), renderer,
					    customize,
					    (gboolean *)FALSE, NULL);
	renderer = gtk_cell_renderer_text_new ();
	gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (cb),
				    renderer,
				    TRUE);
	gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (cb),
					renderer,
					"text", COL_ALIAS,
					NULL);
	g_object_set(renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
	gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (cb), renderer,
					    customize,
					    (gboolean *)TRUE, NULL);

	gtk_combo_box_set_active (GTK_COMBO_BOX (cb), 0);
	gtk_combo_box_get_active_iter (GTK_COMBO_BOX(cb), iter);
	if (gtk_tree_model_iter_has_child (model, iter)) {
		GtkTreePath *path = gtk_tree_path_new_from_indices (0, 0, -1);
		gtk_tree_model_get_iter (model, iter2, path);
		gtk_tree_path_free (path);
		gtk_combo_box_set_active_iter (GTK_COMBO_BOX (cb), iter2);
	}

	g_free (iter);
	g_free (iter2);
	return cb;
}
コード例 #13
0
ファイル: main.c プロジェクト: df3n5/hart
static void file_button_callback(GtkFileChooserButton *widget, gpointer data) {
    g_print("Hello again - %s was pressed\n", (char *) data);
    g_print("dir is %s\n", gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(widget)));

    store = gtk_tree_store_new(N_COLUMNS,
            G_TYPE_STRING,
            G_TYPE_BOOLEAN);
    create_file_tree(gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(widget)), NULL);
    sorted_model = gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(store));
    gtk_tree_view_set_model(GTK_TREE_VIEW(tree), GTK_TREE_MODEL(sorted_model));
}
コード例 #14
0
ファイル: notes.c プロジェクト: DeforaOS/Notes
static void _new_view(Notes * notes)
{
	size_t i;
	GtkTreeSelection * sel;
	GtkCellRenderer * renderer;
	GtkTreeViewColumn * column;

	notes->store = gtk_list_store_new(ND_COL_COUNT,
			G_TYPE_POINTER, /* note */
			G_TYPE_STRING,	/* title */
			G_TYPE_STRING);	/* category */
	/* XXX get rid of filter? */
	notes->filter = gtk_tree_model_filter_new(GTK_TREE_MODEL(notes->store),
			NULL);
	notes->filter_sort = gtk_tree_model_sort_new_with_model(notes->filter);
	notes->view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(
				notes->filter_sort));
	gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(notes->view), FALSE);
	gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(notes->view), TRUE);
	if((sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(notes->view)))
			!= NULL)
		gtk_tree_selection_set_mode(sel, GTK_SELECTION_MULTIPLE);
	g_signal_connect_swapped(notes->view, "cursor-changed", G_CALLBACK(
				_notes_on_note_cursor_changed), notes);
	g_signal_connect_swapped(notes->view, "row-activated", G_CALLBACK(
				_notes_on_note_activated), notes);
	/* columns */
	memset(&notes->columns, 0, sizeof(notes->columns));
	for(i = 0; _notes_columns[i].title != NULL; i++)
	{
		renderer = gtk_cell_renderer_text_new();
		if(_notes_columns[i].callback != NULL)
		{
			g_object_set(G_OBJECT(renderer), "editable", TRUE,
					"ellipsize", PANGO_ELLIPSIZE_END, NULL);
			g_signal_connect(renderer, "edited", G_CALLBACK(
						_notes_columns[i].callback),
					notes);
		}
		column = gtk_tree_view_column_new_with_attributes(
				_(_notes_columns[i].title), renderer, "text",
				_notes_columns[i].col, NULL);
		notes->columns[_notes_columns[i].col] = column;
#if GTK_CHECK_VERSION(2, 4, 0)
		gtk_tree_view_column_set_expand(column, TRUE);
#endif
		gtk_tree_view_column_set_resizable(column, TRUE);
		gtk_tree_view_column_set_sort_column_id(column,
				_notes_columns[i].sort);
		gtk_tree_view_append_column(GTK_TREE_VIEW(notes->view), column);
	}
	gtk_tree_view_column_set_sort_column_id(column, ND_COL_TITLE);
	gtk_container_add(GTK_CONTAINER(notes->scrolled), notes->view);
}
コード例 #15
0
ファイル: main.c プロジェクト: df3n5/hart
/*  Get the selected filename and print it to the console */
static void file_ok_sel(GtkWidget *w, GtkFileSelection *fs)
{
    g_print ("%s\n", gtk_file_selection_get_filename(GTK_FILE_SELECTION(fs)));
    store = gtk_tree_store_new(N_COLUMNS,
            G_TYPE_STRING,
            G_TYPE_BOOLEAN);
    create_file_tree(gtk_file_selection_get_filename(GTK_FILE_SELECTION(fs)), NULL);
    sorted_model = gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(store));
    gtk_tree_view_set_model(GTK_TREE_VIEW(tree), GTK_TREE_MODEL(sorted_model));
    gtk_widget_destroy(filew);
}
コード例 #16
0
ファイル: file-view.c プロジェクト: rosedu/anjuta
static void
file_view_init (AnjutaFileView *object)
{
	GtkCellRenderer* renderer_pixbuf;
	GtkCellRenderer* renderer_display;
	GtkTreeViewColumn* column;
	GtkTreeSelection* selection;
	GtkTreeModel* sort_model;
	
	AnjutaFileViewPrivate* priv = ANJUTA_FILE_VIEW_GET_PRIVATE (object);
	
	priv->current_selection = NULL;
	
	priv->model = file_model_new (GTK_TREE_VIEW(object), NULL);
	sort_model = gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(priv->model));									  
	
	gtk_tree_view_set_model (GTK_TREE_VIEW(object), sort_model);
	gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE(sort_model),
											 file_view_sort_model,
											 NULL,
											 NULL);
	
	renderer_pixbuf = gtk_cell_renderer_pixbuf_new ();
	renderer_display = gtk_cell_renderer_text_new ();
	column = gtk_tree_view_column_new ();
	gtk_tree_view_column_set_title (column, _("Filename"));
	gtk_tree_view_column_pack_start (column, renderer_pixbuf, FALSE);
	gtk_tree_view_column_pack_start (column, renderer_display, FALSE);
	gtk_tree_view_column_set_attributes (column, renderer_pixbuf,
										 "pixbuf", COLUMN_PIXBUF,
										 NULL);
	gtk_tree_view_column_set_attributes (column, renderer_display,
										 "markup", COLUMN_DISPLAY, 
										 NULL);
	gtk_tree_view_append_column (GTK_TREE_VIEW (object), column);
	
	selection =
		gtk_tree_view_get_selection (GTK_TREE_VIEW (object));
	g_signal_connect (selection, "changed",
					  G_CALLBACK (file_view_selection_changed), object);
	
	gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (object), FALSE);
	
	g_object_set (object, "has-tooltip", TRUE, NULL);

	/* DND */
	gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW(object),
	                                        GDK_BUTTON1_MASK,
	                                        uri_targets,
	                                        1,
	                                        GDK_ACTION_MOVE);                                    
}
コード例 #17
0
static int _settings(void)
{
	Settings settings;
	GtkAccelGroup * accel;
	GtkWidget * widget;
	GtkListStore * store;
	GtkTreeModel * model;

	accel = gtk_accel_group_new();
	settings.window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_window_add_accel_group(GTK_WINDOW(settings.window), accel);
	desktop_accel_create(_settings_accel, &settings, accel);
	g_object_unref(accel);
	gtk_window_set_default_size(GTK_WINDOW(settings.window), 400, 300);
	gtk_window_set_icon_name(GTK_WINDOW(settings.window),
			GTK_STOCK_PREFERENCES);
	gtk_window_set_title(GTK_WINDOW(settings.window),
			_("System preferences"));
	g_signal_connect_swapped(settings.window, "delete-event", G_CALLBACK(
				_settings_on_closex), NULL);
	widget = gtk_scrolled_window_new(NULL, NULL);
	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(widget),
			GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
	store = gtk_list_store_new(SC_COUNT,
			GDK_TYPE_PIXBUF,	/* SC_ICON */
			G_TYPE_STRING,		/* SC_NAME */
			G_TYPE_STRING,		/* SC_EXEC */
			G_TYPE_BOOLEAN);	/* SC_PRIVILEGED */
	model = gtk_tree_model_filter_new(GTK_TREE_MODEL(store), NULL);
	gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(model),
			_settings_on_filter_view, &settings, NULL);
	model = gtk_tree_model_sort_new_with_model(model);
	gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(model), SC_NAME,
			GTK_SORT_ASCENDING);
	settings.view = gtk_icon_view_new_with_model(model);
	gtk_icon_view_set_item_width(GTK_ICON_VIEW(settings.view), 96);
	gtk_icon_view_set_pixbuf_column(GTK_ICON_VIEW(settings.view), SC_ICON);
	gtk_icon_view_set_text_column(GTK_ICON_VIEW(settings.view), SC_NAME);
	gtk_icon_view_set_selection_mode(GTK_ICON_VIEW(settings.view),
			GTK_SELECTION_SINGLE);
#if GTK_CHECK_VERSION(2, 10, 0)
	g_signal_connect(settings.view, "item-activated", G_CALLBACK(
				_settings_on_item_activated), &settings);
#endif
	gtk_container_add(GTK_CONTAINER(widget), settings.view);
	gtk_container_add(GTK_CONTAINER(settings.window), widget);
	gtk_widget_show_all(settings.window);
	g_idle_add(_settings_on_idle, &settings);
	gtk_main();
	return 0;
}
コード例 #18
0
ファイル: sortmodel.c プロジェクト: Pfiver/gtk
static void
ref_count_cleanup (void)
{
  GtkTreeIter grandparent1, grandparent2, parent1, parent2;
  GtkTreeIter iter_parent1, iter_parent2;
  GtkTreeModel *model;
  GtkTreeModelRefCount *ref_model;
  GtkTreeModel *sort_model;
  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);

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

  gtk_tree_view_expand_all (GTK_TREE_VIEW (tree_view));

  gtk_widget_destroy (tree_view);

  assert_node_ref_count (ref_model, &grandparent1, 0);
  assert_node_ref_count (ref_model, &grandparent2, 1);
  assert_node_ref_count (ref_model, &parent1, 1);
  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);

  gtk_tree_model_sort_clear_cache (GTK_TREE_MODEL_SORT (sort_model));

  assert_entire_model_unreferenced (ref_model);

  g_object_unref (sort_model);
  g_object_unref (ref_model);
}
コード例 #19
0
void nsgtk_history_init_model(void)
{
	history = malloc(sizeof(struct history_model));
	
	history->history_list = gtk_list_store_new(SITE_NCOLS,
				G_TYPE_STRING,		/* title */
				G_TYPE_STRING,  	/* domain */
				G_TYPE_STRING,		/* address */
				G_TYPE_INT,		/* last visit */
				G_TYPE_INT,		/* num visits */
				G_TYPE_POINTER);	/* thumbnail */
	history->history_filter = gtk_tree_model_filter_new(
			GTK_TREE_MODEL(history->history_list), NULL);
	
	history->site_filter = gtk_tree_model_filter_new(
			history->history_filter,NULL);
	history->site_sort = gtk_tree_model_sort_new_with_model(history->site_filter);
	history->site_treeview = GTK_TREE_VIEW(glade_xml_get_widget(gladeFile,
						"treeHistory"));
	history->site_selection = 
			gtk_tree_view_get_selection(history->site_treeview);
	
	history->domain_list = gtk_list_store_new(DOM_NCOLS,
				G_TYPE_STRING,		/* domain */
				G_TYPE_INT,		/* last visit */
				G_TYPE_INT,		/* num visits */	
				G_TYPE_BOOLEAN);	/* has sites */	
	history->domain_filter = gtk_tree_model_filter_new(
			GTK_TREE_MODEL(history->domain_list), NULL);
	history->domain_hash = g_hash_table_new_full(g_str_hash, g_str_equal, 
			g_free, g_free);
	history->domain_sort = gtk_tree_model_sort_new_with_model(
			history->domain_filter);
	history->domain_treeview = GTK_TREE_VIEW(glade_xml_get_widget(
			gladeFile,"treeDomain"));
	history->domain_selection = 
			gtk_tree_view_get_selection(history->domain_treeview);
}
コード例 #20
0
ファイル: sortmodel.c プロジェクト: Pfiver/gtk
static void
ref_count_two_levels (void)
{
  GtkTreeIter parent1, parent2, iter;
  GtkTreeModel *model;
  GtkTreeModelRefCount *ref_model;
  GtkTreeModel *sort_model;
  GtkWidget *tree_view;

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

  gtk_tree_store_append (GTK_TREE_STORE (model), &parent1, NULL);
  gtk_tree_store_append (GTK_TREE_STORE (model), &parent2, NULL);
  gtk_tree_store_append (GTK_TREE_STORE (model), &iter, &parent2);
  gtk_tree_store_append (GTK_TREE_STORE (model), &iter, &parent2);
  gtk_tree_store_append (GTK_TREE_STORE (model), &iter, &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, &iter, 0);

  gtk_tree_view_expand_all (GTK_TREE_VIEW (tree_view));

  assert_node_ref_count (ref_model, &parent1, 1);
  assert_node_ref_count (ref_model, &parent2, 2);
  assert_node_ref_count (ref_model, &iter, 1);

  gtk_tree_view_collapse_all (GTK_TREE_VIEW (tree_view));

  assert_node_ref_count (ref_model, &parent1, 1);
  assert_node_ref_count (ref_model, &parent2, 2);
  assert_node_ref_count (ref_model, &iter, 0);

  gtk_tree_model_sort_clear_cache (GTK_TREE_MODEL_SORT (sort_model));

  assert_root_level_referenced (ref_model, 1);
  assert_node_ref_count (ref_model, &iter, 0);

  gtk_widget_destroy (tree_view);

  assert_entire_model_unreferenced (ref_model);

  g_object_unref (sort_model);
  g_object_unref (ref_model);
}
コード例 #21
0
static GtkWidget *
_gtk_user_list_dialog_create_tree(GtkWidget *widget)
{
	GtkWidget *tree;
	GtkListStore *store;
	GtkTreeModel *model;
	GtkTreeViewColumn *column;
	GtkCellRenderer *renderer;

	/* create treeview & model */
	tree = gtk_tree_view_new();
	gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tree), TRUE);
	gtk_tree_view_set_enable_search(GTK_TREE_VIEW(tree), FALSE);

	store = gtk_list_store_new(3, G_TYPE_BOOLEAN, GDK_TYPE_PIXBUF, G_TYPE_STRING);
	model = gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(store));
	gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(model), GTK_USER_LIST_TREEVIEW_COLUMN_USERNAME, GTK_SORT_ASCENDING);
	gtk_tree_view_set_model(GTK_TREE_VIEW(tree), model);

	/* insert column to display checkbox */
	column = gtk_tree_view_column_new();

	renderer = gtk_cell_renderer_toggle_new();
	gtk_cell_renderer_toggle_set_activatable(GTK_CELL_RENDERER_TOGGLE(renderer), TRUE);
	g_signal_connect(G_OBJECT(renderer), "toggled", (GCallback)_gtk_user_list_dialog_tree_checkbox_toggled, widget);
	gtk_tree_view_column_pack_start(column, renderer, FALSE);
	gtk_tree_view_column_add_attribute(column, renderer, "active", GTK_USER_LIST_TREEVIEW_COLUMN_CHECKBOX);

	gtk_tree_view_insert_column(GTK_TREE_VIEW(tree), column, -1);

	/* insert column to display icon & text */
	column = gtk_tree_view_column_new();
	gtk_tree_view_column_set_title(column, "User");

	renderer = gtk_cell_renderer_pixbuf_new();
	gtk_tree_view_column_pack_start(column, renderer, FALSE);
	gtk_tree_view_column_add_attribute(column, renderer, "pixbuf", GTK_USER_LIST_TREEVIEW_COLUMN_PIXBUF);

	renderer = gtk_cell_renderer_text_new();
	gtk_tree_view_column_pack_start(column, renderer, TRUE);
	gtk_tree_view_column_add_attribute(column, renderer, "text", GTK_USER_LIST_TREEVIEW_COLUMN_USERNAME);

	gtk_tree_view_insert_column(GTK_TREE_VIEW(tree), column, -1);

	/* free data */
	g_object_unref(store);
	g_object_unref(model);

	return tree;
}
コード例 #22
0
static void
gtk_boursorama_app_activate(GApplication *application) {
    GtkBoursoramaApp* app = (GtkBoursoramaApp*) application;
    app->win = gtk_boursorama_app_window_new(GTK_BOURSORAMA_APP(app));
    app->win->tree_model_sort = gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(app->list_store_action_list));
    gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(app->win->tree_model_sort), ACTION_NAME, GTK_SORT_ASCENDING);
    gtk_tree_view_set_model(app->win->tree, GTK_TREE_MODEL(app->win->tree_model_sort));
    g_object_unref(app->win->tree_model_sort);
    gtk_window_present(GTK_WINDOW(app->win));

    g_thread_new("http thread", app_logic_thread_func, app);
    app->last_update_time = g_get_real_time();
    g_timeout_add(500, gtk_boursorama_app_label_update, app);


}
コード例 #23
0
static void phidias_items_classic_set_model (PhidiasItemsViewer *self, GtkTreeModel *items)
{
    GtkTreeModel *sorter;
    PhidiasItemsClassic *item;

    item = PHIDIAS_ITEMS_CLASSIC (self);
    webkit_web_view_load_html_string (WEBKIT_WEB_VIEW (item->priv->description), "", "file://");

    sorter = gtk_tree_view_get_model (GTK_TREE_VIEW (item->priv->list));
    if (sorter != NULL)
        g_object_unref (sorter);

    sorter = gtk_tree_model_sort_new_with_model (items);
    gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sorter), ITEM_INFO_DATE, GTK_SORT_DESCENDING);
    gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (sorter), ITEM_INFO_DATE, sort_items, NULL, NULL);
    gtk_tree_view_set_model (GTK_TREE_VIEW (item->priv->list), sorter);

    scroll_to_position (item);
}
コード例 #24
0
ファイル: sortmodel.c プロジェクト: Pfiver/gtk
static void
specific_bug_300089 (void)
{
  /* Test case for GNOME Bugzilla bug 300089.  Written by
   * Matthias Clasen.
   */
  GtkTreeModel *sort_model, *child_model;
  GtkTreePath *path;
  GtkTreeIter iter, iter2, sort_iter;

  g_test_bug ("300089");

  child_model = GTK_TREE_MODEL (gtk_tree_store_new (1, G_TYPE_STRING));

  gtk_tree_store_append (GTK_TREE_STORE (child_model), &iter, NULL);
  gtk_tree_store_set (GTK_TREE_STORE (child_model), &iter, 0, "A", -1);
  gtk_tree_store_append (GTK_TREE_STORE (child_model), &iter, NULL);
  gtk_tree_store_set (GTK_TREE_STORE (child_model), &iter, 0, "B", -1);

  gtk_tree_store_append (GTK_TREE_STORE (child_model), &iter2, &iter);
  gtk_tree_store_set (GTK_TREE_STORE (child_model), &iter2, 0, "D", -1);
  gtk_tree_store_append (GTK_TREE_STORE (child_model), &iter2, &iter);
  gtk_tree_store_set (GTK_TREE_STORE (child_model), &iter2, 0, "E", -1);

  gtk_tree_store_append (GTK_TREE_STORE (child_model), &iter, NULL);
  gtk_tree_store_set (GTK_TREE_STORE (child_model), &iter, 0, "C", -1);


  sort_model = GTK_TREE_MODEL (gtk_tree_model_sort_new_with_model (child_model));
  gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort_model),
                                        0, GTK_SORT_ASCENDING);

  path = gtk_tree_path_new_from_indices (1, 1, -1);

  /* make sure a level is constructed */
  gtk_tree_model_get_iter (sort_model, &sort_iter, path);

  /* change the "E" row in a way that causes it to change position */ 
  gtk_tree_model_get_iter (child_model, &iter, path);
  gtk_tree_store_set (GTK_TREE_STORE (child_model), &iter, 0, "A", -1);

  gtk_tree_path_free (path);
}
コード例 #25
0
ファイル: nsp-feed.c プロジェクト: Michael-Z/Nowspide
NspFeed * 
nsp_feed_new()
{
	NspFeed * feed = malloc(sizeof(NspFeed));
	assert(feed != NULL);
	
	feed->type = NSP_FEED_UNKNOWN;
	feed->items = NULL;
	feed->title = feed->url = feed->site_url = feed->description = NULL;
	feed->id = 0;
	feed->unread_items = 0;
	feed->items_store = nsp_feed_item_list_get_model();
	feed->items_sorter = gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(feed->items_store));
	feed->mutex = g_mutex_new();
	feed->icon = NULL;
	
	gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (feed->items_sorter), ITEM_LIST_COL_DATE, GTK_SORT_DESCENDING);
	gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE (feed->items_sorter), ITEM_LIST_COL_DATE, (GtkTreeIterCompareFunc)nsp_feed_sort_date, NULL, NULL);
	
	
	return feed;
}
コード例 #26
0
ファイル: sortmodel.c プロジェクト: Pfiver/gtk
static void
specific_bug_364946 (void)
{
  /* This is a test case for GNOME Bugzilla bug 364946.  It was written
   * by Andreas Koehler.
   */
  GtkTreeStore *store;
  GtkTreeIter a, aa, aaa, aab, iter;
  GtkTreeModel *s_model;

  g_test_bug ("364946");

  store = gtk_tree_store_new (1, G_TYPE_STRING);

  gtk_tree_store_append (store, &a, NULL);
  gtk_tree_store_set (store, &a, 0, "0", -1);

  gtk_tree_store_append (store, &aa, &a);
  gtk_tree_store_set (store, &aa, 0, "0:0", -1);

  gtk_tree_store_append (store, &aaa, &aa);
  gtk_tree_store_set (store, &aaa, 0, "0:0:0", -1);

  gtk_tree_store_append (store, &aab, &aa);
  gtk_tree_store_set (store, &aab, 0, "0:0:1", -1);

  s_model = gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL (store));
  gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (s_model), 0,
                                        GTK_SORT_ASCENDING);

  gtk_tree_model_get_iter_from_string (s_model, &iter, "0:0:0");

  gtk_tree_store_set (store, &aaa, 0, "0:0:0", -1);
  gtk_tree_store_remove (store, &aaa);
  gtk_tree_store_remove (store, &aab);

  gtk_tree_model_sort_clear_cache (GTK_TREE_MODEL_SORT (s_model));
}
コード例 #27
0
static void
gnc_sx_list_tree_model_adapter_init(GTypeInstance *instance, gpointer klass)
{
    GncSxListTreeModelAdapter *adapter = GNC_SX_LIST_TREE_MODEL_ADAPTER(instance);
    adapter->orig = gtk_tree_store_new(5, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
    adapter->real = GTK_TREE_MODEL_SORT(gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(adapter->orig)));

    // setup sorting
    gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(adapter->real), SXLTMA_COL_NAME, _name_comparator, adapter, NULL);
    gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(adapter->real), SXLTMA_COL_ENABLED, _enabled_comparator, adapter, NULL);
    gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(adapter->real), SXLTMA_COL_FREQUENCY, _freq_comparator, adapter, NULL);
    gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(adapter->real), SXLTMA_COL_LAST_OCCUR, _last_occur_comparator, adapter, NULL);
    gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(adapter->real), SXLTMA_COL_NEXT_OCCUR, _next_occur_comparator, adapter, NULL);
    gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(adapter->real), SXLTMA_COL_NEXT_OCCUR, GTK_SORT_ASCENDING);

    g_signal_connect(adapter->real, "row-changed", G_CALLBACK(gsltma_proxy_row_changed), adapter);
    g_signal_connect(adapter->real, "row-deleted", G_CALLBACK(gsltma_proxy_row_deleted), adapter);
    g_signal_connect(adapter->real, "row-has-child-toggled", G_CALLBACK(gsltma_proxy_row_has_child_toggled), adapter);
    g_signal_connect(adapter->real, "row-inserted", G_CALLBACK(gsltma_proxy_row_inserted), adapter);
    g_signal_connect(adapter->real, "rows-reordered", G_CALLBACK(gsltma_proxy_rows_reordered), adapter);

    g_signal_connect(adapter->real, "sort-column-changed", G_CALLBACK(gsltma_proxy_sort_column_changed), adapter);
}
コード例 #28
0
ファイル: tr-core.c プロジェクト: whitequark/transmission
static void
tr_core_init (TrCore * core)
{
  GtkListStore * store;
  struct TrCorePrivate * p;

  /* column types for the model used to store torrent information */
  /* keep this in sync with the enum near the bottom of tr_core.h */
  GType types[] = { G_TYPE_POINTER,   /* collated name */
                    G_TYPE_POINTER,   /* tr_torrent* */
                    G_TYPE_INT,       /* torrent id */
                    G_TYPE_DOUBLE,    /* tr_stat.pieceUploadSpeed_KBps */
                    G_TYPE_DOUBLE,    /* tr_stat.pieceDownloadSpeed_KBps */
                    G_TYPE_DOUBLE,    /* tr_stat.recheckProgress */
                    G_TYPE_BOOLEAN,   /* filter.c:ACTIVITY_FILTER_ACTIVE */
                    G_TYPE_INT,       /* tr_stat.activity */
                    G_TYPE_UCHAR,     /* tr_stat.finished */
                    G_TYPE_CHAR,      /* tr_priority_t */
                    G_TYPE_INT,       /* tr_stat.queuePosition */
                    G_TYPE_UINT,      /* build_torrent_trackers_hash () */
                    G_TYPE_INT,       /* MC_ERROR */
                    G_TYPE_INT };     /* MC_ACTIVE_PEER_COUNT */

  p = core->priv = G_TYPE_INSTANCE_GET_PRIVATE (core,
                                                TR_CORE_TYPE,
                                                struct TrCorePrivate);

  /* create the model used to store torrent data */
  g_assert (G_N_ELEMENTS (types) == MC_ROW_COUNT);
  store = gtk_list_store_newv (MC_ROW_COUNT, types);

  p->raw_model = GTK_TREE_MODEL (store);
  p->sorted_model = gtk_tree_model_sort_new_with_model (p->raw_model);
  p->string_chunk = g_string_chunk_new (2048);
  g_object_unref (p->raw_model);
}
コード例 #29
0
ファイル: destination.c プロジェクト: Jalakas/libgarmin
int destination_address(struct navit *nav)
{

	GtkWidget *window2, *keyboard, *vbox, *table;
	GtkWidget *label_country;
	GtkWidget *label_postal, *label_city, *label_district;
	GtkWidget *label_street, *label_number;
	GtkWidget *hseparator1,*hseparator2;
	GtkWidget *button1,*button2,*button3;
	int i;
	struct search_param *search=&search_param;
	struct attr search_attr, country_name, *country_attr;
	struct tracking *tracking;
	struct country_search *cs;
	struct item *item;
	GtkTreeSelection* selection;


	search->nav=nav;
	search->ms=navit_get_mapset(nav);
	search->sl=search_list_new(search->ms);

	window2 = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_window_set_title(GTK_WINDOW(window2),_("Enter Destination"));
	vbox = gtk_vbox_new(FALSE, 0);
	table = gtk_table_new(3, 8, FALSE);

	search->entry_country = gtk_entry_new();
	label_country = gtk_label_new(_("Country"));
	search->entry_postal = gtk_entry_new();
	label_postal = gtk_label_new(_("Zip Code"));
	search->entry_city = gtk_entry_new();
	label_city = gtk_label_new(_("City"));
	search->entry_district = gtk_entry_new();
	label_district = gtk_label_new(_("District/Township"));
	hseparator1 = gtk_vseparator_new();
	search->entry_street = gtk_entry_new();
	label_street = gtk_label_new(_("Street"));
	search->entry_number = gtk_entry_new();
	label_number = gtk_label_new(_("Number"));
	search->listbox = gtk_scrolled_window_new (NULL, NULL);
	gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (search->listbox),
		GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);

//	gtk_tree_view_set_model (GTK_TREE_VIEW (search->treeview), NULL);
	{ 
		GType types[COL_COUNT+2];
		for(i=0;i<COL_COUNT;i++)
			types[i]=G_TYPE_STRING;
		types[i++]=G_TYPE_POINTER;
		types[i++]=G_TYPE_POINTER;
		search->liststore=gtk_list_store_newv(COL_COUNT+2,types);
		search->liststore2=gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(search->liststore));
		gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (search->liststore2), 0, GTK_SORT_ASCENDING);
	//	gtk_tree_view_set_model (GTK_TREE_VIEW (search->treeview), GTK_TREE_MODEL(search->liststore2));
		search->treeview = gtk_tree_view_new_with_model(search->liststore2);
		gtk_tree_view_set_search_column(GTK_TREE_VIEW (search->treeview),3);
	}
	gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(search->listbox),search->treeview);

#if 1
	selection = gtk_tree_view_get_selection(GTK_TREE_VIEW (search->treeview));
	gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
	g_signal_connect(selection, "changed", G_CALLBACK(select_row), search);
//	g_signal_connect(search->liststore, "row-activated", G_CALLBACK(select_row), search);
//	g_signal_connect(search->liststore2, "row-activated", G_CALLBACK(select_row), search);
//	g_signal_connect(search->treeview, "select-cursor-row", G_CALLBACK(select_row), search);
#endif


	hseparator2 = gtk_vseparator_new();
	button1 = gtk_button_new_with_label(_("Map"));
	button2 = gtk_button_new_with_label(_("Bookmark"));
	button3 = gtk_button_new_with_label(_("Destination"));

	gtk_table_attach(GTK_TABLE(table), label_country,  0, 1,  0, 1,  0, GTK_FILL, 0, 0);
	gtk_table_attach(GTK_TABLE(table), label_postal,   1, 2,  0, 1,  0, GTK_FILL, 0, 0);
	gtk_table_attach(GTK_TABLE(table), label_city,     2, 3,  0, 1,  0, GTK_FILL, 0, 0);

	gtk_table_attach(GTK_TABLE(table), search->entry_country,  0, 1,  1, 2,  0, GTK_FILL, 0, 0);
	gtk_table_attach(GTK_TABLE(table), search->entry_postal,   1, 2,  1, 2,  0, GTK_FILL, 0, 0);
	gtk_table_attach(GTK_TABLE(table), search->entry_city,     2, 3,  1, 2,  0, GTK_FILL, 0, 0);

	gtk_table_attach(GTK_TABLE(table), label_district, 0, 1,  2, 3,  0, GTK_FILL, 0, 0);
	gtk_table_attach(GTK_TABLE(table), label_street,   1, 2,  2, 3,  0, GTK_FILL, 0, 0);
	gtk_table_attach(GTK_TABLE(table), label_number,   2, 3,  2, 3,  0, GTK_FILL, 0, 0);

	gtk_table_attach(GTK_TABLE(table), search->entry_district, 0, 1,  3, 4,  0, GTK_FILL, 0, 0);
	gtk_table_attach(GTK_TABLE(table), search->entry_street,   1, 2,  3, 4,  0, GTK_FILL, 0, 0);
	gtk_table_attach(GTK_TABLE(table), search->entry_number,   2, 3,  3, 4,  0, GTK_FILL, 0, 0);

	gtk_table_attach(GTK_TABLE(table), search->listbox,        0, 3,  4, 5,  GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 0, 0);

	gtk_table_attach(GTK_TABLE(table), button1, 0, 1, 5, 6, GTK_FILL, GTK_FILL, 0, 0);
	gtk_table_attach(GTK_TABLE(table), button2, 1, 2, 5, 6, GTK_FILL, GTK_FILL, 0, 0);
	gtk_table_attach(GTK_TABLE(table), button3, 2, 3, 5, 6, GTK_FILL, GTK_FILL, 0, 0);

	g_signal_connect(G_OBJECT(search->entry_country), "changed", G_CALLBACK(changed), search);
	g_signal_connect(G_OBJECT(search->entry_postal), "changed", G_CALLBACK(changed), search);
	g_signal_connect(G_OBJECT(search->entry_city), "changed", G_CALLBACK(changed), search);
	g_signal_connect(G_OBJECT(search->entry_district), "changed", G_CALLBACK(changed), search);
	g_signal_connect(G_OBJECT(search->entry_street), "changed", G_CALLBACK(changed), search);
	g_signal_connect(G_OBJECT(search->entry_number), "changed", G_CALLBACK(changed), search);
	g_signal_connect(G_OBJECT(button1), "clicked", G_CALLBACK(button_map), search);
	g_signal_connect(G_OBJECT(button2), "clicked", G_CALLBACK(button_bookmark), search);
	g_signal_connect(G_OBJECT(button3), "clicked", G_CALLBACK(button_destination), search);

	gtk_widget_grab_focus(search->entry_city);

	gtk_box_pack_start(GTK_BOX(vbox), table, TRUE, TRUE, 0);
	keyboard=gtk_socket_new();
	gtk_box_pack_end(GTK_BOX(vbox), keyboard, FALSE, FALSE, 0);
	gtk_container_add(GTK_CONTAINER(window2), vbox);
	gtk_widget_show_all(window2);
//	gtk_socket_steal(GTK_SOCKET(keyboard), spawn_xkbd("xkbd","-geometry 200x100"));

	country_attr=country_default();
	tracking=navit_get_tracking(nav);
	if (tracking && tracking_get_current_attr(tracking, attr_country_id, &search_attr)) 
		country_attr=&search_attr;
	cs=country_search_new(country_attr, 0);
	item=country_search_get_item(cs);
	if (item && item_attr_get(item, attr_country_name, &country_name)) 
		gtk_entry_set_text(GTK_ENTRY(search->entry_country), country_name.u.str);
	country_search_destroy(cs);
	return 0;
}
コード例 #30
0
static GtkWidget*
shortcuts_get_preferences_dialog (MidoriExtension* extension)
{
    MidoriApp* app;
    GtkWidget* browser;
    const gchar* dialog_title;
    GtkWidget* dialog;
    gint width, height;
    GtkWidget* xfce_heading;
    GtkWidget* hbox;
    GtkListStore* liststore;
    GtkTreeModel* model;
    GtkWidget* treeview;
    GtkTreeViewColumn* column;
    GtkCellRenderer* renderer;
    GtkWidget* scrolled;
    GtkActionGroup* action_group;
    GList* actions;
    guint i;
    GtkAction* action;
    #if HAVE_OSX
    GtkWidget* icon;
    #endif

    app = midori_extension_get_app (extension);
    browser = katze_object_get_object (app, "browser");

    dialog_title = _("Customize Keyboard shortcuts");
    dialog = gtk_dialog_new_with_buttons (dialog_title, GTK_WINDOW (browser),
        GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_NO_SEPARATOR,
        #if !HAVE_OSX
        GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
        #endif
        NULL);
    g_signal_connect (dialog, "destroy",
                      G_CALLBACK (gtk_widget_destroyed), &dialog);
    gtk_window_set_icon_name (GTK_WINDOW (dialog), GTK_STOCK_PROPERTIES);
    sokoke_widget_get_text_size (dialog, "M", &width, &height);
    gtk_window_set_default_size (GTK_WINDOW (dialog), width * 52, height * 24);
    g_signal_connect (dialog, "response",
                      G_CALLBACK (shortcuts_preferences_response_cb), NULL);
    if ((xfce_heading = sokoke_xfce_header_new (
        gtk_window_get_icon_name (GTK_WINDOW (dialog)), dialog_title)))
        gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox),
                            xfce_heading, FALSE, FALSE, 0);
    hbox = gtk_hbox_new (FALSE, 0);
    gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox,
                                 TRUE, TRUE, 12);
    liststore = gtk_list_store_new (7,
        G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT, G_TYPE_INT, G_TYPE_BOOLEAN,
        G_TYPE_STRING, GTK_TYPE_ACTION);
    model = gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL (liststore));
    treeview = gtk_tree_view_new_with_model (model);
    gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), FALSE);
    column = gtk_tree_view_column_new ();
    renderer = gtk_cell_renderer_text_new ();
    gtk_tree_view_column_pack_start (column, renderer, FALSE);
    gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (column), renderer, "text", 0);
    gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
    column = gtk_tree_view_column_new ();
    renderer = gtk_cell_renderer_accel_new ();
    gtk_tree_view_column_pack_start (column, renderer, TRUE);
    gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (column), renderer, "accel-key", 1);
    gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (column), renderer, "accel-mods", 2);
    gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (column), renderer, "accel-mode", 3);
    gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (column), renderer, "sensitive", 4);
    gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (column), renderer, "editable", 4);
    g_signal_connect (renderer, "accel-edited",
        G_CALLBACK (shortcuts_accel_edited_cb), model);
    g_signal_connect (renderer, "accel-cleared",
        G_CALLBACK (shortcuts_accel_cleared_cb), model);
    gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
    scrolled = gtk_scrolled_window_new (NULL, NULL);
    gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
                                    GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
    gtk_container_add (GTK_CONTAINER (scrolled), treeview);
    gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled),
                                         GTK_SHADOW_IN);
    gtk_box_pack_start (GTK_BOX (hbox), scrolled, TRUE, TRUE, 5);

    action_group = midori_browser_get_action_group (MIDORI_BROWSER (browser));
    actions = gtk_action_group_list_actions (action_group);
    i = 0;
    /* FIXME: Catch added and removed actions */
    while ((action = g_list_nth_data (actions, i++)))
    {
        gchar* label = shortcuts_label_for_action (action);
        GtkAccelKey key;
        gboolean has_hotkey = shortcuts_hotkey_for_action (action, &key);
        gtk_list_store_insert_with_values (GTK_LIST_STORE (liststore),
            NULL, G_MAXINT, 0, label, 1, key.accel_key, 2, key.accel_mods,
                            3, GTK_CELL_RENDERER_ACCEL_MODE_OTHER,
                            4, has_hotkey, 6, action, -1);
        g_free (label);
    }
    g_list_free (actions);

    g_object_unref (liststore);
    gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (model),
                                          0, GTK_SORT_ASCENDING);
    g_object_unref (model);

    gtk_widget_show_all (GTK_DIALOG (dialog)->vbox);

    g_object_unref (browser);

    return dialog;
}