gint main (gint argc, gchar **argv) { GtkWidget *window, *toolbar, *grid, *treeview, *scrolled_window; GtkWidget *hbox, *hbox1, *hbox2, *checkbox, *option_menu, *menu; gint i; static const gchar *toolbar_styles[] = { "icons", "text", "both (vertical)", "both (horizontal)" }; GtkToolItem *item; GtkListStore *store; GtkWidget *image; GtkWidget *menuitem; GtkWidget *button; GtkWidget *label; GIcon *gicon; GSList *group; gtk_init (&argc, &argv); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); g_signal_connect (window, "destroy", G_CALLBACK(gtk_main_quit), NULL); grid = gtk_grid_new (); gtk_container_add (GTK_CONTAINER (window), grid); toolbar = gtk_toolbar_new (); gtk_grid_attach (GTK_GRID (grid), toolbar, 0, 0, 2, 1); hbox1 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 3); gtk_container_set_border_width (GTK_CONTAINER (hbox1), 5); gtk_grid_attach (GTK_GRID (grid), hbox1, 1, 1, 1, 1); hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); gtk_container_set_border_width (GTK_CONTAINER (hbox2), 5); gtk_grid_attach (GTK_GRID (grid), hbox2, 1, 2, 1, 1); checkbox = gtk_check_button_new_with_mnemonic("_Vertical"); gtk_box_pack_start (GTK_BOX (hbox1), checkbox, FALSE, FALSE, 0); g_signal_connect (checkbox, "toggled", G_CALLBACK (change_orientation), toolbar); checkbox = gtk_check_button_new_with_mnemonic("_Show Arrow"); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbox), TRUE); gtk_box_pack_start (GTK_BOX (hbox1), checkbox, FALSE, FALSE, 0); g_signal_connect (checkbox, "toggled", G_CALLBACK (change_show_arrow), toolbar); checkbox = gtk_check_button_new_with_mnemonic("_Set Toolbar Style:"); g_signal_connect (checkbox, "toggled", G_CALLBACK (set_toolbar_style_toggled), toolbar); gtk_box_pack_start (GTK_BOX (hbox1), checkbox, FALSE, FALSE, 0); option_menu = gtk_combo_box_text_new (); gtk_widget_set_sensitive (option_menu, FALSE); g_object_set_data (G_OBJECT (checkbox), "option-menu", option_menu); for (i = 0; i < G_N_ELEMENTS (toolbar_styles); i++) gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (option_menu), toolbar_styles[i]); gtk_combo_box_set_active (GTK_COMBO_BOX (option_menu), gtk_toolbar_get_style (GTK_TOOLBAR (toolbar))); gtk_box_pack_start (GTK_BOX (hbox2), option_menu, FALSE, FALSE, 0); g_signal_connect (option_menu, "changed", G_CALLBACK (change_toolbar_style), toolbar); checkbox = gtk_check_button_new_with_mnemonic("_Set Icon Size:"); g_signal_connect (checkbox, "toggled", G_CALLBACK (set_icon_size_toggled), toolbar); gtk_box_pack_start (GTK_BOX (hbox2), checkbox, FALSE, FALSE, 0); option_menu = gtk_combo_box_text_new (); g_object_set_data (G_OBJECT (checkbox), "option-menu", option_menu); gtk_widget_set_sensitive (option_menu, FALSE); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (option_menu), "small toolbar"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (option_menu), "large toolbar"); gtk_box_pack_start (GTK_BOX (hbox2), option_menu, FALSE, FALSE, 0); g_signal_connect (option_menu, "changed", G_CALLBACK (icon_size_history_changed), toolbar); 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_widget_set_hexpand (scrolled_window, TRUE); gtk_widget_set_vexpand (scrolled_window, TRUE); gtk_grid_attach (GTK_GRID (grid), scrolled_window, 1, 3, 1, 1); store = create_items_list (&treeview); gtk_container_add (GTK_CONTAINER (scrolled_window), treeview); item = gtk_tool_button_new (NULL, NULL); gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "document-new"); gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Custom label"); add_item_to_list (store, item, "New"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); gdk_threads_add_timeout (3000, (GSourceFunc) timeout_cb, item); gtk_tool_item_set_expand (item, TRUE); menu = gtk_menu_new (); for (i = 0; i < 20; i++) { char *text; text = g_strdup_printf ("Menuitem %d", i); menuitem = gtk_menu_item_new_with_label (text); g_free (text); gtk_widget_show (menuitem); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); } item = gtk_menu_tool_button_new (NULL, NULL); gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "document-open"); gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Open"); gtk_menu_tool_button_set_menu (GTK_MENU_TOOL_BUTTON (item), menu); add_item_to_list (store, item, "Open"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); gdk_threads_add_timeout (3000, (GSourceFunc) timeout_cb1, item); menu = gtk_menu_new (); for (i = 0; i < 20; i++) { char *text; text = g_strdup_printf ("A%d", i); menuitem = gtk_menu_item_new_with_label (text); g_free (text); gtk_widget_show (menuitem); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); } item = gtk_menu_tool_button_new (NULL, NULL); gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "go-previous"); gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Back"); gtk_menu_tool_button_set_menu (GTK_MENU_TOOL_BUTTON (item), menu); add_item_to_list (store, item, "BackWithHistory"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); item = gtk_separator_tool_item_new (); add_item_to_list (store, item, "-----"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); image = gtk_image_new_from_icon_name ("dialog-warning", GTK_ICON_SIZE_DIALOG); item = gtk_tool_item_new (); gtk_widget_show (image); gtk_container_add (GTK_CONTAINER (item), image); add_item_to_list (store, item, "(Custom Item)"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); item = gtk_tool_button_new (NULL, NULL); gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "go-previous"); gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Back"); add_item_to_list (store, item, "Back"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); item = gtk_separator_tool_item_new (); add_item_to_list (store, item, "-----"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); item = gtk_tool_button_new (NULL, NULL); gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "go-next"); gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Forward"); add_item_to_list (store, item, "Forward"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); item = gtk_toggle_tool_button_new (); gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Bold"); gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "format-text-bold"); g_signal_connect (item, "toggled", G_CALLBACK (bold_toggled), NULL); add_item_to_list (store, item, "Bold"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); gtk_widget_set_sensitive (GTK_WIDGET (item), FALSE); item = gtk_separator_tool_item_new (); add_item_to_list (store, item, "-----"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); gtk_tool_item_set_expand (item, TRUE); gtk_separator_tool_item_set_draw (GTK_SEPARATOR_TOOL_ITEM (item), FALSE); g_assert (gtk_toolbar_get_nth_item (GTK_TOOLBAR (toolbar), 0) != 0); item = gtk_radio_tool_button_new (NULL); gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Left"); gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "format-justify-left"); group = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (item)); add_item_to_list (store, item, "Left"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); item = gtk_radio_tool_button_new (group); gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Center"); gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "format-justify-center"); group = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (item)); add_item_to_list (store, item, "Center"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); item = gtk_radio_tool_button_new (group); gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Right"); gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "format-justify-right"); add_item_to_list (store, item, "Right"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); item = gtk_tool_button_new (gtk_image_new_from_file ("apple-red.png"), "_Apple"); add_item_to_list (store, item, "Apple"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); gtk_tool_button_set_use_underline (GTK_TOOL_BUTTON (item), TRUE); gicon = g_content_type_get_icon ("video/ogg"); image = gtk_image_new_from_gicon (gicon, GTK_ICON_SIZE_LARGE_TOOLBAR); g_object_unref (gicon); item = gtk_tool_button_new (image, "Video"); add_item_to_list (store, item, "Video"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); image = gtk_image_new_from_icon_name ("utilities-terminal", GTK_ICON_SIZE_LARGE_TOOLBAR); item = gtk_tool_button_new (image, "Terminal"); add_item_to_list (store, item, "Terminal"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); image = gtk_spinner_new (); gtk_spinner_start (GTK_SPINNER (image)); item = gtk_tool_button_new (image, "Spinner"); add_item_to_list (store, item, "Spinner"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5); gtk_container_set_border_width (GTK_CONTAINER (hbox), 5); gtk_widget_set_hexpand (hbox, TRUE); gtk_grid_attach (GTK_GRID (grid), hbox, 1, 4, 1, 1); button = gtk_button_new_with_label ("Drag me to the toolbar"); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); label = gtk_label_new ("Drop index:"); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); label = gtk_label_new (""); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); checkbox = gtk_check_button_new_with_mnemonic("_Right to left"); if (gtk_widget_get_default_direction () == GTK_TEXT_DIR_RTL) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbox), TRUE); else gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbox), FALSE); g_signal_connect (checkbox, "toggled", G_CALLBACK (rtl_toggled), NULL); gtk_box_pack_end (GTK_BOX (hbox), checkbox, FALSE, FALSE, 0); gtk_drag_source_set (button, GDK_BUTTON1_MASK, target_table, G_N_ELEMENTS (target_table), GDK_ACTION_MOVE); gtk_drag_dest_set (toolbar, GTK_DEST_DEFAULT_DROP, target_table, G_N_ELEMENTS (target_table), GDK_ACTION_MOVE); g_signal_connect (toolbar, "drag_motion", G_CALLBACK (toolbar_drag_motion), NULL); g_signal_connect (toolbar, "drag_leave", G_CALLBACK (toolbar_drag_leave), NULL); g_signal_connect (toolbar, "drag_drop", G_CALLBACK (toolbar_drag_drop), label); gtk_widget_show_all (window); g_signal_connect (window, "delete_event", G_CALLBACK (gtk_main_quit), NULL); g_signal_connect (toolbar, "popup_context_menu", G_CALLBACK (popup_context_menu), NULL); gtk_main (); return 0; }
void FormDialog::editable_set (const std::string name, const std::string description, const std::set<std::string> values, const std::set<std::string> proposed_values, bool advanced) { GtkWidget *label = NULL; GtkWidget *scroll = NULL; GtkWidget *button = NULL; GtkWidget *tree_view = NULL; GtkWidget *frame = NULL; GtkWidget *hbox = NULL; GtkWidget *entry = NULL; GtkListStore *list_store = NULL; GtkTreeViewColumn *column = NULL; GtkCellRenderer *renderer = NULL; GtkTreeIter iter; gchar *label_text = NULL; EditableSetSubmitter *submitter = NULL; /* The label */ label = gtk_label_new (NULL); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); label_text = g_strdup_printf ("<b>%s</b>", description.c_str()); gtk_label_set_markup_with_mnemonic (GTK_LABEL (label), label_text); g_free (label_text); /* The GtkListStore containing the values */ list_store = gtk_list_store_new (EditableSetSubmitter::COLUMN_NUMBER, G_TYPE_BOOLEAN, G_TYPE_STRING); tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (list_store)); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (tree_view), TRUE); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tree_view), FALSE); frame = gtk_frame_new (NULL); gtk_widget_set_size_request (GTK_WIDGET (frame), -1, 125); gtk_container_set_border_width (GTK_CONTAINER (frame), 0); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); scroll = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_container_add (GTK_CONTAINER (frame), scroll); gtk_container_add (GTK_CONTAINER (scroll), tree_view); renderer = gtk_cell_renderer_toggle_new (); column = gtk_tree_view_column_new_with_attributes (NULL, renderer, "active", EditableSetSubmitter::COLUMN_ACTIVE, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column); g_signal_connect (renderer, "toggled", G_CALLBACK (editable_set_choice_toggled_cb), list_store); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (NULL, renderer, "text", EditableSetSubmitter::COLUMN_VALUE, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column); for (std::set<std::string>::const_iterator set_iter = values.begin (); set_iter != values.end (); set_iter++) { gtk_list_store_append (GTK_LIST_STORE (list_store), &iter); gtk_list_store_set (GTK_LIST_STORE (list_store), &iter, EditableSetSubmitter::COLUMN_ACTIVE, TRUE, EditableSetSubmitter::COLUMN_VALUE, set_iter->c_str (), -1); } for (std::set<std::string>::const_iterator set_iter = proposed_values.begin (); set_iter != proposed_values.end (); set_iter++) { if (values.find (*set_iter) == values.end ()) { gtk_list_store_append (GTK_LIST_STORE (list_store), &iter); gtk_list_store_set (GTK_LIST_STORE (list_store), &iter, EditableSetSubmitter::COLUMN_ACTIVE, FALSE, EditableSetSubmitter::COLUMN_VALUE, set_iter->c_str (), -1); } } if (advanced) { grow_fields (advanced); gtk_table_attach (GTK_TABLE (advanced_fields), label, 0, 2, advanced_rows - 1, advanced_rows, (GtkAttachOptions) (GTK_FILL|GTK_EXPAND), (GtkAttachOptions) (GTK_FILL|GTK_EXPAND), 0, 0); grow_fields (advanced); gtk_table_attach (GTK_TABLE (advanced_fields), frame, 0, 2, advanced_rows - 1, advanced_rows, (GtkAttachOptions) (GTK_FILL|GTK_EXPAND), (GtkAttachOptions) (GTK_FILL|GTK_EXPAND), 0, 0); } else { grow_fields (advanced); gtk_table_attach (GTK_TABLE (fields), label, 0, 2, rows - 1, rows, (GtkAttachOptions) (GTK_FILL|GTK_EXPAND), (GtkAttachOptions) (GTK_FILL|GTK_EXPAND), 0, 0); grow_fields (advanced); gtk_table_attach (GTK_TABLE (fields), frame, 0, 2, rows - 1, rows, (GtkAttachOptions) (GTK_FILL|GTK_EXPAND), (GtkAttachOptions) (GTK_FILL|GTK_EXPAND), 0, 0); } hbox = gtk_hbox_new (FALSE, 2); entry = gtk_entry_new (); button = gtk_button_new_from_stock (GTK_STOCK_ADD); gtk_box_pack_start (GTK_BOX (hbox), entry, TRUE, TRUE, 2); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 2); g_signal_connect (entry, "activate", (GCallback) editable_set_add_value_activated_cb, (gpointer) tree_view); g_signal_connect (button, "clicked", (GCallback) editable_set_add_value_clicked_cb, (gpointer) entry); grow_fields (advanced); if (advanced) { gtk_table_attach (GTK_TABLE (advanced_fields), hbox, 0, 2, advanced_rows - 1, advanced_rows, (GtkAttachOptions) (GTK_FILL|GTK_EXPAND), (GtkAttachOptions) (GTK_FILL|GTK_EXPAND), 0, 0); } else { gtk_table_attach (GTK_TABLE (fields), hbox, 0, 2, rows - 1, rows, (GtkAttachOptions) (GTK_FILL|GTK_EXPAND), (GtkAttachOptions) (GTK_FILL|GTK_EXPAND), 0, 0); } submitter = new EditableSetSubmitter (name, description, advanced, tree_view); submitters.push_back (submitter); }
int main( int argc, char *argv[] ) { GtkWidget *RecButton; GtkWidget *MainTable; GtkWidget *RightTable; GtkWidget *ExitButton; gtk_init (&argc, &argv); /* Create a new window */ window = gtk_window_new (GTK_WINDOW_TOPLEVEL); /* Set the window title */ gtk_window_set_title (GTK_WINDOW (window), "Start Here"); /* Set a handler for delete_event that immediately * exits GTK. */ g_signal_connect (window, "delete-event", G_CALLBACK (delete_event), NULL); /* Creating tables */ MainTable = gtk_table_new (1, 2, TRUE); RightTable = gtk_table_new (16, 5, TRUE); /* Put the table in the main window */ gtk_container_add (GTK_CONTAINER (window), MainTable); /* Create Recbutton */ RecButton = gtk_button_new_with_label ("Start Recording"); //* When the button is clicked, we call the "callback" function //* with a pointer to "button 1" as its argument g_signal_connect (RecButton, "clicked", G_CALLBACK (startRec),NULL); //* Insert Rec button into the upper right quadrant of the table gtk_table_attach_defaults (GTK_TABLE (MainTable),RightTable , 1, 2, 0, 1); gtk_table_attach_defaults (GTK_TABLE (RightTable), RecButton, 0, 3, 1, 3); // Creating the tempo entry/ TempoEntry = gtk_entry_new (); gtk_table_attach_defaults (GTK_TABLE (RightTable),TempoEntry, 0, 2, 4, 5); // creating the tempo set button/ SetTempoButton = gtk_button_new_with_label ("Set Tempo"); gtk_table_attach_defaults (GTK_TABLE (RightTable),SetTempoButton, 2, 3, 4, 5); g_signal_connect (SetTempoButton,"clicked",G_CALLBACK (tempoSet),NULL); /* Creating the BPMeasure entry*/ BPMeasureEntry = gtk_entry_new (); gtk_table_attach_defaults (GTK_TABLE (RightTable),BPMeasureEntry, 0, 2, 6, 7); //* creating the BPMeasure set button SetBPMeasureButton = gtk_button_new_with_label ("Set Beats/Measure"); gtk_table_attach_defaults (GTK_TABLE (RightTable),SetBPMeasureButton, 2, 3, 6, 7); //g_signal_connect (SetTempoButton,"clicked"); //* Creating the Name entry NameEntry = gtk_entry_new (); gtk_table_attach_defaults (GTK_TABLE (RightTable),NameEntry, 0, 2, 8, 9); // creating the Name set button SetNameButton = gtk_button_new_with_label ("Song Name"); gtk_table_attach_defaults (GTK_TABLE (RightTable),SetNameButton, 2, 3, 8, 9); //g_signal_connect (SetTempoButton,"clicked"); //Next Button NextButton = gtk_button_new_with_label ("Next"); gtk_table_attach_defaults (GTK_TABLE (RightTable),NextButton, 3, 4, 15, 16); g_signal_connect (NextButton, "clicked", G_CALLBACK (nextPage), (gpointer) RightTable); //Exit Button ExitButton = gtk_button_new_with_label ("Exit"); gtk_table_attach_defaults (GTK_TABLE (RightTable),ExitButton, 0, 1, 15, 16); g_signal_connect (ExitButton, "clicked", G_CALLBACK (delete_event), NULL); gtk_widget_show(ExitButton); gtk_widget_show (RecButton); gtk_widget_show (RightTable); gtk_widget_show (MainTable); gtk_widget_show (window); /***************************************************************\\PAGE-2\\************************************************************************/ GtkWidget* HihatImage; //GtkWidget* HihatButton = gtk_button_new(); GtkWidget* CrashImage; GtkWidget *FloorImage; GtkWidget *HiImage; GtkWidget *LowImage; GtkWidget *BaseImage; GtkWidget *SnareImage; //GtkWidget *background; GtkWidget *BackButton; GtkWidget *RestButton; GtkWidget *FinishButton; BackButton = gtk_button_new_with_label ("Back"); RestButton = gtk_button_new_with_label ("Rest"); FinishButton = gtk_button_new_with_label ("Finish"); RightTwo = gtk_table_new(12,12,FALSE); gtk_table_attach_defaults (GTK_TABLE (MainTable),RightTwo, 0, 2, 0, 1); //background = gtk_image_new_from_file ( "cover.png" ); HihatImage = gtk_image_new_from_file ( "index.jpeg" ); //Look further into this to load from another directory CrashImage = gtk_image_new_from_file ( "index.jpeg" ); FloorImage = gtk_image_new_from_file ( "floor.png" ); HiImage = gtk_image_new_from_file ( "floor.png" ); LowImage = gtk_image_new_from_file ( "floor.png" ); BaseImage = gtk_image_new_from_file ( "floor.png" ); SnareImage = gtk_image_new_from_file ( "floor.png" ); gtk_table_attach_defaults (GTK_TABLE (RightTwo),BackButton,1,2,9,10); gtk_table_attach_defaults (GTK_TABLE (RightTwo),RestButton,3,4,9,10); gtk_table_attach_defaults (GTK_TABLE (RightTwo),FinishButton,5,6,9,10); gtk_table_attach_defaults (GTK_TABLE (RightTwo),HihatImage,1,2,0,1); gtk_table_attach_defaults (GTK_TABLE (RightTwo),CrashImage,4,5,0,1); gtk_table_attach_defaults (GTK_TABLE (RightTwo),HiImage,2,3,1,2); gtk_table_attach_defaults (GTK_TABLE (RightTwo),LowImage,3,4,1,2); gtk_table_attach_defaults (GTK_TABLE (RightTwo),BaseImage,4,5,3,4); gtk_table_attach_defaults (GTK_TABLE (RightTwo),SnareImage,1,2,2,3); gtk_table_attach_defaults (GTK_TABLE (RightTwo),FloorImage,5,6,2,3); //Events for any widgets must connect to g_signal handlers gtk_widget_show(BackButton); gtk_widget_show(RestButton); gtk_widget_show(FinishButton); gtk_widget_show(HihatImage); gtk_widget_show(SnareImage); gtk_widget_show(BaseImage); gtk_widget_show(FloorImage); gtk_widget_show(LowImage); gtk_widget_show(HiImage); gtk_widget_show(CrashImage); gtk_main (); return 0; }
void gui_create_tasks_options_page (GtkWidget *vbox, GUI *appGUI) { GtkWidget *appearance_vbox, *categories_vbox; GtkWidget *sorting_vbox, *tasks_opt_vbox, *visible_columns_vbox; GtkWidget *label; GtkWidget *colors_hbox; GtkWidget *valid_hbox; GtkWidget *frame; GtkWidget *table; GtkWidget *alignment; GtkWidget *ti_font_button; GtkWidget *scrolledwindow; GtkWidget *tasks_category_table; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GdkColor color; GtkObject *postpone_time_spinbutton_adj; gchar tmpbuf[BUFFER_SIZE]; appGUI->opt->tasks_vbox = gtk_vbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), appGUI->opt->tasks_vbox, FALSE, FALSE, 0); frame = gtk_frame_new (NULL); gtk_widget_show (frame); gtk_box_pack_start (GTK_BOX (appGUI->opt->tasks_vbox), frame, FALSE, TRUE, 0); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE); sprintf(tmpbuf, "<b>%s</b>", _("Appearance")); label = gtk_label_new (tmpbuf); gtk_widget_show (label); gtk_frame_set_label_widget (GTK_FRAME (frame), label); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); gtk_misc_set_padding (GTK_MISC (label), 0, 4); alignment = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_widget_show (alignment); gtk_container_add (GTK_CONTAINER (frame), alignment); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 12, 12, 0); appearance_vbox = gtk_vbox_new (FALSE, 0); gtk_widget_show (appearance_vbox); gtk_container_add (GTK_CONTAINER (alignment), appearance_vbox); table = gtk_table_new (4, 4, FALSE); gtk_widget_show (table); gtk_box_pack_start (GTK_BOX (appearance_vbox), table, FALSE, FALSE, 0); gtk_table_set_col_spacings (GTK_TABLE (table), 4); gtk_table_set_row_spacings (GTK_TABLE (table), 8); colors_hbox = gtk_hbox_new (FALSE, 8); gtk_widget_show (colors_hbox); gtk_table_attach (GTK_TABLE (table), colors_hbox, 1, 2, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); appGUI->opt->due_today_color_picker = gtk_color_button_new (); gtk_widget_show (appGUI->opt->due_today_color_picker); g_signal_connect (G_OBJECT (appGUI->opt->due_today_color_picker), "color-set", G_CALLBACK(due_today_color_changed_cb), appGUI); if (config.enable_tooltips) { gtk_widget_set_tooltip_text (appGUI->opt->due_today_color_picker, _("Color of items that are due today")); } gdk_color_parse(config.due_today_color, &color); gtk_color_button_set_color (GTK_COLOR_BUTTON (appGUI->opt->due_today_color_picker), &color); gtk_box_pack_start (GTK_BOX (colors_hbox), appGUI->opt->due_today_color_picker, FALSE, FALSE, 0); appGUI->opt->due_7days_color_picker = gtk_color_button_new (); gtk_widget_show (appGUI->opt->due_7days_color_picker); g_signal_connect (G_OBJECT (appGUI->opt->due_7days_color_picker), "color-set", G_CALLBACK(due_7days_color_changed_cb), appGUI); if (config.enable_tooltips) { gtk_widget_set_tooltip_text (appGUI->opt->due_7days_color_picker, _("Color of items that are due in the next 7 days")); } gdk_color_parse(config.due_7days_color, &color); gtk_color_button_set_color (GTK_COLOR_BUTTON (appGUI->opt->due_7days_color_picker), &color); gtk_box_pack_start (GTK_BOX (colors_hbox), appGUI->opt->due_7days_color_picker, FALSE, FALSE, 0); appGUI->opt->past_due_color_picker = gtk_color_button_new (); gtk_widget_show (appGUI->opt->past_due_color_picker); g_signal_connect (G_OBJECT (appGUI->opt->past_due_color_picker), "color-set", G_CALLBACK(past_due_color_changed_cb), appGUI); if (config.enable_tooltips) { gtk_widget_set_tooltip_text (appGUI->opt->past_due_color_picker, _("Color of items that are past due")); } gdk_color_parse(config.past_due_color, &color); gtk_color_button_set_color (GTK_COLOR_BUTTON (appGUI->opt->past_due_color_picker), &color); gtk_box_pack_start (GTK_BOX (colors_hbox), appGUI->opt->past_due_color_picker, FALSE, FALSE, 0); appGUI->opt->ti_font_entry = gtk_entry_new (); GTK_WIDGET_UNSET_FLAGS(appGUI->opt->ti_font_entry, GTK_CAN_FOCUS); gtk_widget_show (appGUI->opt->ti_font_entry); gtk_table_attach (GTK_TABLE (table), appGUI->opt->ti_font_entry, 1, 2, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); if (config.default_stock_icons) { ti_font_button = utl_gui_stock_button (GTK_STOCK_SELECT_FONT, FALSE); } else { ti_font_button = utl_gui_stock_button (OSMO_STOCK_BUTTON_SELECT_FONT, FALSE); } GTK_WIDGET_UNSET_FLAGS(ti_font_button, GTK_CAN_FOCUS); gtk_widget_show (ti_font_button); g_signal_connect (G_OBJECT (ti_font_button), "clicked", G_CALLBACK (ti_font_select_cb), appGUI); gtk_table_attach (GTK_TABLE (table), ti_font_button, 2, 3, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); sprintf(tmpbuf, "%s:", _("Task info font")); label = gtk_label_new (tmpbuf); gtk_widget_show (label); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); sprintf(tmpbuf, "%s:", _("Colors")); label = gtk_label_new (tmpbuf); gtk_widget_show (label); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); appGUI->opt->tasks_enable_rules_hint_checkbutton = gtk_check_button_new_with_mnemonic (_("Draw rows in alternating colors")); GTK_WIDGET_UNSET_FLAGS(appGUI->opt->tasks_enable_rules_hint_checkbutton, GTK_CAN_FOCUS); gtk_widget_show (appGUI->opt->tasks_enable_rules_hint_checkbutton); g_signal_connect (G_OBJECT (appGUI->opt->tasks_enable_rules_hint_checkbutton), "toggled", G_CALLBACK (tasks_enable_rules_hint_checkbutton_cb), appGUI); gtk_table_attach (GTK_TABLE (table), appGUI->opt->tasks_enable_rules_hint_checkbutton, 0, 3, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); appGUI->opt->ct_bold_items_checkbutton = gtk_check_button_new_with_mnemonic (_("Show in bold tasks with high priority")); GTK_WIDGET_UNSET_FLAGS(appGUI->opt->ct_bold_items_checkbutton, GTK_CAN_FOCUS); gtk_widget_show (appGUI->opt->ct_bold_items_checkbutton); gtk_table_attach (GTK_TABLE (table), appGUI->opt->ct_bold_items_checkbutton, 0, 3, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); g_signal_connect (G_OBJECT (appGUI->opt->ct_bold_items_checkbutton), "toggled", G_CALLBACK (bold_items_cb), appGUI); frame = gtk_frame_new (NULL); gtk_widget_show (frame); gtk_box_pack_start (GTK_BOX (appGUI->opt->tasks_vbox), frame, FALSE, TRUE, 0); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE); sprintf(tmpbuf, "<b>%s</b>", _("Visible columns")); label = gtk_label_new (tmpbuf); gtk_widget_show (label); gtk_frame_set_label_widget (GTK_FRAME (frame), label); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); gtk_misc_set_padding (GTK_MISC (label), 0, 4); alignment = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_widget_show (alignment); gtk_container_add (GTK_CONTAINER (frame), alignment); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 12, 12, 0); visible_columns_vbox = gtk_vbox_new (FALSE, 0); gtk_widget_show (visible_columns_vbox); gtk_container_add (GTK_CONTAINER (alignment), visible_columns_vbox); table = gtk_table_new (1, 4, FALSE); gtk_widget_show (table); gtk_box_pack_start (GTK_BOX (visible_columns_vbox), table, FALSE, FALSE, 0); gtk_table_set_row_spacings (GTK_TABLE (table), 4); gtk_table_set_col_spacings (GTK_TABLE (table), 8); appGUI->opt->vc_due_date_checkbutton = gtk_check_button_new_with_mnemonic (_("Due date")); GTK_WIDGET_UNSET_FLAGS(appGUI->opt->vc_due_date_checkbutton, GTK_CAN_FOCUS); gtk_widget_show (appGUI->opt->vc_due_date_checkbutton); g_signal_connect (G_OBJECT (appGUI->opt->vc_due_date_checkbutton), "toggled", G_CALLBACK (visible_columns_changed_cb), appGUI); gtk_table_attach (GTK_TABLE (table), appGUI->opt->vc_due_date_checkbutton, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL | GTK_EXPAND), (GtkAttachOptions) (0), 0, 0); appGUI->opt->vc_type_checkbutton = gtk_check_button_new_with_mnemonic (_("Type")); GTK_WIDGET_UNSET_FLAGS(appGUI->opt->vc_type_checkbutton, GTK_CAN_FOCUS); gtk_widget_show (appGUI->opt->vc_type_checkbutton); g_signal_connect (G_OBJECT (appGUI->opt->vc_type_checkbutton), "toggled", G_CALLBACK (visible_columns_changed_cb), appGUI); gtk_table_attach (GTK_TABLE (table), appGUI->opt->vc_type_checkbutton, 1, 2, 0, 1, (GtkAttachOptions) (GTK_FILL | GTK_EXPAND), (GtkAttachOptions) (0), 0, 0); appGUI->opt->vc_priority_checkbutton = gtk_check_button_new_with_mnemonic (_("Priority")); GTK_WIDGET_UNSET_FLAGS(appGUI->opt->vc_priority_checkbutton, GTK_CAN_FOCUS); gtk_widget_show (appGUI->opt->vc_priority_checkbutton); g_signal_connect (G_OBJECT (appGUI->opt->vc_priority_checkbutton), "toggled", G_CALLBACK (visible_columns_changed_cb), appGUI); gtk_table_attach (GTK_TABLE (table), appGUI->opt->vc_priority_checkbutton, 2, 3, 0, 1, (GtkAttachOptions) (GTK_FILL | GTK_EXPAND), (GtkAttachOptions) (0), 0, 0); appGUI->opt->vc_category_checkbutton = gtk_check_button_new_with_mnemonic (_("Category")); GTK_WIDGET_UNSET_FLAGS(appGUI->opt->vc_category_checkbutton, GTK_CAN_FOCUS); gtk_widget_show (appGUI->opt->vc_category_checkbutton); g_signal_connect (G_OBJECT (appGUI->opt->vc_category_checkbutton), "toggled", G_CALLBACK (visible_columns_changed_cb), appGUI); gtk_table_attach (GTK_TABLE (table), appGUI->opt->vc_category_checkbutton, 3, 4, 0, 1, (GtkAttachOptions) (GTK_FILL | GTK_EXPAND), (GtkAttachOptions) (0), 0, 0); frame = gtk_frame_new (NULL); gtk_widget_show (frame); gtk_box_pack_start (GTK_BOX (appGUI->opt->tasks_vbox), frame, FALSE, TRUE, 0); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE); sprintf(tmpbuf, "<b>%s</b>", _("Categories")); label = gtk_label_new (tmpbuf); gtk_widget_show (label); gtk_frame_set_label_widget (GTK_FRAME (frame), label); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); gtk_misc_set_padding (GTK_MISC (label), 0, 4); alignment = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_widget_show (alignment); gtk_container_add (GTK_CONTAINER (frame), alignment); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 12, 12, 0); categories_vbox = gtk_vbox_new (FALSE, 0); gtk_widget_show (categories_vbox); gtk_container_add (GTK_CONTAINER (alignment), categories_vbox); tasks_category_table = gtk_table_new (4, 3, FALSE); gtk_widget_show (tasks_category_table); gtk_box_pack_start (GTK_BOX (categories_vbox), tasks_category_table, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (tasks_category_table), 8); gtk_table_set_row_spacings (GTK_TABLE (tasks_category_table), 8); gtk_table_set_col_spacings (GTK_TABLE (tasks_category_table), 4); appGUI->opt->tasks_category_entry = gtk_entry_new (); gtk_widget_show (appGUI->opt->tasks_category_entry); gtk_table_attach (GTK_TABLE (tasks_category_table), appGUI->opt->tasks_category_entry, 0, 1, 3, 4, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); g_signal_connect (G_OBJECT (appGUI->opt->tasks_category_entry), "key_release_event", G_CALLBACK (tasks_category_entry_key_release_cb), appGUI); scrolledwindow = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (scrolledwindow); gtk_table_attach (GTK_TABLE (tasks_category_table), scrolledwindow, 0, 3, 0, 3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow), GTK_SHADOW_IN); appGUI->opt->tasks_category_store = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN); appGUI->opt->tasks_category_treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(appGUI->opt->tasks_category_store)); appGUI->opt->tasks_category_select = gtk_tree_view_get_selection(GTK_TREE_VIEW(appGUI->opt->tasks_category_treeview)); gtk_widget_show (appGUI->opt->tasks_category_treeview); g_signal_connect(G_OBJECT(appGUI->opt->tasks_category_select), "changed", G_CALLBACK(tasks_category_selected_cb), appGUI); gtk_container_add (GTK_CONTAINER (scrolledwindow), appGUI->opt->tasks_category_treeview); gtk_container_set_border_width (GTK_CONTAINER (appGUI->opt->tasks_category_treeview), 4); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (appGUI->opt->tasks_category_treeview), TRUE); gtk_tree_view_set_reorderable (GTK_TREE_VIEW (appGUI->opt->tasks_category_treeview), TRUE); gtk_tree_view_set_enable_search (GTK_TREE_VIEW (appGUI->opt->tasks_category_treeview), FALSE); gtk_widget_set_size_request (appGUI->opt->tasks_category_treeview, -1, 120); renderer = gtk_cell_renderer_text_new(); g_object_set (renderer, "editable", TRUE, "editable-set", TRUE, NULL); g_signal_connect (G_OBJECT (renderer), "edited", G_CALLBACK (tasks_category_cell_edited_cb), appGUI); column = gtk_tree_view_column_new_with_attributes(_("Name"), renderer, "text", TC_COLUMN_NAME, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->opt->tasks_category_treeview), column); gtk_tree_view_column_set_expand (column, TRUE); renderer = gtk_cell_renderer_toggle_new(); /* Show in calendar */ column = gtk_tree_view_column_new_with_attributes(_("Calendar"), renderer, "active", TC_COLUMN_CALENDAR, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->opt->tasks_category_treeview), column); g_signal_connect (renderer, "toggled", G_CALLBACK (tsk_show_in_calendar_toggled), appGUI); renderer = gtk_cell_renderer_toggle_new(); /* Show in tasks list */ column = gtk_tree_view_column_new_with_attributes(_("Tasks"), renderer, "active", TC_COLUMN_TASKS, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->opt->tasks_category_treeview), column); g_signal_connect (renderer, "toggled", G_CALLBACK (tsk_show_in_tasks_list_toggled), appGUI); if (config.default_stock_icons) { appGUI->opt->tasks_category_add_button = utl_gui_stock_button (GTK_STOCK_ADD, FALSE); } else { appGUI->opt->tasks_category_add_button = utl_gui_stock_button (OSMO_STOCK_BUTTON_ADD, FALSE); } GTK_WIDGET_UNSET_FLAGS(appGUI->opt->tasks_category_add_button, GTK_CAN_FOCUS); gtk_widget_show (appGUI->opt->tasks_category_add_button); gtk_table_attach (GTK_TABLE (tasks_category_table), appGUI->opt->tasks_category_add_button, 1, 2, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); g_signal_connect(appGUI->opt->tasks_category_add_button, "clicked", G_CALLBACK(tasks_category_add_cb), appGUI); gtk_widget_set_sensitive(appGUI->opt->tasks_category_add_button, FALSE); if (config.default_stock_icons) { appGUI->opt->tasks_category_remove_button = utl_gui_stock_button (GTK_STOCK_REMOVE, FALSE); } else { appGUI->opt->tasks_category_remove_button = utl_gui_stock_button (OSMO_STOCK_BUTTON_REMOVE, FALSE); } GTK_WIDGET_UNSET_FLAGS(appGUI->opt->tasks_category_remove_button, GTK_CAN_FOCUS); gtk_widget_show (appGUI->opt->tasks_category_remove_button); gtk_table_attach (GTK_TABLE (tasks_category_table), appGUI->opt->tasks_category_remove_button, 2, 3, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); g_signal_connect(appGUI->opt->tasks_category_remove_button, "clicked", G_CALLBACK(tasks_category_remove_cb), appGUI); gtk_widget_set_sensitive(appGUI->opt->tasks_category_remove_button, FALSE); frame = gtk_frame_new (NULL); gtk_widget_show (frame); gtk_box_pack_start (GTK_BOX (appGUI->opt->tasks_vbox), frame, FALSE, TRUE, 0); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE); sprintf(tmpbuf, "<b>%s</b>", _("Sorting")); label = gtk_label_new (tmpbuf); gtk_widget_show (label); gtk_frame_set_label_widget (GTK_FRAME (frame), label); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); gtk_misc_set_padding (GTK_MISC (label), 0, 4); alignment = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_widget_show (alignment); gtk_container_add (GTK_CONTAINER (frame), alignment); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 12, 12, 0); sorting_vbox = gtk_vbox_new (FALSE, 0); gtk_widget_show (sorting_vbox); gtk_container_add (GTK_CONTAINER (alignment), sorting_vbox); table = gtk_table_new (1, 5, FALSE); gtk_widget_show (table); gtk_box_pack_start (GTK_BOX (sorting_vbox), table, FALSE, FALSE, 0); gtk_table_set_row_spacings (GTK_TABLE (table), 4); gtk_table_set_col_spacings (GTK_TABLE (table), 8); sprintf(tmpbuf, "%s:", _("Order")); label = gtk_label_new (tmpbuf); gtk_widget_show (label); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL | GTK_EXPAND), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); sprintf(tmpbuf, "%s:", _("Mode")); label = gtk_label_new (tmpbuf); gtk_widget_show (label); gtk_table_attach (GTK_TABLE (table), label, 2, 3, 0, 1, (GtkAttachOptions) (GTK_FILL | GTK_EXPAND), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); appGUI->opt->tasks_sort_order_combobox = gtk_combo_box_new_text (); gtk_widget_show (appGUI->opt->tasks_sort_order_combobox); g_signal_connect (G_OBJECT (appGUI->opt->tasks_sort_order_combobox), "changed", G_CALLBACK(tasks_sort_order_changed_cb), appGUI); gtk_table_attach (GTK_TABLE (table), appGUI->opt->tasks_sort_order_combobox, 1, 2, 0, 1, (GtkAttachOptions) (GTK_FILL | GTK_EXPAND), (GtkAttachOptions) (0), 0, 0); gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->opt->tasks_sort_order_combobox), _("Ascending")); gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->opt->tasks_sort_order_combobox), _("Descending")); gtk_combo_box_set_active (GTK_COMBO_BOX(appGUI->opt->tasks_sort_order_combobox), config.tasks_sorting_order); appGUI->opt->tasks_sort_mode_combobox = gtk_combo_box_new_text (); gtk_widget_show (appGUI->opt->tasks_sort_mode_combobox); g_signal_connect (G_OBJECT (appGUI->opt->tasks_sort_mode_combobox), "changed", G_CALLBACK(tasks_sort_mode_changed_cb), appGUI); gtk_table_attach (GTK_TABLE (table), appGUI->opt->tasks_sort_mode_combobox, 3, 4, 0, 1, (GtkAttachOptions) (GTK_FILL | GTK_EXPAND), (GtkAttachOptions) (0), 0, 0); sprintf (tmpbuf, "%s, %s, %s", _("Done"), _("Due date"), _("Priority")); gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->opt->tasks_sort_mode_combobox), tmpbuf); sprintf (tmpbuf, "%s, %s, %s", _("Done"), _("Priority"), _("Due date")); gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->opt->tasks_sort_mode_combobox), tmpbuf); sprintf (tmpbuf, "%s, %s, %s", _("Priority"), _("Due date"), _("Done")); gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->opt->tasks_sort_mode_combobox), tmpbuf); sprintf (tmpbuf, "%s, %s, %s", _("Priority"), _("Done"), _("Due date")); gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->opt->tasks_sort_mode_combobox), tmpbuf); sprintf (tmpbuf, "%s, %s, %s", _("Due date"), _("Priority"), _("Done")); gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->opt->tasks_sort_mode_combobox), tmpbuf); sprintf (tmpbuf, "%s, %s, %s", _("Due date"), _("Done"), _("Priority")); gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->opt->tasks_sort_mode_combobox), tmpbuf); gtk_combo_box_set_active (GTK_COMBO_BOX(appGUI->opt->tasks_sort_mode_combobox), config.tasks_sorting_mode); frame = gtk_frame_new (NULL); gtk_widget_show (frame); gtk_box_pack_start (GTK_BOX (appGUI->opt->tasks_vbox), frame, FALSE, TRUE, 0); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE); sprintf(tmpbuf, "<b>%s</b>", _("Tasks options")); label = gtk_label_new (tmpbuf); gtk_widget_show (label); gtk_frame_set_label_widget (GTK_FRAME (frame), label); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); gtk_misc_set_padding (GTK_MISC (label), 0, 4); alignment = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_widget_show (alignment); gtk_container_add (GTK_CONTAINER (frame), alignment); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 12, 12, 0); tasks_opt_vbox = gtk_vbox_new (FALSE, 0); gtk_widget_show (tasks_opt_vbox); gtk_container_add (GTK_CONTAINER (alignment), tasks_opt_vbox); appGUI->opt->ct_hide_items_checkbutton = gtk_check_button_new_with_mnemonic (_("Hide completed tasks")); GTK_WIDGET_UNSET_FLAGS(appGUI->opt->ct_hide_items_checkbutton, GTK_CAN_FOCUS); gtk_widget_show (appGUI->opt->ct_hide_items_checkbutton); g_signal_connect (G_OBJECT (appGUI->opt->ct_hide_items_checkbutton), "toggled", G_CALLBACK (hide_delete_changed_cb), appGUI); gtk_box_pack_start (GTK_BOX (tasks_opt_vbox), appGUI->opt->ct_hide_items_checkbutton, FALSE, FALSE, 4); g_signal_connect (G_OBJECT (appGUI->opt->ct_hide_items_checkbutton), "toggled", G_CALLBACK (hide_items_cb), appGUI); appGUI->opt->ct_delete_items_checkbutton = gtk_check_button_new_with_mnemonic (_("Delete completed tasks without confirmation")); GTK_WIDGET_UNSET_FLAGS(appGUI->opt->ct_delete_items_checkbutton, GTK_CAN_FOCUS); gtk_widget_show (appGUI->opt->ct_delete_items_checkbutton); g_signal_connect (G_OBJECT (appGUI->opt->ct_delete_items_checkbutton), "toggled", G_CALLBACK (hide_delete_changed_cb), appGUI); gtk_box_pack_start (GTK_BOX (tasks_opt_vbox), appGUI->opt->ct_delete_items_checkbutton, FALSE, FALSE, 4); g_signal_connect (G_OBJECT (appGUI->opt->ct_delete_items_checkbutton), "toggled", G_CALLBACK (delete_items_cb), appGUI); appGUI->opt->ct_add_item_checkbutton = gtk_check_button_new_with_mnemonic (_("Add new task when double clicked on tasks list")); GTK_WIDGET_UNSET_FLAGS(appGUI->opt->ct_add_item_checkbutton, GTK_CAN_FOCUS); gtk_widget_show (appGUI->opt->ct_add_item_checkbutton); gtk_box_pack_start (GTK_BOX (tasks_opt_vbox), appGUI->opt->ct_add_item_checkbutton, FALSE, FALSE, 4); g_signal_connect (G_OBJECT (appGUI->opt->ct_add_item_checkbutton), "toggled", G_CALLBACK (add_item_cb), appGUI); appGUI->opt->ct_remember_category_checkbutton = gtk_check_button_new_with_mnemonic (_("Remember the last selected category")); GTK_WIDGET_UNSET_FLAGS(appGUI->opt->ct_remember_category_checkbutton, GTK_CAN_FOCUS); gtk_widget_show (appGUI->opt->ct_remember_category_checkbutton); gtk_box_pack_start (GTK_BOX (tasks_opt_vbox), appGUI->opt->ct_remember_category_checkbutton, FALSE, FALSE, 4); g_signal_connect (G_OBJECT (appGUI->opt->ct_remember_category_checkbutton), "toggled", G_CALLBACK (remember_category_cb), appGUI); frame = gtk_frame_new (NULL); gtk_widget_show (frame); gtk_box_pack_start (GTK_BOX (appGUI->opt->tasks_vbox), frame, FALSE, TRUE, 0); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE); g_snprintf (tmpbuf, BUFFER_SIZE, "<b>%s</b>", _("Reminder options")); label = gtk_label_new (tmpbuf); gtk_widget_show (label); gtk_frame_set_label_widget (GTK_FRAME (frame), label); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); gtk_misc_set_padding (GTK_MISC (label), 0, 4); alignment = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_widget_show (alignment); gtk_container_add (GTK_CONTAINER (frame), alignment); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 12, 12, 0); table = gtk_table_new (2, 4, FALSE); gtk_widget_show (table); gtk_container_add (GTK_CONTAINER (alignment), table); gtk_container_set_border_width (GTK_CONTAINER (table), 4); gtk_table_set_col_spacings (GTK_TABLE (table), 4); gtk_table_set_row_spacings (GTK_TABLE (table), 8); g_snprintf (tmpbuf, BUFFER_SIZE, "%s:", _("Postpone time")); label = gtk_label_new (tmpbuf); gtk_widget_show (label); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); postpone_time_spinbutton_adj = gtk_adjustment_new (0, 0, 1440, 1, 10, 0); appGUI->opt->postpone_time_spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (postpone_time_spinbutton_adj), 1, 0); g_signal_connect (G_OBJECT (appGUI->opt->postpone_time_spinbutton), "value-changed", G_CALLBACK (postpone_time_changed_cb), appGUI); gtk_widget_show (appGUI->opt->postpone_time_spinbutton); gtk_table_attach (GTK_TABLE (table), appGUI->opt->postpone_time_spinbutton, 1, 2, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (appGUI->opt->postpone_time_spinbutton), TRUE); gtk_spin_button_set_value (GTK_SPIN_BUTTON(appGUI->opt->postpone_time_spinbutton), config.postpone_time); g_snprintf (tmpbuf, BUFFER_SIZE, "%s (%s)", _("minutes"), _("0 for disable")); label = gtk_label_new (tmpbuf); gtk_widget_show (label); gtk_table_attach (GTK_TABLE (table), label, 2, 3, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); g_snprintf (tmpbuf, BUFFER_SIZE, "%s:", _("Global notification command")); label = gtk_label_new (tmpbuf); gtk_widget_show (label); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); valid_hbox = gtk_hbox_new (FALSE, 2); gtk_widget_show (valid_hbox); gtk_table_attach (GTK_TABLE (table), valid_hbox, 1, 3, 1, 2, (GtkAttachOptions) (GTK_FILL | GTK_EXPAND), (GtkAttachOptions) (GTK_FILL), 0, 0); appGUI->opt->global_notification_cmd_entry = gtk_entry_new (); gtk_widget_show (appGUI->opt->global_notification_cmd_entry); g_signal_connect (G_OBJECT (appGUI->opt->global_notification_cmd_entry), "key_release_event", G_CALLBACK (global_notification_entry_key_release_cb), appGUI); gtk_box_pack_start (GTK_BOX (valid_hbox), appGUI->opt->global_notification_cmd_entry, TRUE, TRUE, 0); appGUI->opt->global_notification_valid_image = gtk_image_new (); gtk_widget_show (appGUI->opt->global_notification_valid_image); gtk_box_pack_start (GTK_BOX (valid_hbox), appGUI->opt->global_notification_valid_image, FALSE, FALSE, 0); }
GtkWidget *create_hdhomerun_config(void) { GtkWidget *hdhomerun_config; GtkWidget *hbox1; GtkWidget *frame1; GtkWidget *vbox2; GtkWidget *scrolledwindow1; GtkWidget *DeviceListTree; GtkWidget *RescanBtn; GtkWidget *label1; GtkWidget *Tab; GtkWidget *vbox1; GtkWidget *frame2; GtkWidget *table2; GtkWidget *label11; GtkWidget *label12; GtkWidget *label13; GtkWidget *LaunchVlcBtn; GtkWidget *StopVlcBtn; GtkWidget *hbox2; GtkWidget *ChannelMapEdit; GtkObject *ChannelNumberSpin_adj; GtkWidget *ChannelNumberSpin; GtkWidget *ProgramList; GtkWidget *ScanDownBtn; GtkWidget *ScanUpBtn; GtkWidget *label15; GtkWidget *frame3; GtkWidget *table1; GtkWidget *label5; GtkWidget *label6; GtkWidget *label7; GtkWidget *label8; GtkWidget *SignalStrengthStatus; GtkWidget *SignalQualityStatus; GtkWidget *SymbolQualityStatus; GtkWidget *PhysicalChannelStatus; GtkWidget *label10; GtkWidget *NetworkRateStatus; GtkWidget *label4; GtkWidget *label2; GtkWidget *vbox3; GtkWidget *frame4; GtkWidget *table3; GtkWidget *FirmwareVersion; GtkWidget *UpgradeBtn; GtkWidget *hbox3; GtkWidget *UpgradeFilename; GtkWidget *UpgradeFilenameBtn; GtkWidget *label14; GtkWidget *label3; hdhomerun_config = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(hdhomerun_config), _("HDHomeRun Config")); gtk_window_set_resizable(GTK_WINDOW(hdhomerun_config), FALSE); hbox1 = gtk_hbox_new(FALSE, 6); gtk_widget_show(hbox1); gtk_container_add(GTK_CONTAINER(hdhomerun_config), hbox1); gtk_container_set_border_width(GTK_CONTAINER(hbox1), 3); frame1 = gtk_frame_new(NULL); gtk_widget_show(frame1); gtk_box_pack_start(GTK_BOX(hbox1), frame1, TRUE, TRUE, 0); vbox2 = gtk_vbox_new(FALSE, 3); gtk_widget_show(vbox2); gtk_container_add(GTK_CONTAINER(frame1), vbox2); gtk_container_set_border_width(GTK_CONTAINER(vbox2), 3); scrolledwindow1 = gtk_scrolled_window_new(NULL, NULL); gtk_widget_show(scrolledwindow1); gtk_box_pack_start(GTK_BOX(vbox2), scrolledwindow1, TRUE, TRUE, 0); DeviceListTree = gtk_tree_view_new(); gtk_widget_show(DeviceListTree); gtk_container_add(GTK_CONTAINER(scrolledwindow1), DeviceListTree); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(DeviceListTree), FALSE); gtk_tree_view_set_enable_search(GTK_TREE_VIEW(DeviceListTree), FALSE); RescanBtn = gtk_button_new_with_mnemonic(_("_Rescan")); gtk_widget_show(RescanBtn); gtk_box_pack_start(GTK_BOX(vbox2), RescanBtn, FALSE, FALSE, 0); label1 = gtk_label_new(_("Device")); gtk_widget_show(label1); gtk_frame_set_label_widget(GTK_FRAME(frame1), label1); gtk_label_set_use_markup(GTK_LABEL(label1), TRUE); gtk_misc_set_padding(GTK_MISC(label1), 3, 0); Tab = gtk_notebook_new(); gtk_widget_show(Tab); gtk_box_pack_start(GTK_BOX(hbox1), Tab, TRUE, TRUE, 0); vbox1 = gtk_vbox_new(FALSE, 0); gtk_widget_show(vbox1); gtk_container_add(GTK_CONTAINER(Tab), vbox1); frame2 = gtk_frame_new(NULL); gtk_widget_show(frame2); gtk_box_pack_start(GTK_BOX(vbox1), frame2, TRUE, TRUE, 0); gtk_container_set_border_width(GTK_CONTAINER(frame2), 3); table2 = gtk_table_new(3, 4, TRUE); gtk_widget_show(table2); gtk_container_add(GTK_CONTAINER(frame2), table2); gtk_container_set_border_width(GTK_CONTAINER(table2), 6); gtk_table_set_row_spacings(GTK_TABLE(table2), 3); gtk_table_set_col_spacings(GTK_TABLE(table2), 3); label11 = gtk_label_new(_("Channel")); gtk_widget_show(label11); gtk_table_attach(GTK_TABLE(table2), label11, 0, 1, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); label12 = gtk_label_new(_("Program")); gtk_widget_show(label12); gtk_table_attach(GTK_TABLE(table2), label12, 0, 1, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); label13 = gtk_label_new(_("Scan")); gtk_widget_show(label13); gtk_table_attach(GTK_TABLE(table2), label13, 0, 1, 2, 3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); LaunchVlcBtn = gtk_button_new_with_mnemonic(_("_View")); gtk_widget_show(LaunchVlcBtn); gtk_table_attach(GTK_TABLE(table2), LaunchVlcBtn, 3, 4, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); StopVlcBtn = gtk_button_new_with_mnemonic(_("_Stop")); gtk_widget_show(StopVlcBtn); gtk_table_attach(GTK_TABLE(table2), StopVlcBtn, 3, 4, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); gtk_widget_set_sensitive(StopVlcBtn, FALSE); hbox2 = gtk_hbox_new(FALSE, 3); gtk_widget_show(hbox2); gtk_table_attach(GTK_TABLE(table2), hbox2, 1, 3, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); ChannelMapEdit = gtk_combo_box_new_text(); gtk_widget_show(ChannelMapEdit); gtk_box_pack_start(GTK_BOX(hbox2), ChannelMapEdit, TRUE, TRUE, 0); ChannelNumberSpin_adj = gtk_adjustment_new(0, 0, 300, 1, 10, 0); ChannelNumberSpin = gtk_spin_button_new(GTK_ADJUSTMENT(ChannelNumberSpin_adj), 1, 0); gtk_widget_show(ChannelNumberSpin); gtk_box_pack_start(GTK_BOX(hbox2), ChannelNumberSpin, FALSE, FALSE, 0); gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(ChannelNumberSpin), TRUE); gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(ChannelNumberSpin), TRUE); ProgramList = gtk_combo_box_new_text(); gtk_widget_show(ProgramList); gtk_table_attach(GTK_TABLE(table2), ProgramList, 1, 3, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); ScanDownBtn = gtk_toggle_button_new_with_mnemonic("_<<-"); gtk_widget_show(ScanDownBtn); gtk_table_attach(GTK_TABLE(table2), ScanDownBtn, 1, 2, 2, 3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); ScanUpBtn = gtk_toggle_button_new_with_mnemonic("->_>"); gtk_widget_show(ScanUpBtn); gtk_table_attach(GTK_TABLE(table2), ScanUpBtn, 2, 3, 2, 3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); label15 = gtk_label_new(_("Configuration")); gtk_widget_show(label15); gtk_frame_set_label_widget(GTK_FRAME(frame2), label15); gtk_label_set_use_markup(GTK_LABEL(label15), TRUE); gtk_misc_set_padding(GTK_MISC(label15), 3, 0); frame3 = gtk_frame_new(NULL); gtk_widget_show(frame3); gtk_box_pack_start(GTK_BOX(vbox1), frame3, TRUE, TRUE, 0); gtk_container_set_border_width(GTK_CONTAINER(frame3), 3); table1 = gtk_table_new(6, 2, FALSE); gtk_widget_show(table1); gtk_container_add(GTK_CONTAINER(frame3), table1); gtk_container_set_border_width(GTK_CONTAINER(table1), 6); gtk_table_set_row_spacings(GTK_TABLE(table1), 2); gtk_table_set_col_spacings(GTK_TABLE(table1), 2); label5 = gtk_label_new(_("Physical Channel")); gtk_widget_show(label5); gtk_table_attach(GTK_TABLE(table1), label5, 0, 1, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); label6 = gtk_label_new(_("Signal Strength %")); gtk_widget_show(label6); gtk_table_attach(GTK_TABLE(table1), label6, 0, 1, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); label7 = gtk_label_new(_("Signal Quality %")); gtk_widget_show(label7); gtk_table_attach(GTK_TABLE(table1), label7, 0, 1, 2, 3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); label8 = gtk_label_new(_("Symbol Quality %")); gtk_widget_show(label8); gtk_table_attach(GTK_TABLE(table1), label8, 0, 1, 3, 4, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); SignalStrengthStatus = gtk_progress_bar_new(); gtk_widget_show(SignalStrengthStatus); gtk_table_attach(GTK_TABLE(table1), SignalStrengthStatus, 1, 2, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); SignalQualityStatus = gtk_progress_bar_new(); gtk_widget_show(SignalQualityStatus); gtk_table_attach(GTK_TABLE(table1), SignalQualityStatus, 1, 2, 2, 3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); SymbolQualityStatus = gtk_progress_bar_new(); gtk_widget_show(SymbolQualityStatus); gtk_table_attach(GTK_TABLE(table1), SymbolQualityStatus, 1, 2, 3, 4, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); PhysicalChannelStatus = gtk_entry_new(); gtk_widget_show(PhysicalChannelStatus); gtk_table_attach(GTK_TABLE(table1), PhysicalChannelStatus, 1, 2, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_widget_set_sensitive(PhysicalChannelStatus, FALSE); GTK_WIDGET_UNSET_FLAGS(PhysicalChannelStatus, GTK_CAN_FOCUS); gtk_editable_set_editable(GTK_EDITABLE(PhysicalChannelStatus), FALSE); gtk_entry_set_text(GTK_ENTRY(PhysicalChannelStatus), _("none")); gtk_entry_set_invisible_char(GTK_ENTRY(PhysicalChannelStatus), 9679); label10 = gtk_label_new(_("Network Rate")); gtk_widget_show(label10); gtk_table_attach(GTK_TABLE(table1), label10, 0, 1, 4, 5, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); NetworkRateStatus = gtk_entry_new(); gtk_widget_show(NetworkRateStatus); gtk_table_attach(GTK_TABLE(table1), NetworkRateStatus, 1, 2, 4, 5, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_widget_set_sensitive(NetworkRateStatus, FALSE); GTK_WIDGET_UNSET_FLAGS(NetworkRateStatus, GTK_CAN_FOCUS); gtk_editable_set_editable(GTK_EDITABLE(NetworkRateStatus), FALSE); gtk_entry_set_text(GTK_ENTRY(NetworkRateStatus), _("0.000 Mbps")); gtk_entry_set_invisible_char(GTK_ENTRY(NetworkRateStatus), 9679); label4 = gtk_label_new(_("Status")); gtk_widget_show(label4); gtk_frame_set_label_widget(GTK_FRAME(frame3), label4); gtk_label_set_use_markup(GTK_LABEL(label4), TRUE); gtk_misc_set_padding(GTK_MISC(label4), 3, 0); label2 = gtk_label_new(_("Tuner")); gtk_widget_show(label2); gtk_notebook_set_tab_label(GTK_NOTEBOOK(Tab), gtk_notebook_get_nth_page(GTK_NOTEBOOK(Tab), 0), label2); vbox3 = gtk_vbox_new(FALSE, 0); gtk_widget_show(vbox3); gtk_container_add(GTK_CONTAINER(Tab), vbox3); frame4 = gtk_frame_new(NULL); gtk_widget_show(frame4); gtk_box_pack_start(GTK_BOX(vbox3), frame4, FALSE, TRUE, 0); gtk_container_set_border_width(GTK_CONTAINER(frame4), 3); table3 = gtk_table_new(2, 2, FALSE); gtk_widget_show(table3); gtk_container_add(GTK_CONTAINER(frame4), table3); gtk_container_set_border_width(GTK_CONTAINER(table3), 3); gtk_table_set_row_spacings(GTK_TABLE(table3), 3); gtk_table_set_col_spacings(GTK_TABLE(table3), 3); FirmwareVersion = gtk_label_new(""); gtk_widget_show(FirmwareVersion); gtk_table_attach(GTK_TABLE(table3), FirmwareVersion, 0, 1, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); gtk_misc_set_alignment(GTK_MISC(FirmwareVersion), 0, 0.5); UpgradeBtn = gtk_button_new_with_mnemonic(_("Upgrade")); gtk_widget_show(UpgradeBtn); gtk_table_attach(GTK_TABLE(table3), UpgradeBtn, 1, 2, 1, 2, (GtkAttachOptions) (0), (GtkAttachOptions) (0), 0, 0); gtk_widget_set_sensitive(UpgradeBtn, FALSE); hbox3 = gtk_hbox_new(FALSE, 3); gtk_widget_show(hbox3); gtk_table_attach(GTK_TABLE(table3), hbox3, 0, 2, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); UpgradeFilename = gtk_entry_new(); gtk_widget_show(UpgradeFilename); gtk_box_pack_start(GTK_BOX(hbox3), UpgradeFilename, TRUE, TRUE, 0); gtk_entry_set_invisible_char(GTK_ENTRY(UpgradeFilename), 9679); UpgradeFilenameBtn = gtk_button_new_with_mnemonic("..."); gtk_widget_show(UpgradeFilenameBtn); gtk_box_pack_start(GTK_BOX(hbox3), UpgradeFilenameBtn, FALSE, FALSE, 0); label14 = gtk_label_new(_("Upgrade")); gtk_widget_show(label14); gtk_frame_set_label_widget(GTK_FRAME(frame4), label14); gtk_misc_set_padding(GTK_MISC(label14), 3, 0); label3 = gtk_label_new(_("Upgrade")); gtk_widget_show(label3); gtk_notebook_set_tab_label(GTK_NOTEBOOK(Tab), gtk_notebook_get_nth_page(GTK_NOTEBOOK(Tab), 1), label3); g_signal_connect((gpointer) hdhomerun_config, "destroy", G_CALLBACK(gtk_main_quit), NULL); g_signal_connect((gpointer) hdhomerun_config, "key_press_event", G_CALLBACK(on_hdhomerun_config_key_press_event), NULL); g_signal_connect((gpointer) RescanBtn, "clicked", G_CALLBACK(on_RescanBtn_clicked), NULL); g_signal_connect_after((gpointer) Tab, "switch_page", G_CALLBACK(on_Tab_switch_page), NULL); g_signal_connect((gpointer) LaunchVlcBtn, "clicked", G_CALLBACK(on_LaunchVlcBtn_clicked), NULL); g_signal_connect((gpointer) StopVlcBtn, "clicked", G_CALLBACK(on_StopVlcBtn_clicked), NULL); g_signal_connect((gpointer) ChannelMapEdit, "changed", G_CALLBACK(on_ChannelMapEdit_changed), NULL); g_signal_connect((gpointer) ChannelNumberSpin, "value_changed", G_CALLBACK(on_ChannelNumberSpin_value_changed), NULL); g_signal_connect_after((gpointer) ChannelNumberSpin, "activate", G_CALLBACK(on_ChannelNumberSpin_activate), NULL); g_signal_connect((gpointer) ProgramList, "changed", G_CALLBACK(on_ProgramList_changed), NULL); g_signal_connect((gpointer) ScanDownBtn, "clicked", G_CALLBACK(on_ScanDownBtn_clicked), NULL); g_signal_connect((gpointer) ScanUpBtn, "clicked", G_CALLBACK(on_ScanUpBtn_clicked), NULL); g_signal_connect((gpointer) UpgradeBtn, "clicked", G_CALLBACK(on_UpgradeBtn_clicked), NULL); g_signal_connect((gpointer) UpgradeFilename, "changed", G_CALLBACK(on_UpgradeFilename_changed), NULL); g_signal_connect((gpointer) UpgradeFilenameBtn, "clicked", G_CALLBACK(on_UpgradeFilenameBtn_clicked), NULL); /* Store pointers to all widgets, for use by lookup_widget(). */ GLADE_HOOKUP_OBJECT_NO_REF(hdhomerun_config, hdhomerun_config, "hdhomerun_config"); GLADE_HOOKUP_OBJECT(hdhomerun_config, hbox1, "hbox1"); GLADE_HOOKUP_OBJECT(hdhomerun_config, frame1, "frame1"); GLADE_HOOKUP_OBJECT(hdhomerun_config, vbox2, "vbox2"); GLADE_HOOKUP_OBJECT(hdhomerun_config, scrolledwindow1, "scrolledwindow1"); GLADE_HOOKUP_OBJECT(hdhomerun_config, DeviceListTree, "DeviceListTree"); GLADE_HOOKUP_OBJECT(hdhomerun_config, RescanBtn, "RescanBtn"); GLADE_HOOKUP_OBJECT(hdhomerun_config, label1, "label1"); GLADE_HOOKUP_OBJECT(hdhomerun_config, Tab, "Tab"); GLADE_HOOKUP_OBJECT(hdhomerun_config, vbox1, "vbox1"); GLADE_HOOKUP_OBJECT(hdhomerun_config, frame2, "frame2"); GLADE_HOOKUP_OBJECT(hdhomerun_config, table2, "table2"); GLADE_HOOKUP_OBJECT(hdhomerun_config, label11, "label11"); GLADE_HOOKUP_OBJECT(hdhomerun_config, label12, "label12"); GLADE_HOOKUP_OBJECT(hdhomerun_config, label13, "label13"); GLADE_HOOKUP_OBJECT(hdhomerun_config, LaunchVlcBtn, "LaunchVlcBtn"); GLADE_HOOKUP_OBJECT(hdhomerun_config, StopVlcBtn, "StopVlcBtn"); GLADE_HOOKUP_OBJECT(hdhomerun_config, hbox2, "hbox2"); GLADE_HOOKUP_OBJECT(hdhomerun_config, ChannelMapEdit, "ChannelMapEdit"); GLADE_HOOKUP_OBJECT(hdhomerun_config, ChannelNumberSpin, "ChannelNumberSpin"); GLADE_HOOKUP_OBJECT(hdhomerun_config, ProgramList, "ProgramList"); GLADE_HOOKUP_OBJECT(hdhomerun_config, ScanDownBtn, "ScanDownBtn"); GLADE_HOOKUP_OBJECT(hdhomerun_config, ScanUpBtn, "ScanUpBtn"); GLADE_HOOKUP_OBJECT(hdhomerun_config, label15, "label15"); GLADE_HOOKUP_OBJECT(hdhomerun_config, frame3, "frame3"); GLADE_HOOKUP_OBJECT(hdhomerun_config, table1, "table1"); GLADE_HOOKUP_OBJECT(hdhomerun_config, label5, "label5"); GLADE_HOOKUP_OBJECT(hdhomerun_config, label6, "label6"); GLADE_HOOKUP_OBJECT(hdhomerun_config, label7, "label7"); GLADE_HOOKUP_OBJECT(hdhomerun_config, label8, "label8"); GLADE_HOOKUP_OBJECT(hdhomerun_config, SignalStrengthStatus, "SignalStrengthStatus"); GLADE_HOOKUP_OBJECT(hdhomerun_config, SignalQualityStatus, "SignalQualityStatus"); GLADE_HOOKUP_OBJECT(hdhomerun_config, SymbolQualityStatus, "SymbolQualityStatus"); GLADE_HOOKUP_OBJECT(hdhomerun_config, PhysicalChannelStatus, "PhysicalChannelStatus"); GLADE_HOOKUP_OBJECT(hdhomerun_config, label10, "label10"); GLADE_HOOKUP_OBJECT(hdhomerun_config, NetworkRateStatus, "NetworkRateStatus"); GLADE_HOOKUP_OBJECT(hdhomerun_config, label4, "label4"); GLADE_HOOKUP_OBJECT(hdhomerun_config, label2, "label2"); GLADE_HOOKUP_OBJECT(hdhomerun_config, vbox3, "vbox3"); GLADE_HOOKUP_OBJECT(hdhomerun_config, frame4, "frame4"); GLADE_HOOKUP_OBJECT(hdhomerun_config, table3, "table3"); GLADE_HOOKUP_OBJECT(hdhomerun_config, FirmwareVersion, "FirmwareVersion"); GLADE_HOOKUP_OBJECT(hdhomerun_config, UpgradeBtn, "UpgradeBtn"); GLADE_HOOKUP_OBJECT(hdhomerun_config, hbox3, "hbox3"); GLADE_HOOKUP_OBJECT(hdhomerun_config, UpgradeFilename, "UpgradeFilename"); GLADE_HOOKUP_OBJECT(hdhomerun_config, UpgradeFilenameBtn, "UpgradeFilenameBtn"); GLADE_HOOKUP_OBJECT(hdhomerun_config, label14, "label14"); GLADE_HOOKUP_OBJECT(hdhomerun_config, label3, "label3"); return hdhomerun_config; }
void pevent_dialog_show () { GtkWidget *vbox, *hbox, *tbox, *wid, *bh, *th; GtkListStore *store, *hstore; GtkTreeSelection *sel; if (pevent_dialog) { mg_bring_tofront (pevent_dialog); return; } pevent_dialog = mg_create_generic_tab ("edit events", _("Edit Events"), TRUE, FALSE, pevent_dialog_close, NULL, 600, 455, &vbox, 0); wid = gtk_vpaned_new (); th = gtk_vbox_new (0, 2); bh = gtk_vbox_new (0, 2); gtk_widget_show (th); gtk_widget_show (bh); gtk_paned_pack1 (GTK_PANED (wid), th, 1, 1); gtk_paned_pack2 (GTK_PANED (wid), bh, 0, 1); gtk_box_pack_start (GTK_BOX (vbox), wid, 1, 1, 0); gtk_widget_show (wid); store = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT); pevent_dialog_list = gtkutil_treeview_new (th, GTK_TREE_MODEL (store), NULL, COL_EVENT_NAME, _("Event"), COL_EVENT_TEXT, _("Text"), -1); sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (pevent_dialog_list)); g_signal_connect (G_OBJECT (sel), "changed", G_CALLBACK (pevent_dialog_select), store); pevent_dialog_twid = gtk_xtext_new (colors, 0); gtk_xtext_set_tint (GTK_XTEXT (pevent_dialog_twid), prefs.hex_text_tint_red, prefs.hex_text_tint_green, prefs.hex_text_tint_blue); gtk_xtext_set_background (GTK_XTEXT (pevent_dialog_twid), channelwin_pix, prefs.hex_text_transparent); pevent_dialog_entry = gtk_entry_new_with_max_length (255); g_signal_connect (G_OBJECT (pevent_dialog_entry), "activate", G_CALLBACK (pevent_dialog_update), pevent_dialog_twid); gtk_box_pack_start (GTK_BOX (bh), pevent_dialog_entry, 0, 0, 0); gtk_widget_show (pevent_dialog_entry); tbox = gtk_hbox_new (0, 0); gtk_container_add (GTK_CONTAINER (bh), tbox); gtk_widget_show (tbox); gtk_widget_set_usize (pevent_dialog_twid, 150, 20); gtk_container_add (GTK_CONTAINER (tbox), pevent_dialog_twid); gtk_xtext_set_font (GTK_XTEXT (pevent_dialog_twid), prefs.hex_text_font); wid = gtk_vscrollbar_new (GTK_XTEXT (pevent_dialog_twid)->adj); gtk_box_pack_start (GTK_BOX (tbox), wid, FALSE, FALSE, 0); show_and_unfocus (wid); gtk_widget_show (pevent_dialog_twid); hstore = gtk_list_store_new (2, G_TYPE_INT, G_TYPE_STRING); pevent_dialog_hlist = gtkutil_treeview_new (bh, GTK_TREE_MODEL (hstore), NULL, 0, _("$ Number"), 1, _("Description"), -1); gtk_widget_show (pevent_dialog_hlist); pevent_dialog_fill (pevent_dialog_list); gtk_widget_show (pevent_dialog_list); hbox = gtk_hbutton_box_new (); gtk_box_pack_end (GTK_BOX (vbox), hbox, 0, 0, 2); /*wid = gtk_button_new_with_label (_("Save")); gtk_box_pack_end (GTK_BOX (hbox), wid, 0, 0, 0); gtk_signal_connect (GTK_OBJECT (wid), "clicked", GTK_SIGNAL_FUNC (pevent_save_cb), NULL); gtk_widget_show (wid);*/ gtkutil_button (hbox, GTK_STOCK_SAVE_AS, NULL, pevent_save_cb, (void *) 1, _("Save As...")); gtkutil_button (hbox, GTK_STOCK_OPEN, NULL, pevent_load_cb, (void *) 0, _("Load From...")); wid = gtk_button_new_with_label (_("Test All")); gtk_box_pack_end (GTK_BOX (hbox), wid, 0, 0, 0); g_signal_connect (G_OBJECT (wid), "clicked", G_CALLBACK (pevent_test_cb), pevent_dialog_twid); gtk_widget_show (wid); wid = gtk_button_new_from_stock (GTK_STOCK_OK); gtk_box_pack_start (GTK_BOX (hbox), wid, 0, 0, 0); g_signal_connect (G_OBJECT (wid), "clicked", G_CALLBACK (pevent_ok_cb), NULL); gtk_widget_show (wid); gtk_widget_show (hbox); gtk_widget_show (pevent_dialog); }
GtkWidget * create_Equalizer( void ) { GtkWidget * vbox1; GtkWidget * hbox1; GtkWidget * scrolledwindow1; GtkWidget * table1; GtkWidget * hbuttonbox1; GtkAccelGroup * accel_group; accel_group=gtk_accel_group_new(); Equalizer=gtk_window_new( GTK_WINDOW_TOPLEVEL ); gtk_widget_set_name( Equalizer,MSGTR_Equalizer ); gtk_object_set_data( GTK_OBJECT( Equalizer ),MSGTR_Equalizer,Equalizer ); gtk_widget_set_usize( Equalizer,-1,256 ); gtk_window_set_title( GTK_WINDOW( Equalizer ),MSGTR_Equalizer ); gtk_window_set_position( GTK_WINDOW( Equalizer ),GTK_WIN_POS_CENTER ); gtk_window_set_policy( GTK_WINDOW( Equalizer ),FALSE,FALSE,FALSE ); gtk_window_set_wmclass( GTK_WINDOW( Equalizer ),"Equalizer","MPlayer" ); gtk_widget_realize( Equalizer ); gtkAddIcon( Equalizer ); vbox1=AddVBox( AddDialogFrame( Equalizer ),0 ); Notebook=gtk_notebook_new(); gtk_widget_set_name( Notebook,"Notebook" ); gtk_widget_show( Notebook ); gtk_box_pack_start( GTK_BOX( vbox1 ),Notebook,TRUE,TRUE,0 ); gtk_container_set_border_width( GTK_CONTAINER( Notebook ),1 ); hbox1=AddHBox( Notebook,0 ); scrolledwindow1=gtk_scrolled_window_new( NULL,NULL ); gtk_widget_set_name( scrolledwindow1,"scrolledwindow1" ); gtk_widget_show( scrolledwindow1 ); gtk_box_pack_start( GTK_BOX( hbox1 ),scrolledwindow1,FALSE,FALSE,0 ); gtk_widget_set_usize( scrolledwindow1,106,-2 ); gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( scrolledwindow1 ),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC ); ChannelsList=gtk_clist_new( 1 ); gtk_widget_set_name( ChannelsList,"ChannelsList" ); gtk_widget_show( ChannelsList ); gtk_container_add( GTK_CONTAINER( scrolledwindow1 ),ChannelsList ); gtk_clist_set_column_width( GTK_CLIST( ChannelsList ),0,80 ); gtk_clist_column_titles_hide( GTK_CLIST( ChannelsList ) ); table1=gtk_table_new( 2,10,FALSE ); gtk_widget_set_name( table1,"table1" ); gtk_widget_show( table1 ); gtk_box_pack_start( GTK_BOX( hbox1 ),table1,FALSE,FALSE,0 ); gtk_table_set_row_spacings( GTK_TABLE( table1 ),4 ); gtk_table_set_col_spacings( GTK_TABLE( table1 ),9 ); A3125adj=GTK_ADJUSTMENT( gtk_adjustment_new( 0,-eqRange,eqRange,0.5,0,0 ) ); A3125=AddVScaler( A3125adj,NULL,-1 ); gtk_table_attach( GTK_TABLE( table1 ),A3125,0,1,0,1,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),0,0 ); A6250adj=GTK_ADJUSTMENT( gtk_adjustment_new( 0,-eqRange,eqRange,0.5,0,0 ) ); A6250=AddVScaler( A6250adj,NULL,-1 ); gtk_table_attach( GTK_TABLE( table1 ),A6250,1,2,0,1,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),0,0 ); A125adj=GTK_ADJUSTMENT( gtk_adjustment_new( 0,-eqRange,eqRange,0.5,0,0 ) ); A125=AddVScaler( A125adj,NULL,-1 ); gtk_table_attach( GTK_TABLE( table1 ),A125,2,3,0,1,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),0,0 ); A250adj=GTK_ADJUSTMENT( gtk_adjustment_new( 0,-eqRange,eqRange,0.5,0,0 ) ); A250=AddVScaler( A250adj,NULL,-1 ); gtk_table_attach( GTK_TABLE( table1 ),A250,3,4,0,1,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),0,0 ); A500adj=GTK_ADJUSTMENT( gtk_adjustment_new( 0,-eqRange,eqRange,0.5,0,0 ) ); A500=AddVScaler( A500adj,NULL,-1 ); gtk_table_attach( GTK_TABLE( table1 ),A500,4,5,0,1,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),0,0 ); A1000adj=GTK_ADJUSTMENT( gtk_adjustment_new( 0,-eqRange,eqRange,0.5,0,0 ) ); A1000=AddVScaler( A1000adj,NULL,-1 ); gtk_table_attach( GTK_TABLE( table1 ),A1000,5,6,0,1,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),0,0 ); A2000adj=GTK_ADJUSTMENT( gtk_adjustment_new( 0,-eqRange,eqRange,0.5,0,0 ) ); A2000=AddVScaler( A2000adj,NULL,-1 ); gtk_table_attach( GTK_TABLE( table1 ),A2000,6,7,0,1,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),0,0 ); A4000adj=GTK_ADJUSTMENT( gtk_adjustment_new( 0,-eqRange,eqRange,0.5,0,0 ) ); A4000=AddVScaler( A4000adj,NULL,-1 ); gtk_table_attach( GTK_TABLE( table1 ),A4000,7,8,0,1,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),0,0 ); A8000adj=GTK_ADJUSTMENT( gtk_adjustment_new( 0,-eqRange,eqRange,0.5,0,0 ) ); A8000=AddVScaler( A8000adj,NULL,-1 ); gtk_table_attach( GTK_TABLE( table1 ),A8000,8,9,0,1,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),0,0 ); A16000adj=GTK_ADJUSTMENT( gtk_adjustment_new( 0,-eqRange,eqRange,0.5,0,0 ) ); A16000=AddVScaler( A16000adj,NULL,-1 ); gtk_table_attach( GTK_TABLE( table1 ),A16000,9,10,0,1,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),0,0 ); gtk_table_attach( GTK_TABLE( table1 ), AddLabel( "31.25",NULL ), 0,1,1,2,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 ); gtk_table_attach( GTK_TABLE( table1 ), AddLabel( "62.50",NULL ), 1,2,1,2,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 ); gtk_table_attach( GTK_TABLE( table1 ), AddLabel( "125",NULL ), 2,3,1,2,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 ); gtk_table_attach( GTK_TABLE( table1 ), AddLabel( "250",NULL ), 3,4,1,2,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 ); gtk_table_attach( GTK_TABLE( table1 ), AddLabel( "500",NULL ), 4,5,1,2,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 ); gtk_table_attach( GTK_TABLE( table1 ), AddLabel( "1000",NULL ), 5,6,1,2,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 ); gtk_table_attach( GTK_TABLE( table1 ), AddLabel( "2000",NULL ), 6,7,1,2,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 ); gtk_table_attach( GTK_TABLE( table1 ), AddLabel( "4000",NULL ), 7,8,1,2,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 ); gtk_table_attach( GTK_TABLE( table1 ), AddLabel( "8000",NULL ), 8,9,1,2,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 ); gtk_table_attach( GTK_TABLE( table1 ), AddLabel( "16000",NULL ), 9,10,1,2,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 ); gtk_notebook_set_tab_label( GTK_NOTEBOOK( Notebook ),gtk_notebook_get_nth_page( GTK_NOTEBOOK( Notebook ),0 ), AddLabel( MSGTR_EQU_Audio,NULL ) ); table1=gtk_table_new( 4,2,FALSE ); gtk_widget_set_name( table1,"table1" ); gtk_widget_show( table1 ); gtk_container_add( GTK_CONTAINER( Notebook ),table1 ); gtk_table_attach( GTK_TABLE( table1 ), AddLabel( MSGTR_EQU_Contrast,NULL ), 0,1,0,1,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 ); gtk_table_attach( GTK_TABLE( table1 ), AddLabel( MSGTR_EQU_Brightness,NULL ), 0,1,1,2,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 ); gtk_table_attach( GTK_TABLE( table1 ), AddLabel( MSGTR_EQU_Hue,NULL ), 0,1,2,3,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 ); gtk_table_attach( GTK_TABLE( table1 ), AddLabel( MSGTR_EQU_Saturation,NULL ), 0,1,3,4,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 ); VContrastadj=GTK_ADJUSTMENT( gtk_adjustment_new( 0,-100,100,1,0,0 ) ); VContrast=AddHScaler( VContrastadj,NULL,1 ); gtk_table_attach( GTK_TABLE( table1 ),VContrast,1,2,0,1,(GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 ); gtk_widget_set_usize( VContrast,-1,45 ); VBrightnessadj=GTK_ADJUSTMENT( gtk_adjustment_new( 0,-100,100,1,0,0 ) ); VBrightness=AddHScaler( VBrightnessadj,NULL,1 ); gtk_table_attach( GTK_TABLE( table1 ),VBrightness,1,2,1,2,(GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 ); gtk_widget_set_usize( VBrightness,-1,45 ); VHueadj=GTK_ADJUSTMENT( gtk_adjustment_new( 0,-100,100,1,0,0 ) ); VHue=AddHScaler( VHueadj,NULL,1 ); gtk_table_attach( GTK_TABLE( table1 ),VHue,1,2,2,3,(GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 ); gtk_widget_set_usize( VHue,-1,45 ); VSaturationadj=GTK_ADJUSTMENT( gtk_adjustment_new( 0,-100,100,1,0,0 ) ); VSaturation=AddHScaler( VSaturationadj,NULL,1 ); gtk_table_attach( GTK_TABLE( table1 ),VSaturation,1,2,3,4,(GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 ); gtk_widget_set_usize( VSaturation,-1,45 ); gtk_notebook_set_tab_label( GTK_NOTEBOOK( Notebook ),gtk_notebook_get_nth_page( GTK_NOTEBOOK( Notebook ),1 ), AddLabel( MSGTR_EQU_Video,NULL ) ); AddHSeparator( vbox1 ); hbuttonbox1=AddHButtonBox( vbox1 ); gtk_button_box_set_layout( GTK_BUTTON_BOX( hbuttonbox1 ),GTK_BUTTONBOX_END ); gtk_button_box_set_spacing( GTK_BUTTON_BOX( hbuttonbox1 ),10 ); Config=AddButton( MSGTR_Config,hbuttonbox1 ); Clear=AddButton( MSGTR_Clear,hbuttonbox1 ); Ok=AddButton( MSGTR_Ok,hbuttonbox1 ); gtk_widget_add_accelerator( Ok,"clicked",accel_group,GDK_Escape,0,GTK_ACCEL_VISIBLE ); gtk_widget_add_accelerator( Ok,"clicked",accel_group,GDK_Return,0,GTK_ACCEL_VISIBLE ); gtk_signal_connect( GTK_OBJECT( Equalizer ),"destroy",GTK_SIGNAL_FUNC( WidgetDestroy ),&Equalizer ); gtk_signal_connect( GTK_OBJECT( Equalizer ),"focus_in_event",GTK_SIGNAL_FUNC( eqFocus ),(void *)2 ); gtk_signal_connect( GTK_OBJECT( ChannelsList ),"select_row",GTK_SIGNAL_FUNC( eqSelectChannelsListRow ),NULL ); gtk_signal_connect( GTK_OBJECT( A3125 ),"motion_notify_event",GTK_SIGNAL_FUNC( eqHScaleMotion ),(void*)0 ); gtk_signal_connect( GTK_OBJECT( A6250 ),"motion_notify_event",GTK_SIGNAL_FUNC( eqHScaleMotion ),(void*)1 ); gtk_signal_connect( GTK_OBJECT( A125 ),"motion_notify_event",GTK_SIGNAL_FUNC( eqHScaleMotion ),(void*)2 ); gtk_signal_connect( GTK_OBJECT( A250 ),"motion_notify_event",GTK_SIGNAL_FUNC( eqHScaleMotion ),(void*)3 ); gtk_signal_connect( GTK_OBJECT( A500 ),"motion_notify_event",GTK_SIGNAL_FUNC( eqHScaleMotion ),(void*)4 ); gtk_signal_connect( GTK_OBJECT( A1000 ),"motion_notify_event",GTK_SIGNAL_FUNC( eqHScaleMotion ),(void*)5 ); gtk_signal_connect( GTK_OBJECT( A2000 ),"motion_notify_event",GTK_SIGNAL_FUNC( eqHScaleMotion ),(void*)6 ); gtk_signal_connect( GTK_OBJECT( A4000 ),"motion_notify_event",GTK_SIGNAL_FUNC( eqHScaleMotion ),(void*)7 ); gtk_signal_connect( GTK_OBJECT( A8000 ),"motion_notify_event",GTK_SIGNAL_FUNC( eqHScaleMotion ),(void*)8 ); gtk_signal_connect( GTK_OBJECT( A16000 ),"motion_notify_event",GTK_SIGNAL_FUNC( eqHScaleMotion ),(void*)9 ); gtk_signal_connect( GTK_OBJECT( VContrast ),"motion_notify_event",GTK_SIGNAL_FUNC( eqVScaleMotion ),(void*)1 ); gtk_signal_connect( GTK_OBJECT( VBrightness ),"motion_notify_event",GTK_SIGNAL_FUNC( eqVScaleMotion ),(void*)2 ); gtk_signal_connect( GTK_OBJECT( VHue ),"motion_notify_event",GTK_SIGNAL_FUNC( eqVScaleMotion ),(void*)3 ); gtk_signal_connect( GTK_OBJECT( VSaturation ),"motion_notify_event",GTK_SIGNAL_FUNC( eqVScaleMotion ),(void *)4 ); gtk_signal_connect( GTK_OBJECT( Ok ),"clicked",GTK_SIGNAL_FUNC( eqButtonReleased ),(void *)0 ); gtk_signal_connect( GTK_OBJECT( Clear ),"clicked",GTK_SIGNAL_FUNC( eqButtonReleased ),(void *)1 ); gtk_signal_connect( GTK_OBJECT( Config ),"clicked",GTK_SIGNAL_FUNC( eqButtonReleased ),(void *)2 ); gtk_signal_connect( GTK_OBJECT( Notebook ),"switch_page",GTK_SIGNAL_FUNC( eqNotebook ),NULL ); gtk_window_add_accel_group( GTK_WINDOW( Equalizer ),accel_group ); return Equalizer; }
static void on_operations_icon_draw (GtkWidget *widget, cairo_t *cr, NautilusToolbar *self) { gfloat elapsed_progress = 0; gint remaining_progress = 0; gint total_progress; gdouble ratio; GList *progress_infos; GList *l; guint width; guint height; gboolean all_cancelled; GdkRGBA background = {.red = 0, .green = 0, .blue = 0, .alpha = 0.2 }; GdkRGBA foreground = {.red = 0, .green = 0, .blue = 0, .alpha = 0.7 }; all_cancelled = TRUE; progress_infos = nautilus_progress_info_manager_get_all_infos (self->priv->progress_manager); for (l = progress_infos; l != NULL; l = l->next) { if (!nautilus_progress_info_get_is_cancelled (l->data)) { all_cancelled = FALSE; remaining_progress += nautilus_progress_info_get_remaining_time (l->data); elapsed_progress += nautilus_progress_info_get_elapsed_time (l->data); } } total_progress = remaining_progress + elapsed_progress; if (all_cancelled) { ratio = 1.0; } else { if (total_progress > 0) { ratio = MAX (0.05, elapsed_progress / total_progress); } else { ratio = 0.05; } } width = gtk_widget_get_allocated_width (widget); height = gtk_widget_get_allocated_height (widget); gdk_cairo_set_source_rgba(cr, &background); cairo_arc (cr, width / 2.0, height / 2.0, MIN (width, height) / 2.0, 0, 2 *G_PI); cairo_fill (cr); cairo_move_to (cr, width / 2.0, height / 2.0); gdk_cairo_set_source_rgba (cr, &foreground); cairo_arc (cr, width / 2.0, height / 2.0, MIN (width, height) / 2.0, -G_PI / 2.0, ratio * 2 * G_PI - G_PI / 2.0); cairo_fill (cr); } static void on_operations_button_toggled (NautilusToolbar *self) { unschedule_remove_finished_operations (self); if (!gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (self->priv->operations_button))) { schedule_remove_finished_operations (self); } else { update_operations (self); } } static void nautilus_toolbar_init (NautilusToolbar *self) { GtkBuilder *builder; self->priv = nautilus_toolbar_get_instance_private (self); gtk_widget_init_template (GTK_WIDGET (self)); self->priv->path_bar = g_object_new (NAUTILUS_TYPE_PATH_BAR, NULL); gtk_container_add (GTK_CONTAINER (self->priv->path_bar_container), self->priv->path_bar); self->priv->location_entry = nautilus_location_entry_new (); gtk_container_add (GTK_CONTAINER (self->priv->location_entry_container), self->priv->location_entry); builder = gtk_builder_new_from_resource ("/org/gnome/nautilus/nautilus-toolbar-view-menu.xml"); self->priv->view_menu_widget = GTK_WIDGET (gtk_builder_get_object (builder, "view_menu_widget")); self->priv->zoom_level_scale = GTK_WIDGET (gtk_builder_get_object (builder, "zoom_level_scale")); self->priv->zoom_adjustment = GTK_ADJUSTMENT (gtk_builder_get_object (builder, "zoom_adjustment")); self->priv->sort_menu = GTK_WIDGET (gtk_builder_get_object (builder, "sort_menu")); self->priv->sort_trash_time = GTK_WIDGET (gtk_builder_get_object (builder, "sort_trash_time")); self->priv->sort_search_relevance = GTK_WIDGET (gtk_builder_get_object (builder, "sort_search_relevance")); self->priv->visible_columns = GTK_WIDGET (gtk_builder_get_object (builder, "visible_columns")); self->priv->reload = GTK_WIDGET (gtk_builder_get_object (builder, "reload")); self->priv->stop = GTK_WIDGET (gtk_builder_get_object (builder, "stop")); g_signal_connect (self->priv->view_menu_widget, "closed", G_CALLBACK (view_menu_popover_closed), self); gtk_menu_button_set_popover (GTK_MENU_BUTTON (self->priv->view_button), self->priv->view_menu_widget); g_object_unref (builder); builder = gtk_builder_new_from_resource ("/org/gnome/nautilus/nautilus-toolbar-action-menu.xml"); self->priv->action_menu = G_MENU (gtk_builder_get_object (builder, "action-menu")); gtk_menu_button_set_menu_model (GTK_MENU_BUTTON (self->priv->action_button), G_MENU_MODEL (self->priv->action_menu)); g_object_unref (builder); self->priv->progress_manager = nautilus_progress_info_manager_dup_singleton (); g_signal_connect (self->priv->progress_manager, "new-progress-info", G_CALLBACK (on_new_progress_info), self); update_operations (self); g_object_set_data (G_OBJECT (self->priv->back_button), "nav-direction", GUINT_TO_POINTER (NAUTILUS_NAVIGATION_DIRECTION_BACK)); g_object_set_data (G_OBJECT (self->priv->forward_button), "nav-direction", GUINT_TO_POINTER (NAUTILUS_NAVIGATION_DIRECTION_FORWARD)); g_signal_connect (self->priv->back_button, "button-press-event", G_CALLBACK (navigation_button_press_cb), self); g_signal_connect (self->priv->back_button, "button-release-event", G_CALLBACK (navigation_button_release_cb), self); g_signal_connect (self->priv->forward_button, "button-press-event", G_CALLBACK (navigation_button_press_cb), self); g_signal_connect (self->priv->forward_button, "button-release-event", G_CALLBACK (navigation_button_release_cb), self); g_signal_connect (self->priv->zoom_level_scale, "value-changed", G_CALLBACK (zoom_level_changed), self); gtk_widget_show_all (GTK_WIDGET (self)); toolbar_update_appearance (self); }
void multi_cols_test (void) { GtkWidget *canvas, *window; ETableModel *e_table_model; ETableHeader *e_table_header, *e_table_header_multiple; ETableCol *col_0, *col_1; ECell *cell_left_just, *cell_image_toggle; GnomeCanvasItem *item; gtk_widget_push_colormap (gdk_rgb_get_cmap ()); e_table_model = e_table_simple_new ( col_count, row_count, value_at, set_value_at, is_cell_editable, duplicate_value, free_value, initialize_value, value_is_empty, value_to_string, NULL); /* * Header */ e_table_header = e_table_header_new (); cell_left_just = e_cell_text_new (e_table_model, NULL, GTK_JUSTIFY_LEFT); { GdkPixbuf **images = g_new (GdkPixbuf *, 3); int i; images [0] = gdk_pixbuf_new_from_file ("image1.png"); images [1] = gdk_pixbuf_new_from_file ("image2.png"); images [2] = gdk_pixbuf_new_from_file ("image3.png"); cell_image_toggle = e_cell_toggle_new (0, 3, images); for (i = 0; i < 3; i++) gdk_pixbuf_unref (images [i]); g_free (images); } col_1 = e_table_col_new (1, "Item Name", 1.0, 20, cell_left_just, e_str_compare, TRUE); e_table_header_add_column (e_table_header, col_1, 0); col_0 = e_table_col_new (0, "A", 0.0, 48, cell_image_toggle, e_int_compare, TRUE); e_table_header_add_column (e_table_header, col_0, 1); /* * Second test */ e_table_header_multiple = e_table_header_new (); e_table_header_add_column (e_table_header_multiple, col_0, 0); e_table_header_add_column (e_table_header_multiple, col_1, 1); e_table_header_add_column (e_table_header_multiple, col_1, 2); /* * GUI */ window = gtk_window_new (GTK_WINDOW_TOPLEVEL); canvas = e_canvas_new (); g_signal_connect (canvas, "size_allocate", G_CALLBACK (set_canvas_size), NULL); gtk_container_add (GTK_CONTAINER (window), canvas); gtk_widget_show_all (window); gnome_canvas_item_new ( gnome_canvas_root (GNOME_CANVAS (canvas)), e_table_header_item_get_type (), "ETableHeader", e_table_header, NULL); item = gnome_canvas_item_new ( gnome_canvas_root (GNOME_CANVAS (canvas)), e_table_item_get_type (), "ETableHeader", e_table_header, "ETableModel", e_table_model, "drawgrid", TRUE, "drawfocus", TRUE, "cursor_mode", E_TABLE_CURSOR_SIMPLE, #if 0 "spreadsheet", TRUE, #endif NULL); e_canvas_item_move_absolute (item, 0, 30); gnome_canvas_item_new ( gnome_canvas_root (GNOME_CANVAS (canvas)), e_table_header_item_get_type (), "ETableHeader", e_table_header_multiple, NULL); item = gnome_canvas_item_new ( gnome_canvas_root (GNOME_CANVAS (canvas)), e_table_item_get_type (), "ETableHeader", e_table_header_multiple, "ETableModel", e_table_model, "drawgrid", TRUE, "drawfocus", TRUE, #if 0 "spreadsheet", TRUE, #endif "cursor_mode", E_TABLE_CURSOR_SIMPLE, NULL); e_canvas_item_move_absolute (item, 300, 30); }
int main (int argc, char *argv[]) { Reg *reg; reg = g_slice_new (Reg); if (reg == NULL) { fprintf (stderr, "Error: not engouh space\n"); exit (1); } reg->path = malloc (sizeof (char) * MAX_VALUE_NAME); if (reg->path == NULL) { fprintf (stderr, "Error: not engouh space\n"); exit (1); } GtkWidget *window; GtkWidget *vbox; GtkWidget *menubar; GtkWidget *sw; GtkWidget *hpaned; GtkWidget *treeview; GtkWidget *listview; GtkWidget *statusbar; GtkTreeSelection *selection; GtkWidget *file; GtkWidget *edit; GtkWidget *option; GtkWidget *filemenu; GtkWidget *file_quit; GtkWidget *editmenu; GtkWidget *edit_insert_reg_sz; GtkWidget *edit_delete_key; GtkWidget *optionmenu; GtkWidget *option_add_to_run; GtkWidget *option_bind_gateway; gtk_init (&argc, &argv); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (window), "注册表编辑器"); gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_CENTER); gtk_window_set_default_size (GTK_WINDOW (window), 600, 400); vbox = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (window), vbox); menubar = gtk_menu_bar_new(); gtk_box_pack_start (GTK_BOX (vbox), menubar, FALSE, FALSE, 0); hpaned = gtk_hpaned_new (); gtk_box_pack_start (GTK_BOX (vbox), hpaned, TRUE, TRUE, 0); sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_paned_add1 (GTK_PANED (hpaned), sw); treeview = create_tree_view_and_model(); gtk_container_add (GTK_CONTAINER (sw), treeview); gtk_widget_set_size_request (treeview, 150, 0); sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_paned_add2 (GTK_PANED (hpaned), sw); listview = create_list_view_and_model(); gtk_container_add (GTK_CONTAINER (sw), listview); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (listview)); statusbar = gtk_statusbar_new(); gtk_box_pack_start (GTK_BOX (vbox), statusbar, FALSE, FALSE, 0); file = gtk_menu_item_new_with_mnemonic ("_File"); edit = gtk_menu_item_new_with_mnemonic ("_Edit"); option = gtk_menu_item_new_with_mnemonic ("_Option"); gtk_menu_shell_append (GTK_MENU_SHELL (menubar), file); gtk_menu_shell_append (GTK_MENU_SHELL (menubar), edit); gtk_menu_shell_append (GTK_MENU_SHELL (menubar), option); filemenu = gtk_menu_new(); editmenu = gtk_menu_new(); optionmenu = gtk_menu_new(); gtk_menu_item_set_submenu (GTK_MENU_ITEM (file), filemenu); gtk_menu_item_set_submenu (GTK_MENU_ITEM (edit), editmenu); gtk_menu_item_set_submenu (GTK_MENU_ITEM (option), optionmenu); file_quit = gtk_image_menu_item_new_from_stock (GTK_STOCK_QUIT, NULL); gtk_menu_shell_append (GTK_MENU_SHELL (filemenu), file_quit); edit_insert_reg_sz = gtk_menu_item_new_with_label ("插入键值(REG_SZ)"); edit_delete_key = gtk_menu_item_new_with_label ("删除选定键值"); gtk_menu_shell_append (GTK_MENU_SHELL (editmenu), edit_insert_reg_sz); gtk_menu_shell_append (GTK_MENU_SHELL (editmenu), edit_delete_key); option_add_to_run = gtk_menu_item_new_with_label ("加入启动项"); option_bind_gateway = gtk_menu_item_new_with_label ("绑定网关"); gtk_menu_shell_append (GTK_MENU_SHELL (optionmenu), option_add_to_run); gtk_menu_shell_append (GTK_MENU_SHELL (optionmenu), option_bind_gateway); reg->rootkey = HKEY_CLASSES_ROOT; reg->path[0] = '\0'; reg->treeview = treeview; reg->listview = listview; reg->selection = selection; reg->progname = argv[0]; gtk_widget_show_all (window); g_signal_connect_swapped (G_OBJECT (window), "destroy", G_CALLBACK (gtk_main_quit), G_OBJECT (window)); g_signal_connect (GTK_TREE_VIEW (treeview), "row-activated", G_CALLBACK (on_tree_view_row_activated), reg); g_signal_connect (GTK_MENU_ITEM (file_quit), "activate", G_CALLBACK (gtk_main_quit), NULL); g_signal_connect (GTK_MENU_ITEM (edit_insert_reg_sz), "activate", G_CALLBACK (on_edit_insert_reg_sz_activate), reg); g_signal_connect (GTK_MENU_ITEM (edit_delete_key), "activate", G_CALLBACK (on_edit_delete_key_activate), reg); g_signal_connect (GTK_MENU_ITEM (option_add_to_run), "activate", G_CALLBACK (on_option_add_to_run_activate), reg); g_signal_connect (GTK_MENU_ITEM (option_bind_gateway), "activate", G_CALLBACK (on_option_bind_gateway_activate), reg); // g_signal_connect (selection, "changed", G_CALLBACK (on_changed), collection); gtk_main(); free (reg->path); g_slice_free (Reg, reg); return 0; }
static void gimp_curves_tool_dialog (GimpImageMapTool *im_tool) { GimpCurvesTool *tool = GIMP_CURVES_TOOL (im_tool); GimpToolOptions *tool_options = GIMP_TOOL_GET_OPTIONS (im_tool); GimpCurvesConfig *config = GIMP_CURVES_CONFIG (im_tool->config); GtkListStore *store; GtkWidget *main_vbox; GtkWidget *frame_vbox; GtkWidget *vbox; GtkWidget *hbox; GtkWidget *hbox2; GtkWidget *label; GtkWidget *main_frame; GtkWidget *frame; GtkWidget *table; GtkWidget *button; GtkWidget *bar; GtkWidget *combo; g_signal_connect (im_tool->settings_box, "file-dialog-setup", G_CALLBACK (gimp_curves_tool_export_setup), im_tool); main_vbox = gimp_image_map_tool_dialog_get_vbox (im_tool); /* The combo box for selecting channels */ main_frame = gimp_frame_new (NULL); gtk_box_pack_start (GTK_BOX (main_vbox), main_frame, TRUE, TRUE, 0); gtk_widget_show (main_frame); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_frame_set_label_widget (GTK_FRAME (main_frame), hbox); gtk_widget_show (hbox); label = gtk_label_new_with_mnemonic (_("Cha_nnel:")); gimp_label_set_attributes (GTK_LABEL (label), PANGO_ATTR_WEIGHT, PANGO_WEIGHT_BOLD, -1); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); store = gimp_enum_store_new_with_range (GIMP_TYPE_HISTOGRAM_CHANNEL, GIMP_HISTOGRAM_VALUE, GIMP_HISTOGRAM_ALPHA); tool->channel_menu = gimp_enum_combo_box_new_with_model (GIMP_ENUM_STORE (store)); g_object_unref (store); gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (tool->channel_menu), config->channel); gimp_enum_combo_box_set_icon_prefix (GIMP_ENUM_COMBO_BOX (tool->channel_menu), "gimp-channel"); gtk_box_pack_start (GTK_BOX (hbox), tool->channel_menu, FALSE, FALSE, 0); gtk_widget_show (tool->channel_menu); g_signal_connect (tool->channel_menu, "changed", G_CALLBACK (curves_channel_callback), tool); gtk_label_set_mnemonic_widget (GTK_LABEL (label), tool->channel_menu); button = gtk_button_new_with_mnemonic (_("R_eset Channel")); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show (button); g_signal_connect (button, "clicked", G_CALLBACK (curves_channel_reset_callback), tool); /* The histogram scale radio buttons */ hbox2 = gimp_prop_enum_icon_box_new (G_OBJECT (tool_options), "histogram-scale", "gimp-histogram", 0, 0); gtk_box_pack_end (GTK_BOX (hbox), hbox2, FALSE, FALSE, 0); gtk_widget_show (hbox2); frame_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 4); gtk_container_add (GTK_CONTAINER (main_frame), frame_vbox); gtk_widget_show (frame_vbox); /* The table for the color bars and the graph */ table = gtk_table_new (2, 2, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 2); gtk_table_set_row_spacings (GTK_TABLE (table), 2); gtk_box_pack_start (GTK_BOX (frame_vbox), table, TRUE, TRUE, 0); /* The left color bar */ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_table_attach (GTK_TABLE (table), vbox, 0, 1, 0, 1, GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0); gtk_widget_show (vbox); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, RADIUS); gtk_widget_show (frame); tool->yrange = gimp_color_bar_new (GTK_ORIENTATION_VERTICAL); gtk_widget_set_size_request (tool->yrange, BAR_SIZE, -1); gtk_container_add (GTK_CONTAINER (frame), tool->yrange); gtk_widget_show (tool->yrange); /* The curves graph */ frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_table_attach (GTK_TABLE (table), frame, 1, 2, 0, 1, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0); gtk_widget_show (frame); tool->graph = gimp_curve_view_new (); gimp_curve_view_set_range_x (GIMP_CURVE_VIEW (tool->graph), 0, 255); gimp_curve_view_set_range_y (GIMP_CURVE_VIEW (tool->graph), 0, 255); gtk_widget_set_size_request (tool->graph, GRAPH_SIZE + RADIUS * 2, GRAPH_SIZE + RADIUS * 2); g_object_set (tool->graph, "border-width", RADIUS, "subdivisions", 1, NULL); gtk_container_add (GTK_CONTAINER (frame), tool->graph); gtk_widget_show (tool->graph); gimp_histogram_options_connect_view (GIMP_HISTOGRAM_OPTIONS (tool_options), GIMP_HISTOGRAM_VIEW (tool->graph)); /* The bottom color bar */ hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_table_attach (GTK_TABLE (table), hbox2, 1, 2, 1, 2, GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0); gtk_widget_show (hbox2); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX (hbox2), frame, TRUE, TRUE, RADIUS); gtk_widget_show (frame); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_box_set_homogeneous (GTK_BOX (vbox), TRUE); gtk_container_add (GTK_CONTAINER (frame), vbox); gtk_widget_show (vbox); tool->xrange = gimp_color_bar_new (GTK_ORIENTATION_HORIZONTAL); gtk_widget_set_size_request (tool->xrange, -1, BAR_SIZE / 2); gtk_box_pack_start (GTK_BOX (vbox), tool->xrange, TRUE, TRUE, 0); gtk_widget_show (tool->xrange); bar = gimp_color_bar_new (GTK_ORIENTATION_HORIZONTAL); gtk_box_pack_start (GTK_BOX (vbox), bar, TRUE, TRUE, 0); gtk_widget_show (bar); gtk_widget_show (table); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_end (GTK_BOX (frame_vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); label = gtk_label_new_with_mnemonic (_("Curve _type:")); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); tool->curve_type = combo = gimp_enum_combo_box_new (GIMP_TYPE_CURVE_TYPE); gimp_enum_combo_box_set_icon_prefix (GIMP_ENUM_COMBO_BOX (combo), "gimp-curve"); gimp_int_combo_box_connect (GIMP_INT_COMBO_BOX (combo), 0, G_CALLBACK (curves_curve_type_callback), tool); gtk_box_pack_start (GTK_BOX (hbox), combo, TRUE, TRUE, 0); gtk_widget_show (combo); gtk_label_set_mnemonic_widget (GTK_LABEL (label), combo); gimp_curves_tool_update_channel (tool); }
int DoLoadPortalFileDialog( GtkWidget *parent ){ GtkWidget *dialog, *vbox, *hbox, *button, *entry, *check2d, *check3d; GtkWidget *content_area, *ok_button, *cancel_button, *change_button; gint response_id; int ret; GtkSizeGroup *size_group; GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT; dialog = gtk_dialog_new_with_buttons( _( "Load .prt" ), NULL, flags, NULL ); gtk_window_set_transient_for( GTK_WINDOW( dialog ), GTK_WINDOW( parent ) ); ok_button = gtk_dialog_add_button( GTK_DIALOG( dialog ), _( "OK" ), GTK_RESPONSE_OK ); cancel_button = gtk_dialog_add_button( GTK_DIALOG( dialog ), _( "Cancel" ), GTK_RESPONSE_CANCEL ); content_area = gtk_dialog_get_content_area( GTK_DIALOG( dialog ) ); vbox = gtk_vbox_new( FALSE, 5 ); gtk_container_add( GTK_CONTAINER( content_area ), vbox ); gtk_container_set_border_width( GTK_CONTAINER( vbox ), 5 ); gtk_widget_show( vbox ); entry = gtk_entry_new(); gtk_editable_set_editable( GTK_EDITABLE( entry ), FALSE ); gtk_box_pack_start( GTK_BOX( vbox ), entry, FALSE, FALSE, 0 ); gtk_widget_show( entry ); hbox = gtk_hbox_new( FALSE, 5 ); gtk_box_pack_start( GTK_BOX( vbox ), hbox, FALSE, FALSE, 0 ); gtk_widget_show( hbox ); check3d = gtk_check_button_new_with_label( _( "Show 3D" ) ); gtk_box_pack_start( GTK_BOX( hbox ), check3d, FALSE, FALSE, 0 ); gtk_widget_show( check3d ); check2d = gtk_check_button_new_with_label( _( "Show 2D" ) ); gtk_box_pack_start( GTK_BOX( hbox ), check2d, FALSE, FALSE, 0 ); gtk_widget_show( check2d ); change_button = button = gtk_button_new_with_label( _( "Change" ) ); gtk_box_pack_end( GTK_BOX( hbox ), button, FALSE, FALSE, 0 ); g_signal_connect( G_OBJECT( button ), "clicked", G_CALLBACK( change_clicked ), parent ); gtk_widget_show( button ); size_group = gtk_size_group_new( GTK_SIZE_GROUP_BOTH ); gtk_size_group_add_widget( size_group, ok_button ); gtk_size_group_add_widget( size_group, cancel_button ); gtk_size_group_add_widget( size_group, change_button ); g_object_unref( size_group ); char *fn = g_FuncTable.m_pfnGetMapName(); strcpy( portals.fn, fn ); fn = strrchr( portals.fn, '.' ); if ( fn != NULL ) { *fn = '\0'; strcat( portals.fn, ".prt" ); } gtk_entry_set_text( GTK_ENTRY( entry ), portals.fn ); gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( check2d ), portals.show_2d ); gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( check3d ), portals.show_3d ); response_id = gtk_dialog_run( GTK_DIALOG( dialog ) ); if( response_id == GTK_RESPONSE_OK ) { portals.Purge(); portals.show_3d = gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( check3d ) ) ? true : false; portals.show_2d = gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( check2d ) ) ? true : false; ret = IDOK; } else { ret = IDCANCEL; } gtk_widget_destroy( dialog ); return ret; }
GtkWidget * x264_gtk_window_create (GtkWidget *parent) { GtkWidget *win_x264_gtk; GtkWidget *notebook; GtkWidget *page; GtkWidget *button; GtkWidget *label; X264_Gui_Config *gconfig; X264_Gtk *x264_gtk; gint result; GtkDialogFlags flags = 0; gconfig = (X264_Gui_Config *)g_malloc (sizeof (X264_Gui_Config)); if (!gconfig) return NULL; x264_gtk = x264_gtk_load (); if (parent) flags = GTK_DIALOG_MODAL |GTK_DIALOG_DESTROY_WITH_PARENT; win_x264_gtk = gtk_dialog_new_with_buttons (_("X264 Configuration"), GTK_WINDOW (parent), flags, NULL); button = gtk_button_new_with_label (_("Default")); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (win_x264_gtk)->action_area), button, FALSE, TRUE, 6); g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (_default_load), gconfig); gtk_widget_show (button); gtk_dialog_add_buttons (GTK_DIALOG (win_x264_gtk), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); g_object_set_data (G_OBJECT (win_x264_gtk), "x264-gui-config", gconfig); g_object_set_data (G_OBJECT (win_x264_gtk), "x264-config", x264_gtk); gtk_window_set_resizable (GTK_WINDOW (win_x264_gtk), FALSE); notebook = gtk_notebook_new (); gtk_container_add (GTK_CONTAINER (GTK_DIALOG (win_x264_gtk)->vbox), notebook); gtk_widget_show (notebook); label = gtk_label_new (_("Bitrate")); gtk_widget_show (label); page = _bitrate_page (gconfig); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), page, label); gtk_widget_show (page); label = gtk_label_new (_("Rate Control")); gtk_widget_show (label); page = _rate_control_page (gconfig); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), page, label); gtk_widget_show (page); label = gtk_label_new (_("MB & Frames")); gtk_widget_show (label); page = _mb_page (gconfig); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), page, label); gtk_widget_show (page); label = gtk_label_new (_("More...")); gtk_widget_show (label); page = _more_page (gconfig); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), page, label); gtk_widget_show (page); label = gtk_label_new (_("Quantization matrices")); gtk_widget_show (label); page = _cqm_page (gconfig); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), page, label); gtk_widget_show (page); _current_set (gconfig, x264_gtk); result = gtk_dialog_run (GTK_DIALOG (win_x264_gtk)); _dialog_run (GTK_DIALOG (win_x264_gtk), result, gconfig, x264_gtk); return win_x264_gtk; }
GtkDialog* seahorse_passphrase_prompt_show (const gchar *title, const gchar *description, const gchar *prompt, const gchar *check, gboolean confirm) { GtkEntryBuffer *buffer; GtkEntry *entry; GtkDialog *dialog; GtkWidget *w; GtkWidget *box; GtkTable *table; GtkWidget *wvbox; GtkWidget *chbox; gchar *msg; if (!title) title = _("Passphrase"); if (!prompt) prompt = _("Password:"******"size-request", G_CALLBACK (constrain_size), NULL); g_signal_connect (G_OBJECT (dialog), "map-event", G_CALLBACK (grab_keyboard), NULL); g_signal_connect (G_OBJECT (dialog), "unmap-event", G_CALLBACK (ungrab_keyboard), NULL); g_signal_connect (G_OBJECT (dialog), "window-state-event", G_CALLBACK (window_state_changed), NULL); wvbox = gtk_vbox_new (FALSE, HIG_LARGE * 2); gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (dialog)), wvbox); gtk_container_set_border_width (GTK_CONTAINER (wvbox), HIG_LARGE); chbox = gtk_hbox_new (FALSE, HIG_LARGE); gtk_box_pack_start (GTK_BOX (wvbox), chbox, FALSE, FALSE, 0); /* The image */ w = gtk_image_new_from_stock (GTK_STOCK_DIALOG_AUTHENTICATION, GTK_ICON_SIZE_DIALOG); gtk_misc_set_alignment (GTK_MISC (w), 0.0, 0.0); gtk_box_pack_start (GTK_BOX (chbox), w, FALSE, FALSE, 0); box = gtk_vbox_new (FALSE, HIG_SMALL); gtk_box_pack_start (GTK_BOX (chbox), box, TRUE, TRUE, 0); /* The description text */ if (description) { msg = utf8_validate (description); w = gtk_label_new (msg); g_free (msg); gtk_misc_set_alignment (GTK_MISC (w), 0.0, 0.5); gtk_label_set_line_wrap (GTK_LABEL (w), TRUE); gtk_box_pack_start (GTK_BOX (box), w, TRUE, FALSE, 0); } /* Two entries (usually on is hidden) in a vbox */ table = GTK_TABLE (gtk_table_new (3, 2, FALSE)); gtk_table_set_row_spacings (table, HIG_SMALL); gtk_table_set_col_spacings (table, HIG_LARGE); gtk_box_pack_start (GTK_BOX (box), GTK_WIDGET (table), FALSE, FALSE, 0); /* The first entry if we have one */ if (confirm) { msg = utf8_validate (prompt); w = gtk_label_new (msg); g_free (msg); gtk_table_attach (table, w, 0, 1, 0, 1, GTK_FILL, 0, 0, 0); buffer = seahorse_secure_buffer_new (); entry = GTK_ENTRY (gtk_entry_new_with_buffer (buffer)); g_object_unref (buffer); gtk_entry_set_visibility (entry, FALSE); gtk_widget_set_size_request (GTK_WIDGET (entry), 200, -1); g_object_set_data (G_OBJECT (dialog), "confirm-entry", entry); g_signal_connect (G_OBJECT (entry), "activate", G_CALLBACK (confirm_callback), dialog); g_signal_connect (G_OBJECT (entry), "changed", G_CALLBACK (entry_changed), dialog); gtk_table_attach_defaults (table, GTK_WIDGET (entry), 1, 2, 0, 1); gtk_widget_grab_focus (GTK_WIDGET (entry)); } /* The second and main entry */ msg = utf8_validate (confirm ? _("Confirm:") : prompt); w = gtk_label_new (msg); g_free (msg); gtk_table_attach (table, w, 0, 1, 1, 2, GTK_FILL, 0, 0, 0); buffer = seahorse_secure_buffer_new (); entry = GTK_ENTRY (gtk_entry_new_with_buffer (buffer)); g_object_unref (buffer); gtk_widget_set_size_request (GTK_WIDGET (entry), 200, -1); gtk_entry_set_visibility (entry, FALSE); g_object_set_data (G_OBJECT (dialog), "secure-entry", entry); g_signal_connect (G_OBJECT (entry), "activate", G_CALLBACK (enter_callback), dialog); gtk_table_attach_defaults (table, GTK_WIDGET (entry), 1, 2, 1, 2); if (!confirm) gtk_widget_grab_focus (GTK_WIDGET (entry)); else g_signal_connect (G_OBJECT (entry), "changed", G_CALLBACK (entry_changed), dialog); /* The checkbox */ if (check) { w = gtk_check_button_new_with_mnemonic (check); gtk_table_attach_defaults (table, w, 1, 2, 2, 3); g_object_set_data (G_OBJECT (dialog), "check-option", w); } gtk_widget_show_all (GTK_WIDGET (table)); w = gtk_button_new_from_stock (GTK_STOCK_CANCEL); gtk_dialog_add_action_widget (dialog, w, GTK_RESPONSE_REJECT); gtk_widget_set_can_default (w, TRUE); w = gtk_button_new_from_stock (GTK_STOCK_OK); gtk_dialog_add_action_widget (dialog, w, GTK_RESPONSE_ACCEPT); gtk_widget_set_can_default (w, TRUE); g_signal_connect_object (G_OBJECT (entry), "focus_in_event", G_CALLBACK (gtk_widget_grab_default), G_OBJECT (w), 0); gtk_widget_grab_default (w); g_signal_connect (dialog, "key_press_event", G_CALLBACK (key_press), NULL); gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER); gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE); gtk_window_set_type_hint (GTK_WINDOW (dialog), GDK_WINDOW_TYPE_HINT_NORMAL); gtk_window_set_keep_above (GTK_WINDOW (dialog), TRUE); gtk_widget_show_all (GTK_WIDGET (dialog)); gdk_window_focus (gtk_widget_get_window (GTK_WIDGET (dialog)), GDK_CURRENT_TIME); if (confirm) entry_changed (NULL, dialog); return dialog; }
void encodings_init(void) { GtkWidget *item, *menu[2], *submenu, *menu_westeuro, *menu_easteuro, *menu_eastasian, *menu_asian, *menu_utf8, *menu_middleeast, *item_westeuro, *item_easteuro, *item_eastasian, *item_asian, *item_utf8, *item_middleeast; GCallback cb_func[2]; GSList *group = NULL; gchar *label; gint order, group_size; guint i, j, k; init_encodings(); if (! pregs_loaded) { regex_compile(&pregs[0], PATTERN_HTMLMETA); regex_compile(&pregs[1], PATTERN_CODING); pregs_loaded = TRUE; } /* create encodings submenu in document menu */ menu[0] = ui_lookup_widget(main_widgets.window, "set_encoding1_menu"); menu[1] = ui_lookup_widget(main_widgets.window, "menu_reload_as1_menu"); cb_func[0] = G_CALLBACK(encodings_radio_item_change_cb); cb_func[1] = G_CALLBACK(on_reload_as_activate); for (k = 0; k < 2; k++) { menu_westeuro = gtk_menu_new(); item_westeuro = gtk_menu_item_new_with_mnemonic(_("_West European")); gtk_menu_item_set_submenu(GTK_MENU_ITEM(item_westeuro), menu_westeuro); gtk_container_add(GTK_CONTAINER(menu[k]), item_westeuro); gtk_widget_show_all(item_westeuro); menu_easteuro = gtk_menu_new(); item_easteuro = gtk_menu_item_new_with_mnemonic(_("_East European")); gtk_menu_item_set_submenu(GTK_MENU_ITEM(item_easteuro), menu_easteuro); gtk_container_add(GTK_CONTAINER(menu[k]), item_easteuro); gtk_widget_show_all(item_easteuro); menu_eastasian = gtk_menu_new(); item_eastasian = gtk_menu_item_new_with_mnemonic(_("East _Asian")); gtk_menu_item_set_submenu(GTK_MENU_ITEM(item_eastasian), menu_eastasian); gtk_container_add(GTK_CONTAINER(menu[k]), item_eastasian); gtk_widget_show_all(item_eastasian); menu_asian = gtk_menu_new(); item_asian = gtk_menu_item_new_with_mnemonic(_("_SE & SW Asian")); gtk_menu_item_set_submenu(GTK_MENU_ITEM(item_asian), menu_asian); gtk_container_add(GTK_CONTAINER(menu[k]), item_asian); gtk_widget_show_all(item_asian); menu_middleeast = gtk_menu_new(); item_middleeast = gtk_menu_item_new_with_mnemonic(_("_Middle Eastern")); gtk_menu_item_set_submenu(GTK_MENU_ITEM(item_middleeast), menu_middleeast); gtk_container_add(GTK_CONTAINER(menu[k]), item_middleeast); gtk_widget_show_all(item_middleeast); menu_utf8 = gtk_menu_new(); item_utf8 = gtk_menu_item_new_with_mnemonic(_("_Unicode")); gtk_menu_item_set_submenu(GTK_MENU_ITEM(item_utf8), menu_utf8); gtk_container_add(GTK_CONTAINER(menu[k]), item_utf8); gtk_widget_show_all(item_utf8); /** TODO can it be optimized? ATM 3782 runs at line "if (encodings[j].group ...)" */ for (i = 0; i < GEANY_ENCODING_GROUPS_MAX; i++) { order = 0; switch (i) { case WESTEUROPEAN: submenu = menu_westeuro; group_size = 9; break; case EASTEUROPEAN: submenu = menu_easteuro; group_size = 14; break; case EASTASIAN: submenu = menu_eastasian; group_size = 14; break; case ASIAN: submenu = menu_asian; group_size = 9; break; case MIDDLEEASTERN: submenu = menu_middleeast; group_size = 7; break; case UNICODE: submenu = menu_utf8; group_size = 8; break; default: submenu = menu[k]; group_size = 1; } while (order < group_size) /* the biggest group has 13 elements */ { for (j = 0; j < GEANY_ENCODINGS_MAX; j++) { if (encodings[j].group == i && encodings[j].order == order) { label = encodings_to_string(&encodings[j]); if (k == 0) { item = gtk_radio_menu_item_new_with_label(group, label); group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(item)); radio_items[j] = item; } else item = gtk_menu_item_new_with_label(label); gtk_widget_show(item); gtk_container_add(GTK_CONTAINER(submenu), item); g_signal_connect(item, "activate", cb_func[k], GINT_TO_POINTER(encodings[j].idx)); g_free(label); break; } } order++; } } } }
static void rc_plugin_tag_ui_init() { GtkWidget *path_label, *title_label, *artist_label, *album_label; GtkWidget *genre_label, *comment_label, *track_label, *year_label; GtkWidget *format_label, *channel_label, *bd_label, *sr_label; GtkWidget *bitrate_label, *length_label, *rg_label; GtkWidget *tag_frame, *media_frame; GtkWidget *tag_table, *media_table; GtkWidget *info_vbox, *media_vbox, *path_hbox, *art_hbox; GtkWidget *button_hbox; GtkWidget *info_scr_window; GtkActionEntry menu_action_entry, popup_action_entry; path_label = gtk_label_new(_("Path")); title_label = gtk_label_new(_("Title")); artist_label = gtk_label_new(_("Artist")); album_label = gtk_label_new(_("Album")); genre_label = gtk_label_new(_("Genre")); comment_label = gtk_label_new(_("Comment")); track_label = gtk_label_new(_("Track")); year_label = gtk_label_new(_("Year")); format_label = gtk_label_new(_("Format")); channel_label = gtk_label_new(_("Channel")); bd_label = gtk_label_new(_("Bit Depth")); sr_label = gtk_label_new(_("Sample Rate")); bitrate_label = gtk_label_new(_("Bitrate")); length_label = gtk_label_new(_("Length")); rg_label = gtk_label_new(_("Replay Gain")); tag_frame = gtk_frame_new(_("Tag")); media_frame = gtk_frame_new(_("Media Information")); tag_table = gtk_table_new(5, 4, FALSE); media_table = gtk_table_new(7, 2, FALSE); info_vbox = gtk_vbox_new(FALSE, 1); media_vbox = gtk_vbox_new(FALSE, 1); path_hbox = gtk_hbox_new(FALSE, 4); art_hbox = gtk_hbox_new(FALSE, 4); button_hbox = gtk_hbutton_box_new(); info_scr_window = gtk_scrolled_window_new(NULL, NULL); tag_ui.tag_main_vbox = gtk_vbox_new(FALSE, 0); tag_ui.path_entry = gtk_entry_new(); tag_ui.title_entry = gtk_entry_new(); tag_ui.artist_entry = gtk_entry_new(); tag_ui.album_entry = gtk_entry_new(); tag_ui.genre_entry = gtk_entry_new(); tag_ui.comment_entry = gtk_entry_new(); tag_ui.track_entry = gtk_entry_new(); tag_ui.year_entry = gtk_entry_new(); tag_ui.format_entry = gtk_label_new(NULL); tag_ui.channel_entry = gtk_label_new(NULL); tag_ui.bd_entry = gtk_label_new(NULL); tag_ui.sr_entry = gtk_label_new(NULL); tag_ui.bitrate_entry = gtk_label_new(NULL); tag_ui.length_entry = gtk_label_new(NULL); tag_ui.rg_entry = gtk_entry_new(); tag_ui.reload_button = gtk_button_new_with_mnemonic(_("Re_load")); tag_ui.save_button = gtk_button_new_with_mnemonic(_("_Save")); gtk_editable_set_editable(GTK_EDITABLE(tag_ui.path_entry), FALSE); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(info_scr_window), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_table_attach(GTK_TABLE(tag_table), title_label, 0, 1, 0, 1, 0, GTK_FILL, 0, 0); gtk_table_attach(GTK_TABLE(tag_table), tag_ui.title_entry, 1, 4, 0, 1, GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_FILL, 0, 0); gtk_table_attach(GTK_TABLE(tag_table), artist_label, 0, 1, 1, 2, 0, GTK_FILL, 0, 0); gtk_table_attach(GTK_TABLE(tag_table), tag_ui.artist_entry, 1, 4, 1, 2, GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_FILL, 0, 0); gtk_table_attach(GTK_TABLE(tag_table), album_label, 0, 1, 2, 3, 0, GTK_FILL, 0, 0); gtk_table_attach(GTK_TABLE(tag_table), tag_ui.album_entry, 1, 2, 2, 3, GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_FILL, 0, 0); gtk_table_attach(GTK_TABLE(tag_table), track_label, 2, 3, 2, 3, 0, GTK_FILL, 4, 0); gtk_table_attach(GTK_TABLE(tag_table), tag_ui.track_entry, 3, 4, 2, 3, GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_FILL, 0, 0); gtk_table_attach(GTK_TABLE(tag_table), genre_label, 0, 1, 3, 4, 0, GTK_FILL, 0, 0); gtk_table_attach(GTK_TABLE(tag_table), tag_ui.genre_entry, 1, 2, 3, 4, GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_FILL, 0, 0); gtk_table_attach(GTK_TABLE(tag_table), year_label, 2, 3, 3, 4, 0, GTK_FILL, 4, 0); gtk_table_attach(GTK_TABLE(tag_table), tag_ui.year_entry, 3, 4, 3, 4, GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_FILL, 0, 0); gtk_table_attach(GTK_TABLE(tag_table), comment_label, 0, 1, 4, 5, 0, GTK_FILL, 0, 0); gtk_table_attach(GTK_TABLE(tag_table), tag_ui.comment_entry, 1, 4, 4, 5, GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_SHRINK, 0, 0); gtk_table_attach(GTK_TABLE(media_table), format_label, 0, 1, 0, 1, 0, GTK_FILL, 0, 0); gtk_table_attach(GTK_TABLE(media_table), tag_ui.format_entry, 1, 2, 0, 1, GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_FILL, 0, 0); gtk_table_attach(GTK_TABLE(media_table), channel_label, 0, 1, 1, 2, 0, GTK_FILL, 0, 0); gtk_table_attach(GTK_TABLE(media_table), tag_ui.channel_entry, 1, 2, 1, 2, GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_FILL, 0, 0); gtk_table_attach(GTK_TABLE(media_table), bd_label, 0, 1, 2, 3, 0, GTK_FILL, 0, 0); gtk_table_attach(GTK_TABLE(media_table), tag_ui.bd_entry, 1, 2, 2, 3, GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_FILL, 0, 0); gtk_table_attach(GTK_TABLE(media_table), sr_label, 0, 1, 3, 4, 0, GTK_FILL, 0, 0); gtk_table_attach(GTK_TABLE(media_table), tag_ui.sr_entry, 1, 2, 3, 4, GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_FILL, 0, 0); gtk_table_attach(GTK_TABLE(media_table), bitrate_label, 0, 1, 4, 5, 0, GTK_FILL, 0, 0); gtk_table_attach(GTK_TABLE(media_table), tag_ui.bitrate_entry, 1, 2, 4, 5, GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_FILL, 0, 0); gtk_table_attach(GTK_TABLE(media_table), length_label, 0, 1, 5, 6, 0, GTK_FILL, 0, 0); gtk_table_attach(GTK_TABLE(media_table), tag_ui.length_entry, 1, 2, 5, 6, GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_FILL, 0, 0); gtk_table_attach(GTK_TABLE(media_table), rg_label, 0, 1, 6, 7, 0, GTK_FILL, 0, 0); gtk_table_attach(GTK_TABLE(media_table), tag_ui.rg_entry, 1, 2, 6, 7, GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_FILL, 0, 0); gtk_container_add(GTK_CONTAINER(tag_frame), tag_table); gtk_container_add(GTK_CONTAINER(media_frame), media_table); gtk_box_pack_start(GTK_BOX(media_vbox), tag_frame, TRUE, TRUE, 4); gtk_box_pack_start(GTK_BOX(media_vbox), media_frame, TRUE, TRUE, 4); gtk_box_pack_start(GTK_BOX(path_hbox), path_label, FALSE, FALSE, 4); gtk_box_pack_start(GTK_BOX(path_hbox), tag_ui.path_entry, TRUE, TRUE, 4); gtk_box_pack_start(GTK_BOX(info_vbox), path_hbox, FALSE, FALSE, 1); gtk_box_pack_start(GTK_BOX(info_vbox), media_vbox, FALSE, FALSE, 1); gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(info_scr_window), info_vbox); gtk_button_box_set_layout(GTK_BUTTON_BOX(button_hbox), GTK_BUTTONBOX_END); gtk_box_pack_start(GTK_BOX(button_hbox), tag_ui.reload_button, FALSE, FALSE, 4); gtk_box_pack_start(GTK_BOX(button_hbox), tag_ui.save_button, FALSE, FALSE, 4); gtk_box_pack_start(GTK_BOX(tag_ui.tag_main_vbox), info_scr_window, TRUE, TRUE, 1); gtk_box_pack_start(GTK_BOX(tag_ui.tag_main_vbox), button_hbox, FALSE, FALSE, 8); g_signal_connect(G_OBJECT(tag_ui.track_entry), "insert-text", G_CALLBACK(rc_plugin_tag_entry_insert_text_cb), NULL); g_signal_connect(G_OBJECT(tag_ui.year_entry), "insert-text", G_CALLBACK(rc_plugin_tag_entry_insert_text_cb), NULL); g_signal_connect(G_OBJECT(tag_ui.rg_entry), "insert-text", G_CALLBACK(rc_plugin_tag_rg_entry_insert_text_cb), NULL); g_signal_connect(G_OBJECT(tag_ui.reload_button), "clicked", G_CALLBACK(rc_plugin_tag_reload_data_cb), NULL); g_signal_connect(G_OBJECT(tag_ui.save_button), "clicked", G_CALLBACK(rc_plugin_tag_data_save_cb), NULL); menu_id = gtk_ui_manager_new_merge_id(rc_gui_get_ui_manager()); menu_action_entry.name = "EditTagEditor"; menu_action_entry.label = _("Tag Editor"); menu_action_entry.accelerator = NULL; menu_action_entry.stock_id = NULL; menu_action_entry.tooltip = _("Edit the tag of the selected music"); menu_action_entry.callback = G_CALLBACK(rc_plugin_tag_edit_menu_cb); gtk_ui_manager_add_ui(rc_gui_get_ui_manager(), menu_id, "/RCMenuBar/EditMenu/EditSep2", "EditTagEditor", "EditTagEditor", GTK_UI_MANAGER_MENUITEM, TRUE); gtk_action_group_add_actions(rc_gui_get_action_group(), &menu_action_entry, 1, NULL); popup_id = gtk_ui_manager_new_merge_id(rc_gui_get_ui_manager()); popup_action_entry.name = "List2TagEditor"; popup_action_entry.label = _("Tag Editor"); popup_action_entry.accelerator = NULL; popup_action_entry.stock_id = NULL; popup_action_entry.tooltip = _("Edit the tag of the selected music"); popup_action_entry.callback = G_CALLBACK(rc_plugin_tag_edit_menu_cb); gtk_ui_manager_add_ui(rc_gui_get_ui_manager(), popup_id, "/List2PopupMenu/List2Sep2", "List2TagEditor", "List2TagEditor", GTK_UI_MANAGER_MENUITEM, FALSE); gtk_action_group_add_actions(rc_gui_get_action_group(), &popup_action_entry, 1, NULL); }
int main (int argc, char **argv) { GtkWidget *w; gtk_init (); toplevel = gtk_window_new (GTK_WINDOW_TOPLEVEL); box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_container_add (GTK_CONTAINER (toplevel), box); button = gtk_app_chooser_button_new ("image/jpeg"); gtk_box_pack_start (GTK_BOX (box), button); g_signal_connect (button, "changed", G_CALLBACK (combo_changed_cb), NULL); w = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (w), "<b>Selected app info</b>"); gtk_box_pack_start (GTK_BOX (box), w); w = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_start (GTK_BOX (box), w); sel_image = gtk_image_new (); gtk_box_pack_start (GTK_BOX (w), sel_image); sel_name = gtk_label_new (NULL); gtk_box_pack_start (GTK_BOX (w), sel_name); gtk_app_chooser_button_set_heading (GTK_APP_CHOOSER_BUTTON (button), "Choose one, <i>not</i> two"); gtk_app_chooser_button_append_separator (GTK_APP_CHOOSER_BUTTON (button)); gtk_app_chooser_button_append_custom_item (GTK_APP_CHOOSER_BUTTON (button), CUSTOM_ITEM, "Hey, I'm special!", g_themed_icon_new ("face-smile")); /* this one will trigger a warning, and will not be added */ gtk_app_chooser_button_append_custom_item (GTK_APP_CHOOSER_BUTTON (button), CUSTOM_ITEM, "Hey, I'm fake!", g_themed_icon_new ("face-evil")); gtk_app_chooser_button_set_show_dialog_item (GTK_APP_CHOOSER_BUTTON (button), TRUE); gtk_app_chooser_button_set_show_default_item (GTK_APP_CHOOSER_BUTTON (button), TRUE); /* connect to the detailed signal */ g_signal_connect (button, "custom-item-activated::" CUSTOM_ITEM, G_CALLBACK (special_item_activated_cb), NULL); /* connect to the generic signal too */ g_signal_connect (button, "custom-item-activated", G_CALLBACK (action_cb), NULL); /* test refresh on a combo */ gtk_app_chooser_refresh (GTK_APP_CHOOSER (button)); #if 0 gtk_app_chooser_button_set_active_custom_item (GTK_APP_CHOOSER_BUTTON (button), CUSTOM_ITEM); #endif gtk_widget_show (toplevel); g_signal_connect (toplevel, "destroy", G_CALLBACK (gtk_main_quit), NULL); gtk_main (); return EXIT_SUCCESS; }
/** * Constructor */ GtkWidget *create_control_window(GtkWidget *parent) { GtkWidget *pp_button, *next_button, *prev_button, *ff_button; GtkWidget *vol, *progress, *hbox, *play_image; int new_volume; /* Create window */ GtkWidget *base = gtk_event_box_new(); GtkWidget *ali = gtk_alignment_new(0.5,0,0.6,1); g_signal_connect(G_OBJECT(base), "enter-notify-event" , G_CALLBACK(control_window_enter_notify_event), NULL); g_signal_connect(G_OBJECT(base), "leave-notify-event" , G_CALLBACK(control_window_leave_notify_event), NULL); /* Overwrite background drawing */ gtk_widget_set_app_paintable(base, TRUE); g_signal_connect(G_OBJECT(base), "draw", G_CALLBACK(expose_window), NULL); hbox = gtk_hbox_new(FALSE, 6); g_object_set_data(G_OBJECT(base), "hbox" , hbox); gtk_container_add(GTK_CONTAINER(base), ali); gtk_container_add(GTK_CONTAINER(ali), hbox); gtk_container_set_border_width(GTK_CONTAINER(ali), 1); /* Previous button */ ff_button = gtk_button_new(); gtk_container_add(GTK_CONTAINER(ff_button), gtk_image_new_from_stock(GTK_STOCK_LEAVE_FULLSCREEN, GTK_ICON_SIZE_BUTTON)); gtk_button_set_relief(GTK_BUTTON(ff_button), GTK_RELIEF_NONE); gtk_box_pack_start(GTK_BOX(hbox), ff_button, FALSE, FALSE, 0); g_signal_connect(G_OBJECT(ff_button), "clicked", G_CALLBACK(control_window_leave_fullscreen), parent); /* Volume button */ vol = (GtkWidget *)gtk_volume_button_new(); gtk_box_pack_end(GTK_BOX(hbox), vol, FALSE, FALSE, 0); new_volume = mpd_status_get_volume(connection); gtk_scale_button_set_value(GTK_SCALE_BUTTON(vol), new_volume/100.0); g_object_set_data(G_OBJECT(base), "vol", vol); g_signal_connect(G_OBJECT(vol), "value_changed", G_CALLBACK(playlist_player_volume_changed), NULL); /* Progress */ progress = (GtkWidget *)gmpc_progress_new(); gmpc_progress_set_hide_text(GMPC_PROGRESS(progress), FALSE); gtk_box_pack_start(GTK_BOX(hbox), progress, TRUE, TRUE, 0); g_object_set_data(G_OBJECT(base), "progress", progress); g_signal_connect(G_OBJECT(progress), "seek-event", G_CALLBACK(pl3_pb_seek_event), NULL); /* Previous button */ prev_button = gtk_button_new(); gtk_container_add(GTK_CONTAINER(prev_button), gtk_image_new_from_stock("gtk-media-previous", GTK_ICON_SIZE_BUTTON)); gtk_activatable_set_related_action(GTK_ACTIVATABLE(prev_button), GTK_ACTION(gtk_builder_get_object(pl3_xml, "MPDPrevious"))); gtk_button_set_relief(GTK_BUTTON(prev_button), GTK_RELIEF_NONE); gtk_box_pack_start(GTK_BOX(hbox), prev_button, FALSE, FALSE, 0); /* Play button */ pp_button = gtk_button_new(); if(mpd_player_get_state(connection) == MPD_PLAYER_PLAY) { play_image = gtk_image_new_from_stock("gtk-media-pause", GTK_ICON_SIZE_BUTTON); } else { play_image = gtk_image_new_from_stock("gtk-media-play", GTK_ICON_SIZE_BUTTON); } gtk_container_add(GTK_CONTAINER(pp_button), play_image); g_object_set_data(G_OBJECT(base), "play_image", play_image); gtk_activatable_set_related_action(GTK_ACTIVATABLE(pp_button), GTK_ACTION(gtk_builder_get_object(pl3_xml, "MPDPlayPause"))); gtk_button_set_relief(GTK_BUTTON(pp_button), GTK_RELIEF_NONE); gtk_box_pack_start(GTK_BOX(hbox), pp_button, FALSE, FALSE, 0); /* Next */ next_button = gtk_button_new(); gtk_container_add(GTK_CONTAINER(next_button), gtk_image_new_from_stock("gtk-media-next", GTK_ICON_SIZE_BUTTON)); gtk_activatable_set_related_action(GTK_ACTIVATABLE(next_button), GTK_ACTION(gtk_builder_get_object(pl3_xml, "MPDNext"))); gtk_button_set_relief(GTK_BUTTON(next_button), GTK_RELIEF_NONE); gtk_box_pack_start(GTK_BOX(hbox), next_button, FALSE, FALSE, 0); /* Change colors */ control_window_modify_colors(base); gtk_widget_show_all(base); timeout = g_timeout_add_seconds(5, (GSourceFunc) gtk_widget_hide, hbox); return base; }
static void gnc_ui_file_access( int type ) { FileAccessWindow *faw; GladeXML* xml; GtkWidget* box; GList* ds_node; GtkButton* op; GtkWidget* align; GtkFileChooserWidget* fileChooser; GtkFileChooserAction fileChooserAction = GTK_FILE_CHOOSER_ACTION_OPEN; GList* list; GList* node; GtkWidget* uri_type_container; gboolean need_access_method_file = FALSE; gboolean need_access_method_mysql = FALSE; gboolean need_access_method_postgres = FALSE; gboolean need_access_method_sqlite3 = FALSE; gboolean need_access_method_xml = FALSE; gint access_method_index = -1; gint active_access_method_index = -1; const gchar* default_db; const gchar *button_label = NULL; g_return_if_fail( type == FILE_ACCESS_OPEN || type == FILE_ACCESS_SAVE_AS ); faw = g_new0(FileAccessWindow, 1); g_return_if_fail( faw != NULL ); faw->type = type; /* Open the dialog */ xml = gnc_glade_xml_new( "dialog-file-access.glade", "File Access" ); faw->dialog = glade_xml_get_widget( xml, "File Access" ); g_object_set_data_full( G_OBJECT(faw->dialog), "FileAccessWindow", faw, g_free ); faw->frame_file = glade_xml_get_widget( xml, "frame_file" ); faw->frame_database = glade_xml_get_widget( xml, "frame_database" ); faw->tf_host = GTK_ENTRY(glade_xml_get_widget( xml, "tf_host" )); gtk_entry_set_text( faw->tf_host, DEFAULT_HOST ); faw->tf_database = GTK_ENTRY(glade_xml_get_widget( xml, "tf_database" )); default_db = get_default_database(); gtk_entry_set_text( faw->tf_database, default_db ); faw->tf_username = GTK_ENTRY(glade_xml_get_widget( xml, "tf_username" )); faw->tf_password = GTK_ENTRY(glade_xml_get_widget( xml, "tf_password" )); switch ( type ) { case FILE_ACCESS_OPEN: gtk_window_set_title(GTK_WINDOW(faw->dialog), _("Open...")); button_label = "gtk-open"; fileChooserAction = GTK_FILE_CHOOSER_ACTION_OPEN; break; case FILE_ACCESS_SAVE_AS: gtk_window_set_title(GTK_WINDOW(faw->dialog), _("Save As...")); button_label = "gtk-save-as"; fileChooserAction = GTK_FILE_CHOOSER_ACTION_SAVE; break; } op = GTK_BUTTON(glade_xml_get_widget( xml, "pb_op" )); if ( op != NULL ) { gtk_button_set_label( op, button_label ); gtk_button_set_use_stock( op, TRUE ); } align = glade_xml_get_widget( xml, "alignment_file_chooser" ); fileChooser = GTK_FILE_CHOOSER_WIDGET(gtk_file_chooser_widget_new( fileChooserAction )); faw->fileChooser = GTK_FILE_CHOOSER(fileChooser); gtk_container_add( GTK_CONTAINER(align), GTK_WIDGET(fileChooser) ); g_object_connect( G_OBJECT(faw->fileChooser), "signal::file-activated", gnc_ui_file_access_file_activated_cb, faw, NULL ); uri_type_container = glade_xml_get_widget( xml, "vb_uri_type_container" ); faw->cb_uri_type = GTK_COMBO_BOX(gtk_combo_box_new_text()); gtk_container_add( GTK_CONTAINER(uri_type_container), GTK_WIDGET(faw->cb_uri_type) ); gtk_box_set_child_packing( GTK_BOX(uri_type_container), GTK_WIDGET(faw->cb_uri_type), /*expand*/TRUE, /*fill*/FALSE, /*padding*/0, GTK_PACK_START ); g_object_connect( G_OBJECT(faw->cb_uri_type), "signal::changed", cb_uri_type_changed_cb, NULL, NULL ); /* Autoconnect signals */ glade_xml_signal_autoconnect_full( xml, gnc_glade_autoconnect_full_func, faw->dialog ); /* See what qof backends are available and add appropriate ones to the combo box */ list = qof_backend_get_registered_access_method_list(); for ( node = list; node != NULL; node = node->next ) { const gchar* access_method = node->data; /* For the different access methods, "mysql" and "postgres" are added if available. Access methods "xml" and "sqlite3" are compressed to "file" if opening a file, but when saving a file, both access methods are added. */ if ( strcmp( access_method, "mysql" ) == 0 ) { need_access_method_mysql = TRUE; } else if ( strcmp( access_method, "postgres" ) == 0 ) { need_access_method_postgres = TRUE; } else if ( strcmp( access_method, "xml" ) == 0 ) { if ( type == FILE_ACCESS_OPEN ) { need_access_method_file = TRUE; } else { need_access_method_xml = TRUE; } } else if ( strcmp( access_method, "sqlite3" ) == 0 ) { if ( type == FILE_ACCESS_OPEN ) { need_access_method_file = TRUE; } else { need_access_method_sqlite3 = TRUE; } } } g_list_free(list); /* Now that the set of access methods has been ascertained, add them to the list, and set the default. */ access_method_index = -1; if ( need_access_method_file ) { gtk_combo_box_append_text( faw->cb_uri_type, "file" ); active_access_method_index = ++access_method_index; } if ( need_access_method_mysql ) { gtk_combo_box_append_text( faw->cb_uri_type, "mysql" ); ++access_method_index; } if ( need_access_method_postgres ) { gtk_combo_box_append_text( faw->cb_uri_type, "postgres" ); ++access_method_index; } if ( need_access_method_sqlite3 ) { gtk_combo_box_append_text( faw->cb_uri_type, "sqlite3" ); active_access_method_index = ++access_method_index; } if ( need_access_method_xml ) { gtk_combo_box_append_text( faw->cb_uri_type, "xml" ); ++access_method_index; // Set XML as default if it is offered (which mean we are in // the "Save As" dialog) active_access_method_index = access_method_index; } g_assert( active_access_method_index >= 0 ); /* Clean up the xml data structure when the dialog is destroyed */ g_object_set_data_full( G_OBJECT(faw->dialog), "dialog-file-access.glade", xml, g_object_unref ); /* Run the dialog */ gtk_widget_show_all( faw->dialog ); /* Hide the frame that's not required for the active access method so either only * the File or only the Database frame are presented. */ gtk_combo_box_set_active( faw->cb_uri_type, active_access_method_index ); set_widget_sensitivity_for_uri_type( faw, gtk_combo_box_get_active_text( faw->cb_uri_type ) ); }
int main( int argc, char *argv[] ) { GtkWidget *window = NULL; GtkWidget *box1; GtkWidget *box2; GtkWidget *button; GtkWidget *separator; GSList *group; gtk_init (&argc, &argv); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); g_signal_connect (window, "delete-event", G_CALLBACK (close_application), NULL); gtk_window_set_title (GTK_WINDOW (window), "radio buttons"); gtk_container_set_border_width (GTK_CONTAINER (window), 0); box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, FALSE, 0); gtk_container_add (GTK_CONTAINER (window), box1); gtk_widget_show (box1); box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, FALSE, 10); gtk_container_set_border_width (GTK_CONTAINER (box2), 10); gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0); gtk_widget_show (box2); button = gtk_radio_button_new_with_label (NULL, "button1"); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); gtk_widget_show (button); group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)); button = gtk_radio_button_new_with_label (group, "button2"); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); gtk_widget_show (button); button = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (button), "button3"); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); gtk_widget_show (button); separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL); gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0); gtk_widget_show (separator); box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, FALSE, 10); gtk_container_set_border_width (GTK_CONTAINER (box2), 10); gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0); gtk_widget_show (box2); button = gtk_button_new_with_label ("close"); g_signal_connect_swapped (button, "clicked", G_CALLBACK (close_application), window); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); gtk_widget_set_can_default (button, TRUE); gtk_widget_grab_default (button); gtk_widget_show (button); gtk_widget_show (window); gtk_main (); return 0; }
/* mixerwindow_new */ MixerWindow * mixerwindow_new(char const * device, MixerLayout layout, gboolean embedded) { MixerWindow * mixer; GtkAccelGroup * accel; GtkWidget * vbox; GtkWidget * widget; MixerProperties properties; char buf[80]; unsigned long id; if((mixer = object_new(sizeof(*mixer))) == NULL) return NULL; accel = gtk_accel_group_new(); mixer->window = NULL; mixer->about = NULL; if(embedded) { mixer->window = gtk_plug_new(0); g_signal_connect_swapped(mixer->window, "embedded", G_CALLBACK( on_embedded), mixer); } else { mixer->window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_add_accel_group(GTK_WINDOW(mixer->window), accel); gtk_window_set_default_size(GTK_WINDOW(mixer->window), 800, 350); #if GTK_CHECK_VERSION(2, 6, 0) gtk_window_set_icon_name(GTK_WINDOW(mixer->window), "stock_volume"); #endif gtk_window_set_title(GTK_WINDOW(mixer->window), _("Mixer")); g_signal_connect_swapped(mixer->window, "delete-event", G_CALLBACK(on_closex), mixer); } mixer->mixer = NULL; mixer->fullscreen = FALSE; if(mixer->window != NULL) { gtk_widget_realize(mixer->window); mixer->mixer = mixer_new(mixer->window, device, layout); } if(mixer->mixer == NULL) { mixerwindow_delete(mixer); return NULL; } #if GTK_CHECK_VERSION(3, 0, 0) vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); #else vbox = gtk_vbox_new(FALSE, 0); #endif #ifndef EMBEDDED /* menubar */ if(embedded == FALSE) { if(layout == ML_TABBED) _mixer_menubar[1].menu = _mixer_menu_view_tabbed; mixer->menubar = desktop_menubar_create(_mixer_menubar, mixer, accel); gtk_box_pack_start(GTK_BOX(vbox), mixer->menubar, FALSE, TRUE, 0); } else mixer->menubar = NULL; #else desktop_accel_create(_mixer_accel, mixer, accel); #endif /* toolbar */ if(embedded == FALSE) { if(layout != ML_TABBED) _mixer_toolbar[3].name = ""; widget = desktop_toolbar_create(_mixer_toolbar, mixer, accel); gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, TRUE, 0); } #ifndef EMBEDDED g_object_unref(accel); #endif widget = mixer_get_widget(mixer->mixer); gtk_box_pack_start(GTK_BOX(vbox), widget, TRUE, TRUE, 0); gtk_container_add(GTK_CONTAINER(mixer->window), vbox); gtk_widget_show_all(vbox); if(embedded) { /* print the window ID and force a flush */ id = gtk_plug_get_id(GTK_PLUG(mixer->window)); printf("%lu\n", id); fclose(stdout); } else { /* set the window title */ if(mixer_get_properties(mixer->mixer, &properties) == 0) { snprintf(buf, sizeof(buf), "%s - %s%s%s", _("Mixer"), properties.name, strlen(properties.version) ? " " : "", properties.version); gtk_window_set_title(GTK_WINDOW(mixer->window), buf); } gtk_widget_show(mixer->window); } return mixer; }
static void gimp_color_picker_tool_info_create (GimpColorPickerTool *picker_tool) { GimpTool *tool = GIMP_TOOL (picker_tool); GimpDisplayShell *shell; GtkWidget *hbox; GtkWidget *frame; GimpRGB color; g_return_if_fail (tool->display != NULL); g_return_if_fail (tool->drawable != NULL); shell = gimp_display_get_shell (tool->display); picker_tool->gui = gimp_tool_gui_new (tool->tool_info, _("Color Picker Information"), gtk_widget_get_screen (GTK_WIDGET (shell)), gimp_widget_get_monitor (GTK_WIDGET (shell)), TRUE, GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL); gimp_tool_gui_set_auto_overlay (picker_tool->gui, TRUE); gimp_tool_gui_set_focus_on_map (picker_tool->gui, FALSE); gimp_tool_gui_set_viewable (picker_tool->gui, GIMP_VIEWABLE (tool->drawable)); g_signal_connect (picker_tool->gui, "response", G_CALLBACK (gimp_color_picker_tool_info_response), picker_tool); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_start (GTK_BOX (gimp_tool_gui_get_vbox (picker_tool->gui)), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); picker_tool->color_frame1 = gimp_color_frame_new (); gimp_color_frame_set_mode (GIMP_COLOR_FRAME (picker_tool->color_frame1), GIMP_COLOR_FRAME_MODE_PIXEL); gtk_box_pack_start (GTK_BOX (hbox), picker_tool->color_frame1, FALSE, FALSE, 0); gtk_widget_show (picker_tool->color_frame1); picker_tool->color_frame2 = gimp_color_frame_new (); gimp_color_frame_set_mode (GIMP_COLOR_FRAME (picker_tool->color_frame2), GIMP_COLOR_FRAME_MODE_RGB); gtk_box_pack_start (GTK_BOX (hbox), picker_tool->color_frame2, FALSE, FALSE, 0); gtk_widget_show (picker_tool->color_frame2); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0); gtk_widget_show (frame); gimp_rgba_set (&color, 0.0, 0.0, 0.0, 0.0); picker_tool->color_area = gimp_color_area_new (&color, gimp_drawable_has_alpha (tool->drawable) ? GIMP_COLOR_AREA_LARGE_CHECKS : GIMP_COLOR_AREA_FLAT, GDK_BUTTON1_MASK | GDK_BUTTON2_MASK); gtk_widget_set_size_request (picker_tool->color_area, 48, -1); gtk_drag_dest_unset (picker_tool->color_area); gtk_container_add (GTK_CONTAINER (frame), picker_tool->color_area); gtk_widget_show (picker_tool->color_area); }
static void make_region_dialog(void) { int i, id; regrow *r; chan_info *cp; GtkWidget *infobox, *labels, *labbox; GtkWidget *sep1, *cww, *toppane, *tophbox, *plw, *formw; region_dialog = snd_gtk_dialog_new(); SG_SIGNAL_CONNECT(region_dialog, "delete_event", region_browser_delete_callback, NULL); gtk_window_set_title(GTK_WINDOW(region_dialog), _("Regions")); sg_make_resizable(region_dialog); gtk_container_set_border_width(GTK_CONTAINER(region_dialog), 10); gtk_window_resize(GTK_WINDOW(region_dialog), 400, 500); gtk_widget_realize(region_dialog); help_button = gtk_button_new_from_stock(GTK_STOCK_HELP); gtk_widget_set_name(help_button, "help_button"); dismiss_button = gtk_button_new_from_stock(GTK_STOCK_QUIT); gtk_widget_set_name(dismiss_button, "quit_button"); insert_button = sg_button_new_from_stock_with_label(_("Insert"), GTK_STOCK_PASTE); gtk_widget_set_name(insert_button, "doit_button"); mix_button = sg_button_new_from_stock_with_label(_("Mix"), GTK_STOCK_ADD); gtk_widget_set_name(mix_button, "doit_again_button"); save_as_button = gtk_button_new_from_stock(GTK_STOCK_SAVE_AS); gtk_widget_set_name(save_as_button, "reset_button"); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(region_dialog)->action_area), dismiss_button, true, true, 4); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(region_dialog)->action_area), insert_button, true, true, 4); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(region_dialog)->action_area), mix_button, true, true, 4); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(region_dialog)->action_area), save_as_button, true, true, 4); gtk_box_pack_end(GTK_BOX(GTK_DIALOG(region_dialog)->action_area), help_button, true, true, 4); SG_SIGNAL_CONNECT(insert_button, "clicked", region_insert_callback, NULL); SG_SIGNAL_CONNECT(mix_button, "clicked", region_mix_callback, NULL); SG_SIGNAL_CONNECT(help_button, "clicked", region_help_callback, NULL); SG_SIGNAL_CONNECT(dismiss_button, "clicked", region_ok_callback, NULL); SG_SIGNAL_CONNECT(save_as_button, "clicked", region_save_callback, NULL); gtk_widget_show(insert_button); gtk_widget_show(mix_button); gtk_widget_show(help_button); gtk_widget_show(dismiss_button); gtk_widget_show(save_as_button); region_grf = gtk_vpaned_new(); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(region_dialog)->vbox), region_grf, true, true, 0); gtk_widget_show(region_grf); toppane = gtk_hbox_new(false, 0); gtk_paned_add1(GTK_PANED(region_grf), toppane); gtk_widget_show(toppane); formw = gtk_vbox_new(false, 0); gtk_box_pack_start(GTK_BOX(toppane), formw, true, true, 4); gtk_widget_show(formw); sep1 = gtk_vseparator_new(); /* not hsep -- damned thing insists on drawing a line */ gtk_box_pack_start(GTK_BOX(formw), sep1, false, false, 2); gtk_widget_show(sep1); tophbox = gtk_hbox_new(false, 0); gtk_box_pack_start(GTK_BOX(formw), tophbox, false, false, 4); gtk_widget_show(tophbox); plw = gtk_label_new(_("play")); gtk_box_pack_start(GTK_BOX(tophbox), plw, false, false, 2); gtk_widget_show(plw); sep1 = gtk_vseparator_new(); gtk_box_pack_start(GTK_BOX(formw), sep1, false, false, 2); gtk_widget_show(sep1); region_list = gtk_vbox_new(false, 0); cww = gtk_scrolled_window_new(NULL, NULL); gtk_box_pack_start(GTK_BOX(formw), cww, true, true, 0); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(cww), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(cww), region_list); gtk_widget_show(region_list); gtk_widget_show(cww); infobox = gtk_vbox_new(false, 0); gtk_box_pack_start(GTK_BOX(toppane), infobox, false, false, 2); gtk_widget_show(infobox); region_rows = (regrow **)CALLOC(max_regions(ss), sizeof(regrow *)); region_rows_size = max_regions(ss); for (i = 0; i < max_regions(ss); i++) { r = make_regrow(region_list, (void (*)())region_play_callback, (void (*)())region_focus_callback); region_rows[i] = r; r->pos = i; } update_region_browser(false); /* in Gtk, apparently, labels are just the text, not the background (i.e. they're transparent) */ /* we need a button simply to get the background color, then a vbox to put four labels on the button */ /* but we get a button which flashes whenever the mouse comes near it and has "relief" */ /* if we turn off the relief, the colors go away */ /* all I want is an opaque label with a background color */ labels = gtk_button_new(); gtk_box_pack_start(GTK_BOX(infobox), labels, true, true, 2); gtk_widget_show(labels); gtk_widget_modify_bg(labels, GTK_STATE_NORMAL, ss->sgx->highlight_color); SG_SIGNAL_CONNECT(labels, "enter_notify_event", region_labels_mouse_enter, NULL); labbox = gtk_vbox_new(true, 0); gtk_container_add(GTK_CONTAINER(labels), labbox); gtk_widget_show(labbox); gtk_widget_modify_bg(labbox, GTK_STATE_NORMAL, ss->sgx->highlight_color); srate_text = gtk_label_new(_("srate:")); sg_left_justify_label(srate_text); gtk_box_pack_start(GTK_BOX(labbox), srate_text, false, false, 2); gtk_widget_show(srate_text); chans_text = gtk_label_new(_("chans:")); sg_left_justify_label(chans_text); gtk_box_pack_start(GTK_BOX(labbox), chans_text, false, false, 2); gtk_widget_show(chans_text); length_text = gtk_label_new(_("length:")); sg_left_justify_label(length_text); gtk_box_pack_start(GTK_BOX(labbox), length_text, false, false, 2); gtk_widget_show(length_text); maxamp_text = gtk_label_new(_("maxamp:")); sg_left_justify_label(maxamp_text); gtk_box_pack_start(GTK_BOX(labbox), maxamp_text, false, false, 2); gtk_widget_show(maxamp_text); edit_button = gtk_button_new_with_label(_("edit")); SG_SIGNAL_CONNECT(edit_button, "clicked", region_edit_callback, NULL); gtk_box_pack_start(GTK_BOX(infobox), edit_button, true, true, 2); gtk_widget_show(edit_button); gtk_widget_modify_bg(edit_button, GTK_STATE_NORMAL, ss->sgx->lighter_blue); gtk_widget_modify_bg(edit_button, GTK_STATE_ACTIVE, ss->sgx->red); print_button = gtk_button_new_with_label(_("print")); SG_SIGNAL_CONNECT(print_button, "clicked", region_print_callback, NULL); gtk_box_pack_start(GTK_BOX(infobox), print_button, true, true, 2); gtk_widget_show(print_button); gtk_widget_modify_bg(print_button, GTK_STATE_NORMAL, ss->sgx->lighter_blue); gtk_widget_modify_bg(print_button, GTK_STATE_ACTIVE, ss->sgx->red); unlist_button = gtk_button_new_with_label(_("unlist")); SG_SIGNAL_CONNECT(unlist_button, "clicked", region_unlist_callback, NULL); gtk_box_pack_start(GTK_BOX(infobox), unlist_button, true, true, 2); gtk_widget_show(unlist_button); gtk_widget_modify_bg(unlist_button, GTK_STATE_NORMAL, ss->sgx->lighter_blue); gtk_widget_modify_bg(unlist_button, GTK_STATE_ACTIVE, ss->sgx->red); gtk_widget_show(region_dialog); id = region_list_position_to_id(0); rsp = make_simple_channel_display(region_srate(id), region_len(id), WITH_ARROWS, region_graph_style(ss), region_grf, WITHOUT_EVENTS); rsp->inuse = SOUND_REGION; set_current_region(0); cp = rsp->chans[0]; gtk_paned_set_position(GTK_PANED(region_grf), 220); SG_SIGNAL_CONNECT(channel_graph(cp), "expose_event", region_resize_callback, cp); SG_SIGNAL_CONNECT(channel_graph(cp), "configure_event", region_expose_callback, cp); SG_SIGNAL_CONNECT(channel_up_arrow(cp), "button_press_event", region_up_arrow_callback, NULL); SG_SIGNAL_CONNECT(channel_down_arrow(cp), "button_press_event", region_down_arrow_callback, NULL); set_sensitive(channel_f(cp), false); if (region_chans(region_list_position_to_id(0)) > 1) set_sensitive(channel_w(cp), true); cp->chan = 0; rsp->hdr = fixup_region_data(cp, 0, 0); make_region_labels(rsp->hdr); highlight_region(); region_update_graph(cp); add_ss_watcher(SS_FILE_OPEN_WATCHER, reflect_file_in_region_browser, NULL); set_dialog_widget(REGION_DIALOG, region_dialog); }
static t_global_monitor * monitor_new(void) { t_global_monitor *global; GtkRcStyle *rc; gint i; global = g_new(t_global_monitor, 1); global->timeout_id = 0; global->ebox = gtk_event_box_new(); gtk_widget_show(global->ebox); global->box = gtk_hbox_new(FALSE, 0); gtk_widget_show(global->box); if (!tooltips) { tooltips = gtk_tooltips_new(); } global->monitor = g_new(t_monitor, 1); global->monitor->options.label_text = g_strdup(DEFAULT_TEXT); global->monitor->options.network_device = g_strdup(DEFAULT_DEVICE); global->monitor->options.old_network_device = g_strdup(""); global->monitor->options.use_label = TRUE; global->monitor->options.auto_max = TRUE; global->monitor->options.update_interval = UPDATE_TIMEOUT; for (i = 0; i < SUM; i++) { gdk_color_parse(DEFAULT_COLOR[i], &global->monitor->options.color[i]); global->monitor->history[i][0] = 0; global->monitor->history[i][1] = 0; global->monitor->history[i][2] = 0; global->monitor->history[i][3] = 0; global->monitor->net_max[i] = INIT_MAX; global->monitor->options.max[i] = INIT_MAX; } global->monitor->ebox = gtk_event_box_new(); gtk_widget_show(global->monitor->ebox); global->monitor->box = GTK_WIDGET(gtk_hbox_new(FALSE, 0)); gtk_container_set_border_width(GTK_CONTAINER(global->monitor->box), border_width); gtk_widget_show(GTK_WIDGET(global->monitor->box)); gtk_container_add(GTK_CONTAINER(global->monitor->ebox), GTK_WIDGET(global->monitor->box)); global->monitor->label = gtk_label_new(global->monitor->options.label_text); gtk_widget_show(global->monitor->label); gtk_box_pack_start(GTK_BOX(global->monitor->box), GTK_WIDGET(global->monitor->label), FALSE, FALSE, 0); for (i = 0; i < SUM; i++) { global->monitor->status[i] = GTK_WIDGET(gtk_progress_bar_new()); gtk_progress_bar_set_orientation(GTK_PROGRESS_BAR(global->monitor->status[i]), GTK_PROGRESS_BOTTOM_TO_TOP); rc = gtk_widget_get_modifier_style(GTK_WIDGET(global->monitor->status[i])); if (!rc) { rc = gtk_rc_style_new(); } else { rc->color_flags[GTK_STATE_PRELIGHT] |= GTK_RC_BG; rc->bg[GTK_STATE_PRELIGHT] = global->monitor->options.color[i]; } gtk_widget_modify_style(GTK_WIDGET(global->monitor->status[i]), rc); gtk_widget_show(GTK_WIDGET(global->monitor->status[i])); gtk_box_pack_start(GTK_BOX(global->monitor->box), GTK_WIDGET(global->monitor->status[i]), FALSE, FALSE, 0); } gtk_box_pack_start(GTK_BOX(global->box), GTK_WIDGET(global->monitor->ebox), FALSE, FALSE, 0); gtk_container_add(GTK_CONTAINER(global->ebox), GTK_WIDGET(global->box)); return global; }
GtkWidget * userlist_create (GtkWidget *box) { GtkWidget *sw, *treeview; static const GtkTargetEntry dnd_dest_targets[] = { {"text/uri-list", 0, 1}, {"XCHAT_CHANVIEW", GTK_TARGET_SAME_APP, 75 } }; static const GtkTargetEntry dnd_src_target[] = { {"XCHAT_USERLIST", GTK_TARGET_SAME_APP, 75 } }; sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_ETCHED_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), prefs.showhostname_in_userlist ? GTK_POLICY_AUTOMATIC : GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_box_pack_start (GTK_BOX (box), sw, TRUE, TRUE, 0); gtk_widget_show (sw); treeview = gtk_tree_view_new (); gtk_widget_set_name (treeview, "xchat-userlist"); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), FALSE); gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)), GTK_SELECTION_MULTIPLE); /* set up drops */ gtk_drag_dest_set (treeview, GTK_DEST_DEFAULT_ALL, dnd_dest_targets, 2, GDK_ACTION_MOVE | GDK_ACTION_COPY | GDK_ACTION_LINK); gtk_drag_source_set (treeview, GDK_BUTTON1_MASK, dnd_src_target, 1, GDK_ACTION_MOVE); /* file DND (for DCC) */ g_signal_connect (G_OBJECT (treeview), "drag_motion", G_CALLBACK (userlist_dnd_motion), treeview); g_signal_connect (G_OBJECT (treeview), "drag_leave", G_CALLBACK (userlist_dnd_leave), 0); g_signal_connect (G_OBJECT (treeview), "drag_data_received", G_CALLBACK (userlist_dnd_drop), treeview); g_signal_connect (G_OBJECT (treeview), "button_press_event", G_CALLBACK (userlist_click_cb), 0); g_signal_connect (G_OBJECT (treeview), "key_press_event", G_CALLBACK (userlist_key_cb), 0); /* tree/chanview DND */ g_signal_connect (G_OBJECT (treeview), "drag_begin", G_CALLBACK (mg_drag_begin_cb), NULL); g_signal_connect (G_OBJECT (treeview), "drag_drop", G_CALLBACK (mg_drag_drop_cb), NULL); g_signal_connect (G_OBJECT (treeview), "drag_motion", G_CALLBACK (mg_drag_motion_cb), NULL); g_signal_connect (G_OBJECT (treeview), "drag_end", G_CALLBACK (mg_drag_end_cb), NULL); userlist_add_columns (GTK_TREE_VIEW (treeview)); gtk_container_add (GTK_CONTAINER (sw), treeview); gtk_widget_show (treeview); return treeview; }
static void monitor_set_orientation (Control * ctrl, int orientation) { t_global_monitor *global = ctrl->data; GtkRcStyle *rc; gint i; if (global->timeout_id) { g_source_remove(global->timeout_id); } gtk_widget_hide(GTK_WIDGET(global->ebox)); gtk_container_remove(GTK_CONTAINER(global->ebox), GTK_WIDGET(global->box)); if (orientation == HORIZONTAL) { global->box = gtk_hbox_new(FALSE, 0); } else { global->box = gtk_vbox_new(FALSE, 0); } gtk_widget_show(global->box); global->monitor->label = gtk_label_new(global->monitor->options.label_text); gtk_widget_show(global->monitor->label); for (i = 0; i < SUM; i++) { global->monitor->status[i] = GTK_WIDGET(gtk_progress_bar_new()); } if (orientation == HORIZONTAL) { global->monitor->box = GTK_WIDGET(gtk_hbox_new(FALSE, 0)); for (i = 0; i < SUM; i++) { gtk_progress_bar_set_orientation(GTK_PROGRESS_BAR(global->monitor->status[i]), GTK_PROGRESS_BOTTOM_TO_TOP); } } else { global->monitor->box = GTK_WIDGET(gtk_vbox_new(FALSE, 0)); for (i = 0; i < SUM; i++) { gtk_progress_bar_set_orientation(GTK_PROGRESS_BAR(global->monitor->status[i]), GTK_PROGRESS_LEFT_TO_RIGHT); } } gtk_box_pack_start(GTK_BOX(global->monitor->box), GTK_WIDGET(global->monitor->label), FALSE, FALSE, 0); gtk_container_set_border_width(GTK_CONTAINER(global->monitor->box), border_width); gtk_widget_show(GTK_WIDGET(global->monitor->box)); global->monitor->ebox = gtk_event_box_new(); gtk_widget_show(global->monitor->ebox); gtk_container_add(GTK_CONTAINER(global->monitor->ebox), GTK_WIDGET(global->monitor->box)); for (i = 0; i < SUM; i++) { rc = gtk_widget_get_modifier_style(GTK_WIDGET(global->monitor->status[i])); if (!rc) { rc = gtk_rc_style_new(); } else { rc->color_flags[GTK_STATE_PRELIGHT] |= GTK_RC_BG; rc->bg[GTK_STATE_PRELIGHT] = global->monitor->options.color[i]; } gtk_widget_modify_style(GTK_WIDGET(global->monitor->status[i]), rc); gtk_widget_show(GTK_WIDGET(global->monitor->status[i])); gtk_box_pack_start(GTK_BOX(global->monitor->box), GTK_WIDGET(global->monitor->status[i]), FALSE, FALSE, 0); } gtk_box_pack_start(GTK_BOX(global->box), GTK_WIDGET(global->monitor->ebox), FALSE, FALSE, 0); gtk_container_add(GTK_CONTAINER(global->ebox), GTK_WIDGET(global->box)); gtk_widget_show(GTK_WIDGET(global->ebox)); run_update( global ); }
static void grain_stat(G_GNUC_UNUSED GwyContainer *data, GwyRunType run) { GtkWidget *dialog, *table; GwyDataField *dfield, *mfield; GwySIUnit *siunit, *siunit2; GwySIValueFormat *vf; gint xres, yres, ngrains; gdouble total_area, area, size, vol_0, vol_min, vol_laplace, v; gdouble *values = NULL; gint *grains; GString *str; gint row; g_return_if_fail(run & STAT_RUN_MODES); gwy_app_data_browser_get_current(GWY_APP_DATA_FIELD, &dfield, GWY_APP_MASK_FIELD, &mfield, 0); g_return_if_fail(dfield); g_return_if_fail(mfield); xres = gwy_data_field_get_xres(mfield); yres = gwy_data_field_get_yres(mfield); total_area = gwy_data_field_get_xreal(dfield) *gwy_data_field_get_yreal(dfield); grains = g_new0(gint, xres*yres); ngrains = gwy_data_field_number_grains(mfield, grains); area = grains_get_total_value(dfield, ngrains, grains, &values, GWY_GRAIN_VALUE_PROJECTED_AREA); size = grains_get_total_value(dfield, ngrains, grains, &values, GWY_GRAIN_VALUE_EQUIV_SQUARE_SIDE); vol_0 = grains_get_total_value(dfield, ngrains, grains, &values, GWY_GRAIN_VALUE_VOLUME_0); vol_min = grains_get_total_value(dfield, ngrains, grains, &values, GWY_GRAIN_VALUE_VOLUME_MIN); vol_laplace = grains_get_total_value(dfield, ngrains, grains, &values, GWY_GRAIN_VALUE_VOLUME_LAPLACE); g_free(values); g_free(grains); dialog = gtk_dialog_new_with_buttons(_("Grain Statistics"), NULL, 0, GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL); gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE); table = gtk_table_new(7, 2, FALSE); gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), table); gtk_container_set_border_width(GTK_CONTAINER(table), 4); row = 0; str = g_string_new(NULL); g_string_printf(str, "%d", ngrains); add_report_row(GTK_TABLE(table), &row, _("Number of grains:"), str->str); siunit = gwy_data_field_get_si_unit_xy(dfield); siunit2 = gwy_si_unit_power(siunit, 2, NULL); v = area; vf = gwy_si_unit_get_format(siunit2, GWY_SI_UNIT_FORMAT_VFMARKUP, v, NULL); g_string_printf(str, "%.*f %s", vf->precision, v/vf->magnitude, vf->units); add_report_row(GTK_TABLE(table), &row, _("Total projected area (abs.):"), str->str); g_string_printf(str, "%.2f %%", 100.0*area/total_area); add_report_row(GTK_TABLE(table), &row, _("Total projected area (rel.):"), str->str); v = area/ngrains; gwy_si_unit_get_format(siunit2, GWY_SI_UNIT_FORMAT_VFMARKUP, v, vf); g_string_printf(str, "%.*f %s", vf->precision, v/vf->magnitude, vf->units); add_report_row(GTK_TABLE(table), &row, _("Mean grain area:"), str->str); v = size/ngrains; gwy_si_unit_get_format(siunit, GWY_SI_UNIT_FORMAT_VFMARKUP, v, vf); g_string_printf(str, "%.*f %s", vf->precision, v/vf->magnitude, vf->units); add_report_row(GTK_TABLE(table), &row, _("Mean grain size:"), str->str); siunit = gwy_data_field_get_si_unit_z(dfield); gwy_si_unit_multiply(siunit2, siunit, siunit2); v = vol_0; gwy_si_unit_get_format(siunit2, GWY_SI_UNIT_FORMAT_VFMARKUP, v, vf); g_string_printf(str, "%.*f %s", vf->precision, v/vf->magnitude, vf->units); add_report_row(GTK_TABLE(table), &row, _("Total grain volume (zero):"), str->str); v = vol_min; gwy_si_unit_get_format(siunit2, GWY_SI_UNIT_FORMAT_VFMARKUP, v, vf); g_string_printf(str, "%.*f %s", vf->precision, v/vf->magnitude, vf->units); add_report_row(GTK_TABLE(table), &row, _("Total grain volume (minimum):"), str->str); v = vol_laplace; gwy_si_unit_get_format(siunit2, GWY_SI_UNIT_FORMAT_VFMARKUP, v, vf); g_string_printf(str, "%.*f %s", vf->precision, v/vf->magnitude, vf->units); add_report_row(GTK_TABLE(table), &row, _("Total grain volume (laplacian):"), str->str); gwy_si_unit_value_format_free(vf); g_string_free(str, TRUE); g_object_unref(siunit2); gtk_widget_show_all(dialog); gtk_dialog_run(GTK_DIALOG(dialog)); gtk_widget_destroy(dialog); }
static void monitor_create_options(Control *control, GtkContainer *container, GtkWidget *done) { t_global_monitor *global; GtkBox *vbox, *global_vbox, *net_hbox; GtkWidget *device_label, *unit_label[SUM], *max_label[SUM]; GtkWidget *sep1, *sep2; GtkBox *update_hbox; GtkWidget *update_label, *update_unit_label; GtkWidget *color_label[SUM]; GtkWidget *align; GtkBox *color_hbox[SUM]; GtkSizeGroup *sg; gint i; gchar buffer[BUFSIZ]; gchar *color_text[] = { N_("Bar color (incoming):"), N_("Bar color (outgoing):") }; gchar *maximum_text_label[] = { N_("Maximum (incoming):"), N_("Maximum (outgoing):") }; sg = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL); global = (t_global_monitor *)control->data; global->opt_dialog = gtk_widget_get_toplevel(done); global_vbox = GTK_BOX(gtk_vbox_new(FALSE, 5)); gtk_container_add(GTK_CONTAINER(container), GTK_WIDGET(global_vbox)); gtk_widget_show_all(GTK_WIDGET(global_vbox)); vbox = GTK_BOX(gtk_vbox_new(FALSE, 5)); gtk_widget_show(GTK_WIDGET(vbox)); global->monitor->opt_vbox = GTK_BOX(gtk_vbox_new(FALSE, 5)); gtk_widget_show(GTK_WIDGET(global->monitor->opt_vbox)); /* Displayed text */ global->monitor->opt_hbox = GTK_BOX(gtk_hbox_new(FALSE, 5)); gtk_widget_show(GTK_WIDGET(global->monitor->opt_hbox)); global->monitor->opt_use_label = gtk_check_button_new_with_mnemonic(_("Text to display:")); gtk_widget_show(global->monitor->opt_use_label); gtk_box_pack_start(GTK_BOX(global->monitor->opt_hbox), GTK_WIDGET(global->monitor->opt_use_label), FALSE, FALSE, 0); gtk_size_group_add_widget(sg, global->monitor->opt_use_label); global->monitor->opt_entry = gtk_entry_new(); gtk_entry_set_max_length(GTK_ENTRY(global->monitor->opt_entry), MAX_LENGTH); gtk_entry_set_text(GTK_ENTRY(global->monitor->opt_entry), global->monitor->options.label_text); gtk_widget_show(global->monitor->opt_entry); gtk_box_pack_start(GTK_BOX(global->monitor->opt_hbox), GTK_WIDGET(global->monitor->opt_entry), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(global->monitor->opt_vbox), GTK_WIDGET(global->monitor->opt_hbox), FALSE, FALSE, 0); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(global->monitor->opt_use_label), global->monitor->options.use_label); gtk_widget_set_sensitive(GTK_WIDGET(global->monitor->opt_entry), global->monitor->options.use_label); /* Network device */ net_hbox = GTK_BOX(gtk_hbox_new(FALSE, 5)); gtk_box_pack_start(GTK_BOX(global->monitor->opt_vbox), GTK_WIDGET(net_hbox), FALSE, FALSE, 0); device_label = gtk_label_new(_("Network device:")); gtk_misc_set_alignment(GTK_MISC(device_label), 0, 0.5); gtk_widget_show(GTK_WIDGET(device_label)); gtk_box_pack_start(GTK_BOX(net_hbox), GTK_WIDGET(device_label), FALSE, FALSE, 0); global->monitor->net_entry = gtk_entry_new(); gtk_entry_set_max_length(GTK_ENTRY(global->monitor->net_entry), MAX_LENGTH); gtk_entry_set_text(GTK_ENTRY(global->monitor->net_entry), global->monitor->options.network_device); gtk_widget_show(global->monitor->opt_entry); gtk_box_pack_start(GTK_BOX(net_hbox), GTK_WIDGET(global->monitor->net_entry), FALSE, FALSE, 0); gtk_size_group_add_widget(sg, device_label); gtk_widget_show_all(GTK_WIDGET(net_hbox)); /* Update timevalue */ update_hbox = GTK_BOX(gtk_hbox_new(FALSE, 5)); gtk_box_pack_start(GTK_BOX(global->monitor->opt_vbox), GTK_WIDGET(update_hbox), FALSE, FALSE, 0); update_label = gtk_label_new(_("Update interval:")); gtk_misc_set_alignment(GTK_MISC(update_label), 0, 0.5); gtk_box_pack_start(GTK_BOX(update_hbox), GTK_WIDGET(update_label), FALSE, FALSE, 0); global->monitor->update_spinner = gtk_spin_button_new_with_range (0.1, 10.0, 0.05); gtk_spin_button_set_digits( GTK_SPIN_BUTTON(global->monitor->update_spinner), 2 ); gtk_spin_button_set_value( GTK_SPIN_BUTTON(global->monitor->update_spinner), global->monitor->options.update_interval / 1000.0 ); gtk_box_pack_start(GTK_BOX(update_hbox), GTK_WIDGET(global->monitor->update_spinner), FALSE, FALSE, 0); update_unit_label = gtk_label_new(_("ms")); gtk_box_pack_start(GTK_BOX(update_hbox), GTK_WIDGET(update_unit_label), FALSE, FALSE, 0); gtk_widget_show_all(GTK_WIDGET(update_hbox)); gtk_size_group_add_widget(sg, update_label); sep1 = gtk_hseparator_new(); gtk_box_pack_start(GTK_BOX(global->monitor->opt_vbox), GTK_WIDGET(sep1), FALSE, FALSE, 0); gtk_widget_show(sep1); global->monitor->max_use_label = gtk_check_button_new_with_mnemonic(_("Automatic maximum")); gtk_widget_show(global->monitor->max_use_label); gtk_box_pack_start(GTK_BOX(global->monitor->opt_vbox), GTK_WIDGET(global->monitor->max_use_label), FALSE, FALSE, 0); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(global->monitor->max_use_label), global->monitor->options.auto_max); /* Input maximum */ for( i = 0; i < SUM; i++) { global->monitor->max_hbox[i] = GTK_BOX(gtk_hbox_new(FALSE, 5)); gtk_box_pack_start(GTK_BOX(global->monitor->opt_vbox), GTK_WIDGET(global->monitor->max_hbox[i]), FALSE, FALSE, 0); max_label[i] = gtk_label_new(_(maximum_text_label[i])); gtk_misc_set_alignment(GTK_MISC(max_label[i]), 0, 0.5); gtk_widget_show(GTK_WIDGET(max_label[i])); gtk_box_pack_start(GTK_BOX(global->monitor->max_hbox[i]), GTK_WIDGET(max_label[i]), FALSE, FALSE, 0); global->monitor->max_entry[i] = gtk_entry_new(); gtk_entry_set_max_length(GTK_ENTRY(global->monitor->max_entry[i]), MAX_LENGTH); g_snprintf( buffer, BUFSIZ, "%.2f", global->monitor->options.max[i] / 1024.0 ); gtk_entry_set_text(GTK_ENTRY(global->monitor->max_entry[i]), buffer); gtk_entry_set_width_chars(GTK_ENTRY(global->monitor->max_entry[i]), 7); gtk_widget_show(global->monitor->max_entry[i]); gtk_box_pack_start(GTK_BOX(global->monitor->max_hbox[i]), GTK_WIDGET(global->monitor->max_entry[i]), FALSE, FALSE, 0); unit_label[i] = gtk_label_new(_("kByte/s")); gtk_box_pack_start(GTK_BOX(global->monitor->max_hbox[i]), GTK_WIDGET(unit_label[i]), FALSE, FALSE, 0); gtk_size_group_add_widget(sg, max_label[i]); gtk_widget_show_all(GTK_WIDGET(global->monitor->max_hbox[i])); gtk_widget_set_sensitive(GTK_WIDGET(global->monitor->max_hbox[i]), !(global->monitor->options.auto_max) ); g_signal_connect(GTK_WIDGET(global->monitor->max_entry[i]), "activate", G_CALLBACK(max_label_changed), global); } sep2 = gtk_hseparator_new(); gtk_box_pack_start(GTK_BOX(global->monitor->opt_vbox), GTK_WIDGET(sep2), FALSE, FALSE, 0); gtk_widget_show(sep2); /* Color 1 */ for (i = 0; i < SUM; i++) { color_hbox[i] = GTK_BOX(gtk_hbox_new(FALSE, 5)); gtk_widget_show(GTK_WIDGET(color_hbox[i])); gtk_box_pack_start(GTK_BOX(global->monitor->opt_vbox), GTK_WIDGET(color_hbox[i]), FALSE, FALSE, 0); color_label[i] = gtk_label_new(_(color_text[i])); gtk_misc_set_alignment(GTK_MISC(color_label[i]), 0, 0.5); gtk_widget_show(GTK_WIDGET(color_label[i])); gtk_box_pack_start(GTK_BOX(color_hbox[i]), GTK_WIDGET(color_label[i]), FALSE, FALSE, 0); global->monitor->opt_button[i] = gtk_button_new(); global->monitor->opt_da[i] = gtk_drawing_area_new(); gtk_widget_modify_bg(global->monitor->opt_da[i], GTK_STATE_NORMAL, &global->monitor->options.color[i]); gtk_widget_set_size_request(global->monitor->opt_da[i], 64, 12); gtk_container_add(GTK_CONTAINER(global->monitor->opt_button[i]), global->monitor->opt_da[i]); gtk_widget_show(GTK_WIDGET(global->monitor->opt_button[i])); gtk_widget_show(GTK_WIDGET(global->monitor->opt_da[i])); gtk_box_pack_start(GTK_BOX(color_hbox[i]), GTK_WIDGET(global->monitor->opt_button[i]), FALSE, FALSE, 0); gtk_size_group_add_widget(sg, color_label[i]); } gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(global->monitor->opt_vbox), FALSE, FALSE, 0); align = gtk_alignment_new(0, 0, 0, 0); gtk_widget_set_size_request(align, 5, 5); gtk_widget_show(GTK_WIDGET(align)); gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(align), FALSE, FALSE, 0); gtk_box_pack_start( GTK_BOX(global_vbox), GTK_WIDGET(vbox), FALSE, FALSE, 0); g_signal_connect(GTK_WIDGET(global->monitor->max_use_label), "toggled", G_CALLBACK(max_label_toggled), global); g_signal_connect(GTK_WIDGET(global->monitor->opt_da[0]), "expose_event", G_CALLBACK(expose_event_cb), NULL); g_signal_connect(GTK_WIDGET(global->monitor->opt_da[1]), "expose_event", G_CALLBACK(expose_event_cb), NULL); g_signal_connect(GTK_WIDGET(global->monitor->opt_button[IN]), "clicked", G_CALLBACK(change_color_in), global); g_signal_connect(GTK_WIDGET(global->monitor->opt_button[OUT]), "clicked", G_CALLBACK(change_color_out), global); g_signal_connect(GTK_WIDGET(global->monitor->opt_use_label), "toggled", G_CALLBACK(label_toggled), global); g_signal_connect(GTK_WIDGET(global->monitor->opt_entry), "activate", G_CALLBACK(label_changed), global); g_signal_connect(GTK_WIDGET(global->monitor->net_entry), "activate", G_CALLBACK(network_changed), global); g_signal_connect(GTK_WIDGET(done), "clicked", G_CALLBACK(monitor_apply_options_cb), global); }
static void create_children (GNCDateEdit *gde) { GtkWidget *frame; GtkWidget *hbox; GtkWidget *arrow; GtkTreeStore *store; GtkCellRenderer *cell; /* Create the text entry area. */ gde->date_entry = gtk_entry_new (); gtk_entry_set_width_chars (GTK_ENTRY (gde->date_entry), 11); gtk_box_pack_start (GTK_BOX (gde), gde->date_entry, TRUE, TRUE, 0); gtk_widget_show (GTK_WIDGET(gde->date_entry)); g_signal_connect (G_OBJECT (gde->date_entry), "key-press-event", G_CALLBACK (key_press_entry), gde); g_signal_connect (G_OBJECT (gde->date_entry), "focus-out-event", G_CALLBACK (date_focus_out_event), gde); /* Create the popup button. */ gde->date_button = gtk_toggle_button_new (); g_signal_connect (gde->date_button, "button-press-event", G_CALLBACK(gnc_date_edit_button_pressed), gde); g_signal_connect (G_OBJECT (gde->date_button), "toggled", G_CALLBACK (gnc_date_edit_button_toggled), gde); gtk_box_pack_start (GTK_BOX (gde), gde->date_button, FALSE, FALSE, 0); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 3); gtk_box_set_homogeneous (GTK_BOX (hbox), FALSE); gtk_container_add (GTK_CONTAINER (gde->date_button), hbox); gtk_widget_show (GTK_WIDGET(hbox)); /* Calendar label, only shown if the date editor has a time field */ gde->cal_label = gtk_label_new (_("Calendar")); gnc_label_set_alignment (gde->cal_label, 0.0, 0.5); gtk_box_pack_start (GTK_BOX (hbox), gde->cal_label, TRUE, TRUE, 0); if (gde->flags & GNC_DATE_EDIT_SHOW_TIME) gtk_widget_show (GTK_WIDGET(gde->cal_label)); /* Graphic for the popup button. */ arrow = gtk_image_new_from_icon_name ("go-down", GTK_ICON_SIZE_BUTTON); g_signal_connect (G_OBJECT (arrow), "draw", G_CALLBACK (gnc_draw_arrow_cb), GINT_TO_POINTER(1)); gtk_box_pack_start (GTK_BOX (hbox), arrow, TRUE, FALSE, 0); gtk_widget_show (GTK_WIDGET(arrow)); gtk_widget_show (GTK_WIDGET(gde->date_button)); /* Time entry controls. */ gde->time_entry = gtk_entry_new (); gtk_entry_set_max_length (GTK_ENTRY(gde->time_entry), 12); gtk_widget_set_size_request (GTK_WIDGET(gde->time_entry), 88, -1); gtk_box_pack_start (GTK_BOX (gde), gde->time_entry, TRUE, TRUE, 0); store = gtk_tree_store_new(1, G_TYPE_STRING); gde->time_combo = GTK_WIDGET(gtk_combo_box_new_with_model(GTK_TREE_MODEL(store))); g_object_unref(store); /* Create cell renderer. */ cell = gtk_cell_renderer_text_new(); /* Pack it to the combo box. */ gtk_cell_layout_pack_start( GTK_CELL_LAYOUT( gde->time_combo ), cell, TRUE ); /* Connect renderer to data source */ gtk_cell_layout_set_attributes( GTK_CELL_LAYOUT( gde->time_combo ), cell, "text", 0, NULL ); g_signal_connect (G_OBJECT (gde->time_combo), "changed", G_CALLBACK (set_time), gde); gtk_box_pack_start (GTK_BOX (gde), gde->time_combo, FALSE, FALSE, 0); /* We do not create the popup menu with the hour range until we are * realized, so that it uses the values that the user might supply in a * future call to gnc_date_edit_set_popup_range */ g_signal_connect (G_OBJECT (gde), "realize", G_CALLBACK (fill_time_combo), gde); if (gde->flags & GNC_DATE_EDIT_SHOW_TIME) { gtk_widget_show (GTK_WIDGET(gde->time_entry)); gtk_widget_show (GTK_WIDGET(gde->time_combo)); } gde->cal_popup = gtk_window_new (GTK_WINDOW_POPUP); gtk_widget_set_name (gde->cal_popup, "gnc-date-edit-popup-window"); gtk_window_set_type_hint (GTK_WINDOW (gde->cal_popup), GDK_WINDOW_TYPE_HINT_COMBO); gtk_widget_set_events (GTK_WIDGET(gde->cal_popup), gtk_widget_get_events (GTK_WIDGET(gde->cal_popup)) | GDK_KEY_PRESS_MASK); g_signal_connect (gde->cal_popup, "delete-event", G_CALLBACK(delete_popup), gde); g_signal_connect (gde->cal_popup, "key-press-event", G_CALLBACK(key_press_popup), gde); g_signal_connect (gde->cal_popup, "button-press-event", G_CALLBACK(gnc_date_edit_button_pressed), gde); g_signal_connect (gde->cal_popup, "button-release-event", G_CALLBACK(gnc_date_edit_button_released), gde); gtk_window_set_resizable (GTK_WINDOW (gde->cal_popup), FALSE); gtk_window_set_screen (GTK_WINDOW (gde->cal_popup), gtk_widget_get_screen (GTK_WIDGET (gde))); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE); gtk_container_add (GTK_CONTAINER (gde->cal_popup), frame); gtk_widget_show (GTK_WIDGET(frame)); gde->calendar = gtk_calendar_new (); gtk_calendar_set_display_options (GTK_CALENDAR (gde->calendar), (GTK_CALENDAR_SHOW_DAY_NAMES | GTK_CALENDAR_SHOW_HEADING)); g_signal_connect (gde->calendar, "button-release-event", G_CALLBACK(gnc_date_edit_button_released), gde); g_signal_connect (G_OBJECT (gde->calendar), "day-selected", G_CALLBACK (day_selected), gde); g_signal_connect (G_OBJECT (gde->calendar), "day-selected-double-click", G_CALLBACK (day_selected_double_click), gde); gtk_container_add (GTK_CONTAINER (frame), gde->calendar); gtk_widget_show (GTK_WIDGET(gde->calendar)); }
void FormDialog::multiple_choice (const std::string name, const std::string description, const std::set<std::string> values, const std::map<std::string, std::string> choices, bool advanced) { GtkWidget *label = NULL; GtkWidget *scroll = NULL; GtkWidget *tree_view = NULL; GtkWidget *frame = NULL; GtkListStore *list_store = NULL; GtkTreeViewColumn *column = NULL; GtkCellRenderer *renderer = NULL; GtkTreeIter iter; gchar *label_text = NULL; MultipleChoiceSubmitter *submitter = NULL; grow_fields (advanced); /* The label */ label = gtk_label_new (NULL); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); label_text = g_strdup_printf ("<b>%s</b>", description.c_str()); gtk_label_set_markup_with_mnemonic (GTK_LABEL (label), label_text); g_free (label_text); /* The GtkListStore containing the choices */ tree_view = gtk_tree_view_new (); list_store = gtk_list_store_new (MultipleChoiceSubmitter::COLUMN_NUMBER, G_TYPE_BOOLEAN, G_TYPE_STRING); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (tree_view), TRUE); gtk_tree_view_set_model (GTK_TREE_VIEW (tree_view), GTK_TREE_MODEL (list_store)); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tree_view), FALSE); frame = gtk_frame_new (NULL); gtk_widget_set_size_request (GTK_WIDGET (frame), -1, 125); gtk_container_set_border_width (GTK_CONTAINER (frame), 0); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); scroll = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_container_add (GTK_CONTAINER (frame), scroll); gtk_container_add (GTK_CONTAINER (scroll), tree_view); renderer = gtk_cell_renderer_toggle_new (); column = gtk_tree_view_column_new_with_attributes (NULL, renderer, "active", MultipleChoiceSubmitter::COLUMN_ACTIVE, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column); g_signal_connect (renderer, "toggled", G_CALLBACK (multiple_choice_choice_toggled_cb), list_store); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (NULL, renderer, "text", MultipleChoiceSubmitter::COLUMN_NAME, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column); for (std::map<std::string, std::string>::const_iterator map_iter = choices.begin (); map_iter != choices.end (); map_iter++) { bool active = (std::find (values.begin (), values.end (), map_iter->first) != values.end ()); gtk_list_store_append (GTK_LIST_STORE (list_store), &iter); gtk_list_store_set (GTK_LIST_STORE (list_store), &iter, MultipleChoiceSubmitter::COLUMN_ACTIVE, active, MultipleChoiceSubmitter::COLUMN_NAME, map_iter->second.c_str (), -1); } if (advanced) { gtk_table_attach (GTK_TABLE (advanced_fields), label, 0, 2, advanced_rows - 1, advanced_rows, (GtkAttachOptions) (GTK_FILL|GTK_EXPAND), (GtkAttachOptions) (GTK_FILL|GTK_EXPAND), 0, 0); gtk_table_attach (GTK_TABLE (advanced_fields), frame, 0, 2, advanced_rows - 1, advanced_rows, (GtkAttachOptions) (GTK_FILL|GTK_EXPAND), (GtkAttachOptions) (GTK_FILL|GTK_EXPAND), 0, 0); } else { gtk_table_attach (GTK_TABLE (fields), label, 0, 2, rows - 1, rows, (GtkAttachOptions) (GTK_FILL|GTK_EXPAND), (GtkAttachOptions) (GTK_FILL|GTK_EXPAND), 0, 0); gtk_table_attach (GTK_TABLE (fields), frame, 0, 2, rows - 1, rows, (GtkAttachOptions) (GTK_FILL|GTK_EXPAND), (GtkAttachOptions) (GTK_FILL|GTK_EXPAND), 0, 0); } submitter = new MultipleChoiceSubmitter (name, description, choices, advanced, tree_view); submitters.push_back (submitter); }