static pid_t
attach_process_show (AttachProcess * ap, GtkWindow *parent)
{
GtkTreeView *view;
GtkTreeStore *store;
GtkCellRenderer *renderer;
GtkTreeSelection *selection;
GtkCheckButton *checkb_hide_paths;
GtkCheckButton *checkb_hide_params;
GtkCheckButton *checkb_process_tree;
gint i, res;
pid_t selected_pid = -1;
g_return_val_if_fail (ap != NULL, -1);
if (!ap->dialog)
{
GtkBuilder *bxml;
bxml = anjuta_util_builder_new (GLADE_FILE, NULL);
if (!bxml) return 0;
anjuta_util_builder_get_objects (bxml,
"attach_process_dialog", &ap->dialog,
"attach_process_tv", &ap->treeview,
"checkb_hide_paths", &checkb_hide_paths,
"checkb_hide_params", &checkb_hide_params,
"checkb_process_tree", &checkb_process_tree,
NULL);
g_object_unref (bxml);
view = GTK_TREE_VIEW (ap->treeview);
store = gtk_tree_store_new (COLUMNS_NB,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING);
gtk_tree_view_set_model (view, GTK_TREE_MODEL (store));
gtk_tree_selection_set_mode (gtk_tree_view_get_selection (view),
GTK_SELECTION_SINGLE);
g_object_unref (G_OBJECT (store));
renderer = gtk_cell_renderer_text_new ();
for (i = PID_COLUMN; i < COLUMNS_NB; i++) {
GtkTreeViewColumn *column;
column = gtk_tree_view_column_new_with_attributes (column_names[i],
renderer, "text", i, NULL);
gtk_tree_view_column_set_sort_column_id(column, i);
gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_append_column (view, column);
if (i == COMMAND_COLUMN)
gtk_tree_view_set_expander_column(view, column);
}
gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (store), PID_COLUMN,
sort_pid, NULL, NULL);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (store),
START_COLUMN, GTK_SORT_DESCENDING);
ap->hide_paths = gtk_toggle_button_get_active (
GTK_TOGGLE_BUTTON (checkb_hide_paths));
ap->hide_params = gtk_toggle_button_get_active (
GTK_TOGGLE_BUTTON (checkb_hide_params));
ap->process_tree = gtk_toggle_button_get_active (
GTK_TOGGLE_BUTTON (checkb_process_tree));
attach_process_update (ap);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (ap->treeview));
g_signal_connect (G_OBJECT (selection), "changed",
G_CALLBACK (on_selection_changed), ap);
g_signal_connect (G_OBJECT (ap->dialog), "delete_event",
G_CALLBACK (on_delete_event), ap);
g_signal_connect (checkb_hide_paths, "toggled",
G_CALLBACK (on_toggle_hide_paths), ap);
g_signal_connect (checkb_hide_params, "toggled",
G_CALLBACK (on_toggle_hide_params), ap);
g_signal_connect (checkb_process_tree, "toggled",
G_CALLBACK (on_toggle_process_tree), ap);
}
gtk_window_set_transient_for (GTK_WINDOW (ap->dialog),
GTK_WINDOW (parent));
/* gtk_widget_show (ap->dialog); */
res = gtk_dialog_run (GTK_DIALOG (ap->dialog));
while (res == GTK_RESPONSE_APPLY)
{
attach_process_update (ap);
res = gtk_dialog_run (GTK_DIALOG (ap->dialog));
}
if (res == GTK_RESPONSE_OK)
{
selected_pid = ap->pid;
}
attach_process_clear (ap, CLEAR_FINAL);
return selected_pid;
}
static GtkWidget *
pidgin_get_mail_dialog(void)
{
if (mail_dialog == NULL) {
GtkWidget *dialog = NULL;
GtkWidget *label;
GtkWidget *sw;
GtkCellRenderer *rend;
GtkTreeViewColumn *column;
GtkWidget *button = NULL;
GtkWidget *vbox = NULL;
dialog = gtk_dialog_new_with_buttons(_("New Mail"), NULL, 0,
GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
NULL);
gtk_window_set_role(GTK_WINDOW(dialog), "new_mail_detailed");
g_signal_connect(G_OBJECT(dialog), "focus-in-event",
G_CALLBACK(mail_window_focus_cb), NULL);
gtk_dialog_add_button(GTK_DIALOG(dialog),
_("Open All Messages"), GTK_RESPONSE_ACCEPT);
button = gtk_dialog_add_button(GTK_DIALOG(dialog),
PIDGIN_STOCK_OPEN_MAIL, GTK_RESPONSE_YES);
/* make "Open All Messages" the default response */
gtk_dialog_set_default_response(GTK_DIALOG(dialog),
GTK_RESPONSE_ACCEPT);
/* Setup the dialog */
gtk_container_set_border_width(GTK_CONTAINER(dialog), PIDGIN_HIG_BOX_SPACE);
gtk_container_set_border_width(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), PIDGIN_HIG_BOX_SPACE);
gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE);
gtk_box_set_spacing(GTK_BOX(GTK_DIALOG(dialog)->vbox), PIDGIN_HIG_BORDER);
/* Vertical box */
vbox = GTK_DIALOG(dialog)->vbox;
/* Golden ratio it up! */
gtk_widget_set_size_request(dialog, 550, 400);
sw = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW(sw), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
mail_dialog = g_new0(PidginMailDialog, 1);
mail_dialog->dialog = dialog;
mail_dialog->open_button = button;
mail_dialog->treemodel = gtk_tree_store_new(COLUMNS_PIDGIN_MAIL,
GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_POINTER);
mail_dialog->treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(mail_dialog->treemodel));
g_object_unref(G_OBJECT(mail_dialog->treemodel));
gtk_tree_view_set_search_column(GTK_TREE_VIEW(mail_dialog->treeview), PIDGIN_MAIL_TEXT);
gtk_tree_view_set_search_equal_func(GTK_TREE_VIEW(mail_dialog->treeview),
pidgin_tree_view_search_equal_func, NULL, NULL);
g_signal_connect(G_OBJECT(dialog), "response",
G_CALLBACK(email_response_cb), mail_dialog);
g_signal_connect(G_OBJECT(gtk_tree_view_get_selection(GTK_TREE_VIEW(mail_dialog->treeview))),
"changed", G_CALLBACK(selection_changed_cb), mail_dialog);
g_signal_connect(G_OBJECT(mail_dialog->treeview), "row-activated", G_CALLBACK(email_row_activated_cb), NULL);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(mail_dialog->treeview), FALSE);
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(mail_dialog->treeview), TRUE);
gtk_container_add(GTK_CONTAINER(sw), mail_dialog->treeview);
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_resizable(column, TRUE);
rend = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(column, rend, FALSE);
gtk_tree_view_column_set_attributes(column, rend, "pixbuf", PIDGIN_MAIL_ICON, NULL);
rend = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, rend, TRUE);
gtk_tree_view_column_set_attributes(column, rend, "markup", PIDGIN_MAIL_TEXT, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(mail_dialog->treeview), column);
label = gtk_label_new(NULL);
gtk_label_set_markup(GTK_LABEL(label), _("<span weight=\"bold\" size=\"larger\">You have mail!</span>"));
gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0);
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), sw, TRUE, TRUE, 0);
}
return mail_dialog->dialog;
}
static GtkTreeModel *
gnac_ui_file_chooser_get_filters_model(void)
{
guint i;
GSList *f;
GtkFileFilter *filter;
GtkTreeIter iter1, iter2, iter3;
GtkTreeStore *store;
/* To translators: translation of filters' name can be
* found in /usr/share/mime */
const gchar *lossy_mime[][2] = {
{ "audio/mpeg" , _("MP3 audio") },
{ "audio/mp4" , _("MPEG-4 audio") },
{ "audio/x-musepack" , _("Musepack audio") },
{ "audio/ogg" , _("Ogg Audio") },
{ "audio/vnd.rn-realaudio", _("RealAudio document") },
{ "audio/x-speex" , _("Speex audio") },
{ "audio/x-ms-wma" , _("Windows Media audio") },
{ NULL, NULL }
};
const gchar *lossless_mime[][2] = {
{ "audio/x-ape" , _("Monkey's audio") },
{ "audio/x-flac" , _("Flac audio") },
{ "audio/x-wav" , _("WAV audio") },
{ "audio/x-wavpack", _("WavPack audio") },
{ NULL, NULL }
};
const gchar *playlists_mime[][2] = {
{ "audio/x-ms-asx" , _("Microsoft ASX playlist") },
{ "audio/x-mpegurl" , _("MP3 audio (streamed)") },
{ "audio/x-scpls" , _("MP3 ShoutCast playlist") },
{ "application/xspf+xml", _("XSPF playlist") },
{ NULL, NULL }
};
const gchar *video_mime[][2] = {
{ "video/3gpp" , _("3GPP multimedia file") },
{ "video/x-ms-asf" , _("ASF video") },
{ "video/x-msvideo" , _("AVI video") },
{ "video/x-flv" , _("Flash video") },
{ "video/x-matroska" , _("Matroska video") },
{ "video/mpeg" , _("MPEG video") },
{ "video/mp4" , _("MPEG-4 video") },
{ "application/ogg" , _("Ogg multimedia file") },
{ "video/ogg" , _("Ogg video") },
{ "video/quicktime" , _("QuickTime video") },
{ "application/vnd.rn-realmedia" , _("RealMedia document") },
{ "application/x-shockwave-flash", _("Shockwave Flash file") },
{ "video/x-ms-wmv" , _("Windows Media video") },
{ NULL, NULL }
};
filters = NULL;
store = gtk_tree_store_new(1, G_TYPE_POINTER);
/* All files */
filter = gtk_file_filter_new();
gtk_file_filter_add_pattern(filter, "*");
gtk_file_filter_set_name(filter, _("All files"));
gtk_tree_store_append(store, &iter1, NULL);
gtk_tree_store_set(store, &iter1, 0, filter, -1);
filters = g_slist_prepend(filters, filter);
/* Supported files */
filter = gtk_file_filter_new();
gtk_file_filter_set_name(filter, _("Supported files"));
i = 0;
while (lossless_mime[i][0]) {
gtk_file_filter_add_mime_type(filter, lossless_mime[i][0]);
i++;
}
i = 0;
while (lossy_mime[i][0]) {
gtk_file_filter_add_mime_type(filter, lossy_mime[i][0]);
i++;
}
i = 0;
while (playlists_mime[i][0]) {
gtk_file_filter_add_mime_type(filter, playlists_mime[i][0]);
i++;
}
i = 0;
while (video_mime[i][0]) {
gtk_file_filter_add_mime_type(filter, video_mime[i][0]);
i++;
}
gtk_tree_store_append(store, &iter1, NULL);
gtk_tree_store_set(store, &iter1, 0, filter, -1);
filters = g_slist_prepend(filters, filter);
default_file_filter = filter;
/* Audio files */
filter = gtk_file_filter_new();
gtk_file_filter_set_name(filter, _("Audio files"));
i = 0;
while (lossless_mime[i][0]) {
gtk_file_filter_add_mime_type(filter, lossless_mime[i][0]);
i++;
}
i = 0;
while (lossy_mime[i][0]) {
gtk_file_filter_add_mime_type(filter, lossy_mime[i][0]);
i++;
}
i = 0;
while (playlists_mime[i][0]) {
gtk_file_filter_add_mime_type(filter, playlists_mime[i][0]);
i++;
}
gtk_tree_store_append(store, &iter1, NULL);
gtk_tree_store_set(store, &iter1, 0, filter, -1);
filters = g_slist_prepend(filters, filter);
/* Lossy files */
filter = gtk_file_filter_new();
gtk_file_filter_set_name(filter, _("Lossy files"));
i = 0;
while (lossy_mime[i][0]) {
gtk_file_filter_add_mime_type(filter, lossy_mime[i][0]);
i++;
}
gtk_tree_store_append(store, &iter2, &iter1);
gtk_tree_store_set(store, &iter2, 0, filter, -1);
filters = g_slist_prepend(filters, filter);
/* Individual lossy files */
i = 0;
while (lossy_mime[i][0]) {
filter = gtk_file_filter_new();
gtk_file_filter_add_mime_type(filter, lossy_mime[i][0]);
gtk_file_filter_set_name(filter, lossy_mime[i][1]);
gtk_tree_store_append(store, &iter3, &iter2);
gtk_tree_store_set(store, &iter3, 0, filter, -1);
filters = g_slist_prepend(filters, filter);
i++;
}
/* Lossless files */
filter = gtk_file_filter_new();
gtk_file_filter_set_name(filter, _("Lossless files"));
i = 0;
while (lossless_mime[i][0]) {
gtk_file_filter_add_mime_type(filter, lossless_mime[i][0]);
i++;
}
gtk_tree_store_append(store, &iter2, &iter1);
gtk_tree_store_set(store, &iter2, 0, filter, -1);
filters = g_slist_prepend(filters, filter);
/* Individual lossless files */
i = 0;
while (lossless_mime[i][0]) {
filter = gtk_file_filter_new();
gtk_file_filter_add_mime_type(filter, lossless_mime[i][0]);
gtk_file_filter_set_name(filter, lossless_mime[i][1]);
gtk_tree_store_append(store, &iter3, &iter2);
gtk_tree_store_set(store, &iter3, 0, filter, -1);
filters = g_slist_prepend(filters, filter);
i++;
}
/* Playlists */
filter = gtk_file_filter_new();
gtk_file_filter_set_name(filter, _("Playlists"));
i = 0;
while (playlists_mime[i][0]) {
gtk_file_filter_add_mime_type(filter, playlists_mime[i][0]);
i++;
}
gtk_tree_store_append(store, &iter1, NULL);
gtk_tree_store_set(store, &iter1, 0, filter, -1);
filters = g_slist_prepend(filters, filter);
/* Individual playlists */
i = 0;
while (playlists_mime[i][0]) {
filter = gtk_file_filter_new();
gtk_file_filter_add_mime_type(filter, playlists_mime[i][0]);
gtk_file_filter_set_name(filter, playlists_mime[i][1]);
gtk_tree_store_append(store, &iter2, &iter1);
gtk_tree_store_set(store, &iter2, 0, filter, -1);
filters = g_slist_prepend(filters, filter);
i++;
}
/* Video files */
filter = gtk_file_filter_new();
gtk_file_filter_set_name(filter, _("Video files"));
i = 0;
while (video_mime[i][0]) {
gtk_file_filter_add_mime_type(filter, video_mime[i][0]);
i++;
}
gtk_tree_store_append(store, &iter1, NULL);
gtk_tree_store_set(store, &iter1, 0, filter, -1);
filters = g_slist_prepend(filters, filter);
/* Individual video files */
i = 0;
while (video_mime[i][0]) {
filter = gtk_file_filter_new();
gtk_file_filter_add_mime_type(filter, video_mime[i][0]);
gtk_file_filter_set_name(filter, video_mime[i][1]);
gtk_tree_store_append(store, &iter2, &iter1);
gtk_tree_store_set(store, &iter2, 0, filter, -1);
filters = g_slist_prepend(filters, filter);
i++;
}
filters = g_slist_reverse(filters);
for (f = filters; f; f = g_slist_next(f)) {
g_object_ref(f->data);
}
return GTK_TREE_MODEL(store);
}
int
main (int argc,
char **argv)
{
GtkWidget *window;
GtkWidget *sw;
GtkWidget *tv;
GtkWidget *box;
GtkWidget *combo_box;
GtkTreeModel *model;
gint i;
gtk_init (&argc, &argv);
if (g_getenv ("RTL"))
gtk_widget_set_default_direction (GTK_TEXT_DIR_RTL);
our_pixbuf = gdk_pixbuf_new_from_xpm_data ((const char **) book_closed_xpm);
#if 0
models[MODEL_TYPES] = GTK_TREE_MODEL (gtk_tree_model_types_new ());
#endif
models[MODEL_LIST] = create_list_model ();
models[MODEL_TREE] = create_tree_model ();
model = create_list_model ();
models[MODEL_SORTED_LIST] = gtk_tree_model_sort_new_with_model (model);
g_object_unref (model);
model = create_tree_model ();
models[MODEL_SORTED_TREE] = gtk_tree_model_sort_new_with_model (model);
g_object_unref (model);
models[MODEL_EMPTY_LIST] = GTK_TREE_MODEL (gtk_list_store_new (1, G_TYPE_INT));
models[MODEL_EMPTY_TREE] = GTK_TREE_MODEL (gtk_tree_store_new (1, G_TYPE_INT));
models[MODEL_NULL] = NULL;
run_automated_tests ();
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
gtk_window_set_default_size (GTK_WINDOW (window), 430, 400);
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window), box);
tv = gtk_tree_view_new_with_model (models[0]);
gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW (tv),
GDK_BUTTON1_MASK,
row_targets,
G_N_ELEMENTS (row_targets),
GDK_ACTION_MOVE | GDK_ACTION_COPY);
gtk_tree_view_enable_model_drag_dest (GTK_TREE_VIEW (tv),
row_targets,
G_N_ELEMENTS (row_targets),
GDK_ACTION_MOVE | GDK_ACTION_COPY);
/* Model menu */
combo_box = gtk_combo_box_text_new ();
gtk_widget_set_halign (combo_box, GTK_ALIGN_CENTER);
for (i = 0; i < MODEL_LAST; i++)
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo_box), model_names[i]);
gtk_container_add (GTK_CONTAINER (box), combo_box);
g_signal_connect (combo_box,
"changed",
G_CALLBACK (model_selected),
tv);
/* Columns menu */
combo_box = gtk_combo_box_text_new ();
gtk_widget_set_halign (combo_box, GTK_ALIGN_CENTER);
for (i = 0; i < COLUMNS_LAST; i++)
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo_box), column_type_names[i]);
gtk_container_add (GTK_CONTAINER (box), combo_box);
set_columns_type (GTK_TREE_VIEW (tv), COLUMNS_LOTS);
gtk_combo_box_set_active (GTK_COMBO_BOX (combo_box), COLUMNS_LOTS);
g_signal_connect (combo_box,
"changed",
G_CALLBACK (columns_selected),
tv);
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_set_hexpand (sw, TRUE);
gtk_widget_set_vexpand (sw, TRUE);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER (box), sw);
gtk_container_add (GTK_CONTAINER (sw), tv);
create_prop_editor (G_OBJECT (tv), GTK_TYPE_TREE_VIEW);
create_prop_editor (G_OBJECT (gtk_tree_view_get_selection (GTK_TREE_VIEW (tv))), GTK_TYPE_TREE_SELECTION);
gtk_widget_show_all (window);
gtk_main ();
return 0;
}
static void
pkg_window_init (PkgWindow *window)
{
PkgWindowPrivate *priv;
GtkAccelGroup *accel_group;
GtkWidget *vbox;
GtkWidget *menu_bar;
GtkWidget *perfkit_menu;
GtkWidget *help_menu;
GtkWidget *hpaned;
GtkWidget *scroller;
GtkTreeViewColumn *column;
GtkCellRenderer *text;
GtkCellRenderer *cpix;
GtkTreeSelection *selection;
ENTRY;
priv = G_TYPE_INSTANCE_GET_PRIVATE(window, PKG_TYPE_WINDOW,
PkgWindowPrivate);
window->priv = priv;
g_static_rw_lock_init(&priv->rw_lock);
gtk_window_set_title(GTK_WINDOW(window), _("Perfkit"));
gtk_window_set_default_size(GTK_WINDOW(window), 780, 550);
accel_group = gtk_accel_group_new();
gtk_window_add_accel_group(GTK_WINDOW(window), accel_group);
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(window), vbox);
gtk_widget_show(vbox);
menu_bar = gtk_menu_bar_new();
gtk_box_pack_start(GTK_BOX(vbox), menu_bar, FALSE, TRUE, 0);
gtk_widget_show(menu_bar);
#define ADD_MENU(_n, _s) \
G_STMT_START { \
GtkWidget *_w; \
_w = gtk_menu_item_new_with_mnemonic((_s)); \
gtk_widget_show((_w)); \
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), (_w)); \
_n = gtk_menu_new(); \
gtk_menu_item_set_submenu(GTK_MENU_ITEM(_w), _n); \
} G_STMT_END
#define ADD_MENU_ITEM(_p, _s, _f) \
G_STMT_START { \
GtkWidget *_w; \
_w = gtk_menu_item_new_with_mnemonic(_s); \
gtk_widget_show((_w)); \
gtk_menu_shell_append(GTK_MENU_SHELL(_p), (_w)); \
g_signal_connect(_w, "activate", G_CALLBACK(_f), \
window); \
} G_STMT_END
#define ADD_MENU_ITEM_STOCK(_p, _s, _f) \
G_STMT_START { \
GtkWidget *_w = gtk_image_menu_item_new_from_stock( \
(_s), accel_group); \
gtk_widget_show((_w)); \
gtk_menu_shell_append(GTK_MENU_SHELL(_p), (_w)); \
g_signal_connect(_w, "activate", G_CALLBACK(_f), \
window); \
} G_STMT_END
#define ADD_SEPARATOR(_p) \
G_STMT_START { \
GtkWidget *_w = gtk_separator_menu_item_new(); \
gtk_widget_show((_w)); \
gtk_menu_shell_append(GTK_MENU_SHELL(_p), (_w)); \
} G_STMT_END
ADD_MENU(perfkit_menu, _("_Perfkit"));
ADD_MENU_ITEM(perfkit_menu, _("Connect to _Server"), gtk_false);
ADD_SEPARATOR(perfkit_menu);
ADD_MENU_ITEM_STOCK(perfkit_menu, GTK_STOCK_REFRESH, pkg_window_refresh_all);
ADD_SEPARATOR(perfkit_menu);
ADD_MENU_ITEM_STOCK(perfkit_menu, GTK_STOCK_QUIT, gtk_main_quit);
ADD_MENU(help_menu, _("_Help"));
ADD_MENU_ITEM_STOCK(help_menu, GTK_STOCK_ABOUT, gtk_false);
hpaned = gtk_hpaned_new();
gtk_paned_set_position(GTK_PANED(hpaned), 275);
gtk_box_pack_start(GTK_BOX(vbox), hpaned, TRUE, TRUE, 0);
gtk_widget_show(hpaned);
scroller = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroller),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scroller),
GTK_SHADOW_IN);
gtk_paned_add1(GTK_PANED(hpaned), scroller);
gtk_widget_show(scroller);
priv->model = gtk_tree_store_new(5,
PK_TYPE_CONNECTION,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_INT,
G_TYPE_INT);
priv->treeview = gtk_tree_view_new();
gtk_container_add(GTK_CONTAINER(scroller), priv->treeview);
gtk_tree_view_set_model(GTK_TREE_VIEW(priv->treeview),
GTK_TREE_MODEL(priv->model));
gtk_tree_view_expand_all(GTK_TREE_VIEW(priv->treeview));
gtk_widget_show(priv->treeview);
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(priv->treeview));
g_signal_connect(selection,
"changed",
G_CALLBACK(pkg_window_selection_changed),
window);
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Agents"));
gtk_tree_view_append_column(GTK_TREE_VIEW(priv->treeview), column);
cpix = gtk_cell_renderer_pixbuf_new();
g_object_set(cpix,
"stock-size", GTK_ICON_SIZE_LARGE_TOOLBAR,
NULL);
gtk_tree_view_column_pack_start(column, cpix, FALSE);
gtk_tree_view_column_set_cell_data_func(column, cpix,
pkg_window_pixbuf_data_func,
window, NULL);
text = gtk_cell_renderer_text_new();
g_object_set(text,
"ellipsize", PANGO_ELLIPSIZE_END,
NULL);
gtk_tree_view_column_pack_start(column, text, TRUE);
gtk_tree_view_column_set_cell_data_func(column, text,
pkg_window_label_data_func,
window, NULL);
priv->container = gtk_alignment_new(0.5f, 0.5f, 1.0f, 1.0f);
gtk_paned_add2(GTK_PANED(hpaned), priv->container);
gtk_widget_show(priv->container);
EXIT;
}
void
gmdb_sql_new_cb (GtkWidget *w, gpointer data) {
GtkTargetEntry src;
GtkWidget *mi, *but, *combobox;
GladeXML *sqlwin_xml;
/* load the interface */
sqlwin_xml = glade_xml_new(GMDB_GLADEDIR "gmdb-sql.glade", NULL, NULL);
/* connect the signals in the interface */
glade_xml_signal_autoconnect(sqlwin_xml);
sql_list = g_list_append(sql_list, sqlwin_xml);
mi = glade_xml_get_widget (sqlwin_xml, "save_menu");
g_signal_connect (G_OBJECT (mi), "activate",
G_CALLBACK (gmdb_sql_save_cb), sqlwin_xml);
but = glade_xml_get_widget (sqlwin_xml, "save_button");
g_signal_connect (G_OBJECT (but), "clicked",
G_CALLBACK (gmdb_sql_save_cb), sqlwin_xml);
mi = glade_xml_get_widget (sqlwin_xml, "save_as_menu");
g_signal_connect (G_OBJECT (mi), "activate",
G_CALLBACK (gmdb_sql_save_as_cb), sqlwin_xml);
//but = glade_xml_get_widget (sqlwin_xml, "save_as_button");
//g_signal_connect (G_OBJECT (but), "clicked",
// G_CALLBACK (gmdb_sql_save_as_cb), sqlwin_xml);
mi = glade_xml_get_widget (sqlwin_xml, "results_menu");
g_signal_connect (G_OBJECT (mi), "activate",
G_CALLBACK (gmdb_sql_results_cb), sqlwin_xml);
but = glade_xml_get_widget (sqlwin_xml, "results_button");
g_signal_connect (G_OBJECT (but), "clicked",
G_CALLBACK (gmdb_sql_results_cb), sqlwin_xml);
mi = glade_xml_get_widget (sqlwin_xml, "open_menu");
g_signal_connect (G_OBJECT (mi), "activate",
G_CALLBACK (gmdb_sql_open_cb), sqlwin_xml);
but = glade_xml_get_widget (sqlwin_xml, "open_button");
g_signal_connect (G_OBJECT (but), "clicked",
G_CALLBACK (gmdb_sql_open_cb), sqlwin_xml);
mi = glade_xml_get_widget (sqlwin_xml, "paste_menu");
g_signal_connect (G_OBJECT (mi), "activate",
G_CALLBACK (gmdb_sql_paste_cb), sqlwin_xml);
mi = glade_xml_get_widget (sqlwin_xml, "cut_menu");
g_signal_connect (G_OBJECT (mi), "activate",
G_CALLBACK (gmdb_sql_cut_cb), sqlwin_xml);
mi = glade_xml_get_widget (sqlwin_xml, "copy_menu");
g_signal_connect (G_OBJECT (mi), "activate",
G_CALLBACK (gmdb_sql_copy_cb), sqlwin_xml);
mi = glade_xml_get_widget (sqlwin_xml, "close_menu");
g_signal_connect (G_OBJECT (mi), "activate",
G_CALLBACK (gmdb_sql_close_cb), sqlwin_xml);
but = glade_xml_get_widget (sqlwin_xml, "close_button");
g_signal_connect (G_OBJECT (but), "clicked",
G_CALLBACK (gmdb_sql_close_cb), sqlwin_xml);
mi = glade_xml_get_widget (sqlwin_xml, "execute_menu");
g_signal_connect (G_OBJECT (mi), "activate",
G_CALLBACK (gmdb_sql_execute_cb), sqlwin_xml);
combobox = glade_xml_get_widget(sqlwin_xml, "sql_combo");
g_signal_connect (G_OBJECT(GTK_COMBO_BOX(combobox)), "changed",
G_CALLBACK (gmdb_sql_select_hist_cb), sqlwin_xml);
but = glade_xml_get_widget (sqlwin_xml, "execute_button");
g_signal_connect (G_OBJECT (but), "clicked",
G_CALLBACK (gmdb_sql_execute_cb), sqlwin_xml);
/* set up treeview, libglade only gives us the empty widget */
GtkWidget *tree = glade_xml_get_widget(sqlwin_xml, "sql_treeview");
GtkTreeStore *store = gtk_tree_store_new(1, G_TYPE_STRING);
gtk_tree_view_set_model(GTK_TREE_VIEW(tree), GTK_TREE_MODEL(store));
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Name",
renderer, "text", 0, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW (tree), column);
GtkTreeSelection *select =
gtk_tree_view_get_selection (GTK_TREE_VIEW (tree));
gtk_tree_selection_set_mode (select, GTK_SELECTION_SINGLE);
//g_signal_connect (G_OBJECT (select), "changed",
//G_CALLBACK (gmdb_sql_select_cb), sqlwin_xml);
/* populate first level of tree */
gmdb_sql_tree_populate(mdb, sqlwin_xml);
GtkWidget *textview = glade_xml_get_widget(sqlwin_xml, "sql_textview");
src.target = "table";
src.flags = 0;
src.info = 1;
gtk_drag_source_set( tree, GDK_BUTTON1_MASK, &src, 1, GDK_ACTION_COPY);
gtk_drag_dest_set( textview,
//GTK_DEST_DEFAULT_MOTION |
GTK_DEST_DEFAULT_HIGHLIGHT ,
// GTK_DEST_DEFAULT_DROP,
&src, 1, GDK_ACTION_COPY | GDK_ACTION_MOVE);
gtk_signal_connect( GTK_OBJECT(tree), "drag_data_get",
GTK_SIGNAL_FUNC(gmdb_sql_dnd_dataget_cb), sqlwin_xml);
gtk_signal_connect( GTK_OBJECT(textview), "drag_data_received",
GTK_SIGNAL_FUNC(gmdb_sql_dnd_datareceived_cb), sqlwin_xml);
//GValue value = {0, };
//but = glade_xml_get_widget(sqlwin_xml, "results_button");
//g_value_init(&value, G_TYPE_STRING);
//g_value_set_static_string(&value, GMDB_ICONDIR "stock_export.png");
//g_object_set_property(G_OBJECT (but), "file" , &value);
//g_value_unset (&value);
gtk_widget_grab_focus(GTK_WIDGET(textview));
}
int main(int argc, char *argv[]) {
GtkWidget *button;
GtkWidget *box1;
gtk_init(&argc, &argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), "hart");
g_signal_connect(window, "delete-event", G_CALLBACK(delete_event), NULL);
gtk_container_set_border_width(GTK_CONTAINER(window), 10);
box1 = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(window), box1);
//Create tree model
store = gtk_tree_store_new(N_COLUMNS,
G_TYPE_STRING,
G_TYPE_BOOLEAN);
create_file_tree(".", NULL);
//Sort the model for convenience
sorted_model = gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(store));
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(sorted_model),
FILE_COLUMN, GTK_SORT_ASCENDING);
//Create the tree's view
tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(sorted_model));
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("File",
renderer,
"text", FILE_COLUMN,
NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
renderer = gtk_cell_renderer_toggle_new();
column = gtk_tree_view_column_new_with_attributes("Locked",
renderer,
"active", LOCKED_COLUMN,
NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
//Add ui callbacks for the tree
GtkTreeSelection *select;
select = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
gtk_tree_selection_set_mode(select, GTK_SELECTION_SINGLE);
g_signal_connect(G_OBJECT(select), "changed",
G_CALLBACK(tree_selection_changed_cb),
NULL);
//Add tree to box
gtk_box_pack_start(GTK_BOX(box1), tree, TRUE, TRUE, 0);
//Create console output label
GtkWidget* frame = gtk_frame_new("Console output");
GtkWidget* text_view = gtk_text_view_new();
GtkTextTagTable* text_tag_table = gtk_text_tag_table_new();
GtkTextBuffer* console_buffer = gtk_text_buffer_new(text_tag_table);
gtk_text_view_set_buffer(GTK_TEXT_VIEW(text_view), console_buffer);
gchar* test_str = "blah\nwoiajheoih\nwoeihoiwha\nweoihewoih\nwoeihoi";
gtk_text_buffer_set_text(console_buffer,
test_str,
strlen(test_str));
gtk_container_add(GTK_CONTAINER(frame), text_view);
gtk_box_pack_start(GTK_BOX(box1), frame, TRUE, TRUE, 0);
//Create button w/ label
GtkWidget* file_button = gtk_file_chooser_button_new("Select a folder",
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
gtk_box_pack_start(GTK_BOX(box1), file_button, TRUE, TRUE, 0);
g_signal_connect(file_button, "file-set", G_CALLBACK(file_button_callback), (gpointer)"file_button");
//Show all of the widgets
gtk_widget_show(file_button);
gtk_widget_show(tree);
gtk_widget_show(frame);
gtk_widget_show(text_view);
gtk_widget_show(box1);
gtk_widget_show(window); //Show window last so they all appear at once.
gtk_main ();
return 0;
}
GtkTreeStore *pl_empty_tree_store(void) {
GtkTreeStore *tree_store = gtk_tree_store_new(N_COLUMNS,G_TYPE_STRING,G_TYPE_INT,G_TYPE_BOOLEAN,G_TYPE_STRING,G_TYPE_STRING,G_TYPE_STRING,G_TYPE_INT,G_TYPE_STRING);
return tree_store;
}
static void foldersel_create(void)
{
GtkWidget *vbox;
GtkWidget *scrolledwin;
GtkWidget *confirm_area;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GtkTreeSelection *selection;
static GdkGeometry geometry;
window = gtkut_window_new(GTK_WINDOW_TOPLEVEL, "foldersel");
gtk_window_set_title(GTK_WINDOW(window), _("Select folder"));
gtk_container_set_border_width(GTK_CONTAINER(window), 4);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_window_set_resizable(GTK_WINDOW(window), TRUE);
gtk_widget_realize(window);
g_signal_connect(G_OBJECT(window), "delete_event",
G_CALLBACK(delete_event), NULL);
g_signal_connect(G_OBJECT(window), "key_press_event",
G_CALLBACK(key_pressed), NULL);
g_signal_connect(G_OBJECT(window), "size_allocate",
G_CALLBACK(foldersel_size_allocate_cb), NULL);
MANAGE_WINDOW_SIGNALS_CONNECT(window);
vbox = gtk_vbox_new(FALSE, 4);
gtk_container_add(GTK_CONTAINER(window), vbox);
scrolledwin = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin),
GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwin),
GTK_SHADOW_IN);
gtk_box_pack_start(GTK_BOX(vbox), scrolledwin, TRUE, TRUE, 0);
tree_store = gtk_tree_store_new(N_FOLDERSEL_COLUMNS,
G_TYPE_STRING,
G_TYPE_POINTER,
GDK_TYPE_PIXBUF,
GDK_TYPE_PIXBUF,
GDK_TYPE_COLOR,
G_TYPE_INT);
gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(tree_store),
FOLDERSEL_FOLDERNAME,
foldersel_folder_name_compare,
NULL, NULL);
treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(tree_store));
g_object_unref(G_OBJECT(tree_store));
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview), FALSE);
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(treeview),
prefs_common.use_stripes_everywhere);
gtk_tree_view_set_enable_tree_lines(GTK_TREE_VIEW(treeview), FALSE);
gtk_tree_view_set_search_column(GTK_TREE_VIEW(treeview),
FOLDERSEL_FOLDERNAME);
if (prefs_common.folder_search_wildcard)
gtk_tree_view_set_search_equal_func(GTK_TREE_VIEW(treeview),
foldersel_search_name_func, NULL, NULL);
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE);
gtk_tree_selection_set_select_function(selection, foldersel_selected,
NULL, NULL);
g_signal_connect(G_OBJECT(treeview), "row-activated",
G_CALLBACK(foldersel_tree_activated), NULL);
gtk_container_add(GTK_CONTAINER(scrolledwin), treeview);
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_spacing(column, 2);
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_attributes
(column, renderer,
"pixbuf", FOLDERSEL_PIXBUF,
"pixbuf-expander-open", FOLDERSEL_PIXBUF_OPEN,
"pixbuf-expander-closed", FOLDERSEL_PIXBUF,
NULL);
/* create text renderer */
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_set_attributes
(column, renderer,
"text", FOLDERSEL_FOLDERNAME,
"foreground-gdk", FOLDERSEL_FOREGROUND,
"weight", FOLDERSEL_BOLD,
NULL);
g_object_set(G_OBJECT(renderer), "weight", PANGO_WEIGHT_BOLD, NULL);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
entry = gtk_entry_new();
gtk_editable_set_editable(GTK_EDITABLE(entry), FALSE);
gtk_box_pack_start(GTK_BOX(vbox), entry, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(entry), "activate",
G_CALLBACK(foldersel_entry_activated), NULL);
gtkut_stock_button_set_create(&confirm_area,
&new_button, GTK_STOCK_NEW,
&cancel_button, GTK_STOCK_CANCEL,
&ok_button, GTK_STOCK_OK);
gtk_box_pack_end(GTK_BOX(vbox), confirm_area, FALSE, FALSE, 0);
gtk_widget_grab_default(ok_button);
g_signal_connect(G_OBJECT(ok_button), "clicked",
G_CALLBACK(foldersel_ok), NULL);
g_signal_connect(G_OBJECT(cancel_button), "clicked",
G_CALLBACK(foldersel_cancel), NULL);
g_signal_connect(G_OBJECT(new_button), "clicked",
G_CALLBACK(foldersel_new_folder), NULL);
if (!geometry.min_height) {
geometry.min_width = 300;
geometry.min_height = 360;
}
gtk_window_set_geometry_hints(GTK_WINDOW(window), NULL, &geometry,
GDK_HINT_MIN_SIZE);
gtk_widget_set_size_request(window, prefs_common.folderselwin_width,
prefs_common.folderselwin_height);
gtk_widget_show_all(vbox);
}
int
main (int argc, char *argv[])
{
GtkTreeModel *model;
gtk_init_with_args (&argc, &argv, NULL, entries, NULL, NULL);
model = GTK_TREE_MODEL (gtk_list_store_new (2, G_TYPE_INT, G_TYPE_STRING));
test_run ("list store append",
model,
(ClearFunc*)gtk_list_store_clear,
(InsertFunc*)list_store_append);
test_run ("list store prepend",
model,
(ClearFunc*)gtk_list_store_clear,
(InsertFunc*)list_store_prepend);
test_run ("list store insert",
model,
(ClearFunc*)gtk_list_store_clear,
(InsertFunc*)list_store_insert);
gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (model),
compare, NULL, NULL);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (model),
GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID,
GTK_SORT_ASCENDING);
test_run ("list store insert (sorted)",
model,
(ClearFunc*)gtk_list_store_clear,
(InsertFunc*)list_store_insert);
g_object_unref (model);
model = GTK_TREE_MODEL (gtk_tree_store_new (2, G_TYPE_INT, G_TYPE_STRING));
test_run ("tree store append",
model,
(ClearFunc*)gtk_tree_store_clear,
(InsertFunc*)tree_store_append);
test_run ("tree store prepend",
model,
(ClearFunc*)gtk_tree_store_clear,
(InsertFunc*)tree_store_prepend);
test_run ("tree store insert (flat)",
model,
(ClearFunc*)gtk_tree_store_clear,
(InsertFunc*)tree_store_insert_flat);
test_run ("tree store insert (deep)",
model,
(ClearFunc*)gtk_tree_store_clear,
(InsertFunc*)tree_store_insert_deep);
gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (model),
compare, NULL, NULL);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (model),
GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID,
GTK_SORT_ASCENDING);
test_run ("tree store insert (flat, sorted)",
model,
(ClearFunc*)gtk_tree_store_clear,
(InsertFunc*)tree_store_insert_flat);
test_run ("tree store insert (deep, sorted)",
model,
(ClearFunc*)gtk_tree_store_clear,
(InsertFunc*)tree_store_insert_deep);
return 0;
}
static GtkTreeModel *
create_object_tree_model(void)
{
return GTK_TREE_MODEL(gtk_tree_store_new(OBJECT_COLUMN_TYPE_NUM, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_OBJECT, G_TYPE_INT, G_TYPE_INT, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN));
}
void
terminal_edit_keys_dialog_show (GtkWindow *transient_parent)
{
TerminalApp *app;
GtkWidget *dialog, *tree_view, *disable_mnemonics_button, *disable_menu_accel_button;
GtkTreeViewColumn *column;
GtkCellRenderer *cell_renderer;
GtkTreeStore *tree;
guint i;
if (edit_keys_dialog != NULL)
goto done;
if (!terminal_util_load_builder_file ("keybinding-editor.ui",
"keybindings-dialog", &dialog,
"disable-mnemonics-checkbutton", &disable_mnemonics_button,
"disable-menu-accel-checkbutton", &disable_menu_accel_button,
"accelerators-treeview", &tree_view,
NULL))
return;
app = terminal_app_get ();
terminal_util_bind_object_property_to_widget (G_OBJECT (app), TERMINAL_APP_ENABLE_MNEMONICS,
disable_mnemonics_button, 0);
terminal_util_bind_object_property_to_widget (G_OBJECT (app), TERMINAL_APP_ENABLE_MENU_BAR_ACCEL,
disable_menu_accel_button, 0);
/* Column 1 */
cell_renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (_("_Action"),
cell_renderer,
"text", ACTION_COLUMN,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column);
gtk_tree_view_column_set_sort_column_id (column, ACTION_COLUMN);
/* Column 2 */
cell_renderer = gtk_cell_renderer_accel_new ();
g_object_set (cell_renderer,
"editable", TRUE,
"accel-mode", GTK_CELL_RENDERER_ACCEL_MODE_GTK,
NULL);
g_signal_connect (cell_renderer, "accel-edited",
G_CALLBACK (accel_edited_callback), tree_view);
g_signal_connect (cell_renderer, "accel-cleared",
G_CALLBACK (accel_cleared_callback), tree_view);
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("Shortcut _Key"));
gtk_tree_view_column_pack_start (column, cell_renderer, TRUE);
gtk_tree_view_column_set_cell_data_func (column, cell_renderer, accel_set_func, NULL, NULL);
gtk_tree_view_column_set_sort_column_id (column, KEYVAL_COLUMN);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column);
/* Add the data */
tree = edit_keys_store = gtk_tree_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_POINTER);
#ifdef MATE_ENABLE_DEBUG
_TERMINAL_DEBUG_IF (TERMINAL_DEBUG_ACCELS)
g_signal_connect (tree, "row-changed", G_CALLBACK (row_changed), NULL);
#endif
for (i = 0; i < G_N_ELEMENTS (all_entries); ++i)
{
GtkTreeIter parent_iter;
guint j;
gtk_tree_store_append (tree, &parent_iter, NULL);
gtk_tree_store_set (tree, &parent_iter,
ACTION_COLUMN, _(all_entries[i].user_visible_name),
-1);
for (j = 0; j < all_entries[i].n_elements; ++j)
{
KeyEntry *key_entry = &(all_entries[i].key_entry[j]);
GtkTreeIter iter;
gtk_tree_store_insert_with_values (tree, &iter, &parent_iter, -1,
ACTION_COLUMN, _(key_entry->user_visible_name),
KEYVAL_COLUMN, key_entry,
-1);
}
}
gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (tree),
KEYVAL_COLUMN, accel_compare_func,
NULL, NULL);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (tree), ACTION_COLUMN,
GTK_SORT_ASCENDING);
gtk_tree_view_set_model (GTK_TREE_VIEW (tree_view), GTK_TREE_MODEL (tree));
g_object_unref (tree);
gtk_tree_view_expand_all (GTK_TREE_VIEW (tree_view));
g_signal_connect (notification_group, "accel-changed",
G_CALLBACK (treeview_accel_changed_cb), tree);
edit_keys_dialog = dialog;
g_signal_connect (dialog, "destroy",
G_CALLBACK (edit_keys_dialog_destroy_cb), tree);
g_signal_connect (dialog, "response",
G_CALLBACK (edit_keys_dialog_response_cb),
NULL);
gtk_window_set_default_size (GTK_WINDOW (dialog), -1, 350);
done:
gtk_window_set_transient_for (GTK_WINDOW (edit_keys_dialog), transient_parent);
gtk_window_present (GTK_WINDOW (edit_keys_dialog));
}
static void
_lib_tag_gui_update (gpointer instance,gpointer self)
{
dt_lib_module_t *dm = (dt_lib_module_t *)self;
dt_lib_keywords_t *d = (dt_lib_keywords_t*)dm->data;
GtkTreeStore *store = gtk_tree_store_new(1, G_TYPE_STRING);
/* initialize the tree store with known tags */
sqlite3_stmt *stmt;
GtkTreeIter uncategorized, temp;
memset(&uncategorized,0,sizeof(GtkTreeIter));
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db),
"SELECT name,icon,description FROM tags ORDER BY UPPER(name) DESC", -1, &stmt, NULL);
gtk_tree_store_clear(store);
while (sqlite3_step(stmt) == SQLITE_ROW)
{
if(strchr((const char *)sqlite3_column_text(stmt, 0),'|')==0)
{
/* add uncategorized root iter if not exists */
if (!uncategorized.stamp)
{
gtk_tree_store_insert(store, &uncategorized, NULL,0);
gtk_tree_store_set(store, &uncategorized, 0, _(UNCATEGORIZED_TAG), -1);
}
/* adding a uncategorized tag */
gtk_tree_store_insert(store, &temp, &uncategorized,0);
gtk_tree_store_set(store, &temp, 0, sqlite3_column_text(stmt, 0), -1);
}
else
{
int level = 0;
char *value;
GtkTreeIter current,iter;
char **pch = g_strsplit((char *)sqlite3_column_text(stmt, 0),"|", -1);
if (pch != NULL)
{
int j = 0;
while (pch[j] != NULL)
{
gboolean found=FALSE;
int children = gtk_tree_model_iter_n_children(GTK_TREE_MODEL(store),level>0?¤t:NULL);
/* find child with name, if not found create and continue */
for (int k=0; k<children; k++)
{
if (gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(store), &iter, level>0?¤t:NULL, k))
{
gtk_tree_model_get (GTK_TREE_MODEL(store), &iter, 0, &value, -1);
if (strcmp(value, pch[j])==0)
{
current = iter;
found = TRUE;
break;
}
}
}
/* lets add new keyword and assign current */
if (!found)
{
gtk_tree_store_insert(store, &iter, level>0?¤t:NULL,0);
gtk_tree_store_set(store, &iter, 0, pch[j], -1);
current = iter;
}
level++;
j++;
}
g_strfreev(pch);
}
}
}
gtk_tree_view_set_model(d->view, GTK_TREE_MODEL(store));
/* free store, treeview has its own storage now */
g_object_unref(store);
}
/* \brief Create the tree model for the "Library" view.
* \par Function Description
* Creates a tree where the branches are the available library
* sources and the leaves are the footprints.
*/
static GtkTreeModel *
create_lib_tree_model (GhidLibraryWindow * library_window)
{
GtkTreeStore *tree;
GtkTreeIter iter, p_iter, e_iter, c_iter;
gchar *name;
gboolean exists;
tree = gtk_tree_store_new (N_MENU_COLUMNS,
G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_POINTER);
MENU_LOOP (&Library);
{
/* Watch for directory changes of library parts and create new
| parent iter at each change.
*/
if (!menu->directory) /* Shouldn't happen */
menu->directory = g_strdup ("???");
exists = FALSE;
if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (tree), &e_iter))
do
{
gtk_tree_model_get (GTK_TREE_MODEL (tree), &e_iter,
MENU_NAME_COLUMN, &name, -1);
if (!strcmp (name, menu->directory))
{
exists = TRUE;
break;
}
}
while (gtk_tree_model_iter_next (GTK_TREE_MODEL (tree), &e_iter));
if (exists)
p_iter = e_iter;
else
{
gtk_tree_store_append (tree, &p_iter, NULL);
gtk_tree_store_set (tree, &p_iter,
MENU_NAME_COLUMN, menu->directory,
MENU_LIBRARY_COLUMN, NULL,
MENU_ENTRY_COLUMN, NULL, -1);
}
gtk_tree_store_append (tree, &iter, &p_iter);
gtk_tree_store_set (tree, &iter,
MENU_NAME_COLUMN, menu->Name,
MENU_LIBRARY_COLUMN, menu,
MENU_ENTRY_COLUMN, NULL, -1);
ENTRY_LOOP (menu);
{
gtk_tree_store_append (tree, &c_iter, &iter);
gtk_tree_store_set (tree, &c_iter,
MENU_NAME_COLUMN, entry->ListEntry,
MENU_LIBRARY_COLUMN, menu,
MENU_ENTRY_COLUMN, entry, -1);
}
END_LOOP;
}
END_LOOP;
return (GtkTreeModel *) tree;
}
static GtkTreeModel* create_model(void) {
GtkTreeStore* treestore = gtk_tree_store_new(3, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_POINTER);
GtkTreeIter rootlevel, toplevel;
int t;
file_info root_file_data, current_file_data, *addeditem = NULL;
char tempstring[STRINGSIZE];
// EnableControls(FALSE);
strcpy(root_file_data.filename, "/");
root_file_data.filesize = 0;
root_file_data.filetype = FIROOT;
strcpy(root_file_data.fullpath, "");
root_file_data.partition = 255;
root_file_data.number_of_children = 0;
AddToTreeStore(treestore, NULL, &rootlevel, &root_file_data, NULL);
/* gtk_tree_store_append(treestore, &rootlevel, NULL); //create blank entry
root_directory = AddFileDataToList(&root_file_data);
addeditem = root_directory;
gtk_tree_store_set(treestore, &rootlevel, COL_FILENAME, root_file_data.filename, COL_POINTER, addeditem, -1);*/
for (t=0; t<5; ++t) {
if (t == 1) continue; //skip the non-filesystem partition
snprintf(tempstring, STRINGSIZE-1, "p%d",t); //partition directory name
strcpy(current_file_data.filename, tempstring);
current_file_data.filesize = 0;
strcpy(current_file_data.fullpath, "/");
strcpy(current_file_data.dirpath, "/");
current_file_data.partition = t;
current_file_data.filetype = FIPART;
current_file_data.number_of_children = 0;
strcpy(tempstring, "add filename: ");
if (strlen(tempstring) + strlen(current_file_data.filename) < STRINGSIZE)
strcat(tempstring, current_file_data.filename);
// Log("add filename:");
Log(DEBUGGING, "current_file_data.filename: %s", current_file_data.filename);
AddToTreeStore(treestore, &rootlevel, &toplevel, ¤t_file_data, &root_file_data);
if (ChangePartition(t) == FALSE) {
EnableControls(TRUE);
return NULL;
}
if(ChangeDirectory("/")==FALSE) {
EnableControls(TRUE);
return NULL;
}
//RecursiveListing("/",addeditem,t);
// strcpy(tempstring, "/");
RecursiveListing("/", addeditem, &toplevel, t, 0, treestore);
//m_directory_tree.Expand(hItem[t],TVE_EXPAND);//hmm?
//TODO: map filename data to some data in memory
}
//m_directory_tree.Expand(rItem,TVE_EXPAND);
ChangePartition(0); //make sure we're back at the media partition!!!
ChangeDirectory("/DCIM");
//Log();
EnableControls(TRUE);
return GTK_TREE_MODEL(treestore);
}
/**
* Build data storage by querying the X server for all input devices.
* Can be called multiple times, in which case it'll clean out and re-fill
* update the tree store.
*/
static GtkTreeStore* query_devices(GDeviceSetup* gds)
{
GtkTreeStore *treestore;
GtkTreeModel *model;
GtkTreeIter iter, child;
XIDeviceInfo *devices, *dev;
int ndevices;
int i, j;
int icontype;
GdkPixbuf *icon;
int valid, child_valid;
int id, masterid;
if (!gds->treeview)
{
treestore = gtk_tree_store_new(NUM_COLS,
G_TYPE_UINT, /* deviceid*/
G_TYPE_STRING, /* name */
G_TYPE_UINT,
GDK_TYPE_PIXBUF,
G_TYPE_UINT
);
model = GTK_TREE_MODEL(treestore);
} else
{
model = gtk_tree_view_get_model(gds->treeview);
treestore = GTK_TREE_STORE(model);
}
gds->generation++;
devices = XIQueryDevice(gds->dpy, XIAllDevices, &ndevices);
/* First, run through all master device and append them to the tree store
*/
for (i = 0; i < ndevices; i++)
{
dev = &devices[i];
if (dev->use != XIMasterPointer && dev->use != XIMasterKeyboard)
continue;
valid = gtk_tree_model_get_iter_first(model, &iter);
g_debug("MD %d: %s", dev->deviceid, dev->name);
while(valid) {
gtk_tree_model_get(model, &iter, COL_ID, &id, -1);
if (id == dev->deviceid)
{
gtk_tree_store_set(treestore, &iter,
COL_GENERATION, gds->generation, -1);
valid = 0xFF;
break;
}
valid = gtk_tree_model_iter_next(model, &iter);
}
if (valid != 0xFF) /* new MD */
{
icontype = (dev->use == XIMasterPointer) ? ICON_MOUSE : ICON_KEYBOARD;
icon = load_icon(icontype);
gtk_tree_store_append(treestore, &iter, NULL);
gtk_tree_store_set(treestore, &iter,
COL_ID, dev->deviceid,
COL_NAME, dev->name,
COL_USE, dev->use,
COL_ICON, icon,
COL_GENERATION, gds->generation,
-1);
g_object_unref(icon);
}
}
/* search for Floating fake master device */
valid = gtk_tree_model_get_iter_first(model, &iter);
while(valid)
{
gtk_tree_model_get(model, &iter, COL_ID, &id, -1);
if (id == ID_FLOATING)
break;
valid = gtk_tree_model_iter_next(model, &iter);
}
if (!valid)
{
/* Attach a fake master device for "Floating" */
icon = load_icon(ICON_FLOATING);
gtk_tree_store_append(treestore, &iter, NULL);
gtk_tree_store_set(treestore, &iter,
COL_ID, ID_FLOATING,
COL_NAME, "Floating",
COL_USE, ID_FLOATING,
COL_ICON, icon,
COL_GENERATION, gds->generation,
-1);
g_object_unref(icon);
} else {
GtkTreeIter prev;
GtkTreeIter pos = iter; /* current position of Floating */
/* always move Floating fake device to end of list */
while(valid)
{
prev = iter;
valid = gtk_tree_model_iter_next(model, &iter);
}
gtk_tree_store_move_after(treestore, &pos, &prev);
/* update generation too */
gtk_tree_store_set(treestore, &pos,
COL_GENERATION, gds->generation, -1);
}
/* now that we added all MDs, run through again and add SDs to the
* respective MD */
for (i = 0; i < ndevices; i++)
{
dev = &devices[i];
if (dev->use == XIMasterPointer || dev->use == XIMasterKeyboard)
continue;
g_debug("SD %d: %s", dev->deviceid, dev->name);
valid = gtk_tree_model_get_iter_first(model, &iter);
while(valid) {
gtk_tree_model_get(model, &iter, COL_ID, &masterid, -1);
if(dev->attachment == masterid || (dev->use == XIFloatingSlave && masterid == ID_FLOATING))
{
/* found master, check if we're already attached to it in
* the tree model */
child_valid = gtk_tree_model_iter_children(model, &child, &iter);
while (child_valid)
{
gtk_tree_model_get(model, &child, COL_ID, &id);
if (id == dev->deviceid)
{
gtk_tree_store_set(treestore, &child,
COL_GENERATION, gds->generation, -1);
child_valid = 0xFF;
break;
}
child_valid = gtk_tree_model_iter_next(model, &child);
}
/* new slave device, attach */
if (child_valid != 0xFF)
{
gtk_tree_store_append(treestore, &child, &iter);
gtk_tree_store_set(treestore, &child,
COL_ID, dev->deviceid,
COL_NAME, dev->name,
COL_USE, dev->use,
COL_GENERATION, gds->generation,
-1);
}
break;
}
valid = gtk_tree_model_iter_next(model, &iter);
}
}
XIFreeDeviceInfo(devices);
/* clean tree store of anything that doesn't have the current
server generation */
valid = gtk_tree_model_get_iter_first(model, &iter);
while(valid)
{
int gen;
child_valid = gtk_tree_model_iter_children(model, &child, &iter);
while(child_valid)
{
gtk_tree_model_get(model, &child, COL_GENERATION, &gen, -1);
if (gen < gds->generation)
child_valid = gtk_tree_store_remove(treestore, &child);
else
child_valid = gtk_tree_model_iter_next(model, &child);
}
gtk_tree_model_get(model, &iter, COL_GENERATION, &gen, -1);
if (gen < gds->generation)
valid = gtk_tree_store_remove(treestore, &iter);
else
valid = gtk_tree_model_iter_next(model, &iter);
}
return treestore;
}
GtkWidget *gtkui_cheats() {
// Create the Cheats window
if (cheatwindow) { return NULL; }
cheatwindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW (cheatwindow), "Cheat Manager");
GtkWidget *cheatbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add(GTK_CONTAINER(cheatwindow), cheatbox);
GtkWidget *scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
gtk_box_pack_start(GTK_BOX(cheatbox), scrolledwindow, TRUE, TRUE, 0);
gtk_widget_set_size_request(scrolledwindow, 512, 256);
treeview = gtk_tree_view_new();
gtk_container_add(GTK_CONTAINER (scrolledwindow), treeview);
infobar = gtk_info_bar_new();
infolabel = gtk_widget_new(GTK_TYPE_LABEL,"label", "", NULL);
gtk_box_pack_start(GTK_BOX(cheatbox), infobar, TRUE, TRUE, 0);
GtkWidget *content_area = gtk_info_bar_get_content_area(GTK_INFO_BAR(infobar));
gtk_box_pack_start(GTK_BOX(content_area), infolabel, TRUE, TRUE, 0);
GtkWidget *opensavebox = gtk_widget_new(GTK_TYPE_BOX, "halign", GTK_ALIGN_END, NULL);
gtk_box_pack_start(GTK_BOX(cheatbox), opensavebox, FALSE, FALSE, 0);
GtkWidget *cheatopen = gtk_widget_new(
GTK_TYPE_BUTTON,
"label", "Open",
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-right", 8,
NULL);
gtk_box_pack_start(GTK_BOX(opensavebox), cheatopen, FALSE, FALSE, 0);
GtkWidget *cheatclear = gtk_widget_new(
GTK_TYPE_BUTTON,
"label", "Clear",
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-right", 8,
NULL);
gtk_box_pack_start(GTK_BOX(opensavebox), cheatclear, FALSE, FALSE, 0);
GtkWidget *cheatremove = gtk_widget_new(
GTK_TYPE_BUTTON,
"label", "Remove",
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-right", 8,
NULL);
gtk_box_pack_start(GTK_BOX(opensavebox), cheatremove, FALSE, FALSE, 0);
GtkWidget *descbox = gtk_widget_new(
GTK_TYPE_BOX,
"halign", GTK_ALIGN_END,
NULL);
gtk_box_pack_start(GTK_BOX(cheatbox), descbox, FALSE, FALSE, 0);
GtkWidget *desclabel = gtk_widget_new(
GTK_TYPE_LABEL,
"label", "Description:",
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-left", 8,
"margin-right", 8,
NULL);
gtk_box_pack_start(GTK_BOX(descbox), desclabel, FALSE, FALSE, 0);
descedit = gtk_widget_new(
GTK_TYPE_ENTRY,
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-right", 8,
NULL);
gtk_box_pack_start(GTK_BOX(descbox), descedit, TRUE, TRUE, 0);
GtkWidget *ggbox = gtk_widget_new(
GTK_TYPE_BOX,
"halign", GTK_ALIGN_END,
NULL);
gtk_box_pack_start(GTK_BOX(cheatbox), ggbox, FALSE, FALSE, 0);
GtkWidget *gglabel = gtk_widget_new(
GTK_TYPE_LABEL,
"label", "Game Genie:",
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-left", 8,
"margin-right", 8,
NULL);
gtk_box_pack_start(GTK_BOX(ggbox), gglabel, FALSE, FALSE, 0);
ggedit = gtk_widget_new(
GTK_TYPE_ENTRY,
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-right", 8,
NULL);
gtk_box_pack_start(GTK_BOX(ggbox), ggedit, TRUE, TRUE, 0);
GtkWidget *genieadd = gtk_widget_new(
GTK_TYPE_BUTTON,
"label", "Add",
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-right", 8,
NULL);
gtk_box_pack_start(GTK_BOX(ggbox), genieadd, FALSE, FALSE, 0);
GtkWidget *parbox = gtk_widget_new(
GTK_TYPE_BOX,
"halign", GTK_ALIGN_END,
NULL);
gtk_box_pack_start(GTK_BOX(cheatbox), parbox, FALSE, FALSE, 0);
GtkWidget *parlabel = gtk_widget_new(
GTK_TYPE_LABEL,
"label", "Pro Action Rocky:",
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-left", 8,
"margin-right", 8,
NULL);
gtk_box_pack_start(GTK_BOX(parbox), parlabel, FALSE, FALSE, 0);
paredit = gtk_widget_new(
GTK_TYPE_ENTRY,
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-right", 8,
NULL);
gtk_box_pack_start(GTK_BOX(parbox), paredit, FALSE, FALSE, 0);
GtkWidget *paradd = gtk_widget_new(
GTK_TYPE_BUTTON,
"label", "Add",
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-right", 8,
NULL);
gtk_box_pack_start(GTK_BOX(parbox), paradd, FALSE, FALSE, 0);
GtkWidget *cheatok = gtk_widget_new(
GTK_TYPE_BUTTON,
"label", "OK",
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-right", 8,
NULL);
gtk_box_pack_start(GTK_BOX(cheatbox), cheatok, FALSE, FALSE, 0);
gtk_tree_view_set_fixed_height_mode(GTK_TREE_VIEW(treeview), FALSE);
treestore = gtk_tree_store_new(5, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
gtk_tree_view_set_model(GTK_TREE_VIEW(treeview), GTK_TREE_MODEL(treestore));
GtkCellRenderer *renderer = gtk_cell_renderer_text_new();
GtkCellRenderer *checkbox = gtk_cell_renderer_toggle_new();
GtkTreeViewColumn *column[5];
// create the display columns
column[0] = gtk_tree_view_column_new_with_attributes("Enable", checkbox, "active", 0, NULL);
column[1] = gtk_tree_view_column_new_with_attributes("Game Genie", renderer, "text", 1, NULL);
column[2] = gtk_tree_view_column_new_with_attributes("PAR", renderer, "text", 2, NULL);
column[3] = gtk_tree_view_column_new_with_attributes("Raw", renderer, "text", 3, NULL);
column[4] = gtk_tree_view_column_new_with_attributes("Description", renderer, "text", 4, NULL);
// add the display column and renderer to the tree view
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column[0]);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column[1]);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column[2]);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column[3]);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column[4]);
gtkui_cheats_fill_tree(nstpaths.cheatpath);
/*g_signal_connect(G_OBJECT(checkbox), "toggled",
G_CALLBACK(gtkui_cheats_check), NULL);*/
g_signal_connect(G_OBJECT(treeview), "row-activated",
G_CALLBACK(gtkui_cheats_toggle), NULL);
g_signal_connect(G_OBJECT(cheatopen), "clicked",
G_CALLBACK(gtkui_cheats_load), NULL);
g_signal_connect(G_OBJECT(cheatclear), "clicked",
G_CALLBACK(gtkui_cheats_clear), NULL);
g_signal_connect(G_OBJECT(cheatremove), "clicked",
G_CALLBACK(gtkui_cheats_remove), NULL);
g_signal_connect(G_OBJECT(genieadd), "clicked",
G_CALLBACK(gtkui_cheats_gg_add), NULL);
g_signal_connect(G_OBJECT(paradd), "clicked",
G_CALLBACK(gtkui_cheats_par_add), NULL);
g_signal_connect(G_OBJECT(cheatok), "clicked",
G_CALLBACK(gtkui_cheats_ok), NULL);
g_signal_connect(G_OBJECT(cheatwindow), "destroy",
G_CALLBACK(gtkui_cheats_ok), NULL);
gtk_widget_show_all(cheatwindow);
gtk_widget_hide(infobar);
return cheatwindow;
}
static GtkWidget *
create_tree (void)
{
GtkTreeSelection *selection;
GtkCellRenderer *cell;
GtkWidget *tree_view;
GtkTreeViewColumn *column;
GtkTreeStore *model;
GtkTreeIter iter;
GtkWidget *box, *label, *scrolled_window;
Demo *d = gtk_demos;
model = gtk_tree_store_new (NUM_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_INT);
tree_view = gtk_tree_view_new ();
gtk_tree_view_set_model (GTK_TREE_VIEW (tree_view), GTK_TREE_MODEL (model));
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view));
gtk_tree_selection_set_mode (GTK_TREE_SELECTION (selection),
GTK_SELECTION_BROWSE);
gtk_widget_set_size_request (tree_view, 200, -1);
/* this code only supports 1 level of children. If we
* want more we probably have to use a recursing function.
*/
while (d->title)
{
Demo *children = d->children;
gtk_tree_store_append (GTK_TREE_STORE (model), &iter, NULL);
gtk_tree_store_set (GTK_TREE_STORE (model),
&iter,
TITLE_COLUMN, d->title,
FILENAME_COLUMN, d->filename,
FUNC_COLUMN, d->func,
STYLE_COLUMN, PANGO_STYLE_NORMAL,
-1);
d++;
if (!children)
continue;
while (children->title)
{
GtkTreeIter child_iter;
gtk_tree_store_append (GTK_TREE_STORE (model), &child_iter, &iter);
gtk_tree_store_set (GTK_TREE_STORE (model),
&child_iter,
TITLE_COLUMN, children->title,
FILENAME_COLUMN, children->filename,
FUNC_COLUMN, children->func,
STYLE_COLUMN, PANGO_STYLE_NORMAL,
-1);
children++;
}
}
cell = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Widget (double click for demo)",
cell,
"text", TITLE_COLUMN,
"style", STYLE_COLUMN,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view),
GTK_TREE_VIEW_COLUMN (column));
gtk_tree_model_get_iter_first (GTK_TREE_MODEL (model), &iter);
gtk_tree_selection_select_iter (GTK_TREE_SELECTION (selection), &iter);
g_signal_connect (selection, "changed", G_CALLBACK (selection_cb), model);
g_signal_connect (tree_view, "row_activated", G_CALLBACK (row_activated_cb), model);
gtk_tree_view_collapse_all (GTK_TREE_VIEW (tree_view));
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tree_view), FALSE);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER (scrolled_window), tree_view);
label = gtk_label_new ("Widget (double click for demo)");
box = gtk_notebook_new ();
gtk_notebook_append_page (GTK_NOTEBOOK (box), scrolled_window, label);
gtk_widget_grab_focus (tree_view);
g_object_unref (model);
return box;
}
static void init_tree()
{
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkTreeStore *store;
int i;
PangoFontDescription *font_desc = pango_font_description_from_string(prefs.divelist_font);
gtk_widget_modify_font(yearly_tree, font_desc);
pango_font_description_free(font_desc);
renderer = gtk_cell_renderer_text_new ();
/* don't use empty strings "" - they confuse gettext */
char *columnstop[] = { N_("Year"), N_("#"), N_("Duration"), " ", " ", " ", N_("Depth"), " ", " ", N_("SAC"), " ", " ", N_("Temperature"), " ", " " };
const char *columnsbot[15];
columnsbot[0] = C_("Stats", " > Month");
columnsbot[1] = " ";
columnsbot[2] = C_("Duration","Total");
columnsbot[3] = C_("Duration","Average");
columnsbot[4] = C_("Duration","Shortest");
columnsbot[5] = C_("Duration","Longest");
columnsbot[6] = C_("Depth", "Average");
columnsbot[7] = C_("Depth","Minimum");
columnsbot[8] = C_("Depth","Maximum");
columnsbot[9] = C_("SAC","Average");
columnsbot[10]= C_("SAC","Minimum");
columnsbot[11]= C_("SAC","Maximum");
columnsbot[12]= C_("Temp","Average");
columnsbot[13]= C_("Temp","Minimum");
columnsbot[14]= C_("Temp","Maximum");
/* Add all the columns to the tree view */
for (i = 0; i < N_COLUMNS; ++i) {
char buf[256];
column = gtk_tree_view_column_new();
snprintf(buf, sizeof(buf), "%s\n%s", _(columnstop[i]), columnsbot[i]);
gtk_tree_view_column_set_title(column, buf);
gtk_tree_view_append_column(GTK_TREE_VIEW(yearly_tree), column);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_add_attribute(column, renderer, "text", i);
gtk_tree_view_column_set_resizable(column, TRUE);
}
/* Field types */
store = gtk_tree_store_new (
N_COLUMNS, // Columns in structure
G_TYPE_STRING, // Period (year or month)
G_TYPE_STRING, // Number of dives
G_TYPE_STRING, // Total duration
G_TYPE_STRING, // Average dive duation
G_TYPE_STRING, // Shortest dive
G_TYPE_STRING, // Longest dive
G_TYPE_STRING, // Average depth
G_TYPE_STRING, // Shallowest dive
G_TYPE_STRING, // Deepest dive
G_TYPE_STRING, // Average air consumption (SAC)
G_TYPE_STRING, // Minimum SAC
G_TYPE_STRING, // Maximum SAC
G_TYPE_STRING, // Average temperature
G_TYPE_STRING, // Minimum temperature
G_TYPE_STRING // Maximum temperature
);
gtk_tree_view_set_model (GTK_TREE_VIEW (yearly_tree), GTK_TREE_MODEL (store));
g_object_unref (store);
}
static void
parasite_widget_tree_init(ParasiteWidgetTree *widget_tree,
ParasiteWidgetTreeClass *klass)
{
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkTreeSelection *selection;
widget_tree->priv = PARASITE_WIDGET_TREE_GET_PRIVATE(widget_tree);
widget_tree->priv->model = gtk_tree_store_new(
NUM_COLUMNS,
G_TYPE_POINTER, // WIDGET
G_TYPE_STRING, // WIDGET_NAME
G_TYPE_STRING, // WIDGET_NAME
G_TYPE_BOOLEAN, // WIDGET_REALIZED
G_TYPE_BOOLEAN, // WIDGET_VISIBLE
G_TYPE_BOOLEAN, // WIDGET_MAPPED
G_TYPE_STRING, // WIDGET_WINDOW
G_TYPE_STRING, // WIDGET_ADDRESS
G_TYPE_STRING); // ROW_COLOR
widget_tree->priv->edit_mode_enabled = FALSE;
gtk_tree_view_set_model(GTK_TREE_VIEW(widget_tree),
GTK_TREE_MODEL(widget_tree->priv->model));
gtk_tree_view_set_enable_search(GTK_TREE_VIEW(widget_tree), TRUE);
gtk_tree_view_set_search_column(GTK_TREE_VIEW(widget_tree), WIDGET_NAME);
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(widget_tree));
g_signal_connect(G_OBJECT(selection), "changed",
G_CALLBACK(parasite_widget_tree_on_widget_selected),
widget_tree);
// Widget column
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer), "scale", TREE_TEXT_SCALE, NULL);
column = gtk_tree_view_column_new_with_attributes("Widget", renderer,
"text", WIDGET_TYPE,
"foreground", ROW_COLOR,
NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(widget_tree), column);
gtk_tree_view_column_set_resizable(column, TRUE);
// Name column
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer), "scale", TREE_TEXT_SCALE, NULL);
column = gtk_tree_view_column_new_with_attributes("Name", renderer,
"text", WIDGET_NAME,
"foreground", ROW_COLOR,
NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(widget_tree), column);
gtk_tree_view_column_set_resizable(column, TRUE);
// Realized column
renderer = gtk_cell_renderer_toggle_new();
g_object_set(G_OBJECT(renderer),
"activatable", TRUE,
"indicator-size", TREE_CHECKBOX_SIZE,
NULL);
column = gtk_tree_view_column_new_with_attributes("Realized",
renderer,
"active", WIDGET_REALIZED,
NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(widget_tree), column);
g_signal_connect(G_OBJECT(renderer), "toggled",
G_CALLBACK(on_toggle_realize), widget_tree);
// Mapped column
renderer = gtk_cell_renderer_toggle_new();
g_object_set(G_OBJECT(renderer),
"activatable", TRUE,
"indicator-size", TREE_CHECKBOX_SIZE,
NULL);
column = gtk_tree_view_column_new_with_attributes("Mapped",
renderer,
"active", WIDGET_MAPPED,
NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(widget_tree), column);
//g_signal_connect(G_OBJECT(renderer), "toggled",
// G_CALLBACK(on_toggle_map), widget_tree);
// Visible column
renderer = gtk_cell_renderer_toggle_new();
g_object_set(G_OBJECT(renderer),
"activatable", TRUE,
"indicator-size", TREE_CHECKBOX_SIZE,
NULL);
column = gtk_tree_view_column_new_with_attributes("Visible",
renderer,
"active", WIDGET_VISIBLE,
NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(widget_tree), column);
//g_signal_connect(G_OBJECT(renderer), "toggled",
// G_CALLBACK(on_toggle_visible), widget_tree);
// X Window column
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer),
"scale", TREE_TEXT_SCALE,
"family", "monospace",
NULL);
column = gtk_tree_view_column_new_with_attributes("X Window",
renderer,
"text", WIDGET_WINDOW,
"foreground", ROW_COLOR,
NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(widget_tree), column);
gtk_tree_view_column_set_resizable(column, TRUE);
// Poinder Address column
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer),
"scale", TREE_TEXT_SCALE,
"family", "monospace",
NULL);
column = gtk_tree_view_column_new_with_attributes("Pointer Address",
renderer,
"text", WIDGET_ADDRESS,
"foreground", ROW_COLOR,
NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(widget_tree), column);
gtk_tree_view_column_set_resizable(column, TRUE);
}
static void
run_automated_tests (void)
{
g_print ("Running automated tests...\n");
/* FIXME TreePath basic verification */
/* FIXME generic consistency checks on the models */
{
/* Make sure list store mutations don't crash anything */
GtkListStore *store;
GtkTreeModel *model;
gint i;
GtkTreeIter iter;
store = gtk_list_store_new (1, G_TYPE_INT);
model = GTK_TREE_MODEL (store);
i = 0;
while (i < 100)
{
gtk_list_store_append (store, &iter);
++i;
}
while (gtk_tree_model_get_iter_first (model, &iter))
gtk_list_store_remove (store, &iter);
gtk_list_store_append (store, &iter);
/* inserts before last node in list */
i = 0;
while (i < 100)
{
gtk_list_store_insert_before (store, &iter, &iter);
++i;
}
/* inserts after the node before the last node */
i = 0;
while (i < 100)
{
gtk_list_store_insert_after (store, &iter, &iter);
++i;
}
/* inserts after the last node */
gtk_list_store_append (store, &iter);
i = 0;
while (i < 100)
{
gtk_list_store_insert_after (store, &iter, &iter);
++i;
}
/* remove everything again */
while (gtk_tree_model_get_iter_first (model, &iter))
gtk_list_store_remove (store, &iter);
/* Prepends */
gtk_list_store_prepend (store, &iter);
i = 0;
while (i < 100)
{
gtk_list_store_prepend (store, &iter);
++i;
}
/* remove everything again */
while (gtk_tree_model_get_iter_first (model, &iter))
gtk_list_store_remove (store, &iter);
g_object_unref (store);
}
{
/* Make sure tree store mutations don't crash anything */
GtkTreeStore *store;
GtkTreeIter root;
store = gtk_tree_store_new (1, G_TYPE_INT);
gtk_tree_store_append (GTK_TREE_STORE (store), &root, NULL);
/* Remove test until it is rewritten to work */
/* treestore_torture_recurse (store, &root, 0);*/
g_object_unref (store);
}
g_print ("Passed.\n");
}
void bestelakoak()
{
GtkWidget *frame;
GtkWidget *alignment;
GtkWidget *fixed;
GtkWidget *cmdGehi;
GtkWidget *cmdKendu;
GtkWidget *cmdAdos;
GtkWidget *cmdUtzi;
GtkWidget *cmdKen;
GtkWidget *labela;
GtkWidget *cmdGehitu;
GtkWidget *taula;
GtkWidget *eventbox;
GtkWidget *cmdZenbakiak3;
GtkWidget *cmdZenbakiak2;
GtkWidget *cmdZenbakiak4;
GtkWidget *cmdZenbakiak5;
GtkWidget *cmdZenbakiak6;
GtkWidget *cmdZenbakiak9;
GtkWidget *cmdZenbakiak8;
GtkWidget *cmdZenbakiak7;
GtkWidget *cmdZenbakiak0;
GtkWidget *cmdZenbakiak10;
GtkWidget *cmdZenbakiak11;
GtkWidget *cmdZenbakiak1;
GtkTreeModel *model;
GtkCellRenderer *renderer;
/* Lehioa sortu eta konfiguratu */
frmBestelakoak = gtk_window_new (GTK_WINDOW_POPUP);
gtk_window_set_position (GTK_WINDOW (frmBestelakoak), GTK_WIN_POS_CENTER_ALWAYS);
gtk_window_set_modal (GTK_WINDOW (frmBestelakoak), TRUE);
gtk_window_set_decorated (GTK_WINDOW (frmBestelakoak), FALSE);
//gtk_window_set_type_hint (GTK_WINDOW (frmBestelakoak), GDK_WINDOW_TYPE_HINT_DIALOG);
//gtk_window_set_transient_for(GTK_WINDOW(frmBestelakoak), GTK_WINDOW(frmKontua));
/* Lehioaren egitura sortu eta kokatu */
frame = gtk_frame_new ("");
gtk_container_add (GTK_CONTAINER (frmBestelakoak), frame);
gdk_color_parse("#e3e0e0", &kolorea);
gtk_widget_modify_bg(frame, GTK_STATE_NORMAL, &kolorea);
alignment = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_container_add (GTK_CONTAINER (frame), alignment);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 12, 12, 12, 12);
fixed = gtk_fixed_new ();
gtk_container_add (GTK_CONTAINER (alignment), fixed);
labela = gtk_label_new ("<span size='large'><b> Sartu zerrendan bestelako gastuak </b></span>");
gtk_fixed_put (GTK_FIXED (fixed), labela, 0, 0);
gtk_widget_set_size_request (labela, 312, 32);
gtk_label_set_use_markup (GTK_LABEL (labela), TRUE);
/* Kalkulagailua sortu eta kokatu */
frame = gtk_frame_new (NULL);
gtk_fixed_put (GTK_FIXED (fixed), frame, 0, 32);
gdk_color_parse("#858484", &kolorea);
gtk_widget_modify_bg(frame, GTK_STATE_NORMAL, &kolorea);
gtk_widget_set_size_request (frame, 250, 300);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
alignment = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_container_add(GTK_CONTAINER(frame), alignment);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 12, 12, 12, 12);
taula = gtk_table_new (10, 3, TRUE);
gtk_container_add (GTK_CONTAINER (alignment), taula);
gtk_table_set_row_spacings (GTK_TABLE (taula), 4);
gtk_table_set_col_spacings (GTK_TABLE (taula), 4);
txtZenbakiak = gtk_entry_new ();
gtk_table_attach (GTK_TABLE (taula), txtZenbakiak, 0, 3, 0, 2,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
gtk_entry_set_invisible_char (GTK_ENTRY (txtZenbakiak), 9679);
gtk_entry_set_text(GTK_ENTRY(txtZenbakiak), "0");
cmdZenbakiak3 = gtk_button_new_with_label("3");
gtk_table_attach (GTK_TABLE (taula), cmdZenbakiak3, 2, 3, 6, 8,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
g_signal_connect(G_OBJECT(cmdZenbakiak3), "clicked",
G_CALLBACK(btmZenbakia), NULL);
cmdZenbakiak2 = gtk_button_new_with_label("2");
gtk_table_attach (GTK_TABLE (taula), cmdZenbakiak2, 1, 2, 6, 8,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
g_signal_connect(G_OBJECT(cmdZenbakiak2), "clicked",
G_CALLBACK(btmZenbakia), NULL);
cmdZenbakiak4 = gtk_button_new_with_label("4");
gtk_table_attach (GTK_TABLE (taula), cmdZenbakiak4, 0, 1, 4, 6,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
g_signal_connect(G_OBJECT(cmdZenbakiak4), "clicked",
G_CALLBACK(btmZenbakia), NULL);
cmdZenbakiak5 = gtk_button_new_with_label("5");
gtk_table_attach (GTK_TABLE (taula), cmdZenbakiak5, 1, 2, 4, 6,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
g_signal_connect(G_OBJECT(cmdZenbakiak5), "clicked",
G_CALLBACK(btmZenbakia), NULL);
cmdZenbakiak6 = gtk_button_new_with_label("6");
gtk_widget_show (cmdZenbakiak6);
gtk_table_attach (GTK_TABLE (taula), cmdZenbakiak6, 2, 3, 4, 6,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
g_signal_connect(G_OBJECT(cmdZenbakiak6), "clicked",
G_CALLBACK(btmZenbakia), NULL);
cmdZenbakiak9 = gtk_button_new_with_label("9");
gtk_widget_show (cmdZenbakiak9);
gtk_table_attach (GTK_TABLE (taula), cmdZenbakiak9, 2, 3, 2, 4,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
g_signal_connect(G_OBJECT(cmdZenbakiak9), "clicked",
G_CALLBACK(btmZenbakia), NULL);
cmdZenbakiak8 = gtk_button_new_with_label("8");
gtk_widget_show (cmdZenbakiak8);
gtk_table_attach (GTK_TABLE (taula), cmdZenbakiak8, 1, 2, 2, 4,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
g_signal_connect(G_OBJECT(cmdZenbakiak8), "clicked",
G_CALLBACK(btmZenbakia), NULL);
cmdZenbakiak7 = gtk_button_new_with_label("7");
gtk_widget_show (cmdZenbakiak7);
gtk_table_attach (GTK_TABLE (taula), cmdZenbakiak7, 0, 1, 2, 4,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
g_signal_connect(G_OBJECT(cmdZenbakiak7), "clicked",
G_CALLBACK(btmZenbakia), NULL);
cmdZenbakiak0 = gtk_button_new_with_label("0");
gtk_widget_show (cmdZenbakiak0);
gtk_table_attach (GTK_TABLE (taula), cmdZenbakiak0, 0, 1, 8, 10,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
g_signal_connect(G_OBJECT(cmdZenbakiak0), "clicked",
G_CALLBACK(btmZenbakia), NULL);
cmdZenbakiak10 = gtk_button_new_with_label(",");
gtk_widget_show (cmdZenbakiak10);
gtk_table_attach (GTK_TABLE (taula), cmdZenbakiak10, 1, 2, 8, 10,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
g_signal_connect(G_OBJECT(cmdZenbakiak10), "clicked",
G_CALLBACK(btmZenbakia), NULL);
cmdZenbakiak11 = gtk_button_new_with_label("C");
gtk_widget_show (cmdZenbakiak11);
gtk_table_attach (GTK_TABLE (taula), cmdZenbakiak11, 2, 3, 8, 10,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
g_signal_connect(G_OBJECT(cmdZenbakiak11), "clicked",
G_CALLBACK(btmZenbakia), NULL);
cmdZenbakiak1 = gtk_button_new_with_label("1");
gtk_widget_show (cmdZenbakiak1);
gtk_table_attach (GTK_TABLE (taula), cmdZenbakiak1, 0, 1, 6, 8,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
g_signal_connect(G_OBJECT(cmdZenbakiak1), "clicked",
G_CALLBACK(btmZenbakia), NULL);
labela = gtk_label_new("<span size='x-large'>>></span>");
gtk_label_set_use_markup(GTK_LABEL(labela), TRUE);
cmdGehitu = gtk_button_new();
gtk_container_add(GTK_CONTAINER(cmdGehitu), labela);
gtk_fixed_put (GTK_FIXED (fixed), cmdGehitu, 256, 136);
gtk_widget_set_size_request (cmdGehitu, 96, 64);
g_signal_connect(G_OBJECT(cmdGehitu), "clicked",
G_CALLBACK(btmGehitu), NULL);
labela = gtk_label_new("<span size='x-large'> Kendu </span>");
gtk_label_set_use_markup(GTK_LABEL(labela), TRUE);
cmdKendu = gtk_button_new();
gtk_container_add(GTK_CONTAINER(cmdKendu), labela);
gtk_fixed_put (GTK_FIXED (fixed), cmdKendu, 256, 216);
gtk_widget_set_size_request (cmdKendu, 96, 64);
g_signal_connect(G_OBJECT(cmdKendu), "clicked",
G_CALLBACK(btmKendu), NULL);
model = GTK_TREE_MODEL (gtk_tree_store_new(1, G_TYPE_STRING));
lista = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model));
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (lista),
-1, "Sartutakoak", renderer,
"text", 0,
NULL);
gtk_fixed_put (GTK_FIXED (fixed), lista, 368, 0);
gtk_widget_set_size_request (lista, 208, 560);
labela = gtk_label_new ("<span size='large'><b> Zenbat zarete ordaintzeko? </b></span>");
gtk_fixed_put (GTK_FIXED (fixed), labela, 16, 344);
gtk_widget_set_size_request (labela, 296, 32);
gtk_label_set_use_markup (GTK_LABEL (labela), TRUE);
labela = gtk_label_new("<span size='x-large'>+</span>");
gtk_label_set_use_markup(GTK_LABEL(labela), TRUE);
cmdGehi = gtk_button_new();
gtk_container_add(GTK_CONTAINER(cmdGehi), labela);
gtk_fixed_put (GTK_FIXED (fixed), cmdGehi, 112, 384);
gtk_widget_set_size_request (cmdGehi, 64, 48);
g_signal_connect(G_OBJECT(cmdGehi), "clicked",
G_CALLBACK(btmGehi), NULL);
gdk_color_parse("#bff9ed", &kolorea);
gtk_widget_modify_bg(cmdGehi, GTK_STATE_NORMAL, &kolorea);
gtk_widget_modify_bg(cmdGehi, GTK_STATE_PRELIGHT, &kolorea);
labela = gtk_label_new("<span size='x-large'>-</span>");
gtk_label_set_use_markup(GTK_LABEL(labela), TRUE);
cmdKen = gtk_button_new();
gtk_container_add(GTK_CONTAINER(cmdKen), labela);
gtk_fixed_put (GTK_FIXED (fixed), cmdKen, 176, 384);
gtk_widget_set_size_request (cmdKen, 64, 48);
g_signal_connect(G_OBJECT(cmdKen), "clicked",
G_CALLBACK(btmKen), NULL);
gdk_color_parse("#fdb5d5", &kolorea);
gtk_widget_modify_bg(cmdKen, GTK_STATE_NORMAL, &kolorea);
gtk_widget_modify_bg(cmdKen, GTK_STATE_PRELIGHT, &kolorea);
lblZenbat = gtk_label_new ("<span size='xx-large'><b>1</b></span>");
gtk_widget_set_size_request (lblZenbat, 96, 48);
gtk_label_set_use_markup (GTK_LABEL (lblZenbat), TRUE);
eventbox = gtk_event_box_new();
gtk_widget_set_size_request (eventbox, 96, 48);
gtk_container_add(GTK_CONTAINER(eventbox), lblZenbat);
gdk_color_parse("black", &kolorea);
gtk_widget_modify_bg(eventbox, GTK_STATE_NORMAL, &kolorea);
gdk_color_parse("yellow", &kolorea);
gtk_widget_modify_fg(lblZenbat, GTK_STATE_NORMAL, &kolorea);
gtk_fixed_put (GTK_FIXED (fixed), eventbox, 16, 384);
labela = gtk_label_new("<span size='x-large'>Ados</span>");
gtk_label_set_use_markup(GTK_LABEL(labela), TRUE);
cmdAdos = gtk_button_new();
gtk_container_add(GTK_CONTAINER(cmdAdos), labela);
gtk_widget_show (cmdAdos);
gtk_fixed_put (GTK_FIXED (fixed), cmdAdos, 24, 480);
gtk_widget_set_size_request (cmdAdos, 136, 48);
g_signal_connect(G_OBJECT(cmdAdos), "clicked",
G_CALLBACK(btmAdos), NULL);
labela = gtk_label_new("<span size='x-large'>Utzi</span>");
gtk_label_set_use_markup(GTK_LABEL(labela), TRUE);
cmdUtzi = gtk_button_new();
gtk_container_add(GTK_CONTAINER(cmdUtzi), labela);
gtk_widget_show (cmdUtzi);
gtk_fixed_put (GTK_FIXED (fixed), cmdUtzi, 192, 480);
gtk_widget_set_size_request (cmdUtzi, 136, 48);
g_signal_connect(G_OBJECT(cmdUtzi), "clicked",
G_CALLBACK(btmUtzi), NULL);
/* Dena bistaratu eta martxan jarri */
form_load();
gtk_widget_show_all(frmBestelakoak);
gtk_main();
}
void display_desktop_init(GtkWindow *window)
{
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
display_label_title = GTK_LABEL(lookup_widget(GTK_WIDGET(window), "label_title"));
display_desktop_treeview = GTK_TREE_VIEW(lookup_widget(GTK_WIDGET(window), "desktop_treeview"));
display_current = NULL;
display_desktop_model = GTK_TREE_MODEL(gtk_tree_store_new(DESKTOP_TREE_NCOLS,
/* DESKTOP_TREE_PIXBUF */ GDK_TYPE_PIXBUF,
/* DESKTOP_TREE_ID */ G_TYPE_STRING,
/* DESKTOP_TREE_GEOMETRY */ G_TYPE_STRING,
/* DESKTOP_TREE_STYLE */ PANGO_TYPE_STYLE,
/* DESKTOP_TREE_SCALE */ G_TYPE_FLOAT,
/* DESKTOP_TREE_DISPLAY */ G_TYPE_POINTER,
/* DESKTOP_TREE_FRAME */ G_TYPE_POINTER));
gtk_tree_view_set_model(display_desktop_treeview, display_desktop_model);
/* List selection */
display_desktop_selection = gtk_tree_view_get_selection(display_desktop_treeview);
gtk_tree_selection_set_mode(display_desktop_selection, GTK_SELECTION_BROWSE);
gtk_tree_selection_set_select_function(display_desktop_selection,
(GtkTreeSelectionFunc) display_desktop_select, NULL,
NULL);
/* Setup row activation handler */
gtk_signal_connect(GTK_OBJECT(display_desktop_treeview), "row-activated",
GTK_SIGNAL_FUNC(display_desktop_row_activated), NULL);
/* Column #0: Status pixbuf and Desktop/Frame id */
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, "Desktop / Frame");
gtk_tree_view_column_set_expand(column, TRUE);
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_add_attribute(column, renderer, "pixbuf", DESKTOP_TREE_PIXBUF);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_add_attribute(column, renderer, "text", DESKTOP_TREE_ID);
gtk_tree_view_column_add_attribute(column, renderer, "style", DESKTOP_TREE_STYLE);
gtk_tree_view_column_add_attribute(column, renderer, "scale", DESKTOP_TREE_SCALE);
gtk_tree_view_append_column(display_desktop_treeview, column);
/* Column #1: Frame geometry */
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes(display_desktop_treeview, -1, "Geometry", renderer,
"text", DESKTOP_TREE_GEOMETRY,
"style", DESKTOP_TREE_STYLE,
"scale", DESKTOP_TREE_SCALE,
NULL);
/* Collect all available display connections */
display_desktop_mklist();
if ( display_timeout == 0 )
display_timeout = g_timeout_add(1000, (GSourceFunc) display_desktop_heartbeat, NULL);
}
/*
* Creates (or activates) the addlist window
*/
void mpc_addlist_create(void) {
GtkWidget * scrollwindow;
GtkTreeSelection * selection;
GtkWidget *hbox;
GtkWidget *vbox;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkWidget * buttonbar;
GtkWidget * button;
GtkWidget * bar;
GtkWidget * url_label;
GtkWidget * url_add;
if (!mpc_addlist) {
/*
* Create the addlist window
*/
mpc_addlist = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_wmclass(GTK_WINDOW(mpc_addlist), "playlistadd", "gkrellmpc");
gtk_window_set_title(GTK_WINDOW(mpc_addlist), _("MPD ADD SONGS"));
gtk_container_border_width (GTK_CONTAINER(mpc_addlist), 10);
gtk_window_set_default_size(GTK_WINDOW(mpc_addlist), mpc_addlist_width, mpc_addlist_height);
gtk_window_set_position(GTK_WINDOW(mpc_addlist), GTK_WIN_POS_CENTER);
g_signal_connect(GTK_OBJECT(mpc_addlist), "configure_event", G_CALLBACK(mpc_addlist_configure_event), NULL);
g_signal_connect(GTK_OBJECT(mpc_addlist), "delete_event", G_CALLBACK(mpc_addlist_delete_event), NULL);
g_signal_connect(GTK_OBJECT(mpc_addlist), "destroy", G_CALLBACK(mpc_addlist_destroy_event), NULL);
g_signal_connect(mpc_addlist, "key-release-event", G_CALLBACK(mpc_cb_addlist_key), NULL);
/*
* Create URL label
*/
url_label = gtk_label_new("URL:");
/*
* Create the URL entry box
*/
mpc_addlist_url = gtk_entry_new();
/*
* Create the URL add button
*/
url_add = gtk_button_new_from_stock(GTK_STOCK_ADD);
g_signal_connect(GTK_OBJECT(url_add), "clicked", G_CALLBACK(mpc_cb_addlist_button_add), "url");
/*
* Create the bar
*/
bar = gtk_hseparator_new();
/*
* Create the data store
*/
mpc_addlist_store = gtk_tree_store_new(MPC_ADDLIST_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT);
/*
* Create addlist tree
*/
mpc_addlist_tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(mpc_addlist_store));
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(mpc_addlist_tree), TRUE);
// gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(mpc_addlist_tree), FALSE);
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(mpc_addlist_tree));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
g_signal_connect(mpc_addlist_tree, "row-activated", G_CALLBACK(mpc_cb_addlist_row), NULL);
/*
* Create the scrollwindow the addlist goes in
*/
scrollwindow = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER(scrollwindow), mpc_addlist_tree);
/*
* Create the visual columns
*/
renderer = gtk_cell_renderer_pixbuf_new ();
column = gtk_tree_view_column_new_with_attributes (NULL, renderer
, "stock-id", MPC_ADDLIST_COLUMN_ICON
, NULL);
gtk_tree_view_column_set_sort_column_id (column, MPC_ADDLIST_COLUMN_ICON);
gtk_tree_view_append_column(GTK_TREE_VIEW(mpc_addlist_tree), column);
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (_("Name"), renderer
, "text", MPC_ADDLIST_COLUMN_DISPLAYNAME
, NULL);
gtk_tree_view_column_set_sort_column_id (column, MPC_ADDLIST_COLUMN_DISPLAYNAME);
gtk_tree_view_set_search_column(GTK_TREE_VIEW(mpc_addlist_tree), MPC_ADDLIST_COLUMN_DISPLAYNAME);
gtk_tree_view_append_column(GTK_TREE_VIEW(mpc_addlist_tree), column);
/*
* Create the bottom buttons
*/
buttonbar = gtk_hbutton_box_new();
button = gtk_button_new_from_stock(GTK_STOCK_ADD);
g_signal_connect(GTK_OBJECT(button), "clicked", G_CALLBACK(mpc_cb_addlist_button_add), "list");
gtk_container_add(GTK_CONTAINER(buttonbar), button);
button = gtk_button_new_from_stock(GTK_STOCK_CLOSE);
g_signal_connect(GTK_OBJECT(button), "clicked", G_CALLBACK(mpc_cb_addlist_button_close), NULL);
gtk_container_add(GTK_CONTAINER(buttonbar), button);
/*
* And pack everything
*/
hbox = gtk_hbox_new(FALSE, 8);
gtk_box_pack_start(GTK_BOX(hbox), url_label, 0, 0, 0);
gtk_box_pack_start(GTK_BOX(hbox), mpc_addlist_url, 1, 1, 0);
gtk_box_pack_start(GTK_BOX(hbox), url_add, 0, 0, 0);
vbox = gtk_vbox_new(FALSE, 8);
gtk_box_pack_start(GTK_BOX(vbox), hbox, 0, 0, 0);
gtk_box_pack_start(GTK_BOX(vbox), bar, 0, 0, 0);
gtk_box_pack_start(GTK_BOX(vbox), scrollwindow, 1, 1, 0);
gtk_box_pack_start(GTK_BOX(vbox), buttonbar, 0, 0, 0);
gtk_container_add(GTK_CONTAINER(mpc_addlist), vbox);
/*
* Update the addlist
*/
mpc_addlist_update();
/*
* Finally show everything
*/
gtk_widget_show_all(mpc_addlist);
}
else {
/*
* Make the addlist window the foreground window
*/
gtk_window_present(GTK_WINDOW(mpc_addlist));
}
}
PrefabSelector::PrefabSelector () :
_widget(gtk_vbox_new(FALSE, 2)), _store(gtk_tree_store_new(PREFAB_STORE_SIZE, G_TYPE_STRING, G_TYPE_STRING,
GDK_TYPE_PIXBUF, G_TYPE_STRING)),
_fileFiltered(gtk_tree_model_filter_new(GTK_TREE_MODEL(_store), NULL)), _fileSorted(
GTK_TREE_MODEL(gtk_tree_model_sort_new_with_model(_fileFiltered))), _view(
GTK_TREE_VIEW(gtk_tree_view_new_with_model(_fileSorted)))
{
std::string fullpath = GlobalRegistry().get(RKEY_APP_PATH) + "prefabs/";
_selectedSelectionStrategy = PREFAB_SELECT_EXTEND;
GtkWidget* scr = gtk_scrolled_window_new(0, 0);
gtk_box_pack_start(GTK_BOX(_widget), scr, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scr), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scr), GTK_SHADOW_IN);
{
gtk_tree_view_set_enable_search(_view, TRUE);
gtk_tree_view_set_search_column(_view, PREFAB_SHORTNAME);
gtk_tree_view_set_headers_visible(_view, TRUE);
gtk_tree_view_set_headers_clickable(_view, TRUE);
#if GTK_CHECK_VERSION(2,10,0)
gtk_tree_view_set_grid_lines(_view, GTK_TREE_VIEW_GRID_LINES_HORIZONTAL);
#endif
g_signal_connect(G_OBJECT(_view), "button_press_event", G_CALLBACK(callbackButtonPress), this);
{
GtkTreeViewColumn* column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Prefab"));
gtk_tree_view_column_set_expand(column, FALSE);
gtk_tree_view_column_set_sort_indicator(column, TRUE);
gtk_tree_view_column_set_sort_column_id(column, PREFAB_SHORTNAME);
gtk_tree_view_append_column(_view, column);
GtkCellRenderer* imageRenderer = gtk_cell_renderer_pixbuf_new();
gtk_cell_renderer_set_fixed_size(imageRenderer, 128, -1);
gtk_tree_view_column_pack_start(column, imageRenderer, false);
gtk_tree_view_column_add_attribute(column, imageRenderer, "pixbuf", PREFAB_IMAGE);
GtkCellRenderer* nameRenderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_end(column, nameRenderer, false);
gtk_tree_view_column_add_attribute(column, nameRenderer, "markup", PREFAB_DESCRIPTION);
}
gtk_container_add(GTK_CONTAINER(scr), GTK_WIDGET(_view));
g_object_unref(G_OBJECT(_store));
}
GtkWidget* hboxFooter = gtk_hbox_new(TRUE, 0);
gtk_box_pack_start(GTK_BOX(_widget), hboxFooter, FALSE, TRUE, 0);
{
// options
GtkWidget* vboxOptions = gtk_vbox_new(FALSE, 3);
gtk_box_pack_start(GTK_BOX(hboxFooter), vboxOptions, FALSE, TRUE, 0);
GtkRadioButton* radioExtendSelection =
GTK_RADIO_BUTTON(gtk_radio_button_new_with_label(NULL, _("Extend current selection")));
gtk_widget_ref(GTK_WIDGET(radioExtendSelection));
gtk_box_pack_start(GTK_BOX(vboxOptions), GTK_WIDGET(radioExtendSelection), TRUE, TRUE, 0);
g_object_set_data(G_OBJECT(radioExtendSelection), "handler", gint_to_pointer(
g_signal_connect(radioExtendSelection,
"toggled", G_CALLBACK(callbackSelectionOptionToggleExtend), this)));
GtkRadioButton
* radioUnselect =
GTK_RADIO_BUTTON(gtk_radio_button_new_with_label_from_widget(radioExtendSelection, _("Deselect before insert")));
gtk_widget_ref(GTK_WIDGET(radioUnselect));
gtk_box_pack_start(GTK_BOX(vboxOptions), GTK_WIDGET(radioUnselect), TRUE, TRUE, 0);
g_object_set_data(G_OBJECT(radioUnselect), "handler", gint_to_pointer(
g_signal_connect(G_OBJECT(radioUnselect),
"toggled", G_CALLBACK(callbackSelectionOptionToggleUnselect), this)));
GtkRadioButton
* radioReplace =
GTK_RADIO_BUTTON(gtk_radio_button_new_with_label_from_widget(radioUnselect, _("Replace current selection")));
gtk_widget_ref(GTK_WIDGET(radioReplace));
gtk_box_pack_start(GTK_BOX(vboxOptions), GTK_WIDGET(radioReplace), TRUE, TRUE, 0);
g_object_set_data(G_OBJECT(radioReplace), "handler", gint_to_pointer(
g_signal_connect(G_OBJECT(radioReplace),
"toggled", G_CALLBACK(callbackSelectionOptionToggleReplace), this)));
}
{
//search entry, connect to file filter
GtkWidget* vboxSearch = gtk_vbox_new(FALSE, 3);
gtk_box_pack_start(GTK_BOX(hboxFooter), vboxSearch, FALSE, TRUE, 3);
GtkWidget *searchEntry = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(vboxSearch), searchEntry, FALSE, TRUE, 3);
gtk_widget_show(searchEntry);
gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(_fileFiltered),
(GtkTreeModelFilterVisibleFunc) callbackFilterFiles, this, NULL);
g_signal_connect(G_OBJECT(searchEntry), "changed", G_CALLBACK(callbackRefilter), NULL);
_filterEntry = GTK_ENTRY(searchEntry);
#if GTK_CHECK_VERSION(2,10,0)
gtk_tree_view_set_search_entry(_view, _filterEntry);
#endif
}
/* fill prefab store with data */
Directory_forEach(fullpath, LoadPrefabDirectoryFunctor(fullpath, "", NULL, _store));
Directory_forEach(fullpath, MatchFileExtension<LoadPrefabFileFunctor> ("map", LoadPrefabFileFunctor("", NULL, _store)));
gtk_tree_model_filter_refilter(GTK_TREE_MODEL_FILTER(_fileFiltered));
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(_fileSorted), PREFAB_SHORTNAME, GTK_SORT_ASCENDING);
}
void gif_receive_messages(void *server)
{
int server_sockfd = *(int *)server;
gifhdr_t *gifheader;
int rcv_status;
char *gifdata, *gifbuffer;
char PATHNAME[MAX_PATH_LENGTH];
pthread_t pthd = pthread_self();
while(1)
{
gifbuffer = (char *) malloc(BUFF_SIZE);
rcv_status = recv(server_sockfd, gifbuffer, BUFF_SIZE, 0);
if(rcv_status < 0) //发生错误
{
gdk_threads_enter();
message_dialog(GTK_MESSAGE_INFO, strerror(errno));
gdk_threads_leave();
pthread_cancel(pthd); //非正常退出
}
else if(rcv_status == 0) //断开连接
{
contacts_chat_window_id_t *ptr;
GtkWidget *widget;
gdk_threads_enter();
message_dialog(GTK_MESSAGE_INFO, "Server Disconnected");
gdk_threads_leave();
while(head != NULL) // freeing the allocated spaces for linked list
{
ptr = head;
head = head->next;
free(ptr);
}
gdk_threads_enter();
gtk_container_remove(GTK_CONTAINER(scrolledwindow1), tree);
widget = lookup_widget(gifmain, "butConnect");
gtk_widget_set_sensitive(widget, TRUE);
widget = lookup_widget(gifmain, "mnuConnect");
gtk_widget_set_sensitive(widget, TRUE);
widget = lookup_widget(gifmain, "mnuDisconect");
gtk_widget_set_sensitive(widget, FALSE);
widget = lookup_widget(gifmain, "butAdd");
gtk_widget_set_sensitive(widget, FALSE);
widget = lookup_widget(gifmain, "mnuAdd");
gtk_widget_set_sensitive(widget, FALSE);
widget = lookup_widget(gifmain, "mnuDelete");
gtk_widget_set_sensitive(widget, FALSE);
widget = lookup_widget(gifmain, "butConf");
gtk_widget_set_sensitive(widget, FALSE);
widget = lookup_widget(gifmain, "butOffline");
gtk_widget_set_sensitive(widget, FALSE);
widget = lookup_widget(gifmain, "mnuOffline");
gtk_widget_set_sensitive(widget, FALSE);
gdk_threads_leave();
pthread_cancel(pthd);
}
gifheader = (gifhdr_t *) malloc(sizeof(gifhdr_t));
memcpy(gifheader, gifbuffer, HEADER_LENGTH);
if((gifheader->length) > 0)
{
gifdata = (char *) malloc(gifheader->length);
memcpy(gifdata, (gifbuffer + HEADER_LENGTH), gifheader->length);
}
else
{
gifdata = NULL;
}
switch(gifheader->type)
{
case GIF_ADDRLIST_MSG:
{
contacts_chat_window_id_t *ptr;
user_status_t *usrs;
int i, counter;
gdk_threads_enter();
GtkWidget *widget;
GtkTreeStore *store;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GtkTreeIter parent_iter, child_iter;
GdkPixbuf *img;
GtkTreeSelection *select;
gdk_threads_leave();
if(gifheader->reserved == 1)
{
// removing the tree from the container for refresing
gdk_threads_enter();
gtk_container_remove(GTK_CONTAINER(scrolledwindow1), tree);
gdk_threads_leave();
while(head != NULL) // freeing the allocated spaces for linked list
{
ptr = head;
head = head->next;
free(ptr);
}
}
gdk_threads_enter();
widget = lookup_widget(gifmain, "butConnect");
gtk_widget_set_sensitive(widget, FALSE);
widget = lookup_widget(gifmain, "mnuConnect");
gtk_widget_set_sensitive(widget, FALSE);
widget = lookup_widget(gifmain, "mnuDisconect");
gtk_widget_set_sensitive(widget, TRUE);
widget = lookup_widget(gifmain, "butAdd");
gtk_widget_set_sensitive(widget, TRUE);
widget = lookup_widget(gifmain, "mnuAdd");
gtk_widget_set_sensitive(widget, TRUE);
widget = lookup_widget(gifmain, "mnuDelete");
gtk_widget_set_sensitive(widget, TRUE);
widget = lookup_widget(gifmain, "butConf");
gtk_widget_set_sensitive(widget, TRUE);
widget = lookup_widget(gifmain, "butOffline");
gtk_widget_set_sensitive(widget, TRUE);
widget = lookup_widget(gifmain, "mnuOffline");
gtk_widget_set_sensitive(widget, TRUE);
gdk_threads_leave();
//creating a model
gdk_threads_enter();
store = gtk_tree_store_new(2, G_TYPE_STRING, GDK_TYPE_PIXBUF);
gdk_threads_leave();
//creating a view
gdk_threads_enter();
tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
gdk_threads_leave();
//adding the view to the scrolledwindow
gdk_threads_enter();
gtk_container_add(GTK_CONTAINER(scrolledwindow1), tree);
gdk_threads_leave();
//creating first column
gdk_threads_enter();
renderer = gtk_cell_renderer_pixbuf_new();
column = gtk_tree_view_column_new_with_attributes("Status", renderer, "pixbuf", STATUS_COLUMN_PIXMAP, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
gdk_threads_leave();
//creating second column
gdk_threads_enter();
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Contacts", renderer, "text", CONTACTS_COLUMN_TEXT, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
gdk_threads_leave();
//Acquire a top-level iterator
gdk_threads_enter();
gtk_tree_store_append(store, &parent_iter, NULL);
if(gifheader->length != 0)
{
gtk_tree_store_set(store, &parent_iter, CONTACTS_COLUMN_TEXT, "Available", -1);
}
else
{
gtk_tree_store_set(store, &parent_iter, CONTACTS_COLUMN_TEXT, "Not Available", -1);
}
gdk_threads_leave();
i = counter = 0;
usrs = (user_status_t *) malloc(sizeof(user_status_t));
while(counter < (gifheader->length))
{
contacts_chat_window_id_t *ptr;
memcpy(usrs, (gifdata + (i * sizeof(user_status_t))), sizeof(user_status_t));
// setting the window id for each contacts and constructing a linked list
ptr = (contacts_chat_window_id_t *) malloc(sizeof(contacts_chat_window_id_t));
strcpy(ptr->contacts_name, usrs->loginid);
ptr->window_id = i;
ptr->window_open = 0;
if(head == NULL)
{
head = ptr;
ptr->next = NULL;
}
else
{
ptr->next = head;
head = ptr;
}
// setting the status image for online clients and offline clients
gdk_threads_enter();
if(usrs->status == 1)
{
get_full_path_name(PATHNAME,"ok.png",1,"client/pixmaps");
img = gdk_pixbuf_new_from_file(PATHNAME, NULL);
}
else
{
get_full_path_name(PATHNAME,"kill.png",1,"client/pixmaps");
img = gdk_pixbuf_new_from_file(PATHNAME, NULL);
}
gdk_threads_leave();
//Acquire a child iterator
gdk_threads_enter();
gtk_tree_store_append(store, &child_iter, &parent_iter);
gtk_tree_store_set(store, &child_iter, CONTACTS_COLUMN_TEXT, usrs->loginid, STATUS_COLUMN_PIXMAP, img, -1);
gdk_threads_leave();
i++;
counter = i * sizeof(user_status_t);
}
free(usrs);
gdk_threads_enter();
gtk_tree_view_expand_all(GTK_TREE_VIEW(tree));
gtk_widget_show(tree);
gdk_threads_leave();
// signal handling for "changed" event
gdk_threads_enter();
select = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
gtk_tree_selection_set_mode(select, GTK_SELECTION_SINGLE);
g_signal_connect(G_OBJECT(select), "changed", G_CALLBACK(gif_call_client_for_chat), NULL);
gdk_threads_leave();
if((gifheader->length) != 0)
{
free(gifdata);
}
free(gifheader);
free(gifbuffer);
break;
}
case GIF_CHAT_MSG:
{
contacts_chat_window_id_t *ptr;
GtkWidget *display_text;
GtkTextBuffer *buff;
GtkTextIter start, end;
int line_no;
for(ptr = head; ptr != NULL; ptr = ptr->next)
{
if((strcmp(ptr->contacts_name, gifheader->sender)) == 0)
break;
else
continue;
}
if(ptr->window_open == 0)
{
GtkWidget *widget;
GtkTextBuffer *buff;
ptr->window_open = 1; // since the window is gonna be opened
gdk_threads_enter();
chat_window[ptr->window_id] = create_Chat();
widget =
lookup_widget(chat_window[ptr->window_id], "entInput");
gtk_window_set_focus(GTK_WINDOW
(chat_window[ptr->window_id]), widget);
gtk_window_set_title(GTK_WINDOW
(chat_window[ptr->window_id]),
gifheader->sender);
gtk_widget_show(chat_window[ptr->window_id]);
gdk_threads_leave();
// creating tags(foreground color) for the buffer
gdk_threads_enter();
widget =
lookup_widget(chat_window[ptr->window_id], "txtDisplay");
buff = gtk_text_view_get_buffer(GTK_TEXT_VIEW(widget));
gtk_text_buffer_create_tag(buff, "red_foreground",
"foreground", "red", NULL);
gtk_text_buffer_create_tag(buff, "blue_foreground",
"foreground", "blue", NULL);
gdk_threads_leave();
}
gdk_threads_enter();
display_text =
lookup_widget(chat_window[ptr->window_id], "txtDisplay");
buff = gtk_text_view_get_buffer(GTK_TEXT_VIEW(display_text));
gtk_text_buffer_insert_at_cursor(buff, gifheader->sender, -1);
gtk_text_buffer_insert_at_cursor(buff, " : ", -1);
gtk_text_buffer_insert_at_cursor(buff, gifdata, -1);
gdk_threads_leave();
// setting the color(blue) for client's name in the display text box
gdk_threads_enter();
line_no = gtk_text_buffer_get_line_count(buff);
gtk_text_buffer_get_iter_at_line(buff, &start, line_no);
gtk_text_buffer_get_iter_at_line_offset(buff, &end,
line_no,
strlen
(gifheader->sender));
gtk_text_buffer_apply_tag_by_name(buff,
"blue_foreground",
&start, &end);
gtk_text_buffer_insert_at_cursor(buff, "\n", -1);
gdk_threads_leave();
if((gifheader->length) != 0)
free(gifdata);
free(gifheader);
free(gifbuffer);
break;
}
case GIF_SUCCESS_N_ERROR_MSG:
{
switch(gifheader->reserved)
{
case GIF_ERROR_LOGIN_INCORRECT:
{
gdk_threads_enter();
message_dialog(GTK_MESSAGE_INFO, "Login Incorrect");
gdk_threads_leave();
break;
}
case GIF_SUCCESS_ADD_CONTACTS:
{
gdk_threads_enter();
message_dialog(GTK_MESSAGE_INFO, "Your new contact has been successfully added");
gdk_threads_leave();
break;
}
case GIF_ERROR_ADD_CONTACTS:
{
gdk_threads_enter();
message_dialog(GTK_MESSAGE_INFO,"The contact id you entered does not belong to a gchat user");
gdk_threads_leave();
break;
}
case GIF_SUCCESS_DELETE_CONTACTS:
{
gdk_threads_enter();
message_dialog(GTK_MESSAGE_INFO,"Deleted. See the new list after you re-login");
gdk_threads_leave();
break;
}
case GIF_ERROR_DELETE_CONTACTS_NOT_A_CONTACT:
{
gdk_threads_enter();
message_dialog(GTK_MESSAGE_INFO,"1. The id you entered is not in your contact list");
gdk_threads_leave();
break;
}
case GIF_ERROR_DELETE_CONTACTS_NOT_A_MEMBER:
{
gdk_threads_enter();
message_dialog(GTK_MESSAGE_INFO,"2. The id you entered is not in your contact list");
gdk_threads_leave();
break;
}
}
if((gifheader->length) != 0)
{
free(gifdata);
}
free(gifheader);
free(gifbuffer);
break;
}
case GIF_OFFLINE_MSG:
{
int counter;
char *message;
offline_msgs_send_t *omsgs_se;
gdk_threads_enter();
GtkWidget *widget;
GtkListStore *store;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GtkTreeIter iter;
GdkPixbuf *img;
gdk_threads_leave();
if(gifheader->reserved == 1) //刷新联系人在线状态
{
offline_messages_count = 0;
//creating a model
gdk_threads_enter();
store = gtk_list_store_new(OFFLINE_COLUMNS, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
offline_temp_store = store;
gdk_threads_leave();
//creating a view
gdk_threads_enter();
offline_tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
gdk_threads_leave();
//adding the view to the scrolledwindow
gdk_threads_enter();
gtk_container_add(GTK_CONTAINER(scrolledwindow4), offline_tree);
gdk_threads_leave();
//creating first column
gdk_threads_enter();
renderer = gtk_cell_renderer_pixbuf_new();
column = gtk_tree_view_column_new_with_attributes("New/Old", renderer, "pixbuf", OFFLINE_NEW_PIXMAP, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(offline_tree), column);
gdk_threads_leave();
//creating second column
gdk_threads_enter();
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer), "foreground", "red", NULL);
column = gtk_tree_view_column_new_with_attributes("From", renderer, "text", OFFLINE_SENDER_TEXT, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(offline_tree), column);
gdk_threads_leave();
//creating third column
gdk_threads_enter();
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer), "foreground", "dark green", NULL);
column = gtk_tree_view_column_new_with_attributes("Date & Time", renderer, "text",OFFLINE_DATESERIAL_TEXT, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(offline_tree), column);
gdk_threads_leave();
//creating fourth column
gdk_threads_enter();
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Message", renderer, "text", OFFLINE_MSG_TEXT, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(offline_tree), column);
gdk_threads_leave();
}
else
{
_DEBUG("error: condition");
pthread_cancel(pthd);
return;
}
counter = 0;
omsgs_se =
(offline_msgs_send_t *) malloc(sizeof(offline_msgs_send_t));
while(counter < (gifheader->length))
{
gdk_threads_enter();
widget = lookup_widget(offline, "butOfflineDelete");
gtk_widget_set_sensitive(widget, TRUE);
gdk_threads_leave();
memcpy(omsgs_se, (gifdata + counter),
sizeof(offline_msgs_send_t));
counter = counter + sizeof(offline_msgs_send_t);
message = (char *) malloc(omsgs_se->length);
strncpy(message, (gifdata + counter), omsgs_se->length);
counter = counter + (omsgs_se->length);
// setting the status image for online clients and offline clients
gdk_threads_enter();
if(omsgs_se->new == 1)
{
get_full_path_name(PATHNAME,"ok.png",1,"client/pixmaps");
img = gdk_pixbuf_new_from_file(PATHNAME, NULL);
}
else
{
get_full_path_name(PATHNAME,"kill.png",1,"client/pixmaps");
img = gdk_pixbuf_new_from_file(PATHNAME, NULL);
}
gdk_threads_leave();
//Acquire a child iterator
gdk_threads_enter();
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter,
OFFLINE_NEW_PIXMAP, img,
OFFLINE_SENDER_TEXT,
omsgs_se->sender,
OFFLINE_DATESERIAL_TEXT,
omsgs_se->dateserial,
OFFLINE_MSG_TEXT, message, -1);
gdk_threads_leave();
offline_messages_count++;
free(message);
}
free(omsgs_se);
gdk_threads_enter();
gtk_widget_show(offline_tree);
gdk_threads_leave();
if(gifheader->reserved == 1)
{
GtkTreeSelection *select;
// signal handling for "changed" event
gdk_threads_enter();
select =
gtk_tree_view_get_selection(GTK_TREE_VIEW(offline_tree));
gtk_tree_selection_set_mode(select, GTK_SELECTION_SINGLE);
g_signal_connect(G_OBJECT(select), "changed",
G_CALLBACK
(gif_select_offline_messages), NULL);
gdk_threads_leave();
}
if((gifheader->length) != 0)
free(gifdata);
free(gifheader);
free(gifbuffer);
break;
}
}
}
gint
main (gint argc, gchar ** argv)
{
GstElement *pipeline, *src, *mxfdemux;
GstBus *bus;
GtkWidget *scrolled_window, *treeview;
if (argc < 2) {
g_print ("usage: %s MXF-FILE\n", argv[0]);
return -1;
}
if (!g_thread_supported ())
g_thread_init (NULL);
gst_init (NULL, NULL);
gtk_init (NULL, NULL);
pipeline = gst_pipeline_new ("pipeline");
src = gst_element_factory_make ("filesrc", "src");
g_object_set (G_OBJECT (src), "location", argv[1], NULL);
mxfdemux = gst_element_factory_make ("mxfdemux", "mxfdemux");
g_signal_connect (mxfdemux, "pad-added", G_CALLBACK (on_pad_added), NULL);
if (!src || !mxfdemux) {
g_error ("Unable to create all elements");
return -2;
}
gst_bin_add_many (GST_BIN (pipeline), src, mxfdemux, NULL);
if (!gst_element_link_many (src, mxfdemux, NULL)) {
g_error ("Failed to link elements");
return -3;
}
bus = gst_element_get_bus (pipeline);
gst_bus_add_signal_watch (bus);
g_signal_connect (bus, "message", G_CALLBACK (on_message), NULL);
gst_object_unref (bus);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size (GTK_WINDOW (window), 640, 480);
g_signal_connect (window, "delete-event", gtk_main_quit, NULL);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
treestore = gtk_tree_store_new (1, G_TYPE_STRING, NULL);
treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (treestore));
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview),
gtk_tree_view_column_new_with_attributes ("Element",
gtk_cell_renderer_text_new (), "text", 0, NULL));
gtk_container_add (GTK_CONTAINER (scrolled_window), treeview);
gtk_container_add (GTK_CONTAINER (window), scrolled_window);
gst_element_set_state (pipeline, GST_STATE_PLAYING);
gtk_main ();
gst_element_set_state (pipeline, GST_STATE_NULL);
gst_object_unref (pipeline);
return 0;
}
void ctree_init(void)
{
GtkTreeView *view = GTK_TREE_VIEW(ctree_wnd);
GtkTreeModel *model;
GtkCellRenderer *renderer;
GtkTreeSelection *selection;
GtkTreeViewColumn *column;
gint i;
tree = gtk_tree_store_new(CTREE_NCOLS, G_TYPE_STRING,
GDK_TYPE_PIXBUF, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_POINTER,
G_TYPE_STRING, GDK_TYPE_PIXBUF);
model = GTK_TREE_MODEL(tree);
gtk_tree_view_set_model(view, model);
gtk_tree_view_set_headers_visible(view, TRUE);
gtk_tree_view_set_headers_clickable(view, TRUE);
gtk_tree_view_set_rules_hint(view, FALSE);
column = gtk_tree_view_column_new();
gtk_tree_view_append_column(view, column);
gtk_tree_view_column_set_title(column, _("Name"));
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column),
renderer, FALSE);
gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column),
renderer, "pixbuf",
COLUMN_ICON, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column),
renderer, FALSE);
gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column),
renderer, "text", COLUMN_NAME,
"font", COLUMN_FONT,
NULL);
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_insert_column_with_attributes(view, -1, _("Attr"),
renderer, "pixbuf",
COLUMN_ATTR, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes(view, -1, _("Type"),
renderer, "text",
COLUMN_TYPE, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes(view, -1, _("Size"),
renderer, "text",
COLUMN_SIZE, NULL);
for (i = 0; i < CTREE_NVCOLS; i++)
{
GtkTreeViewColumn *col;
col = gtk_tree_view_get_column(view, i);
gtk_tree_view_column_set_resizable(col, TRUE);
gtk_tree_view_column_set_clickable(col, TRUE);
g_signal_connect(G_OBJECT(col), "clicked", G_CALLBACK(column_clicked), view);
}
selection = gtk_tree_view_get_selection(view);
gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
gtk_tree_selection_set_select_function(selection, select_func, NULL, NULL);
g_signal_connect(G_OBJECT(selection), "changed", G_CALLBACK(tree_selection_changed), NULL);
ctree_set_basetree();
}
static gboolean
callback_button_box_click (GtkWidget * widget, GdkEvent * event,
gpointer user_data)
{
GList *list, *header_list;
GList *hlist = NULL, *slist = NULL;
GtkWidget *notebook = NULL;
GtkWidget *textview = NULL;
GFile *hexfile;
GtkWidget *sc_window, *tree_view;
gboolean is_header, is_slice, is_hexval;
CodecComponents component = (CodecComponents) user_data;
char *xml_name = ui->current_xml;
char *hex_name = ui->current_hex;
switch (component) {
case COMPONENTS_HEADERS_GENERAL:
is_header = TRUE;
is_slice = FALSE;
is_hexval = FALSE;
break;
case COMPONENTS_HEADERS_SLICE:
is_slice = TRUE;
is_header = FALSE;
is_hexval = FALSE;
break;
case COMPONENTS_HEXVAL:
is_hexval = TRUE;
is_header = FALSE;
is_slice = FALSE;
break;
default:
break;
}
if (ui->prev_page)
gtk_widget_destroy (GTK_WIDGET (ui->prev_page));
if (ui->notebook_hash)
g_hash_table_destroy (ui->notebook_hash);
ui->notebook_hash = g_hash_table_new (g_str_hash, g_str_equal);
if (!is_hexval) {
header_list = analyzer_get_list_header_strings (xml_name);
while (header_list) {
if (strcmp (header_list->data, "comment")) {
if (is_header && !g_str_has_prefix (header_list->data, "slice"))
hlist = g_list_append (hlist, header_list->data);
else if (is_slice && g_str_has_prefix (header_list->data, "slice"))
hlist = g_list_append (hlist, header_list->data);
}
header_list = header_list->next;
}
notebook = gtk_notebook_new ();
g_object_set (G_OBJECT (notebook), "expand", TRUE, NULL);
gtk_notebook_set_scrollable (GTK_NOTEBOOK (notebook), TRUE);
gtk_notebook_popup_enable (GTK_NOTEBOOK (notebook));
gtk_notebook_set_show_border (GTK_NOTEBOOK (notebook), TRUE);
g_list_foreach (hlist, (GFunc) populate_notebook, (gpointer) notebook);
while (hlist) {
sc_window = g_hash_table_lookup (ui->notebook_hash, hlist->data);
if (sc_window && GTK_IS_BIN (sc_window))
tree_view = gtk_bin_get_child (GTK_BIN (sc_window));
if (tree_view) {
list = analyzer_get_list_analyzer_node_from_xml (xml_name, hlist->data);
if (list) {
GtkTreeStore *treestore;
GtkTreeModel *model;
treestore = gtk_tree_store_new (NUM_COLS,
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
g_list_foreach (list, (GFunc) fill_tree_store, treestore);
analyzer_node_list_free (list);
list = NULL;
model = GTK_TREE_MODEL (treestore);
gtk_tree_view_set_model (GTK_TREE_VIEW (tree_view), model);
g_object_unref (model);
}
}
hlist = hlist->next;
}
ui->prev_page = notebook;
gtk_container_add (GTK_CONTAINER (ui->parsed_info_vbox), notebook);
} else {
/*Display the hex dump of the frame */
GtkWidget *scrolled_window;
GtkTextBuffer *buffer;
gchar *contents;
gsize length;
textview = gtk_text_view_new ();
gtk_text_view_set_left_margin (GTK_TEXT_VIEW (textview), 20);
g_object_set (G_OBJECT (textview), "expand", TRUE, "editable", FALSE, NULL);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_container_add (GTK_CONTAINER (scrolled_window), textview);
hexfile = g_file_new_for_path (hex_name);
if (hexfile) {
if (g_file_load_contents (hexfile, NULL, &contents, &length, NULL, NULL)) {
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (textview));
gtk_text_buffer_set_text (buffer, contents, length);
g_free (contents);
g_object_unref (G_OBJECT (hexfile));
}
}
ui->prev_page = scrolled_window;
gtk_container_add (GTK_CONTAINER (ui->parsed_info_vbox), scrolled_window);
}
gtk_widget_show_all (ui->main_window);
return TRUE;
}
static void
heap_view_init (HeapView* self)
{
GtkTreeViewColumn* col = NULL;
GtkCellRenderer* renderer = NULL;
GtkTreeSelection* selection = NULL;
self->priv = g_new0 (HeapViewPrivate, 1);
/* prepare the store */
self->priv->store = gtk_tree_store_new (COLUMN_NUMBER,
G_TYPE_INT, // type
G_TYPE_POINTER, // presentity
G_TYPE_STRING, // name
G_TYPE_STRING, // status
G_TYPE_STRING); // presence
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (self->priv->store),
COLUMN_NAME, GTK_SORT_ASCENDING);
/* prepare the view */
self->priv->view = GTK_TREE_VIEW (gtk_tree_view_new_with_model (GTK_TREE_MODEL (self->priv->store)));
g_object_unref (self->priv->store);
gtk_tree_view_set_headers_visible (self->priv->view, FALSE);
/* show the name of a group */
col = gtk_tree_view_column_new ();
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_set_spacing (col, 0);
gtk_tree_view_column_pack_start (col, renderer, FALSE);
gtk_tree_view_column_add_attribute (col, renderer, "text", COLUMN_NAME);
gtk_tree_view_column_set_alignment (col, 0.0);
g_object_set (renderer, "xalign", 0.5, "ypad", 0, NULL);
g_object_set (renderer, "weight", PANGO_WEIGHT_BOLD, NULL);
gtk_tree_view_append_column (self->priv->view, col);
gtk_tree_view_column_set_cell_data_func (col, renderer,
hide_show_depending_on_type,
GINT_TO_POINTER (TYPE_GROUP), NULL);
/* show the name+status of a presentity */
col = gtk_tree_view_column_new ();
renderer = gm_cell_renderer_bitext_new ();
gtk_tree_view_column_set_spacing (col, 0);
gtk_tree_view_column_pack_start (col, renderer, FALSE);
gtk_tree_view_column_add_attribute (col, renderer, "primary-text", COLUMN_NAME);
gtk_tree_view_column_add_attribute (col, renderer, "secondary-text", COLUMN_STATUS);
gtk_tree_view_column_set_alignment (col, 0.0);
g_object_set (renderer, "xalign", 0.5, "ypad", 0, NULL);
gtk_tree_view_append_column (self->priv->view, col);
gtk_tree_view_column_set_cell_data_func (col, renderer,
hide_show_depending_on_type,
GINT_TO_POINTER (TYPE_PRESENTITY), NULL);
/* show the presence of a presentity */
col = gtk_tree_view_column_new ();
renderer = gtk_cell_renderer_pixbuf_new ();
g_object_set (renderer, "yalign", 0.5, "xpad", 5, NULL);
gtk_tree_view_column_pack_start (col, renderer, FALSE);
gtk_tree_view_column_add_attribute (col, renderer,
"stock-id",
COLUMN_PRESENCE);
gtk_tree_view_append_column (self->priv->view, col);
gtk_tree_view_column_set_cell_data_func (col, renderer,
hide_show_depending_on_type,
GINT_TO_POINTER (TYPE_PRESENTITY), NULL);
/* notify when the selection changed */
selection = gtk_tree_view_get_selection (self->priv->view);
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
g_signal_connect (selection, "changed", G_CALLBACK (on_selection_changed), self);
/* show a popup menu when right-click */
g_signal_connect (self->priv->view, "event-after", G_CALLBACK (on_right_click_in_the_view), self);
}
