static void
feed_list_view_reduce_mode_changed (void)
{
if (flv->feedlist_reduced_unread) {
gtk_tree_view_set_reorderable (flv->treeview, FALSE);
gtk_tree_view_set_model (flv->treeview, GTK_TREE_MODEL (flv->filter));
gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (flv->filter));
} else {
gtk_tree_view_set_reorderable (flv->treeview, TRUE);
gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (flv->filter));
gtk_tree_view_set_model (flv->treeview, GTK_TREE_MODEL (flv->feedstore));
feedlist_foreach (feed_list_view_restore_folder_expansion);
}
}
static void create_treeview(GtkWidget *treeview, GtkWidget *treeview_sw, char *col_names[],
int col_names_count)
{
GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));
gtk_tree_selection_set_mode (sel, GTK_SELECTION_NONE);
/* fixed with and height improve performance */
gtk_tree_view_set_fixed_height_mode(GTK_TREE_VIEW(treeview), TRUE);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (treeview), TRUE);
gtk_tree_view_set_reorderable(GTK_TREE_VIEW (treeview), FALSE);
gtk_container_add (GTK_CONTAINER (treeview_sw), treeview);
/* add columns to the tree view */
GtkCellRenderer *renderer;
GtkTreeViewColumn *col;
/* hack! minimal screen width - scroll bar width - separators and borders */
int width = 430 / col_names_count;
int i;
for (i=0; i<col_names_count; i++) {
renderer = gtk_cell_renderer_text_new();
col = gtk_tree_view_column_new_with_attributes (col_names[i], renderer, "text", i, NULL);
gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_fixed_width(col, width);
gtk_tree_view_column_set_clickable(col, FALSE);
gtk_tree_view_column_set_cell_data_func (col, renderer, svinfo_treeview_func_text, NULL, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW(treeview), col);
}
}
static GtkWidget * create_batchinfo_treeview()
{
batchinfo_treeview = gtk_tree_view_new ();
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (batchinfo_treeview), TRUE);
gtk_tree_view_set_reorderable(GTK_TREE_VIEW (batchinfo_treeview), FALSE);
GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(batchinfo_treeview));
gtk_tree_selection_set_mode (sel, GTK_SELECTION_NONE);
batchinfo_treeview_sw = new_scrolled_window (NULL);
gtk_container_add (GTK_CONTAINER (batchinfo_treeview_sw), batchinfo_treeview);
/* add columns to the tree view */
GtkCellRenderer *renderer;
GtkTreeViewColumn *col;
int i;
for (i=0; i<COL_BINFO_COUNT; i++) {
renderer = gtk_cell_renderer_text_new();
col = gtk_tree_view_column_new_with_attributes (batchinfo_col_names[i], renderer, "text", i, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW(batchinfo_treeview), col);
}
batchinfo_store = gtk_list_store_new (COL_BINFO_COUNT, G_TYPE_STRING, G_TYPE_STRING);
gtk_tree_view_set_model(GTK_TREE_VIEW(batchinfo_treeview), GTK_TREE_MODEL(batchinfo_store));
return batchinfo_treeview_sw;
}
static void setup_treeview ()
{
GtkTreeSelection *selection;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
gtk_tree_view_set_headers_visible (editor->treeview, FALSE);
editor->store = GTK_TREE_STORE (bookmark_tree_store_new());
gtk_tree_view_set_model (editor->treeview,
GTK_TREE_MODEL (editor->store));
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (_("Name"),
renderer, "text", COLUMN_NAME, NULL);
gtk_tree_view_append_column (editor->treeview, column);
add_bookmarks ();
selection = gtk_tree_view_get_selection (editor->treeview);
gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE);
g_signal_connect (G_OBJECT (selection), "changed",
G_CALLBACK (selection_changed_cb), editor);
editor->selection = selection;
g_signal_connect (editor->store, "row_deleted",
G_CALLBACK (on_row_deleted_cb), NULL);
gtk_tree_view_set_reorderable (editor->treeview, TRUE);
}
G_MODULE_EXPORT void setup_rtt_treeview(GtkWidget *treeview)
{
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkWidget *parent = gtk_widget_get_parent(treeview);
GtkStyle * style = NULL;
style = gtk_widget_get_style(parent);
renderer = gtk_cell_renderer_text_new();
/*gtk_cell_renderer_set_fixed_size(GTK_CELL_RENDERER(renderer),-1, 1);*/
g_object_set(renderer, "background-gdk", &style->bg[GTK_STATE_NORMAL], NULL);
column = gtk_tree_view_column_new_with_attributes("",renderer, "text", COL_RTT_INT_NAME, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
renderer = gtk_cell_renderer_text_new();
/*gtk_cell_renderer_set_fixed_size(GTK_CELL_RENDERER(renderer),65, 1);*/
g_object_set(renderer, "background-gdk", &style->bg[GTK_STATE_NORMAL], NULL);
column = gtk_tree_view_column_new_with_attributes("",renderer, "markup", COL_RTT_DATA, NULL);
g_object_set(column, "alignment", 1.0, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview), FALSE);
gtk_tree_view_set_reorderable(GTK_TREE_VIEW(treeview), TRUE);
}
static GObject * radare_gui_list_constructor (GType type, guint n_construct_properties, GObjectConstructParam * construct_properties) {
GObject * obj;
RadareGUIListClass * klass;
GObjectClass * parent_class;
RadareGUIList * self;
klass = RADARE_GUI_LIST_CLASS (g_type_class_peek (RADARE_GUI_TYPE_LIST));
parent_class = G_OBJECT_CLASS (g_type_class_peek_parent (klass));
obj = parent_class->constructor (type, n_construct_properties, construct_properties);
self = RADARE_GUI_LIST (obj);
{
GtkScrolledWindow* _tmp0;
GtkTreeView* _tmp1;
GtkListStore* _tmp2;
_tmp0 = NULL;
#line 44 "list.vala"
radare_gui_list_set_widget (self, (_tmp0 = g_object_ref_sink (((GtkScrolledWindow*) (gtk_scrolled_window_new (NULL, NULL))))));
(_tmp0 == NULL ? NULL : (_tmp0 = (g_object_unref (_tmp0), NULL)));
#line 45 "list.vala"
gtk_scrolled_window_set_policy (self->priv->_widget, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
_tmp1 = NULL;
#line 47 "list.vala"
self->priv->tv = (_tmp1 = g_object_ref_sink (((GtkTreeView*) (gtk_tree_view_new ()))), (self->priv->tv == NULL ? NULL : (self->priv->tv = (g_object_unref (self->priv->tv), NULL))), _tmp1);
#line 48 "list.vala"
gtk_tree_view_set_reorderable (self->priv->tv, TRUE);
#line 49 "list.vala"
gtk_tree_view_set_rules_hint (self->priv->tv, TRUE);
_tmp2 = NULL;
#line 50 "list.vala"
gtk_tree_view_set_model (self->priv->tv, ((GtkTreeModel*) (self->priv->ls = (_tmp2 = gtk_list_store_new (1, G_TYPE_STRING, NULL), (self->priv->ls == NULL ? NULL : (self->priv->ls = (g_object_unref (self->priv->ls), NULL))), _tmp2))));
#line 52 "list.vala"
gtk_container_add (((GtkContainer*) (self->priv->_widget)), ((GtkWidget*) (self->priv->tv)));
}
return obj;
}
static void playlist_widget_init(PlaylistWidget *wgt)
{
wgt->indicator_renderer = gtk_cell_renderer_text_new();
wgt->title_renderer = gtk_cell_renderer_text_new();
wgt->list_store = gtk_list_store_new( 3,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING );
wgt->tree_view
= gtk_tree_view_new_with_model(GTK_TREE_MODEL(wgt->list_store));
wgt->indicator_column
= gtk_tree_view_column_new_with_attributes
( "\xe2\x80\xa2", /* UTF-8 bullet */
wgt->indicator_renderer,
"text",
0,
NULL );
wgt->title_column
= gtk_tree_view_column_new_with_attributes
(_("Playlist"), wgt->title_renderer, "text", 1, NULL);
gtk_tree_view_set_reorderable(GTK_TREE_VIEW(wgt->tree_view), TRUE);
gtk_tree_view_append_column
(GTK_TREE_VIEW(wgt->tree_view), wgt->indicator_column);
gtk_tree_view_append_column
(GTK_TREE_VIEW(wgt->tree_view), wgt->title_column);
gtk_container_add(GTK_CONTAINER(wgt), wgt->tree_view);
}
void button_refresh_clicked(GtkWidget *widget, gpointer data)
{
GtkListStore *store = gui_model_fill_data ();
gtk_tree_view_set_model (gui_get_gtk_tree_viewer(),(GtkTreeModel*)store);
//viewer "sortierbar" machen
gtk_tree_view_set_reorderable (gui_get_gtk_tree_viewer(),TRUE);
}
static GtkWidget *
editlist_treeview_new (GtkWidget *box, char *title1, char *title2)
{
GtkWidget *scroll;
GtkListStore *store;
GtkTreeViewColumn *col;
GtkWidget *view;
GtkCellRenderer *render;
scroll = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scroll), GTK_SHADOW_IN);
store = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING);
g_return_val_if_fail (store != NULL, NULL);
view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
gtk_tree_view_set_fixed_height_mode (GTK_TREE_VIEW (view), TRUE);
gtk_tree_view_set_enable_search (GTK_TREE_VIEW (view), FALSE);
gtk_tree_view_set_reorderable (GTK_TREE_VIEW (view), TRUE);
g_signal_connect (G_OBJECT (view), "key_press_event",
G_CALLBACK (editlist_keypress), NULL);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (view), TRUE);
render = gtk_cell_renderer_text_new ();
g_object_set (render, "editable", TRUE, NULL);
g_signal_connect (G_OBJECT (render), "edited",
G_CALLBACK (editlist_edited), GINT_TO_POINTER(NAME_COLUMN));
gtk_tree_view_insert_column_with_attributes (
GTK_TREE_VIEW (view), NAME_COLUMN,
title1, render,
"text", NAME_COLUMN,
NULL);
render = gtk_cell_renderer_text_new ();
g_object_set (render, "editable", TRUE, NULL);
g_signal_connect (G_OBJECT (render), "edited",
G_CALLBACK (editlist_edited), GINT_TO_POINTER(CMD_COLUMN));
gtk_tree_view_insert_column_with_attributes (
GTK_TREE_VIEW (view), CMD_COLUMN,
title2, render,
"text", CMD_COLUMN,
NULL);
col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), NAME_COLUMN);
gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_resizable (col, TRUE);
gtk_tree_view_column_set_min_width (col, 100);
gtk_container_add (GTK_CONTAINER (scroll), view);
gtk_container_add (GTK_CONTAINER (box), scroll);
gtk_widget_show_all (box);
return view;
}
void
fill_qck_launcher_dlg()
{
GtkTreeModel *treemodel;
GList *i;
GtkTreeIter iter;
GdkPixbuf *pixbuf;
GtkTreeViewColumn *column;
GtkCellRenderer *render;
t_launcher *launcher;
_icon_window = create_icon_window();
treemodel = GTK_TREE_MODEL(gtk_list_store_new(3, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_POINTER));
gtk_tree_view_set_model(GTK_TREE_VIEW(_dlg->treeview1), treemodel);
gtk_tree_view_set_reorderable (GTK_TREE_VIEW (_dlg->treeview1), FALSE);//==>besoin de gérer le reorder
gtk_spin_button_set_value(GTK_SPIN_BUTTON(_dlg->spin1), (gdouble)_quicklauncher->nb_lines);
render = gtk_cell_renderer_pixbuf_new();
//render = gtk_cell_renderer_combo_new();
//configure_combo(render); if I one day can use combo with pixbuf...
g_object_set (G_OBJECT(render), "mode", GTK_CELL_RENDERER_MODE_ACTIVATABLE,"sensitive", TRUE, NULL);
column = gtk_tree_view_column_new_with_attributes(_("icone"), render, "pixbuf", 0, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(_dlg->treeview1), column);
render = gtk_cell_renderer_text_new();
g_object_set (G_OBJECT(render),"editable", TRUE, NULL);
g_signal_connect(render, "edited", G_CALLBACK (cmd_changed), NULL);
column = gtk_tree_view_column_new_with_attributes(_("commande"), render, "text", 1, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(_dlg->treeview1), column);
//load current config
for( i = g_list_last(_quicklauncher->launchers); i != NULL; i = g_list_previous(i) )
{
launcher = i->data;
gtk_list_store_insert(GTK_LIST_STORE(treemodel), &iter, 0);
pixbuf = _create_pixbuf(launcher->icon_id, launcher->icon_name, 16);
gtk_list_store_set(GTK_LIST_STORE(treemodel), &iter, 0, pixbuf,
1, launcher->command, 2, (gpointer)launcher, -1);
UNREF(pixbuf);
}
g_signal_connect(_dlg->treeview1, "row-activated",
G_CALLBACK(show_icon_window), NULL);
g_signal_connect((gpointer)_dlg->spin1, "value-changed",
G_CALLBACK (on_spin_value_changed), NULL);
g_signal_connect ((gpointer) _dlg->btn_new, "clicked",
G_CALLBACK (on_btn_new_clicked), NULL);
g_signal_connect ((gpointer) _dlg->btn_remove, "clicked",
G_CALLBACK (on_btn_remove_clicked), NULL);
g_signal_connect ((gpointer) _dlg->btn_up, "clicked",
G_CALLBACK (on_btn_up_clicked), NULL);
g_signal_connect ((gpointer) _dlg->btn_down, "clicked",
G_CALLBACK (on_btn_down_clicked), NULL);
}
static void
gal_define_views_dialog_init (GalDefineViewsDialog *dialog)
{
GladeXML *gui;
GtkWidget *widget;
gchar *filename = g_build_filename (EVOLUTION_GLADEDIR,
"gal-define-views.glade",
NULL);
dialog->collection = NULL;
gui = glade_xml_new (filename, NULL, GETTEXT_PACKAGE);
g_free (filename);
dialog->gui = gui;
widget = glade_xml_get_widget(gui, "table-top");
if (!widget) {
return;
}
g_object_ref (widget);
gtk_container_remove (GTK_CONTAINER (widget->parent), widget);
gtk_window_set_default_size (GTK_WINDOW (dialog), 360, 270);
gtk_container_set_border_width (GTK_CONTAINER (dialog), 6);
gtk_container_set_border_width (GTK_CONTAINER (widget), 6);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), widget, TRUE, TRUE, 0);
g_object_unref(widget);
gtk_dialog_add_buttons (GTK_DIALOG (dialog),
GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
NULL);
dialog->treeview = GTK_TREE_VIEW (glade_xml_get_widget (dialog->gui, "treeview1"));
gtk_tree_view_set_reorderable (GTK_TREE_VIEW (dialog->treeview), FALSE);
gtk_tree_view_set_headers_visible (dialog->treeview, TRUE);
gtk_window_set_policy (GTK_WINDOW (dialog), FALSE, TRUE, FALSE);
gdvd_connect_signal(dialog, "button-new", "clicked", G_CALLBACK(gdvd_button_new_callback));
gdvd_connect_signal(dialog, "button-modify", "clicked", G_CALLBACK(gdvd_button_modify_callback));
gdvd_connect_signal(dialog, "button-delete", "clicked", G_CALLBACK(gdvd_button_delete_callback));
#if 0
gdvd_connect_signal(dialog, "button-copy", "clicked", G_CALLBACK(gdvd_button_copy_callback));
#endif
gdvd_connect_signal(dialog, "treeview1", "cursor-changed", G_CALLBACK(gdvd_cursor_changed_callback));
g_signal_connect (dialog, "response", G_CALLBACK (dialog_response), NULL);
gtk_widget_show (GTK_WIDGET (dialog));
}
void
xkb_layouts_prepare_selected_tree (GtkBuilder * dialog)
{
GtkListStore *list_store;
GtkWidget *tree_view = WID ("xkb_layouts_selected");
GtkTreeSelection *selection;
GtkTreeViewColumn *desc_column;
list_store = gtk_list_store_new (SEL_LAYOUT_N_COLS,
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN);
text_renderer = GTK_CELL_RENDERER (gtk_cell_renderer_text_new ());
desc_column =
gtk_tree_view_column_new_with_attributes (_("Layout"),
text_renderer,
"text",
SEL_LAYOUT_TREE_COL_DESCRIPTION,
"sensitive",
SEL_LAYOUT_TREE_COL_ENABLED,
NULL);
selection =
gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view));
gtk_tree_view_set_model (GTK_TREE_VIEW (tree_view),
GTK_TREE_MODEL (list_store));
gtk_tree_view_column_set_sizing (desc_column,
GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_resizable (desc_column, TRUE);
gtk_tree_view_column_set_expand (desc_column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view),
desc_column);
g_signal_connect_swapped (G_OBJECT (selection), "changed",
G_CALLBACK
(xkb_layouts_enable_disable_buttons),
dialog);
max_selected_layouts = xkl_engine_get_max_num_groups (engine);
/* Setting up DnD */
gtk_tree_view_set_reorderable (GTK_TREE_VIEW (tree_view), TRUE);
g_signal_connect (G_OBJECT (tree_view), "drag-end",
G_CALLBACK (xkb_layouts_drag_end), dialog);
}
static GtkWidget * create_batchlist_treeview()
{
batchlist_treeview = gtk_tree_view_new ();
gtk_tree_view_set_reorderable(GTK_TREE_VIEW(batchlist_treeview), FALSE);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (batchlist_treeview), TRUE);
GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(batchlist_treeview));
gtk_tree_selection_set_mode (sel, GTK_SELECTION_BROWSE);
/* For touch screen, better to use "cursor-changed", instead of "row-activated" */
g_signal_connect (G_OBJECT(batchlist_treeview), "cursor-changed",
G_CALLBACK (batchlist_treeview_row_selected), NULL);
batchlist_treeview_sw = new_scrolled_window (NULL);
gtk_container_add (GTK_CONTAINER (batchlist_treeview_sw), batchlist_treeview);
/* add columns to the tree view */
GtkCellRenderer *cell;
GtkTreeViewColumn *col;
int i;
for (i=COL_BL_LEVELS; i<=COL_BL_FAILED_PERCENT; i++) {
cell = gtk_cell_renderer_text_new();
col = gtk_tree_view_column_new_with_attributes (batchlist_col_names[i], cell, "text", i, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW(batchlist_treeview), col);
}
/* cancel column */
cell = clickable_cell_renderer_pixbuf_new();
col = gtk_tree_view_column_new_with_attributes("", cell, "pixbuf", COL_BL_CANCEL, NULL);
g_signal_connect (G_OBJECT (cell), "clicked", G_CALLBACK (cancel_batch_button_clicked), NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW(batchlist_treeview), col);
gtk_tree_view_column_set_fixed_width(col, 16);
cell = gtk_cell_renderer_progress_new();
col = gtk_tree_view_column_new_with_attributes (batchlist_col_names[COL_BL_DONE_PERCENT],
cell, "value", COL_BL_DONE_PERCENT, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW(batchlist_treeview), col);
batchlist_store = gtk_list_store_new (COL_BL_COUNT,
G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING, GDK_TYPE_PIXBUF,
G_TYPE_INT, G_TYPE_POINTER);
gtk_tree_view_set_model(GTK_TREE_VIEW(batchlist_treeview), GTK_TREE_MODEL(batchlist_store));
return batchlist_treeview_sw;
}
static void
set_features (EmpathyPersonaView *self,
EmpathyPersonaViewFeatureFlags features)
{
EmpathyPersonaViewPriv *priv = GET_PRIV (self);
priv->features = features;
/* Setting reorderable is a hack that gets us row previews as drag icons
for free. We override all the drag handlers. It's tricky to get the
position of the drag icon right in drag_begin. GtkTreeView has special
voodoo for it, so we let it do the voodoo that he do (but only if dragging
is enabled). */
gtk_tree_view_set_reorderable (GTK_TREE_VIEW (self),
(features & EMPATHY_PERSONA_VIEW_FEATURE_PERSONA_DRAG));
/* Update DnD source/dest */
if (features & EMPATHY_PERSONA_VIEW_FEATURE_PERSONA_DRAG)
{
gtk_drag_source_set (GTK_WIDGET (self),
GDK_BUTTON1_MASK,
drag_types_source,
G_N_ELEMENTS (drag_types_source),
GDK_ACTION_MOVE | GDK_ACTION_COPY);
}
else
{
gtk_drag_source_unset (GTK_WIDGET (self));
}
if (features & EMPATHY_PERSONA_VIEW_FEATURE_PERSONA_DROP)
{
gtk_drag_dest_set (GTK_WIDGET (self),
GTK_DEST_DEFAULT_ALL,
drag_types_dest,
G_N_ELEMENTS (drag_types_dest), GDK_ACTION_MOVE | GDK_ACTION_COPY);
}
else
{
gtk_drag_dest_unset (GTK_WIDGET (self));
}
g_object_notify (G_OBJECT (self), "features");
}
static void playlist_widget_init(PlaylistWidget *wgt)
{
wgt->indicator_renderer = gtk_cell_renderer_text_new();
wgt->title_renderer = gtk_cell_renderer_text_new();
wgt->list_store = gtk_list_store_new( 3,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING );
wgt->tree_view
= gtk_tree_view_new_with_model(GTK_TREE_MODEL(wgt->list_store));
wgt->indicator_column
= gtk_tree_view_column_new_with_attributes
( "\xe2\x80\xa2", /* UTF-8 bullet */
wgt->indicator_renderer,
"text",
0,
NULL );
wgt->title_column
= gtk_tree_view_column_new_with_attributes
(_("Playlist"), wgt->title_renderer, "text", 1, NULL);
g_signal_connect( wgt->tree_view,
"button-press-event",
G_CALLBACK(mouse_press_handler),
NULL );
gtk_widget_set_can_focus(GTK_WIDGET(wgt->tree_view), FALSE);
gtk_tree_view_set_reorderable(GTK_TREE_VIEW(wgt->tree_view), TRUE);
gtk_tree_view_append_column
(GTK_TREE_VIEW(wgt->tree_view), wgt->indicator_column);
gtk_tree_view_append_column
(GTK_TREE_VIEW(wgt->tree_view), wgt->title_column);
gtk_container_add(GTK_CONTAINER(wgt), wgt->tree_view);
}
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);
}
static GtkWidget * _preferences_window_applets_view(GtkListStore * store,
gboolean reorderable)
{
GtkWidget * view;
GtkTreeSelection * treesel;
GtkCellRenderer * renderer;
GtkTreeViewColumn * column;
view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(view), FALSE);
gtk_tree_view_set_reorderable(GTK_TREE_VIEW(view), reorderable);
treesel = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
gtk_tree_selection_set_mode(treesel, GTK_SELECTION_SINGLE);
renderer = gtk_cell_renderer_pixbuf_new();
column = gtk_tree_view_column_new_with_attributes("", renderer,
"pixbuf", 1, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("", renderer,
"text", 2, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), column);
return view;
}
static void
search_list_tree_view_init(void)
{
GtkTreeView *tv;
tv = GTK_TREE_VIEW(gui_main_window_lookup("tree_view_search"));
tree_view_search = tv;
gtk_tree_view_set_reorderable(tv, TRUE);
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(tv),
GTK_SELECTION_MULTIPLE);
gtk_tree_view_set_model(tv, create_searches_model());
add_list_columns(tv);
widget_add_popup_menu(GTK_WIDGET(tv),
search_gui_get_search_list_popup_menu);
gui_signal_connect(tv,
"button-release-event", on_search_list_button_release_event, NULL);
gui_signal_connect(tv,
"key-release-event", on_search_list_key_release_event, NULL);
gui_signal_connect_after(gtk_tree_view_get_model(tv),
"row-deleted", on_search_list_row_deleted, NULL);
}
static GtkWidget* do_todos (MaintainrProjectbox *item)
{
GtkListStore *model;
GtkCellRenderer *renderer;
GtkTreeViewColumn *col;
GtkTreeSelection *selection;
model = gtk_list_store_new (3, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_INT);
item->priv->todos = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model));
gtk_widget_set_tooltip_text (item->priv->todos, "Press '+' to add an item, '-' to remove the selected one");
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (item->priv->todos), FALSE);
gtk_tree_view_set_reorderable (GTK_TREE_VIEW (item->priv->todos), TRUE);
renderer = gtk_cell_renderer_toggle_new ();
gtk_cell_renderer_toggle_set_activatable (GTK_CELL_RENDERER_TOGGLE (renderer), TRUE);
g_object_set (G_OBJECT (renderer), "yalign", 0, NULL);
col = gtk_tree_view_column_new_with_attributes ("Check", renderer, "active", 0, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (item->priv->todos), col);
g_signal_connect (renderer, "toggled", G_CALLBACK (todo_check_changed), item);
renderer = gtk_cell_renderer_text_new ();
g_object_set (G_OBJECT (renderer), "wrap-mode", PANGO_WRAP_WORD, "yalign", 0, NULL);
g_object_set (G_OBJECT (renderer), "editable", TRUE, "wrap-width", 200, NULL);
col = gtk_tree_view_column_new_with_attributes ("String", renderer, "text", 1, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (item->priv->todos), col);
g_signal_connect (renderer, "edited", G_CALLBACK (todo_string_changed), item);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (item->priv->todos));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
g_signal_connect (item->priv->todos, "realize", G_CALLBACK (activate_focus_management), NULL);
g_signal_connect (item->priv->todos, "focus-out-event", G_CALLBACK (unselect_all_todos), NULL);
g_signal_connect (item->priv->todos, "key-press-event", G_CALLBACK (edit_todo_shortcuts), item);
return item->priv->todos;
}
static void
add_tree_view (NautilusColumnChooser *chooser)
{
GtkWidget *scrolled;
GtkWidget *view;
GtkListStore *store;
GtkCellRenderer *cell;
GtkTreeSelection *selection;
view = gtk_tree_view_new ();
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (view), FALSE);
store = gtk_list_store_new (NUM_COLUMNS,
G_TYPE_BOOLEAN,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_BOOLEAN);
gtk_tree_view_set_model (GTK_TREE_VIEW (view),
GTK_TREE_MODEL (store));
g_object_unref (store);
gtk_tree_view_set_reorderable (GTK_TREE_VIEW (view), TRUE);
g_signal_connect (view, "row-activated",
G_CALLBACK (view_row_activated_callback), chooser);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (view));
g_signal_connect (selection, "changed",
G_CALLBACK (selection_changed_callback), chooser);
cell = gtk_cell_renderer_toggle_new ();
g_signal_connect (G_OBJECT (cell), "toggled",
G_CALLBACK (visible_toggled_callback), chooser);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (view),
-1, NULL,
cell,
"active", COLUMN_VISIBLE,
"sensitive", COLUMN_SENSITIVE,
NULL);
cell = gtk_cell_renderer_text_new ();
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (view),
-1, NULL,
cell,
"text", COLUMN_LABEL,
"sensitive", COLUMN_SENSITIVE,
NULL);
chooser->details->view = GTK_TREE_VIEW (view);
chooser->details->store = store;
gtk_widget_show (view);
scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled),
GTK_SHADOW_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_widget_show (GTK_WIDGET (scrolled));
gtk_container_add (GTK_CONTAINER (scrolled), view);
gtk_box_pack_start (GTK_BOX (chooser), scrolled, TRUE, TRUE, 0);
}
/**
* dialog_init:
* @state:
*
* Create the dialog (guru).
*
**/
static gboolean
dialog_init (SolverState *state)
{
GtkGrid *grid;
GnmSolverParameters *param;
GtkCellRenderer *renderer;
GtkListStore *store;
GtkTreeViewColumn *column;
GSList *cl;
GnmCell *target_cell;
GnmValue const *input;
int i;
param = state->sheet->solver_parameters;
state->gui = gnm_gtk_builder_load ("solver.ui", NULL, GO_CMD_CONTEXT (state->wbcg));
if (state->gui == NULL)
return TRUE;
state->dialog = go_gtk_builder_get_widget (state->gui, "Solver");
if (state->dialog == NULL)
return TRUE;
state->notebook = go_gtk_builder_get_widget (state->gui, "solver_notebook");
/* buttons */
state->solve_button = go_gtk_builder_get_widget (state->gui, "solvebutton");
g_signal_connect (G_OBJECT (state->solve_button), "clicked",
G_CALLBACK (cb_dialog_solve_clicked), state);
state->close_button = go_gtk_builder_get_widget (state->gui, "closebutton");
g_signal_connect (G_OBJECT (state->close_button), "clicked",
G_CALLBACK (cb_dialog_close_clicked), state);
state->help_button = go_gtk_builder_get_widget (state->gui, "helpbutton");
gnm_init_help_button (state->help_button, GNUMERIC_HELP_LINK_SOLVER);
state->add_button = go_gtk_builder_get_widget (state->gui, "addbutton");
gtk_button_set_alignment (GTK_BUTTON (state->add_button), 0.5, .5);
g_signal_connect_swapped (G_OBJECT (state->add_button), "clicked",
G_CALLBACK (cb_dialog_add_clicked), state);
state->change_button = go_gtk_builder_get_widget (state->gui,
"changebutton");
g_signal_connect (G_OBJECT (state->change_button), "clicked",
G_CALLBACK (cb_dialog_change_clicked), state);
state->delete_button = go_gtk_builder_get_widget (state->gui,
"deletebutton");
gtk_button_set_alignment (GTK_BUTTON (state->delete_button), 0.5, .5);
g_signal_connect (G_OBJECT (state->delete_button), "clicked",
G_CALLBACK (cb_dialog_delete_clicked), state);
state->stop_button = go_gtk_builder_get_widget (state->gui, "stopbutton");
g_signal_connect_swapped (G_OBJECT (state->stop_button),
"clicked", G_CALLBACK (cb_stop_solver),
state);
/* target_entry */
grid = GTK_GRID (go_gtk_builder_get_widget (state->gui,
"parameter-grid"));
state->target_entry = gnm_expr_entry_new (state->wbcg, TRUE);
gnm_expr_entry_set_flags (state->target_entry,
GNM_EE_SINGLE_RANGE |
GNM_EE_FORCE_ABS_REF |
GNM_EE_SHEET_OPTIONAL, GNM_EE_MASK);
gtk_widget_set_hexpand (GTK_WIDGET (state->target_entry), TRUE);
gtk_grid_attach (grid, GTK_WIDGET (state->target_entry), 1, 0, 2, 1);
gnm_editable_enters (GTK_WINDOW (state->dialog),
GTK_WIDGET (state->target_entry));
gtk_widget_show (GTK_WIDGET (state->target_entry));
g_signal_connect_after (G_OBJECT (state->target_entry), "changed",
G_CALLBACK (dialog_set_main_button_sensitivity),
state);
/* change_cell_entry */
state->change_cell_entry = gnm_expr_entry_new (state->wbcg, TRUE);
gnm_expr_entry_set_flags (state->change_cell_entry,
GNM_EE_SINGLE_RANGE |
GNM_EE_FORCE_ABS_REF |
GNM_EE_SHEET_OPTIONAL, GNM_EE_MASK);
gtk_widget_set_hexpand (GTK_WIDGET (state->change_cell_entry), TRUE);
gtk_grid_attach (grid,
GTK_WIDGET (state->change_cell_entry), 1, 2, 2, 1);
gnm_editable_enters (GTK_WINDOW (state->dialog),
GTK_WIDGET (state->change_cell_entry));
gtk_widget_show (GTK_WIDGET (state->change_cell_entry));
g_signal_connect_after (G_OBJECT (state->change_cell_entry), "changed",
G_CALLBACK (dialog_set_main_button_sensitivity), state);
/* Algorithm */
state->algorithm_combo = GTK_COMBO_BOX
(go_gtk_builder_get_widget (state->gui, "algorithm_combo"));
renderer = (GtkCellRenderer*) gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (state->algorithm_combo), renderer, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (state->algorithm_combo), renderer,
"text", 0,
NULL);
fill_algorithm_combo (state, param->options.model_type);
for (i = 0; model_type_group[i]; i++) {
const char *bname = model_type_group[i];
GtkWidget *w = go_gtk_builder_get_widget(state->gui, bname);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w),
param->options.model_type ==
(GnmSolverModelType)i);
g_signal_connect (G_OBJECT (w), "clicked",
G_CALLBACK (cb_dialog_model_type_clicked), state);
}
/* Options */
state->max_iter_entry = go_gtk_builder_get_widget (state->gui,
"max_iter_entry");
gtk_spin_button_set_value (GTK_SPIN_BUTTON (state->max_iter_entry),
param->options.max_iter);
state->max_time_entry = go_gtk_builder_get_widget (state->gui,
"max_time_entry");
gtk_spin_button_set_value (GTK_SPIN_BUTTON (state->max_time_entry),
param->options.max_time_sec);
state->gradient_order_entry = go_gtk_builder_get_widget (state->gui,
"gradient_order_entry");
gtk_spin_button_set_value (GTK_SPIN_BUTTON (state->gradient_order_entry),
param->options.gradient_order);
/* lhs_entry */
grid = GTK_GRID (go_gtk_builder_get_widget (state->gui,
"constraints-grid"));
state->lhs.entry = gnm_expr_entry_new (state->wbcg, TRUE);
gnm_expr_entry_set_flags (state->lhs.entry,
GNM_EE_SINGLE_RANGE |
GNM_EE_FORCE_ABS_REF |
GNM_EE_SHEET_OPTIONAL, GNM_EE_MASK);
gtk_widget_set_hexpand (GTK_WIDGET (state->lhs.entry), TRUE);
gtk_grid_attach (grid, GTK_WIDGET (state->lhs.entry), 0, 4, 1, 1);
state->lhs.label = go_gtk_builder_get_widget (state->gui, "lhs_label");
gtk_label_set_mnemonic_widget (GTK_LABEL (state->lhs.label),
GTK_WIDGET (state->lhs.entry));
gtk_widget_show (GTK_WIDGET (state->lhs.entry));
g_signal_connect_after (G_OBJECT (state->lhs.entry),
"changed",
G_CALLBACK (dialog_set_sec_button_sensitivity), state);
g_signal_connect_swapped (
gnm_expr_entry_get_entry (GNM_EXPR_ENTRY (state->lhs.entry)),
"activate", G_CALLBACK (cb_dialog_add_clicked), state);
/* rhs_entry */
state->rhs.entry = gnm_expr_entry_new (state->wbcg, TRUE);
gnm_expr_entry_set_flags (state->rhs.entry,
GNM_EE_SINGLE_RANGE |
GNM_EE_FORCE_ABS_REF |
GNM_EE_SHEET_OPTIONAL |
GNM_EE_CONSTANT_ALLOWED,
GNM_EE_MASK);
gtk_widget_set_hexpand (GTK_WIDGET (state->rhs.entry), TRUE);
gtk_grid_attach (grid, GTK_WIDGET (state->rhs.entry), 2, 4, 1, 1);
gtk_widget_show (GTK_WIDGET (state->rhs.entry));
state->rhs.label = go_gtk_builder_get_widget (state->gui, "rhs_label");
gtk_label_set_mnemonic_widget (
GTK_LABEL (state->rhs.label), GTK_WIDGET (state->rhs.entry));
g_signal_connect_after (G_OBJECT (state->rhs.entry),
"changed",
G_CALLBACK (dialog_set_sec_button_sensitivity), state);
g_signal_connect_swapped (
gnm_expr_entry_get_entry (GNM_EXPR_ENTRY (state->rhs.entry)),
"activate", G_CALLBACK (cb_dialog_add_clicked), state);
/* type_menu */
state->type_combo = GTK_COMBO_BOX
(go_gtk_builder_get_widget (state->gui, "type_menu"));
gtk_combo_box_set_active (state->type_combo, 0);
g_signal_connect (state->type_combo, "changed",
G_CALLBACK (dialog_set_sec_button_sensitivity),
state);
/* constraint_list */
state->constraint_list = GTK_TREE_VIEW (go_gtk_builder_get_widget
(state->gui, "constraint_list"));
state->constr = NULL;
g_signal_connect (G_OBJECT (gtk_tree_view_get_selection (state->constraint_list)), "changed",
G_CALLBACK (constraint_select_click), state);
gtk_tree_view_set_reorderable (state->constraint_list, TRUE);
store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_POINTER);
gtk_tree_view_set_model (state->constraint_list, GTK_TREE_MODEL(store));
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (
_("Subject to the Constraints:"),
renderer, "text", 0, NULL);
gtk_tree_view_column_set_expand (column, TRUE);
gtk_tree_view_append_column (state->constraint_list, column);
{
GtkWidget *w = GTK_WIDGET (state->constraint_list);
int width, height, vsep;
PangoLayout *layout =
gtk_widget_create_pango_layout (w, "Mg19");
gtk_widget_style_get (w,
"vertical_separator", &vsep,
NULL);
pango_layout_get_pixel_size (layout, &width, &height);
gtk_widget_set_size_request (w,
-1,
(2 * height + vsep) * (4 + 1));
g_object_unref (layout);
}
/* Loading the old solver specs... from param */
for (cl = param->constraints; cl; cl = cl->next) {
GnmSolverConstraint const *c = cl->data;
GtkTreeIter iter;
char *str;
gtk_list_store_append (store, &iter);
str = gnm_solver_constraint_as_str (c, state->sheet);
gtk_list_store_set (store, &iter, 0, str, 1, c, -1);
g_free (str);
}
g_object_unref (store);
INIT_BOOL_ENTRY ("autoscale_button", options.automatic_scaling);
INIT_BOOL_ENTRY ("non_neg_button", options.assume_non_negative);
INIT_BOOL_ENTRY ("all_int_button", options.assume_discrete);
INIT_BOOL_ENTRY ("program", options.program_report);
INIT_BOOL_ENTRY ("sensitivity", options.sensitivity_report);
input = gnm_solver_param_get_input (param);
if (input != NULL)
gnm_expr_entry_load_from_text (state->change_cell_entry,
value_peek_string (input));
target_cell = gnm_solver_param_get_target_cell (param);
if (target_cell)
gnm_expr_entry_load_from_text (state->target_entry,
cell_name (target_cell));
else {
SheetView *sv = wb_control_cur_sheet_view
(GNM_WBC (state->wbcg));
if (sv) {
GnmRange first = {sv->edit_pos, sv->edit_pos};
gnm_expr_entry_load_from_range (state->target_entry,
state->sheet, &first);
}
}
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (
go_gtk_builder_get_widget(state->gui, "max_button")),
param->problem_type == GNM_SOLVER_MAXIMIZE);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (
go_gtk_builder_get_widget(state->gui, "min_button")),
param->problem_type == GNM_SOLVER_MINIMIZE);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (
go_gtk_builder_get_widget(state->gui, "no_scenario")),
! param->options.add_scenario);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (
go_gtk_builder_get_widget(state->gui, "optimal_scenario")),
param->options.add_scenario);
state->scenario_name_entry = go_gtk_builder_get_widget
(state->gui, "scenario_name_entry");
gtk_entry_set_text (GTK_ENTRY (state->scenario_name_entry),
param->options.scenario_name);
state->run.status_widget = go_gtk_builder_get_widget (state->gui, "solver_status_label");
state->run.problem_status_widget = go_gtk_builder_get_widget (state->gui, "problem_status_label");
state->run.objective_value_widget = go_gtk_builder_get_widget (state->gui, "objective_value_label");
state->run.timer_widget = go_gtk_builder_get_widget (state->gui, "elapsed_time_label");
state->run.spinner = go_gtk_builder_get_widget (state->gui, "run_spinner");
/* Done */
gnm_expr_entry_grab_focus (state->target_entry, FALSE);
wbcg_set_entry (state->wbcg, state->target_entry);
dialog_set_main_button_sensitivity (NULL, state);
dialog_set_sec_button_sensitivity (NULL, state);
/* dialog */
wbc_gtk_attach_guru (state->wbcg, state->dialog);
g_signal_connect_swapped (G_OBJECT (state->dialog),
"destroy",
G_CALLBACK (cb_dialog_solver_destroy),
state);
g_object_set_data_full (G_OBJECT (state->dialog),
"state", state,
(GDestroyNotify)unref_state);
return FALSE;
}
void create_romBrowser()
{
GtkWidget* menu;
GtkWidget* submenu;
GtkWidget* item;
australia = gdk_pixbuf_new_from_file(get_iconpath("australia.png"), NULL);
europe = gdk_pixbuf_new_from_file(get_iconpath("europe.png"), NULL);
france = gdk_pixbuf_new_from_file(get_iconpath("france.png"), NULL);
germany = gdk_pixbuf_new_from_file(get_iconpath("germany.png"), NULL);
italy = gdk_pixbuf_new_from_file(get_iconpath("italy.png"), NULL);
japan = gdk_pixbuf_new_from_file(get_iconpath("japan.png"), NULL);
spain = gdk_pixbuf_new_from_file(get_iconpath("spain.png"), NULL);
usa = gdk_pixbuf_new_from_file(get_iconpath("usa.png"), NULL);
japanusa = gdk_pixbuf_new_from_file(get_iconpath("japanusa.png"), NULL);
n64cart = gdk_pixbuf_new_from_file(get_iconpath("16x16/mupen64cart.png"), NULL);
/* Setup rombrowser column names.
g_MainWindow.column_names[column][0] is the translated column header.
g_MainWindow.column_names[column][1] toggles visability in the config system. */
snprintf(g_MainWindow.column_names[0][0], 128, tr("Country"));
snprintf(g_MainWindow.column_names[0][1], 128, "ColumnCountryVisible");
snprintf(g_MainWindow.column_names[1][0], 128, tr("Good Name"));
snprintf(g_MainWindow.column_names[1][1], 128, "ColumnGoodNameVisible");
snprintf(g_MainWindow.column_names[2][0], 128, tr("Status"));
snprintf(g_MainWindow.column_names[2][1], 128, "ColumnStatusVisible");
snprintf(g_MainWindow.column_names[3][0], 128, tr("User Comments"));
snprintf(g_MainWindow.column_names[3][1], 128, "ColumnUserCommentsVisible");
snprintf(g_MainWindow.column_names[4][0], 128, tr("File Name"));
snprintf(g_MainWindow.column_names[4][1], 128, "ColumnFileNameVisible");
snprintf(g_MainWindow.column_names[5][0], 128, tr("MD5 Hash"));
snprintf(g_MainWindow.column_names[5][1], 128, "ColumnMD5HashVisible");
snprintf(g_MainWindow.column_names[6][0], 128, tr("CRC1"));
snprintf(g_MainWindow.column_names[6][1], 128, "ColumnCRC1Visible");
snprintf(g_MainWindow.column_names[7][0], 128, tr("CRC2"));
snprintf(g_MainWindow.column_names[7][1], 128, "ColumnCRC2Visible");
snprintf(g_MainWindow.column_names[8][0], 128, tr("Internal Name"));
snprintf(g_MainWindow.column_names[8][1], 128, "ColumnInternalNameVisible");
snprintf(g_MainWindow.column_names[9][0], 128, tr("Save Types"));
snprintf(g_MainWindow.column_names[9][1], 128, "ColumnSaveTypeVisible");
snprintf(g_MainWindow.column_names[10][0], 128, tr("Players"));
snprintf(g_MainWindow.column_names[10][1], 128, "ColumnPlayersVisible");
snprintf(g_MainWindow.column_names[11][0], 128, tr("Size"));
snprintf(g_MainWindow.column_names[11][1], 128, "ColumnSizeVisible");
snprintf(g_MainWindow.column_names[12][0], 128, tr("Compression"));
snprintf(g_MainWindow.column_names[12][1], 128, "ColumnCompressionVisible");
snprintf(g_MainWindow.column_names[13][0], 128, tr("Image Type"));
snprintf(g_MainWindow.column_names[13][1], 128, "ColumnImageTypeVisible");
snprintf(g_MainWindow.column_names[14][0], 128, tr("CIC Chip"));
snprintf(g_MainWindow.column_names[14][1], 128, "ColumnCICChipVisible");
snprintf(g_MainWindow.column_names[15][0], 128, tr("Rumble"));
snprintf(g_MainWindow.column_names[15][1], 128, "ColumnRumbleVisible");
/* Setup rombrowser tree views. */
g_MainWindow.romFullList = gtk_tree_view_new();
g_MainWindow.romDisplay = gtk_tree_view_new();
/* Multiple selections needed due to the way we clear the TreeViews. */
GtkTreeSelection* selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(g_MainWindow.romFullList));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(g_MainWindow.romDisplay));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
/* Initialize TreeViews - i.e. setup column info. models */
setup_view(g_MainWindow.romFullList);
setup_view(g_MainWindow.romDisplay);
g_MainWindow.romScrolledWindow = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(g_MainWindow.romScrolledWindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
/* Add the Display TreeView into our scrolled window. */
gtk_container_add(GTK_CONTAINER(g_MainWindow.romScrolledWindow), g_MainWindow.romDisplay);
gtk_container_add(GTK_CONTAINER(g_MainWindow.toplevelVBox), g_MainWindow.romScrolledWindow);
gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(g_MainWindow.romDisplay), TRUE);
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(g_MainWindow.romDisplay), TRUE);
gtk_tree_view_set_reorderable(GTK_TREE_VIEW(g_MainWindow.romDisplay), FALSE);
/* Open on double click. */
g_signal_connect(g_MainWindow.romDisplay, "row-activated", G_CALLBACK(callback_play_rom), NULL);
/* Setup right-click menu. */
menu = gtk_menu_new();
g_MainWindow.playRomItem = gtk_image_menu_item_new_with_label(tr("Play Rom"));
g_MainWindow.playRombrowserImage = gtk_image_new();
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(g_MainWindow.playRomItem), g_MainWindow.playRombrowserImage);
g_signal_connect(g_MainWindow.playRomItem, "activate", G_CALLBACK(callback_play_rom), NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), g_MainWindow.playRomItem);
g_MainWindow.romPropertiesItem = gtk_image_menu_item_new_with_label(tr("Rom Properties"));
g_MainWindow.propertiesRombrowserImage = gtk_image_new();
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(g_MainWindow.romPropertiesItem), g_MainWindow.propertiesRombrowserImage);
g_signal_connect(g_MainWindow.romPropertiesItem, "activate", G_CALLBACK(callback_rom_properties), NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), g_MainWindow.romPropertiesItem);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), gtk_separator_menu_item_new());
item = gtk_image_menu_item_new_with_label(tr("Refresh"));
g_MainWindow.refreshRombrowserImage = gtk_image_new();
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), g_MainWindow.refreshRombrowserImage);
g_signal_connect(item, "activate", G_CALLBACK(callback_call_rcs), NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
item = gtk_menu_item_new_with_label(tr("Configure Rombrowser"));
g_signal_connect(item, "activate", G_CALLBACK(callback_configure_rombrowser), NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), gtk_separator_menu_item_new());
submenu = gtk_image_menu_item_new_with_label(tr("Configure Columns"));
gtk_menu_item_set_submenu(GTK_MENU_ITEM(submenu), g_MainWindow.romHeaderMenu);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), submenu);
gtk_widget_show_all(menu);
g_signal_connect(g_MainWindow.romDisplay, "button-press-event", G_CALLBACK(callback_rombrowser_context), (gpointer)menu);
}
static void
codecs_box_init (CodecsBox *self)
{
GtkWidget *image = NULL;
GtkWidget *scroll_window = NULL;
GtkWidget *button = NULL;
GtkWidget *buttons_vbox = NULL;
GtkWidget *alignment = NULL;
GtkListStore *list_store = NULL;
GtkCellRenderer *renderer = NULL;
GtkTreeViewColumn *column = NULL;
self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, CODECS_BOX_TYPE, CodecsBoxPrivate);
self->priv->type = Ekiga::Call::Audio;
self->priv->audio_settings =
boost::shared_ptr<Ekiga::Settings> (new Ekiga::Settings (AUDIO_CODECS_SCHEMA));
self->priv->video_settings =
boost::shared_ptr<Ekiga::Settings> (new Ekiga::Settings (VIDEO_CODECS_SCHEMA));
self->priv->codecs_list = gtk_tree_view_new ();
gtk_box_set_spacing (GTK_BOX (self), 6);
gtk_box_set_homogeneous (GTK_BOX (self), FALSE);
list_store = gtk_list_store_new (COLUMN_CODEC_NUMBER,
G_TYPE_BOOLEAN,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_BOOLEAN,
G_TYPE_BOOLEAN);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (self->priv->codecs_list), TRUE);
gtk_tree_view_set_reorderable (GTK_TREE_VIEW (self->priv->codecs_list), TRUE);
gtk_tree_view_set_search_column (GTK_TREE_VIEW (self->priv->codecs_list),0);
gtk_tree_view_set_model (GTK_TREE_VIEW (self->priv->codecs_list),
GTK_TREE_MODEL (list_store));
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (self->priv->codecs_list), FALSE);
/* Set all Colums */
renderer = gtk_cell_renderer_toggle_new ();
column = gtk_tree_view_column_new_with_attributes (NULL,
renderer,
"active",
COLUMN_CODEC_ACTIVE,
NULL);
gtk_tree_view_column_add_attribute (column, renderer,
"activatable", COLUMN_CODEC_SELECTABLE);
gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (column), 25);
gtk_tree_view_append_column (GTK_TREE_VIEW (self->priv->codecs_list), column);
g_signal_connect (renderer, "toggled",
G_CALLBACK (codec_toggled_cb),
(gpointer) self);
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (NULL,
renderer,
"text",
COLUMN_CODEC_NAME,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (self->priv->codecs_list), column);
g_object_set (G_OBJECT (renderer), "weight", PANGO_WEIGHT_BOLD, NULL);
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (NULL,
renderer,
"text",
COLUMN_CODEC_CLOCKRATE,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (self->priv->codecs_list), column);
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (NULL,
renderer,
"text",
COLUMN_CODEC_PROTOCOLS,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (self->priv->codecs_list), column);
scroll_window = gtk_scrolled_window_new (FALSE, FALSE);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll_window),
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scroll_window),
GTK_SHADOW_IN);
gtk_widget_set_size_request (scroll_window, -1, 130);
gtk_container_add (GTK_CONTAINER (scroll_window),
GTK_WIDGET (self->priv->codecs_list));
gtk_box_pack_start (GTK_BOX (self), scroll_window, TRUE, TRUE, 0);
/* The buttons */
alignment = gtk_alignment_new (1, 0.5, 0, 0);
buttons_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_container_add (GTK_CONTAINER (alignment), buttons_vbox);
image = gtk_image_new_from_icon_name ("go-up", GTK_ICON_SIZE_MENU);
button = gtk_button_new ();
gtk_container_add (GTK_CONTAINER (button), image);
gtk_widget_set_tooltip_text (button, _("Move selected codec priority upwards"));
gtk_box_pack_start (GTK_BOX (buttons_vbox), button, FALSE, FALSE, 0);
g_object_set_data (G_OBJECT (button), "operation", (gpointer) "up");
g_signal_connect (button, "clicked",
G_CALLBACK (codec_moved_cb),
(gpointer) self);
image = gtk_image_new_from_icon_name ("go-down", GTK_ICON_SIZE_MENU);
button = gtk_button_new ();
gtk_container_add (GTK_CONTAINER (button), image);
gtk_widget_set_tooltip_text (button, _("Move selected codec priority downwards"));
gtk_box_pack_start (GTK_BOX (buttons_vbox), button, FALSE, FALSE, 0);
g_object_set_data (G_OBJECT (button), "operation", (gpointer) "down");
g_signal_connect (button, "clicked",
G_CALLBACK (codec_moved_cb),
(gpointer) self);
gtk_box_pack_start (GTK_BOX (self), alignment, FALSE, FALSE, 0);
gtk_widget_set_hexpand (GTK_WIDGET (self), TRUE);
gtk_widget_show_all (GTK_WIDGET (self));
}
GtkWidget * scratch_tab_create()
{
GtkWidget *vbox = gtk_vbox_new(FALSE, 5);
/* file list treeview */
filelist_treeview = gtk_tree_view_new ();
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (filelist_treeview), TRUE);
gtk_tree_view_set_reorderable(GTK_TREE_VIEW (filelist_treeview), FALSE);
GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(filelist_treeview));
gtk_tree_selection_set_mode (sel, GTK_SELECTION_SINGLE);
g_signal_connect (G_OBJECT(filelist_treeview), "cursor-changed",
G_CALLBACK (filelist_treeview_row_selected), NULL);
filelist_treeview_sw = new_scrolled_window (NULL);
gtk_container_add (GTK_CONTAINER (filelist_treeview_sw), filelist_treeview);
/* add columns to the tree view */
GtkCellRenderer *renderer;
GtkTreeViewColumn *col;
int i;
int col_count = sizeof (filelist_treeview_col_names) / sizeof (char *);
for (i=0; i<col_count; i++) {
renderer = gtk_cell_renderer_text_new();
col = gtk_tree_view_column_new_with_attributes (filelist_treeview_col_names[i],
renderer, "text", i, NULL);
if (i == 0) {
gtk_tree_view_column_set_clickable(col, TRUE);
gtk_tree_view_column_set_sort_order(col, GTK_SORT_DESCENDING);
gtk_tree_view_column_set_sort_column_id(col, 0);
gtk_tree_view_column_set_sort_indicator(col, TRUE);
} else {
gtk_tree_view_column_set_clickable(col, FALSE);
}
gtk_tree_view_append_column (GTK_TREE_VIEW(filelist_treeview), col);
}
filelist_store = gtk_list_store_new (col_count, G_TYPE_STRING, G_TYPE_STRING);
GtkTreeSortable *sortable = GTK_TREE_SORTABLE(filelist_store);
gtk_tree_sortable_set_sort_column_id(sortable, 0, GTK_SORT_DESCENDING);
gtk_tree_view_set_model(GTK_TREE_VIEW(filelist_treeview), GTK_TREE_MODEL(filelist_store));
GtkWidget *hbox = gtk_hbox_new(TRUE, 5);
GtkWidget *scratch_button = gtk_button_new_with_label("Scratch on map");
g_signal_connect (G_OBJECT (scratch_button), "clicked",
G_CALLBACK (scratch_button_clicked), NULL);
view_button = gtk_button_new_with_label("View");
g_signal_connect (G_OBJECT(view_button), "clicked",
G_CALLBACK (view_button_clicked), NULL);
delete_button = gtk_button_new_with_label("Delete");
g_signal_connect (G_OBJECT(delete_button), "clicked",
G_CALLBACK (delete_button_clicked), NULL);
gtk_container_add(GTK_CONTAINER(hbox), view_button);
gtk_container_add(GTK_CONTAINER(hbox), delete_button);
gtk_container_add(GTK_CONTAINER(hbox), scratch_button);
gtk_box_pack_start(GTK_BOX(vbox), filelist_treeview_sw, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 5);
/* populate files into filelist treeview */
GtkTreeIter iter;
struct dirent *ep;
char buf[256];
char *file_path = NULL;
int len, ext_len = strlen(SCREENSHOT_FILE_EXT);
char *fname;
struct stat st;
DIR *dp = opendir (g_context.screenshot_dir);
if (dp == NULL) {
if (stat(buf, &st) == 0)
warn_dialog("unable to list screenshot files");
} else {
while ((ep = readdir (dp))) {
fname = ep->d_name;
len = strlen(fname);
if (ep->d_type == DT_REG && len > ext_len &&
(strncmp(&fname[len-ext_len], SCREENSHOT_FILE_EXT, ext_len) == 0)) {
gtk_list_store_prepend (filelist_store, &iter);
file_path = get_full_path(buf, sizeof(buf), fname);
add_file_to_list(&iter, file_path, fname);
}
}
closedir (dp);
}
notebook = gtk_notebook_new();
gtk_notebook_set_scrollable(GTK_NOTEBOOK(notebook), FALSE);
gtk_notebook_set_show_border(GTK_NOTEBOOK(notebook), FALSE);
GtkWidget *label;
label = gtk_label_new("screen shot list");
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), vbox, label);
GtkWidget *image_box = gtk_vbox_new(FALSE, 0);
screenshot_label = gtk_label_new("");
screenshot_image = gtk_image_new();
gtk_box_pack_start(GTK_BOX(image_box), screenshot_label, FALSE, FALSE, 0);
GtkWidget *sw = new_scrolled_window (screenshot_image);
/* stretch */
gtk_box_pack_start(GTK_BOX(image_box), sw, TRUE, TRUE, 0);
label = gtk_label_new("view screen shot");
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), image_box, label);
return notebook;
}
void
app_new(int argc, char *argv[], const char *geometry_string)
{
GtkWidget *vbox;
GtkWidget *widget;
GtkWidget *vpane;
GtkWidget *separator;
GtkLabel *filler;
GtkHBox *labels;
GtkVBox *status_vbox;
GtkStatusbar *grip;
app_window = gnome_app_new(GTT_APP_NAME, GTT_APP_TITLE " " VERSION);
gtk_window_set_wmclass(GTK_WINDOW(app_window),
GTT_APP_NAME, GTT_APP_PROPER_NAME);
/* 485 x 272 seems to be a good size to default to */
gtk_window_set_default_size(GTK_WINDOW(app_window), 485, 272);
gtk_window_set_resizable (GTK_WINDOW(app_window), TRUE);
/* build menus */
menus_create(GNOME_APP(app_window));
/* build toolbar */
widget = build_toolbar();
gtk_widget_show(widget);
gnome_app_set_toolbar(GNOME_APP(app_window), GTK_TOOLBAR(widget));
/* container holds status bar, main ctree widget */
vbox = gtk_vbox_new(FALSE, 0);
/* build statusbar */
status_vbox = GTK_VBOX(gtk_vbox_new(FALSE, 0));
gtk_widget_show(GTK_WIDGET(status_vbox));
labels = GTK_HBOX(gtk_hbox_new(FALSE, 0));
gtk_widget_show(GTK_WIDGET(labels));
status_bar = gtk_hbox_new(FALSE, 0);
gtk_widget_show(status_bar);
separator = gtk_hseparator_new();
gtk_widget_show(separator);
gtk_box_pack_start(GTK_BOX(status_vbox), separator, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(status_vbox), GTK_WIDGET (labels), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(status_bar), GTK_WIDGET (status_vbox), TRUE, TRUE, 0);
grip = GTK_STATUSBAR(gtk_statusbar_new());
gtk_statusbar_set_has_resize_grip(grip, TRUE);
gtk_widget_show(GTK_WIDGET(grip));
gtk_box_pack_start(GTK_BOX(status_bar), GTK_WIDGET(grip), FALSE, FALSE, 0);
/* put elapsed time into statusbar */
status_day_time = GTK_LABEL(gtk_label_new(_("00:00")));
gtk_widget_show(GTK_WIDGET(status_day_time));
gtk_box_pack_start(GTK_BOX(labels), GTK_WIDGET(status_day_time),
FALSE, TRUE, 0);
/* put project name into statusbar */
status_project = GTK_LABEL(gtk_label_new( _("Timer is not running")));
gtk_widget_show(GTK_WIDGET(status_project));
gtk_box_pack_start(GTK_BOX(labels), GTK_WIDGET(status_project),
FALSE, TRUE, 10);
filler = GTK_LABEL(gtk_label_new(""));
gtk_widget_show(GTK_WIDGET(filler));
gtk_box_pack_start(GTK_BOX(labels), GTK_WIDGET(filler), TRUE, TRUE, 1);
/* put timer icon into statusbar */
status_timer = gtk_image_new_from_stock (GNOME_STOCK_TIMER,
GTK_ICON_SIZE_MENU);
gtk_widget_show(status_timer);
gtk_box_pack_end(GTK_BOX(status_bar), GTK_WIDGET(status_timer),
FALSE, FALSE, 1);
/* create the main columned tree for showing projects */
projects_tree = gtt_projects_tree_new ();
g_signal_connect (projects_tree, "columns-setup-done", G_CALLBACK (projects_tree_columns_setup_done), NULL);
gtk_tree_view_set_reorderable (GTK_TREE_VIEW (projects_tree), TRUE);
g_signal_connect (projects_tree, "row-activated", G_CALLBACK (projects_tree_row_activated), NULL);
/* create the notes area */
global_na = notes_area_new();
vpane = notes_area_get_widget (global_na);
/* Need to reparent, to get rid of glade parent-window hack.
* But gtk_widget_reparent (vpane); causes a "Gtk-CRITICAL"
* to occur. So we need a fancier move.
*/
gtk_widget_ref (vpane);
gtk_container_remove(GTK_CONTAINER(vpane->parent), vpane);
gtk_box_pack_start(GTK_BOX(vbox), vpane, TRUE, TRUE, 0);
gtk_widget_unref (vpane);
gtk_box_pack_end(GTK_BOX(vbox), status_bar, FALSE, FALSE, 2);
notes_area_add_projects_tree (global_na, projects_tree);
/* we are done building it, make it visible */
gtk_widget_show(vbox);
gnome_app_set_contents(GNOME_APP(app_window), vbox);
gtt_status_icon_create();
if (!geometry_string) return;
if (gtk_window_parse_geometry(GTK_WINDOW(app_window),geometry_string))
{
geom_size_override=TRUE;
}
else
{
gnome_app_error(GNOME_APP(app_window),
_("Couldn't understand geometry (position and size)\n"
" specified on command line"));
}
}
/* Shows the preferences dialog on the given tab */
void show_preferences(gint tab) {
if(gtk_grab_get_current()) {
/* A window is already open, so we present it to the user */
GtkWidget *toplevel = gtk_widget_get_toplevel(gtk_grab_get_current());
gtk_window_present((GtkWindow*)toplevel);
return;
}
/* Declare some variables */
GtkWidget *frame, *label,
*alignment, *hbox,
*vbox;
GtkObject *adjustment, *adjustment_small, *adjustment_statics;
GtkTreeViewColumn *tree_column;
/* Create the dialog */
GtkWidget* dialog = gtk_dialog_new_with_buttons(_("Preferences"), NULL,
(GTK_DIALOG_MODAL + GTK_DIALOG_NO_SEPARATOR),
GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL);
gtk_window_set_icon((GtkWindow*)dialog, gtk_widget_render_icon(dialog, GTK_STOCK_PREFERENCES, GTK_ICON_SIZE_MENU, NULL));
gtk_window_set_resizable((GtkWindow*)dialog, FALSE);
/* Create notebook */
GtkWidget* notebook = gtk_notebook_new();
#if GTK_CHECK_VERSION (2,14,0)
gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area (GTK_DIALOG(dialog))), notebook, TRUE, TRUE, 2);
#else
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), notebook, TRUE, TRUE, 2);
#endif
/* Build the settings page */
GtkWidget* page_settings = gtk_alignment_new(0.50, 0.50, 1.0, 1.0);
gtk_alignment_set_padding((GtkAlignment*)page_settings, 12, 6, 12, 6);
gtk_notebook_append_page((GtkNotebook*)notebook, page_settings, gtk_label_new(_("Settings")));
GtkWidget* vbox_settings = gtk_vbox_new(FALSE, 12);
gtk_container_add((GtkContainer*)page_settings, vbox_settings);
/* Build the clipboards frame */
frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type((GtkFrame*)frame, GTK_SHADOW_NONE);
label = gtk_label_new(NULL);
gtk_label_set_markup((GtkLabel*)label, _("<b>Clipboards</b>"));
gtk_frame_set_label_widget((GtkFrame*)frame, label);
alignment = gtk_alignment_new(0.50, 0.50, 1.0, 1.0);
gtk_alignment_set_padding((GtkAlignment*)alignment, 12, 0, 12, 0);
gtk_container_add((GtkContainer*)frame, alignment);
vbox = gtk_vbox_new(FALSE, 2);
gtk_container_add((GtkContainer*)alignment, vbox);
copy_check = gtk_check_button_new_with_mnemonic(_("Use _Copy (Ctrl-C)"));
g_signal_connect((GObject*)copy_check, "toggled", (GCallback)check_toggled, NULL);
gtk_box_pack_start((GtkBox*)vbox, copy_check, FALSE, FALSE, 0);
primary_check = gtk_check_button_new_with_mnemonic(_("Use _Primary (Selection)"));
g_signal_connect((GObject*)primary_check, "toggled", (GCallback)check_toggled, NULL);
gtk_box_pack_start((GtkBox*)vbox, primary_check, FALSE, FALSE, 0);
synchronize_check = gtk_check_button_new_with_mnemonic(_("S_ynchronize clipboards"));
gtk_box_pack_start((GtkBox*)vbox, synchronize_check, FALSE, FALSE, 0);
paste_check = gtk_check_button_new_with_mnemonic(_("_Automatically paste selected item"));
g_signal_connect((GObject*)paste_check, "toggled", (GCallback)check_toggled, NULL);
gtk_box_pack_start((GtkBox*)vbox, paste_check, FALSE, FALSE, 0);
gtk_box_pack_start((GtkBox*)vbox_settings, frame, FALSE, FALSE, 0);
/* Build the miscellaneous frame */
frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type((GtkFrame*)frame, GTK_SHADOW_NONE);
label = gtk_label_new(NULL);
gtk_label_set_markup((GtkLabel*)label, _("<b>Miscellaneous</b>"));
gtk_frame_set_label_widget((GtkFrame*)frame, label);
alignment = gtk_alignment_new(0.50, 0.50, 1.0, 1.0);
gtk_alignment_set_padding((GtkAlignment*)alignment, 12, 0, 12, 0);
gtk_container_add((GtkContainer*)frame, alignment);
vbox = gtk_vbox_new(FALSE, 2);
gtk_container_add((GtkContainer*)alignment, vbox);
show_indexes_check = gtk_check_button_new_with_mnemonic(_("Show _indexes in history menu"));
gtk_box_pack_start((GtkBox*)vbox, show_indexes_check, FALSE, FALSE, 0);
save_uris_check = gtk_check_button_new_with_mnemonic(_("S_ave URIs"));
gtk_box_pack_start((GtkBox*)vbox, save_uris_check, FALSE, FALSE, 0);
hyperlinks_check = gtk_check_button_new_with_mnemonic(_("Capture _hyperlinks only"));
gtk_box_pack_start((GtkBox*)vbox, hyperlinks_check, FALSE, FALSE, 0);
confirm_check = gtk_check_button_new_with_mnemonic(_("C_onfirm before clearing history"));
gtk_box_pack_start((GtkBox*)vbox, confirm_check, FALSE, FALSE, 0);
use_rmb_menu_check = gtk_check_button_new_with_mnemonic(_("_Use right-click menu"));
gtk_box_pack_start((GtkBox*)vbox, use_rmb_menu_check, FALSE, FALSE, 0);
hbox = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0);
gtk_box_pack_start((GtkBox*)vbox_settings, frame, FALSE, FALSE, 0);
/* Build the history page */
GtkWidget* page_history = gtk_alignment_new(0.50, 0.50, 1.0, 1.0);
gtk_alignment_set_padding((GtkAlignment*)page_history, 12, 6, 12, 6);
gtk_notebook_append_page((GtkNotebook*)notebook, page_history, gtk_label_new(_("History")));
GtkWidget* vbox_history = gtk_vbox_new(FALSE, 12);
gtk_container_add((GtkContainer*)page_history, vbox_history);
/* Build the history frame */
frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type((GtkFrame*)frame, GTK_SHADOW_NONE);
label = gtk_label_new(NULL);
gtk_label_set_markup((GtkLabel*)label, _("<b>History</b>"));
gtk_frame_set_label_widget((GtkFrame*)frame, label);
alignment = gtk_alignment_new(0.50, 0.50, 1.0, 1.0);
gtk_alignment_set_padding((GtkAlignment*)alignment, 12, 0, 12, 0);
gtk_container_add((GtkContainer*)frame, alignment);
vbox = gtk_vbox_new(FALSE, 2);
gtk_container_add((GtkContainer*)alignment, vbox);
save_check = gtk_check_button_new_with_mnemonic(_("Save _history"));
gtk_widget_set_tooltip_text(save_check, _("Save and restore history between sessions"));
gtk_box_pack_start((GtkBox*)vbox, save_check, FALSE, FALSE, 0);
hbox = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0);
label = gtk_label_new(_("Items in history:"));
gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50);
gtk_box_pack_start((GtkBox*)hbox, label, FALSE, FALSE, 0);
adjustment = gtk_adjustment_new(25, 5, 1000, 1, 10, 0);
history_spin = gtk_spin_button_new((GtkAdjustment*)adjustment, 0.0, 0);
gtk_spin_button_set_update_policy((GtkSpinButton*)history_spin, GTK_UPDATE_IF_VALID);
gtk_box_pack_start((GtkBox*)hbox, history_spin, FALSE, FALSE, 0);
hbox = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0);
label = gtk_label_new(_("Items in menu:"));
gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50);
gtk_box_pack_start((GtkBox*)hbox, label, FALSE, FALSE, 0);
adjustment_small = gtk_adjustment_new(25, 5, 100, 1, 10, 0);
items_menu = gtk_spin_button_new((GtkAdjustment*)adjustment_small, 0.0, 0);
gtk_spin_button_set_update_policy((GtkSpinButton*)items_menu, GTK_UPDATE_IF_VALID);
gtk_box_pack_start((GtkBox*)hbox, items_menu, FALSE, FALSE, 0);
statics_show_check = gtk_check_button_new_with_mnemonic(_("Show _static items in menu"));
g_signal_connect((GObject*)statics_show_check, "toggled", (GCallback)check_toggled, NULL);
gtk_box_pack_start((GtkBox*)vbox, statics_show_check, FALSE, FALSE, 0);
hbox = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0);
label = gtk_label_new(_("Static items in menu:"));
gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50);
gtk_box_pack_start((GtkBox*)hbox, label, FALSE, FALSE, 0);
adjustment_statics = gtk_adjustment_new(10, 1, 100, 1, 10, 0);
statics_items_spin = gtk_spin_button_new((GtkAdjustment*)adjustment_statics, 0.0, 0);
gtk_spin_button_set_update_policy((GtkSpinButton*)statics_items_spin, GTK_UPDATE_IF_VALID);
gtk_box_pack_start((GtkBox*)hbox, statics_items_spin, FALSE, FALSE, 0);
gtk_box_pack_start((GtkBox*)vbox_history, frame, FALSE, FALSE, 0);
/* Build the items frame */
frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type((GtkFrame*)frame, GTK_SHADOW_NONE);
label = gtk_label_new(NULL);
gtk_label_set_markup((GtkLabel*)label, _("<b>Items</b>"));
gtk_frame_set_label_widget((GtkFrame*)frame, label);
alignment = gtk_alignment_new(0.50, 0.50, 1.0, 1.0);
gtk_alignment_set_padding((GtkAlignment*)alignment, 12, 0, 12, 0);
gtk_container_add((GtkContainer*)frame, alignment);
vbox = gtk_vbox_new(FALSE, 2);
gtk_container_add((GtkContainer*)alignment, vbox);
linemode_check = gtk_check_button_new_with_mnemonic(_("Show in a single _line"));
gtk_box_pack_start((GtkBox*)vbox, linemode_check, FALSE, FALSE, 0);
reverse_check = gtk_check_button_new_with_mnemonic(_("Show in _reverse order"));
gtk_box_pack_start((GtkBox*)vbox, reverse_check, FALSE, FALSE, 0);
hbox = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0);
label = gtk_label_new(_("Character length of items:"));
gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50);
gtk_box_pack_start((GtkBox*)hbox, label, FALSE, FALSE, 0);
adjustment = gtk_adjustment_new(50, 25, 75, 1, 5, 0);
charlength_spin = gtk_spin_button_new((GtkAdjustment*)adjustment, 0.0, 0);
gtk_spin_button_set_update_policy((GtkSpinButton*)charlength_spin, GTK_UPDATE_IF_VALID);
gtk_box_pack_start((GtkBox*)hbox, charlength_spin, FALSE, FALSE, 0);
hbox = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0);
label = gtk_label_new(_("Omit items in the:"));
gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50);
gtk_box_pack_start((GtkBox*)hbox, label, FALSE, FALSE, 0);
ellipsize_combo = gtk_combo_box_new_text();
gtk_combo_box_append_text((GtkComboBox*)ellipsize_combo, _("Beginning"));
gtk_combo_box_append_text((GtkComboBox*)ellipsize_combo, _("Middle"));
gtk_combo_box_append_text((GtkComboBox*)ellipsize_combo, _("End"));
gtk_box_pack_start((GtkBox*)hbox, ellipsize_combo, FALSE, FALSE, 0);
gtk_box_pack_start((GtkBox*)vbox_history, frame, FALSE, FALSE, 0);
/* Build the omitting frame
frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type((GtkFrame*)frame, GTK_SHADOW_NONE);
label = gtk_label_new(NULL);
gtk_label_set_markup((GtkLabel*)label, _("<b>Omitting</b>"));
gtk_frame_set_label_widget((GtkFrame*)frame, label);
alignment = gtk_alignment_new(0.50, 0.50, 1.0, 1.0);
gtk_alignment_set_padding((GtkAlignment*)alignment, 12, 0, 12, 0);
gtk_container_add((GtkContainer*)frame, alignment);
vbox = gtk_vbox_new(FALSE, 2);
gtk_container_add((GtkContainer*)alignment, vbox);
hbox = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0);
label = gtk_label_new(_("Omit items in the:"));
gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50);
gtk_box_pack_start((GtkBox*)hbox, label, FALSE, FALSE, 0);
ellipsize_combo = gtk_combo_box_new_text();
gtk_combo_box_append_text((GtkComboBox*)ellipsize_combo, _("Beginning"));
gtk_combo_box_append_text((GtkComboBox*)ellipsize_combo, _("Middle"));
gtk_combo_box_append_text((GtkComboBox*)ellipsize_combo, _("End"));
gtk_box_pack_start((GtkBox*)hbox, ellipsize_combo, FALSE, FALSE, 0);
gtk_box_pack_start((GtkBox*)vbox_history, frame, FALSE, FALSE, 0); */
/* Build the actions page */
GtkWidget* page_actions = gtk_alignment_new(0.50, 0.50, 1.0, 1.0);
gtk_alignment_set_padding((GtkAlignment*)page_actions, 6, 6, 6, 6);
gtk_notebook_append_page((GtkNotebook*)notebook, page_actions, gtk_label_new(_("Actions")));
GtkWidget* vbox_actions = gtk_vbox_new(FALSE, 6);
gtk_container_add((GtkContainer*)page_actions, vbox_actions);
/* Build the actions label */
label = gtk_label_new(_("Control-click ClipIt\'s tray icon to use actions"));
gtk_label_set_line_wrap((GtkLabel*)label, TRUE);
gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50);
gtk_box_pack_start((GtkBox*)vbox_actions, label, FALSE, FALSE, 0);
/* Build the actions treeview */
GtkWidget* scrolled_window = gtk_scrolled_window_new(
(GtkAdjustment*)gtk_adjustment_new(0, 0, 0, 0, 0, 0),
(GtkAdjustment*)gtk_adjustment_new(0, 0, 0, 0, 0, 0));
gtk_scrolled_window_set_policy((GtkScrolledWindow*)scrolled_window, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type((GtkScrolledWindow*)scrolled_window, GTK_SHADOW_ETCHED_OUT);
GtkWidget* treeview = gtk_tree_view_new();
gtk_tree_view_set_reorderable((GtkTreeView*)treeview, TRUE);
gtk_tree_view_set_rules_hint((GtkTreeView*)treeview, TRUE);
actions_list = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING, -1);
gtk_tree_view_set_model((GtkTreeView*)treeview, (GtkTreeModel*)actions_list);
GtkCellRenderer* name_renderer = gtk_cell_renderer_text_new();
g_object_set(name_renderer, "editable", TRUE, NULL);
g_signal_connect((GObject*)name_renderer, "edited", (GCallback)edit_action, (gpointer)0);
tree_column = gtk_tree_view_column_new_with_attributes(_("Action"), name_renderer, "text", 0, NULL);
gtk_tree_view_column_set_resizable(tree_column, TRUE);
gtk_tree_view_append_column((GtkTreeView*)treeview, tree_column);
GtkCellRenderer* command_renderer = gtk_cell_renderer_text_new();
g_object_set(command_renderer, "editable", TRUE, NULL);
g_object_set(command_renderer, "ellipsize-set", TRUE, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
g_signal_connect((GObject*)command_renderer, "edited", (GCallback)edit_action, (gpointer)1);
tree_column = gtk_tree_view_column_new_with_attributes(_("Command"), command_renderer, "text", 1, NULL);
gtk_tree_view_column_set_expand(tree_column, TRUE);
gtk_tree_view_append_column((GtkTreeView*)treeview, tree_column);
gtk_container_add((GtkContainer*)scrolled_window, treeview);
gtk_box_pack_start((GtkBox*)vbox_actions, scrolled_window, TRUE, TRUE, 0);
/* Edit selection and connect treeview related signals */
actions_selection = gtk_tree_view_get_selection((GtkTreeView*)treeview);
gtk_tree_selection_set_mode(actions_selection, GTK_SELECTION_BROWSE);
g_signal_connect((GObject*)treeview, "key-press-event", (GCallback)delete_key_pressed, NULL);
/* Build the buttons */
GtkWidget* hbbox = gtk_hbutton_box_new();
gtk_box_set_spacing((GtkBox*)hbbox, 6);
gtk_button_box_set_layout((GtkButtonBox*)hbbox, GTK_BUTTONBOX_START);
GtkWidget* add_button = gtk_button_new_with_label(_("Add..."));
gtk_button_set_image((GtkButton*)add_button, gtk_image_new_from_stock(GTK_STOCK_ADD, GTK_ICON_SIZE_MENU));
g_signal_connect((GObject*)add_button, "clicked", (GCallback)add_action, NULL);
gtk_box_pack_start((GtkBox*)hbbox, add_button, FALSE, TRUE, 0);
GtkWidget* remove_button = gtk_button_new_with_label(_("Remove"));
gtk_button_set_image((GtkButton*)remove_button, gtk_image_new_from_stock(GTK_STOCK_REMOVE, GTK_ICON_SIZE_MENU));
g_signal_connect((GObject*)remove_button, "clicked", (GCallback)remove_action, NULL);
gtk_box_pack_start((GtkBox*)hbbox, remove_button, FALSE, TRUE, 0);
GtkWidget* up_button = gtk_button_new();
gtk_button_set_image((GtkButton*)up_button, gtk_image_new_from_stock(GTK_STOCK_GO_UP, GTK_ICON_SIZE_MENU));
g_signal_connect((GObject*)up_button, "clicked", (GCallback)move_action_up, NULL);
gtk_box_pack_start((GtkBox*)hbbox, up_button, FALSE, TRUE, 0);
GtkWidget* down_button = gtk_button_new();
gtk_button_set_image((GtkButton*)down_button, gtk_image_new_from_stock(GTK_STOCK_GO_DOWN, GTK_ICON_SIZE_MENU));
g_signal_connect((GObject*)down_button, "clicked", (GCallback)move_action_down, NULL);
gtk_box_pack_start((GtkBox*)hbbox, down_button, FALSE, TRUE, 0);
gtk_box_pack_start((GtkBox*)vbox_actions, hbbox, FALSE, FALSE, 0);
/* Build the exclude page */
GtkWidget* page_exclude = gtk_alignment_new(0.50, 0.50, 1.0, 1.0);
gtk_alignment_set_padding((GtkAlignment*)page_exclude, 6, 6, 6, 6);
gtk_notebook_append_page((GtkNotebook*)notebook, page_exclude, gtk_label_new(_("Exclude")));
GtkWidget* vbox_exclude = gtk_vbox_new(FALSE, 6);
gtk_container_add((GtkContainer*)page_exclude, vbox_exclude);
/* Build the exclude label */
label = gtk_label_new(_("Regex list of items that should not be inserted into the history (passwords/sites that you don't need in history, etc)."));
gtk_label_set_line_wrap((GtkLabel*)label, TRUE);
gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50);
gtk_box_pack_start((GtkBox*)vbox_exclude, label, FALSE, FALSE, 0);
/* Build the exclude treeview */
GtkWidget* scrolled_window_exclude = gtk_scrolled_window_new(
(GtkAdjustment*)gtk_adjustment_new(0, 0, 0, 0, 0, 0),
(GtkAdjustment*)gtk_adjustment_new(0, 0, 0, 0, 0, 0));
gtk_scrolled_window_set_policy((GtkScrolledWindow*)scrolled_window_exclude, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type((GtkScrolledWindow*)scrolled_window_exclude, GTK_SHADOW_ETCHED_OUT);
GtkWidget* treeview_exclude = gtk_tree_view_new();
gtk_tree_view_set_reorderable((GtkTreeView*)treeview_exclude, TRUE);
gtk_tree_view_set_rules_hint((GtkTreeView*)treeview_exclude, TRUE);
exclude_list = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING, -1);
gtk_tree_view_set_model((GtkTreeView*)treeview_exclude, (GtkTreeModel*)exclude_list);
GtkCellRenderer* name_renderer_exclude = gtk_cell_renderer_text_new();
g_object_set(name_renderer_exclude, "editable", TRUE, NULL);
g_signal_connect((GObject*)name_renderer_exclude, "edited", (GCallback)edit_exclude, (gpointer)0);
tree_column = gtk_tree_view_column_new_with_attributes(_("Regex"), name_renderer_exclude, "text", 0, NULL);
gtk_tree_view_column_set_resizable(tree_column, TRUE);
gtk_tree_view_append_column((GtkTreeView*)treeview_exclude, tree_column);
gtk_container_add((GtkContainer*)scrolled_window_exclude, treeview_exclude);
gtk_box_pack_start((GtkBox*)vbox_exclude, scrolled_window_exclude, TRUE, TRUE, 0);
/* Edit selection and connect treeview related signals */
exclude_selection = gtk_tree_view_get_selection((GtkTreeView*)treeview_exclude);
gtk_tree_selection_set_mode(exclude_selection, GTK_SELECTION_BROWSE);
g_signal_connect((GObject*)treeview_exclude, "key-press-event", (GCallback)delete_key_pressed, NULL);
/* Build the buttons */
GtkWidget* hbbox_exclude = gtk_hbutton_box_new();
gtk_box_set_spacing((GtkBox*)hbbox_exclude, 6);
gtk_button_box_set_layout((GtkButtonBox*)hbbox_exclude, GTK_BUTTONBOX_START);
GtkWidget* add_button_exclude = gtk_button_new_with_label(_("Add..."));
gtk_button_set_image((GtkButton*)add_button_exclude, gtk_image_new_from_stock(GTK_STOCK_ADD, GTK_ICON_SIZE_MENU));
g_signal_connect((GObject*)add_button_exclude, "clicked", (GCallback)add_exclude, NULL);
gtk_box_pack_start((GtkBox*)hbbox_exclude, add_button_exclude, FALSE, TRUE, 0);
GtkWidget* remove_button_exclude = gtk_button_new_with_label(_("Remove"));
gtk_button_set_image((GtkButton*)remove_button_exclude, gtk_image_new_from_stock(GTK_STOCK_REMOVE, GTK_ICON_SIZE_MENU));
g_signal_connect((GObject*)remove_button_exclude, "clicked", (GCallback)remove_exclude, NULL);
gtk_box_pack_start((GtkBox*)hbbox_exclude, remove_button_exclude, FALSE, TRUE, 0);
gtk_box_pack_start((GtkBox*)vbox_exclude, hbbox_exclude, FALSE, FALSE, 0);
/* Build the hotkeys page */
GtkWidget* page_extras = gtk_alignment_new(0.50, 0.50, 1.0, 1.0);
gtk_alignment_set_padding((GtkAlignment*)page_extras, 12, 6, 12, 6);
gtk_notebook_append_page((GtkNotebook*)notebook, page_extras, gtk_label_new(_("Hotkeys")));
GtkWidget* vbox_extras = gtk_vbox_new(FALSE, 12);
gtk_container_add((GtkContainer*)page_extras, vbox_extras);
/* Build the hotkeys frame */
frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type((GtkFrame*)frame, GTK_SHADOW_NONE);
label = gtk_label_new(NULL);
gtk_label_set_markup((GtkLabel*)label, _("<b>Hotkeys</b>"));
gtk_frame_set_label_widget((GtkFrame*)frame, label);
alignment = gtk_alignment_new(0.50, 0.50, 1.0, 1.0);
gtk_alignment_set_padding((GtkAlignment*)alignment, 12, 0, 12, 0);
gtk_container_add((GtkContainer*)frame, alignment);
vbox = gtk_vbox_new(FALSE, 2);
gtk_container_add((GtkContainer*)alignment, vbox);
/* History key combination */
hbox = gtk_hbox_new(TRUE, 4);
gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0);
label = gtk_label_new(_("History hotkey:"));
gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50);
gtk_box_pack_start((GtkBox*)hbox, label, TRUE, TRUE, 0);
history_key_entry = gtk_entry_new();
gtk_entry_set_width_chars((GtkEntry*)history_key_entry, 10);
gtk_box_pack_end((GtkBox*)hbox, history_key_entry, TRUE, TRUE, 0);
/* Actions key combination */
hbox = gtk_hbox_new(TRUE, 4);
gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0);
label = gtk_label_new(_("Actions hotkey:"));
gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50);
gtk_box_pack_start((GtkBox*)hbox, label, TRUE, TRUE, 0);
actions_key_entry = gtk_entry_new();
gtk_entry_set_width_chars((GtkEntry*)actions_key_entry, 10);
gtk_box_pack_end((GtkBox*)hbox, actions_key_entry, TRUE, TRUE, 0);
/* Menu key combination */
hbox = gtk_hbox_new(TRUE, 4);
gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0);
label = gtk_label_new(_("Menu hotkey:"));
gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50);
gtk_box_pack_start((GtkBox*)hbox, label, TRUE, TRUE, 0);
menu_key_entry = gtk_entry_new();
gtk_entry_set_width_chars((GtkEntry*)menu_key_entry, 10);
gtk_box_pack_end((GtkBox*)hbox, menu_key_entry, TRUE, TRUE, 0);
/* Search key combination */
hbox = gtk_hbox_new(TRUE, 4);
gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0);
label = gtk_label_new(_("Manage hotkey:"));
gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50);
gtk_box_pack_start((GtkBox*)hbox, label, TRUE, TRUE, 0);
search_key_entry = gtk_entry_new();
gtk_entry_set_width_chars((GtkEntry*)search_key_entry, 10);
gtk_box_pack_end((GtkBox*)hbox, search_key_entry, TRUE, TRUE, 0);
/* Offline mode key combination */
hbox = gtk_hbox_new(TRUE, 4);
gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0);
label = gtk_label_new(_("Offline mode hotkey:"));
gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50);
gtk_box_pack_start((GtkBox*)hbox, label, TRUE, TRUE, 0);
offline_key_entry = gtk_entry_new();
gtk_entry_set_width_chars((GtkEntry*)offline_key_entry, 10);
gtk_box_pack_end((GtkBox*)hbox, offline_key_entry, TRUE, TRUE, 0);
gtk_box_pack_start((GtkBox*)vbox_extras, frame, FALSE, FALSE, 0);
/* Make widgets reflect current preferences */
gtk_toggle_button_set_active((GtkToggleButton*)copy_check, prefs.use_copy);
gtk_toggle_button_set_active((GtkToggleButton*)primary_check, prefs.use_primary);
gtk_toggle_button_set_active((GtkToggleButton*)synchronize_check, prefs.synchronize);
gtk_toggle_button_set_active((GtkToggleButton*)paste_check, prefs.automatic_paste);
gtk_toggle_button_set_active((GtkToggleButton*)show_indexes_check, prefs.show_indexes);
gtk_toggle_button_set_active((GtkToggleButton*)save_uris_check, prefs.save_uris);
gtk_toggle_button_set_active((GtkToggleButton*)use_rmb_menu_check, prefs.use_rmb_menu);
gtk_toggle_button_set_active((GtkToggleButton*)save_check, prefs.save_history);
gtk_spin_button_set_value((GtkSpinButton*)history_spin, (gdouble)prefs.history_limit);
gtk_spin_button_set_value((GtkSpinButton*)items_menu, (gdouble)prefs.items_menu);
gtk_toggle_button_set_active((GtkToggleButton*)statics_show_check, prefs.statics_show);
gtk_spin_button_set_value((GtkSpinButton*)statics_items_spin, (gdouble)prefs.statics_items);
gtk_toggle_button_set_active((GtkToggleButton*)hyperlinks_check, prefs.hyperlinks_only);
gtk_toggle_button_set_active((GtkToggleButton*)confirm_check, prefs.confirm_clear);
gtk_toggle_button_set_active((GtkToggleButton*)linemode_check, prefs.single_line);
gtk_toggle_button_set_active((GtkToggleButton*)reverse_check, prefs.reverse_history);
gtk_spin_button_set_value((GtkSpinButton*)charlength_spin, (gdouble)prefs.item_length);
gtk_combo_box_set_active((GtkComboBox*)ellipsize_combo, prefs.ellipsize - 1);
gtk_entry_set_text((GtkEntry*)history_key_entry, prefs.history_key);
gtk_entry_set_text((GtkEntry*)actions_key_entry, prefs.actions_key);
gtk_entry_set_text((GtkEntry*)menu_key_entry, prefs.menu_key);
gtk_entry_set_text((GtkEntry*)search_key_entry, prefs.search_key);
gtk_entry_set_text((GtkEntry*)offline_key_entry, prefs.offline_key);
/* Read actions */
read_actions();
read_excludes();
/* Run the dialog */
gtk_widget_show_all(dialog);
#ifdef HAVE_APPINDICATOR
gtk_widget_hide(use_rmb_menu_check);
#endif
gtk_notebook_set_current_page((GtkNotebook*)notebook, tab);
if (gtk_dialog_run((GtkDialog*)dialog) == GTK_RESPONSE_ACCEPT)
{
/* If the user disabled history saving, we ask him if he wants to delete the history file */
if(prefs.save_history && !gtk_toggle_button_get_active((GtkToggleButton*)save_check))
check_saved_hist_file();
/* Apply and save preferences */
apply_preferences();
save_preferences();
save_actions();
save_excludes();
}
gtk_widget_destroy(dialog);
}
TextReplacementDialog::TextReplacementDialog(int dummy)
{
// Get configurations.
extern Settings *settings;
// Shortcuts.
Shortcuts shortcuts(0);
textreplacementdialog = gtk_dialog_new();
gtk_window_set_title(GTK_WINDOW(textreplacementdialog), _("Text Replacement"));
gtk_window_set_position(GTK_WINDOW(textreplacementdialog), GTK_WIN_POS_CENTER_ON_PARENT);
gtk_window_set_modal(GTK_WINDOW(textreplacementdialog), TRUE);
gtk_window_set_type_hint(GTK_WINDOW(textreplacementdialog), GDK_WINDOW_TYPE_HINT_DIALOG);
dialog_vbox1 = gtk_dialog_get_content_area (GTK_DIALOG(textreplacementdialog));
gtk_widget_show(dialog_vbox1);
vbox1 = gtk_vbox_new(FALSE, 2);
gtk_widget_show(vbox1);
gtk_box_pack_start(GTK_BOX(dialog_vbox1), vbox1, TRUE, TRUE, 0);
checkbutton1 = gtk_check_button_new_with_mnemonic(_("Replace text when printing and exporting"));
gtk_widget_show(checkbutton1);
gtk_box_pack_start(GTK_BOX(vbox1), checkbutton1, FALSE, FALSE, 0);
shortcuts.button(checkbutton1);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton1), settings->genconfig.text_replacement_get());
scrolledwindow1 = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_show(scrolledwindow1);
gtk_box_pack_start(GTK_BOX(vbox1), scrolledwindow1, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow1), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwindow1), GTK_SHADOW_IN);
treeview1 = gtk_tree_view_new();
gtk_widget_show(treeview1);
gtk_container_add(GTK_CONTAINER(scrolledwindow1), treeview1);
gtk_tree_view_set_reorderable(GTK_TREE_VIEW(treeview1), TRUE);
dialog_action_area1 = gtk_dialog_get_action_area (GTK_DIALOG(textreplacementdialog));
gtk_widget_show(dialog_action_area1);
gtk_button_box_set_layout(GTK_BUTTON_BOX(dialog_action_area1), GTK_BUTTONBOX_END);
new InDialogHelp(textreplacementdialog, NULL, &shortcuts, "menu-preferences/text-replacement");
cancelbutton1 = gtk_button_new_from_stock("gtk-cancel");
gtk_widget_show(cancelbutton1);
gtk_dialog_add_action_widget(GTK_DIALOG(textreplacementdialog), cancelbutton1, GTK_RESPONSE_CANCEL);
gtk_widget_set_can_default (GTK_WIDGET (cancelbutton1), true);
shortcuts.stockbutton(cancelbutton1);
okbutton1 = gtk_button_new_from_stock("gtk-ok");
gtk_widget_show(okbutton1);
gtk_dialog_add_action_widget(GTK_DIALOG(textreplacementdialog), okbutton1, GTK_RESPONSE_OK);
gtk_widget_set_can_default (GTK_WIDGET (okbutton1), true);
shortcuts.stockbutton(okbutton1);
shortcuts.process();
g_signal_connect((gpointer) checkbutton1, "toggled", G_CALLBACK(on_checkbutton1_toggled), gpointer(this));
g_signal_connect((gpointer) okbutton1, "clicked", G_CALLBACK(on_okbutton1_clicked), gpointer(this));
gtk_widget_grab_focus(okbutton1);
gtk_widget_grab_default(okbutton1);
// Toggle button.
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton1), settings->genconfig.text_replacement_get());
// Storage, renderer, column and selection.
model = gtk_list_store_new(NUM_COLUMNS, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_BOOLEAN);
gtk_tree_view_set_model(GTK_TREE_VIEW(treeview1), GTK_TREE_MODEL(model));
g_object_unref(model);
GtkCellRenderer *renderer1 = gtk_cell_renderer_text_new();
g_signal_connect(renderer1, "edited", G_CALLBACK(cell_text_edited), gpointer(this));
gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(treeview1), -1, "Texts", renderer1, "text", COLUMN_ORIGINALS, "editable", COLUMN_EDITABLE1, NULL);
GtkCellRenderer *renderer2 = gtk_cell_renderer_text_new();
g_signal_connect(renderer2, "edited", G_CALLBACK(cell_replacement_edited), gpointer(this));
gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(treeview1), -1, "Replacements", renderer2, "text", COLUMN_REPLACEMENTS, "editable", COLUMN_EDITABLE2, NULL);
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview1)), GTK_SELECTION_SINGLE);
// Load texts and replacements - these get initialized to defaults if there were none.
vector < ustring > originals;
vector < ustring > replacements;
text_replacement_get_words(originals, replacements);
GtkTreeIter iter;
for (unsigned int i = 0; i < originals.size(); i++) {
gtk_list_store_append(model, &iter);
gtk_list_store_set(model, &iter, COLUMN_ORIGINALS, originals[i].c_str(), COLUMN_EDITABLE1, 1, COLUMN_REPLACEMENTS, replacements[i].c_str(), COLUMN_EDITABLE2, 1, -1);
}
gui();
new DialogAutoScaler (textreplacementdialog, G_MAXINT);
}
static GtkWidget *
key_dialog_treeview_new (GtkWidget *box)
{
GtkWidget *scroll;
GtkListStore *store, *combostore;
GtkTreeViewColumn *col;
GtkWidget *view;
GtkCellRenderer *render;
int i;
scroll = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scroll), GTK_SHADOW_IN);
store = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING);
g_return_val_if_fail (store != NULL, NULL);
view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
gtk_tree_view_set_fixed_height_mode (GTK_TREE_VIEW (view), TRUE);
gtk_tree_view_set_enable_search (GTK_TREE_VIEW (view), FALSE);
gtk_tree_view_set_reorderable (GTK_TREE_VIEW (view), TRUE);
g_signal_connect (G_OBJECT (view), "key-press-event",
G_CALLBACK (key_dialog_keypress), NULL);
g_signal_connect (G_OBJECT (gtk_tree_view_get_selection (GTK_TREE_VIEW(view))),
"changed", G_CALLBACK (key_dialog_selection_changed), NULL);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (view), TRUE);
render = gtk_cell_renderer_accel_new ();
g_object_set (render, "editable", TRUE,
#ifndef WIN32
"accel-mode", GTK_CELL_RENDERER_ACCEL_MODE_OTHER,
#endif
NULL);
g_signal_connect (G_OBJECT (render), "accel-edited",
G_CALLBACK (key_dialog_set_key), NULL);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (view), KEY_COLUMN,
"Key", render,
"text", KEY_COLUMN,
NULL);
render = gtk_cell_renderer_text_new ();
gtk_tree_view_insert_column_with_attributes (
GTK_TREE_VIEW (view), ACCEL_COLUMN,
"Accel", render,
"text", ACCEL_COLUMN,
NULL);
combostore = gtk_list_store_new (1, G_TYPE_STRING);
for (i = 0; i <= KEY_MAX_ACTIONS; i++)
{
GtkTreeIter iter;
if (key_actions[i].name[0])
{
gtk_list_store_append (combostore, &iter);
gtk_list_store_set (combostore, &iter, 0, key_actions[i].name, -1);
}
}
render = gtk_cell_renderer_combo_new ();
g_object_set (G_OBJECT (render), "model", combostore,
"has-entry", FALSE,
"editable", TRUE,
"text-column", 0,
NULL);
g_signal_connect (G_OBJECT (render), "edited",
G_CALLBACK (key_dialog_entry_edited), GINT_TO_POINTER (ACTION_COLUMN));
g_signal_connect (G_OBJECT (render), "changed",
G_CALLBACK (key_dialog_combo_changed), combostore);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (view), ACTION_COLUMN,
"Action", render,
"text", ACTION_COLUMN,
NULL);
render = gtk_cell_renderer_text_new ();
g_object_set (render, "editable", TRUE, NULL);
g_signal_connect (G_OBJECT (render), "edited",
G_CALLBACK (key_dialog_entry_edited), GINT_TO_POINTER (D1_COLUMN));
gtk_tree_view_insert_column_with_attributes (
GTK_TREE_VIEW (view), D1_COLUMN,
"Data1", render,
"text", D1_COLUMN,
NULL);
render = gtk_cell_renderer_text_new ();
g_object_set (render, "editable", TRUE, NULL);
g_signal_connect (G_OBJECT (render), "edited",
G_CALLBACK (key_dialog_entry_edited), GINT_TO_POINTER (D2_COLUMN));
gtk_tree_view_insert_column_with_attributes (
GTK_TREE_VIEW (view), D2_COLUMN,
"Data2", render,
"text", D2_COLUMN,
NULL);
col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), KEY_COLUMN);
gtk_tree_view_column_set_fixed_width (col, 200);
gtk_tree_view_column_set_resizable (col, TRUE);
col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), ACCEL_COLUMN);
gtk_tree_view_column_set_visible (col, FALSE);
col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), ACTION_COLUMN);
gtk_tree_view_column_set_fixed_width (col, 160);
col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), D1_COLUMN);
gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_min_width (col, 80);
gtk_tree_view_column_set_resizable (col, TRUE);
col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), D2_COLUMN);
gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_min_width (col, 80);
gtk_tree_view_column_set_resizable (col, TRUE);
gtk_container_add (GTK_CONTAINER (scroll), view);
gtk_container_add (GTK_CONTAINER (box), scroll);
return view;
}
static void
pluma_documents_panel_init (PlumaDocumentsPanel *panel)
{
GtkWidget *sw;
GtkTreeViewColumn *column;
GtkCellRenderer *cell;
GtkTreeSelection *selection;
panel->priv = PLUMA_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);
g_return_if_fail (sw != NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
GTK_SHADOW_IN);
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_list_store_new (N_COLUMNS,
GDK_TYPE_PIXBUF,
G_TYPE_STRING,
G_TYPE_POINTER));
/* 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), TRUE);
g_object_set (panel->priv->treeview, "has-tooltip", TRUE, NULL);
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);
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);
selection = gtk_tree_view_get_selection (
GTK_TREE_VIEW (panel->priv->treeview));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
g_signal_connect (panel->priv->treeview,
"cursor_changed",
G_CALLBACK (treeview_cursor_changed),
panel);
g_signal_connect (panel->priv->treeview,
"button-press-event",
G_CALLBACK (panel_button_press_event),
panel);
g_signal_connect (panel->priv->treeview,
"popup-menu",
G_CALLBACK (panel_popup_menu),
panel);
g_signal_connect (panel->priv->treeview,
"query-tooltip",
G_CALLBACK (treeview_query_tooltip),
NULL);
g_signal_connect (panel->priv->model,
"row-inserted",
G_CALLBACK (treeview_row_inserted),
panel);
}
static TBEditorWidget *tb_editor_create_dialog(MarlinViewWindow *mvw)
{
GtkWidget *dialog, *vbox, *hbox, *vbox_buttons, *button_add, *button_remove;
GtkWidget *swin_available, *swin_used, *tree_available, *tree_used, *label;
GtkCellRenderer *text_renderer, *icon_renderer;
GtkTreeViewColumn *column;
TBEditorWidget *tbw = g_new(TBEditorWidget, 1);
dialog = gtk_dialog_new_with_buttons(_("Customize Toolbar"),
GTK_WINDOW (mvw),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL);
vbox = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
gtk_widget_set_name(dialog, "GeanyDialog");
gtk_window_set_default_size(GTK_WINDOW(dialog), 400, 300);
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_CLOSE);
tbw->store_available = gtk_list_store_new(TB_EDITOR_COLS_MAX,
G_TYPE_STRING, G_TYPE_STRING, GDK_TYPE_PIXBUF);
tbw->store_used = gtk_list_store_new(TB_EDITOR_COLS_MAX,
G_TYPE_STRING, G_TYPE_STRING, GDK_TYPE_PIXBUF);
label = gtk_label_new(_("Select items to be displayed on the toolbar. Items can be reordered by drag and drop."));
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
tree_available = gtk_tree_view_new();
gtk_tree_view_set_model(GTK_TREE_VIEW(tree_available), GTK_TREE_MODEL(tbw->store_available));
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tree_available), TRUE);
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(tbw->store_available), TB_EDITOR_COL_LABEL, GTK_SORT_ASCENDING);
icon_renderer = gtk_cell_renderer_pixbuf_new();
column = gtk_tree_view_column_new_with_attributes(NULL, icon_renderer, "pixbuf", TB_EDITOR_COL_ICON, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree_available), column);
text_renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("Available Items"), text_renderer, "text", TB_EDITOR_COL_LABEL, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree_available), column);
swin_available = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(swin_available),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(swin_available), GTK_SHADOW_ETCHED_IN);
gtk_container_add(GTK_CONTAINER(swin_available), tree_available);
tree_used = gtk_tree_view_new();
gtk_tree_view_set_model(GTK_TREE_VIEW(tree_used), GTK_TREE_MODEL(tbw->store_used));
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tree_used), TRUE);
gtk_tree_view_set_reorderable(GTK_TREE_VIEW(tree_used), TRUE);
icon_renderer = gtk_cell_renderer_pixbuf_new();
column = gtk_tree_view_column_new_with_attributes(NULL, icon_renderer, "pixbuf", TB_EDITOR_COL_ICON, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree_used), column);
text_renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("Displayed Items"), text_renderer, "text", TB_EDITOR_COL_LABEL, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree_used), column);
swin_used = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(swin_used),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(swin_used), GTK_SHADOW_ETCHED_IN);
gtk_container_add(GTK_CONTAINER(swin_used), tree_used);
/* drag'n'drop */
gtk_tree_view_enable_model_drag_source(GTK_TREE_VIEW(tree_available), GDK_BUTTON1_MASK,
tb_editor_dnd_targets, tb_editor_dnd_targets_len, GDK_ACTION_MOVE);
gtk_tree_view_enable_model_drag_dest(GTK_TREE_VIEW(tree_available),
tb_editor_dnd_targets, tb_editor_dnd_targets_len, GDK_ACTION_MOVE);
g_signal_connect(tree_available, "drag-data-get",
G_CALLBACK(tb_editor_drag_data_get_cb), tbw);
g_signal_connect(tree_available, "drag-data-received",
G_CALLBACK(tb_editor_drag_data_rcvd_cb), tbw);
g_signal_connect(tree_available, "drag-motion",
G_CALLBACK(tb_editor_drag_motion_cb), tbw);
gtk_tree_view_enable_model_drag_source(GTK_TREE_VIEW(tree_used), GDK_BUTTON1_MASK,
tb_editor_dnd_targets, tb_editor_dnd_targets_len, GDK_ACTION_MOVE);
gtk_tree_view_enable_model_drag_dest(GTK_TREE_VIEW(tree_used),
tb_editor_dnd_targets, tb_editor_dnd_targets_len, GDK_ACTION_MOVE);
g_signal_connect(tree_used, "drag-data-get",
G_CALLBACK(tb_editor_drag_data_get_cb), tbw);
g_signal_connect(tree_used, "drag-data-received",
G_CALLBACK(tb_editor_drag_data_rcvd_cb), tbw);
g_signal_connect(tree_used, "drag-motion",
G_CALLBACK(tb_editor_drag_motion_cb), tbw);
button_add = gtk_button_new();
gtk_button_set_image(GTK_BUTTON(button_add),
gtk_image_new_from_stock(GTK_STOCK_GO_FORWARD, GTK_ICON_SIZE_BUTTON));
button_remove = gtk_button_new();
g_signal_connect(button_add, "clicked", G_CALLBACK(tb_editor_btn_add_clicked_cb), tbw);
gtk_button_set_image(GTK_BUTTON(button_remove),
gtk_image_new_from_stock(GTK_STOCK_GO_BACK, GTK_ICON_SIZE_BUTTON));
g_signal_connect(button_remove, "clicked", G_CALLBACK(tb_editor_btn_remove_clicked_cb), tbw);
vbox_buttons = gtk_box_new(GTK_ORIENTATION_VERTICAL, 6);
/* FIXME this is a little hack'ish, any better ideas? */
gtk_box_pack_start(GTK_BOX(vbox_buttons), gtk_label_new(""), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox_buttons), button_add, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_buttons), button_remove, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_buttons), gtk_label_new(""), TRUE, TRUE, 0);
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start(GTK_BOX(hbox), swin_available, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), vbox_buttons, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), swin_used, TRUE, TRUE, 0);
g_object_set (label, "margin", 5, NULL);
g_object_set (hbox, "margin", 5, NULL);
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
gtk_widget_show_all(vbox);
g_object_unref(tbw->store_available);
g_object_unref(tbw->store_used);
tbw->dialog = dialog;
tbw->tree_available = GTK_TREE_VIEW(tree_available);
tbw->tree_used = GTK_TREE_VIEW(tree_used);
tbw->last_drag_path = NULL;
return tbw;
}
