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