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); }