/*
* Init entry view
* Called from create_book_page in page.c
*/
gboolean init_entry_view(GtkTreeView *entry_view, book_data *book)
{
GtkTreeViewColumn *view_col = NULL;
GtkCellRenderer *cell_rend = NULL;
GtkTreeSelection *selection = NULL;
// Create entry column
view_col = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(view_col, "Name");
gtk_tree_view_set_headers_visible(entry_view, FALSE);
gtk_tree_view_append_column(entry_view, view_col);
// Create entry cell_rend with get_entry_name callback
cell_rend = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(view_col, cell_rend, TRUE);
gtk_tree_view_column_set_cell_data_func
(view_col, cell_rend, get_entry_name, NULL, NULL);
// Set selection function
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(entry_view));
gtk_tree_selection_set_select_function
(selection, on_entry_selection, NULL, NULL);
// Set signal handlers
g_signal_connect(entry_view, "cursor-changed",
G_CALLBACK(on_entry_change), book);
g_signal_connect(entry_view, "key-press-event",
G_CALLBACK(on_entry_key_press), book);
return TRUE;
} // Init entry view
void world_tree_init(void)
{
GtkTreeViewColumn * col;
GtkCellRenderer * renderer;
GtkTreeSelection * selection;
g_world_tree_widget = get_gtk_builder_widget("world_tree");
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(g_world_tree_widget), FALSE);
col = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(col, _("Name"));
gtk_tree_view_append_column(GTK_TREE_VIEW(g_world_tree_widget), col);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(col, renderer, TRUE);
gtk_tree_view_column_add_attribute(col, renderer, "text", COL_NAME);
g_treestore = gtk_tree_store_new(
NUM_COLS,
G_TYPE_INT,
G_TYPE_STRING,
G_TYPE_POINTER,
G_TYPE_UINT64,
G_TYPE_BOOLEAN,
G_TYPE_BOOLEAN,
G_TYPE_STRING);
gtk_tree_view_set_model(GTK_TREE_VIEW(g_world_tree_widget), GTK_TREE_MODEL(g_treestore));
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(g_world_tree_widget));
gtk_tree_selection_set_select_function(selection, on_select, NULL, NULL);
g_signal_connect(g_world_tree_widget, "button-press-event", (GCallback)on_button_pressed, NULL);
g_signal_connect(g_world_tree_widget, "popup-menu", (GCallback)on_popup_menu, NULL);
g_signal_connect(g_world_tree_widget, "row-activated", (GCallback)on_row_activated, NULL);
}
static void
git_stash_pane_init (GitStashPane *self)
{
gchar *objects[] = {"stash_pane",
"stash_model",
NULL};
GError *error = NULL;
GtkTreeView *stash_view;
GtkTreeViewColumn *stash_number_column;
GtkCellRenderer *stash_number_renderer;
GtkTreeViewColumn *stash_message_column;
GtkCellRenderer *stash_message_renderer;
GtkCellRenderer *diff_renderer;
GtkTreeSelection *selection;
self->priv = g_new0 (GitStashPanePriv, 1);
self->priv->builder = gtk_builder_new ();
if (!gtk_builder_add_objects_from_file (self->priv->builder, BUILDER_FILE,
objects,
&error))
{
g_warning ("Couldn't load builder file: %s", error->message);
g_error_free (error);
}
stash_view = GTK_TREE_VIEW (gtk_builder_get_object (self->priv->builder,
"stash_view"));
stash_number_column = GTK_TREE_VIEW_COLUMN (gtk_builder_get_object (self->priv->builder,
"stash_number_column"));
stash_number_renderer = GTK_CELL_RENDERER (gtk_builder_get_object (self->priv->builder,
"stash_number_renderer"));
stash_message_column = GTK_TREE_VIEW_COLUMN (gtk_builder_get_object (self->priv->builder,
"stash_message_column"));
stash_message_renderer = GTK_CELL_RENDERER (gtk_builder_get_object (self->priv->builder,
"stash_message_renderer"));
diff_renderer = anjuta_cell_renderer_diff_new ();
selection = gtk_tree_view_get_selection (stash_view);
gtk_tree_view_column_set_cell_data_func (stash_number_column, stash_number_renderer,
stash_number_renderer_data_func,
NULL, NULL);
gtk_tree_view_column_set_cell_data_func (stash_message_column, stash_message_renderer,
stash_message_renderer_data_func,
NULL, NULL);
gtk_tree_view_column_pack_start (stash_message_column, diff_renderer, TRUE);
gtk_tree_view_column_add_attribute (stash_message_column, diff_renderer,
"diff", COL_DIFF);
/* Don't allow diffs to be selected */
gtk_tree_selection_set_select_function (selection, on_stash_view_row_selected,
NULL, NULL);
g_signal_connect (G_OBJECT (stash_view), "button-press-event",
G_CALLBACK (on_stash_view_button_press_event),
self);
}
ViewDir *vdtree_new(ViewDir *vd, FileData *dir_fd)
{
GtkTreeStore *store;
GtkTreeSelection *selection;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
vd->info = g_new0(ViewDirInfoTree, 1);
vd->type = DIRVIEW_TREE;
vd->dnd_drop_leave_func = vdtree_dnd_drop_expand_cancel;
vd->dnd_drop_update_func = vdtree_dnd_drop_expand;
store = gtk_tree_store_new(6, G_TYPE_POINTER, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING);
vd->view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
g_object_unref(store);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(vd->view), FALSE);
gtk_tree_view_set_enable_search(GTK_TREE_VIEW(vd->view), FALSE);
gtk_tree_sortable_set_default_sort_func(GTK_TREE_SORTABLE(store), vdtree_sort_cb, vd, NULL);
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(store),
GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, GTK_SORT_ASCENDING);
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(vd->view));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
gtk_tree_selection_set_select_function(selection, vdtree_select_cb, vd, NULL);
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_GROW_ONLY);
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_add_attribute(column, renderer, "pixbuf", DIR_COLUMN_ICON);
gtk_tree_view_column_set_cell_data_func(column, renderer, vd_color_cb, vd, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_add_attribute(column, renderer, "text", DIR_COLUMN_NAME);
gtk_tree_view_column_set_cell_data_func(column, renderer, vd_color_cb, vd, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(vd->view), column);
gtk_tree_view_set_tooltip_column(GTK_TREE_VIEW(vd->view), DIR_COLUMN_LINK);
vdtree_setup_root(vd);
g_signal_connect(G_OBJECT(vd->view), "row_expanded",
G_CALLBACK(vdtree_row_expanded), vd);
g_signal_connect(G_OBJECT(vd->view), "row_collapsed",
G_CALLBACK(vdtree_row_collapsed), vd);
return vd;
}
void
gnomegadu_ui_init_contacts_treeview ()
{
GtkTreeView *contacts_tree_view;
GtkCellRenderer *render_text, *render_pixbuf, *render_expander;
GtkTreeViewColumn *col;
contacts_tree_view = GTK_TREE_VIEW (glade_xml_get_widget (gladexml, "ContactsTreeView"));
g_object_set (contacts_tree_view, "show-expanders", FALSE, NULL);
col = gtk_tree_view_column_new ();
/* icon */
render_pixbuf = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (col, render_pixbuf, FALSE);
gtk_tree_view_column_set_cell_data_func (col, render_pixbuf,
(GtkTreeCellDataFunc) gnomegadu_contact_list_icon_cell_data_func,
contacts_tree_view, NULL);
gtk_tree_view_column_add_attribute (col, render_pixbuf, "pixbuf", UI_CONTACTS_COLUMN_ICON);
g_object_set (render_pixbuf, "xpad", 5, "ypad", 1, "visible", FALSE, NULL);
/* name */
render_text = gtk_cell_renderer_text_new ();
g_object_set (G_OBJECT (render_text), "editable", FALSE, NULL);
g_object_set (G_OBJECT (render_text), "wrap-width", 120, NULL);
gtk_tree_view_column_pack_start (col, render_text, TRUE);
gtk_tree_view_column_set_cell_data_func (col, render_text,
(GtkTreeCellDataFunc) gnomegadu_contact_list_name_cell_data_func,
contacts_tree_view, NULL);
gtk_tree_view_column_add_attribute (col, render_text, "markup", UI_CONTACTS_COLUMN_DISPLAYED);
/* expander */
render_expander = gossip_cell_renderer_expander_new ();
gtk_tree_view_column_pack_start (col, render_expander, FALSE);
gtk_tree_view_column_set_cell_data_func (col, render_expander,
(GtkTreeCellDataFunc) gnomegadu_contact_list_expander_cell_data_func,
contacts_tree_view, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (contacts_tree_view), col);
/* set selection */
GtkTreeSelection *selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (contacts_tree_view));
gtk_tree_selection_set_select_function (selection, gnomegadu_ui_contacts_selection_cb, NULL, NULL);
g_signal_connect (G_OBJECT (selection), "changed", (GCallback) gnomegadu_ui_selected_changed_cb, NULL);
/* D&D stuff */
// http://hoogervorst.dyndns.org/cgi-bin/darcs.cgi/sylpheed-claws-feb-20-2005/?c=diff&p=20041228213234-38e0e-e1cec3432277e1fb893b9edcdc556431f7a34617.gz
// g_signal_connect(G_OBJECT(contacts_tree_view), "drag_begin",G_CALLBACK(gnomegadu_contacts_drag_begin_cb),contacts_tree_view);
// g_signal_connect(G_OBJECT(contacts_tree_view), "drag_end",G_CALLBACK(gnomegadu_contacts_drag_end_cb),contacts_tree_view);
// g_signal_connect(G_OBJECT(contacts_tree_view), "drag_drop",G_CALLBACK(gnomegadu_contacts_drag_drop_cb),contacts_tree_view);
}
static GtkTreeStore* ctree_create(GtkWidget *widget)
{
GtkTreeView *view = GTK_TREE_VIEW(widget);
GtkTreeStore *store;
GtkTreeModel *model;
GtkCellRenderer *renderer;
GtkTreeSelection *selection;
gint i;
store = gtk_tree_store_new(CLIST_NCOLS,
G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_BOOLEAN, GDK_TYPE_COLOR, G_TYPE_STRING,
-1
);
model = GTK_TREE_MODEL(store);
gtk_tree_view_set_model(view, model);
gtk_tree_view_set_headers_visible(view, FALSE);
gtk_tree_view_set_rules_hint(view, TRUE);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes(view, -1,
"", renderer,
"text", COL_NAME,
"font", COL_FONT,
NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes(view, -1,
"", renderer,
"text", COL_VALUE,
"editable", COL_EDITABLE,
"foreground-gdk", COL_COLOR,
"font", COL_FONT,
NULL);
g_signal_connect(G_OBJECT(renderer), "edited",
G_CALLBACK(renderer_edited), widget);
for (i = 0; i < CLIST_NVCOLS; i++)
{
GtkTreeViewColumn *col;
col = gtk_tree_view_get_column(view, i);
//gtk_tree_view_column_set_resizable(col, TRUE);
}
selection = gtk_tree_view_get_selection(view);
gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
gtk_tree_selection_set_select_function(selection, select_func, NULL, NULL);
return store;
}
static void create_clist(GtkWidget * clist_wnd)
{
GtkTreeView *view = GTK_TREE_VIEW(clist_wnd);
GtkTreeModel *model;
GtkCellRenderer *renderer;
GtkTreeSelection *sel;
gint i;
list = gtk_list_store_new(COLUMN_NUMBER,
G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_POINTER, G_TYPE_POINTER, G_TYPE_INT);
model = GTK_TREE_MODEL(list);
gtk_tree_view_set_model(view, model);
gtk_tree_view_set_headers_visible(view, TRUE);
gtk_tree_view_set_headers_clickable(view, TRUE);
gtk_tree_view_set_rules_hint(view, FALSE);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes(view, -1,
_("Varname"),
renderer, "text",
COLUMN_VAR, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes(view, -1,
_("Attribute"),
renderer, "text",
COLUMN_ATTR, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes(view, -1,
_("Filename"),
renderer, "text",
COLUMN_FILE, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes(view, -1,
_("Action"),
renderer, "text",
COLUMN_ACTION, NULL);
for (i = 0; i < CLIST_NVCOLS - 1; i++)
{
GtkTreeViewColumn *col;
col = gtk_tree_view_get_column(view, i);
gtk_tree_view_column_set_resizable(col, TRUE);
}
sel = gtk_tree_view_get_selection(view);
gtk_tree_selection_set_mode(sel, GTK_SELECTION_MULTIPLE);
gtk_tree_selection_set_select_function(sel, select_function, NULL, NULL);
}
GtkWidget *
gal_view_new_dialog_construct (GalViewNewDialog *dialog,
GalViewCollection *collection)
{
GList *iterator;
GtkTreeSelection *selection;
GtkTreeViewColumn *column;
GtkCellRenderer *rend;
dialog->collection = collection;
dialog->list = e_builder_get_widget(dialog->builder,"list-type-list");
dialog->entry = e_builder_get_widget(dialog->builder, "entry-name");
dialog->list_store = gtk_list_store_new (2,
G_TYPE_STRING,
G_TYPE_POINTER);
rend = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("factory title",
rend,
"text", 0,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (dialog->list), column);
iterator = dialog->collection->factory_list;
for (; iterator; iterator = g_list_next (iterator) ) {
GalViewFactory *factory = iterator->data;
GtkTreeIter iter;
g_object_ref (factory);
gtk_list_store_append (dialog->list_store,
&iter);
gtk_list_store_set (dialog->list_store,
&iter,
0, gal_view_factory_get_title (factory),
1, factory,
-1);
}
gtk_tree_view_set_model (GTK_TREE_VIEW (dialog->list), GTK_TREE_MODEL (dialog->list_store));
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (dialog->list));
gtk_tree_selection_set_select_function (selection, selection_func, dialog, NULL);
g_signal_connect (dialog->entry, "changed",
G_CALLBACK (entry_changed), dialog);
sensitize_ok_response (dialog);
return GTK_WIDGET (dialog);
}
static void
uim_cand_win_vertical_gtk_init (UIMCandWinVerticalGtk *vertical_cwin)
{
UIMCandWinGtk *cwin;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkTreeSelection *selection;
cwin = UIM_CAND_WIN_GTK(vertical_cwin);
cwin->view = gtk_tree_view_new();
gtk_container_add(GTK_CONTAINER(cwin->scrolled_window), cwin->view);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(cwin->view));
gtk_tree_selection_set_select_function(selection,
tree_selection_change,
cwin,
NULL);
g_signal_connect (G_OBJECT(selection), "changed",
G_CALLBACK(tree_selection_changed), cwin);
renderer = gtk_cell_renderer_text_new();
g_object_set(renderer, "scale", 0.8, (const gchar *)NULL);
column = gtk_tree_view_column_new_with_attributes("No",
renderer,
"text", COLUMN_HEADING,
(const gchar *)NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(cwin->view), column);
gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
renderer = gtk_cell_renderer_text_new();
g_object_set(renderer, "scale", 1.2, (const gchar *)NULL);
/* g_object_set(renderer, "size-points", 20.0, NULL); */
column = gtk_tree_view_column_new_with_attributes("Text",
renderer,
"text", COLUMN_CANDIDATE,
(const gchar *)NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(cwin->view), column);
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(cwin->view), TRUE);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(cwin->view), FALSE);
gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
g_signal_connect(G_OBJECT(cwin->view), "button-press-event",
G_CALLBACK(tree_view_button_press), cwin);
gtk_widget_show(cwin->view);
}
static void
gtk_app_chooser_widget_init (GtkAppChooserWidget *self)
{
GtkTreeSelection *selection;
GtkTreeModel *sort;
GtkGesture *gesture;
self->priv = gtk_app_chooser_widget_get_instance_private (self);
gtk_widget_set_has_surface (GTK_WIDGET (self), FALSE);
gtk_widget_init_template (GTK_WIDGET (self));
/* Various parts of the GtkTreeView code need custom code to setup, mostly
* because we lack signals to connect to, or properties to set.
*/
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (self->priv->program_list));
gtk_tree_selection_set_select_function (selection, gtk_app_chooser_selection_func,
self, NULL);
sort = gtk_tree_view_get_model (GTK_TREE_VIEW (self->priv->program_list));
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort),
COLUMN_NAME,
GTK_SORT_ASCENDING);
gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (sort),
COLUMN_NAME,
gtk_app_chooser_sort_func,
self, NULL);
gtk_tree_view_set_search_column (GTK_TREE_VIEW (self->priv->program_list), COLUMN_NAME);
gtk_tree_view_set_search_equal_func (GTK_TREE_VIEW (self->priv->program_list),
gtk_app_chooser_search_equal_func,
NULL, NULL);
gtk_tree_view_column_set_cell_data_func (self->priv->column,
self->priv->secondary_padding,
padding_cell_renderer_func,
NULL, NULL);
self->priv->monitor = g_app_info_monitor_get ();
g_signal_connect (self->priv->monitor, "changed",
G_CALLBACK (app_info_changed), self);
gesture = gtk_gesture_multi_press_new ();
gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (gesture), GDK_BUTTON_SECONDARY);
g_signal_connect (gesture, "pressed",
G_CALLBACK (gtk_app_chooser_row_pressed_cb), self);
gtk_widget_add_controller (self->priv->program_list, GTK_EVENT_CONTROLLER (gesture));
}
static void rc_gui_list2_block_selection(GtkWidget *widget, gboolean block,
gint x, gint y)
{
static const gboolean which[] = {FALSE, TRUE};
gtk_tree_selection_set_select_function(rc_ui->list2_selection,
rc_gui_list2_mdrag_selection_block, (gboolean *)&which[!!block],
NULL);
gint *where = g_object_get_data(G_OBJECT(rc_ui->list2_tree_view),
"multidrag-where");
if(where==NULL)
{
where = g_new(gint, 2);
g_object_set_data_full(G_OBJECT(rc_ui->list2_tree_view),
"multidrag-where", where, g_free);
}
where[0] = x;
where[1] = y;
}
static GtkWidget *prefswindow_tree_view_create(PrefsWindow *prefswindow)
{
GtkTreeView *tree_view;
GtkTreeSelection *selector;
GtkTreeModel *model;
model = GTK_TREE_MODEL(prefswindow_create_data_store());
tree_view = GTK_TREE_VIEW(gtk_tree_view_new_with_model(model));
g_object_unref(model);
gtk_tree_view_set_rules_hint(tree_view, prefs_common.use_stripes_everywhere);
selector = gtk_tree_view_get_selection(tree_view);
gtk_tree_selection_set_mode(selector, GTK_SELECTION_BROWSE);
gtk_tree_selection_set_select_function(selector, prefswindow_row_selected,
prefswindow, NULL);
/* create the columns */
prefs_filtering_create_tree_view_columns(GTK_WIDGET(tree_view));
return GTK_WIDGET(tree_view);
}
static void
gtk_app_chooser_widget_init (GtkAppChooserWidget *self)
{
GtkWidget *scrolled_window;
GtkTreeSelection *selection;
self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, GTK_TYPE_APP_CHOOSER_WIDGET,
GtkAppChooserWidgetPrivate);
gtk_orientable_set_orientation (GTK_ORIENTABLE (self), GTK_ORIENTATION_VERTICAL);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_set_size_request (scrolled_window, 400, 300);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_SHADOW_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
gtk_widget_show (scrolled_window);
self->priv->program_list = gtk_tree_view_new ();
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (self->priv->program_list),
FALSE);
gtk_container_add (GTK_CONTAINER (scrolled_window), self->priv->program_list);
gtk_box_pack_start (GTK_BOX (self), scrolled_window, TRUE, TRUE, 0);
gtk_widget_show (self->priv->program_list);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (self->priv->program_list));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE);
gtk_tree_selection_set_select_function (selection, gtk_app_chooser_selection_func,
self, NULL);
g_signal_connect_swapped (selection, "changed",
G_CALLBACK (refresh_and_emit_app_selected),
self);
g_signal_connect (self->priv->program_list, "row-activated",
G_CALLBACK (program_list_selection_activated),
self);
g_signal_connect (self->priv->program_list, "button-press-event",
G_CALLBACK (widget_button_press_event_cb),
self);
}
void EntityList::populateWindow() {
// Create the treeview
_treeView = GTK_TREE_VIEW(gtk_tree_view_new());
gtk_tree_view_set_headers_visible(_treeView, FALSE);
gtk_tree_view_set_model(_treeView, _treeModel);
GtkTreeViewColumn* column = gtkutil::TextColumn(_("Name"), GraphTreeModel::COL_NAME);
gtk_tree_view_column_pack_start(column, gtk_cell_renderer_text_new(), TRUE);
_selection = gtk_tree_view_get_selection(_treeView);
gtk_tree_selection_set_mode(_selection, GTK_SELECTION_MULTIPLE);
gtk_tree_selection_set_select_function(_selection, onSelection, this, 0);
g_signal_connect(G_OBJECT(_treeView), "row-expanded", G_CALLBACK(onRowExpand), this);
gtk_tree_view_append_column (_treeView, column);
gtk_tree_view_column_set_sort_column_id(column, GraphTreeModel::COL_NAME);
gtk_tree_view_column_clicked(column);
// Create the toggle item
_focusOnSelectedEntityToggle = gtk_check_button_new_with_label(_("Focus camera on selected entity."));
// Update the toggle item status according to the registry
bool isActive = GlobalRegistry().get(RKEY_ENTITYLIST_FOCUS_SELECTION) == "1";
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(_focusOnSelectedEntityToggle), isActive);
// Connect the toggle button's "toggled" signal
g_signal_connect(G_OBJECT(_focusOnSelectedEntityToggle), "toggled", G_CALLBACK(onFocusSelectionToggle), this);
// Create a VBOX
GtkWidget* vbox = gtk_vbox_new(FALSE, 6);
gtk_box_pack_start(GTK_BOX(vbox), gtkutil::ScrolledFrame(GTK_WIDGET(_treeView)), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), _focusOnSelectedEntityToggle, FALSE, FALSE, 0);
// Pack the VBOX into the window
gtk_container_add(GTK_CONTAINER(getWindow()), vbox);
}
static GtkWidget *prefs_custom_header_list_view_create(void)
{
GtkTreeView *list_view;
GtkTreeSelection *selector;
GtkTreeModel *model;
model = GTK_TREE_MODEL(prefs_custom_header_create_data_store());
list_view = GTK_TREE_VIEW(gtk_tree_view_new_with_model(model));
g_object_unref(model);
gtk_tree_view_set_rules_hint(list_view, prefs_common.use_stripes_everywhere);
gtk_tree_view_set_reorderable(list_view, TRUE);
selector = gtk_tree_view_get_selection(list_view);
gtk_tree_selection_set_mode(selector, GTK_SELECTION_BROWSE);
gtk_tree_selection_set_select_function(selector, prefs_custom_header_selected,
NULL, NULL);
/* create the columns */
prefs_custom_header_create_list_view_columns(GTK_WIDGET(list_view));
return GTK_WIDGET(list_view);
}
JNIEXPORT void JNICALL
Java_gnu_java_awt_peer_gtk_GtkListPeer_connectSignals
(JNIEnv *env, jobject obj)
{
void *ptr;
jobject gref;
GtkWidget *list;
GtkTreeSelection *selection;
gdk_threads_enter ();
ptr = gtkpeer_get_widget (env, obj);
gref = gtkpeer_get_global_ref (env, obj);
list = list_get_widget (GTK_WIDGET (ptr));
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (list));
gtk_tree_selection_set_select_function (selection, item_highlighted_cb,
gref, NULL);
cp_gtk_component_connect_signals (G_OBJECT (list), gref);
gdk_threads_leave ();
}
static void
gimp_component_editor_init (GimpComponentEditor *editor)
{
GtkWidget *frame;
GtkListStore *list;
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (editor), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
list = gtk_list_store_new (NUM_COLUMNS,
G_TYPE_INT,
G_TYPE_BOOLEAN,
GIMP_TYPE_VIEW_RENDERER,
G_TYPE_STRING);
editor->model = GTK_TREE_MODEL (list);
editor->view = GTK_TREE_VIEW (gtk_tree_view_new_with_model (editor->model));
g_object_unref (list);
gtk_tree_view_set_headers_visible (editor->view, FALSE);
editor->eye_column = gtk_tree_view_column_new ();
gtk_tree_view_append_column (editor->view, editor->eye_column);
editor->eye_cell = gimp_cell_renderer_toggle_new (GIMP_STOCK_VISIBLE);
gtk_tree_view_column_pack_start (editor->eye_column, editor->eye_cell,
FALSE);
gtk_tree_view_column_set_attributes (editor->eye_column, editor->eye_cell,
"active", COLUMN_VISIBLE,
NULL);
g_signal_connect (editor->eye_cell, "clicked",
G_CALLBACK (gimp_component_editor_clicked),
editor);
editor->renderer_cell = gimp_cell_renderer_viewable_new ();
gtk_tree_view_insert_column_with_attributes (editor->view,
-1, NULL,
editor->renderer_cell,
"renderer", COLUMN_RENDERER,
NULL);
gtk_tree_view_insert_column_with_attributes (editor->view,
-1, NULL,
gtk_cell_renderer_text_new (),
"text", COLUMN_NAME,
NULL);
gtk_container_add (GTK_CONTAINER (frame), GTK_WIDGET (editor->view));
gtk_widget_show (GTK_WIDGET (editor->view));
g_signal_connect (editor->view, "button-press-event",
G_CALLBACK (gimp_component_editor_button_press),
editor);
editor->selection = gtk_tree_view_get_selection (editor->view);
gtk_tree_selection_set_mode (editor->selection, GTK_SELECTION_MULTIPLE);
gtk_tree_selection_set_select_function (editor->selection,
gimp_component_editor_select,
editor, NULL);
gimp_dnd_component_source_add (GTK_WIDGET (editor->view),
gimp_component_editor_drag_component,
editor);
}
/* Create a new dir tree view */
GtkWidget* ptk_dir_tree_view_new( PtkFileBrowser* browser,
gboolean show_hidden )
{
GtkTreeView * dir_tree_view;
GtkTreeViewColumn* col;
GtkCellRenderer* renderer;
GtkTreeModel* model;
GtkTreeSelection* tree_sel;
GtkTreePath* tree_path;
GtkTreeModel* filter;
dir_tree_view = GTK_TREE_VIEW( gtk_tree_view_new () );
gtk_tree_view_set_headers_visible( dir_tree_view, FALSE );
#if GTK_CHECK_VERSION(2, 10, 0)
gtk_tree_view_set_enable_tree_lines(dir_tree_view, TRUE);
#endif
/*
FIXME: Temporarily disable drag & drop since it doesn't work right now.
gtk_tree_view_enable_model_drag_dest ( dir_tree_view,
drag_targets,
sizeof( drag_targets ) / sizeof( GtkTargetEntry ),
GDK_ACTION_DEFAULT | GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK );
gtk_tree_view_enable_model_drag_source ( dir_tree_view,
( GDK_CONTROL_MASK | GDK_BUTTON1_MASK | GDK_BUTTON3_MASK ),
drag_targets,
sizeof( drag_targets ) / sizeof( GtkTargetEntry ),
GDK_ACTION_DEFAULT | GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK );
*/
col = gtk_tree_view_column_new ();
renderer = ( GtkCellRenderer* ) ptk_file_icon_renderer_new();
gtk_tree_view_column_pack_start( col, renderer, FALSE );
gtk_tree_view_column_set_attributes( col, renderer, "pixbuf", COL_DIR_TREE_ICON,
"info", COL_DIR_TREE_INFO, NULL );
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start( col, renderer, TRUE );
gtk_tree_view_column_set_attributes( col, renderer, "text", COL_DIR_TREE_DISP_NAME, NULL );
gtk_tree_view_append_column ( dir_tree_view, col );
tree_sel = gtk_tree_view_get_selection( dir_tree_view );
gtk_tree_selection_set_select_function( tree_sel, sel_func, NULL, NULL );
if ( G_UNLIKELY( !dir_tree_view_data ) )
dir_tree_view_data = g_quark_from_static_string( "show_hidden" );
g_object_set_qdata( G_OBJECT( dir_tree_view ),
dir_tree_view_data, ( gpointer ) show_hidden );
model = get_dir_tree_model();
filter = gtk_tree_model_filter_new( model, NULL );
g_object_unref( G_OBJECT( model ) );
gtk_tree_model_filter_set_visible_func( GTK_TREE_MODEL_FILTER( filter ),
filter_func, dir_tree_view, NULL );
gtk_tree_view_set_model( dir_tree_view, filter );
g_object_unref( G_OBJECT( filter ) );
g_signal_connect ( dir_tree_view, "row-expanded",
G_CALLBACK ( on_dir_tree_view_row_expanded ),
model );
g_signal_connect_data ( dir_tree_view, "row-collapsed",
G_CALLBACK ( on_dir_tree_view_row_collapsed ),
model, NULL, G_CONNECT_AFTER );
g_signal_connect ( dir_tree_view, "button-press-event",
G_CALLBACK ( on_dir_tree_view_button_press ),
browser );
g_signal_connect ( dir_tree_view, "key-press-event",
G_CALLBACK ( on_dir_tree_view_key_press ),
NULL );
tree_path = gtk_tree_path_new_first();
gtk_tree_view_expand_row( dir_tree_view, tree_path, FALSE );
gtk_tree_path_free( tree_path );
g_signal_connect( dir_tree_view, "destroy", G_CALLBACK(on_destroy), NULL );
return GTK_WIDGET( dir_tree_view );
}
void EntityList_DisconnectSignals(GtkTreeView* view)
{
GtkTreeSelection* select = gtk_tree_view_get_selection(view);
gtk_tree_selection_set_select_function(select, entitylist_tree_select_null, 0, 0);
}
GtkWidget *create_list_upcoming(void)
{
GtkListStore *store;
GtkWidget *view;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
DB( g_print ("\n[list_upcoming] create\n") );
/* create list store */
store = gtk_list_store_new(
NUM_LST_DSPUPC,
G_TYPE_POINTER,
G_TYPE_BOOLEAN, /* payee */
G_TYPE_STRING, /* memo */
G_TYPE_DOUBLE, /* expense */
G_TYPE_DOUBLE, /* income */
G_TYPE_POINTER, /* account */
G_TYPE_BOOLEAN, /* next on */
G_TYPE_INT, /* remaining */
G_TYPE_INT /* nb late */
);
//treeview
view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
g_object_unref(store);
gtk_tree_view_set_grid_lines (GTK_TREE_VIEW (view), PREFS->grid_lines);
//gtk_tree_view_set_search_column (GTK_TREE_VIEW (treeview),
// COLUMN_DESCRIPTION);
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(view)), GTK_SELECTION_SINGLE);
/* column : Late */
column = gtk_tree_view_column_new();
//TRANSLATORS: title of list column to inform the scheduled transaction is Late
gtk_tree_view_column_set_title(column, _("Late"));
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_set_cell_data_func(column, renderer, sched_lateicon_cell_data_function, NULL, NULL);
renderer = gtk_cell_renderer_text_new ();
g_object_set(renderer, "xalign", 1.0, NULL);
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_set_cell_data_func(column, renderer, sched_latetext_cell_data_function, NULL, NULL);
//gtk_tree_view_column_set_sort_column_id (column, LST_DSPUPC_NB_LATE);
gtk_tree_view_column_set_alignment (column, 0.5);
gtk_tree_view_append_column (GTK_TREE_VIEW(view), column);
/* column : Remaining */
/*column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("In"));
renderer = gtk_cell_renderer_text_new ();
g_object_set(renderer, "xalign", 1.0, NULL);
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_set_cell_data_func(column, renderer, remaining_cell_data_function, NULL, NULL);
//gtk_tree_view_column_set_sort_column_id (column, LST_DSPUPC_REMAINING);
gtk_tree_view_column_set_alignment (column, 0.5);
gtk_tree_view_append_column (GTK_TREE_VIEW(view), column);
*/
/* column: Next on */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Next date"));
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_set_cell_data_func(column, renderer, date_cell_data_function, NULL, NULL);
//gtk_tree_view_column_set_sort_column_id (column, LST_DSPUPC_DATE);
gtk_tree_view_column_set_alignment (column, 0.5);
gtk_tree_view_append_column (GTK_TREE_VIEW(view), column);
/* column: Payee */
renderer = gtk_cell_renderer_text_new ();
g_object_set(renderer,
"ellipsize", PANGO_ELLIPSIZE_END,
"ellipsize-set", TRUE,
NULL);
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Payee"));
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_set_cell_data_func(column, renderer, payee_cell_data_function, NULL, NULL);
gtk_tree_view_column_set_resizable(column, TRUE);
//gtk_tree_view_column_add_attribute(column, renderer, "text", 1);
//gtk_tree_view_column_set_sort_column_id (column, LST_DSPACC_NAME);
gtk_tree_view_column_set_alignment (column, 0.5);
gtk_tree_view_column_set_min_width(column, HB_MINWIDTH_LIST/2);
gtk_tree_view_append_column (GTK_TREE_VIEW(view), column);
gtk_tree_view_column_set_fixed_width(column, PREFS->pnl_upc_col_pay_width);
/* column: Memo */
renderer = gtk_cell_renderer_text_new ();
g_object_set(renderer,
"ellipsize", PANGO_ELLIPSIZE_END,
"ellipsize-set", TRUE,
NULL);
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Memo"));
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_set_cell_data_func(column, renderer, memo_cell_data_function, NULL, NULL);
gtk_tree_view_column_set_resizable(column, TRUE);
//gtk_tree_view_column_add_attribute(column, renderer, "text", 2);
//gtk_tree_view_column_set_sort_column_id (column, LST_DSPACC_NAME);
gtk_tree_view_column_set_alignment (column, 0.5);
gtk_tree_view_column_set_min_width(column, HB_MINWIDTH_LIST/2);
gtk_tree_view_append_column (GTK_TREE_VIEW(view), column);
gtk_tree_view_column_set_fixed_width(column, PREFS->pnl_upc_col_mem_width);
/* column: Amount */
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Expense"));
renderer = gtk_cell_renderer_text_new ();
g_object_set(renderer, "xalign", 1.0, NULL);
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_set_cell_data_func(column, renderer, amount_cell_data_function, GINT_TO_POINTER(-1), NULL);
//gtk_tree_view_column_set_sort_column_id (column, LST_DSPACC_NAME);
gtk_tree_view_column_set_alignment (column, 0.5);
gtk_tree_view_append_column (GTK_TREE_VIEW(view), column);
/* column: Amount */
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Income"));
renderer = gtk_cell_renderer_text_new ();
g_object_set(renderer, "xalign", 1.0, NULL);
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_set_cell_data_func(column, renderer, amount_cell_data_function, GINT_TO_POINTER(1), NULL);
//gtk_tree_view_column_set_sort_column_id (column, LST_DSPACC_NAME);
gtk_tree_view_column_set_alignment (column, 0.5);
gtk_tree_view_append_column (GTK_TREE_VIEW(view), column);
/* column: Account */
renderer = gtk_cell_renderer_text_new ();
/*g_object_set(renderer,
"ellipsize", PANGO_ELLIPSIZE_END,
"ellipsize-set", TRUE,
NULL);*/
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Account"));
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_set_cell_data_func(column, renderer, account_cell_data_function, NULL, NULL);
gtk_tree_view_column_set_resizable(column, TRUE);
//gtk_tree_view_column_set_sort_column_id (column, LST_DSPOPE_DATE);
gtk_tree_view_column_set_alignment (column, 0.5);
//gtk_tree_view_column_set_min_width(column, HB_MINWIDTH_LIST);
gtk_tree_view_append_column (GTK_TREE_VIEW(view), column);
/* column: empty */
column = gtk_tree_view_column_new();
gtk_tree_view_append_column (GTK_TREE_VIEW(view), column);
gtk_tree_selection_set_select_function(gtk_tree_view_get_selection(GTK_TREE_VIEW(view)), list_account_selectionfunc, NULL, NULL);
/* set initial sort order */
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(store), LST_DSPUPC_REMAINING, GTK_SORT_ASCENDING);
g_signal_connect (view, "destroy", G_CALLBACK (list_upcoming_destroy), NULL);
return(view);
}
/**
* gwy_grain_value_tree_view_new:
* @show_id: %TRUE to include grain id number among the values, %FALSE to
* exclude it.
* @first_column: The first column to show (may be %NULL for no columns).
* @...: %NULL-terminated list of columns to show.
*
* Creates a new tree view selector of grain values.
*
* Possible column names are <literal>"name"</literal> for the grain value
* name, <literal>"symbol_markup"</literal> for the rich text symbol,
* <literal>"symbol"</literal> for identifier-style symbol and
* <literal>"enabled"</literal> for a checkbox column.
*
* The tree view selection is set to %GTK_SELECTION_BROWSE mode and it is
* allowed only on leaves.
*
* Returns: A new tree view with grain values.
*
* Since: 2.8
**/
GtkWidget*
gwy_grain_value_tree_view_new(gboolean show_id,
const gchar *first_column,
...)
{
GrainValueViewPrivate *priv;
GtkTreeView *treeview;
GtkTreeSelection *selection;
GtkWidget *widget;
GtkTreeModel *model;
va_list ap;
model = gwy_grain_value_tree_model_new(show_id);
widget = gtk_tree_view_new_with_model(model);
treeview = GTK_TREE_VIEW(widget);
g_object_unref(model);
priv = g_new0(GrainValueViewPrivate, 1);
priv->same_units = TRUE;
g_object_set_qdata_full(G_OBJECT(treeview), priv_quark, priv, g_free);
va_start(ap, first_column);
while (first_column) {
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
gboolean expand;
const gchar *title;
column = gtk_tree_view_column_new();
expand = FALSE;
if (gwy_strequal(first_column, "name")) {
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, TRUE);
g_object_set(renderer,
"ellipsize-set", TRUE,
"weight-set", TRUE,
"foreground-set", TRUE,
NULL);
gtk_tree_view_column_set_cell_data_func(column, renderer,
render_name, treeview,
NULL);
title = _("Quantity");
expand = TRUE;
}
else if (gwy_strequal(first_column, "symbol_markup")) {
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,
render_symbol_markup,
treeview,
NULL);
title =_("Symbol");
}
else if (gwy_strequal(first_column, "symbol")) {
renderer = gtk_cell_renderer_text_new();
g_object_set(renderer,
"family", "monospace",
"family-set", TRUE,
"foreground-set", TRUE,
NULL);
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_set_cell_data_func(column, renderer,
render_symbol, NULL,
NULL);
title = _("Symbol");
}
else if (gwy_strequal(first_column, "enabled")) {
renderer = gtk_cell_renderer_toggle_new();
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_set_cell_data_func(column, renderer,
render_enabled, treeview,
NULL);
g_signal_connect(renderer, "toggled",
G_CALLBACK(enabled_activated), model);
title = _("Enabled");
}
else {
g_warning("Unknown column `%s'", first_column);
title = "Unknown";
}
gtk_tree_view_column_set_title(column, title);
gtk_tree_view_column_set_expand(column, expand);
gtk_tree_view_append_column(treeview, column);
first_column = va_arg(ap, const gchar*);
}
va_end(ap);
selection = gtk_tree_view_get_selection(treeview);
gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE);
gtk_tree_selection_set_select_function(selection,
selection_allowed, treeview, NULL);
gtk_tree_view_collapse_all(treeview);
return widget;
}
static void remmina_main_init(RemminaMain *remminamain)
{
RemminaMainPriv *priv;
GtkWidget *vbox;
GtkWidget *menubar;
GtkWidget *hbox;
GtkWidget *quickconnect;
GtkWidget *tool_item;
GtkUIManager *uimanager;
GtkActionGroup *action_group;
GtkWidget *scrolledwindow;
GtkWidget *tree;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GError *error;
priv = g_new0(RemminaMainPriv, 1);
remminamain->priv = priv;
remminamain->priv->expanded_group = remmina_string_array_new_from_string(remmina_pref.expanded_group);
/* Create main window */
g_signal_connect(G_OBJECT(remminamain), "delete-event", G_CALLBACK(remmina_main_on_delete_event), NULL);
g_signal_connect(G_OBJECT(remminamain), "destroy", G_CALLBACK(remmina_main_destroy), NULL);
g_signal_connect(G_OBJECT(remminamain), "window-state-event", G_CALLBACK(remmina_main_on_window_state_event), NULL);
gtk_container_set_border_width(GTK_CONTAINER(remminamain), 0);
gtk_window_set_title(GTK_WINDOW(remminamain), _("Remmina Remote Desktop Client"));
gtk_window_set_default_size(GTK_WINDOW(remminamain), remmina_pref.main_width, remmina_pref.main_height);
gtk_window_set_position(GTK_WINDOW(remminamain), GTK_WIN_POS_CENTER);
if (remmina_pref.main_maximize)
{
gtk_window_maximize(GTK_WINDOW(remminamain));
}
/* Create the main container */
#if GTK_VERSION == 3
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
#elif GTK_VERSION == 2
vbox = gtk_vbox_new(FALSE, 0);
#endif
gtk_container_add(GTK_CONTAINER(remminamain), vbox);
gtk_widget_show(vbox);
/* Create the menubar and toolbar */
uimanager = gtk_ui_manager_new();
priv->uimanager = uimanager;
action_group = gtk_action_group_new("RemminaMainActions");
gtk_action_group_set_translation_domain(action_group, NULL);
gtk_action_group_add_actions(action_group, remmina_main_ui_menu_entries, G_N_ELEMENTS(remmina_main_ui_menu_entries),
remminamain);
gtk_action_group_add_toggle_actions(action_group, remmina_main_ui_toggle_menu_entries,
G_N_ELEMENTS(remmina_main_ui_toggle_menu_entries), remminamain);
gtk_action_group_add_radio_actions(action_group, remmina_main_ui_view_file_mode_entries,
G_N_ELEMENTS(remmina_main_ui_view_file_mode_entries), remmina_pref.view_file_mode,
G_CALLBACK(remmina_main_action_view_file_mode), remminamain);
gtk_ui_manager_insert_action_group(uimanager, action_group, 0);
g_object_unref(action_group);
priv->main_group = action_group;
action_group = gtk_action_group_new("RemminaMainFileSensitiveActions");
gtk_action_group_set_translation_domain(action_group, NULL);
gtk_action_group_add_actions(action_group, remmina_main_ui_file_sensitive_menu_entries,
G_N_ELEMENTS(remmina_main_ui_file_sensitive_menu_entries), remminamain);
gtk_ui_manager_insert_action_group(uimanager, action_group, 0);
g_object_unref(action_group);
priv->file_sensitive_group = action_group;
error = NULL;
gtk_ui_manager_add_ui_from_string(uimanager, remmina_main_ui_xml, -1, &error);
if (error)
{
g_message("building menus failed: %s", error->message);
g_error_free(error);
}
remmina_plugin_manager_for_each_plugin(REMMINA_PLUGIN_TYPE_TOOL, remmina_main_add_tool_plugin, remminamain);
menubar = gtk_ui_manager_get_widget(uimanager, "/MenuBar");
gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 0);
priv->toolbar = gtk_ui_manager_get_widget(uimanager, "/ToolBar");
#if GTK_VERSION == 3
gtk_style_context_add_class(gtk_widget_get_style_context(priv->toolbar), GTK_STYLE_CLASS_PRIMARY_TOOLBAR);
#endif
gtk_box_pack_start(GTK_BOX(vbox), priv->toolbar, FALSE, FALSE, 0);
tool_item = gtk_ui_manager_get_widget(uimanager, "/ToolBar/ConnectionConnect");
gtk_tool_item_set_is_important (GTK_TOOL_ITEM(tool_item), TRUE);
tool_item = gtk_ui_manager_get_widget(uimanager, "/ToolBar/ConnectionNew");
gtk_tool_item_set_is_important (GTK_TOOL_ITEM(tool_item), TRUE);
remmina_main_create_quick_search(remminamain);
gtk_window_add_accel_group(GTK_WINDOW(remminamain), gtk_ui_manager_get_accel_group(uimanager));
gtk_action_group_set_sensitive(priv->file_sensitive_group, FALSE);
/* Add a Fast Connection box */
#if GTK_VERSION == 3
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
#elif GTK_VERSION == 2
hbox = gtk_hbox_new(FALSE, 0);
#endif
priv->quickconnect_protocol = gtk_combo_box_text_new();
#if GTK_VERSION == 3
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(priv->quickconnect_protocol), "RDP", "RDP");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(priv->quickconnect_protocol), "VNC", "VNC");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(priv->quickconnect_protocol), "NX", "NX");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(priv->quickconnect_protocol), "SSH", "SSH");
#elif GTK_VERSION == 2
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(priv->quickconnect_protocol), "RDP");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(priv->quickconnect_protocol), "VNC");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(priv->quickconnect_protocol), "NX");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(priv->quickconnect_protocol), "SSH");
#endif
gtk_combo_box_set_active(GTK_COMBO_BOX(priv->quickconnect_protocol), 0);
gtk_widget_show(priv->quickconnect_protocol);
gtk_box_pack_start(GTK_BOX(hbox), priv->quickconnect_protocol, FALSE, FALSE, 0);
priv->quickconnect_server = gtk_entry_new();
gtk_entry_set_width_chars(GTK_ENTRY(priv->quickconnect_server), 25);
gtk_widget_show(priv->quickconnect_server);
gtk_box_pack_start(GTK_BOX(hbox), priv->quickconnect_server, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(priv->quickconnect_server), "key-press-event", G_CALLBACK(remmina_main_quickconnect_on_key_press), remminamain);
quickconnect = gtk_button_new_with_label("Connect !");
gtk_widget_show(quickconnect);
gtk_box_pack_start(GTK_BOX(hbox), quickconnect, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(quickconnect), "clicked", G_CALLBACK(remmina_main_quickconnect_on_click), remminamain);
gtk_container_add(GTK_CONTAINER(vbox), hbox);
gtk_widget_show(hbox);
/* Create the scrolled window for the file list */
scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_show(scrolledwindow);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start(GTK_BOX(vbox), scrolledwindow, TRUE, TRUE, 0);
/* Create the remmina file list */
tree = gtk_tree_view_new();
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Name"));
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sort_column_id(column, NAME_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", PROTOCOL_COLUMN);
g_object_set(G_OBJECT(renderer), "stock-size", GTK_ICON_SIZE_LARGE_TOOLBAR, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_add_attribute(column, renderer, "text", NAME_COLUMN);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("Group"), renderer, "text", GROUP_COLUMN, NULL);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sort_column_id(column, GROUP_COLUMN);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
priv->group_column = column;
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("Server"), renderer, "text", SERVER_COLUMN, NULL);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sort_column_id(column, SERVER_COLUMN);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
gtk_container_add(GTK_CONTAINER(scrolledwindow), tree);
gtk_widget_show(tree);
gtk_tree_selection_set_select_function(gtk_tree_view_get_selection(GTK_TREE_VIEW(tree)), remmina_main_selection_func,
remminamain, NULL);
g_signal_connect(G_OBJECT(tree), "button-press-event", G_CALLBACK(remmina_main_file_list_on_button_press), remminamain);
g_signal_connect(G_OBJECT(tree), "key-press-event", G_CALLBACK(remmina_main_file_list_on_key_press), remminamain);
priv->file_list = tree;
/* Create statusbar */
priv->statusbar = gtk_statusbar_new();
gtk_box_pack_start(GTK_BOX(vbox), priv->statusbar, FALSE, FALSE, 0);
gtk_widget_show(priv->statusbar);
/* Prepare the data */
remmina_main_load_files(remminamain, FALSE);
/* Load the preferences */
if (remmina_pref.hide_toolbar)
{
gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(gtk_action_group_get_action(priv->main_group, "ViewToolbar")),
FALSE);
}
if (remmina_pref.hide_statusbar)
{
gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(gtk_action_group_get_action(priv->main_group, "ViewStatusbar")),
FALSE);
}
if (remmina_pref.show_quick_search)
{
gtk_toggle_action_set_active(
GTK_TOGGLE_ACTION(gtk_action_group_get_action(priv->main_group, "ViewQuickSearch")), TRUE);
}
if (remmina_pref.small_toolbutton)
{
gtk_toggle_action_set_active(
GTK_TOGGLE_ACTION(gtk_action_group_get_action(priv->main_group, "ViewSmallToolbutton")), TRUE);
}
/* Drag-n-drop support */
gtk_drag_dest_set(GTK_WIDGET(remminamain), GTK_DEST_DEFAULT_ALL, remmina_drop_types, 1, GDK_ACTION_COPY);
g_signal_connect(G_OBJECT(remminamain), "drag-data-received", G_CALLBACK(remmina_main_on_drag_data_received), NULL);
priv->initialized = TRUE;
remmina_widget_pool_register(GTK_WIDGET(remminamain));
}
static void report_gui_list_clicked(report_gui_t *rg)
{
report_gui_list_t *rgl = &(rg->list);
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GtkTreeSelection *selection;
int i;
if ( rgl->window == NULL ) {
rgl->window = create_report_list_window();
/* Create list display widget */
rgl->view = GTK_TREE_VIEW(lookup_widget(rgl->window, "report_list_view"));
rgl->model = gtk_list_store_new(REPORT_LIST_NCOLS,
/* Node Name */ G_TYPE_STRING,
/* Verdict */ GDK_TYPE_PIXBUF,
/* Verdict Value */ G_TYPE_INT,
/* Def. Crit. */ G_TYPE_STRING,
/* Def. Crit. Color */ G_TYPE_STRING,
/* Def. Crit. Value */ G_TYPE_INT,
/* Criticity */ G_TYPE_STRING,
/* Crit. Color */ G_TYPE_STRING,
/* Criticity Value */ G_TYPE_INT,
/* Key */ G_TYPE_ULONG);
rgl->model_sort = gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(rgl->model));
gtk_tree_view_set_model(rgl->view, rgl->model_sort);
/* Setup tree selection handler */
report_gui_list_select_clear(rgl);
selection = gtk_tree_view_get_selection(rgl->view);
gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
gtk_tree_selection_set_select_function(selection,
(GtkTreeSelectionFunc) report_gui_list_select, &(rg->list),
NULL);
/* Column #0: Test Case name */
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes(rgl->view, -1, "Test Case", renderer,
"text", REPORT_LIST_COL_NAME,
NULL);
column = gtk_tree_view_get_column(rgl->view, 0);
gtk_tree_view_column_set_clickable(column, TRUE);
gtk_tree_view_column_set_sort_column_id(column, REPORT_LIST_SORT_NAME);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_expand(column, TRUE);
/* Column #1: Default criticity */
renderer = gtk_cell_renderer_text_new();
gtk_object_set(GTK_OBJECT(renderer), "scale", 0.7, NULL);
gtk_tree_view_insert_column_with_attributes(rgl->view, -1, "Def. Criticity", renderer,
"text", REPORT_LIST_COL_CRITICITY_DEFAULT,
"foreground", REPORT_LIST_COL_CRITICITY_DEFAULT_COLOR,
NULL);
column = gtk_tree_view_get_column(rgl->view, 1);
gtk_tree_view_column_set_clickable(column, TRUE);
gtk_tree_view_column_set_sort_column_id(column, REPORT_LIST_SORT_CRITICITY);
gtk_tree_view_column_set_resizable(column, FALSE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
/* Column #2: 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", REPORT_LIST_COL_VERDICT);
renderer = gtk_cell_renderer_text_new();
gtk_object_set(GTK_OBJECT(renderer), "scale", 0.7, NULL);
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_add_attribute(column, renderer, "text", REPORT_LIST_COL_CRITICITY);
gtk_tree_view_column_add_attribute(column, renderer, "foreground", REPORT_LIST_COL_CRITICITY_COLOR);
gtk_tree_view_column_set_clickable(column, TRUE);
gtk_tree_view_column_set_sort_column_id(column, REPORT_LIST_SORT_VERDICT);
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(rgl->view, column);
/* Setup list sort functions */
for (i = 0; i < REPORT_LIST_NSORTS; i++)
gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(rgl->model_sort), i,
(GtkTreeIterCompareFunc) report_gui_list_sort, GINT_TO_POINTER(i),
NULL);
/* Setup spot buttons */
rgl->spot_tree = lookup_widget(rgl->window, "report_list_tree");
gtk_widget_set_sensitive(rgl->spot_tree, 0);
gtk_signal_connect_object(GTK_OBJECT(rgl->spot_tree),
"clicked", (GtkSignalFunc) report_gui_list_tree_clicked, rg);
rgl->spot_log = lookup_widget(rgl->window, "report_list_log");
gtk_widget_set_sensitive(rgl->spot_log, 0);
gtk_signal_connect_object(GTK_OBJECT(rgl->spot_log),
"clicked", (GtkSignalFunc) report_gui_list_log_clicked, rg);
/* Setup termination events */
gtk_signal_connect_object(GTK_OBJECT(rgl->window), "destroy",
(GtkSignalFunc) report_gui_list_destroyed, rg);
gtk_signal_connect_object(GTK_OBJECT(lookup_widget(rgl->window, "report_list_close")),
"clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT(rgl->window));
/* Feed the list */
report_gui_list_feed(rg);
gtk_widget_show(rgl->window);
gtk_tree_selection_unselect_all(selection);
}
else {
gtk_window_present(GTK_WINDOW(rgl->window));
}
}
static void create_bus_layout_dialog (bus_layout_D *dialog)
{
GtkWidget *tblMain = NULL, *frm = NULL, *img = NULL, *tbl = NULL, *align = NULL, *bbox = NULL ;
dialog->dialog = gtk_dialog_new () ;
gtk_window_set_title (GTK_WINDOW (dialog->dialog), _("Bus Layout")) ;
gtk_window_set_resizable (GTK_WINDOW (dialog->dialog), TRUE) ;
gtk_window_set_default_size (GTK_WINDOW (dialog->dialog), 300, 200) ;
tblMain = gtk_table_new (1, 2, FALSE) ;
gtk_widget_show (tblMain) ;
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog->dialog)->vbox), tblMain, TRUE, TRUE, 0) ;
gtk_container_set_border_width (GTK_CONTAINER (tblMain), 2) ;
frm = gtk_frame_new (_("Cells And Buses")) ;
gtk_widget_show (frm) ;
gtk_table_attach (GTK_TABLE (tblMain), frm, 0, 1, 0, 1,
(GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
(GtkAttachOptions)(GTK_EXPAND | GTK_FILL), 2, 2) ;
gtk_container_set_border_width (GTK_CONTAINER (frm), 2) ;
dialog->sw = gtk_scrolled_window_new (NULL, NULL) ;
gtk_widget_show (dialog->sw) ;
gtk_container_add (GTK_CONTAINER (frm), dialog->sw) ;
gtk_container_set_border_width (GTK_CONTAINER (dialog->sw), 2) ;
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (dialog->sw), GTK_SHADOW_IN) ;
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (dialog->sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC) ;
dialog->tview = create_bus_layout_tree_view (FALSE, NULL, GTK_SELECTION_MULTIPLE) ;
gtk_widget_show (dialog->tview) ;
gtk_container_add (GTK_CONTAINER (dialog->sw), dialog->tview) ;
gtk_tree_selection_set_select_function (gtk_tree_view_get_selection (GTK_TREE_VIEW (dialog->tview)),
(GtkTreeSelectionFunc)select_cell_row_p, NULL, NULL) ;
align = gtk_alignment_new (0.0, 0.0, 1.0, 1.0) ;
gtk_widget_show (align) ;
gtk_table_attach (GTK_TABLE (tblMain), align, 1, 2, 0, 1,
(GtkAttachOptions)(GTK_FILL),
(GtkAttachOptions)(GTK_FILL), 2, 2) ;
gtk_container_set_border_width (GTK_CONTAINER (align), 2) ;
tbl = gtk_table_new (3, 1, FALSE) ;
gtk_widget_show (tbl) ;
gtk_container_add (GTK_CONTAINER (align), tbl) ;
gtk_container_set_border_width (GTK_CONTAINER (tbl), 2) ;
bbox = gtk_vbutton_box_new () ;
gtk_widget_show (bbox) ;
gtk_table_attach (GTK_TABLE (tbl), bbox, 0, 1, 0, 1,
(GtkAttachOptions)(0),
(GtkAttachOptions)(0), 2, 2) ;
gtk_container_set_border_width (GTK_CONTAINER (bbox), 2) ;
// gtk_button_box_set_spacing (GTK_BUTTON_BOX (bbox), gtk_vbutton_box_get_spacing_default ()) ;
dialog->btnCreateBus = create_pixmap_button (img = gtk_image_new_from_stock (GTK_STOCK_ADD, GTK_ICON_SIZE_BUTTON), _("Create Bus"), FALSE) ;
gtk_widget_show (dialog->btnCreateBus) ;
gtk_widget_show (img) ;
gtk_box_pack_start (GTK_BOX (bbox), dialog->btnCreateBus, FALSE, TRUE, 0) ;
dialog->btnDeleteBus = create_pixmap_button (img = gtk_image_new_from_stock (GTK_STOCK_REMOVE, GTK_ICON_SIZE_BUTTON), _("Delete Bus"), FALSE) ;
gtk_widget_show (dialog->btnDeleteBus) ;
gtk_widget_show (img) ;
gtk_box_pack_start (GTK_BOX (bbox), dialog->btnDeleteBus, FALSE, TRUE, 0) ;
dialog->btnMoveBusUp = create_pixmap_button (img = gtk_image_new_from_stock (GTK_STOCK_GO_UP, GTK_ICON_SIZE_BUTTON), _("Move Bus Up"), FALSE) ;
gtk_widget_show (dialog->btnMoveBusUp) ;
gtk_widget_show (img) ;
gtk_box_pack_start (GTK_BOX (bbox), dialog->btnMoveBusUp, FALSE, TRUE, 0) ;
dialog->btnMoveBusDown = create_pixmap_button (img = gtk_image_new_from_stock (GTK_STOCK_GO_DOWN, GTK_ICON_SIZE_BUTTON), _("Move Bus Down"), FALSE) ;
gtk_widget_show (dialog->btnMoveBusDown) ;
gtk_widget_show (img) ;
gtk_box_pack_start (GTK_BOX (bbox), dialog->btnMoveBusDown, FALSE, TRUE, 0) ;
dialog->btnMoveCellsUp = create_pixmap_button (img = gtk_image_new_from_stock (GTK_STOCK_GO_UP, GTK_ICON_SIZE_BUTTON), _("Make Cell(s) More Significant"), FALSE) ;
gtk_widget_show (dialog->btnMoveCellsUp) ;
gtk_widget_show (img) ;
gtk_box_pack_start (GTK_BOX (bbox), dialog->btnMoveCellsUp, FALSE, TRUE, 0) ;
dialog->btnMoveCellsDown = create_pixmap_button (img = gtk_image_new_from_stock (GTK_STOCK_GO_DOWN, GTK_ICON_SIZE_BUTTON), _("Make Cell(s) Less Significant"), FALSE) ;
gtk_widget_show (dialog->btnMoveCellsDown) ;
gtk_widget_show (img) ;
gtk_box_pack_start (GTK_BOX (bbox), dialog->btnMoveCellsDown, FALSE, TRUE, 0) ;
dialog->lblBusName = gtk_label_new (_("Bus Name:")) ;
gtk_widget_show (dialog->lblBusName) ;
gtk_table_attach (GTK_TABLE (tbl), dialog->lblBusName, 0, 1, 1, 2,
(GtkAttachOptions)(GTK_FILL),
(GtkAttachOptions)(0), 2, 2) ;
gtk_label_set_justify (GTK_LABEL (dialog->lblBusName), GTK_JUSTIFY_LEFT) ;
gtk_misc_set_alignment (GTK_MISC (dialog->lblBusName), 0.0, 1.0) ;
dialog->txtBusName = g_object_new (GTK_TYPE_ENTRY, "text", _("Untitled Bus"), NULL) ;
gtk_widget_show (dialog->txtBusName) ;
gtk_table_attach (GTK_TABLE (tbl), dialog->txtBusName, 0, 1, 2, 3,
(GtkAttachOptions)(GTK_FILL),
(GtkAttachOptions)(0), 2, 2) ;
gtk_dialog_add_button (GTK_DIALOG (dialog->dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL) ;
gtk_dialog_add_button (GTK_DIALOG (dialog->dialog), GTK_STOCK_OK, GTK_RESPONSE_OK) ;
gtk_dialog_set_default_response (GTK_DIALOG (dialog->dialog), GTK_RESPONSE_OK) ;
g_signal_connect (G_OBJECT (gtk_tree_view_get_selection (GTK_TREE_VIEW (dialog->tview))), "changed", (GCallback)tree_view_selection_changed, dialog) ;
g_signal_connect (G_OBJECT (dialog->btnCreateBus), "clicked", (GCallback)create_bus_button_clicked, dialog) ;
g_signal_connect (G_OBJECT (dialog->btnDeleteBus), "clicked", (GCallback)delete_bus_button_clicked, dialog) ;
g_signal_connect (G_OBJECT (dialog->btnMoveCellsUp), "clicked", (GCallback)raise_bus_cell_position, dialog) ;
g_signal_connect (G_OBJECT (dialog->btnMoveCellsDown), "clicked", (GCallback)lower_bus_cell_position, dialog) ;
g_signal_connect (G_OBJECT (dialog->btnMoveBusUp), "clicked", (GCallback)raise_bus_position, dialog) ;
g_signal_connect (G_OBJECT (dialog->btnMoveBusDown), "clicked", (GCallback)lower_bus_position, dialog) ;
g_signal_connect (G_OBJECT (dialog->txtBusName), "changed", (GCallback)bus_name_changed, dialog) ;
g_signal_connect (G_OBJECT (dialog->txtBusName), "insert-text", (GCallback)entry_insert_text, dialog) ;
g_signal_connect (G_OBJECT (dialog->txtBusName), "delete-text", (GCallback)entry_delete_text, dialog) ;
}
static void
mate_volume_applet_preferences_init (MateVolumeAppletPreferences *prefs)
{
GtkWidget *box, *label, *view;
GtkListStore *store;
GtkTreeSelection *sel;
GtkTreeViewColumn *col;
GtkCellRenderer *render;
GList *cells;
prefs->applet = NULL;
prefs->mixer = NULL;
/* make window look cute */
gtk_window_set_title (GTK_WINDOW (prefs), _("Volume Control Preferences"));
gtk_dialog_set_has_separator (GTK_DIALOG (prefs), FALSE);
gtk_container_set_border_width (GTK_CONTAINER (prefs), 5);
gtk_box_set_spacing (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG(prefs))), 2);
gtk_dialog_add_buttons (GTK_DIALOG (prefs),
GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
/* help goes here (future) */
NULL);
/* add a treeview for all the properties */
box = gtk_vbox_new (FALSE, 6);
gtk_container_set_border_width (GTK_CONTAINER (box), 5);
label = gtk_label_new (_("Select the device and track to control."));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (box), label, FALSE, FALSE, 0);
gtk_widget_show (label);
/* optionmenu */
prefs->optionmenu = gtk_combo_box_new_text ();
cells = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (prefs->optionmenu));
g_object_set (G_OBJECT (cells->data), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
g_list_free (cells);
gtk_box_pack_start (GTK_BOX (box), prefs->optionmenu, FALSE, FALSE, 0);
gtk_widget_show (prefs->optionmenu);
g_signal_connect (prefs->optionmenu, "changed",
G_CALLBACK (cb_dev_selected), prefs);
store = gtk_list_store_new (NUM_COLS,
G_TYPE_STRING, G_TYPE_POINTER);
prefs->treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (prefs->treeview), FALSE);
/* viewport for lots of tracks */
view = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (view),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (view),
GTK_SHADOW_IN);
gtk_widget_set_size_request (view, -1, 100);
gtk_container_add (GTK_CONTAINER (view), prefs->treeview);
gtk_box_pack_start (GTK_BOX (box), view, TRUE, TRUE, 0);
gtk_widget_show (prefs->treeview);
gtk_widget_show (view);
/* treeview internals */
sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (prefs->treeview));
gtk_tree_selection_set_mode (sel, GTK_SELECTION_MULTIPLE);
gtk_tree_selection_set_select_function (sel, cb_track_select, prefs, NULL);
render = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes ("Track name", render,
"text", COL_LABEL,
NULL);
gtk_tree_view_column_set_clickable (col, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (prefs->treeview), col);
gtk_tree_view_set_search_column (GTK_TREE_VIEW (prefs->treeview), COL_LABEL);
/* and show */
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (prefs))), box,
TRUE, TRUE, 0);
gtk_widget_show (box);
}
void clist_init(void)
{
GtkTreeView *view = GTK_TREE_VIEW(clist_wnd);
GtkTreeModel *model = GTK_TREE_MODEL(list);
GtkCellRenderer *renderer;
GtkTreeSelection *selection;
gint i;
list = gtk_list_store_new(CLIST_NCOLS, GDK_TYPE_PIXBUF,
G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_POINTER
);
model = GTK_TREE_MODEL(list);
gtk_tree_view_set_model(view, model);
gtk_tree_view_set_headers_visible(view, TRUE);
gtk_tree_view_set_headers_clickable(view, TRUE);
gtk_tree_view_set_rules_hint(view, FALSE);
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_insert_column_with_attributes(view, -1, "",
renderer, "pixbuf",
COLUMN_ICON, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes(view, -1, _("Name"),
renderer, "text",
COLUMN_NAME, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes(view, -1, _("Type"),
renderer, "text",
COLUMN_TYPE, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes(view, -1, _("Size"),
renderer, "text",
COLUMN_SIZE, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes(view, -1, _("Date"),
renderer, "text",
COLUMN_DATE, NULL);
for (i = 0; i < CLIST_NVCOLS; i++)
{
GtkTreeViewColumn *col;
col = gtk_tree_view_get_column(view, i);
gtk_tree_view_column_set_resizable(col, TRUE);
gtk_tree_view_column_set_clickable(col, TRUE);
g_signal_connect(G_OBJECT(col), "clicked", G_CALLBACK(column_clicked), view);
}
selection = gtk_tree_view_get_selection(view);
gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
gtk_tree_selection_set_select_function(selection, select_func, NULL, NULL);
g_signal_connect(G_OBJECT(selection), "changed",
G_CALLBACK(tree_selection_changed), NULL);
}
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 gboolean
remmina_nx_session_manager_main (RemminaProtocolWidget *gp)
{
RemminaPluginNxData *gpdata;
RemminaFile *remminafile;
GtkWidget *dialog;
GtkWidget *widget;
gchar *s;
GtkWidget *scrolledwindow;
GtkWidget *tree;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
gpdata = (RemminaPluginNxData*) g_object_get_data (G_OBJECT (gp), "plugin-data");
remminafile = remmina_plugin_nx_service->protocol_plugin_get_file (gp);
if (!gpdata->manager_started)
{
remmina_plugin_nx_service->protocol_plugin_init_hide (gp);
dialog = gtk_dialog_new ();
s = g_strdup_printf (_("NX Sessions on %s"), remmina_plugin_nx_service->file_get_string (remminafile, "server"));
gtk_window_set_title (GTK_WINDOW (dialog), s);
g_free (s);
if (gpdata->attach_session)
{
gtk_dialog_add_button (GTK_DIALOG (dialog), _("Attach"), REMMINA_NX_EVENT_ATTACH);
}
else
{
gtk_dialog_add_button (GTK_DIALOG (dialog), _("Restore"), REMMINA_NX_EVENT_RESTORE);
gtk_dialog_add_button (GTK_DIALOG (dialog), _("Start"), REMMINA_NX_EVENT_START);
}
gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_CANCEL, REMMINA_NX_EVENT_CANCEL);
widget = gtk_dialog_add_button (GTK_DIALOG (dialog), _("Terminate"), REMMINA_NX_EVENT_TERMINATE);
gtk_button_box_set_child_secondary (GTK_BUTTON_BOX (gtk_dialog_get_action_area (GTK_DIALOG (dialog))),
widget, TRUE);
gtk_window_set_default_size (GTK_WINDOW (dialog), 640, 300);
gpdata->manager_dialog = dialog;
scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (scrolledwindow);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), scrolledwindow, TRUE, TRUE, 0);
tree = gtk_tree_view_new ();
gtk_container_add (GTK_CONTAINER (scrolledwindow), tree);
gtk_widget_show (tree);
remmina_nx_session_set_tree_view (gpdata->nx, GTK_TREE_VIEW (tree));
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("#",
renderer, "text", REMMINA_NX_SESSION_COLUMN_ID, NULL);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_column_set_sort_column_id (column, REMMINA_NX_SESSION_COLUMN_ID);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (_("Type"),
renderer, "text", REMMINA_NX_SESSION_COLUMN_TYPE, NULL);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_column_set_sort_column_id (column, REMMINA_NX_SESSION_COLUMN_TYPE);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (_("Display"),
renderer, "text", REMMINA_NX_SESSION_COLUMN_DISPLAY, NULL);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_column_set_sort_column_id (column, REMMINA_NX_SESSION_COLUMN_DISPLAY);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (_("Status"),
renderer, "text", REMMINA_NX_SESSION_COLUMN_STATUS, NULL);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_column_set_sort_column_id (column, REMMINA_NX_SESSION_COLUMN_STATUS);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (_("Name"),
renderer, "text", REMMINA_NX_SESSION_COLUMN_NAME, NULL);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_column_set_sort_column_id (column, REMMINA_NX_SESSION_COLUMN_NAME);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
gtk_tree_selection_set_select_function (
gtk_tree_view_get_selection (GTK_TREE_VIEW (tree)),
remmina_nx_session_manager_selection_func, gp, NULL);
g_signal_connect (G_OBJECT (dialog), "response", G_CALLBACK (remmina_nx_session_manager_on_response), gp);
gpdata->manager_started = TRUE;
}
gpdata->manager_selected = FALSE;
if (gpdata->manager_dialog)
{
remmina_nx_session_manager_set_sensitive (gp, FALSE);
gtk_widget_show (gpdata->manager_dialog);
}
if (remmina_nx_session_has_error (gpdata->nx))
{
dialog = gtk_message_dialog_new ((gpdata->manager_dialog ? GTK_WINDOW (gpdata->manager_dialog) : NULL),
GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "%s",
remmina_nx_session_get_error (gpdata->nx));
remmina_nx_session_clear_error (gpdata->nx);
gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
remmina_nx_session_manager_send_signal (gpdata, 0);
}
gpdata->session_manager_start_handler = 0;
return FALSE;
}
gboolean completion_create(GtkTreeModel *model, CompletionSelectFunc selfunc,
gboolean back)
{
GtkCellRenderer *renderer;
GtkTreeSelection *selection;
GtkTreeViewColumn *column;
GtkRequisition size;
GtkTreePath *path;
GtkTreeIter iter;
int height, width;
/* if there is only one match - don't build the tree view */
if (gtk_tree_model_iter_n_children(model, NULL) == 1) {
char *value;
path = gtk_tree_path_new_from_indices(0, -1);
if (gtk_tree_model_get_iter(model, &iter, path)) {
gtk_tree_model_get(model, &iter, COMPLETION_STORE_FIRST, &value, -1);
/* call the select function */
selfunc(value);
g_free(value);
g_object_unref(model);
return false;
}
}
comp.selfunc = selfunc;
/* prepare the tree view */
comp.win = gtk_scrolled_window_new(NULL, NULL);
comp.tree = gtk_tree_view_new();
#ifndef HAS_GTK3
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(comp.win), GTK_POLICY_NEVER, GTK_POLICY_NEVER);
#endif
gtk_box_pack_end(GTK_BOX(vb.gui.box), comp.win, false, false, 0);
gtk_container_add(GTK_CONTAINER(comp.win), comp.tree);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(comp.tree), false);
/* we have only on line per item so we can use the faster fixed heigh mode */
gtk_tree_view_set_fixed_height_mode(GTK_TREE_VIEW(comp.tree), true);
gtk_tree_view_set_model(GTK_TREE_VIEW(comp.tree), model);
g_object_unref(model);
VB_WIDGET_OVERRIDE_TEXT(comp.tree, VB_GTK_STATE_NORMAL, &vb.style.comp_fg[VB_COMP_NORMAL]);
VB_WIDGET_OVERRIDE_BASE(comp.tree, VB_GTK_STATE_NORMAL, &vb.style.comp_bg[VB_COMP_NORMAL]);
VB_WIDGET_OVERRIDE_TEXT(comp.tree, VB_GTK_STATE_SELECTED, &vb.style.comp_fg[VB_COMP_ACTIVE]);
VB_WIDGET_OVERRIDE_BASE(comp.tree, VB_GTK_STATE_SELECTED, &vb.style.comp_bg[VB_COMP_ACTIVE]);
VB_WIDGET_OVERRIDE_TEXT(comp.tree, VB_GTK_STATE_ACTIVE, &vb.style.comp_fg[VB_COMP_ACTIVE]);
VB_WIDGET_OVERRIDE_BASE(comp.tree, VB_GTK_STATE_ACTIVE, &vb.style.comp_bg[VB_COMP_ACTIVE]);
/* prepare the selection */
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(comp.tree));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE);
gtk_tree_selection_set_select_function(selection, tree_selection_func, NULL, NULL);
/* get window dimension */
gtk_window_get_size(GTK_WINDOW(vb.gui.window), &width, &height);
/* prepare first column */
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column(GTK_TREE_VIEW(comp.tree), column);
renderer = gtk_cell_renderer_text_new();
g_object_set(renderer,
"font-desc", vb.style.comp_font,
"ellipsize", PANGO_ELLIPSIZE_MIDDLE,
NULL
);
gtk_tree_view_column_pack_start(column, renderer, true);
gtk_tree_view_column_add_attribute(column, renderer, "text", COMPLETION_STORE_FIRST);
gtk_tree_view_column_set_min_width(column, 2 * width/3);
/* prepare second column */
#ifdef FEATURE_TITLE_IN_COMPLETION
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column(GTK_TREE_VIEW(comp.tree), column);
renderer = gtk_cell_renderer_text_new();
g_object_set(renderer,
"font-desc", vb.style.comp_font,
"ellipsize", PANGO_ELLIPSIZE_END,
NULL
);
gtk_tree_view_column_pack_start(column, renderer, true);
gtk_tree_view_column_add_attribute(column, renderer, "text", COMPLETION_STORE_SECOND);
#endif
/* to set the height for the treeview the tree must be realized first */
gtk_widget_show(comp.tree);
/* this prevents the first item to be placed out of view if the completion
* is shown */
while (gtk_events_pending()) {
gtk_main_iteration();
}
/* use max 1/3 of window height for the completion */
#ifdef HAS_GTK3
gtk_widget_get_preferred_size(comp.tree, NULL, &size);
height /= 3;
gtk_scrolled_window_set_min_content_height(
GTK_SCROLLED_WINDOW(comp.win),
size.height > height ? height : size.height
);
#else
gtk_widget_size_request(comp.tree, &size);
height /= 3;
if (size.height > height) {
gtk_widget_set_size_request(comp.win, -1, height);
}
#endif
vb.mode->flags |= FLAG_COMPLETION;
/* set to -1 to have the cursor on first or last item set in move_cursor */
comp.active = -1;
completion_next(back);
gtk_widget_show(comp.win);
return true;
}
/*!
* Fill the GUI tree with the styles as defined in the XP tree.
*/
void AP_UnixDialog_Stylist::_fillTree(void)
{
Stylist_tree * pStyleTree = getStyleTree();
if(pStyleTree == NULL)
{
updateDialog();
pStyleTree = getStyleTree();
}
if(pStyleTree->getNumRows() == 0)
{
updateDialog();
pStyleTree = getStyleTree();
}
UT_DEBUGMSG(("Number of rows of styles in document %d \n",pStyleTree->getNumRows()));
if(m_wRenderer)
{
// g_object_unref (G_OBJECT (m_wRenderer));
gtk_widget_destroy (m_wStyleList);
}
GtkTreeIter iter;
GtkTreeIter child_iter;
GtkTreeSelection *sel;
UT_sint32 row,col, page;
m_wModel = gtk_tree_store_new (3, G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT);
page = 0;
UT_UTF8String sTmp("");
for(row= 0; row < pStyleTree->getNumRows();row++)
{
gtk_tree_store_append (m_wModel, &iter, NULL);
if(!pStyleTree->getNameOfRow(sTmp,row))
{
UT_ASSERT(UT_SHOULD_NOT_HAPPEN);
break;
}
if(pStyleTree->getNumCols(row) > 0)
{
xxx_UT_DEBUGMSG(("Adding Heading %s at row %d \n",sTmp.utf8_str(),row));
gtk_tree_store_set (m_wModel, &iter, 0, sTmp.utf8_str(), 1, row,2,0, -1);
for(col =0 ; col < pStyleTree->getNumCols(row); col++)
{
gtk_tree_store_append (m_wModel, &child_iter, &iter);
if(!pStyleTree->getStyleAtRowCol(sTmp,row,col))
{
UT_ASSERT(UT_SHOULD_NOT_HAPPEN);
break;
}
gtk_tree_store_set (m_wModel, &child_iter, 0, sTmp.utf8_str(), 1, row,2,col+1, -1);
xxx_UT_DEBUGMSG(("Adding style %s at row %d col %d \n",sTmp.utf8_str(),row,col+1));
page++;
}
}
else
{
xxx_UT_DEBUGMSG(("Adding style %s at row %d \n",sTmp.utf8_str(),row));
gtk_tree_store_set (m_wModel, &iter, 0, sTmp.utf8_str(), 1,row,2,0,-1);
page++;
}
}
// create a new treeview
m_wStyleList = gtk_tree_view_new_with_model (GTK_TREE_MODEL (m_wModel));
g_object_unref (G_OBJECT (m_wModel));
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (m_wStyleList), true);
// get the current selection
sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (m_wStyleList));
gtk_tree_selection_set_mode (sel, GTK_SELECTION_BROWSE);
gtk_tree_selection_set_select_function (sel, tree_select_filter,
NULL, NULL);
const XAP_StringSet * pSS = m_pApp->getStringSet ();
m_wRenderer = gtk_cell_renderer_text_new ();
UT_UTF8String s;
pSS->getValueUTF8(AP_STRING_ID_DLG_Stylist_Styles,s);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (m_wStyleList),
-1, s.utf8_str(),
m_wRenderer, "text", 0, NULL);
gtk_tree_view_collapse_all (GTK_TREE_VIEW (m_wStyleList));
gtk_container_add (GTK_CONTAINER (m_wStyleListContainer), m_wStyleList);
g_signal_connect_after(G_OBJECT(m_wStyleList),
"cursor-changed",
G_CALLBACK(s_types_clicked),
static_cast<gpointer>(this));
g_signal_connect_after(G_OBJECT(m_wStyleList),
"row-activated",
G_CALLBACK(s_types_dblclicked),
static_cast<gpointer>(this));
gtk_widget_show_all(m_wStyleList);
setStyleTreeChanged(false);
}
