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;
}
static GtkWidget *
glade_eprop_accel_view (GladeEditorProperty * eprop)
{
GladeEPropAccel *eprop_accel = GLADE_EPROP_ACCEL (eprop);
GtkWidget *view_widget;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
eprop_accel->model = (GtkTreeModel *)
gtk_tree_store_new (ACCEL_NUM_COLUMNS, G_TYPE_STRING, /* The GSignal name formatted for display */
G_TYPE_STRING, /* The GSignal name */
G_TYPE_STRING, /* The text to show in the accelerator cell */
G_TYPE_INT, /* PangoWeight attribute for bold headers */
G_TYPE_INT, /* PangoStyle attribute for italic grey unset items */
G_TYPE_STRING, /* Foreground colour for italic grey unset items */
G_TYPE_BOOLEAN, /* Visible attribute to hide items for header entries */
G_TYPE_BOOLEAN, /* Whether the key has been entered for this row */
G_TYPE_UINT, /* Hardware keycode */
G_TYPE_INT); /* GdkModifierType */
view_widget = gtk_tree_view_new_with_model (eprop_accel->model);
gtk_tree_view_set_show_expanders (GTK_TREE_VIEW (view_widget), FALSE);
gtk_tree_view_set_enable_search (GTK_TREE_VIEW (view_widget), FALSE);
/********************* signal name column *********************/
renderer = gtk_cell_renderer_text_new ();
g_object_set (G_OBJECT (renderer), "editable", FALSE, NULL);
column = gtk_tree_view_column_new_with_attributes
(_("Signal"), renderer,
"text", ACCEL_COLUMN_SIGNAL, "weight", ACCEL_COLUMN_WEIGHT, NULL);
gtk_tree_view_column_set_expand (GTK_TREE_VIEW_COLUMN (column), TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (view_widget), column);
/********************* accel editor column *********************/
renderer = gtk_cell_renderer_accel_new ();
g_object_set (G_OBJECT (renderer), "editable", TRUE, NULL);
g_signal_connect (renderer, "accel-edited", G_CALLBACK (accel_edited), eprop);
g_signal_connect (renderer, "accel-cleared",
G_CALLBACK (accel_cleared), eprop);
column = gtk_tree_view_column_new_with_attributes
(_("Accelerator Key"), renderer,
"text", ACCEL_COLUMN_TEXT,
"foreground", ACCEL_COLUMN_FOREGROUND,
"style", ACCEL_COLUMN_STYLE, "visible", ACCEL_COLUMN_VISIBLE, NULL);
gtk_tree_view_column_set_expand (GTK_TREE_VIEW_COLUMN (column), TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (view_widget), column);
return view_widget;
}
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
}
void
qtcTreeViewSetup(GtkWidget *widget)
{
QTC_DEF_WIDGET_PROPS(props, widget);
if (widget && !qtcWidgetProps(props)->treeViewHacked) {
QtCTreeView *tv = qtcTreeViewLookupHash(widget, true);
GtkTreeView *treeView = GTK_TREE_VIEW(widget);
GtkWidget *parent = gtk_widget_get_parent(widget);
if (tv) {
qtcWidgetProps(props)->treeViewHacked = true;
int x, y;
#if GTK_CHECK_VERSION(2, 90, 0) /* Gtk3:TODO !!! */
tv->fullWidth = true;
#else
gtk_widget_style_get(widget, "row_ending_details",
&tv->fullWidth, NULL);
#endif
gdk_window_get_pointer(gtk_widget_get_window(widget), &x, &y, 0L);
gtk_tree_view_convert_widget_to_bin_window_coords(treeView, x, y,
&x, &y);
qtcTreeViewUpdatePosition(widget, x, y);
qtcConnectToProp(props, treeViewDestroy, "destroy-event",
qtcTreeViewDestroy, NULL);
qtcConnectToProp(props, treeViewUnrealize, "unrealize",
qtcTreeViewDestroy, NULL);
qtcConnectToProp(props, treeViewStyleSet, "style-set",
qtcTreeViewStyleSet, NULL);
qtcConnectToProp(props, treeViewMotion, "motion-notify-event",
qtcTreeViewMotion, NULL);
qtcConnectToProp(props, treeViewLeave, "leave-notify-event",
qtcTreeViewLeave, NULL);
}
if (!gtk_tree_view_get_show_expanders(treeView))
gtk_tree_view_set_show_expanders(treeView, true);
if (gtk_tree_view_get_enable_tree_lines(treeView))
gtk_tree_view_set_enable_tree_lines(treeView, false);
if (GTK_IS_SCROLLED_WINDOW(parent) &&
gtk_scrolled_window_get_shadow_type(GTK_SCROLLED_WINDOW(parent)) !=
GTK_SHADOW_IN) {
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(parent),
GTK_SHADOW_IN);
}
}
}
static void
gedit_documents_panel_init (GeditDocumentsPanel *panel)
{
GtkWidget *sw;
GtkTreeViewColumn *column;
GtkCellRenderer *cell;
GtkTreeSelection *selection;
GIcon *icon;
gedit_debug (DEBUG_PANEL);
panel->priv = GEDIT_DOCUMENTS_PANEL_GET_PRIVATE (panel);
panel->priv->adding_tab = FALSE;
panel->priv->is_reodering = FALSE;
gtk_orientable_set_orientation (GTK_ORIENTABLE (panel),
GTK_ORIENTATION_VERTICAL);
/* Create the scrolled window */
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_widget_show (sw);
gtk_box_pack_start (GTK_BOX (panel), sw, TRUE, TRUE, 0);
/* Create the empty model */
panel->priv->model = GTK_TREE_MODEL (gtk_tree_store_new (N_COLUMNS,
GDK_TYPE_PIXBUF,
G_TYPE_STRING,
G_TYPE_OBJECT,
G_TYPE_OBJECT));
/* Create the treeview */
panel->priv->treeview = gtk_tree_view_new_with_model (panel->priv->model);
g_object_unref (G_OBJECT (panel->priv->model));
gtk_container_add (GTK_CONTAINER (sw), panel->priv->treeview);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (panel->priv->treeview), FALSE);
gtk_tree_view_set_reorderable (GTK_TREE_VIEW (panel->priv->treeview), FALSE); /* TODO */
gtk_tree_view_set_show_expanders (GTK_TREE_VIEW (panel->priv->treeview), FALSE);
gtk_tree_view_set_level_indentation (GTK_TREE_VIEW (panel->priv->treeview), 18);
/* Disable search because each time the selection is changed, the
active tab is changed which focuses the view, and thus would remove
the search entry, rendering it useless */
gtk_tree_view_set_enable_search (GTK_TREE_VIEW (panel->priv->treeview), FALSE);
/* Disable focus so it doesn't steal focus each time from the view */
gtk_widget_set_can_focus (panel->priv->treeview, FALSE);
gtk_widget_set_has_tooltip (panel->priv->treeview, TRUE);
gtk_widget_show (panel->priv->treeview);
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("Documents"));
cell = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (column, cell, FALSE);
gtk_tree_view_column_add_attribute (column, cell, "pixbuf", PIXBUF_COLUMN);
gtk_tree_view_column_set_cell_data_func (column, cell,
(GtkTreeCellDataFunc)pixbuf_data_func,
panel, NULL);
cell = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, cell, TRUE);
gtk_tree_view_column_add_attribute (column, cell, "markup", NAME_COLUMN);
gtk_tree_view_append_column (GTK_TREE_VIEW (panel->priv->treeview),
column);
cell = gedit_cell_renderer_button_new ();
icon = g_themed_icon_new_with_default_fallbacks ("window-close-symbolic");
g_object_set (cell, "gicon", icon, NULL);
g_object_unref (icon);
gtk_tree_view_column_pack_end (column, cell, FALSE);
g_signal_connect (cell,
"clicked",
G_CALLBACK (close_button_clicked),
panel);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (panel->priv->treeview));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
panel->priv->selection_changed_handler_id = g_signal_connect (selection,
"changed",
G_CALLBACK (treeview_selection_changed),
panel);
g_signal_connect (panel->priv->treeview,
"button-press-event",
G_CALLBACK (panel_button_press_event),
panel);
g_signal_connect (panel->priv->treeview,
"query-tooltip",
G_CALLBACK (treeview_query_tooltip),
panel);
/*
g_signal_connect (panel->priv->model,
"row-inserted",
G_CALLBACK (treeview_row_inserted),
panel);*/
}
/*
* inits stack trace tree
*/
GtkWidget* stree_init(move_to_line_cb cb)
{
callback = cb;
/* create tree view */
store = gtk_tree_store_new (
S_N_COLUMNS,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_INT,
G_TYPE_STRING,
G_TYPE_INT,
G_TYPE_INT);
model = GTK_TREE_MODEL(store);
tree = gtk_tree_view_new_with_model (GTK_TREE_MODEL(store));
/* set tree view properties */
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tree), 1);
gtk_widget_set_has_tooltip(tree, TRUE);
gtk_tree_view_set_show_expanders(GTK_TREE_VIEW(tree), FALSE);
/* connect signals */
selection_callback = g_signal_connect(G_OBJECT(gtk_tree_view_get_selection(GTK_TREE_VIEW(tree))), "changed", G_CALLBACK (on_selection_changed), NULL);
/* for clicking on already selected frame */
g_signal_connect(G_OBJECT(tree), "button-press-event", G_CALLBACK(on_msgwin_button_press), NULL);
g_signal_connect(G_OBJECT(tree), "query-tooltip", G_CALLBACK (on_query_tooltip), NULL);
/* creating columns */
GtkTreeViewColumn *column;
/* address */
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Address"));
GtkCellRenderer *renderer_arrow = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start(column, renderer_arrow, TRUE);
gtk_tree_view_column_set_cell_data_func(column, renderer_arrow, on_render_icon, NULL, NULL);
GtkCellRenderer *renderer_address = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start(column, renderer_address, TRUE);
gtk_tree_view_column_set_attributes(column, renderer_address, "text", S_ADRESS, NULL);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
/* function */
GtkCellRenderer *renderer_function = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (_("Function"), renderer_function, "text", S_FUNCTION, NULL);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
/* file */
GtkCellRenderer *renderer_file = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (_("File"), renderer_file, NULL);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
gtk_tree_view_column_set_cell_data_func(column, renderer_file, on_render_filename, NULL, NULL);
/* line */
GtkCellRenderer *renderer_line = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (_("Line"), renderer_line, "text", S_LINE, NULL);
gtk_tree_view_column_set_cell_data_func(column, renderer_line, on_render_line, NULL, NULL);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
/* Last invisible column */
GtkCellRenderer *renderer_last = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("", renderer_last, "text", S_LAST_VISIBLE, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
/* create threads hash table */
threads = g_hash_table_new_full(
g_direct_hash,
g_direct_equal,
NULL,
(GDestroyNotify)gtk_tree_row_reference_free
);
return tree;
}
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));
}
gpointer do_tree_store()
{
GtkWidget *window = __g_priv.window;
if (!window) {
GtkWidget *vbox, *tool_hbox, *grep_hbox;
GtkWidget *scan_button;
GtkWidget *grep_button;
GtkWidget *grep_entry;
GtkWidget *sw;
GtkWidget *treeview;
GtkTreeModel *model;
GtkTreeModel *filter;
/* create window, etc */
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_screen(GTK_WINDOW(window), gtk_widget_get_screen(NULL));
gtk_window_set_title(GTK_WINDOW(window), "list");
g_signal_connect(window, "destroy", G_CALLBACK(gtk_widget_destroyed), &window);
vbox = gtk_vbox_new(FALSE, 1);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 1);
gtk_container_add(GTK_CONTAINER(window), vbox);
tool_hbox = gtk_hbox_new(FALSE, 1);
gtk_container_set_border_width(GTK_CONTAINER(tool_hbox), 1);
gtk_box_pack_start(GTK_BOX(vbox), tool_hbox, FALSE, FALSE, 0);
scan_button = gtk_toggle_button_new_with_mnemonic("_Rescan");
gtk_box_pack_start(GTK_BOX(tool_hbox), scan_button, FALSE, FALSE, 0);
grep_button = gtk_toggle_button_new_with_mnemonic("_Search");
gtk_box_pack_end(GTK_BOX(tool_hbox), grep_button, FALSE, FALSE, 0);
grep_hbox = gtk_hbox_new(FALSE, 1);
gtk_container_set_border_width(GTK_CONTAINER(grep_hbox), 1);
gtk_box_pack_start(GTK_BOX(vbox), grep_hbox, FALSE, FALSE, 0);
grep_entry = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(grep_hbox), grep_entry, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(grep_button), "toggled", G_CALLBACK(cb_search_toggled), GTK_ENTRY(grep_entry));
sw = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw), GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start(GTK_BOX(vbox), sw, TRUE, TRUE, 0);
/* create model */
model = create_model();
gtk_tree_view_set_model(GTK_TREE_VIEW(treeview), GTK_TREE_MODEL(model));
/* Create filter and set visible function */
filter = gtk_tree_model_filter_new(model, NULL);
gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(filter), (GtkTreeModelFilterVisibleFunc)
filter_func, grep_entry, NULL);
/* Create treeview with model */
treeview = gtk_tree_view_new_with_model(filter);
fill_data(treeview, GTK_TREE_STORE(model));
g_signal_connect(G_OBJECT(grep_entry), "changed", G_CALLBACK(cb_entry_changed), GTK_TREE_VIEW(treeview));
g_object_unref(model);
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(treeview), TRUE);
gtk_tree_view_set_show_expanders(GTK_TREE_VIEW(treeview), TRUE);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview), FALSE);
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview)), GTK_SELECTION_SINGLE);
add_columns(GTK_TREE_VIEW(treeview));
gtk_container_add(GTK_CONTAINER(sw), treeview);
/* expand all rows after the treeview widget has been realized */
g_signal_connect(treeview, "realize", G_CALLBACK(gtk_tree_view_expand_all), NULL);
gtk_window_set_default_size(GTK_WINDOW(window), 650, 400);
/* set priv */
__g_priv.window = window;
__g_priv.treeview = treeview;
__g_priv.model = model;
__g_priv.filter = filter;
__g_priv.scan_button = scan_button;
__g_priv.grep_button = grep_button;
__g_priv.grep_entry = grep_entry;
}
if (!GTK_WIDGET_VISIBLE(window))
gtk_widget_show_all(window);
else {
gtk_widget_destroy(window);
window = NULL;
}
return (gpointer) & __g_priv;
}
static GtkWidget *create_tree(void)
{
GtkWidget *tree;
GtkTreeModel *model;
GtkTreeSelection *selection;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
tree = gtk_tree_view_new();
gtk_tree_view_set_show_expanders(GTK_TREE_VIEW(tree), FALSE);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tree), FALSE);
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tree), TRUE);
gtk_tree_view_set_grid_lines(GTK_TREE_VIEW(tree),
GTK_TREE_VIEW_GRID_LINES_NONE);
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_expand(column, TRUE);
gtk_tree_view_column_set_spacing(column, 6);
gtk_tree_view_column_set_min_width(column, 250);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_add_attribute(column, renderer,
"icon-name", CONNMAN_COLUMN_ICON);
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,
service_to_text, NULL, NULL);
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_cell_data_func(column, renderer,
security_to_icon, NULL, NULL);
renderer = gtk_cell_renderer_progress_new();
gtk_cell_renderer_set_fixed_size(renderer, 100, -1);
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_cell_data_func(column, renderer,
strength_to_value, NULL, NULL);
model = connman_client_get_model(client);
gtk_tree_view_set_model(GTK_TREE_VIEW(tree), model);
g_object_unref(model);
gtk_tree_view_set_search_column(GTK_TREE_VIEW(tree),
CONNMAN_COLUMN_NAME);
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
g_signal_connect(G_OBJECT(selection), "changed",
G_CALLBACK(select_callback), tree);
g_signal_connect(G_OBJECT(tree), "button-press-event",
G_CALLBACK(button_pressed), NULL);
g_signal_connect(G_OBJECT(tree), "popup-menu",
G_CALLBACK(popup_callback), NULL);
g_signal_connect(G_OBJECT(tree), "drag-drop",
G_CALLBACK(drag_drop), NULL);
g_signal_connect(G_OBJECT(tree), "drag-data-get",
G_CALLBACK(drag_data_get), selection);
g_signal_connect(G_OBJECT(tree), "drag-data-received",
G_CALLBACK(drag_data_received), model);
return tree;
}
static GtkWidget *
glade_eprop_attrs_view (GladeEditorProperty *eprop)
{
GladeEPropAttrs *eprop_attrs = GLADE_EPROP_ATTRS (eprop);
GtkWidget *view_widget;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkAdjustment *adjustment;
eprop_attrs->model = (GtkTreeModel *)
gtk_list_store_new (NUM_COLUMNS,
/* Main Data */
G_TYPE_STRING, // COLUMN_NAME
G_TYPE_INT, // COLUMN_NAME_WEIGHT
G_TYPE_INT, // COLUMN_TYPE
G_TYPE_INT, // COLUMN_EDIT_TYPE
G_TYPE_POINTER, // COLUMN_VALUE
G_TYPE_UINT, // COLUMN_START
G_TYPE_UINT, // COLUMN_END
/* Editor renderer related */
G_TYPE_BOOLEAN, // COLUMN_TOGGLE_ACTIVE
G_TYPE_BOOLEAN, // COLUMN_TOGGLE_DOWN
G_TYPE_BOOLEAN, // COLUMN_BUTTON_ACTIVE
G_TYPE_STRING, // COLUMN_TEXT
G_TYPE_INT, // COLUMN_TEXT_STYLE
G_TYPE_STRING, // COLUMN_TEXT_FG
G_TYPE_BOOLEAN, // COLUMN_COMBO_ACTIVE
GTK_TYPE_LIST_STORE, // COLUMN_COMBO_MODEL
G_TYPE_BOOLEAN, // COLUMN_SPIN_ACTIVE
G_TYPE_UINT); // COLUMN_SPIN_DIGITS
view_widget = gtk_tree_view_new_with_model (eprop_attrs->model);
gtk_tree_view_set_show_expanders (GTK_TREE_VIEW (view_widget), FALSE);
gtk_tree_view_set_enable_search (GTK_TREE_VIEW (view_widget), FALSE);
/********************* attribute name column *********************/
renderer = gtk_cell_renderer_text_new ();
g_object_set (G_OBJECT (renderer), "editable", FALSE, NULL);
column = gtk_tree_view_column_new_with_attributes
(_("Attribute"), renderer,
"text", COLUMN_NAME, "weight", COLUMN_NAME_WEIGHT, NULL);
gtk_tree_view_column_set_expand (GTK_TREE_VIEW_COLUMN (column), TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (view_widget), column);
/********************* attribute value column *********************/
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("Value"));
/* Toggle renderer */
renderer = gtk_cell_renderer_toggle_new ();
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_set_attributes (column, renderer,
"activatable", COLUMN_TOGGLE_ACTIVE,
"visible", COLUMN_TOGGLE_ACTIVE,
"active", COLUMN_TOGGLE_DOWN, NULL);
g_signal_connect (G_OBJECT (renderer), "toggled",
G_CALLBACK (value_toggled), eprop);
/* Text renderer */
renderer = gtk_cell_renderer_text_new ();
g_object_set (G_OBJECT (renderer), "editable", FALSE, NULL);
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_set_attributes (column, renderer,
"editable", COLUMN_BUTTON_ACTIVE,
"visible", COLUMN_BUTTON_ACTIVE,
"text", COLUMN_TEXT,
"style", COLUMN_TEXT_STYLE,
"foreground", COLUMN_TEXT_FG, NULL);
/* Icon renderer */
renderer = glade_cell_renderer_icon_new ();
g_object_set (G_OBJECT (renderer), "icon-name", GTK_STOCK_EDIT, NULL);
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_set_attributes (column, renderer,
"activatable", COLUMN_BUTTON_ACTIVE,
"visible", COLUMN_BUTTON_ACTIVE, NULL);
g_signal_connect (G_OBJECT (renderer), "activate",
G_CALLBACK (value_icon_activate), eprop);
/* Combo renderer */
renderer = gtk_cell_renderer_combo_new ();
g_object_set (G_OBJECT (renderer), "text-column", 0, "has-entry", FALSE,
NULL);
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_set_attributes (column, renderer,
"editable", COLUMN_COMBO_ACTIVE,
"visible", COLUMN_COMBO_ACTIVE,
"model", COLUMN_COMBO_MODEL,
"text", COLUMN_TEXT,
"style", COLUMN_TEXT_STYLE,
"foreground", COLUMN_TEXT_FG, NULL);
g_signal_connect (G_OBJECT (renderer), "edited",
G_CALLBACK (value_combo_spin_edited), eprop);
/* Spin renderer */
renderer = gtk_cell_renderer_spin_new ();
adjustment =
(GtkAdjustment *) gtk_adjustment_new (0, -G_MAXDOUBLE, G_MAXDOUBLE, 100,
100, 100);
g_object_set (G_OBJECT (renderer), "adjustment", adjustment, NULL);
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_set_attributes (column, renderer,
"visible", COLUMN_SPIN_ACTIVE,
"editable", COLUMN_SPIN_ACTIVE,
"text", COLUMN_TEXT,
"style", COLUMN_TEXT_STYLE,
"foreground", COLUMN_TEXT_FG,
"digits", COLUMN_SPIN_DIGITS, NULL);
g_signal_connect (G_OBJECT (renderer), "edited",
G_CALLBACK (value_combo_spin_edited), eprop);
g_signal_connect (G_OBJECT (renderer), "editing-started",
G_CALLBACK (value_combo_spin_editing_started), NULL);
gtk_tree_view_column_set_expand (GTK_TREE_VIEW_COLUMN (column), TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (view_widget), column);
return view_widget;
}
gint gui_contact_open_by_dial(const gchar *dial)
{
debug("gui_contact_open_by_dial\n");
store_contact_struct *contact=NULL;
store_contact_match(&contact,dial);
if(!contact)
return -1;
store_contact_load_details(contact);
GtkWidget *window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
if(contact->name)
gtk_window_set_title(GTK_WINDOW(window),contact->name);
else
gtk_window_set_title(GTK_WINDOW(window),"<Unknown>");
gtk_window_set_default_size(GTK_WINDOW(window),400,220);
GtkWidget *notebook=gtk_notebook_new();
GtkWidget *v1=gtk_vbox_new(FALSE,0);
GtkWidget *title_bar=gtk_hbox_new(FALSE,0);
GdkPixbuf *pixbuf=NULL;
if(contact->name==NULL && contact->picture==NULL)
pixbuf=utils_get_photo_unknown();
else if(contact->picture==NULL)
pixbuf=utils_get_photo_default();
else
pixbuf=utils_get_photo(contact->picture);
GtkWidget *picture=gtk_image_new_from_pixbuf(pixbuf);
GtkWidget *name;
if(contact->name){
name=gtk_label_new (contact->name);
}else{
name=gtk_label_new ("<Unknown>");
}
gtk_box_pack_start(GTK_BOX(title_bar), picture, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(title_bar), name, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(v1), title_bar, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(v1), gtk_hseparator_new(), FALSE, FALSE, 5);
GList *dials=contact->dials;
debug("Dials %p\n",dials);
while(dials){
gchar *dial=((store_dial_struct*)dials->data)->dial;
GtkWidget *label=gtk_label_new(dial);
GtkWidget *button_sms=gtk_button_new ();
GtkWidget *button_voice=gtk_button_new ();
GtkWidget *h_dial=gtk_hbox_new(FALSE,0);
GtkWidget *sms=gtk_image_new_from_pixbuf(utils_get_icon("sms.png"));
GtkWidget *voice=gtk_image_new_from_pixbuf(utils_get_icon("voice.png"));
g_signal_connect(G_OBJECT(button_sms),"clicked", G_CALLBACK(gui_contact_send_sms_callback),label);
g_signal_connect(G_OBJECT(button_voice),"clicked", G_CALLBACK(gui_contact_dial_callback),label);
gtk_container_add (GTK_CONTAINER(button_sms),sms);
gtk_container_add (GTK_CONTAINER(button_voice),voice);
gtk_misc_set_alignment(GTK_MISC(label),0,0.5);
debug("gui_contact_open_by_dial add dial %d\n",dial);
gtk_box_pack_start(GTK_BOX(h_dial), label, TRUE, TRUE, 20);
gtk_box_pack_start(GTK_BOX(h_dial), button_sms, FALSE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(h_dial), button_voice, FALSE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(v1), h_dial, FALSE, FALSE, 0);
dials=g_list_next(dials);
}
gtk_notebook_append_page(GTK_NOTEBOOK(notebook),v1,gtk_label_new("Details"));
// Call history
GtkWidget *scroll;
GtkWidget *calls_view = gtk_tree_view_new();
gtk_tree_view_set_show_expanders(GTK_TREE_VIEW(calls_view),TRUE);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(calls_view),TRUE);
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Dir", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_INTERACTION_DIRECTION, NULL);
gtk_tree_view_column_set_fixed_width(column,70);
gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Status", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_INTERACTION_CALL_STATUS, NULL);
gtk_tree_view_column_set_fixed_width(column,70);
gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column);
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
column = gtk_tree_view_column_new_with_attributes("Dial", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_DIAL, NULL);
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(calls_view), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Date", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_INTERACTION_DATE, NULL);
gtk_tree_view_column_set_fixed_width(column,80);
gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Duration", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_INTERACTION_CALL_DURACTION, NULL);
gtk_tree_view_column_set_fixed_width(column,70);
gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column);
gtk_tree_view_set_fixed_height_mode(GTK_TREE_VIEW(calls_view),TRUE);
scroll = gtk_scrolled_window_new(NULL,NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll),GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER(scroll),calls_view);
//g_signal_connect_after(G_OBJECT(g_gui_calls.dials_view),"cursor-changed", G_CALLBACK(gui_dialer_book_click_callback),NULL);
SphoneStoreTreeModel *calls;
if(contact->name!=NULL){ // known contact
gchar contactid[20];
sprintf(contactid,"%d",contact->id);
debug("SPHONE_STORE_TREE_MODEL_FILTER_CALLS_MATCH_CONTACT_ID query='%s'\n",contactid);
calls = sphone_store_tree_model_new(&SPHONE_STORE_TREE_MODEL_FILTER_CALLS_MATCH_CONTACT_ID, contactid);
}else{
gchar dialid[20];
sprintf(dialid,"%d",store_dial_get_id(dial));
debug("SPHONE_STORE_TREE_MODEL_FILTER_CALLS_MATCH_DIAL_ID query='%s'\n",dialid);
calls = sphone_store_tree_model_new(&SPHONE_STORE_TREE_MODEL_FILTER_CALLS_MATCH_DIAL_ID, dialid);
}
gtk_tree_view_set_model(GTK_TREE_VIEW(calls_view), GTK_TREE_MODEL(calls));
g_object_unref(G_OBJECT(calls));
gtk_notebook_append_page(GTK_NOTEBOOK(notebook),scroll,gtk_label_new("Calls"));
// SMS history
v1=gtk_vbox_new(FALSE,0);
calls_view = gtk_tree_view_new();
gtk_tree_view_set_show_expanders(GTK_TREE_VIEW(calls_view),TRUE);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(calls_view),TRUE);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Dir", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_INTERACTION_DIRECTION, NULL);
gtk_tree_view_column_set_fixed_width(column,70);
gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column);
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
column = gtk_tree_view_column_new_with_attributes("Dial", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_DIAL, NULL);
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(calls_view), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Date", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_INTERACTION_DATE, NULL);
gtk_tree_view_column_set_fixed_width(column,80);
gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column);
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
column = gtk_tree_view_column_new_with_attributes("Text", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_INTERACTION_SMS_TEXT, NULL);
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(calls_view), column);
gtk_tree_view_set_fixed_height_mode(GTK_TREE_VIEW(calls_view),TRUE);
scroll = gtk_scrolled_window_new(NULL,NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll),GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER(scroll),calls_view);
GtkWidget *sms_content=gtk_label_new (NULL);
gtk_label_set_selectable(GTK_LABEL(sms_content), TRUE);
gtk_label_set_line_wrap(GTK_LABEL(sms_content), TRUE);
g_signal_connect_after(G_OBJECT(calls_view),"cursor-changed", G_CALLBACK(gui_contact_sms_selected_callback),sms_content);
if(contact->name!=NULL){ // known contact
gchar contactid[20];
sprintf(contactid,"%d",contact->id);
debug("SPHONE_STORE_TREE_MODEL_FILTER_SMS_MATCH_CONTACT_ID query='%s'\n",contactid);
calls = sphone_store_tree_model_new(&SPHONE_STORE_TREE_MODEL_FILTER_SMS_MATCH_CONTACT_ID, contactid);
}else{
gchar dialid[20];
sprintf(dialid,"%d",store_dial_get_id(dial));
debug("SPHONE_STORE_TREE_MODEL_FILTER_SMS_MATCH_DIAL_ID query='%s'\n",dialid);
calls = sphone_store_tree_model_new(&SPHONE_STORE_TREE_MODEL_FILTER_SMS_MATCH_DIAL_ID, dialid);
}
gtk_tree_view_set_model(GTK_TREE_VIEW(calls_view), GTK_TREE_MODEL(calls));
g_object_unref(G_OBJECT(calls));
gtk_container_add (GTK_CONTAINER(v1),scroll);
gtk_container_add (GTK_CONTAINER(v1),sms_content);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook),v1,gtk_label_new("Messages"));
gtk_container_add(GTK_CONTAINER(window),notebook);
gtk_widget_show_all(window);
store_contact_free(contact);
return 0;
}
gint gui_history_sms(void)
{
SphoneStoreTreeModel *calls;
static GtkWidget *calls_view=NULL;
debug("gui_history_sms\n");
if(sms_window){
calls = sphone_store_tree_model_new(&SPHONE_STORE_TREE_MODEL_FILTER_SMS_ALL, NULL);
gtk_tree_view_set_model(GTK_TREE_VIEW(calls_view), GTK_TREE_MODEL(calls));
g_object_unref(G_OBJECT(calls));
gtk_window_present(GTK_WINDOW(sms_window));
return 0;
}
sms_window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(sms_window),"SMS History");
gtk_window_set_default_size(GTK_WINDOW(sms_window),600,220);
GtkWidget *v1=gtk_vbox_new(FALSE,0);
GtkWidget *scroll;
calls_view = gtk_tree_view_new();
gtk_tree_view_set_show_expanders(GTK_TREE_VIEW(calls_view),TRUE);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(calls_view),TRUE);
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
renderer = gtk_cell_renderer_pixbuf_new();
column = gtk_tree_view_column_new_with_attributes("", renderer, "pixbuf", SPHONE_STORE_TREE_MODEL_COLUMN_PICTURE, NULL);
gtk_tree_view_column_set_fixed_width(column,40);
gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Dir", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_INTERACTION_DIRECTION, NULL);
gtk_tree_view_column_set_fixed_width(column,70);
gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column);
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
column = gtk_tree_view_column_new_with_attributes("Name", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_NAME, NULL);
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(calls_view), column);
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
column = gtk_tree_view_column_new_with_attributes("Dial", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_DIAL, NULL);
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(calls_view), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Date", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_INTERACTION_DATE, NULL);
gtk_tree_view_column_set_fixed_width(column,80);
gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column);
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
column = gtk_tree_view_column_new_with_attributes("Text", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_INTERACTION_SMS_TEXT, NULL);
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(calls_view), column);
gtk_tree_view_set_fixed_height_mode(GTK_TREE_VIEW(calls_view),TRUE);
scroll = gtk_scrolled_window_new(NULL,NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll),GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
GtkWidget *sms_content=gtk_label_new (NULL);
gtk_label_set_selectable(GTK_LABEL(sms_content), TRUE);
gtk_label_set_line_wrap(GTK_LABEL(sms_content), TRUE);
g_signal_connect_after(G_OBJECT(calls_view),"cursor-changed", G_CALLBACK(gui_contact_sms_selected_callback),sms_content);
g_signal_connect_after(G_OBJECT(calls_view),"row-activated", G_CALLBACK(gui_contact_book_double_click_callback),NULL);
gtk_container_add (GTK_CONTAINER(scroll),calls_view);
gtk_container_add (GTK_CONTAINER(v1),scroll);
gtk_container_add (GTK_CONTAINER(v1),sms_content);
gtk_container_add (GTK_CONTAINER(sms_window),v1);
g_signal_connect(G_OBJECT(sms_window),"delete-event", G_CALLBACK(gui_contact_make_null),&sms_window);
calls = sphone_store_tree_model_new(&SPHONE_STORE_TREE_MODEL_FILTER_SMS_ALL, NULL);
gtk_tree_view_set_model(GTK_TREE_VIEW(calls_view), GTK_TREE_MODEL(calls));
g_object_unref(G_OBJECT(calls));
gtk_widget_show_all(sms_window);
return 0;
}
SeahorseKeyManagerStore*
seahorse_key_manager_store_new (GcrCollection *collection,
GtkTreeView *view,
SeahorsePredicate *pred,
GSettings *settings)
{
SeahorseKeyManagerStore *self;
GtkTreeViewColumn *col;
SeahorseCollection *filtered;
GtkCellRenderer *renderer;
gchar *sort_by;
guint last;
filtered = seahorse_collection_new_for_predicate (collection, pred, NULL);
pred->custom = on_filter_visible;
self = g_object_new (SEAHORSE_TYPE_KEY_MANAGER_STORE,
"collection", filtered,
"settings", settings,
"mode", GCR_COLLECTION_MODEL_LIST,
NULL);
pred->custom_target = self;
g_object_unref (filtered);
last = gcr_collection_model_set_columns (GCR_COLLECTION_MODEL (self), columns);
g_return_val_if_fail (last == N_COLS, NULL);
/* The sorted model is the top level model */
gtk_tree_view_set_model (view, GTK_TREE_MODEL (self));
/* add the icon column */
renderer = gtk_cell_renderer_pixbuf_new ();
g_object_set (renderer, "stock-size", GTK_ICON_SIZE_DND, NULL);
g_object_set (renderer, "ypad", 6, NULL);
g_object_set (renderer, "yalign", 0.0, NULL);
col = gtk_tree_view_column_new_with_attributes ("", renderer, "gicon", COL_ICON, NULL);
gtk_tree_view_column_set_resizable (col, FALSE);
gtk_tree_view_append_column (view, col);
/* Name column */
col = gtk_tree_view_column_new ();
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer,
"ypad", 6,
"yalign", 0.0,
"ellipsize", PANGO_ELLIPSIZE_END,
NULL);
gtk_tree_view_column_pack_start (col, renderer, TRUE);
gtk_tree_view_column_set_attributes (col, renderer,
"markup", COL_MARKUP,
NULL);
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer,
"ypad", 6,
"xpad", 3,
"yalign", 0.0,
"xalign", 1.0,
"scale", PANGO_SCALE_SMALL,
"alignment", PANGO_ALIGN_RIGHT,
NULL);
gtk_tree_view_column_pack_start (col, renderer, FALSE);
gtk_tree_view_column_set_attributes (col, renderer,
"markup", COL_DESCRIPTION,
NULL);
gtk_tree_view_column_set_resizable (col, TRUE);
gtk_tree_view_column_set_expand (col, TRUE);
gtk_tree_view_append_column (view, col);
gtk_tree_view_column_set_sort_column_id (col, COL_LABEL);
/* Use predicate to figure out which columns to add */
if (SEAHORSE_IS_COLLECTION (collection))
pred = seahorse_collection_get_predicate (SEAHORSE_COLLECTION (collection));
else
pred = NULL;
/* Also watch for sort-changed on the store */
g_signal_connect (self, "sort-column-changed", G_CALLBACK (on_sort_column_changed), self);
/* Update sort order in case the sorted column was added */
if ((sort_by = g_settings_get_string (settings, "sort-by")) != NULL) {
set_sort_to (self, sort_by);
g_free (sort_by);
}
gtk_tree_view_set_enable_search (view, FALSE);
gtk_tree_view_set_show_expanders (view, FALSE);
gtk_tree_view_set_rules_hint (view, TRUE);
gtk_tree_view_set_headers_visible (view, FALSE);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (self), COL_LABEL,
GTK_SORT_ASCENDING);
/* Tree drag */
egg_tree_multi_drag_add_drag_support (view);
g_signal_connect (G_OBJECT (view), "drag_data_get", G_CALLBACK (drag_data_get), self);
g_signal_connect (G_OBJECT (view), "drag_begin", G_CALLBACK (drag_begin), self);
g_signal_connect (G_OBJECT (view), "drag_end", G_CALLBACK (drag_end), self);
gtk_drag_source_set (GTK_WIDGET (view), GDK_BUTTON1_MASK,
store_targets, G_N_ELEMENTS (store_targets), GDK_ACTION_COPY);
return self;
}
static void
gb_book_links_construct (GbBookLinks *self)
{
GbBookLinksPrivate *priv;
GtkWidget *swindow;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GtkTreeSelection *selection;
priv = self->priv;
swindow = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (swindow),
GTK_SHADOW_IN);
/* Create tree view */
priv->tree_view = gtk_tree_view_new ();
gtk_tree_view_set_activate_on_single_click (GTK_TREE_VIEW (priv->tree_view), TRUE);
g_signal_connect_swapped (priv->tree_view, "row-activated",
G_CALLBACK (schedule_emit_link_activated), self);
gtk_tree_view_set_show_expanders (GTK_TREE_VIEW (priv->tree_view), FALSE);
gtk_tree_view_set_level_indentation (GTK_TREE_VIEW (priv->tree_view), 20);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->tree_view));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (priv->tree_view), FALSE);
gtk_container_add (GTK_CONTAINER (swindow), priv->tree_view);
gtk_box_pack_start (GTK_BOX (self), swindow, TRUE, TRUE, 0);
gtk_widget_show_all (GTK_WIDGET (self));
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 (priv->tree_view), column);
renderer = (GtkCellRenderer *)
g_object_new (GTK_TYPE_CELL_RENDERER_TEXT,
"ellipsize", PANGO_ELLIPSIZE_END,
"weight", PANGO_WEIGHT_BOLD,
"xpad", 10,
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", BOOK_LINKS_COLUMN_MARKUP,
NULL);
renderer = gd_styled_text_renderer_new ();
gd_styled_text_renderer_add_class (GD_STYLED_TEXT_RENDERER (renderer), "dim-label");
g_object_set (renderer,
"max-width-chars", 12,
"scale", PANGO_SCALE_SMALL,
"xalign", 1.0,
"xpad", 10,
NULL);
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", BOOK_LINKS_COLUMN_LABEL,
NULL);
*/
priv->model = (GtkTreeModel *)gtk_list_store_new (BOOK_LINKS_COLUMN_N,
G_TYPE_STRING,
G_TYPE_STRING);
}
static GtkWidget *create_right(void)
{
GtkWidget *mainbox;
GtkWidget *vbox;
GtkWidget *label;
GtkWidget *scrolled;
GtkWidget *tree;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
mainbox = gtk_vbox_new(FALSE, 24);
gtk_container_set_border_width(GTK_CONTAINER(mainbox), 8);
vbox = gtk_vbox_new(FALSE, 6);
gtk_box_pack_start(GTK_BOX(mainbox), vbox, TRUE, TRUE, 0);
label = create_label("Networks");
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
scrolled = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled),
GTK_SHADOW_OUT);
gtk_container_add(GTK_CONTAINER(vbox), scrolled);
tree = gtk_tree_view_new();
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tree), FALSE);
gtk_tree_view_set_show_expanders(GTK_TREE_VIEW(tree), FALSE);
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tree), TRUE);
gtk_container_add(GTK_CONTAINER(scrolled), tree);
gtk_tree_view_insert_column_with_data_func(GTK_TREE_VIEW(tree), 0,
NULL, gtk_cell_renderer_pixbuf_new(),
status_to_icon, NULL, NULL);
column = gtk_tree_view_get_column(GTK_TREE_VIEW(tree), 0);
gtk_tree_view_column_set_min_width(column, 24);
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(tree), column);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_add_attribute(column, renderer,
"text", CONNMAN_COLUMN_NAME);
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_end(column, renderer, FALSE);
gtk_tree_view_column_set_cell_data_func(column, renderer,
security_to_icon, NULL, NULL);
tree_networks = tree;
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
g_signal_connect(G_OBJECT(selection), "changed",
G_CALLBACK(select_callback), NULL);
return mainbox;
}
static void
tab_panel_app_add_browser_cb (MidoriApp* app,
MidoriBrowser* browser,
MidoriExtension* extension)
{
GtkTreeStore* model;
GtkWidget* treeview;
GtkTreeViewColumn* column;
GtkCellRenderer* renderer_pixbuf;
GtkCellRenderer* renderer_text;
GtkWidget* panel;
GtkWidget* toolbar;
gint i;
/* GtkToolItem* toolitem; */
g_object_set (browser, "show-tabs", FALSE, NULL);
panel = katze_object_get_object (browser, "panel");
model = gtk_tree_store_new (8, MIDORI_TYPE_VIEW,
G_TYPE_STRING, G_TYPE_BOOLEAN, GDK_TYPE_PIXBUF, G_TYPE_STRING,
G_TYPE_INT, GDK_TYPE_COLOR, GDK_TYPE_COLOR);
g_object_set_data (G_OBJECT (browser), "tab-panel-ext-model", model);
treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model));
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), FALSE);
gtk_tree_view_set_show_expanders (GTK_TREE_VIEW (treeview), FALSE);
g_signal_connect (treeview, "query-tooltip",
G_CALLBACK (tab_panel_treeview_query_tooltip_cb), NULL);
gtk_widget_set_has_tooltip (treeview, TRUE);
column = gtk_tree_view_column_new ();
renderer_pixbuf = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (column, renderer_pixbuf, FALSE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (column), renderer_pixbuf,
"pixbuf", 3, "cell-background-gdk", 6, NULL);
renderer_text = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, renderer_text, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (column), renderer_text,
"text", 4, "ellipsize", 5,
"cell-background-gdk", 6, "foreground-gdk", 7, NULL);
gtk_tree_view_column_set_expand (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
column = gtk_tree_view_column_new ();
renderer_pixbuf = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (column, renderer_pixbuf, FALSE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (column), renderer_pixbuf,
"stock-id", 1, "follow-state", 2,
"visible", 2, "cell-background-gdk", 6, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
g_object_connect (treeview,
"signal::row-activated",
midori_extension_row_activated_cb, extension,
"signal::cursor-changed",
midori_extension_cursor_or_row_changed_cb, extension,
"signal::columns-changed",
midori_extension_cursor_or_row_changed_cb, extension,
"signal::button-release-event",
midori_extension_button_release_event_cb, extension,
"signal::key-release-event",
midori_extension_key_release_event_cb, extension,
"signal::popup-menu",
midori_extension_popup_menu_cb, extension,
NULL);
gtk_widget_show (treeview);
toolbar = gtk_toolbar_new ();
g_object_set_data (G_OBJECT (browser), "tab-panel-ext-toolbar", toolbar);
gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_BOTH_HORIZ);
gtk_toolbar_set_icon_size (GTK_TOOLBAR (toolbar), GTK_ICON_SIZE_BUTTON);
gtk_widget_show (toolbar);
/*
TODO: Implement optional thumbnail images
toolitem = gtk_toggle_tool_button_new_from_stock (STOCK_IMAGE);
gtk_tool_item_set_is_important (toolitem, TRUE);
g_signal_connect (toolitem, "toggled",
G_CALLBACK (tab_panel_button_thumbnail_toggled_cb), notebook);
gtk_widget_show (GTK_WIDGET (toolitem));
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, -1); */
i = midori_panel_append_widget (MIDORI_PANEL (panel), treeview,
STOCK_TAB_PANEL, _("Tab Panel"), toolbar);
if (gtk_widget_get_visible (GTK_WIDGET (browser)))
midori_panel_set_current_page (MIDORI_PANEL (panel), i);
g_object_unref (panel);
midori_browser_foreach (browser,
(GtkCallback)tab_panel_browser_foreach_cb, treeview);
g_signal_connect_after (browser, "add-tab",
G_CALLBACK (tab_panel_browser_add_tab_cb), extension);
g_signal_connect (browser, "remove-tab",
G_CALLBACK (tab_panel_browser_remove_tab_cb), extension);
g_signal_connect (browser, "notify::tab",
G_CALLBACK (tab_panel_browser_notify_tab_cb), treeview);
g_signal_connect (extension, "deactivate",
G_CALLBACK (tab_panel_deactivate_cb), treeview);
g_signal_connect (browser, "move-tab",
G_CALLBACK (tab_panel_browser_move_tab_cb), NULL);
}
static GtkTreeView *
build_view (GladeEditorProperty * eprop)
{
GladeEPropIconSources *eprop_sources = GLADE_EPROP_ICON_SOURCES (eprop);
static GtkListStore *direction_store = NULL, *size_store =
NULL, *state_store = NULL;
GtkTreeView *view = (GtkTreeView *) gtk_tree_view_new ();
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
if (!direction_store)
{
direction_store =
glade_utils_liststore_from_enum_type (GTK_TYPE_TEXT_DIRECTION, FALSE);
size_store =
glade_utils_liststore_from_enum_type (GTK_TYPE_ICON_SIZE, FALSE);
state_store =
glade_utils_liststore_from_enum_type (GTK_TYPE_STATE_TYPE, FALSE);
}
/* Filename / icon name column/renderer */
renderer = gtk_cell_renderer_text_new ();
g_object_set (G_OBJECT (renderer), "editable", FALSE, NULL);
g_signal_connect (G_OBJECT (renderer), "edited",
G_CALLBACK (value_filename_edited), eprop);
eprop_sources->filename_column =
gtk_tree_view_column_new_with_attributes (_("File Name"), renderer,
"text", COLUMN_TEXT,
"weight", COLUMN_TEXT_WEIGHT,
"editable",
COLUMN_TEXT_EDITABLE, NULL);
gtk_tree_view_column_set_expand (eprop_sources->filename_column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (view),
eprop_sources->filename_column);
g_object_set_data (G_OBJECT (eprop_sources->filename_column), "column-id",
GINT_TO_POINTER (COLUMN_TEXT));
/********************* Size *********************/
/* Attribute active portion */
renderer = gtk_cell_renderer_toggle_new ();
g_object_set (G_OBJECT (renderer), "activatable", TRUE, NULL);
g_object_set_data (G_OBJECT (renderer), "attribute-column",
GINT_TO_POINTER (COLUMN_SIZE_ACTIVE));
g_signal_connect (G_OBJECT (renderer), "toggled",
G_CALLBACK (value_attribute_toggled), eprop);
column = gtk_tree_view_column_new_with_attributes
("dummy", renderer,
"visible", COLUMN_TEXT_EDITABLE, "active", COLUMN_SIZE_ACTIVE, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (view), column);
g_object_set_data (G_OBJECT (column), "column-id",
GINT_TO_POINTER (COLUMN_SIZE_ACTIVE));
/* Attribute portion */
renderer = gtk_cell_renderer_combo_new ();
g_object_set (G_OBJECT (renderer), "editable", TRUE, "has-entry", FALSE,
"text-column", 0, "model", size_store, NULL);
g_object_set_data (G_OBJECT (renderer), "attribute-column",
GINT_TO_POINTER (COLUMN_SIZE));
g_signal_connect (G_OBJECT (renderer), "edited",
G_CALLBACK (value_attribute_edited), eprop);
column = gtk_tree_view_column_new_with_attributes
("dummy", renderer,
"visible", COLUMN_TEXT_EDITABLE,
"editable", COLUMN_SIZE_ACTIVE, "text", COLUMN_SIZE, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (view), column);
g_object_set_data (G_OBJECT (column), "column-id",
GINT_TO_POINTER (COLUMN_SIZE));
/********************* State *********************/
/* Attribute active portion */
renderer = gtk_cell_renderer_toggle_new ();
g_object_set (G_OBJECT (renderer), "activatable", TRUE, NULL);
g_object_set_data (G_OBJECT (renderer), "attribute-column",
GINT_TO_POINTER (COLUMN_STATE_ACTIVE));
g_signal_connect (G_OBJECT (renderer), "toggled",
G_CALLBACK (value_attribute_toggled), eprop);
column = gtk_tree_view_column_new_with_attributes
("dummy", renderer,
"visible", COLUMN_TEXT_EDITABLE, "active", COLUMN_STATE_ACTIVE, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (view), column);
g_object_set_data (G_OBJECT (column), "column-id",
GINT_TO_POINTER (COLUMN_STATE_ACTIVE));
/* Attribute portion */
renderer = gtk_cell_renderer_combo_new ();
g_object_set (G_OBJECT (renderer), "editable", TRUE, "has-entry", FALSE,
"text-column", 0, "model", state_store, NULL);
g_object_set_data (G_OBJECT (renderer), "attribute-column",
GINT_TO_POINTER (COLUMN_STATE));
g_signal_connect (G_OBJECT (renderer), "edited",
G_CALLBACK (value_attribute_edited), eprop);
column = gtk_tree_view_column_new_with_attributes
("dummy", renderer,
"visible", COLUMN_TEXT_EDITABLE,
"editable", COLUMN_STATE_ACTIVE, "text", COLUMN_STATE, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (view), column);
g_object_set_data (G_OBJECT (column), "column-id",
GINT_TO_POINTER (COLUMN_STATE));
/********************* Direction *********************/
/* Attribute active portion */
renderer = gtk_cell_renderer_toggle_new ();
g_object_set (G_OBJECT (renderer), "activatable", TRUE, NULL);
g_object_set_data (G_OBJECT (renderer), "attribute-column",
GINT_TO_POINTER (COLUMN_DIRECTION_ACTIVE));
g_signal_connect (G_OBJECT (renderer), "toggled",
G_CALLBACK (value_attribute_toggled), eprop);
column = gtk_tree_view_column_new_with_attributes
("dummy", renderer,
"visible", COLUMN_TEXT_EDITABLE,
"active", COLUMN_DIRECTION_ACTIVE, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (view), column);
g_object_set_data (G_OBJECT (column), "column-id",
GINT_TO_POINTER (COLUMN_DIRECTION_ACTIVE));
/* Attribute portion */
renderer = gtk_cell_renderer_combo_new ();
g_object_set (G_OBJECT (renderer), "editable", TRUE, "has-entry", FALSE,
"text-column", 0, "model", direction_store, NULL);
g_object_set_data (G_OBJECT (renderer), "attribute-column",
GINT_TO_POINTER (COLUMN_DIRECTION));
g_signal_connect (G_OBJECT (renderer), "edited",
G_CALLBACK (value_attribute_edited), eprop);
column = gtk_tree_view_column_new_with_attributes
("dummy", renderer,
"visible", COLUMN_TEXT_EDITABLE,
"editable", COLUMN_DIRECTION_ACTIVE, "text", COLUMN_DIRECTION, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (view), column);
g_object_set_data (G_OBJECT (column), "column-id",
GINT_TO_POINTER (COLUMN_DIRECTION));
/* Connect ::query-tooltip here for fancy tooltips... */
g_object_set (G_OBJECT (view), "has-tooltip", TRUE, NULL);
g_signal_connect (G_OBJECT (view), "query-tooltip",
G_CALLBACK (icon_sources_query_tooltip), eprop);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (view), FALSE);
gtk_tree_view_set_show_expanders (GTK_TREE_VIEW (view), FALSE);
return view;
}
