static void load_locations(MateWeatherPref* pref)
{
GtkTreeView* tree = GTK_TREE_VIEW(pref->priv->tree);
GtkTreeViewColumn* column;
GtkCellRenderer* cell_renderer;
/* Add a column for the locations */
cell_renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("not used", cell_renderer, "text", MATEWEATHER_XML_COL_LOC, NULL);
gtk_tree_view_append_column(tree, column);
gtk_tree_view_set_expander_column(GTK_TREE_VIEW(tree), column);
/* load locations from xml file */
pref->priv->model = mateweather_xml_load_locations();
if (!pref->priv->model)
{
GtkWidget* d = gtk_message_dialog_new(NULL, 0, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("Failed to load the Locations XML database. Please report this as a bug."));
gtk_dialog_run(GTK_DIALOG(d));
gtk_widget_destroy(d);
}
gtk_tree_view_set_model (tree, pref->priv->model);
if (pref->priv->applet->mateweather_pref.location)
{
/* Select the current (default) location */
gtk_tree_model_foreach(GTK_TREE_MODEL(pref->priv->model), compare_location, pref);
}
}
GtkWidget*
bst_msg_absorb_config_box (void)
{
GxkRadget *self = gxk_radget_create ("beast", "message-absorb-config-box", NULL);
GtkTreeView *tview = gxk_radget_find (self, "message-tree-view");
/* setup model */
GxkListWrapper *lwrapper = gxk_list_wrapper_new (N_MCOLS,
G_TYPE_BOOLEAN, /* MCOL_CHECK */
G_TYPE_STRING, /* MCOL_BLURB */
G_TYPE_STRING /* MCOL_VERSION */
);
g_signal_connect_object (lwrapper, "fill-value",
G_CALLBACK (msg_absorb_string_seq_fill_value),
self, G_CONNECT_SWAPPED);
gtk_tree_view_set_model (tview, GTK_TREE_MODEL (lwrapper));
/* setup selection mode */
GtkTreeSelection *tsel = gtk_tree_view_get_selection (tview);
gtk_tree_selection_set_mode (tsel, GTK_SELECTION_NONE);
/* columns */
GtkTreeViewColumn *col;
col = gxk_tree_view_add_toggle_column (tview, MCOL_CHECK, "", 0.5, "X",
_("Enable or disable message display of a specific message type"),
msg_absorb_string_toggled, self, G_CONNECT_AFTER);
col = gxk_tree_view_add_text_column (tview, MCOL_BLURB, "S", 0.0, _("Message Type"),
NULL, // _("The message type selection phrase displayed in message dialogs"),
NULL, NULL, 0);
col = gxk_tree_view_add_text_column (tview, MCOL_VERSION, "S", 0.0, _("Version"),
_("The last program version that displayed this message type"),
NULL, NULL, 0);
gtk_tree_view_set_expander_column (tview, col); /* where to put unused expander space */
return self;
}
static GtkWidget *
debug_tree_create (DebugTree *tree, GtkTreeView *view)
{
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkTreeModel * model = GTK_TREE_MODEL (gtk_tree_store_new
(N_COLUMNS,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_BOOLEAN,
G_TYPE_POINTER));
if (view == NULL)
{
view = GTK_TREE_VIEW (gtk_tree_view_new ());
}
gtk_tree_view_set_model (view, GTK_TREE_MODEL (model));
GtkTreeSelection *selection = gtk_tree_view_get_selection (view);
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
g_object_unref (G_OBJECT (model));
/* Columns */
column = gtk_tree_view_column_new ();
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_add_attribute (column, renderer, "text", VARIABLE_COLUMN);
gtk_tree_view_column_add_attribute (column, renderer, "editable", ROOT_COLUMN);
g_signal_connect(renderer, "edited", (GCallback) on_debug_tree_variable_changed, tree);
gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_title (column, _(tree_title[0]));
gtk_tree_view_append_column (view, column);
gtk_tree_view_set_expander_column (view, column);
column = gtk_tree_view_column_new ();
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_set_cell_data_func (column, renderer,
debug_tree_cell_data_func, NULL, NULL);
gtk_tree_view_column_add_attribute (column, renderer, "text", VALUE_COLUMN);
g_object_set(renderer, "editable", TRUE, NULL);
g_signal_connect(renderer, "edited", (GCallback) on_debug_tree_value_changed, tree);
gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_title (column, _(tree_title[1]));
gtk_tree_view_append_column (view, column);
column = gtk_tree_view_column_new ();
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_add_attribute (column, renderer, "text", TYPE_COLUMN);
gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_title (column, _(tree_title[2]));
gtk_tree_view_append_column (view, column);
return GTK_WIDGET (view);
}
void gTree::showExpanders()
{
#if GTK_CHECK_VERSION(2, 12, 0)
gtk_tree_view_set_show_expanders(GTK_TREE_VIEW(widget), true);
#else
gtk_tree_view_set_expander_column(GTK_TREE_VIEW(widget), gt_tree_view_find_column(GTK_TREE_VIEW(widget), 0));
#endif
_expander = true;
}
/** Hide expanders in the given GtkTreeView.
*
* @todo
* This should be replaced by a gtk_tree_view_set_show_expanders when
* we switch to GTK+ 2.12.
*
* @param view the given GtkTreeView
*/
static void hide_expanders(GtkTreeView * view)
{
GtkTreeViewColumn * column;
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_visible(column, FALSE);
gtk_tree_view_insert_column(view, column, -1 /* at the end */);
gtk_tree_view_set_expander_column(view, column);
}
gTree::gTree()
{
onRemove = NULL;
datakey = g_hash_table_new((GHashFunc)g_str_hash,(GEqualFunc)gTree_equal);
store = gtk_tree_store_new(2, G_TYPE_STRING, G_TYPE_POINTER);
widget = NULL;
//_editable = false;
_resizable = false;
_auto_resize = false;
//_edited_row = NULL;
_sorted = false;
_ascending = true;
_sort_column = 0;
_init_sort = false;
_sort_dirty = false;
_expander = false;
_no_click = 0;
#if 0
if (view)
{
#if GTK_CHECK_VERSION(2, 12, 0)
gtk_tree_view_set_show_expanders(GTK_TREE_VIEW(widget), false);
#else
GtkTreeViewColumn *column = gtk_tree_view_column_new();
//gtk_tree_view_column_pack_start(column,rgraph,false);
//gtk_tree_view_column_pack_start(column,rtext,true);
//gtk_tree_view_column_set_cell_data_func(column,rgraph,(GtkTreeCellDataFunc)tree_cell_graph,(gpointer)this,NULL);
//gtk_tree_view_column_set_cell_data_func(column,rtext,(GtkTreeCellDataFunc)tree_cell_text,(gpointer)this,NULL);
gtk_tree_view_column_set_visible(column, false);
gtk_tree_view_append_column(GTK_TREE_VIEW(widget), column);
gtk_tree_view_set_expander_column(GTK_TREE_VIEW(widget), column);
#endif
rgraph = gtk_cell_renderer_pixbuf_new();
g_object_ref_sink(rgraph);
rtext = gtk_cell_renderer_text_new();
g_object_ref_sink(rtext);
g_signal_connect(G_OBJECT(rtext), "edited", G_CALLBACK(cb_tree_edited), (gpointer)this);
g_signal_connect(G_OBJECT(rtext), "editing-started", G_CALLBACK(cb_tree_started), (gpointer)this);
g_signal_connect(G_OBJECT(rtext), "editing-canceled", G_CALLBACK(cb_tree_canceled), (gpointer)this);
//addColumn();
setAutoResize(true);
}
#endif
}
static void
setup_locations_dialog()
{
GladeXML *xml = glade_xml;
g_signal_connect(locations_dialog, "delete_event",
G_CALLBACK(locations_delete_event), NULL);
g_signal_connect(locations_dialog, "response",
G_CALLBACK(locations_response), NULL);
GtkTreeStore *model;
/*GtkTreeSelection *selection;*/
GtkWidget *scrolled_window;
GtkTreeViewColumn *column;
GtkCellRenderer *cell_renderer;
/*WeatherLocation *current_location;*/
scrolled_window = (GtkWidget*) glade_xml_get_widget(xml, "location_list_scroll");
model = gtk_tree_store_new (GWEATHER_XML_NUM_COLUMNS, G_TYPE_STRING, G_TYPE_POINTER);
locations_widgets->tree = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model));
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (locations_widgets->tree), FALSE);
/* Add a colum for the locations */
cell_renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("not used", cell_renderer,
"text", GWEATHER_XML_COL_LOC, NULL);
gtk_tree_view_append_column ((GtkTreeView *)locations_widgets->tree, column);
gtk_tree_view_set_expander_column (GTK_TREE_VIEW (locations_widgets->tree), column);
gtk_container_add (GTK_CONTAINER (scrolled_window), locations_widgets->tree);
gtk_widget_show (locations_widgets->tree);
gtk_widget_show (scrolled_window);
/* current_location = weather_location_clone (gw_applet->gweather_pref.location);*/
/* load locations from xml file */
if (gweather_xml_load_locations ((GtkTreeView *)locations_widgets->tree, NULL))
{
GtkWidget *d;
d = gtk_message_dialog_new (NULL, 0, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
_("Failed to load the Locations XML "
"database. Please report this as "
"a bug."));
gtk_dialog_run (GTK_DIALOG (d));
gtk_widget_destroy (d);
}
}
static void
render_column(HybridInfo *info)
{
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
/* expander columns */
column = gtk_tree_view_column_new();
gtk_tree_view_append_column(GTK_TREE_VIEW(info->treeview), column);
gtk_tree_view_column_set_visible(column, FALSE);
gtk_tree_view_set_expander_column(GTK_TREE_VIEW(info->treeview), column);
/* main column */
column = gtk_tree_view_column_new ();
gtk_tree_view_append_column(GTK_TREE_VIEW(info->treeview), column);
gtk_tree_view_columns_autosize(GTK_TREE_VIEW(info->treeview));
/* name */
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_attributes(column, renderer,
"markup", HYBRID_INFO_NAME_COLUMN,
NULL);
g_object_set(renderer, "wrap-mode", PANGO_WRAP_CHAR, NULL);
g_object_set(renderer, "wrap-width",120, NULL);
/* value */
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_attributes(column, renderer,
"markup", HYBRID_INFO_VALUE_COLUMN,
"visible", HYBRID_INFO_VALUE_COLUMN_VISIBLE,
NULL);
g_object_set(renderer, "wrap-mode", PANGO_WRAP_CHAR, NULL);
g_object_set(renderer, "wrap-width",250, NULL);
/* pixbuf */
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_attributes(column, renderer,
"pixbuf", HYBRID_INFO_PIXBUF_COLUMN,
"visible", HYBRID_INFO_PIXBUF_COLUMN_VISIBLE,
NULL);
}
static void add_columns(GtkTreeView *treeview)
{
GtkCellRenderer *rend;
GtkTreeViewColumn *column;
GtkTreeViewColumn *text_column;
/**< Column */
GtkCellRenderer *text_rend;
column = gtk_tree_view_column_new();
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
// auv gtk_tree_view_column_set_visible(column, FALSE);
gtk_tree_view_column_set_visible(column, TRUE);
gtk_tree_view_set_expander_column(GTK_TREE_VIEW(treeview), column);
rend = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(column, rend, FALSE);
gtk_tree_view_column_set_attributes(column, rend,
"pixbuf", STATUS_ICON_COLUMN, "visible", STATUS_ICON_VISIBLE_COLUMN, NULL);
g_object_set(rend, "xalign", 0.0, "xpad", 6, "ypad", 0, NULL);
text_rend = rend = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, rend, TRUE);
gtk_tree_view_column_set_attributes(column, rend, "markup", TITLE_COLUMN, NULL);
#if GTK_CHECK_VERSION(2,6,0)
// g_signal_connect(G_OBJECT(rend), "editing-started", G_CALLBACK(gtk_blist_renderer_editing_started_cb), NULL);
#endif
g_object_set(rend, "ypad", 0, "yalign", 0.5, NULL);
g_object_set(rend, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
rend = gtk_cell_renderer_pixbuf_new();
g_object_set(rend, "xalign", 1.0, "ypad", 0, NULL);
gtk_tree_view_column_pack_start(column, rend, FALSE);
gtk_tree_view_column_set_attributes(column, rend, "pixbuf",
RATE_ICON_COLUMN, "visible", RATE_ICON_VISIBLE_COLUMN, NULL);
}
void
ghid_netlist_window_create (GHidPort * out)
{
GtkWidget *vbox, *hbox, *button, *label, *sep;
GtkTreeView *treeview;
GtkTreeModel *model;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
if (netlist_window)
return;
netlist_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (G_OBJECT (netlist_window), "destroy",
G_CALLBACK (netlist_destroy_cb), out);
gtk_window_set_title (GTK_WINDOW (netlist_window), _("PCB Netlist"));
gtk_window_set_wmclass (GTK_WINDOW (netlist_window), "PCB_Netlist", "PCB");
g_signal_connect (G_OBJECT (netlist_window), "configure_event",
G_CALLBACK (netlist_window_configure_event_cb), NULL);
gtk_window_set_default_size (GTK_WINDOW (netlist_window),
-1, ghidgui->netlist_window_height);
gtk_container_set_border_width (GTK_CONTAINER (netlist_window), 2);
vbox = gtk_vbox_new (FALSE, 4);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 6);
gtk_container_add (GTK_CONTAINER (netlist_window), vbox);
hbox = gtk_hbox_new (FALSE, 8);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 4);
model = net_model_create ();
treeview = GTK_TREE_VIEW (gtk_tree_view_new_with_model (model));
net_model = model;
net_treeview = treeview;
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (net_model),
NET_NAME_COLUMN, GTK_SORT_ASCENDING);
gtk_tree_view_set_rules_hint (treeview, FALSE);
g_object_set (treeview, "enable-tree-lines", TRUE, NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_insert_column_with_attributes (treeview, -1, _(" "),
renderer,
"text", NET_ENABLED_COLUMN,
NULL);
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (_("Net Name"),
renderer,
"text", NET_NAME_COLUMN, NULL);
gtk_tree_view_insert_column (treeview, column, -1);
gtk_tree_view_set_expander_column (treeview, column);
/* TODO: dont expand all, but record expanded states when window is
| destroyed and restore state here.
*/
gtk_tree_view_expand_all (treeview);
ghid_scrolled_selection (treeview, hbox,
GTK_SELECTION_SINGLE,
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC,
net_selection_changed_cb, NULL);
/* Connect to the double click event.
*/
g_signal_connect (G_OBJECT (treeview), "row-activated",
G_CALLBACK (net_selection_double_click_cb), NULL);
/* Create the elements treeview and wait for a callback to populate it.
*/
treeview = GTK_TREE_VIEW (gtk_tree_view_new ());
node_treeview = treeview;
gtk_tree_view_set_rules_hint (treeview, FALSE);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_insert_column_with_attributes (treeview, -1, _("Nodes"),
renderer,
"text", NODE_NAME_COLUMN,
NULL);
ghid_scrolled_selection (treeview, hbox,
GTK_SELECTION_SINGLE,
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC,
node_selection_changed_cb, NULL);
hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
label = gtk_label_new (_("Operations on selected 'Net Name':"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 4);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 4);
button = gtk_button_new_with_label (_("Select"));
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (netlist_select_cb), GINT_TO_POINTER (1));
button = gtk_button_new_with_label (_("Unselect"));
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (netlist_select_cb), GINT_TO_POINTER (0));
button = gtk_button_new_with_label (_("Find"));
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (netlist_find_cb), GINT_TO_POINTER (0));
button = gtk_button_new_with_label (_("Rip Up"));
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (netlist_rip_up_cb), GINT_TO_POINTER (0));
ghid_check_button_connected (vbox, &disable_all_button, FALSE, TRUE, FALSE,
FALSE, 0, netlist_disable_all_cb, NULL,
_("Disable all nets for adding rats"));
sep = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (vbox), sep, FALSE, FALSE, 3);
hbox = gtk_hbutton_box_new ();
gtk_button_box_set_layout (GTK_BUTTON_BOX (hbox), GTK_BUTTONBOX_END);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 4);
button = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (netlist_close_cb), NULL);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
gtk_widget_realize (netlist_window);
if (Settings.AutoPlace)
gtk_window_move (GTK_WINDOW (netlist_window), 10, 10);
}
static void tree_gui_init_treeview(tree_gui_t *gui)
{
//GtkTooltips *tooltips;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
/* Get tooltips engine */
//tooltips = gtk_object_get_data(GTK_OBJECT(gui->window), "tooltips");
/* Create test tree */
gui->tree_model = gtk_tree_store_new(TREE_GUI_NCOLS,
/* TREE_GUI_COL_TYPE_PIXBUF */ GDK_TYPE_PIXBUF,
/* TREE_GUI_COL_NAME */ G_TYPE_STRING,
/* TREE_GUI_COL_BRKPT_PIXBUF */ GDK_TYPE_PIXBUF,
/* TREE_GUI_COL_BRKPT */ G_TYPE_INT,
/* TREE_GUI_COL_FLAGS_PIXBUF */ GDK_TYPE_PIXBUF,
/* TREE_GUI_COL_SKIP */ G_TYPE_INT,
/* TREE_GUI_COL_VERDICT_PIXBUF */ GDK_TYPE_PIXBUF,
/* TREE_GUI_COL_CRITICITY */ G_TYPE_STRING,
/* TREE_GUI_COL_CRITICITY_COLOR */ G_TYPE_STRING,
/* TREE_GUI_COL_BACKGROUND */ GDK_TYPE_COLOR,
/* TREE_GUI_COL_STYLE */ PANGO_TYPE_STYLE,
/* TREE_GUI_COL_KEY */ G_TYPE_ULONG,
/* TREE_GUI_COL_OBJECT */ G_TYPE_POINTER);
gui->tree_view = GTK_TREE_VIEW(lookup_widget(gui->window, "tree_view"));
gtk_tree_view_set_model(gui->tree_view, GTK_TREE_MODEL(gui->tree_model));
/* Setup tree selection handler */
gui->tree_selection = gtk_tree_view_get_selection(gui->tree_view);
gtk_tree_selection_set_mode(gui->tree_selection, GTK_SELECTION_SINGLE);
gtk_tree_selection_set_select_function(gui->tree_selection,
(GtkTreeSelectionFunc) tree_gui_select, gui,
NULL);
/* Set up row activation handler */
gtk_signal_connect(GTK_OBJECT(gui->tree_view), "row-activated",
GTK_SIGNAL_FUNC(tree_gui_row_activated), gui);
/* Column #0: breakpoint flag */
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_insert_column_with_attributes(gui->tree_view, -1, "Brk", renderer,
"pixbuf", TREE_GUI_COL_BRKPT_PIXBUF,
"cell-background-gdk", TREE_GUI_COL_BACKGROUND,
NULL);
/* Setup breakpoints clear button */
column = gtk_tree_view_get_column(gui->tree_view, 0);
gtk_tree_view_column_set_resizable(column, FALSE);
gtk_tree_view_column_set_clickable(column, TRUE);
// TODO: gtk_tooltips_set_tip (tooltips, w, "Clear all breakpoints", NULL);
gtk_signal_connect_object(GTK_OBJECT(column), "clicked",
GTK_SIGNAL_FUNC(tree_gui_breakpoint_clear_clicked), gui);
/* Column #1: Node pix and name */
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, "Test Tree");
gtk_tree_view_column_set_expand(column, TRUE);
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_add_attribute(column, renderer, "pixbuf", TREE_GUI_COL_TYPE_PIXBUF);
gtk_tree_view_column_add_attribute(column, renderer, "cell-background-gdk", TREE_GUI_COL_BACKGROUND);
renderer = gtk_cell_renderer_text_new();
//gtk_object_set(GTK_OBJECT(renderer), "family", "Monospace", NULL);
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_add_attribute(column, renderer, "text", TREE_GUI_COL_NAME);
gtk_tree_view_column_add_attribute(column, renderer, "cell-background-gdk", TREE_GUI_COL_BACKGROUND);
gtk_tree_view_column_add_attribute(column, renderer, "style", TREE_GUI_COL_STYLE);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_append_column(gui->tree_view, column);
gtk_tree_view_set_expander_column(gui->tree_view, column);
/* Setup selection clear button */
gtk_tree_view_column_set_clickable(column, TRUE);
// TODO: gtk_tooltips_set_tip (tooltips, w, "Clear selection", NULL);
gtk_signal_connect_object(GTK_OBJECT(column), "clicked",
GTK_SIGNAL_FUNC(tree_gui_unselect), gui);
/* Column #2: runtime flag */
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_insert_column_with_attributes(gui->tree_view, -1, "Flg", renderer,
"pixbuf", TREE_GUI_COL_FLAGS_PIXBUF,
"cell-background-gdk", TREE_GUI_COL_BACKGROUND,
NULL);
/* Column #3: verdict and criticity */
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, "Verdict");
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_add_attribute(column, renderer, "pixbuf", TREE_GUI_COL_VERDICT_PIXBUF);
gtk_tree_view_column_add_attribute(column, renderer, "cell-background-gdk", TREE_GUI_COL_BACKGROUND);
renderer = gtk_cell_renderer_text_new();
gtk_object_set(GTK_OBJECT(renderer), "scale", 0.6, NULL);
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_add_attribute(column, renderer, "text", TREE_GUI_COL_CRITICITY);
gtk_tree_view_column_add_attribute(column, renderer, "foreground", TREE_GUI_COL_CRITICITY_COLOR);
gtk_tree_view_column_add_attribute(column, renderer, "cell-background-gdk", TREE_GUI_COL_BACKGROUND);
gtk_tree_view_column_set_resizable(column, FALSE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_append_column(gui->tree_view, column);
}
static void
roster_view_gtk_init (G_GNUC_UNUSED RosterViewGtk* self)
{
GtkWidget *scrolled_window;
GtkWidget *vbox = NULL;
GtkTreeModel *filtered = NULL;
GtkTreeSelection *selection = NULL;
GtkTreeViewColumn *col = NULL;
GtkCellRenderer *renderer = NULL;
self->priv = new RosterViewGtkPrivate;
self->priv->folded_groups = gm_conf_get_string_list (CONTACTS_KEY "roster_folded_groups");
self->priv->show_offline_contacts = gm_conf_get_bool (CONTACTS_KEY "show_offline_contacts");
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 0);
gtk_container_set_border_width (GTK_CONTAINER (scrolled_window), 0);
gtk_frame_set_shadow_type (GTK_FRAME (self), GTK_SHADOW_NONE);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
self->priv->store = gtk_tree_store_new (COLUMN_NUMBER,
G_TYPE_INT, // type
G_TYPE_POINTER, // heap
G_TYPE_POINTER, // presentity
G_TYPE_STRING, // name
G_TYPE_STRING, // status
G_TYPE_STRING, // presence
G_TYPE_STRING, // color if active
G_TYPE_STRING, // group name (invisible)
G_TYPE_STRING, // presence
G_TYPE_BOOLEAN, // offline
G_TYPE_INT); // timeout source
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (self->priv->store),
COLUMN_NAME, GTK_SORT_ASCENDING);
filtered = gtk_tree_model_filter_new (GTK_TREE_MODEL (self->priv->store),
NULL);
g_object_unref (self->priv->store);
self->priv->tree_view =
GTK_TREE_VIEW (gtk_tree_view_new_with_model (filtered));
g_object_unref (filtered);
gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (filtered),
tree_model_filter_hide_show_offline,
self, NULL);
gtk_tree_view_set_headers_visible (self->priv->tree_view, FALSE);
gtk_container_add (GTK_CONTAINER (self), GTK_WIDGET (vbox));
gtk_box_pack_start (GTK_BOX (vbox),
GTK_WIDGET (scrolled_window), TRUE, TRUE, 0);
gtk_container_add (GTK_CONTAINER (scrolled_window),
GTK_WIDGET (self->priv->tree_view));
/* Build the GtkTreeView */
// We hide the normal GTK+ expanders and use our own
col = gtk_tree_view_column_new ();
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_set_spacing (col, 0);
gtk_tree_view_column_pack_start (col, renderer, TRUE);
g_object_set (col, "visible", FALSE, NULL);
gtk_tree_view_append_column (self->priv->tree_view, col);
gtk_tree_view_set_expander_column (self->priv->tree_view, col);
col = gtk_tree_view_column_new ();
renderer = gm_cell_renderer_expander_new ();
gtk_tree_view_column_pack_start (col, renderer, FALSE);
g_object_set (renderer,
"xalign", 0.0,
"xpad", 0,
"ypad", 0,
"visible", TRUE,
"expander-style", GTK_EXPANDER_COLLAPSED,
NULL);
gtk_tree_view_column_set_cell_data_func (col, renderer, expand_cell_data_func, NULL, NULL);
gtk_tree_view_append_column (self->priv->tree_view, col);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_set_spacing (col, 0);
gtk_tree_view_column_pack_start (col, renderer, TRUE);
gtk_tree_view_column_add_attribute (col, renderer, "text", COLUMN_NAME);
gtk_tree_view_column_set_alignment (col, 0.0);
g_object_set (renderer, "xalign", 0.5, "ypad", 0, NULL);
g_object_set (renderer, "weight", PANGO_WEIGHT_BOLD, NULL);
gtk_tree_view_column_set_cell_data_func (col, renderer,
show_cell_data_func, GINT_TO_POINTER (TYPE_HEAP), NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (col, renderer, TRUE);
gtk_tree_view_column_add_attribute (col, renderer,
"text", COLUMN_NAME);
g_object_set (renderer, "weight", PANGO_WEIGHT_BOLD, NULL);
gtk_tree_view_column_set_cell_data_func (col, renderer,
show_cell_data_func, GINT_TO_POINTER (TYPE_GROUP), NULL);
renderer = gtk_cell_renderer_pixbuf_new ();
g_object_set (renderer, "yalign", 0.5, "xpad", 5, NULL);
gtk_tree_view_column_pack_start (col, renderer, FALSE);
gtk_tree_view_column_add_attribute (col, renderer,
"icon-name",
COLUMN_PRESENCE_ICON);
gtk_tree_view_column_set_cell_data_func (col, renderer,
show_cell_data_func, GINT_TO_POINTER (TYPE_PRESENTITY), NULL);
renderer = gm_cell_renderer_bitext_new ();
g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, "width-chars", 30, NULL);
gtk_tree_view_column_pack_start (col, renderer, FALSE);
gtk_tree_view_column_add_attribute (col, renderer, "primary-text", COLUMN_NAME);
gtk_tree_view_column_add_attribute (col, renderer, "secondary-text", COLUMN_STATUS);
gtk_tree_view_column_add_attribute (col, renderer, "foreground", COLUMN_ACTIVE);
gtk_tree_view_column_set_cell_data_func (col, renderer,
show_cell_data_func, GINT_TO_POINTER (TYPE_PRESENTITY), NULL);
/* Callback when the selection has been changed */
selection = gtk_tree_view_get_selection (self->priv->tree_view);
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
g_signal_connect (selection, "changed",
G_CALLBACK (on_selection_changed), self);
g_signal_connect (self->priv->tree_view, "event-after",
G_CALLBACK (on_view_event_after), self);
/* Notifiers */
self->priv->notifier =
gm_conf_notifier_add (CONTACTS_KEY "show_offline_contacts",
show_offline_contacts_changed_nt, self);
}
static void
rb_grilo_source_constructed (GObject *object)
{
RBGriloSource *source;
RBShell *shell;
RBShellPlayer *shell_player;
const GList *source_keys;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GtkTreeSelection *selection;
GtkWidget *scrolled;
GtkWidget *browserbox;
GtkWidget *vbox;
GtkWidget *mainbox;
GtkAdjustment *adjustment;
RB_CHAIN_GOBJECT_METHOD (rb_grilo_source_parent_class, constructed, object);
source = RB_GRILO_SOURCE (object);
g_object_get (source, "shell", &shell, NULL);
g_object_get (shell,
"db", &source->priv->db,
"shell-player", &shell_player,
NULL);
g_object_unref (shell);
g_object_get (source, "entry-type", &source->priv->entry_type, NULL);
source->priv->entry_view = rb_entry_view_new (source->priv->db, G_OBJECT (shell_player), TRUE, FALSE);
g_object_unref (shell_player);
g_signal_connect (source->priv->entry_view,
"notify::sort-order",
G_CALLBACK (notify_sort_order_cb),
source);
source_keys = grl_source_supported_keys (source->priv->grilo_source);
if (g_list_find ((GList *)source_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_TRACK_NUMBER))) {
rb_entry_view_append_column (source->priv->entry_view, RB_ENTRY_VIEW_COL_TRACK_NUMBER, FALSE);
source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys,
GUINT_TO_POINTER(GRL_METADATA_KEY_TRACK_NUMBER));
}
if (g_list_find ((GList *)source_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_TITLE))) {
rb_entry_view_append_column (source->priv->entry_view, RB_ENTRY_VIEW_COL_TITLE, TRUE);
source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys,
GUINT_TO_POINTER(GRL_METADATA_KEY_TITLE));
}
if (g_list_find ((GList *)source_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_GENRE))) {
rb_entry_view_append_column (source->priv->entry_view, RB_ENTRY_VIEW_COL_GENRE, FALSE);
source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys,
GUINT_TO_POINTER(GRL_METADATA_KEY_GENRE));
}
if (g_list_find ((GList *)source_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_ARTIST))) {
rb_entry_view_append_column (source->priv->entry_view, RB_ENTRY_VIEW_COL_ARTIST, FALSE);
source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys,
GUINT_TO_POINTER(GRL_METADATA_KEY_ARTIST));
}
if (g_list_find ((GList *)source_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_ALBUM))) {
rb_entry_view_append_column (source->priv->entry_view, RB_ENTRY_VIEW_COL_ALBUM, FALSE);
source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys,
GUINT_TO_POINTER(GRL_METADATA_KEY_ALBUM));
}
/*
if (g_list_find ((GList *)source_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_DATE))) {
rb_entry_view_append_column (source->priv->entry_view, RB_ENTRY_VIEW_COL_YEAR, FALSE);
source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys,
GUINT_TO_POINTER(GRL_METADATA_KEY_DATE));
}
*/
if (g_list_find ((GList *)source_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_DURATION))) {
rb_entry_view_append_column (source->priv->entry_view, RB_ENTRY_VIEW_COL_DURATION, FALSE);
source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys,
GUINT_TO_POINTER(GRL_METADATA_KEY_DURATION));
}
source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_CHILDCOUNT));
source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_URL));
source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_THUMBNAIL));
/* probably add an image column too? */
source->priv->browser_model = gtk_tree_store_new (4, GRL_TYPE_MEDIA, G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT);
source->priv->browser_view = gtk_tree_view_new ();
gtk_tree_view_set_model (GTK_TREE_VIEW (source->priv->browser_view), GTK_TREE_MODEL (source->priv->browser_model));
column = gtk_tree_view_column_new ();
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_set_title (column, _("Browse"));
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_add_attribute (column, renderer, "text", 1);
gtk_tree_view_column_set_expand (column, TRUE);
gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column (GTK_TREE_VIEW (source->priv->browser_view), column);
gtk_tree_view_set_show_expanders (GTK_TREE_VIEW (source->priv->browser_view), TRUE);
gtk_tree_view_set_expander_column (GTK_TREE_VIEW (source->priv->browser_view), column);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (source->priv->browser_view), TRUE);
gtk_tree_view_set_fixed_height_mode (GTK_TREE_VIEW (source->priv->browser_view), TRUE);
g_signal_connect (source->priv->browser_view, "row-expanded", G_CALLBACK (browser_row_expanded_cb), source);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (source->priv->browser_view));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); /* should be multiple eventually */
g_signal_connect (selection, "changed", G_CALLBACK (browser_selection_changed_cb), source);
scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled), GTK_SHADOW_IN);
adjustment = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled));
g_signal_connect (adjustment, "changed", G_CALLBACK (scroll_adjust_changed_cb), source);
g_signal_connect (adjustment, "value-changed", G_CALLBACK (scroll_adjust_value_changed_cb), source);
browserbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
/* search bar (if the source supports searching) */
if (grl_source_supported_operations (source->priv->grilo_source) & GRL_OP_SEARCH) {
source->priv->search_entry = rb_search_entry_new (FALSE);
g_object_set (source->priv->search_entry, "explicit-mode", TRUE, NULL);
g_signal_connect (source->priv->search_entry, "search", G_CALLBACK (search_cb), source);
g_signal_connect (source->priv->search_entry, "activate", G_CALLBACK (search_cb), source);
gtk_box_pack_start (GTK_BOX (browserbox), GTK_WIDGET (source->priv->search_entry), FALSE, FALSE, 6);
}
gtk_container_add (GTK_CONTAINER (scrolled), source->priv->browser_view);
gtk_box_pack_start (GTK_BOX (browserbox), scrolled, TRUE, TRUE, 0);
mainbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_box_pack_start (GTK_BOX (source), mainbox, TRUE, TRUE, 0);
/* info bar */
source->priv->info_bar_label = gtk_label_new ("");
source->priv->info_bar = gtk_info_bar_new ();
gtk_info_bar_set_message_type (GTK_INFO_BAR (source->priv->info_bar), GTK_MESSAGE_INFO);
gtk_info_bar_add_button (GTK_INFO_BAR (source->priv->info_bar), _("Fetch more tracks"), GTK_RESPONSE_OK);
gtk_container_add (GTK_CONTAINER (gtk_info_bar_get_content_area (GTK_INFO_BAR (source->priv->info_bar))),
source->priv->info_bar_label);
gtk_widget_show (GTK_WIDGET (source->priv->info_bar_label));
gtk_widget_set_no_show_all (GTK_WIDGET (source->priv->info_bar), TRUE);
g_signal_connect (source->priv->info_bar, "response", G_CALLBACK (fetch_more_cb), source);
/* don't allow the browser to be hidden? */
source->priv->paned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
rb_source_bind_settings (RB_SOURCE (source), GTK_WIDGET (source->priv->entry_view), source->priv->paned, NULL);
gtk_paned_pack1 (GTK_PANED (source->priv->paned), browserbox, FALSE, FALSE);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_box_pack_start (GTK_BOX (vbox), GTK_WIDGET (source->priv->entry_view), TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox), source->priv->info_bar, FALSE, FALSE, 0);
gtk_paned_pack2 (GTK_PANED (source->priv->paned), vbox, TRUE, FALSE);
gtk_box_pack_start (GTK_BOX (mainbox), source->priv->paned, TRUE, TRUE, 0);
gtk_widget_show_all (GTK_WIDGET (source));
}
static void
set_columns_type (GtkTreeView *tree_view, ColumnsType type)
{
GtkTreeViewColumn *col;
GtkCellRenderer *rend;
GdkPixbuf *pixbuf;
GtkWidget *image;
GtkAdjustment *adjustment;
current_column_type = type;
col = gtk_tree_view_get_column (tree_view, 0);
while (col)
{
gtk_tree_view_remove_column (tree_view, col);
col = gtk_tree_view_get_column (tree_view, 0);
}
gtk_tree_view_set_rules_hint (tree_view, FALSE);
switch (type)
{
case COLUMNS_NONE:
break;
case COLUMNS_LOTS:
/* with lots of columns we need to turn on rules */
gtk_tree_view_set_rules_hint (tree_view, TRUE);
rend = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes ("Column 1",
rend,
"text", 1,
NULL);
setup_column (col);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
col = gtk_tree_view_column_new();
gtk_tree_view_column_set_title (col, "Column 2");
rend = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (col, rend, FALSE);
gtk_tree_view_column_add_attribute (col, rend, "pixbuf", 2);
rend = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (col, rend, TRUE);
gtk_tree_view_column_add_attribute (col, rend, "text", 0);
setup_column (col);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
gtk_tree_view_set_expander_column (tree_view, col);
rend = gtk_cell_renderer_toggle_new ();
g_signal_connect (rend, "toggled",
G_CALLBACK (toggled_callback), tree_view);
col = gtk_tree_view_column_new_with_attributes ("Column 3",
rend,
"active", BOOL_COLUMN,
NULL);
setup_column (col);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
pixbuf = gdk_pixbuf_new_from_xpm_data ((const char **)book_closed_xpm);
image = gtk_image_new_from_pixbuf (pixbuf);
g_object_unref (pixbuf);
gtk_widget_show (image);
gtk_tree_view_column_set_widget (col, image);
rend = gtk_cell_renderer_toggle_new ();
/* you could also set this per-row by tying it to a column
* in the model of course.
*/
g_object_set (rend, "radio", TRUE, NULL);
g_signal_connect (rend, "toggled",
G_CALLBACK (toggled_callback), tree_view);
col = gtk_tree_view_column_new_with_attributes ("Column 4",
rend,
"active", BOOL_COLUMN,
NULL);
setup_column (col);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
rend = gtk_cell_renderer_spin_new ();
adjustment = gtk_adjustment_new (0, 0, 10000, 100, 100, 100);
g_object_set (rend, "editable", TRUE, NULL);
g_object_set (rend, "adjustment", adjustment, NULL);
g_signal_connect (rend, "edited",
G_CALLBACK (edited_callback), tree_view);
col = gtk_tree_view_column_new_with_attributes ("Column 5",
rend,
"text", 4,
NULL);
setup_column (col);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
#if 0
rend = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes ("Column 6",
rend,
"text", 4,
NULL);
setup_column (col);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
rend = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes ("Column 7",
rend,
"text", 5,
NULL);
setup_column (col);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
rend = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes ("Column 8",
rend,
"text", 6,
NULL);
setup_column (col);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
rend = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes ("Column 9",
rend,
"text", 7,
NULL);
setup_column (col);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
rend = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes ("Column 10",
rend,
"text", 8,
NULL);
setup_column (col);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
#endif
/* FALL THRU */
case COLUMNS_ONE:
rend = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes ("Column 0",
rend,
"text", 0,
NULL);
setup_column (col);
gtk_tree_view_insert_column (GTK_TREE_VIEW (tree_view), col, 0);
default:
break;
}
}
void
dialog_preferences (WBCGtk *wbcg, gchar const *page)
{
PrefState *state;
GtkBuilder *gui;
GtkWidget *w;
gint i;
GtkTreeViewColumn *column;
GtkTreeSelection *selection;
w = g_object_get_data (gnm_app_get_app (), PREF_DIALOG_KEY);
if (w) {
gtk_widget_show (w);
gdk_window_raise (gtk_widget_get_window (w));
return;
}
gui = gnm_gtk_builder_load ("preferences.ui", NULL, GO_CMD_CONTEXT (wbcg));
if (gui == NULL)
return;
state = g_new0 (PrefState, 1);
state->gui = gui;
state->dialog = go_gtk_builder_get_widget (gui, "preferences");
state->notebook = (GtkNotebook*)go_gtk_builder_get_widget (gui, "notebook");
state->view = GTK_TREE_VIEW(go_gtk_builder_get_widget (gui, "itemlist"));
state->store = gtk_tree_store_new (NUM_COLUMNS,
GDK_TYPE_PIXBUF,
G_TYPE_STRING,
G_TYPE_INT);
gtk_tree_view_set_model (state->view, GTK_TREE_MODEL(state->store));
selection = gtk_tree_view_get_selection (state->view);
gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE);
column = gtk_tree_view_column_new_with_attributes ("",
gtk_cell_renderer_pixbuf_new (),
"pixbuf", ITEM_ICON,
NULL);
gtk_tree_view_append_column (state->view, column);
column = gtk_tree_view_column_new_with_attributes ("",
gtk_cell_renderer_text_new (),
"text", ITEM_NAME,
NULL);
gtk_tree_view_append_column (state->view, column);
gtk_tree_view_set_expander_column (state->view, column);
g_signal_connect (selection,
"changed",
G_CALLBACK (cb_dialog_pref_selection_changed), state);
g_signal_connect_swapped (G_OBJECT (go_gtk_builder_get_widget (gui, "close_button")),
"clicked",
G_CALLBACK (cb_close_clicked), state);
gnumeric_init_help_button (
go_gtk_builder_get_widget (state->gui, "help_button"),
GNUMERIC_HELP_LINK_PREFERENCES);
g_signal_connect_swapped (G_OBJECT (state->dialog),
"destroy",
G_CALLBACK(cb_preferences_destroy),
state);
g_object_set_data_full (G_OBJECT (state->dialog),
"state", state,
(GDestroyNotify)g_free);
g_object_set_data (gnm_app_get_app (), PREF_DIALOG_KEY, state->dialog);
state->app_wb_removed_sig =
g_signal_connect_swapped (gnm_app_get_app (),
"workbook_removed",
G_CALLBACK (cb_workbook_removed),
state);
for (i = 0; page_info[i].page_initializer; i++) {
const page_info_t *this_page = &page_info[i];
GtkWidget *page_widget =
this_page->page_initializer (state, NULL,
state->notebook, i);
gtk_notebook_append_page (state->notebook, page_widget, NULL);
dialog_pref_add_item (state, this_page->page_name,
this_page->icon_name, i,
this_page->parent_path);
}
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (state->store),
ITEM_NAME, GTK_SORT_ASCENDING);
go_gtk_nonmodal_dialog (wbcg_toplevel (wbcg),
GTK_WINDOW (state->dialog));
gtk_widget_show (GTK_WIDGET (state->dialog));
dialog_pref_select_page (state, page);
}
static void
attr_dialog_impl (AttrState *state)
{
GtkWidget *dialog = go_gtk_builder_get_widget (state->gui, "WorkbookAttr");
GtkTreeViewColumn *column;
GtkTreeSelection *selection;
int i;
g_return_if_fail (dialog != NULL);
/* Initialize */
state->dialog = dialog;
state->notebook = go_gtk_builder_get_widget (state->gui, "notebook");
state->destroying = FALSE;
state->tview = GTK_TREE_VIEW(go_gtk_builder_get_widget (state->gui, "itemlist"));
state->store = gtk_tree_store_new (NUM_COLUMNS,
GDK_TYPE_PIXBUF,
G_TYPE_STRING,
G_TYPE_INT);
gtk_tree_view_set_model (state->tview, GTK_TREE_MODEL(state->store));
g_object_unref (state->store);
selection = gtk_tree_view_get_selection (state->tview);
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
column = gtk_tree_view_column_new_with_attributes ("",
gtk_cell_renderer_pixbuf_new (),
"pixbuf", ITEM_ICON,
NULL);
gtk_tree_view_append_column (state->tview, column);
column = gtk_tree_view_column_new_with_attributes ("",
gtk_cell_renderer_text_new (),
"text", ITEM_NAME,
NULL);
gtk_tree_view_append_column (state->tview, column);
gtk_tree_view_set_expander_column (state->tview, column);
g_signal_connect (selection,
"changed",
G_CALLBACK (cb_attr_dialog_selection_changed), state);
for (i = 0; page_info[i].page > -1; i++) {
const page_info_t *this_page = &page_info[i];
this_page->page_initializer (state);
attr_dialog_add_item (state, this_page->page_name, this_page->icon_name,
this_page->page, this_page->parent_path);
}
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (state->store), ITEM_NAME, GTK_SORT_ASCENDING);
g_signal_connect (G_OBJECT (go_gtk_builder_get_widget (state->gui, "close_button")),
"clicked",
G_CALLBACK (cb_attr_dialog_dialog_close), state);
gnm_init_help_button (
go_gtk_builder_get_widget (state->gui, "help_button"),
GNUMERIC_HELP_LINK_WORKBOOK_ATTRIBUTE);
/* a candidate for merging into attach guru */
g_object_set_data_full (G_OBJECT (dialog),
"state", state, (GDestroyNotify) cb_attr_dialog_dialog_destroy);
wbc_gtk_attach_guru (state->wbcg, state->dialog);
gnm_keyed_dialog (state->wbcg, GTK_WINDOW (state->dialog),
WORKBOOK_ATTRIBUTE_KEY);
gtk_widget_show (state->dialog);
}
static pid_t
attach_process_show (AttachProcess * ap, GtkWindow *parent)
{
GtkTreeView *view;
GtkTreeStore *store;
GtkCellRenderer *renderer;
GtkTreeSelection *selection;
GtkCheckButton *checkb_hide_paths;
GtkCheckButton *checkb_hide_params;
GtkCheckButton *checkb_process_tree;
gint i, res;
pid_t selected_pid = -1;
g_return_val_if_fail (ap != NULL, -1);
if (!ap->dialog)
{
GtkBuilder *bxml;
bxml = anjuta_util_builder_new (GLADE_FILE, NULL);
if (!bxml) return 0;
anjuta_util_builder_get_objects (bxml,
"attach_process_dialog", &ap->dialog,
"attach_process_tv", &ap->treeview,
"checkb_hide_paths", &checkb_hide_paths,
"checkb_hide_params", &checkb_hide_params,
"checkb_process_tree", &checkb_process_tree,
NULL);
g_object_unref (bxml);
view = GTK_TREE_VIEW (ap->treeview);
store = gtk_tree_store_new (COLUMNS_NB,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING);
gtk_tree_view_set_model (view, GTK_TREE_MODEL (store));
gtk_tree_selection_set_mode (gtk_tree_view_get_selection (view),
GTK_SELECTION_SINGLE);
g_object_unref (G_OBJECT (store));
renderer = gtk_cell_renderer_text_new ();
for (i = PID_COLUMN; i < COLUMNS_NB; i++) {
GtkTreeViewColumn *column;
column = gtk_tree_view_column_new_with_attributes (column_names[i],
renderer, "text", i, NULL);
gtk_tree_view_column_set_sort_column_id(column, i);
gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_append_column (view, column);
if (i == COMMAND_COLUMN)
gtk_tree_view_set_expander_column(view, column);
}
gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (store), PID_COLUMN,
sort_pid, NULL, NULL);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (store),
START_COLUMN, GTK_SORT_DESCENDING);
ap->hide_paths = gtk_toggle_button_get_active (
GTK_TOGGLE_BUTTON (checkb_hide_paths));
ap->hide_params = gtk_toggle_button_get_active (
GTK_TOGGLE_BUTTON (checkb_hide_params));
ap->process_tree = gtk_toggle_button_get_active (
GTK_TOGGLE_BUTTON (checkb_process_tree));
attach_process_update (ap);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (ap->treeview));
g_signal_connect (G_OBJECT (selection), "changed",
G_CALLBACK (on_selection_changed), ap);
g_signal_connect (G_OBJECT (ap->dialog), "delete_event",
G_CALLBACK (on_delete_event), ap);
g_signal_connect (checkb_hide_paths, "toggled",
G_CALLBACK (on_toggle_hide_paths), ap);
g_signal_connect (checkb_hide_params, "toggled",
G_CALLBACK (on_toggle_hide_params), ap);
g_signal_connect (checkb_process_tree, "toggled",
G_CALLBACK (on_toggle_process_tree), ap);
}
gtk_window_set_transient_for (GTK_WINDOW (ap->dialog),
GTK_WINDOW (parent));
/* gtk_widget_show (ap->dialog); */
res = gtk_dialog_run (GTK_DIALOG (ap->dialog));
while (res == GTK_RESPONSE_APPLY)
{
attach_process_update (ap);
res = gtk_dialog_run (GTK_DIALOG (ap->dialog));
}
if (res == GTK_RESPONSE_OK)
{
selected_pid = ap->pid;
}
attach_process_clear (ap, CLEAR_FINAL);
return selected_pid;
}
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); */
}
static GtkWidget *bar_pane_keywords_new(const gchar *id, const gchar *title, const gchar *key, gboolean expanded)
{
PaneKeywordsData *pkd;
GtkWidget *hbox;
GtkWidget *scrolled;
GtkTextBuffer *buffer;
GtkTreeModel *store;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GtkTreeIter iter;
pkd = g_new0(PaneKeywordsData, 1);
pkd->pane.pane_set_fd = bar_pane_keywords_set_fd;
pkd->pane.pane_event = bar_pane_keywords_event;
pkd->pane.pane_write_config = bar_pane_keywords_write_config;
pkd->pane.title = bar_pane_expander_title(title);
pkd->pane.id = g_strdup(id);
pkd->pane.type = PANE_KEYWORDS;
pkd->pane.expanded = expanded;
pkd->key = g_strdup(key);
pkd->expand_checked = TRUE;
hbox = gtk_hbox_new(FALSE, PREF_PAD_GAP);
pkd->widget = hbox;
g_object_set_data(G_OBJECT(pkd->widget), "pane_data", pkd);
g_signal_connect(G_OBJECT(pkd->widget), "destroy",
G_CALLBACK(bar_pane_keywords_destroy), pkd);
gtk_widget_show(hbox);
scrolled = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start(GTK_BOX(hbox), scrolled, TRUE, TRUE, 0);
gtk_widget_show(scrolled);
pkd->keyword_view = gtk_text_view_new();
gtk_container_add(GTK_CONTAINER(scrolled), pkd->keyword_view);
g_signal_connect(G_OBJECT(pkd->keyword_view), "populate-popup",
G_CALLBACK(bar_pane_keywords_populate_popup_cb), pkd);
gtk_widget_show(pkd->keyword_view);
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(pkd->keyword_view));
g_signal_connect(G_OBJECT(buffer), "changed",
G_CALLBACK(bar_pane_keywords_changed), pkd);
scrolled = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start(GTK_BOX(hbox), scrolled, TRUE, TRUE, 0);
gtk_widget_show(scrolled);
if (!keyword_tree || !gtk_tree_model_get_iter_first(GTK_TREE_MODEL(keyword_tree), &iter))
{
/* keyword tree does not exist or is empty - fill with defaults */
keyword_tree_new_default();
}
store = gtk_tree_model_filter_new(GTK_TREE_MODEL(keyword_tree), NULL);
gtk_tree_model_filter_set_modify_func(GTK_TREE_MODEL_FILTER(store),
FILTER_KEYWORD_COLUMN_COUNT,
filter_keyword_column_types,
bar_pane_keywords_filter_modify,
pkd,
NULL);
gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(store),
bar_pane_keywords_filter_visible,
store,
NULL);
pkd->keyword_treeview = gtk_tree_view_new_with_model(store);
g_object_unref(store);
gtk_widget_set_size_request(pkd->keyword_treeview, -1, 400);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(pkd->keyword_treeview), FALSE);
// gtk_tree_view_set_search_column(GTK_TREE_VIEW(pkd->keyword_treeview), FILTER_KEYWORD_COLUMN_);
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_GROW_ONLY);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_add_attribute(column, renderer, "text", FILTER_KEYWORD_COLUMN_MARK);
gtk_tree_view_append_column(GTK_TREE_VIEW(pkd->keyword_treeview), column);
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
renderer = gtk_cell_renderer_toggle_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_add_attribute(column, renderer, "active", FILTER_KEYWORD_COLUMN_TOGGLE);
gtk_tree_view_column_add_attribute(column, renderer, "visible", FILTER_KEYWORD_COLUMN_IS_KEYWORD);
g_signal_connect(G_OBJECT(renderer), "toggled",
G_CALLBACK(bar_pane_keywords_keyword_toggle), pkd);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_add_attribute(column, renderer, "text", FILTER_KEYWORD_COLUMN_NAME);
gtk_tree_view_append_column(GTK_TREE_VIEW(pkd->keyword_treeview), column);
gtk_tree_view_set_expander_column(GTK_TREE_VIEW(pkd->keyword_treeview), column);
gtk_drag_source_set(pkd->keyword_treeview,
GDK_BUTTON1_MASK | GDK_BUTTON2_MASK,
bar_pane_keywords_drag_types, n_keywords_drag_types,
GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK);
g_signal_connect(G_OBJECT(pkd->keyword_treeview), "drag_data_get",
G_CALLBACK(bar_pane_keywords_dnd_get), pkd);
g_signal_connect(G_OBJECT(pkd->keyword_treeview), "drag_begin",
G_CALLBACK(bar_pane_keywords_dnd_begin), pkd);
g_signal_connect(G_OBJECT(pkd->keyword_treeview), "drag_end",
G_CALLBACK(bar_pane_keywords_dnd_end), pkd);
gtk_drag_dest_set(pkd->keyword_treeview,
GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_DROP,
bar_pane_keywords_drop_types, n_keywords_drop_types,
GDK_ACTION_COPY | GDK_ACTION_MOVE);
g_signal_connect(G_OBJECT(pkd->keyword_treeview), "drag_data_received",
G_CALLBACK(bar_pane_keywords_dnd_receive), pkd);
g_signal_connect(G_OBJECT(pkd->keyword_treeview), "drag_motion",
G_CALLBACK(bar_pane_keywords_dnd_motion), pkd);
g_signal_connect(G_OBJECT(pkd->keyword_treeview), "button_release_event",
G_CALLBACK(bar_pane_keywords_menu_cb), pkd);
gtk_container_add(GTK_CONTAINER(scrolled), pkd->keyword_treeview);
gtk_widget_show(pkd->keyword_treeview);
file_data_register_notify_func(bar_pane_keywords_notify_cb, pkd, NOTIFY_PRIORITY_LOW);
return pkd->widget;
}
static void
save_got_message(CamelFolder *folder, const char *uid, CamelMimeMessage *msg, void *d)
{
struct _save_data *data = d;
GtkDialog *dialog;
GtkWidget *w, *tree;
GtkTreeStore *model;
GtkCellRenderer *renderer;
/* not found, the mailer will show an error box for this */
if (msg == NULL) {
free_data(data);
return;
}
data->msg = msg;
camel_object_ref(msg);
dialog = (GtkDialog *)gtk_dialog_new_with_buttons(_("Save attachments"),
NULL, /* target->parent? */
0,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE, GTK_RESPONSE_OK,
NULL);
w = gtk_file_chooser_button_new (_("Select save base name"), GTK_FILE_CHOOSER_ACTION_OPEN);
data->entry = w;
g_object_set(w, "filechooser_action", GTK_FILE_CHOOSER_ACTION_SAVE, NULL);
gtk_widget_show(w);
gtk_box_pack_start((GtkBox *)dialog->vbox, w, FALSE, TRUE, 6);
g_signal_connect(GTK_FILE_CHOOSER_BUTTON (w), "selection-changed", G_CALLBACK(entry_changed), data);
model = gtk_tree_store_new(5, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER);
data->model = model;
fill_model(msg, model);
tree = gtk_tree_view_new_with_model((GtkTreeModel *)model);
data->tree = tree;
gtk_widget_show(tree);
gtk_tree_view_expand_all((GtkTreeView *)tree);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes((GtkTreeView *)tree, -1,
_("MIME Type"), renderer, "text", 1, NULL);
gtk_tree_view_set_expander_column((GtkTreeView *)tree, gtk_tree_view_get_column((GtkTreeView *)tree, 0));
renderer = gtk_cell_renderer_toggle_new();
g_object_set(renderer, "activatable", TRUE, NULL);
g_signal_connect(renderer, "toggled", G_CALLBACK(toggle_changed), data);
gtk_tree_view_insert_column_with_attributes((GtkTreeView *)tree, -1,
_("Save"), renderer, "active", 0, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes((GtkTreeView *)tree, -1,
_("Name"), renderer, "text", 2, NULL);
w = g_object_new(gtk_frame_get_type(),
"shadow_type", GTK_SHADOW_NONE,
"label_widget", g_object_new(gtk_label_get_type(),
"label", "<span weight=\"bold\">Attachments</span>",
"use_markup", TRUE,
"xalign", 0.0, NULL),
"child", g_object_new(gtk_alignment_get_type(),
"left_padding", 12,
"top_padding", 6,
"child", g_object_new(gtk_scrolled_window_get_type(),
"hscrollbar_policy", GTK_POLICY_AUTOMATIC,
"vscrollbar_policy", GTK_POLICY_AUTOMATIC,
"shadow_type", GTK_SHADOW_IN,
"child", tree,
NULL),
NULL),
NULL);
gtk_widget_show_all(w);
gtk_box_pack_start((GtkBox *)dialog->vbox, w, TRUE, TRUE, 0);
g_signal_connect(dialog, "response", G_CALLBACK(save_response), data);
gtk_window_set_default_size((GtkWindow *)dialog, 500, 500);
gtk_widget_show((GtkWidget *)dialog);
}
