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); }
G_MODULE_EXPORT gboolean create_2d_table_editor(gint table_num, GtkWidget *parent) { GladeXML *main_xml = NULL; GladeXML *xml = NULL; GtkWidget *widget = NULL; GtkWidget *window = NULL; GtkWidget *curve = NULL; GtkWidget *x_parent = NULL; GtkWidget *y_parent = NULL; GtkWidget *x_table = NULL; GtkWidget *y_table = NULL; GtkWidget *label = NULL; GtkWidget *entry = NULL; GtkWidget *dummy = NULL; GtkWidget *gauge = NULL; GtkWidget *curve_parent = NULL; CurveData *cdata = NULL; GArray *x_entries = NULL; GArray *y_entries = NULL; GList *widget_list = NULL; GList *curve_list = NULL; GList *gauge_list = NULL; gchar * tmpbuf = NULL; gchar * filename = NULL; GList ***ecu_widgets = NULL; gfloat *mult = NULL; gfloat *adder = NULL; gfloat raw_lower = 0; gfloat raw_upper = 0; gint x_mult = 0; gint y_mult = 0; gint page = 0; gint offset = 0; gint i = 0; guint32 id = 0; gfloat tmpf = 0.0; gint rows = 0; gboolean embedded = FALSE; Firmware_Details *firmware = NULL; firmware = DATA_GET(global_data,"firmware"); ecu_widgets = DATA_GET(global_data,"ecu_widgets"); if (table_num >= firmware->total_te_tables) { warn_user_f("Requested to create 2D table editor window for an undefined (out of range) table ID"); return FALSE; } if (!firmware->te_params) { warn_user_f("No 2D table Editor tables (te_tables) defined in interrogation profile, yet told to create a graph for a table... BUG detected!"); return FALSE; } if (!firmware->te_params[table_num]) { warn_user_f("Requested to create a 2D table editor window for an undefined table!"); return FALSE; } main_xml = (GladeXML *)DATA_GET(global_data,"main_xml"); if (!main_xml) return FALSE; if (GTK_IS_WIDGET(parent)) /* Embedded mode */ embedded = TRUE; if (!embedded) { xml = glade_xml_new(main_xml->filename,"table_editor_window",NULL); window = glade_xml_get_widget(xml,"table_editor_window"); if (firmware->te_params[table_num]->bind_to_list) { OBJ_SET_FULL(window,"bind_to_list", g_strdup(firmware->te_params[table_num]->bind_to_list),g_free); OBJ_SET(window,"match_type", GINT_TO_POINTER(firmware->te_params[table_num]->match_type)); bind_to_lists_f(window,firmware->te_params[table_num]->bind_to_list); widget_list = g_list_prepend(widget_list,(gpointer)window); } glade_xml_signal_autoconnect(xml); g_signal_connect(G_OBJECT(window),"destroy_event", G_CALLBACK(close_2d_editor),NULL); g_signal_connect(G_OBJECT(window),"delete_event", G_CALLBACK(close_2d_editor),NULL); tmpbuf = g_strdup_printf("%s (%s)",_("2D Table Editor"),firmware->te_params[table_num]->title); gtk_window_set_title(GTK_WINDOW(window),tmpbuf); g_free(tmpbuf); gtk_window_set_default_size(GTK_WINDOW(window),640,480); widget = glade_xml_get_widget(xml,"2d_close_button"); g_signal_connect_swapped(G_OBJECT(widget),"clicked", G_CALLBACK(close_2d_editor),window); widget = glade_xml_get_widget(xml,"get_data_button"); OBJ_SET(widget,"handler",GINT_TO_POINTER(READ_VE_CONST)); OBJ_SET_FULL(widget,"bind_to_list",g_strdup("get_data_buttons"),g_free); bind_to_lists_f(widget,"get_data_buttons"); widget_list = g_list_prepend(widget_list,(gpointer)widget); widget = glade_xml_get_widget(xml,"burn_data_button"); OBJ_SET(widget,"handler",GINT_TO_POINTER(BURN_MS_FLASH)); OBJ_SET_FULL(widget,"bind_to_list",g_strdup("burners"),g_free); bind_to_lists_f(widget,"burners"); widget_list = g_list_prepend(widget_list,(gpointer)widget); widget = glade_xml_get_widget(xml,"curve_editor_menuitem"); gtk_widget_set_sensitive(GTK_WIDGET(widget), FALSE); widget = glade_xml_get_widget(xml,"close_menuitem"); OBJ_SET(widget,"window",(gpointer)window); curve_parent = glade_xml_get_widget(xml,"te_right_frame"); } else curve_parent = parent; curve = mtx_curve_new(); if (!embedded) curve_list = g_list_prepend(curve_list,(gpointer)curve); mtx_curve_set_title(MTX_CURVE(curve),(gchar *)_(firmware->te_params[table_num]->title)); mtx_curve_set_x_axis_label(MTX_CURVE(curve),_(firmware->te_params[table_num]->x_axis_label)); mtx_curve_set_y_axis_label(MTX_CURVE(curve),_(firmware->te_params[table_num]->y_axis_label)); if ((firmware->te_params[table_num]->gauge || firmware->te_params[table_num]->c_gauge || firmware->te_params[table_num]->f_gauge) && (!embedded)) { parent = glade_xml_get_widget(xml,"te_gaugeframe"); gauge = mtx_gauge_face_new(); gauge_list = g_list_prepend(gauge_list,(gpointer)gauge); if (firmware->te_params[table_num]->gauge_temp_dep) { if ((GINT)DATA_GET(global_data,"mtx_temp_units") == CELSIUS) tmpbuf = g_strdelimit(firmware->te_params[table_num]->c_gauge,"\\",'/'); else if ((GINT)DATA_GET(global_data,"mtx_temp_units") == KELVIN) tmpbuf = g_strdelimit(firmware->te_params[table_num]->c_gauge,"\\",'/'); else tmpbuf = g_strdelimit(firmware->te_params[table_num]->f_gauge,"\\",'/'); } else tmpbuf = g_strdelimit(firmware->te_params[table_num]->gauge,"\\",'/'); filename = get_file(g_strconcat(GAUGES_DATA_DIR,PSEP,tmpbuf,NULL),NULL); mtx_gauge_face_import_xml(MTX_GAUGE_FACE(gauge),filename); lookup_current_value_f(firmware->te_params[table_num]->gauge_datasource, &tmpf); mtx_gauge_face_set_value(MTX_GAUGE_FACE(gauge),tmpf); g_free(filename); id = create_value_change_watch_f(firmware->te_params[table_num]->gauge_datasource,FALSE,"update_misc_gauge",(gpointer)gauge); OBJ_SET(gauge,"gauge_id",GINT_TO_POINTER(id)); gtk_container_add(GTK_CONTAINER(parent),gauge); } cdata = g_new0(CurveData, 1); cdata->curve = curve; cdata->axis = _X_; cdata->source = firmware->te_params[table_num]->x_source; mtx_curve_set_show_x_marker(MTX_CURVE(curve),TRUE); OBJ_SET(curve,"cdata",(gpointer)cdata); mtx_curve_set_auto_hide_vertexes(MTX_CURVE(curve),TRUE); g_signal_connect(G_OBJECT(curve),"coords-changed", G_CALLBACK(coords_changed), NULL); g_signal_connect(G_OBJECT(curve),"vertex-proximity", G_CALLBACK(vertex_proximity), NULL); g_signal_connect(G_OBJECT(curve),"marker-proximity", G_CALLBACK(marker_proximity), NULL); if (!embedded) { label = glade_xml_get_widget(xml,"x_units"); gtk_label_set_markup(GTK_LABEL(label),firmware->te_params[table_num]->x_units); label = glade_xml_get_widget(xml,"y_units"); gtk_label_set_markup(GTK_LABEL(label),firmware->te_params[table_num]->y_units); label = glade_xml_get_widget(xml,"x_title"); gtk_label_set_markup(GTK_LABEL(label),firmware->te_params[table_num]->x_name); label = glade_xml_get_widget(xml,"y_title"); gtk_label_set_markup(GTK_LABEL(label),firmware->te_params[table_num]->y_name); } rows = firmware->te_params[table_num]->bincount; mtx_curve_set_empty_array(MTX_CURVE(curve),rows); x_table = gtk_table_new(rows,1,FALSE); y_table = gtk_table_new(rows,1,FALSE); if (embedded) { x_parent = gtk_frame_new(NULL); y_parent = gtk_frame_new(NULL); } else { x_parent = glade_xml_get_widget(xml,"te_x_frame"); y_parent = glade_xml_get_widget(xml,"te_y_frame"); } gtk_container_set_border_width(GTK_CONTAINER(x_table),5); gtk_container_set_border_width(GTK_CONTAINER(y_table),5); gtk_container_add(GTK_CONTAINER(x_parent),x_table); gtk_container_add(GTK_CONTAINER(y_parent),y_table); x_mult = get_multiplier_f(firmware->te_params[table_num]->x_size); y_mult = get_multiplier_f(firmware->te_params[table_num]->y_size); x_entries = g_array_new(FALSE,TRUE,sizeof(GtkWidget *)); y_entries = g_array_new(FALSE,TRUE,sizeof(GtkWidget *)); for (i=0;i<rows;i++) { /* X Column */ entry = gtk_entry_new(); OBJ_SET(entry,"curve_index",GINT_TO_POINTER(i)); gtk_entry_set_width_chars(GTK_ENTRY(entry),7); OBJ_SET(entry,"curve_index",GINT_TO_POINTER(i)); g_array_insert_val(x_entries,i,entry); OBJ_SET(entry,"curve_axis",GINT_TO_POINTER(_X_)); OBJ_SET(entry,"dl_type",GINT_TO_POINTER(IMMEDIATE)); OBJ_SET(entry,"handler",GINT_TO_POINTER(GENERIC)); OBJ_SET_FULL(entry,"raw_lower",g_strdup_printf("%i",(firmware->te_params[table_num]->x_raw_lower)),g_free); OBJ_SET_FULL(entry,"raw_upper",g_strdup_printf("%i",(firmware->te_params[table_num]->x_raw_upper)),g_free); OBJ_SET(entry,"fromecu_mult",firmware->te_params[table_num]->x_fromecu_mult); OBJ_SET(entry,"fromecu_add",firmware->te_params[table_num]->x_fromecu_add); OBJ_SET(entry,"precision",GINT_TO_POINTER(firmware->te_params[table_num]->x_precision)); OBJ_SET(entry,"size",GINT_TO_POINTER(firmware->te_params[table_num]->x_size)); OBJ_SET(entry,"page",GINT_TO_POINTER(firmware->te_params[table_num]->x_page)); OBJ_SET(entry,"temp_dep",GINT_TO_POINTER(firmware->te_params[table_num]->x_temp_dep)); OBJ_SET(entry,"use_color",GINT_TO_POINTER(firmware->te_params[table_num]->x_use_color)); OBJ_SET(entry,"force_color_update",GINT_TO_POINTER(firmware->te_params[table_num]->x_use_color)); if(firmware->te_params[table_num]->x_temp_dep) { OBJ_SET(entry,"widget_temp",DATA_GET(global_data,"mtx_temp_units")); OBJ_SET_FULL(entry,"bind_to_list",g_strdup("temperature"),g_free); bind_to_lists_f(entry,"temperature"); } offset = (i*x_mult) + firmware->te_params[table_num]->x_base; OBJ_SET(entry,"offset",GINT_TO_POINTER(offset)); g_signal_connect(G_OBJECT(entry),"changed", G_CALLBACK(update_2d_curve),curve); g_signal_connect(G_OBJECT(entry),"changed", G_CALLBACK(entry_changed_handler_f),NULL); g_signal_connect(G_OBJECT(entry),"key_press_event", G_CALLBACK(key_event_f),NULL); g_signal_connect(G_OBJECT(entry),"key_release_event", G_CALLBACK(key_event_f),NULL); g_signal_connect(G_OBJECT(entry),"focus_out_event", G_CALLBACK(focus_out_handler_f),NULL); g_signal_connect(G_OBJECT(entry),"activate", G_CALLBACK(std_entry_handler_f),NULL); if (firmware->te_params[table_num]->reversed) gtk_table_attach(GTK_TABLE(x_table),entry, 0,1,rows-i-1,rows-i, GTK_SHRINK,GTK_SHRINK,0,0); else gtk_table_attach(GTK_TABLE(x_table),entry, 0,1,i,i+1, GTK_SHRINK,GTK_SHRINK,0,0); page = firmware->te_params[table_num]->x_page; ecu_widgets[page][offset] = g_list_prepend(ecu_widgets[page][offset],(gpointer)entry); if (!embedded) widget_list = g_list_prepend(widget_list,(gpointer)entry); update_widget(G_OBJECT(entry),NULL); /* Y Column */ entry = gtk_entry_new(); gtk_entry_set_width_chars(GTK_ENTRY(entry),7); OBJ_SET(entry,"curve_index",GINT_TO_POINTER(i)); g_array_insert_val(y_entries,i,entry); OBJ_SET(entry,"curve_axis",GINT_TO_POINTER(_Y_)); OBJ_SET(entry,"dl_type",GINT_TO_POINTER(IMMEDIATE)); OBJ_SET(entry,"handler",GINT_TO_POINTER(GENERIC)); OBJ_SET_FULL(entry,"raw_lower",g_strdup_printf("%i",(firmware->te_params[table_num]->y_raw_lower)),g_free); OBJ_SET_FULL(entry,"raw_upper",g_strdup_printf("%i",(firmware->te_params[table_num]->y_raw_upper)),g_free); OBJ_SET(entry,"fromecu_mult",firmware->te_params[table_num]->y_fromecu_mult); OBJ_SET(entry,"fromecu_add",firmware->te_params[table_num]->y_fromecu_add); OBJ_SET(entry,"precision",GINT_TO_POINTER(firmware->te_params[table_num]->y_precision)); OBJ_SET(entry,"size",GINT_TO_POINTER(firmware->te_params[table_num]->y_size)); OBJ_SET(entry,"page",GINT_TO_POINTER(firmware->te_params[table_num]->y_page)); OBJ_SET(entry,"temp_dep",GINT_TO_POINTER(firmware->te_params[table_num]->y_temp_dep)); OBJ_SET(entry,"use_color",GINT_TO_POINTER(firmware->te_params[table_num]->y_use_color)); OBJ_SET(entry,"force_color_update",GINT_TO_POINTER(firmware->te_params[table_num]->y_use_color)); if(firmware->te_params[table_num]->y_temp_dep) { OBJ_SET(entry,"widget_temp",DATA_GET(global_data,"mtx_temp_units")); OBJ_SET_FULL(entry,"bind_to_list",g_strdup("temperature"),g_free); bind_to_lists_f(entry,"temperature"); } offset = (i*y_mult) + firmware->te_params[table_num]->y_base; OBJ_SET(entry,"offset",GINT_TO_POINTER(offset)); g_signal_connect(G_OBJECT(entry),"changed", G_CALLBACK(update_2d_curve),curve); g_signal_connect(G_OBJECT(entry),"changed", G_CALLBACK(entry_changed_handler_f),NULL); g_signal_connect(G_OBJECT(entry),"key_press_event", G_CALLBACK(key_event_f),NULL); g_signal_connect(G_OBJECT(entry),"key_release_event", G_CALLBACK(key_event_f),NULL); g_signal_connect(G_OBJECT(entry),"focus_out_event", G_CALLBACK(focus_out_handler_f),NULL); g_signal_connect(G_OBJECT(entry),"activate", G_CALLBACK(std_entry_handler_f),NULL); if (firmware->te_params[table_num]->reversed) gtk_table_attach(GTK_TABLE(y_table),entry, 0,1,rows-i-1,rows-i, GTK_SHRINK,GTK_SHRINK,0,0); else gtk_table_attach(GTK_TABLE(y_table),entry, 0,1,i,i+1, GTK_SHRINK,GTK_SHRINK,0,0); page = firmware->te_params[table_num]->y_page; ecu_widgets[page][offset] = g_list_prepend(ecu_widgets[page][offset],(gpointer)entry); if (!embedded) widget_list = g_list_prepend(widget_list,(gpointer)entry); update_widget(G_OBJECT(entry),NULL); } /* Create the "LOCK" buttons */ dummy = gtk_toggle_button_new_with_label("Unlocked"); OBJ_SET(dummy,"axis",GINT_TO_POINTER(_X_)); g_signal_connect(G_OBJECT(dummy),"toggled", G_CALLBACK(set_axis_locking),curve); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dummy),firmware->te_params[table_num]->x_lock); gtk_table_attach(GTK_TABLE(x_table),dummy, 0,1,i,i+1, GTK_EXPAND|GTK_FILL,0,0,0); dummy = gtk_toggle_button_new_with_label("Unlocked"); OBJ_SET(dummy,"axis",GINT_TO_POINTER(_Y_)); g_signal_connect(G_OBJECT(dummy),"toggled", G_CALLBACK(set_axis_locking),curve); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dummy),firmware->te_params[table_num]->y_lock); gtk_table_attach(GTK_TABLE(y_table),dummy, 0,1,i,i+1, GTK_EXPAND|GTK_FILL,0,0,0); mtx_curve_set_x_precision(MTX_CURVE(curve),firmware->te_params[table_num]->x_precision); mtx_curve_set_y_precision(MTX_CURVE(curve),firmware->te_params[table_num]->y_precision); mult = firmware->te_params[table_num]->x_fromecu_mult; adder = firmware->te_params[table_num]->x_fromecu_add; raw_lower = firmware->te_params[table_num]->x_raw_lower; raw_upper = firmware->te_params[table_num]->x_raw_upper; if ((mult) && (adder)) { firmware->te_params[table_num]->x_2d_lower_limit = (raw_lower * (*mult)) + (*adder); firmware->te_params[table_num]->x_2d_upper_limit = (raw_upper * (*mult)) + (*adder); } else if (mult) { firmware->te_params[table_num]->x_2d_lower_limit = raw_lower * (*mult); firmware->te_params[table_num]->x_2d_upper_limit = raw_upper * (*mult); } else { firmware->te_params[table_num]->x_2d_lower_limit = raw_lower; firmware->te_params[table_num]->x_2d_upper_limit = raw_upper; } /* Y */ mult = firmware->te_params[table_num]->y_fromecu_mult; adder = firmware->te_params[table_num]->y_fromecu_add; raw_lower = firmware->te_params[table_num]->y_raw_lower; raw_upper = firmware->te_params[table_num]->y_raw_upper; if ((mult) && (adder)) { firmware->te_params[table_num]->y_2d_lower_limit = (raw_lower * (*mult)) + (*adder); firmware->te_params[table_num]->y_2d_upper_limit = (raw_upper * (*mult)) + (*adder); } else if (mult) { firmware->te_params[table_num]->y_2d_lower_limit = raw_lower * (*mult); firmware->te_params[table_num]->y_2d_upper_limit = raw_upper * (*mult); } else { firmware->te_params[table_num]->y_2d_lower_limit = raw_lower; firmware->te_params[table_num]->y_2d_upper_limit = raw_upper; } mtx_curve_set_hard_limits(MTX_CURVE(curve), firmware->te_params[table_num]->x_2d_lower_limit, firmware->te_params[table_num]->x_2d_upper_limit, firmware->te_params[table_num]->y_2d_lower_limit, firmware->te_params[table_num]->y_2d_upper_limit); /* One shot to get marker drawn. */ create_value_change_watch_f(cdata->source,TRUE,"update_curve_marker",(gpointer)cdata); /* continuous to catch changes. */ id = create_value_change_watch_f(cdata->source,FALSE,"update_curve_marker",(gpointer)cdata); OBJ_SET(curve,"marker_id",GINT_TO_POINTER(id)); if (!embedded) { OBJ_SET(window,"widget_list",widget_list); OBJ_SET(window,"curve_list",curve_list); OBJ_SET(window,"x_entries",x_entries); OBJ_SET(window,"y_entries",y_entries); } /* else { OBJ_SET(parent,"widget_list",widget_list); OBJ_SET(parent,"curve_list",curve_list); OBJ_SET(parent,"x_entries",x_entries); OBJ_SET(parent,"y_entries",y_entries); } */ OBJ_SET(curve,"x_entries",x_entries); OBJ_SET(curve,"y_entries",y_entries); gtk_container_add(GTK_CONTAINER(curve_parent),curve); if (embedded) gtk_widget_show_all(curve); else gtk_widget_show_all(window); return TRUE; }
void filter_expression_save_dlg(gpointer data) { GtkWidget *main_vb, *main_filter_save_hb, *filter_save_frame, *filter_save_type_vb, *filter_save_type_hb, *entry_hb, *bbox, *ok_bt, *cancel_bt, *help_bt, *filter_text_box, *label_text_box; const char *expr; /* The filter requested */ expr = gtk_entry_get_text(GTK_ENTRY(data)); if (filter_save_frame_w != NULL) { /* There's already a "Filter Save" dialog box; reactivate it. */ reactivate_window(filter_save_frame_w); return; } filter_save_frame_w = dlg_window_new("Wireshark: Save Filter"); /* Container for each row of widgets */ main_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 3, FALSE); gtk_container_set_border_width(GTK_CONTAINER(main_vb), 5); gtk_container_add(GTK_CONTAINER(filter_save_frame_w), main_vb); gtk_widget_show(main_vb); /* */ main_filter_save_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3, FALSE); gtk_container_add(GTK_CONTAINER(main_vb), main_filter_save_hb); gtk_widget_show(main_filter_save_hb); /* Filter Save frame */ filter_save_frame = gtk_frame_new("Save Filter as..."); gtk_box_pack_start(GTK_BOX(main_filter_save_hb), filter_save_frame, TRUE, TRUE, 0); gtk_widget_show(filter_save_frame); filter_save_type_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 3, FALSE); gtk_container_set_border_width(GTK_CONTAINER(filter_save_type_vb), 3); gtk_container_add(GTK_CONTAINER(filter_save_frame), filter_save_type_vb); gtk_widget_show(filter_save_type_vb); /* filter_save type row */ filter_save_type_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3, FALSE); gtk_container_add(GTK_CONTAINER(filter_save_type_vb), filter_save_type_hb); gtk_widget_show(filter_save_type_hb); /* filter_save row */ entry_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3, FALSE); gtk_box_pack_start(GTK_BOX(filter_save_type_vb), entry_hb, FALSE, FALSE, 0); gtk_widget_show(entry_hb); filter_text_box = gtk_entry_new(); gtk_box_pack_start(GTK_BOX(entry_hb), filter_text_box, TRUE, TRUE, 0); g_signal_connect(filter_text_box, "changed", G_CALLBACK(filter_te_syntax_check_cb), NULL); g_signal_connect(filter_text_box, "key-press-event", G_CALLBACK (filter_string_te_key_pressed_cb), NULL); g_signal_connect(filter_save_frame_w, "key-press-event", G_CALLBACK (filter_parent_dlg_key_pressed_cb), NULL); gtk_entry_set_text(GTK_ENTRY(filter_text_box), expr); gtk_widget_show(filter_text_box); label_text_box = gtk_entry_new(); gtk_box_pack_start(GTK_BOX(entry_hb), label_text_box, TRUE, TRUE, 0); gtk_entry_set_text(GTK_ENTRY(label_text_box), "Filter"); gtk_widget_show(label_text_box); /* Button row */ bbox = dlg_button_row_new(GTK_STOCK_OK, GTK_STOCK_CANCEL, GTK_STOCK_HELP, NULL); gtk_box_pack_start(GTK_BOX(main_vb), bbox, FALSE, FALSE, 0); gtk_widget_show(bbox); ok_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_OK); g_signal_connect(ok_bt, "clicked", G_CALLBACK(filter_save_ok_cb), filter_save_frame_w); cancel_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_CANCEL); g_signal_connect(cancel_bt, "clicked", G_CALLBACK(filter_save_close_cb), filter_save_frame_w); help_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_HELP); g_signal_connect(help_bt, "clicked", G_CALLBACK(topic_cb), (gpointer)HELP_FILTER_SAVE_DIALOG); g_object_set_data(G_OBJECT(filter_save_frame_w), E_FILTER_SAVE_EXPR_KEY, filter_text_box); g_object_set_data(G_OBJECT(filter_save_frame_w), E_FILTER_SAVE_LABEL_KEY, label_text_box); dlg_set_activate(label_text_box, ok_bt); /* Give the initial focus to the "offset" entry box. */ gtk_widget_grab_focus(label_text_box); g_signal_connect(filter_save_frame_w, "delete_event", G_CALLBACK(window_delete_event_cb), NULL); g_signal_connect(filter_save_frame_w, "destroy", G_CALLBACK(filter_save_frame_destroy_cb), NULL); gtk_widget_show(filter_save_frame_w); window_present(filter_save_frame_w); }
GtkWidget *plugin_configure(GtkDialog *dialog) { GtkWidget *label_language, *label_dir, *vbox; GtkWidget *combo, *check_type, *check_on_open, *check_msgwin, *check_toolbar, *check_editor_menu; GtkWidget *vbox_interface, *frame_interface, *label_interface; GtkWidget *vbox_behavior, *frame_behavior, *label_behavior; #ifdef HAVE_ENCHANT_1_5 GtkWidget *entry_dir, *hbox, *button, *image; #endif vbox = gtk_vbox_new(FALSE, 6); check_toolbar = gtk_check_button_new_with_label( _("Show toolbar item to toggle spell checking")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_toolbar), sc_info->show_toolbar_item); check_editor_menu = gtk_check_button_new_with_label( _("Show editor menu item to show spelling suggestions")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_editor_menu), sc_info->show_editor_menu_item); check_msgwin = gtk_check_button_new_with_label( _("Print misspelled words and suggestions in the messages window")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_msgwin), sc_info->use_msgwin); vbox_interface = gtk_vbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox_interface), check_toolbar, FALSE, FALSE, 3); gtk_box_pack_start(GTK_BOX(vbox_interface), check_editor_menu, TRUE, TRUE, 3); gtk_box_pack_start(GTK_BOX(vbox_interface), check_msgwin, TRUE, TRUE, 3); label_interface = gtk_label_new(NULL); gtk_label_set_use_markup(GTK_LABEL(label_interface), TRUE); gtk_label_set_markup(GTK_LABEL(label_interface), _("<b>Interface</b>")); frame_interface = gtk_frame_new(NULL); gtk_frame_set_label_widget(GTK_FRAME(frame_interface), label_interface); gtk_container_add(GTK_CONTAINER(frame_interface), vbox_interface); gtk_box_pack_start(GTK_BOX(vbox), frame_interface, FALSE, FALSE, 3); check_type = gtk_check_button_new_with_label(_("Check spelling while typing")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_type), sc_info->check_while_typing); check_on_open = gtk_check_button_new_with_label(_("Check spelling when opening a document")); ui_widget_set_tooltip_text(check_on_open, _("Enabling this option will check every document after it is opened in Geany. " "Reloading a document will also trigger a re-check.")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_on_open), sc_info->check_on_document_open); label_language = gtk_label_new(_("Language to use for the spell check:")); gtk_misc_set_alignment(GTK_MISC(label_language), 0, 0.5); combo = gtk_combo_box_text_new(); populate_dict_combo(GTK_COMBO_BOX(combo)); if (sc_info->dicts->len > 20) gtk_combo_box_set_wrap_width(GTK_COMBO_BOX(combo), 3); else if (sc_info->dicts->len > 10) gtk_combo_box_set_wrap_width(GTK_COMBO_BOX(combo), 2); #ifdef HAVE_ENCHANT_1_5 label_dir = gtk_label_new_with_mnemonic(_("_Directory to look for dictionary files:")); gtk_misc_set_alignment(GTK_MISC(label_dir), 0, 0.5); entry_dir = gtk_entry_new(); ui_entry_add_clear_icon(GTK_ENTRY(entry_dir)); gtk_label_set_mnemonic_widget(GTK_LABEL(label_dir), entry_dir); ui_widget_set_tooltip_text(entry_dir, _("Read additional dictionary files from this directory. " "For now, this only works with myspell dictionaries.")); if (! EMPTY(sc_info->dictionary_dir)) gtk_entry_set_text(GTK_ENTRY(entry_dir), sc_info->dictionary_dir); button = gtk_button_new(); g_signal_connect(button, "clicked", G_CALLBACK(dictionary_dir_button_clicked_cb), entry_dir); image = gtk_image_new_from_stock("gtk-open", GTK_ICON_SIZE_BUTTON); gtk_container_add(GTK_CONTAINER(button), image); hbox = gtk_hbox_new(FALSE, 6); gtk_box_pack_start(GTK_BOX(hbox), entry_dir, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0); g_object_set_data(G_OBJECT(dialog), "dict_dir", entry_dir); #endif vbox_behavior = gtk_vbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox_behavior), check_type, FALSE, FALSE, 3); gtk_box_pack_start(GTK_BOX(vbox_behavior), check_on_open, TRUE, TRUE, 3); gtk_box_pack_start(GTK_BOX(vbox_behavior), label_language, TRUE, TRUE, 3); gtk_box_pack_start(GTK_BOX(vbox_behavior), combo, TRUE, TRUE, 3); #ifdef HAVE_ENCHANT_1_5 gtk_box_pack_start(GTK_BOX(vbox_behavior), label_dir, TRUE, TRUE, 3); gtk_box_pack_start(GTK_BOX(vbox_behavior), hbox, TRUE, TRUE, 3); #endif label_behavior = gtk_label_new(NULL); gtk_label_set_use_markup(GTK_LABEL(label_behavior), TRUE); gtk_label_set_markup(GTK_LABEL(label_behavior), _("<b>Behavior</b>")); frame_behavior = gtk_frame_new(NULL); gtk_frame_set_label_widget(GTK_FRAME(frame_behavior), label_behavior); gtk_container_add(GTK_CONTAINER(frame_behavior), vbox_behavior); gtk_box_pack_start(GTK_BOX(vbox), frame_behavior, FALSE, FALSE, 3); g_object_set_data(G_OBJECT(dialog), "combo", combo); g_object_set_data(G_OBJECT(dialog), "check_type", check_type); g_object_set_data(G_OBJECT(dialog), "check_on_open", check_on_open); g_object_set_data(G_OBJECT(dialog), "check_msgwin", check_msgwin); g_object_set_data(G_OBJECT(dialog), "check_toolbar", check_toolbar); g_object_set_data(G_OBJECT(dialog), "check_editor_menu", check_editor_menu); g_signal_connect(dialog, "response", G_CALLBACK(configure_response_cb), NULL); gtk_widget_show_all(vbox); return vbox; }
GtkWidget* initGTKStuff(int *argc, char ***argv) { // fprintf(stderr,"explicit threads init %d\n", XInitThreads()); gtk_init(argc, argv); /* Create a new window */ GtkWidget* window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(window), "Java Plugin Host"); /* Here we connect the "destroy" event to a signal handler */ gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC (gtk_main_quit), NULL); gtk_widget_set_usize(window, 300, 400); /* Sets the border width of the window. */ gtk_container_set_border_width (GTK_CONTAINER (window), 10); /* Create a Frame */ GtkWidget* frame = gtk_frame_new(NULL); /* Set the style of the frame */ gtk_frame_set_shadow_type( GTK_FRAME(frame), GTK_SHADOW_ETCHED_OUT); gtk_container_add(GTK_CONTAINER(window), frame); ///////// gtk_signal_connect(GTK_OBJECT(window), "destroy", GTK_SIGNAL_FUNC(gtk_main_quit), NULL); gtk_signal_connect(GTK_OBJECT(window), "delete-event", GTK_SIGNAL_FUNC(gtk_false), NULL); /* Button initialization */ GtkWidget* button1 = gtk_button_new_with_label ("Start JVM"); GtkWidget* button2 = gtk_button_new_with_label ("Stop JVM"); GtkWidget* button3 = gtk_button_new_with_label ("Close application"); GtkWidget* button4 = gtk_button_new_with_label ("Register native window"); GtkWidget* button5 = gtk_button_new_with_label ("Test registered window"); GtkWidget* button6 = gtk_button_new_with_label ("Unregister window"); GtkWidget* button7 = gtk_button_new_with_label ("Enable/Disable system capabilities"); GtkWidget* button8 = gtk_button_new_with_label ("Attach new native thread"); GtkWidget* button9 = gtk_button_new_with_label ("Get WF description"); GtkWidget* button10 = gtk_button_new_with_label ("Register test extension"); GtkWidget* button11 = gtk_button_new_with_label ("Create/Remove test peer"); GtkWidget* button12 = gtk_button_new_with_label ("Test Java/native locking ability"); GtkWidget* button13 = gtk_button_new_with_label ("Show/hide Java console"); gtk_signal_connect (GTK_OBJECT (button1), "clicked", GTK_SIGNAL_FUNC (b1_handler), NULL); gtk_signal_connect (GTK_OBJECT (button2), "clicked", GTK_SIGNAL_FUNC (b2_handler), NULL); gtk_signal_connect_object (GTK_OBJECT (button3), "clicked", GTK_SIGNAL_FUNC (gtk_main_quit), GTK_OBJECT (window)); gtk_signal_connect_object (GTK_OBJECT (button4), "clicked", GTK_SIGNAL_FUNC (b4_handler), GTK_OBJECT (window)); gtk_signal_connect_object (GTK_OBJECT (button5), "clicked", GTK_SIGNAL_FUNC (b5_handler), GTK_OBJECT (window)); gtk_signal_connect_object (GTK_OBJECT (button6), "clicked", GTK_SIGNAL_FUNC (b6_handler), GTK_OBJECT (window)); gtk_signal_connect_object (GTK_OBJECT (button7), "clicked", GTK_SIGNAL_FUNC (b7_handler), GTK_OBJECT (window)); gtk_signal_connect_object (GTK_OBJECT (button8), "clicked", GTK_SIGNAL_FUNC (b8_handler), GTK_OBJECT (window)); gtk_signal_connect_object (GTK_OBJECT (button9), "clicked", GTK_SIGNAL_FUNC (b9_handler), GTK_OBJECT (window)); gtk_signal_connect_object (GTK_OBJECT (button10), "clicked", GTK_SIGNAL_FUNC (b10_handler), GTK_OBJECT (window)); gtk_signal_connect_object (GTK_OBJECT (button11), "clicked", GTK_SIGNAL_FUNC (b11_handler), GTK_OBJECT (window)); gtk_signal_connect_object (GTK_OBJECT (button12), "clicked", GTK_SIGNAL_FUNC (b12_handler), GTK_OBJECT (window)); gtk_signal_connect_object (GTK_OBJECT (button13), "clicked", GTK_SIGNAL_FUNC (b13_handler), GTK_OBJECT (window)); GtkWidget* vbox1 = gtk_vbox_new (FALSE, 4); gtk_box_pack_start (GTK_BOX (vbox1), button1, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox1), button2, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox1), button13, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox1), button10, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox1), button4, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox1), button6, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox1), button7, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox1), button11, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox1), button5, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox1), button8, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox1), button9, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox1), button12, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox1), button3, TRUE, TRUE, 0); gtk_container_add(GTK_CONTAINER(frame), vbox1); /////////// gtk_widget_show(button1); gtk_widget_show(button2); gtk_widget_show(button3); gtk_widget_show(button4); gtk_widget_show(button5); gtk_widget_show(button6); gtk_widget_show(button7); gtk_widget_show(button8); gtk_widget_show(button9); gtk_widget_show(button10); gtk_widget_show(button11); gtk_widget_show(button12); gtk_widget_show(button13); gtk_widget_show(vbox1); gtk_widget_show(frame); /* Display the window */ gtk_widget_show (window); /* another window to play with JDK */ GtkWidget* window1 = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_widget_set_usize(window1, 300, 300); GtkWidget* frame1 = gtk_frame_new(NULL); gtk_frame_set_shadow_type( GTK_FRAME(frame1), GTK_SHADOW_ETCHED_OUT); gtk_container_add(GTK_CONTAINER(window1), frame1); gtk_widget_show (frame1); gtk_widget_show (window1); topLevel = window1; return window1; }
void createMPQCOptimization(GtkWidget *box) { GtkWidget* frame; GtkWidget* vboxFrame; GtkWidget* comboMaxIterations = NULL; GtkWidget* entryMaxIterations = NULL; GtkWidget *table = NULL; gint i; GtkWidget *buttonSinglePoint = NULL; GtkWidget *buttonOptimization = NULL; GtkWidget *button = NULL; static ButtonTypes buttonTypes[] = {SINGLEPOINT, OPTIMIZE}; table = gtk_table_new(3,3,FALSE); frame = gtk_frame_new (_("Type of calcul")); gtk_widget_show (frame); gtk_box_pack_start (GTK_BOX (box), frame, TRUE, TRUE, 3); gtk_frame_set_label_align (GTK_FRAME (frame), 0.5, 0.5); vboxFrame = gtk_vbox_new (FALSE, 3); gtk_widget_show (vboxFrame); gtk_container_add (GTK_CONTAINER (frame), vboxFrame); gtk_box_pack_start (GTK_BOX (vboxFrame), table, TRUE, TRUE, 0); i = 0; button = gtk_radio_button_new_with_label(NULL, _("Single point")); gtk_table_attach(GTK_TABLE(table),button,0,0+1,i,i+1, (GtkAttachOptions) (GTK_FILL | GTK_EXPAND), (GtkAttachOptions) (GTK_FILL | GTK_EXPAND), 3,3); buttonSinglePoint = button; g_object_set_data(G_OBJECT (buttonSinglePoint), "Type", &buttonTypes[0]); g_signal_connect(G_OBJECT(buttonSinglePoint),"clicked", G_CALLBACK(activateRadioButton),NULL); i = 1; button = gtk_radio_button_new_with_label(gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)), _("Optimization")); gtk_table_attach(GTK_TABLE(table),button,0,0+1,i,i+1, (GtkAttachOptions) (GTK_FILL | GTK_EXPAND), (GtkAttachOptions) (GTK_FILL | GTK_EXPAND), 3,3); buttonOptimization = button; g_object_set_data(G_OBJECT (buttonOptimization), "Type", &buttonTypes[1]); g_signal_connect(G_OBJECT(buttonOptimization),"clicked", G_CALLBACK(activateRadioButton),NULL); button = gtk_check_button_new_with_label (_("Transition state")); gtk_table_attach(GTK_TABLE(table),button,1,1+2,i,i+1, (GtkAttachOptions)(GTK_FILL | GTK_EXPAND), (GtkAttachOptions)(GTK_FILL | GTK_EXPAND), 3,3); gtk_widget_set_sensitive(button, mpqcMpqc.optimize); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), FALSE); g_signal_connect(G_OBJECT(button),"clicked", G_CALLBACK(activateTransButton),NULL); g_object_set_data(G_OBJECT (buttonOptimization), "ButtonTransition", button); g_object_set_data(G_OBJECT (buttonSinglePoint), "ButtonTransition", button); i = 2; comboMaxIterations = addMPQCMaxIterationsToTable(table, i, buttonSinglePoint, buttonOptimization); entryMaxIterations = GTK_BIN(comboMaxIterations)->child; g_signal_connect(G_OBJECT(entryMaxIterations),"changed", G_CALLBACK(changedEntryMaxIterations),NULL); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (buttonSinglePoint), !mpqcMpqc.optimize); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (buttonOptimization), mpqcMpqc.optimize); g_object_set_data(G_OBJECT (box), "ButtonSinglePoint", buttonSinglePoint); g_object_set_data(G_OBJECT (box), "ButtonOptimization", buttonOptimization); }
/* * initialization/finalization: */ static GObject * _gtk_user_list_dialog_constructor(GType type, guint n_construct_properties, GObjectConstructParam *construct_params) { GObject *object; GtkWidget *hbox; GtkWidget *vbox; GtkWidget *frame; GtkWidget *align; GtkWidget *scrolled; GtkUserListDialogPrivate *priv; object = G_OBJECT_CLASS(gtk_user_list_dialog_parent_class)->constructor(type, n_construct_properties, construct_params); gtk_widget_push_composite_child(); priv = GTK_USER_LIST_DIALOG(object)->priv; /* create main box */ hbox = gtk_hbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(gtk_deletable_dialog_get_content_area(GTK_DELETABLE_DIALOG(object))), hbox); /* create frame */ frame = gtk_frame_new(NULL); gtk_box_pack_start(GTK_BOX(hbox), frame, TRUE, TRUE, 2); vbox = gtk_vbox_new(FALSE, 5); gtk_container_add(GTK_CONTAINER(frame), vbox); hbox = gtk_hbox_new(FALSE, 5); gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 2); vbox = gtk_vbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 2); /* dialog message */ align = gtk_alignment_new(0, 0, 0, 0); gtk_box_pack_start(GTK_BOX(vbox), align, FALSE, TRUE, 10); priv->label_message = gtk_label_new(""); gtk_container_add(GTK_CONTAINER(align), priv->label_message); /* create tree */ scrolled = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start(GTK_BOX(vbox), scrolled, TRUE, TRUE, 0); priv->tree = _gtk_user_list_dialog_create_tree(GTK_WIDGET(object)); gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled), priv->tree); /* label */ priv->label_count = gtk_label_new(NULL); gtk_box_pack_start(GTK_BOX(vbox), priv->label_count, FALSE, TRUE, 2); /* show widgets */ gtk_widget_show_all(gtk_deletable_dialog_get_content_area(GTK_DELETABLE_DIALOG(object))); gtk_widget_set_visible(priv->label_message, FALSE); gtk_widget_push_composite_child(); return object; }
GtkWidget * create_canvas_fifteen (void) { GtkWidget *vbox; GtkWidget *frame; GtkWidget *canvas; GtkWidget *button; GooCanvasItem **board; GooCanvasItem *root, *rect G_GNUC_UNUSED, *text; int i, x, y; char buf[20]; vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 4); g_object_set (vbox, "margin", 4, NULL); 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); gtk_widget_set_halign (frame, GTK_ALIGN_FILL); gtk_widget_set_valign (frame, GTK_ALIGN_FILL); gtk_widget_set_hexpand (frame, TRUE); gtk_widget_set_vexpand (frame, TRUE); gtk_widget_show (frame); g_object_set (frame, "halign", GTK_ALIGN_CENTER, "valign", GTK_ALIGN_CENTER, NULL); /* Create the canvas and board */ canvas = goo_canvas_new (); g_object_set (G_OBJECT (canvas), "automatic-bounds", TRUE, "bounds-from-origin", FALSE, NULL); root = goo_canvas_get_root_item (GOO_CANVAS (canvas)); gtk_widget_set_size_request (canvas, PIECE_SIZE * 4 + 1, PIECE_SIZE * 4 + 1); #if 0 goo_canvas_set_bounds (GOO_CANVAS (canvas), 0, 0, PIECE_SIZE * 4 + 1, PIECE_SIZE * 4 + 1); #endif gtk_container_add (GTK_CONTAINER (frame), canvas); gtk_widget_show (canvas); board = g_new (GooCanvasItem *, 16); g_object_set_data (G_OBJECT (canvas), "board", board); g_signal_connect (canvas, "destroy", G_CALLBACK (free_stuff), board); for (i = 0; i < 15; i++) { y = i / 4; x = i % 4; board[i] = goo_canvas_group_new (root, NULL); goo_canvas_item_translate (board[i], x * PIECE_SIZE, y * PIECE_SIZE); setup_item_signals (board[i]); rect = goo_canvas_rect_new (board[i], 0, 0, PIECE_SIZE, PIECE_SIZE, "fill_color", get_piece_color (i), "stroke_color", "black", "line-width", 1.0, NULL); sprintf (buf, "%d", i + 1); text = goo_canvas_text_new (board[i], buf, PIECE_SIZE / 2.0, PIECE_SIZE / 2.0, -1, GOO_CANVAS_ANCHOR_CENTER, "font", "Sans bold 24", "fill_color", "black", NULL); g_object_set_data (G_OBJECT (board[i]), "text", text); g_object_set_data (G_OBJECT (board[i]), "piece_num", GINT_TO_POINTER (i)); g_object_set_data (G_OBJECT (board[i]), "piece_pos", GINT_TO_POINTER (i)); } board[15] = NULL; /* Scramble button */ button = gtk_button_new_with_label ("Scramble"); gtk_box_pack_start (GTK_BOX (vbox), button); g_object_set_data (G_OBJECT (button), "board", board); g_signal_connect (button, "clicked", G_CALLBACK (scramble), canvas); gtk_widget_show (button); return vbox; }
void chmod_dialog (gpointer data) { GtkWidget *tempwid, *dialog, *hbox, *vbox; GList * templist, * filelist; gftp_window_data * wdata; gftp_file * tempfle; int num; wdata = data; if (!check_status (_("Chmod"), wdata, gftpui_common_use_threads (wdata->request), 0, 1, wdata->request->chmod != NULL)) return; #if GTK_MAJOR_VERSION == 1 dialog = gtk_dialog_new (); gtk_window_set_title (GTK_WINDOW (dialog), _("Chmod")); gtk_container_border_width (GTK_CONTAINER (GTK_DIALOG (dialog)->action_area), 5); gtk_box_set_homogeneous (GTK_BOX (GTK_DIALOG (dialog)->action_area), TRUE); #else dialog = gtk_dialog_new_with_buttons (_("Chmod"), NULL, 0, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); #endif gtk_window_set_wmclass (GTK_WINDOW(dialog), "Chmod", "gFTP"); gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE); gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (dialog)->vbox), 5); gtk_container_border_width (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), 10); gtk_widget_realize (dialog); if (gftp_icon != NULL) { gdk_window_set_icon (dialog->window, NULL, gftp_icon->pixmap, gftp_icon->bitmap); gdk_window_set_icon_name (dialog->window, gftp_version); } tempwid = gtk_label_new (_("You can now adjust the attributes of your file(s)\nNote: Not all ftp servers support the chmod feature")); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), tempwid, FALSE, FALSE, 0); gtk_widget_show (tempwid); hbox = gtk_hbox_new (TRUE, 5); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); tempwid = gtk_frame_new (_("Special")); gtk_box_pack_start (GTK_BOX (hbox), tempwid, FALSE, FALSE, 0); gtk_widget_show (tempwid); vbox = gtk_vbox_new (TRUE, 5); gtk_container_add (GTK_CONTAINER (tempwid), vbox); gtk_widget_show (vbox); suid = gtk_check_button_new_with_label (_("SUID")); gtk_box_pack_start (GTK_BOX (vbox), suid, FALSE, FALSE, 0); gtk_widget_show (suid); sgid = gtk_check_button_new_with_label (_("SGID")); gtk_box_pack_start (GTK_BOX (vbox), sgid, FALSE, FALSE, 0); gtk_widget_show (sgid); sticky = gtk_check_button_new_with_label (_("Sticky")); gtk_box_pack_start (GTK_BOX (vbox), sticky, FALSE, FALSE, 0); gtk_widget_show (sticky); tempwid = gtk_frame_new (_("User")); gtk_box_pack_start (GTK_BOX (hbox), tempwid, FALSE, FALSE, 0); gtk_widget_show (tempwid); vbox = gtk_vbox_new (TRUE, 5); gtk_container_add (GTK_CONTAINER (tempwid), vbox); gtk_widget_show (vbox); ur = gtk_check_button_new_with_label (_("Read")); gtk_box_pack_start (GTK_BOX (vbox), ur, FALSE, FALSE, 0); gtk_widget_show (ur); uw = gtk_check_button_new_with_label (_("Write")); gtk_box_pack_start (GTK_BOX (vbox), uw, FALSE, FALSE, 0); gtk_widget_show (uw); ux = gtk_check_button_new_with_label (_("Execute")); gtk_box_pack_start (GTK_BOX (vbox), ux, FALSE, FALSE, 0); gtk_widget_show (ux); tempwid = gtk_frame_new (_("Group")); gtk_box_pack_start (GTK_BOX (hbox), tempwid, FALSE, FALSE, 0); gtk_widget_show (tempwid); vbox = gtk_vbox_new (TRUE, 5); gtk_container_add (GTK_CONTAINER (tempwid), vbox); gtk_widget_show (vbox); gr = gtk_check_button_new_with_label (_("Read")); gtk_box_pack_start (GTK_BOX (vbox), gr, FALSE, FALSE, 0); gtk_widget_show (gr); gw = gtk_check_button_new_with_label (_("Write")); gtk_box_pack_start (GTK_BOX (vbox), gw, FALSE, FALSE, 0); gtk_widget_show (gw); gx = gtk_check_button_new_with_label (_("Execute")); gtk_box_pack_start (GTK_BOX (vbox), gx, FALSE, FALSE, 0); gtk_widget_show (gx); tempwid = gtk_frame_new (_("Other")); gtk_box_pack_start (GTK_BOX (hbox), tempwid, FALSE, FALSE, 0); gtk_widget_show (tempwid); vbox = gtk_vbox_new (TRUE, 5); gtk_container_add (GTK_CONTAINER (tempwid), vbox); gtk_widget_show (vbox); or = gtk_check_button_new_with_label (_("Read")); gtk_box_pack_start (GTK_BOX (vbox), or, FALSE, FALSE, 0); gtk_widget_show (or); ow = gtk_check_button_new_with_label (_("Write")); gtk_box_pack_start (GTK_BOX (vbox), ow, FALSE, FALSE, 0); gtk_widget_show (ow); ox = gtk_check_button_new_with_label (_("Execute")); gtk_box_pack_start (GTK_BOX (vbox), ox, FALSE, FALSE, 0); gtk_widget_show (ox); #if GTK_MAJOR_VERSION == 1 tempwid = gtk_button_new_with_label (_("OK")); GTK_WIDGET_SET_FLAGS (tempwid, GTK_CAN_DEFAULT); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->action_area), tempwid, TRUE, TRUE, 0); gtk_signal_connect (GTK_OBJECT (tempwid), "clicked", GTK_SIGNAL_FUNC (dochmod), (gpointer) wdata); gtk_signal_connect_object (GTK_OBJECT (tempwid), "clicked", GTK_SIGNAL_FUNC (gtk_widget_destroy), GTK_OBJECT (dialog)); gtk_widget_grab_default (tempwid); gtk_widget_show (tempwid); tempwid = gtk_button_new_with_label (_(" Cancel ")); GTK_WIDGET_SET_FLAGS (tempwid, GTK_CAN_DEFAULT); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->action_area), tempwid, TRUE, TRUE, 0); gtk_signal_connect_object (GTK_OBJECT (tempwid), "clicked", GTK_SIGNAL_FUNC (gtk_widget_destroy), GTK_OBJECT (dialog)); gtk_widget_show (tempwid); #else g_signal_connect (GTK_OBJECT (dialog), "response", G_CALLBACK (chmod_action), wdata); #endif if (IS_ONE_SELECTED (wdata)) { filelist = wdata->files; templist = gftp_gtk_get_list_selection (wdata); num = 0; templist = get_next_selection (templist, &filelist, &num); tempfle = filelist->data; gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (suid), tempfle->st_mode & S_ISUID); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (ur), tempfle->st_mode & S_IRUSR); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (uw), tempfle->st_mode & S_IWUSR); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (ux), tempfle->st_mode & S_IXUSR); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (sgid), tempfle->st_mode & S_ISGID); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (gr), tempfle->st_mode & S_IRGRP); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (gw), tempfle->st_mode & S_IWGRP); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (gx), tempfle->st_mode & S_IXGRP); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (sticky), tempfle->st_mode & S_ISVTX); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (or), tempfle->st_mode & S_IROTH); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (ow), tempfle->st_mode & S_IWOTH); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (ox), tempfle->st_mode & S_IXOTH); } gtk_widget_show (dialog); }
/*! \brief Creates the lookuptables configurator window (MS1 FW's only) \param widget is unused \param data is unused \returns TRUE on success */ G_MODULE_EXPORT gboolean lookuptables_configurator(GtkWidget *widget, gpointer data) { static gboolean ltc_created = FALSE; static GtkWidget * lookuptables_config_window = NULL; GtkListStore *store = NULL; GtkTreeStore *combostore = NULL; GtkTreeIter iter; GtkTreeIter per_iter; GtkTreeIter sys_iter; GtkCellRenderer *renderer = NULL; GtkTreeViewColumn *column = NULL; GtkWidget * vbox = NULL; GtkWidget * tree = NULL; GtkWidget * frame = NULL; GtkWidget * label = NULL; ListElement *element = NULL; ConfigFile *cfgfile = NULL; GArray *classes = NULL; GList *p_list = NULL; GList *s_list = NULL; gchar * tmpbuf = NULL; gchar ** vector = NULL; gchar ** tmpvector = NULL; Firmware_Details *firmware = NULL; firmware = (Firmware_Details *)DATA_GET(global_data,"firmware"); if ((ltc_created) && (ltc_visible)) return TRUE; if ((ltc_created) && (!ltc_visible)) { gtk_widget_show_all(lookuptables_config_window); return TRUE; } else /* i.e. NOT created, build it */ { lookuptables_config_window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(lookuptables_config_window),_("MegaTunix LookupTables")); gtk_window_set_default_size(GTK_WINDOW(lookuptables_config_window),300,200); vbox = gtk_vbox_new(FALSE,0); gtk_container_add(GTK_CONTAINER(lookuptables_config_window),vbox); gtk_container_set_border_width(GTK_CONTAINER(vbox),5); g_signal_connect(G_OBJECT(lookuptables_config_window),"delete_event", G_CALLBACK(lookuptables_configurator_hide),NULL); ltc_created = TRUE; ltc_visible = TRUE; frame = gtk_frame_new("MegaTunix LookupTables"); gtk_box_pack_start (GTK_BOX(vbox),frame,TRUE,TRUE,5); vbox = gtk_vbox_new(FALSE,0); gtk_container_add(GTK_CONTAINER(frame),vbox); label = gtk_label_new(NULL); gtk_label_set_markup(GTK_LABEL(label),_(" Click on the <i>LookupTable Filename</i> and press <b><u> Enter </u></b> to change ")); gtk_box_pack_start(GTK_BOX(vbox),label,TRUE,TRUE,5); store = gtk_list_store_new(N_COLS, /* total cols */ G_TYPE_STRING, /* int name */ G_TYPE_STRING, /* filename combo*/ G_TYPE_BOOLEAN,/* View/Edit */ G_TYPE_BOOLEAN); /* change */ combostore = gtk_tree_store_new(1,G_TYPE_STRING);/* lookuptable filename */ gtk_tree_store_append(combostore,&per_iter,NULL); gtk_tree_store_append(combostore,&sys_iter,NULL); gtk_tree_store_set(combostore,&per_iter, 0,"Personal", -1); gtk_tree_store_set(combostore,&sys_iter, 0,"System", -1); vector = get_files((const gchar *)DATA_GET(global_data,"project_name"),LOOKUPTABLES_DATA_DIR,"inc",&classes); for (guint i=0;i<g_strv_length(vector);i++) { tmpvector = g_strsplit(vector[i],PSEP,-1); if (g_array_index(classes,FileClass,i) == PERSONAL) { element = (ListElement *)g_new0(ListElement, 1); element->name = g_strdup(tmpvector[g_strv_length(tmpvector)-1]); p_list = g_list_append(p_list,element); } if (g_array_index(classes,FileClass,i) == SYSTEM) { element = (ListElement *)g_new0(ListElement, 1); element->name = g_strdup(tmpvector[g_strv_length(tmpvector)-1]); s_list = g_list_append(s_list,element); } g_strfreev(tmpvector); } g_strfreev(vector); g_array_free(classes,TRUE); p_list = g_list_sort(p_list,list_sort); s_list = g_list_sort(s_list,list_sort); for (guint i=0;i<g_list_length(p_list);i++) { gtk_tree_store_append(combostore,&iter,&per_iter); element = (ListElement *)g_list_nth_data(p_list,i); gtk_tree_store_set(combostore,&iter, 0,element->name, -1); } for (guint i=0;i<g_list_length(s_list);i++) { gtk_tree_store_append(combostore,&iter,&sys_iter); element = (ListElement *)g_list_nth_data(s_list,i); gtk_tree_store_set(combostore,&iter, 0,element->name, -1); } g_list_foreach(p_list,free_element,NULL); g_list_foreach(s_list,free_element,NULL); g_list_free(p_list); g_list_free(s_list); cfgfile = cfg_open_file(firmware->profile_filename); if (!cfgfile) return FALSE; cfg_read_string(cfgfile,"lookuptables","tables",&tmpbuf); vector = g_strsplit(tmpbuf,",",-1); g_free(tmpbuf); for (guint i=0;i<g_strv_length(vector);i++) { cfg_read_string(cfgfile,"lookuptables",vector[i],&tmpbuf); gtk_list_store_append(store,&iter); gtk_list_store_set(store,&iter, INTERNAL_NAME_COL,vector[i], FILENAME_COL,tmpbuf, VIEW_EDIT_COL,FALSE, -1); g_free(tmpbuf); } g_strfreev(vector); tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store)); gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tree),TRUE); gtk_box_pack_start(GTK_BOX(vbox),tree,TRUE,TRUE,0); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes("Internal Table Name",renderer,"text",INTERNAL_NAME_COL,NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(tree),column); renderer = gtk_cell_renderer_combo_new(); g_object_set(G_OBJECT(renderer),"has-entry",FALSE,"editable",TRUE,"model",combostore,"text-column",0,"style",PANGO_STYLE_ITALIC,NULL); g_signal_connect(G_OBJECT(renderer),"changed", G_CALLBACK(lookuptable_changed),store); // g_signal_connect(G_OBJECT(renderer),"editing-started", G_CALLBACK(editing_started),store); column = gtk_tree_view_column_new_with_attributes("LookupTable Filename",renderer,"text",FILENAME_COL,NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(tree),column); /* renderer = gtk_cell_renderer_toggle_new(); column = gtk_tree_view_column_new_with_attributes("View/Edit",renderer,"active",VIEW_EDIT_COL,NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(tree),column); */ gtk_window_set_transient_for(GTK_WINDOW(lookuptables_config_window),GTK_WINDOW(lookup_widget("main_window"))); gtk_widget_show_all (lookuptables_config_window); gtk_tree_view_columns_autosize( GTK_TREE_VIEW(tree)); gtk_tree_view_set_grid_lines( GTK_TREE_VIEW(tree),GTK_TREE_VIEW_GRID_LINES_BOTH); // g_signal_connect(G_OBJECT(tree),"row-activated", G_CALLBACK(row_activated),NULL); } return TRUE; }
/***** * * Main CTK widget creation. * */ GtkWidget* ctk_clocks_new(NvCtrlAttributeHandle *handle, CtkConfig *ctk_config, CtkEvent *ctk_event) { GObject *object; CtkClocks *ctk_object; GtkObject *adjustment; GtkWidget *alignment; GtkWidget *scale; CtkDropDownMenu *menu; GtkWidget *label; GtkWidget *frame; GtkWidget *banner; GtkWidget *hbox; GtkWidget *vbox; ReturnStatus ret; /* NvCtrlxxx function return value */ int value, i = 0; int clocks_2D; NVCTRLAttributeValidValuesRec ranges_2D; NVCTRLAttributeValidValuesRec range_detection; int clocks_3D; NVCTRLAttributeValidValuesRec ranges_3D; Bool overclocking_enabled; Bool auto_detection_available = FALSE; Bool probing_optimal = FALSE; Bool can_access_2d_clocks; Bool can_access_3d_clocks; /* Make sure we have a handle */ g_return_val_if_fail(handle != NULL, NULL); /* If we can't query the overclocking state, don't load the page */ ret = NvCtrlGetAttribute(handle, NV_CTRL_GPU_OVERCLOCKING_STATE, &value); if ( ret != NvCtrlSuccess ) return NULL; overclocking_enabled = (value==NV_CTRL_GPU_OVERCLOCKING_STATE_MANUAL)?True:False; /* Check if overclocking is busy */ if ( overclocking_enabled ) { ret = NvCtrlGetValidAttributeValues(handle, NV_CTRL_GPU_OPTIMAL_CLOCK_FREQS_DETECTION, &range_detection); if ( ret == NvCtrlSuccess ) { ret = NvCtrlGetAttribute(handle, NV_CTRL_GPU_OPTIMAL_CLOCK_FREQS_DETECTION_STATE, &value); if ( ret != NvCtrlSuccess ) return NULL; probing_optimal = (value == NV_CTRL_GPU_OPTIMAL_CLOCK_FREQS_DETECTION_STATE_BUSY); auto_detection_available = TRUE; } } /* Can we access the 2D clocks? */ can_access_2d_clocks = True; ret = NvCtrlGetAttribute(handle, NV_CTRL_GPU_2D_CLOCK_FREQS, &clocks_2D); if ( ret != NvCtrlSuccess ) can_access_2d_clocks = False; ret = NvCtrlGetValidAttributeValues(handle, NV_CTRL_GPU_2D_CLOCK_FREQS, &ranges_2D); if ( ret != NvCtrlSuccess ) can_access_2d_clocks = False; /* Can we access the 3D clocks? */ can_access_3d_clocks = True; ret = NvCtrlGetAttribute(handle, NV_CTRL_GPU_3D_CLOCK_FREQS, &clocks_3D); if ( ret != NvCtrlSuccess ) can_access_3d_clocks = False; ret = NvCtrlGetValidAttributeValues(handle, NV_CTRL_GPU_3D_CLOCK_FREQS, &ranges_3D); if ( ret != NvCtrlSuccess ) can_access_3d_clocks = False; /* If we can't access either of the clocks, don't load the page */ if ( !can_access_2d_clocks && !can_access_3d_clocks ) return NULL; /* Create the ctk object */ object = g_object_new(CTK_TYPE_CLOCKS, NULL); ctk_object = CTK_CLOCKS(object); /* Cache the handle and configuration */ ctk_object->handle = handle; ctk_object->ctk_config = ctk_config; ctk_object->overclocking_enabled = overclocking_enabled; ctk_object->auto_detection_available = auto_detection_available; ctk_object->probing_optimal = probing_optimal; /* Create the Clock menu widget */ menu = (CtkDropDownMenu *) ctk_drop_down_menu_new(CTK_DROP_DOWN_MENU_FLAG_READONLY); i = 0; if ( can_access_2d_clocks ) { ctk_drop_down_menu_append_item(menu, "2D Clock Frequencies", i++); } if ( can_access_3d_clocks ) { ctk_drop_down_menu_append_item(menu, "3D Clock Frequencies", i++); } ctk_object->clock_menu = GTK_WIDGET(menu); g_signal_connect(G_OBJECT(ctk_object->clock_menu), "changed", G_CALLBACK(clock_menu_changed), (gpointer) ctk_object); ctk_config_set_tooltip(ctk_config, ctk_object->clock_menu, __clock_menu_help); gtk_widget_set_sensitive(ctk_object->clock_menu, overclocking_enabled && !probing_optimal); /* Create the Graphics clock frequency slider widget */ if ( can_access_2d_clocks ) { adjustment = gtk_adjustment_new(GET_GPU_CLOCK(clocks_2D), GET_GPU_CLOCK(ranges_2D.u.range.min), GET_GPU_CLOCK(ranges_2D.u.range.max), 1, 5, 0.0); ctk_object->clocks_being_modified = CLOCKS_2D; } else { adjustment = gtk_adjustment_new(GET_GPU_CLOCK(clocks_3D), GET_GPU_CLOCK(ranges_3D.u.range.min), GET_GPU_CLOCK(ranges_3D.u.range.max), 1, 5, 0.0); ctk_object->clocks_being_modified = CLOCKS_3D; } scale = ctk_scale_new(GTK_ADJUSTMENT(adjustment), "GPU (MHz)", ctk_config, G_TYPE_INT); ctk_object->gpu_clk_scale = scale; g_signal_connect(adjustment, "value_changed", G_CALLBACK(adjustment_value_changed), (gpointer) ctk_object); ctk_config_set_tooltip(ctk_config, CTK_SCALE(ctk_object->gpu_clk_scale)->gtk_scale, __graphics_clock_help); gtk_widget_set_sensitive(ctk_object->gpu_clk_scale, overclocking_enabled && !probing_optimal); /* Create the Memory clock frequency slider widget */ if ( can_access_2d_clocks ) { adjustment = gtk_adjustment_new(GET_MEM_CLOCK(clocks_2D), GET_MEM_CLOCK(ranges_2D.u.range.min), GET_MEM_CLOCK(ranges_2D.u.range.max), 1, 5, 0.0); } else { adjustment = gtk_adjustment_new(GET_MEM_CLOCK(clocks_3D), GET_MEM_CLOCK(ranges_3D.u.range.min), GET_MEM_CLOCK(ranges_3D.u.range.max), 1, 5, 0.0); } scale = ctk_scale_new(GTK_ADJUSTMENT(adjustment), "Memory (MHz)", ctk_config, G_TYPE_INT); ctk_object->mem_clk_scale = scale; g_signal_connect(adjustment, "value_changed", G_CALLBACK(adjustment_value_changed), (gpointer) ctk_object); ctk_config_set_tooltip(ctk_config, CTK_SCALE(ctk_object->mem_clk_scale)->gtk_scale, __mem_clock_help); gtk_widget_set_sensitive(ctk_object->mem_clk_scale, overclocking_enabled && !probing_optimal); /* Create the Enable Overclocking checkbox widget */ ctk_object->enable_checkbox = gtk_check_button_new_with_label("Enable Overclocking"); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(ctk_object->enable_checkbox), overclocking_enabled); gtk_widget_set_sensitive(ctk_object->enable_checkbox, overclocking_enabled && !probing_optimal); g_signal_connect(G_OBJECT(ctk_object->enable_checkbox), "toggled", G_CALLBACK(overclocking_state_toggled), (gpointer) ctk_object); ctk_config_set_tooltip(ctk_config, ctk_object->enable_checkbox, __enable_button_help); gtk_widget_set_sensitive(ctk_object->enable_checkbox, !probing_optimal); /* Create the Apply button widget */ ctk_object->apply_button = gtk_button_new_with_label("Apply"); g_signal_connect(G_OBJECT(ctk_object->apply_button), "clicked", G_CALLBACK(apply_clocks_clicked), (gpointer) ctk_object); ctk_config_set_tooltip(ctk_config, ctk_object->apply_button, __apply_button_help); gtk_widget_set_sensitive(ctk_object->apply_button, False); /* Create the Auto Detect button widget */ ctk_object->detect_button = gtk_button_new_with_label("Auto Detect"); g_signal_connect(G_OBJECT(ctk_object->detect_button), "clicked", G_CALLBACK(detect_clocks_clicked), (gpointer) ctk_object); ctk_config_set_tooltip(ctk_config, ctk_object->detect_button, __detect_button_help); if ( ctk_object->clocks_being_modified == CLOCKS_2D ) { gtk_widget_set_sensitive(ctk_object->detect_button, False); } else { gtk_widget_set_sensitive(ctk_object->detect_button, overclocking_enabled && auto_detection_available && !probing_optimal); } /* Create the Reset hardware button widget */ ctk_object->reset_button = gtk_button_new_with_label("Reset Hardware Defaults"); g_signal_connect(G_OBJECT(ctk_object->reset_button), "clicked", G_CALLBACK(reset_clocks_clicked), (gpointer) ctk_object); ctk_config_set_tooltip(ctk_config, ctk_object->reset_button, __reset_button_help); gtk_widget_set_sensitive(ctk_object->reset_button, False); /* Create the auto detect dialog */ ctk_object->detect_dialog = gtk_dialog_new_with_buttons("Auto Detect Optimal 3D Clock Frequencies?", GTK_WINDOW(gtk_widget_get_parent(GTK_WIDGET(ctk_object))), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_NO_SEPARATOR, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL ); label = gtk_label_new(__detect_confirm_msg); hbox = gtk_hbox_new(TRUE, 15); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 15); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(ctk_object->detect_dialog)->vbox), hbox, FALSE, FALSE, 15); /* * Now that we've created all the widgets we care about, we're * ready to compose the panel */ /* Set container properties of the ctk object */ gtk_box_set_spacing(GTK_BOX(ctk_object), 10); banner = ctk_banner_image_new(BANNER_ARTWORK_CLOCK); gtk_box_pack_start(GTK_BOX(object), banner, FALSE, FALSE, 0); /* Add Overclocking checkbox */ hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(object), hbox, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), ctk_object->enable_checkbox, FALSE, FALSE, 0); /* Add Clock frequency frame */ frame = gtk_frame_new("Clock Frequencies"); vbox = gtk_vbox_new(FALSE, 0); hbox = gtk_hbox_new(FALSE, 0); gtk_container_set_border_width(GTK_CONTAINER(vbox), FRAME_PADDING); gtk_box_pack_start(GTK_BOX(object), frame, FALSE, FALSE, 0); gtk_container_add(GTK_CONTAINER(frame), vbox); gtk_box_pack_start(GTK_BOX(hbox), ctk_object->clock_menu, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 5); gtk_box_pack_start(GTK_BOX(vbox), ctk_object->gpu_clk_scale, FALSE, FALSE, 5); gtk_box_pack_start(GTK_BOX(vbox), ctk_object->mem_clk_scale, FALSE, FALSE, 5); /* Add the Apply, Auto Detect, and Reset buttons */ hbox = gtk_hbox_new(FALSE, 5); gtk_box_pack_start(GTK_BOX(hbox), ctk_object->apply_button, FALSE, FALSE, 0); gtk_container_add(GTK_CONTAINER(hbox), ctk_object->detect_button); gtk_container_add(GTK_CONTAINER(hbox), ctk_object->reset_button); alignment = gtk_alignment_new(1, 1, 0, 0); gtk_container_add(GTK_CONTAINER(alignment), hbox); gtk_box_pack_start(GTK_BOX(object), alignment, TRUE, TRUE, 0); /* Setup the initial gui state */ sync_gui_to_modify_clocks(ctk_object, ctk_object->clocks_being_modified); /* Handle events from other NV-CONTROL clients */ g_signal_connect(G_OBJECT(ctk_event), CTK_EVENT_NAME(NV_CTRL_GPU_OVERCLOCKING_STATE), G_CALLBACK(overclocking_state_received), (gpointer) ctk_object); g_signal_connect(G_OBJECT(ctk_event), CTK_EVENT_NAME(NV_CTRL_GPU_2D_CLOCK_FREQS), G_CALLBACK(clocks_received), (gpointer) ctk_object); g_signal_connect(G_OBJECT(ctk_event), CTK_EVENT_NAME(NV_CTRL_GPU_3D_CLOCK_FREQS), G_CALLBACK(clocks_received), (gpointer) ctk_object); g_signal_connect(G_OBJECT(ctk_event), CTK_EVENT_NAME(NV_CTRL_GPU_OPTIMAL_CLOCK_FREQS), G_CALLBACK(clocks_received), (gpointer) ctk_object); g_signal_connect(G_OBJECT(ctk_event), CTK_EVENT_NAME(NV_CTRL_GPU_OPTIMAL_CLOCK_FREQS_DETECTION_STATE), G_CALLBACK(auto_detection_state_received), (gpointer) ctk_object); /* Show the widget */ gtk_widget_show_all(GTK_WIDGET(ctk_object)); return GTK_WIDGET(ctk_object); } /* ctk_clocks_new() */
static GtkWidget *server_info_page (struct server *s) { GtkWidget *page_vbox; GtkWidget *table; GtkWidget *frame; GtkWidget *hbox; GtkWidget *vbox; GtkWidget *label; GSList *sources; GSList *list; struct master *m; struct server_props *props; char buf[32]; GList *cfgs; int slots_buffer; guint row = 0; props = properties (s); page_vbox = gtk_vbox_new (FALSE, 8); gtk_container_set_border_width (GTK_CONTAINER (page_vbox), 8); /* Address */ table = gtk_table_new (6, 4, FALSE); gtk_table_set_row_spacings (GTK_TABLE (table), 4); gtk_table_set_col_spacings (GTK_TABLE (table), 8); gtk_box_pack_start (GTK_BOX (page_vbox), table, FALSE, FALSE, 0); gtk_table_set_col_spacing (GTK_TABLE (table), 1, 16); label = gtk_label_new (_("IP Address:")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, row, row+1); gtk_widget_show (label); label = gtk_label_new (inet_ntoa (s->host->ip)); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach_defaults (GTK_TABLE (table), label, 1, 2, row, row+1); gtk_widget_show (label); label = gtk_label_new (_("Port:")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach_defaults (GTK_TABLE (table), label, 2, 3, row, row+1); gtk_widget_show (label); g_snprintf (buf, 32, "%d", s->port); label = gtk_label_new (buf); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach_defaults (GTK_TABLE (table), label, 3, 4, row, row+1); gtk_widget_show (label); row++; label = gtk_label_new (_("Host Name:")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, row, row+1); gtk_widget_show (label); if (s->host->name) { label = gtk_label_new (s->host->name); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach_defaults (GTK_TABLE (table), label, 1, 4, row, row+1); gtk_widget_show (label); } row++; label = gtk_label_new (_("Country:")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, row, row+1); gtk_widget_show (label); #ifdef USE_GEOIP if (geoip_name_by_id(s->country_id)) { GtkWidget* hbox = gtk_hbox_new (FALSE, 4); struct pixmap* pix = get_pixmap_for_country(s->country_id); if (pix) { GtkWidget *pixmap = gtk_pixmap_new(pix->pix,pix->mask); gtk_box_pack_start (GTK_BOX (hbox), pixmap, FALSE, FALSE, 0); gtk_widget_show (pixmap); } label = gtk_label_new (geoip_name_by_id(s->country_id)); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); gtk_table_attach_defaults (GTK_TABLE (table), hbox, 1, 4, row, row+1); gtk_widget_show (hbox); } #endif row++; label = gtk_label_new (_("Refreshed:")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, row, row+1); gtk_widget_show (label); if (s->refreshed) { char* str = timet2string(&s->refreshed); label = gtk_label_new (str); g_free(str); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach_defaults (GTK_TABLE (table), label, 1, 4, row, row+1); gtk_widget_show (label); } row++; // translator: last time and date the server answered the query label = gtk_label_new (_("Last answer:")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, row, row+1); gtk_widget_show (label); if (s->last_answer) { GtkStyle *style; GdkColor color; time_t max_days = 3; // XXX: hardcoded, has to be configurable some time char* str = timet2string(&s->last_answer); label = gtk_label_new (str); g_free(str); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach_defaults (GTK_TABLE (table), label, 1, 4, row, row+1); if (s->last_answer + max_days*24*60*60 < s->refreshed) { // XXX: I don't know if that is the correct way, it's undocumented :-( style = gtk_widget_get_style(label); gdk_color_parse("red",&color); style->fg [GTK_STATE_NORMAL] = color; style->fg [GTK_STATE_ACTIVE] = color; style->fg [GTK_STATE_PRELIGHT] = color; style->fg [GTK_STATE_SELECTED] = color; style->fg [GTK_STATE_INSENSITIVE] = color; gtk_widget_set_style (label, style); } gtk_widget_show (label); } row++; /*pulp*/ /*Reserved Slots spin widget*/ if (props) { if (props->reserved_slots) { slots_buffer=props->reserved_slots; } else { slots_buffer=0; } } else { slots_buffer=0; } label = gtk_label_new (_("Reserved Slots:")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, row, row+1); gtk_widget_show (label); adj = (GtkAdjustment *) gtk_adjustment_new (slots_buffer, 0, 9, 1, 2,0); spinner = gtk_spin_button_new (adj, 0, 0); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinner), TRUE); gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON (spinner), GTK_UPDATE_IF_VALID); gtk_table_attach_defaults (GTK_TABLE (table), spinner, 1, 2, row, row+1); gtk_widget_show (spinner); gtk_widget_show (table); /* Sources */ frame = gtk_frame_new (_("Sources")); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN); gtk_box_pack_start (GTK_BOX (page_vbox), frame, FALSE, FALSE, 0); vbox = gtk_vbox_new (FALSE, 4); gtk_container_set_border_width (GTK_CONTAINER (vbox), 6); gtk_container_add (GTK_CONTAINER (frame), vbox); sources = references_to_server (s); for (list = sources; list; list = list->next) { m = (struct master *) list->data; label = gtk_label_new (_(m->name)); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); gtk_widget_show (label); } g_slist_free (sources); gtk_widget_show (vbox); gtk_widget_show (frame); /* Custom CFG */ hbox = gtk_hbox_new (FALSE, 8); gtk_box_pack_start (GTK_BOX (page_vbox), hbox, FALSE, FALSE, 0); customcfg_combo = gtk_combo_new (); gtk_entry_set_max_length (GTK_ENTRY (GTK_COMBO (customcfg_combo)->entry), 256); gtk_widget_set_usize (GTK_COMBO (customcfg_combo)->entry, 112, -1); if ((games[s->type].flags & GAME_CONNECT) != 0 && games[s->type].custom_cfgs) { cfgs = (*games[s->type].custom_cfgs) (&games[s->type], NULL, s->game); combo_set_vals (customcfg_combo, cfgs, (props && props->custom_cfg)? props->custom_cfg : NULL); if (cfgs) { g_list_foreach (cfgs, (GFunc) g_free, NULL); g_list_free (cfgs); } } else { gtk_widget_set_sensitive (customcfg_combo, FALSE); } gtk_box_pack_end (GTK_BOX (hbox), customcfg_combo, FALSE, FALSE, 0); gtk_widget_show (customcfg_combo); label = gtk_label_new (_("Custom CFG:")); gtk_box_pack_end (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); gtk_widget_show (hbox); gtk_widget_show (page_vbox); return page_vbox; }
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)); }
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; }
static GtkWidget *create_custom_widget(GtkPrintOperation *operation, gpointer user_data) { /* copied from interface.c */ GtkWidget *page; GtkWidget *frame33; GtkWidget *alignment36; GtkWidget *vbox30; GtkWidget *hbox10; GtkWidget *label203; PrintWidgets *w = user_data; gtk_print_operation_set_custom_tab_label(operation, _("Document Setup")); page = gtk_vbox_new(FALSE, 0); gtk_container_set_border_width(GTK_CONTAINER(page), 5); w->check_print_linenumbers = gtk_check_button_new_with_mnemonic(_("Print line numbers")); gtk_box_pack_start(GTK_BOX(page), w->check_print_linenumbers, FALSE, FALSE, 0); gtk_widget_set_tooltip_text(w->check_print_linenumbers, _("Add line numbers to the printed page")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w->check_print_linenumbers), printing_prefs.print_line_numbers); w->check_print_pagenumbers = gtk_check_button_new_with_mnemonic(_("Print page numbers")); gtk_box_pack_start(GTK_BOX(page), w->check_print_pagenumbers, FALSE, FALSE, 0); gtk_widget_set_tooltip_text(w->check_print_pagenumbers, _("Add page numbers at the bottom of each page. It takes 2 lines of the page.")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w->check_print_pagenumbers), printing_prefs.print_page_numbers); w->check_print_pageheader = gtk_check_button_new_with_mnemonic(_("Print page header")); gtk_box_pack_start(GTK_BOX(page), w->check_print_pageheader, FALSE, FALSE, 0); gtk_widget_set_tooltip_text(w->check_print_pageheader, _("Add a little header to every page containing the page number, the filename and the current date (see below). It takes 3 lines of the page.")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w->check_print_pageheader), printing_prefs.print_page_header); g_signal_connect(w->check_print_pageheader, "toggled", G_CALLBACK(on_page_header_toggled), w); frame33 = gtk_frame_new(NULL); gtk_box_pack_start(GTK_BOX(page), frame33, FALSE, FALSE, 0); gtk_frame_set_label_align(GTK_FRAME(frame33), 0, 0); gtk_frame_set_shadow_type(GTK_FRAME(frame33), GTK_SHADOW_NONE); alignment36 = gtk_alignment_new(0, 0.5, 1, 1); gtk_container_add(GTK_CONTAINER(frame33), alignment36); gtk_alignment_set_padding(GTK_ALIGNMENT(alignment36), 0, 0, 12, 0); vbox30 = gtk_vbox_new(FALSE, 1); gtk_container_add(GTK_CONTAINER(alignment36), vbox30); w->check_print_basename = gtk_check_button_new_with_mnemonic(_("Use the basename of the printed file")); gtk_box_pack_start(GTK_BOX(vbox30), w->check_print_basename, FALSE, FALSE, 0); gtk_widget_set_tooltip_text(w->check_print_basename, _("Print only the basename(without the path) of the printed file")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w->check_print_basename), printing_prefs.page_header_basename); hbox10 = gtk_hbox_new(FALSE, 5); gtk_box_pack_start(GTK_BOX(vbox30), hbox10, TRUE, TRUE, 0); label203 = gtk_label_new(_("Date format:")); gtk_box_pack_start(GTK_BOX(hbox10), label203, FALSE, FALSE, 0); w->entry_print_dateformat = gtk_entry_new(); ui_entry_add_clear_icon(GTK_ENTRY(w->entry_print_dateformat)); gtk_box_pack_start(GTK_BOX(hbox10), w->entry_print_dateformat, TRUE, TRUE, 0); gtk_widget_set_tooltip_text(w->entry_print_dateformat, _("Specify a format for the date and time stamp which is added to the page header on each page. You can use any conversion specifiers which can be used with the ANSI C strftime function.")); gtk_entry_set_text(GTK_ENTRY(w->entry_print_dateformat), printing_prefs.page_header_datefmt); on_page_header_toggled(GTK_TOGGLE_BUTTON(w->check_print_pageheader), w); gtk_widget_show_all(page); return page; }
void gui_animate_dialog(void) { gchar *tmp, *title; gpointer dialog; GtkWidget *window, *frame, *vbox, *hbox, *hbox2, *anim_box; GtkWidget *notebook, *page, *button, *label, *entry, *scale; GSList *group=NULL; struct model_pak *data; /* checks */ data = sysenv.active_model; if (!data) return; if (!data->animation) return; /* CURRENT */ /* anim_read_all_frames(data); */ /* prevent recording whilst in animation */ gui_mode_switch(FREE); /* dialog setup */ title = g_strdup_printf("Animation: %s", data->basename); dialog = dialog_request(ANIM, title, NULL, animate_cleanup, data); g_free(title); if (!dialog) return; window = dialog_window(dialog); /* notebook frame */ frame = gtk_frame_new(NULL); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(window)->vbox), frame, FALSE, FALSE, 0); gtk_container_set_border_width(GTK_CONTAINER(frame), PANEL_SPACING); /* create notebook */ notebook = gtk_notebook_new(); gtk_notebook_set_tab_pos(GTK_NOTEBOOK(notebook), GTK_POS_TOP); gtk_container_add(GTK_CONTAINER(frame), notebook); gtk_notebook_set_show_border(GTK_NOTEBOOK(notebook), TRUE); /* page 1 */ page = gtk_vbox_new(FALSE, PANEL_SPACING); label = gtk_label_new("Control"); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), page, label); /* general animation stuff */ frame = gtk_frame_new(NULL); gtk_box_pack_start(GTK_BOX(page),frame,FALSE,FALSE,0); /* create a vbox in the frame */ vbox = gtk_vbox_new(TRUE, PANEL_SPACING); gtk_container_add(GTK_CONTAINER(frame), vbox); /* num frames */ hbox = gtk_hbox_new(FALSE, 0); gtk_container_set_border_width(GTK_CONTAINER(hbox), PANEL_SPACING); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0); label = gtk_label_new("Number of frames:"); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); tmp = g_strdup_printf("%9d", data->num_frames); label = gtk_label_new(tmp); g_free(tmp); gtk_box_pack_end(GTK_BOX(hbox), label, FALSE, FALSE, 0); /* desired delay */ gui_direct_spin("Animation delay", &data->anim_speed, 1.0, 40.0, 1.0, NULL, NULL, vbox); gui_direct_spin("Animation step size ", &data->anim_step, 1.0, data->num_frames, 1.0, NULL, NULL, vbox); gui_direct_check("Don't recalculate connectivity", &data->anim_fix, NULL, NULL, vbox); gui_direct_check("Don't recalculate scale", &data->anim_noscale, NULL, NULL, vbox); gui_direct_check("Loop", &data->anim_loop, NULL, NULL, vbox); /* page 2 */ page = gtk_vbox_new(FALSE, PANEL_SPACING); label = gtk_label_new("Processing"); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), page, label); /* cycle options */ frame = gtk_frame_new(NULL); gtk_box_pack_start(GTK_BOX(page),frame,FALSE,FALSE,0); vbox = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(frame), vbox); gtk_container_set_border_width(GTK_CONTAINER(vbox), PANEL_SPACING); /* actions at start of each cycle */ new_radio_group(0, vbox, FF); button = add_radio_button("Confine atoms to PBC", (gpointer) atom_pbc, data); if (data->anim_confine == PBC_CONFINE_ATOMS) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE); button = add_radio_button("Confine mols to PBC", (gpointer) mol_pbc, data); if (data->anim_confine == PBC_CONFINE_MOLS) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE); button = add_radio_button("Cell confinement off", (gpointer) no_pbc, data); if (data->anim_confine == PBC_CONFINE_NONE) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE); /* page 3 */ page = gtk_vbox_new(FALSE, PANEL_SPACING); label = gtk_label_new("Rendering"); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), page, label); /* cycle options */ frame = gtk_frame_new(NULL); gtk_box_pack_start(GTK_BOX(page), frame, FALSE, FALSE, 0); vbox = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(frame), vbox); gtk_container_set_border_width(GTK_CONTAINER(vbox), PANEL_SPACING); anim_box = gtk_vbox_new(TRUE, 0); gui_direct_check("Create movie", &sysenv.render.animate, anim_render, anim_box, vbox); gtk_box_pack_end(GTK_BOX(vbox), anim_box, TRUE, TRUE, 0); /* sensitive box */ vbox = gtk_vbox_new(FALSE,0); gtk_box_pack_start(GTK_BOX(anim_box), vbox, TRUE, TRUE, 0); gtk_container_set_border_width(GTK_CONTAINER(vbox), PANEL_SPACING); /* start off with a button */ button = gtk_radio_button_new_with_label (NULL, "Animated GIF"); g_signal_connect(GTK_OBJECT(button), "clicked", GTK_SIGNAL_FUNC(event_render_modify), (gpointer) button); gtk_box_pack_start(GTK_BOX(vbox), button, FALSE, TRUE, 0); g_object_set_data(G_OBJECT(button), "id", (gpointer) ANIM_GIF); /* make a radio group */ group = gtk_radio_button_group(GTK_RADIO_BUTTON(button)); /* do the rest of the buttons */ button = gtk_radio_button_new_with_label(group, "MPEG"); g_signal_connect(GTK_OBJECT(button), "clicked", GTK_SIGNAL_FUNC(event_render_modify), (gpointer) button); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, TRUE, 0); g_object_set_data(G_OBJECT(button), "id", (gpointer) ANIM_MPEG); /* movie creation parameters */ gui_direct_spin("MPEG quality", &sysenv.render.mpeg_quality, 1, 100, 1, NULL, NULL, vbox); gui_direct_spin("Delay (ms)", &sysenv.render.delay, 0, 100, 5, NULL, NULL, vbox); /* file entry */ hbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox),hbox,FALSE,TRUE,0); label = gtk_label_new("Filename "); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); entry = gtk_entry_new(); gtk_box_pack_end(GTK_BOX (hbox), entry, FALSE, TRUE, 0); gtk_entry_set_text(GTK_ENTRY(entry), sysenv.render.animate_file); /* update hook */ g_signal_connect(GTK_OBJECT(entry), "changed", GTK_SIGNAL_FUNC(event_render_modify), (gpointer) entry); g_object_set_data(G_OBJECT(entry), "id", (gpointer) ANIM_NAME); /* misc options */ /* gui_direct_check("Create povray input files then stop", &sysenv.render.no_povray_exec, NULL, NULL, vbox); gui_direct_check("Delete intermediate input/image files", &sysenv.render.no_keep_tempfiles, NULL, NULL, vbox); */ /* set initial state */ if (!sysenv.render.animate) gtk_widget_set_sensitive(anim_box, FALSE); /* NEW - slider for current frame */ frame = gtk_frame_new(NULL); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(window)->vbox), frame, FALSE, FALSE, 0); vbox = gtk_vbox_new(FALSE, PANEL_SPACING); gtk_container_add(GTK_CONTAINER(frame), vbox); scale = gui_direct_hscale(0, data->num_frames-1, 1, &data->cur_frame, select_frame, data, vbox); gtk_range_set_update_policy(GTK_RANGE(scale), GTK_UPDATE_DISCONTINUOUS); /* control buttons */ hbox2 = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox2, FALSE, FALSE, PANEL_SPACING); hbox = gtk_hbox_new(TRUE, PANEL_SPACING); gtk_box_pack_start(GTK_BOX(hbox2), hbox, TRUE, FALSE, 0); gui_icon_button("GDIS_REWIND", NULL, anim_rewind, dialog, hbox); gui_icon_button("GDIS_STEP_BACKWARD", NULL, anim_step_backward, dialog, hbox); gui_icon_button("GDIS_PLAY", NULL, anim_start, dialog, hbox); gui_icon_button("GDIS_PAUSE", NULL, anim_stop, dialog, hbox); gui_icon_button("GDIS_STEP_FORWARD", NULL, anim_step_forward, dialog, hbox); gui_icon_button("GDIS_FASTFORWARD", NULL, anim_fastforward, dialog, hbox); gui_stock_button(GTK_STOCK_CLOSE, dialog_destroy, dialog, GTK_DIALOG(window)->action_area); /* display the dialog */ gtk_widget_show_all(window); gui_relation_update(data); }
static void op_configure(void) { GtkWidget *dev_vbox; GtkWidget *adevice_frame, *adevice_text, *adevice_vbox; GtkWidget *bbox, *ok, *cancel; if (configure_win) { gdk_window_raise(configure_win->window); return; } configure_win = gtk_window_new(GTK_WINDOW_DIALOG); gtk_signal_connect(GTK_OBJECT(configure_win), "destroy", GTK_SIGNAL_FUNC(configure_win_destroy), NULL); gtk_window_set_title(GTK_WINDOW(configure_win), _("sndio device")); gtk_window_set_policy(GTK_WINDOW(configure_win), FALSE, FALSE, FALSE); gtk_window_set_position(GTK_WINDOW(configure_win), GTK_WIN_POS_MOUSE); gtk_container_border_width(GTK_CONTAINER(configure_win), 10); dev_vbox = gtk_vbox_new(FALSE, 5); gtk_container_add(GTK_CONTAINER(configure_win), dev_vbox); gtk_container_set_border_width(GTK_CONTAINER(dev_vbox), 5); adevice_frame = gtk_frame_new(_("Audio device:")); gtk_box_pack_start(GTK_BOX(dev_vbox), adevice_frame, FALSE, FALSE, 0); adevice_vbox = gtk_vbox_new(FALSE, 5); gtk_container_set_border_width(GTK_CONTAINER(adevice_vbox), 5); gtk_container_add(GTK_CONTAINER(adevice_frame), adevice_vbox); adevice_text = gtk_label_new(_("(empty means default)")); gtk_box_pack_start_defaults(GTK_BOX(adevice_vbox), adevice_text); adevice_entry = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(adevice_entry), audiodev); gtk_box_pack_start_defaults(GTK_BOX(adevice_vbox), adevice_entry); bbox = gtk_hbutton_box_new(); gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END); gtk_button_box_set_spacing(GTK_BUTTON_BOX(bbox), 5); gtk_box_pack_start(GTK_BOX(dev_vbox), bbox, FALSE, FALSE, 0); ok = gtk_button_new_with_label(_("OK")); gtk_signal_connect(GTK_OBJECT(ok), "clicked", GTK_SIGNAL_FUNC(configure_win_ok_cb), NULL); GTK_WIDGET_SET_FLAGS(ok, GTK_CAN_DEFAULT); gtk_box_pack_start(GTK_BOX(bbox), ok, TRUE, TRUE, 0); gtk_widget_grab_default(ok); cancel = gtk_button_new_with_label(_("Cancel")); gtk_signal_connect_object(GTK_OBJECT(cancel), "clicked", GTK_SIGNAL_FUNC(configure_win_cancel_cb), GTK_OBJECT(configure_win)); GTK_WIDGET_SET_FLAGS(cancel, GTK_CAN_DEFAULT); gtk_box_pack_start(GTK_BOX(bbox), cancel, TRUE, TRUE, 0); gtk_widget_show_all(configure_win); }
GtkWidget *build_joystick_status_widget(app_shell_type *as, GdkWindow *window) { GtkWidget *joystick_box, *frame; int i = 0; char *empty = util_concat("<", _("empty"), ">", NULL); joystick_box = gtk_hbox_new(FALSE, 0); for (i = 0; i < JOYSTICK_NUM; i++) { /* skip port 2 for machines that only have one joystick port */ if (((machine_class == VICE_MACHINE_VIC20) || (machine_class == VICE_MACHINE_CBM6x0) || (machine_class == VICE_MACHINE_PET) ) && (i == 1)) { as->joystick_status[i].led = NULL; continue; } /* skip port 3 and 4 for machines with no user port */ if (((machine_class == VICE_MACHINE_CBM5x0) ) && (i > 1)) { as->joystick_status[i].led = NULL; continue; } /* skip port 4 */ if (((machine_class == VICE_MACHINE_PLUS4) ) && (i > 2)) { as->joystick_status[i].led = NULL; continue; } as->joystick_status[i].event_box = gtk_event_box_new(); frame = gtk_frame_new(NULL); gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN); as->joystick_status[i].box = gtk_hbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(frame), as->joystick_status[i].box); gtk_widget_show(as->joystick_status[i].box); gtk_container_add(GTK_CONTAINER(as->joystick_status[i].event_box), frame); gtk_widget_show(frame); #if 0 /* FIXME */ gtk_widget_set_tooltip_text(GTK_WIDGET(gtk_widget_get_parent(gtk_widget_get_parent(as->joystick_status[i].box))), empty); #endif /* Single Led */ #if !defined(HAVE_CAIRO) as->joystick_status[i].led_pixmap = gdk_pixmap_new(window, JOY_AREA_WIDTH, JOY_AREA_HEIGHT, -1); as->joystick_status[i].led = gtk_image_new_from_pixmap(as->joystick_status[i].led_pixmap, NULL); #else as->joystick_status[i].led = gtk_drawing_area_new(); #endif gtk_widget_set_size_request(as->joystick_status[i].led, JOY_AREA_WIDTH, JOY_AREA_HEIGHT); gtk_box_pack_start(GTK_BOX(as->joystick_status[i].box), (GtkWidget *)as->joystick_status[i].led, FALSE, FALSE, 4); gtk_widget_show(as->joystick_status[i].led); /* Pack everything together */ gtk_box_pack_start(GTK_BOX(joystick_box), as->joystick_status[i].event_box, FALSE, FALSE, 0); gtk_widget_set_events(as->joystick_status[i].event_box, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_ENTER_NOTIFY_MASK); g_signal_connect(G_OBJECT(as->joystick_status[i].event_box), "button-press-event", G_CALLBACK(joystick_popup_cb), (gpointer)(int_to_void_ptr(i))); gtk_widget_show(as->joystick_status[i].event_box); #if defined(HAVE_CAIRO) #if GTK_CHECK_VERSION(3, 0, 0) g_signal_connect(G_OBJECT(as->joystick_status[i].led), "draw", G_CALLBACK(joys_draw), int_to_void_ptr(i)); #else g_signal_connect(G_OBJECT(as->joystick_status[i].led), "expose-event", G_CALLBACK(joys_draw), int_to_void_ptr(i)); #endif #endif } lib_free(empty); return joystick_box; }
void sp_text_edit_dialog (void) { if (!dlg) { gchar title[500]; sp_ui_dialog_title_string (Inkscape::Verb::get(SP_VERB_DIALOG_TEXT), title); Inkscape::Preferences *prefs = Inkscape::Preferences::get(); dlg = sp_window_new (title, TRUE); if (x == -1000 || y == -1000) { x = prefs->getInt(prefs_path + "x", -1000); y = prefs->getInt(prefs_path + "y", -1000); } if (w ==0 || h == 0) { w = prefs->getInt(prefs_path + "w", 0); h = prefs->getInt(prefs_path + "h", 0); } // if (x<0) x=0; // if (y<0) y=0; if (w && h) gtk_window_resize ((GtkWindow *) dlg, w, h); if (x >= 0 && y >= 0 && (x < (gdk_screen_width()-MIN_ONSCREEN_DISTANCE)) && (y < (gdk_screen_height()-MIN_ONSCREEN_DISTANCE))) { gtk_window_move ((GtkWindow *) dlg, x, y); } else { gtk_window_set_position(GTK_WINDOW(dlg), GTK_WIN_POS_CENTER); } sp_transientize (dlg); wd.win = dlg; wd.stop = 0; g_signal_connect ( G_OBJECT (INKSCAPE), "activate_desktop", G_CALLBACK (sp_transientize_callback), &wd ); gtk_signal_connect ( GTK_OBJECT (dlg), "event", GTK_SIGNAL_FUNC (sp_dialog_event_handler), dlg ); gtk_signal_connect ( GTK_OBJECT (dlg), "destroy", G_CALLBACK (sp_text_edit_dialog_destroy), dlg ); gtk_signal_connect ( GTK_OBJECT (dlg), "delete_event", G_CALLBACK (sp_text_edit_dialog_delete), dlg ); g_signal_connect ( G_OBJECT (INKSCAPE), "shut_down", G_CALLBACK (sp_text_edit_dialog_delete), dlg ); g_signal_connect ( G_OBJECT (INKSCAPE), "dialogs_hide", G_CALLBACK (sp_dialog_hide), dlg ); g_signal_connect ( G_OBJECT (INKSCAPE), "dialogs_unhide", G_CALLBACK (sp_dialog_unhide), dlg ); gtk_window_set_policy (GTK_WINDOW (dlg), TRUE, TRUE, FALSE); GtkTooltips *tt = gtk_tooltips_new(); // box containing the notebook and the bottom buttons GtkWidget *mainvb = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (dlg), mainvb); // notebook GtkWidget *nb = gtk_notebook_new (); gtk_box_pack_start (GTK_BOX (mainvb), nb, TRUE, TRUE, 0); g_object_set_data (G_OBJECT (dlg), "notebook", nb); // Font tab { GtkWidget *l = gtk_label_new (_("Font")); GtkWidget *vb = gtk_vbox_new (FALSE, VB_MARGIN); gtk_container_set_border_width (GTK_CONTAINER (vb), VB_MARGIN); gtk_notebook_append_page (GTK_NOTEBOOK (nb), vb, l); /* HBox containing font selection and layout */ GtkWidget *hb = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (vb), hb, TRUE, TRUE, 0); // font and style selector GtkWidget *fontsel = sp_font_selector_new (); g_signal_connect ( G_OBJECT (fontsel), "font_set", G_CALLBACK (sp_text_edit_dialog_font_changed), dlg ); g_signal_connect_swapped ( G_OBJECT (g_object_get_data (G_OBJECT(fontsel), "family-treeview")), "row-activated", G_CALLBACK (gtk_window_activate_default), dlg); gtk_box_pack_start (GTK_BOX (hb), fontsel, TRUE, TRUE, 0); g_object_set_data (G_OBJECT (dlg), "fontsel", fontsel); // Layout { GtkWidget *f = gtk_frame_new (_("Layout")); gtk_box_pack_start (GTK_BOX (hb), f, FALSE, FALSE, 4); GtkWidget *l_vb = gtk_vbox_new (FALSE, VB_MARGIN); gtk_container_add (GTK_CONTAINER (f), l_vb); { GtkWidget *row = gtk_hbox_new (FALSE, VB_MARGIN); GtkWidget *group; // align left { // TODO - replace with Inkscape-specific call GtkWidget *px = gtk_image_new_from_stock ( GTK_STOCK_JUSTIFY_LEFT, GTK_ICON_SIZE_LARGE_TOOLBAR ); GtkWidget *b = group = gtk_radio_button_new (NULL); gtk_tooltips_set_tip (tt, b, _("Align lines left"), NULL); gtk_button_set_relief (GTK_BUTTON (b), GTK_RELIEF_NONE); g_signal_connect ( G_OBJECT (b), "toggled", G_CALLBACK (sp_text_edit_dialog_any_toggled), dlg); gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE ); gtk_container_add (GTK_CONTAINER (b), px); gtk_box_pack_start (GTK_BOX (row), b, FALSE, FALSE, 0); g_object_set_data (G_OBJECT (dlg), "text_anchor_start", b); } // align center { // TODO - replace with Inkscape-specific call GtkWidget *px = gtk_image_new_from_stock ( GTK_STOCK_JUSTIFY_CENTER, GTK_ICON_SIZE_LARGE_TOOLBAR ); GtkWidget *b = gtk_radio_button_new (gtk_radio_button_group (GTK_RADIO_BUTTON (group))); /* TRANSLATORS: `Center' here is a verb. */ gtk_tooltips_set_tip (tt, b, _("Center lines"), NULL); gtk_button_set_relief (GTK_BUTTON (b), GTK_RELIEF_NONE); g_signal_connect ( G_OBJECT (b), "toggled", G_CALLBACK (sp_text_edit_dialog_any_toggled), dlg ); gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE); gtk_container_add (GTK_CONTAINER (b), px); gtk_box_pack_start (GTK_BOX (row), b, FALSE, FALSE, 0); g_object_set_data (G_OBJECT (dlg), "text_anchor_middle", b); } // align right { // TODO - replace with Inkscape-specific call GtkWidget *px = gtk_image_new_from_stock ( GTK_STOCK_JUSTIFY_RIGHT, GTK_ICON_SIZE_LARGE_TOOLBAR ); GtkWidget *b = gtk_radio_button_new (gtk_radio_button_group (GTK_RADIO_BUTTON (group))); gtk_tooltips_set_tip (tt, b, _("Align lines right"), NULL); gtk_button_set_relief (GTK_BUTTON (b), GTK_RELIEF_NONE); g_signal_connect ( G_OBJECT (b), "toggled", G_CALLBACK (sp_text_edit_dialog_any_toggled), dlg ); gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE); gtk_container_add (GTK_CONTAINER (b), px); gtk_box_pack_start (GTK_BOX (row), b, FALSE, FALSE, 0); g_object_set_data (G_OBJECT (dlg), "text_anchor_end", b); } // align justify { // TODO - replace with Inkscape-specific call GtkWidget *px = gtk_image_new_from_stock ( GTK_STOCK_JUSTIFY_FILL, GTK_ICON_SIZE_LARGE_TOOLBAR ); GtkWidget *b = gtk_radio_button_new (gtk_radio_button_group (GTK_RADIO_BUTTON (group))); gtk_tooltips_set_tip (tt, b, _("Justify lines"), NULL); gtk_button_set_relief (GTK_BUTTON (b), GTK_RELIEF_NONE); g_signal_connect ( G_OBJECT (b), "toggled", G_CALLBACK (sp_text_edit_dialog_any_toggled), dlg ); gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE); gtk_container_add (GTK_CONTAINER (b), px); gtk_box_pack_start (GTK_BOX (row), b, FALSE, FALSE, 0); g_object_set_data (G_OBJECT (dlg), "text_anchor_justify", b); } gtk_box_pack_start (GTK_BOX (l_vb), row, FALSE, FALSE, 0); } { GtkWidget *row = gtk_hbox_new (FALSE, VB_MARGIN); GtkWidget *group; // horizontal { GtkWidget *px = sp_icon_new( Inkscape::ICON_SIZE_LARGE_TOOLBAR, INKSCAPE_STOCK_WRITING_MODE_LR ); GtkWidget *b = group = gtk_radio_button_new (NULL); gtk_tooltips_set_tip (tt, b, _("Horizontal text"), NULL); gtk_button_set_relief (GTK_BUTTON (b), GTK_RELIEF_NONE); g_signal_connect ( G_OBJECT (b), "toggled", G_CALLBACK (sp_text_edit_dialog_any_toggled), dlg ); gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE); gtk_container_add (GTK_CONTAINER (b), px); gtk_box_pack_start (GTK_BOX (row), b, FALSE, FALSE, 0); g_object_set_data (G_OBJECT (dlg), INKSCAPE_STOCK_WRITING_MODE_LR, b); } // vertical { GtkWidget *px = sp_icon_new( Inkscape::ICON_SIZE_LARGE_TOOLBAR, INKSCAPE_STOCK_WRITING_MODE_TB ); GtkWidget *b = gtk_radio_button_new (gtk_radio_button_group (GTK_RADIO_BUTTON (group))); gtk_tooltips_set_tip (tt, b, _("Vertical text"), NULL); gtk_button_set_relief (GTK_BUTTON (b), GTK_RELIEF_NONE); g_signal_connect ( G_OBJECT (b), "toggled", G_CALLBACK (sp_text_edit_dialog_any_toggled), dlg ); gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE); gtk_container_add (GTK_CONTAINER (b), px); gtk_box_pack_start (GTK_BOX (row), b, FALSE, FALSE, 0); g_object_set_data (G_OBJECT (dlg), INKSCAPE_STOCK_WRITING_MODE_TB, b); } gtk_box_pack_start (GTK_BOX (l_vb), row, FALSE, FALSE, 0); } { GtkWidget *row = gtk_hbox_new (FALSE, VB_MARGIN); l = gtk_label_new (_("Line spacing:")); gtk_misc_set_alignment (GTK_MISC (l), 1.0, 0.5); gtk_box_pack_start (GTK_BOX (row), l, FALSE, FALSE, VB_MARGIN); gtk_box_pack_start (GTK_BOX (l_vb), row, FALSE, FALSE, 0); } { GtkWidget *row = gtk_hbox_new (FALSE, VB_MARGIN); GtkWidget *c = gtk_combo_new (); gtk_combo_set_value_in_list ((GtkCombo *) c, FALSE, FALSE); gtk_combo_set_use_arrows ((GtkCombo *) c, TRUE); gtk_combo_set_use_arrows_always ((GtkCombo *) c, TRUE); gtk_widget_set_size_request (c, 90, -1); { /* Setup strings */ GList *sl = NULL; for (int i = 0; spacings[i]; i++) { sl = g_list_prepend (sl, (void *) spacings[i]); } sl = g_list_reverse (sl); gtk_combo_set_popdown_strings ((GtkCombo *) c, sl); g_list_free (sl); } g_signal_connect ( (GObject *) ((GtkCombo *) c)->entry, "changed", (GCallback) sp_text_edit_dialog_line_spacing_changed, dlg ); gtk_box_pack_start (GTK_BOX (row), c, FALSE, FALSE, VB_MARGIN); g_object_set_data (G_OBJECT (dlg), "line_spacing", c); gtk_box_pack_start (GTK_BOX (l_vb), row, FALSE, FALSE, VB_MARGIN); } } /* Font preview */ GtkWidget *preview = sp_font_preview_new (); gtk_box_pack_start (GTK_BOX (vb), preview, TRUE, TRUE, 4); g_object_set_data (G_OBJECT (dlg), "preview", preview); } // Text tab { GtkWidget *l = gtk_label_new (_("Text")); GtkWidget *vb = gtk_vbox_new (FALSE, VB_MARGIN); gtk_container_set_border_width (GTK_CONTAINER (vb), VB_MARGIN); gtk_notebook_append_page (GTK_NOTEBOOK (nb), vb, l); GtkWidget *scroller = gtk_scrolled_window_new ( NULL, NULL ); gtk_scrolled_window_set_policy ( GTK_SCROLLED_WINDOW (scroller), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC ); gtk_scrolled_window_set_shadow_type ( GTK_SCROLLED_WINDOW(scroller), GTK_SHADOW_IN ); gtk_widget_show (scroller); GtkTextBuffer *tb = gtk_text_buffer_new (NULL); GtkWidget *txt = gtk_text_view_new_with_buffer (tb); gtk_text_view_set_wrap_mode ((GtkTextView *) txt, GTK_WRAP_WORD); #ifdef WITH_GTKSPELL GError *error = NULL; char *errortext = NULL; /* todo: Use computed xml:lang attribute of relevant element, if present, to specify the language (either as 2nd arg of gtkspell_new_attach, or with explicit gtkspell_set_language call in; see advanced.c example in gtkspell docs). sp_text_edit_dialog_read_selection looks like a suitable place. */ if (gtkspell_new_attach(GTK_TEXT_VIEW(txt), NULL, &error) == NULL) { g_print("gtkspell error: %s\n", error->message); errortext = g_strdup_printf("GtkSpell was unable to initialize.\n" "%s", error->message); g_error_free(error); } #endif gtk_widget_set_size_request (txt, -1, 64); gtk_text_view_set_editable (GTK_TEXT_VIEW (txt), TRUE); gtk_container_add (GTK_CONTAINER (scroller), txt); gtk_box_pack_start (GTK_BOX (vb), scroller, TRUE, TRUE, 0); g_signal_connect ( G_OBJECT (tb), "changed", G_CALLBACK (sp_text_edit_dialog_text_changed), dlg ); g_signal_connect (G_OBJECT (txt), "focus-in-event", G_CALLBACK (text_view_focus_in), dlg); g_signal_connect (G_OBJECT (txt), "focus-out-event", G_CALLBACK (text_view_focus_out), dlg); g_object_set_data (G_OBJECT (dlg), "text", tb); g_object_set_data (G_OBJECT (dlg), "textw", txt); } /* Buttons */ GtkWidget *hb = gtk_hbox_new (FALSE, VB_MARGIN); gtk_container_set_border_width (GTK_CONTAINER (hb), 4); gtk_box_pack_start (GTK_BOX (mainvb), hb, FALSE, FALSE, 0); { GtkWidget *b = gtk_button_new_with_label (_("Set as default")); g_signal_connect ( G_OBJECT (b), "clicked", G_CALLBACK (sp_text_edit_dialog_set_default), dlg ); gtk_box_pack_start (GTK_BOX (hb), b, FALSE, FALSE, 0); g_object_set_data (G_OBJECT (dlg), "default", b); } { GtkWidget *b = gtk_button_new_from_stock (GTK_STOCK_CLOSE); g_signal_connect ( G_OBJECT (b), "clicked", G_CALLBACK (sp_text_edit_dialog_close), dlg ); gtk_box_pack_end (GTK_BOX (hb), b, FALSE, FALSE, 0); } { GtkWidget *b = gtk_button_new_from_stock (GTK_STOCK_APPLY); GTK_WIDGET_SET_FLAGS (b, GTK_CAN_DEFAULT | GTK_HAS_DEFAULT); g_signal_connect ( G_OBJECT (b), "clicked", G_CALLBACK (sp_text_edit_dialog_apply), dlg ); gtk_box_pack_end ( GTK_BOX (hb), b, FALSE, FALSE, 0 ); g_object_set_data (G_OBJECT (dlg), "apply", b); } g_signal_connect ( G_OBJECT (INKSCAPE), "modify_selection", G_CALLBACK (sp_text_edit_dialog_selection_modified), dlg); g_signal_connect ( G_OBJECT (INKSCAPE), "change_selection", G_CALLBACK (sp_text_edit_dialog_selection_changed), dlg); g_signal_connect (INKSCAPE, "change_subselection", G_CALLBACK (sp_text_edit_dialog_subselection_changed), dlg); gtk_widget_show_all (dlg); sp_text_edit_dialog_read_selection (dlg, TRUE, TRUE); } gtk_window_present ((GtkWindow *) dlg); } // end of sp_text_edit_dialog()
//============================================================================== // GOBJECT RELATED FUNCTIONS = //============================================================================== static void gebr_gui_sequence_edit_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *param_spec) { GebrGuiSequenceEdit *self; self = GEBR_GUI_SEQUENCE_EDIT (object); switch (property_id) { case VALUE_WIDGET: self->widget = g_value_get_pointer(value); gtk_box_pack_start(GTK_BOX(self->widget_hbox), self->widget, TRUE, TRUE, 0); break; case LIST_STORE: { GtkWidget *container; GtkWidget *tree_view; self->list_store = g_value_get_pointer(value); if (self->list_store == NULL) self->list_store = gtk_list_store_new(1, G_TYPE_STRING, -1); tree_view = GEBR_GUI_SEQUENCE_EDIT_GET_CLASS (self)->create_tree_view (self); self->priv->keypress_handler = g_signal_connect(tree_view, "key-release-event", G_CALLBACK (on_tree_view_key_release), self); gebr_gui_gtk_tree_view_set_reorder_callback(GTK_TREE_VIEW(tree_view), (GebrGuiGtkTreeViewReorderCallback) on_reorder, NULL, self); self->tree_view = tree_view; if (self->has_scroll) { container = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW (container), GTK_SHADOW_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (container), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); } else { container = gtk_frame_new(NULL); gtk_frame_set_shadow_type(GTK_FRAME(container), GTK_SHADOW_IN); g_signal_connect(tree_view, "size-request", G_CALLBACK(on_tree_view_size_request), NULL); } gtk_container_add(GTK_CONTAINER(container), tree_view); gtk_box_pack_start(GTK_BOX(self), container, TRUE, TRUE, 0); gtk_widget_show_all(container); gebr_gui_gtk_tree_view_set_popup_callback(GTK_TREE_VIEW(tree_view), (GebrGuiGtkPopupCallback) popup_menu, self); break; } case MAY_RENAME: self->may_rename = g_value_get_boolean(value); g_object_set(self->renderer, "editable", self->may_rename, NULL); break; case HAS_SCROLL: self->has_scroll = g_value_get_boolean(value); break; default: /*We don't have any other property... */ G_OBJECT_WARN_INVALID_PROPERTY_ID(self, property_id, param_spec); break; } }
void cartesianMover::cartesian_table_open(GtkButton *button, cartesianMover *cm) { //int *joint = currentClassData->indexPointer; /*ipos = currentPart->pos; iiencs = currentPart->iencs; iamp = currentPart->amp; ipid = currentPart->pid; */ GtkWidget *winTable = NULL; //adding a popup window winTable = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (winTable), cm->partLabel); gtk_window_set_default_size((GtkWindow*) winTable, 300, 300); //creating a new box GtkWidget *bottom_hbox = gtk_hbox_new (FALSE, 8); gtk_container_set_border_width (GTK_CONTAINER (bottom_hbox), 10); gtk_container_add (GTK_CONTAINER (winTable), bottom_hbox); //In the bottom frame there is: //1) the list of the cards GtkWidget *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), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_box_pack_start (GTK_BOX (bottom_hbox), sw, TRUE, TRUE, 0); //GtkTreeModel *myModel = currentPart->model; //GtkWidget *myTreeview = currentPart->treeview; GtkTreeModel *myModel = refresh_cartesian_list_model(cm); //create tree view GtkTreeSelection *treeSelection2 = NULL; GtkWidget *myTreeview = gtk_tree_view_new_with_model (myModel); cm->treeview=myTreeview; gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (myTreeview), TRUE); treeSelection2 = gtk_tree_view_get_selection(GTK_TREE_VIEW(myTreeview)); gtk_tree_selection_set_mode(treeSelection2, GTK_SELECTION_SINGLE); g_signal_connect (myTreeview, "row-activated", G_CALLBACK (cm->cartesian_line_click), cm); //g_object_unref (myModel); gtk_container_add (GTK_CONTAINER (sw), myTreeview); // add columns to the tree view add_cartesian_columns (GTK_TREE_VIEW (myTreeview), cm); //creating a new box GtkWidget *inv1 = gtk_fixed_new(); GtkWidget *frame1 = gtk_frame_new ("Commands"); gtk_container_add (GTK_CONTAINER (bottom_hbox), inv1); gtk_widget_set_size_request (frame1, 150, 400); gtk_fixed_put (GTK_FIXED (inv1), frame1, 10, 10); //GtkWidget *bottom_box = gtk_vbox_new (FALSE, 8); //gtk_container_set_border_width (GTK_CONTAINER (bottom_box), 10); //gtk_container_add (GTK_CONTAINER (bottom_hbox), bottom_box); //Button Go! in the panel cm->buttonGo = gtk_button_new_with_mnemonic ("Go!"); gtk_widget_set_size_request (cm->buttonGo, 100, 30); gtk_fixed_put (GTK_FIXED (inv1), cm->buttonGo, 30, 30); g_signal_connect (cm->buttonGo, "clicked", G_CALLBACK (go_click), cm); //Button "Save Sequence" in the panel cm->buttonSave = gtk_button_new_with_mnemonic ("Save"); gtk_widget_set_size_request (cm->buttonSave, 100, 30); gtk_fixed_put (GTK_FIXED (inv1), cm->buttonSave, 30, 130); g_signal_connect (cm->buttonSave, "clicked", G_CALLBACK (sequence_save), cm); //Button "Load Sequence" in the panel cm->buttonLoad = gtk_file_chooser_button_new ("Load Seqeunce", GTK_FILE_CHOOSER_ACTION_OPEN); gtk_widget_set_size_request (cm->buttonLoad, 100, 30); gtk_fixed_put (GTK_FIXED (inv1), cm->buttonLoad, 30, 180); g_signal_connect (cm->buttonLoad, "selection-changed", G_CALLBACK (sequence_load), cm); //g_signal_connect (button4, "clicked", G_CALLBACK (sequence_load),this); //Button "Cycle Sequence (time)" in the panel cm->buttonCycTim = gtk_button_new_with_mnemonic ("Cycle (time)"); gtk_widget_set_size_request (cm->buttonCycTim, 100, 30); gtk_fixed_put (GTK_FIXED (inv1), cm->buttonCycTim, 30, 280); g_signal_connect (cm->buttonCycTim, "clicked", G_CALLBACK (cm->sequence_cycle_time), cm); //Button "Stop Sequence" in the panel cm->buttonStp = gtk_button_new_with_mnemonic ("Stop"); gtk_widget_set_size_request (cm->buttonStp, 100, 30); gtk_fixed_put (GTK_FIXED (inv1), cm->buttonStp, 30, 330); g_signal_connect (cm->buttonStp, "clicked", G_CALLBACK (cm->sequence_stop),cm); //connection to the destroyer //g_signal_connect (winTable, "destroy",G_CALLBACK (destroy_main), &winTable); g_signal_connect (winTable, "destroy",G_CALLBACK (destroy_main), cm); //make it visible if (!GTK_WIDGET_VISIBLE (winTable)) gtk_widget_show_all (winTable); else { //fprintf(stderr, "Reinitializing all pointers\n"); //currentPart->button8 = NULL; gtk_widget_destroy (winTable); winTable = NULL; } gtk_main (); return; }
/***************************************************************************** Create citizens dialog *****************************************************************************/ static struct citizens_dialog *citizens_dialog_create(const struct city *pcity) { GtkWidget *frame, *sw; struct citizens_dialog *pdialog = fc_malloc(sizeof(struct citizens_dialog)); int i; pdialog->pcity = pcity; pdialog->store = citizens_dialog_store_new(); pdialog->sort = gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(pdialog->store)); g_object_unref(pdialog->store); gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(pdialog->sort), citizens_dialog_default_sort_column(), GTK_SORT_DESCENDING); pdialog->list = gtk_tree_view_new_with_model(GTK_TREE_MODEL(pdialog->sort)); gtk_widget_set_halign(pdialog->list, GTK_ALIGN_CENTER); g_object_unref(pdialog->sort); for (i = 0; i < num_citizens_cols; i++) { struct citizens_column *pcol; GtkCellRenderer *renderer; GtkTreeViewColumn *col; pcol = &citizens_cols[i]; col = NULL; switch (pcol->type) { case COL_FLAG: renderer = gtk_cell_renderer_pixbuf_new(); col = gtk_tree_view_column_new_with_attributes(_(pcol->title), renderer, "pixbuf", i, NULL); break; case COL_TEXT: renderer = gtk_cell_renderer_text_new(); g_object_set(renderer, "style-set", TRUE, "weight-set", TRUE, NULL); col = gtk_tree_view_column_new_with_attributes(_(pcol->title), renderer, "text", i, "style", CITIZENS_DLG_COL_STYLE, "weight", CITIZENS_DLG_COL_WEIGHT, NULL); gtk_tree_view_column_set_sort_column_id(col, i); break; case COL_RIGHT_TEXT: renderer = gtk_cell_renderer_text_new(); g_object_set(renderer, "style-set", TRUE, "weight-set", TRUE, NULL); col = gtk_tree_view_column_new_with_attributes(_(pcol->title), renderer, "text", i, "style", CITIZENS_DLG_COL_STYLE, "weight", CITIZENS_DLG_COL_WEIGHT, NULL); gtk_tree_view_column_set_sort_column_id(col, i); g_object_set(renderer, "xalign", 1.0, NULL); gtk_tree_view_column_set_alignment(col, 1.0); break; case COL_COLOR: case COL_BOOLEAN: /* These are not used. */ fc_assert(pcol->type != COL_COLOR && pcol->type != COL_BOOLEAN); continue; } if (col) { gtk_tree_view_append_column(GTK_TREE_VIEW(pdialog->list), col); } } gtk_widget_set_hexpand(GTK_WIDGET(pdialog->list), TRUE); gtk_widget_set_vexpand(GTK_WIDGET(pdialog->list), TRUE); sw = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw), GTK_SHADOW_NONE); gtk_container_add(GTK_CONTAINER(sw), pdialog->list); frame = gtk_frame_new(_("Citizens")); gtk_container_add(GTK_CONTAINER(frame), sw); pdialog->shell = frame; dialog_list_prepend(dialog_list, pdialog); citizens_dialog_refresh(pcity); return pdialog; }
static GtkWidget * do_image (const char *filename) { GtkWidget *frame; GtkWidget *vbox; GtkWidget *image; GtkWidget *label; GtkWidget *align; GtkWidget *window; gchar *str, *escaped; LoadContext *lc; window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (window), "Image Loading"); gtk_container_set_border_width (GTK_CONTAINER (window), 8); vbox = gtk_vbox_new (FALSE, 8); gtk_container_set_border_width (GTK_CONTAINER (vbox), 8); gtk_container_add (GTK_CONTAINER (window), vbox); label = gtk_label_new (NULL); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); escaped = g_markup_escape_text (filename, -1); str = g_strdup_printf ("Progressively loading: <b>%s</b>", escaped); gtk_label_set_markup (GTK_LABEL (label), str); g_free (escaped); g_free (str); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); /* The alignment keeps the frame from growing when users resize * the window */ align = gtk_alignment_new (0.5, 0.5, 0, 0); gtk_container_add (GTK_CONTAINER (align), frame); gtk_box_pack_start (GTK_BOX (vbox), align, FALSE, FALSE, 0); image = gtk_image_new_from_pixbuf (NULL); gtk_container_add (GTK_CONTAINER (frame), image); lc = get_load_context (image); lc->window = window; lc->filename = g_strdup (filename); start_progressive_loading (image); g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL); g_signal_connect (window, "delete_event", G_CALLBACK (gtk_main_quit), NULL); gtk_widget_show_all (window); return window; }
static void scrollable_policy (void) { GtkWidget *window, *swindow, *hbox, *vbox, *frame, *cntl, *listbox; GtkWidget *viewport, *label, *expander, *widget, *popover; window = gtk_window_new (GTK_WINDOW_TOPLEVEL); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_container_set_border_width (GTK_CONTAINER (window), 8); gtk_widget_show (vbox); gtk_widget_show (hbox); gtk_container_add (GTK_CONTAINER (window), hbox); gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0); frame = gtk_frame_new ("Scrolled Window"); gtk_widget_show (frame); gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0); swindow = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_show (swindow); gtk_container_add (GTK_CONTAINER (frame), swindow); viewport = gtk_viewport_new (NULL, NULL); label = gtk_label_new ("Here is a wrapping label with a minimum width-chars of 40 and " "a natural max-width-chars of 100 to demonstrate the usage of " "scrollable widgets \"hscroll-policy\" and \"vscroll-policy\" " "properties. Note also that when playing with the window height, " "one can observe that the vscrollbar disappears as soon as there " "is enough height to fit the content vertically if the window were " "to be allocated a width without a vscrollbar present"); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gtk_label_set_width_chars (GTK_LABEL (label), 40); gtk_label_set_max_width_chars (GTK_LABEL (label), 100); gtk_widget_show (label); gtk_widget_show (viewport); gtk_container_add (GTK_CONTAINER (viewport), label); gtk_container_add (GTK_CONTAINER (swindow), viewport); /* Add controls here */ expander = gtk_expander_new ("Controls"); gtk_expander_set_expanded (GTK_EXPANDER (expander), TRUE); cntl = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2); gtk_widget_show (cntl); gtk_widget_show (expander); gtk_container_add (GTK_CONTAINER (expander), cntl); gtk_box_pack_start (GTK_BOX (vbox), expander, FALSE, FALSE, 0); /* Add Horizontal policy control here */ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); gtk_widget_show (hbox); widget = gtk_label_new ("hscroll-policy"); gtk_widget_show (widget); gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0); widget = gtk_combo_box_text_new (); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Minimum"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Natural"); gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 0); gtk_widget_show (widget); gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (cntl), hbox, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (widget), "changed", G_CALLBACK (horizontal_policy_changed), viewport); /* Add Vertical policy control here */ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); gtk_widget_show (hbox); widget = gtk_label_new ("vscroll-policy"); gtk_widget_show (widget); gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0); widget = gtk_combo_box_text_new (); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Minimum"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Natural"); gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 0); gtk_widget_show (widget); gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (cntl), hbox, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (widget), "changed", G_CALLBACK (vertical_policy_changed), viewport); /* Content size controls */ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); widget = gtk_label_new ("min-content-width"); gtk_widget_show (widget); gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0); widget = gtk_spin_button_new_with_range (100.0, 1000.0, 10.0); gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (cntl), hbox, FALSE, FALSE, 0); gtk_widget_show (widget); gtk_widget_show (hbox); g_signal_connect (G_OBJECT (widget), "value-changed", G_CALLBACK (content_width_changed), swindow); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); widget = gtk_label_new ("min-content-height"); gtk_widget_show (widget); gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0); widget = gtk_spin_button_new_with_range (100.0, 1000.0, 10.0); gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (cntl), hbox, FALSE, FALSE, 0); gtk_widget_show (widget); gtk_widget_show (hbox); g_signal_connect (G_OBJECT (widget), "value-changed", G_CALLBACK (content_height_changed), swindow); /* Add Label orientation control here */ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); gtk_widget_show (hbox); widget = gtk_label_new ("label-flip"); gtk_widget_show (widget); gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0); widget = gtk_combo_box_text_new (); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Horizontal"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Vertical"); gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 0); gtk_widget_show (widget); gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (cntl), hbox, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (widget), "changed", G_CALLBACK (label_flip_changed), label); /* Add Kinetic scrolling control here */ widget = gtk_check_button_new_with_label ("Kinetic scrolling"); gtk_widget_show (widget); gtk_box_pack_start (GTK_BOX (cntl), widget, TRUE, TRUE, 0); g_signal_connect (G_OBJECT (widget), "toggled", G_CALLBACK (kinetic_scrolling_changed), swindow); gtk_widget_show (window); /* Popover */ popover = gtk_popover_new (NULL); widget = gtk_menu_button_new (); gtk_menu_button_set_popover (GTK_MENU_BUTTON (widget), popover); gtk_container_add (GTK_CONTAINER (widget), gtk_label_new ("Popover")); gtk_box_pack_start (GTK_BOX (cntl), widget, FALSE, FALSE, 0); gtk_widget_show_all (widget); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_container_add (GTK_CONTAINER (popover), vbox); gtk_widget_show (vbox); /* Popover's scrolled window */ swindow = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_end (GTK_BOX (vbox), swindow, FALSE, FALSE, 0); gtk_widget_show (swindow); gtk_widget_show (hbox); /* Listbox */ listbox = gtk_list_box_new (); gtk_container_add (GTK_CONTAINER (swindow), listbox); gtk_widget_show (listbox); /* Min content */ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); widget = gtk_label_new ("min-content-width"); gtk_widget_show (widget); gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0); widget = gtk_spin_button_new_with_range (0.0, 150.0, 10.0); gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0); gtk_widget_show (widget); gtk_widget_show (hbox); g_object_bind_property (gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (widget)), "value", swindow, "min-content-width", G_BINDING_DEFAULT | G_BINDING_SYNC_CREATE); widget = gtk_label_new ("min-content-height"); gtk_widget_show (widget); gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0); widget = gtk_spin_button_new_with_range (0.0, 150.0, 10.0); gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (widget); gtk_widget_show (hbox); g_object_bind_property (gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (widget)), "value", swindow, "min-content-height", G_BINDING_DEFAULT | G_BINDING_SYNC_CREATE); /* Max content */ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); widget = gtk_label_new ("max-content-width"); gtk_widget_show (widget); gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0); widget = gtk_spin_button_new_with_range (250.0, 1000.0, 10.0); gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0); gtk_widget_show (widget); gtk_widget_show (hbox); g_object_bind_property (gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (widget)), "value", swindow, "max-content-width", G_BINDING_DEFAULT | G_BINDING_SYNC_CREATE); widget = gtk_label_new ("max-content-height"); gtk_widget_show (widget); gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0); widget = gtk_spin_button_new_with_range (250.0, 1000.0, 10.0); gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (widget); gtk_widget_show (hbox); g_object_bind_property (gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (widget)), "value", swindow, "max-content-height", G_BINDING_DEFAULT | G_BINDING_SYNC_CREATE); /* Add and Remove buttons */ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); widget = gtk_button_new_with_label ("Remove"); gtk_widget_show (widget); gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0); g_signal_connect (widget, "clicked", G_CALLBACK (remove_row), listbox); widget = gtk_button_new_with_label ("Add"); gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (widget); gtk_widget_show (hbox); g_signal_connect (widget, "clicked", G_CALLBACK (add_row), listbox); }
int main(int argc, char *argv[]) { gtk_init(&argc, &argv); GtkWidget *window = gtk_window_new(GTK_WINDOW_TOPLEVEL); g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(gtk_main_quit), NULL); gtk_window_set_title(GTK_WINDOW(window), "Label Demo"); GtkWidget *hbox = gtk_hbox_new(FALSE, 5); gtk_container_add(GTK_CONTAINER(window), hbox); gtk_widget_show(hbox); GtkWidget *vbox = gtk_vbox_new(FALSE, 5); gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 0); gtk_widget_show(vbox); GtkWidget *frame; GtkWidget *label; frame = gtk_frame_new("Normal Label"); label = gtk_label_new("This is a normal label."); gtk_container_add(GTK_CONTAINER(frame), label); gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 0); frame = gtk_frame_new("Multi-line Label"); label = gtk_label_new("This is a Multi-line \n label."); gtk_container_add(GTK_CONTAINER(frame), label); gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 0); frame = gtk_frame_new("Left Justed Label"); label = gtk_label_new("Left?.\nThis is the second line."); gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT); gtk_container_add(GTK_CONTAINER(frame), label); gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 0); frame = gtk_frame_new("Right Justed Label"); label = gtk_label_new("Right?.\nThis is the second line."); gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_RIGHT); gtk_container_add(GTK_CONTAINER(frame), label); gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 0); vbox = gtk_vbox_new(FALSE, 5); gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 0); frame = gtk_frame_new("Line wrapped label"); label = gtk_label_new("This is an example of a line-warpped label. It should not be taking up the entire width allocated to it, but automatically wraps the words to fit."); gtk_label_set_line_wrap(GTK_LABEL(label), TRUE); gtk_container_add(GTK_CONTAINER(frame), label); gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 0); frame = gtk_frame_new("Filled, wrapped label"); label = gtk_label_new("This is an example of a line-warpped label. It should not be taking up the entire width allocated to it, but automatically wraps the words to fit."); gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_FILL); gtk_label_set_line_wrap(GTK_LABEL(label), TRUE); gtk_container_add(GTK_CONTAINER(frame), label); gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 0); frame = gtk_frame_new("Filled, wrapped label"); label = gtk_label_new("This is an example of a line-warpped \nlabel. It should not be taking up the entire width allocated to it, but automatically wraps the words to fit."); gtk_label_set_pattern(GTK_LABEL(label), "_ _ "); gtk_container_add(GTK_CONTAINER(frame), label); gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 0); gtk_widget_show_all(window); gtk_main(); return 0; }
/* Create actual buttons */ GtkWidget * create_zoom_buttons (void) { GtkWidget *table; GtkWidget *table2; GtkWidget *frame; GtkWidget *main_vbox; GtkWidget *b1; GtkWidget *b2; GtkWidget *b3; GtkWidget *b4; GtkWidget *b5; GtkWidget *b6; GtkWidget *pixmapzout, *pixmapzin, *pixmapzfit, *pixmapzundo; GtkWidget *pixmapzleft, *pixmapzright; GtkTooltips *tooltips; tooltips=gtk_tooltips_new_2(); gtk_tooltips_set_delay_2(tooltips,1500); pixmapzin=gtk_pixmap_new(GLOBALS->zoomin_pixmap, GLOBALS->zoomin_mask); gtk_widget_show(pixmapzin); pixmapzout=gtk_pixmap_new(GLOBALS->zoomout_pixmap, GLOBALS->zoomout_mask); gtk_widget_show(pixmapzout); pixmapzfit=gtk_pixmap_new(GLOBALS->zoomfit_pixmap, GLOBALS->zoomfit_mask); gtk_widget_show(pixmapzfit); pixmapzundo=gtk_pixmap_new(GLOBALS->zoomundo_pixmap, GLOBALS->zoomundo_mask); gtk_widget_show(pixmapzundo); pixmapzleft=gtk_pixmap_new(GLOBALS->zoom_larrow_pixmap, GLOBALS->zoom_larrow_mask); gtk_widget_show(pixmapzleft); pixmapzright=gtk_pixmap_new(GLOBALS->zoom_rarrow_pixmap, GLOBALS->zoom_rarrow_mask); gtk_widget_show(pixmapzright); /* Create a table to hold the text widget and scrollbars */ table = gtk_table_new (1, 1, FALSE); main_vbox = gtk_vbox_new (FALSE, 1); gtk_container_border_width (GTK_CONTAINER (main_vbox), 1); gtk_container_add (GTK_CONTAINER (table), main_vbox); frame = gtk_frame_new ("Zoom "); gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0); gtk_widget_show (frame); gtk_widget_show (main_vbox); table2 = gtk_table_new (2, 3, FALSE); b1 = gtk_button_new(); gtk_container_add(GTK_CONTAINER(b1), pixmapzin); gtk_table_attach (GTK_TABLE (table2), b1, 0, 1, 0, 1, GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND | GTK_SHRINK, 1, 1); gtk_signal_connect_object (GTK_OBJECT (b1), "clicked", GTK_SIGNAL_FUNC(service_zoom_out), GTK_OBJECT (table2)); gtk_tooltips_set_tip_2(tooltips, b1, "Zoom Out", NULL); gtk_widget_show(b1); b2 = gtk_button_new(); gtk_container_add(GTK_CONTAINER(b2), pixmapzout); gtk_table_attach (GTK_TABLE (table2), b2, 0, 1, 1, 2, GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND | GTK_SHRINK, 1, 1); gtk_signal_connect_object (GTK_OBJECT (b2), "clicked", GTK_SIGNAL_FUNC(service_zoom_in), GTK_OBJECT (table2)); gtk_tooltips_set_tip_2(tooltips, b2, "Zoom In", NULL); gtk_widget_show(b2); b3 = gtk_button_new(); gtk_container_add(GTK_CONTAINER(b3), pixmapzfit); gtk_table_attach (GTK_TABLE (table2), b3, 1, 2, 0, 1, GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND | GTK_SHRINK, 1, 1); gtk_signal_connect_object (GTK_OBJECT (b3), "clicked", GTK_SIGNAL_FUNC(service_zoom_fit), GTK_OBJECT (table2)); gtk_tooltips_set_tip_2(tooltips, b3, "Zoom Best Fit", NULL); gtk_widget_show(b3); b4 = gtk_button_new(); gtk_container_add(GTK_CONTAINER(b4), pixmapzundo); gtk_table_attach (GTK_TABLE (table2), b4, 1, 2, 1, 2, GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND | GTK_SHRINK, 1, 1); gtk_signal_connect_object (GTK_OBJECT (b4), "clicked", GTK_SIGNAL_FUNC(service_zoom_undo), GTK_OBJECT (table2)); gtk_tooltips_set_tip_2(tooltips, b4, "Undo Last Zoom", NULL); gtk_widget_show(b4); b5 = gtk_button_new(); gtk_container_add(GTK_CONTAINER(b5), pixmapzleft); gtk_table_attach (GTK_TABLE (table2), b5, 2, 3, 0, 1, GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND | GTK_SHRINK, 1, 1); gtk_signal_connect_object (GTK_OBJECT (b5), "clicked", GTK_SIGNAL_FUNC(service_zoom_left), GTK_OBJECT (table2)); gtk_tooltips_set_tip_2(tooltips, b5, "Zoom To Start", NULL); gtk_widget_show(b5); b6 = gtk_button_new(); gtk_container_add(GTK_CONTAINER(b6), pixmapzright); gtk_table_attach (GTK_TABLE (table2), b6, 2, 3, 1, 2, GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND | GTK_SHRINK, 1, 1); gtk_signal_connect_object (GTK_OBJECT (b6), "clicked", GTK_SIGNAL_FUNC(service_zoom_right), GTK_OBJECT (table2)); gtk_tooltips_set_tip_2(tooltips, b6, "Zoom To End", NULL); gtk_widget_show(b6); gtk_container_add (GTK_CONTAINER (frame), table2); gtk_widget_show(table2); return table; }
void create_brushpage (GtkNotebook *notebook) { GtkWidget *box1, *box2, *box3, *thispage; GtkWidget *view; GtkWidget *tmpw, *grid; GtkWidget *frame; GtkWidget *combo; GtkWidget *label; GtkSizeGroup *group; GtkTreeSelection *selection; label = gtk_label_new_with_mnemonic (_("_Brush")); thispage = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); gtk_container_set_border_width (GTK_CONTAINER (thispage), 12); gtk_widget_show (thispage); box1 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_box_pack_start (GTK_BOX (thispage), box1, TRUE,TRUE,0); gtk_widget_show (box1); view = create_one_column_list (box1, brush_select_file); brush_list = view; brush_list_store = GTK_LIST_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (view))); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (view)); box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0); gtk_widget_show (box2); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX (box2), frame, FALSE, FALSE, 0); gtk_widget_show (frame); brush_preview = tmpw = gimp_preview_area_new (); gtk_widget_set_size_request (brush_preview, 100, 100); gtk_container_add (GTK_CONTAINER (frame), tmpw); gtk_widget_show (tmpw); g_signal_connect (brush_preview, "size-allocate", G_CALLBACK (brush_preview_size_allocate), NULL); box3 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2); gtk_box_pack_end (GTK_BOX (box2), box3, FALSE, FALSE,0); gtk_widget_show (box3); tmpw = gtk_label_new (_("Gamma:")); gtk_label_set_xalign (GTK_LABEL (tmpw), 0.0); gtk_box_pack_start (GTK_BOX (box3), tmpw, FALSE, FALSE,0); gtk_widget_show (tmpw); brush_gamma_adjust = gtk_adjustment_new (pcvals.brushgamma, 0.5, 3.0, 0.1, 0.1, 1.0); tmpw = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, brush_gamma_adjust); gtk_widget_set_size_request (GTK_WIDGET (tmpw), 100, 30); gtk_scale_set_draw_value (GTK_SCALE (tmpw), FALSE); gtk_scale_set_digits (GTK_SCALE (tmpw), 2); gtk_box_pack_start (GTK_BOX (box3), tmpw, FALSE, FALSE, 0); gtk_widget_show (tmpw); g_signal_connect_swapped (brush_gamma_adjust, "value-changed", G_CALLBACK (update_brush_preview), pcvals.selected_brush); gimp_help_set_help_data (tmpw, _("Changes the gamma (brightness) of the selected brush"), NULL); box3 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_start (GTK_BOX (thispage), box3, FALSE, FALSE,0); gtk_widget_show (box3); group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL); tmpw = gtk_label_new (_("Select:")); gtk_label_set_xalign (GTK_LABEL (tmpw), 0.0); gtk_box_pack_start (GTK_BOX (box3), tmpw, FALSE, FALSE, 0); gtk_widget_show (tmpw); gtk_size_group_add_widget (group, tmpw); g_object_unref (group); combo = gimp_drawable_combo_box_new (validdrawable, NULL); gimp_int_combo_box_connect (GIMP_INT_COMBO_BOX (combo), -1, G_CALLBACK (brushdmenuselect), NULL); gtk_box_pack_start (GTK_BOX (box3), combo, TRUE, TRUE, 0); gtk_widget_show (combo); tmpw = gtk_button_new_with_mnemonic (_("Save _as")); gtk_box_pack_start (GTK_BOX (box3),tmpw, FALSE, FALSE, 0); g_signal_connect (tmpw, "clicked", G_CALLBACK (savebrush), NULL); gtk_widget_show (tmpw); grid = gtk_grid_new (); gtk_grid_set_row_spacing (GTK_GRID (grid), 6); gtk_grid_set_column_spacing (GTK_GRID (grid), 6); gtk_box_pack_start (GTK_BOX (thispage), grid, FALSE, FALSE, 0); gtk_widget_show (grid); brush_aspect_adjust = gimp_scale_entry_new (GTK_GRID (grid), 0, 0, _("Aspect ratio:"), 150, -1, pcvals.brush_aspect, -1.0, 1.0, 0.1, 0.1, 2, TRUE, 0, 0, _("Specifies the aspect ratio of the brush"), NULL); gtk_size_group_add_widget (group, GIMP_SCALE_ENTRY_LABEL (brush_aspect_adjust)); g_signal_connect (brush_aspect_adjust, "value-changed", G_CALLBACK (brush_asepct_adjust_cb), &pcvals.brush_aspect); brush_relief_adjust = gimp_scale_entry_new (GTK_GRID (grid), 0, 1, _("Relief:"), 150, -1, pcvals.brush_relief, 0.0, 100.0, 1.0, 10.0, 1, TRUE, 0, 0, _("Specifies the amount of embossing to apply to the image (in percent)"), NULL); gtk_size_group_add_widget (group, GIMP_SCALE_ENTRY_LABEL (brush_relief_adjust)); g_signal_connect (brush_relief_adjust, "value-changed", G_CALLBACK (gimp_double_adjustment_update), &pcvals.brush_relief); brush_select (selection, FALSE); readdirintolist ("Brushes", view, pcvals.selected_brush); /* * This is so the "changed signal won't get sent to the brushes' list * and reset the gamma and stuff. * */ gtk_widget_grab_focus (brush_list); gtk_notebook_append_page_menu (notebook, thispage, label, NULL); }
GtkWidget *plugin_configure(GtkDialog *dialog) { GtkWidget *vbox, *check_openuri, *check_tasks, *check_systray; GtkWidget *check_doclist, *vbox_doclist, *frame_doclist; GtkWidget *radio_doclist_name, *radio_doclist_occurrence; GtkWidget *check_bookmarklist, *check_markword, *frame_tasks, *vbox_tasks; GtkWidget *check_tasks_scan_mode, *entry_tasks_tokens, *label_tasks_tokens, *tokens_hbox; GtkWidget *check_blanklines, *check_xmltagging; vbox = gtk_vbox_new(FALSE, 6); check_doclist = gtk_check_button_new_with_label( _("Show toolbar item to show a list of currently open documents")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_doclist), ao_info->enable_doclist); g_signal_connect(check_doclist, "toggled", G_CALLBACK(ao_configure_doclist_toggled_cb), dialog); radio_doclist_name = gtk_radio_button_new_with_mnemonic(NULL, _("Sort documents by _name")); ui_widget_set_tooltip_text(radio_doclist_name, _("Sort the documents in the list by their filename")); radio_doclist_occurrence = gtk_radio_button_new_with_mnemonic_from_widget( GTK_RADIO_BUTTON(radio_doclist_name), _("Sort documents by _occurrence")); ui_widget_set_tooltip_text(radio_doclist_name, _("Sort the documents in the order of the document tabs")); if (ao_info->doclist_sort_mode == DOCLIST_SORT_BY_NAME) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radio_doclist_name), TRUE); else gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radio_doclist_occurrence), TRUE); vbox_doclist = gtk_vbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox_doclist), radio_doclist_name, FALSE, FALSE, 3); gtk_box_pack_start(GTK_BOX(vbox_doclist), radio_doclist_occurrence, TRUE, TRUE, 3); frame_doclist = gtk_frame_new(NULL); gtk_frame_set_label_widget(GTK_FRAME(frame_doclist), check_doclist); gtk_container_add(GTK_CONTAINER(frame_doclist), vbox_doclist); gtk_box_pack_start(GTK_BOX(vbox), frame_doclist, FALSE, FALSE, 3); check_openuri = gtk_check_button_new_with_label( /* TODO fix the string */ _("Show a 'Open URI' menu item in the editor menu")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_openuri), ao_info->enable_openuri); gtk_box_pack_start(GTK_BOX(vbox), check_openuri, FALSE, FALSE, 3); check_tasks = gtk_check_button_new_with_label( _("Show available Tasks in the Messages Window")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_tasks), ao_info->enable_tasks); g_signal_connect(check_tasks, "toggled", G_CALLBACK(ao_configure_tasks_toggled_cb), dialog); check_tasks_scan_mode = gtk_check_button_new_with_label( _("Show tasks of all documents")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_tasks_scan_mode), ao_info->tasks_scan_all_documents); ui_widget_set_tooltip_text(check_tasks_scan_mode, _("Whether to show the tasks of all open documents in the list or only those of the current document.")); entry_tasks_tokens = gtk_entry_new(); if (NZV(ao_info->tasks_token_list)) gtk_entry_set_text(GTK_ENTRY(entry_tasks_tokens), ao_info->tasks_token_list); ui_entry_add_clear_icon(GTK_ENTRY(entry_tasks_tokens)); ui_widget_set_tooltip_text(entry_tasks_tokens, _("Specify a semicolon separated list of search tokens.")); label_tasks_tokens = gtk_label_new_with_mnemonic(_("Search tokens:")); gtk_label_set_mnemonic_widget(GTK_LABEL(label_tasks_tokens), entry_tasks_tokens); tokens_hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(tokens_hbox), label_tasks_tokens, FALSE, FALSE, 3); gtk_box_pack_start(GTK_BOX(tokens_hbox), entry_tasks_tokens, TRUE, TRUE, 3); vbox_tasks = gtk_vbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox_tasks), check_tasks_scan_mode, FALSE, FALSE, 3); gtk_box_pack_start(GTK_BOX(vbox_tasks), tokens_hbox, TRUE, TRUE, 3); frame_tasks = gtk_frame_new(NULL); gtk_frame_set_label_widget(GTK_FRAME(frame_tasks), check_tasks); gtk_container_add(GTK_CONTAINER(frame_tasks), vbox_tasks); gtk_box_pack_start(GTK_BOX(vbox), frame_tasks, FALSE, FALSE, 3); check_systray = gtk_check_button_new_with_label( _("Show status icon in the Notification Area")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_systray), ao_info->enable_systray); gtk_box_pack_start(GTK_BOX(vbox), check_systray, FALSE, FALSE, 3); check_bookmarklist = gtk_check_button_new_with_label( _("Show defined bookmarks (marked lines) in the sidebar")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_bookmarklist), ao_info->enable_bookmarklist); gtk_box_pack_start(GTK_BOX(vbox), check_bookmarklist, FALSE, FALSE, 3); check_markword = gtk_check_button_new_with_label( _("Mark all occurrences of a word when double-clicking it")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_markword), ao_info->enable_markword); gtk_box_pack_start(GTK_BOX(vbox), check_markword, FALSE, FALSE, 3); check_blanklines = gtk_check_button_new_with_label( _("Strip trailing blank lines")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_blanklines), ao_info->strip_trailing_blank_lines); gtk_box_pack_start(GTK_BOX(vbox), check_blanklines, FALSE, FALSE, 3); check_xmltagging = gtk_check_button_new_with_label( _("XML tagging for selection")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_xmltagging), ao_info->enable_xmltagging); gtk_box_pack_start(GTK_BOX(vbox), check_xmltagging, FALSE, FALSE, 3); g_object_set_data(G_OBJECT(dialog), "check_doclist", check_doclist); g_object_set_data(G_OBJECT(dialog), "radio_doclist_name", radio_doclist_name); g_object_set_data(G_OBJECT(dialog), "radio_doclist_occurrence", radio_doclist_occurrence); g_object_set_data(G_OBJECT(dialog), "check_openuri", check_openuri); g_object_set_data(G_OBJECT(dialog), "check_tasks", check_tasks); g_object_set_data(G_OBJECT(dialog), "entry_tasks_tokens", entry_tasks_tokens); g_object_set_data(G_OBJECT(dialog), "check_tasks_scan_mode", check_tasks_scan_mode); g_object_set_data(G_OBJECT(dialog), "check_systray", check_systray); g_object_set_data(G_OBJECT(dialog), "check_bookmarklist", check_bookmarklist); g_object_set_data(G_OBJECT(dialog), "check_markword", check_markword); g_object_set_data(G_OBJECT(dialog), "check_blanklines", check_blanklines); g_object_set_data(G_OBJECT(dialog), "check_xmltagging", check_xmltagging); g_signal_connect(dialog, "response", G_CALLBACK(ao_configure_response_cb), NULL); ao_configure_tasks_toggled_cb(GTK_TOGGLE_BUTTON(check_tasks), dialog); ao_configure_doclist_toggled_cb(GTK_TOGGLE_BUTTON(check_doclist), dialog); gtk_widget_show_all(vbox); #if ! GTK_CHECK_VERSION(2, 10, 0) gtk_widget_hide(check_systray); #endif return vbox; }
static gboolean avatar_image_button_press_event (GtkWidget *widget, GdkEventButton *event) { EmpathyAvatarImagePriv *priv; GtkWidget *popup; GtkWidget *frame; GtkWidget *image; gint x, y; gint popup_width, popup_height; gint width, height; GdkPixbuf *pixbuf; GtkAllocation allocation; priv = GET_PRIV (widget); if (priv->popup) { gtk_widget_destroy (priv->popup); priv->popup = NULL; } if (event->button != 1 || event->type != GDK_BUTTON_PRESS || !priv->pixbuf) { return FALSE; } popup_width = gdk_pixbuf_get_width (priv->pixbuf); popup_height = gdk_pixbuf_get_height (priv->pixbuf); gtk_widget_get_allocation (priv->image, &allocation); width = allocation.width; height = allocation.height; /* Don't show a popup if the popup is smaller then the currently avatar * image. */ if (popup_height <= height && popup_width <= width) { return TRUE; } pixbuf = tpaw_pixbuf_scale_down_if_necessary (priv->pixbuf, MAX_LARGE); popup_width = gdk_pixbuf_get_width (pixbuf); popup_height = gdk_pixbuf_get_height (pixbuf); popup = gtk_window_new (GTK_WINDOW_POPUP); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT); gtk_container_add (GTK_CONTAINER (popup), frame); image = gtk_image_new (); gtk_container_add (GTK_CONTAINER (frame), image); gtk_image_set_from_pixbuf (GTK_IMAGE (image), pixbuf); g_object_unref (pixbuf); gdk_window_get_origin (gtk_widget_get_window (priv->image), &x, &y); x = x - (popup_width - width) / 2; y = y - (popup_height - height) / 2; gtk_window_move (GTK_WINDOW (popup), x, y); priv->popup = popup; gtk_widget_show_all (popup); return TRUE; }
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); }