int main(int argc,char **argv)
{
GtkWidget *win;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *notebook;
GtkWidget *page;
GtkWidget *button;
GtkWidget *api[4];
GtkWidget *box;
GtkWidget *label;
PREData data;
char *name[]={"百度词典:","必应词典:","金山词霸:","有道词典:"};
char *dic[]={"百度词典","必应词典","金山词霸","有道词典"};
int i;
/*设置默认UTF-8编码*/
setlocale(LC_ALL,"");
#ifdef _WIN32
putenv("LANG=zh_CN.UTF-8");
#else
setenv("LANG","zh_CN.UTF-8");
#endif
/*先读取出配置*/
duoyi_read_config(&data.data);
/*默认状态为未更改*/
data.changed=FALSE;
gtk_init(&argc,&argv);
win=gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(win),"配置");
gtk_window_set_position(GTK_WINDOW(win),GTK_WIN_POS_CENTER);
gtk_window_set_icon_from_file(GTK_WINDOW(win),
"img/64x64/preferences.png",NULL);
gtk_window_set_resizable(GTK_WINDOW(win),FALSE);
g_signal_connect(G_OBJECT(win),"delete-event",
G_CALLBACK(pre_quit),&data);
vbox=gtk_box_new(GTK_ORIENTATION_VERTICAL,0);
notebook=gtk_notebook_new();
gtk_container_add(GTK_CONTAINER(win),vbox);
gtk_box_pack_start(GTK_BOX(vbox),notebook,FALSE,FALSE,5);
/*添加常规页*/
page=gtk_box_new(GTK_ORIENTATION_VERTICAL,0);
label=gtk_label_new("常规");
gtk_notebook_append_page(GTK_NOTEBOOK(notebook),page,label);
/*添加选择字体按钮*/
label=gtk_label_new("选择字体:");
hbox=gtk_box_new(GTK_ORIENTATION_HORIZONTAL,0);
gtk_box_pack_start(GTK_BOX(page),hbox,FALSE,FALSE,20);
gtk_box_pack_start(GTK_BOX(hbox),label,FALSE,FALSE,20);
if(data.data.font)
button=gtk_font_button_new_with_font(data.data.font);
else
button=gtk_font_button_new();
/*按钮使用字体显示文字*/
gtk_font_button_set_use_font(GTK_FONT_BUTTON(button),TRUE);
gtk_font_button_set_title(GTK_FONT_BUTTON(button),"字体选择");
gtk_box_pack_start(GTK_BOX(hbox),button,TRUE,TRUE,100);
g_signal_connect(G_OBJECT(button),"font-set",
G_CALLBACK(pre_set_font),&data);
/*添加默认词典选择*/
hbox=gtk_box_new(GTK_ORIENTATION_HORIZONTAL,0);
gtk_box_pack_start(GTK_BOX(page),hbox,FALSE,FALSE,20);
label=gtk_label_new("默认词典:");
gtk_box_pack_start(GTK_BOX(hbox),label,FALSE,FALSE,20);
box=gtk_combo_box_text_new();
for(i=0;i != 4;++i)
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(box),dic[i]);
gtk_combo_box_set_active(GTK_COMBO_BOX(box),data.data.dic);
g_signal_connect(G_OBJECT(box),"changed",
G_CALLBACK(pre_set_default_dic),&data);
//gtk_combo_box_set_active(GTK_COMBO_BOX(box),data.data.dic);
gtk_box_pack_start(GTK_BOX(hbox),box,TRUE,TRUE,100);
/*添加API页*/
page=gtk_box_new(GTK_ORIENTATION_VERTICAL,0);
label=gtk_label_new("API");
gtk_notebook_append_page(GTK_NOTEBOOK(notebook),page,label);
for(i=0;i != 4;++i)
{
/*名称*/
label=gtk_label_new(name[i]);
/*api输入框*/
api[i]=gtk_entry_new();
/*api*/
data.api[i]=api[i];
/*如果当前API已设置，则显示出来*/
if(data.data.api[i])
gtk_entry_set_text(GTK_ENTRY(api[i]),data.data.api[i]);
hbox=gtk_box_new(GTK_ORIENTATION_HORIZONTAL,0);
gtk_box_pack_start(GTK_BOX(page),hbox,TRUE,TRUE,10);
gtk_box_pack_start(GTK_BOX(hbox),label,TRUE,TRUE,10);
gtk_box_pack_start(GTK_BOX(hbox),api[i],TRUE,TRUE,10);
/*如有改动更改操作状态*/
g_signal_connect(G_OBJECT(api[i]),"changed",
G_CALLBACK(pre_save_flag),&data);
}
hbox=gtk_box_new(GTK_ORIENTATION_HORIZONTAL,0);
gtk_box_pack_end(GTK_BOX(vbox),hbox,FALSE,FALSE,5);
gtk_box_pack_end(GTK_BOX(vbox),
gtk_separator_new(GTK_ORIENTATION_HORIZONTAL),
FALSE,FALSE,5);
label=gtk_label_new("所有更改均在重启后生效!");
gtk_box_pack_end(GTK_BOX(vbox),label,FALSE,FALSE,5);
/*取消按钮*/
button=gtk_button_new_with_label("取消");
gtk_box_pack_start(GTK_BOX(hbox),button,FALSE,FALSE,20);
g_signal_connect(G_OBJECT(button),"clicked",
G_CALLBACK(pre_quit),&data);
/*保存按钮*/
button=gtk_button_new_with_label("保存");
gtk_box_pack_end(GTK_BOX(hbox),button,FALSE,FALSE,20);
g_signal_connect(G_OBJECT(button),"clicked",
G_CALLBACK(pre_quit_with_save),&data);
gtk_widget_show_all(win);
gtk_main();
return 0;
}
static void
display_prefs_dialog (GtkAction *action,
WinPickerApp *applet)
{
GtkWidget *window, *box, *vbox, *nb, *hbox, *label, *check, *button;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), _("Preferences"));
gtk_window_set_icon_name (GTK_WINDOW (window), "preferences-system-windows");
gtk_window_set_type_hint (GTK_WINDOW (window),
GDK_WINDOW_TYPE_HINT_DIALOG);
gtk_container_set_border_width (GTK_CONTAINER (window), 12);
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
gtk_container_add (GTK_CONTAINER (window), box);
nb = gtk_notebook_new ();
g_object_set (nb, "show-tabs", FALSE, "show-border", TRUE, NULL);
gtk_box_pack_start (GTK_BOX (box), nb, TRUE, TRUE, 0);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 8);
gtk_notebook_append_page (GTK_NOTEBOOK (nb), vbox, NULL);
check = gtk_check_button_new_with_label (_("Show all windows"));
gtk_widget_set_tooltip_text (GTK_WIDGET (check),
_("Show windows from all workspaces."));
gtk_box_pack_start (GTK_BOX (vbox), check, FALSE, TRUE, 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check),
g_settings_get_boolean (mainapp->settings, SHOW_WIN_KEY));
g_signal_connect (check, "toggled",
G_CALLBACK (on_show_win_key_checkbox_toggled), NULL);
check = gtk_check_button_new_with_label (_("Show desktop title and logout button"));
gtk_widget_set_tooltip_text (GTK_WIDGET (check),
_("Show a title for the desktop when no window is selected, and append a logout button."));
gtk_box_pack_start (GTK_BOX (vbox), check, FALSE, TRUE, 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check),
g_settings_get_boolean (mainapp->settings, SHOW_HOME_TITLE_KEY));
g_signal_connect (check, "toggled",
G_CALLBACK (on_show_home_title_checkbox_toggled), NULL);
check = gtk_check_button_new_with_label (_("Bold windows title"));
gtk_widget_set_tooltip_text (GTK_WIDGET (check),
_("Show windows title with a bold face."));
gtk_box_pack_start (GTK_BOX (vbox), check, FALSE, TRUE, 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check),
g_settings_get_boolean (mainapp->settings, BOLD_WINDOW_TITLE_KEY));
g_signal_connect (check, "toggled",
G_CALLBACK (on_bold_window_title_checkbox_toggled), NULL);
check = gtk_label_new (" ");
gtk_box_pack_start (GTK_BOX (vbox), check, TRUE, TRUE, 0);
gtk_widget_set_size_request (nb, -1, 100);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (box), hbox, FALSE, FALSE, 0);
label = gtk_label_new (" ");
gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0);
button = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
gtk_widget_show_all (window);
g_signal_connect (window, "delete-event",
G_CALLBACK (gtk_widget_destroy), window);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroy), window);
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_widget_destroy), window);
gtk_window_present (GTK_WINDOW (window));
}
bool RunLinuxDialog()
{
GtkWidget *dialog;
int return_value;
/* Create the widgets */
dialog = gtk_dialog_new_with_buttons (
"GSdx Config",
NULL, /* parent window*/
(GtkDialogFlags)(GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT),
"OK", GTK_RESPONSE_ACCEPT,
// "Cancel", GTK_RESPONSE_REJECT, // Drop because it is too annoying to support call back this way
NULL);
// The main area for the whole dialog box.
GtkWidget* main_box = gtk_vbox_new(false, 5);
GtkWidget* central_box = gtk_vbox_new(false, 5);
GtkWidget* advanced_box = gtk_vbox_new(false, 5);
GtkWidget* debug_box = gtk_vbox_new(false, 5);
// Grab a logo, to make things look nice.
GdkPixbuf* logo_pixmap = gdk_pixbuf_from_pixdata(&gsdx_ogl_logo, false, NULL);
GtkWidget* logo_image = gtk_image_new_from_pixbuf(logo_pixmap);
gtk_box_pack_start(GTK_BOX(main_box), logo_image, true, true, 0);
GtkWidget* main_table = CreateTableInBox(main_box , NULL , 2 , 2);
GtkWidget* shader_table = CreateTableInBox(central_box , "Custom Shader Settings" , 9 , 2);
GtkWidget* hw_table = CreateTableInBox(central_box , "Hardware Mode Settings" , 7 , 2);
GtkWidget* sw_table = CreateTableInBox(central_box , "Software Mode Settings" , 2 , 2);
GtkWidget* hack_table = CreateTableInBox(advanced_box, "Hacks" , 7 , 2);
GtkWidget* gl_table = CreateTableInBox(advanced_box, "OpenGL Very Advanced Custom Settings" , 6 , 2);
GtkWidget* record_table = CreateTableInBox(debug_box , "Recording Settings" , 4 , 3);
GtkWidget* debug_table = CreateTableInBox(debug_box , "OpenGL / GSdx Debug Settings" , 6 , 3);
// Populate all the tables
populate_main_table(main_table);
populate_shader_table(shader_table);
populate_hw_table(hw_table);
populate_sw_table(sw_table);
populate_hack_table(hack_table);
populate_gl_table(gl_table);
populate_debug_table(debug_table);
populate_record_table(record_table);
// Handle some nice tab
GtkWidget* notebook = gtk_notebook_new();
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), central_box , gtk_label_new("Global Settings"));
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), advanced_box, gtk_label_new("Advanced Settings"));
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), debug_box , gtk_label_new("Debug/Recording Settings"));
// Put everything in the big box.
gtk_container_add(GTK_CONTAINER(main_box), notebook);
// Put the box in the dialog and show it to the world.
gtk_container_add (GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), main_box);
gtk_widget_show_all (dialog);
return_value = gtk_dialog_run (GTK_DIALOG (dialog));
// Compatibility & not supported option
int mode_width = theApp.GetConfig("ModeWidth", 640);
int mode_height = theApp.GetConfig("ModeHeight", 480);
theApp.SetConfig("ModeHeight", mode_height);
theApp.SetConfig("ModeWidth", mode_width);
theApp.SetConfig("msaa", 0);
theApp.SetConfig("windowed", 1);
gtk_widget_destroy (dialog);
return (return_value == GTK_RESPONSE_ACCEPT);
}
void termit_append_tab_with_details(const struct TabInfo* ti)
{
struct TermitTab* pTab = g_malloc0(sizeof(struct TermitTab));
termit_style_copy(&pTab->style, &configs.style);
if (ti->name) {
pTab->tab_name = gtk_label_new(ti->name);
pTab->custom_tab_name = TRUE;
} else {
gchar* label_text = g_strdup_printf("%s %d", configs.default_tab_name, termit.tab_max_number++);
pTab->tab_name = gtk_label_new(label_text);
g_free(label_text);
pTab->custom_tab_name = FALSE;
}
pTab->encoding = (ti->encoding) ? g_strdup(ti->encoding) : g_strdup(configs.default_encoding);
pTab->bksp_binding = ti->bksp_binding;
pTab->delete_binding = ti->delete_binding;
pTab->hbox = gtk_hbox_new(FALSE, 0);
pTab->vte = vte_terminal_new();
vte_terminal_set_scrollback_lines(VTE_TERMINAL(pTab->vte), configs.scrollback_lines);
if (configs.default_word_chars)
vte_terminal_set_word_chars(VTE_TERMINAL(pTab->vte), configs.default_word_chars);
vte_terminal_set_mouse_autohide(VTE_TERMINAL(pTab->vte), TRUE);
vte_terminal_set_backspace_binding(VTE_TERMINAL(pTab->vte), pTab->bksp_binding);
vte_terminal_set_delete_binding(VTE_TERMINAL(pTab->vte), pTab->delete_binding);
#ifdef TERMIT_ENABLE_SEARCH
vte_terminal_search_set_wrap_around(VTE_TERMINAL(pTab->vte), TRUE);
#endif // TERMIT_ENABLE_SEARCH
/* parse command */
gchar **cmd_argv;
GError *cmd_err = NULL;
gchar *cmd_path = NULL;
gchar *cmd_file = NULL;
pTab->command = (ti->command) ? g_strdup(ti->command) : g_strdup(configs.default_command);
if (!g_shell_parse_argv(pTab->command, NULL, &cmd_argv, &cmd_err)) {
ERROR("%s", _("Cannot parse command. Creating tab with shell"));
g_error_free(cmd_err);
} else {
cmd_path = g_find_program_in_path(cmd_argv[0]);
cmd_file = g_path_get_basename(cmd_argv[0]);
}
TRACE("command=%s cmd_path=%s cmd_file=%s", pTab->command, cmd_path, cmd_file);
if (cmd_path && cmd_file) {
g_free(cmd_argv[0]);
cmd_argv[0] = g_strdup(cmd_path);
#if VTE_CHECK_VERSION(0, 26, 0) > 0
if (vte_terminal_fork_command_full(VTE_TERMINAL(pTab->vte),
VTE_PTY_DEFAULT,
ti->working_dir,
cmd_argv, NULL,
0,
NULL, NULL,
&pTab->pid,
&cmd_err) != TRUE) {
ERROR("failed to open tab: %s", cmd_err->message);
g_error_free(cmd_err);
}
#else
pTab->pid = vte_terminal_fork_command(VTE_TERMINAL(pTab->vte),
cmd_path, cmd_argv, NULL, ti->working_dir, TRUE, TRUE, TRUE);
#endif // version >= 0.26
} else {
g_free(pTab->command);
pTab->command = g_strdup(configs.default_command);
gchar* argv[] = {pTab->command, NULL};
TRACE("defaults: cmd=%s working_dir=%s", pTab->command, ti->working_dir);
/* default tab */
#if VTE_CHECK_VERSION(0, 26, 0) > 0
if (vte_terminal_fork_command_full(VTE_TERMINAL(pTab->vte),
VTE_PTY_DEFAULT,
ti->working_dir,
argv, NULL,
G_SPAWN_SEARCH_PATH,
NULL, NULL,
&pTab->pid,
&cmd_err) != TRUE) {
ERROR("failed to open tab: %s", cmd_err->message);
g_error_free(cmd_err);
}
#else
pTab->pid = vte_terminal_fork_command(VTE_TERMINAL(pTab->vte),
pTab->command, NULL, NULL, ti->working_dir, TRUE, TRUE, TRUE);
#endif // version >= 0.26
}
g_strfreev(cmd_argv);
g_free(cmd_path);
g_free(cmd_file);
g_signal_connect(G_OBJECT(pTab->vte), "beep", G_CALLBACK(termit_on_beep), pTab);
g_signal_connect(G_OBJECT(pTab->vte), "focus-in-event", G_CALLBACK(termit_on_focus), pTab);
g_signal_connect(G_OBJECT(pTab->vte), "window-title-changed", G_CALLBACK(termit_on_tab_title_changed), NULL);
g_signal_connect(G_OBJECT(pTab->vte), "child-exited", G_CALLBACK(termit_on_child_exited), NULL);
// g_signal_connect(G_OBJECT(pTab->vte), "eof", G_CALLBACK(termit_eof), NULL);
g_signal_connect_swapped(G_OBJECT(pTab->vte), "button-press-event", G_CALLBACK(termit_on_popup), NULL);
vte_terminal_set_encoding(VTE_TERMINAL(pTab->vte), pTab->encoding);
pTab->matches = g_array_new(FALSE, TRUE, sizeof(struct Match));
termit_tab_add_matches(pTab, configs.matches);
termit_tab_set_transparency(pTab, pTab->style.transparency);
vte_terminal_set_font(VTE_TERMINAL(pTab->vte), pTab->style.font);
gint index = gtk_notebook_append_page(GTK_NOTEBOOK(termit.notebook), pTab->hbox, pTab->tab_name);
if (index == -1) {
ERROR("%s", _("Cannot create a new tab"));
return;
}
if (configs.fill_tabbar) {
GValue val = {};
g_value_init(&val, G_TYPE_BOOLEAN);
g_value_set_boolean(&val, TRUE);
gtk_container_child_set_property(GTK_CONTAINER(termit.notebook), pTab->hbox, "tab-expand", &val);
gtk_container_child_set_property(GTK_CONTAINER(termit.notebook), pTab->hbox, "tab-fill", &val);
}
termit_tab_set_audible_bell(pTab, configs.audible_bell);
termit_tab_set_visible_bell(pTab, configs.visible_bell);
pTab->scrollbar = gtk_vscrollbar_new(vte_terminal_get_adjustment(VTE_TERMINAL(pTab->vte)));
gtk_box_pack_start(GTK_BOX(pTab->hbox), pTab->vte, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(pTab->hbox), pTab->scrollbar, FALSE, FALSE, 0);
GtkWidget* tabWidget = gtk_notebook_get_nth_page(GTK_NOTEBOOK(termit.notebook), index);
if (!tabWidget) {
ERROR("tabWidget is NULL");
return;
}
g_object_set_data(G_OBJECT(tabWidget), TERMIT_TAB_DATA, pTab);
if (index == 0) { // there is no "switch-page" signal on the first page
termit_set_statusbar_message(index);
}
pTab->scrollbar_is_shown = configs.show_scrollbar;
gtk_widget_show_all(termit.notebook);
if (pTab->style.image_file == NULL) {
vte_terminal_set_background_image(VTE_TERMINAL(pTab->vte), NULL);
} else {
vte_terminal_set_background_image_file(VTE_TERMINAL(pTab->vte), pTab->style.image_file);
}
termit_tab_apply_colors(pTab);
gtk_notebook_set_current_page(GTK_NOTEBOOK(termit.notebook), index);
gtk_notebook_set_tab_reorderable(GTK_NOTEBOOK(termit.notebook), pTab->hbox, TRUE);
gtk_window_set_focus(GTK_WINDOW(termit.main_window), pTab->vte);
termit_check_single_tab();
termit_hide_scrollbars();
}
void show_about()
{
GtkWidget *window;
GtkWidget *image;
GdkPixbuf *pixbuf;
GtkWidget *vbox;
GtkWidget *notebook;
GtkWidget *scroll;
GtkWidget *textview;
GtkWidget *tablabel;
GtkWidget *action_area;
GtkWidget *button;
hand_cursor = gdk_cursor_new (GDK_HAND2);
regular_cursor = gdk_cursor_new (GDK_XTERM);
pixbuf = gdk_pixbuf_new_from_file_at_size(SKIN_DIR"fetion.svg", 40, 40, NULL);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_window_set_icon(GTK_WINDOW(window), pixbuf);
g_object_unref(pixbuf);
gtk_window_set_title(GTK_WINDOW(window), _("About OpenFetion"));
gtk_widget_set_usize(window, 500, 400);
vbox = gtk_vbox_new(FALSE, 5);
pixbuf = gdk_pixbuf_new_from_file_at_size(SKIN_DIR"fetion.svg", 98, 98, NULL);
image = gtk_image_new_from_pixbuf(pixbuf);
g_object_unref(pixbuf);
gtk_box_pack_start(GTK_BOX(vbox), image, FALSE, FALSE, 0);
notebook = gtk_notebook_new();
gtk_notebook_set_tab_pos(GTK_NOTEBOOK(notebook), GTK_POS_LEFT);
gtk_box_pack_start(GTK_BOX(vbox), notebook, TRUE, TRUE, 5);
tablabel = gtk_label_new(_("Introduction"));
scroll = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll),
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
textview = gtk_text_view_new();
create_intro(GTK_TEXT_VIEW(textview));
gtk_container_add(GTK_CONTAINER(scroll), textview);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook),
scroll, tablabel);
tablabel = gtk_label_new(_("About the author"));
scroll = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll),
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
textview = gtk_text_view_new();
create_author(GTK_TEXT_VIEW(textview));
gtk_container_add(GTK_CONTAINER(scroll), textview);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook),
scroll, tablabel);
tablabel = gtk_label_new(_("Contributor"));
scroll = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll),
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
textview = gtk_text_view_new();
create_contri(GTK_TEXT_VIEW(textview));
gtk_container_add(GTK_CONTAINER(scroll), textview);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook),
scroll, tablabel);
tablabel = gtk_label_new(_("License"));
scroll = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
textview = gtk_text_view_new();
create_gpl(GTK_TEXT_VIEW(textview));
gtk_container_add(GTK_CONTAINER(scroll), textview);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook),
scroll, tablabel);
action_area = gtk_hbox_new(FALSE, 10);
gtk_box_pack_start(GTK_BOX(vbox), action_area, FALSE, FALSE, 5);
button = gtk_button_new_with_label(_("Close"));
gtk_widget_set_usize(button, 90, 0);
gtk_box_pack_end(GTK_BOX(action_area), button, FALSE, FALSE, 5);
g_signal_connect(button, "clicked", G_CALLBACK(close_about), window);
gtk_container_add(GTK_CONTAINER(window), vbox);
gtk_widget_show_all(window);
}
int
main (int argc, char **argv)
{
GtkWidget *window;
GtkWidget *collection;
GError *err;
clock_t start, end;
GtkWidget *notebook;
int i;
bindtextdomain (GETTEXT_PACKAGE, METACITY_LOCALEDIR);
textdomain(GETTEXT_PACKAGE);
bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
run_position_expression_tests ();
#if 0
run_position_expression_timings ();
#endif
gtk_init (&argc, &argv);
if (g_getenv ("METACITY_DEBUG") != NULL)
{
meta_set_debugging (TRUE);
meta_set_verbose (TRUE);
}
start = clock ();
err = NULL;
if (argc == 1)
global_theme = meta_theme_load ("Atlanta", &err);
else if (argc == 2)
global_theme = meta_theme_load (argv[1], &err);
else
{
g_printerr (_("Usage: metacity-theme-viewer [THEMENAME]\n"));
exit (1);
}
end = clock ();
if (global_theme == NULL)
{
g_printerr (_("Error loading theme: %s\n"),
err->message);
g_error_free (err);
exit (1);
}
g_print (_("Loaded theme \"%s\" in %g seconds\n"),
global_theme->name,
(end - start) / (double) CLOCKS_PER_SEC);
run_theme_benchmark ();
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size (GTK_WINDOW (window), 350, 350);
if (strcmp (global_theme->name, global_theme->readable_name)==0)
gtk_window_set_title (GTK_WINDOW (window),
global_theme->readable_name);
else
{
/* The theme directory name is different from the name the theme
* gives itself within its file. Display both, directory name first.
*/
gchar *title = g_strconcat (global_theme->name, " - ",
global_theme->readable_name,
NULL);
gtk_window_set_title (GTK_WINDOW (window),
title);
g_free (title);
}
g_signal_connect (G_OBJECT (window), "destroy",
G_CALLBACK (gtk_main_quit), NULL);
gtk_widget_realize (window);
g_assert (window->style);
g_assert (window->style->font_desc);
notebook = gtk_notebook_new ();
gtk_container_add (GTK_CONTAINER (window), notebook);
collection = preview_collection (FONT_SIZE_NORMAL,
window->style->font_desc);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook),
collection,
gtk_label_new (_("Normal Title Font")));
collection = preview_collection (FONT_SIZE_SMALL,
window->style->font_desc);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook),
collection,
gtk_label_new (_("Small Title Font")));
collection = preview_collection (FONT_SIZE_LARGE,
window->style->font_desc);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook),
collection,
gtk_label_new (_("Large Title Font")));
collection = previews_of_button_layouts ();
gtk_notebook_append_page (GTK_NOTEBOOK (notebook),
collection,
gtk_label_new (_("Button Layouts")));
collection = benchmark_summary ();
gtk_notebook_append_page (GTK_NOTEBOOK (notebook),
collection,
gtk_label_new (_("Benchmark")));
i = 0;
while (i < (int) G_N_ELEMENTS (previews))
{
/* preview widget likes to be realized before its size request.
* it's lame that way.
*/
gtk_widget_realize (previews[i]);
++i;
}
gtk_widget_show_all (window);
gtk_main ();
return 0;
}
static void
xfpm_info_add_device_view (XfpmInfo *info, GHashTable *props, const gchar *object_path)
{
GtkWidget *view;
GtkListStore *list_store;
GtkTreeIter iter;
GtkTreeViewColumn *col;
GtkCellRenderer *renderer;
GValue *value;
const gchar *cstr;
gchar *str;
gint i = 0;
guint type = 0;
const gchar *battery_type = NULL;
view = gtk_tree_view_new ();
list_store = gtk_list_store_new (XFPM_DEVICE_INFO_LAST, G_TYPE_STRING, G_TYPE_STRING);
gtk_tree_view_set_model (GTK_TREE_VIEW (view), GTK_TREE_MODEL (list_store));
renderer = gtk_cell_renderer_text_new ();
/*Device Attribute*/
col = gtk_tree_view_column_new();
gtk_tree_view_column_pack_start (col, renderer, FALSE);
gtk_tree_view_column_set_attributes (col, renderer, "text", XFPM_DEVICE_INFO_NAME, NULL);
gtk_tree_view_column_set_title (col, _("Attribute"));
gtk_tree_view_append_column (GTK_TREE_VIEW (view), col);
/*Device Attribute Value*/
col = gtk_tree_view_column_new();
gtk_tree_view_column_pack_start (col, renderer, FALSE);
gtk_tree_view_column_set_attributes (col, renderer, "text", XFPM_DEVICE_INFO_VALUE, NULL);
gtk_tree_view_column_set_title (col, _("Value"));
gtk_tree_view_append_column (GTK_TREE_VIEW (view), col);
/**
* Add Device information:
**/
/*Device*/
gtk_list_store_append (list_store, &iter);
gtk_list_store_set (list_store, &iter,
XFPM_DEVICE_INFO_NAME, _("Device"),
XFPM_DEVICE_INFO_VALUE, g_str_has_prefix (object_path, UPOWER_PATH_DEVICE) ? object_path + strlen (UPOWER_PATH_DEVICE) : object_path,
-1);
i++;
/*Type*/
value = g_hash_table_lookup (props, "Type");
if ( value )
{
type = g_value_get_uint (value);
battery_type = xfpm_power_translate_device_type (type);
gtk_list_store_append (list_store, &iter);
gtk_list_store_set (list_store, &iter,
XFPM_DEVICE_INFO_NAME, _("Type"),
XFPM_DEVICE_INFO_VALUE, battery_type,
-1);
i++;
}
value = g_hash_table_lookup (props, "PowerSupply");
if ( value )
{
gtk_list_store_append (list_store, &iter);
gtk_list_store_set (list_store, &iter,
XFPM_DEVICE_INFO_NAME, _("PowerSupply"),
XFPM_DEVICE_INFO_VALUE, g_value_get_boolean (value) == TRUE ? _("True") : _("False"),
-1);
i++;
}
if ( type != XFPM_DEVICE_TYPE_LINE_POWER )
{
/*Model*/
value = g_hash_table_lookup (props, "Model");
if ( value )
{
cstr = g_value_get_string (value);
if ( cstr && strlen (cstr) > 0)
{
gtk_list_store_append (list_store, &iter);
gtk_list_store_set (list_store, &iter,
XFPM_DEVICE_INFO_NAME, _("Model"),
XFPM_DEVICE_INFO_VALUE, g_value_get_string (value),
-1);
i++;
}
}
/*Technology*/
value = g_hash_table_lookup (props, "Technology");
if ( value )
{
gtk_list_store_append (list_store, &iter);
gtk_list_store_set (list_store, &iter,
XFPM_DEVICE_INFO_NAME, _("Technology"),
XFPM_DEVICE_INFO_VALUE, xfpm_power_translate_technology (g_value_get_uint (value)),
-1);
i++;
}
value = g_hash_table_lookup (props, "Percentage");
if ( value )
{
str = g_strdup_printf("%d", (guint) g_value_get_double (value));
gtk_list_store_append (list_store, &iter);
gtk_list_store_set (list_store, &iter,
XFPM_DEVICE_INFO_NAME, _("Energy percent"),
XFPM_DEVICE_INFO_VALUE, str,
-1);
i++;
g_free(str);
}
/* TRANSLATORS: Unit here is What hour*/
str = xfpm_info_get_energy_property (props, "EnergyFullDesign", _("Wh"));
if ( str )
{
gtk_list_store_append (list_store, &iter);
gtk_list_store_set (list_store, &iter,
XFPM_DEVICE_INFO_NAME, _("Energy full design"),
XFPM_DEVICE_INFO_VALUE, str,
-1);
i++;
g_free (str);
}
/* TRANSLATORS: Unit here is What hour*/
str = xfpm_info_get_energy_property (props, "EnergyFull", _("Wh"));
if ( str )
{
gtk_list_store_append (list_store, &iter);
gtk_list_store_set (list_store, &iter,
XFPM_DEVICE_INFO_NAME, _("Energy full"),
XFPM_DEVICE_INFO_VALUE, str,
-1);
i++;
g_free (str);
}
/* TRANSLATORS: Unit here is What hour*/
str = xfpm_info_get_energy_property (props, "EnergyEmpty", _("Wh"));
if ( str )
{
gtk_list_store_append (list_store, &iter);
gtk_list_store_set (list_store, &iter,
XFPM_DEVICE_INFO_NAME, _("Energy empty"),
XFPM_DEVICE_INFO_VALUE, str,
-1);
i++;
g_free (str);
}
/* TRANSLATORS: Unit here is volt*/
str = xfpm_info_get_energy_property (props, "Voltage", _("V"));
if ( str )
{
gtk_list_store_append (list_store, &iter);
gtk_list_store_set (list_store, &iter,
XFPM_DEVICE_INFO_NAME, _("Voltage"),
XFPM_DEVICE_INFO_VALUE, str,
-1);
i++;
g_free (str);
}
/*Percentage*/
str = xfpm_info_get_energy_property (props, "Percentage", _("%"));
if ( str )
{
gtk_list_store_append (list_store, &iter);
gtk_list_store_set (list_store, &iter,
XFPM_DEVICE_INFO_NAME, _("Percentage"),
XFPM_DEVICE_INFO_VALUE, str,
-1);
i++;
g_free (str);
}
/*Vendor*/
value = g_hash_table_lookup (props, "Vendor");
if ( value )
{
cstr = g_value_get_string (value);
if ( cstr && strlen (cstr) > 0)
{
gtk_list_store_append (list_store, &iter);
gtk_list_store_set (list_store, &iter,
XFPM_DEVICE_INFO_NAME, _("Vendor"),
XFPM_DEVICE_INFO_VALUE, g_value_get_string (value),
-1);
i++;
}
}
/*Serial*/
value = g_hash_table_lookup (props, "Serial");
if ( value )
{
cstr = g_value_get_string (value);
if ( cstr && strlen (cstr) > 0)
{
gtk_list_store_append (list_store, &iter);
gtk_list_store_set (list_store, &iter,
XFPM_DEVICE_INFO_NAME, _("Serial"),
XFPM_DEVICE_INFO_VALUE, g_value_get_string (value),
-1);
i++;
}
}
}
xfpm_info_add_sidebar_icon (info, battery_type, xfpm_power_get_icon_name (type));
gtk_notebook_append_page (GTK_NOTEBOOK (info->notebook), view, NULL);
gtk_widget_show (view);
}
static void
cc_wacom_panel_init (CcWacomPanel *self)
{
CcWacomPanelPrivate *priv;
GtkNotebook *notebook;
GtkWidget *widget;
GList *devices, *l;
GError *error = NULL;
char *objects[] = {
"main-box",
NULL
};
priv = self->priv = WACOM_PANEL_PRIVATE (self);
g_resources_register (cc_wacom_get_resource ());
priv->builder = gtk_builder_new ();
gtk_builder_add_objects_from_resource (priv->builder,
"/org/gnome/control-center/wacom/gnome-wacom-properties.ui",
objects,
&error);
if (error != NULL)
{
g_warning ("Error loading UI file: %s", error->message);
g_object_unref (priv->builder);
g_error_free (error);
return;
}
priv->cancellable = g_cancellable_new ();
g_dbus_proxy_new_for_bus (G_BUS_TYPE_SESSION,
G_DBUS_PROXY_FLAGS_NONE,
NULL,
"org.gnome.SettingsDaemon.Wacom",
"/org/gnome/SettingsDaemon/Wacom",
"org.gnome.SettingsDaemon.Wacom",
priv->cancellable,
got_wacom_proxy_cb,
self);
/* Notebook */
notebook = GTK_NOTEBOOK (gtk_notebook_new ());
priv->notebook = GTK_WIDGET (notebook);
gtk_notebook_set_show_tabs (notebook, FALSE);
gtk_notebook_set_show_border (notebook, FALSE);
gtk_widget_set_vexpand (GTK_WIDGET (notebook), TRUE);
gtk_container_set_border_width (GTK_CONTAINER (notebook), 0);
g_object_set (G_OBJECT (notebook),
"margin-top", 6,
"margin-end", 30,
"margin-start", 30,
"margin-bottom", 30,
NULL);
gtk_container_add (GTK_CONTAINER (self), GTK_WIDGET (notebook));
gtk_widget_show (priv->notebook);
/* No tablets page */
widget = WID ("main-box");
enbiggen_label (GTK_LABEL (WID ("advice-label1")));
gtk_notebook_append_page (notebook, widget, NULL);
g_signal_connect (G_OBJECT (WID ("linkbutton")), "activate-link",
G_CALLBACK (link_activated), self);
priv->devices = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, g_object_unref);
priv->pages = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
priv->manager = gdk_display_get_device_manager (gdk_display_get_default ());
priv->device_added_id = g_signal_connect (G_OBJECT (priv->manager), "device-added",
G_CALLBACK (device_added_cb), self);
priv->device_removed_id = g_signal_connect (G_OBJECT (priv->manager), "device-removed",
G_CALLBACK (device_removed_cb), self);
devices = gdk_device_manager_list_devices (priv->manager, GDK_DEVICE_TYPE_SLAVE);
for (l = devices; l ; l = l->next)
add_known_device (self, l->data);
g_list_free (devices);
update_current_page (self);
}
/*
* Función listarDireccionWindow()
*/
void listarDireccionWindow (void)
{
int i, num, ret, indice;
char *nombre, *direccion, *telefono;
GtkWidget *datos[NUM_LETRAS];
GtkWidget *window;
GtkWidget *libro;
GtkWidget *label;
GtkWidget *scroll;
char* dir[3];
char letras[NUM_LETRAS][2]={"#","A","B","C","D","E","F","G","H","I","J","K","L","M","N","Ñ","O","P","Q","R","S","T","U","V","W","X","Y","Z"};
char inicial;
/*
* Dialog
*/
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_widget_set_usize (GTK_WIDGET (window), 585, 300);
gtk_window_set_policy(GTK_WINDOW (window), TRUE, TRUE, FALSE);
gtk_window_set_title (GTK_WINDOW (window), "Libro de direcciones");
gtk_container_border_width (GTK_CONTAINER (window), 10);
gtk_widget_set_uposition( window, 300, 300 );
libro=gtk_notebook_new();
gtk_notebook_set_tab_pos(GTK_NOTEBOOK(libro),GTK_POS_TOP);
for (indice=0;indice<NUM_LETRAS;indice++) {
scroll = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll),
GTK_POLICY_AUTOMATIC,GTK_POLICY_ALWAYS);
datos[indice]=gtk_clist_new(3);
gtk_container_add(GTK_CONTAINER(scroll), datos[indice]);
gtk_clist_set_column_title(GTK_CLIST(datos[indice]),0,"Nombre");
gtk_clist_set_column_title(GTK_CLIST(datos[indice]),1,"Direccion");
gtk_clist_set_column_title(GTK_CLIST(datos[indice]),2,"Telefono");
gtk_clist_column_titles_show(GTK_CLIST(datos[indice]));
gtk_clist_set_column_width(GTK_CLIST(datos[indice]),0,175);
gtk_clist_set_column_width(GTK_CLIST(datos[indice]),1,250);
gtk_clist_set_column_width(GTK_CLIST(datos[indice]),2,75);
label=gtk_label_new(letras[indice]);
gtk_widget_set_usize(label,10,10);
gtk_notebook_append_page((GtkNotebook*)libro,scroll,label);
}
num=numeroDir((&datosAgenda.direcciones));
gtk_container_add (GTK_CONTAINER (window),libro);
for (i=0; i<num; i++) {
ret = consultarDir((&datosAgenda.direcciones),i,&nombre,
&direccion, &telefono);
if (0 == ret) {
dir[0]=stringDup(nombre);
dir[1]=stringDup(direccion);
dir[2]=stringDup(telefono);
/*
* Buscamos en el array de letras, la inicial del nombre.
* Insertaremos sus datos en la lista correspondiente.
*/
inicial=toupper(nombre[0]);
indice=NUM_LETRAS-1;
while ( (letras[indice][0]!=inicial) && (0 < indice) ) {
indice--;
}
gtk_clist_append(GTK_CLIST(datos[indice]),dir);
}
}
gtk_grab_add(window);
gtk_widget_show_all(window);
}
static void
notebook_add_page (GtkWidget *notebook,
GtkWidget *page)
{
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), page, NULL);
}
GtkWidget *main_window(){
GtkWidget *vbox, *hpane, *vpane, *swin, *vbox2, *stage_width_entry, *stage_height_entry, *rectangle_button;
WebKitWebView *web_view;
ClutterActor *stage;
ClutterColor
stage_bg_color = { 128, 128, 128, 255 },
white = { 255, 255, 255, 255 }
;
// Create widgets
app.window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
app.menubar = gtk_menu_bar_new();
app.toolbar = gtk_toolbar_new();
hpane = gtk_paned_new(GTK_ORIENTATION_HORIZONTAL);
vpane = gtk_paned_new(GTK_ORIENTATION_VERTICAL);
app.statusbar = gtk_statusbar_new();
app.stage = gtk_clutter_embed_new();
app.notebook = gtk_notebook_new();
web_view= WEBKIT_WEB_VIEW(webkit_web_view_new());
swin = gtk_scrolled_window_new(NULL, NULL);
vbox2 = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
stage_width_entry = gtk_spin_button_new_with_range(0, 9999, 1);
stage_height_entry = gtk_spin_button_new_with_range(0, 9999, 1);
app.colorpicker = gtk_color_button_new();
app.fileselector = gtk_file_chooser_button_new("Background image", GTK_FILE_CHOOSER_ACTION_OPEN);
app.background_repeat_select = gtk_combo_box_text_new();
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(app.background_repeat_select), "no-repeat");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(app.background_repeat_select), "repeat-x");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(app.background_repeat_select), "repeat-y");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(app.background_repeat_select), "repeat-xy");
stage = gtk_clutter_embed_get_stage(GTK_CLUTTER_EMBED(app.stage));
rectangle_button = gtk_button_new_from_stock(GTK_STOCK_NEW);
app.mainstage = clutter_rectangle_new_with_color(&white);
// Pack widgets
gtk_container_add(GTK_CONTAINER(app.window), vbox);
gtk_box_pack_start(GTK_BOX(vbox), app.menubar, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), app.toolbar, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), app.notebook, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), app.statusbar, FALSE, FALSE, 0);
gtk_notebook_append_page(GTK_NOTEBOOK(app.notebook), vpane, gtk_label_new("Animator"));
gtk_notebook_append_page(GTK_NOTEBOOK(app.notebook), swin, gtk_label_new("Browser"));
gtk_notebook_append_page(GTK_NOTEBOOK(app.notebook), gtk_label_new("tbc"), gtk_label_new("Source"));
gtk_container_add(GTK_CONTAINER(swin), GTK_WIDGET(web_view));
gtk_paned_pack1(GTK_PANED(vpane), hpane, TRUE, TRUE);
gtk_paned_pack2(GTK_PANED(vpane), gtk_label_new("Timeline"), FALSE, TRUE);
gtk_paned_pack1(GTK_PANED(hpane), app.stage,TRUE, TRUE);
gtk_paned_pack2(GTK_PANED(hpane), vbox2, FALSE, TRUE);
gtk_box_pack_start(GTK_BOX(vbox2), stage_width_entry, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox2), stage_height_entry, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox2), app.colorpicker, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox2), app.fileselector, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox2), app.background_repeat_select, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox2), rectangle_button, FALSE, FALSE, 0);
//Setup widgets
gtk_paned_set_position(GTK_PANED(hpane), 600);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(swin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
webkit_web_view_load_uri(web_view, "http://www.webkitgtk.org/");
gtk_widget_set_size_request(app.stage, 800, 600);
gtk_paned_set_position(GTK_PANED(hpane), 600);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(stage_width_entry), 300);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(stage_height_entry), 200);
g_object_set_data(G_OBJECT(stage_width_entry), "type", "width");
g_object_set_data(G_OBJECT(stage_height_entry), "type", "height");
clutter_stage_set_user_resizable(CLUTTER_STAGE(stage), FALSE);
gtk_color_button_set_use_alpha(GTK_COLOR_BUTTON(app.colorpicker), TRUE);
gtk_combo_box_set_active(GTK_COMBO_BOX(app.background_repeat_select), 0);
clutter_actor_set_background_color(stage, &stage_bg_color);
clutter_actor_set_size(app.mainstage, 400, 300);
clutter_actor_set_position(app.mainstage, 100, 100);
clutter_actor_add_child(stage, app.mainstage);
clutter_actor_show(app.mainstage);
clutter_actor_show(stage);
// Connect signals
g_signal_connect(app.fileselector, "file-set", G_CALLBACK(on_file_set), NULL);
g_signal_connect(app.window, "destroy", G_CALLBACK(gtk_main_quit), NULL);
g_signal_connect(stage_width_entry, "value-changed", G_CALLBACK(on_stage_dim_changed), stage);
g_signal_connect(stage_height_entry, "value-changed", G_CALLBACK(on_stage_dim_changed), stage);
g_signal_connect(rectangle_button, "clicked", G_CALLBACK(on_new_button_clicked), NULL);
return (app.window);
}
static void
source_viewer_constructed (GObject *object)
{
ESourceViewer *viewer;
GtkTreeViewColumn *column;
GtkTreeSelection *selection;
GtkCellRenderer *renderer;
GtkWidget *container;
GtkWidget *paned;
GtkWidget *widget;
PangoAttribute *attr;
PangoAttrList *bold;
PangoFontDescription *desc;
GIcon *icon;
const gchar *title;
gchar *font_name;
gint page_num;
viewer = E_SOURCE_VIEWER (object);
/* Chain up to parent's constructed() method. */
G_OBJECT_CLASS (e_source_viewer_parent_class)->constructed (object);
bold = pango_attr_list_new ();
attr = pango_attr_weight_new (PANGO_WEIGHT_BOLD);
pango_attr_list_insert (bold, attr);
title = _("Evolution Source Viewer");
gtk_window_set_title (GTK_WINDOW (viewer), title);
gtk_window_set_default_size (GTK_WINDOW (viewer), 800, 600);
paned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
gtk_paned_set_position (GTK_PANED (paned), 400);
gtk_container_add (GTK_CONTAINER (viewer), paned);
gtk_widget_show (paned);
/* Left panel */
widget = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (
GTK_SCROLLED_WINDOW (widget),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (
GTK_SCROLLED_WINDOW (widget), GTK_SHADOW_IN);
gtk_paned_add1 (GTK_PANED (paned), widget);
gtk_widget_show (widget);
container = widget;
widget = gtk_tree_view_new_with_model (
GTK_TREE_MODEL (viewer->tree_store));
gtk_container_add (GTK_CONTAINER (container), widget);
viewer->tree_view = widget; /* do not reference */
gtk_widget_show (widget);
column = gtk_tree_view_column_new ();
/* Translators: The name that is displayed in the user interface */
gtk_tree_view_column_set_title (column, _("Display Name"));
gtk_tree_view_append_column (GTK_TREE_VIEW (widget), 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", COLUMN_DISPLAY_NAME);
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("Flags"));
gtk_tree_view_append_column (GTK_TREE_VIEW (widget), column);
renderer = gtk_cell_renderer_pixbuf_new ();
g_object_set (
renderer,
"icon-name", "media-record",
"stock-size", GTK_ICON_SIZE_MENU,
NULL);
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_add_attribute (
column, renderer, "visible", COLUMN_WRITABLE);
renderer = gtk_cell_renderer_pixbuf_new ();
g_object_set (
renderer,
"icon-name", "list-remove",
"stock-size", GTK_ICON_SIZE_MENU,
NULL);
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_add_attribute (
column, renderer, "visible", COLUMN_REMOVABLE);
icon = source_view_new_remote_creatable_icon ();
renderer = gtk_cell_renderer_pixbuf_new ();
g_object_set (
renderer,
"gicon", icon,
"stock-size", GTK_ICON_SIZE_MENU,
NULL);
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_add_attribute (
column, renderer, "visible", COLUMN_REMOTE_CREATABLE);
g_object_unref (icon);
icon = source_view_new_remote_deletable_icon ();
renderer = gtk_cell_renderer_pixbuf_new ();
g_object_set (
renderer,
"gicon", icon,
"stock-size", GTK_ICON_SIZE_MENU,
NULL);
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_add_attribute (
column, renderer, "visible", COLUMN_REMOTE_DELETABLE);
g_object_unref (icon);
/* Append an empty pixbuf renderer to fill leftover space. */
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (column, renderer, TRUE);
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("Identity"));
gtk_tree_view_append_column (GTK_TREE_VIEW (widget), column);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_add_attribute (
column, renderer, "text", COLUMN_SOURCE_UID);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (widget));
/* Right panel */
widget = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_paned_add2 (GTK_PANED (paned), widget);
gtk_widget_show (widget);
container = widget;
widget = gtk_notebook_new ();
gtk_widget_set_margin_top (widget, 3);
gtk_widget_set_margin_right (widget, 3);
gtk_widget_set_margin_bottom (widget, 3);
/* leave left margin at zero */
gtk_notebook_set_show_tabs (GTK_NOTEBOOK (widget), FALSE);
gtk_notebook_set_show_border (GTK_NOTEBOOK (widget), FALSE);
gtk_box_pack_start (GTK_BOX (container), widget, FALSE, FALSE, 0);
viewer->top_panel = widget; /* do not reference */
gtk_widget_show (widget);
widget = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (
GTK_SCROLLED_WINDOW (widget),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (
GTK_SCROLLED_WINDOW (widget), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (container), widget, TRUE, TRUE, 0);
gtk_widget_show (widget);
container = widget;
widget = gtk_text_view_new ();
gtk_text_view_set_editable (GTK_TEXT_VIEW (widget), FALSE);
gtk_container_add (GTK_CONTAINER (container), widget);
viewer->text_view = widget; /* do not reference */
gtk_widget_show (widget);
font_name = source_viewer_get_monospace_font_name ();
desc = pango_font_description_from_string (font_name);
gtk_widget_override_font (widget, desc);
pango_font_description_free (desc);
g_free (font_name);
/* Top panel: Viewing */
container = viewer->top_panel;
widget = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
page_num = gtk_notebook_append_page (
GTK_NOTEBOOK (container), widget, NULL);
g_warn_if_fail (page_num == PAGE_VIEWING);
gtk_widget_show (widget);
container = widget;
widget = gtk_label_new ("Identity:");
gtk_box_pack_start (GTK_BOX (container), widget, FALSE, FALSE, 0);
gtk_widget_show (widget);
widget = gtk_label_new (NULL);
gtk_label_set_attributes (GTK_LABEL (widget), bold);
gtk_label_set_ellipsize (GTK_LABEL (widget), PANGO_ELLIPSIZE_END);
gtk_label_set_selectable (GTK_LABEL (widget), TRUE);
gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (container), widget, TRUE, TRUE, 0);
viewer->viewing_label = widget; /* do not reference */
gtk_widget_show (widget);
widget = e_dialog_button_new_with_icon ("edit-delete", _("_Delete"));
gtk_box_pack_end (GTK_BOX (container), widget, FALSE, FALSE, 0);
viewer->delete_button = widget; /* do not reference */
gtk_widget_hide (widget);
/* Top panel: Deleting */
container = viewer->top_panel;
widget = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
page_num = gtk_notebook_append_page (
GTK_NOTEBOOK (container), widget, NULL);
g_warn_if_fail (page_num == PAGE_DELETING);
gtk_widget_show (widget);
container = widget;
widget = gtk_label_new ("Deleting");
gtk_box_pack_start (GTK_BOX (container), widget, FALSE, FALSE, 0);
gtk_widget_show (widget);
widget = gtk_label_new (NULL);
gtk_label_set_attributes (GTK_LABEL (widget), bold);
gtk_label_set_ellipsize (GTK_LABEL (widget), PANGO_ELLIPSIZE_END);
gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (container), widget, TRUE, TRUE, 0);
viewer->deleting_label = widget; /* do not reference */
gtk_widget_show (widget);
widget = e_dialog_button_new_with_icon ("process-stop", _("_Cancel"));
gtk_box_pack_end (GTK_BOX (container), widget, FALSE, FALSE, 0);
viewer->deleting_cancel = widget; /* do not reference */
gtk_widget_show (widget);
pango_attr_list_unref (bold);
g_signal_connect (
selection, "changed",
G_CALLBACK (source_viewer_selection_changed_cb), viewer);
g_signal_connect (
viewer->delete_button, "clicked",
G_CALLBACK (source_viewer_delete_button_clicked_cb), viewer);
g_signal_connect (
viewer->deleting_cancel, "clicked",
G_CALLBACK (source_viewer_deleting_cancel_clicked_cb), viewer);
}
void showMainWindow(int argc, char** argv) {
fprintf(stderr, "DEBUG: Running main window\n");
gtk_init(&argc, &argv);
GtkWindow *window;
// Main window
window = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL));
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_window_set_default_size(GTK_WINDOW(window), 460, 450);
gtk_container_set_border_width(GTK_CONTAINER(window), 8);
gtk_window_set_title(GTK_WINDOW(window), _("Keyboard configuration tool"));
/* TODO Set application icon
GtkImage *app_icon = GTK_IMAGE(gtk_image_new_from_icon_name("keyboard", GTK_ICON_SIZE_SMALL_TOOLBAR));
gtk_window_set_icon( window, gtk_image_get_pixbuf(app_icon));
*/
g_signal_connect(window, "destroy",
G_CALLBACK(gtk_main_quit), NULL);
GtkWidget *vbox = gtk_vbox_new(FALSE, 10);
gtk_container_add(GTK_CONTAINER(window), vbox);
GtkWidget *tabs = gtk_notebook_new();
gtk_container_add(GTK_CONTAINER(vbox), tabs);
/*
* Adding tabs to the notebook
*/
Layouts_Tab *tab_layouts = build_tab_layouts();
Others_Tab *tab_others = build_tab_others();
About_Tab *tab_credits = build_tab_credits();
gtk_notebook_append_page(GTK_NOTEBOOK(tabs), tab_layouts->tab_content, tab_layouts->tab_name);
gtk_notebook_append_page(GTK_NOTEBOOK(tabs), tab_others->tab_content, tab_others->tab_name);
gtk_notebook_append_page(GTK_NOTEBOOK(tabs), tab_credits->tab_content, tab_credits->tab_name);
/*
* Adding Control Buttons
*/
GtkWidget *control_box = gtk_hbox_new(FALSE, 4);
gtk_container_add(GTK_CONTAINER(vbox), control_box);
GtkWidget *span, *button_cancel, *button_accept, * button_aplic;
span = gtk_label_new("");
gtk_widget_set_size_request(span, 45, 0);
button_cancel = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
gtk_widget_set_size_request(button_cancel, BUTTON_WIDTH, BUTTON_HIGH);
button_accept = gtk_button_new_from_stock(GTK_STOCK_OK);
gtk_widget_set_size_request(button_accept, BUTTON_WIDTH, BUTTON_HIGH);
button_aplic = gtk_button_new_from_stock(GTK_STOCK_APPLY);
gtk_widget_set_size_request(button_aplic, BUTTON_WIDTH, BUTTON_HIGH);
gtk_container_add(GTK_CONTAINER(control_box), span);
gtk_container_add(GTK_CONTAINER(control_box), button_accept);
gtk_container_add(GTK_CONTAINER(control_box), button_aplic);
gtk_container_add(GTK_CONTAINER(control_box), button_cancel);
g_signal_connect(button_accept, "clicked",
G_CALLBACK(button_acept_callback), NULL);
g_signal_connect(button_aplic, "clicked",
G_CALLBACK(button_aplic_callback), NULL);
g_signal_connect(button_cancel, "clicked",
G_CALLBACK(button_cancel_callback), NULL);
gtk_widget_show_all(GTK_WIDGET(window));
gtk_main();
}
void FLAC_XMMS__configure(void)
{
GtkWidget *title_frame, *title_tag_vbox, *title_tag_label;
GtkWidget *replaygain_frame, *resolution_frame, *output_vbox, *resolution_normal_frame, *resolution_replaygain_frame;
GtkWidget *replaygain_vbox, *resolution_hbox, *resolution_normal_vbox, *resolution_replaygain_vbox;
GtkWidget *resolution_replaygain_noise_shaping_vbox;
GtkWidget *resolution_replaygain_bps_out_vbox;
GtkWidget *label, *hbox;
GtkWidget *bbox, *ok, *cancel;
GList *list;
GtkWidget *streaming_vbox;
GtkWidget *streaming_buf_frame, *streaming_buf_hbox;
GtkWidget *streaming_size_box, *streaming_size_label, *streaming_size_spin;
GtkWidget *streaming_pre_box, *streaming_pre_label, *streaming_pre_spin;
GtkWidget *streaming_proxy_frame, *streaming_proxy_vbox;
GtkWidget *streaming_proxy_port_label, *streaming_proxy_host_label;
GtkWidget *streaming_save_frame, *streaming_save_vbox;
GtkWidget *streaming_save_label, *streaming_save_browse;
#ifdef FLAC_ICECAST
GtkWidget *streaming_cast_frame, *streaming_cast_vbox;
#endif
char *temp;
if (flac_configurewin != NULL) {
gdk_window_raise(flac_configurewin->window);
return;
}
flac_configurewin = gtk_window_new(GTK_WINDOW_DIALOG);
gtk_signal_connect(GTK_OBJECT(flac_configurewin), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &flac_configurewin);
gtk_signal_connect(GTK_OBJECT(flac_configurewin), "destroy", GTK_SIGNAL_FUNC(configure_destroy), &flac_configurewin);
gtk_window_set_title(GTK_WINDOW(flac_configurewin), _("Flac Configuration"));
gtk_window_set_policy(GTK_WINDOW(flac_configurewin), FALSE, FALSE, FALSE);
gtk_container_border_width(GTK_CONTAINER(flac_configurewin), 10);
vbox = gtk_vbox_new(FALSE, 10);
gtk_container_add(GTK_CONTAINER(flac_configurewin), vbox);
notebook = gtk_notebook_new();
gtk_box_pack_start(GTK_BOX(vbox), notebook, TRUE, TRUE, 0);
/* Title config.. */
title_frame = gtk_frame_new(_("Tag Handling"));
gtk_container_border_width(GTK_CONTAINER(title_frame), 5);
title_tag_vbox = gtk_vbox_new(FALSE, 10);
gtk_container_border_width(GTK_CONTAINER(title_tag_vbox), 5);
gtk_container_add(GTK_CONTAINER(title_frame), title_tag_vbox);
/* Convert Char Set */
convert_char_set = gtk_check_button_new_with_label(_("Convert Character Set"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(convert_char_set), flac_cfg.title.convert_char_set);
gtk_signal_connect(GTK_OBJECT(convert_char_set), "clicked", convert_char_set_cb, NULL);
gtk_box_pack_start(GTK_BOX(title_tag_vbox), convert_char_set, FALSE, FALSE, 0);
/* Combo boxes... */
hbox = gtk_hbox_new(FALSE,4);
gtk_container_add(GTK_CONTAINER(title_tag_vbox),hbox);
label = gtk_label_new(_("Convert character set from :"));
gtk_box_pack_start(GTK_BOX(hbox),label,FALSE,FALSE,0);
fileCharacterSetEntry = gtk_combo_new();
gtk_box_pack_start(GTK_BOX(hbox),fileCharacterSetEntry,TRUE,TRUE,0);
label = gtk_label_new (_("to :"));
gtk_box_pack_start(GTK_BOX(hbox),label,FALSE,FALSE,0);
userCharacterSetEntry = gtk_combo_new();
gtk_box_pack_start(GTK_BOX(hbox),userCharacterSetEntry,TRUE,TRUE,0);
gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(fileCharacterSetEntry)->entry),FALSE);
gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(userCharacterSetEntry)->entry),FALSE);
gtk_combo_set_value_in_list(GTK_COMBO(fileCharacterSetEntry),TRUE,FALSE);
gtk_combo_set_value_in_list(GTK_COMBO(userCharacterSetEntry),TRUE,FALSE);
list = Charset_Create_List();
gtk_combo_set_popdown_strings(GTK_COMBO(fileCharacterSetEntry),Charset_Create_List_UTF8_Only());
gtk_combo_set_popdown_strings(GTK_COMBO(userCharacterSetEntry),list);
gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(userCharacterSetEntry)->entry),Charset_Get_Title_From_Name(flac_cfg.title.user_char_set));
gtk_widget_set_sensitive(fileCharacterSetEntry, FALSE);
gtk_widget_set_sensitive(userCharacterSetEntry, flac_cfg.title.convert_char_set);
/* Override Tagging Format */
title_tag_override = gtk_check_button_new_with_label(_("Override generic titles"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(title_tag_override), flac_cfg.title.tag_override);
gtk_signal_connect(GTK_OBJECT(title_tag_override), "clicked", title_tag_override_cb, NULL);
gtk_box_pack_start(GTK_BOX(title_tag_vbox), title_tag_override, FALSE, FALSE, 0);
title_tag_box = gtk_hbox_new(FALSE, 5);
gtk_widget_set_sensitive(title_tag_box, flac_cfg.title.tag_override);
gtk_box_pack_start(GTK_BOX(title_tag_vbox), title_tag_box, FALSE, FALSE, 0);
title_tag_label = gtk_label_new(_("Title format:"));
gtk_box_pack_start(GTK_BOX(title_tag_box), title_tag_label, FALSE, FALSE, 0);
title_tag_entry = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(title_tag_entry), flac_cfg.title.tag_format);
gtk_box_pack_start(GTK_BOX(title_tag_box), title_tag_entry, TRUE, TRUE, 0);
title_desc = xmms_titlestring_descriptions("pafFetnygc", 2);
gtk_widget_set_sensitive(title_desc, flac_cfg.title.tag_override);
gtk_box_pack_start(GTK_BOX(title_tag_vbox), title_desc, FALSE, FALSE, 0);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), title_frame, gtk_label_new(_("Title")));
/* Output config.. */
output_vbox = gtk_vbox_new(FALSE, 10);
gtk_container_border_width(GTK_CONTAINER(output_vbox), 5);
/* replaygain */
replaygain_frame = gtk_frame_new(_("ReplayGain"));
gtk_container_border_width(GTK_CONTAINER(replaygain_frame), 5);
gtk_box_pack_start(GTK_BOX(output_vbox), replaygain_frame, TRUE, TRUE, 0);
replaygain_vbox = gtk_vbox_new(FALSE, 10);
gtk_container_border_width(GTK_CONTAINER(replaygain_vbox), 5);
gtk_container_add(GTK_CONTAINER(replaygain_frame), replaygain_vbox);
replaygain_enable = gtk_check_button_new_with_label(_("Enable ReplayGain processing"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(replaygain_enable), flac_cfg.output.replaygain.enable);
gtk_signal_connect(GTK_OBJECT(replaygain_enable), "clicked", replaygain_enable_cb, NULL);
gtk_box_pack_start(GTK_BOX(replaygain_vbox), replaygain_enable, FALSE, FALSE, 0);
replaygain_album_mode = gtk_check_button_new_with_label(_("Album mode"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(replaygain_album_mode), flac_cfg.output.replaygain.album_mode);
gtk_signal_connect(GTK_OBJECT(replaygain_album_mode), "clicked", replaygain_album_mode_cb, NULL);
gtk_box_pack_start(GTK_BOX(replaygain_vbox), replaygain_album_mode, FALSE, FALSE, 0);
hbox = gtk_hbox_new(FALSE,3);
gtk_container_add(GTK_CONTAINER(replaygain_vbox),hbox);
label = gtk_label_new(_("Preamp:"));
gtk_box_pack_start(GTK_BOX(hbox),label,FALSE,FALSE,0);
replaygain_preamp = gtk_adjustment_new(flac_cfg.output.replaygain.preamp, -24.0, +24.0, 1.0, 6.0, 0.0);
gtk_signal_connect(GTK_OBJECT(replaygain_preamp), "value-changed", replaygain_preamp_cb, NULL);
replaygain_preamp_hscale = gtk_hscale_new(GTK_ADJUSTMENT(replaygain_preamp));
gtk_scale_set_draw_value(GTK_SCALE(replaygain_preamp_hscale), FALSE);
gtk_box_pack_start(GTK_BOX(hbox),replaygain_preamp_hscale,TRUE,TRUE,0);
replaygain_preamp_label = gtk_label_new(_("0 dB"));
gtk_box_pack_start(GTK_BOX(hbox),replaygain_preamp_label,FALSE,FALSE,0);
gtk_adjustment_value_changed(GTK_ADJUSTMENT(replaygain_preamp));
replaygain_hard_limit = gtk_check_button_new_with_label(_("6dB hard limiting"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(replaygain_hard_limit), flac_cfg.output.replaygain.hard_limit);
gtk_signal_connect(GTK_OBJECT(replaygain_hard_limit), "clicked", replaygain_hard_limit_cb, NULL);
gtk_box_pack_start(GTK_BOX(replaygain_vbox), replaygain_hard_limit, FALSE, FALSE, 0);
replaygain_enable_cb(replaygain_enable, NULL);
/* resolution */
resolution_frame = gtk_frame_new(_("Resolution"));
gtk_container_border_width(GTK_CONTAINER(resolution_frame), 5);
gtk_box_pack_start(GTK_BOX(output_vbox), resolution_frame, TRUE, TRUE, 0);
resolution_hbox = gtk_hbox_new(FALSE, 10);
gtk_container_border_width(GTK_CONTAINER(resolution_hbox), 5);
gtk_container_add(GTK_CONTAINER(resolution_frame), resolution_hbox);
resolution_normal_frame = gtk_frame_new(_("Without ReplayGain"));
gtk_container_border_width(GTK_CONTAINER(resolution_normal_frame), 5);
gtk_box_pack_start(GTK_BOX(resolution_hbox), resolution_normal_frame, TRUE, TRUE, 0);
resolution_normal_vbox = gtk_vbox_new(FALSE, 10);
gtk_container_border_width(GTK_CONTAINER(resolution_normal_vbox), 5);
gtk_container_add(GTK_CONTAINER(resolution_normal_frame), resolution_normal_vbox);
resolution_normal_dither_24_to_16 = gtk_check_button_new_with_label(_("Dither 24bps to 16bps"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(resolution_normal_dither_24_to_16), flac_cfg.output.resolution.normal.dither_24_to_16);
gtk_signal_connect(GTK_OBJECT(resolution_normal_dither_24_to_16), "clicked", resolution_normal_dither_24_to_16_cb, NULL);
gtk_box_pack_start(GTK_BOX(resolution_normal_vbox), resolution_normal_dither_24_to_16, FALSE, FALSE, 0);
resolution_replaygain_frame = gtk_frame_new(_("With ReplayGain"));
gtk_container_border_width(GTK_CONTAINER(resolution_replaygain_frame), 5);
gtk_box_pack_start(GTK_BOX(resolution_hbox), resolution_replaygain_frame, TRUE, TRUE, 0);
resolution_replaygain_vbox = gtk_vbox_new(FALSE, 10);
gtk_container_border_width(GTK_CONTAINER(resolution_replaygain_vbox), 5);
gtk_container_add(GTK_CONTAINER(resolution_replaygain_frame), resolution_replaygain_vbox);
resolution_replaygain_dither = gtk_check_button_new_with_label(_("Enable dithering"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(resolution_replaygain_dither), flac_cfg.output.resolution.replaygain.dither);
gtk_signal_connect(GTK_OBJECT(resolution_replaygain_dither), "clicked", resolution_replaygain_dither_cb, NULL);
gtk_box_pack_start(GTK_BOX(resolution_replaygain_vbox), resolution_replaygain_dither, FALSE, FALSE, 0);
hbox = gtk_hbox_new(FALSE, 10);
gtk_container_border_width(GTK_CONTAINER(hbox), 5);
gtk_box_pack_start(GTK_BOX(resolution_replaygain_vbox), hbox, TRUE, TRUE, 0);
resolution_replaygain_noise_shaping_frame = gtk_frame_new(_("Noise shaping"));
gtk_container_border_width(GTK_CONTAINER(resolution_replaygain_noise_shaping_frame), 5);
gtk_box_pack_start(GTK_BOX(hbox), resolution_replaygain_noise_shaping_frame, TRUE, TRUE, 0);
resolution_replaygain_noise_shaping_vbox = gtk_vbutton_box_new();
gtk_container_border_width(GTK_CONTAINER(resolution_replaygain_noise_shaping_vbox), 5);
gtk_container_add(GTK_CONTAINER(resolution_replaygain_noise_shaping_frame), resolution_replaygain_noise_shaping_vbox);
resolution_replaygain_noise_shaping_radio_none = gtk_radio_button_new_with_label(NULL, _("none"));
if(flac_cfg.output.resolution.replaygain.noise_shaping == 0)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(resolution_replaygain_noise_shaping_radio_none), TRUE);
gtk_signal_connect(GTK_OBJECT(resolution_replaygain_noise_shaping_radio_none), "clicked", resolution_replaygain_noise_shaping_cb, NULL);
gtk_container_add(GTK_CONTAINER(resolution_replaygain_noise_shaping_vbox), resolution_replaygain_noise_shaping_radio_none);
resolution_replaygain_noise_shaping_radio_low = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(resolution_replaygain_noise_shaping_radio_none), _("low"));
if(flac_cfg.output.resolution.replaygain.noise_shaping == 1)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(resolution_replaygain_noise_shaping_radio_low), TRUE);
gtk_signal_connect(GTK_OBJECT(resolution_replaygain_noise_shaping_radio_low), "clicked", resolution_replaygain_noise_shaping_cb, NULL);
gtk_container_add(GTK_CONTAINER(resolution_replaygain_noise_shaping_vbox), resolution_replaygain_noise_shaping_radio_low);
resolution_replaygain_noise_shaping_radio_medium = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(resolution_replaygain_noise_shaping_radio_none), _("medium"));
if(flac_cfg.output.resolution.replaygain.noise_shaping == 2)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(resolution_replaygain_noise_shaping_radio_medium), TRUE);
gtk_signal_connect(GTK_OBJECT(resolution_replaygain_noise_shaping_radio_medium), "clicked", resolution_replaygain_noise_shaping_cb, NULL);
gtk_container_add(GTK_CONTAINER(resolution_replaygain_noise_shaping_vbox), resolution_replaygain_noise_shaping_radio_medium);
resolution_replaygain_noise_shaping_radio_high = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(resolution_replaygain_noise_shaping_radio_none), _("high"));
if(flac_cfg.output.resolution.replaygain.noise_shaping == 3)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(resolution_replaygain_noise_shaping_radio_high), TRUE);
gtk_signal_connect(GTK_OBJECT(resolution_replaygain_noise_shaping_radio_high), "clicked", resolution_replaygain_noise_shaping_cb, NULL);
gtk_container_add(GTK_CONTAINER(resolution_replaygain_noise_shaping_vbox), resolution_replaygain_noise_shaping_radio_high);
resolution_replaygain_bps_out_frame = gtk_frame_new(_("Dither to"));
gtk_container_border_width(GTK_CONTAINER(resolution_replaygain_bps_out_frame), 5);
gtk_box_pack_start(GTK_BOX(hbox), resolution_replaygain_bps_out_frame, FALSE, FALSE, 0);
resolution_replaygain_bps_out_vbox = gtk_vbutton_box_new();
gtk_container_border_width(GTK_CONTAINER(resolution_replaygain_bps_out_vbox), 0);
gtk_container_add(GTK_CONTAINER(resolution_replaygain_bps_out_frame), resolution_replaygain_bps_out_vbox);
resolution_replaygain_bps_out_radio_16bps = gtk_radio_button_new_with_label(NULL, _("16 bps"));
if(flac_cfg.output.resolution.replaygain.bps_out == 16)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(resolution_replaygain_bps_out_radio_16bps), TRUE);
gtk_signal_connect(GTK_OBJECT(resolution_replaygain_bps_out_radio_16bps), "clicked", resolution_replaygain_bps_out_cb, NULL);
gtk_container_add(GTK_CONTAINER(resolution_replaygain_bps_out_vbox), resolution_replaygain_bps_out_radio_16bps);
resolution_replaygain_bps_out_radio_24bps = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(resolution_replaygain_bps_out_radio_16bps), _("24 bps"));
if(flac_cfg.output.resolution.replaygain.bps_out == 24)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(resolution_replaygain_bps_out_radio_24bps), TRUE);
gtk_signal_connect(GTK_OBJECT(resolution_replaygain_bps_out_radio_24bps), "clicked", resolution_replaygain_bps_out_cb, NULL);
gtk_container_add(GTK_CONTAINER(resolution_replaygain_bps_out_vbox), resolution_replaygain_bps_out_radio_24bps);
resolution_replaygain_dither_cb(resolution_replaygain_dither, NULL);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), output_vbox, gtk_label_new(_("Output")));
/* Streaming */
streaming_vbox = gtk_vbox_new(FALSE, 0);
streaming_buf_frame = gtk_frame_new(_("Buffering:"));
gtk_container_set_border_width(GTK_CONTAINER(streaming_buf_frame), 5);
gtk_box_pack_start(GTK_BOX(streaming_vbox), streaming_buf_frame, FALSE, FALSE, 0);
streaming_buf_hbox = gtk_hbox_new(TRUE, 5);
gtk_container_set_border_width(GTK_CONTAINER(streaming_buf_hbox), 5);
gtk_container_add(GTK_CONTAINER(streaming_buf_frame), streaming_buf_hbox);
streaming_size_box = gtk_hbox_new(FALSE, 5);
/*gtk_table_attach_defaults(GTK_TABLE(streaming_buf_table),streaming_size_box,0,1,0,1); */
gtk_box_pack_start(GTK_BOX(streaming_buf_hbox), streaming_size_box, TRUE, TRUE, 0);
streaming_size_label = gtk_label_new(_("Buffer size (kb):"));
gtk_box_pack_start(GTK_BOX(streaming_size_box), streaming_size_label, FALSE, FALSE, 0);
streaming_size_adj = gtk_adjustment_new(flac_cfg.stream.http_buffer_size, 4, 4096, 4, 4, 4);
streaming_size_spin = gtk_spin_button_new(GTK_ADJUSTMENT(streaming_size_adj), 8, 0);
gtk_widget_set_usize(streaming_size_spin, 60, -1);
gtk_box_pack_start(GTK_BOX(streaming_size_box), streaming_size_spin, FALSE, FALSE, 0);
streaming_pre_box = gtk_hbox_new(FALSE, 5);
/*gtk_table_attach_defaults(GTK_TABLE(streaming_buf_table),streaming_pre_box,1,2,0,1); */
gtk_box_pack_start(GTK_BOX(streaming_buf_hbox), streaming_pre_box, TRUE, TRUE, 0);
streaming_pre_label = gtk_label_new(_("Pre-buffer (percent):"));
gtk_box_pack_start(GTK_BOX(streaming_pre_box), streaming_pre_label, FALSE, FALSE, 0);
streaming_pre_adj = gtk_adjustment_new(flac_cfg.stream.http_prebuffer, 0, 90, 1, 1, 1);
streaming_pre_spin = gtk_spin_button_new(GTK_ADJUSTMENT(streaming_pre_adj), 1, 0);
gtk_widget_set_usize(streaming_pre_spin, 60, -1);
gtk_box_pack_start(GTK_BOX(streaming_pre_box), streaming_pre_spin, FALSE, FALSE, 0);
/*
* Proxy config.
*/
streaming_proxy_frame = gtk_frame_new(_("Proxy:"));
gtk_container_set_border_width(GTK_CONTAINER(streaming_proxy_frame), 5);
gtk_box_pack_start(GTK_BOX(streaming_vbox), streaming_proxy_frame, FALSE, FALSE, 0);
streaming_proxy_vbox = gtk_vbox_new(FALSE, 5);
gtk_container_set_border_width(GTK_CONTAINER(streaming_proxy_vbox), 5);
gtk_container_add(GTK_CONTAINER(streaming_proxy_frame), streaming_proxy_vbox);
streaming_proxy_use = gtk_check_button_new_with_label(_("Use proxy"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(streaming_proxy_use), flac_cfg.stream.use_proxy);
gtk_signal_connect(GTK_OBJECT(streaming_proxy_use), "clicked", GTK_SIGNAL_FUNC(proxy_use_cb), NULL);
gtk_box_pack_start(GTK_BOX(streaming_proxy_vbox), streaming_proxy_use, FALSE, FALSE, 0);
streaming_proxy_hbox = gtk_hbox_new(FALSE, 5);
gtk_widget_set_sensitive(streaming_proxy_hbox, flac_cfg.stream.use_proxy);
gtk_box_pack_start(GTK_BOX(streaming_proxy_vbox), streaming_proxy_hbox, FALSE, FALSE, 0);
streaming_proxy_host_label = gtk_label_new(_("Host:"));
gtk_box_pack_start(GTK_BOX(streaming_proxy_hbox), streaming_proxy_host_label, FALSE, FALSE, 0);
streaming_proxy_host_entry = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(streaming_proxy_host_entry), flac_cfg.stream.proxy_host? flac_cfg.stream.proxy_host : "");
gtk_box_pack_start(GTK_BOX(streaming_proxy_hbox), streaming_proxy_host_entry, TRUE, TRUE, 0);
streaming_proxy_port_label = gtk_label_new(_("Port:"));
gtk_box_pack_start(GTK_BOX(streaming_proxy_hbox), streaming_proxy_port_label, FALSE, FALSE, 0);
streaming_proxy_port_entry = gtk_entry_new();
gtk_widget_set_usize(streaming_proxy_port_entry, 50, -1);
temp = g_strdup_printf("%d", flac_cfg.stream.proxy_port);
gtk_entry_set_text(GTK_ENTRY(streaming_proxy_port_entry), temp);
g_free(temp);
gtk_box_pack_start(GTK_BOX(streaming_proxy_hbox), streaming_proxy_port_entry, FALSE, FALSE, 0);
streaming_proxy_auth_use = gtk_check_button_new_with_label(_("Use authentication"));
gtk_widget_set_sensitive(streaming_proxy_auth_use, flac_cfg.stream.use_proxy);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(streaming_proxy_auth_use), flac_cfg.stream.proxy_use_auth);
gtk_signal_connect(GTK_OBJECT(streaming_proxy_auth_use), "clicked", GTK_SIGNAL_FUNC(proxy_auth_use_cb), NULL);
gtk_box_pack_start(GTK_BOX(streaming_proxy_vbox), streaming_proxy_auth_use, FALSE, FALSE, 0);
streaming_proxy_auth_hbox = gtk_hbox_new(FALSE, 5);
gtk_widget_set_sensitive(streaming_proxy_auth_hbox, flac_cfg.stream.use_proxy && flac_cfg.stream.proxy_use_auth);
gtk_box_pack_start(GTK_BOX(streaming_proxy_vbox), streaming_proxy_auth_hbox, FALSE, FALSE, 0);
streaming_proxy_auth_user_label = gtk_label_new(_("Username:"******"Password:"******"Save stream to disk:"));
gtk_container_set_border_width(GTK_CONTAINER(streaming_save_frame), 5);
gtk_box_pack_start(GTK_BOX(streaming_vbox), streaming_save_frame, FALSE, FALSE, 0);
streaming_save_vbox = gtk_vbox_new(FALSE, 5);
gtk_container_set_border_width(GTK_CONTAINER(streaming_save_vbox), 5);
gtk_container_add(GTK_CONTAINER(streaming_save_frame), streaming_save_vbox);
streaming_save_use = gtk_check_button_new_with_label(_("Save stream to disk"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(streaming_save_use), flac_cfg.stream.save_http_stream);
gtk_signal_connect(GTK_OBJECT(streaming_save_use), "clicked", GTK_SIGNAL_FUNC(streaming_save_use_cb), NULL);
gtk_box_pack_start(GTK_BOX(streaming_save_vbox), streaming_save_use, FALSE, FALSE, 0);
streaming_save_hbox = gtk_hbox_new(FALSE, 5);
gtk_widget_set_sensitive(streaming_save_hbox, flac_cfg.stream.save_http_stream);
gtk_box_pack_start(GTK_BOX(streaming_save_vbox), streaming_save_hbox, FALSE, FALSE, 0);
streaming_save_label = gtk_label_new(_("Path:"));
gtk_box_pack_start(GTK_BOX(streaming_save_hbox), streaming_save_label, FALSE, FALSE, 0);
streaming_save_entry = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(streaming_save_entry), flac_cfg.stream.save_http_path? flac_cfg.stream.save_http_path : "");
gtk_box_pack_start(GTK_BOX(streaming_save_hbox), streaming_save_entry, TRUE, TRUE, 0);
streaming_save_browse = gtk_button_new_with_label(_("Browse"));
gtk_signal_connect(GTK_OBJECT(streaming_save_browse), "clicked", GTK_SIGNAL_FUNC(streaming_save_browse_cb), NULL);
gtk_box_pack_start(GTK_BOX(streaming_save_hbox), streaming_save_browse, FALSE, FALSE, 0);
#ifdef FLAC_ICECAST
streaming_cast_frame = gtk_frame_new(_("SHOUT/Icecast:"));
gtk_container_set_border_width(GTK_CONTAINER(streaming_cast_frame), 5);
gtk_box_pack_start(GTK_BOX(streaming_vbox), streaming_cast_frame, FALSE, FALSE, 0);
streaming_cast_vbox = gtk_vbox_new(5, FALSE);
gtk_container_add(GTK_CONTAINER(streaming_cast_frame), streaming_cast_vbox);
streaming_cast_title = gtk_check_button_new_with_label(_("Enable SHOUT/Icecast title streaming"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(streaming_cast_title), flac_cfg.stream.cast_title_streaming);
gtk_box_pack_start(GTK_BOX(streaming_cast_vbox), streaming_cast_title, FALSE, FALSE, 0);
streaming_udp_title = gtk_check_button_new_with_label(_("Enable Icecast Metadata UDP Channel"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(streaming_udp_title), flac_cfg.stream.use_udp_channel);
gtk_box_pack_start(GTK_BOX(streaming_cast_vbox), streaming_udp_title, FALSE, FALSE, 0);
#endif
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), streaming_vbox, gtk_label_new(_("Streaming")));
/* Buttons */
bbox = gtk_hbutton_box_new();
gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END);
gtk_button_box_set_spacing(GTK_BUTTON_BOX(bbox), 5);
gtk_box_pack_start(GTK_BOX(vbox), bbox, FALSE, FALSE, 0);
ok = gtk_button_new_with_label(_("Ok"));
gtk_signal_connect(GTK_OBJECT(ok), "clicked", GTK_SIGNAL_FUNC(flac_configurewin_ok), NULL);
GTK_WIDGET_SET_FLAGS(ok, GTK_CAN_DEFAULT);
gtk_box_pack_start(GTK_BOX(bbox), ok, TRUE, TRUE, 0);
gtk_widget_grab_default(ok);
cancel = gtk_button_new_with_label(_("Cancel"));
gtk_signal_connect_object(GTK_OBJECT(cancel), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT(flac_configurewin));
GTK_WIDGET_SET_FLAGS(cancel, GTK_CAN_DEFAULT);
gtk_box_pack_start(GTK_BOX(bbox), cancel, TRUE, TRUE, 0);
gtk_widget_show_all(flac_configurewin);
}
/* Generated by glade, sorta. */
static void *
create_cfgdlg(void)
{
GtkWidget *vbox2;
GtkWidget *table1;
GtkWidget *label3;
GtkWidget *label1;
GtkWidget *label2;
GtkWidget *label4;
GtkWidget *align1;
GtkWidget *notebook1;
vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
label1 = gtk_label_new (_("<b>Services</b>"));
gtk_widget_show (label1);
gtk_label_set_use_markup (GTK_LABEL (label1), TRUE);
gtk_misc_set_alignment (GTK_MISC (label1), 0, 0.5);
gtk_box_pack_start (GTK_BOX (vbox2), label1, FALSE, FALSE, 0);
notebook1 = gtk_notebook_new();
gtk_widget_show (notebook1);
// last fm
align1 = gtk_alignment_new(0, 0, 0, 0);
gtk_widget_show (align1);
gtk_alignment_set_padding(GTK_ALIGNMENT(align1), 0, 0, 12, 0);
table1 = gtk_table_new (2, 2, FALSE);
gtk_widget_show (table1);
gtk_container_add(GTK_CONTAINER(align1), table1);
gtk_table_set_row_spacings (GTK_TABLE(table1), 6);
gtk_table_set_col_spacings (GTK_TABLE(table1), 6);
label2 = gtk_label_new (_("Username:"******"Password:"******"Scrobbler URL:"));
gtk_widget_show (label4);
gtk_table_attach (GTK_TABLE (table1), label4, 0, 1, 4, 5,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify (GTK_LABEL (label4), GTK_JUSTIFY_RIGHT);
gtk_misc_set_alignment (GTK_MISC (label4), 1, 0.5);
entry1 = gtk_entry_new ();
gtk_widget_show (entry1);
gtk_table_attach_defaults (GTK_TABLE (table1), entry1, 1, 2, 2, 3);
entry2 = gtk_entry_new ();
gtk_entry_set_text(GTK_ENTRY(entry2), _("Change password"));
g_signal_connect(G_OBJECT(entry2), "focus-in-event",
G_CALLBACK(entry_focus_in),
NULL);
g_signal_connect(G_OBJECT(entry2), "focus-out-event",
G_CALLBACK(entry_focus_out),
NULL);
gtk_widget_show (entry2);
gtk_table_attach_defaults (GTK_TABLE (table1), entry2, 1, 2, 3, 4);
entry3 = gtk_entry_new ();
gtk_widget_show (entry3);
gtk_table_attach_defaults (GTK_TABLE (table1), entry3, 1, 2, 4, 5);
label1 = gtk_label_new (_("<b>Last.FM</b>"));
gtk_label_set_use_markup (GTK_LABEL (label1), TRUE);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook1), GTK_WIDGET(align1), label1);
// common
gtk_box_pack_start (GTK_BOX (vbox2), notebook1, TRUE, TRUE, 6);
gchar * username = aud_get_string ("audioscrobbler", "username");
gtk_entry_set_text ((GtkEntry *) entry1, username);
g_free (username);
gchar * sc_url = aud_get_string ("audioscrobbler", "sc_url");
gtk_entry_set_text ((GtkEntry *) entry3, sc_url);
g_free (sc_url);
g_signal_connect(entry1, "changed", G_CALLBACK(entry_changed), NULL);
g_signal_connect(entry3, "changed", G_CALLBACK(entry_changed), NULL);
return vbox2;
}
void display_packet(GtkWidget *widget) {
GtkTreeSelection *selection; /* tree selection */
GtkTreeModel *model; /* tree model */
GtkTreeIter iter; /* tree iterator */
pcap_t *handler; /* pcap file handler */
char errbuf[PCAP_ERRBUF_SIZE]; /* pcap error buffer */
struct pcap_pkthdr *header; /* the header from libpcap */
const u_char *packet; /* current packet pointer */
unsigned int packetnumber; /* currently secected packet number */
struct ether_header *eth = NULL;
struct sll_header *sll = NULL; /* sll header (linux cooked) */
struct arphdr *arp = NULL;
struct iphdr *ipv4 = NULL; /* ipv4_header pointer */
struct ip6_hdr *ipv6 = NULL;
struct icmphdr *icmp = NULL;
struct icmp6_hdr *icmpv6 = NULL;
struct tcphdr *tcp = NULL;
struct udphdr *udp = NULL;
unsigned int i = 1; /* loop counter to track packet */
unsigned short nextproto = 0;
char *nextptr = NULL;
int pos;
if (filename == NULL) return;
/* open pcap to find packet */
handler = pcap_open_offline(filename, errbuf);
if (handler == NULL) return;
/* get currently selected packet */
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(widget));
if (gtk_tree_selection_get_selected(selection, &model, &iter)) {
gtk_tree_model_get(model, &iter, 0, &packetnumber, -1);
}
/* iterate through packets until selected packet is found
this might also be done by preloading of this technique is too slow */
while (i++ <= packetnumber) pcap_next_ex(handler, &header, &packet);
/* remember tab position and hide all tabs */
pos = gtk_notebook_get_current_page(protocolheadernotebook);
/* clear grids */
while (gtk_notebook_get_n_pages(protocolheadernotebook) > 0) {
gtk_notebook_remove_page(protocolheadernotebook, 0);
}
switch (pcap_datalink(handler)) {
case DLT_EN10MB:
/* set pointer to ethernet header */
eth = (struct ether_header*)(packet);
/* display ethernet tab */
gtk_notebook_append_page(protocolheadernotebook, GTK_WIDGET(ethernet_grid(eth)), gtk_label_new(hardwaretype(pcap_datalink(handler))));
nextproto = htons(eth->ether_type);
nextptr = (void*)(packet + sizeof(struct ether_header));
break;
case LINKTYPE_LINUX_SLL:
/* LINUX COOKED */
sll = (struct sll_header*)(packet);
/* display sll tab */
gtk_notebook_append_page(protocolheadernotebook, GTK_WIDGET(sll_grid(sll)), gtk_label_new(hardwaretype(pcap_datalink(handler))));
nextproto = htons(sll->sll_protocol);
nextptr = (void*)(packet + sizeof(struct sll_header));
break;
default:
/* display not supported tab */
gtk_notebook_append_page(protocolheadernotebook, GTK_WIDGET(not_supported_grid(hardwaretype(pcap_datalink(handler)))), gtk_label_new(hardwaretype(pcap_datalink(handler))));
return;
}
switch (nextproto) {
case ETHERTYPE_ARP:
/* ARP */
arp = (struct arphdr*)nextptr;
nextptr += sizeof(struct arphdr);
/* display arp tab */
gtk_notebook_append_page(protocolheadernotebook, GTK_WIDGET(arp_grid(arp, ((u_char*)nextptr))), gtk_label_new(ethertype(nextproto)));
nextproto = 0xffff;
break;
case ETHERTYPE_IP:
/* IPV4 */
ipv4 = (struct iphdr*)nextptr;
nextptr += sizeof(struct iphdr);
/* display ipv4 tab */
gtk_notebook_append_page(protocolheadernotebook, GTK_WIDGET(ipv4_grid(ipv4, ((u_char*)nextptr))), gtk_label_new(ethertype(nextproto)));
nextproto = ipv4->protocol;
break;
case ETHERTYPE_IPV6:
/* IPV6 */
ipv6 = (struct ip6_hdr*)nextptr;
nextptr += sizeof(struct ip6_hdr);
/* display ipv4 tab */
gtk_notebook_append_page(protocolheadernotebook, GTK_WIDGET(ipv6_grid(ipv6, ((u_char*)nextptr))), gtk_label_new(ethertype(nextproto)));
nextproto = ipv6->ip6_ctlun.ip6_un1.ip6_un1_nxt;
while (nextproto == IPPROTO_HOPOPTS) {
/* next header */
nextproto = ((u_char*)nextptr)[0];
nextptr += (((u_char*)nextptr)[1]+1) * 8;
}
break;
default:
/* display not supported tab */
gtk_notebook_append_page(protocolheadernotebook, GTK_WIDGET(not_supported_grid(ethertype(nextproto))), gtk_label_new(ethertype(nextproto)));
nextproto = 0xffff;
break;
}
if (nextproto != 0xffff) {
switch (nextproto) {
case IPPROTO_ICMP:
icmp = (struct icmphdr*)nextptr;
nextptr += sizeof(struct icmphdr);
gtk_notebook_append_page(protocolheadernotebook, GTK_WIDGET(icmp_grid(icmp, ((u_char*)nextptr), htons(ipv4->tot_len)-(ipv4->ihl*4))), gtk_label_new(ipprotocol(nextproto)));
break;
case IPPROTO_ICMPV6:
icmpv6 = (struct icmp6_hdr*)nextptr;
/* skip 4 bytes of unused / reserved fields of header struct and pass to next protocol pointer */
nextptr += sizeof(struct icmp6_hdr)-4;
gtk_notebook_append_page(protocolheadernotebook, GTK_WIDGET(icmpv6_grid(icmpv6, ((u_char*)nextptr), htons(ipv6->ip6_ctlun.ip6_un1.ip6_un1_plen))), gtk_label_new(ipprotocol(nextproto)));
break;
case IPPROTO_TCP:
tcp = (struct tcphdr*)nextptr;
nextptr += sizeof(struct tcphdr);
gtk_notebook_append_page(protocolheadernotebook, GTK_WIDGET(tcp_grid(tcp, ((u_char*)nextptr))), gtk_label_new(ipprotocol(nextproto)));
break;
case IPPROTO_UDP:
udp = (struct udphdr*)nextptr;
gtk_notebook_append_page(protocolheadernotebook, GTK_WIDGET(udp_grid(udp)), gtk_label_new(ipprotocol(nextproto)));
break;
default:
/* display not supported tab */
gtk_notebook_append_page(protocolheadernotebook, GTK_WIDGET(not_supported_grid(ipprotocol(nextproto))), gtk_label_new(ipprotocol(nextproto)));
nextproto = 0xffff;
break;
}
}
/* switch to tab that was former selected */
if ((pos >= 0) && (pos < gtk_notebook_get_n_pages(protocolheadernotebook))) {
gtk_notebook_set_current_page(protocolheadernotebook, pos);
}
/* close pcap handler */
pcap_close(handler);
}
void
procdialog_create_preferences_dialog (ProcData *procdata)
{
static GtkWidget *dialog = NULL;
typedef SpinButtonUpdater SBU;
static SBU interval_updater("update-interval");
static SBU graph_interval_updater("graph-update-interval");
static SBU disks_interval_updater("disks-interval");
GtkWidget *notebook;
GtkWidget *proc_box;
GtkWidget *sys_box;
GtkWidget *main_vbox;
GtkWidget *vbox, *vbox2, *vbox3;
GtkWidget *hbox, *hbox2, *hbox3;
GtkWidget *label;
GtkAdjustment *adjustment;
GtkWidget *spin_button;
GtkWidget *check_button;
GtkWidget *tab_label;
GtkWidget *smooth_button;
GtkSizeGroup *size;
gfloat update;
gchar *tmp;
if (prefs_dialog)
return;
size = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
dialog = gtk_dialog_new_with_buttons (_("System Monitor Preferences"),
GTK_WINDOW (procdata->app),
GTK_DIALOG_DESTROY_WITH_PARENT,
"gtk-help", GTK_RESPONSE_HELP,
"gtk-close", GTK_RESPONSE_CLOSE,
NULL);
/* FIXME: we should not declare the window size, but let it's */
/* driven by window childs. The problem is that the fields list */
/* have to show at least 4 items to respect HIG. I don't know */
/* any function to set list height by contents/items inside it. */
gtk_window_set_default_size (GTK_WINDOW (dialog), 400, 500);
gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
prefs_dialog = dialog;
main_vbox = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
gtk_box_set_spacing (GTK_BOX (main_vbox), 2);
notebook = gtk_notebook_new ();
gtk_container_set_border_width (GTK_CONTAINER (notebook), 5);
gtk_box_pack_start (GTK_BOX (main_vbox), notebook, TRUE, TRUE, 0);
proc_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 18);
gtk_container_set_border_width (GTK_CONTAINER (proc_box), 12);
tab_label = gtk_label_new (_("Processes"));
gtk_widget_show (tab_label);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), proc_box, tab_label);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_box_pack_start (GTK_BOX (proc_box), vbox, FALSE, FALSE, 0);
tmp = g_strdup_printf ("<b>%s</b>", _("Behavior"));
label = gtk_label_new (NULL);
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_label_set_markup (GTK_LABEL (label), tmp);
g_free (tmp);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
label = gtk_label_new (" ");
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 0);
hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_box_pack_start (GTK_BOX (vbox2), hbox2, FALSE, FALSE, 0);
label = gtk_label_new_with_mnemonic (_("_Update interval in seconds:"));
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, FALSE, 0);
hbox3 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start (GTK_BOX (hbox2), hbox3, TRUE, TRUE, 0);
update = (gfloat) procdata->config.update_interval;
adjustment = (GtkAdjustment *) gtk_adjustment_new(update / 1000.0,
MIN_UPDATE_INTERVAL / 1000,
MAX_UPDATE_INTERVAL / 1000,
0.25,
1.0,
0);
spin_button = gtk_spin_button_new (adjustment, 1.0, 2);
gtk_box_pack_start (GTK_BOX (hbox3), spin_button, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (spin_button), "focus_out_event",
G_CALLBACK (SBU::callback), &interval_updater);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), spin_button);
hbox2 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start(GTK_BOX(vbox2), hbox2, FALSE, FALSE, 0);
smooth_button = gtk_check_button_new_with_mnemonic(_("Enable _smooth refresh"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(smooth_button),
g_settings_get_boolean(procdata->settings,
SmoothRefresh::KEY.c_str()));
g_signal_connect(G_OBJECT(smooth_button), "toggled",
G_CALLBACK(smooth_refresh_toggled), procdata);
gtk_box_pack_start(GTK_BOX(hbox2), smooth_button, TRUE, TRUE, 0);
hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start (GTK_BOX (vbox2), hbox2, FALSE, FALSE, 0);
check_button = gtk_check_button_new_with_mnemonic (_("Alert before ending or _killing processes"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button),
procdata->config.show_kill_warning);
g_signal_connect (G_OBJECT (check_button), "toggled",
G_CALLBACK (show_kill_dialog_toggled), procdata);
gtk_box_pack_start (GTK_BOX (hbox2), check_button, FALSE, FALSE, 0);
hbox2 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start(GTK_BOX(vbox2), hbox2, FALSE, FALSE, 0);
GtkWidget *solaris_button = gtk_check_button_new_with_mnemonic(_("Divide CPU usage by CPU count"));
gtk_widget_set_tooltip_text(solaris_button, _("Solaris mode"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(solaris_button),
g_settings_get_boolean(procdata->settings,
procman::settings::solaris_mode.c_str()));
g_signal_connect(G_OBJECT(solaris_button), "toggled",
G_CALLBACK(solaris_mode_toggled), procdata);
gtk_box_pack_start(GTK_BOX(hbox2), solaris_button, TRUE, TRUE, 0);
hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start (GTK_BOX (vbox2), hbox2, FALSE, FALSE, 0);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_box_pack_start (GTK_BOX (proc_box), vbox, TRUE, TRUE, 0);
tmp = g_strdup_printf ("<b>%s</b>", _("Information Fields"));
label = gtk_label_new (NULL);
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_label_set_markup (GTK_LABEL (label), tmp);
g_free (tmp);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
label = gtk_label_new (" ");
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
vbox2 = create_field_page (procdata->tree, "proctree", _("Process i_nformation shown in list:"));
gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 0);
sys_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_container_set_border_width (GTK_CONTAINER (sys_box), 12);
tab_label = gtk_label_new (_("Resources"));
gtk_widget_show (tab_label);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), sys_box, tab_label);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_box_pack_start (GTK_BOX (sys_box), vbox, FALSE, FALSE, 0);
tmp = g_strdup_printf ("<b>%s</b>", _("Graphs"));
label = gtk_label_new (NULL);
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_label_set_markup (GTK_LABEL (label), tmp);
g_free (tmp);
gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, FALSE, 0);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
label = gtk_label_new (" ");
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 0);
hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_box_pack_start (GTK_BOX (vbox2), hbox2, FALSE, FALSE, 0);
label = gtk_label_new_with_mnemonic (_("_Update interval in 1/10 sec:"));
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, FALSE, 0);
gtk_size_group_add_widget (size, label);
hbox3 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start (GTK_BOX (hbox2), hbox3, TRUE, TRUE, 0);
update = (gfloat) procdata->config.graph_update_interval;
adjustment = (GtkAdjustment *) gtk_adjustment_new(update / 1000.0, 0.25,
100.0, 0.25, 1.0, 0);
spin_button = gtk_spin_button_new (adjustment, 1.0, 2);
g_signal_connect (G_OBJECT (spin_button), "focus_out_event",
G_CALLBACK(SBU::callback),
&graph_interval_updater);
gtk_box_pack_start (GTK_BOX (hbox3), spin_button, FALSE, FALSE, 0);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), spin_button);
GtkWidget *bits_button;
bits_button = gtk_check_button_new_with_mnemonic(_("Show network speed in bits"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(bits_button),
g_settings_get_boolean(procdata->settings,
procman::settings::network_in_bits.c_str()));
g_signal_connect(G_OBJECT(bits_button), "toggled",
G_CALLBACK(network_in_bits_toggled), procdata);
gtk_box_pack_start(GTK_BOX(vbox2), bits_button, TRUE, TRUE, 0);
hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_box_pack_start (GTK_BOX (vbox2), hbox2, TRUE, TRUE, 0);
/*
* Devices
*/
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
tab_label = gtk_label_new (_("File Systems"));
gtk_widget_show (tab_label);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), vbox, tab_label);
tmp = g_strdup_printf ("<b>%s</b>", _("File Systems"));
label = gtk_label_new (NULL);
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_label_set_markup (GTK_LABEL (label), tmp);
g_free (tmp);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
label = gtk_label_new (" ");
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 0);
hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_box_pack_start (GTK_BOX (vbox2), hbox2, FALSE, FALSE, 0);
label = gtk_label_new_with_mnemonic (_("_Update interval in seconds:"));
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, FALSE, 0);
hbox3 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start (GTK_BOX (hbox2), hbox3, TRUE, TRUE, 0);
update = (gfloat) procdata->config.disks_update_interval;
adjustment = (GtkAdjustment *) gtk_adjustment_new (update / 1000.0, 1.0,
100.0, 1.0, 1.0, 0);
spin_button = gtk_spin_button_new (adjustment, 1.0, 0);
gtk_box_pack_start (GTK_BOX (hbox3), spin_button, FALSE, FALSE, 0);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), spin_button);
g_signal_connect (G_OBJECT (spin_button), "focus_out_event",
G_CALLBACK(SBU::callback),
&disks_interval_updater);
hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start (GTK_BOX (vbox2), hbox2, FALSE, FALSE, 0);
check_button = gtk_check_button_new_with_mnemonic (_("Show _all file systems"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button),
procdata->config.show_all_fs);
g_signal_connect (G_OBJECT (check_button), "toggled",
G_CALLBACK (show_all_fs_toggled), procdata);
gtk_box_pack_start (GTK_BOX (hbox2), check_button, FALSE, FALSE, 0);
vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_box_pack_start (GTK_BOX (vbox), vbox2, FALSE, FALSE, 0);
label = gtk_label_new (" ");
gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, FALSE, 0);
tmp = g_strdup_printf ("<b>%s</b>", _("Information Fields"));
label = gtk_label_new (NULL);
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_label_set_markup (GTK_LABEL (label), tmp);
g_free (tmp);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
label = gtk_label_new (" ");
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
vbox3 = create_field_page (procdata->disk_list, "disktreenew", _("File system i_nformation shown in list:"));
gtk_box_pack_start (GTK_BOX (hbox), vbox3, TRUE, TRUE, 0);
gtk_widget_show_all (dialog);
g_signal_connect (G_OBJECT (dialog), "response",
G_CALLBACK (prefs_dialog_button_pressed), procdata);
switch (procdata->config.current_tab) {
case PROCMAN_TAB_SYSINFO:
case PROCMAN_TAB_PROCESSES:
gtk_notebook_set_current_page(GTK_NOTEBOOK(notebook), 0);
break;
case PROCMAN_TAB_RESOURCES:
gtk_notebook_set_current_page(GTK_NOTEBOOK(notebook), 1);
break;
case PROCMAN_TAB_DISKS:
gtk_notebook_set_current_page(GTK_NOTEBOOK(notebook), 2);
break;
}
}
static GtkWidget *create_dialog(void)
{
GtkWidget *dialog;
GtkWidget *header_image;
GtkWidget *header_label;
GtkWidget *label_info;
GtkWidget *codename_label;
GtkWidget *builddate_label;
GtkWidget *url_button;
GtkWidget *cop_label;
GtkWidget *label;
GtkWidget *license_textview;
GtkWidget *notebook;
GtkWidget *box;
GtkWidget *credits_scrollwin;
GtkWidget *table;
GtkWidget *license_scrollwin;
GtkWidget *info_box;
GtkWidget *header_hbox;
GtkWidget *header_eventbox;
GdkPixbuf *icon;
GtkTextBuffer* tb;
gchar *license_text = NULL;
gchar buffer[512];
gchar buffer2[128];
guint i, row = 0;
dialog = gtk_dialog_new();
/* configure dialog */
gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(main_widgets.window));
gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER_ON_PARENT);
gtk_window_set_title(GTK_WINDOW(dialog), _("About Geany"));
gtk_widget_set_name(dialog, "GeanyDialog");
gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE);
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_CLOSE);
gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE);
g_signal_connect(dialog, "key-press-event", G_CALLBACK(gb_on_key_pressed), NULL);
/* create header */
header_eventbox = gtk_event_box_new();
gtk_widget_show(header_eventbox);
header_hbox = gtk_hbox_new(FALSE, 12);
gtk_container_set_border_width(GTK_CONTAINER(header_hbox), 4);
gtk_widget_show(header_hbox);
gtk_container_add(GTK_CONTAINER(header_eventbox), header_hbox);
header_image = gtk_image_new();
gtk_box_pack_start(GTK_BOX(header_hbox), header_image, FALSE, FALSE, 0);
header_label = gtk_label_new(NULL);
gtk_label_set_use_markup(GTK_LABEL(header_label), TRUE);
/* print the subversion revision generated by ./configure if it is available */
g_snprintf(buffer, sizeof(buffer), HEADER, main_get_version_string());
gtk_label_set_markup(GTK_LABEL(header_label), buffer);
gtk_widget_show(header_label);
gtk_box_pack_start(GTK_BOX(header_hbox), header_label, FALSE, FALSE, 0);
header_eventbox_style_set(header_eventbox);
header_label_style_set(header_label);
g_signal_connect_after(header_eventbox, "style-set", G_CALLBACK(header_eventbox_style_set), NULL);
g_signal_connect_after(header_label, "style-set", G_CALLBACK(header_label_style_set), NULL);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), header_eventbox, FALSE, FALSE, 0);
/* set image */
icon = ui_new_pixbuf_from_inline(GEANY_IMAGE_LOGO);
gtk_image_set_from_pixbuf(GTK_IMAGE(header_image), icon);
gtk_window_set_icon(GTK_WINDOW(dialog), icon);
g_object_unref(icon); /* free our reference */
/* create notebook */
notebook = gtk_notebook_new();
gtk_widget_show(notebook);
gtk_container_set_border_width(GTK_CONTAINER(notebook), 2);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), notebook, TRUE, TRUE, 0);
/* create "Info" tab */
info_box = gtk_vbox_new(FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(info_box), 6);
gtk_widget_show(info_box);
label_info = gtk_label_new(NULL);
gtk_label_set_justify(GTK_LABEL(label_info), GTK_JUSTIFY_CENTER);
gtk_label_set_selectable(GTK_LABEL(label_info), TRUE);
gtk_label_set_use_markup(GTK_LABEL(label_info), TRUE);
g_snprintf(buffer, sizeof(buffer), INFO, _("A fast and lightweight IDE"));
gtk_label_set_markup(GTK_LABEL(label_info), buffer);
gtk_misc_set_padding(GTK_MISC(label_info), 2, 11);
gtk_widget_show(label_info);
gtk_box_pack_start(GTK_BOX(info_box), label_info, FALSE, FALSE, 0);
/* Codename label */
codename_label = gtk_label_new(NULL);
gtk_label_set_justify(GTK_LABEL(codename_label), GTK_JUSTIFY_CENTER);
gtk_label_set_selectable(GTK_LABEL(codename_label), TRUE);
gtk_label_set_use_markup(GTK_LABEL(codename_label), TRUE);
gtk_label_set_markup(GTK_LABEL(codename_label), CODENAME);
gtk_misc_set_padding(GTK_MISC(codename_label), 2, 8);
gtk_widget_show(codename_label);
gtk_box_pack_start(GTK_BOX(info_box), codename_label, FALSE, FALSE, 0);
/* build date label */
builddate_label = gtk_label_new(NULL);
gtk_label_set_justify(GTK_LABEL(builddate_label), GTK_JUSTIFY_CENTER);
gtk_label_set_selectable(GTK_LABEL(builddate_label), TRUE);
gtk_label_set_use_markup(GTK_LABEL(builddate_label), TRUE);
g_snprintf(buffer2, sizeof(buffer2), _("(built on or after %s)"), __DATE__);
g_snprintf(buffer, sizeof(buffer), BUILDDATE, buffer2);
gtk_label_set_markup(GTK_LABEL(builddate_label), buffer);
gtk_misc_set_padding(GTK_MISC(builddate_label), 2, 2);
gtk_widget_show(builddate_label);
gtk_box_pack_start(GTK_BOX(info_box), builddate_label, FALSE, FALSE, 0);
box = gtk_hbutton_box_new();
url_button = gtk_button_new();
gtk_button_set_relief(GTK_BUTTON(url_button), GTK_RELIEF_NONE);
g_signal_connect(url_button, "clicked", G_CALLBACK(homepage_clicked), (gpointer)GEANY_HOMEPAGE);
label = gtk_label_new(NULL);
gtk_label_set_text(GTK_LABEL(label), GEANY_HOMEPAGE);
gtk_widget_show(label);
gtk_container_add(GTK_CONTAINER(url_button), label);
gtk_widget_show(url_button);
gtk_box_pack_start(GTK_BOX(box), url_button, FALSE, FALSE, 0);
gtk_widget_show(box);
gtk_box_pack_start(GTK_BOX(info_box), box, FALSE, FALSE, 10);
/* copyright label */
cop_label = gtk_label_new(NULL);
gtk_label_set_justify(GTK_LABEL(cop_label), GTK_JUSTIFY_CENTER);
gtk_label_set_selectable(GTK_LABEL(cop_label), FALSE);
gtk_label_set_use_markup(GTK_LABEL(cop_label), TRUE);
gtk_label_set_markup(GTK_LABEL(cop_label), COPYRIGHT);
gtk_misc_set_padding(GTK_MISC(cop_label), 2, 10);
gtk_widget_show(cop_label);
gtk_box_pack_start(GTK_BOX(info_box), cop_label, FALSE, FALSE, 0);
/*gtk_container_add(GTK_CONTAINER(info_box), cop_label); */
label = gtk_label_new(_("Info"));
gtk_widget_show(label);
gtk_widget_show_all(info_box);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), info_box, label);
/* create "Credits" tab */
credits_scrollwin = gtk_scrolled_window_new(NULL, NULL);
gtk_container_set_border_width(GTK_CONTAINER(credits_scrollwin), 6);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(credits_scrollwin),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
table = gtk_table_new(23 + translators_len + prev_translators_len, 3, FALSE);
gtk_table_set_col_spacings(GTK_TABLE(table), 10);
row = 0;
g_snprintf(buffer, sizeof(buffer),
"<span size=\"larger\" weight=\"bold\">%s</span>", _("Developers"));
label = gtk_label_new(buffer);
gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, GTK_FILL, 0, 0, 5);
gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0);
row++;
g_snprintf(buffer, sizeof(buffer), "Colomban Wendling - %s", _("maintainer"));
ROW(buffer, row, 0, 0, 0, 1);
row++;
ROW("<[email protected]>", row, 0, 0, 0, 1);
row++;
ROW("", row, 0, 0, 0, 0);
row++;
g_snprintf(buffer, sizeof(buffer), "Nick Treleaven - %s", _("developer"));
ROW(buffer, row, 0, 0, 0, 1);
row++;
ROW("<[email protected]>", row, 0, 0, 0, 1);
row++;
ROW("", row, 0, 0, 0, 0);
row++;
g_snprintf(buffer, sizeof(buffer), "Enrico Tröger - %s", _("developer"));
ROW(buffer, row, 0, 0, 0, 1);
row++;
ROW("<[email protected]>", row, 0, 0, 0, 1);
row++;
ROW("", row, 0, 0, 0, 0);
row++;
g_snprintf(buffer, sizeof(buffer), "Matthew Brush - %s", _("developer"));
ROW(buffer, row, 0, 0, 0, 1);
row++;
ROW("<[email protected]>", row, 0, 0, 0, 1);
row++;
ROW("", row, 0, 0, 0, 0);
row++;
g_snprintf(buffer, sizeof(buffer), "Frank Lanitz - %s", _("translation maintainer"));
ROW(buffer, row, 0, 0, 0, 1);
row++;
ROW("<[email protected]>", row, 0, 0, 0, 1);
row++;
ROW("", row, 0, 0, 0, 0);
row++;
g_snprintf(buffer, sizeof(buffer),
"<span size=\"larger\" weight=\"bold\">%s</span>", _("Translators"));
label = gtk_label_new(buffer);
gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 5);
gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
row++;
for (i = 0; i < translators_len; i++)
{
ROW(translators[i][0], row, 0, 1, 4, 0);
ROW(translators[i][1], row, 1, 0, 4, 0);
row++;
}
ROW("", row, 0, 0, 0, 0);
row++;
g_snprintf(buffer, sizeof(buffer),
"<span size=\"larger\" weight=\"bold\">%s</span>", _("Previous Translators"));
label = gtk_label_new(buffer);
gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 5);
gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
row++;
for (i = 0; i < prev_translators_len; i++)
{
ROW(prev_translators[i][0], row, 0, 1, 4, 0);
ROW(prev_translators[i][1], row, 1, 0, 4, 0);
row++;
}
ROW("", row, 0, 0, 0, 0);
row++;
g_snprintf(buffer, sizeof(buffer),
"<span size=\"larger\" weight=\"bold\">%s</span>", _("Contributors"));
label = gtk_label_new(buffer);
gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 5);
gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
row++;
g_snprintf(buffer, sizeof(buffer),
_("Some of the many contributors (for a more detailed list, see the file %s):"),
#ifdef G_OS_WIN32
"Thanks.txt"
#else
"THANKS"
#endif
);
label = geany_wrap_label_new(buffer);
gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 5);
gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
row++;
label = geany_wrap_label_new(contributors);
gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1,
(GtkAttachOptions) (GTK_FILL | GTK_EXPAND),
(GtkAttachOptions) (0), 0, 5);
gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
row++;
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(credits_scrollwin), table);
gtk_viewport_set_shadow_type(GTK_VIEWPORT(gtk_widget_get_parent(table)), GTK_SHADOW_NONE);
gtk_widget_show_all(table);
label = gtk_label_new(_("Credits"));
gtk_widget_show(label);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), credits_scrollwin, label);
/* create "License" tab */
license_scrollwin = gtk_scrolled_window_new(NULL, NULL);
gtk_container_set_border_width(GTK_CONTAINER(license_scrollwin), 6);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(license_scrollwin),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(license_scrollwin), GTK_SHADOW_IN);
license_textview = gtk_text_view_new();
gtk_text_view_set_left_margin(GTK_TEXT_VIEW(license_textview), 2);
gtk_text_view_set_right_margin(GTK_TEXT_VIEW(license_textview), 2);
gtk_text_view_set_editable(GTK_TEXT_VIEW(license_textview), FALSE);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(license_textview), FALSE);
gtk_widget_show(license_textview);
gtk_container_add(GTK_CONTAINER(license_scrollwin), license_textview);
label = gtk_label_new(_("License"));
gtk_widget_show(label);
g_snprintf(buffer, sizeof(buffer), "%s" G_DIR_SEPARATOR_S "GPL-2", app->datadir);
g_file_get_contents(buffer, &license_text, NULL, NULL);
if (license_text == NULL)
{
license_text = g_strdup(
_("License text could not be found, please visit http://www.gnu.org/licenses/gpl-2.0.txt to view it online."));
}
tb = gtk_text_view_get_buffer(GTK_TEXT_VIEW(license_textview));
gtk_text_buffer_set_text(tb, license_text, -1);
g_free(license_text);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), license_scrollwin, label);
gtk_widget_show_all(dialog);
return dialog;
}
/* returns a parent widget to pack the contents of the page into */
GtkWidget *gtkui_page_new(char *title, void (*callback)(void), void (*detacher)(GtkWidget *)) {
GtkWidget *parent, *label;
GtkWidget *hbox, *button, *image;
/* a container to hold the close button and tab label */
hbox = gtk_hbox_new(FALSE, 0);
gtk_widget_show(hbox);
/* the label for the tab title */
label = gtk_label_new(title);
gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, TRUE, 0);
gtk_widget_show(label);
/* the close button */
button = gtk_button_new();
gtk_button_set_relief(GTK_BUTTON (button), GTK_RELIEF_NONE);
gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_set_size_request(button, 20, 20);
gtk_widget_show(button);
/* an image for the button */
image = gtk_image_new_from_stock (GTK_STOCK_CLOSE, GTK_ICON_SIZE_MENU);
gtk_container_add(GTK_CONTAINER (button), image);
gtk_widget_show(image);
/* a parent to pack the contents into */
parent = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(parent), GTK_SHADOW_NONE);
gtk_widget_show(parent);
if(!notebook && notebook_frame) {
gtk_container_remove(GTK_CONTAINER (notebook_frame), gtk_bin_get_child(GTK_BIN (notebook_frame)));
notebook = gtk_notebook_new();
gtk_notebook_set_tab_pos(GTK_NOTEBOOK (notebook), GTK_POS_TOP);
gtk_notebook_set_scrollable(GTK_NOTEBOOK (notebook), TRUE);
gtk_container_add(GTK_CONTAINER (notebook_frame), notebook);
gtk_widget_show(notebook);
#if GTK_MINOR_VERSION == 2
g_signal_connect(G_OBJECT (notebook), "switch-page", G_CALLBACK(gtkui_page_defocus_tabs), NULL);
#endif
gtkui_create_tab_menu();
}
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), parent, hbox);
/* attach callback to destroy the tab/page */
g_signal_connect(G_OBJECT (button), "clicked", G_CALLBACK(gtkui_page_close), parent);
/* attach callback to do specific clean-up */
if(callback)
g_object_set_data(G_OBJECT (parent), "destroy", callback);
if(detacher)
g_object_set_data(G_OBJECT (parent), "detach", detacher);
gtkui_page_present(parent);
return(parent);
}
GtkWidget *
do_search_entry (GtkWidget *do_widget)
{
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *label;
GtkWidget *entry;
GtkWidget *find_button;
GtkWidget *cancel_button;
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_screen (GTK_WINDOW (window), gtk_widget_get_screen (do_widget));
gtk_window_set_title (GTK_WINDOW (window), "Search Entry");
gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
g_signal_connect (window, "destroy",
G_CALLBACK (search_entry_destroyed), &window);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_container_add (GTK_CONTAINER (window), vbox);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label), "Search entry demo");
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 0);
/* Create our entry */
entry = gtk_search_entry_new ();
gtk_box_pack_start (GTK_BOX (hbox), entry, FALSE, FALSE, 0);
/* Create the find and cancel buttons */
notebook = gtk_notebook_new ();
gtk_notebook_set_show_tabs (GTK_NOTEBOOK (notebook), FALSE);
gtk_notebook_set_show_border (GTK_NOTEBOOK (notebook), FALSE);
gtk_box_pack_start (GTK_BOX (hbox), notebook, FALSE, FALSE, 0);
find_button = gtk_button_new_with_label ("Find");
g_signal_connect (find_button, "clicked",
G_CALLBACK (start_search), entry);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), find_button, NULL);
gtk_widget_show (find_button);
cancel_button = gtk_button_new_with_label ("Cancel");
g_signal_connect (cancel_button, "clicked",
G_CALLBACK (stop_search), NULL);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), cancel_button, NULL);
gtk_widget_show (cancel_button);
/* Set up the search icon */
search_by_name (NULL, GTK_ENTRY (entry));
/* Set up the clear icon */
g_signal_connect (entry, "icon-press",
G_CALLBACK (icon_press_cb), NULL);
g_signal_connect (entry, "activate",
G_CALLBACK (activate_cb), NULL);
/* Create the menu */
menu = create_search_menu (entry);
gtk_menu_attach_to_widget (GTK_MENU (menu), entry, NULL);
/* add accessible alternatives for icon functionality */
g_object_set (entry, "populate-all", TRUE, NULL);
g_signal_connect (entry, "populate-popup",
G_CALLBACK (entry_populate_popup), NULL);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
{
gtk_widget_destroy (menu);
gtk_widget_destroy (window);
}
return window;
}
static void
xfpm_info_cpu_wakeups (XfpmInfo *info)
{
GtkWidget *vbox;
GtkWidget *scrolled;
GtkListStore *list_store;
GtkTreeViewColumn *col;
GtkCellRenderer *renderer;
info->wakeups_proxy = dbus_g_proxy_new_for_name (info->bus,
UPOWER_NAME,
UPOWER_PATH_WAKEUPS,
UPOWER_IFACE_WAKEUPS);
if ( !info->wakeups_proxy )
{
g_warning ("Unable to create proxy for %s", UPOWER_PATH_WAKEUPS);
return;
}
list_store = gtk_list_store_new (NCOLS_WAKEUPS,
G_TYPE_STRING, /*type*/
G_TYPE_STRING, /*pid*/
G_TYPE_STRING, /*value*/
G_TYPE_STRING, /*command*/
G_TYPE_STRING); /*details*/
info->wakeups = gtk_tree_view_new_with_model (GTK_TREE_MODEL (list_store));
xfpm_info_add_sidebar_icon (info, _("Processor"), XFPM_PROCESSOR_ICON);
col = gtk_tree_view_column_new ();
renderer = gtk_cell_renderer_pixbuf_new ();
g_object_set (G_OBJECT (renderer), "stock-size", GTK_ICON_SIZE_BUTTON, NULL);
gtk_tree_view_column_pack_start (col, renderer, FALSE);
gtk_tree_view_column_set_attributes (col, renderer, "icon-name", COL_WAKEUPS_TYPE, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (info->wakeups), col);
gtk_tree_view_column_set_title (col, _("Type"));
renderer = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new ();
gtk_tree_view_column_pack_start (col, renderer, FALSE);
gtk_tree_view_column_set_attributes (col, renderer, "text", COL_WAKEUPS_PID, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (info->wakeups), col);
/* TANSLATORS: PID, is the process id, e.g what ps x gives*/
gtk_tree_view_column_set_title (col, _("PID"));
col = gtk_tree_view_column_new ();
gtk_tree_view_column_pack_start (col, renderer, FALSE);
gtk_tree_view_column_set_attributes (col, renderer, "markup", COL_WAKEUPS_VALUE, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (info->wakeups), col);
gtk_tree_view_column_set_title (col, _("Wakeups"));
col = gtk_tree_view_column_new ();
gtk_tree_view_column_pack_start (col, renderer, FALSE);
gtk_tree_view_column_set_attributes (col, renderer, "markup", COL_WAKEUPS_CMD, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (info->wakeups), col);
gtk_tree_view_column_set_title (col, _("Command"));
col = gtk_tree_view_column_new ();
gtk_tree_view_column_pack_start (col, renderer, FALSE);
gtk_tree_view_column_set_attributes (col, renderer, "markup", COL_WAKEUPS_DETAILS, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (info->wakeups), col);
gtk_tree_view_column_set_title (col, _("Details"));
vbox = gtk_vbox_new (FALSE, 4);
scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER (scrolled), info->wakeups);
gtk_box_pack_start (GTK_BOX (vbox), scrolled, TRUE, TRUE, 0);
gtk_notebook_append_page (GTK_NOTEBOOK (info->notebook), vbox, NULL);
xfpm_info_update_wakeups (info);
xfpm_info_update_wakeups (info);
g_timeout_add_seconds (4, (GSourceFunc) xfpm_info_update_wakeups_idle, info);
gtk_widget_show (vbox);
}
static void
update_current_page (CcWacomPanel *self)
{
GHashTable *ht;
GList *devices, *tablets, *l;
gboolean changed;
CcWacomPanelPrivate *priv;
priv = self->priv;
changed = FALSE;
ht = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, g_free);
devices = g_hash_table_get_values (priv->devices);
for (l = devices; l; l = l->next) {
Tablet *tablet;
GsdWacomDevice *device;
device = l->data;
tablet = g_hash_table_lookup (ht, gsd_wacom_device_get_name (device));
if (tablet == NULL) {
tablet = g_new0 (Tablet, 1);
tablet->name = gsd_wacom_device_get_name (device);
g_hash_table_insert (ht, (gpointer) tablet->name, tablet);
}
switch (gsd_wacom_device_get_device_type (device)) {
case WACOM_TYPE_STYLUS:
tablet->stylus = device;
break;
case WACOM_TYPE_ERASER:
tablet->eraser = device;
break;
case WACOM_TYPE_PAD:
tablet->pad = device;
break;
default:
/* Nothing */
;
}
}
g_list_free (devices);
/* We now have a list of Tablet structs,
* see which ones are full tablets */
tablets = g_hash_table_get_values (ht);
for (l = tablets; l; l = l->next) {
Tablet *tablet;
GtkWidget *page;
tablet = l->data;
if (tablet->stylus == NULL ||
tablet->eraser == NULL) {
page = g_hash_table_lookup (priv->pages, tablet->name);
if (page != NULL) {
remove_page (GTK_NOTEBOOK (priv->notebook), page);
g_hash_table_remove (priv->pages, tablet->name);
changed = TRUE;
}
continue;
}
/* this code is called once the stylus + eraser were set up, but the pad does not exist yet */
page = g_hash_table_lookup (priv->pages, tablet->name);
if (page == NULL) {
page = cc_wacom_page_new (self, tablet->stylus, tablet->eraser, tablet->pad);
cc_wacom_page_set_navigation (CC_WACOM_PAGE (page), GTK_NOTEBOOK (priv->notebook), TRUE);
gtk_widget_show (page);
gtk_notebook_append_page (GTK_NOTEBOOK (priv->notebook), page, NULL);
g_hash_table_insert (priv->pages, g_strdup (tablet->name), page);
changed = TRUE;
} else {
cc_wacom_page_update_tools (CC_WACOM_PAGE (page), tablet->stylus, tablet->eraser, tablet->pad);
}
}
g_list_free (tablets);
g_hash_table_destroy (ht);
if (changed == TRUE) {
int num_pages;
num_pages = gtk_notebook_get_n_pages (GTK_NOTEBOOK (priv->notebook));
if (num_pages > 1)
gtk_notebook_set_current_page (GTK_NOTEBOOK (priv->notebook), WACOM_PAGE);
}
}
int
nsWelcomeDlg::Show()
{
int err = OK;
if (!mShowDlg)
{
gCtx->ldlg->Show();
return err;
}
char *readmeContents = NULL;
XI_VERIFY(gCtx);
XI_VERIFY(gCtx->notebook);
if (mWidgetsInit == FALSE) // static widget init
{
// create a new table and add it as a page of the notebook
mTable = gtk_table_new(1, 3, FALSE);
gtk_notebook_append_page(GTK_NOTEBOOK(gCtx->notebook), mTable, NULL);
mPageNum = gtk_notebook_get_current_page(GTK_NOTEBOOK(gCtx->notebook));
// gtk_table_set_row_spacing(GTK_TABLE(mTable), 0, 0);
gtk_table_set_col_spacing(GTK_TABLE(mTable), 1, 0);
gtk_widget_show(mTable);
// read the readme file contents into memory
readmeContents = GetReadmeContents();
if (!readmeContents)
{
err = ErrorHandler(E_EMPTY_README);
goto BAIL;
}
// create a new scrollable textarea and add it to the table
#if defined(MOZ_WIDGET_GTK)
GtkWidget *text = gtk_text_new(NULL, NULL);
GdkFont *font = gdk_font_load( README_FONT );
gtk_text_set_editable(GTK_TEXT(text), FALSE);
gtk_table_attach(GTK_TABLE(mTable), text, 1, 2, 0, 1,
static_cast<GtkAttachOptions>(GTK_FILL | GTK_EXPAND),
static_cast<GtkAttachOptions>(GTK_FILL | GTK_EXPAND),
0, 0);
gtk_text_freeze(GTK_TEXT(text));
gtk_text_insert (GTK_TEXT(text), font, &text->style->black, NULL,
readmeContents, -1);
gtk_text_thaw(GTK_TEXT(text));
gtk_text_set_word_wrap(GTK_TEXT(text), TRUE);
gtk_widget_show(text);
// Add a vertical scrollbar to the GtkText widget
GtkWidget *vscrollbar = gtk_vscrollbar_new (GTK_TEXT (text)->vadj);
gtk_table_attach(GTK_TABLE(mTable), vscrollbar, 2, 3, 0, 1, GTK_FILL,
static_cast<GtkAttachOptions>(GTK_EXPAND | GTK_SHRINK | GTK_FILL),
0, 0);
gtk_widget_show(vscrollbar);
#elif defined(MOZ_WIDGET_GTK2)
GtkWidget *text = gtk_scrolled_window_new (NULL, NULL);
GtkWidget *textview = gtk_text_view_new();
GtkTextBuffer *textbuffer;
textbuffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
gtk_text_buffer_set_text (textbuffer, readmeContents, -1);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (text),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER (text), textview);
gtk_text_view_set_editable(GTK_TEXT_VIEW(textview), FALSE);
gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW(textview), FALSE);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(textview), GTK_WRAP_WORD);
gtk_table_attach_defaults(GTK_TABLE(mTable), text, 1, 2, 0, 1);
gtk_widget_show_all(text);
#endif
mWidgetsInit = TRUE;
}
else
{
gtk_notebook_set_page(GTK_NOTEBOOK(gCtx->notebook), mPageNum);
gtk_widget_show(mTable);
}
// signal connect the buttons
gCtx->nextID = gtk_signal_connect(GTK_OBJECT(gCtx->next), "clicked",
GTK_SIGNAL_FUNC(nsWelcomeDlg::Next), gCtx->wdlg);
GTK_WIDGET_SET_FLAGS(gCtx->next, GTK_CAN_DEFAULT);
gtk_widget_grab_default(gCtx->next);
gtk_widget_grab_focus(gCtx->next);
// show the Next button
gCtx->nextLabel = gtk_label_new(gCtx->Res("NEXT"));
gtk_container_add(GTK_CONTAINER(gCtx->next), gCtx->nextLabel);
gtk_widget_show(gCtx->nextLabel);
gtk_widget_show(gCtx->next);
BAIL:
XI_IF_FREE(readmeContents);
return err;
}
static void
cc_wacom_panel_init (CcWacomPanel *self)
{
CcWacomPanelPrivate *priv;
GtkNotebook *notebook;
GtkWidget *widget;
GList *devices, *l;
GError *error = NULL;
char *objects[] = {
"main-box",
NULL
};
priv = self->priv = WACOM_PANEL_PRIVATE (self);
priv->builder = gtk_builder_new ();
gtk_builder_add_objects_from_file (priv->builder,
CINNAMONCC_UI_DIR "/cinnamon-wacom-properties.ui",
objects,
&error);
if (error != NULL)
{
g_warning ("Error loading UI file: %s", error->message);
g_object_unref (priv->builder);
g_error_free (error);
return;
}
/* Notebook */
notebook = GTK_NOTEBOOK (gtk_notebook_new ());
priv->notebook = GTK_WIDGET (notebook);
gtk_notebook_set_show_tabs (notebook, FALSE);
gtk_widget_set_vexpand (GTK_WIDGET (notebook), TRUE);
gtk_container_set_border_width (GTK_CONTAINER (notebook), 0);
g_object_set (G_OBJECT (notebook),
"margin-top", 0,
"margin-right", 24,
"margin-left", 24,
"margin-bottom", 24,
NULL);
gtk_container_add (GTK_CONTAINER (self), GTK_WIDGET (notebook));
gtk_widget_show (priv->notebook);
/* No tablets page */
widget = WID ("main-box");
enbiggen_label (GTK_LABEL (WID ("advice-label1")));
gtk_notebook_append_page (notebook, widget, NULL);
g_signal_connect (G_OBJECT (WID ("linkbutton")), "activate-link",
G_CALLBACK (link_activated), self);
priv->devices = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, g_object_unref);
priv->pages = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
priv->manager = gdk_display_get_device_manager (gdk_display_get_default ());
priv->device_added_id = g_signal_connect (G_OBJECT (priv->manager), "device-added",
G_CALLBACK (device_added_cb), self);
priv->device_removed_id = g_signal_connect (G_OBJECT (priv->manager), "device-removed",
G_CALLBACK (device_removed_cb), self);
devices = gdk_device_manager_list_devices (priv->manager, GDK_DEVICE_TYPE_SLAVE);
for (l = devices; l ; l = l->next)
add_known_device (self, l->data);
g_list_free (devices);
update_current_page (self);
}
static void
gucharmap_charmap_init (GucharmapCharmap *charmap)
{
GucharmapCharmapPrivate *priv;
GtkWidget *scrolled_window, *view, *chartable, *textview;
GtkTreeSelection *selection;
GtkTextBuffer *buffer;
int page;
priv = charmap->priv = G_TYPE_INSTANCE_GET_PRIVATE (charmap, GUCHARMAP_TYPE_CHARMAP, GucharmapCharmapPrivate);
/* FIXME: move this to realize */
priv->hand_cursor = gdk_cursor_new (GDK_HAND2);
priv->regular_cursor = gdk_cursor_new (GDK_XTERM);
priv->hovering_over_link = FALSE;
/* Left pane */
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_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_SHADOW_ETCHED_IN);
view = gucharmap_chapters_view_new ();
priv->chapters_view = GUCHARMAP_CHAPTERS_VIEW (view);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (view));
g_signal_connect (selection, "changed",
G_CALLBACK (chapters_view_selection_changed_cb), charmap);
gtk_container_add (GTK_CONTAINER (scrolled_window), view);
gtk_widget_show (view);
gtk_paned_pack1 (GTK_PANED (charmap), scrolled_window, FALSE, FALSE);
gtk_widget_show (scrolled_window);
/* Right pane */
priv->notebook = gtk_notebook_new ();
/* Chartable page */
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_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_SHADOW_NONE);
#if GTK_CHECK_VERSION (3, 15, 9)
gtk_scrolled_window_set_overlay_scrolling (GTK_SCROLLED_WINDOW (scrolled_window),
FALSE);
#endif
chartable = gucharmap_chartable_new ();
priv->chartable = GUCHARMAP_CHARTABLE (chartable);
g_signal_connect_swapped (chartable, "status-message",
G_CALLBACK (chartable_status_message), charmap);
g_signal_connect (chartable, "notify::active-character",
G_CALLBACK (chartable_sync_active_char), charmap);
g_signal_connect (chartable, "notify::font-desc",
G_CALLBACK (chartable_sync_font_desc), charmap);
g_signal_connect (chartable, "notify::codepoint-list",
G_CALLBACK (chartable_notify_cb), charmap);
g_signal_connect (chartable, "notify::snap-pow2",
G_CALLBACK (chartable_notify_cb), charmap);
gtk_container_add (GTK_CONTAINER (scrolled_window), chartable);
gtk_widget_show (chartable);
page = gtk_notebook_append_page (GTK_NOTEBOOK (priv->notebook),
scrolled_window,
gtk_label_new_with_mnemonic (_("Characte_r Table")));
g_assert (page == GUCHARMAP_CHARMAP_PAGE_CHARTABLE);
gtk_widget_show (scrolled_window);
/* Details page */
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_SHADOW_NONE);
textview = gtk_text_view_new ();
priv->details_view = GTK_TEXT_VIEW (textview);
gtk_text_view_set_editable (GTK_TEXT_VIEW (textview), FALSE);
gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (textview), FALSE);
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (textview),
GTK_WRAP_WORD);
g_signal_connect (textview, "style-set",
G_CALLBACK (details_style_set), charmap);
g_signal_connect (textview, "key-press-event",
G_CALLBACK (details_key_press_event), charmap);
g_signal_connect (textview, "event-after",
G_CALLBACK (details_event_after), charmap);
g_signal_connect (textview, "motion-notify-event",
G_CALLBACK (details_motion_notify_event), charmap);
g_signal_connect (textview, "visibility-notify-event",
G_CALLBACK (details_visibility_notify_event), charmap);
buffer = gtk_text_view_get_buffer (priv->details_view);
priv->text_tag_gimongous =
gtk_text_buffer_create_tag (buffer, "gimongous",
NULL);
priv->text_tag_big =
gtk_text_buffer_create_tag (buffer, "big",
NULL);
gtk_text_buffer_create_tag (buffer, "bold",
"weight", PANGO_WEIGHT_BOLD,
NULL);
gtk_text_buffer_create_tag (buffer, "detail-value",
NULL);
gtk_container_add (GTK_CONTAINER (scrolled_window), textview);
gtk_widget_show (textview);
page = gtk_notebook_append_page (GTK_NOTEBOOK (priv->notebook),
scrolled_window,
gtk_label_new_with_mnemonic (_("Character _Details")));
g_assert (page == GUCHARMAP_CHARMAP_PAGE_DETAILS);
gtk_widget_show (scrolled_window);
priv->active_page = 0;
gtk_notebook_set_current_page (GTK_NOTEBOOK (priv->notebook), 0);
g_signal_connect (priv->notebook, "switch-page",
G_CALLBACK (notebook_switch_page), charmap);
gtk_paned_pack2 (GTK_PANED (charmap), priv->notebook, TRUE, FALSE);
gtk_widget_show (priv->notebook);
gtk_widget_set_hexpand (GTK_WIDGET (charmap), TRUE);
gtk_widget_set_vexpand (GTK_WIDGET (charmap), TRUE);
}
void
cdda_drive_info(cdda_drive_t * drive) {
CdIo_t * cdio;
cdio_hwinfo_t hwinfo;
cdio_drive_read_cap_t read_cap;
cdio_drive_write_cap_t write_cap;
cdio_drive_misc_cap_t misc_cap;
GtkWidget * dialog;
GtkWidget * content_area;
GtkWidget * label;
GtkWidget * hbox;
GtkWidget * vbox;
GtkWidget * notebook;
GtkWidget * table;
char str[MAXLEN];
cdio = cdio_open(drive->device_path, DRIVER_UNKNOWN);
if (!cdio_get_hwinfo(cdio, &hwinfo)) {
cdio_destroy(cdio);
return;
}
cdio_get_drive_cap(cdio, &read_cap, &write_cap, &misc_cap);
cdio_destroy(cdio);
snprintf(str, MAXLEN-1, "%s [%s]", _("Drive info"), cdda_displayed_device_path(drive->device_path));
dialog = gtk_dialog_new_with_buttons(str,
GTK_WINDOW(browser_window),
GTK_DIALOG_DESTROY_WITH_PARENT |
GTK_DIALOG_NO_SEPARATOR,
GTK_STOCK_CLOSE, GTK_RESPONSE_OK,
NULL);
gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER);
content_area = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 5);
gtk_box_pack_start(GTK_BOX(content_area), vbox, FALSE, FALSE, 4);
table = gtk_table_new(4, 2, FALSE);
gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, FALSE, 2);
hbox = gtk_hbox_new(FALSE, 0);
label = gtk_label_new(_("Device path:"));
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
gtk_table_attach(GTK_TABLE(table), hbox, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 4, 1);
hbox = gtk_hbox_new(FALSE, 0);
label = gtk_label_new(cdda_displayed_device_path(drive->device_path));
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
gtk_table_attach(GTK_TABLE(table), hbox, 1, 2, 0, 1, GTK_FILL, GTK_FILL, 4, 1);
hbox = gtk_hbox_new(FALSE, 0);
label = gtk_label_new(_("Vendor:"));
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
gtk_table_attach(GTK_TABLE(table), hbox, 0, 1, 1, 2, GTK_FILL, GTK_FILL, 4, 1);
hbox = gtk_hbox_new(FALSE, 0);
label = gtk_label_new(hwinfo.psz_vendor);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
gtk_table_attach(GTK_TABLE(table), hbox, 1, 2, 1, 2, GTK_FILL, GTK_FILL, 4, 1);
hbox = gtk_hbox_new(FALSE, 0);
label = gtk_label_new(_("Model:"));
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
gtk_table_attach(GTK_TABLE(table), hbox, 0, 1, 2, 3, GTK_FILL, GTK_FILL, 4, 1);
hbox = gtk_hbox_new(FALSE, 0);
label = gtk_label_new(hwinfo.psz_model);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
gtk_table_attach(GTK_TABLE(table), hbox, 1, 2, 2, 3, GTK_FILL, GTK_FILL, 4, 1);
hbox = gtk_hbox_new(FALSE, 0);
label = gtk_label_new(_("Revision:"));
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
gtk_table_attach(GTK_TABLE(table), hbox, 0, 1, 3, 4, GTK_FILL, GTK_FILL, 4, 1);
hbox = gtk_hbox_new(FALSE, 0);
label = gtk_label_new(hwinfo.psz_revision);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
gtk_table_attach(GTK_TABLE(table), hbox, 1, 2, 3, 4, GTK_FILL, GTK_FILL, 4, 1);
hbox = gtk_hbox_new(FALSE, 0);
label = gtk_label_new(_("The information below is reported by the drive, and\n"
"may not reflect the actual capabilities of the device."));
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 3);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 10);
if ((misc_cap == CDIO_DRIVE_CAP_ERROR) &&
(read_cap == CDIO_DRIVE_CAP_ERROR) &&
(write_cap == CDIO_DRIVE_CAP_ERROR)) {
goto cdda_info_finish;
}
notebook = gtk_notebook_new();
gtk_box_pack_start(GTK_BOX(content_area), notebook, TRUE, TRUE, 0);
if (misc_cap != CDIO_DRIVE_CAP_ERROR) {
int cnt = 0;
label = gtk_label_new(_("General"));
table = gtk_table_new(8, 2, FALSE);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), table, label);
cdda_info_row(_("Eject"), misc_cap & CDIO_DRIVE_CAP_MISC_EJECT, table, &cnt);
cdda_info_row(_("Close tray"), misc_cap & CDIO_DRIVE_CAP_MISC_CLOSE_TRAY, table, &cnt);
cdda_info_row(_("Disable manual eject"), misc_cap & CDIO_DRIVE_CAP_MISC_LOCK, table, &cnt);
cdda_info_row(_("Select juke-box disc"), misc_cap & CDIO_DRIVE_CAP_MISC_SELECT_DISC, table, &cnt);
cdda_info_row(_("Set drive speed"), misc_cap & CDIO_DRIVE_CAP_MISC_SELECT_SPEED, table, &cnt);
cdda_info_row(_("Detect media change"), misc_cap & CDIO_DRIVE_CAP_MISC_MEDIA_CHANGED, table, &cnt);
cdda_info_row(_("Read multiple sessions"), misc_cap & CDIO_DRIVE_CAP_MISC_MULTI_SESSION, table, &cnt);
cdda_info_row(_("Hard reset device"), misc_cap & CDIO_DRIVE_CAP_MISC_RESET, table, &cnt);
}
if (read_cap != CDIO_DRIVE_CAP_ERROR) {
int cnt = 0;
label = gtk_label_new(_("Reading"));
table = gtk_table_new(16, 2, FALSE);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), table, label);
cdda_info_row(_("Play CD Audio"), read_cap & CDIO_DRIVE_CAP_READ_AUDIO, table, &cnt);
cdda_info_row(_("Read CD-DA"), read_cap & CDIO_DRIVE_CAP_READ_CD_DA, table, &cnt);
cdda_info_row(_("Read CD+G"), read_cap & CDIO_DRIVE_CAP_READ_CD_G, table, &cnt);
cdda_info_row(_("Read CD-R"), read_cap & CDIO_DRIVE_CAP_READ_CD_R, table, &cnt);
cdda_info_row(_("Read CD-RW"), read_cap & CDIO_DRIVE_CAP_READ_CD_RW, table, &cnt);
cdda_info_row(_("Read DVD-R"), read_cap & CDIO_DRIVE_CAP_READ_DVD_R, table, &cnt);
cdda_info_row(_("Read DVD+R"), read_cap & CDIO_DRIVE_CAP_READ_DVD_PR, table, &cnt);
cdda_info_row(_("Read DVD-RW"), read_cap & CDIO_DRIVE_CAP_READ_DVD_RW, table, &cnt);
cdda_info_row(_("Read DVD+RW"), read_cap & CDIO_DRIVE_CAP_READ_DVD_RPW, table, &cnt);
cdda_info_row(_("Read DVD-RAM"), read_cap & CDIO_DRIVE_CAP_READ_DVD_RAM, table, &cnt);
cdda_info_row(_("Read DVD-ROM"), read_cap & CDIO_DRIVE_CAP_READ_DVD_ROM, table, &cnt);
cdda_info_row(_("C2 Error Correction"), read_cap & CDIO_DRIVE_CAP_READ_C2_ERRS, table, &cnt);
cdda_info_row(_("Read Mode 2 Form 1"), read_cap & CDIO_DRIVE_CAP_READ_MODE2_FORM1, table, &cnt);
cdda_info_row(_("Read Mode 2 Form 2"), read_cap & CDIO_DRIVE_CAP_READ_MODE2_FORM2, table, &cnt);
cdda_info_row(_("Read MCN"), read_cap & CDIO_DRIVE_CAP_READ_MCN, table, &cnt);
cdda_info_row(_("Read ISRC"), read_cap & CDIO_DRIVE_CAP_READ_ISRC, table, &cnt);
}
if (write_cap != CDIO_DRIVE_CAP_ERROR) {
int cnt = 0;
label = gtk_label_new(_("Writing"));
table = gtk_table_new(9, 2, FALSE);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), table, label);
cdda_info_row(_("Write CD-R"), write_cap & CDIO_DRIVE_CAP_WRITE_CD_R, table, &cnt);
cdda_info_row(_("Write CD-RW"), write_cap & CDIO_DRIVE_CAP_WRITE_CD_RW, table, &cnt);
cdda_info_row(_("Write DVD-R"), write_cap & CDIO_DRIVE_CAP_WRITE_DVD_R, table, &cnt);
cdda_info_row(_("Write DVD+R"), write_cap & CDIO_DRIVE_CAP_WRITE_DVD_PR, table, &cnt);
cdda_info_row(_("Write DVD-RW"), write_cap & CDIO_DRIVE_CAP_WRITE_DVD_RW, table, &cnt);
cdda_info_row(_("Write DVD+RW"), write_cap & CDIO_DRIVE_CAP_WRITE_DVD_RPW, table, &cnt);
cdda_info_row(_("Write DVD-RAM"), write_cap & CDIO_DRIVE_CAP_WRITE_DVD_RAM, table, &cnt);
cdda_info_row(_("Mount Rainier"), write_cap & CDIO_DRIVE_CAP_WRITE_MT_RAINIER, table, &cnt);
cdda_info_row(_("Burn Proof"), write_cap & CDIO_DRIVE_CAP_WRITE_BURN_PROOF, table, &cnt);
}
cdda_info_finish:
gtk_widget_show_all(dialog);
aqualung_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
}
GtkWidget* linphone_gtk_init_chatroom(LinphoneChatRoom *cr, const LinphoneAddress *with){
GtkWidget *chat_view=linphone_gtk_create_widget("chatroom_frame");
GtkWidget *main_window=linphone_gtk_get_main_window();
GtkNotebook *notebook=(GtkNotebook *)linphone_gtk_get_widget(main_window,"viewswitch");
GtkWidget *text=linphone_gtk_get_widget(chat_view,"textview");
GdkColor color_grey = {0, 32512, 32512, 32512};
GdkColor color_light_grey = {0, 56832, 60928, 61952};
GdkColor color_black = {0};
int idx;
GtkWidget *button;
GtkWidget *entry = linphone_gtk_get_widget(chat_view,"text_entry");
MSList *messages;
GHashTable *table;
GtkTextTag *tmp_tag;
GtkWidget *link_ctx_menu = gtk_menu_new();
GtkWidget *link_ctx_menu_copy_item = gtk_menu_item_new_with_label(_("Copy"));
gtk_notebook_append_page(notebook,chat_view,create_tab_chat_header(cr,with));
idx = gtk_notebook_page_num(notebook, chat_view);
gtk_notebook_set_current_page(notebook, idx);
gtk_widget_show(chat_view);
table=g_hash_table_new_full(g_direct_hash,g_direct_equal,NULL,NULL);
g_object_set_data(G_OBJECT(chat_view),"cr",cr);
g_object_set_data(G_OBJECT(chat_view),"from_message",NULL);
g_object_set_data_full(G_OBJECT(chat_view),"table",table,(GDestroyNotify)g_hash_table_destroy);
gtk_text_buffer_create_tag(
gtk_text_view_get_buffer(GTK_TEXT_VIEW(text)),
"me",
"foreground_gdk", &color_black,
"paragraph-background-gdk", &color_light_grey,
NULL);
gtk_text_buffer_create_tag(
gtk_text_view_get_buffer(GTK_TEXT_VIEW(text)),
"from",
"weight", PANGO_WEIGHT_BOLD,
NULL);
gtk_text_buffer_create_tag(
gtk_text_view_get_buffer(GTK_TEXT_VIEW(text)),
"body",
"indent", 10,
NULL);
gtk_text_buffer_create_tag(
gtk_text_view_get_buffer(GTK_TEXT_VIEW(text)),
"status",
"size-points", 9.0,
"foreground_gdk", &color_grey,
"style", PANGO_STYLE_ITALIC,
"justification", GTK_JUSTIFY_RIGHT,
NULL);
tmp_tag = gtk_text_buffer_create_tag(
gtk_text_view_get_buffer(GTK_TEXT_VIEW(text)),
"link",
"underline", PANGO_UNDERLINE_SINGLE,
"foreground_gdk", _linphone_gtk_chatroom_get_link_color(chat_view),
NULL);
g_signal_connect(G_OBJECT(tmp_tag), "event", G_CALLBACK(link_event_handler), chat_view);
g_signal_connect(G_OBJECT(text), "event", G_CALLBACK(chatroom_event), NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(link_ctx_menu), link_ctx_menu_copy_item);
g_signal_connect(G_OBJECT(link_ctx_menu_copy_item), "activate", G_CALLBACK(copy_uri_into_clipboard_handler), NULL);
gtk_widget_show_all(link_ctx_menu);
g_object_set_data_full(G_OBJECT(text), "link_ctx_menu", link_ctx_menu, g_object_unref);
g_object_ref_sink(G_OBJECT(link_ctx_menu));
messages = linphone_chat_room_get_history(cr,NB_MSG_HIST);
display_history_message(chat_view,messages,with);
button = linphone_gtk_get_widget(chat_view,"send");
g_signal_connect_swapped(G_OBJECT(button),"clicked",(GCallback)linphone_gtk_send_text,NULL);
g_signal_connect_swapped(G_OBJECT(entry),"activate",(GCallback)linphone_gtk_send_text,NULL);
g_signal_connect_swapped(G_OBJECT(entry),"changed",(GCallback)linphone_gtk_compose_text,NULL);
g_signal_connect(G_OBJECT(notebook),"switch_page",(GCallback)linphone_gtk_notebook_tab_select,NULL);
return chat_view;
}
void ir_configure(void)
{
GtkWidget *vbox, *notebook, *box, *frame, *table, *vbox2, *label,
*button, *label_codelen;
GtkAdjustment *adj;
gint i;
irapp_read_config();
if (!irconf_mainwin)
{
irconf_mainwin = gtk_window_new(GTK_WINDOW_DIALOG);
gtk_signal_connect(GTK_OBJECT(irconf_mainwin), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &irconf_mainwin);
gtk_window_set_title(GTK_WINDOW(irconf_mainwin), _("XMMS IRman Configuration"));
gtk_window_set_policy(GTK_WINDOW(irconf_mainwin), FALSE, FALSE, FALSE);
gtk_window_set_position(GTK_WINDOW(irconf_mainwin), GTK_WIN_POS_MOUSE);
gtk_container_border_width(GTK_CONTAINER(irconf_mainwin), 10);
vbox = gtk_vbox_new(FALSE, 10);
gtk_container_add(GTK_CONTAINER(irconf_mainwin), vbox);
notebook = gtk_notebook_new();
gtk_box_pack_start(GTK_BOX(vbox), notebook, TRUE, TRUE, 0);
box = gtk_vbox_new(FALSE, 5);
gtk_container_set_border_width(GTK_CONTAINER(box), 5);
frame = gtk_frame_new(_("Device:"));
gtk_box_pack_start(GTK_BOX(box), frame, FALSE, FALSE, 0);
table = gtk_table_new(2, 1, FALSE);
gtk_container_set_border_width(GTK_CONTAINER(table), 5);
gtk_container_add(GTK_CONTAINER(frame), table);
gtk_table_set_row_spacings(GTK_TABLE(table), 5);
gtk_table_set_col_spacings(GTK_TABLE(table), 5);
label = gtk_label_new(_("Device: "));
gtk_misc_set_alignment(GTK_MISC(label), 1.0, 0.5);
gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 0, 1);
gtk_widget_show(label);
dev_entry = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(dev_entry), ircfg.device);
gtk_table_attach_defaults(GTK_TABLE(table), dev_entry, 1, 2, 0, 1);
gtk_widget_show(dev_entry);
label_codelen = gtk_label_new(_("IR code length: "));
gtk_misc_set_alignment(GTK_MISC(label_codelen), 1.0, 0.5);
gtk_table_attach_defaults(GTK_TABLE(table), label_codelen, 0, 1, 1, 2);
gtk_widget_show(label_codelen);
codelen_entry = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(codelen_entry), g_strdup_printf("%d", ircfg.codelen));
gtk_table_attach_defaults(GTK_TABLE(table), codelen_entry, 1, 2, 1, 2);
gtk_widget_show(codelen_entry);
gtk_widget_show(table);
gtk_widget_show(frame);
frame = gtk_frame_new(_("Controls:"));
gtk_box_pack_start(GTK_BOX(box), frame, FALSE, FALSE, 0);
vbox2 = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(frame), vbox2);
table = gtk_table_new(5, 3, TRUE);
gtk_container_set_border_width(GTK_CONTAINER(table), 5);
gtk_table_set_row_spacings(GTK_TABLE(table), 5);
gtk_table_set_col_spacings(GTK_TABLE(table), 5);
gtk_box_pack_start(GTK_BOX(vbox2), table, FALSE, FALSE, 0);
for (i = 0; i < 13; i++)
{
button = gtk_button_new_with_label(_(ir_control[i]));
gtk_signal_connect(GTK_OBJECT(button), "clicked", GTK_SIGNAL_FUNC(irconf_control_cb), ir_control[i]);
gtk_table_attach_defaults(GTK_TABLE(table), button, i % 3, (i % 3) + 1, i / 3, (i / 3) + 1);
gtk_widget_show(button);
}
gtk_widget_show(table);
gtk_widget_show(frame);
table = gtk_table_new(2, 5, FALSE);
gtk_container_set_border_width(GTK_CONTAINER(table), 5);
gtk_table_set_row_spacings(GTK_TABLE(table), 0);
gtk_table_set_col_spacings(GTK_TABLE(table), 0);
gtk_box_pack_start(GTK_BOX(vbox2), table, FALSE, FALSE, 0);
for (i = 0; i < 10; i++)
{
button = gtk_button_new_with_label(_(ir_playlist[i]));
gtk_signal_connect(GTK_OBJECT(button), "clicked", GTK_SIGNAL_FUNC(irconf_control_cb), ir_playlist[i]);
gtk_table_attach_defaults(GTK_TABLE(table), button, i % 5, (i % 5) + 1, i / 5, (i / 5) + 1);
gtk_widget_show(button);
}
gtk_widget_show(table);
gtk_widget_show(frame);
frame = gtk_frame_new(_("Playlists:"));
gtk_box_pack_start(GTK_BOX(box), frame, FALSE, FALSE, 0);
table = gtk_table_new(2, 1, FALSE);
gtk_container_set_border_width(GTK_CONTAINER(table), 5);
gtk_container_add(GTK_CONTAINER(frame), table);
gtk_table_set_row_spacings(GTK_TABLE(table), 5);
gtk_table_set_col_spacings(GTK_TABLE(table), 5);
adj = (GtkAdjustment *) gtk_adjustment_new(0, 0, 99, 1, 5, 0);
playlist_spin = gtk_spin_button_new(adj, 0, 0);
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(playlist_spin), TRUE);
gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(playlist_spin), GTK_UPDATE_IF_VALID);
gtk_spin_button_set_wrap(GTK_SPIN_BUTTON(playlist_spin), FALSE);
gtk_table_attach_defaults(GTK_TABLE(table), playlist_spin, 0, 1, 0, 1);
gtk_signal_connect(GTK_OBJECT(adj), "value_changed", GTK_SIGNAL_FUNC(spin_change_cb), (gpointer) playlist_spin);
gtk_widget_show(playlist_spin);
playlist_entry = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(playlist_entry), ircfg.playlist[0]);
gtk_signal_connect(GTK_OBJECT(playlist_entry), "changed", GTK_SIGNAL_FUNC(pl_entry_change_cb), (gpointer) playlist_spin);
gtk_table_attach_defaults(GTK_TABLE(table), playlist_entry, 1, 2, 0, 1);
gtk_widget_show(playlist_entry);
gtk_widget_show(table);
gtk_widget_show(frame);
gtk_widget_show(vbox2);
gtk_widget_show(box);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), box, gtk_label_new(_("General")));
gtk_widget_show(notebook);
box = gtk_hbutton_box_new();
gtk_button_box_set_layout(GTK_BUTTON_BOX(box), GTK_BUTTONBOX_END);
gtk_button_box_set_spacing(GTK_BUTTON_BOX(box), 5);
gtk_box_pack_start(GTK_BOX(vbox), box, FALSE, FALSE, 0);
button = gtk_button_new_with_label(_("OK"));
gtk_signal_connect(GTK_OBJECT(button), "clicked", GTK_SIGNAL_FUNC(irconf_ok_cb), NULL);
GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
gtk_box_pack_start(GTK_BOX(box), button, TRUE, TRUE, 0);
gtk_widget_grab_default(button);
gtk_widget_show(button);
button = gtk_button_new_with_label(_("Cancel"));
gtk_signal_connect(GTK_OBJECT(button), "clicked", GTK_SIGNAL_FUNC(irconf_cancel_cb), NULL);
GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
gtk_box_pack_start(GTK_BOX(box), button, TRUE, TRUE, 0);
gtk_widget_show(button);
gtk_widget_show(box);
gtk_widget_show(vbox);
gtk_widget_show(irconf_mainwin);
}
}
int
main (int argc, char **argv)
{
GdkScreen *screen;
GtkWidget *nb;
GtkWidget *general_vbox;
GtkWidget *behaviour_vbox;
GtkWidget *placement_vbox;
GtkWidget *widget;
GtkWidget *vbox;
GtkWidget *vbox1;
GtkWidget *hbox;
GtkWidget *hbox1;
GtkWidget *hbox2;
GtkWidget *hbox3;
GtkWidget *content_area;
gchar *str;
const char *current_wm;
int i;
bindtextdomain (GETTEXT_PACKAGE, MATELOCALEDIR);
bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
gtk_init (&argc, &argv);
screen = gdk_display_get_default_screen (gdk_display_get_default ());
current_wm = gdk_x11_screen_get_window_manager_name (screen);
if (g_strcmp0 (current_wm, WM_COMMON_METACITY) == 0) {
mate_metacity_config_tool ();
return 0;
}
if (g_strcmp0 (current_wm, WM_COMMON_MARCO) != 0) {
wm_unsupported ();
return 1;
}
marco_settings = g_settings_new (MARCO_SCHEMA);
/* Window */
dialog_win = gtk_dialog_new_with_buttons (_("Window Preferences"),
NULL,
GTK_DIALOG_MODAL,
GTK_STOCK_HELP,
GTK_RESPONSE_HELP,
GTK_STOCK_CLOSE,
GTK_RESPONSE_CLOSE,
NULL);
//gtk_window_set_resizable (GTK_WINDOW (dialog_win), FALSE);
gtk_window_set_icon_name (GTK_WINDOW (dialog_win), "preferences-system-windows");
gtk_container_set_border_width (GTK_CONTAINER (dialog_win), 10);
nb = gtk_notebook_new ();
general_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
behaviour_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
placement_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
widget = gtk_label_new (_("General"));
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (hbox), general_vbox, FALSE, FALSE, 6);
gtk_notebook_append_page (GTK_NOTEBOOK (nb), hbox, widget);
widget = gtk_label_new (_("Behaviour"));
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (hbox), behaviour_vbox, FALSE, FALSE, 6);
gtk_notebook_append_page (GTK_NOTEBOOK (nb), hbox, widget);
widget = gtk_label_new (_("Placement"));
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (hbox), placement_vbox, FALSE, FALSE, 6);
gtk_notebook_append_page (GTK_NOTEBOOK (nb), hbox, widget);
/* Compositing manager */
widget = title_label_new (N_("Compositing Manager"));
gtk_box_pack_start (GTK_BOX (general_vbox), widget, FALSE, FALSE, 6);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
hbox1 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
compositing_checkbutton = gtk_check_button_new_with_mnemonic (_("Enable software _compositing window manager"));
compositing_fast_alt_tab_checkbutton = gtk_check_button_new_with_mnemonic (_("Disable _thumbnails in Alt-Tab"));
gtk_box_pack_start (GTK_BOX (vbox), compositing_checkbutton, FALSE, FALSE, 6);
gtk_box_pack_start (GTK_BOX (hbox1), compositing_fast_alt_tab_checkbutton, FALSE, FALSE, 6);
gtk_box_pack_start (GTK_BOX (vbox), hbox1, FALSE, FALSE, 6);
gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 6);
gtk_box_pack_start (GTK_BOX (general_vbox), hbox, FALSE, FALSE, 6);
/* Titlebar buttons */
widget = title_label_new (N_("Titlebar Buttons"));
gtk_box_pack_start (GTK_BOX (general_vbox), widget, FALSE, FALSE, 6);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
widget = gtk_label_new (_("Position:"));
gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 6);
titlebar_layout_optionmenu = gtk_combo_box_text_new ();
gtk_box_pack_start (GTK_BOX (hbox), titlebar_layout_optionmenu, FALSE, FALSE, 6);
gtk_box_pack_start (GTK_BOX (general_vbox), hbox, FALSE, FALSE, 6);
/* New Windows */
widget = title_label_new (N_("New Windows"));
gtk_box_pack_start (GTK_BOX (placement_vbox), widget, FALSE, FALSE, 6);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
center_new_windows_checkbutton = gtk_check_button_new_with_mnemonic (_("Center _new windows"));
gtk_box_pack_start (GTK_BOX (hbox), center_new_windows_checkbutton, FALSE, FALSE, 6);
gtk_box_pack_start (GTK_BOX (placement_vbox), hbox, FALSE, FALSE, 6);
/* Window Snapping */
widget = title_label_new (N_("Window Snapping"));
gtk_box_pack_start (GTK_BOX (placement_vbox), widget, FALSE, FALSE, 6);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
side_by_side_tiling_checkbutton = gtk_check_button_new_with_mnemonic (_("Enable side by side _tiling"));
gtk_box_pack_start (GTK_BOX (hbox), side_by_side_tiling_checkbutton, FALSE, FALSE, 6);
gtk_box_pack_start (GTK_BOX (placement_vbox), hbox, FALSE, FALSE, 6);
/* Window Selection */
widget = title_label_new (N_("Window Selection"));
gtk_box_pack_start (GTK_BOX (behaviour_vbox), widget, FALSE, FALSE, 6);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
vbox1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
hbox1 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
hbox3 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
focus_mode_checkbutton = gtk_check_button_new_with_mnemonic (_("_Select windows when the mouse moves over them"));
gtk_box_pack_start (GTK_BOX (vbox), focus_mode_checkbutton, FALSE, FALSE, 6);
focus_mode_mouse_checkbutton = gtk_check_button_new_with_mnemonic (_("U_nselect windows when the mouse leaves them"));
gtk_box_pack_start (GTK_BOX (hbox1), focus_mode_mouse_checkbutton, FALSE, FALSE, 6);
gtk_box_pack_start (GTK_BOX (vbox1), hbox1, FALSE, FALSE, 6);
autoraise_checkbutton = gtk_check_button_new_with_mnemonic (_("_Raise selected windows after an interval"));
gtk_box_pack_start (GTK_BOX (hbox2), autoraise_checkbutton, FALSE, FALSE, 6);
gtk_box_pack_start (GTK_BOX (vbox1), hbox2, FALSE, FALSE, 6);
autoraise_delay_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
autoraise_delay_slider = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0, 10, 0.2);
widget = gtk_label_new_with_mnemonic (_("_Interval before raising:"));
gtk_box_pack_start (GTK_BOX (autoraise_delay_hbox), widget, FALSE, FALSE, 6);
gtk_box_pack_start (GTK_BOX (autoraise_delay_hbox), autoraise_delay_slider, TRUE, TRUE, 6);
gtk_label_set_mnemonic_widget (GTK_LABEL (widget), autoraise_delay_slider);
widget = gtk_label_new (_("seconds"));
gtk_range_set_increments (GTK_RANGE (autoraise_delay_slider), 0.2, 1.0);
gtk_box_pack_start (GTK_BOX (autoraise_delay_hbox), widget, FALSE, FALSE, 6);
gtk_box_pack_start (GTK_BOX (vbox1), autoraise_delay_hbox, FALSE, FALSE, 6);
gtk_box_pack_start (GTK_BOX (hbox3), vbox1, FALSE, FALSE, 6);
gtk_box_pack_start (GTK_BOX (vbox), hbox3, FALSE, FALSE, 6);
gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 6);
gtk_box_pack_start (GTK_BOX (behaviour_vbox), hbox, FALSE, FALSE, 6);
/* Titlebar Action */
widget = title_label_new (N_("Titlebar Action"));
gtk_box_pack_start (GTK_BOX (behaviour_vbox), widget, FALSE, FALSE, 6);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
widget = gtk_label_new_with_mnemonic (_("_Double-click titlebar to perform this action:"));
gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 6);
double_click_titlebar_optionmenu = gtk_combo_box_text_new ();
gtk_label_set_mnemonic_widget (GTK_LABEL (widget), double_click_titlebar_optionmenu);
gtk_box_pack_start (GTK_BOX (hbox), double_click_titlebar_optionmenu, FALSE, FALSE, 6);
gtk_box_pack_start (GTK_BOX (behaviour_vbox), hbox, FALSE, FALSE, 6);
/* Movement Key */
widget = title_label_new (N_("Movement Key"));
gtk_box_pack_start (GTK_BOX (behaviour_vbox), widget, FALSE, FALSE, 6);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
widget = gtk_label_new_with_mnemonic (_("To move a window, press-and-hold this key then grab the window:"));
#if GTK_CHECK_VERSION (3, 16, 0)
gtk_label_set_xalign (GTK_LABEL (widget), 0.0);
gtk_label_set_yalign (GTK_LABEL (widget), 0.0);
#else
gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.0);
#endif
gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 6);
alt_click_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_label_set_mnemonic_widget (GTK_LABEL (widget), alt_click_vbox);
gtk_box_pack_start (GTK_BOX (vbox), alt_click_vbox, FALSE, FALSE, 6);
gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 6);
gtk_box_pack_start (GTK_BOX (behaviour_vbox), hbox, FALSE, FALSE, 6);
reload_mouse_modifiers ();
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (titlebar_layout_optionmenu), _("Right"));
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (titlebar_layout_optionmenu), _("Left"));
str = g_settings_get_string (marco_settings, MARCO_BUTTON_LAYOUT_KEY);
gtk_combo_box_set_active (GTK_COMBO_BOX (titlebar_layout_optionmenu),
g_strcmp0 (str, MARCO_BUTTON_LAYOUT_RIGHT) == 0 ? 0 : 1);
g_free (str);
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (double_click_titlebar_optionmenu), _("Roll up"));
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (double_click_titlebar_optionmenu), _("Maximize"));
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (double_click_titlebar_optionmenu), _("Maximize Horizontally"));
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (double_click_titlebar_optionmenu), _("Maximize Vertically"));
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (double_click_titlebar_optionmenu), _("Minimize"));
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (double_click_titlebar_optionmenu), _("None"));
gtk_combo_box_set_active (GTK_COMBO_BOX (double_click_titlebar_optionmenu),
g_settings_get_enum (marco_settings, MARCO_DOUBLE_CLICK_TITLEBAR_KEY));
set_alt_click_value ();
gtk_range_set_value (GTK_RANGE (autoraise_delay_slider),
g_settings_get_int (marco_settings, MARCO_AUTORAISE_DELAY_KEY) / 1000.0);
gtk_combo_box_set_active (GTK_COMBO_BOX (double_click_titlebar_optionmenu),
g_settings_get_enum (marco_settings, MARCO_DOUBLE_CLICK_TITLEBAR_KEY));
g_signal_connect (G_OBJECT (dialog_win), "response",
G_CALLBACK (response_cb), NULL);
g_signal_connect (G_OBJECT (dialog_win), "destroy",
G_CALLBACK (gtk_main_quit), NULL);
g_signal_connect (marco_settings, "changed",
G_CALLBACK (marco_settings_changed_callback), NULL);
g_settings_bind (marco_settings,
MARCO_COMPOSITING_MANAGER_KEY,
compositing_checkbutton,
"active",
G_SETTINGS_BIND_DEFAULT);
g_settings_bind (marco_settings,
MARCO_COMPOSITING_FAST_ALT_TAB_KEY,
compositing_fast_alt_tab_checkbutton,
"active",
G_SETTINGS_BIND_DEFAULT);
g_settings_bind (marco_settings,
MARCO_SIDE_BY_SIDE_TILING_KEY,
side_by_side_tiling_checkbutton,
"active",
G_SETTINGS_BIND_DEFAULT);
g_settings_bind (marco_settings,
MARCO_CENTER_NEW_WINDOWS_KEY,
center_new_windows_checkbutton,
"active",
G_SETTINGS_BIND_DEFAULT);
g_signal_connect (marco_settings, "changed::" MARCO_FOCUS_KEY,
G_CALLBACK (mouse_focus_changed_callback), NULL);
/* Initialize the checkbox state appropriately */
mouse_focus_changed_callback(marco_settings, MARCO_FOCUS_KEY, NULL);
g_signal_connect (focus_mode_checkbutton, "toggled",
G_CALLBACK (mouse_focus_toggled_callback), NULL);
g_signal_connect (focus_mode_mouse_checkbutton, "toggled",
G_CALLBACK (mouse_focus_toggled_callback), NULL);
g_settings_bind (marco_settings,
MARCO_AUTORAISE_KEY,
autoraise_checkbutton,
"active",
G_SETTINGS_BIND_DEFAULT);
g_signal_connect (autoraise_delay_slider, "value_changed",
G_CALLBACK (autoraise_delay_value_changed_callback), NULL);
g_signal_connect (double_click_titlebar_optionmenu, "changed",
G_CALLBACK (double_click_titlebar_changed_callback), NULL);
g_signal_connect (titlebar_layout_optionmenu, "changed",
G_CALLBACK (titlebar_layout_changed_callback), NULL);
g_signal_connect (G_OBJECT (screen), "window_manager_changed",
G_CALLBACK (wm_changed_callback), NULL);
i = 0;
while (i < n_mouse_modifiers) {
g_signal_connect (G_OBJECT (mouse_modifiers[i].radio), "toggled",
G_CALLBACK (alt_click_radio_toggled_callback),
&mouse_modifiers[i]);
++i;
}
/* update sensitivity */
update_sensitivity ();
capplet_set_icon (dialog_win, "preferences-system-windows");
content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog_win));
gtk_box_pack_start (GTK_BOX (content_area), nb, TRUE, TRUE, 0);
gtk_widget_show_all (dialog_win);
gtk_main ();
g_object_unref (marco_settings);
return 0;
}
/**
* anjuta_command_bar_add_action_group:
* @self: An AnjutaCommandBar
* @group_name: A unique name for this group of entries
* @entries: (array length=num_entries): A list of entries to add
* @num_entries: The number of items pointed to by entries
* @user_data: User data to pass to the entry callback
*
* Adds a group of entries to an AnjutaCommandBar.
*/
void
anjuta_command_bar_add_action_group (AnjutaCommandBar *self,
const gchar *group_name,
const AnjutaCommandBarEntry *entries,
int num_entries, gpointer user_data)
{
GtkWidget *vbox;
GtkWidget *scrolled_window;
GtkWidget *current_vbox;
GtkActionGroup *action_group;
int i;
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
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_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_SHADOW_IN);
g_hash_table_insert (self->priv->widgets, (gchar *) group_name,
scrolled_window);
action_group = gtk_action_group_new (group_name);
g_hash_table_insert (self->priv->action_groups, (gchar *) group_name,
action_group);
/* The current_vbox is the vbox we're currently adding buttons to. As
* frame entries are encountered, the current box changes to the newly
* created frame vbox. But start by adding any other buttons to the top
* level vbox. */
current_vbox = vbox;
for (i = 0; i < num_entries; i++)
{
if (entries[i].type == ANJUTA_COMMAND_BAR_ENTRY_BUTTON)
{
GtkAction *action;
GtkWidget *button;
GtkWidget *button_box;
GtkWidget *button_label;
action = gtk_action_new (entries[i].action_name, _(entries[i].label),
_(entries[i].tooltip), entries[i].stock_icon);
button = gtk_button_new();
button_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
gtk_container_add (GTK_CONTAINER (button), button_box);
gtk_action_group_add_action (action_group, action);
gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE);
if (entries[i].stock_icon)
{
GtkWidget* image;
image = gtk_action_create_icon (action,
GTK_ICON_SIZE_BUTTON);
gtk_box_pack_start (GTK_BOX (button_box), image, FALSE, FALSE, 5);
}
gtk_activatable_set_related_action (GTK_ACTIVATABLE (button),
action);
button_label = gtk_label_new (gettext(entries[i].label));
gtk_label_set_width_chars (GTK_LABEL (button_label), self->priv->max_text_width);
gtk_label_set_line_wrap (GTK_LABEL (button_label), TRUE);
gtk_misc_set_alignment (GTK_MISC (button_label), 0, 0.5);
gtk_box_pack_start (GTK_BOX (button_box), button_label,
FALSE, FALSE, 5);
gtk_widget_show_all (button);
g_signal_connect (G_OBJECT (action), "activate",
entries[i].callback,
user_data);
/* Left-align button contents */
g_object_set (G_OBJECT (button), "xalign", 0.0, NULL);
gtk_box_pack_start (GTK_BOX (current_vbox), button, FALSE, FALSE,
2);
}
else
{
gchar *frame_label_text;
GtkWidget *frame_label;
GtkWidget *frame;
GtkWidget *frame_vbox;
frame_label_text = g_strdup_printf ("<b>%s</b>", _(entries[i].label));
frame_label = gtk_label_new (NULL);
frame = gtk_frame_new (NULL);
gtk_label_set_markup(GTK_LABEL (frame_label), frame_label_text);
gtk_frame_set_label_widget (GTK_FRAME (frame), frame_label);
g_free (frame_label_text);
frame_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
g_object_set (G_OBJECT (frame), "shadow-type", GTK_SHADOW_NONE,
NULL);
gtk_container_add (GTK_CONTAINER (frame), frame_vbox);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 2);
current_vbox = frame_vbox;
}
}
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_window),
vbox);
gtk_widget_show_all (scrolled_window);
gtk_notebook_append_page (GTK_NOTEBOOK (self), scrolled_window, NULL);
}