Exemplo n.º 1
0
void nsgtk_history_init_filters(void)
{	
	GtkWidget *search_entry, *clear_button;
	GString *filter_string = g_string_new(NULL);
							
	search_entry = glade_xml_get_widget(gladeFile,"entrySearch");
	clear_button = glade_xml_get_widget(gladeFile,"buttonClearSearch");
	
	g_signal_connect(G_OBJECT(search_entry), "changed", 
			G_CALLBACK(nsgtk_history_search), NULL);
	g_signal_connect_swapped(G_OBJECT(clear_button), "clicked",
			G_CALLBACK(nsgtk_history_search_clear),
			GTK_ENTRY(search_entry));
	
	gtk_tree_model_filter_set_visible_func(
			GTK_TREE_MODEL_FILTER(history->history_filter), 
			(GtkTreeModelFilterVisibleFunc)
			nsgtk_history_filter_search, search_entry, NULL);
	gtk_tree_model_filter_set_visible_func(
			GTK_TREE_MODEL_FILTER(history->site_filter), 
			(GtkTreeModelFilterVisibleFunc)
			nsgtk_history_filter_sites, filter_string, NULL);
	gtk_tree_model_filter_set_visible_column(
			GTK_TREE_MODEL_FILTER(history->domain_filter), 
			DOM_HAS_SITES);	

	g_signal_connect(G_OBJECT(history->site_selection), "changed",
		G_CALLBACK(nsgtk_history_update_info), FALSE);
	g_signal_connect(G_OBJECT(history->domain_selection), "changed",
		G_CALLBACK(nsgtk_history_show_domain), filter_string);
}
void
recordings_list_init(FreetuxTVApp *app)
{
	GtkWidget *widget;
	GtkCellRenderer *renderer;
	GtkTreeViewColumn *column;
	GtkTreeModel * filter;

	GtkListStore *liststore;
	liststore = gtk_list_store_new (N_COLUMNS, FREETUXTV_TYPE_RECORDING_INFOS);
	app->pRecordingList = GTK_TREE_MODEL(liststore);
	
	// Set the in progress recordings list view
	widget = (GtkWidget *)gtk_builder_get_object (app->gui,
	    "windowmain_treeviewrecordings");
	filter = gtk_tree_model_filter_new (app->pRecordingList, NULL);
	gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER(filter),
	    on_filter_recording_list_in_progress, (gpointer)app, NULL);
	gtk_tree_view_set_model (GTK_TREE_VIEW(widget), filter);
	g_signal_connect(widget, "row-activated",
	    G_CALLBACK(on_row_activated_recordings_list), app);
	g_signal_connect(widget, "button-press-event",
	    G_CALLBACK(on_button_press_event_recordings_list), app);

	column = gtk_tree_view_column_new();
	renderer = freetuxtv_cellrenderer_recordingslist_new ();
	gtk_tree_view_column_pack_start(column, renderer, FALSE);
	gtk_tree_view_column_set_cell_data_func(column, renderer,
	    on_row_displayed_recordings_list,
	    (gpointer)app, NULL);	
	gtk_tree_view_append_column (GTK_TREE_VIEW (widget), column);

	// Set the in progress recordings list view
	widget = (GtkWidget *)gtk_builder_get_object (app->gui,
	    "windowmain_treeviewfinishedrecordings");
	filter = gtk_tree_model_filter_new (app->pRecordingList, NULL);
	gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER(filter),
	    on_filter_recording_list_terminated, (gpointer)app, NULL);
	gtk_tree_view_set_model (GTK_TREE_VIEW(widget), filter);
	g_signal_connect(widget, "row-activated",
	    G_CALLBACK(on_row_activated_recordings_list), app);
	g_signal_connect(widget, "button-press-event",
	    G_CALLBACK(on_button_press_event_recordings_list), app);
	
	column = gtk_tree_view_column_new();
	renderer = freetuxtv_cellrenderer_recordingslist_new ();
	gtk_tree_view_column_pack_start(column, renderer, FALSE);
	gtk_tree_view_column_set_cell_data_func(column, renderer,
	    on_row_displayed_recordings_list,
	    (gpointer)app, NULL);	
	gtk_tree_view_append_column (GTK_TREE_VIEW (widget), column);
}
Exemplo n.º 3
0
static void
_glade_adaptor_chooser_widget_constructed (GObject *object)
{
  _GladeAdaptorChooserWidget *chooser = GLADE_ADAPTOR_CHOOSER_WIDGET (object);
  _GladeAdaptorChooserWidgetPrivate *priv = GET_PRIVATE (chooser);

  /* Set cell data function: this save us from alocating name and icon name for each adaptor. */
  gtk_tree_view_column_set_cell_data_func (priv->column_icon,
                                           priv->icon_cell,
                                           adaptor_icon_cell_data_func,
                                           NULL, NULL);
  gtk_tree_view_column_set_cell_data_func (priv->column_adaptor,
                                           priv->adaptor_cell,
                                           adaptor_text_cell_data_func,
                                           NULL, NULL);
  /* Set tree model filter function */
  gtk_tree_model_filter_set_visible_func (priv->treemodelfilter,
                                          treemodelfilter_visible_func,
                                          chooser, NULL);
  /* Set completion match function */
  gtk_entry_completion_set_match_func (priv->entrycompletion,
                                       entrycompletion_match_func,
                                       chooser, NULL);
  /* Enable Drag & Drop */
  gtk_tree_view_enable_model_drag_source (priv->treeview, GDK_BUTTON1_MASK,
                                          _glade_dnd_get_target (), 1, 0);
  g_signal_connect_after (priv->treeview, "drag-begin",
                          G_CALLBACK (glade_adaptor_chooser_widget_drag_begin),
                          NULL);
  g_signal_connect (priv->treeview, "drag-data-get",
                    G_CALLBACK (glade_adaptor_chooser_widget_drag_data_get),
                    NULL);
}
/*
 * Set an GtkTreeModel visible filter on this commodity.  This filter will be
 * called for each commodity that the tree is about to show, and the
 * commodity will be passed to the callback function.
 */
