GtkWidget* EClassTree::createEClassTreeView() {
_eclassView = GTK_TREE_VIEW(
gtk_tree_view_new_with_model(GTK_TREE_MODEL(_eclassStore))
);
// Use the TreeModel's full string search function
gtk_tree_view_set_search_equal_func(_eclassView, gtkutil::TreeModel::equalFuncStringContains, NULL, NULL);
// Tree selection
_eclassSelection = gtk_tree_view_get_selection(GTK_TREE_VIEW(_eclassView));
gtk_tree_selection_set_mode(_eclassSelection, GTK_SELECTION_BROWSE);
g_signal_connect(G_OBJECT(_eclassSelection), "changed", G_CALLBACK(onSelectionChanged), this);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(_eclassView), TRUE);
// Pack the columns
// Single column with icon and name
GtkTreeViewColumn* col =
gtkutil::IconTextColumn(_("Classname"), NAME_COLUMN, ICON_COLUMN);
gtk_tree_view_column_set_sort_column_id(col, NAME_COLUMN);
gtk_tree_view_append_column(GTK_TREE_VIEW(_eclassView), col);
return gtkutil::ScrolledFrame(GTK_WIDGET(_eclassView));
}
GtkWidget * ui_playlist_widget_new (gint playlist)
{
PlaylistWidgetData * data = g_malloc0 (sizeof (PlaylistWidgetData));
data->list = playlist;
data->queue = NULL;
data->popup_source = 0;
data->popup_pos = -1;
data->popup_shown = FALSE;
GtkWidget * list = audgui_list_new (& callbacks, data,
aud_playlist_entry_count (playlist));
gtk_tree_view_set_headers_visible ((GtkTreeView *) list,
aud_get_bool ("gtkui", "playlist_headers"));
gtk_tree_view_set_search_equal_func ((GtkTreeView *) list, search_cb, data,
NULL);
g_signal_connect_swapped (list, "destroy", (GCallback) destroy_cb, data);
/* Disable type-to-search because it blocks CTRL-V, causing URI's to be
* pasted into the search box rather than added to the playlist. The search
* box can still be brought up with CTRL-F. */
gtk_tree_view_set_enable_search ((GtkTreeView *) list, FALSE);
for (gint i = 0; i < pw_num_cols; i ++)
{
gint n = pw_cols[i];
audgui_list_add_column (list, pw_col_label[n] ? _(pw_col_names[n]) :
NULL, i, pw_col_types[n], pw_col_widths[n]);
}
return list;
}
/**
* Create a new GtkTreeView for search results.
*/
GtkWidget *
search_gui_create_tree(void)
{
GtkTreeModel *model = create_results_model();
GtkTreeSelection *selection;
GtkTreeView *tv;
tv = GTK_TREE_VIEW(gtk_tree_view_new_with_model(model));
g_object_unref(model);
selection = gtk_tree_view_get_selection(tv);
gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
gtk_tree_view_set_headers_clickable(tv, TRUE);
gtk_tree_view_set_headers_visible(tv, TRUE);
gtk_tree_view_set_enable_search(tv, TRUE);
gtk_tree_view_set_search_column(tv, 0);
gtk_tree_view_set_rules_hint(tv, TRUE);
gtk_tree_view_set_search_equal_func(tv, search_by_regex, NULL, NULL);
tree_view_set_fixed_height_mode(tv, TRUE);
/* add columns to the tree view */
add_results_columns(tv);
tree_view_restore_visibility(tv, PROP_SEARCH_RESULTS_COL_VISIBLE);
tree_view_restore_widths(tv, PROP_SEARCH_RESULTS_COL_WIDTHS);
gui_signal_connect(tv,
"cursor-changed", on_tree_view_search_results_select_row, tv);
gui_signal_connect(tv, "leave-notify-event", on_leave_notify, NULL);
return GTK_WIDGET(tv);
}
static void
build_search_entry(GitgWindow *window, GtkBuilder *builder)
{
GtkWidget *box = GTK_WIDGET(gtk_builder_get_object(builder, "hbox_top"));
GtkWidget *entry = sexy_icon_entry_new();
GtkImage *image = GTK_IMAGE(gtk_image_new_from_stock(GTK_STOCK_FIND, GTK_ICON_SIZE_MENU));
sexy_icon_entry_set_icon(SEXY_ICON_ENTRY(entry), SEXY_ICON_ENTRY_PRIMARY, image);
gtk_tree_view_set_search_entry(window->priv->tree_view, GTK_ENTRY(entry));
gtk_widget_show(entry);
gtk_box_pack_end(GTK_BOX(box), entry, FALSE, FALSE, 0);
GtkBuilder *b = gitg_utils_new_builder( "gitg-menus.xml");
GtkUIManager *manager = GTK_UI_MANAGER(gtk_builder_get_object(b, "uiman"));
window->priv->search_popup = GTK_WIDGET(g_object_ref(gtk_ui_manager_get_widget(manager, "/ui/search_popup")));
gtk_builder_connect_signals(b, window);
g_object_unref(b);
g_signal_connect(entry, "icon-pressed", G_CALLBACK(on_search_icon_pressed), window);
gtk_tree_view_set_search_column(window->priv->tree_view, 1);
gtk_tree_view_set_search_equal_func(window->priv->tree_view, search_equal_func, window, NULL);
GtkAccelGroup *group = gtk_accel_group_new();
GClosure *closure = g_cclosure_new(G_CALLBACK(focus_search), entry, NULL);
gtk_accel_group_connect(group, GDK_f, GDK_CONTROL_MASK, 0, closure);
gtk_window_add_accel_group(GTK_WINDOW(window), group);
}
static GtkWidget * create_playlist_manager (void)
{
GtkWidget * playman_win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_type_hint ((GtkWindow *) playman_win, GDK_WINDOW_TYPE_HINT_DIALOG);
gtk_window_set_title ((GtkWindow *) playman_win, _("Playlist Manager"));
gtk_container_set_border_width ((GtkContainer *) playman_win, 6);
gtk_widget_set_size_request (playman_win, 400, 250);
g_signal_connect (playman_win, "destroy", (GCallback) destroy_cb, NULL);
audgui_destroy_on_escape (playman_win);
GtkWidget * playman_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_container_add ((GtkContainer *) playman_win, playman_vbox);
/* ListView */
GtkWidget * playman_pl_lv = audgui_list_new (& callbacks, NULL, aud_playlist_count ());
audgui_list_add_column (playman_pl_lv, _("Title"), 0, G_TYPE_STRING, -1);
audgui_list_add_column (playman_pl_lv, _("Entries"), 1, G_TYPE_INT, 7);
audgui_list_set_highlight (playman_pl_lv, aud_playlist_get_playing ());
gtk_tree_view_set_search_equal_func ((GtkTreeView *) playman_pl_lv,
search_cb, NULL, NULL);
hook_associate ("playlist update", update_hook, playman_pl_lv);
hook_associate ("playlist activate", activate_hook, playman_pl_lv);
hook_associate ("playlist set playing", position_hook, playman_pl_lv);
GtkWidget * playman_pl_lv_sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type ((GtkScrolledWindow *) playman_pl_lv_sw,
GTK_SHADOW_IN);
gtk_scrolled_window_set_policy ((GtkScrolledWindow *) playman_pl_lv_sw,
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add ((GtkContainer *) playman_pl_lv_sw, playman_pl_lv);
gtk_box_pack_start ((GtkBox *) playman_vbox, playman_pl_lv_sw, TRUE, TRUE, 0);
/* ButtonBox */
GtkWidget * playman_button_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
GtkWidget * new_button = audgui_button_new (_("_New"), "document-new", new_cb, NULL);
GtkWidget * delete_button = audgui_button_new (_("_Remove"), "edit-delete", delete_cb, NULL);
GtkWidget * rename_button = audgui_button_new (_("Ren_ame"), "insert-text", rename_cb, NULL);
GtkWidget * play_button = audgui_button_new (_("_Play"), "media-playback-start", play_cb, NULL);
gtk_container_add ((GtkContainer *) playman_button_hbox, new_button);
gtk_container_add ((GtkContainer *) playman_button_hbox, delete_button);
gtk_box_pack_end ((GtkBox *) playman_button_hbox, play_button, FALSE, FALSE, 0);
gtk_box_pack_end ((GtkBox *) playman_button_hbox, rename_button, FALSE, FALSE, 0);
gtk_container_add ((GtkContainer *) playman_vbox, playman_button_hbox);
/* CheckButton */
GtkWidget * hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start ((GtkBox *) playman_vbox, hbox, FALSE, FALSE, 0);
GtkWidget * check_button = gtk_check_button_new_with_mnemonic
(_("_Close dialog on activating playlist"));
gtk_box_pack_start ((GtkBox *) hbox, check_button, FALSE, FALSE, 0);
gtk_toggle_button_set_active ((GtkToggleButton *) check_button, aud_get_bool
("audgui", "playlist_manager_close_on_activate"));
g_signal_connect (check_button, "toggled", (GCallback) close_on_activate_cb, NULL);
return playman_win;
}
static VALUE
rg_set_search_equal_func(VALUE self)
{
VALUE func = rb_block_proc();
G_RELATIVE(self, func);
gtk_tree_view_set_search_equal_func(_SELF(self),
(GtkTreeViewSearchEqualFunc)search_equal_func,
(gpointer)func, NULL);
return self;
}
SidebarIndexPage::SidebarIndexPage(Control* control) : AbstractSidebarPage(
control)
{
XOJ_INIT_TYPE(SidebarIndexPage);
this->searchTimeout = 0;
this->hasContents = false;
this->treeViewBookmarks = gtk_tree_view_new();
g_object_ref(this->treeViewBookmarks);
gtk_tree_view_set_enable_search(GTK_TREE_VIEW(treeViewBookmarks), true);
gtk_tree_view_set_search_column(GTK_TREE_VIEW(treeViewBookmarks),
DOCUMENT_LINKS_COLUMN_NAME);
gtk_tree_view_set_search_equal_func(GTK_TREE_VIEW(treeViewBookmarks),
(GtkTreeViewSearchEqualFunc) treeSearchFunction, this, NULL);
this->scrollBookmarks = gtk_scrolled_window_new(NULL, NULL);
g_object_ref(this->scrollBookmarks);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollBookmarks),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrollBookmarks),
GTK_SHADOW_IN);
GtkTreeSelection* selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(
treeViewBookmarks));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeViewBookmarks), FALSE);
gtk_container_add(GTK_CONTAINER(scrollBookmarks), treeViewBookmarks);
GtkTreeViewColumn* column = gtk_tree_view_column_new();
gtk_tree_view_column_set_expand(GTK_TREE_VIEW_COLUMN(column), TRUE);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeViewBookmarks), column);
GtkCellRenderer* renderer = (GtkCellRenderer*) g_object_new(
GTK_TYPE_CELL_RENDERER_TEXT, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column), renderer, TRUE);
gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column), renderer,
"markup", DOCUMENT_LINKS_COLUMN_NAME, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_end(GTK_TREE_VIEW_COLUMN(column), renderer, FALSE);
gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column), renderer,
"text", DOCUMENT_LINKS_COLUMN_PAGE_NUMBER, NULL);
g_object_set(G_OBJECT(renderer), "style", PANGO_STYLE_ITALIC, NULL);
g_signal_connect(treeViewBookmarks, "cursor-changed",
G_CALLBACK(treeBookmarkSelected), this);
gtk_widget_show(this->treeViewBookmarks);
registerListener(control);
}
static void
gtk_app_chooser_widget_init (GtkAppChooserWidget *self)
{
GtkTreeSelection *selection;
GtkTreeModel *sort;
GtkGesture *gesture;
self->priv = gtk_app_chooser_widget_get_instance_private (self);
gtk_widget_set_has_surface (GTK_WIDGET (self), FALSE);
gtk_widget_init_template (GTK_WIDGET (self));
/* Various parts of the GtkTreeView code need custom code to setup, mostly
* because we lack signals to connect to, or properties to set.
*/
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (self->priv->program_list));
gtk_tree_selection_set_select_function (selection, gtk_app_chooser_selection_func,
self, NULL);
sort = gtk_tree_view_get_model (GTK_TREE_VIEW (self->priv->program_list));
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort),
COLUMN_NAME,
GTK_SORT_ASCENDING);
gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (sort),
COLUMN_NAME,
gtk_app_chooser_sort_func,
self, NULL);
gtk_tree_view_set_search_column (GTK_TREE_VIEW (self->priv->program_list), COLUMN_NAME);
gtk_tree_view_set_search_equal_func (GTK_TREE_VIEW (self->priv->program_list),
gtk_app_chooser_search_equal_func,
NULL, NULL);
gtk_tree_view_column_set_cell_data_func (self->priv->column,
self->priv->secondary_padding,
padding_cell_renderer_func,
NULL, NULL);
self->priv->monitor = g_app_info_monitor_get ();
g_signal_connect (self->priv->monitor, "changed",
G_CALLBACK (app_info_changed), self);
gesture = gtk_gesture_multi_press_new ();
gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (gesture), GDK_BUTTON_SECONDARY);
g_signal_connect (gesture, "pressed",
G_CALLBACK (gtk_app_chooser_row_pressed_cb), self);
gtk_widget_add_controller (self->priv->program_list, GTK_EVENT_CONTROLLER (gesture));
}
void
treeview2_set_up_constants(GtkTreeView *treeview, gint type)
{
#ifdef DEBUG
printf("treeview2_set_up_constants\n");
#endif
GtkTreeViewColumn *col;
GtkCellRenderer *renderer;
gchar *titles[2] =
{_("Name"),
_("Value")};
gint i;
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(treeview),
GTK_SELECTION_SINGLE);
gtk_tree_view_set_headers_visible(treeview, TRUE);
gtk_tree_view_set_rules_hint(treeview, TRUE);
gtk_tree_view_set_search_column(treeview, 0);
gtk_tree_view_set_search_equal_func(treeview,
treeview_helper_search_equal_strings,
NULL, NULL);
for(i = 0; i < 2; i++)
{
col = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(col, titles[i]);
gtk_tree_view_append_column(treeview, col);
renderer = treeview_helper_cell_renderer_text_new();
gtk_tree_view_column_pack_start(col, renderer, TRUE);
gtk_tree_view_column_add_attribute(col, renderer,
"text", i);
if(i == 1)
{
g_object_set(renderer, "editable", TRUE, NULL);
g_signal_connect (renderer,
"edited",
(type == CONSTANTS_TYPE_APP) ?
G_CALLBACK (treeview_helper_constants_app_editing_done) :
G_CALLBACK (treeview_helper_constants_editing_done),
treeview);
}
}
}
// Create the Tree View
GtkWidget* ShaderSelector::createTreeView() {
// Tree model
GtkTreeStore* store = gtk_tree_store_new(N_COLUMNS,
G_TYPE_STRING, // display name in tree
G_TYPE_STRING, // full shader name
GDK_TYPE_PIXBUF);
// Instantiate the helper class that populates the tree according to the paths
gtkutil::VFSTreePopulator populator(store);
ShaderNameVisitor func(populator, _prefixes);
GlobalShaderSystem().foreachShaderName(func);
// Now visit the created GtkTreeIters to load the actual data into the tree
DataInserter inserter;
populator.forEachNode(inserter);
// Tree view
_treeView = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(_treeView), FALSE);
g_object_unref(store); // tree view owns the reference now
// Single visible column, containing the directory/shader name and the icon
gtk_tree_view_append_column(GTK_TREE_VIEW(_treeView),
gtkutil::IconTextColumn(_("Value"),
NAME_COL,
IMAGE_COL));
// Set the tree store to sort on this column
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(store), NAME_COL, GTK_SORT_ASCENDING);
// Use the TreeModel's full string search function
gtk_tree_view_set_search_equal_func(GTK_TREE_VIEW(_treeView), gtkutil::TreeModel::equalFuncStringContains, NULL, NULL);
// Get selection and connect the changed callback
_selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(_treeView));
g_signal_connect(G_OBJECT(_selection),
"changed",
G_CALLBACK(_onSelChange),
this);
// Pack into scrolled window and frame
return gtkutil::ScrolledFrame(_treeView);
}
bool wxListBox::Create( wxWindow *parent, wxWindowID id,
const wxPoint &pos, const wxSize &size,
int n, const wxString choices[],
long style, const wxValidator& validator,
const wxString &name )
{
if (!PreCreation( parent, pos, size ) ||
!CreateBase( parent, id, pos, size, style, validator, name ))
{
wxFAIL_MSG( wxT("wxListBox creation failed") );
return false;
}
m_widget = gtk_scrolled_window_new( NULL, NULL );
g_object_ref(m_widget);
GtkPolicyType vPolicy = GTK_POLICY_AUTOMATIC;
if (style & wxLB_ALWAYS_SB)
vPolicy = GTK_POLICY_ALWAYS;
else if (style & wxLB_NO_SB)
vPolicy = GTK_POLICY_NEVER;
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(m_widget),
GTK_POLICY_AUTOMATIC, vPolicy);
GTKScrolledWindowSetBorder(m_widget, style);
m_treeview = GTK_TREE_VIEW( gtk_tree_view_new( ) );
//wxListBox doesn't have a header :)
//NB: If enabled SetFirstItem doesn't work correctly
gtk_tree_view_set_headers_visible(m_treeview, FALSE);
#if wxUSE_CHECKLISTBOX
if(m_hasCheckBoxes)
((wxCheckListBox*)this)->DoCreateCheckList();
#endif // wxUSE_CHECKLISTBOX
// Create the data column
gtk_tree_view_insert_column_with_attributes(m_treeview, -1, "",
gtk_cell_renderer_text_new(),
"text",
WXLISTBOX_DATACOLUMN, NULL);
// Now create+set the model (GtkListStore) - first argument # of columns
#if wxUSE_CHECKLISTBOX
if(m_hasCheckBoxes)
m_liststore = gtk_list_store_new(2, G_TYPE_BOOLEAN,
WX_TYPE_TREE_ENTRY);
else
#endif
m_liststore = gtk_list_store_new(1, WX_TYPE_TREE_ENTRY);
gtk_tree_view_set_model(m_treeview, GTK_TREE_MODEL(m_liststore));
g_object_unref (m_liststore); //free on treeview destruction
// Disable the pop-up textctrl that enables searching - note that
// the docs specify that even if this disabled (which we are doing)
// the user can still have it through the start-interactive-search
// key binding...either way we want to provide a searchequal callback
// NB: If this is enabled a doubleclick event (activate) gets sent
// on a successful search
gtk_tree_view_set_search_column(m_treeview, WXLISTBOX_DATACOLUMN);
gtk_tree_view_set_search_equal_func(m_treeview, search_callback, this, NULL);
gtk_tree_view_set_enable_search(m_treeview, FALSE);
GtkSelectionMode mode;
// GTK_SELECTION_EXTENDED is a deprecated synonym for GTK_SELECTION_MULTIPLE
if ( style & (wxLB_MULTIPLE | wxLB_EXTENDED) )
{
mode = GTK_SELECTION_MULTIPLE;
}
else // no multi-selection flags specified
{
m_windowStyle |= wxLB_SINGLE;
// Notice that we must use BROWSE and not GTK_SELECTION_SINGLE because
// the latter allows to not select any items at all while a single
// selection listbox is supposed to always have a selection (at least
// once the user selected something, it might not have any initially).
mode = GTK_SELECTION_BROWSE;
}
GtkTreeSelection* selection = gtk_tree_view_get_selection( m_treeview );
gtk_tree_selection_set_mode( selection, mode );
// Handle sortable stuff
if(HasFlag(wxLB_SORT))
{
// Setup sorting in ascending (wx) order
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(m_liststore),
WXLISTBOX_DATACOLUMN,
GTK_SORT_ASCENDING);
// Set the sort callback
gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(m_liststore),
WXLISTBOX_DATACOLUMN,
sort_callback,
this, //userdata
NULL //"destroy notifier"
);
}
gtk_container_add (GTK_CONTAINER (m_widget), GTK_WIDGET(m_treeview) );
gtk_widget_show( GTK_WIDGET(m_treeview) );
m_focusWidget = GTK_WIDGET(m_treeview);
Append(n, choices); // insert initial items
// generate dclick events
g_signal_connect_after(m_treeview, "row-activated",
G_CALLBACK(gtk_listbox_row_activated_callback), this);
// for intercepting dclick generation by <ENTER>
g_signal_connect (m_treeview, "key_press_event",
G_CALLBACK (gtk_listbox_key_press_callback),
this);
m_parent->DoAddChild( this );
PostCreation(size);
SetInitialSize(size); // need this too because this is a wxControlWithItems
g_signal_connect_after (selection, "changed",
G_CALLBACK (gtk_listitem_changed_callback), this);
return true;
}
static void
plugin_manager_construct_tree (EomPluginManager *pm)
{
GtkTreeViewColumn *column;
GtkCellRenderer *cell;
GtkListStore *model;
eom_debug (DEBUG_PLUGINS);
model = gtk_list_store_new (N_COLUMNS,
G_TYPE_BOOLEAN,
G_TYPE_BOOLEAN,
G_TYPE_POINTER);
gtk_tree_view_set_model (GTK_TREE_VIEW (pm->priv->tree),
GTK_TREE_MODEL (model));
g_object_unref (model);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (pm->priv->tree), TRUE);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (pm->priv->tree), FALSE);
/* First column */
cell = gtk_cell_renderer_toggle_new ();
g_object_set (cell, "xpad", 6, NULL);
g_signal_connect (cell,
"toggled",
G_CALLBACK (active_toggled_cb),
pm);
column = gtk_tree_view_column_new_with_attributes (PLUGIN_MANAGER_ACTIVE_TITLE,
cell,
"active", ACTIVE_COLUMN,
"activatable", AVAILABLE_COLUMN,
"sensitive", AVAILABLE_COLUMN,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (pm->priv->tree), column);
/* Second column */
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, PLUGIN_MANAGER_NAME_TITLE);
gtk_tree_view_column_set_resizable (column, TRUE);
cell = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (column, cell, FALSE);
g_object_set (cell, "stock-size", GTK_ICON_SIZE_SMALL_TOOLBAR, NULL);
gtk_tree_view_column_set_cell_data_func (column, cell,
plugin_manager_view_icon_cell_cb,
pm, NULL);
cell = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, cell, TRUE);
g_object_set (cell, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_tree_view_column_set_cell_data_func (column, cell,
plugin_manager_view_info_cell_cb,
pm, NULL);
gtk_tree_view_column_set_spacing (column, 6);
gtk_tree_view_append_column (GTK_TREE_VIEW (pm->priv->tree), column);
/* Sort on the plugin names */
gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (model),
model_name_sort_func,
NULL,
NULL);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (model),
GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID,
GTK_SORT_ASCENDING);
/* Enable search for our non-string column */
gtk_tree_view_set_search_column (GTK_TREE_VIEW (pm->priv->tree),
INFO_COLUMN);
gtk_tree_view_set_search_equal_func (GTK_TREE_VIEW (pm->priv->tree),
name_search_cb,
NULL,
NULL);
g_signal_connect (pm->priv->tree,
"cursor_changed",
G_CALLBACK (cursor_changed_cb),
pm);
g_signal_connect (pm->priv->tree,
"row_activated",
G_CALLBACK (row_activated_cb),
pm);
g_signal_connect (pm->priv->tree,
"button-press-event",
G_CALLBACK (button_press_event_cb),
pm);
g_signal_connect (pm->priv->tree,
"popup-menu",
G_CALLBACK (popup_menu_cb),
pm);
gtk_widget_show (pm->priv->tree);
}
static void
setup_main_window (UmUserPanelPrivate *d)
{
GtkWidget *userlist;
GtkTreeModel *model;
GtkListStore *store;
GtkTreeViewColumn *column;
GtkCellRenderer *cell;
GtkTreeSelection *selection;
GtkWidget *button;
GtkTreeIter iter;
gint expander_size;
gchar *title;
GIcon *icon;
gchar *names[3];
userlist = get_widget (d, "list-treeview");
store = gtk_list_store_new (NUM_USER_LIST_COLS,
UM_TYPE_USER,
GDK_TYPE_PIXBUF,
G_TYPE_STRING,
G_TYPE_BOOLEAN,
G_TYPE_STRING,
G_TYPE_BOOLEAN,
G_TYPE_INT,
G_TYPE_BOOLEAN);
model = (GtkTreeModel *)store;
gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (model), sort_users, NULL, NULL);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (model), GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, GTK_SORT_ASCENDING);
gtk_tree_view_set_model (GTK_TREE_VIEW (userlist), model);
gtk_tree_view_set_search_column (GTK_TREE_VIEW (userlist), USER_COL);
gtk_tree_view_set_search_equal_func (GTK_TREE_VIEW (userlist),
match_user, NULL, NULL);
g_object_unref (model);
g_signal_connect (d->um, "users-loaded", G_CALLBACK (users_loaded), d);
gtk_widget_style_get (userlist, "expander-size", &expander_size, NULL);
gtk_tree_view_set_level_indentation (GTK_TREE_VIEW (userlist), - (expander_size + 6));
title = g_strdup_printf ("<small><span foreground=\"#555555\">%s</span></small>", _("My Account"));
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter,
TITLE_COL, title,
HEADING_ROW_COL, TRUE,
SORT_KEY_COL, 0,
AUTOLOGIN_COL, FALSE,
-1);
g_free (title);
title = g_strdup_printf ("<small><span foreground=\"#555555\">%s</span></small>", _("Other Accounts"));
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter,
TITLE_COL, title,
HEADING_ROW_COL, TRUE,
SORT_KEY_COL, 2,
AUTOLOGIN_COL, FALSE,
-1);
g_free (title);
column = gtk_tree_view_column_new ();
cell = gtk_cell_renderer_pixbuf_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (column), cell, FALSE);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (column), cell, "pixbuf", FACE_COL);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (column), cell, "visible", USER_ROW_COL);
cell = gtk_cell_renderer_text_new ();
g_object_set (cell, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (column), cell, TRUE);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (column), cell, "markup", NAME_COL);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (column), cell, "visible", USER_ROW_COL);
cell = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (column), cell, TRUE);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (column), cell, "markup", TITLE_COL);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (column), cell, "visible", HEADING_ROW_COL);
cell = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (column, cell, FALSE);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (column), cell, "visible", USER_ROW_COL);
gtk_tree_view_column_set_cell_data_func (column,
cell,
(GtkTreeCellDataFunc) autologin_cell_data_func,
d,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (userlist), column);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (userlist));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE);
g_signal_connect (selection, "changed", G_CALLBACK (selected_user_changed), d);
gtk_tree_selection_set_select_function (selection, dont_select_headings, NULL, NULL);
gtk_scrolled_window_set_min_content_width (GTK_SCROLLED_WINDOW (get_widget (d, "list-scrolledwindow")), 300);
gtk_widget_set_size_request (get_widget (d, "list-scrolledwindow"), 200, -1);
button = get_widget (d, "add-user-toolbutton");
g_signal_connect (button, "clicked", G_CALLBACK (add_user), d);
button = get_widget (d, "remove-user-toolbutton");
g_signal_connect (button, "clicked", G_CALLBACK (delete_user), d);
button = get_widget (d, "user-icon-nonbutton");
add_unlock_tooltip (button);
button = get_widget (d, "full-name-entry");
g_signal_connect (button, "editing-done", G_CALLBACK (change_name_done), d);
button = get_widget (d, "account-type-combo");
g_signal_connect (button, "editing-done", G_CALLBACK (account_type_changed), d);
button = get_widget (d, "account-password-button");
g_signal_connect (button, "start-editing", G_CALLBACK (change_password), d);
button = get_widget (d, "account-language-combo");
g_signal_connect (button, "editing-done", G_CALLBACK (language_changed), d);
button = get_widget (d, "autologin-switch");
g_signal_connect (button, "notify::active", G_CALLBACK (autologin_changed), d);
button = get_widget (d, "account-fingerprint-button");
g_signal_connect (button, "clicked",
G_CALLBACK (change_fingerprint), d);
d->permission = (GPermission *)polkit_permission_new_sync ("org.freedesktop.accounts.user-administration", NULL, NULL, NULL);
g_signal_connect (d->permission, "notify",
G_CALLBACK (on_permission_changed), d);
on_permission_changed (d->permission, NULL, d);
button = get_widget (d, "add-user-toolbutton");
names[0] = "changes-allow-symbolic";
names[1] = "changes-allow";
names[2] = NULL;
icon = (GIcon *)g_themed_icon_new_from_names (names, -1);
setup_tooltip_with_embedded_icon (button,
_("To create a user account,\nclick the * icon first"),
"*",
icon);
button = get_widget (d, "remove-user-toolbutton");
setup_tooltip_with_embedded_icon (button,
_("To delete the selected user account,\nclick the * icon first"),
"*",
icon);
g_object_unref (icon);
}
EXPORT void audgui_playlist_manager (void)
{
GtkWidget * playman_vbox;
GtkWidget * playman_pl_lv, * playman_pl_lv_sw;
GtkWidget * playman_button_hbox;
GtkWidget * new_button, * delete_button, * rename_button, * play_button;
GtkWidget * hbox, * check_button;
GdkGeometry playman_win_hints;
if (playman_win)
{
gtk_window_present ((GtkWindow *) playman_win);
return;
}
playman_win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_type_hint ((GtkWindow *) playman_win, GDK_WINDOW_TYPE_HINT_DIALOG);
gtk_window_set_title ((GtkWindow *) playman_win, _("Playlist Manager"));
gtk_container_set_border_width ((GtkContainer *) playman_win, 6);
playman_win_hints.min_width = 400;
playman_win_hints.min_height = 250;
gtk_window_set_geometry_hints ((GtkWindow *) playman_win, playman_win,
&playman_win_hints , GDK_HINT_MIN_SIZE);
int x = aud_get_int ("audgui", "playlist_manager_x");
int y = aud_get_int ("audgui", "playlist_manager_y");
int w = aud_get_int ("audgui", "playlist_manager_w");
int h = aud_get_int ("audgui", "playlist_manager_h");
if (w && h)
{
gtk_window_move ((GtkWindow *) playman_win, x, y);
gtk_window_set_default_size ((GtkWindow *) playman_win, w, h);
}
g_signal_connect (playman_win, "delete-event", (GCallback) hide_cb, NULL);
audgui_hide_on_escape (playman_win);
playman_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_container_add ((GtkContainer *) playman_win, playman_vbox);
/* ListView */
playman_pl_lv = audgui_list_new (& callbacks, NULL, aud_playlist_count ());
audgui_list_add_column (playman_pl_lv, _("Title"), 0, G_TYPE_STRING, -1);
audgui_list_add_column (playman_pl_lv, _("Entries"), 1, G_TYPE_INT, 7);
audgui_list_set_highlight (playman_pl_lv, aud_playlist_get_playing ());
gtk_tree_view_set_search_equal_func ((GtkTreeView *) playman_pl_lv,
search_cb, NULL, NULL);
hook_associate ("playlist update", update_hook, playman_pl_lv);
hook_associate ("playlist activate", activate_hook, playman_pl_lv);
hook_associate ("playlist set playing", position_hook, playman_pl_lv);
playman_pl_lv_sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type ((GtkScrolledWindow *) playman_pl_lv_sw,
GTK_SHADOW_IN);
gtk_scrolled_window_set_policy ((GtkScrolledWindow *) playman_pl_lv_sw,
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add ((GtkContainer *) playman_pl_lv_sw, playman_pl_lv);
gtk_box_pack_start ((GtkBox *) playman_vbox, playman_pl_lv_sw, TRUE, TRUE, 0);
/* ButtonBox */
playman_button_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
new_button = gtk_button_new_from_stock (GTK_STOCK_NEW);
delete_button = gtk_button_new_from_stock (GTK_STOCK_DELETE);
rename_button = gtk_button_new_with_mnemonic (_("_Rename"));
gtk_button_set_image ((GtkButton *) rename_button, gtk_image_new_from_stock
(GTK_STOCK_EDIT, GTK_ICON_SIZE_BUTTON));
play_button = gtk_button_new_from_stock (GTK_STOCK_MEDIA_PLAY);
gtk_container_add ((GtkContainer *) playman_button_hbox, new_button);
gtk_container_add ((GtkContainer *) playman_button_hbox, delete_button);
gtk_box_pack_end ((GtkBox *) playman_button_hbox, play_button, FALSE, FALSE, 0);
gtk_box_pack_end ((GtkBox *) playman_button_hbox, rename_button, FALSE, FALSE, 0);
gtk_container_add ((GtkContainer *) playman_vbox, playman_button_hbox);
g_signal_connect (new_button, "clicked", (GCallback) new_cb, NULL);
g_signal_connect (delete_button, "clicked", (GCallback) delete_cb, NULL);
g_signal_connect (rename_button, "clicked", (GCallback) rename_cb, NULL);
g_signal_connect (play_button, "clicked", (GCallback) play_cb, NULL);
/* CheckButton */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start ((GtkBox *) playman_vbox, hbox, FALSE, FALSE, 0);
check_button = gtk_check_button_new_with_mnemonic
(_("_Close dialog on activating playlist"));
gtk_box_pack_start ((GtkBox *) hbox, check_button, FALSE, FALSE, 0);
gtk_toggle_button_set_active ((GtkToggleButton *) check_button, aud_get_bool
("audgui", "playlist_manager_close_on_activate"));
g_signal_connect (check_button, "toggled", (GCallback) close_on_activate_cb, NULL);
gtk_widget_show_all (playman_win);
hook_associate ("config save", save_config_cb, playman_win);
}
static void
contact_list_view_setup (EmpathyContactListView *view)
{
EmpathyContactListViewPriv *priv;
GtkCellRenderer *cell;
GtkTreeViewColumn *col;
gint i;
priv = GET_PRIV (view);
gtk_tree_view_set_search_equal_func (GTK_TREE_VIEW (view),
empathy_contact_list_store_search_equal_func,
NULL, NULL);
g_signal_connect (priv->store, "row-has-child-toggled",
G_CALLBACK (contact_list_view_row_has_child_toggled_cb),
view);
gtk_tree_view_set_model (GTK_TREE_VIEW (view),
GTK_TREE_MODEL (priv->store));
/* Setup view */
g_object_set (view,
"headers-visible", FALSE,
"reorderable", TRUE,
"show-expanders", FALSE,
NULL);
col = gtk_tree_view_column_new ();
/* State */
cell = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (col, cell, FALSE);
gtk_tree_view_column_set_cell_data_func (
col, cell,
(GtkTreeCellDataFunc) contact_list_view_pixbuf_cell_data_func,
view, NULL);
g_object_set (cell,
"xpad", 5,
"ypad", 1,
"visible", FALSE,
NULL);
/* Name */
cell = empathy_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (col, cell, TRUE);
gtk_tree_view_column_set_cell_data_func (
col, cell,
(GtkTreeCellDataFunc) contact_list_view_text_cell_data_func,
view, NULL);
gtk_tree_view_column_add_attribute (col, cell,
"name", EMPATHY_CONTACT_LIST_STORE_COL_NAME);
gtk_tree_view_column_add_attribute (col, cell,
"status", EMPATHY_CONTACT_LIST_STORE_COL_STATUS);
gtk_tree_view_column_add_attribute (col, cell,
"is_group", EMPATHY_CONTACT_LIST_STORE_COL_IS_GROUP);
/* Voip Capability Icon */
cell = empathy_cell_renderer_activatable_new ();
gtk_tree_view_column_pack_start (col, cell, FALSE);
gtk_tree_view_column_set_cell_data_func (
col, cell,
(GtkTreeCellDataFunc) contact_list_view_voip_cell_data_func,
view, NULL);
g_object_set (cell,
"visible", FALSE,
NULL);
g_signal_connect (cell, "path-activated",
G_CALLBACK (contact_list_view_voip_activated_cb),
view);
/* Avatar */
cell = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (col, cell, FALSE);
gtk_tree_view_column_set_cell_data_func (
col, cell,
(GtkTreeCellDataFunc) contact_list_view_avatar_cell_data_func,
view, NULL);
g_object_set (cell,
"xpad", 0,
"ypad", 0,
"visible", FALSE,
"width", 32,
"height", 32,
NULL);
/* Expander */
cell = empathy_cell_renderer_expander_new ();
gtk_tree_view_column_pack_end (col, cell, FALSE);
gtk_tree_view_column_set_cell_data_func (
col, cell,
(GtkTreeCellDataFunc) contact_list_view_expander_cell_data_func,
view, NULL);
/* Actually add the column now we have added all cell renderers */
gtk_tree_view_append_column (GTK_TREE_VIEW (view), col);
/* Drag & Drop. */
for (i = 0; i < G_N_ELEMENTS (drag_types_dest); ++i) {
drag_atoms_dest[i] = gdk_atom_intern (drag_types_dest[i].target,
FALSE);
}
for (i = 0; i < G_N_ELEMENTS (drag_types_source); ++i) {
drag_atoms_source[i] = gdk_atom_intern (drag_types_source[i].target,
FALSE);
}
}
static void foldersel_create(void)
{
GtkWidget *vbox;
GtkWidget *scrolledwin;
GtkWidget *confirm_area;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GtkTreeSelection *selection;
static GdkGeometry geometry;
window = gtkut_window_new(GTK_WINDOW_TOPLEVEL, "foldersel");
gtk_window_set_title(GTK_WINDOW(window), _("Select folder"));
gtk_container_set_border_width(GTK_CONTAINER(window), 4);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_window_set_resizable(GTK_WINDOW(window), TRUE);
gtk_widget_realize(window);
g_signal_connect(G_OBJECT(window), "delete_event",
G_CALLBACK(delete_event), NULL);
g_signal_connect(G_OBJECT(window), "key_press_event",
G_CALLBACK(key_pressed), NULL);
g_signal_connect(G_OBJECT(window), "size_allocate",
G_CALLBACK(foldersel_size_allocate_cb), NULL);
MANAGE_WINDOW_SIGNALS_CONNECT(window);
vbox = gtk_vbox_new(FALSE, 4);
gtk_container_add(GTK_CONTAINER(window), vbox);
scrolledwin = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin),
GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwin),
GTK_SHADOW_IN);
gtk_box_pack_start(GTK_BOX(vbox), scrolledwin, TRUE, TRUE, 0);
tree_store = gtk_tree_store_new(N_FOLDERSEL_COLUMNS,
G_TYPE_STRING,
G_TYPE_POINTER,
GDK_TYPE_PIXBUF,
GDK_TYPE_PIXBUF,
GDK_TYPE_COLOR,
G_TYPE_INT);
gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(tree_store),
FOLDERSEL_FOLDERNAME,
foldersel_folder_name_compare,
NULL, NULL);
treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(tree_store));
g_object_unref(G_OBJECT(tree_store));
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview), FALSE);
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(treeview),
prefs_common.use_stripes_everywhere);
gtk_tree_view_set_enable_tree_lines(GTK_TREE_VIEW(treeview), FALSE);
gtk_tree_view_set_search_column(GTK_TREE_VIEW(treeview),
FOLDERSEL_FOLDERNAME);
if (prefs_common.folder_search_wildcard)
gtk_tree_view_set_search_equal_func(GTK_TREE_VIEW(treeview),
foldersel_search_name_func, NULL, NULL);
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE);
gtk_tree_selection_set_select_function(selection, foldersel_selected,
NULL, NULL);
g_signal_connect(G_OBJECT(treeview), "row-activated",
G_CALLBACK(foldersel_tree_activated), NULL);
gtk_container_add(GTK_CONTAINER(scrolledwin), treeview);
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_spacing(column, 2);
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_attributes
(column, renderer,
"pixbuf", FOLDERSEL_PIXBUF,
"pixbuf-expander-open", FOLDERSEL_PIXBUF_OPEN,
"pixbuf-expander-closed", FOLDERSEL_PIXBUF,
NULL);
/* create text renderer */
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_set_attributes
(column, renderer,
"text", FOLDERSEL_FOLDERNAME,
"foreground-gdk", FOLDERSEL_FOREGROUND,
"weight", FOLDERSEL_BOLD,
NULL);
g_object_set(G_OBJECT(renderer), "weight", PANGO_WEIGHT_BOLD, NULL);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
entry = gtk_entry_new();
gtk_editable_set_editable(GTK_EDITABLE(entry), FALSE);
gtk_box_pack_start(GTK_BOX(vbox), entry, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(entry), "activate",
G_CALLBACK(foldersel_entry_activated), NULL);
gtkut_stock_button_set_create(&confirm_area,
&new_button, GTK_STOCK_NEW,
&cancel_button, GTK_STOCK_CANCEL,
&ok_button, GTK_STOCK_OK);
gtk_box_pack_end(GTK_BOX(vbox), confirm_area, FALSE, FALSE, 0);
gtk_widget_grab_default(ok_button);
g_signal_connect(G_OBJECT(ok_button), "clicked",
G_CALLBACK(foldersel_ok), NULL);
g_signal_connect(G_OBJECT(cancel_button), "clicked",
G_CALLBACK(foldersel_cancel), NULL);
g_signal_connect(G_OBJECT(new_button), "clicked",
G_CALLBACK(foldersel_new_folder), NULL);
if (!geometry.min_height) {
geometry.min_width = 300;
geometry.min_height = 360;
}
gtk_window_set_geometry_hints(GTK_WINDOW(window), NULL, &geometry,
GDK_HINT_MIN_SIZE);
gtk_widget_set_size_request(window, prefs_common.folderselwin_width,
prefs_common.folderselwin_height);
gtk_widget_show_all(vbox);
}
static void
sdb_view_locals_init (SymbolDBViewLocals *dbvl)
{
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GtkTreeSelection *selection;
GtkTreeStore *store;
SymbolDBViewLocalsPriv *priv;
g_return_if_fail (dbvl != NULL);
/*DEBUG_PRINT ("%s", "sdb_view_locals_init ()");*/
dbvl->priv = g_new0 (SymbolDBViewLocalsPriv, 1);
priv = dbvl->priv;
priv->current_db_file = NULL;
priv->current_local_file_path = NULL;
priv->nodes_displayed = NULL;
priv->waiting_for = NULL;
priv->nodes_not_yet_removed = g_tree_new_full ((GCompareDataFunc)&symbol_db_gtree_compare_func,
NULL,
NULL,
NULL);
priv->symbols_inserted_ids = NULL;
priv->insert_handler = 0;
priv->scan_end_handler = 0;
priv->remove_handler = 0;
priv->scope_update_handler = 0;
priv->insertion_idle_handler = 0;
priv->files_view_status = g_hash_table_new_full (g_str_hash,
g_str_equal, g_free, (GDestroyNotify)file_view_status_destroy);
priv->recv_signals = FALSE;
priv->display_nothing = FALSE;
/* initially set it to NULL */
store = NULL;
gtk_tree_view_set_model (GTK_TREE_VIEW (dbvl), GTK_TREE_MODEL (store));
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (dbvl), FALSE);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (dbvl));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
/* search through the tree interactively */
gtk_tree_view_set_enable_search (GTK_TREE_VIEW (dbvl), TRUE);
gtk_tree_view_set_search_column (GTK_TREE_VIEW (dbvl), COLUMN_NAME);
gtk_tree_view_set_search_equal_func (GTK_TREE_VIEW (dbvl),
sdb_view_locals_search_equal_func, NULL, NULL);
/* Columns */
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_sizing (column,
GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_title (column, _("Symbol"));
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_add_attribute (column, renderer, "pixbuf",
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",
COLUMN_NAME);
gtk_tree_view_append_column (GTK_TREE_VIEW (dbvl), column);
gtk_tree_view_set_expander_column (GTK_TREE_VIEW (dbvl), column);
/* gtk 2.12
* gtk_tree_view_set_show_expanders (GTK_TREE_VIEW (dbvl), FALSE); */
}
GtkWidget *
create_directory_treeview (void)
{
GtkCellRenderer *cell;
GtkTreeViewColumn *col;
GtkWidget *scrolled;
GtkWidget *tvw = GTK_WIDGET (gtk_builder_get_object (baobab.main_ui, "treeview1"));
g_signal_connect (tvw, "row-expanded",
G_CALLBACK (on_tv_row_expanded), NULL);
g_signal_connect (tvw, "cursor-changed",
G_CALLBACK (on_tv_cur_changed), NULL);
g_signal_connect (tvw, "button-press-event",
G_CALLBACK (on_tv_button_press), NULL);
/* dir name column */
g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (tvw)), "changed",
G_CALLBACK (on_tv_selection_changed), NULL);
cell = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes (NULL, cell, "markup",
COL_DIR_NAME, "text",
COL_DIR_NAME, NULL);
gtk_tree_view_column_set_sort_column_id (col, COL_DIR_NAME);
gtk_tree_view_column_set_reorderable (col, TRUE);
gtk_tree_view_column_set_title (col, _("Folder"));
gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_resizable (col, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (tvw), col);
/* percentage bar & text column */
col = gtk_tree_view_column_new ();
cell = baobab_cell_renderer_progress_new ();
gtk_tree_view_column_pack_start (col, cell, FALSE);
gtk_tree_view_column_set_attributes (col, cell, "perc",
COL_H_PERC, NULL);
cell = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (col, cell, TRUE);
gtk_tree_view_column_set_cell_data_func (col, cell,
perc_cell_data_func,
NULL, NULL);
g_object_set (G_OBJECT (cell), "xalign", (gfloat) 1.0, NULL);
gtk_tree_view_column_set_sort_column_id (col, COL_H_PERC);
gtk_tree_view_column_set_reorderable (col, TRUE);
gtk_tree_view_column_set_title (col, _("Usage"));
gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_resizable (col, FALSE);
gtk_tree_view_append_column (GTK_TREE_VIEW (tvw), col);
/* directory size column */
cell = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes (NULL, cell, "markup",
COL_DIR_SIZE, "text",
COL_DIR_SIZE, NULL);
g_object_set (G_OBJECT (cell), "xalign", (gfloat) 1.0, NULL);
gtk_tree_view_column_set_sort_column_id (col,
baobab.show_allocated ? COL_H_ALLOCSIZE : COL_H_SIZE);
gtk_tree_view_column_set_reorderable (col, TRUE);
gtk_tree_view_column_set_title (col, _("Size"));
gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_resizable (col, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (tvw), col);
/* store this column, we need it when toggling 'allocated' */
g_object_set_data (G_OBJECT (tvw), "baobab_size_col", col);
/* objects column */
cell = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes (NULL, cell, "markup",
COL_ELEMENTS, "text",
COL_ELEMENTS, NULL);
g_object_set (G_OBJECT (cell), "xalign", (gfloat) 1.0, NULL);
gtk_tree_view_column_set_sort_column_id (col, COL_H_ELEMENTS);
gtk_tree_view_column_set_reorderable (col, TRUE);
gtk_tree_view_column_set_title (col, _("Contents"));
gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_resizable (col, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (tvw), col);
/* hardlink column */
cell = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes (NULL, cell, "markup",
COL_HARDLINK, "text",
COL_HARDLINK, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tvw), col);
gtk_tree_view_collapse_all (GTK_TREE_VIEW (tvw));
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tvw), FALSE);
scrolled = GTK_WIDGET (gtk_builder_get_object (baobab.main_ui, "scrolledwindow1"));
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_tree_view_set_search_equal_func (GTK_TREE_VIEW (tvw),
baobab_treeview_equal_func,
NULL, NULL);
baobab.model = create_model ();
/* By default, sort by size */
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (baobab.model),
baobab.show_allocated ? COL_H_ALLOCSIZE : COL_H_SIZE,
GTK_SORT_DESCENDING);
gtk_tree_view_set_model (GTK_TREE_VIEW (tvw),
GTK_TREE_MODEL (baobab.model));
g_object_unref (baobab.model);
return tvw;
}
static void
gtk_app_chooser_widget_add_items (GtkAppChooserWidget *self)
{
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkTreeModel *sort;
/* create list store */
self->priv->program_list_store = gtk_list_store_new (NUM_COLUMNS,
G_TYPE_APP_INFO,
G_TYPE_ICON,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_BOOLEAN,
G_TYPE_BOOLEAN,
G_TYPE_STRING,
G_TYPE_BOOLEAN,
G_TYPE_BOOLEAN);
sort = gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL (self->priv->program_list_store));
gtk_tree_view_set_model (GTK_TREE_VIEW (self->priv->program_list),
GTK_TREE_MODEL (sort));
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort),
COLUMN_NAME,
GTK_SORT_ASCENDING);
gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (sort),
COLUMN_NAME,
gtk_app_chooser_sort_func,
self, NULL);
gtk_tree_view_set_search_column (GTK_TREE_VIEW (self->priv->program_list),
COLUMN_NAME);
gtk_tree_view_set_search_equal_func (GTK_TREE_VIEW (self->priv->program_list),
gtk_app_chooser_search_equal_func,
NULL, NULL);
column = gtk_tree_view_column_new ();
/* initial padding */
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, renderer, FALSE);
g_object_set (renderer,
"xpad", self->priv->show_all ? 0 : 6,
NULL);
self->priv->padding_renderer = renderer;
/* heading text renderer */
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_set_attributes (column, renderer,
"markup", COLUMN_HEADING_TEXT,
"visible", COLUMN_HEADING,
NULL);
g_object_set (renderer,
"ypad", 6,
"xpad", 0,
"wrap-width", 350,
"wrap-mode", PANGO_WRAP_WORD,
NULL);
/* padding renderer for non-heading cells */
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_set_cell_data_func (column, renderer,
padding_cell_renderer_func,
NULL, NULL);
/* app icon renderer */
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_set_attributes (column, renderer,
"gicon", COLUMN_GICON,
NULL);
g_object_set (renderer,
"stock-size", GTK_ICON_SIZE_MENU,
NULL);
/* app name renderer */
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_set_attributes (column, renderer,
"markup", COLUMN_DESC,
NULL);
g_object_set (renderer,
"ellipsize", PANGO_ELLIPSIZE_END,
"ellipsize-set", TRUE,
NULL);
gtk_tree_view_column_set_sort_column_id (column, COLUMN_NAME);
gtk_tree_view_append_column (GTK_TREE_VIEW (self->priv->program_list), column);
/* populate the widget */
gtk_app_chooser_widget_real_add_items (self);
}
static GtkWidget *
pidgin_get_mail_dialog(void)
{
if (mail_dialog == NULL) {
GtkWidget *dialog = NULL;
GtkWidget *label;
GtkWidget *sw;
GtkCellRenderer *rend;
GtkTreeViewColumn *column;
GtkWidget *button = NULL;
GtkWidget *vbox = NULL;
dialog = gtk_dialog_new_with_buttons(_("New Mail"), NULL, 0,
GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
NULL);
gtk_window_set_role(GTK_WINDOW(dialog), "new_mail_detailed");
g_signal_connect(G_OBJECT(dialog), "focus-in-event",
G_CALLBACK(mail_window_focus_cb), NULL);
gtk_dialog_add_button(GTK_DIALOG(dialog),
_("Open All Messages"), GTK_RESPONSE_ACCEPT);
button = gtk_dialog_add_button(GTK_DIALOG(dialog),
PIDGIN_STOCK_OPEN_MAIL, GTK_RESPONSE_YES);
/* make "Open All Messages" the default response */
gtk_dialog_set_default_response(GTK_DIALOG(dialog),
GTK_RESPONSE_ACCEPT);
/* Setup the dialog */
gtk_container_set_border_width(GTK_CONTAINER(dialog), PIDGIN_HIG_BOX_SPACE);
gtk_container_set_border_width(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), PIDGIN_HIG_BOX_SPACE);
gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE);
gtk_box_set_spacing(GTK_BOX(GTK_DIALOG(dialog)->vbox), PIDGIN_HIG_BORDER);
/* Vertical box */
vbox = GTK_DIALOG(dialog)->vbox;
/* Golden ratio it up! */
gtk_widget_set_size_request(dialog, 550, 400);
sw = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW(sw), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
mail_dialog = g_new0(PidginMailDialog, 1);
mail_dialog->dialog = dialog;
mail_dialog->open_button = button;
mail_dialog->treemodel = gtk_tree_store_new(COLUMNS_PIDGIN_MAIL,
GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_POINTER);
mail_dialog->treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(mail_dialog->treemodel));
g_object_unref(G_OBJECT(mail_dialog->treemodel));
gtk_tree_view_set_search_column(GTK_TREE_VIEW(mail_dialog->treeview), PIDGIN_MAIL_TEXT);
gtk_tree_view_set_search_equal_func(GTK_TREE_VIEW(mail_dialog->treeview),
pidgin_tree_view_search_equal_func, NULL, NULL);
g_signal_connect(G_OBJECT(dialog), "response",
G_CALLBACK(email_response_cb), mail_dialog);
g_signal_connect(G_OBJECT(gtk_tree_view_get_selection(GTK_TREE_VIEW(mail_dialog->treeview))),
"changed", G_CALLBACK(selection_changed_cb), mail_dialog);
g_signal_connect(G_OBJECT(mail_dialog->treeview), "row-activated", G_CALLBACK(email_row_activated_cb), NULL);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(mail_dialog->treeview), FALSE);
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(mail_dialog->treeview), TRUE);
gtk_container_add(GTK_CONTAINER(sw), mail_dialog->treeview);
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_resizable(column, TRUE);
rend = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(column, rend, FALSE);
gtk_tree_view_column_set_attributes(column, rend, "pixbuf", PIDGIN_MAIL_ICON, NULL);
rend = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, rend, TRUE);
gtk_tree_view_column_set_attributes(column, rend, "markup", PIDGIN_MAIL_TEXT, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(mail_dialog->treeview), column);
label = gtk_label_new(NULL);
gtk_label_set_markup(GTK_LABEL(label), _("<span weight=\"bold\" size=\"larger\">You have mail!</span>"));
gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0);
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), sw, TRUE, TRUE, 0);
}
return mail_dialog->dialog;
}
