gint
main (gint argc, gchar **argv)
{
GtkWidget *window, *toolbar, *grid, *treeview, *scrolled_window;
GtkWidget *hbox, *hbox1, *hbox2, *checkbox, *option_menu, *menu;
gint i;
static const gchar *toolbar_styles[] = { "icons", "text", "both (vertical)",
"both (horizontal)" };
GtkToolItem *item;
GtkListStore *store;
GtkWidget *image;
GtkWidget *menuitem;
GtkWidget *button;
GtkWidget *label;
GIcon *gicon;
GSList *group;
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (window, "destroy", G_CALLBACK(gtk_main_quit), NULL);
grid = gtk_grid_new ();
gtk_container_add (GTK_CONTAINER (window), grid);
toolbar = gtk_toolbar_new ();
gtk_grid_attach (GTK_GRID (grid), toolbar, 0, 0, 2, 1);
hbox1 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 3);
gtk_container_set_border_width (GTK_CONTAINER (hbox1), 5);
gtk_grid_attach (GTK_GRID (grid), hbox1, 1, 1, 1, 1);
hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
gtk_container_set_border_width (GTK_CONTAINER (hbox2), 5);
gtk_grid_attach (GTK_GRID (grid), hbox2, 1, 2, 1, 1);
checkbox = gtk_check_button_new_with_mnemonic("_Vertical");
gtk_box_pack_start (GTK_BOX (hbox1), checkbox, FALSE, FALSE, 0);
g_signal_connect (checkbox, "toggled",
G_CALLBACK (change_orientation), toolbar);
checkbox = gtk_check_button_new_with_mnemonic("_Show Arrow");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbox), TRUE);
gtk_box_pack_start (GTK_BOX (hbox1), checkbox, FALSE, FALSE, 0);
g_signal_connect (checkbox, "toggled",
G_CALLBACK (change_show_arrow), toolbar);
checkbox = gtk_check_button_new_with_mnemonic("_Set Toolbar Style:");
g_signal_connect (checkbox, "toggled", G_CALLBACK (set_toolbar_style_toggled), toolbar);
gtk_box_pack_start (GTK_BOX (hbox1), checkbox, FALSE, FALSE, 0);
option_menu = gtk_combo_box_text_new ();
gtk_widget_set_sensitive (option_menu, FALSE);
g_object_set_data (G_OBJECT (checkbox), "option-menu", option_menu);
for (i = 0; i < G_N_ELEMENTS (toolbar_styles); i++)
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (option_menu), toolbar_styles[i]);
gtk_combo_box_set_active (GTK_COMBO_BOX (option_menu),
gtk_toolbar_get_style (GTK_TOOLBAR (toolbar)));
gtk_box_pack_start (GTK_BOX (hbox2), option_menu, FALSE, FALSE, 0);
g_signal_connect (option_menu, "changed",
G_CALLBACK (change_toolbar_style), toolbar);
checkbox = gtk_check_button_new_with_mnemonic("_Set Icon Size:");
g_signal_connect (checkbox, "toggled", G_CALLBACK (set_icon_size_toggled), toolbar);
gtk_box_pack_start (GTK_BOX (hbox2), checkbox, FALSE, FALSE, 0);
option_menu = gtk_combo_box_text_new ();
g_object_set_data (G_OBJECT (checkbox), "option-menu", option_menu);
gtk_widget_set_sensitive (option_menu, FALSE);
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (option_menu), "small toolbar");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (option_menu), "large toolbar");
gtk_box_pack_start (GTK_BOX (hbox2), option_menu, FALSE, FALSE, 0);
g_signal_connect (option_menu, "changed",
G_CALLBACK (icon_size_history_changed), toolbar);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_widget_set_hexpand (scrolled_window, TRUE);
gtk_widget_set_vexpand (scrolled_window, TRUE);
gtk_grid_attach (GTK_GRID (grid), scrolled_window, 1, 3, 1, 1);
store = create_items_list (&treeview);
gtk_container_add (GTK_CONTAINER (scrolled_window), treeview);
item = gtk_tool_button_new (NULL, NULL);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "document-new");
gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Custom label");
add_item_to_list (store, item, "New");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
gdk_threads_add_timeout (3000, (GSourceFunc) timeout_cb, item);
gtk_tool_item_set_expand (item, TRUE);
menu = gtk_menu_new ();
for (i = 0; i < 20; i++)
{
char *text;
text = g_strdup_printf ("Menuitem %d", i);
menuitem = gtk_menu_item_new_with_label (text);
g_free (text);
gtk_widget_show (menuitem);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
}
item = gtk_menu_tool_button_new (NULL, NULL);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "document-open");
gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Open");
gtk_menu_tool_button_set_menu (GTK_MENU_TOOL_BUTTON (item), menu);
add_item_to_list (store, item, "Open");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
gdk_threads_add_timeout (3000, (GSourceFunc) timeout_cb1, item);
menu = gtk_menu_new ();
for (i = 0; i < 20; i++)
{
char *text;
text = g_strdup_printf ("A%d", i);
menuitem = gtk_menu_item_new_with_label (text);
g_free (text);
gtk_widget_show (menuitem);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
}
item = gtk_menu_tool_button_new (NULL, NULL);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "go-previous");
gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Back");
gtk_menu_tool_button_set_menu (GTK_MENU_TOOL_BUTTON (item), menu);
add_item_to_list (store, item, "BackWithHistory");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_separator_tool_item_new ();
add_item_to_list (store, item, "-----");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
image = gtk_image_new_from_icon_name ("dialog-warning", GTK_ICON_SIZE_DIALOG);
item = gtk_tool_item_new ();
gtk_widget_show (image);
gtk_container_add (GTK_CONTAINER (item), image);
add_item_to_list (store, item, "(Custom Item)");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_tool_button_new (NULL, NULL);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "go-previous");
gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Back");
add_item_to_list (store, item, "Back");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_separator_tool_item_new ();
add_item_to_list (store, item, "-----");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_tool_button_new (NULL, NULL);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "go-next");
gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Forward");
add_item_to_list (store, item, "Forward");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_toggle_tool_button_new ();
gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Bold");
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "format-text-bold");
g_signal_connect (item, "toggled", G_CALLBACK (bold_toggled), NULL);
add_item_to_list (store, item, "Bold");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
gtk_widget_set_sensitive (GTK_WIDGET (item), FALSE);
item = gtk_separator_tool_item_new ();
add_item_to_list (store, item, "-----");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
gtk_tool_item_set_expand (item, TRUE);
gtk_separator_tool_item_set_draw (GTK_SEPARATOR_TOOL_ITEM (item), FALSE);
g_assert (gtk_toolbar_get_nth_item (GTK_TOOLBAR (toolbar), 0) != 0);
item = gtk_radio_tool_button_new (NULL);
gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Left");
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "format-justify-left");
group = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (item));
add_item_to_list (store, item, "Left");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_radio_tool_button_new (group);
gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Center");
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "format-justify-center");
group = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (item));
add_item_to_list (store, item, "Center");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_radio_tool_button_new (group);
gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Right");
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "format-justify-right");
add_item_to_list (store, item, "Right");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_tool_button_new (gtk_image_new_from_file ("apple-red.png"), "_Apple");
add_item_to_list (store, item, "Apple");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
gtk_tool_button_set_use_underline (GTK_TOOL_BUTTON (item), TRUE);
gicon = g_content_type_get_icon ("video/ogg");
image = gtk_image_new_from_gicon (gicon, GTK_ICON_SIZE_LARGE_TOOLBAR);
g_object_unref (gicon);
item = gtk_tool_button_new (image, "Video");
add_item_to_list (store, item, "Video");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
image = gtk_image_new_from_icon_name ("utilities-terminal", GTK_ICON_SIZE_LARGE_TOOLBAR);
item = gtk_tool_button_new (image, "Terminal");
add_item_to_list (store, item, "Terminal");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
image = gtk_spinner_new ();
gtk_spinner_start (GTK_SPINNER (image));
item = gtk_tool_button_new (image, "Spinner");
add_item_to_list (store, item, "Spinner");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
gtk_widget_set_hexpand (hbox, TRUE);
gtk_grid_attach (GTK_GRID (grid), hbox, 1, 4, 1, 1);
button = gtk_button_new_with_label ("Drag me to the toolbar");
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
label = gtk_label_new ("Drop index:");
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
label = gtk_label_new ("");
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
checkbox = gtk_check_button_new_with_mnemonic("_Right to left");
if (gtk_widget_get_default_direction () == GTK_TEXT_DIR_RTL)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbox), TRUE);
else
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbox), FALSE);
g_signal_connect (checkbox, "toggled", G_CALLBACK (rtl_toggled), NULL);
gtk_box_pack_end (GTK_BOX (hbox), checkbox, FALSE, FALSE, 0);
gtk_drag_source_set (button, GDK_BUTTON1_MASK,
target_table, G_N_ELEMENTS (target_table),
GDK_ACTION_MOVE);
gtk_drag_dest_set (toolbar, GTK_DEST_DEFAULT_DROP,
target_table, G_N_ELEMENTS (target_table),
GDK_ACTION_MOVE);
g_signal_connect (toolbar, "drag_motion",
G_CALLBACK (toolbar_drag_motion), NULL);
g_signal_connect (toolbar, "drag_leave",
G_CALLBACK (toolbar_drag_leave), NULL);
g_signal_connect (toolbar, "drag_drop",
G_CALLBACK (toolbar_drag_drop), label);
gtk_widget_show_all (window);
g_signal_connect (window, "delete_event", G_CALLBACK (gtk_main_quit), NULL);
g_signal_connect (toolbar, "popup_context_menu", G_CALLBACK (popup_context_menu), NULL);
gtk_main ();
return 0;
}
GtkWidget *
pgd_layers_create_widget (PopplerDocument *document)
{
PgdLayersDemo *demo;
GtkWidget *swindow;
GtkWidget *treeview;
GtkTreeModel *model;
GtkCellRenderer *renderer;
GtkWidget *hpaned, *viewer;
demo = g_new0 (PgdLayersDemo, 1);
demo->doc = g_object_ref (document);
hpaned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
viewer = pgd_layers_create_viewer (demo);
swindow = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
model = pgd_layers_create_model (document);
treeview = gtk_tree_view_new_with_model (model);
demo->treeview = treeview;
g_object_unref (model);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),
0, "Layer",
renderer,
"markup", LAYERS_TITLE_COLUMN,
NULL);
g_object_set (G_OBJECT (renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
g_object_set (G_OBJECT (gtk_tree_view_get_column (GTK_TREE_VIEW (treeview), 0)),
"expand", TRUE, NULL);
if (GTK_IS_TREE_STORE (model)) {
renderer = gtk_cell_renderer_toggle_new ();
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),
1, "Show/Hide",
renderer,
"active", LAYERS_VISIBILITY_COLUMN,
"activatable", LAYERS_ENABLE_COLUMN,
"visible", LAYERS_SHOWTOGGLE_COLUMN,
NULL);
g_signal_connect (renderer, "toggled",
G_CALLBACK (pgd_layers_visibility_changed),
(gpointer)demo);
gtk_tree_view_column_set_clickable (gtk_tree_view_get_column (GTK_TREE_VIEW (treeview), 1),
TRUE);
}
gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)),
GTK_SELECTION_NONE);
gtk_container_add (GTK_CONTAINER (swindow), treeview);
gtk_widget_show (treeview);
gtk_paned_add1 (GTK_PANED (hpaned), swindow);
gtk_widget_show (swindow);
gtk_paned_add2 (GTK_PANED (hpaned), viewer);
gtk_widget_show (viewer);
gtk_paned_set_position (GTK_PANED (hpaned), 150);
g_object_weak_ref (G_OBJECT (hpaned),
(GWeakNotify)pgd_layers_free,
(gpointer)demo);
return hpaned;
}
int
main(int argc, char **argv)
{
GtkWidget *label, *terminal, *tophalf, *pane, *window, *sw;
AtkObject *obj;
char *text, *p;
gunichar c;
guint count;
gtk_init(&argc, &argv);
contents = g_array_new(TRUE, FALSE, sizeof(gunichar));
terminal_init(&terminal);
#ifdef USE_TEXT_VIEW
tophalf = gtk_scrolled_window_new(NULL, terminal_adjustment(terminal));
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(tophalf),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(tophalf), terminal);
#else
tophalf = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(tophalf), terminal, TRUE, TRUE, 0);
gtk_widget_show(terminal);
GtkWidget* scrollbar = gtk_vscrollbar_new(terminal_adjustment(terminal));
gtk_box_pack_start(GTK_BOX(tophalf), scrollbar, FALSE, TRUE, 0);
gtk_widget_show(scrollbar);
#endif
gtk_widget_show(terminal);
label = gtk_label_new("");
gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0);
sw = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(sw), label);
gtk_widget_show(label);
pane = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
gtk_paned_pack1(GTK_PANED(pane), tophalf, TRUE, FALSE);
gtk_paned_pack2(GTK_PANED(pane), sw, TRUE, FALSE);
gtk_widget_show(tophalf);
gtk_widget_show(sw);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
g_signal_connect(G_OBJECT(window), "delete_event",
G_CALLBACK(gtk_main_quit), NULL);
gtk_container_add(GTK_CONTAINER(window), pane);
gtk_widget_show(pane);
obj = gtk_widget_get_accessible(terminal);
g_assert(obj != NULL);
g_signal_connect(G_OBJECT(obj), "text-changed::insert",
G_CALLBACK(text_changed_insert), label);
g_signal_connect(G_OBJECT(obj), "text-changed::delete",
G_CALLBACK(text_changed_delete), label);
g_signal_connect(G_OBJECT(obj), "text-caret-moved",
G_CALLBACK(text_caret_moved), label);
g_signal_connect(G_OBJECT(obj), "text-selection-changed",
G_CALLBACK(text_selection_changed), label);
count = (guint)atk_text_get_character_count(ATK_TEXT(obj));
if (count > 0) {
text = atk_text_get_text(ATK_TEXT(obj), 0, count);
if (text != NULL) {
for (p = text;
contents->len < count;
p = g_utf8_next_char(p)) {
c = g_utf8_get_char(p);
g_array_append_val(contents, c);
}
g_free(text);
}
}
terminal_shell(terminal);
gtk_window_set_default_size(GTK_WINDOW(window), 600, 450);
gtk_widget_show(window);
update_contents(obj, terminal);
gtk_main();
g_array_free(contents, TRUE);
contents = NULL;
return 0;
}
void
gui_create_tasks_options_page (GtkWidget *vbox, GUI *appGUI) {
GtkWidget *appearance_vbox, *categories_vbox;
GtkWidget *sorting_vbox, *tasks_opt_vbox, *visible_columns_vbox;
GtkWidget *label;
GtkWidget *colors_hbox;
GtkWidget *valid_hbox;
GtkWidget *frame;
GtkWidget *table;
GtkWidget *alignment;
GtkWidget *ti_font_button;
GtkWidget *scrolledwindow;
GtkWidget *tasks_category_table;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GdkColor color;
GtkObject *postpone_time_spinbutton_adj;
gchar tmpbuf[BUFFER_SIZE];
appGUI->opt->tasks_vbox = gtk_vbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), appGUI->opt->tasks_vbox, FALSE, FALSE, 0);
frame = gtk_frame_new (NULL);
gtk_widget_show (frame);
gtk_box_pack_start (GTK_BOX (appGUI->opt->tasks_vbox), frame, FALSE, TRUE, 0);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
sprintf(tmpbuf, "<b>%s</b>", _("Appearance"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_frame_set_label_widget (GTK_FRAME (frame), label);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_misc_set_padding (GTK_MISC (label), 0, 4);
alignment = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment);
gtk_container_add (GTK_CONTAINER (frame), alignment);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 12, 12, 0);
appearance_vbox = gtk_vbox_new (FALSE, 0);
gtk_widget_show (appearance_vbox);
gtk_container_add (GTK_CONTAINER (alignment), appearance_vbox);
table = gtk_table_new (4, 4, FALSE);
gtk_widget_show (table);
gtk_box_pack_start (GTK_BOX (appearance_vbox), table, FALSE, FALSE, 0);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_table_set_row_spacings (GTK_TABLE (table), 8);
colors_hbox = gtk_hbox_new (FALSE, 8);
gtk_widget_show (colors_hbox);
gtk_table_attach (GTK_TABLE (table), colors_hbox, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
appGUI->opt->due_today_color_picker = gtk_color_button_new ();
gtk_widget_show (appGUI->opt->due_today_color_picker);
g_signal_connect (G_OBJECT (appGUI->opt->due_today_color_picker), "color-set",
G_CALLBACK(due_today_color_changed_cb), appGUI);
if (config.enable_tooltips) {
gtk_widget_set_tooltip_text (appGUI->opt->due_today_color_picker, _("Color of items that are due today"));
}
gdk_color_parse(config.due_today_color, &color);
gtk_color_button_set_color (GTK_COLOR_BUTTON (appGUI->opt->due_today_color_picker), &color);
gtk_box_pack_start (GTK_BOX (colors_hbox), appGUI->opt->due_today_color_picker, FALSE, FALSE, 0);
appGUI->opt->due_7days_color_picker = gtk_color_button_new ();
gtk_widget_show (appGUI->opt->due_7days_color_picker);
g_signal_connect (G_OBJECT (appGUI->opt->due_7days_color_picker), "color-set",
G_CALLBACK(due_7days_color_changed_cb), appGUI);
if (config.enable_tooltips) {
gtk_widget_set_tooltip_text (appGUI->opt->due_7days_color_picker, _("Color of items that are due in the next 7 days"));
}
gdk_color_parse(config.due_7days_color, &color);
gtk_color_button_set_color (GTK_COLOR_BUTTON (appGUI->opt->due_7days_color_picker), &color);
gtk_box_pack_start (GTK_BOX (colors_hbox), appGUI->opt->due_7days_color_picker, FALSE, FALSE, 0);
appGUI->opt->past_due_color_picker = gtk_color_button_new ();
gtk_widget_show (appGUI->opt->past_due_color_picker);
g_signal_connect (G_OBJECT (appGUI->opt->past_due_color_picker), "color-set",
G_CALLBACK(past_due_color_changed_cb), appGUI);
if (config.enable_tooltips) {
gtk_widget_set_tooltip_text (appGUI->opt->past_due_color_picker, _("Color of items that are past due"));
}
gdk_color_parse(config.past_due_color, &color);
gtk_color_button_set_color (GTK_COLOR_BUTTON (appGUI->opt->past_due_color_picker), &color);
gtk_box_pack_start (GTK_BOX (colors_hbox), appGUI->opt->past_due_color_picker, FALSE, FALSE, 0);
appGUI->opt->ti_font_entry = gtk_entry_new ();
GTK_WIDGET_UNSET_FLAGS(appGUI->opt->ti_font_entry, GTK_CAN_FOCUS);
gtk_widget_show (appGUI->opt->ti_font_entry);
gtk_table_attach (GTK_TABLE (table), appGUI->opt->ti_font_entry, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
if (config.default_stock_icons) {
ti_font_button = utl_gui_stock_button (GTK_STOCK_SELECT_FONT, FALSE);
} else {
ti_font_button = utl_gui_stock_button (OSMO_STOCK_BUTTON_SELECT_FONT, FALSE);
}
GTK_WIDGET_UNSET_FLAGS(ti_font_button, GTK_CAN_FOCUS);
gtk_widget_show (ti_font_button);
g_signal_connect (G_OBJECT (ti_font_button), "clicked",
G_CALLBACK (ti_font_select_cb), appGUI);
gtk_table_attach (GTK_TABLE (table), ti_font_button, 2, 3, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
sprintf(tmpbuf, "%s:", _("Task info font"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
sprintf(tmpbuf, "%s:", _("Colors"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
appGUI->opt->tasks_enable_rules_hint_checkbutton = gtk_check_button_new_with_mnemonic (_("Draw rows in alternating colors"));
GTK_WIDGET_UNSET_FLAGS(appGUI->opt->tasks_enable_rules_hint_checkbutton, GTK_CAN_FOCUS);
gtk_widget_show (appGUI->opt->tasks_enable_rules_hint_checkbutton);
g_signal_connect (G_OBJECT (appGUI->opt->tasks_enable_rules_hint_checkbutton), "toggled",
G_CALLBACK (tasks_enable_rules_hint_checkbutton_cb), appGUI);
gtk_table_attach (GTK_TABLE (table), appGUI->opt->tasks_enable_rules_hint_checkbutton, 0, 3, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
appGUI->opt->ct_bold_items_checkbutton = gtk_check_button_new_with_mnemonic (_("Show in bold tasks with high priority"));
GTK_WIDGET_UNSET_FLAGS(appGUI->opt->ct_bold_items_checkbutton, GTK_CAN_FOCUS);
gtk_widget_show (appGUI->opt->ct_bold_items_checkbutton);
gtk_table_attach (GTK_TABLE (table), appGUI->opt->ct_bold_items_checkbutton, 0, 3, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
g_signal_connect (G_OBJECT (appGUI->opt->ct_bold_items_checkbutton), "toggled",
G_CALLBACK (bold_items_cb), appGUI);
frame = gtk_frame_new (NULL);
gtk_widget_show (frame);
gtk_box_pack_start (GTK_BOX (appGUI->opt->tasks_vbox), frame, FALSE, TRUE, 0);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
sprintf(tmpbuf, "<b>%s</b>", _("Visible columns"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_frame_set_label_widget (GTK_FRAME (frame), label);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_misc_set_padding (GTK_MISC (label), 0, 4);
alignment = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment);
gtk_container_add (GTK_CONTAINER (frame), alignment);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 12, 12, 0);
visible_columns_vbox = gtk_vbox_new (FALSE, 0);
gtk_widget_show (visible_columns_vbox);
gtk_container_add (GTK_CONTAINER (alignment), visible_columns_vbox);
table = gtk_table_new (1, 4, FALSE);
gtk_widget_show (table);
gtk_box_pack_start (GTK_BOX (visible_columns_vbox), table, FALSE, FALSE, 0);
gtk_table_set_row_spacings (GTK_TABLE (table), 4);
gtk_table_set_col_spacings (GTK_TABLE (table), 8);
appGUI->opt->vc_due_date_checkbutton = gtk_check_button_new_with_mnemonic (_("Due date"));
GTK_WIDGET_UNSET_FLAGS(appGUI->opt->vc_due_date_checkbutton, GTK_CAN_FOCUS);
gtk_widget_show (appGUI->opt->vc_due_date_checkbutton);
g_signal_connect (G_OBJECT (appGUI->opt->vc_due_date_checkbutton), "toggled",
G_CALLBACK (visible_columns_changed_cb), appGUI);
gtk_table_attach (GTK_TABLE (table), appGUI->opt->vc_due_date_checkbutton, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL | GTK_EXPAND),
(GtkAttachOptions) (0), 0, 0);
appGUI->opt->vc_type_checkbutton = gtk_check_button_new_with_mnemonic (_("Type"));
GTK_WIDGET_UNSET_FLAGS(appGUI->opt->vc_type_checkbutton, GTK_CAN_FOCUS);
gtk_widget_show (appGUI->opt->vc_type_checkbutton);
g_signal_connect (G_OBJECT (appGUI->opt->vc_type_checkbutton), "toggled",
G_CALLBACK (visible_columns_changed_cb), appGUI);
gtk_table_attach (GTK_TABLE (table), appGUI->opt->vc_type_checkbutton, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_FILL | GTK_EXPAND),
(GtkAttachOptions) (0), 0, 0);
appGUI->opt->vc_priority_checkbutton = gtk_check_button_new_with_mnemonic (_("Priority"));
GTK_WIDGET_UNSET_FLAGS(appGUI->opt->vc_priority_checkbutton, GTK_CAN_FOCUS);
gtk_widget_show (appGUI->opt->vc_priority_checkbutton);
g_signal_connect (G_OBJECT (appGUI->opt->vc_priority_checkbutton), "toggled",
G_CALLBACK (visible_columns_changed_cb), appGUI);
gtk_table_attach (GTK_TABLE (table), appGUI->opt->vc_priority_checkbutton, 2, 3, 0, 1,
(GtkAttachOptions) (GTK_FILL | GTK_EXPAND),
(GtkAttachOptions) (0), 0, 0);
appGUI->opt->vc_category_checkbutton = gtk_check_button_new_with_mnemonic (_("Category"));
GTK_WIDGET_UNSET_FLAGS(appGUI->opt->vc_category_checkbutton, GTK_CAN_FOCUS);
gtk_widget_show (appGUI->opt->vc_category_checkbutton);
g_signal_connect (G_OBJECT (appGUI->opt->vc_category_checkbutton), "toggled",
G_CALLBACK (visible_columns_changed_cb), appGUI);
gtk_table_attach (GTK_TABLE (table), appGUI->opt->vc_category_checkbutton, 3, 4, 0, 1,
(GtkAttachOptions) (GTK_FILL | GTK_EXPAND),
(GtkAttachOptions) (0), 0, 0);
frame = gtk_frame_new (NULL);
gtk_widget_show (frame);
gtk_box_pack_start (GTK_BOX (appGUI->opt->tasks_vbox), frame, FALSE, TRUE, 0);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
sprintf(tmpbuf, "<b>%s</b>", _("Categories"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_frame_set_label_widget (GTK_FRAME (frame), label);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_misc_set_padding (GTK_MISC (label), 0, 4);
alignment = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment);
gtk_container_add (GTK_CONTAINER (frame), alignment);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 12, 12, 0);
categories_vbox = gtk_vbox_new (FALSE, 0);
gtk_widget_show (categories_vbox);
gtk_container_add (GTK_CONTAINER (alignment), categories_vbox);
tasks_category_table = gtk_table_new (4, 3, FALSE);
gtk_widget_show (tasks_category_table);
gtk_box_pack_start (GTK_BOX (categories_vbox), tasks_category_table, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (tasks_category_table), 8);
gtk_table_set_row_spacings (GTK_TABLE (tasks_category_table), 8);
gtk_table_set_col_spacings (GTK_TABLE (tasks_category_table), 4);
appGUI->opt->tasks_category_entry = gtk_entry_new ();
gtk_widget_show (appGUI->opt->tasks_category_entry);
gtk_table_attach (GTK_TABLE (tasks_category_table), appGUI->opt->tasks_category_entry, 0, 1, 3, 4,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
g_signal_connect (G_OBJECT (appGUI->opt->tasks_category_entry), "key_release_event",
G_CALLBACK (tasks_category_entry_key_release_cb), appGUI);
scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (scrolledwindow);
gtk_table_attach (GTK_TABLE (tasks_category_table), scrolledwindow, 0, 3, 0, 3,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow), GTK_SHADOW_IN);
appGUI->opt->tasks_category_store = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN);
appGUI->opt->tasks_category_treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(appGUI->opt->tasks_category_store));
appGUI->opt->tasks_category_select = gtk_tree_view_get_selection(GTK_TREE_VIEW(appGUI->opt->tasks_category_treeview));
gtk_widget_show (appGUI->opt->tasks_category_treeview);
g_signal_connect(G_OBJECT(appGUI->opt->tasks_category_select), "changed",
G_CALLBACK(tasks_category_selected_cb), appGUI);
gtk_container_add (GTK_CONTAINER (scrolledwindow), appGUI->opt->tasks_category_treeview);
gtk_container_set_border_width (GTK_CONTAINER (appGUI->opt->tasks_category_treeview), 4);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (appGUI->opt->tasks_category_treeview), TRUE);
gtk_tree_view_set_reorderable (GTK_TREE_VIEW (appGUI->opt->tasks_category_treeview), TRUE);
gtk_tree_view_set_enable_search (GTK_TREE_VIEW (appGUI->opt->tasks_category_treeview), FALSE);
gtk_widget_set_size_request (appGUI->opt->tasks_category_treeview, -1, 120);
renderer = gtk_cell_renderer_text_new();
g_object_set (renderer, "editable", TRUE, "editable-set", TRUE, NULL);
g_signal_connect (G_OBJECT (renderer), "edited", G_CALLBACK (tasks_category_cell_edited_cb), appGUI);
column = gtk_tree_view_column_new_with_attributes(_("Name"), renderer, "text", TC_COLUMN_NAME, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->opt->tasks_category_treeview), column);
gtk_tree_view_column_set_expand (column, TRUE);
renderer = gtk_cell_renderer_toggle_new(); /* Show in calendar */
column = gtk_tree_view_column_new_with_attributes(_("Calendar"), renderer, "active", TC_COLUMN_CALENDAR, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->opt->tasks_category_treeview), column);
g_signal_connect (renderer, "toggled", G_CALLBACK (tsk_show_in_calendar_toggled), appGUI);
renderer = gtk_cell_renderer_toggle_new(); /* Show in tasks list */
column = gtk_tree_view_column_new_with_attributes(_("Tasks"), renderer, "active", TC_COLUMN_TASKS, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->opt->tasks_category_treeview), column);
g_signal_connect (renderer, "toggled", G_CALLBACK (tsk_show_in_tasks_list_toggled), appGUI);
if (config.default_stock_icons) {
appGUI->opt->tasks_category_add_button = utl_gui_stock_button (GTK_STOCK_ADD, FALSE);
} else {
appGUI->opt->tasks_category_add_button = utl_gui_stock_button (OSMO_STOCK_BUTTON_ADD, FALSE);
}
GTK_WIDGET_UNSET_FLAGS(appGUI->opt->tasks_category_add_button, GTK_CAN_FOCUS);
gtk_widget_show (appGUI->opt->tasks_category_add_button);
gtk_table_attach (GTK_TABLE (tasks_category_table), appGUI->opt->tasks_category_add_button, 1, 2, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
g_signal_connect(appGUI->opt->tasks_category_add_button, "clicked",
G_CALLBACK(tasks_category_add_cb), appGUI);
gtk_widget_set_sensitive(appGUI->opt->tasks_category_add_button, FALSE);
if (config.default_stock_icons) {
appGUI->opt->tasks_category_remove_button = utl_gui_stock_button (GTK_STOCK_REMOVE, FALSE);
} else {
appGUI->opt->tasks_category_remove_button = utl_gui_stock_button (OSMO_STOCK_BUTTON_REMOVE, FALSE);
}
GTK_WIDGET_UNSET_FLAGS(appGUI->opt->tasks_category_remove_button, GTK_CAN_FOCUS);
gtk_widget_show (appGUI->opt->tasks_category_remove_button);
gtk_table_attach (GTK_TABLE (tasks_category_table), appGUI->opt->tasks_category_remove_button, 2, 3, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
g_signal_connect(appGUI->opt->tasks_category_remove_button, "clicked",
G_CALLBACK(tasks_category_remove_cb), appGUI);
gtk_widget_set_sensitive(appGUI->opt->tasks_category_remove_button, FALSE);
frame = gtk_frame_new (NULL);
gtk_widget_show (frame);
gtk_box_pack_start (GTK_BOX (appGUI->opt->tasks_vbox), frame, FALSE, TRUE, 0);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
sprintf(tmpbuf, "<b>%s</b>", _("Sorting"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_frame_set_label_widget (GTK_FRAME (frame), label);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_misc_set_padding (GTK_MISC (label), 0, 4);
alignment = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment);
gtk_container_add (GTK_CONTAINER (frame), alignment);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 12, 12, 0);
sorting_vbox = gtk_vbox_new (FALSE, 0);
gtk_widget_show (sorting_vbox);
gtk_container_add (GTK_CONTAINER (alignment), sorting_vbox);
table = gtk_table_new (1, 5, FALSE);
gtk_widget_show (table);
gtk_box_pack_start (GTK_BOX (sorting_vbox), table, FALSE, FALSE, 0);
gtk_table_set_row_spacings (GTK_TABLE (table), 4);
gtk_table_set_col_spacings (GTK_TABLE (table), 8);
sprintf(tmpbuf, "%s:", _("Order"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL | GTK_EXPAND),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
sprintf(tmpbuf, "%s:", _("Mode"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_table_attach (GTK_TABLE (table), label, 2, 3, 0, 1,
(GtkAttachOptions) (GTK_FILL | GTK_EXPAND),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
appGUI->opt->tasks_sort_order_combobox = gtk_combo_box_new_text ();
gtk_widget_show (appGUI->opt->tasks_sort_order_combobox);
g_signal_connect (G_OBJECT (appGUI->opt->tasks_sort_order_combobox), "changed",
G_CALLBACK(tasks_sort_order_changed_cb), appGUI);
gtk_table_attach (GTK_TABLE (table), appGUI->opt->tasks_sort_order_combobox, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_FILL | GTK_EXPAND),
(GtkAttachOptions) (0), 0, 0);
gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->opt->tasks_sort_order_combobox), _("Ascending"));
gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->opt->tasks_sort_order_combobox), _("Descending"));
gtk_combo_box_set_active (GTK_COMBO_BOX(appGUI->opt->tasks_sort_order_combobox), config.tasks_sorting_order);
appGUI->opt->tasks_sort_mode_combobox = gtk_combo_box_new_text ();
gtk_widget_show (appGUI->opt->tasks_sort_mode_combobox);
g_signal_connect (G_OBJECT (appGUI->opt->tasks_sort_mode_combobox), "changed",
G_CALLBACK(tasks_sort_mode_changed_cb), appGUI);
gtk_table_attach (GTK_TABLE (table), appGUI->opt->tasks_sort_mode_combobox, 3, 4, 0, 1,
(GtkAttachOptions) (GTK_FILL | GTK_EXPAND),
(GtkAttachOptions) (0), 0, 0);
sprintf (tmpbuf, "%s, %s, %s", _("Done"), _("Due date"), _("Priority"));
gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->opt->tasks_sort_mode_combobox), tmpbuf);
sprintf (tmpbuf, "%s, %s, %s", _("Done"), _("Priority"), _("Due date"));
gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->opt->tasks_sort_mode_combobox), tmpbuf);
sprintf (tmpbuf, "%s, %s, %s", _("Priority"), _("Due date"), _("Done"));
gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->opt->tasks_sort_mode_combobox), tmpbuf);
sprintf (tmpbuf, "%s, %s, %s", _("Priority"), _("Done"), _("Due date"));
gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->opt->tasks_sort_mode_combobox), tmpbuf);
sprintf (tmpbuf, "%s, %s, %s", _("Due date"), _("Priority"), _("Done"));
gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->opt->tasks_sort_mode_combobox), tmpbuf);
sprintf (tmpbuf, "%s, %s, %s", _("Due date"), _("Done"), _("Priority"));
gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->opt->tasks_sort_mode_combobox), tmpbuf);
gtk_combo_box_set_active (GTK_COMBO_BOX(appGUI->opt->tasks_sort_mode_combobox), config.tasks_sorting_mode);
frame = gtk_frame_new (NULL);
gtk_widget_show (frame);
gtk_box_pack_start (GTK_BOX (appGUI->opt->tasks_vbox), frame, FALSE, TRUE, 0);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
sprintf(tmpbuf, "<b>%s</b>", _("Tasks options"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_frame_set_label_widget (GTK_FRAME (frame), label);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_misc_set_padding (GTK_MISC (label), 0, 4);
alignment = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment);
gtk_container_add (GTK_CONTAINER (frame), alignment);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 12, 12, 0);
tasks_opt_vbox = gtk_vbox_new (FALSE, 0);
gtk_widget_show (tasks_opt_vbox);
gtk_container_add (GTK_CONTAINER (alignment), tasks_opt_vbox);
appGUI->opt->ct_hide_items_checkbutton = gtk_check_button_new_with_mnemonic (_("Hide completed tasks"));
GTK_WIDGET_UNSET_FLAGS(appGUI->opt->ct_hide_items_checkbutton, GTK_CAN_FOCUS);
gtk_widget_show (appGUI->opt->ct_hide_items_checkbutton);
g_signal_connect (G_OBJECT (appGUI->opt->ct_hide_items_checkbutton), "toggled",
G_CALLBACK (hide_delete_changed_cb), appGUI);
gtk_box_pack_start (GTK_BOX (tasks_opt_vbox), appGUI->opt->ct_hide_items_checkbutton, FALSE, FALSE, 4);
g_signal_connect (G_OBJECT (appGUI->opt->ct_hide_items_checkbutton), "toggled",
G_CALLBACK (hide_items_cb), appGUI);
appGUI->opt->ct_delete_items_checkbutton = gtk_check_button_new_with_mnemonic (_("Delete completed tasks without confirmation"));
GTK_WIDGET_UNSET_FLAGS(appGUI->opt->ct_delete_items_checkbutton, GTK_CAN_FOCUS);
gtk_widget_show (appGUI->opt->ct_delete_items_checkbutton);
g_signal_connect (G_OBJECT (appGUI->opt->ct_delete_items_checkbutton), "toggled",
G_CALLBACK (hide_delete_changed_cb), appGUI);
gtk_box_pack_start (GTK_BOX (tasks_opt_vbox), appGUI->opt->ct_delete_items_checkbutton, FALSE, FALSE, 4);
g_signal_connect (G_OBJECT (appGUI->opt->ct_delete_items_checkbutton), "toggled",
G_CALLBACK (delete_items_cb), appGUI);
appGUI->opt->ct_add_item_checkbutton = gtk_check_button_new_with_mnemonic (_("Add new task when double clicked on tasks list"));
GTK_WIDGET_UNSET_FLAGS(appGUI->opt->ct_add_item_checkbutton, GTK_CAN_FOCUS);
gtk_widget_show (appGUI->opt->ct_add_item_checkbutton);
gtk_box_pack_start (GTK_BOX (tasks_opt_vbox), appGUI->opt->ct_add_item_checkbutton, FALSE, FALSE, 4);
g_signal_connect (G_OBJECT (appGUI->opt->ct_add_item_checkbutton), "toggled",
G_CALLBACK (add_item_cb), appGUI);
appGUI->opt->ct_remember_category_checkbutton = gtk_check_button_new_with_mnemonic (_("Remember the last selected category"));
GTK_WIDGET_UNSET_FLAGS(appGUI->opt->ct_remember_category_checkbutton, GTK_CAN_FOCUS);
gtk_widget_show (appGUI->opt->ct_remember_category_checkbutton);
gtk_box_pack_start (GTK_BOX (tasks_opt_vbox), appGUI->opt->ct_remember_category_checkbutton, FALSE, FALSE, 4);
g_signal_connect (G_OBJECT (appGUI->opt->ct_remember_category_checkbutton), "toggled",
G_CALLBACK (remember_category_cb), appGUI);
frame = gtk_frame_new (NULL);
gtk_widget_show (frame);
gtk_box_pack_start (GTK_BOX (appGUI->opt->tasks_vbox), frame, FALSE, TRUE, 0);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
g_snprintf (tmpbuf, BUFFER_SIZE, "<b>%s</b>", _("Reminder options"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_frame_set_label_widget (GTK_FRAME (frame), label);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_misc_set_padding (GTK_MISC (label), 0, 4);
alignment = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment);
gtk_container_add (GTK_CONTAINER (frame), alignment);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 12, 12, 0);
table = gtk_table_new (2, 4, FALSE);
gtk_widget_show (table);
gtk_container_add (GTK_CONTAINER (alignment), table);
gtk_container_set_border_width (GTK_CONTAINER (table), 4);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_table_set_row_spacings (GTK_TABLE (table), 8);
g_snprintf (tmpbuf, BUFFER_SIZE, "%s:", _("Postpone time"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
postpone_time_spinbutton_adj = gtk_adjustment_new (0, 0, 1440, 1, 10, 0);
appGUI->opt->postpone_time_spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (postpone_time_spinbutton_adj), 1, 0);
g_signal_connect (G_OBJECT (appGUI->opt->postpone_time_spinbutton), "value-changed",
G_CALLBACK (postpone_time_changed_cb), appGUI);
gtk_widget_show (appGUI->opt->postpone_time_spinbutton);
gtk_table_attach (GTK_TABLE (table), appGUI->opt->postpone_time_spinbutton, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (appGUI->opt->postpone_time_spinbutton), TRUE);
gtk_spin_button_set_value (GTK_SPIN_BUTTON(appGUI->opt->postpone_time_spinbutton), config.postpone_time);
g_snprintf (tmpbuf, BUFFER_SIZE, "%s (%s)", _("minutes"), _("0 for disable"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_table_attach (GTK_TABLE (table), label, 2, 3, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
g_snprintf (tmpbuf, BUFFER_SIZE, "%s:", _("Global notification command"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
valid_hbox = gtk_hbox_new (FALSE, 2);
gtk_widget_show (valid_hbox);
gtk_table_attach (GTK_TABLE (table), valid_hbox, 1, 3, 1, 2,
(GtkAttachOptions) (GTK_FILL | GTK_EXPAND),
(GtkAttachOptions) (GTK_FILL), 0, 0);
appGUI->opt->global_notification_cmd_entry = gtk_entry_new ();
gtk_widget_show (appGUI->opt->global_notification_cmd_entry);
g_signal_connect (G_OBJECT (appGUI->opt->global_notification_cmd_entry), "key_release_event",
G_CALLBACK (global_notification_entry_key_release_cb), appGUI);
gtk_box_pack_start (GTK_BOX (valid_hbox), appGUI->opt->global_notification_cmd_entry, TRUE, TRUE, 0);
appGUI->opt->global_notification_valid_image = gtk_image_new ();
gtk_widget_show (appGUI->opt->global_notification_valid_image);
gtk_box_pack_start (GTK_BOX (valid_hbox), appGUI->opt->global_notification_valid_image, FALSE, FALSE, 0);
}
GtkWidget *create_hdhomerun_config(void)
{
GtkWidget *hdhomerun_config;
GtkWidget *hbox1;
GtkWidget *frame1;
GtkWidget *vbox2;
GtkWidget *scrolledwindow1;
GtkWidget *DeviceListTree;
GtkWidget *RescanBtn;
GtkWidget *label1;
GtkWidget *Tab;
GtkWidget *vbox1;
GtkWidget *frame2;
GtkWidget *table2;
GtkWidget *label11;
GtkWidget *label12;
GtkWidget *label13;
GtkWidget *LaunchVlcBtn;
GtkWidget *StopVlcBtn;
GtkWidget *hbox2;
GtkWidget *ChannelMapEdit;
GtkObject *ChannelNumberSpin_adj;
GtkWidget *ChannelNumberSpin;
GtkWidget *ProgramList;
GtkWidget *ScanDownBtn;
GtkWidget *ScanUpBtn;
GtkWidget *label15;
GtkWidget *frame3;
GtkWidget *table1;
GtkWidget *label5;
GtkWidget *label6;
GtkWidget *label7;
GtkWidget *label8;
GtkWidget *SignalStrengthStatus;
GtkWidget *SignalQualityStatus;
GtkWidget *SymbolQualityStatus;
GtkWidget *PhysicalChannelStatus;
GtkWidget *label10;
GtkWidget *NetworkRateStatus;
GtkWidget *label4;
GtkWidget *label2;
GtkWidget *vbox3;
GtkWidget *frame4;
GtkWidget *table3;
GtkWidget *FirmwareVersion;
GtkWidget *UpgradeBtn;
GtkWidget *hbox3;
GtkWidget *UpgradeFilename;
GtkWidget *UpgradeFilenameBtn;
GtkWidget *label14;
GtkWidget *label3;
hdhomerun_config = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(hdhomerun_config), _("HDHomeRun Config"));
gtk_window_set_resizable(GTK_WINDOW(hdhomerun_config), FALSE);
hbox1 = gtk_hbox_new(FALSE, 6);
gtk_widget_show(hbox1);
gtk_container_add(GTK_CONTAINER(hdhomerun_config), hbox1);
gtk_container_set_border_width(GTK_CONTAINER(hbox1), 3);
frame1 = gtk_frame_new(NULL);
gtk_widget_show(frame1);
gtk_box_pack_start(GTK_BOX(hbox1), frame1, TRUE, TRUE, 0);
vbox2 = gtk_vbox_new(FALSE, 3);
gtk_widget_show(vbox2);
gtk_container_add(GTK_CONTAINER(frame1), vbox2);
gtk_container_set_border_width(GTK_CONTAINER(vbox2), 3);
scrolledwindow1 = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_show(scrolledwindow1);
gtk_box_pack_start(GTK_BOX(vbox2), scrolledwindow1, TRUE, TRUE, 0);
DeviceListTree = gtk_tree_view_new();
gtk_widget_show(DeviceListTree);
gtk_container_add(GTK_CONTAINER(scrolledwindow1), DeviceListTree);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(DeviceListTree), FALSE);
gtk_tree_view_set_enable_search(GTK_TREE_VIEW(DeviceListTree), FALSE);
RescanBtn = gtk_button_new_with_mnemonic(_("_Rescan"));
gtk_widget_show(RescanBtn);
gtk_box_pack_start(GTK_BOX(vbox2), RescanBtn, FALSE, FALSE, 0);
label1 = gtk_label_new(_("Device"));
gtk_widget_show(label1);
gtk_frame_set_label_widget(GTK_FRAME(frame1), label1);
gtk_label_set_use_markup(GTK_LABEL(label1), TRUE);
gtk_misc_set_padding(GTK_MISC(label1), 3, 0);
Tab = gtk_notebook_new();
gtk_widget_show(Tab);
gtk_box_pack_start(GTK_BOX(hbox1), Tab, TRUE, TRUE, 0);
vbox1 = gtk_vbox_new(FALSE, 0);
gtk_widget_show(vbox1);
gtk_container_add(GTK_CONTAINER(Tab), vbox1);
frame2 = gtk_frame_new(NULL);
gtk_widget_show(frame2);
gtk_box_pack_start(GTK_BOX(vbox1), frame2, TRUE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(frame2), 3);
table2 = gtk_table_new(3, 4, TRUE);
gtk_widget_show(table2);
gtk_container_add(GTK_CONTAINER(frame2), table2);
gtk_container_set_border_width(GTK_CONTAINER(table2), 6);
gtk_table_set_row_spacings(GTK_TABLE(table2), 3);
gtk_table_set_col_spacings(GTK_TABLE(table2), 3);
label11 = gtk_label_new(_("Channel"));
gtk_widget_show(label11);
gtk_table_attach(GTK_TABLE(table2), label11, 0, 1, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
label12 = gtk_label_new(_("Program"));
gtk_widget_show(label12);
gtk_table_attach(GTK_TABLE(table2), label12, 0, 1, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
label13 = gtk_label_new(_("Scan"));
gtk_widget_show(label13);
gtk_table_attach(GTK_TABLE(table2), label13, 0, 1, 2, 3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
LaunchVlcBtn = gtk_button_new_with_mnemonic(_("_View"));
gtk_widget_show(LaunchVlcBtn);
gtk_table_attach(GTK_TABLE(table2), LaunchVlcBtn, 3, 4, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
StopVlcBtn = gtk_button_new_with_mnemonic(_("_Stop"));
gtk_widget_show(StopVlcBtn);
gtk_table_attach(GTK_TABLE(table2), StopVlcBtn, 3, 4, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
gtk_widget_set_sensitive(StopVlcBtn, FALSE);
hbox2 = gtk_hbox_new(FALSE, 3);
gtk_widget_show(hbox2);
gtk_table_attach(GTK_TABLE(table2), hbox2, 1, 3, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
ChannelMapEdit = gtk_combo_box_new_text();
gtk_widget_show(ChannelMapEdit);
gtk_box_pack_start(GTK_BOX(hbox2), ChannelMapEdit, TRUE, TRUE, 0);
ChannelNumberSpin_adj = gtk_adjustment_new(0, 0, 300, 1, 10, 0);
ChannelNumberSpin = gtk_spin_button_new(GTK_ADJUSTMENT(ChannelNumberSpin_adj), 1, 0);
gtk_widget_show(ChannelNumberSpin);
gtk_box_pack_start(GTK_BOX(hbox2), ChannelNumberSpin, FALSE, FALSE, 0);
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(ChannelNumberSpin), TRUE);
gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(ChannelNumberSpin), TRUE);
ProgramList = gtk_combo_box_new_text();
gtk_widget_show(ProgramList);
gtk_table_attach(GTK_TABLE(table2), ProgramList, 1, 3, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
ScanDownBtn = gtk_toggle_button_new_with_mnemonic("_<<-");
gtk_widget_show(ScanDownBtn);
gtk_table_attach(GTK_TABLE(table2), ScanDownBtn, 1, 2, 2, 3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0);
ScanUpBtn = gtk_toggle_button_new_with_mnemonic("->_>");
gtk_widget_show(ScanUpBtn);
gtk_table_attach(GTK_TABLE(table2), ScanUpBtn, 2, 3, 2, 3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0);
label15 = gtk_label_new(_("Configuration"));
gtk_widget_show(label15);
gtk_frame_set_label_widget(GTK_FRAME(frame2), label15);
gtk_label_set_use_markup(GTK_LABEL(label15), TRUE);
gtk_misc_set_padding(GTK_MISC(label15), 3, 0);
frame3 = gtk_frame_new(NULL);
gtk_widget_show(frame3);
gtk_box_pack_start(GTK_BOX(vbox1), frame3, TRUE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(frame3), 3);
table1 = gtk_table_new(6, 2, FALSE);
gtk_widget_show(table1);
gtk_container_add(GTK_CONTAINER(frame3), table1);
gtk_container_set_border_width(GTK_CONTAINER(table1), 6);
gtk_table_set_row_spacings(GTK_TABLE(table1), 2);
gtk_table_set_col_spacings(GTK_TABLE(table1), 2);
label5 = gtk_label_new(_("Physical Channel"));
gtk_widget_show(label5);
gtk_table_attach(GTK_TABLE(table1), label5, 0, 1, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
label6 = gtk_label_new(_("Signal Strength %"));
gtk_widget_show(label6);
gtk_table_attach(GTK_TABLE(table1), label6, 0, 1, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
label7 = gtk_label_new(_("Signal Quality %"));
gtk_widget_show(label7);
gtk_table_attach(GTK_TABLE(table1), label7, 0, 1, 2, 3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
label8 = gtk_label_new(_("Symbol Quality %"));
gtk_widget_show(label8);
gtk_table_attach(GTK_TABLE(table1), label8, 0, 1, 3, 4, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
SignalStrengthStatus = gtk_progress_bar_new();
gtk_widget_show(SignalStrengthStatus);
gtk_table_attach(GTK_TABLE(table1), SignalStrengthStatus, 1, 2, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0);
SignalQualityStatus = gtk_progress_bar_new();
gtk_widget_show(SignalQualityStatus);
gtk_table_attach(GTK_TABLE(table1), SignalQualityStatus, 1, 2, 2, 3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0);
SymbolQualityStatus = gtk_progress_bar_new();
gtk_widget_show(SymbolQualityStatus);
gtk_table_attach(GTK_TABLE(table1), SymbolQualityStatus, 1, 2, 3, 4, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0);
PhysicalChannelStatus = gtk_entry_new();
gtk_widget_show(PhysicalChannelStatus);
gtk_table_attach(GTK_TABLE(table1), PhysicalChannelStatus, 1, 2, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0);
gtk_widget_set_sensitive(PhysicalChannelStatus, FALSE);
GTK_WIDGET_UNSET_FLAGS(PhysicalChannelStatus, GTK_CAN_FOCUS);
gtk_editable_set_editable(GTK_EDITABLE(PhysicalChannelStatus), FALSE);
gtk_entry_set_text(GTK_ENTRY(PhysicalChannelStatus), _("none"));
gtk_entry_set_invisible_char(GTK_ENTRY(PhysicalChannelStatus), 9679);
label10 = gtk_label_new(_("Network Rate"));
gtk_widget_show(label10);
gtk_table_attach(GTK_TABLE(table1), label10, 0, 1, 4, 5, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
NetworkRateStatus = gtk_entry_new();
gtk_widget_show(NetworkRateStatus);
gtk_table_attach(GTK_TABLE(table1), NetworkRateStatus, 1, 2, 4, 5, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0);
gtk_widget_set_sensitive(NetworkRateStatus, FALSE);
GTK_WIDGET_UNSET_FLAGS(NetworkRateStatus, GTK_CAN_FOCUS);
gtk_editable_set_editable(GTK_EDITABLE(NetworkRateStatus), FALSE);
gtk_entry_set_text(GTK_ENTRY(NetworkRateStatus), _("0.000 Mbps"));
gtk_entry_set_invisible_char(GTK_ENTRY(NetworkRateStatus), 9679);
label4 = gtk_label_new(_("Status"));
gtk_widget_show(label4);
gtk_frame_set_label_widget(GTK_FRAME(frame3), label4);
gtk_label_set_use_markup(GTK_LABEL(label4), TRUE);
gtk_misc_set_padding(GTK_MISC(label4), 3, 0);
label2 = gtk_label_new(_("Tuner"));
gtk_widget_show(label2);
gtk_notebook_set_tab_label(GTK_NOTEBOOK(Tab), gtk_notebook_get_nth_page(GTK_NOTEBOOK(Tab), 0), label2);
vbox3 = gtk_vbox_new(FALSE, 0);
gtk_widget_show(vbox3);
gtk_container_add(GTK_CONTAINER(Tab), vbox3);
frame4 = gtk_frame_new(NULL);
gtk_widget_show(frame4);
gtk_box_pack_start(GTK_BOX(vbox3), frame4, FALSE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(frame4), 3);
table3 = gtk_table_new(2, 2, FALSE);
gtk_widget_show(table3);
gtk_container_add(GTK_CONTAINER(frame4), table3);
gtk_container_set_border_width(GTK_CONTAINER(table3), 3);
gtk_table_set_row_spacings(GTK_TABLE(table3), 3);
gtk_table_set_col_spacings(GTK_TABLE(table3), 3);
FirmwareVersion = gtk_label_new("");
gtk_widget_show(FirmwareVersion);
gtk_table_attach(GTK_TABLE(table3), FirmwareVersion, 0, 1, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
gtk_misc_set_alignment(GTK_MISC(FirmwareVersion), 0, 0.5);
UpgradeBtn = gtk_button_new_with_mnemonic(_("Upgrade"));
gtk_widget_show(UpgradeBtn);
gtk_table_attach(GTK_TABLE(table3), UpgradeBtn, 1, 2, 1, 2, (GtkAttachOptions) (0), (GtkAttachOptions) (0), 0, 0);
gtk_widget_set_sensitive(UpgradeBtn, FALSE);
hbox3 = gtk_hbox_new(FALSE, 3);
gtk_widget_show(hbox3);
gtk_table_attach(GTK_TABLE(table3), hbox3, 0, 2, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
UpgradeFilename = gtk_entry_new();
gtk_widget_show(UpgradeFilename);
gtk_box_pack_start(GTK_BOX(hbox3), UpgradeFilename, TRUE, TRUE, 0);
gtk_entry_set_invisible_char(GTK_ENTRY(UpgradeFilename), 9679);
UpgradeFilenameBtn = gtk_button_new_with_mnemonic("...");
gtk_widget_show(UpgradeFilenameBtn);
gtk_box_pack_start(GTK_BOX(hbox3), UpgradeFilenameBtn, FALSE, FALSE, 0);
label14 = gtk_label_new(_("Upgrade"));
gtk_widget_show(label14);
gtk_frame_set_label_widget(GTK_FRAME(frame4), label14);
gtk_misc_set_padding(GTK_MISC(label14), 3, 0);
label3 = gtk_label_new(_("Upgrade"));
gtk_widget_show(label3);
gtk_notebook_set_tab_label(GTK_NOTEBOOK(Tab), gtk_notebook_get_nth_page(GTK_NOTEBOOK(Tab), 1), label3);
g_signal_connect((gpointer) hdhomerun_config, "destroy", G_CALLBACK(gtk_main_quit), NULL);
g_signal_connect((gpointer) hdhomerun_config, "key_press_event", G_CALLBACK(on_hdhomerun_config_key_press_event), NULL);
g_signal_connect((gpointer) RescanBtn, "clicked", G_CALLBACK(on_RescanBtn_clicked), NULL);
g_signal_connect_after((gpointer) Tab, "switch_page", G_CALLBACK(on_Tab_switch_page), NULL);
g_signal_connect((gpointer) LaunchVlcBtn, "clicked", G_CALLBACK(on_LaunchVlcBtn_clicked), NULL);
g_signal_connect((gpointer) StopVlcBtn, "clicked", G_CALLBACK(on_StopVlcBtn_clicked), NULL);
g_signal_connect((gpointer) ChannelMapEdit, "changed", G_CALLBACK(on_ChannelMapEdit_changed), NULL);
g_signal_connect((gpointer) ChannelNumberSpin, "value_changed", G_CALLBACK(on_ChannelNumberSpin_value_changed), NULL);
g_signal_connect_after((gpointer) ChannelNumberSpin, "activate", G_CALLBACK(on_ChannelNumberSpin_activate), NULL);
g_signal_connect((gpointer) ProgramList, "changed", G_CALLBACK(on_ProgramList_changed), NULL);
g_signal_connect((gpointer) ScanDownBtn, "clicked", G_CALLBACK(on_ScanDownBtn_clicked), NULL);
g_signal_connect((gpointer) ScanUpBtn, "clicked", G_CALLBACK(on_ScanUpBtn_clicked), NULL);
g_signal_connect((gpointer) UpgradeBtn, "clicked", G_CALLBACK(on_UpgradeBtn_clicked), NULL);
g_signal_connect((gpointer) UpgradeFilename, "changed", G_CALLBACK(on_UpgradeFilename_changed), NULL);
g_signal_connect((gpointer) UpgradeFilenameBtn, "clicked", G_CALLBACK(on_UpgradeFilenameBtn_clicked), NULL);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF(hdhomerun_config, hdhomerun_config, "hdhomerun_config");
GLADE_HOOKUP_OBJECT(hdhomerun_config, hbox1, "hbox1");
GLADE_HOOKUP_OBJECT(hdhomerun_config, frame1, "frame1");
GLADE_HOOKUP_OBJECT(hdhomerun_config, vbox2, "vbox2");
GLADE_HOOKUP_OBJECT(hdhomerun_config, scrolledwindow1, "scrolledwindow1");
GLADE_HOOKUP_OBJECT(hdhomerun_config, DeviceListTree, "DeviceListTree");
GLADE_HOOKUP_OBJECT(hdhomerun_config, RescanBtn, "RescanBtn");
GLADE_HOOKUP_OBJECT(hdhomerun_config, label1, "label1");
GLADE_HOOKUP_OBJECT(hdhomerun_config, Tab, "Tab");
GLADE_HOOKUP_OBJECT(hdhomerun_config, vbox1, "vbox1");
GLADE_HOOKUP_OBJECT(hdhomerun_config, frame2, "frame2");
GLADE_HOOKUP_OBJECT(hdhomerun_config, table2, "table2");
GLADE_HOOKUP_OBJECT(hdhomerun_config, label11, "label11");
GLADE_HOOKUP_OBJECT(hdhomerun_config, label12, "label12");
GLADE_HOOKUP_OBJECT(hdhomerun_config, label13, "label13");
GLADE_HOOKUP_OBJECT(hdhomerun_config, LaunchVlcBtn, "LaunchVlcBtn");
GLADE_HOOKUP_OBJECT(hdhomerun_config, StopVlcBtn, "StopVlcBtn");
GLADE_HOOKUP_OBJECT(hdhomerun_config, hbox2, "hbox2");
GLADE_HOOKUP_OBJECT(hdhomerun_config, ChannelMapEdit, "ChannelMapEdit");
GLADE_HOOKUP_OBJECT(hdhomerun_config, ChannelNumberSpin, "ChannelNumberSpin");
GLADE_HOOKUP_OBJECT(hdhomerun_config, ProgramList, "ProgramList");
GLADE_HOOKUP_OBJECT(hdhomerun_config, ScanDownBtn, "ScanDownBtn");
GLADE_HOOKUP_OBJECT(hdhomerun_config, ScanUpBtn, "ScanUpBtn");
GLADE_HOOKUP_OBJECT(hdhomerun_config, label15, "label15");
GLADE_HOOKUP_OBJECT(hdhomerun_config, frame3, "frame3");
GLADE_HOOKUP_OBJECT(hdhomerun_config, table1, "table1");
GLADE_HOOKUP_OBJECT(hdhomerun_config, label5, "label5");
GLADE_HOOKUP_OBJECT(hdhomerun_config, label6, "label6");
GLADE_HOOKUP_OBJECT(hdhomerun_config, label7, "label7");
GLADE_HOOKUP_OBJECT(hdhomerun_config, label8, "label8");
GLADE_HOOKUP_OBJECT(hdhomerun_config, SignalStrengthStatus, "SignalStrengthStatus");
GLADE_HOOKUP_OBJECT(hdhomerun_config, SignalQualityStatus, "SignalQualityStatus");
GLADE_HOOKUP_OBJECT(hdhomerun_config, SymbolQualityStatus, "SymbolQualityStatus");
GLADE_HOOKUP_OBJECT(hdhomerun_config, PhysicalChannelStatus, "PhysicalChannelStatus");
GLADE_HOOKUP_OBJECT(hdhomerun_config, label10, "label10");
GLADE_HOOKUP_OBJECT(hdhomerun_config, NetworkRateStatus, "NetworkRateStatus");
GLADE_HOOKUP_OBJECT(hdhomerun_config, label4, "label4");
GLADE_HOOKUP_OBJECT(hdhomerun_config, label2, "label2");
GLADE_HOOKUP_OBJECT(hdhomerun_config, vbox3, "vbox3");
GLADE_HOOKUP_OBJECT(hdhomerun_config, frame4, "frame4");
GLADE_HOOKUP_OBJECT(hdhomerun_config, table3, "table3");
GLADE_HOOKUP_OBJECT(hdhomerun_config, FirmwareVersion, "FirmwareVersion");
GLADE_HOOKUP_OBJECT(hdhomerun_config, UpgradeBtn, "UpgradeBtn");
GLADE_HOOKUP_OBJECT(hdhomerun_config, hbox3, "hbox3");
GLADE_HOOKUP_OBJECT(hdhomerun_config, UpgradeFilename, "UpgradeFilename");
GLADE_HOOKUP_OBJECT(hdhomerun_config, UpgradeFilenameBtn, "UpgradeFilenameBtn");
GLADE_HOOKUP_OBJECT(hdhomerun_config, label14, "label14");
GLADE_HOOKUP_OBJECT(hdhomerun_config, label3, "label3");
return hdhomerun_config;
}
void
FormDialog::editable_set (const std::string name,
const std::string description,
const std::set<std::string> values,
const std::set<std::string> proposed_values,
bool advanced)
{
GtkWidget *label = NULL;
GtkWidget *scroll = NULL;
GtkWidget *button = NULL;
GtkWidget *tree_view = NULL;
GtkWidget *frame = NULL;
GtkWidget *hbox = NULL;
GtkWidget *entry = NULL;
GtkListStore *list_store = NULL;
GtkTreeViewColumn *column = NULL;
GtkCellRenderer *renderer = NULL;
GtkTreeIter iter;
gchar *label_text = NULL;
EditableSetSubmitter *submitter = NULL;
/* The label */
label = gtk_label_new (NULL);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
label_text = g_strdup_printf ("<b>%s</b>", description.c_str());
gtk_label_set_markup_with_mnemonic (GTK_LABEL (label), label_text);
g_free (label_text);
/* The GtkListStore containing the values */
list_store = gtk_list_store_new (EditableSetSubmitter::COLUMN_NUMBER,
G_TYPE_BOOLEAN, G_TYPE_STRING);
tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (list_store));
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (tree_view), TRUE);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tree_view), FALSE);
frame = gtk_frame_new (NULL);
gtk_widget_set_size_request (GTK_WIDGET (frame), -1, 125);
gtk_container_set_border_width (GTK_CONTAINER (frame), 0);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
scroll = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER (frame), scroll);
gtk_container_add (GTK_CONTAINER (scroll), tree_view);
renderer = gtk_cell_renderer_toggle_new ();
column =
gtk_tree_view_column_new_with_attributes (NULL, renderer,
"active", EditableSetSubmitter::COLUMN_ACTIVE,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column);
g_signal_connect (renderer, "toggled",
G_CALLBACK (editable_set_choice_toggled_cb), list_store);
renderer = gtk_cell_renderer_text_new ();
column =
gtk_tree_view_column_new_with_attributes (NULL, renderer,
"text", EditableSetSubmitter::COLUMN_VALUE,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column);
for (std::set<std::string>::const_iterator set_iter = values.begin ();
set_iter != values.end ();
set_iter++) {
gtk_list_store_append (GTK_LIST_STORE (list_store), &iter);
gtk_list_store_set (GTK_LIST_STORE (list_store), &iter,
EditableSetSubmitter::COLUMN_ACTIVE, TRUE,
EditableSetSubmitter::COLUMN_VALUE, set_iter->c_str (),
-1);
}
for (std::set<std::string>::const_iterator set_iter
= proposed_values.begin ();
set_iter != proposed_values.end ();
set_iter++) {
if (values.find (*set_iter) == values.end ()) {
gtk_list_store_append (GTK_LIST_STORE (list_store), &iter);
gtk_list_store_set (GTK_LIST_STORE (list_store), &iter,
EditableSetSubmitter::COLUMN_ACTIVE, FALSE,
EditableSetSubmitter::COLUMN_VALUE, set_iter->c_str (),
-1);
}
}
if (advanced) {
grow_fields (advanced);
gtk_table_attach (GTK_TABLE (advanced_fields), label,
0, 2, advanced_rows - 1, advanced_rows,
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
0, 0);
grow_fields (advanced);
gtk_table_attach (GTK_TABLE (advanced_fields), frame,
0, 2, advanced_rows - 1, advanced_rows,
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
0, 0);
} else {
grow_fields (advanced);
gtk_table_attach (GTK_TABLE (fields), label,
0, 2, rows - 1, rows,
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
0, 0);
grow_fields (advanced);
gtk_table_attach (GTK_TABLE (fields), frame,
0, 2, rows - 1, rows,
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
0, 0);
}
hbox = gtk_hbox_new (FALSE, 2);
entry = gtk_entry_new ();
button = gtk_button_new_from_stock (GTK_STOCK_ADD);
gtk_box_pack_start (GTK_BOX (hbox), entry, TRUE, TRUE, 2);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 2);
g_signal_connect (entry, "activate",
(GCallback) editable_set_add_value_activated_cb,
(gpointer) tree_view);
g_signal_connect (button, "clicked",
(GCallback) editable_set_add_value_clicked_cb,
(gpointer) entry);
grow_fields (advanced);
if (advanced) {
gtk_table_attach (GTK_TABLE (advanced_fields), hbox,
0, 2, advanced_rows - 1, advanced_rows,
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
0, 0);
} else {
gtk_table_attach (GTK_TABLE (fields), hbox,
0, 2, rows - 1, rows,
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
0, 0);
}
submitter = new EditableSetSubmitter (name, description, advanced, tree_view);
submitters.push_back (submitter);
}
static void rc_plugin_tag_ui_init()
{
GtkWidget *path_label, *title_label, *artist_label, *album_label;
GtkWidget *genre_label, *comment_label, *track_label, *year_label;
GtkWidget *format_label, *channel_label, *bd_label, *sr_label;
GtkWidget *bitrate_label, *length_label, *rg_label;
GtkWidget *tag_frame, *media_frame;
GtkWidget *tag_table, *media_table;
GtkWidget *info_vbox, *media_vbox, *path_hbox, *art_hbox;
GtkWidget *button_hbox;
GtkWidget *info_scr_window;
GtkActionEntry menu_action_entry, popup_action_entry;
path_label = gtk_label_new(_("Path"));
title_label = gtk_label_new(_("Title"));
artist_label = gtk_label_new(_("Artist"));
album_label = gtk_label_new(_("Album"));
genre_label = gtk_label_new(_("Genre"));
comment_label = gtk_label_new(_("Comment"));
track_label = gtk_label_new(_("Track"));
year_label = gtk_label_new(_("Year"));
format_label = gtk_label_new(_("Format"));
channel_label = gtk_label_new(_("Channel"));
bd_label = gtk_label_new(_("Bit Depth"));
sr_label = gtk_label_new(_("Sample Rate"));
bitrate_label = gtk_label_new(_("Bitrate"));
length_label = gtk_label_new(_("Length"));
rg_label = gtk_label_new(_("Replay Gain"));
tag_frame = gtk_frame_new(_("Tag"));
media_frame = gtk_frame_new(_("Media Information"));
tag_table = gtk_table_new(5, 4, FALSE);
media_table = gtk_table_new(7, 2, FALSE);
info_vbox = gtk_vbox_new(FALSE, 1);
media_vbox = gtk_vbox_new(FALSE, 1);
path_hbox = gtk_hbox_new(FALSE, 4);
art_hbox = gtk_hbox_new(FALSE, 4);
button_hbox = gtk_hbutton_box_new();
info_scr_window = gtk_scrolled_window_new(NULL, NULL);
tag_ui.tag_main_vbox = gtk_vbox_new(FALSE, 0);
tag_ui.path_entry = gtk_entry_new();
tag_ui.title_entry = gtk_entry_new();
tag_ui.artist_entry = gtk_entry_new();
tag_ui.album_entry = gtk_entry_new();
tag_ui.genre_entry = gtk_entry_new();
tag_ui.comment_entry = gtk_entry_new();
tag_ui.track_entry = gtk_entry_new();
tag_ui.year_entry = gtk_entry_new();
tag_ui.format_entry = gtk_label_new(NULL);
tag_ui.channel_entry = gtk_label_new(NULL);
tag_ui.bd_entry = gtk_label_new(NULL);
tag_ui.sr_entry = gtk_label_new(NULL);
tag_ui.bitrate_entry = gtk_label_new(NULL);
tag_ui.length_entry = gtk_label_new(NULL);
tag_ui.rg_entry = gtk_entry_new();
tag_ui.reload_button = gtk_button_new_with_mnemonic(_("Re_load"));
tag_ui.save_button = gtk_button_new_with_mnemonic(_("_Save"));
gtk_editable_set_editable(GTK_EDITABLE(tag_ui.path_entry), FALSE);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(info_scr_window),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_table_attach(GTK_TABLE(tag_table), title_label, 0, 1, 0, 1,
0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(tag_table), tag_ui.title_entry, 1, 4, 0, 1,
GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(tag_table), artist_label, 0, 1, 1, 2,
0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(tag_table), tag_ui.artist_entry, 1, 4, 1, 2,
GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(tag_table), album_label, 0, 1, 2, 3,
0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(tag_table), tag_ui.album_entry, 1, 2, 2, 3,
GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(tag_table), track_label, 2, 3, 2, 3,
0, GTK_FILL, 4, 0);
gtk_table_attach(GTK_TABLE(tag_table), tag_ui.track_entry, 3, 4, 2, 3,
GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(tag_table), genre_label, 0, 1, 3, 4,
0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(tag_table), tag_ui.genre_entry, 1, 2, 3, 4,
GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(tag_table), year_label, 2, 3, 3, 4,
0, GTK_FILL, 4, 0);
gtk_table_attach(GTK_TABLE(tag_table), tag_ui.year_entry, 3, 4, 3, 4,
GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(tag_table), comment_label, 0, 1, 4, 5,
0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(tag_table), tag_ui.comment_entry, 1, 4, 4, 5,
GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_SHRINK, 0, 0);
gtk_table_attach(GTK_TABLE(media_table), format_label, 0, 1, 0, 1,
0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(media_table), tag_ui.format_entry, 1, 2, 0, 1,
GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(media_table), channel_label, 0, 1, 1, 2,
0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(media_table), tag_ui.channel_entry, 1, 2, 1, 2,
GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(media_table), bd_label, 0, 1, 2, 3,
0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(media_table), tag_ui.bd_entry, 1, 2, 2, 3,
GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(media_table), sr_label, 0, 1, 3, 4,
0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(media_table), tag_ui.sr_entry, 1, 2, 3, 4,
GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(media_table), bitrate_label, 0, 1, 4, 5,
0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(media_table), tag_ui.bitrate_entry, 1, 2, 4, 5,
GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(media_table), length_label, 0, 1, 5, 6,
0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(media_table), tag_ui.length_entry, 1, 2, 5, 6,
GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(media_table), rg_label, 0, 1, 6, 7,
0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(media_table), tag_ui.rg_entry, 1, 2, 6, 7,
GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_FILL, 0, 0);
gtk_container_add(GTK_CONTAINER(tag_frame), tag_table);
gtk_container_add(GTK_CONTAINER(media_frame), media_table);
gtk_box_pack_start(GTK_BOX(media_vbox), tag_frame, TRUE, TRUE, 4);
gtk_box_pack_start(GTK_BOX(media_vbox), media_frame, TRUE, TRUE, 4);
gtk_box_pack_start(GTK_BOX(path_hbox), path_label, FALSE, FALSE, 4);
gtk_box_pack_start(GTK_BOX(path_hbox), tag_ui.path_entry, TRUE, TRUE, 4);
gtk_box_pack_start(GTK_BOX(info_vbox), path_hbox, FALSE, FALSE, 1);
gtk_box_pack_start(GTK_BOX(info_vbox), media_vbox, FALSE, FALSE, 1);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(info_scr_window),
info_vbox);
gtk_button_box_set_layout(GTK_BUTTON_BOX(button_hbox), GTK_BUTTONBOX_END);
gtk_box_pack_start(GTK_BOX(button_hbox), tag_ui.reload_button, FALSE,
FALSE, 4);
gtk_box_pack_start(GTK_BOX(button_hbox), tag_ui.save_button, FALSE,
FALSE, 4);
gtk_box_pack_start(GTK_BOX(tag_ui.tag_main_vbox), info_scr_window,
TRUE, TRUE, 1);
gtk_box_pack_start(GTK_BOX(tag_ui.tag_main_vbox), button_hbox,
FALSE, FALSE, 8);
g_signal_connect(G_OBJECT(tag_ui.track_entry), "insert-text",
G_CALLBACK(rc_plugin_tag_entry_insert_text_cb), NULL);
g_signal_connect(G_OBJECT(tag_ui.year_entry), "insert-text",
G_CALLBACK(rc_plugin_tag_entry_insert_text_cb), NULL);
g_signal_connect(G_OBJECT(tag_ui.rg_entry), "insert-text",
G_CALLBACK(rc_plugin_tag_rg_entry_insert_text_cb), NULL);
g_signal_connect(G_OBJECT(tag_ui.reload_button), "clicked",
G_CALLBACK(rc_plugin_tag_reload_data_cb), NULL);
g_signal_connect(G_OBJECT(tag_ui.save_button), "clicked",
G_CALLBACK(rc_plugin_tag_data_save_cb), NULL);
menu_id = gtk_ui_manager_new_merge_id(rc_gui_get_ui_manager());
menu_action_entry.name = "EditTagEditor";
menu_action_entry.label = _("Tag Editor");
menu_action_entry.accelerator = NULL;
menu_action_entry.stock_id = NULL;
menu_action_entry.tooltip = _("Edit the tag of the selected music");
menu_action_entry.callback = G_CALLBACK(rc_plugin_tag_edit_menu_cb);
gtk_ui_manager_add_ui(rc_gui_get_ui_manager(), menu_id,
"/RCMenuBar/EditMenu/EditSep2", "EditTagEditor", "EditTagEditor",
GTK_UI_MANAGER_MENUITEM, TRUE);
gtk_action_group_add_actions(rc_gui_get_action_group(),
&menu_action_entry, 1, NULL);
popup_id = gtk_ui_manager_new_merge_id(rc_gui_get_ui_manager());
popup_action_entry.name = "List2TagEditor";
popup_action_entry.label = _("Tag Editor");
popup_action_entry.accelerator = NULL;
popup_action_entry.stock_id = NULL;
popup_action_entry.tooltip = _("Edit the tag of the selected music");
popup_action_entry.callback = G_CALLBACK(rc_plugin_tag_edit_menu_cb);
gtk_ui_manager_add_ui(rc_gui_get_ui_manager(), popup_id,
"/List2PopupMenu/List2Sep2", "List2TagEditor", "List2TagEditor",
GTK_UI_MANAGER_MENUITEM, FALSE);
gtk_action_group_add_actions(rc_gui_get_action_group(),
&popup_action_entry, 1, NULL);
}
WVselGtk::WVselGtk (
pwr_tStatus *status,
void *wv_parent_ctx,
GtkWidget *wv_parent_wid,
const char *wv_name,
ldh_tWBContext wv_wbctx,
char *volumename,
int (*bc_success)( void *, pwr_tVolumeId *, int),
void (*bc_cancel)(),
int (*bc_time_to_exit)( void *),
int show_volumes,
wb_eType wv_wb_type) :
WVsel(status,wv_parent_ctx,wv_name,wv_wbctx,volumename,bc_success,bc_cancel,
bc_time_to_exit,show_volumes,wv_wb_type), parent_wid(wv_parent_wid)
{
int sts;
pwr_tVolumeId volid, *volume_ptr;
pwr_tVolumeId volume;
pwr_tClassId classid;
char volname[80];
int size;
int volume_count;
int display_window;
GtkCellRenderer *text_renderer;
GtkTreeViewColumn *name_column;
strcpy( volname, "");
if ( volumename != NULL && *volumename != 0 && !show_volumes)
/* Start the navigater for this volume */
strcpy( volname, volumename);
else if ( !show_volumes && wb_type != wb_eType_Buffer)
{
/* If there is only one volume in the db, select this volume */
volume_count = 0;
sts = ldh_GetVolumeList( wbctx, &volume);
while ( ODD(sts) )
{
sts = ldh_GetVolumeClass( wbctx, volume, &classid);
if (EVEN(sts)) { *status = sts; return; }
if ( cdh_isClassVolumeClass( classid) ||
classid == pwr_eClass_WorkBenchVolume ||
volume == ldh_cRtVolume)
{
sts = ldh_GetNextVolume( wbctx, volume, &volume);
continue;
}
sts = ldh_VolumeIdToName( wbctx, volume, volname, sizeof(volname),
&size);
if (EVEN(sts)) { *status = sts; return; }
volume_count++;
sts = ldh_GetNextVolume( wbctx, volume, &volume);
}
if ( volume_count != 1)
strcpy( volname, "");
}
// If volume name is supplied, find this volume and open the navigator.
if ( strcmp( volname, "") && wb_type != wb_eType_Buffer)
/* Check syntax, if new volumes is found, show the window */
sts = check_volumelist( 1, &display_window);
if ( strcmp( volname, "") && !display_window)
{
sts = ldh_VolumeNameToId( wbctx, volname, &volid);
WFoe::error_msg(sts);
if ( ODD(sts))
{
volume_ptr = (pwr_tVolumeId *) calloc( 1, sizeof( pwr_tVolumeId));
*volume_ptr = volid;
(vsel_bc_success) ( (void *)this, volume_ptr, 1);
if (vsel_bc_cancel != NULL)
(vsel_bc_cancel) ();
*status = LOGIN__SUCCESS;
return;
}
else
printf( "-- Unable to open volume '%s', volume doesn't exist\n",
volname);
}
// Create the window
widgets.toplevel = (GtkWidget *) g_object_new( GTK_TYPE_WINDOW,
"default-height", 400,
"default-width", 500,
"title", name,
NULL);
CoWowGtk::SetWindowIcon( widgets.toplevel);
// Menu
GtkAccelGroup *accel_g = (GtkAccelGroup *) g_object_new(GTK_TYPE_ACCEL_GROUP, NULL);
gtk_window_add_accel_group(GTK_WINDOW(widgets.toplevel), accel_g);
GtkMenuBar *menu_bar = (GtkMenuBar *) g_object_new(GTK_TYPE_MENU_BAR, NULL);
// File Entry
GtkWidget *file_close = gtk_image_menu_item_new_from_stock(GTK_STOCK_CLOSE, accel_g);
g_signal_connect(file_close, "activate", G_CALLBACK(WVselGtk::activate_close), this);
GtkMenu *file_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_close);
GtkWidget *file = gtk_menu_item_new_with_mnemonic("_File");
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), file);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(file), GTK_WIDGET(file_menu));
// Functions Entry
GtkWidget *functions_showall = gtk_check_menu_item_new_with_mnemonic( "_Show All Volumes");
g_signal_connect( functions_showall, "activate",
G_CALLBACK(WVselGtk::activate_showall), this);
gtk_widget_add_accelerator( functions_showall, "activate", accel_g,
'a', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkMenu *functions_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(functions_menu), functions_showall);
GtkWidget *functions = gtk_menu_item_new_with_mnemonic("F_unctions");
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), functions);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(functions), GTK_WIDGET(functions_menu));
// List widget
store = gtk_list_store_new( 1, G_TYPE_STRING);
widgets.volumelist = (GtkWidget *) g_object_new(GTK_TYPE_TREE_VIEW,
"model", store,
"rules-hint", TRUE,
"headers-visible", FALSE,
"reorderable", TRUE,
"enable-search", TRUE,
"search-column", 0,
NULL);
text_renderer = gtk_cell_renderer_text_new();
name_column = gtk_tree_view_column_new_with_attributes( NULL,
text_renderer,
"text", 0,
NULL);
g_object_set( name_column,
"resizable", TRUE,
"clickable", TRUE,
NULL);
gtk_tree_view_append_column( GTK_TREE_VIEW(widgets.volumelist), name_column);
GtkWidget *ok_button = gtk_button_new_with_label( "Ok");
gtk_widget_set_size_request( ok_button, 70, 25);
g_signal_connect( ok_button, "clicked",
G_CALLBACK(activate_ok), this);
GtkWidget *cancel_button = gtk_button_new_with_label( "Cancel");
gtk_widget_set_size_request( cancel_button, 70, 25);
g_signal_connect( cancel_button, "clicked",
G_CALLBACK(activate_cancel), this);
GtkWidget *hboxbuttons = gtk_hbox_new( TRUE, 40);
gtk_box_pack_start( GTK_BOX(hboxbuttons), ok_button, FALSE, FALSE, 20);
gtk_box_pack_end( GTK_BOX(hboxbuttons), cancel_button, FALSE, FALSE, 20);
GtkWidget *scrolled_window = gtk_scrolled_window_new( NULL, NULL);
gtk_container_add( GTK_CONTAINER( scrolled_window), widgets.volumelist);
GtkWidget *vbox = gtk_vbox_new( FALSE, 0);
gtk_box_pack_start( GTK_BOX(vbox), GTK_WIDGET(menu_bar), FALSE, FALSE, 0);
gtk_box_pack_start( GTK_BOX(vbox), scrolled_window, TRUE, TRUE, 0);
gtk_box_pack_end( GTK_BOX(vbox), hboxbuttons, FALSE, FALSE, 10);
gtk_container_add( GTK_CONTAINER(widgets.toplevel), vbox);
gtk_widget_show_all( widgets.toplevel);
// GtkTreeSelection *selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(widgets.volumelist));
// gtk_tree_selection_set_mode( selection, GTK_SELECTION_SINGLE);
sts = load_volumelist();
WFoe::error_msg(sts);
// Set input focus to the scrolled list widget
gtk_widget_grab_focus( widgets.volumelist);
wow = new CoWowGtk( widgets.toplevel);
if ( wb_type != wb_eType_Buffer)
sts = check_volumelist( 0, &display_window);
*status = LOGIN__SUCCESS;
}
static sequence_view_t *new_sequence_view( void *vp, int num )
{
sequence_view_t *seqv = (sequence_view_t*) vj_calloc(sizeof(sequence_view_t));
seqv->num = num;
seqv->backlink = vp;
seqv->event_box = gtk_event_box_new();
gtk_event_box_set_visible_window( GTK_EVENT_BOX(seqv->event_box), TRUE );
GTK_WIDGET_SET_FLAGS( seqv->event_box, GTK_CAN_FOCUS );
g_signal_connect( G_OBJECT( seqv->event_box ),
"button_press_event",
G_CALLBACK( seqv_mouse_press_event ),
(gpointer*) seqv );
gtk_widget_show( GTK_WIDGET( seqv->event_box ) );
gchar *track_title = g_new0( gchar, 20 );
sprintf(track_title, "Track %d", num );
seqv->frame = gtk_frame_new( track_title );
g_free(track_title);
gtk_container_set_border_width( GTK_CONTAINER( seqv->frame) , 1 );
gtk_widget_show( GTK_WIDGET( seqv->frame ) );
gtk_container_add( GTK_CONTAINER( seqv->event_box), seqv->frame );
seqv->main_vbox = gtk_vbox_new(FALSE,0);
gtk_container_add( GTK_CONTAINER( seqv->frame ), seqv->main_vbox );
gtk_widget_show( GTK_WIDGET( seqv->main_vbox ) );
seqv->area = gtk_image_new();
gtk_box_pack_start( GTK_BOX(seqv->main_vbox),GTK_WIDGET( seqv->area), FALSE,FALSE,0);
gtk_widget_set_size_request_( seqv->area, 176,144 ); //FIXME
seqv->panel = gtk_frame_new(NULL);
seqv->toggle = gtk_toggle_button_new_with_label( "preview" );
if(num>0) {
gtk_toggle_button_set_active(
GTK_TOGGLE_BUTTON(seqv->toggle), FALSE );
g_signal_connect( G_OBJECT( seqv->toggle ), "toggled", G_CALLBACK(sequence_preview_cb),
(gpointer)seqv );
gtk_box_pack_start( GTK_BOX(seqv->main_vbox), seqv->toggle,FALSE,FALSE, 0 );
gtk_widget_set_sensitive_( GTK_WIDGET( seqv->toggle ), FALSE );
gtk_widget_show( seqv->toggle );
} else {
gtk_box_pack_start( GTK_BOX(seqv->main_vbox), seqv->toggle,FALSE,FALSE, 0 );
gtk_widget_show( seqv->toggle );
gtk_widget_set_sensitive_( GTK_WIDGET( seqv->toggle ), FALSE );
}
GtkWidget *vvbox = gtk_vbox_new(FALSE, 0);
seqv->button_box = gtk_hbox_new(FALSE,0);
gtk_box_pack_start( GTK_BOX(vvbox), seqv->button_box ,FALSE,FALSE, 0 );
add_buttons( seqv,seqv,seqv->button_box );
gtk_widget_show( seqv->button_box );
gtk_container_add( GTK_CONTAINER( seqv->main_vbox ), seqv->panel );
seqv->button_box2 = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start( GTK_BOX(vvbox), seqv->button_box2, FALSE,FALSE, 0 );
add_buttons2( seqv,seqv,seqv->button_box2 );
gtk_widget_show( seqv->button_box2 );
gtk_container_add( GTK_CONTAINER( seqv->panel ), vvbox );
gtk_widget_show(vvbox);
GtkWidget *box = gtk_vbox_new(FALSE,0);
seqv->timeline_ = gtk_hscale_new_with_range( 0.0,1.0,0.1 );
gtk_scale_set_draw_value( GTK_SCALE(seqv->timeline_), FALSE );
//gtk_widget_set_size_request_( seqv->panel,180 ,180);
gtk_adjustment_set_value(
GTK_ADJUSTMENT(GTK_RANGE(seqv->timeline_)->adjustment), 0.0 );
gtk_widget_show( seqv->panel );
gtk_box_pack_start( GTK_BOX( box ), seqv->timeline_, FALSE,FALSE, 0 );
gtk_box_pack_start( GTK_BOX( vvbox ), box , FALSE,FALSE,0);
gtk_widget_show(seqv->timeline_);
g_signal_connect( seqv->timeline_, "value_changed",
(GCallback) sequence_set_current_frame, (gpointer*) seqv );
GtkWidget *scroll = gtk_scrolled_window_new(NULL,NULL);
gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW(scroll), GTK_SHADOW_ETCHED_IN );
gtk_widget_set_size_request_(scroll,30,140);
gtk_container_set_border_width(GTK_CONTAINER(scroll),0);
gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(scroll),GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC );
GtkWidget *vvvbox = gtk_hbox_new(FALSE,0);
seqv->tracks = create_track_view(seqv->num, MAX_TRACKS, (void*) seqv );
gtk_tree_view_set_headers_visible( GTK_TREE_VIEW( get_track_tree(seqv->tracks)) , FALSE );
gtk_widget_set_size_request_( get_track_tree(seqv->tracks),20,80 );
gtk_widget_show(scroll);
gtk_scrolled_window_add_with_viewport(
GTK_SCROLLED_WINDOW( scroll ), get_track_tree(seqv->tracks) );
gtk_widget_show( get_track_tree(seqv->tracks));
gtk_box_pack_start( GTK_BOX(vvvbox), scroll, TRUE,TRUE, 0);
GtkWidget *hhbox = gtk_hbox_new(FALSE,0);
seqv->sliders_[0] = gtk_vscale_new_with_range( -12.0,12.0,1.0 );
seqv->sliders_[1] = gtk_vscale_new_with_range( 0.0, 1.0, 0.01 );
gtk_adjustment_set_value(
GTK_ADJUSTMENT(GTK_RANGE(seqv->sliders_[0])->adjustment), 1.0 );
gtk_adjustment_set_value(
GTK_ADJUSTMENT(GTK_RANGE(seqv->sliders_[1])->adjustment), 0.0 );
gtk_scale_set_digits( GTK_SCALE(seqv->sliders_[1]), 2 );
g_signal_connect( G_OBJECT( seqv->sliders_[0] ), "value_changed", G_CALLBACK( seq_speed ),
(gpointer*)seqv );
g_signal_connect( G_OBJECT( seqv->sliders_[1] ), "value_changed", G_CALLBACK( seq_opacity ),
(gpointer*)seqv );
gtk_box_pack_start( GTK_BOX( hhbox ), seqv->sliders_[0], TRUE, TRUE, 0 );
gtk_box_pack_start( GTK_BOX( hhbox ), seqv->sliders_[1], TRUE, TRUE, 0 );
gtk_widget_show( seqv->sliders_[0] );
gtk_widget_show( seqv->sliders_[1] );
gtk_box_pack_start( GTK_BOX(vvvbox), hhbox, TRUE,TRUE, 0 );
gtk_widget_show( hhbox );
gtk_container_add( GTK_CONTAINER( box ), vvvbox );
gtk_widget_show( vvvbox );
gtk_widget_show( box );
GtkWidget *hbox = gtk_hbox_new(FALSE,0);
gtk_box_set_spacing( GTK_BOX(hbox), 10 );
seqv->labels_[0] = gtk_label_new( "00:00:00:00" );
seqv->labels_[1] = gtk_label_new( "00:00:00:00" );
gtk_box_pack_start( GTK_BOX( hbox ), seqv->labels_[0], FALSE, FALSE, 0 );
gtk_box_pack_start( GTK_BOX( hbox ), seqv->labels_[1], FALSE, FALSE, 0 );
gtk_widget_show( seqv->labels_[0] );
gtk_widget_show( seqv->labels_[1] );
gtk_box_pack_start( GTK_BOX(seqv->main_vbox), hbox, FALSE,FALSE, 0 );
gtk_widget_show( hbox );
gtk_widget_set_sensitive_(GTK_WIDGET(seqv->panel), FALSE );
gtk_widget_show( GTK_WIDGET( seqv->area ) );
return seqv;
}
int main(int argc, char *argv[])
{
GtkWidget *window;
GtkWidget *ltable1;
GtkWidget *btnplay;
GtkWidget *btnsetting;
GtkWidget *btnquit;
GtkWidget *listwindow;
GdkBitmap *splash_mask;
GdkPixmap *splash_image;
GtkWidget *x_splash_image;
GdkPixbuf *icon_image;
GtkWidget *listgames;
GtkTreeSelection *selection;
if(argv[1])
{
chdir(argv[1]);
printf("[LAUNCHER] Using Directory %s\n", argv[1]);
}
sprintf(engine_game, "data");
gtk_init(&argc, &argv);
launcher_settings_load();
GdkGeometry hints;
hints.min_width = 444;
hints.max_width = 444;
hints.min_height = 225;
hints.max_height = 1080;
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), "NGUNIX Launcher");
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_container_set_border_width(GTK_CONTAINER(window), 2);
gtk_window_set_geometry_hints(GTK_WINDOW(window), window, &hints, (GdkWindowHints)(GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE));
gtk_widget_realize(window);
icon_image = gdk_pixbuf_new_from_xpm_data((const char**)icon_xpm);
gtk_window_set_default_icon (icon_image);
ltable1 = gtk_fixed_new();
gtk_container_add(GTK_CONTAINER(window), ltable1);
splash_image = gdk_pixmap_create_from_xpm_d(window->window, &splash_mask, NULL, (gchar **)splash_xpm );
if(!access("./splash.xpm", R_OK))
x_splash_image = gtk_image_new_from_file("./splash.xpm");
else
x_splash_image = gtk_image_new_from_pixmap(splash_image, splash_mask);
gtk_fixed_put(GTK_FIXED(ltable1), x_splash_image, 0, 0);
btnplay = gtk_button_new_from_stock(GTK_STOCK_MEDIA_PLAY);
btnsetting = gtk_button_new_from_stock(GTK_STOCK_PROPERTIES);
btnquit = gtk_button_new_from_stock(GTK_STOCK_QUIT);
gtk_fixed_put(GTK_FIXED(ltable1), btnplay, 0, 118);
gtk_widget_set_size_request(btnplay, 146, 40);
gtk_fixed_put(GTK_FIXED(ltable1), btnsetting, 148, 118);
gtk_widget_set_size_request(btnsetting, 144, 40);
gtk_fixed_put(GTK_FIXED(ltable1), btnquit, 148+146, 118);
gtk_widget_set_size_request(btnquit, 144, 40);
listwindow = gtk_scrolled_window_new (NULL, NULL);
gtk_fixed_put(GTK_FIXED(ltable1), listwindow, 0, 118+41);
listgames = gtk_tree_view_new();
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW (listwindow), listgames);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(listwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_widget_set_size_request(listwindow, 440, 300);
launcher_init_list(listgames);
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(listgames));
gtk_widget_show_all(window);
g_signal_connect(window, "destroy", G_CALLBACK(gtk_main_quit), NULL);
g_signal_connect(selection, "changed", G_CALLBACK(launcher_list_changed), listgames);
gtk_signal_connect (GTK_OBJECT (btnplay), "clicked", GTK_SIGNAL_FUNC (launcher_start),NULL);
gtk_signal_connect (GTK_OBJECT (btnsetting), "clicked", GTK_SIGNAL_FUNC (launcher_settings_window),NULL);
gtk_signal_connect (GTK_OBJECT (btnquit), "clicked", GTK_SIGNAL_FUNC (gtk_main_quit),NULL);
g_signal_connect(G_OBJECT(window), "configure-event", G_CALLBACK(resize_list), (gpointer)listwindow);
printf("[LAUNCHER] Scanning directories....\n");
launcher_cachefolders(listgames);
printf(".......... %d folder(s) found\n", iGameCnt);
gtk_main();
return 0;
}
static void
gpinstruct_analyzer_examinee_view_init (GPInstructAnalyzerExamineeView *object)
{
object->priv = GPINSTRUCT_ANALYZER_EXAMINEE_VIEW_GET_PRIVATE (object);
GPInstructAnalyzerExamineeViewPrivate *priv = object->priv;
GtkTreeSelection *selection;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
gtk_paned_set_position (GTK_PANED (object), 200);
GtkWidget *examinee_scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (examinee_scrolledwindow),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_paned_pack1 (GTK_PANED (object), examinee_scrolledwindow, FALSE, TRUE);
priv->examinee_scrolledwindow = examinee_scrolledwindow;
priv->examinee_store = gtk_list_store_new (EXAMINEE_N_COLUMNS,
G_TYPE_STRING,
G_TYPE_POINTER);
GtkWidget *examinee_treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (priv->examinee_store));
gtk_container_add (GTK_CONTAINER (examinee_scrolledwindow), examinee_treeview);
priv->examinee_treeview = examinee_treeview;
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (examinee_treeview));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
g_signal_connect (selection, "changed",
G_CALLBACK (examinee_tree_selection_changed_cb),
object);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_renderer_set_alignment (renderer, 0, 0.5);
column = gtk_tree_view_column_new_with_attributes (_("Examinees"),
renderer,
"text", EXAMINEE_NAME_COLUMN,
NULL);
gtk_tree_view_column_set_expand (column, TRUE);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (examinee_treeview), column);
GtkWidget *vpaned = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
gtk_paned_pack2 (GTK_PANED (object), vpaned, TRUE, TRUE);
GtkWidget *project_scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (project_scrolledwindow),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_paned_pack1 (GTK_PANED (vpaned), project_scrolledwindow, TRUE, TRUE);
priv->project_scrolledwindow = project_scrolledwindow;
priv->project_store = gtk_tree_store_new (PROJECT_N_COLUMNS,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_UINT,
G_TYPE_POINTER);
GtkWidget *project_treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (priv->project_store));
gtk_container_add (GTK_CONTAINER (project_scrolledwindow), project_treeview);
priv->project_treeview = project_treeview;
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (project_treeview));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
g_signal_connect (selection, "changed",
G_CALLBACK (project_tree_selection_changed_cb),
object);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_renderer_set_alignment (renderer, 0, 0.5);
column = gtk_tree_view_column_new_with_attributes (_("Project View"),
renderer,
"text", PROJECT_TITLE_COLUMN,
NULL);
gtk_tree_view_column_set_expand (column, TRUE);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (project_treeview), column);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_renderer_set_alignment (renderer, 1.0, 0.5);
column = gtk_tree_view_column_new_with_attributes (_("Total Items"),
renderer,
"text", PROJECT_ITEMS_COLUMN,
NULL);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (project_treeview), column);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_renderer_set_alignment (renderer, 1.0, 0.5);
column = gtk_tree_view_column_new_with_attributes (_("Frequency"),
renderer,
"text", PROJECT_FREQUENCY_COLUMN,
NULL);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (project_treeview), column);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_renderer_set_alignment (renderer, 1.0, 0.5);
column = gtk_tree_view_column_new_with_attributes (_("Total Score"),
renderer,
"text", PROJECT_SCORE_COLUMN,
NULL);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (project_treeview), column);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_renderer_set_alignment (renderer, 1.0, 0.5);
column = gtk_tree_view_column_new_with_attributes (_("Average Score"),
renderer,
"text", PROJECT_AVE_SCORE_COLUMN,
NULL);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (project_treeview), column);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_renderer_set_alignment (renderer, 1.0, 0.5);
column = gtk_tree_view_column_new_with_attributes (_("Percentage"),
renderer,
"text", PROJECT_PERCENTAGE_COLUMN,
NULL);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (project_treeview), column);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_renderer_set_alignment (renderer, 1.0, 0.5);
column = gtk_tree_view_column_new_with_attributes (_("Time Spent"),
renderer,
"text", PROJECT_TIME_COLUMN,
NULL);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (project_treeview), column);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_renderer_set_alignment (renderer, 1.0, 0.5);
column = gtk_tree_view_column_new_with_attributes (_("Average Time Spent"),
renderer,
"text", PROJECT_AVE_TIME_COLUMN,
NULL);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (project_treeview), column);
GtkWidget *test_scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (test_scrolledwindow),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_paned_pack2 (GTK_PANED (vpaned), test_scrolledwindow, TRUE, TRUE);
priv->test_scrolledwindow = test_scrolledwindow;
priv->test_store = gtk_tree_store_new (TEST_N_COLUMNS,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_UINT,
G_TYPE_POINTER);
GtkWidget *test_treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (priv->test_store));
gtk_container_add (GTK_CONTAINER (test_scrolledwindow), test_treeview);
priv->test_treeview = test_treeview;
renderer = gtk_cell_renderer_text_new ();
gtk_cell_renderer_set_alignment (renderer, 0, 0.5);
column = gtk_tree_view_column_new_with_attributes (_("Test View"),
renderer,
"text", TEST_TITLE_COLUMN,
NULL);
gtk_tree_view_column_set_expand (column, TRUE);
gtk_tree_view_column_set_resizable (column, TRUE);
g_object_set (renderer,
"ellipsize", PANGO_ELLIPSIZE_END,
"ellipsize-set", TRUE,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (test_treeview), column);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_renderer_set_alignment (renderer, 1.0, 0.5);
column = gtk_tree_view_column_new_with_attributes (_("Number of Choices"),
renderer,
"text", TEST_ITEMS_COLUMN,
NULL);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (test_treeview), column);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_renderer_set_alignment (renderer, 1.0, 0.5);
column = gtk_tree_view_column_new_with_attributes (_("Frequency"),
renderer,
"text", TEST_FREQUENCY_COLUMN,
NULL);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (test_treeview), column);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_renderer_set_alignment (renderer, 1.0, 0.5);
column = gtk_tree_view_column_new_with_attributes (_("Total Score"),
renderer,
"text", TEST_SCORE_COLUMN,
NULL);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (test_treeview), column);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_renderer_set_alignment (renderer, 1.0, 0.5);
column = gtk_tree_view_column_new_with_attributes (_("Percentage"),
renderer,
"text", TEST_PERCENTAGE_COLUMN,
NULL);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (test_treeview), column);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_renderer_set_alignment (renderer, 1.0, 0.5);
column = gtk_tree_view_column_new_with_attributes (_("Time Spent"),
renderer,
"text", TEST_TIME_COLUMN,
NULL);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (test_treeview), column);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_renderer_set_alignment (renderer, 1.0, 0.5);
column = gtk_tree_view_column_new_with_attributes (_("Average Time Spent"),
renderer,
"text", TEST_AVE_TIME_COLUMN,
NULL);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (test_treeview), column);
}
static void
rb_grilo_source_constructed (GObject *object)
{
RBGriloSource *source;
RBShell *shell;
RBShellPlayer *shell_player;
const GList *source_keys;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GtkTreeSelection *selection;
GtkWidget *scrolled;
GtkWidget *browserbox;
GtkWidget *vbox;
GtkWidget *mainbox;
GtkAdjustment *adjustment;
RB_CHAIN_GOBJECT_METHOD (rb_grilo_source_parent_class, constructed, object);
source = RB_GRILO_SOURCE (object);
g_object_get (source, "shell", &shell, NULL);
g_object_get (shell,
"db", &source->priv->db,
"shell-player", &shell_player,
NULL);
g_object_unref (shell);
g_object_get (source, "entry-type", &source->priv->entry_type, NULL);
source->priv->entry_view = rb_entry_view_new (source->priv->db, G_OBJECT (shell_player), TRUE, FALSE);
g_object_unref (shell_player);
g_signal_connect (source->priv->entry_view,
"notify::sort-order",
G_CALLBACK (notify_sort_order_cb),
source);
source_keys = grl_source_supported_keys (source->priv->grilo_source);
if (g_list_find ((GList *)source_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_TRACK_NUMBER))) {
rb_entry_view_append_column (source->priv->entry_view, RB_ENTRY_VIEW_COL_TRACK_NUMBER, FALSE);
source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys,
GUINT_TO_POINTER(GRL_METADATA_KEY_TRACK_NUMBER));
}
if (g_list_find ((GList *)source_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_TITLE))) {
rb_entry_view_append_column (source->priv->entry_view, RB_ENTRY_VIEW_COL_TITLE, TRUE);
source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys,
GUINT_TO_POINTER(GRL_METADATA_KEY_TITLE));
}
if (g_list_find ((GList *)source_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_GENRE))) {
rb_entry_view_append_column (source->priv->entry_view, RB_ENTRY_VIEW_COL_GENRE, FALSE);
source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys,
GUINT_TO_POINTER(GRL_METADATA_KEY_GENRE));
}
if (g_list_find ((GList *)source_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_ARTIST))) {
rb_entry_view_append_column (source->priv->entry_view, RB_ENTRY_VIEW_COL_ARTIST, FALSE);
source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys,
GUINT_TO_POINTER(GRL_METADATA_KEY_ARTIST));
}
if (g_list_find ((GList *)source_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_ALBUM))) {
rb_entry_view_append_column (source->priv->entry_view, RB_ENTRY_VIEW_COL_ALBUM, FALSE);
source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys,
GUINT_TO_POINTER(GRL_METADATA_KEY_ALBUM));
}
/*
if (g_list_find ((GList *)source_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_DATE))) {
rb_entry_view_append_column (source->priv->entry_view, RB_ENTRY_VIEW_COL_YEAR, FALSE);
source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys,
GUINT_TO_POINTER(GRL_METADATA_KEY_DATE));
}
*/
if (g_list_find ((GList *)source_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_DURATION))) {
rb_entry_view_append_column (source->priv->entry_view, RB_ENTRY_VIEW_COL_DURATION, FALSE);
source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys,
GUINT_TO_POINTER(GRL_METADATA_KEY_DURATION));
}
source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_CHILDCOUNT));
source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_URL));
source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_THUMBNAIL));
/* probably add an image column too? */
source->priv->browser_model = gtk_tree_store_new (4, GRL_TYPE_MEDIA, G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT);
source->priv->browser_view = gtk_tree_view_new ();
gtk_tree_view_set_model (GTK_TREE_VIEW (source->priv->browser_view), GTK_TREE_MODEL (source->priv->browser_model));
column = gtk_tree_view_column_new ();
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_set_title (column, _("Browse"));
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_add_attribute (column, renderer, "text", 1);
gtk_tree_view_column_set_expand (column, TRUE);
gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column (GTK_TREE_VIEW (source->priv->browser_view), column);
gtk_tree_view_set_show_expanders (GTK_TREE_VIEW (source->priv->browser_view), TRUE);
gtk_tree_view_set_expander_column (GTK_TREE_VIEW (source->priv->browser_view), column);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (source->priv->browser_view), TRUE);
gtk_tree_view_set_fixed_height_mode (GTK_TREE_VIEW (source->priv->browser_view), TRUE);
g_signal_connect (source->priv->browser_view, "row-expanded", G_CALLBACK (browser_row_expanded_cb), source);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (source->priv->browser_view));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); /* should be multiple eventually */
g_signal_connect (selection, "changed", G_CALLBACK (browser_selection_changed_cb), source);
scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled), GTK_SHADOW_IN);
adjustment = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled));
g_signal_connect (adjustment, "changed", G_CALLBACK (scroll_adjust_changed_cb), source);
g_signal_connect (adjustment, "value-changed", G_CALLBACK (scroll_adjust_value_changed_cb), source);
browserbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
/* search bar (if the source supports searching) */
if (grl_source_supported_operations (source->priv->grilo_source) & GRL_OP_SEARCH) {
source->priv->search_entry = rb_search_entry_new (FALSE);
g_object_set (source->priv->search_entry, "explicit-mode", TRUE, NULL);
g_signal_connect (source->priv->search_entry, "search", G_CALLBACK (search_cb), source);
g_signal_connect (source->priv->search_entry, "activate", G_CALLBACK (search_cb), source);
gtk_box_pack_start (GTK_BOX (browserbox), GTK_WIDGET (source->priv->search_entry), FALSE, FALSE, 6);
}
gtk_container_add (GTK_CONTAINER (scrolled), source->priv->browser_view);
gtk_box_pack_start (GTK_BOX (browserbox), scrolled, TRUE, TRUE, 0);
mainbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_box_pack_start (GTK_BOX (source), mainbox, TRUE, TRUE, 0);
/* info bar */
source->priv->info_bar_label = gtk_label_new ("");
source->priv->info_bar = gtk_info_bar_new ();
gtk_info_bar_set_message_type (GTK_INFO_BAR (source->priv->info_bar), GTK_MESSAGE_INFO);
gtk_info_bar_add_button (GTK_INFO_BAR (source->priv->info_bar), _("Fetch more tracks"), GTK_RESPONSE_OK);
gtk_container_add (GTK_CONTAINER (gtk_info_bar_get_content_area (GTK_INFO_BAR (source->priv->info_bar))),
source->priv->info_bar_label);
gtk_widget_show (GTK_WIDGET (source->priv->info_bar_label));
gtk_widget_set_no_show_all (GTK_WIDGET (source->priv->info_bar), TRUE);
g_signal_connect (source->priv->info_bar, "response", G_CALLBACK (fetch_more_cb), source);
/* don't allow the browser to be hidden? */
source->priv->paned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
rb_source_bind_settings (RB_SOURCE (source), GTK_WIDGET (source->priv->entry_view), source->priv->paned, NULL, TRUE);
gtk_paned_pack1 (GTK_PANED (source->priv->paned), browserbox, FALSE, FALSE);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_box_pack_start (GTK_BOX (vbox), GTK_WIDGET (source->priv->entry_view), TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox), source->priv->info_bar, FALSE, FALSE, 0);
gtk_paned_pack2 (GTK_PANED (source->priv->paned), vbox, TRUE, FALSE);
gtk_box_pack_start (GTK_BOX (mainbox), source->priv->paned, TRUE, TRUE, 0);
gtk_widget_show_all (GTK_WIDGET (source));
}
/*
** Create the window.
*/
static void create_changelog_window ()
{
/*GtkTooltips *tooltips;*/
GtkWidget *hbox, *textarea, *vscrollbar, *button;
GtkWidget *vbox, *textview, *swindow, *ok_button; // PV: +
GtkTextBuffer *txbuf; // PV: +
int txlen; // PV: +
GtkStyle *style;
char msg[100];
changelog_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_wmclass ( GTK_WINDOW ( changelog_window ), "GTimer", "gtimer" );
sprintf ( msg, "GTimer: %s", gettext ("Change Log") );
gtk_window_set_title (GTK_WINDOW (changelog_window), msg );
gtk_window_set_position ( GTK_WINDOW(changelog_window), GTK_WIN_POS_MOUSE );
// gtk_widget_realize ( changelog_window );
gdk_window_set_icon ( GTK_WIDGET ( changelog_window )->window,
NULL, appicon2, appicon2_mask );
vbox = gtk_vbox_new ( FALSE, 2 );
gtk_container_add ( GTK_CONTAINER (changelog_window), vbox);
hbox = gtk_hbox_new ( FALSE, 2 );
gtk_box_pack_start ( GTK_BOX ( vbox ), hbox, FALSE, FALSE, 2 );
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_start ( GTK_BOX(vbox), swindow, TRUE, TRUE, 0);
// style = gtk_style_new ();
// PV: -
/*
gdk_font_unref ( style->font );
style->font = gdk_font_load (
"-adobe-courier-medium-r-*-*-12-*-*-*-*-*-*-*" );
if ( style->font == NULL )
style->font = gdk_font_load ( "fixed" );
*/
// gtk_widget_push_style ( style );
txbuf = gtk_text_buffer_new(NULL);
txlen = strlen(changelog_text);
gtk_text_buffer_set_text (GTK_TEXT_BUFFER(txbuf), changelog_text, txlen);
textview = gtk_text_view_new_with_buffer(txbuf);
gtk_text_view_set_editable(GTK_TEXT_VIEW(textview),0);
gtk_container_add (GTK_CONTAINER (swindow), textview);
ok_button = gtk_button_new_with_label(gettext("Ok"));
gtk_box_pack_start(GTK_BOX(vbox), ok_button, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(ok_button), "clicked",
G_CALLBACK (changelog_ok_callback), NULL);
g_signal_connect(G_OBJECT(changelog_window), "delete-event",
G_CALLBACK (changelog_X_callback), NULL);
// gtk_widget_show (button);
gtk_window_set_default_size ( changelog_window, 600, 600 );
/*gdk_window_resize ( GTK_WIDGET ( changelog_window )->window, 600, 400 );*/
gtk_widget_show (changelog_window);
gtk_widget_show_all(changelog_window);
GTK_WIDGET_SET_FLAGS (ok_button, GTK_CAN_DEFAULT);
gtk_widget_grab_default (ok_button);
}
MedSLTPatWindow::MedSLTPatWindow(MedSLTPatWindowObserver& observer)
: m_observer(observer),
m_list_index(0),
m_list_items(0),
m_is_fullscreen(FALSE),
m_back_translation(""),
m_ui_state(UI_STATE_DISCONNECTED)
{
ACE_TRACE("[MedSLTPatWindow::MedSLTPatWindow()]");
GtkBox* hbox;
GtkBox* coverbox;
GtkBox* textbox;
GtkBox* buthbox;
GtkWidget* menu;
GtkWidget* appimage;
GtkWidget* scroll1;
GtkWidget* scroll2;
GtkWidget* scroll3;
PangoFontDescription* font1;
PangoFontDescription* font2;
GtkStyle* style;
GtkAccelGroup* accel = gtk_accel_group_new();
// Window
#ifdef _MAEMO
m_window = GTK_WINDOW(hildon_window_new());
#else
m_window = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL));
gtk_window_set_default_size(m_window, 450, -1);
#endif
gtk_window_add_accel_group(m_window, accel);
gtk_window_set_icon_from_file(m_window, app_icon, NULL);
gtk_container_set_border_width(GTK_CONTAINER(m_window), 5);
// Boxes
coverbox = GTK_BOX(gtk_vbox_new(False, 5));
hbox = GTK_BOX(gtk_hbox_new(False, 5));
textbox = GTK_BOX(gtk_vbox_new(False, 5));
buthbox = GTK_BOX(gtk_vbox_new(False, 5));
// Image
appimage = gtk_image_new_from_file(app_icon_big);
// Fonts
font1 = pango_font_description_from_string("Monospace Bold 20");
font2 = pango_font_description_from_string("Monospace Bold 16");
// Styles
style = gtk_style_new();
style->font_desc = font1;
gdk_color_parse ("red", &(style->fg[GTK_STATE_NORMAL]));
// Lists
m_list = gtk_clist_new(1);
gtk_widget_set_size_request(GTK_WIDGET(m_list), 550, 130);
gtk_widget_modify_font(m_list, font1);
/*gchar* text[3][1] = { {"où avez vous mal?"},
{"avez vous mal sous le devant de la tête?"},
{"la douleur survient elle le matin?"}}; */
gchar* text[3][1] = { {"sí mucho"},
{"no sé"},
{"la cabeza"}};
gtk_clist_append((GtkCList*)m_list, text[0]);
gtk_clist_append((GtkCList*)m_list, text[1]);
gtk_clist_append((GtkCList*)m_list, text[2]);
m_list_items = 3;
gtk_clist_select_row((GtkCList*)m_list, 0, 0);
// Text Boxes
m_txtbox1 = gtk_text_view_new();
gtk_widget_modify_font(m_txtbox1, font1);
gtk_widget_set_size_request(GTK_WIDGET(m_txtbox1), 550, 50);
gtk_text_view_set_editable(GTK_TEXT_VIEW(m_txtbox1), false);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(m_txtbox1), GTK_WRAP_WORD_CHAR);
gtk_widget_set_style (m_txtbox1, style);
m_txtbox2 = gtk_text_view_new();
gtk_widget_modify_font(m_txtbox2, font1);
gtk_widget_set_size_request(GTK_WIDGET(m_txtbox2), 550, 50);
gtk_text_view_set_editable(GTK_TEXT_VIEW(m_txtbox2), false);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(m_txtbox2), GTK_WRAP_WORD_CHAR);
// Scroll bars
scroll1 = gtk_scrolled_window_new(NULL, NULL);
scroll2 = gtk_scrolled_window_new(NULL, NULL);
scroll3 = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll1), GTK_POLICY_ALWAYS, GTK_POLICY_ALWAYS);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll2), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll3), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scroll1), GTK_SHADOW_IN);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scroll2), GTK_SHADOW_IN);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scroll3), GTK_SHADOW_IN);
gtk_container_add(GTK_CONTAINER(scroll1), GTK_WIDGET(m_list));
gtk_container_add(GTK_CONTAINER(scroll2), GTK_WIDGET(m_txtbox1));
gtk_container_add(GTK_CONTAINER(scroll3), GTK_WIDGET(m_txtbox2));
// Text labels
m_understood = gtk_label_new("Understood");
m_question = gtk_label_new("Question");
m_translation = gtk_label_new("Translation");
gtk_widget_modify_font(m_understood, font2);
gtk_widget_modify_font(m_question, font2);
gtk_widget_modify_font(m_translation, font2);
gtk_label_set_justify(GTK_LABEL(m_understood), GTK_JUSTIFY_LEFT);
gtk_label_set_justify(GTK_LABEL(m_question), GTK_JUSTIFY_LEFT);
gtk_label_set_justify(GTK_LABEL(m_translation), GTK_JUSTIFY_LEFT);
gtk_label_set_ellipsize(GTK_LABEL(m_understood), PANGO_ELLIPSIZE_END);
gtk_label_set_ellipsize(GTK_LABEL(m_question), PANGO_ELLIPSIZE_END);
gtk_label_set_ellipsize(GTK_LABEL(m_translation), PANGO_ELLIPSIZE_END);
// Buttons
m_rec = gtk_button_new();
m_speech = gtk_button_new();
m_abort = gtk_button_new();
m_up = gtk_button_new();
m_select = gtk_button_new();
m_down = gtk_button_new();
gtk_button_set_image(GTK_BUTTON(m_rec),
gtk_image_new_from_file(record_icon));
gtk_button_set_image(GTK_BUTTON(m_speech),
gtk_image_new_from_file(speech_icon));
gtk_button_set_image(GTK_BUTTON(m_abort),
gtk_image_new_from_file(stop_icon));
gtk_button_set_image(GTK_BUTTON(m_up),
gtk_image_new_from_file(up_icon));
gtk_button_set_image(GTK_BUTTON(m_select),
gtk_image_new_from_file(select_icon));
gtk_button_set_image(GTK_BUTTON(m_down),
gtk_image_new_from_file(down_icon));
// Menu
// Recheck: Is it destroyed somewhere
menu = CreateMenu(accel);
// Progress bar
m_progressbar = gtk_progress_bar_new();
gtk_progress_set_text_alignment(GTK_PROGRESS(m_progressbar),
0.5, 0.5);
gtk_widget_set_size_request(GTK_WIDGET(m_progressbar), 150, 50);
//gtk_container_add(GTK_CONTAINER(m_window), GTK_WIDGET(vbox));
gtk_box_pack_start(textbox, m_understood, TRUE, TRUE, 0);
gtk_box_pack_start(textbox, scroll1, TRUE, TRUE, 0);
gtk_box_pack_start(textbox, m_question, TRUE, TRUE, 0);
gtk_box_pack_start(textbox, scroll2, TRUE, TRUE, 0);
gtk_box_pack_start(textbox, m_translation, TRUE, TRUE, 0);
gtk_box_pack_start(textbox, scroll3, TRUE, TRUE, 0);
//gtk_box_pack_start(buthbox, appimage, TRUE, TRUE, 0);
gtk_box_pack_start(buthbox, m_rec, TRUE, TRUE, 0);
gtk_box_pack_start(buthbox, m_speech, TRUE, TRUE, 0);
gtk_box_pack_start(buthbox, m_abort, TRUE, TRUE, 0);
gtk_box_pack_start(buthbox, m_up, TRUE, TRUE, 0);
gtk_box_pack_start(buthbox, m_select, TRUE, TRUE, 0);
gtk_box_pack_start(buthbox, m_down, TRUE, TRUE, 0);
gtk_box_pack_start(hbox, GTK_WIDGET(textbox), TRUE, TRUE, 0);
gtk_box_pack_start(hbox, GTK_WIDGET(buthbox), TRUE, TRUE, 0);
gtk_box_pack_start(coverbox, GTK_WIDGET(hbox), TRUE, TRUE, 0);
gtk_box_pack_start(coverbox, m_progressbar, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(m_window), GTK_WIDGET(coverbox));
#ifdef _MAEMO
hildon_window_set_menu(HILDON_WINDOW(m_window), GTK_MENU(menu));
#else
gtk_box_pack_start(vbox, menu, FALSE, FALSE, 0);
#endif
// Signals
g_signal_connect(G_OBJECT(m_rec), "clicked",
G_CALLBACK(RecognizeClicked), this);
g_signal_connect(G_OBJECT(m_speech), "clicked",
G_CALLBACK(AbortClicked), this);
g_signal_connect(G_OBJECT(m_abort), "clicked",
G_CALLBACK(AbortClicked), this);
g_signal_connect(G_OBJECT(m_up), "clicked",
G_CALLBACK(UpClicked), this);
g_signal_connect(G_OBJECT(m_select), "clicked",
G_CALLBACK(SelectClicked), this);
g_signal_connect(G_OBJECT(m_down), "clicked",
G_CALLBACK(DownClicked), this);
g_signal_connect(G_OBJECT(m_list), "select_row",
G_CALLBACK(ListRowSelected), this);
g_signal_connect(G_OBJECT(m_window), "destroy",
G_CALLBACK(CloseApp), this);
g_signal_connect(G_OBJECT(m_window), "delete_event",
G_CALLBACK(CloseApp), this);
// Shortcuts
#ifndef _MAEMO
gtk_widget_add_accelerator(m_rec, "clicked", accel, GDK_space,
0, 0);
gtk_widget_add_accelerator(m_speech, "clicked", accel, GDK_space,
0, 0);
gtk_widget_add_accelerator(m_abort, "clicked", accel, GDK_space,
0, 0);
gtk_widget_add_accelerator(m_next, "clicked", accel, GDK_Right,
GDK_CONTROL_MASK, 0);
#endif
// Initial state
SetUiState(UI_STATE_DISCONNECTED);
return;
}
static void prefs_summary_column_create(void)
{
GtkWidget *window;
GtkWidget *vbox;
GtkWidget *label_hbox;
GtkWidget *label;
GtkWidget *vbox1;
GtkWidget *hbox1;
GtkWidget *clist_hbox;
GtkWidget *scrolledwin;
GtkWidget *stock_clist;
GtkWidget *shown_clist;
GtkWidget *btn_vbox;
GtkWidget *btn_vbox1;
GtkWidget *add_btn;
GtkWidget *remove_btn;
GtkWidget *up_btn;
GtkWidget *down_btn;
GtkWidget *btn_hbox;
GtkWidget *default_btn;
GtkWidget *confirm_area;
GtkWidget *ok_btn;
GtkWidget *cancel_btn;
gchar *title[1];
debug_print("Creating summary column setting window...\n");
window = gtk_window_new(GTK_WINDOW_DIALOG);
gtk_container_set_border_width(GTK_CONTAINER(window), 8);
gtk_window_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_window_set_modal(GTK_WINDOW(window), TRUE);
gtk_window_set_policy(GTK_WINDOW(window), FALSE, FALSE, FALSE);
gtk_window_set_title(GTK_WINDOW(window),
_("Displayed items configuration"));
gtk_signal_connect(GTK_OBJECT(window), "delete_event",
GTK_SIGNAL_FUNC(prefs_summary_column_delete_event),
NULL);
gtk_signal_connect(GTK_OBJECT(window), "key_press_event",
GTK_SIGNAL_FUNC(prefs_summary_column_key_pressed),
NULL);
vbox = gtk_vbox_new(FALSE, 6);
gtk_widget_show(vbox);
gtk_container_add(GTK_CONTAINER(window), vbox);
label_hbox = gtk_hbox_new(FALSE, 0);
gtk_widget_show(label_hbox);
gtk_box_pack_start(GTK_BOX(vbox), label_hbox, FALSE, FALSE, 4);
label = gtk_label_new
(_("Select items to be displayed in the summary view. You can modify\n"
"the order by using the Up / Down buttons or by dragging the items."));
gtk_widget_show(label);
gtk_box_pack_start(GTK_BOX(label_hbox), label, FALSE, FALSE, 4);
gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT);
vbox1 = gtk_vbox_new(FALSE, VSPACING);
gtk_widget_show(vbox1);
gtk_box_pack_start(GTK_BOX(vbox), vbox1, TRUE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(vbox1), 2);
hbox1 = gtk_hbox_new(FALSE, 8);
gtk_widget_show(hbox1);
gtk_box_pack_start(GTK_BOX(vbox1), hbox1, FALSE, TRUE, 0);
clist_hbox = gtk_hbox_new(FALSE, 8);
gtk_widget_show(clist_hbox);
gtk_box_pack_start(GTK_BOX(hbox1), clist_hbox, TRUE, TRUE, 0);
scrolledwin = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_set_usize(scrolledwin, 180, 210);
gtk_widget_show(scrolledwin);
gtk_box_pack_start(GTK_BOX(clist_hbox), scrolledwin, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
title[0] = _("Available items");
stock_clist = gtk_clist_new_with_titles(1, title);
gtk_widget_show(stock_clist);
gtk_container_add(GTK_CONTAINER(scrolledwin), stock_clist);
gtk_clist_set_selection_mode(GTK_CLIST(stock_clist),
GTK_SELECTION_BROWSE);
GTK_WIDGET_UNSET_FLAGS(GTK_CLIST(stock_clist)->column[0].button,
GTK_CAN_FOCUS);
/* add/remove button */
btn_vbox = gtk_vbox_new(FALSE, 0);
gtk_widget_show(btn_vbox);
gtk_box_pack_start(GTK_BOX(hbox1), btn_vbox, FALSE, FALSE, 0);
btn_vbox1 = gtk_vbox_new(FALSE, 8);
gtk_widget_show(btn_vbox1);
gtk_box_pack_start(GTK_BOX(btn_vbox), btn_vbox1, TRUE, FALSE, 0);
add_btn = gtk_button_new_with_label(_(" -> "));
gtk_widget_show(add_btn);
gtk_box_pack_start(GTK_BOX(btn_vbox1), add_btn, FALSE, FALSE, 0);
remove_btn = gtk_button_new_with_label(_(" <- "));
gtk_widget_show(remove_btn);
gtk_box_pack_start(GTK_BOX(btn_vbox1), remove_btn, FALSE, FALSE, 0);
gtk_signal_connect(GTK_OBJECT(add_btn), "clicked",
GTK_SIGNAL_FUNC(prefs_summary_column_add), NULL);
gtk_signal_connect(GTK_OBJECT(remove_btn), "clicked",
GTK_SIGNAL_FUNC(prefs_summary_column_remove), NULL);
clist_hbox = gtk_hbox_new(FALSE, 8);
gtk_widget_show(clist_hbox);
gtk_box_pack_start(GTK_BOX(hbox1), clist_hbox, TRUE, TRUE, 0);
scrolledwin = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_set_usize(scrolledwin, 180, 210);
gtk_widget_show(scrolledwin);
gtk_box_pack_start(GTK_BOX(clist_hbox), scrolledwin, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
title[0] = _("Displayed items");
shown_clist = gtk_clist_new_with_titles(1, title);
gtk_widget_show(shown_clist);
gtk_container_add(GTK_CONTAINER(scrolledwin), shown_clist);
gtk_clist_set_selection_mode(GTK_CLIST(shown_clist),
GTK_SELECTION_BROWSE);
gtk_clist_set_reorderable(GTK_CLIST(shown_clist), TRUE);
gtk_clist_set_use_drag_icons(GTK_CLIST(shown_clist), FALSE);
GTK_WIDGET_UNSET_FLAGS(GTK_CLIST(shown_clist)->column[0].button,
GTK_CAN_FOCUS);
/* up/down button */
btn_vbox = gtk_vbox_new(FALSE, 0);
gtk_widget_show(btn_vbox);
gtk_box_pack_start(GTK_BOX(hbox1), btn_vbox, FALSE, FALSE, 0);
btn_vbox1 = gtk_vbox_new(FALSE, 8);
gtk_widget_show(btn_vbox1);
gtk_box_pack_start(GTK_BOX(btn_vbox), btn_vbox1, TRUE, FALSE, 0);
up_btn = gtk_button_new_with_label(_("Up"));
gtk_widget_show(up_btn);
gtk_box_pack_start(GTK_BOX(btn_vbox1), up_btn, FALSE, FALSE, 0);
down_btn = gtk_button_new_with_label(_("Down"));
gtk_widget_show(down_btn);
gtk_box_pack_start(GTK_BOX(btn_vbox1), down_btn, FALSE, FALSE, 0);
gtk_signal_connect(GTK_OBJECT(up_btn), "clicked",
GTK_SIGNAL_FUNC(prefs_summary_column_up), NULL);
gtk_signal_connect(GTK_OBJECT(down_btn), "clicked",
GTK_SIGNAL_FUNC(prefs_summary_column_down), NULL);
btn_hbox = gtk_hbox_new(FALSE, 8);
gtk_widget_show(btn_hbox);
gtk_box_pack_end(GTK_BOX(vbox), btn_hbox, FALSE, FALSE, 0);
btn_vbox = gtk_vbox_new(FALSE, 0);
gtk_widget_show(btn_vbox);
gtk_box_pack_start(GTK_BOX(btn_hbox), btn_vbox, FALSE, FALSE, 0);
default_btn = gtk_button_new_with_label(_(" Use default "));
gtk_widget_show(default_btn);
gtk_box_pack_start(GTK_BOX(btn_vbox), default_btn, TRUE, FALSE, 0);
gtk_signal_connect(GTK_OBJECT(default_btn), "clicked",
GTK_SIGNAL_FUNC(prefs_summary_column_set_to_default),
NULL);
gtkut_button_set_create(&confirm_area, &ok_btn, _("OK"),
&cancel_btn, _("Cancel"), NULL, NULL);
gtk_widget_show(confirm_area);
gtk_box_pack_end(GTK_BOX(btn_hbox), confirm_area, FALSE, FALSE, 0);
gtk_widget_grab_default(ok_btn);
gtk_signal_connect(GTK_OBJECT(ok_btn), "clicked",
GTK_SIGNAL_FUNC(prefs_summary_column_ok), NULL);
gtk_signal_connect(GTK_OBJECT(cancel_btn), "clicked",
GTK_SIGNAL_FUNC(prefs_summary_column_cancel), NULL);
summary_col.window = window;
summary_col.stock_clist = stock_clist;
summary_col.shown_clist = shown_clist;
summary_col.add_btn = add_btn;
summary_col.remove_btn = remove_btn;
summary_col.up_btn = up_btn;
summary_col.down_btn = down_btn;
summary_col.ok_btn = ok_btn;
summary_col.cancel_btn = cancel_btn;
}
int l_uosindm(int innom,GtkWidget *wpredok)
{
l_uosindm_data data;
char bros[512];
SQL_str row;
class SQLCURSOR cur;
data.innom=innom;
sprintf(bros,"select naim from Uosin where innom=%d",innom);
if(iceb_sql_readkey(bros,&row,&cur,wpredok) == 1)
data.naim_in.new_plus(row[0]);
data.window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_position( GTK_WINDOW(data.window),ICEB_POS_CENTER);
gtk_window_set_modal(GTK_WINDOW(data.window),TRUE);
sprintf(bros,"%s %s",name_system,gettext("Список драгоценных металлов"));
gtk_window_set_title (GTK_WINDOW (data.window),bros);
gtk_container_set_border_width (GTK_CONTAINER (data.window), 5);
gtk_signal_connect(GTK_OBJECT(data.window),"delete_event",GTK_SIGNAL_FUNC(gtk_widget_destroy),NULL);
gtk_signal_connect(GTK_OBJECT(data.window),"destroy",GTK_SIGNAL_FUNC(gtk_main_quit),NULL);
if(wpredok != NULL)
{
gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR_GDITE));
//Удерживать окно над породившем его окном всегда
gtk_window_set_transient_for(GTK_WINDOW(data.window),GTK_WINDOW(wpredok));
//Закрыть окно если окно предок удалено
gtk_window_set_destroy_with_parent(GTK_WINDOW(data.window),TRUE);
}
gtk_signal_connect_after(GTK_OBJECT(data.window),"key_press_event",GTK_SIGNAL_FUNC(l_uosindm_key_press),&data);
gtk_signal_connect_after(GTK_OBJECT(data.window),"key_release_event",GTK_SIGNAL_FUNC(iceb_key_release),&data.kl_shift);
GtkWidget *hbox = gtk_hbox_new (FALSE, 1);
gtk_container_add (GTK_CONTAINER (data.window), hbox);
GtkWidget *vbox1 = gtk_vbox_new (FALSE, 1);
GtkWidget *vbox2 = gtk_vbox_new (FALSE, 1);
gtk_box_pack_start (GTK_BOX (hbox), vbox1, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 0);
gtk_widget_show(hbox);
data.label_kolstr=gtk_label_new (gettext("Список драгоценных металлов"));
//gdk_color_parse("green",&color);
//gtk_widget_modify_fg(data.label_kolstr,GTK_STATE_NORMAL,&color);
gtk_box_pack_start (GTK_BOX (vbox2),data.label_kolstr,FALSE, FALSE, 0);
gtk_widget_show(vbox1);
gtk_widget_show(vbox2);
data.sw = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_set_usize(GTK_WIDGET(data.sw),400,300);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (data.sw),GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (data.sw),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
//gtk_box_pack_start (GTK_BOX (vbox2), data.sw, TRUE, TRUE, 0);
gtk_box_pack_end (GTK_BOX (vbox2), data.sw, TRUE, TRUE, 0);
//Кнопки
GtkTooltips *tooltips[KOL_F_KL];
sprintf(bros,"F2 %s",gettext("Запись"));
data.knopka[FK2]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK2], TRUE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK2]), "clicked",GTK_SIGNAL_FUNC(l_uosindm_knopka),&data);
tooltips[FK2]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK2],data.knopka[FK2],gettext("Ввод новой записи"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK2]),(gpointer)FK2);
gtk_widget_show(data.knopka[FK2]);
sprintf(bros,"%sF2 %s",RFK,gettext("Корректировать"));
data.knopka[SFK2]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[SFK2],TRUE,TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[SFK2]), "clicked",GTK_SIGNAL_FUNC(l_uosindm_knopka),&data);
tooltips[SFK2]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[SFK2],data.knopka[SFK2],gettext("Корректировка выбранной записи"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[SFK2]),(gpointer)SFK2);
gtk_widget_show(data.knopka[SFK2]);
sprintf(bros,"F3 %s",gettext("Удалить"));
data.knopka[FK3]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK3],TRUE,TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK3]), "clicked",GTK_SIGNAL_FUNC(l_uosindm_knopka),&data);
tooltips[FK3]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK3],data.knopka[FK3],gettext("Удаление выбранной записи"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK3]),(gpointer)FK3);
gtk_widget_show(data.knopka[FK3]);
sprintf(bros,"F5 %s",gettext("Печать"));
data.knopka[FK5]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK5],TRUE,TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK5]), "clicked",GTK_SIGNAL_FUNC(l_uosindm_knopka),&data);
tooltips[FK5]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK5],data.knopka[FK5],gettext("Распечатка записей"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK5]),(gpointer)FK5);
gtk_widget_show(data.knopka[FK5]);
sprintf(bros,"F10 %s",gettext("Выход"));
data.knopka[FK10]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1),data.knopka[FK10],TRUE,TRUE, 0);
tooltips[FK10]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK10],data.knopka[FK10],gettext("Завершение работы в этом окне"),NULL);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK10]), "clicked",GTK_SIGNAL_FUNC(l_uosindm_knopka),&data);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK10]),(gpointer)FK10);
gtk_widget_show(data.knopka[FK10]);
gtk_widget_realize(data.window);
gdk_window_set_cursor(data.window->window,gdk_cursor_new(ICEB_CURSOR));
gtk_widget_grab_focus(data.knopka[FK10]);
l_uosindm_create_list(&data);
gtk_widget_show(data.window);
gtk_window_maximize(GTK_WINDOW(data.window));
//gtk_window_fullscreen(GTK_WINDOW(data.window));
gtk_main();
if(wpredok != NULL)
gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR));
return(data.metka_voz);
}
void
FormDialog::multiple_choice (const std::string name,
const std::string description,
const std::set<std::string> values,
const std::map<std::string, std::string> choices,
bool advanced)
{
GtkWidget *label = NULL;
GtkWidget *scroll = NULL;
GtkWidget *tree_view = NULL;
GtkWidget *frame = NULL;
GtkListStore *list_store = NULL;
GtkTreeViewColumn *column = NULL;
GtkCellRenderer *renderer = NULL;
GtkTreeIter iter;
gchar *label_text = NULL;
MultipleChoiceSubmitter *submitter = NULL;
grow_fields (advanced);
/* The label */
label = gtk_label_new (NULL);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
label_text = g_strdup_printf ("<b>%s</b>", description.c_str());
gtk_label_set_markup_with_mnemonic (GTK_LABEL (label), label_text);
g_free (label_text);
/* The GtkListStore containing the choices */
tree_view = gtk_tree_view_new ();
list_store = gtk_list_store_new (MultipleChoiceSubmitter::COLUMN_NUMBER,
G_TYPE_BOOLEAN, G_TYPE_STRING);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (tree_view), TRUE);
gtk_tree_view_set_model (GTK_TREE_VIEW (tree_view), GTK_TREE_MODEL (list_store));
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tree_view), FALSE);
frame = gtk_frame_new (NULL);
gtk_widget_set_size_request (GTK_WIDGET (frame), -1, 125);
gtk_container_set_border_width (GTK_CONTAINER (frame), 0);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
scroll = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER (frame), scroll);
gtk_container_add (GTK_CONTAINER (scroll), tree_view);
renderer = gtk_cell_renderer_toggle_new ();
column =
gtk_tree_view_column_new_with_attributes (NULL, renderer,
"active", MultipleChoiceSubmitter::COLUMN_ACTIVE,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column);
g_signal_connect (renderer, "toggled",
G_CALLBACK (multiple_choice_choice_toggled_cb), list_store);
renderer = gtk_cell_renderer_text_new ();
column =
gtk_tree_view_column_new_with_attributes (NULL, renderer,
"text", MultipleChoiceSubmitter::COLUMN_NAME,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column);
for (std::map<std::string, std::string>::const_iterator map_iter
= choices.begin ();
map_iter != choices.end ();
map_iter++) {
bool active = (std::find (values.begin (), values.end (), map_iter->first) != values.end ());
gtk_list_store_append (GTK_LIST_STORE (list_store), &iter);
gtk_list_store_set (GTK_LIST_STORE (list_store), &iter,
MultipleChoiceSubmitter::COLUMN_ACTIVE, active,
MultipleChoiceSubmitter::COLUMN_NAME, map_iter->second.c_str (),
-1);
}
if (advanced) {
gtk_table_attach (GTK_TABLE (advanced_fields), label,
0, 2, advanced_rows - 1, advanced_rows,
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
0, 0);
gtk_table_attach (GTK_TABLE (advanced_fields), frame,
0, 2, advanced_rows - 1, advanced_rows,
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
0, 0);
} else {
gtk_table_attach (GTK_TABLE (fields), label,
0, 2, rows - 1, rows,
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
0, 0);
gtk_table_attach (GTK_TABLE (fields), frame,
0, 2, rows - 1, rows,
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
0, 0);
}
submitter = new MultipleChoiceSubmitter (name, description,
choices, advanced, tree_view);
submitters.push_back (submitter);
}
static void * search_get_widget (void)
{
GtkWidget * vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
entry = gtk_entry_new ();
gtk_entry_set_icon_from_icon_name ((GtkEntry *) entry, GTK_ENTRY_ICON_PRIMARY, "edit-find");
gtk_entry_set_placeholder_text ((GtkEntry *) entry, _("Search library"));
g_signal_connect (entry, "destroy", (GCallback) gtk_widget_destroyed, & entry);
gtk_box_pack_start ((GtkBox *) vbox, entry, FALSE, FALSE, 0);
help_label = gtk_label_new (_("To import your music library into "
"Audacious, choose a folder and then click the \"refresh\" icon."));
gtk_widget_set_size_request (help_label, 194, -1);
gtk_label_set_line_wrap ((GtkLabel *) help_label, TRUE);
g_signal_connect (help_label, "destroy", (GCallback) gtk_widget_destroyed, & help_label);
gtk_widget_set_no_show_all (help_label, TRUE);
gtk_box_pack_start ((GtkBox *) vbox, help_label, TRUE, FALSE, 0);
wait_label = gtk_label_new (_("Please wait ..."));
g_signal_connect (wait_label, "destroy", (GCallback) gtk_widget_destroyed, & wait_label);
gtk_widget_set_no_show_all (wait_label, TRUE);
gtk_box_pack_start ((GtkBox *) vbox, wait_label, TRUE, FALSE, 0);
scrolled = gtk_scrolled_window_new (NULL, NULL);
g_signal_connect (scrolled, "destroy", (GCallback) gtk_widget_destroyed, & scrolled);
gtk_scrolled_window_set_shadow_type ((GtkScrolledWindow *) scrolled, GTK_SHADOW_IN);
gtk_scrolled_window_set_policy ((GtkScrolledWindow *) scrolled,
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_widget_set_no_show_all (scrolled, TRUE);
gtk_box_pack_start ((GtkBox *) vbox, scrolled, TRUE, TRUE, 0);
results_list = audgui_list_new (& list_callbacks, NULL, items ? index_count (items) : 0);
g_signal_connect (results_list, "destroy", (GCallback) gtk_widget_destroyed, & results_list);
gtk_tree_view_set_headers_visible ((GtkTreeView *) results_list, FALSE);
audgui_list_add_column (results_list, NULL, 0, G_TYPE_STRING, -1);
gtk_container_add ((GtkContainer *) scrolled, results_list);
GtkWidget * hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_end ((GtkBox *) vbox, hbox, FALSE, FALSE, 0);
GtkWidget * chooser = gtk_file_chooser_button_new (_("Choose Folder"),
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
gtk_box_pack_start ((GtkBox *) hbox, chooser, TRUE, TRUE, 0);
char * path = get_path ();
gtk_file_chooser_set_filename ((GtkFileChooser *) chooser, path);
str_unref (path);
GtkWidget * button = gtk_button_new ();
gtk_container_add ((GtkContainer *) button, gtk_image_new_from_icon_name
("view-refresh", GTK_ICON_SIZE_BUTTON));
gtk_button_set_relief ((GtkButton *) button, GTK_RELIEF_NONE);
gtk_box_pack_start ((GtkBox *) hbox, button, FALSE, FALSE, 0);
g_signal_connect (entry, "changed", (GCallback) entry_cb, NULL);
g_signal_connect (entry, "activate", (GCallback) action_play, NULL);
g_signal_connect (button, "clicked", (GCallback) refresh_cb, chooser);
gtk_widget_show_all (vbox);
gtk_widget_show (results_list);
show_hide_widgets ();
return vbox;
}
int main (int argc, char *argv[]) {
Reg *reg;
reg = g_slice_new (Reg);
if (reg == NULL)
{
fprintf (stderr, "Error: not engouh space\n");
exit (1);
}
reg->path = malloc (sizeof (char) * MAX_VALUE_NAME);
if (reg->path == NULL)
{
fprintf (stderr, "Error: not engouh space\n");
exit (1);
}
GtkWidget *window;
GtkWidget *vbox;
GtkWidget *menubar;
GtkWidget *sw;
GtkWidget *hpaned;
GtkWidget *treeview;
GtkWidget *listview;
GtkWidget *statusbar;
GtkTreeSelection *selection;
GtkWidget *file;
GtkWidget *edit;
GtkWidget *option;
GtkWidget *filemenu;
GtkWidget *file_quit;
GtkWidget *editmenu;
GtkWidget *edit_insert_reg_sz;
GtkWidget *edit_delete_key;
GtkWidget *optionmenu;
GtkWidget *option_add_to_run;
GtkWidget *option_bind_gateway;
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "注册表编辑器");
gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_CENTER);
gtk_window_set_default_size (GTK_WINDOW (window), 600, 400);
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), vbox);
menubar = gtk_menu_bar_new();
gtk_box_pack_start (GTK_BOX (vbox), menubar, FALSE, FALSE, 0);
hpaned = gtk_hpaned_new ();
gtk_box_pack_start (GTK_BOX (vbox), hpaned, TRUE, TRUE, 0);
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_paned_add1 (GTK_PANED (hpaned), sw);
treeview = create_tree_view_and_model();
gtk_container_add (GTK_CONTAINER (sw), treeview);
gtk_widget_set_size_request (treeview, 150, 0);
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_paned_add2 (GTK_PANED (hpaned), sw);
listview = create_list_view_and_model();
gtk_container_add (GTK_CONTAINER (sw), listview);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (listview));
statusbar = gtk_statusbar_new();
gtk_box_pack_start (GTK_BOX (vbox), statusbar, FALSE, FALSE, 0);
file = gtk_menu_item_new_with_mnemonic ("_File");
edit = gtk_menu_item_new_with_mnemonic ("_Edit");
option = gtk_menu_item_new_with_mnemonic ("_Option");
gtk_menu_shell_append (GTK_MENU_SHELL (menubar), file);
gtk_menu_shell_append (GTK_MENU_SHELL (menubar), edit);
gtk_menu_shell_append (GTK_MENU_SHELL (menubar), option);
filemenu = gtk_menu_new();
editmenu = gtk_menu_new();
optionmenu = gtk_menu_new();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (file), filemenu);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (edit), editmenu);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (option), optionmenu);
file_quit = gtk_image_menu_item_new_from_stock (GTK_STOCK_QUIT, NULL);
gtk_menu_shell_append (GTK_MENU_SHELL (filemenu), file_quit);
edit_insert_reg_sz = gtk_menu_item_new_with_label ("插入键值(REG_SZ)");
edit_delete_key = gtk_menu_item_new_with_label ("删除选定键值");
gtk_menu_shell_append (GTK_MENU_SHELL (editmenu), edit_insert_reg_sz);
gtk_menu_shell_append (GTK_MENU_SHELL (editmenu), edit_delete_key);
option_add_to_run = gtk_menu_item_new_with_label ("加入启动项");
option_bind_gateway = gtk_menu_item_new_with_label ("绑定网关");
gtk_menu_shell_append (GTK_MENU_SHELL (optionmenu), option_add_to_run);
gtk_menu_shell_append (GTK_MENU_SHELL (optionmenu), option_bind_gateway);
reg->rootkey = HKEY_CLASSES_ROOT;
reg->path[0] = '\0';
reg->treeview = treeview;
reg->listview = listview;
reg->selection = selection;
reg->progname = argv[0];
gtk_widget_show_all (window);
g_signal_connect_swapped (G_OBJECT (window), "destroy", G_CALLBACK (gtk_main_quit), G_OBJECT (window));
g_signal_connect (GTK_TREE_VIEW (treeview), "row-activated", G_CALLBACK (on_tree_view_row_activated), reg);
g_signal_connect (GTK_MENU_ITEM (file_quit), "activate", G_CALLBACK (gtk_main_quit), NULL);
g_signal_connect (GTK_MENU_ITEM (edit_insert_reg_sz), "activate", G_CALLBACK (on_edit_insert_reg_sz_activate), reg);
g_signal_connect (GTK_MENU_ITEM (edit_delete_key), "activate", G_CALLBACK (on_edit_delete_key_activate), reg);
g_signal_connect (GTK_MENU_ITEM (option_add_to_run), "activate", G_CALLBACK (on_option_add_to_run_activate), reg);
g_signal_connect (GTK_MENU_ITEM (option_bind_gateway), "activate", G_CALLBACK (on_option_bind_gateway_activate), reg);
// g_signal_connect (selection, "changed", G_CALLBACK (on_changed), collection);
gtk_main();
free (reg->path);
g_slice_free (Reg, reg);
return 0;
}
int main(int argc, char *argv[])
{
if (argc < 3) {
printf("Usage: %s <username> <password>\n", argv[0]);
return 1;
}
GtkWidget *vbox;
GtkWidget *swin;
GtkTreeSelection *selection;
/* Create needed variables - not anymore, use appdata instead
HildonProgram *program;
HildonWindow *window; */
/* Create AppData */
AppData *appdata=g_malloc( sizeof( *appdata ) );
/* Initialize the GTK. */
gtk_init(&argc, &argv);
/* Create the Hildon program and setup the title */
g_set_application_name("Maemify");
#ifdef MAEMO4
appdata->program = HILDON_PROGRAM(hildon_program_get_instance());
/* Create HildonWindow and set it to HildonProgram */
appdata->window = HILDON_WINDOW(hildon_window_new());
hildon_program_add_window(appdata->program, appdata->window);
#else
appdata->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (appdata->window), "Maemify");
gtk_widget_set_usize( GTK_WIDGET ( appdata->window ) , 600 , 300 );
/* create our table */
appdata->table = gtk_table_new(3, 3, FALSE); //three rows, three columns, not homogenous
gtk_container_add(GTK_CONTAINER(appdata->window),appdata->table);
#endif
/* Create find toolbar, but keep it hidden */
create_find_toolbar(appdata);
#ifdef MAEMO4
gtk_widget_show_all(GTK_WIDGET(appdata->find_toolbar));
/* Create menu for the Window */
create_menu(appdata->window);
#else
gtk_table_attach_defaults(GTK_TABLE(appdata->table), GTK_WIDGET(appdata->entry), 1, 2, 2, 3);
gtk_widget_show_all(GTK_WIDGET(appdata->table));
#endif
/* Begin the main application */
gtk_widget_show_all(GTK_WIDGET(appdata->window));
/* Connect signal to X in the upper corner */
g_signal_connect(G_OBJECT(appdata->window), "delete_event",
G_CALLBACK(gtk_main_quit), NULL);
if (!despotify_init())
{
printf("despotify_init() failed\n");
return 1;
}
appdata->ds = despotify_init_client(callback, NULL, false);
if (!appdata->ds) {
printf("despotify_init_client() failed\n");
return 1;
}
if (!despotify_authenticate(appdata->ds, argv[1], argv[2])) {
printf( "Authentication failed: %s\n", despotify_get_error(appdata->ds));
despotify_exit(appdata->ds);
return 1;
}
/* Create a tree view and place it in a scrolled window */
appdata->list = gtk_tree_view_new();
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(appdata->list), TRUE);
swin = gtk_scrolled_window_new(NULL, NULL);
vbox = gtk_vbox_new(FALSE, 0);
/* add labels to the fields */
appdata->label = gtk_label_new("Search hits");
gtk_label_set_justify(GTK_LABEL(appdata->label), GTK_JUSTIFY_CENTER);
gtk_box_pack_start(GTK_BOX(vbox), appdata->label, FALSE, FALSE, 5);
gtk_container_add(GTK_CONTAINER(swin), appdata->list);
#ifdef MAEMO4
gtk_container_add(GTK_CONTAINER(appdata->window), swin);
#else
gtk_table_attach_defaults(GTK_TABLE(appdata->table), swin, 1, 2, 1, 2);
#endif
/* initialize a list to hold search hits */
init_list(appdata->list);
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(appdata->list));
g_signal_connect(selection, "changed",
G_CALLBACK(on_changed), appdata);
gtk_widget_show_all(GTK_WIDGET(appdata->window));
gtk_main();
despotify_deinit(appdata);
/* Exit */
return 0;
}
GtkWidget * create_Equalizer( void )
{
GtkWidget * vbox1;
GtkWidget * hbox1;
GtkWidget * scrolledwindow1;
GtkWidget * table1;
GtkWidget * hbuttonbox1;
GtkAccelGroup * accel_group;
accel_group=gtk_accel_group_new();
Equalizer=gtk_window_new( GTK_WINDOW_TOPLEVEL );
gtk_widget_set_name( Equalizer,MSGTR_Equalizer );
gtk_object_set_data( GTK_OBJECT( Equalizer ),MSGTR_Equalizer,Equalizer );
gtk_widget_set_usize( Equalizer,-1,256 );
gtk_window_set_title( GTK_WINDOW( Equalizer ),MSGTR_Equalizer );
gtk_window_set_position( GTK_WINDOW( Equalizer ),GTK_WIN_POS_CENTER );
gtk_window_set_policy( GTK_WINDOW( Equalizer ),FALSE,FALSE,FALSE );
gtk_window_set_wmclass( GTK_WINDOW( Equalizer ),"Equalizer","MPlayer" );
gtk_widget_realize( Equalizer );
gtkAddIcon( Equalizer );
vbox1=AddVBox( AddDialogFrame( Equalizer ),0 );
Notebook=gtk_notebook_new();
gtk_widget_set_name( Notebook,"Notebook" );
gtk_widget_show( Notebook );
gtk_box_pack_start( GTK_BOX( vbox1 ),Notebook,TRUE,TRUE,0 );
gtk_container_set_border_width( GTK_CONTAINER( Notebook ),1 );
hbox1=AddHBox( Notebook,0 );
scrolledwindow1=gtk_scrolled_window_new( NULL,NULL );
gtk_widget_set_name( scrolledwindow1,"scrolledwindow1" );
gtk_widget_show( scrolledwindow1 );
gtk_box_pack_start( GTK_BOX( hbox1 ),scrolledwindow1,FALSE,FALSE,0 );
gtk_widget_set_usize( scrolledwindow1,106,-2 );
gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( scrolledwindow1 ),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC );
ChannelsList=gtk_clist_new( 1 );
gtk_widget_set_name( ChannelsList,"ChannelsList" );
gtk_widget_show( ChannelsList );
gtk_container_add( GTK_CONTAINER( scrolledwindow1 ),ChannelsList );
gtk_clist_set_column_width( GTK_CLIST( ChannelsList ),0,80 );
gtk_clist_column_titles_hide( GTK_CLIST( ChannelsList ) );
table1=gtk_table_new( 2,10,FALSE );
gtk_widget_set_name( table1,"table1" );
gtk_widget_show( table1 );
gtk_box_pack_start( GTK_BOX( hbox1 ),table1,FALSE,FALSE,0 );
gtk_table_set_row_spacings( GTK_TABLE( table1 ),4 );
gtk_table_set_col_spacings( GTK_TABLE( table1 ),9 );
A3125adj=GTK_ADJUSTMENT( gtk_adjustment_new( 0,-eqRange,eqRange,0.5,0,0 ) );
A3125=AddVScaler( A3125adj,NULL,-1 );
gtk_table_attach( GTK_TABLE( table1 ),A3125,0,1,0,1,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),0,0 );
A6250adj=GTK_ADJUSTMENT( gtk_adjustment_new( 0,-eqRange,eqRange,0.5,0,0 ) );
A6250=AddVScaler( A6250adj,NULL,-1 );
gtk_table_attach( GTK_TABLE( table1 ),A6250,1,2,0,1,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),0,0 );
A125adj=GTK_ADJUSTMENT( gtk_adjustment_new( 0,-eqRange,eqRange,0.5,0,0 ) );
A125=AddVScaler( A125adj,NULL,-1 );
gtk_table_attach( GTK_TABLE( table1 ),A125,2,3,0,1,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),0,0 );
A250adj=GTK_ADJUSTMENT( gtk_adjustment_new( 0,-eqRange,eqRange,0.5,0,0 ) );
A250=AddVScaler( A250adj,NULL,-1 );
gtk_table_attach( GTK_TABLE( table1 ),A250,3,4,0,1,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),0,0 );
A500adj=GTK_ADJUSTMENT( gtk_adjustment_new( 0,-eqRange,eqRange,0.5,0,0 ) );
A500=AddVScaler( A500adj,NULL,-1 );
gtk_table_attach( GTK_TABLE( table1 ),A500,4,5,0,1,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),0,0 );
A1000adj=GTK_ADJUSTMENT( gtk_adjustment_new( 0,-eqRange,eqRange,0.5,0,0 ) );
A1000=AddVScaler( A1000adj,NULL,-1 );
gtk_table_attach( GTK_TABLE( table1 ),A1000,5,6,0,1,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),0,0 );
A2000adj=GTK_ADJUSTMENT( gtk_adjustment_new( 0,-eqRange,eqRange,0.5,0,0 ) );
A2000=AddVScaler( A2000adj,NULL,-1 );
gtk_table_attach( GTK_TABLE( table1 ),A2000,6,7,0,1,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),0,0 );
A4000adj=GTK_ADJUSTMENT( gtk_adjustment_new( 0,-eqRange,eqRange,0.5,0,0 ) );
A4000=AddVScaler( A4000adj,NULL,-1 );
gtk_table_attach( GTK_TABLE( table1 ),A4000,7,8,0,1,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),0,0 );
A8000adj=GTK_ADJUSTMENT( gtk_adjustment_new( 0,-eqRange,eqRange,0.5,0,0 ) );
A8000=AddVScaler( A8000adj,NULL,-1 );
gtk_table_attach( GTK_TABLE( table1 ),A8000,8,9,0,1,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),0,0 );
A16000adj=GTK_ADJUSTMENT( gtk_adjustment_new( 0,-eqRange,eqRange,0.5,0,0 ) );
A16000=AddVScaler( A16000adj,NULL,-1 );
gtk_table_attach( GTK_TABLE( table1 ),A16000,9,10,0,1,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),0,0 );
gtk_table_attach( GTK_TABLE( table1 ),
AddLabel( "31.25",NULL ),
0,1,1,2,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 );
gtk_table_attach( GTK_TABLE( table1 ),
AddLabel( "62.50",NULL ),
1,2,1,2,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 );
gtk_table_attach( GTK_TABLE( table1 ),
AddLabel( "125",NULL ),
2,3,1,2,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 );
gtk_table_attach( GTK_TABLE( table1 ),
AddLabel( "250",NULL ),
3,4,1,2,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 );
gtk_table_attach( GTK_TABLE( table1 ),
AddLabel( "500",NULL ),
4,5,1,2,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 );
gtk_table_attach( GTK_TABLE( table1 ),
AddLabel( "1000",NULL ),
5,6,1,2,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 );
gtk_table_attach( GTK_TABLE( table1 ),
AddLabel( "2000",NULL ),
6,7,1,2,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 );
gtk_table_attach( GTK_TABLE( table1 ),
AddLabel( "4000",NULL ),
7,8,1,2,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 );
gtk_table_attach( GTK_TABLE( table1 ),
AddLabel( "8000",NULL ),
8,9,1,2,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 );
gtk_table_attach( GTK_TABLE( table1 ),
AddLabel( "16000",NULL ),
9,10,1,2,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 );
gtk_notebook_set_tab_label( GTK_NOTEBOOK( Notebook ),gtk_notebook_get_nth_page( GTK_NOTEBOOK( Notebook ),0 ),
AddLabel( MSGTR_EQU_Audio,NULL ) );
table1=gtk_table_new( 4,2,FALSE );
gtk_widget_set_name( table1,"table1" );
gtk_widget_show( table1 );
gtk_container_add( GTK_CONTAINER( Notebook ),table1 );
gtk_table_attach( GTK_TABLE( table1 ),
AddLabel( MSGTR_EQU_Contrast,NULL ),
0,1,0,1,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 );
gtk_table_attach( GTK_TABLE( table1 ),
AddLabel( MSGTR_EQU_Brightness,NULL ),
0,1,1,2,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 );
gtk_table_attach( GTK_TABLE( table1 ),
AddLabel( MSGTR_EQU_Hue,NULL ),
0,1,2,3,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 );
gtk_table_attach( GTK_TABLE( table1 ),
AddLabel( MSGTR_EQU_Saturation,NULL ),
0,1,3,4,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 );
VContrastadj=GTK_ADJUSTMENT( gtk_adjustment_new( 0,-100,100,1,0,0 ) );
VContrast=AddHScaler( VContrastadj,NULL,1 );
gtk_table_attach( GTK_TABLE( table1 ),VContrast,1,2,0,1,(GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 );
gtk_widget_set_usize( VContrast,-1,45 );
VBrightnessadj=GTK_ADJUSTMENT( gtk_adjustment_new( 0,-100,100,1,0,0 ) );
VBrightness=AddHScaler( VBrightnessadj,NULL,1 );
gtk_table_attach( GTK_TABLE( table1 ),VBrightness,1,2,1,2,(GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 );
gtk_widget_set_usize( VBrightness,-1,45 );
VHueadj=GTK_ADJUSTMENT( gtk_adjustment_new( 0,-100,100,1,0,0 ) );
VHue=AddHScaler( VHueadj,NULL,1 );
gtk_table_attach( GTK_TABLE( table1 ),VHue,1,2,2,3,(GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 );
gtk_widget_set_usize( VHue,-1,45 );
VSaturationadj=GTK_ADJUSTMENT( gtk_adjustment_new( 0,-100,100,1,0,0 ) );
VSaturation=AddHScaler( VSaturationadj,NULL,1 );
gtk_table_attach( GTK_TABLE( table1 ),VSaturation,1,2,3,4,(GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 );
gtk_widget_set_usize( VSaturation,-1,45 );
gtk_notebook_set_tab_label( GTK_NOTEBOOK( Notebook ),gtk_notebook_get_nth_page( GTK_NOTEBOOK( Notebook ),1 ),
AddLabel( MSGTR_EQU_Video,NULL ) );
AddHSeparator( vbox1 );
hbuttonbox1=AddHButtonBox( vbox1 );
gtk_button_box_set_layout( GTK_BUTTON_BOX( hbuttonbox1 ),GTK_BUTTONBOX_END );
gtk_button_box_set_spacing( GTK_BUTTON_BOX( hbuttonbox1 ),10 );
Config=AddButton( MSGTR_Config,hbuttonbox1 );
Clear=AddButton( MSGTR_Clear,hbuttonbox1 );
Ok=AddButton( MSGTR_Ok,hbuttonbox1 );
gtk_widget_add_accelerator( Ok,"clicked",accel_group,GDK_Escape,0,GTK_ACCEL_VISIBLE );
gtk_widget_add_accelerator( Ok,"clicked",accel_group,GDK_Return,0,GTK_ACCEL_VISIBLE );
gtk_signal_connect( GTK_OBJECT( Equalizer ),"destroy",GTK_SIGNAL_FUNC( WidgetDestroy ),&Equalizer );
gtk_signal_connect( GTK_OBJECT( Equalizer ),"focus_in_event",GTK_SIGNAL_FUNC( eqFocus ),(void *)2 );
gtk_signal_connect( GTK_OBJECT( ChannelsList ),"select_row",GTK_SIGNAL_FUNC( eqSelectChannelsListRow ),NULL );
gtk_signal_connect( GTK_OBJECT( A3125 ),"motion_notify_event",GTK_SIGNAL_FUNC( eqHScaleMotion ),(void*)0 );
gtk_signal_connect( GTK_OBJECT( A6250 ),"motion_notify_event",GTK_SIGNAL_FUNC( eqHScaleMotion ),(void*)1 );
gtk_signal_connect( GTK_OBJECT( A125 ),"motion_notify_event",GTK_SIGNAL_FUNC( eqHScaleMotion ),(void*)2 );
gtk_signal_connect( GTK_OBJECT( A250 ),"motion_notify_event",GTK_SIGNAL_FUNC( eqHScaleMotion ),(void*)3 );
gtk_signal_connect( GTK_OBJECT( A500 ),"motion_notify_event",GTK_SIGNAL_FUNC( eqHScaleMotion ),(void*)4 );
gtk_signal_connect( GTK_OBJECT( A1000 ),"motion_notify_event",GTK_SIGNAL_FUNC( eqHScaleMotion ),(void*)5 );
gtk_signal_connect( GTK_OBJECT( A2000 ),"motion_notify_event",GTK_SIGNAL_FUNC( eqHScaleMotion ),(void*)6 );
gtk_signal_connect( GTK_OBJECT( A4000 ),"motion_notify_event",GTK_SIGNAL_FUNC( eqHScaleMotion ),(void*)7 );
gtk_signal_connect( GTK_OBJECT( A8000 ),"motion_notify_event",GTK_SIGNAL_FUNC( eqHScaleMotion ),(void*)8 );
gtk_signal_connect( GTK_OBJECT( A16000 ),"motion_notify_event",GTK_SIGNAL_FUNC( eqHScaleMotion ),(void*)9 );
gtk_signal_connect( GTK_OBJECT( VContrast ),"motion_notify_event",GTK_SIGNAL_FUNC( eqVScaleMotion ),(void*)1 );
gtk_signal_connect( GTK_OBJECT( VBrightness ),"motion_notify_event",GTK_SIGNAL_FUNC( eqVScaleMotion ),(void*)2 );
gtk_signal_connect( GTK_OBJECT( VHue ),"motion_notify_event",GTK_SIGNAL_FUNC( eqVScaleMotion ),(void*)3 );
gtk_signal_connect( GTK_OBJECT( VSaturation ),"motion_notify_event",GTK_SIGNAL_FUNC( eqVScaleMotion ),(void *)4 );
gtk_signal_connect( GTK_OBJECT( Ok ),"clicked",GTK_SIGNAL_FUNC( eqButtonReleased ),(void *)0 );
gtk_signal_connect( GTK_OBJECT( Clear ),"clicked",GTK_SIGNAL_FUNC( eqButtonReleased ),(void *)1 );
gtk_signal_connect( GTK_OBJECT( Config ),"clicked",GTK_SIGNAL_FUNC( eqButtonReleased ),(void *)2 );
gtk_signal_connect( GTK_OBJECT( Notebook ),"switch_page",GTK_SIGNAL_FUNC( eqNotebook ),NULL );
gtk_window_add_accel_group( GTK_WINDOW( Equalizer ),accel_group );
return Equalizer;
}
GtkWidget *
module_dialog_new (Gimp *gimp)
{
GtkWidget *shell;
GtkWidget *vbox;
GtkWidget *sw;
GtkWidget *view;
GtkWidget *image;
ModuleDialog *dialog;
GtkTreeSelection *sel;
GtkTreeIter iter;
GtkTreeViewColumn *col;
GtkCellRenderer *rend;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
dialog = g_slice_new0 (ModuleDialog);
dialog->gimp = gimp;
shell = gimp_dialog_new (_("Module Manager"),
"gimp-modules", NULL, 0,
gimp_standard_help_func, GIMP_HELP_MODULE_DIALOG,
GTK_STOCK_REFRESH, RESPONSE_REFRESH,
GTK_STOCK_CLOSE, GTK_STOCK_CLOSE,
NULL);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (shell),
GTK_RESPONSE_CLOSE,
RESPONSE_REFRESH,
-1);
g_signal_connect (shell, "response",
G_CALLBACK (dialog_response),
dialog);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (shell))),
vbox, TRUE, TRUE, 0);
gtk_widget_show (vbox);
dialog->hint = gimp_hint_box_new (_("You will have to restart GIMP "
"for the changes to take effect."));
gtk_box_pack_start (GTK_BOX (vbox), dialog->hint, FALSE, FALSE, 0);
if (gimp->write_modulerc)
gtk_widget_show (dialog->hint);
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
GTK_SHADOW_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0);
gtk_widget_set_size_request (sw, 124, 100);
gtk_widget_show (sw);
dialog->list = gtk_list_store_new (N_COLUMNS,
G_TYPE_STRING,
G_TYPE_BOOLEAN,
GIMP_TYPE_MODULE);
view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (dialog->list));
g_object_unref (dialog->list);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (view), FALSE);
g_list_foreach (gimp->module_db->modules, make_list_item, dialog);
rend = gtk_cell_renderer_toggle_new ();
g_signal_connect (rend, "toggled",
G_CALLBACK (dialog_enabled_toggled),
dialog);
col = gtk_tree_view_column_new ();
gtk_tree_view_column_pack_start (col, rend, FALSE);
gtk_tree_view_column_add_attribute (col, rend, "active", COLUMN_ENABLED);
gtk_tree_view_append_column (GTK_TREE_VIEW (view), col);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (view), 1,
_("Module"),
gtk_cell_renderer_text_new (),
"text", COLUMN_NAME,
NULL);
gtk_container_add (GTK_CONTAINER (sw), view);
gtk_widget_show (view);
dialog->table = gtk_table_new (2, N_INFOS, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (dialog->table), 6);
gtk_box_pack_start (GTK_BOX (vbox), dialog->table, FALSE, FALSE, 0);
gtk_widget_show (dialog->table);
dialog->error_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start (GTK_BOX (vbox), dialog->error_box, FALSE, FALSE, 0);
image = gtk_image_new_from_stock (GIMP_STOCK_WARNING, GTK_ICON_SIZE_BUTTON);
gtk_box_pack_start (GTK_BOX (dialog->error_box), image, FALSE, FALSE, 0);
gtk_widget_show (image);
dialog->error_label = gtk_label_new (NULL);
gtk_misc_set_alignment (GTK_MISC (dialog->error_label), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (dialog->error_box),
dialog->error_label, TRUE, TRUE, 0);
gtk_widget_show (dialog->error_label);
dialog_info_init (dialog, dialog->table);
dialog_info_update (gimp->module_db, dialog->selected, dialog);
sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (view));
g_signal_connect (sel, "changed",
G_CALLBACK (dialog_select_callback),
dialog);
if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (dialog->list), &iter))
gtk_tree_selection_select_iter (sel, &iter);
/* hook the GimpModuleDB signals so we can refresh the display
* appropriately.
*/
g_signal_connect (gimp->module_db, "add",
G_CALLBACK (dialog_info_add),
dialog);
g_signal_connect (gimp->module_db, "remove",
G_CALLBACK (dialog_info_remove),
dialog);
g_signal_connect (gimp->module_db, "module-modified",
G_CALLBACK (dialog_info_update),
dialog);
g_signal_connect (shell, "destroy",
G_CALLBACK (dialog_destroy_callback),
dialog);
return shell;
}
static void make_region_dialog(void)
{
int i, id;
regrow *r;
chan_info *cp;
GtkWidget *infobox, *labels, *labbox;
GtkWidget *sep1, *cww, *toppane, *tophbox, *plw, *formw;
region_dialog = snd_gtk_dialog_new();
SG_SIGNAL_CONNECT(region_dialog, "delete_event", region_browser_delete_callback, NULL);
gtk_window_set_title(GTK_WINDOW(region_dialog), _("Regions"));
sg_make_resizable(region_dialog);
gtk_container_set_border_width(GTK_CONTAINER(region_dialog), 10);
gtk_window_resize(GTK_WINDOW(region_dialog), 400, 500);
gtk_widget_realize(region_dialog);
help_button = gtk_button_new_from_stock(GTK_STOCK_HELP);
gtk_widget_set_name(help_button, "help_button");
dismiss_button = gtk_button_new_from_stock(GTK_STOCK_QUIT);
gtk_widget_set_name(dismiss_button, "quit_button");
insert_button = sg_button_new_from_stock_with_label(_("Insert"), GTK_STOCK_PASTE);
gtk_widget_set_name(insert_button, "doit_button");
mix_button = sg_button_new_from_stock_with_label(_("Mix"), GTK_STOCK_ADD);
gtk_widget_set_name(mix_button, "doit_again_button");
save_as_button = gtk_button_new_from_stock(GTK_STOCK_SAVE_AS);
gtk_widget_set_name(save_as_button, "reset_button");
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(region_dialog)->action_area), dismiss_button, true, true, 4);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(region_dialog)->action_area), insert_button, true, true, 4);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(region_dialog)->action_area), mix_button, true, true, 4);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(region_dialog)->action_area), save_as_button, true, true, 4);
gtk_box_pack_end(GTK_BOX(GTK_DIALOG(region_dialog)->action_area), help_button, true, true, 4);
SG_SIGNAL_CONNECT(insert_button, "clicked", region_insert_callback, NULL);
SG_SIGNAL_CONNECT(mix_button, "clicked", region_mix_callback, NULL);
SG_SIGNAL_CONNECT(help_button, "clicked", region_help_callback, NULL);
SG_SIGNAL_CONNECT(dismiss_button, "clicked", region_ok_callback, NULL);
SG_SIGNAL_CONNECT(save_as_button, "clicked", region_save_callback, NULL);
gtk_widget_show(insert_button);
gtk_widget_show(mix_button);
gtk_widget_show(help_button);
gtk_widget_show(dismiss_button);
gtk_widget_show(save_as_button);
region_grf = gtk_vpaned_new();
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(region_dialog)->vbox), region_grf, true, true, 0);
gtk_widget_show(region_grf);
toppane = gtk_hbox_new(false, 0);
gtk_paned_add1(GTK_PANED(region_grf), toppane);
gtk_widget_show(toppane);
formw = gtk_vbox_new(false, 0);
gtk_box_pack_start(GTK_BOX(toppane), formw, true, true, 4);
gtk_widget_show(formw);
sep1 = gtk_vseparator_new(); /* not hsep -- damned thing insists on drawing a line */
gtk_box_pack_start(GTK_BOX(formw), sep1, false, false, 2);
gtk_widget_show(sep1);
tophbox = gtk_hbox_new(false, 0);
gtk_box_pack_start(GTK_BOX(formw), tophbox, false, false, 4);
gtk_widget_show(tophbox);
plw = gtk_label_new(_("play"));
gtk_box_pack_start(GTK_BOX(tophbox), plw, false, false, 2);
gtk_widget_show(plw);
sep1 = gtk_vseparator_new();
gtk_box_pack_start(GTK_BOX(formw), sep1, false, false, 2);
gtk_widget_show(sep1);
region_list = gtk_vbox_new(false, 0);
cww = gtk_scrolled_window_new(NULL, NULL);
gtk_box_pack_start(GTK_BOX(formw), cww, true, true, 0);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(cww), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(cww), region_list);
gtk_widget_show(region_list);
gtk_widget_show(cww);
infobox = gtk_vbox_new(false, 0);
gtk_box_pack_start(GTK_BOX(toppane), infobox, false, false, 2);
gtk_widget_show(infobox);
region_rows = (regrow **)CALLOC(max_regions(ss), sizeof(regrow *));
region_rows_size = max_regions(ss);
for (i = 0; i < max_regions(ss); i++)
{
r = make_regrow(region_list, (void (*)())region_play_callback, (void (*)())region_focus_callback);
region_rows[i] = r;
r->pos = i;
}
update_region_browser(false);
/* in Gtk, apparently, labels are just the text, not the background (i.e. they're transparent) */
/* we need a button simply to get the background color, then a vbox to put four labels on the button */
/* but we get a button which flashes whenever the mouse comes near it and has "relief" */
/* if we turn off the relief, the colors go away */
/* all I want is an opaque label with a background color */
labels = gtk_button_new();
gtk_box_pack_start(GTK_BOX(infobox), labels, true, true, 2);
gtk_widget_show(labels);
gtk_widget_modify_bg(labels, GTK_STATE_NORMAL, ss->sgx->highlight_color);
SG_SIGNAL_CONNECT(labels, "enter_notify_event", region_labels_mouse_enter, NULL);
labbox = gtk_vbox_new(true, 0);
gtk_container_add(GTK_CONTAINER(labels), labbox);
gtk_widget_show(labbox);
gtk_widget_modify_bg(labbox, GTK_STATE_NORMAL, ss->sgx->highlight_color);
srate_text = gtk_label_new(_("srate:"));
sg_left_justify_label(srate_text);
gtk_box_pack_start(GTK_BOX(labbox), srate_text, false, false, 2);
gtk_widget_show(srate_text);
chans_text = gtk_label_new(_("chans:"));
sg_left_justify_label(chans_text);
gtk_box_pack_start(GTK_BOX(labbox), chans_text, false, false, 2);
gtk_widget_show(chans_text);
length_text = gtk_label_new(_("length:"));
sg_left_justify_label(length_text);
gtk_box_pack_start(GTK_BOX(labbox), length_text, false, false, 2);
gtk_widget_show(length_text);
maxamp_text = gtk_label_new(_("maxamp:"));
sg_left_justify_label(maxamp_text);
gtk_box_pack_start(GTK_BOX(labbox), maxamp_text, false, false, 2);
gtk_widget_show(maxamp_text);
edit_button = gtk_button_new_with_label(_("edit"));
SG_SIGNAL_CONNECT(edit_button, "clicked", region_edit_callback, NULL);
gtk_box_pack_start(GTK_BOX(infobox), edit_button, true, true, 2);
gtk_widget_show(edit_button);
gtk_widget_modify_bg(edit_button, GTK_STATE_NORMAL, ss->sgx->lighter_blue);
gtk_widget_modify_bg(edit_button, GTK_STATE_ACTIVE, ss->sgx->red);
print_button = gtk_button_new_with_label(_("print"));
SG_SIGNAL_CONNECT(print_button, "clicked", region_print_callback, NULL);
gtk_box_pack_start(GTK_BOX(infobox), print_button, true, true, 2);
gtk_widget_show(print_button);
gtk_widget_modify_bg(print_button, GTK_STATE_NORMAL, ss->sgx->lighter_blue);
gtk_widget_modify_bg(print_button, GTK_STATE_ACTIVE, ss->sgx->red);
unlist_button = gtk_button_new_with_label(_("unlist"));
SG_SIGNAL_CONNECT(unlist_button, "clicked", region_unlist_callback, NULL);
gtk_box_pack_start(GTK_BOX(infobox), unlist_button, true, true, 2);
gtk_widget_show(unlist_button);
gtk_widget_modify_bg(unlist_button, GTK_STATE_NORMAL, ss->sgx->lighter_blue);
gtk_widget_modify_bg(unlist_button, GTK_STATE_ACTIVE, ss->sgx->red);
gtk_widget_show(region_dialog);
id = region_list_position_to_id(0);
rsp = make_simple_channel_display(region_srate(id), region_len(id), WITH_ARROWS, region_graph_style(ss), region_grf, WITHOUT_EVENTS);
rsp->inuse = SOUND_REGION;
set_current_region(0);
cp = rsp->chans[0];
gtk_paned_set_position(GTK_PANED(region_grf), 220);
SG_SIGNAL_CONNECT(channel_graph(cp), "expose_event", region_resize_callback, cp);
SG_SIGNAL_CONNECT(channel_graph(cp), "configure_event", region_expose_callback, cp);
SG_SIGNAL_CONNECT(channel_up_arrow(cp), "button_press_event", region_up_arrow_callback, NULL);
SG_SIGNAL_CONNECT(channel_down_arrow(cp), "button_press_event", region_down_arrow_callback, NULL);
set_sensitive(channel_f(cp), false);
if (region_chans(region_list_position_to_id(0)) > 1) set_sensitive(channel_w(cp), true);
cp->chan = 0;
rsp->hdr = fixup_region_data(cp, 0, 0);
make_region_labels(rsp->hdr);
highlight_region();
region_update_graph(cp);
add_ss_watcher(SS_FILE_OPEN_WATCHER, reflect_file_in_region_browser, NULL);
set_dialog_widget(REGION_DIALOG, region_dialog);
}
/*
* Trace Capture Dialog Window
*
* +--------------------------------------------------------------------+
* | Dialog Window |
* | +-------------------------------+-------------------------------+ |
* | | Paned Window | +---------------------------+ | |
* | | +---------------------------+ | | Scroll window | | |
* | | | Hbox | | | +-----------------------+ | | |
* | | | Label Plugin Combo | | | | Event Tree | | | |
* | | +---------------------------+ | | | | | | |
* | | | | | | | | |
* | | | | +-----------------------+ | | |
* | | | +---------------------------+ | |
* | +-------------------------------+-------------------------------+ |
* +--------------------------------------------------------------------+
*/
static void tracing_dialog(struct shark_info *info, const char *tracing)
{
struct pevent *pevent;
GtkWidget *dialog;
GtkWidget *button;
GtkWidget *combo;
GtkWidget *label;
GtkWidget *entry;
GtkWidget *frame;
GtkWidget *vbox;
GtkWidget *scrollwin;
GtkWidget *table;
GtkWidget *table2;
GtkWidget *event_tree;
GtkWidget *viewport;
GtkWidget *textview;
GtkWidget *hbox;
GtkTextBuffer *buffer;
GtkTextIter start_iter;
GtkTextIter end_iter;
char **plugins;
int nr_plugins;
struct trace_capture cap;
const gchar *file;
const char *command;
const char *val;
GString *str;
gint result;
memset(&cap, 0, sizeof(cap));
cap.info = info;
plugins = tracecmd_local_plugins(tracing);
/* Skip latency plugins */
nr_plugins = trim_plugins(plugins);
if (!nr_plugins && plugins) {
tracecmd_free_list(plugins);
plugins = NULL;
}
/* Send parse warnings to status display */
trace_dialog_register_alt_warning(vpr_stat);
pevent = tracecmd_local_events(tracing);
trace_dialog_register_alt_warning(NULL);
cap.pevent = pevent;
if (!pevent && !nr_plugins) {
warning("No events or plugins found");
return;
}
dialog = gtk_dialog_new();
gtk_window_set_title(GTK_WINDOW(dialog), "Capture");
button = gtk_button_new_with_label("Run");
gtk_dialog_add_action_widget(GTK_DIALOG(dialog), button,
GTK_RESPONSE_ACCEPT);
gtk_widget_show(button);
cap.run_button = button;
gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_CLOSE,
GTK_RESPONSE_REJECT);
cap.main_dialog = dialog;
/* --- Top Level Hpaned --- */
table = gtk_table_new(4, 2, FALSE);
/* It is possible that no pevents exist. */
if (pevent) {
scrollwin = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwin),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_table_attach(GTK_TABLE(table), scrollwin, 0, 1, 1, 2,
GTK_FILL, GTK_FILL|GTK_EXPAND, 0, 0);
gtk_widget_show(scrollwin);
event_tree = trace_create_event_list_view(pevent, NULL,
cap.info->cap_all_events,
cap.info->cap_systems,
cap.info->cap_events);
gtk_container_add(GTK_CONTAINER(scrollwin), event_tree);
gtk_widget_show(event_tree);
cap.event_view = event_tree;
} else {
/* No events */
label = gtk_label_new("No events enabled on system");
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 1, 2,
GTK_FILL, GTK_EXPAND|GTK_FILL,
0, 10);
gtk_widget_show(label);
cap.event_view = NULL;
}
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), table, TRUE, TRUE, 0);
gtk_widget_show(table);
/*------------------ Frame Settings --------------------------- */
frame = gtk_frame_new("Settings");
gtk_table_attach(GTK_TABLE(table), frame, 0, 1, 0, 1,
GTK_FILL, 0, 0, 10);
gtk_widget_show(frame);
table2 = gtk_table_new(2, 3, FALSE);
gtk_container_add(GTK_CONTAINER(frame), table2);
gtk_widget_show(table2);
gtk_table_set_col_spacings(GTK_TABLE(table2), 5);
button = gtk_button_new_with_label("Save Settings");
gtk_table_attach_defaults(GTK_TABLE(table2), button, 0, 1, 0, 1);
gtk_widget_show(button);
g_signal_connect (button, "clicked",
G_CALLBACK (save_settings_clicked),
(gpointer)&cap);
button = gtk_button_new_with_label("Import Settings");
gtk_table_attach_defaults(GTK_TABLE(table2), button, 1, 2, 0, 1);
gtk_widget_show(button);
g_signal_connect (button, "clicked",
G_CALLBACK (import_settings_clicked),
(gpointer)&cap);
button = gtk_button_new_with_label("Export Settings");
gtk_table_attach_defaults(GTK_TABLE(table2), button, 2, 3, 0, 1);
gtk_widget_show(button);
g_signal_connect (button, "clicked",
G_CALLBACK (export_settings_clicked),
(gpointer)&cap);
if (cap.info->cap_settings_name)
set_settings(&cap);
label = gtk_label_new("Available Settings: ");
gtk_table_attach_defaults(GTK_TABLE(table2), label, 0, 1, 1, 2);
gtk_widget_show(label);
combo = trace_create_combo_box(NULL, NULL,
create_settings_model, NULL);
gtk_table_attach_defaults(GTK_TABLE(table2), combo, 1, 3, 1, 2);
cap.settings_combo = combo;
g_signal_connect (combo, "changed",
G_CALLBACK (settings_changed),
(gpointer)&cap);
/*------------------ Frame Settings --------------------------- */
frame = gtk_frame_new("Execute");
gtk_table_attach(GTK_TABLE(table), frame, 0, 1, 3, 4,
GTK_FILL, 0, 0, 10);
gtk_widget_show(frame);
table2 = gtk_table_new(3, 3, FALSE);
gtk_container_add(GTK_CONTAINER(frame), table2);
gtk_widget_show(table2);
label = gtk_label_new("Plugin: ");
gtk_table_attach_defaults(GTK_TABLE(table2), label, 0, 1, 0, 1);
gtk_widget_show(label);
combo = trace_create_combo_box(NULL, NULL, create_plugin_combo_model, plugins);
cap.plugin_combo = combo;
gtk_table_attach_defaults(GTK_TABLE(table2), combo, 1, 3, 0, 1);
if (cap.info->cap_plugin)
set_plugin(&cap);
label = gtk_label_new("Command:");
gtk_table_attach_defaults(GTK_TABLE(table2), label, 0, 1, 1, 2);
gtk_widget_show(label);
entry = gtk_entry_new();
gtk_table_attach_defaults(GTK_TABLE(table2), entry, 1, 3, 1, 2);
gtk_widget_show(entry);
cap.command_entry = entry;
if (cap.info->cap_command)
gtk_entry_set_text(GTK_ENTRY(entry), cap.info->cap_command);
label = gtk_label_new("Output file: ");
gtk_table_attach_defaults(GTK_TABLE(table2), label, 0, 1, 2, 3);
gtk_widget_show(label);
entry = gtk_entry_new();
gtk_table_attach_defaults(GTK_TABLE(table2), entry, 1, 2, 2, 3);
gtk_widget_show(entry);
if (cap.info->cap_file)
file = cap.info->cap_file;
else
file = default_output_file;
gtk_entry_set_text(GTK_ENTRY(entry), file);
cap.file_entry = entry;
button = gtk_button_new_with_label("Browse");
gtk_table_attach_defaults(GTK_TABLE(table2), button, 2, 3, 2, 3);
gtk_widget_show(button);
g_signal_connect (button, "clicked",
G_CALLBACK (file_clicked),
(gpointer)&cap);
/*------------------ Command Output ------------------ */
vbox = gtk_vbox_new(FALSE, 0);
gtk_table_attach_defaults(GTK_TABLE(table), vbox, 1, 2, 0, 4);
gtk_widget_show(vbox);
gtk_widget_set_size_request(GTK_WIDGET(vbox), 500, 0);
label = gtk_label_new("Output Display:");
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
gtk_widget_show(label);
scrollwin = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwin),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start(GTK_BOX(vbox), scrollwin, TRUE, TRUE, 0);
gtk_widget_show(scrollwin);
viewport = gtk_viewport_new(NULL, NULL);
gtk_widget_show(viewport);
gtk_container_add(GTK_CONTAINER(scrollwin), viewport);
textview = gtk_text_view_new();
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
gtk_container_add(GTK_CONTAINER(viewport), textview);
gtk_widget_show(textview);
cap.output_text = textview;
cap.output_buffer = buffer;
/* set the buffer from its previous setting */
if (info->cap_buffer_output)
gtk_text_buffer_set_text(buffer, info->cap_buffer_output,
strlen(info->cap_buffer_output));
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show(hbox);
label = gtk_label_new("Max # of characters in output display: ");
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
gtk_widget_show(label);
entry = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(hbox), entry, FALSE, FALSE, 0);
gtk_widget_show(entry);
cap.max_num_entry = entry;
if (!info->cap_max_buf_size)
info->cap_max_buf_size = DEFAULT_MAX_BUF_SIZE;
str = g_string_new("");
g_string_append_printf(str, "%d", info->cap_max_buf_size);
gtk_entry_set_text(GTK_ENTRY(entry), str->str);
g_string_free(str, TRUE);
g_signal_connect (entry, "insert-text",
G_CALLBACK (insert_text),
(gpointer)&cap);
gtk_widget_set_size_request(GTK_WIDGET(dialog),
DIALOG_WIDTH, DIALOG_HEIGHT);
gtk_widget_show(dialog);
cont:
result = gtk_dialog_run(GTK_DIALOG(dialog));
if (result == GTK_RESPONSE_ACCEPT) {
execute_button_clicked(&cap);
goto cont;
}
/* Make sure no capture is running */
end_capture(&cap);
/* Get the max buffer size */
val = gtk_entry_get_text(GTK_ENTRY(entry));
info->cap_max_buf_size = atoi(val);
gtk_text_buffer_get_start_iter(cap.output_buffer, &start_iter);
gtk_text_buffer_get_end_iter(cap.output_buffer, &end_iter);
g_free(info->cap_buffer_output);
info->cap_buffer_output = gtk_text_buffer_get_text(cap.output_buffer,
&start_iter,
&end_iter,
FALSE);
/* save the plugin and file to reuse if we come back */
update_plugin(&cap);
free(info->cap_file);
cap.info->cap_file = strdup(gtk_entry_get_text(GTK_ENTRY(cap.file_entry)));
free(info->cap_command);
command = gtk_entry_get_text(GTK_ENTRY(cap.command_entry));
if (command && strlen(command) && !is_just_ws(command))
cap.info->cap_command = strdup(command);
else
cap.info->cap_command = NULL;
update_events(&cap);
gtk_widget_destroy(dialog);
if (pevent)
pevent_free(pevent);
if (plugins)
tracecmd_free_list(plugins);
}
GtkWidget *
userlist_create (GtkWidget *box)
{
GtkWidget *sw, *treeview;
static const GtkTargetEntry dnd_dest_targets[] =
{
{"text/uri-list", 0, 1},
{"XCHAT_CHANVIEW", GTK_TARGET_SAME_APP, 75 }
};
static const GtkTargetEntry dnd_src_target[] =
{
{"XCHAT_USERLIST", GTK_TARGET_SAME_APP, 75 }
};
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
prefs.showhostname_in_userlist ?
GTK_POLICY_AUTOMATIC :
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (box), sw, TRUE, TRUE, 0);
gtk_widget_show (sw);
treeview = gtk_tree_view_new ();
gtk_widget_set_name (treeview, "xchat-userlist");
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), FALSE);
gtk_tree_selection_set_mode (gtk_tree_view_get_selection
(GTK_TREE_VIEW (treeview)),
GTK_SELECTION_MULTIPLE);
/* set up drops */
gtk_drag_dest_set (treeview, GTK_DEST_DEFAULT_ALL, dnd_dest_targets, 2,
GDK_ACTION_MOVE | GDK_ACTION_COPY | GDK_ACTION_LINK);
gtk_drag_source_set (treeview, GDK_BUTTON1_MASK, dnd_src_target, 1, GDK_ACTION_MOVE);
/* file DND (for DCC) */
g_signal_connect (G_OBJECT (treeview), "drag_motion",
G_CALLBACK (userlist_dnd_motion), treeview);
g_signal_connect (G_OBJECT (treeview), "drag_leave",
G_CALLBACK (userlist_dnd_leave), 0);
g_signal_connect (G_OBJECT (treeview), "drag_data_received",
G_CALLBACK (userlist_dnd_drop), treeview);
g_signal_connect (G_OBJECT (treeview), "button_press_event",
G_CALLBACK (userlist_click_cb), 0);
g_signal_connect (G_OBJECT (treeview), "key_press_event",
G_CALLBACK (userlist_key_cb), 0);
/* tree/chanview DND */
g_signal_connect (G_OBJECT (treeview), "drag_begin",
G_CALLBACK (mg_drag_begin_cb), NULL);
g_signal_connect (G_OBJECT (treeview), "drag_drop",
G_CALLBACK (mg_drag_drop_cb), NULL);
g_signal_connect (G_OBJECT (treeview), "drag_motion",
G_CALLBACK (mg_drag_motion_cb), NULL);
g_signal_connect (G_OBJECT (treeview), "drag_end",
G_CALLBACK (mg_drag_end_cb), NULL);
userlist_add_columns (GTK_TREE_VIEW (treeview));
gtk_container_add (GTK_CONTAINER (sw), treeview);
gtk_widget_show (treeview);
return treeview;
}
bool wxListBox::Create( wxWindow *parent, wxWindowID id,
const wxPoint &pos, const wxSize &size,
int n, const wxString choices[],
long style, const wxValidator& validator,
const wxString &name )
{
if (!PreCreation( parent, pos, size ) ||
!CreateBase( parent, id, pos, size, style, validator, name ))
{
wxFAIL_MSG( wxT("wxListBox creation failed") );
return false;
}
m_widget = gtk_scrolled_window_new( NULL, NULL );
g_object_ref(m_widget);
if (style & wxLB_ALWAYS_SB)
{
gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(m_widget),
GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS );
}
else
{
gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(m_widget),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
}
GTKScrolledWindowSetBorder(m_widget, style);
m_treeview = GTK_TREE_VIEW( gtk_tree_view_new( ) );
//wxListBox doesn't have a header :)
//NB: If enabled SetFirstItem doesn't work correctly
gtk_tree_view_set_headers_visible(m_treeview, FALSE);
#if wxUSE_CHECKLISTBOX
if(m_hasCheckBoxes)
((wxCheckListBox*)this)->DoCreateCheckList();
#endif // wxUSE_CHECKLISTBOX
// Create the data column
gtk_tree_view_insert_column_with_attributes(m_treeview, -1, "",
gtk_cell_renderer_text_new(),
"text",
WXLISTBOX_DATACOLUMN, NULL);
// Now create+set the model (GtkListStore) - first argument # of columns
#if wxUSE_CHECKLISTBOX
if(m_hasCheckBoxes)
m_liststore = gtk_list_store_new(2, G_TYPE_BOOLEAN,
GTK_TYPE_TREE_ENTRY);
else
#endif
m_liststore = gtk_list_store_new(1, GTK_TYPE_TREE_ENTRY);
gtk_tree_view_set_model(m_treeview, GTK_TREE_MODEL(m_liststore));
g_object_unref (m_liststore); //free on treeview destruction
// Disable the pop-up textctrl that enables searching - note that
// the docs specify that even if this disabled (which we are doing)
// the user can still have it through the start-interactive-search
// key binding...either way we want to provide a searchequal callback
// NB: If this is enabled a doubleclick event (activate) gets sent
// on a successful search
gtk_tree_view_set_search_column(m_treeview, WXLISTBOX_DATACOLUMN);
gtk_tree_view_set_search_equal_func(m_treeview,
(GtkTreeViewSearchEqualFunc) gtk_listbox_searchequal_callback,
this,
NULL);
gtk_tree_view_set_enable_search(m_treeview, FALSE);
GtkSelectionMode mode;
// GTK_SELECTION_EXTENDED is a deprecated synonym for GTK_SELECTION_MULTIPLE
if ( style & (wxLB_MULTIPLE | wxLB_EXTENDED) )
{
mode = GTK_SELECTION_MULTIPLE;
}
else // no multi-selection flags specified
{
m_windowStyle |= wxLB_SINGLE;
mode = GTK_SELECTION_SINGLE;
}
GtkTreeSelection* selection = gtk_tree_view_get_selection( m_treeview );
gtk_tree_selection_set_mode( selection, mode );
// Handle sortable stuff
if(HasFlag(wxLB_SORT))
{
// Setup sorting in ascending (wx) order
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(m_liststore),
WXLISTBOX_DATACOLUMN,
GTK_SORT_ASCENDING);
// Set the sort callback
gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(m_liststore),
WXLISTBOX_DATACOLUMN,
(GtkTreeIterCompareFunc) gtk_listbox_sort_callback,
this, //userdata
NULL //"destroy notifier"
);
}
gtk_container_add (GTK_CONTAINER (m_widget), GTK_WIDGET(m_treeview) );
gtk_widget_show( GTK_WIDGET(m_treeview) );
m_focusWidget = GTK_WIDGET(m_treeview);
Append(n, choices); // insert initial items
// generate dclick events
g_signal_connect_after(m_treeview, "row-activated",
G_CALLBACK(gtk_listbox_row_activated_callback), this);
// for intercepting dclick generation by <ENTER>
g_signal_connect (m_treeview, "key_press_event",
G_CALLBACK (gtk_listbox_key_press_callback),
this);
m_parent->DoAddChild( this );
PostCreation(size);
SetInitialSize(size); // need this too because this is a wxControlWithItems
g_signal_connect_after (selection, "changed",
G_CALLBACK (gtk_listitem_changed_callback), this);
return true;
}
void l_uosamortbu(int innom,int podr,const char *hzt,const char *hna,GtkWidget *wpredok)
{
class l_uosamortbu_data data;
char bros[512];
char strsql[512];
SQL_str row;
class SQLCURSOR cur;
data.innom=innom;
data.podr=podr;
data.hzt.new_plus(hzt);
data.hna.new_plus(hna);
data.naim.plus("");
iceb_u_poltekdat(&data.dr,&data.mr,&data.gr);
data.dr=1;
sprintf(strsql,"bsizbu%d.lst",getpid());
data.imafprot.new_plus(strsql);
unlink(data.imafprot.ravno());
sprintf(strsql,"bsizbua%d.lst",getpid());
data.imafprot_am.new_plus(strsql);
unlink(data.imafprot_am.ravno());
/*узнаём наименование*/
sprintf(strsql,"select naim from Uosin where innom=%d",innom);
if(iceb_sql_readkey(strsql,&row,&cur,wpredok) == 1)
data.naim.new_plus(row[0]);
data.window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_position( GTK_WINDOW(data.window),ICEB_POS_CENTER);
gtk_window_set_modal(GTK_WINDOW(data.window),TRUE);
sprintf(bros,"%s %s",name_system,gettext("Амортизационные отчисления налогового учёта"));
gtk_window_set_title (GTK_WINDOW (data.window),bros);
gtk_container_set_border_width (GTK_CONTAINER (data.window), 5);
gtk_signal_connect(GTK_OBJECT(data.window),"delete_event",GTK_SIGNAL_FUNC(gtk_widget_destroy),NULL);
gtk_signal_connect(GTK_OBJECT(data.window),"destroy",GTK_SIGNAL_FUNC(gtk_main_quit),NULL);
if(wpredok != NULL)
{
gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR_GDITE));
//Удерживать окно над породившем его окном всегда
gtk_window_set_transient_for(GTK_WINDOW(data.window),GTK_WINDOW(wpredok));
//Закрыть окно если окно предок удалено
gtk_window_set_destroy_with_parent(GTK_WINDOW(data.window),TRUE);
}
gtk_signal_connect_after(GTK_OBJECT(data.window),"key_press_event",GTK_SIGNAL_FUNC(l_uosamortbu_key_press),&data);
gtk_signal_connect_after(GTK_OBJECT(data.window),"key_release_event",GTK_SIGNAL_FUNC(iceb_key_release),&data.kl_shift);
GtkWidget *hbox = gtk_hbox_new (FALSE, 1);
gtk_container_add (GTK_CONTAINER (data.window), hbox);
GtkWidget *vbox1 = gtk_vbox_new (FALSE, 1);
GtkWidget *vbox2 = gtk_vbox_new (FALSE, 1);
gtk_box_pack_start (GTK_BOX (hbox), vbox1, FALSE, FALSE, 1);
gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 1);
gtk_widget_show(hbox);
class iceb_u_str zagol;
zagol.plus(gettext("Амортизационные отчисления бух.учёта"));
zagol.ps_plus(gettext("Инвентарный номер"));
zagol.plus(":");
zagol.plus(data.innom);
zagol.plus("/");
zagol.plus(data.naim.ravno());
data.label_kolstr=gtk_label_new(zagol.ravno_toutf());
gtk_box_pack_start (GTK_BOX (vbox2),data.label_kolstr,FALSE, FALSE, 1);
gtk_widget_show(vbox1);
gtk_widget_show(vbox2);
data.sw = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_set_usize(GTK_WIDGET(data.sw),-1,200);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (data.sw),GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (data.sw),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
gtk_box_pack_start(GTK_BOX (vbox2), data.sw, TRUE, TRUE, 1);
data.label_bsiz=gtk_label_new("");
gtk_box_pack_start(GTK_BOX (vbox2), data.label_bsiz, FALSE, FALSE, 1);
PangoFontDescription *font_pango=pango_font_description_from_string(shrift_ravnohir.ravno());
gtk_widget_modify_font(GTK_WIDGET(data.label_bsiz),font_pango);
pango_font_description_free(font_pango);
gtk_widget_show(data.label_bsiz);
//Кнопки
GtkTooltips *tooltips[KOL_F_KL];
sprintf(bros,"F2 %s",gettext("Ввести"));
data.knopka[FK2]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK2],TRUE,TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK2]), "clicked",GTK_SIGNAL_FUNC(l_uosamortbu_knopka),&data);
tooltips[FK2]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK2],data.knopka[FK2],gettext("Ввод новой записи"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK2]),(gpointer)FK2);
gtk_widget_show(data.knopka[FK2]);
sprintf(bros,"%sF2 %s",RFK,gettext("Корректировать"));
data.knopka[SFK2]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[SFK2],TRUE,TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[SFK2]), "clicked",GTK_SIGNAL_FUNC(l_uosamortbu_knopka),&data);
tooltips[SFK2]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[SFK2],data.knopka[SFK2],gettext("Корректировка выбранной записи"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[SFK2]),(gpointer)SFK2);
gtk_widget_show(data.knopka[SFK2]);
sprintf(bros,"F3 %s",gettext("Удалить"));
data.knopka[FK3]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK3],TRUE,TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK3]), "clicked",GTK_SIGNAL_FUNC(l_uosamortbu_knopka),&data);
tooltips[FK3]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK3],data.knopka[FK3],gettext("Удалить выбранную запись"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK3]),(gpointer)FK3);
gtk_widget_show(data.knopka[FK3]);
sprintf(bros,"F4 %s",gettext("Расчёт"));
data.knopka[FK4]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK4],TRUE,TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK4]), "clicked",GTK_SIGNAL_FUNC(l_uosamortbu_knopka),&data);
tooltips[FK4]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK4],data.knopka[FK4],gettext("Расчёт амортизации"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK4]),(gpointer)FK4);
gtk_widget_show(data.knopka[FK4]);
sprintf(bros,"F5 %s",gettext("Печать"));
data.knopka[FK5]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK5],TRUE,TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK5]), "clicked",GTK_SIGNAL_FUNC(l_uosamortbu_knopka),&data);
tooltips[FK5]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK5],data.knopka[FK5],gettext("Распечатка записей"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK5]),(gpointer)FK5);
gtk_widget_show(data.knopka[FK5]);
sprintf(bros,"F6 %s",gettext("Документы"));
data.knopka[FK6]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK6],TRUE,TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK6]), "clicked",GTK_SIGNAL_FUNC(l_uosamortbu_knopka),&data);
tooltips[FK6]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK6],data.knopka[FK6],gettext("Получить список документов"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK6]),(gpointer)FK6);
gtk_widget_show(data.knopka[FK6]);
sprintf(bros,"F7 %s",gettext("Протокол"));
data.knopka[FK7]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK7],TRUE,TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK7]), "clicked",GTK_SIGNAL_FUNC(l_uosamortbu_knopka),&data);
tooltips[FK7]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK7],data.knopka[FK7],gettext("Просмотр протокола определения балансовой стоимости"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK7]),(gpointer)FK7);
gtk_widget_show(data.knopka[FK7]);
sprintf(bros,"F8 %s",gettext("Смена даты"));
data.knopka[FK8]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK8],TRUE,TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK8]), "clicked",GTK_SIGNAL_FUNC(l_uosamortbu_knopka),&data);
tooltips[FK8]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK8],data.knopka[FK8],gettext("Сменить дату на которую рассчитать остаточную стоимость"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK8]),(gpointer)FK8);
gtk_widget_show(data.knopka[FK8]);
sprintf(bros,"F10 %s",gettext("Выход"));
data.knopka[FK10]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1),data.knopka[FK10],TRUE,TRUE, 0);
tooltips[FK10]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK10],data.knopka[FK10],gettext("Завершение работы в этом окне"),NULL);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK10]), "clicked",GTK_SIGNAL_FUNC(l_uosamortbu_knopka),&data);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK10]),(gpointer)FK10);
gtk_widget_show(data.knopka[FK10]);
gtk_widget_realize(data.window);
gdk_window_set_cursor(data.window->window,gdk_cursor_new(ICEB_CURSOR));
gtk_widget_grab_focus(data.knopka[FK10]);
l_uosamortbu_create_list(&data);
gtk_widget_show(data.window);
gtk_window_maximize(GTK_WINDOW(data.window));
gtk_main();
unlink(data.imafprot.ravno());
unlink(data.imafprot_am.ravno());
if(wpredok != NULL)
gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR));
}
GtkWidget *
do_list_store (GtkWidget *do_widget)
{
if (!window)
{
GtkWidget *vbox;
GtkWidget *label;
GtkWidget *sw;
GtkWidget *treeview;
/* create window, etc */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (do_widget));
gtk_window_set_title (GTK_WINDOW (window), "List Store");
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);
gtk_container_set_border_width (GTK_CONTAINER (window), 8);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
gtk_container_add (GTK_CONTAINER (window), vbox);
label = gtk_label_new ("This is the bug list (note: not based on real data, it would be nice to have a nice ODBC interface to bugzilla or so, though).");
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
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 (vbox), sw, TRUE, TRUE, 0);
/* create tree model */
model = create_model ();
/* create tree view */
treeview = gtk_tree_view_new_with_model (model);
gtk_tree_view_set_search_column (GTK_TREE_VIEW (treeview),
COLUMN_DESCRIPTION);
g_object_unref (model);
gtk_container_add (GTK_CONTAINER (sw), treeview);
/* add columns to the tree view */
add_columns (GTK_TREE_VIEW (treeview));
/* finish & show */
gtk_window_set_default_size (GTK_WINDOW (window), 280, 250);
g_signal_connect (window, "delete-event",
G_CALLBACK (window_closed), NULL);
}
if (!gtk_widget_get_visible (window))
{
gtk_widget_show_all (window);
if (timeout == 0) {
/* FIXME this should use the animation-duration instead */
timeout = g_timeout_add (80, spinner_timeout, NULL);
}
}
else
{
gtk_widget_destroy (window);
window = NULL;
if (timeout != 0)
{
g_source_remove (timeout);
timeout = 0;
}
}
return window;
}
/** \brief Show details about a satellite pass.
* \param parent The parent widget.
* \param satname The name of the satellite.
* \param qth Pointer to the QTH data.
* \param pass The pass info.
* \param toplevel The toplevel window or NULL.
*
* This function creates a dialog window containing a notebook with three pages:
* 1. A list showing the details of a pass
* 2. Polar plot of the pass
* 3. Az/El plot of the pass
*
* Reference to the parent widget is needed to acquire the correct top-level
* window, otherwise simply using the main window would bring that to front
* covering any possible module windows. This would be unfortunate in the case
* of fullscreen modules.
*
*/
void show_pass (const gchar *satname, qth_t *qth, pass_t *pass, GtkWidget *toplevel)
{
GtkWidget *dialog; /* the dialogue window */
GtkWidget *notebook; /* the notebook widet */
GtkWidget *list;
GtkListStore *liststore;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkTreeIter item;
GtkWidget *swin; /* scrolled window containing the list view */
GtkWidget *polar; /* polar plot */
GtkWidget *azel; /* Az/El plot */
GtkWidget *hbox; /* hbox used in tab headers */
GtkWidget *image; /* icon used in tab header */
gchar *title;
guint flags;
guint i, num;
pass_detail_t *detail;
gchar *buff;
gint retcode;
gdouble doppler;
gdouble delay;
gdouble loss;
obs_astro_t astro;
gdouble ra,dec;
/* get columns flags */
flags = sat_cfg_get_int (SAT_CFG_INT_PRED_SINGLE_COL);
/* create list */
list = gtk_tree_view_new ();
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (list), TRUE);
for (i = 0; i < SINGLE_PASS_COL_NUMBER; i++) {
renderer = gtk_cell_renderer_text_new ();
g_object_set (G_OBJECT (renderer), "xalign", SINGLE_PASS_COL_XALIGN[i], NULL);
column = gtk_tree_view_column_new_with_attributes (_(SINGLE_PASS_COL_TITLE[i]),
renderer,
"text", i,
NULL);
gtk_tree_view_insert_column (GTK_TREE_VIEW (list), column, -1);
/* only aligns the headers */
gtk_tree_view_column_set_alignment (column, 0.5);
/* set cell data function; allows to format data before rendering */
check_and_set_single_cell_renderer (column, renderer, i);
/* hide columns that have not been specified */
if (!(flags & (1 << i))) {
gtk_tree_view_column_set_visible (column, FALSE);
}
}
/* create and fill model */
liststore = gtk_list_store_new (SINGLE_PASS_COL_NUMBER,
G_TYPE_DOUBLE, // time
G_TYPE_DOUBLE, // az
G_TYPE_DOUBLE, // el
G_TYPE_DOUBLE, // ra
G_TYPE_DOUBLE, // dec
G_TYPE_DOUBLE, // range
G_TYPE_DOUBLE, // range rate
G_TYPE_DOUBLE, // lat
G_TYPE_DOUBLE, // lon
G_TYPE_STRING, // SSP
G_TYPE_DOUBLE, // footprint
G_TYPE_DOUBLE, // alt
G_TYPE_DOUBLE, // vel
G_TYPE_DOUBLE, // doppler
G_TYPE_DOUBLE, // loss
G_TYPE_DOUBLE, // delay
G_TYPE_DOUBLE, // ma
G_TYPE_DOUBLE, // phase
G_TYPE_STRING); // visibility
/* add rows to list store */
num = g_slist_length (pass->details);
for (i = 0; i < num; i++) {
detail = PASS_DETAIL(g_slist_nth_data (pass->details, i));
gtk_list_store_append (liststore, &item);
gtk_list_store_set (liststore, &item,
SINGLE_PASS_COL_TIME, detail->time,
SINGLE_PASS_COL_AZ, detail->az,
SINGLE_PASS_COL_EL, detail->el,
SINGLE_PASS_COL_RANGE, detail->range,
SINGLE_PASS_COL_RANGE_RATE, detail->range_rate,
SINGLE_PASS_COL_LAT, detail->lat,
SINGLE_PASS_COL_LON, detail->lon,
SINGLE_PASS_COL_FOOTPRINT, detail->footprint,
SINGLE_PASS_COL_ALT, detail->alt,
SINGLE_PASS_COL_VEL, detail->velo,
SINGLE_PASS_COL_MA, detail->ma,
SINGLE_PASS_COL_PHASE, detail->phase,
-1);
/* SINGLE_PASS_COL_RA */
/* SINGLE_PASS_COL_DEC */
if (flags & (SINGLE_PASS_FLAG_RA | SINGLE_PASS_FLAG_DEC)) {
Calc_RADec (detail->time, detail->az, detail->el, qth, &astro);
ra = Degrees(astro.ra);
dec = Degrees(astro.dec);
gtk_list_store_set (liststore, &item,
SINGLE_PASS_COL_RA, ra,
SINGLE_PASS_COL_DEC, dec,
-1);
}
/* SINGLE_PASS_COL_SSP */
if (flags & SINGLE_PASS_FLAG_SSP) {
buff = g_try_malloc (7);
retcode = longlat2locator (detail->lon, detail->lat, buff, 3);
if (retcode == RIG_OK) {
buff[6] = '\0';
gtk_list_store_set (liststore, &item,
SINGLE_PASS_COL_SSP, buff,
-1);
}
g_free (buff);
}
/* SINGLE_PASS_COL_DOPPLER */
if (flags & SINGLE_PASS_FLAG_DOPPLER) {
doppler = -100.0e06 * (detail->range_rate / 299792.4580); // Hz
gtk_list_store_set (liststore, &item,
SINGLE_PASS_COL_DOPPLER, doppler,
-1);
}
/* SINGLE_PASS_COL_LOSS */
if (flags & SINGLE_PASS_FLAG_LOSS) {
loss = 72.4 + 20.0*log10(detail->range); // dB
gtk_list_store_set (liststore, &item,
SINGLE_PASS_COL_LOSS, loss,
-1);
}
/* SINGLE_PASS_COL_DELAY */
if (flags & SINGLE_PASS_FLAG_DELAY) {
delay = detail->range / 299.7924580; // msec
gtk_list_store_set (liststore, &item,
SINGLE_PASS_COL_DELAY, delay,
-1);
}
/* SINGLE_PASS_COL_VIS */
if (flags & SINGLE_PASS_FLAG_VIS) {
buff = g_strdup_printf ("%c", vis_to_chr (detail->vis));
gtk_list_store_set (liststore, &item,
SINGLE_PASS_COL_VIS, buff,
-1);
g_free (buff);
}
}
/* connect model to tree view */
gtk_tree_view_set_model (GTK_TREE_VIEW (list), GTK_TREE_MODEL (liststore));
g_object_unref (liststore);
/* scrolled window */
swin = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swin),
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER (swin), list);
/* create notebook and add pages */
notebook = gtk_notebook_new ();
image = gtk_image_new_from_stock (GTK_STOCK_JUSTIFY_FILL, GTK_ICON_SIZE_MENU);
hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (hbox), gtk_label_new (_("Data")), FALSE, TRUE, 5);
gtk_widget_show_all (hbox);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), swin, hbox);
/* polar plot */
polar = gtk_polar_plot_new (qth, pass);
buff = icon_file_name ("gpredict-polar-small.png");
image = gtk_image_new_from_file (buff);
g_free (buff);
hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (hbox), gtk_label_new (_("Polar")), FALSE, TRUE, 5);
gtk_widget_show_all (hbox);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), polar, hbox);
/* Az/El plot */
azel = gtk_azel_plot_new (qth, pass);
buff = icon_file_name ("gpredict-azel-small.png");
image = gtk_image_new_from_file (buff);
g_free (buff);
hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (hbox), gtk_label_new (_("Az/El")), FALSE, TRUE, 5);
gtk_widget_show_all (hbox);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), azel, hbox);
/* create dialog */
title = g_strdup_printf (_("Pass details for %s (orbit %d)"),
satname, pass->orbit);
/* use NULL as parent to avoid conflict when using undocked windows
as parents.
*/
dialog = gtk_dialog_new_with_buttons (title,
GTK_WINDOW (toplevel),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_PRINT, RESPONSE_PRINT,
GTK_STOCK_SAVE, RESPONSE_SAVE,
GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
NULL);
g_free (title);
/* Make Close button default */
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_CLOSE);
/* window icon */
buff = icon_file_name ("gpredict-sat-list.png");
gtk_window_set_icon_from_file (GTK_WINDOW (dialog), buff, NULL);
g_free (buff);
/* allow interaction with other windows */
gtk_window_set_modal (GTK_WINDOW (dialog), FALSE);
g_object_set_data (G_OBJECT (dialog), "sat", (gpointer) satname);
g_object_set_data (G_OBJECT (dialog), "qth", qth);
g_object_set_data (G_OBJECT (dialog), "pass", pass);
g_signal_connect (dialog, "response",
G_CALLBACK (single_pass_response), NULL);
g_signal_connect (dialog, "destroy",
G_CALLBACK (single_pass_dialog_destroy), NULL);
g_signal_connect (dialog, "delete_event",
G_CALLBACK (single_pass_dialog_delete), NULL);
gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area(GTK_DIALOG(dialog))), notebook);
gtk_window_set_default_size (GTK_WINDOW (dialog), -1, 300);
gtk_widget_show_all (dialog);
}
static void
button_clicked (GtkButton *button, GNCSearchAccount *fi)
{
GNCSearchAccountPrivate *priv;
GtkDialog *dialog;
GtkWidget *account_tree;
GtkWidget *accounts_scroller;
GtkWidget *label;
char *desc;
GtkTreeSelection *selection;
/* Create the account tree */
account_tree = GTK_WIDGET(gnc_tree_view_account_new (FALSE));
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW(account_tree), FALSE);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(account_tree));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);
/* Select the currently-selected accounts */
priv = _PRIVATE(fi);
if (priv->selected_accounts)
gnc_tree_view_account_set_selected_accounts (GNC_TREE_VIEW_ACCOUNT(account_tree),
priv->selected_accounts, FALSE);
/* Create the account scroller and put the tree in it */
accounts_scroller = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(accounts_scroller),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(accounts_scroller), account_tree);
gtk_widget_set_size_request(GTK_WIDGET(accounts_scroller), 300, 300);
/* Create the label */
label = gtk_label_new (_("Select Accounts to Match"));
/* Create the dialog */
dialog =
GTK_DIALOG(gtk_dialog_new_with_buttons(_("Select the Accounts to Compare"),
NULL,
0,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL));
/* Put the dialog together */
gtk_box_pack_start ((GtkBox *) gtk_dialog_get_content_area (dialog), label,
FALSE, FALSE, 3);
gtk_box_pack_start ((GtkBox *) gtk_dialog_get_content_area (dialog), accounts_scroller,
TRUE, TRUE, 3);
gtk_widget_show_all (GTK_WIDGET (dialog));
/* Now run the dialog */
if (gtk_dialog_run (dialog) == GTK_RESPONSE_OK)
{
if (priv->selected_accounts)
g_list_free (priv->selected_accounts);
priv->selected_accounts =
gnc_tree_view_account_get_selected_accounts (GNC_TREE_VIEW_ACCOUNT (account_tree));
desc = describe_button (fi);
gtk_label_set_text (GTK_LABEL (gtk_bin_get_child (GTK_BIN (button))), desc);
}
gtk_widget_destroy (GTK_WIDGET (dialog));
}