void
gnc_tree_view_commodity_set_filter (GncTreeViewCommodity *view,
                                    gnc_tree_view_commodity_ns_filter_func ns_func,
                                    gnc_tree_view_commodity_cm_filter_func cm_func,
                                    gpointer data,
                                    GDestroyNotify destroy)
{
    GtkTreeModel *f_model, *s_model;
    filter_user_data *fd = data;

    g_return_if_fail(GNC_IS_TREE_VIEW_COMMODITY(view));
    g_return_if_fail((ns_func != NULL) || (cm_func != NULL));

    ENTER("view %p, ns func %p, cm func %p, data %p, destroy %p",
          view, ns_func, cm_func, data, destroy);

    fd = g_malloc(sizeof(filter_user_data));
    fd->user_ns_fn   = ns_func;
    fd->user_cm_fn   = cm_func;
    fd->user_data    = data;
    fd->user_destroy = destroy;

    s_model = gtk_tree_view_get_model(GTK_TREE_VIEW(view));
    f_model = gtk_tree_model_sort_get_model(GTK_TREE_MODEL_SORT(s_model));
    gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (f_model),
                                            gnc_tree_view_commodity_filter_helper,
                                            fd,
                                            gnc_tree_view_commodity_filter_destroy);

    /* Whack any existing levels. The top two levels have been created
     * before this routine can be called. */
    gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (f_model));
    LEAVE(" ");
}
Exemplo n.º 5
0
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")));
}
Exemplo n.º 6
0
EinaMuine*
eina_muine_new (void)
{
    gchar *xml_string = NULL;
    gel_io_resources_load_file_contents_or_error(EINA_APP_PATH_DOMAIN "/muine/main.ui", &xml_string, NULL);

    EinaMuine *self = g_object_new (EINA_TYPE_MUINE, "xml-string", xml_string , NULL);
    EinaMuinePrivate *priv = self->priv;
    g_free(xml_string);

    GelUIGeneric *ui_generic = GEL_UI_GENERIC(self);

    priv->listview = gel_ui_generic_get_typed(ui_generic, GTK_TREE_VIEW,         "list-view");
    priv->filter   = gel_ui_generic_get_typed(ui_generic, GTK_TREE_MODEL_FILTER, "model-filter");
    priv->model    = gel_ui_generic_get_typed(ui_generic, GTK_LIST_STORE,        "model");
    priv->search   = gel_ui_generic_get_typed(ui_generic, GTK_ENTRY,             "search-entry");

    g_object_set(gel_ui_generic_get_object(ui_generic, "markup-renderer"),
                 "yalign", 0.0f,
                 NULL);
    gtk_tree_model_filter_set_visible_func(priv->filter, (GtkTreeModelFilterVisibleFunc) muine_filter_func, self, NULL);
    g_object_bind_property(self, "mode", gel_ui_generic_get_object(ui_generic, "mode-view"), "active", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE);

    gchar *actions[] = { "play-action", "queue-action" };
    for (guint i = 0; i < G_N_ELEMENTS(actions); i++)
    {
        GObject *a = gel_ui_generic_get_object(ui_generic, actions[i]);
        g_signal_connect(a, "activate", (GCallback) action_activate_cb, self);
    }
    g_signal_connect(priv->listview, "row-activated", (GCallback) row_activated_cb, self);
    g_signal_connect(priv->search,   "changed",       (GCallback) search_changed_cb, self);
    g_signal_connect(priv->search,   "icon-press",    (GCallback) search_icon_press_cb, self);

    return self;
}
void
empathy_protocol_chooser_set_visible (EmpathyProtocolChooser *protocol_chooser,
    EmpathyProtocolChooserFilterFunc func,
    gpointer user_data)
{
  EmpathyProtocolChooserPriv *priv;
  GtkTreeModel *filter_model;

  g_return_if_fail (EMPATHY_IS_PROTOCOL_CHOOSER (protocol_chooser));

  priv = GET_PRIV (protocol_chooser);
  priv->filter_func = func;
  priv->filter_user_data = user_data;

  filter_model = gtk_tree_model_filter_new (GTK_TREE_MODEL (priv->store),
      NULL);
  gtk_combo_box_set_model (GTK_COMBO_BOX (protocol_chooser), filter_model);
  g_object_unref (filter_model);

  gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER
      (filter_model), protocol_chooser_filter_visible_func,
      protocol_chooser, NULL);

  gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (filter_model));

  gtk_combo_box_set_active (GTK_COMBO_BOX (protocol_chooser), 0);
}
Exemplo n.º 8
0
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);
}
void
um_password_dialog_set_user (UmPasswordDialog *um,
                             UmUser           *user)
{
        GdkPixbuf *pixbuf;
        GtkTreeModel *model;

        if (um->user) {
                g_object_unref (um->user);
                um->user = NULL;
        }
        if (user) {
                um->user = g_object_ref (user);

                um->using_ecryptfs = is_using_ecryptfs (um_user_get_user_name (user));

                pixbuf = um_user_render_icon (user, FALSE, 48);
                gtk_image_set_from_pixbuf (GTK_IMAGE (um->user_icon), pixbuf);
                g_object_unref (pixbuf);

                gtk_label_set_label (GTK_LABEL (um->user_name),
                                     um_user_get_real_name (user));

                gtk_entry_set_text (GTK_ENTRY (um->password_entry), "");
                gtk_entry_set_text (GTK_ENTRY (um->verify_entry), "");
                gtk_entry_set_text (GTK_ENTRY (um->normal_hint_entry), "");
                gtk_entry_set_text (GTK_ENTRY (um->old_password_entry), "");
                gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (um->show_password_button), FALSE);
                if (um_user_get_uid (um->user) == getuid () &&
                    um_user_get_password_mode (um->user) == UM_PASSWORD_MODE_REGULAR) {
                        gtk_widget_show (um->old_password_label);
                        gtk_widget_show (um->old_password_entry);
                        um->old_password_ok = FALSE;
                }
                else {
                        gtk_widget_hide (um->old_password_label);
                        gtk_widget_hide (um->old_password_entry);
                        um->old_password_ok = TRUE;
                }
                if (um_user_get_uid (um->user) == getuid()) {
                        if (um->passwd_handler != NULL)
                                passwd_destroy (um->passwd_handler);
                        um->passwd_handler = passwd_init ();
                }
        }

        model = gtk_combo_box_get_model (GTK_COMBO_BOX (um->action_combo));
        if (!GTK_IS_TREE_MODEL_FILTER (model)) {
                model = gtk_tree_model_filter_new (model, NULL);
                gtk_combo_box_set_model (GTK_COMBO_BOX (um->action_combo), model);
                gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (model),
                                                        (GtkTreeModelFilterVisibleFunc) visible_func,
                                                        um, NULL);
        }

        gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (model));
        gtk_combo_box_set_active (GTK_COMBO_BOX (um->action_combo), 0);
}
Exemplo n.º 10
0
static VALUE
rg_set_visible_func(VALUE self)
{
    VALUE func = rb_block_proc();
    G_RELATIVE(self, func);
    gtk_tree_model_filter_set_visible_func(_SELF(self), 
                                           (GtkTreeModelFilterVisibleFunc)visible_func, 
                                           (gpointer)func, NULL);
    return self;
}
Exemplo n.º 11
0
static GtkTreeModel *
glade_project_toplevel_model_filter_new (GladeProjectProperties *properties)
{
  GladeProjectPropertiesPrivate *priv = properties->priv;
  GtkTreeModel *model;

  model = gtk_tree_model_filter_new (GTK_TREE_MODEL (priv->project), NULL);
  gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (model),
                                          template_visible_func, NULL, NULL);
  return model;
}
Exemplo n.º 12
0
GtkTreeModel *
get_filter_model (gboolean first)
{
  GtkTreeModelFilter *model;

  model = (GtkTreeModelFilter *)gtk_tree_model_filter_new (get_model (), NULL);

  gtk_tree_model_filter_set_visible_func (model, visible_func, GINT_TO_POINTER (first), NULL);

  return (GtkTreeModel *) model;
}
Exemplo n.º 13
0
GtkTreeModelFilter *
rs_dcp_factory_get_compatible_as_model(RSProfileFactory *factory, const gchar *unique_id)
{
	g_return_val_if_fail(RS_IS_PROFILE_FACTORY(factory), NULL);

	GtkTreeModelFilter *filter = GTK_TREE_MODEL_FILTER(gtk_tree_model_filter_new(GTK_TREE_MODEL(factory->profiles), NULL));

	gtk_tree_model_filter_set_visible_func(filter, visible_func, g_strdup(unique_id), g_free);

	return filter;
}
Exemplo n.º 14
0
static void
gnac_properties_build_table(void)
{
  GtkCellRenderer *renderer;
  GtkTreeModel    *model;
  GtkTreeView     *view;

  model = GTK_TREE_MODEL(gnac_properties_get_object("properties_store"));
  view = GTK_TREE_VIEW(gnac_properties_get_widget("properties_view"));

  gtk_tree_view_set_tooltip_column(view, PROPERTY_TOOLTIP);

  properties_filter = gtk_tree_model_filter_new(model, NULL);
  gtk_tree_model_filter_set_visible_func(
      GTK_TREE_MODEL_FILTER(properties_filter),
      gnac_properties_visible_func, NULL, NULL);
  gtk_tree_view_set_model(view, properties_filter);

  renderer = gtk_cell_renderer_text_new();
  g_object_set(G_OBJECT(renderer), "xalign", 1.0, NULL);
  g_object_set(G_OBJECT(renderer), "xpad", 6, NULL);
  g_object_set(G_OBJECT(renderer), "weight", 700, NULL);
  gtk_tree_view_insert_column_with_attributes(view, -1,
      "Property", renderer, "text", PROPERTY_NAME, NULL);

  renderer = gtk_cell_renderer_text_new();
  g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
  gtk_tree_view_insert_column_with_attributes(view, -1,
      "Value", renderer, "text", PROPERTY_VALUE, NULL);

  gnac_properties_table = g_hash_table_new_full(g_str_hash,
      g_str_equal, g_free, (GDestroyNotify) gtk_tree_row_reference_free);
  
  guint i;
  for (i = 0; displayed_properties[i][0]; i++) {
    GtkTreeIter iter;

    gtk_list_store_append(GTK_LIST_STORE(model), &iter);
    gtk_list_store_set(GTK_LIST_STORE(model), &iter,
        PROPERTY_NAME, gettext(displayed_properties[i][1]),
        PROPERTY_VISIBLE, TRUE,
        -1);

    GtkTreePath *path = gtk_tree_model_get_path(model, &iter);
    GtkTreeRowReference *ref = gtk_tree_row_reference_new(model, path);

    g_hash_table_insert(gnac_properties_table,
        g_strdup(displayed_properties[i][0]), ref);

    gtk_tree_path_free(path);
  }
}
Exemplo n.º 15
0
void
dates_navigator_view_set_visible_func (DatesNavigatorView * view,
									   GtkTreeModelFilterVisibleFunc func,
									   gpointer data,
									   GtkDestroyNotify destroy)
{
	if (!view->priv->navigator)
		return;

	GtkTreeModelFilter *filter = GTK_TREE_MODEL_FILTER (view->priv->navigator);

	gtk_tree_model_filter_set_visible_func (filter, func, data, destroy);
}
Exemplo n.º 16
0
static GtkTreeModel *
encodings_create_treemodel (GtkListStore *base_store,
                            gboolean active)
{
	GtkTreeModel *model;

	model = gtk_tree_model_filter_new (GTK_TREE_MODEL (base_store), NULL);
	gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (model),
	                                        filter_active_encodings,
	                                        GUINT_TO_POINTER (active), NULL);

	return model;
}
Exemplo n.º 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;
}
static void
set_model (EmpathyPersonaView *self,
    GtkTreeModel *model)
{
  EmpathyPersonaViewPriv *priv = GET_PRIV (self);

  tp_clear_object (&priv->filter);

  priv->filter = GTK_TREE_MODEL_FILTER (gtk_tree_model_filter_new (model,
      NULL));
  gtk_tree_model_filter_set_visible_func (priv->filter,
      (GtkTreeModelFilterVisibleFunc) filter_visible_func, self, NULL);

  gtk_tree_view_set_model (GTK_TREE_VIEW (self), GTK_TREE_MODEL (priv->filter));
}
Exemplo n.º 19
0
static void
nmn_model_init (NmnModel *model)
{
    NmnModelPrivate *priv = GET_PRIVATE (model);

    gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (model),
                                            model_row_visible_func, model, NULL);

    /* FIXME: Load from gconf? */
    priv->ethernet_active = TRUE;
    priv->wifi_active = TRUE;
    priv->modems_active = TRUE;
    priv->bt_active = TRUE;
    priv->offline_mode_active = FALSE;
}
static void ryostklconfig_pro_dimness_selector_init(RyostklconfigProDimnessSelector *dimness_selector) {
	RyostklconfigProDimnessSelectorPrivate *priv = RYOSTKLCONFIG_PRO_DIMNESS_SELECTOR_GET_PRIVATE(dimness_selector);
	RyostklconfigProDimnessSelectorClass *klass = RYOSTKLCONFIG_PRO_DIMNESS_SELECTOR_GET_CLASS(dimness_selector);
	GtkTreeModel *filter;

	dimness_selector->priv = priv;

	filter = gtk_tree_model_filter_new(GTK_TREE_MODEL(klass->store), NULL);
	gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(filter), visible_func, dimness_selector, NULL);
	gtk_combo_box_set_model(GTK_COMBO_BOX(dimness_selector), filter);

	priv->changed_handler_id = g_signal_connect(G_OBJECT(dimness_selector), "changed", G_CALLBACK(changed_cb), NULL);
	priv->is_pro = TRUE; /* max features on startup */
	priv->light_macro = NULL;
}
static void
maybe_add_category_view (GnomeControlCenter *shell,
                         const char         *name)
{
  GtkTreeModel *filter;
  GtkWidget *categoryview;

  if (g_hash_table_lookup (shell->priv->category_views, name) != NULL)
    return;

  if (g_hash_table_size (shell->priv->category_views) > 0)
    {
      GtkWidget *separator;
      separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
      gtk_widget_set_margin_top (separator, 11);
      gtk_widget_set_margin_bottom (separator, 10);
      gtk_box_pack_start (GTK_BOX (shell->priv->main_vbox), separator, FALSE, FALSE, 0);
      gtk_widget_show (separator);
    }

  /* create new category view for this category */
  filter = gtk_tree_model_filter_new (GTK_TREE_MODEL (shell->priv->store),
                                      NULL);
  gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (filter),
                                          (GtkTreeModelFilterVisibleFunc) category_filter_func,
                                          g_strdup (name), g_free);

  categoryview = cc_shell_category_view_new (name, filter);
  gtk_box_pack_start (GTK_BOX (shell->priv->main_vbox), categoryview, FALSE, TRUE, 0);

  g_signal_connect (cc_shell_category_view_get_item_view (CC_SHELL_CATEGORY_VIEW (categoryview)),
                    "desktop-item-activated",
                    G_CALLBACK (item_activated_cb), shell);

  gtk_widget_show (categoryview);

  g_signal_connect (cc_shell_category_view_get_item_view (CC_SHELL_CATEGORY_VIEW (categoryview)),
                    "focus-in-event",
                    G_CALLBACK (category_focus_in), shell);
  g_signal_connect (cc_shell_category_view_get_item_view (CC_SHELL_CATEGORY_VIEW (categoryview)),
                    "focus-out-event",
                    G_CALLBACK (category_focus_out), shell);
  g_signal_connect (cc_shell_category_view_get_item_view (CC_SHELL_CATEGORY_VIEW (categoryview)),
                    "keynav-failed",
                    G_CALLBACK (keynav_failed), shell);

  g_hash_table_insert (shell->priv->category_views, g_strdup (name), categoryview);
}
Exemplo n.º 22
0
static void
photos_preview_model_init (PhotosPreviewModel *self)
{
  PhotosPreviewModelPrivate *priv;
  GApplication *app;
  PhotosSearchContextState *state;

  self->priv = photos_preview_model_get_instance_private (self);
  priv = self->priv;

  app = g_application_get_default ();
  state = photos_search_context_get_state (PHOTOS_SEARCH_CONTEXT (app));

  priv->item_mngr = g_object_ref (state->item_mngr);
  gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (self), photos_preview_model_visible, self, NULL);
}
Exemplo n.º 23
0
static GtkTreeModel *
gebr_dict_complete_get_filter_full(GebrGuiCompleteVariables *complete,
                                   GebrGeoXmlParameterType type,
                                   GebrGeoXmlDocumentType doc_type)
{
    GebrDictComplete *self = GEBR_DICT_COMPLETE(complete);
    GtkTreeModel *filter = gtk_tree_model_filter_new(GTK_TREE_MODEL(self->priv->store), NULL);

    struct FilterData *data = g_new(struct FilterData, 1);
    data->type = type;
    data->doc_type = doc_type;

    gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(filter),
                                           visible_func, data, g_free);
    return filter;
}
Exemplo n.º 24
0
GtkWidget*
xml_tree_model_filter_new (GtkTreeModel *child_model,
                           GtkTreePath *root)
{
	xmlTreeModelFilter * ttt;

	ttt->model = child_model;
	ttt->root = root;	
	
	ttt = (xmlTreeModelFilter *)g_object_new (xml_tree_model_filter_get_type (), ttt);

	
	gtk_tree_model_filter_set_visible_func(ttt, show_visible, ttt, NULL);
	
	return ttt;
}
Exemplo n.º 25
0
static void panel_addto_make_application_model(PanelAddtoDialog* dialog)
{
	GtkTreeStore* store;
	MateMenuTree* tree;
	MateMenuTreeDirectory* root;

	if (dialog->filter_application_model != NULL)
		return;

	store = gtk_tree_store_new(NUMBER_COLUMNS, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_STRING);

	tree = matemenu_tree_lookup("mate-applications.menu", MATEMENU_TREE_FLAGS_NONE);
	matemenu_tree_set_sort_key(tree, MATEMENU_TREE_SORT_DISPLAY_NAME);

	if ((root = matemenu_tree_get_root_directory (tree)))
	{
		panel_addto_make_application_list(&dialog->application_list, root, "mate-applications.menu");
		panel_addto_populate_application_model(store, NULL, dialog->application_list);

		matemenu_tree_item_unref(root);
	}

	matemenu_tree_unref(tree);

	tree = matemenu_tree_lookup("mate-settings.menu", MATEMENU_TREE_FLAGS_NONE);
	matemenu_tree_set_sort_key(tree, MATEMENU_TREE_SORT_DISPLAY_NAME);

	if ((root = matemenu_tree_get_root_directory(tree)))
	{
		GtkTreeIter iter;

		gtk_tree_store_append(store, &iter, NULL);
		gtk_tree_store_set(store, &iter, COLUMN_ICON, NULL, COLUMN_TEXT, NULL, COLUMN_DATA, NULL, COLUMN_SEARCH, NULL, -1);

		panel_addto_make_application_list(&dialog->settings_list, root, "mate-settings.menu");
		panel_addto_populate_application_model(store, NULL, dialog->settings_list);

		matemenu_tree_item_unref(root);
	}

	matemenu_tree_unref(tree);

	dialog->application_model = GTK_TREE_MODEL(store);
	dialog->filter_application_model = gtk_tree_model_filter_new(GTK_TREE_MODEL(dialog->application_model), NULL);
	gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(dialog->filter_application_model), panel_addto_filter_func, dialog, NULL);
}
Exemplo n.º 26
0
static void
cryptui_key_store_init (CryptUIKeyStore *ckstore)
{
    /* init private vars */
    ckstore->priv = g_new0 (CryptUIKeyStorePriv, 1);

    /* Our key -> row ref mapping */
    ckstore->priv->rows = g_hash_table_new_full (g_str_hash, g_str_equal, NULL,
                          (GDestroyNotify)gtk_tree_row_reference_free);

    /* The base store */
    ckstore->priv->store = gtk_tree_store_newv (CRYPTUI_KEY_STORE_NCOLS, (GType*)col_types);

    /* The filtering model */
    ckstore->priv->filter = GTK_TREE_MODEL_FILTER (gtk_tree_model_filter_new (GTK_TREE_MODEL (ckstore->priv->store), NULL));
    gtk_tree_model_filter_set_visible_func (ckstore->priv->filter, (GtkTreeModelFilterVisibleFunc)filter_callback, ckstore, NULL);
}
Exemplo n.º 27
0
static void default_adapter_changed (GObject    *gobject,
				     GParamSpec *arg1,
				     gpointer    data)
{
	BluetoothChooser *self = BLUETOOTH_CHOOSER (data);
	BluetoothChooserPrivate *priv = BLUETOOTH_CHOOSER_GET_PRIVATE(self);
	char *adapter;

	g_object_get (gobject, "default-adapter", &adapter, NULL);

	if (adapter == NULL) {
		gtk_widget_set_sensitive (GTK_WIDGET (priv->treeview), FALSE);
		set_search_label (self, FALSE);
		gtk_tree_view_set_model (GTK_TREE_VIEW(priv->treeview), NULL);
	}

	if (priv->model) {
		g_object_unref (priv->model);
		priv->model = NULL;
	}

	if (adapter == NULL)
		return;

	g_free (adapter);

	priv->model = bluetooth_client_get_device_model (priv->client);
	if (priv->model) {
		priv->filter = gtk_tree_model_filter_new (priv->model, NULL);
		gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (priv->filter),
							filter_func, self, NULL);
		gtk_tree_view_set_model (GTK_TREE_VIEW(priv->treeview), priv->filter);
		g_signal_connect (priv->filter, "row-changed",
				  G_CALLBACK (device_model_row_changed), self);
		g_object_unref (priv->filter);
		gtk_widget_set_sensitive (GTK_WIDGET (priv->treeview), TRUE);

		/* Start a discovery if it was requested before we
		 * had an adapter available */
		if (priv->disco_rq != FALSE) {
			bluetooth_chooser_start_discovery (self);
			set_search_label (self, TRUE);
		}
	}
}
Exemplo n.º 28
0
static void
setup_action (PdmActionInfo *action)
{
	GList *l;
	GtkWidget *remove_button, *clear_button, *find_entry;
	GtkTreeSelection *selection;
	GtkTreeModelFilter *filter;
	
	for (l = action->list; l != NULL; l = l->next)
	{
		action->add (action, l->data);
	}

	remove_button = galeon_dialog_get_control(GALEON_DIALOG(action->dialog), 
						  action->remove_id);
	g_signal_connect (remove_button, "clicked",
			  G_CALLBACK(pdm_dialog_remove_button_clicked_cb),
			  action);
	
	selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(action->treeview));
	g_signal_connect (selection, "changed",
			  G_CALLBACK(action_treeview_selection_changed_cb),
			  action);

	g_signal_connect (G_OBJECT (action->treeview),
			  "key_press_event",
			  G_CALLBACK (pdm_key_pressed_cb),
			  action);

	filter = get_filter_from_treeview(action->treeview);
	gtk_tree_model_filter_set_visible_func(filter, visibility_filter_func,
					       action, NULL);

	find_entry = galeon_dialog_get_control(GALEON_DIALOG(action->dialog),
					       (action->remove_id)+1);
	g_signal_connect(find_entry, "changed",
			 G_CALLBACK(action_find_entry_changed_cb),
			 action);

	clear_button = galeon_dialog_get_control(GALEON_DIALOG(action->dialog),
						 (action->remove_id)+2);
	g_signal_connect(clear_button, "clicked",
			 G_CALLBACK(action_clear_button_clicked_cb),
			 action);
}
Exemplo n.º 29
0
QMetaObject::Connection
gtk_combo_box_set_qmodel(GtkComboBox *box, QAbstractItemModel *qmodel, QItemSelectionModel *selection_model)
{
    QMetaObject::Connection connection;
    GtkTreeModel *model;

    model = (GtkTreeModel *)gtk_q_tree_model_new(
        qmodel,
        1,
        0, Qt::DisplayRole, G_TYPE_STRING);

    /* use a filter model to remove disabled items */
    GtkTreeModel *filter_model = gtk_tree_model_filter_new(model, NULL);
    gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(filter_model),
                                           (GtkTreeModelFilterVisibleFunc)filter_disabled_items,
                                           NULL, NULL);

    gtk_combo_box_set_model(box, GTK_TREE_MODEL(filter_model));
    GtkCellRenderer *renderer = gtk_cell_renderer_text_new();
    gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(box), renderer, FALSE);
    gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(box), renderer,
                                   "text", 0, NULL);

    if (!selection_model) return connection;

   /* sync the initial selection */
   gtk_combo_box_set_active_index(box, selection_model->currentIndex());

    /* connect signals to and from the selection model */
    connection = QObject::connect(
        selection_model,
        &QItemSelectionModel::currentChanged,
        [=](const QModelIndex current, G_GNUC_UNUSED const QModelIndex & previous) {
            gtk_combo_box_set_active_index(box, current);
        }
    );
    g_signal_connect(box,
                     "changed",
                     G_CALLBACK(update_selection),
                     selection_model);

    return connection;
}
void
create_user_privileges_table (void)
{
	GtkWidget *list;
	GtkTreeModel *model, *filter_model;
	GtkCellRenderer *renderer;
	GtkTreeViewColumn *column;
	GtkTreeIter iter;

	list = gst_dialog_get_widget (tool->main_dialog, "user_privileges");

	model = GTK_TREE_MODEL (gtk_list_store_new (3, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_OBJECT));
	filter_model = gtk_tree_model_filter_new (model, NULL);
	gtk_tree_view_set_model (GTK_TREE_VIEW (list), filter_model);
	g_object_unref (filter_model);
	g_object_unref (model);

	gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (model), COL_DESCRIPTION, GTK_SORT_ASCENDING);
	gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (filter_model),
						privileges_table_visible_func,
						NULL, NULL);

	column = gtk_tree_view_column_new ();

	renderer = gtk_cell_renderer_toggle_new ();
	gtk_tree_view_column_pack_start (column, renderer, FALSE);
	gtk_tree_view_column_set_attributes (column,
					     renderer,
					     "active", COL_MEMBER,
					     NULL);
	g_signal_connect (G_OBJECT (renderer), "toggled",
			  G_CALLBACK (on_user_privilege_toggled), filter_model);

	renderer = gtk_cell_renderer_text_new ();
	gtk_tree_view_column_pack_end (column, renderer, TRUE);
	gtk_tree_view_column_set_attributes (column,
					     renderer,
					     "text", COL_DESCRIPTION,
					     NULL);

	gtk_tree_view_column_set_sort_column_id (column, 1);
	gtk_tree_view_insert_column (GTK_TREE_VIEW (list), column, 0);
}