GtkWidget * create_URL( void )
{
GtkWidget * vbox1;
GtkWidget * hbox1;
GtkWidget * hbuttonbox1;
GtkWidget * Ok;
GtkWidget * Cancel;
GtkAccelGroup * accel_group;
accel_group=gtk_accel_group_new();
URL=gtk_window_new( GTK_WINDOW_TOPLEVEL );
gtk_widget_set_name( URL,"URL" );
gtk_object_set_data( GTK_OBJECT( URL ),"URL",URL );
gtk_widget_set_usize( URL,384,70 );
GTK_WIDGET_SET_FLAGS( URL,GTK_CAN_DEFAULT );
gtk_window_set_title( GTK_WINDOW( URL ),MSGTR_Network );
gtk_window_set_position( GTK_WINDOW( URL ),GTK_WIN_POS_CENTER );
gtk_window_set_policy( GTK_WINDOW( URL ),TRUE,TRUE,FALSE );
gtk_window_set_wmclass( GTK_WINDOW( URL ),"Network","MPlayer" );
gtk_widget_realize( URL );
gtkAddIcon( URL );
vbox1=AddVBox( AddDialogFrame( URL ),0 );
hbox1=AddHBox( vbox1,1 );
AddLabel( "URL: ",hbox1 );
URLCombo=AddComboBox( hbox1 );
/*
gtk_combo_new();
gtk_widget_set_name( URLCombo,"URLCombo" );
gtk_widget_show( URLCombo );
gtk_box_pack_start( GTK_BOX( hbox1 ),URLCombo,TRUE,TRUE,0 );
*/
URLEntry=GTK_COMBO( URLCombo )->entry;
gtk_widget_set_name( URLEntry,"URLEntry" );
gtk_widget_show( URLEntry );
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 );
Ok=AddButton( MSGTR_Ok,hbuttonbox1 );
Cancel=AddButton( MSGTR_Cancel,hbuttonbox1 );
gtk_widget_add_accelerator( Ok,"clicked",accel_group,GDK_Return,0,GTK_ACCEL_VISIBLE );
gtk_widget_add_accelerator( Cancel,"clicked",accel_group,GDK_Escape,0,GTK_ACCEL_VISIBLE );
gtk_signal_connect( GTK_OBJECT( URL ),"destroy",GTK_SIGNAL_FUNC( WidgetDestroy ),&URL );
gtk_signal_connect( GTK_OBJECT( Ok ),"clicked",GTK_SIGNAL_FUNC( on_Button_pressed ),(void *)1 );
gtk_signal_connect( GTK_OBJECT( Cancel ),"clicked",GTK_SIGNAL_FUNC( on_Button_pressed ),NULL );
gtk_widget_grab_focus( URLEntry );
gtk_window_add_accel_group( GTK_WINDOW( URL ),accel_group );
return URL;
}
static GtkWidget *CreateURLDialog(void)
{
GtkWidget *vbox1;
GtkWidget *hbox1;
GtkWidget *hbuttonbox1;
GtkWidget *Ok;
GtkWidget *Cancel;
GtkAccelGroup *accel_group;
GdkGeometry geometry;
accel_group = gtk_accel_group_new();
URLDialog = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_widget_set_usize(URLDialog, 384, -1);
gtk_window_set_title(GTK_WINDOW(URLDialog), MSGTR_Network);
gtk_window_set_position(GTK_WINDOW(URLDialog), GTK_WIN_POS_CENTER);
gtk_window_set_wmclass(GTK_WINDOW(URLDialog), "Network", MPlayer);
gtk_widget_realize(URLDialog);
gtkAddIcon(URLDialog);
vbox1 = gtkAddVBox(gtkAddDialogFrame(URLDialog), 0);
hbox1 = gtkAddHBox(vbox1, 1);
gtkAddLabel("URL: ", hbox1);
urlCombo = gtkAddCombo(hbox1);
/*
* gtk_combo_new();
* gtk_widget_show( urlCombo );
* gtk_box_pack_start( GTK_BOX( hbox1 ),urlCombo,TRUE,TRUE,0 );
*/
urlEntry = GTK_COMBO(urlCombo)->entry;
gtk_widget_show(urlEntry);
gtkAddHSeparator(vbox1);
hbuttonbox1 = gtkAddHButtonBox(vbox1);
gtk_button_box_set_layout(GTK_BUTTON_BOX(hbuttonbox1), GTK_BUTTONBOX_END);
gtk_button_box_set_spacing(GTK_BUTTON_BOX(hbuttonbox1), 10);
Ok = gtkAddButton(MSGTR_Ok, hbuttonbox1);
Cancel = gtkAddButton(MSGTR_Cancel, hbuttonbox1);
geometry.max_width = gdk_screen_get_width(gtk_widget_get_screen(URLDialog));
geometry.max_height = -1;
gtk_window_set_geometry_hints(GTK_WINDOW(URLDialog), NULL, &geometry, GDK_HINT_MAX_SIZE);
gtk_widget_add_accelerator(Ok, "clicked", accel_group, GDK_Return, 0, GTK_ACCEL_VISIBLE);
gtk_widget_add_accelerator(Cancel, "clicked", accel_group, GDK_Escape, 0, GTK_ACCEL_VISIBLE);
gtk_signal_connect(GTK_OBJECT(URLDialog), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &URLDialog);
gtk_signal_connect(GTK_OBJECT(Ok), "clicked", GTK_SIGNAL_FUNC(button_clicked), Ok);
gtk_signal_connect(GTK_OBJECT(Cancel), "clicked", GTK_SIGNAL_FUNC(button_clicked), NULL);
gtk_widget_grab_focus(urlEntry);
gtk_window_add_accel_group(GTK_WINDOW(URLDialog), accel_group);
return URLDialog;
}
/* create horizontal button box for top of main window */
GtkWidget *create_toolbar()
{
GtkWidget *bbox, *btn;
bbox = gtk_hbutton_box_new();
gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_START);
gtk_button_box_set_spacing(GTK_BUTTON_BOX(bbox), 5);
gtk_widget_show(bbox);
return bbox;
}
/* Sets the amount of spacing between buttons in a given button box. */
int
clip_GTK_BUTTONBOXSETSPACING(ClipMachine * ClipMachineMemory)
{
C_widget *cbbox = _fetch_cw_arg(ClipMachineMemory);
gint spacing = _clip_parni(ClipMachineMemory, 2);
CHECKCWID(cbbox, GTK_IS_BUTTON_BOX);
CHECKOPT(2, NUMERIC_type_of_ClipVarType);
gtk_button_box_set_spacing(GTK_BUTTON_BOX(cbbox->widget), spacing);
return 0;
err:
return 1;
}
void preference_dlg(void) {
GtkWidget *button;
GtkWidget *bbox;
GtkWidget *frame;
prefer_dialog = gtk_dialog_new();
gtk_window_set_modal(GTK_WINDOW(prefer_dialog), TRUE);
GTK_WINDOW(prefer_dialog)->type = GTK_WINDOW_DIALOG;
gtk_window_set_title(GTK_WINDOW(prefer_dialog), _("Preference"));
gtk_window_set_policy(GTK_WINDOW(prefer_dialog), FALSE, FALSE, TRUE);
gtk_container_set_border_width(GTK_CONTAINER(prefer_dialog), 10);
gtk_window_position(GTK_WINDOW(prefer_dialog), GTK_WIN_POS_MOUSE);
gtk_widget_show(prefer_dialog);
frame = gtk_frame_new(_("Not implemented!!"));
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(prefer_dialog)->vbox), frame , TRUE, TRUE, 2);
gtk_widget_show(frame);
bbox = gtk_hbutton_box_new();
gtk_container_set_border_width(GTK_CONTAINER(bbox), 0);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(prefer_dialog)->action_area), bbox, TRUE, TRUE, 2);
gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END);
gtk_button_box_set_spacing(GTK_BUTTON_BOX(bbox), 10);
gtk_button_box_set_child_size(GTK_BUTTON_BOX(bbox), 85, 20);
gtk_widget_show(bbox);
button = gtk_button_new_with_label(_("OK"));
gtk_container_add(GTK_CONTAINER(bbox),button);
gtk_signal_connect_object(GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(gtk_widget_destroy),
GTK_OBJECT(prefer_dialog));
gtk_widget_show(button);
GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
gtk_widget_grab_default(button);
button = gtk_button_new_with_label(_("Apply"));
gtk_container_add(GTK_CONTAINER(bbox),button);
gtk_signal_connect(GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(prefer_dlg_apply),
NULL);
gtk_widget_show(button);
button = gtk_button_new_with_label(_("Close"));
gtk_container_add(GTK_CONTAINER(bbox),button);
gtk_signal_connect_object(GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(gtk_widget_destroy),
GTK_OBJECT(prefer_dialog));
gtk_widget_show(button);
return;
}
void sal_gui_hbbox(vm_t *vm)
{
GtkWidget *hbbox;
obj_t *ptr;
hbbox = gtk_hbutton_box_new();
gtk_button_box_set_layout(GTK_BUTTON_BOX(hbbox), GTK_BUTTONBOX_END);
gtk_button_box_set_spacing(GTK_BUTTON_BOX(hbbox), 5);
ptr = pointer_new("gui-hbbox",NULL);
ptr->data = hbbox;
sal_stack_push(vm->stack, ptr);
}
void prefs_open()
{
GtkWidget *vbox;
GtkWidget *hbbox;
GtkWidget *ok, *cancel;
GtkWidget *nb;
if (pw_opened) {
puts("dry!");
// focus the window
// gtk_widget_set_focus(GTK_WIDGET(pw));
return;
}
pw_opened = 1;
pw = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(pw), "gradare preferences");
g_signal_connect(pw, "destroy", G_CALLBACK(prefs_close), 0);
vbox = gtk_vbox_new(FALSE, 5);
gtk_container_add(GTK_CONTAINER(pw), vbox);
nb = gtk_notebook_new();
gtk_notebook_append_page(GTK_NOTEBOOK(nb), draw_toggles_for(0), gtk_label_new("Disassembly"));
gtk_notebook_append_page(GTK_NOTEBOOK(nb), draw_toggles_for(1), gtk_label_new("Global"));
gtk_notebook_append_page(GTK_NOTEBOOK(nb), draw_toggles_for(2), gtk_label_new("Graphs"));
gtk_notebook_append_page(GTK_NOTEBOOK(nb), draw_toggles_for(3), gtk_label_new("Debugger"));
gtk_container_add(GTK_CONTAINER(vbox), nb);
//gtk_box_pack_start(GTK_BOX(vbox), gtk_label_new("TODO O:)"), FALSE, FALSE, 5);
hbbox = gtk_hbutton_box_new();
gtk_container_set_border_width(GTK_CONTAINER(hbbox), 5);
gtk_button_box_set_layout(GTK_BUTTON_BOX(hbbox), GTK_BUTTONBOX_END);
#if USE_GTK2
gtk_button_box_set_spacing(GTK_BUTTON_BOX(hbbox), 5);
#endif
cancel = gtk_button_new_from_stock("gtk-cancel");
g_signal_connect(cancel, "button-release-event",
(gpointer)prefs_close, (gpointer)NULL);
gtk_container_add(GTK_CONTAINER(hbbox), cancel);
ok = gtk_button_new_from_stock("gtk-ok");
g_signal_connect(ok, "button-release-event",
(gpointer)prefs_close, (gpointer)1);
gtk_container_add(GTK_CONTAINER(hbbox), ok);
gtk_box_pack_end(GTK_BOX(vbox), GTK_WIDGET(hbbox), FALSE, FALSE, 5);
gtk_widget_show_all(pw);
}
static void warn_user(void)
{
GtkWidget *warn_win, *warn_vbox, *warn_desc;
GtkWidget *warn_bbox, *warn_yes, *warn_no;
warn_win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(warn_win), _("Warning"));
gtk_window_set_transient_for(GTK_WINDOW(warn_win),
GTK_WINDOW(configure_win));
gtk_window_set_modal(GTK_WINDOW(warn_win), TRUE);
gtk_container_set_border_width(GTK_CONTAINER(warn_win), 10);
warn_vbox = gtk_vbox_new(FALSE, 10);
gtk_container_add(GTK_CONTAINER(warn_win), warn_vbox);
warn_desc = gtk_label_new(_(
"Filename and song title tags should be inside "
"double quotes (\"). Not doing so might be a "
"security risk. Continue anyway?"));
gtk_label_set_justify(GTK_LABEL(warn_desc), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment(GTK_MISC(warn_desc), 0, 0.5);
gtk_box_pack_start(GTK_BOX(warn_vbox), warn_desc, FALSE, FALSE, 0);
gtk_label_set_line_wrap(GTK_LABEL(warn_desc), TRUE);
warn_bbox = gtk_hbutton_box_new();
gtk_button_box_set_layout(GTK_BUTTON_BOX(warn_bbox), GTK_BUTTONBOX_END);
gtk_button_box_set_spacing(GTK_BUTTON_BOX(warn_bbox), 5);
gtk_box_pack_start(GTK_BOX(warn_vbox), warn_bbox, FALSE, FALSE, 0);
warn_yes = gtk_button_new_with_label(_("Yes"));
gtk_signal_connect(GTK_OBJECT(warn_yes), "clicked",
GTK_SIGNAL_FUNC(save_and_close), NULL);
gtk_signal_connect_object(GTK_OBJECT(warn_yes), "clicked",
GTK_SIGNAL_FUNC(gtk_widget_destroy),
GTK_OBJECT(warn_win));
GTK_WIDGET_SET_FLAGS(warn_yes, GTK_CAN_DEFAULT);
gtk_box_pack_start(GTK_BOX(warn_bbox), warn_yes, TRUE, TRUE, 0);
gtk_widget_grab_default(warn_yes);
warn_no = gtk_button_new_with_label(_("No"));
gtk_signal_connect_object(GTK_OBJECT(warn_no), "clicked",
GTK_SIGNAL_FUNC(gtk_widget_destroy),
GTK_OBJECT(warn_win));
GTK_WIDGET_SET_FLAGS(warn_no, GTK_CAN_DEFAULT);
gtk_box_pack_start(GTK_BOX(warn_bbox), warn_no, TRUE, TRUE, 0);
gtk_widget_show_all(warn_win);
}
void html_diag_finish(Thtml_diag *dg, GtkSignalFunc ok_func) {
GtkWidget *hbox;
gtk_box_pack_start(GTK_BOX(dg->vbox), gtk_hseparator_new(), FALSE, FALSE, 12);
hbox = gtk_hbutton_box_new();
gtk_hbutton_box_set_layout_default(GTK_BUTTONBOX_END);
gtk_button_box_set_spacing(GTK_BUTTON_BOX(hbox), 12);
dg->obut = bf_stock_ok_button(ok_func, dg);
dg->cbut = bf_stock_cancel_button(G_CALLBACK(html_diag_cancel_clicked_cb), dg);
gtk_box_pack_start(GTK_BOX(hbox),dg->cbut , FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox),dg->obut , FALSE, FALSE, 0);
gtk_window_set_default(GTK_WINDOW(dg->dialog), dg->obut);
gtk_box_pack_start(GTK_BOX(dg->vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show_all(GTK_WIDGET(dg->dialog));
}
static void _settings_window(GPS * gps)
{
GtkSizeGroup * group;
GtkWidget * vbox;
GtkWidget * hbox;
GtkWidget * widget;
group = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
gps->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_container_set_border_width(GTK_CONTAINER(gps->window), 4);
gtk_window_set_default_size(GTK_WINDOW(gps->window), 200, 300);
#if GTK_CHECK_VERSION(2, 6, 0)
gtk_window_set_icon_name(GTK_WINDOW(gps->window), "gnome-settings");
#endif
gtk_window_set_title(GTK_WINDOW(gps->window), "GPS");
g_signal_connect(gps->window, "delete-event", G_CALLBACK(
gtk_widget_hide), NULL);
vbox = gtk_vbox_new(FALSE, 4);
/* controls */
hbox = gtk_hbutton_box_new();
widget = gtk_button_new_with_label("Start");
g_signal_connect_swapped(widget, "clicked",
G_CALLBACK(_gps_on_settings_start), gps);
gtk_container_add(GTK_CONTAINER(hbox), widget);
widget = gtk_button_new_with_label("Stop");
g_signal_connect_swapped(widget, "clicked",
G_CALLBACK(_gps_on_settings_stop), gps);
gtk_container_add(GTK_CONTAINER(hbox), widget);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);
/* button box */
hbox = gtk_hbutton_box_new();
gtk_button_box_set_layout(GTK_BUTTON_BOX(hbox), GTK_BUTTONBOX_END);
gtk_button_box_set_spacing(GTK_BUTTON_BOX(hbox), 4);
widget = gtk_button_new_from_stock(GTK_STOCK_CLOSE);
g_signal_connect_swapped(widget, "clicked", G_CALLBACK(
_gps_on_settings_close), gps);
gtk_container_add(GTK_CONTAINER(hbox), widget);
gtk_box_pack_end(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(gps->window), vbox);
gtk_widget_show_all(vbox);
}
void vorbis_file_info_box(char *fn)
{
char *track_name, *performer, *album_name, *date, *track_number;
char *genre, *user_comment, *tmp;
char *description, *version, *isrc, *copyright, *organization;
char *location, *vendor = "N/A";
char *rg_track_gain, *rg_album_gain, *rg_track_peak, *rg_album_peak;
int time, minutes, seconds, bitrate, avgbitrate, rate, channels;
int filesize, i;
OggVorbis_File vf;
vorbis_info *vi;
vorbis_comment *comment = NULL;
FILE *fh;
gboolean clear_vf = FALSE;
g_free(vte.filename);
vte.filename = g_strdup(fn);
if (!window)
{
GtkWidget *info_frame, *info_box;
GtkWidget *hbox, *label, *filename_hbox, *vbox, *left_vbox;
GtkWidget *table, *bbox, *cancel_button;
GtkWidget *save_button, *remove_button;
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_policy(GTK_WINDOW(window), FALSE, FALSE, FALSE);
gtk_signal_connect(GTK_OBJECT(window), "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroyed), &window);
gtk_signal_connect(GTK_OBJECT(window), "key_press_event",
keypress_cb, NULL);
gtk_container_set_border_width(GTK_CONTAINER(window), 10);
vbox = gtk_vbox_new(FALSE, 10);
gtk_container_add(GTK_CONTAINER(window), vbox);
filename_hbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(vbox), filename_hbox, FALSE,
TRUE, 0);
label = gtk_label_new(_("Filename:"));
gtk_box_pack_start(GTK_BOX(filename_hbox), label, FALSE,
TRUE, 0);
filename_entry = gtk_entry_new();
gtk_editable_set_editable(GTK_EDITABLE(filename_entry), FALSE);
gtk_box_pack_start(GTK_BOX(filename_hbox), filename_entry,
TRUE, TRUE, 0);
hbox = gtk_hbox_new(FALSE, 10);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);
left_vbox = gtk_vbox_new(FALSE, 10);
gtk_box_pack_start(GTK_BOX(hbox), left_vbox, FALSE, FALSE, 0);
tag_frame = gtk_frame_new(_("Ogg Vorbis Tag:"));
gtk_box_pack_start(GTK_BOX(left_vbox), tag_frame, FALSE,
FALSE, 0);
table = gtk_table_new(5, 5, FALSE);
gtk_container_set_border_width(GTK_CONTAINER(table), 5);
gtk_container_add(GTK_CONTAINER(tag_frame), table);
label = gtk_label_new(_("Title:"));
gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 0, 1,
GTK_FILL, GTK_FILL, 5, 5);
title_entry = gtk_entry_new();
gtk_table_attach(GTK_TABLE(table), title_entry, 1, 4, 0, 1,
GTK_FILL | GTK_EXPAND | GTK_SHRINK,
GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 5);
label = gtk_label_new(_("Artist:"));
gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 1, 2,
GTK_FILL, GTK_FILL, 5, 5);
performer_entry = gtk_entry_new();
gtk_table_attach(GTK_TABLE(table), performer_entry, 1, 4, 1, 2,
GTK_FILL | GTK_EXPAND | GTK_SHRINK,
GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 5);
label = gtk_label_new(_("Album:"));
gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 2, 3,
GTK_FILL, GTK_FILL, 5, 5);
album_entry = gtk_entry_new();
gtk_table_attach(GTK_TABLE(table), album_entry, 1, 4, 2, 3,
GTK_FILL | GTK_EXPAND | GTK_SHRINK,
GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 5);
label = gtk_label_new(_("Comment:"));
gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 3, 4,
GTK_FILL, GTK_FILL, 5, 5);
user_comment_entry = gtk_entry_new();
gtk_table_attach(GTK_TABLE(table), user_comment_entry, 1, 4, 3,
4, GTK_FILL | GTK_EXPAND | GTK_SHRINK,
GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 5);
label = gtk_label_new(_("Date:"));
gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 4, 5,
GTK_FILL, GTK_FILL, 5, 5);
date_entry = gtk_entry_new();
gtk_widget_set_usize(date_entry, 60, -1);
gtk_table_attach(GTK_TABLE(table), date_entry, 1, 2, 4, 5,
GTK_FILL | GTK_EXPAND | GTK_SHRINK,
GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 5);
label = gtk_label_new(_("Track number:"));
gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
gtk_table_attach(GTK_TABLE(table), label, 2, 3, 4, 5,
GTK_FILL, GTK_FILL, 5, 5);
tracknumber_entry = gtk_entry_new_with_max_length(4);
gtk_widget_set_usize(tracknumber_entry, 20, -1);
gtk_table_attach(GTK_TABLE(table), tracknumber_entry, 3, 4, 4,
5, GTK_FILL | GTK_EXPAND | GTK_SHRINK,
GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 5);
label = gtk_label_new(_("Genre:"));
gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 5, 6,
GTK_FILL, GTK_FILL, 5, 5);
genre_combo = gtk_combo_new();
if (!genre_list)
{
for (i = 0; i < sizeof(vorbis_genres)/sizeof(*vorbis_genres) ; i++)
genre_list = g_list_prepend(genre_list, _(vorbis_genres[i]));
genre_list = g_list_sort(genre_list, (GCompareFunc)g_strcasecmp);
}
gtk_combo_set_popdown_strings(GTK_COMBO(genre_combo),
genre_list);
gtk_table_attach(GTK_TABLE(table), genre_combo, 1, 4, 5, 6,
GTK_FILL | GTK_EXPAND | GTK_SHRINK,
GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 5);
#ifdef ALL_VORBIS_TAGS
label = gtk_label_new(_("Description:"));
gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 6, 7,
GTK_FILL, GTK_FILL, 5, 5);
description_entry = gtk_entry_new();
gtk_table_attach(GTK_TABLE(table), description_entry, 1, 4, 6,
7, GTK_FILL | GTK_EXPAND | GTK_SHRINK,
GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 5);
label = gtk_label_new(_("Location:"));
gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 7, 8,
GTK_FILL, GTK_FILL, 5, 5);
location_entry = gtk_entry_new();
gtk_table_attach(GTK_TABLE(table), location_entry, 1, 4, 7, 8,
GTK_FILL | GTK_EXPAND | GTK_SHRINK,
GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 5);
label = gtk_label_new(_("Version:"));
gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 8, 9,
GTK_FILL, GTK_FILL, 5, 5);
version_entry = gtk_entry_new();
gtk_widget_set_usize(version_entry, 60, -1);
gtk_table_attach(GTK_TABLE(table), version_entry, 1, 2, 8, 9,
GTK_FILL | GTK_EXPAND | GTK_SHRINK,
GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 5);
label = gtk_label_new(_("ISRC number:"));
gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
gtk_table_attach(GTK_TABLE(table), label, 2, 3, 8, 9,
GTK_FILL, GTK_FILL, 5, 5);
isrc_entry = gtk_entry_new();
gtk_widget_set_usize(isrc_entry, 20, -1);
gtk_table_attach(GTK_TABLE(table), isrc_entry, 3, 4, 8, 9,
GTK_FILL | GTK_EXPAND | GTK_SHRINK,
GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 5);
label = gtk_label_new(_("Organization:"));
gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 9, 10,
GTK_FILL, GTK_FILL, 5, 5);
organization_entry = gtk_entry_new();
gtk_table_attach(GTK_TABLE(table), organization_entry, 1, 4, 9,
10, GTK_FILL | GTK_EXPAND | GTK_SHRINK,
GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 5);
label = gtk_label_new(_("Copyright:"));
gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 10, 11,
GTK_FILL, GTK_FILL, 5, 5);
copyright_entry = gtk_entry_new();
gtk_table_attach(GTK_TABLE(table), copyright_entry, 1, 4, 10,
11, GTK_FILL | GTK_EXPAND | GTK_SHRINK,
GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 5);
#endif
rg_show_button = gtk_check_button_new_with_label(_("ReplayGain Settings:"));
gtk_signal_connect(GTK_OBJECT(rg_show_button), "toggled",
GTK_SIGNAL_FUNC(rg_show_cb), NULL);
gtk_table_attach(GTK_TABLE(table), rg_show_button, 0, 2, 11, 12,
GTK_FILL, GTK_FILL, 5, 5);
rg_track_label = gtk_label_new(_("Track gain:"));
gtk_misc_set_alignment(GTK_MISC(rg_track_label), 1, 0.5);
gtk_table_attach(GTK_TABLE(table), rg_track_label, 2, 3, 11, 12,
GTK_FILL, GTK_FILL, 5, 5);
rg_track_entry = gtk_entry_new();
gtk_table_attach(GTK_TABLE(table), rg_track_entry, 3, 4, 11,
12, GTK_FILL | GTK_EXPAND | GTK_SHRINK,
GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 5);
rg_track_peak_label = gtk_label_new(_("Track peak:"));
gtk_misc_set_alignment(GTK_MISC(rg_track_peak_label), 1, 0.5);
gtk_table_attach(GTK_TABLE(table), rg_track_peak_label, 2, 3, 12, 13,
GTK_FILL, GTK_FILL, 5, 5);
rg_track_peak_entry = gtk_entry_new();
gtk_table_attach(GTK_TABLE(table), rg_track_peak_entry, 3, 4, 12,
13, GTK_FILL | GTK_EXPAND | GTK_SHRINK,
GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 5);
rg_album_label = gtk_label_new(_("Album gain:"));
gtk_misc_set_alignment(GTK_MISC(rg_album_label), 1, 0.5);
gtk_table_attach(GTK_TABLE(table), rg_album_label, 2, 3, 13, 14,
GTK_FILL, GTK_FILL, 5, 5);
rg_album_entry = gtk_entry_new();
gtk_table_attach(GTK_TABLE(table), rg_album_entry, 3, 4, 13,
14, GTK_FILL | GTK_EXPAND | GTK_SHRINK,
GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 5);
rg_album_peak_label = gtk_label_new(_("Album peak:"));
gtk_misc_set_alignment(GTK_MISC(rg_album_peak_label), 1, 0.5);
gtk_table_attach(GTK_TABLE(table), rg_album_peak_label, 2, 3, 14, 15,
GTK_FILL, GTK_FILL, 5, 5);
rg_album_peak_entry = gtk_entry_new();
gtk_table_attach(GTK_TABLE(table), rg_album_peak_entry, 3, 4, 14,
15, GTK_FILL | GTK_EXPAND | GTK_SHRINK,
GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 5);
bbox = gtk_hbutton_box_new();
gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox),
GTK_BUTTONBOX_END);
gtk_button_box_set_spacing(GTK_BUTTON_BOX(bbox), 5);
gtk_box_pack_start(GTK_BOX(left_vbox), bbox, FALSE, FALSE, 0);
save_button = gtk_button_new_with_label(_("Save"));
gtk_signal_connect(GTK_OBJECT(save_button), "clicked",
GTK_SIGNAL_FUNC(save_cb), NULL);
GTK_WIDGET_SET_FLAGS(save_button, GTK_CAN_DEFAULT);
gtk_box_pack_start(GTK_BOX(bbox), save_button, TRUE, TRUE, 0);
gtk_widget_grab_default(save_button);
remove_button = gtk_button_new_with_label(_("Remove Tag"));
gtk_signal_connect_object(GTK_OBJECT(remove_button),
"clicked",
GTK_SIGNAL_FUNC(remove_cb), NULL);
GTK_WIDGET_SET_FLAGS(remove_button, GTK_CAN_DEFAULT);
gtk_box_pack_start(GTK_BOX(bbox),remove_button, TRUE, TRUE, 0);
cancel_button = gtk_button_new_with_label(_("Cancel"));
gtk_signal_connect_object(GTK_OBJECT(cancel_button),
"clicked",
GTK_SIGNAL_FUNC(gtk_widget_destroy),
GTK_OBJECT(window));
GTK_WIDGET_SET_FLAGS(cancel_button, GTK_CAN_DEFAULT);
gtk_box_pack_start(GTK_BOX(bbox),cancel_button, TRUE, TRUE, 0);
info_frame = gtk_frame_new(_("Ogg Vorbis Info:"));
gtk_box_pack_start(GTK_BOX(hbox), info_frame, FALSE, FALSE, 0);
info_box = gtk_vbox_new(FALSE, 5);
gtk_container_add(GTK_CONTAINER(info_frame), info_box);
gtk_container_set_border_width(GTK_CONTAINER(info_box), 10);
gtk_box_set_spacing(GTK_BOX(info_box), 0);
bitrate_label = gtk_label_new("");
gtk_misc_set_alignment(GTK_MISC(bitrate_label), 0, 0);
gtk_label_set_justify(GTK_LABEL(bitrate_label),
GTK_JUSTIFY_LEFT);
gtk_box_pack_start(GTK_BOX(info_box), bitrate_label, FALSE,
FALSE, 0);
avgbitrate_label = gtk_label_new("");
gtk_misc_set_alignment(GTK_MISC(avgbitrate_label), 0, 0);
gtk_label_set_justify(GTK_LABEL(avgbitrate_label),
GTK_JUSTIFY_LEFT);
gtk_box_pack_start(GTK_BOX(info_box), avgbitrate_label, FALSE,
FALSE, 0);
rate_label = gtk_label_new("");
gtk_misc_set_alignment(GTK_MISC(rate_label), 0, 0);
gtk_label_set_justify(GTK_LABEL(rate_label), GTK_JUSTIFY_LEFT);
gtk_box_pack_start(GTK_BOX(info_box), rate_label, FALSE,
FALSE, 0);
channel_label = gtk_label_new("");
gtk_misc_set_alignment(GTK_MISC(channel_label), 0, 0);
gtk_label_set_justify(GTK_LABEL(channel_label),
GTK_JUSTIFY_LEFT);
gtk_box_pack_start(GTK_BOX(info_box), channel_label, FALSE,
FALSE, 0);
length_label = gtk_label_new("");
gtk_misc_set_alignment(GTK_MISC(length_label), 0, 0);
gtk_label_set_justify(GTK_LABEL(length_label),
GTK_JUSTIFY_LEFT);
gtk_box_pack_start(GTK_BOX(info_box), length_label, FALSE,
FALSE, 0);
filesize_label = gtk_label_new("");
gtk_misc_set_alignment(GTK_MISC(filesize_label), 0, 0);
gtk_label_set_justify(GTK_LABEL(filesize_label),
GTK_JUSTIFY_LEFT);
gtk_box_pack_start(GTK_BOX(info_box), filesize_label, FALSE,
FALSE, 0);
vendor_label = gtk_label_new("");
gtk_misc_set_alignment(GTK_MISC(vendor_label), 0, 0);
gtk_label_set_justify(GTK_LABEL(vendor_label),
GTK_JUSTIFY_LEFT);
gtk_box_pack_start(GTK_BOX(info_box), vendor_label, FALSE,
FALSE, 0);
replaygain_label = gtk_label_new("");
gtk_misc_set_alignment(GTK_MISC(replaygain_label), 0, 0);
gtk_label_set_justify(GTK_LABEL(replaygain_label),
GTK_JUSTIFY_LEFT);
gtk_box_pack_start(GTK_BOX(info_box), replaygain_label, FALSE,
FALSE, 0);
audiophilegain_label = gtk_label_new("");
gtk_misc_set_alignment(GTK_MISC(audiophilegain_label), 0, 0);
gtk_label_set_justify(GTK_LABEL(audiophilegain_label),
GTK_JUSTIFY_LEFT);
gtk_box_pack_start(GTK_BOX(info_box), audiophilegain_label, FALSE,
FALSE, 0);
peak_label = gtk_label_new("");
gtk_misc_set_alignment(GTK_MISC(peak_label), 0, 0);
gtk_label_set_justify(GTK_LABEL(peak_label),
GTK_JUSTIFY_LEFT);
gtk_box_pack_start(GTK_BOX(info_box), peak_label, FALSE,
FALSE, 0);
gtk_widget_show_all(window);
} else
gdk_window_raise(window->window);
if (!g_strncasecmp(vte.filename, "http://", 7))
gtk_widget_set_sensitive(tag_frame, FALSE);
else
gtk_widget_set_sensitive(tag_frame, TRUE);
gtk_label_set_text(GTK_LABEL(bitrate_label), "");
gtk_label_set_text(GTK_LABEL(avgbitrate_label), "");
gtk_label_set_text(GTK_LABEL(rate_label), "");
gtk_label_set_text(GTK_LABEL(channel_label), "");
gtk_label_set_text(GTK_LABEL(length_label), "");
gtk_label_set_text(GTK_LABEL(filesize_label), "");
gtk_label_set_text(GTK_LABEL(vendor_label), "");
if ((fh = fopen(vte.filename, "r")) != NULL)
{
pthread_mutex_lock(&vf_mutex);
if (ov_open(fh, &vf, NULL, 0) == 0)
{
comment = ov_comment(&vf, -1);
if (comment && comment->vendor)
vendor = comment->vendor;
if ((vi = ov_info(&vf, 0)) != NULL)
{
bitrate = vi->bitrate_nominal/1000;
avgbitrate = ov_bitrate(&vf, -1);
if (avgbitrate == OV_EINVAL ||
avgbitrate == OV_FALSE)
avgbitrate = 0;
rate = vi->rate;
channels = vi->channels;
clear_vf = TRUE;
}
else
{
bitrate = 0;
avgbitrate = 0;
rate = 0;
channels = 0;
}
time = ov_time_total(&vf, -1);
minutes = time / 60;
seconds = time % 60;
fseek(fh, 0, SEEK_END);
filesize = ftell(fh);
label_set_text(bitrate_label, _("Nominal bitrate: %d kbps"), bitrate);
label_set_text(avgbitrate_label, _("Average bitrate: %.1f kbps"), ((float) avgbitrate) / 1000);
label_set_text(rate_label, _("Samplerate: %d Hz"), rate);
label_set_text(channel_label, _("Channels: %d"), channels);
label_set_text(length_label, _("Length: %d:%.2d"), minutes, seconds);
label_set_text(filesize_label, _("File size: %d B"), filesize);
label_set_text(vendor_label, _("Vendor: %s"), vendor);
}
else
fclose(fh);
}
track_name = get_comment(comment, "title");
performer = get_comment(comment, "artist");
album_name = get_comment(comment, "album");
track_number = get_comment(comment, "tracknumber");
genre = get_comment(comment, "genre");
date = get_comment(comment, "date");
user_comment = get_comment(comment, "comment");
location = get_comment(comment, "location");
description = get_comment(comment, "description");
version = get_comment(comment, "version");
isrc = get_comment(comment, "isrc");
organization = get_comment(comment, "organization");
copyright = get_comment(comment, "copyright");
rg_track_gain = get_comment(comment, "replaygain_track_gain");
if (*rg_track_gain == '\0')
{
g_free(rg_track_gain);
rg_track_gain = get_comment(comment, "rg_radio"); /* Old */
}
rg_album_gain = get_comment(comment, "replaygain_album_gain");
if (*rg_album_gain == '\0')
{
g_free(rg_album_gain);
rg_album_gain = get_comment(comment, "rg_audiophile"); /* Old */
}
rg_track_peak = get_comment(comment, "replaygain_track_peak");
if (*rg_track_peak == '\0')
{
g_free(rg_track_peak);
rg_track_peak = get_comment(comment, "rg_peak"); /* Old */
}
rg_album_peak = get_comment(comment, "replaygain_album_peak"); /* Old had no album peak */
/* ov_clear closes the file */
if (clear_vf)
ov_clear(&vf);
pthread_mutex_unlock(&vf_mutex);
/* Fill it all in .. */
gtk_entry_set_text(GTK_ENTRY(title_entry), track_name);
gtk_entry_set_text(GTK_ENTRY(performer_entry), performer);
gtk_entry_set_text(GTK_ENTRY(album_entry), album_name);
gtk_entry_set_text(GTK_ENTRY(user_comment_entry), user_comment);
gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(genre_combo)->entry), genre);
gtk_entry_set_text(GTK_ENTRY(tracknumber_entry), track_number);
gtk_entry_set_text(GTK_ENTRY(date_entry), date);
#ifdef ALL_VORBIS_TAGS
gtk_entry_set_text(GTK_ENTRY(version_entry), version);
gtk_entry_set_text(GTK_ENTRY(description_entry), description);
gtk_entry_set_text(GTK_ENTRY(organization_entry), organization);
gtk_entry_set_text(GTK_ENTRY(copyright_entry), copyright);
gtk_entry_set_text(GTK_ENTRY(isrc_entry), isrc);
gtk_entry_set_text(GTK_ENTRY(location_entry), location);
#endif
gtk_entry_set_text(GTK_ENTRY(filename_entry), vte.filename);
gtk_editable_set_position(GTK_EDITABLE(filename_entry), -1);
gtk_entry_set_text(GTK_ENTRY(rg_track_entry), rg_track_gain);
gtk_entry_set_text(GTK_ENTRY(rg_album_entry), rg_album_gain);
gtk_entry_set_text(GTK_ENTRY(rg_track_peak_entry), rg_track_peak);
gtk_editable_set_position(GTK_EDITABLE(rg_track_peak_entry), -1);
gtk_entry_set_text(GTK_ENTRY(rg_album_peak_entry), rg_album_peak);
gtk_editable_set_position(GTK_EDITABLE(rg_album_peak_entry), -1);
if (*rg_track_gain == '\0' && *rg_album_gain == '\0' && *rg_track_peak == '\0' && *rg_album_peak == '\0')
{
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(rg_show_button), FALSE);
rg_show_cb(rg_show_button, NULL);
}
else
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(rg_show_button), TRUE);
tmp = g_strdup_printf(_("File Info - %s"), g_basename(vte.filename));
gtk_window_set_title(GTK_WINDOW(window), tmp);
g_free(tmp);
/* Cleanup .. */
g_free(track_name);
g_free(performer);
g_free(album_name);
g_free(track_number);
g_free(genre);
g_free(date);
g_free(user_comment);
g_free(location);
g_free(description);
g_free(version);
g_free(isrc);
g_free(organization);
g_free(copyright);
g_free(rg_track_gain);
g_free(rg_album_gain);
g_free(rg_track_peak);
g_free(rg_album_peak);
}
GtkWidget *create_dir_browser(gchar * title, gchar * current_path, GtkSelectionMode mode, void (*handler) (gchar *))
{
GtkWidget *window, *scroll_win, *tree, *vbox, *bbox, *ok, *cancel,
*sep;
gchar *root_text = "/", *node_text = "dummy";
gchar *currentdir, *pos, *tpath, *tpathnew;
GtkCTreeNode *root_node, *node, *nextnode;
DirNode *dirnode;
gboolean leaf;
#ifdef _GTK2
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_modal(GTK_WINDOW(window), TRUE);
// gtk_window_set_decorated(GTK_WINDOW(window), TRUE);
#else
window = gtk_window_new(GTK_WINDOW_DIALOG);
#endif
gtk_window_set_title(GTK_WINDOW(window), title);
gtk_container_border_width(GTK_CONTAINER(window), 10);
vbox = gtk_vbox_new(FALSE, 10);
gtk_container_add(GTK_CONTAINER(window), vbox);
scroll_win = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll_win), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_widget_set_usize(scroll_win, 250, 200);
gtk_box_pack_start(GTK_BOX(vbox), scroll_win, TRUE, TRUE, 0);
gtk_widget_show(scroll_win);
gtk_widget_realize(window);
if (!folder_pixmap)
{
folder_pixmap = gdk_pixmap_create_from_xpm_d(window->window, &folder_mask, NULL, folder);
ofolder_pixmap = gdk_pixmap_create_from_xpm_d(window->window, &ofolder_mask, NULL, ofolder);
}
tree = gtk_ctree_new(1, 0);
gtk_clist_set_column_auto_resize(GTK_CLIST(tree), 0, TRUE);
gtk_clist_set_selection_mode(GTK_CLIST(tree), mode);
gtk_ctree_set_line_style(GTK_CTREE(tree), GTK_CTREE_LINES_DOTTED);
gtk_signal_connect(GTK_OBJECT(tree), "tree_expand", GTK_SIGNAL_FUNC(expand_cb), NULL);
gtk_signal_connect(GTK_OBJECT(tree), "select_row", GTK_SIGNAL_FUNC(select_row_cb), NULL);
gtk_container_add(GTK_CONTAINER(scroll_win), tree);
gtk_object_set_user_data(GTK_OBJECT(tree), (gpointer) handler);
root_node = gtk_ctree_insert_node(GTK_CTREE(tree), NULL, NULL, &root_text, 4, folder_pixmap, folder_mask, ofolder_pixmap, ofolder_mask, FALSE, FALSE);
dirnode = g_malloc0(sizeof (DirNode));
dirnode->path = g_strdup("/");
gtk_ctree_node_set_row_data_full(GTK_CTREE(tree), root_node, dirnode, destroy_cb);
node = gtk_ctree_insert_node(GTK_CTREE(tree), root_node, NULL, &node_text, 4, NULL, NULL, NULL, NULL, TRUE, TRUE);
gtk_ctree_expand(GTK_CTREE(tree), root_node);
gtk_widget_show(tree);
sep = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(vbox), sep, FALSE, FALSE, 0);
gtk_widget_show(sep);
bbox = gtk_hbutton_box_new();
gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END);
gtk_button_box_set_spacing(GTK_BUTTON_BOX(bbox), 5);
ok = gtk_button_new_with_label(tr("Ok"));
gtk_object_set_user_data(GTK_OBJECT(ok), window);
GTK_WIDGET_SET_FLAGS(ok, GTK_CAN_DEFAULT);
gtk_window_set_default(GTK_WINDOW(window), ok);
gtk_box_pack_start(GTK_BOX(bbox), ok, TRUE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT(ok), "clicked", GTK_SIGNAL_FUNC(ok_clicked), tree);
gtk_widget_show(ok);
cancel = gtk_button_new_with_label(tr("Cancel"));
GTK_WIDGET_SET_FLAGS(cancel, GTK_CAN_DEFAULT);
gtk_box_pack_start(GTK_BOX(bbox), cancel, TRUE, TRUE, 0);
gtk_signal_connect_object(GTK_OBJECT(cancel), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT(window));
gtk_widget_show(cancel);
gtk_box_pack_start(GTK_BOX(vbox), bbox, FALSE, FALSE, 0);
gtk_widget_show(bbox);
gtk_widget_show(vbox);
if (current_path && *current_path)
{
currentdir = g_strdup(current_path);
tpath = g_strdup("/");
pos = strtok(currentdir, "/");
node = gtk_ctree_find_by_row_data_custom(GTK_CTREE(tree), NULL, "/", filetreeent_compare_func);
do
{
tpathnew = g_strconcat(tpath, pos, "/", NULL);
g_free(tpath);
tpath = tpathnew;
nextnode = gtk_ctree_find_by_row_data_custom(GTK_CTREE(tree), node, tpath, filetreeent_compare_func);
if (!nextnode)
break;
node = nextnode;
pos = strtok(NULL, "/");
gtk_ctree_get_node_info(GTK_CTREE(tree), node, NULL, NULL, NULL, NULL, NULL, NULL, &leaf, NULL);
if (!leaf && pos)
gtk_ctree_expand(GTK_CTREE(tree), node);
else
{
gtk_ctree_select(GTK_CTREE(tree), node);
break;
}
}
while (pos);
g_free(tpath);
g_free(currentdir);
}
else
gtk_ctree_select(GTK_CTREE(tree), root_node);
return window;
}
void uade_gui_file_info(char *filename, char *gui_player_filename,
char *modulename, char *playername, char *formatname)
{
GtkWidget *fileinfo_base_vbox;
GtkWidget *fileinfo_frame;
GtkWidget *fileinfo_table;
GtkWidget *fileinfo_modulename_label;
GtkWidget *fileinfo_modulename_hbox;
GtkWidget *fileinfo_hrule1;
GtkWidget *fileinfo_playername_hbox;
GtkWidget *fileinfo_playername_label;
GtkWidget *fileinfo_playerinfo_button;
GtkWidget *fileinfo_hrule2;
GtkWidget *fileinfo_subsong_label;
GtkWidget *fileinfo_minsubsong_label;
GtkWidget *fileinfo_maxsubsong_label;
GtkWidget *fileinfo_hrule3;
GtkWidget *fileinfo_hrule4;
GtkWidget *fileinfo_button_box;
GtkWidget *ok_button;
#ifdef __AUDACIOUS_INPUT_PLUGIN_API__
char * decoded = NULL;
if (strncmp(filename, "file:/",6) == 0) {
decoded = g_filename_from_uri((char *) filename, NULL, NULL);
filename = decoded;
}
#endif
strlcpy(module_filename, filename, sizeof module_filename);
strlcpy(player_filename, gui_player_filename, sizeof player_filename);
if (fileinfowin == NULL) {
fileinfo_tooltips = gtk_tooltips_new();
fileinfowin = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(fileinfowin), "UADE file info");
gtk_window_set_position(GTK_WINDOW(fileinfowin),
GTK_WIN_POS_MOUSE);
gtk_container_set_border_width(GTK_CONTAINER(fileinfowin), 10);
gtk_window_set_policy(GTK_WINDOW(fileinfowin), FALSE, FALSE,
FALSE);
gtk_signal_connect(GTK_OBJECT(fileinfowin), "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroyed),
&fileinfowin);
/* Start of Contents Box */
fileinfo_base_vbox = gtk_vbox_new(FALSE, 10);
gtk_container_set_border_width(GTK_CONTAINER
(fileinfo_base_vbox), 5);
gtk_container_add(GTK_CONTAINER(fileinfowin),
fileinfo_base_vbox);
/* Start of File info frame, text and option widgets */
fileinfo_frame = gtk_frame_new("File info: ");
gtk_box_pack_start(GTK_BOX(fileinfo_base_vbox), fileinfo_frame,
TRUE, TRUE, 0);
/* Start of Fileinfotable */
fileinfo_table = gtk_table_new(12, 2, FALSE);
gtk_widget_show(fileinfo_table);
gtk_container_add(GTK_CONTAINER(fileinfo_frame),
fileinfo_table);
gtk_container_set_border_width(GTK_CONTAINER(fileinfo_table), 5);
/* 1x1 */
fileinfo_modulename_label = gtk_label_new("Module: ");
gtk_misc_set_padding(GTK_MISC(fileinfo_modulename_label), 5,
5);
/* gtk_misc_set_alignment (GTK_MISC (fileinfo_modulename_label), 1, 0); */
gtk_table_attach(GTK_TABLE(fileinfo_table),
fileinfo_modulename_label, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
/* 1x2 */
/* 1x3 */
fileinfo_hrule1 = gtk_hseparator_new();
gtk_table_attach(GTK_TABLE(fileinfo_table), fileinfo_hrule1, 0,
1, 2, 3, (GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
/* 1x4 */
fileinfo_playername_label = gtk_label_new("Playerformat: ");
gtk_misc_set_padding(GTK_MISC(fileinfo_playername_label), 5,
5);
/* gtk_misc_set_alignment (GTK_MISC (fileinfo_playername_label), 1, 0); */
gtk_table_attach(GTK_TABLE(fileinfo_table),
fileinfo_playername_label, 0, 1, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
fileinfo_hrule2 = gtk_hseparator_new();
gtk_table_attach(GTK_TABLE(fileinfo_table), fileinfo_hrule2, 0,
1, 6, 7, (GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
/* 1x8*/
fileinfo_subsong_label = gtk_label_new("Curr. subsong: ");
gtk_misc_set_padding(GTK_MISC(fileinfo_subsong_label), 5, 5);
/* gtk_misc_set_alignment (GTK_MISC (fileinfo_subsong_label), 1, 0); */
gtk_table_attach(GTK_TABLE(fileinfo_table),
fileinfo_subsong_label, 0, 1, 7, 8,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
/* 1x9*/
fileinfo_minsubsong_label = gtk_label_new("Min. subsong: ");
gtk_misc_set_padding(GTK_MISC(fileinfo_minsubsong_label), 5,
5);
/* gtk_misc_set_alignment (GTK_MISC (fileinfo_minsubsong_label), 1, 0); */
gtk_table_attach(GTK_TABLE(fileinfo_table),
fileinfo_minsubsong_label, 0, 1, 8, 9,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
/* 1x10*/
fileinfo_maxsubsong_label = gtk_label_new("Max. subsong: ");
gtk_misc_set_padding(GTK_MISC(fileinfo_maxsubsong_label), 5,
5);
/* gtk_misc_set_alignment (GTK_MISC (fileinfo_maxsubsong_label), 1, 0); */
gtk_table_attach(GTK_TABLE(fileinfo_table),
fileinfo_maxsubsong_label, 0, 1, 9, 10,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
/* 2nd Column */
/* 2x1*/
fileinfo_modulename_hbox = gtk_hbox_new(FALSE, 10);
gtk_table_attach(GTK_TABLE(fileinfo_table),
fileinfo_modulename_hbox, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
if (modulename[0] == 0) {
fileinfo_modulename_txt = gtk_label_new(basename(filename));
} else {
fileinfo_modulename_txt = gtk_label_new(g_strdup_printf("%s\n(%s)",
modulename,
basename(filename)
));
}
gtk_label_set_justify(GTK_LABEL(fileinfo_modulename_txt),
GTK_JUSTIFY_LEFT);
gtk_label_set_line_wrap(GTK_LABEL(fileinfo_modulename_txt),
TRUE);
gtk_misc_set_alignment(GTK_MISC(fileinfo_modulename_txt), 0,
0.5);
gtk_misc_set_padding(GTK_MISC(fileinfo_modulename_txt), 5, 5);
fileinfo_hexinfo_button = gtk_button_new_with_label("hex");
GTK_WIDGET_SET_FLAGS(fileinfo_hexinfo_button,
GTK_CAN_DEFAULT);
gtk_widget_ref(fileinfo_hexinfo_button);
gtk_object_set_data_full(GTK_OBJECT(fileinfowin),
"fileinfo_hexinfo_button",
fileinfo_hexinfo_button,
(GtkDestroyNotify) gtk_widget_unref);
gtk_tooltips_set_tip(fileinfo_tooltips,
fileinfo_hexinfo_button,
g_strdup_printf("%s", filename),
NULL);
gtk_signal_connect_object(GTK_OBJECT
(fileinfo_hexinfo_button),
"clicked",
GTK_SIGNAL_FUNC(uade_mod_info_hex), NULL);
fileinfo_moduleinfo_button = gtk_button_new_with_label("Info");
GTK_WIDGET_SET_FLAGS(fileinfo_moduleinfo_button,
GTK_CAN_DEFAULT);
gtk_widget_ref(fileinfo_moduleinfo_button);
gtk_object_set_data_full(GTK_OBJECT(fileinfowin),
"fileinfo_moduleinfo_button",
fileinfo_moduleinfo_button,
(GtkDestroyNotify) gtk_widget_unref);
gtk_tooltips_set_tip(fileinfo_tooltips,
fileinfo_moduleinfo_button,
g_strdup_printf("%s", filename),
NULL);
gtk_signal_connect_object(GTK_OBJECT
(fileinfo_moduleinfo_button),
"clicked",
GTK_SIGNAL_FUNC(uade_mod_info_module), NULL);
gtk_box_pack_start(GTK_BOX(fileinfo_modulename_hbox),
fileinfo_modulename_txt, TRUE, TRUE, 0);
gtk_box_pack_start_defaults(GTK_BOX(fileinfo_modulename_hbox),
fileinfo_hexinfo_button);
gtk_box_pack_start_defaults(GTK_BOX(fileinfo_modulename_hbox),
fileinfo_moduleinfo_button);
/* 2x2*/
/* 2x3*/
fileinfo_hrule3 = gtk_hseparator_new();
gtk_table_attach(GTK_TABLE(fileinfo_table), fileinfo_hrule3, 1,
2, 2, 3, (GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
/* 2x4*/
fileinfo_playername_hbox = gtk_hbox_new(FALSE, 10);
gtk_table_attach(GTK_TABLE(fileinfo_table),
fileinfo_playername_hbox, 1, 2, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
if (formatname[0] == 0) {
fileinfo_playername_txt = gtk_label_new(g_strdup_printf("%s", playername));
} else {
/* memory leaks using g_strdup_printf? */
fileinfo_playername_txt = gtk_label_new(g_strdup_printf("%s\n%s", playername, formatname));
}
/* fileinfo_playername_txt = gtk_label_new (get_playername()); */
gtk_label_set_justify(GTK_LABEL(fileinfo_playername_txt),
GTK_JUSTIFY_LEFT);
gtk_label_set_line_wrap(GTK_LABEL(fileinfo_playername_txt),
TRUE);
gtk_misc_set_alignment(GTK_MISC(fileinfo_playername_txt), 0,
0.5);
gtk_misc_set_padding(GTK_MISC(fileinfo_playername_txt), 5, 5);
fileinfo_playerinfo_button = gtk_button_new_with_label("?");
GTK_WIDGET_SET_FLAGS(fileinfo_playerinfo_button,
GTK_CAN_DEFAULT);
gtk_signal_connect_object(GTK_OBJECT
(fileinfo_playerinfo_button),
"clicked",
GTK_SIGNAL_FUNC(uade_player_info),
NULL);
gtk_box_pack_start(GTK_BOX(fileinfo_playername_hbox),
fileinfo_playername_txt, TRUE, TRUE, 0);
gtk_box_pack_start_defaults(GTK_BOX(fileinfo_playername_hbox),
fileinfo_playerinfo_button);
fileinfo_hrule4 = gtk_hseparator_new();
gtk_table_attach(GTK_TABLE(fileinfo_table), fileinfo_hrule4, 1,
2, 6, 7, (GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
fileinfo_subsong_txt =
gtk_label_new(g_strdup_printf("%d", uade_get_cur_subsong(0)));
/* gtk_widget_setusize for this widget is a bit of a cludge to set
a minimal size for the FileinfoWindow. I can't get it to work either with
setting the usize for the window or the table... weird */
gtk_widget_set_usize(fileinfo_subsong_txt, 176, -2);
gtk_table_attach(GTK_TABLE(fileinfo_table),
fileinfo_subsong_txt, 1, 2, 7, 8,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify(GTK_LABEL(fileinfo_subsong_txt),
GTK_JUSTIFY_LEFT);
gtk_label_set_line_wrap(GTK_LABEL(fileinfo_subsong_txt), TRUE);
gtk_misc_set_alignment(GTK_MISC(fileinfo_subsong_txt), 0, 0.5);
gtk_misc_set_padding(GTK_MISC(fileinfo_subsong_txt), 5, 5);
/* 2x9*/
fileinfo_minsubsong_txt =
gtk_label_new(g_strdup_printf("%d", uade_get_min_subsong(0)));
gtk_table_attach(GTK_TABLE(fileinfo_table),
fileinfo_minsubsong_txt, 1, 2, 8, 9,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify(GTK_LABEL(fileinfo_minsubsong_txt),
GTK_JUSTIFY_LEFT);
gtk_label_set_line_wrap(GTK_LABEL(fileinfo_subsong_txt), TRUE);
gtk_misc_set_alignment(GTK_MISC(fileinfo_minsubsong_txt), 0,
0.5);
gtk_misc_set_padding(GTK_MISC(fileinfo_minsubsong_txt), 5, 5);
/* 2x10*/
fileinfo_maxsubsong_txt =
gtk_label_new(g_strdup_printf("%d", uade_get_max_subsong(0)));
gtk_table_attach(GTK_TABLE(fileinfo_table),
fileinfo_maxsubsong_txt, 1, 2, 9, 10,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify(GTK_LABEL(fileinfo_maxsubsong_txt),
GTK_JUSTIFY_LEFT);
gtk_label_set_line_wrap(GTK_LABEL(fileinfo_maxsubsong_txt),
TRUE);
gtk_misc_set_alignment(GTK_MISC(fileinfo_maxsubsong_txt), 0,
0.5);
gtk_misc_set_padding(GTK_MISC(fileinfo_maxsubsong_txt), 5, 5);
/* end of frame. */
/* Start of Ok and Cancel Button Box */
fileinfo_button_box = gtk_hbutton_box_new();
gtk_button_box_set_layout(GTK_BUTTON_BOX(fileinfo_button_box),
GTK_BUTTONBOX_END);
gtk_button_box_set_spacing(GTK_BUTTON_BOX(fileinfo_button_box),
5);
gtk_box_pack_start(GTK_BOX(fileinfo_base_vbox),
fileinfo_button_box, FALSE, FALSE, 0);
ok_button = gtk_button_new_with_label("Close");
GTK_WIDGET_SET_FLAGS(ok_button, GTK_CAN_DEFAULT);
gtk_signal_connect_object(GTK_OBJECT(ok_button), "clicked",
GTK_SIGNAL_FUNC(gtk_widget_destroy),
GTK_OBJECT(fileinfowin));
gtk_box_pack_start_defaults(GTK_BOX(fileinfo_button_box),
ok_button);
/* End of Button Box */
gtk_widget_show_all(fileinfowin);
} else {
gdk_window_raise(fileinfowin->window);
}
#ifdef __AUDACIOUS_INPUT_PLUGIN_API__
if (decoded != NULL)
free (decoded);
#endif
}
static void uade_mod_info(char *credits, int creditslen)
{
GtkWidget *modinfo_button_box;
GtkWidget *close_button;
GtkWidget *modinfo_base_vbox;
GtkWidget *uadeplay_scrolledwindow;
GtkWidget *uadeplay_textview;
GtkTextBuffer *uadeplay_textbuffer;
GtkTextIter textIter;
gchar *text =NULL;
GError *error = NULL;
if (!modinfowin) {
/* *sigh* code inflation to get just a simple fixed font text view*/
/* first we have to convert to utf-8 */
/* then we have to mess around with Iters,Tags, Views and Buffer */
/* gtk1.2 was easier to use in that aspect */
if (!g_utf8_validate (credits, -1, NULL))
{
text = g_locale_to_utf8 (credits, -1, NULL, NULL, &error);
if (!text)
{
g_error_free (error);
text = g_convert_with_fallback(credits, creditslen, "UTF8", "ISO-8859-1", ".", NULL, NULL, NULL);
if (!text) text = g_strdup ("unable to convert to UTF-8");
}
} else text = g_strdup (credits);
modinfowin = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(modinfowin), "UADE Modinfo");
gtk_window_set_position(GTK_WINDOW(modinfowin), GTK_WIN_POS_MOUSE);
gtk_container_set_border_width(GTK_CONTAINER(modinfowin), 10);
gtk_window_set_policy(GTK_WINDOW(modinfowin), FALSE, FALSE, FALSE);
gtk_signal_connect(GTK_OBJECT(modinfowin), "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroyed),
&modinfowin);
//Start of Contents Box
modinfo_base_vbox = gtk_vbox_new(FALSE, 10);
gtk_container_set_border_width(GTK_CONTAINER(modinfo_base_vbox),
5);
gtk_container_add(GTK_CONTAINER(modinfowin), modinfo_base_vbox);
uadeplay_scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_set_usize(uadeplay_scrolledwindow, 600, 256);
gtk_container_add(GTK_CONTAINER(modinfo_base_vbox),
uadeplay_scrolledwindow);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW
(uadeplay_scrolledwindow),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
uadeplay_textview = gtk_text_view_new();
gtk_text_view_set_editable(GTK_TEXT_VIEW(uadeplay_textview), FALSE);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(uadeplay_scrolledwindow), uadeplay_textview);
uadeplay_textbuffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(uadeplay_textview));
gtk_text_view_set_buffer(GTK_TEXT_VIEW(uadeplay_textview), uadeplay_textbuffer);
gtk_text_buffer_get_iter_at_offset(GTK_TEXT_BUFFER(uadeplay_textbuffer), &textIter,0);
gtk_text_buffer_create_tag (uadeplay_textbuffer, "monospaced",
"family", "Monospace",
"wrap_mode", GTK_WRAP_NONE,
NULL);
gtk_text_buffer_insert_with_tags_by_name(uadeplay_textbuffer,
&textIter,
text, -1,
"monospaced", NULL);
gtk_text_view_set_buffer(GTK_TEXT_VIEW(uadeplay_textview), uadeplay_textbuffer);
// Start of Close Button Box
modinfo_button_box = gtk_hbutton_box_new();
gtk_button_box_set_layout(GTK_BUTTON_BOX(modinfo_button_box),
GTK_BUTTONBOX_END);
gtk_button_box_set_spacing(GTK_BUTTON_BOX(modinfo_button_box), 5);
gtk_box_pack_start(GTK_BOX(modinfo_base_vbox), modinfo_button_box,
FALSE, FALSE, 0);
close_button = gtk_button_new_with_label("Close");
GTK_WIDGET_SET_FLAGS(close_button, GTK_CAN_DEFAULT);
gtk_signal_connect_object(GTK_OBJECT(close_button), "clicked",
GTK_SIGNAL_FUNC(gtk_widget_destroy),
GTK_OBJECT(modinfowin));
gtk_box_pack_start_defaults(GTK_BOX(modinfo_button_box),
close_button);
gtk_widget_show_all(modinfowin);
} else {
gdk_window_raise(modinfowin->window);
}
}
void edit_properties(GtkWidget *widget, gpointer data)
{
GtkWidget *props_window;
GtkWidget *main_box;
GtkWidget *settings_box;
GtkWidget *wide_box;
GtkWidget *general_frame;
GtkWidget *general_box;
GtkWidget *syntax_frame;
GtkWidget *syntax_box;
GtkWidget *bracket_frame;
GtkWidget *bracket_box;
GtkWidget *tabs_frame;
GtkWidget *tabs_box;
GtkWidget *compile_frame;
GtkWidget *compile_box;
GtkWidget *util_box;
GtkWidget *util_label;
GtkWidget *buttons_box;
GtkWidget *ok_button;
GtkWidget *defaults_button;
GtkWidget *undo_button;
GtkWidget *close_button;
FileProps *file_props;
gchar *chars = NULL;
GtkWidget *hsep;
if(cur_file->props_dialog && GTK_IS_WINDOW(cur_file->props_dialog))
{
gdk_window_raise(cur_file->props_dialog->window);
return;
}
file_props = g_new(FileProps, 1);
file_props->defaults = cur_file->tables ? &cur_file->tables->props : NULL;
file_props->current = &cur_file->props;
file_props->backups = g_new(GdsFileProperties, 1);
copy_properties(file_props->backups, file_props->current);
props_window = gtk_window_new(GTK_WINDOW_DIALOG);
gtk_container_set_border_width(GTK_CONTAINER(props_window), 5);
chars = g_strconcat(_("GdsFileProperties Editor - "), cur_file->filename, NULL);
gtk_window_set_title(GTK_WINDOW(props_window), chars);
g_free(chars);
cur_file->props_dialog = props_window;
main_box = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(props_window), main_box);
gtk_widget_show(main_box);
settings_box = gtk_vbox_new(FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(settings_box), 0);
gtk_box_pack_start(GTK_BOX(main_box), settings_box, FALSE, FALSE, 0);
gtk_widget_show(settings_box);
/* File Settings */
general_frame = gtk_frame_new(_("File Specific Settings"));
gtk_box_pack_start(GTK_BOX(settings_box), general_frame, FALSE, FALSE, 0);
gtk_widget_show(general_frame);
wide_box = gtk_hbox_new(FALSE, 5);
gtk_container_set_border_width(GTK_CONTAINER(wide_box), 5);
gtk_container_add(GTK_CONTAINER(general_frame), wide_box);
gtk_widget_show(wide_box);
general_box = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(wide_box), general_box, TRUE, TRUE, 0);
gtk_widget_show(general_box);
util_box = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(general_box), util_box, TRUE, TRUE, 5);
gtk_container_set_border_width(GTK_CONTAINER(util_box), 5);
gtk_widget_show(util_box);
file_props->over_ride = make_button(_("Override defaults ?"), util_box, &file_props->current->over_ride);
util_box = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(general_box), util_box, TRUE, TRUE, 5);
gtk_widget_show(util_box);
util_label = gtk_label_new(_("Directory:"));
gtk_box_pack_start(GTK_BOX(util_box), util_label, FALSE, FALSE, 0);
gtk_widget_show(util_label);
file_props->dir = gnome_direntry_new();
gtk_box_pack_start(GTK_BOX(util_box), file_props->dir, TRUE, TRUE, 0);
gtk_widget_show(file_props->dir);
bracket_frame = gtk_frame_new(_("Bracket Highlighting"));
gtk_box_pack_start(GTK_BOX(general_box), bracket_frame, FALSE, FALSE, 0);
gtk_widget_show(bracket_frame);
bracket_box = gtk_vbox_new(FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(bracket_box), 5);
gtk_container_add(GTK_CONTAINER(bracket_frame), bracket_box);
gtk_widget_show(bracket_box);
util_box = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(bracket_box), util_box, FALSE, TRUE, 0);
gtk_widget_show(util_box);
file_props->bracketmatch = make_button(_("Enable bracket highlighting ?"), util_box, &file_props->current->bracketmatch);
syntax_frame = gtk_frame_new(_("Syntax Highlighting"));
gtk_box_pack_start(GTK_BOX(general_box), syntax_frame, FALSE, FALSE, 0);
gtk_widget_show(syntax_frame);
syntax_box = gtk_vbox_new(FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(syntax_box), 5);
gtk_container_add(GTK_CONTAINER(syntax_frame), syntax_box);
gtk_widget_show(syntax_box);
util_box = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(syntax_box), util_box, FALSE, TRUE, 0);
gtk_widget_show(util_box);
file_props->syntax = make_button(_("Enable syntax highlighting ?"), util_box, &file_props->current->syntax);
tabs_frame = gtk_frame_new(_("Indentation"));
gtk_box_pack_start(GTK_BOX(general_box), tabs_frame, TRUE, TRUE, 0);
gtk_widget_show(tabs_frame);
tabs_box = gtk_vbox_new(FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(tabs_box), 5);
gtk_container_add(GTK_CONTAINER(tabs_frame), tabs_box);
gtk_widget_show(tabs_box);
util_box = gtk_hbox_new(FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(util_box), 5);
gtk_box_pack_start(GTK_BOX(tabs_box), util_box, TRUE, TRUE, 0);
gtk_widget_show(util_box);
file_props->auto_indent = make_button(_("Auto Indent ?"), util_box, &file_props->current->auto_indent);
util_box = gtk_hbox_new(FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(util_box), 5);
gtk_box_pack_start(GTK_BOX(tabs_box), util_box, TRUE, TRUE, 0);
gtk_widget_show(util_box);
file_props->use_spaces = make_button(_("Use spaces instead of tabs ?"), util_box, &file_props->current->use_spaces);
util_box = gtk_hbox_new(FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(util_box), 5);
gtk_box_pack_start(GTK_BOX(tabs_box), util_box, TRUE, TRUE, 0);
gtk_widget_show(util_box);
util_label = gtk_label_new(_("Tab stop:"));
gtk_box_pack_start(GTK_BOX(util_box), util_label, FALSE, FALSE, 0);
gtk_widget_show(util_label);
file_props->spaces_spin = gtk_spin_button_new(GTK_ADJUSTMENT(gtk_adjustment_new(0, 1, 8, 1, 2, 0)), 1, 0);
gtk_box_pack_start(GTK_BOX(util_box), file_props->spaces_spin, TRUE, TRUE, 0);
gtk_widget_show(file_props->spaces_spin);
compile_frame = gtk_frame_new(_("Build Information"));
gtk_box_pack_start(GTK_BOX(wide_box), compile_frame, TRUE, TRUE, 0);
gtk_widget_show(compile_frame);
compile_box = gtk_vbox_new(FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(compile_box), 5);
gtk_container_add(GTK_CONTAINER(compile_frame), compile_box);
gtk_widget_show(compile_box);
util_box = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(compile_box), util_box, TRUE, TRUE, 5);
gtk_widget_show(util_box);
util_label = gtk_label_new(_("Compiler: "));
gtk_box_pack_start(GTK_BOX(util_box), util_label, FALSE, FALSE, 0);
gtk_widget_show(util_label);
file_props->compiler = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(util_box), file_props->compiler, TRUE, TRUE, 0);
gtk_widget_show(file_props->compiler);
util_box = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(compile_box), util_box, TRUE, TRUE, 5);
gtk_widget_show(util_box);
util_label = gtk_label_new(_("Debugger: "));
gtk_box_pack_start(GTK_BOX(util_box), util_label, FALSE, FALSE, 0);
gtk_widget_show(util_label);
file_props->debugger = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(util_box), file_props->debugger, TRUE, TRUE, 0);
gtk_widget_show(file_props->debugger);
util_box = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(compile_box), util_box, TRUE, TRUE, 5);
gtk_widget_show(util_box);
util_label = gtk_label_new(_("Execution: "));
gtk_box_pack_start(GTK_BOX(util_box), util_label, FALSE, FALSE, 0);
gtk_widget_show(util_label);
file_props->execution = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(util_box), file_props->execution, TRUE, TRUE, 0);
gtk_widget_show(file_props->execution);
hsep = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(main_box), hsep, FALSE, TRUE, 10);
gtk_widget_show(hsep);
buttons_box = gtk_hbutton_box_new();
gtk_box_pack_start(GTK_BOX(main_box), buttons_box, FALSE, TRUE, 0);
gtk_button_box_set_layout(GTK_BUTTON_BOX(buttons_box), gnome_preferences_get_button_layout());
gtk_button_box_set_spacing(GTK_BUTTON_BOX(buttons_box), GNOME_PAD);
gtk_widget_show(buttons_box);
ok_button = gnome_stock_button(GNOME_STOCK_BUTTON_OK);
gtk_box_pack_start(GTK_BOX(buttons_box), ok_button, FALSE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT(ok_button), "clicked", GTK_SIGNAL_FUNC(save_properties), file_props);
gtk_signal_connect(GTK_OBJECT(ok_button), "clicked", GTK_SIGNAL_FUNC(set_properties), cur_file);
gtk_signal_connect(GTK_OBJECT(ok_button), "clicked", GTK_SIGNAL_FUNC(kill_widget), GTK_OBJECT(props_window));
GTK_WIDGET_SET_FLAGS(ok_button, GTK_CAN_DEFAULT);
gtk_widget_show(ok_button);
defaults_button = gnome_stock_or_ordinary_button(_("Defaults"));
gtk_box_pack_start(GTK_BOX(buttons_box), defaults_button, FALSE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT(defaults_button), "clicked", GTK_SIGNAL_FUNC(get_default_props), file_props);
GTK_WIDGET_SET_FLAGS(defaults_button, GTK_CAN_DEFAULT);
gtk_widget_show(defaults_button);
undo_button = gnome_stock_or_ordinary_button(_("Undo"));
gtk_box_pack_start(GTK_BOX(buttons_box), undo_button, FALSE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT(undo_button), "clicked", GTK_SIGNAL_FUNC(get_backup_props), file_props);
GTK_WIDGET_SET_FLAGS(undo_button, GTK_CAN_DEFAULT);
gtk_widget_show(undo_button);
close_button = gnome_stock_button(GNOME_STOCK_BUTTON_CLOSE);
gtk_box_pack_end(GTK_BOX(buttons_box), close_button, FALSE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT(close_button), "clicked", GTK_SIGNAL_FUNC(kill_widget), GTK_OBJECT(props_window));
gtk_signal_connect(GTK_OBJECT(close_button), "clicked", GTK_SIGNAL_FUNC(redo_backup_props), file_props);
GTK_WIDGET_SET_FLAGS(close_button, GTK_CAN_DEFAULT);
gtk_widget_grab_default(close_button);
gtk_widget_show(close_button);
gtk_signal_connect(GTK_OBJECT(props_window), "destroy", GTK_SIGNAL_FUNC(kill_widget_ptr), &cur_file->props_dialog);
gtk_signal_connect(GTK_OBJECT(props_window), "destroy", GTK_SIGNAL_FUNC(free_properties), file_props->backups);
gtk_signal_connect(GTK_OBJECT(props_window), "destroy", GTK_SIGNAL_FUNC(kill_data), file_props);
put_properties(file_props, file_props->current);
gtk_widget_show(props_window);
}
GtkWindow * gw_categories_edit_box_create ( GtkWindow *window, GWDBCatalog *catalog) {
/* This window must be single, this property may be changed */
static GtkWidget *w = NULL;
GtkWidget *vb, *hb, *scr, *list, *bt, *hsp, *ent, *lbl, *frm, *txt;
guint bt_key;
GtkAccelGroup *accel;
GtkTooltips *tips;
gchar *text_utf8 = NULL;
#ifdef GW_DEBUG_GUI_COMPONENT
g_print ( "*** GW - %s (%d) :: %s()\n", __FILE__, __LINE__, __PRETTY_FUNCTION__);
#endif
/* Init an accel group for shortcuts */
accel = gtk_accel_group_new ( );
/* Init tooltips */
tips = gtk_tooltips_new ( );
if ( !w ) {
w = gtk_window_new ( GTK_WINDOW_TOPLEVEL);
gtk_window_set_modal ( GTK_WINDOW ( w), TRUE);
gtk_window_set_transient_for ( GTK_WINDOW ( w), window);
gtk_window_set_position ( GTK_WINDOW ( w), GTK_WIN_POS_CENTER);
gtk_window_set_policy ( GTK_WINDOW ( w), FALSE, FALSE, FALSE);
g_strdup_to_gtk_text ( _( "Edit categories"), text_utf8);
gtk_window_set_title ( GTK_WINDOW ( w), text_utf8);
g_free ( text_utf8);
gtk_container_set_border_width ( GTK_CONTAINER ( w), 5);
gtk_object_set_data ( GTK_OBJECT ( w), GW_REF_CATEGORIES_EDIT_BOX_MAIN_WINDOW, window);
gtk_signal_connect ( GTK_OBJECT ( w), "destroy", GTK_SIGNAL_FUNC (gtk_widget_destroyed), &w);
/* Vertical box */
vb = gtk_vbox_new ( FALSE, 10);
gtk_container_add ( GTK_CONTAINER ( w), vb);
/* Frame category description */
g_strdup_to_gtk_text ( _( "Categories list : "), text_utf8);
frm = gtk_frame_new ( text_utf8);
g_free ( text_utf8);
gtk_box_pack_start ( GTK_BOX ( vb), frm, TRUE, TRUE, 0);
/* 1st horizontal box*/
hb = gtk_hbox_new ( TRUE, 0);
gtk_container_set_border_width ( GTK_CONTAINER ( hb), 5);
gtk_container_add ( GTK_CONTAINER ( frm), hb);
/* Scrolled panel */
scr = gtk_scrolled_window_new ( NULL, NULL);
gtk_box_pack_start ( GTK_BOX ( hb), scr, TRUE, TRUE, 0);
/* Categories list */
list = gtk_clist_new ( 2);
gtk_widget_set_usize ( list, 100, 100);
/*gtk_widget_ref ( list);*/
gtk_object_set_data_full ( GTK_OBJECT ( w), GW_REF_CATEGORIES_EDIT_BOX_CATEGORIES_LIST, list, /*(GtkDestroyNotify)gtk_widget_unref*/NULL);
/*gtk_signal_connect ( GTK_OBJECT ( list), "click_column", GTK_SIGNAL_FUNC ( gw_categories_edit_box_list_click_column), w);*/
gtk_signal_connect ( GTK_OBJECT ( list), "select_row", GTK_SIGNAL_FUNC ( gw_categories_edit_box_list_select_row), w);
gtk_container_add ( GTK_CONTAINER ( scr), list);
gtk_clist_set_column_width ( GTK_CLIST ( list), 0, 80);
gtk_clist_set_column_width ( GTK_CLIST ( list), 1, 20);
gtk_clist_column_titles_show ( GTK_CLIST ( list));
/* 1st column label */
g_strdup_to_gtk_text ( _( "Name"), text_utf8);
lbl = gtk_label_new ( text_utf8);
g_free ( text_utf8);
gtk_clist_set_column_widget ( GTK_CLIST ( list), 0, lbl);
/* 2nd column label */
g_strdup_to_gtk_text ( _( "Description"), text_utf8);
lbl = gtk_label_new ( text_utf8);
g_free ( text_utf8);
gtk_clist_set_column_widget ( GTK_CLIST ( list), 1, lbl);
/* 2nd horizontal box */
hb = gtk_hbox_new ( TRUE, 0);
gtk_box_pack_start ( GTK_BOX ( vb), hb, TRUE, TRUE, 0);
/* Update button */
bt = gtk_button_new_with_label ( "");
g_strdup_to_gtk_text ( _( "_Update"), text_utf8);
bt_key = gtk_label_parse_uline ( GTK_LABEL ( GTK_BIN ( bt)->child), text_utf8);
g_free ( text_utf8);
gtk_object_set_data_full ( GTK_OBJECT ( w), GW_REF_CATEGORIES_EDIT_BOX_UPDATE_BUTTON, bt, /*(GtkDestroyNotify)gtk_widget_unref*/NULL);
gtk_widget_add_accelerator ( bt, "clicked", accel, bt_key, GDK_MOD1_MASK, 0);
gtk_signal_connect ( GTK_OBJECT ( bt), "clicked", GTK_SIGNAL_FUNC ( gw_categories_edit_box_update_click), GTK_WINDOW ( w));
gtk_object_set_user_data ( GTK_OBJECT ( bt), w);
gtk_box_pack_start ( GTK_BOX ( hb), bt, FALSE, TRUE, 5);
g_strdup_to_gtk_text ( _( "Allows to update category properties of the selected category. Clicks on Add / Update button to save updates."), text_utf8);
gtk_tooltips_set_tip ( tips, bt, text_utf8, GW_REF_CATEGORIES_EDIT_BOX_UPDATE_BUTTON_TOOLTIPS);
g_free ( text_utf8);
gtk_widget_set_sensitive ( GTK_WIDGET ( bt), FALSE);
/* Remove button */
bt = gtk_button_new_with_label ( "");
g_strdup_to_gtk_text ( _( "_Remove"), text_utf8);
bt_key = gtk_label_parse_uline ( GTK_LABEL ( GTK_BIN ( bt)->child), text_utf8);
g_free ( text_utf8);
gtk_object_set_data_full ( GTK_OBJECT ( w), GW_REF_CATEGORIES_EDIT_BOX_REMOVE_BUTTON, bt, /*(GtkDestroyNotify) gtk_widget_unref)*/NULL);
gtk_widget_add_accelerator ( bt, "clicked", accel, bt_key, GDK_MOD1_MASK, 0);
gtk_signal_connect ( GTK_OBJECT ( bt), "clicked", GTK_SIGNAL_FUNC ( gw_categories_edit_box_remove_click), GTK_WINDOW ( w));
gtk_object_set_user_data ( GTK_OBJECT ( bt), w);
gtk_box_pack_start ( GTK_BOX ( hb), bt, FALSE, TRUE, 5);
g_strdup_to_gtk_text ( _( "Remove the selected category from categories list. This categories may removed only if there's not any item which uses this category."), text_utf8);
gtk_tooltips_set_tip ( tips, bt, text_utf8, GW_REF_CATEGORIES_EDIT_BOX_REMOVE_BUTTON_TOOLTIPS);
g_free ( text_utf8);
gtk_widget_set_sensitive ( GTK_WIDGET ( bt), FALSE);
/* 1st horizontal separator */
hsp = gtk_hseparator_new ( );
gtk_box_pack_start ( GTK_BOX ( vb), hsp, TRUE, TRUE, 0);
/* 3rd horizontal box */
hb = gtk_hbox_new ( FALSE, 0);
gtk_box_pack_start ( GTK_BOX ( vb), hb, TRUE, TRUE, 0);
/* Label for category name */
g_strdup_to_gtk_text ( _( "Category name : "), text_utf8);
lbl = gtk_label_new ( text_utf8);
g_free ( text_utf8);
gtk_box_pack_start ( GTK_BOX ( hb), lbl, FALSE, FALSE, 5);
/* Field text for category name */
ent = gtk_entry_new ( );
/*gtk_widget_ref ( ent);*/
gtk_object_set_data_full ( GTK_OBJECT ( w), GW_REF_CATEGORIES_EDIT_BOX_CATEGORY_NAME_ENTRY, ent, /*(GtkDestroyNotify)gtk_widget_unref*/NULL);
gtk_signal_connect ( GTK_OBJECT ( ent), "changed", GTK_SIGNAL_FUNC ( gw_categories_edit_box_category_name_changed), w);
gtk_box_pack_start ( GTK_BOX ( hb), ent, TRUE, TRUE, 5);
g_strdup_to_gtk_text ( _( "Enter the name of the category."), text_utf8);
gtk_tooltips_set_tip ( tips, ent, text_utf8, GW_REF_CATEGORIES_EDIT_BOX_CATEGORY_NAME_ENTRY_TOOLTIPS);
g_free ( text_utf8);
/* Frame category description */
g_strdup_to_gtk_text ( _( "Description : "), text_utf8);
frm = gtk_frame_new ( text_utf8);
g_free ( text_utf8);
gtk_box_pack_start ( GTK_BOX ( vb), frm, TRUE, TRUE, 0);
/* 4th horizontal box */
hb = gtk_hbox_new ( TRUE, 0);
gtk_container_set_border_width ( GTK_CONTAINER ( hb), 5);
gtk_container_add ( GTK_CONTAINER ( frm), hb);
/* Text scrollbar */
scr = gtk_scrolled_window_new ( NULL, NULL);
gtk_box_pack_start ( GTK_BOX ( hb), scr, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy ( GTK_SCROLLED_WINDOW ( scr), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
/* Text area for category description */
txt = gtk_text_area_new ( );
gtk_text_area_set_editable ( GTK_TEXT_AREA ( txt), TRUE);
gtk_object_set_data_full ( GTK_OBJECT ( w), GW_REF_CATEGORIES_EDIT_BOX_CATEGORY_DESCRIPTION_TEXT, txt, /*(GtkDestroyNotify)gtk_widget_unref*/NULL);
#if defined ( HAVE_GTK12)
gtk_signal_connect ( GTK_OBJECT ( txt), "changed", GTK_SIGNAL_FUNC ( gw_categories_edit_box_category_description_changed), w);
#elif defined ( HAVE_GTK20)
g_signal_connect ( G_OBJECT ( gtk_text_view_get_buffer ( GTK_TEXT_VIEW ( txt))), "changed", GTK_SIGNAL_FUNC ( gw_categories_edit_box_category_description_changed), w);
#endif
gtk_container_add ( GTK_CONTAINER ( scr), txt);
g_strdup_to_gtk_text ( _( "Enter the description of the category."), text_utf8);
gtk_tooltips_set_tip ( tips, txt, text_utf8, GW_REF_CATEGORIES_EDIT_BOX_CATEGORY_DESCRIPTION_TEXT_TOOLTIPS);
g_free ( text_utf8);
/* The Add/Update/Close button area */
hb = gtk_hbutton_box_new ( );
gtk_button_box_set_layout ( GTK_BUTTON_BOX ( hb), GTK_BUTTONBOX_END);
gtk_button_box_set_spacing ( GTK_BUTTON_BOX ( hb), 5);
gtk_box_pack_end ( GTK_BOX ( vb), hb, FALSE, FALSE, 0);
/* Add/Update button */
bt = gtk_button_new_with_label ( "");
/* Is it not mandatory? */
/*g_strdup_to_gtk_text ( _( "Add"), text_utf8);
gtk_label_set_text ( GTK_LABEL ( GTK_BIN ( bt)->child), text_utf8);
g_free ( text_utf8);
*/
/*gtk_widget_ref ( bt);*/
gtk_object_set_data_full ( GTK_OBJECT ( w), GW_REF_CATEGORIES_EDIT_BOX_ADD_UPDATE_BUTTON, bt, /*(GtkDestroyNotify)gtk_widget_unref*/NULL);
g_strdup_to_gtk_text ( _( "Add / Update"), text_utf8);
bt_key = gtk_label_parse_uline ( GTK_LABEL ( GTK_BIN ( bt)->child), text_utf8);
g_free ( text_utf8);
gtk_widget_add_accelerator ( bt, "clicked", accel, bt_key, GDK_MOD1_MASK, 0);
gtk_signal_connect ( GTK_OBJECT ( bt), "clicked", GTK_SIGNAL_FUNC ( gw_categories_edit_box_add_update_click), w);
gtk_object_set_user_data ( GTK_OBJECT ( bt), w);
gtk_box_pack_start ( GTK_BOX ( hb), bt, TRUE, TRUE, 5);
g_strdup_to_gtk_text ( _( "Save properties changes of category."), text_utf8);
gtk_tooltips_set_tip ( tips, bt, text_utf8, GW_REF_CATEGORIES_EDIT_BOX_ADD_UPDATE_BUTTON_TOOLTIPS);
g_free ( text_utf8);
gtk_widget_set_sensitive ( GTK_WIDGET ( bt), FALSE);
GTK_WIDGET_SET_FLAGS ( bt, GTK_CAN_FOCUS);
GTK_WIDGET_SET_FLAGS ( bt, GTK_CAN_DEFAULT);
gtk_widget_grab_default ( bt);
/* Close button */
bt = gtk_button_new_with_label ( "");
g_strdup_to_gtk_text ( _( "Close"), text_utf8);
bt_key = gtk_label_parse_uline ( GTK_LABEL ( GTK_BIN ( bt)->child), text_utf8);
g_free ( text_utf8);
gtk_widget_add_accelerator ( bt, "clicked", accel, bt_key, GDK_MOD1_MASK, 0);
gtk_signal_connect_object ( GTK_OBJECT ( bt), "clicked", GTK_SIGNAL_FUNC ( gtk_widget_destroy), GTK_OBJECT ( w));
gtk_object_set_user_data ( GTK_OBJECT ( bt), w);
gtk_box_pack_start ( GTK_BOX ( hb), bt, TRUE, TRUE, 5);
g_strdup_to_gtk_text ( _( "Close the categories properties edit window."), text_utf8);
gtk_tooltips_set_tip ( tips, bt, text_utf8, GW_REF_CATEGORIES_EDIT_BOX_CLOSE_BUTTON_TOOLTIPS);
g_free ( text_utf8);
GTK_WIDGET_SET_FLAGS ( bt, GTK_CAN_FOCUS);
gtk_window_add_accel_group ( GTK_WINDOW ( w), accel);
}
if ( !GTK_WIDGET_VISIBLE ( w) ) {
#ifdef GW_DEBUG_GUI_COMPONENT
g_print ( "*** GW - %s (%d) :: %s() : show the window\n", __FILE__, __LINE__, __PRETTY_FUNCTION__);
#endif
gtk_widget_show_all ( w);
} else {
#ifdef GW_DEBUG_GUI_COMPONENT
g_print ( "*** GW - %s (%d) :: %s() : destroy the window\n", __FILE__, __LINE__, __PRETTY_FUNCTION__);
#endif
gtk_widget_destroy ( w);
}
gw_categories_edit_box_load_categories_list ( GTK_WINDOW ( w));
return GTK_WINDOW ( w);
}
void FLAC_XMMS__configure(void)
{
GtkWidget *title_frame, *title_tag_vbox, *title_tag_label;
GtkWidget *replaygain_frame, *resolution_frame, *output_vbox, *resolution_normal_frame, *resolution_replaygain_frame;
GtkWidget *replaygain_vbox, *resolution_hbox, *resolution_normal_vbox, *resolution_replaygain_vbox;
GtkWidget *resolution_replaygain_noise_shaping_vbox;
GtkWidget *resolution_replaygain_bps_out_vbox;
GtkWidget *label, *hbox;
GtkWidget *bbox, *ok, *cancel;
GList *list;
GtkWidget *streaming_vbox;
GtkWidget *streaming_buf_frame, *streaming_buf_hbox;
GtkWidget *streaming_size_box, *streaming_size_label, *streaming_size_spin;
GtkWidget *streaming_pre_box, *streaming_pre_label, *streaming_pre_spin;
GtkWidget *streaming_proxy_frame, *streaming_proxy_vbox;
GtkWidget *streaming_proxy_port_label, *streaming_proxy_host_label;
GtkWidget *streaming_save_frame, *streaming_save_vbox;
GtkWidget *streaming_save_label, *streaming_save_browse;
#ifdef FLAC_ICECAST
GtkWidget *streaming_cast_frame, *streaming_cast_vbox;
#endif
char *temp;
if (flac_configurewin != NULL) {
gdk_window_raise(flac_configurewin->window);
return;
}
flac_configurewin = gtk_window_new(GTK_WINDOW_DIALOG);
gtk_signal_connect(GTK_OBJECT(flac_configurewin), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &flac_configurewin);
gtk_signal_connect(GTK_OBJECT(flac_configurewin), "destroy", GTK_SIGNAL_FUNC(configure_destroy), &flac_configurewin);
gtk_window_set_title(GTK_WINDOW(flac_configurewin), _("Flac Configuration"));
gtk_window_set_policy(GTK_WINDOW(flac_configurewin), FALSE, FALSE, FALSE);
gtk_container_border_width(GTK_CONTAINER(flac_configurewin), 10);
vbox = gtk_vbox_new(FALSE, 10);
gtk_container_add(GTK_CONTAINER(flac_configurewin), vbox);
notebook = gtk_notebook_new();
gtk_box_pack_start(GTK_BOX(vbox), notebook, TRUE, TRUE, 0);
/* Title config.. */
title_frame = gtk_frame_new(_("Tag Handling"));
gtk_container_border_width(GTK_CONTAINER(title_frame), 5);
title_tag_vbox = gtk_vbox_new(FALSE, 10);
gtk_container_border_width(GTK_CONTAINER(title_tag_vbox), 5);
gtk_container_add(GTK_CONTAINER(title_frame), title_tag_vbox);
/* Convert Char Set */
convert_char_set = gtk_check_button_new_with_label(_("Convert Character Set"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(convert_char_set), flac_cfg.title.convert_char_set);
gtk_signal_connect(GTK_OBJECT(convert_char_set), "clicked", convert_char_set_cb, NULL);
gtk_box_pack_start(GTK_BOX(title_tag_vbox), convert_char_set, FALSE, FALSE, 0);
/* Combo boxes... */
hbox = gtk_hbox_new(FALSE,4);
gtk_container_add(GTK_CONTAINER(title_tag_vbox),hbox);
label = gtk_label_new(_("Convert character set from :"));
gtk_box_pack_start(GTK_BOX(hbox),label,FALSE,FALSE,0);
fileCharacterSetEntry = gtk_combo_new();
gtk_box_pack_start(GTK_BOX(hbox),fileCharacterSetEntry,TRUE,TRUE,0);
label = gtk_label_new (_("to :"));
gtk_box_pack_start(GTK_BOX(hbox),label,FALSE,FALSE,0);
userCharacterSetEntry = gtk_combo_new();
gtk_box_pack_start(GTK_BOX(hbox),userCharacterSetEntry,TRUE,TRUE,0);
gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(fileCharacterSetEntry)->entry),FALSE);
gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(userCharacterSetEntry)->entry),FALSE);
gtk_combo_set_value_in_list(GTK_COMBO(fileCharacterSetEntry),TRUE,FALSE);
gtk_combo_set_value_in_list(GTK_COMBO(userCharacterSetEntry),TRUE,FALSE);
list = Charset_Create_List();
gtk_combo_set_popdown_strings(GTK_COMBO(fileCharacterSetEntry),Charset_Create_List_UTF8_Only());
gtk_combo_set_popdown_strings(GTK_COMBO(userCharacterSetEntry),list);
gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(userCharacterSetEntry)->entry),Charset_Get_Title_From_Name(flac_cfg.title.user_char_set));
gtk_widget_set_sensitive(fileCharacterSetEntry, FALSE);
gtk_widget_set_sensitive(userCharacterSetEntry, flac_cfg.title.convert_char_set);
/* Override Tagging Format */
title_tag_override = gtk_check_button_new_with_label(_("Override generic titles"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(title_tag_override), flac_cfg.title.tag_override);
gtk_signal_connect(GTK_OBJECT(title_tag_override), "clicked", title_tag_override_cb, NULL);
gtk_box_pack_start(GTK_BOX(title_tag_vbox), title_tag_override, FALSE, FALSE, 0);
title_tag_box = gtk_hbox_new(FALSE, 5);
gtk_widget_set_sensitive(title_tag_box, flac_cfg.title.tag_override);
gtk_box_pack_start(GTK_BOX(title_tag_vbox), title_tag_box, FALSE, FALSE, 0);
title_tag_label = gtk_label_new(_("Title format:"));
gtk_box_pack_start(GTK_BOX(title_tag_box), title_tag_label, FALSE, FALSE, 0);
title_tag_entry = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(title_tag_entry), flac_cfg.title.tag_format);
gtk_box_pack_start(GTK_BOX(title_tag_box), title_tag_entry, TRUE, TRUE, 0);
title_desc = xmms_titlestring_descriptions("pafFetnygc", 2);
gtk_widget_set_sensitive(title_desc, flac_cfg.title.tag_override);
gtk_box_pack_start(GTK_BOX(title_tag_vbox), title_desc, FALSE, FALSE, 0);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), title_frame, gtk_label_new(_("Title")));
/* Output config.. */
output_vbox = gtk_vbox_new(FALSE, 10);
gtk_container_border_width(GTK_CONTAINER(output_vbox), 5);
/* replaygain */
replaygain_frame = gtk_frame_new(_("ReplayGain"));
gtk_container_border_width(GTK_CONTAINER(replaygain_frame), 5);
gtk_box_pack_start(GTK_BOX(output_vbox), replaygain_frame, TRUE, TRUE, 0);
replaygain_vbox = gtk_vbox_new(FALSE, 10);
gtk_container_border_width(GTK_CONTAINER(replaygain_vbox), 5);
gtk_container_add(GTK_CONTAINER(replaygain_frame), replaygain_vbox);
replaygain_enable = gtk_check_button_new_with_label(_("Enable ReplayGain processing"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(replaygain_enable), flac_cfg.output.replaygain.enable);
gtk_signal_connect(GTK_OBJECT(replaygain_enable), "clicked", replaygain_enable_cb, NULL);
gtk_box_pack_start(GTK_BOX(replaygain_vbox), replaygain_enable, FALSE, FALSE, 0);
replaygain_album_mode = gtk_check_button_new_with_label(_("Album mode"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(replaygain_album_mode), flac_cfg.output.replaygain.album_mode);
gtk_signal_connect(GTK_OBJECT(replaygain_album_mode), "clicked", replaygain_album_mode_cb, NULL);
gtk_box_pack_start(GTK_BOX(replaygain_vbox), replaygain_album_mode, FALSE, FALSE, 0);
hbox = gtk_hbox_new(FALSE,3);
gtk_container_add(GTK_CONTAINER(replaygain_vbox),hbox);
label = gtk_label_new(_("Preamp:"));
gtk_box_pack_start(GTK_BOX(hbox),label,FALSE,FALSE,0);
replaygain_preamp = gtk_adjustment_new(flac_cfg.output.replaygain.preamp, -24.0, +24.0, 1.0, 6.0, 0.0);
gtk_signal_connect(GTK_OBJECT(replaygain_preamp), "value-changed", replaygain_preamp_cb, NULL);
replaygain_preamp_hscale = gtk_hscale_new(GTK_ADJUSTMENT(replaygain_preamp));
gtk_scale_set_draw_value(GTK_SCALE(replaygain_preamp_hscale), FALSE);
gtk_box_pack_start(GTK_BOX(hbox),replaygain_preamp_hscale,TRUE,TRUE,0);
replaygain_preamp_label = gtk_label_new(_("0 dB"));
gtk_box_pack_start(GTK_BOX(hbox),replaygain_preamp_label,FALSE,FALSE,0);
gtk_adjustment_value_changed(GTK_ADJUSTMENT(replaygain_preamp));
replaygain_hard_limit = gtk_check_button_new_with_label(_("6dB hard limiting"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(replaygain_hard_limit), flac_cfg.output.replaygain.hard_limit);
gtk_signal_connect(GTK_OBJECT(replaygain_hard_limit), "clicked", replaygain_hard_limit_cb, NULL);
gtk_box_pack_start(GTK_BOX(replaygain_vbox), replaygain_hard_limit, FALSE, FALSE, 0);
replaygain_enable_cb(replaygain_enable, NULL);
/* resolution */
resolution_frame = gtk_frame_new(_("Resolution"));
gtk_container_border_width(GTK_CONTAINER(resolution_frame), 5);
gtk_box_pack_start(GTK_BOX(output_vbox), resolution_frame, TRUE, TRUE, 0);
resolution_hbox = gtk_hbox_new(FALSE, 10);
gtk_container_border_width(GTK_CONTAINER(resolution_hbox), 5);
gtk_container_add(GTK_CONTAINER(resolution_frame), resolution_hbox);
resolution_normal_frame = gtk_frame_new(_("Without ReplayGain"));
gtk_container_border_width(GTK_CONTAINER(resolution_normal_frame), 5);
gtk_box_pack_start(GTK_BOX(resolution_hbox), resolution_normal_frame, TRUE, TRUE, 0);
resolution_normal_vbox = gtk_vbox_new(FALSE, 10);
gtk_container_border_width(GTK_CONTAINER(resolution_normal_vbox), 5);
gtk_container_add(GTK_CONTAINER(resolution_normal_frame), resolution_normal_vbox);
resolution_normal_dither_24_to_16 = gtk_check_button_new_with_label(_("Dither 24bps to 16bps"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(resolution_normal_dither_24_to_16), flac_cfg.output.resolution.normal.dither_24_to_16);
gtk_signal_connect(GTK_OBJECT(resolution_normal_dither_24_to_16), "clicked", resolution_normal_dither_24_to_16_cb, NULL);
gtk_box_pack_start(GTK_BOX(resolution_normal_vbox), resolution_normal_dither_24_to_16, FALSE, FALSE, 0);
resolution_replaygain_frame = gtk_frame_new(_("With ReplayGain"));
gtk_container_border_width(GTK_CONTAINER(resolution_replaygain_frame), 5);
gtk_box_pack_start(GTK_BOX(resolution_hbox), resolution_replaygain_frame, TRUE, TRUE, 0);
resolution_replaygain_vbox = gtk_vbox_new(FALSE, 10);
gtk_container_border_width(GTK_CONTAINER(resolution_replaygain_vbox), 5);
gtk_container_add(GTK_CONTAINER(resolution_replaygain_frame), resolution_replaygain_vbox);
resolution_replaygain_dither = gtk_check_button_new_with_label(_("Enable dithering"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(resolution_replaygain_dither), flac_cfg.output.resolution.replaygain.dither);
gtk_signal_connect(GTK_OBJECT(resolution_replaygain_dither), "clicked", resolution_replaygain_dither_cb, NULL);
gtk_box_pack_start(GTK_BOX(resolution_replaygain_vbox), resolution_replaygain_dither, FALSE, FALSE, 0);
hbox = gtk_hbox_new(FALSE, 10);
gtk_container_border_width(GTK_CONTAINER(hbox), 5);
gtk_box_pack_start(GTK_BOX(resolution_replaygain_vbox), hbox, TRUE, TRUE, 0);
resolution_replaygain_noise_shaping_frame = gtk_frame_new(_("Noise shaping"));
gtk_container_border_width(GTK_CONTAINER(resolution_replaygain_noise_shaping_frame), 5);
gtk_box_pack_start(GTK_BOX(hbox), resolution_replaygain_noise_shaping_frame, TRUE, TRUE, 0);
resolution_replaygain_noise_shaping_vbox = gtk_vbutton_box_new();
gtk_container_border_width(GTK_CONTAINER(resolution_replaygain_noise_shaping_vbox), 5);
gtk_container_add(GTK_CONTAINER(resolution_replaygain_noise_shaping_frame), resolution_replaygain_noise_shaping_vbox);
resolution_replaygain_noise_shaping_radio_none = gtk_radio_button_new_with_label(NULL, _("none"));
if(flac_cfg.output.resolution.replaygain.noise_shaping == 0)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(resolution_replaygain_noise_shaping_radio_none), TRUE);
gtk_signal_connect(GTK_OBJECT(resolution_replaygain_noise_shaping_radio_none), "clicked", resolution_replaygain_noise_shaping_cb, NULL);
gtk_container_add(GTK_CONTAINER(resolution_replaygain_noise_shaping_vbox), resolution_replaygain_noise_shaping_radio_none);
resolution_replaygain_noise_shaping_radio_low = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(resolution_replaygain_noise_shaping_radio_none), _("low"));
if(flac_cfg.output.resolution.replaygain.noise_shaping == 1)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(resolution_replaygain_noise_shaping_radio_low), TRUE);
gtk_signal_connect(GTK_OBJECT(resolution_replaygain_noise_shaping_radio_low), "clicked", resolution_replaygain_noise_shaping_cb, NULL);
gtk_container_add(GTK_CONTAINER(resolution_replaygain_noise_shaping_vbox), resolution_replaygain_noise_shaping_radio_low);
resolution_replaygain_noise_shaping_radio_medium = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(resolution_replaygain_noise_shaping_radio_none), _("medium"));
if(flac_cfg.output.resolution.replaygain.noise_shaping == 2)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(resolution_replaygain_noise_shaping_radio_medium), TRUE);
gtk_signal_connect(GTK_OBJECT(resolution_replaygain_noise_shaping_radio_medium), "clicked", resolution_replaygain_noise_shaping_cb, NULL);
gtk_container_add(GTK_CONTAINER(resolution_replaygain_noise_shaping_vbox), resolution_replaygain_noise_shaping_radio_medium);
resolution_replaygain_noise_shaping_radio_high = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(resolution_replaygain_noise_shaping_radio_none), _("high"));
if(flac_cfg.output.resolution.replaygain.noise_shaping == 3)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(resolution_replaygain_noise_shaping_radio_high), TRUE);
gtk_signal_connect(GTK_OBJECT(resolution_replaygain_noise_shaping_radio_high), "clicked", resolution_replaygain_noise_shaping_cb, NULL);
gtk_container_add(GTK_CONTAINER(resolution_replaygain_noise_shaping_vbox), resolution_replaygain_noise_shaping_radio_high);
resolution_replaygain_bps_out_frame = gtk_frame_new(_("Dither to"));
gtk_container_border_width(GTK_CONTAINER(resolution_replaygain_bps_out_frame), 5);
gtk_box_pack_start(GTK_BOX(hbox), resolution_replaygain_bps_out_frame, FALSE, FALSE, 0);
resolution_replaygain_bps_out_vbox = gtk_vbutton_box_new();
gtk_container_border_width(GTK_CONTAINER(resolution_replaygain_bps_out_vbox), 0);
gtk_container_add(GTK_CONTAINER(resolution_replaygain_bps_out_frame), resolution_replaygain_bps_out_vbox);
resolution_replaygain_bps_out_radio_16bps = gtk_radio_button_new_with_label(NULL, _("16 bps"));
if(flac_cfg.output.resolution.replaygain.bps_out == 16)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(resolution_replaygain_bps_out_radio_16bps), TRUE);
gtk_signal_connect(GTK_OBJECT(resolution_replaygain_bps_out_radio_16bps), "clicked", resolution_replaygain_bps_out_cb, NULL);
gtk_container_add(GTK_CONTAINER(resolution_replaygain_bps_out_vbox), resolution_replaygain_bps_out_radio_16bps);
resolution_replaygain_bps_out_radio_24bps = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(resolution_replaygain_bps_out_radio_16bps), _("24 bps"));
if(flac_cfg.output.resolution.replaygain.bps_out == 24)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(resolution_replaygain_bps_out_radio_24bps), TRUE);
gtk_signal_connect(GTK_OBJECT(resolution_replaygain_bps_out_radio_24bps), "clicked", resolution_replaygain_bps_out_cb, NULL);
gtk_container_add(GTK_CONTAINER(resolution_replaygain_bps_out_vbox), resolution_replaygain_bps_out_radio_24bps);
resolution_replaygain_dither_cb(resolution_replaygain_dither, NULL);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), output_vbox, gtk_label_new(_("Output")));
/* Streaming */
streaming_vbox = gtk_vbox_new(FALSE, 0);
streaming_buf_frame = gtk_frame_new(_("Buffering:"));
gtk_container_set_border_width(GTK_CONTAINER(streaming_buf_frame), 5);
gtk_box_pack_start(GTK_BOX(streaming_vbox), streaming_buf_frame, FALSE, FALSE, 0);
streaming_buf_hbox = gtk_hbox_new(TRUE, 5);
gtk_container_set_border_width(GTK_CONTAINER(streaming_buf_hbox), 5);
gtk_container_add(GTK_CONTAINER(streaming_buf_frame), streaming_buf_hbox);
streaming_size_box = gtk_hbox_new(FALSE, 5);
/*gtk_table_attach_defaults(GTK_TABLE(streaming_buf_table),streaming_size_box,0,1,0,1); */
gtk_box_pack_start(GTK_BOX(streaming_buf_hbox), streaming_size_box, TRUE, TRUE, 0);
streaming_size_label = gtk_label_new(_("Buffer size (kb):"));
gtk_box_pack_start(GTK_BOX(streaming_size_box), streaming_size_label, FALSE, FALSE, 0);
streaming_size_adj = gtk_adjustment_new(flac_cfg.stream.http_buffer_size, 4, 4096, 4, 4, 4);
streaming_size_spin = gtk_spin_button_new(GTK_ADJUSTMENT(streaming_size_adj), 8, 0);
gtk_widget_set_usize(streaming_size_spin, 60, -1);
gtk_box_pack_start(GTK_BOX(streaming_size_box), streaming_size_spin, FALSE, FALSE, 0);
streaming_pre_box = gtk_hbox_new(FALSE, 5);
/*gtk_table_attach_defaults(GTK_TABLE(streaming_buf_table),streaming_pre_box,1,2,0,1); */
gtk_box_pack_start(GTK_BOX(streaming_buf_hbox), streaming_pre_box, TRUE, TRUE, 0);
streaming_pre_label = gtk_label_new(_("Pre-buffer (percent):"));
gtk_box_pack_start(GTK_BOX(streaming_pre_box), streaming_pre_label, FALSE, FALSE, 0);
streaming_pre_adj = gtk_adjustment_new(flac_cfg.stream.http_prebuffer, 0, 90, 1, 1, 1);
streaming_pre_spin = gtk_spin_button_new(GTK_ADJUSTMENT(streaming_pre_adj), 1, 0);
gtk_widget_set_usize(streaming_pre_spin, 60, -1);
gtk_box_pack_start(GTK_BOX(streaming_pre_box), streaming_pre_spin, FALSE, FALSE, 0);
/*
* Proxy config.
*/
streaming_proxy_frame = gtk_frame_new(_("Proxy:"));
gtk_container_set_border_width(GTK_CONTAINER(streaming_proxy_frame), 5);
gtk_box_pack_start(GTK_BOX(streaming_vbox), streaming_proxy_frame, FALSE, FALSE, 0);
streaming_proxy_vbox = gtk_vbox_new(FALSE, 5);
gtk_container_set_border_width(GTK_CONTAINER(streaming_proxy_vbox), 5);
gtk_container_add(GTK_CONTAINER(streaming_proxy_frame), streaming_proxy_vbox);
streaming_proxy_use = gtk_check_button_new_with_label(_("Use proxy"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(streaming_proxy_use), flac_cfg.stream.use_proxy);
gtk_signal_connect(GTK_OBJECT(streaming_proxy_use), "clicked", GTK_SIGNAL_FUNC(proxy_use_cb), NULL);
gtk_box_pack_start(GTK_BOX(streaming_proxy_vbox), streaming_proxy_use, FALSE, FALSE, 0);
streaming_proxy_hbox = gtk_hbox_new(FALSE, 5);
gtk_widget_set_sensitive(streaming_proxy_hbox, flac_cfg.stream.use_proxy);
gtk_box_pack_start(GTK_BOX(streaming_proxy_vbox), streaming_proxy_hbox, FALSE, FALSE, 0);
streaming_proxy_host_label = gtk_label_new(_("Host:"));
gtk_box_pack_start(GTK_BOX(streaming_proxy_hbox), streaming_proxy_host_label, FALSE, FALSE, 0);
streaming_proxy_host_entry = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(streaming_proxy_host_entry), flac_cfg.stream.proxy_host);
gtk_box_pack_start(GTK_BOX(streaming_proxy_hbox), streaming_proxy_host_entry, TRUE, TRUE, 0);
streaming_proxy_port_label = gtk_label_new(_("Port:"));
gtk_box_pack_start(GTK_BOX(streaming_proxy_hbox), streaming_proxy_port_label, FALSE, FALSE, 0);
streaming_proxy_port_entry = gtk_entry_new();
gtk_widget_set_usize(streaming_proxy_port_entry, 50, -1);
temp = g_strdup_printf("%d", flac_cfg.stream.proxy_port);
gtk_entry_set_text(GTK_ENTRY(streaming_proxy_port_entry), temp);
g_free(temp);
gtk_box_pack_start(GTK_BOX(streaming_proxy_hbox), streaming_proxy_port_entry, FALSE, FALSE, 0);
streaming_proxy_auth_use = gtk_check_button_new_with_label(_("Use authentication"));
gtk_widget_set_sensitive(streaming_proxy_auth_use, flac_cfg.stream.use_proxy);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(streaming_proxy_auth_use), flac_cfg.stream.proxy_use_auth);
gtk_signal_connect(GTK_OBJECT(streaming_proxy_auth_use), "clicked", GTK_SIGNAL_FUNC(proxy_auth_use_cb), NULL);
gtk_box_pack_start(GTK_BOX(streaming_proxy_vbox), streaming_proxy_auth_use, FALSE, FALSE, 0);
streaming_proxy_auth_hbox = gtk_hbox_new(FALSE, 5);
gtk_widget_set_sensitive(streaming_proxy_auth_hbox, flac_cfg.stream.use_proxy && flac_cfg.stream.proxy_use_auth);
gtk_box_pack_start(GTK_BOX(streaming_proxy_vbox), streaming_proxy_auth_hbox, FALSE, FALSE, 0);
streaming_proxy_auth_user_label = gtk_label_new(_("Username:"******"Password:"******"Save stream to disk:"));
gtk_container_set_border_width(GTK_CONTAINER(streaming_save_frame), 5);
gtk_box_pack_start(GTK_BOX(streaming_vbox), streaming_save_frame, FALSE, FALSE, 0);
streaming_save_vbox = gtk_vbox_new(FALSE, 5);
gtk_container_set_border_width(GTK_CONTAINER(streaming_save_vbox), 5);
gtk_container_add(GTK_CONTAINER(streaming_save_frame), streaming_save_vbox);
streaming_save_use = gtk_check_button_new_with_label(_("Save stream to disk"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(streaming_save_use), flac_cfg.stream.save_http_stream);
gtk_signal_connect(GTK_OBJECT(streaming_save_use), "clicked", GTK_SIGNAL_FUNC(streaming_save_use_cb), NULL);
gtk_box_pack_start(GTK_BOX(streaming_save_vbox), streaming_save_use, FALSE, FALSE, 0);
streaming_save_hbox = gtk_hbox_new(FALSE, 5);
gtk_widget_set_sensitive(streaming_save_hbox, flac_cfg.stream.save_http_stream);
gtk_box_pack_start(GTK_BOX(streaming_save_vbox), streaming_save_hbox, FALSE, FALSE, 0);
streaming_save_label = gtk_label_new(_("Path:"));
gtk_box_pack_start(GTK_BOX(streaming_save_hbox), streaming_save_label, FALSE, FALSE, 0);
streaming_save_entry = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(streaming_save_entry), flac_cfg.stream.save_http_path);
gtk_box_pack_start(GTK_BOX(streaming_save_hbox), streaming_save_entry, TRUE, TRUE, 0);
streaming_save_browse = gtk_button_new_with_label(_("Browse"));
gtk_signal_connect(GTK_OBJECT(streaming_save_browse), "clicked", GTK_SIGNAL_FUNC(streaming_save_browse_cb), NULL);
gtk_box_pack_start(GTK_BOX(streaming_save_hbox), streaming_save_browse, FALSE, FALSE, 0);
#ifdef FLAC_ICECAST
streaming_cast_frame = gtk_frame_new(_("SHOUT/Icecast:"));
gtk_container_set_border_width(GTK_CONTAINER(streaming_cast_frame), 5);
gtk_box_pack_start(GTK_BOX(streaming_vbox), streaming_cast_frame, FALSE, FALSE, 0);
streaming_cast_vbox = gtk_vbox_new(5, FALSE);
gtk_container_add(GTK_CONTAINER(streaming_cast_frame), streaming_cast_vbox);
streaming_cast_title = gtk_check_button_new_with_label(_("Enable SHOUT/Icecast title streaming"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(streaming_cast_title), flac_cfg.stream.cast_title_streaming);
gtk_box_pack_start(GTK_BOX(streaming_cast_vbox), streaming_cast_title, FALSE, FALSE, 0);
streaming_udp_title = gtk_check_button_new_with_label(_("Enable Icecast Metadata UDP Channel"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(streaming_udp_title), flac_cfg.stream.use_udp_channel);
gtk_box_pack_start(GTK_BOX(streaming_cast_vbox), streaming_udp_title, FALSE, FALSE, 0);
#endif
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), streaming_vbox, gtk_label_new(_("Streaming")));
/* Buttons */
bbox = gtk_hbutton_box_new();
gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END);
gtk_button_box_set_spacing(GTK_BUTTON_BOX(bbox), 5);
gtk_box_pack_start(GTK_BOX(vbox), bbox, FALSE, FALSE, 0);
ok = gtk_button_new_with_label(_("Ok"));
gtk_signal_connect(GTK_OBJECT(ok), "clicked", GTK_SIGNAL_FUNC(flac_configurewin_ok), NULL);
GTK_WIDGET_SET_FLAGS(ok, GTK_CAN_DEFAULT);
gtk_box_pack_start(GTK_BOX(bbox), ok, TRUE, TRUE, 0);
gtk_widget_grab_default(ok);
cancel = gtk_button_new_with_label(_("Cancel"));
gtk_signal_connect_object(GTK_OBJECT(cancel), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT(flac_configurewin));
GTK_WIDGET_SET_FLAGS(cancel, GTK_CAN_DEFAULT);
gtk_box_pack_start(GTK_BOX(bbox), cancel, TRUE, TRUE, 0);
gtk_widget_show_all(flac_configurewin);
}
GtkWidget * create_PlayList( void )
{
GtkWidget * vbox1;
GtkWidget * hbox1;
GtkWidget * scrolledwindow1;
GtkWidget * vbox2;
GtkWidget * scrolledwindow2;
GtkWidget * scrolledwindow3;
GtkWidget * hbuttonbox1;
GtkAccelGroup * accel_group;
GdkColor transparent = { 0,0,0,0 };
gchar * root = "/";
gchar * dummy = "dummy";
DirNodeType * DirNode;
accel_group=gtk_accel_group_new();
PlayList=gtk_window_new( GTK_WINDOW_TOPLEVEL );
gtk_object_set_data( GTK_OBJECT( PlayList ),"PlayList",PlayList );
gtk_widget_set_usize( PlayList,512,384 );
gtk_window_set_title( GTK_WINDOW( PlayList ),MSGTR_PlayList );
gtk_window_set_position( GTK_WINDOW( PlayList ),GTK_WIN_POS_CENTER );
// gtk_window_set_policy( GTK_WINDOW( PlayList ),FALSE,FALSE,FALSE );
gtk_window_set_wmclass( GTK_WINDOW( PlayList ),"Playlist","MPlayer" );
gtk_widget_realize( PlayList );
gtkAddIcon( PlayList );
vbox1=AddVBox( AddDialogFrame( PlayList ),0 );
hbox1=AddHBox( NULL,1 );
gtk_box_pack_start( GTK_BOX( vbox1 ),hbox1,TRUE,TRUE,0 );
scrolledwindow1=gtk_scrolled_window_new( NULL,NULL );
gtk_widget_show( scrolledwindow1 );
gtk_container_add( GTK_CONTAINER(
AddFrame( NULL,0,hbox1,1 ) ),scrolledwindow1 );
gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( scrolledwindow1 ),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC );
CTDirTree=gtk_ctree_new( 1,0 );
gtk_signal_connect( GTK_OBJECT( CTDirTree ),"tree_expand",GTK_SIGNAL_FUNC( plCTree ),(void*)0 );
gtk_signal_connect( GTK_OBJECT( CTDirTree ),"select_row",GTK_SIGNAL_FUNC( plCTRow ),(void *)0 );
gtk_container_add( GTK_CONTAINER( scrolledwindow1 ),CTDirTree );
gtk_clist_set_column_auto_resize( GTK_CLIST( CTDirTree ),0,TRUE );
gtk_clist_set_column_width( GTK_CLIST( CTDirTree ),0,80 );
gtk_clist_set_selection_mode( GTK_CLIST( CTDirTree ),GTK_SELECTION_SINGLE );
gtk_ctree_set_line_style( GTK_CTREE( CTDirTree ),GTK_CTREE_LINES_SOLID );
gtk_clist_column_titles_show( GTK_CLIST( CTDirTree ) );
gtk_clist_set_shadow_type( GTK_CLIST( CTDirTree ),GTK_SHADOW_NONE );
if ( !pxOpenedBook ) pxOpenedBook=gdk_pixmap_create_from_xpm_d( PlayList->window,&msOpenedBook,&transparent,(gchar **)dir2_xpm );
if ( !pxClosedBook ) pxClosedBook=gdk_pixmap_create_from_xpm_d( PlayList->window,&msClosedBook,&transparent,(gchar **)open2_xpm );
parent=gtk_ctree_insert_node( GTK_CTREE( CTDirTree ),NULL,NULL,&root,4,pxOpenedBook,msOpenedBook,pxClosedBook,msClosedBook,FALSE,FALSE );
DirNode=malloc( sizeof( DirNodeType ) );
DirNode->scaned=0; DirNode->path=strdup( root );
gtk_ctree_node_set_row_data_full(GTK_CTREE( CTDirTree ),parent,DirNode,NULL );
sibling=gtk_ctree_insert_node( GTK_CTREE( CTDirTree ),parent,NULL,&dummy,4,NULL,NULL,NULL,NULL,TRUE,TRUE );
gtk_ctree_expand( GTK_CTREE( CTDirTree ),parent );
gtk_widget_show( CTDirTree );
if ( fsHistory[0] ) old_path = g_filename_from_utf8( fsHistory[0], -1, NULL, NULL, NULL );
gtk_clist_set_column_widget( GTK_CLIST( CTDirTree ),0,
AddLabel( MSGTR_PLAYLIST_DirectoryTree,NULL ) );
gtk_clist_column_title_passive( GTK_CLIST( CTDirTree ),0 );
vbox2=AddVBox(
AddFrame( NULL,1,hbox1,1 ),0 );
scrolledwindow2=gtk_scrolled_window_new( NULL,NULL );
gtk_widget_show( scrolledwindow2 );
gtk_box_pack_start( GTK_BOX( vbox2 ),scrolledwindow2,TRUE,TRUE,0 );
gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( scrolledwindow2 ),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC );
CLFiles=gtk_clist_new( 1 );
gtk_widget_show( CLFiles );
gtk_container_add( GTK_CONTAINER( scrolledwindow2 ),CLFiles );
gtk_clist_set_column_width( GTK_CLIST( CLFiles ),0,80 );
gtk_clist_set_selection_mode( GTK_CLIST( CLFiles ),GTK_SELECTION_EXTENDED );
gtk_clist_column_titles_show( GTK_CLIST( CLFiles ) );
gtk_clist_set_shadow_type( GTK_CLIST( CLFiles ),GTK_SHADOW_NONE );
gtk_clist_set_column_widget( GTK_CLIST( CLFiles ),0,
AddLabel( MSGTR_PLAYLIST_Files,NULL ) );
gtk_clist_column_title_passive( GTK_CLIST( CLFiles ),0 );
AddHSeparator( vbox2 );
scrolledwindow3=gtk_scrolled_window_new( NULL,NULL );
gtk_widget_show( scrolledwindow3 );
gtk_box_pack_start( GTK_BOX( vbox2 ),scrolledwindow3,TRUE,TRUE,0 );
gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( scrolledwindow3 ),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC );
CLSelected=gtk_clist_new( 2 );
gtk_widget_show( CLSelected );
gtk_container_add( GTK_CONTAINER( scrolledwindow3 ),CLSelected );
gtk_clist_set_column_width( GTK_CLIST( CLSelected ),0,295 );
gtk_clist_set_column_width( GTK_CLIST( CLSelected ),1,295 );
gtk_clist_set_selection_mode( GTK_CLIST( CLSelected ),GTK_SELECTION_MULTIPLE );
gtk_clist_column_titles_show( GTK_CLIST( CLSelected ) );
gtk_clist_set_shadow_type( GTK_CLIST( CLSelected ),GTK_SHADOW_NONE );
gtk_clist_set_column_widget( GTK_CLIST( CLSelected ),0,
AddLabel( MSGTR_PLAYLIST_Selected,NULL ) );
gtk_clist_set_column_widget( GTK_CLIST( CLSelected ),1,
AddLabel( MSGTR_PLAYLIST_Path,NULL ) );
gtk_clist_column_title_passive( GTK_CLIST( CLSelected ),0 );
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 );
Add=AddButton( MSGTR_Add,hbuttonbox1 );
Remove=AddButton( MSGTR_Remove,hbuttonbox1 );
Ok=AddButton( MSGTR_Ok,hbuttonbox1 );
Cancel=AddButton( MSGTR_Cancel,hbuttonbox1 );
gtk_widget_add_accelerator( Cancel,"clicked",accel_group,GDK_Escape,0,GTK_ACCEL_VISIBLE );
gtk_signal_connect( GTK_OBJECT( PlayList ),"destroy",GTK_SIGNAL_FUNC( WidgetDestroy ),&PlayList );
gtk_signal_connect( GTK_OBJECT( CLFiles ),"select_row",GTK_SIGNAL_FUNC( plRowSelect ),(void *)0 );
gtk_signal_connect( GTK_OBJECT( CLFiles ),"unselect_row",GTK_SIGNAL_FUNC( plUnRowSelect ),(void *)0 );
gtk_signal_connect( GTK_OBJECT( CLFiles ),"event",GTK_SIGNAL_FUNC( plEvent ),(void *)0 );
gtk_signal_connect( GTK_OBJECT( CLFiles ),"key_release_event",GTK_SIGNAL_FUNC( plKeyReleased ),(void *)0 );
sigSel=gtk_signal_connect( GTK_OBJECT( CLSelected ),"select_row",GTK_SIGNAL_FUNC( plRowSelect ),(void*)1 );
sigUnsel=gtk_signal_connect( GTK_OBJECT( CLSelected ),"unselect_row",GTK_SIGNAL_FUNC( plUnRowSelect ),(void*)1 );
sigEvent=gtk_signal_connect( GTK_OBJECT( CLSelected ),"event",GTK_SIGNAL_FUNC( plEvent ),(void *)1 );
gtk_signal_connect( GTK_OBJECT( CLSelected ),"key_release_event",GTK_SIGNAL_FUNC( plKeyReleased ),(void *)1 );
gtk_signal_connect( GTK_OBJECT( Add ),"released",GTK_SIGNAL_FUNC( plButtonReleased ),(void*)3 );
gtk_signal_connect( GTK_OBJECT( Add ),"key_release_event",GTK_SIGNAL_FUNC( plKeyReleased ),(void*)3 );
gtk_signal_connect( GTK_OBJECT( Remove ),"released",GTK_SIGNAL_FUNC( plButtonReleased ),(void*)2 );
gtk_signal_connect( GTK_OBJECT( Remove ),"key_release_event",GTK_SIGNAL_FUNC( plKeyReleased ),(void*)2 );
gtk_signal_connect( GTK_OBJECT( Ok ),"released",GTK_SIGNAL_FUNC( plButtonReleased ),(void*)1 );
gtk_signal_connect( GTK_OBJECT( Ok ),"key_release_event",GTK_SIGNAL_FUNC( plKeyReleased ),(void*)1 );
gtk_signal_connect( GTK_OBJECT( Cancel ),"released",GTK_SIGNAL_FUNC( plButtonReleased ),(void*)0 );
gtk_signal_connect( GTK_OBJECT( Cancel ),"key_release_event",GTK_SIGNAL_FUNC( plKeyReleased ),(void*)0 );
gtk_window_add_accel_group( GTK_WINDOW( PlayList ),accel_group );
return PlayList;
}
void FLAC_XMMS__file_info_box(char *filename)
{
unsigned i;
gchar *title;
if (!window)
{
GtkWidget *vbox, *hbox, *left_vbox, *table;
GtkWidget *flac_frame, *flac_box;
GtkWidget *label, *filename_hbox;
GtkWidget *bbox, *save, *remove, *cancel;
window = gtk_window_new(GTK_WINDOW_DIALOG);
gtk_window_set_policy(GTK_WINDOW(window), FALSE, FALSE, FALSE);
gtk_signal_connect(GTK_OBJECT(window), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &window);
gtk_container_set_border_width(GTK_CONTAINER(window), 10);
vbox = gtk_vbox_new(FALSE, 10);
gtk_container_add(GTK_CONTAINER(window), vbox);
filename_hbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(vbox), filename_hbox, FALSE, TRUE, 0);
label = gtk_label_new(_("Filename:"));
gtk_box_pack_start(GTK_BOX(filename_hbox), label, FALSE, TRUE, 0);
filename_entry = gtk_entry_new();
gtk_editable_set_editable(GTK_EDITABLE(filename_entry), FALSE);
gtk_box_pack_start(GTK_BOX(filename_hbox), filename_entry, TRUE, TRUE, 0);
hbox = gtk_hbox_new(FALSE, 10);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);
left_vbox = gtk_vbox_new(FALSE, 10);
gtk_box_pack_start(GTK_BOX(hbox), left_vbox, FALSE, FALSE, 0);
tag_frame = gtk_frame_new(_("Tag:"));
gtk_box_pack_start(GTK_BOX(left_vbox), tag_frame, FALSE, FALSE, 0);
table = gtk_table_new(5, 5, FALSE);
gtk_container_set_border_width(GTK_CONTAINER(table), 5);
gtk_container_add(GTK_CONTAINER(tag_frame), table);
label = gtk_label_new(_("Title:"));
gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 5, 5);
title_entry = gtk_entry_new();
gtk_table_attach(GTK_TABLE(table), title_entry, 1, 4, 0, 1, GTK_FILL | GTK_EXPAND | GTK_SHRINK, GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 5);
label = gtk_label_new(_("Artist:"));
gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 1, 2, GTK_FILL, GTK_FILL, 5, 5);
artist_entry = gtk_entry_new();
gtk_table_attach(GTK_TABLE(table), artist_entry, 1, 4, 1, 2, GTK_FILL | GTK_EXPAND | GTK_SHRINK, GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 5);
label = gtk_label_new(_("Album:"));
gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 2, 3, GTK_FILL, GTK_FILL, 5, 5);
album_entry = gtk_entry_new();
gtk_table_attach(GTK_TABLE(table), album_entry, 1, 4, 2, 3, GTK_FILL | GTK_EXPAND | GTK_SHRINK, GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 5);
label = gtk_label_new(_("Comment:"));
gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 3, 4, GTK_FILL, GTK_FILL, 5, 5);
comment_entry = gtk_entry_new();
gtk_table_attach(GTK_TABLE(table), comment_entry, 1, 4, 3, 4, GTK_FILL | GTK_EXPAND | GTK_SHRINK, GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 5);
label = gtk_label_new(_("Date:"));
gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 4, 5, GTK_FILL, GTK_FILL, 5, 5);
date_entry = gtk_entry_new();
gtk_widget_set_usize(date_entry, 40, -1);
gtk_table_attach(GTK_TABLE(table), date_entry, 1, 2, 4, 5, GTK_FILL | GTK_EXPAND | GTK_SHRINK, GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 5);
label = gtk_label_new(_("Track number:"));
gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
gtk_table_attach(GTK_TABLE(table), label, 2, 3, 4, 5, GTK_FILL, GTK_FILL, 5, 5);
tracknum_entry = gtk_entry_new();
gtk_widget_set_usize(tracknum_entry, 40, -1);
gtk_table_attach(GTK_TABLE(table), tracknum_entry, 3, 4, 4, 5, GTK_FILL | GTK_EXPAND | GTK_SHRINK, GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 5);
label = gtk_label_new(_("Genre:"));
gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 5, 6, GTK_FILL, GTK_FILL, 5, 5);
genre_combo = gtk_combo_new();
gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(genre_combo)->entry), TRUE);
if (!genre_list)
{
for (i = 0; i < sizeof(vorbis_genres) / sizeof(*vorbis_genres) ; i++)
genre_list = g_list_prepend(genre_list, (char *)vorbis_genres[i]);
genre_list = g_list_prepend(genre_list, "");
genre_list = g_list_sort(genre_list, (GCompareFunc)g_strcasecmp);
}
gtk_combo_set_popdown_strings(GTK_COMBO(genre_combo), genre_list);
gtk_table_attach(GTK_TABLE(table), genre_combo, 1, 4, 5, 6, GTK_FILL | GTK_EXPAND | GTK_SHRINK, GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 5);
bbox = gtk_hbutton_box_new();
gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END);
gtk_button_box_set_spacing(GTK_BUTTON_BOX(bbox), 5);
gtk_box_pack_start(GTK_BOX(left_vbox), bbox, FALSE, FALSE, 0);
save = gtk_button_new_with_label(_("Save"));
gtk_signal_connect(GTK_OBJECT(save), "clicked", GTK_SIGNAL_FUNC(save_tag), NULL);
GTK_WIDGET_SET_FLAGS(save, GTK_CAN_DEFAULT);
gtk_box_pack_start(GTK_BOX(bbox), save, TRUE, TRUE, 0);
gtk_widget_grab_default(save);
remove= gtk_button_new_with_label(_("Remove Tag"));
gtk_signal_connect(GTK_OBJECT(remove), "clicked", GTK_SIGNAL_FUNC(remove_tag), NULL);
GTK_WIDGET_SET_FLAGS(remove, GTK_CAN_DEFAULT);
gtk_box_pack_start(GTK_BOX(bbox), remove, TRUE, TRUE, 0);
cancel = gtk_button_new_with_label(_("Cancel"));
gtk_signal_connect_object(GTK_OBJECT(cancel), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT(window));
GTK_WIDGET_SET_FLAGS(cancel, GTK_CAN_DEFAULT);
gtk_box_pack_start(GTK_BOX(bbox), cancel, TRUE, TRUE, 0);
flac_frame = gtk_frame_new(_("FLAC Info:"));
gtk_box_pack_start(GTK_BOX(hbox), flac_frame, FALSE, FALSE, 0);
flac_box = gtk_vbox_new(FALSE, 5);
gtk_container_add(GTK_CONTAINER(flac_frame), flac_box);
gtk_container_set_border_width(GTK_CONTAINER(flac_box), 10);
gtk_box_set_spacing(GTK_BOX(flac_box), 0);
flac_samplerate = gtk_label_new("");
gtk_misc_set_alignment(GTK_MISC(flac_samplerate), 0, 0);
gtk_label_set_justify(GTK_LABEL(flac_samplerate), GTK_JUSTIFY_LEFT);
gtk_box_pack_start(GTK_BOX(flac_box), flac_samplerate, FALSE, FALSE, 0);
flac_channels = gtk_label_new("");
gtk_misc_set_alignment(GTK_MISC(flac_channels), 0, 0);
gtk_label_set_justify(GTK_LABEL(flac_channels), GTK_JUSTIFY_LEFT);
gtk_box_pack_start(GTK_BOX(flac_box), flac_channels, FALSE, FALSE, 0);
flac_bits_per_sample = gtk_label_new("");
gtk_misc_set_alignment(GTK_MISC(flac_bits_per_sample), 0, 0);
gtk_label_set_justify(GTK_LABEL(flac_bits_per_sample), GTK_JUSTIFY_LEFT);
gtk_box_pack_start(GTK_BOX(flac_box), flac_bits_per_sample, FALSE, FALSE, 0);
flac_blocksize = gtk_label_new("");
gtk_misc_set_alignment(GTK_MISC(flac_blocksize), 0, 0);
gtk_label_set_justify(GTK_LABEL(flac_blocksize), GTK_JUSTIFY_LEFT);
gtk_box_pack_start(GTK_BOX(flac_box), flac_blocksize, FALSE, FALSE, 0);
flac_filesize = gtk_label_new("");
gtk_misc_set_alignment(GTK_MISC(flac_filesize), 0, 0);
gtk_label_set_justify(GTK_LABEL(flac_filesize), GTK_JUSTIFY_LEFT);
gtk_box_pack_start(GTK_BOX(flac_box), flac_filesize, FALSE, FALSE, 0);
flac_samples = gtk_label_new("");
gtk_misc_set_alignment(GTK_MISC(flac_samples), 0, 0);
gtk_label_set_justify(GTK_LABEL(flac_samples), GTK_JUSTIFY_LEFT);
gtk_box_pack_start(GTK_BOX(flac_box), flac_samples, FALSE, FALSE, 0);
flac_bitrate = gtk_label_new("");
gtk_misc_set_alignment(GTK_MISC(flac_bitrate), 0, 0);
gtk_label_set_justify(GTK_LABEL(flac_bitrate), GTK_JUSTIFY_LEFT);
gtk_box_pack_start(GTK_BOX(flac_box), flac_bitrate, FALSE, FALSE, 0);
replaygain_reference = gtk_label_new("");
gtk_misc_set_alignment(GTK_MISC(replaygain_reference), 0, 0);
gtk_label_set_justify(GTK_LABEL(replaygain_reference), GTK_JUSTIFY_LEFT);
gtk_box_pack_start(GTK_BOX(flac_box), replaygain_reference, FALSE, FALSE, 0);
replaygain_track_gain = gtk_label_new("");
gtk_misc_set_alignment(GTK_MISC(replaygain_track_gain), 0, 0);
gtk_label_set_justify(GTK_LABEL(replaygain_track_gain), GTK_JUSTIFY_LEFT);
gtk_box_pack_start(GTK_BOX(flac_box), replaygain_track_gain, FALSE, FALSE, 0);
replaygain_album_gain = gtk_label_new("");
gtk_misc_set_alignment(GTK_MISC(replaygain_album_gain), 0, 0);
gtk_label_set_justify(GTK_LABEL(replaygain_album_gain), GTK_JUSTIFY_LEFT);
gtk_box_pack_start(GTK_BOX(flac_box), replaygain_album_gain, FALSE, FALSE, 0);
replaygain_track_peak = gtk_label_new("");
gtk_misc_set_alignment(GTK_MISC(replaygain_track_peak), 0, 0);
gtk_label_set_justify(GTK_LABEL(replaygain_track_peak), GTK_JUSTIFY_LEFT);
gtk_box_pack_start(GTK_BOX(flac_box), replaygain_track_peak, FALSE, FALSE, 0);
replaygain_album_peak = gtk_label_new("");
gtk_misc_set_alignment(GTK_MISC(replaygain_album_peak), 0, 0);
gtk_label_set_justify(GTK_LABEL(replaygain_album_peak), GTK_JUSTIFY_LEFT);
gtk_box_pack_start(GTK_BOX(flac_box), replaygain_album_peak, FALSE, FALSE, 0);
gtk_widget_show_all(window);
}
if(current_filename)
g_free(current_filename);
if(!(current_filename = g_strdup(filename)))
return;
title = g_strdup_printf(_("File Info - %s"), g_basename(filename));
gtk_window_set_title(GTK_WINDOW(window), title);
g_free(title);
gtk_entry_set_text(GTK_ENTRY(filename_entry), filename);
gtk_editable_set_position(GTK_EDITABLE(filename_entry), -1);
if(tags_)
FLAC_plugin__tags_destroy(&tags_);
FLAC_plugin__tags_get(current_filename, &tags_);
show_tag();
show_file_info();
show_replaygain();
gtk_widget_set_sensitive(tag_frame, TRUE);
}
static void configure(void)
{
GtkWidget *sep1, *sep2, *sep3;
GtkWidget *cmd_hbox, *cmd_label;
GtkWidget *cmd_after_hbox, *cmd_after_label;
GtkWidget *cmd_end_hbox, *cmd_end_label;
GtkWidget *cmd_desc, *cmd_after_desc, *cmd_end_desc, *f_desc;
GtkWidget *configure_bbox, *configure_ok, *configure_cancel;
GtkWidget *song_frame, *song_vbox;
char *temp;
if (configure_win)
return;
read_config();
configure_win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_signal_connect(GTK_OBJECT(configure_win), "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroyed),
&configure_win);
gtk_window_set_title(GTK_WINDOW(configure_win),
_("Song Change Configuration"));
gtk_container_set_border_width(GTK_CONTAINER(configure_win), 10);
configure_vbox = gtk_vbox_new(FALSE, 10);
gtk_container_add(GTK_CONTAINER(configure_win), configure_vbox);
song_frame = gtk_frame_new(_("Commands"));
gtk_box_pack_start(GTK_BOX(configure_vbox), song_frame, FALSE, FALSE, 0);
song_vbox = gtk_vbox_new(FALSE, 10);
gtk_container_set_border_width(GTK_CONTAINER(song_vbox), 5);
gtk_container_add(GTK_CONTAINER(song_frame), song_vbox);
cmd_desc = gtk_label_new(_(
"Shell-command to run when xmms starts a new song."));
gtk_label_set_justify(GTK_LABEL(cmd_desc), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment(GTK_MISC(cmd_desc), 0, 0.5);
gtk_box_pack_start(GTK_BOX(song_vbox), cmd_desc, FALSE, FALSE, 0);
gtk_label_set_line_wrap(GTK_LABEL(cmd_desc), TRUE);
cmd_hbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(song_vbox), cmd_hbox, FALSE, FALSE, 0);
cmd_label = gtk_label_new(_("Command:"));
gtk_box_pack_start(GTK_BOX(cmd_hbox), cmd_label, FALSE, FALSE, 0);
cmd_entry = gtk_entry_new();
if (cmd_line)
gtk_entry_set_text(GTK_ENTRY(cmd_entry), cmd_line);
gtk_widget_set_usize(cmd_entry, 200, -1);
gtk_box_pack_start(GTK_BOX(cmd_hbox), cmd_entry, TRUE, TRUE, 0);
sep1 = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(song_vbox), sep1, TRUE, TRUE, 0);
cmd_after_desc = gtk_label_new(_(
"Shell-command to run toward the end of a song."));
gtk_label_set_justify(GTK_LABEL(cmd_after_desc), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment(GTK_MISC(cmd_after_desc), 0, 0.5);
gtk_box_pack_start(GTK_BOX(song_vbox), cmd_after_desc, FALSE, FALSE, 0);
gtk_label_set_line_wrap(GTK_LABEL(cmd_after_desc), TRUE);
cmd_after_hbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(song_vbox), cmd_after_hbox, FALSE, FALSE, 0);
cmd_after_label = gtk_label_new(_("Command:"));
gtk_box_pack_start(GTK_BOX(cmd_after_hbox), cmd_after_label, FALSE, FALSE, 0);
cmd_after_entry = gtk_entry_new();
if (cmd_line_after)
gtk_entry_set_text(GTK_ENTRY(cmd_after_entry), cmd_line_after);
gtk_widget_set_usize(cmd_after_entry, 200, -1);
gtk_box_pack_start(GTK_BOX(cmd_after_hbox), cmd_after_entry, TRUE, TRUE, 0);
sep2 = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(song_vbox), sep2, TRUE, TRUE, 0);
cmd_end_desc = gtk_label_new(_(
"Shell-command to run when xmms reaches the end "
"of the playlist."));
gtk_label_set_justify(GTK_LABEL(cmd_end_desc), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment(GTK_MISC(cmd_end_desc), 0, 0.5);
gtk_box_pack_start(GTK_BOX(song_vbox), cmd_end_desc, FALSE, FALSE, 0);
gtk_label_set_line_wrap(GTK_LABEL(cmd_end_desc), TRUE);
cmd_end_hbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(song_vbox), cmd_end_hbox, FALSE, FALSE, 0);
cmd_end_label = gtk_label_new(_("Command:"));
gtk_box_pack_start(GTK_BOX(cmd_end_hbox), cmd_end_label, FALSE, FALSE, 0);
cmd_end_entry = gtk_entry_new();
if (cmd_line_end)
gtk_entry_set_text(GTK_ENTRY(cmd_end_entry), cmd_line_end);
gtk_widget_set_usize(cmd_end_entry, 200, -1);
gtk_box_pack_start(GTK_BOX(cmd_end_hbox), cmd_end_entry, TRUE, TRUE, 0);
sep3 = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(song_vbox), sep3, TRUE, TRUE, 0);
temp = g_strdup_printf(
_("You can use the following format strings which "
"will be substituted before calling the command "
"(not all are useful for the end-of-playlist command).\n\n"
"%%F: Frequency (in hertz)\n"
"%%c: Number of channels\n"
"%%f: filename (full path)\n"
"%%l: length (in milliseconds)\n"
"%%n or %%s: Song name\n"
"%%r: Rate (in bits per second)\n"
"%%t: Playlist position (%%02d)\n"
"%%p: Currently playing (1 or 0)"));
f_desc = gtk_label_new(temp);
g_free(temp);
gtk_label_set_justify(GTK_LABEL(f_desc), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment(GTK_MISC(f_desc), 0, 0.5);
gtk_box_pack_start(GTK_BOX(song_vbox), f_desc, FALSE, FALSE, 0);
gtk_label_set_line_wrap(GTK_LABEL(f_desc), TRUE);
configure_bbox = gtk_hbutton_box_new();
gtk_button_box_set_layout(GTK_BUTTON_BOX(configure_bbox), GTK_BUTTONBOX_END);
gtk_button_box_set_spacing(GTK_BUTTON_BOX(configure_bbox), 5);
gtk_box_pack_start(GTK_BOX(configure_vbox), configure_bbox, FALSE, FALSE, 0);
configure_ok = gtk_button_new_with_label(_("OK"));
gtk_signal_connect(GTK_OBJECT(configure_ok), "clicked", GTK_SIGNAL_FUNC(configure_ok_cb), NULL);
GTK_WIDGET_SET_FLAGS(configure_ok, GTK_CAN_DEFAULT);
gtk_box_pack_start(GTK_BOX(configure_bbox), configure_ok, TRUE, TRUE, 0);
gtk_widget_grab_default(configure_ok);
configure_cancel = gtk_button_new_with_label(_("Cancel"));
gtk_signal_connect_object(GTK_OBJECT(configure_cancel), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT(configure_win));
GTK_WIDGET_SET_FLAGS(configure_cancel, GTK_CAN_DEFAULT);
gtk_box_pack_start(GTK_BOX(configure_bbox), configure_cancel, TRUE, TRUE, 0);
gtk_widget_show_all(configure_win);
}
void bscope_configure (void)
{
gdouble color[3];
if(configure_win)
return;
bscope_read_config();
color[0]=((gdouble)(bscope_cfg.color /0x10000))/256;
color[1]=((gdouble)((bscope_cfg.color %0x10000)/0x100))/256;
color[2]=((gdouble)(bscope_cfg.color %0x100))/256;
configure_win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_container_set_border_width(GTK_CONTAINER(configure_win), 10);
gtk_window_set_title(GTK_WINDOW(configure_win), _("Color Entry"));
gtk_window_set_policy(GTK_WINDOW(configure_win), FALSE, FALSE, FALSE);
gtk_window_set_position(GTK_WINDOW(configure_win), GTK_WIN_POS_MOUSE);
gtk_signal_connect(GTK_OBJECT(configure_win), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed),
&configure_win);
vbox = gtk_vbox_new(FALSE, 5);
options_frame = gtk_frame_new(_("Options:"));
gtk_container_set_border_width(GTK_CONTAINER(options_frame), 5);
options_vbox = gtk_vbox_new(FALSE, 5);
gtk_container_set_border_width(GTK_CONTAINER(options_vbox), 5);
options_colorpicker = gtk_color_selection_new();
gtk_color_selection_set_color(GTK_COLOR_SELECTION(options_colorpicker), color);
gtk_signal_connect(GTK_OBJECT(options_colorpicker), "color_changed", GTK_SIGNAL_FUNC(color_changed), NULL);
gtk_box_pack_start(GTK_BOX(options_vbox), options_colorpicker, FALSE, FALSE, 0);
gtk_widget_show(options_colorpicker);
gtk_container_add(GTK_CONTAINER(options_frame), options_vbox);
gtk_widget_show(options_vbox);
gtk_box_pack_start(GTK_BOX(vbox), options_frame, TRUE, TRUE, 0);
gtk_widget_show(options_frame);
bbox = gtk_hbutton_box_new();
gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END);
gtk_button_box_set_spacing(GTK_BUTTON_BOX(bbox), 5);
gtk_box_pack_start(GTK_BOX(vbox), bbox, FALSE, FALSE, 0);
ok = gtk_button_new_with_label(_("OK"));
gtk_signal_connect(GTK_OBJECT(ok), "clicked",
GTK_SIGNAL_FUNC(configure_ok), NULL);
GTK_WIDGET_SET_FLAGS(ok, GTK_CAN_DEFAULT);
gtk_box_pack_start(GTK_BOX(bbox), ok, TRUE, TRUE, 0);
gtk_widget_show(ok);
cancel = gtk_button_new_with_label(_("Cancel"));
gtk_signal_connect(GTK_OBJECT(cancel), "clicked",
GTK_SIGNAL_FUNC(configure_cancel),
GUINT_TO_POINTER(bscope_cfg.color));
GTK_WIDGET_SET_FLAGS(cancel, GTK_CAN_DEFAULT);
gtk_box_pack_start(GTK_BOX(bbox), cancel, TRUE, TRUE, 0);
gtk_widget_show(cancel);
gtk_widget_show(bbox);
gtk_container_add(GTK_CONTAINER(configure_win), vbox);
gtk_widget_show(vbox);
gtk_widget_show(configure_win);
gtk_widget_grab_default(ok);
}
void create_calendar()
{
GtkWidget *window;
GtkWidget *vbox, *vbox2, *vbox3;
GtkWidget *hbox;
GtkWidget *hbbox;
GtkWidget *calendar;
GtkWidget *toggle;
GtkWidget *button;
GtkWidget *frame;
GtkWidget *separator;
GtkWidget *label;
GtkWidget *bbox;
static CalendarData calendar_data;
gint i;
struct {
char *label;
} flags[] =
{
{ "Show Heading" },
{ "Show Day Names" },
{ "No Month Change" },
{ "Show Week Numbers" },
{ "Week Start Monday" }
};
calendar_data.window = NULL;
calendar_data.font = NULL;
calendar_data.font_dialog = NULL;
for (i=0; i<5; i++) {
calendar_data.settings[i]=0;
}
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), "GtkCalendar Example");
gtk_container_border_width (GTK_CONTAINER (window), 5);
gtk_signal_connect(GTK_OBJECT(window), "destroy",
GTK_SIGNAL_FUNC(gtk_main_quit),
NULL);
gtk_signal_connect(GTK_OBJECT(window), "delete-event",
GTK_SIGNAL_FUNC(gtk_false),
NULL);
gtk_window_set_policy(GTK_WINDOW(window), FALSE, FALSE, TRUE);
vbox = gtk_vbox_new(FALSE, DEF_PAD);
gtk_container_add (GTK_CONTAINER (window), vbox);
/*
* The top part of the window, Calendar, flags and fontsel.
*/
hbox = gtk_hbox_new(FALSE, DEF_PAD);
gtk_box_pack_start (GTK_BOX(vbox), hbox, TRUE, TRUE, DEF_PAD);
hbbox = gtk_hbutton_box_new();
gtk_box_pack_start(GTK_BOX(hbox), hbbox, FALSE, FALSE, DEF_PAD);
gtk_button_box_set_layout(GTK_BUTTON_BOX(hbbox), GTK_BUTTONBOX_SPREAD);
gtk_button_box_set_spacing(GTK_BUTTON_BOX(hbbox), 5);
/* Calendar widget */
frame = gtk_frame_new("Calendar");
gtk_box_pack_start(GTK_BOX(hbbox), frame, FALSE, TRUE, DEF_PAD);
calendar=gtk_calendar_new();
calendar_data.window = calendar;
calendar_set_flags(&calendar_data);
gtk_calendar_mark_day ( GTK_CALENDAR(calendar), 19);
gtk_container_add( GTK_CONTAINER( frame), calendar);
gtk_signal_connect (GTK_OBJECT (calendar), "month_changed",
GTK_SIGNAL_FUNC (calendar_month_changed),
&calendar_data);
gtk_signal_connect (GTK_OBJECT (calendar), "day_selected",
GTK_SIGNAL_FUNC (calendar_day_selected),
&calendar_data);
gtk_signal_connect (GTK_OBJECT (calendar), "day_selected_double_click",
GTK_SIGNAL_FUNC (calendar_day_selected_double_click),
&calendar_data);
gtk_signal_connect (GTK_OBJECT (calendar), "prev_month",
GTK_SIGNAL_FUNC (calendar_prev_month),
&calendar_data);
gtk_signal_connect (GTK_OBJECT (calendar), "next_month",
GTK_SIGNAL_FUNC (calendar_next_month),
&calendar_data);
gtk_signal_connect (GTK_OBJECT (calendar), "prev_year",
GTK_SIGNAL_FUNC (calendar_prev_year),
&calendar_data);
gtk_signal_connect (GTK_OBJECT (calendar), "next_year",
GTK_SIGNAL_FUNC (calendar_next_year),
&calendar_data);
separator = gtk_vseparator_new ();
gtk_box_pack_start (GTK_BOX (hbox), separator, FALSE, TRUE, 0);
vbox2 = gtk_vbox_new(FALSE, DEF_PAD);
gtk_box_pack_start(GTK_BOX(hbox), vbox2, FALSE, FALSE, DEF_PAD);
/* Build the Right frame with the flags in */
frame = gtk_frame_new("Flags");
gtk_box_pack_start(GTK_BOX(vbox2), frame, TRUE, TRUE, DEF_PAD);
vbox3 = gtk_vbox_new(TRUE, DEF_PAD_SMALL);
gtk_container_add(GTK_CONTAINER(frame), vbox3);
for (i = 0; i < 5; i++)
{
toggle = gtk_check_button_new_with_label(flags[i].label);
gtk_signal_connect (GTK_OBJECT (toggle),
"toggled",
GTK_SIGNAL_FUNC(calendar_toggle_flag),
&calendar_data);
gtk_box_pack_start (GTK_BOX (vbox3), toggle, TRUE, TRUE, 0);
calendar_data.flag_checkboxes[i]=toggle;
}
/* Build the right font-button */
button = gtk_button_new_with_label("Font...");
gtk_signal_connect (GTK_OBJECT (button),
"clicked",
GTK_SIGNAL_FUNC(calendar_select_font),
&calendar_data);
gtk_box_pack_start (GTK_BOX (vbox2), button, FALSE, FALSE, 0);
/*
* Build the Signal-event part.
*/
frame = gtk_frame_new("Signal events");
gtk_box_pack_start(GTK_BOX(vbox), frame, TRUE, TRUE, DEF_PAD);
vbox2 = gtk_vbox_new(TRUE, DEF_PAD_SMALL);
gtk_container_add(GTK_CONTAINER(frame), vbox2);
hbox = gtk_hbox_new (FALSE, 3);
gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, TRUE, 0);
label = gtk_label_new ("Signal:");
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
calendar_data.last_sig = gtk_label_new ("");
gtk_box_pack_start (GTK_BOX (hbox), calendar_data.last_sig, FALSE, TRUE, 0);
hbox = gtk_hbox_new (FALSE, 3);
gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, TRUE, 0);
label = gtk_label_new ("Previous signal:");
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
calendar_data.prev_sig = gtk_label_new ("");
gtk_box_pack_start (GTK_BOX (hbox), calendar_data.prev_sig, FALSE, TRUE, 0);
hbox = gtk_hbox_new (FALSE, 3);
gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, TRUE, 0);
label = gtk_label_new ("Second previous signal:");
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
calendar_data.prev2_sig = gtk_label_new ("");
gtk_box_pack_start (GTK_BOX (hbox), calendar_data.prev2_sig, FALSE, TRUE, 0);
bbox = gtk_hbutton_box_new ();
gtk_box_pack_start (GTK_BOX (vbox), bbox, FALSE, FALSE, 0);
gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END);
button = gtk_button_new_with_label ("Close");
gtk_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (gtk_main_quit),
NULL);
gtk_container_add (GTK_CONTAINER (bbox), button);
gtk_widget_set_flags (button, GTK_CAN_DEFAULT);
gtk_widget_grab_default (button);
gtk_widget_show_all(window);
}
/**
* gimp_dialog_create_action_areav:
* @dialog: The #GtkDialog you want to create the action_area for.
* @args: A @va_list as obtained with va_start() describing the action_area
* buttons.
*
*/
void
gimp_dialog_create_action_areav (GtkDialog *dialog,
va_list args)
{
GtkWidget *hbbox = NULL;
GtkWidget *button;
/* action area variables */
const gchar *label;
GtkSignalFunc callback;
gpointer data;
GtkObject *slot_object;
GtkWidget **widget_ptr;
gboolean default_action;
gboolean connect_delete;
gboolean delete_connected = FALSE;
g_return_if_fail (dialog != NULL);
g_return_if_fail (GTK_IS_DIALOG (dialog));
/* prepare the action_area */
label = va_arg (args, const gchar *);
if (label)
{
gtk_container_set_border_width (GTK_CONTAINER (dialog->action_area), 2);
gtk_box_set_homogeneous (GTK_BOX (dialog->action_area), FALSE);
hbbox = gtk_hbutton_box_new ();
gtk_button_box_set_spacing (GTK_BUTTON_BOX (hbbox), 4);
gtk_box_pack_end (GTK_BOX (dialog->action_area), hbbox, FALSE, FALSE, 0);
gtk_widget_show (hbbox);
}
/* the action_area buttons */
while (label)
{
callback = va_arg (args, GtkSignalFunc);
data = va_arg (args, gpointer);
slot_object = va_arg (args, GtkObject *);
widget_ptr = va_arg (args, GtkWidget **);
default_action = va_arg (args, gboolean);
connect_delete = va_arg (args, gboolean);
button = gtk_button_new_with_label (label);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_box_pack_start (GTK_BOX (hbbox), button, FALSE, FALSE, 0);
if (slot_object == (GtkObject *) 1)
slot_object = GTK_OBJECT (dialog);
if (data == NULL)
data = dialog;
if (callback)
{
if (slot_object)
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (callback),
slot_object);
else
gtk_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (callback),
data);
}
if (widget_ptr)
*widget_ptr = button;
if (connect_delete && callback && !delete_connected)
{
gtk_object_set_data (GTK_OBJECT (dialog),
"gimp_dialog_cancel_callback",
callback);
gtk_object_set_data (GTK_OBJECT (dialog),
"gimp_dialog_cancel_widget",
slot_object ? slot_object : GTK_OBJECT (button));
/* catch the WM delete event */
gtk_signal_connect (GTK_OBJECT (dialog), "delete_event",
GTK_SIGNAL_FUNC (gimp_dialog_delete_callback),
data);
delete_connected = TRUE;
}
if (default_action)
gtk_widget_grab_default (button);
gtk_widget_show (button);
label = va_arg (args, gchar *);
}
}
void create_plugins_gui(Sven *sven,GtkWidget *vbox1)
{
GtkTreeViewColumn *column;
GtkCellRenderer *cell;
GtkWidget *scrolled_win;
GtkWidget *hbbox;
GtkWidget *hbox;
GtkWidget *frame;
GtkWidget *alignment;
GtkWidget *label;
DEBUG_MSG("Start create_plugins_gui\n");
gtk_box_pack_start (GTK_BOX (vbox1), create_header(_("Plugins")), FALSE, FALSE, 0);
plugins_model = gtk_tree_store_new (3,G_TYPE_BOOLEAN,G_TYPE_STRING,G_TYPE_STRING);
plugins_tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (plugins_model));
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (plugins_tree_view), TRUE);
plugins_selection = G_OBJECT (gtk_tree_view_get_selection (GTK_TREE_VIEW (plugins_tree_view)));
gtk_tree_selection_set_mode (GTK_TREE_SELECTION (plugins_selection), GTK_SELECTION_SINGLE);
g_signal_connect (G_OBJECT (plugins_selection),"changed",G_CALLBACK (prefs_plugins_list_clicked),sven);
g_signal_connect(G_OBJECT(plugins_tree_view), "button-press-event",G_CALLBACK(plugin_list_event_mouseclick), sven);
scrolled_win = gtk_scrolled_window_new(NULL, NULL);
gtk_container_add(GTK_CONTAINER(scrolled_win), plugins_tree_view);
gtk_container_border_width(GTK_CONTAINER(scrolled_win), 5);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_win), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_box_pack_start(GTK_BOX(vbox1), scrolled_win, TRUE, TRUE, 0);
frame = gtk_frame_new (NULL);
gtk_widget_show (frame);
gtk_box_pack_start(GTK_BOX(vbox1), frame, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (frame), 2);
gtk_frame_set_label_align (GTK_FRAME (frame), 0.05, 0.5);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT);
label = gtk_label_new (_("Description"));
gtk_widget_show (label);
gtk_frame_set_label_widget (GTK_FRAME (frame), label);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
alignment = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment);
gtk_container_add (GTK_CONTAINER (frame), alignment);
gtk_container_set_border_width (GTK_CONTAINER (alignment), 2);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 5, 5, 5, 5);
infotext = gtk_label_new (_("Not information"));
gtk_widget_show (infotext);
gtk_container_add (GTK_CONTAINER (alignment), infotext);
GTK_WIDGET_SET_FLAGS (infotext, GTK_CAN_FOCUS);
gtk_label_set_line_wrap (GTK_LABEL (infotext), TRUE);
gtk_label_set_selectable (GTK_LABEL (infotext), TRUE);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox1), hbox, FALSE, FALSE, 5);
hbbox = gtk_hbutton_box_new();
gtk_button_box_set_layout(GTK_BUTTON_BOX(hbbox), GTK_BUTTONBOX_START);
gtk_button_box_set_spacing(GTK_BUTTON_BOX(hbbox), 10);
gtk_button_box_set_child_size(GTK_BUTTON_BOX(hbbox), 85, 17);
gtk_box_pack_start(GTK_BOX(hbox), hbbox, TRUE, TRUE, 0);
prefs_plugins_config_wid = gtk_button_new_with_label(_("Configure"));
g_signal_connect(G_OBJECT(prefs_plugins_config_wid ), "clicked", G_CALLBACK(prefs_plugins_configure),sven);
gtk_box_pack_start(GTK_BOX(hbbox), prefs_plugins_config_wid, TRUE, TRUE, 0);
prefs_plugins_about_wid = gtk_button_new_with_label(_("About"));
g_signal_connect(G_OBJECT(prefs_plugins_about_wid), "clicked", G_CALLBACK(prefs_plugins_about), sven);
gtk_box_pack_start(GTK_BOX(hbbox), prefs_plugins_about_wid, TRUE, TRUE, 0);
cell = gtk_cell_renderer_toggle_new ();
column = gtk_tree_view_column_new_with_attributes (_("Status"), cell, "active",0, NULL);
gtk_tree_view_column_set_clickable (column, TRUE);
g_signal_connect (G_OBJECT (cell), "toggled",G_CALLBACK (plugin_fixed_toggled),sven);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (plugins_tree_view), column);
cell = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (_("Name"), cell, "markup", 1, NULL);
gtk_tree_view_column_set_sort_column_id (column, 0);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (plugins_tree_view), column);
cell = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (_("Module"), cell, "markup",2, NULL);
gtk_tree_view_column_set_sort_column_id (column, 1);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (plugins_tree_view), column);
gtk_widget_show(plugins_tree_view);
add_print_plugins(GTK_TREE_VIEW (plugins_tree_view),sven);
}
GtkWidget * create_SkinBrowser( void )
{
GtkWidget * vbox5;
GtkWidget * scrolledwindow1;
GtkWidget * hbuttonbox4;
GtkWidget * Cancel;
GtkWidget * Ok;
GtkAccelGroup * accel_group;
accel_group = gtk_accel_group_new ();
SkinBrowser=gtk_window_new( GTK_WINDOW_TOPLEVEL );
gtk_widget_set_name( SkinBrowser,MSGTR_SkinBrowser );
gtk_object_set_data( GTK_OBJECT( SkinBrowser ),MSGTR_SkinBrowser,SkinBrowser );
gtk_widget_set_usize( SkinBrowser,256,320 );
gtk_container_set_border_width( GTK_CONTAINER( SkinBrowser ),1 );
GTK_WIDGET_SET_FLAGS( SkinBrowser,GTK_CAN_DEFAULT );
gtk_widget_set_events( SkinBrowser,GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK | GDK_FOCUS_CHANGE_MASK | GDK_STRUCTURE_MASK | GDK_PROPERTY_CHANGE_MASK | GDK_VISIBILITY_NOTIFY_MASK );
gtk_window_set_title( GTK_WINDOW( SkinBrowser ),MSGTR_SkinBrowser );
gtk_window_set_position( GTK_WINDOW( SkinBrowser ),GTK_WIN_POS_CENTER );
gtk_window_set_policy( GTK_WINDOW( SkinBrowser ),FALSE,FALSE,TRUE );
gtk_window_set_wmclass( GTK_WINDOW( SkinBrowser ),"SkinBrowser","MPlayer" );
gtk_widget_realize( SkinBrowser );
gtkAddIcon( SkinBrowser );
vbox5=AddVBox( AddDialogFrame( SkinBrowser ),0 );
AddLabel( MSGTR_SKIN_LABEL,vbox5 );
AddHSeparator( vbox5 );
scrolledwindow1=gtk_scrolled_window_new( NULL,NULL );
gtk_widget_set_name( scrolledwindow1,"scrolledwindow1" );
gtk_widget_ref( scrolledwindow1 );
gtk_object_set_data_full( GTK_OBJECT( SkinBrowser ),"scrolledwindow1",scrolledwindow1,(GtkDestroyNotify)gtk_widget_unref );
gtk_widget_show( scrolledwindow1 );
gtk_box_pack_start( GTK_BOX( vbox5 ),scrolledwindow1,TRUE,TRUE,0 );
gtk_container_set_border_width( GTK_CONTAINER( scrolledwindow1 ),2 );
gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( scrolledwindow1 ),GTK_POLICY_NEVER,GTK_POLICY_AUTOMATIC );
SkinList=gtk_clist_new( 1 );
gtk_widget_set_name( SkinList,"SkinList" );
gtk_widget_ref( SkinList );
gtk_object_set_data_full( GTK_OBJECT( SkinBrowser ),"SkinList",SkinList,(GtkDestroyNotify)gtk_widget_unref );
gtk_widget_show( SkinList );
gtk_container_add( GTK_CONTAINER( scrolledwindow1 ),SkinList );
gtk_clist_set_column_width( GTK_CLIST( SkinList ),0,80 );
gtk_clist_set_selection_mode( GTK_CLIST( SkinList ),GTK_SELECTION_SINGLE );
gtk_clist_column_titles_hide( GTK_CLIST( SkinList ) );
gtk_clist_set_shadow_type( GTK_CLIST( SkinList ),GTK_SHADOW_ETCHED_OUT );
AddHSeparator( vbox5 );
hbuttonbox4=AddHButtonBox( vbox5 );
gtk_button_box_set_layout( GTK_BUTTON_BOX( hbuttonbox4 ),GTK_BUTTONBOX_SPREAD );
gtk_button_box_set_spacing( GTK_BUTTON_BOX( hbuttonbox4 ),10 );
Ok=AddButton( MSGTR_Ok,hbuttonbox4 );
Cancel=AddButton( MSGTR_Cancel,hbuttonbox4 );
gtk_widget_add_accelerator( Ok,"clicked",accel_group,GDK_Return,0,GTK_ACCEL_VISIBLE );
gtk_widget_add_accelerator( Cancel,"clicked",accel_group,GDK_Escape,0,GTK_ACCEL_VISIBLE );
gtk_signal_connect( GTK_OBJECT( SkinBrowser ),"destroy",GTK_SIGNAL_FUNC( WidgetDestroy ),&SkinBrowser );
gtk_signal_connect( GTK_OBJECT( SkinList ),"select_row",GTK_SIGNAL_FUNC( on_SkinList_select_row ),NULL );
gtk_signal_connect( GTK_OBJECT( Ok ),"clicked",GTK_SIGNAL_FUNC( prButton ),(void *)1 );
gtk_signal_connect( GTK_OBJECT( Cancel ),"clicked",GTK_SIGNAL_FUNC( prButton ),(void *)0 );
if ( ( sbMPlayerDirInHome=calloc( 1,strlen( skinDirInHome ) + 4 ) ) != NULL )
{ strcpy( sbMPlayerDirInHome,skinDirInHome ); strcat( sbMPlayerDirInHome,"/*" ); }
if ( ( sbMPlayerPrefixDir=calloc( 1,strlen( skinMPlayerDir ) + 4 ) ) != NULL )
{ strcpy( sbMPlayerPrefixDir,skinMPlayerDir ); strcat( sbMPlayerPrefixDir,"/*" ); }
gtk_window_add_accel_group( GTK_WINDOW( SkinBrowser ),accel_group );
gtk_widget_grab_focus( SkinList );
return SkinBrowser;
}
/*
* Sets the properties of the widget. This is used for both applying the
* properties changed in the property editor, and also for loading.
*/
static void
gb_vbutton_box_set_properties (GtkWidget * widget, GbWidgetSetArgData * data)
{
gint size, i, spacing, min_width, min_height, ipad_x, ipad_y;
gchar *layout;
gboolean set_child_size = FALSE, set_child_padding = FALSE;
gboolean queue_resize = FALSE;
size = gb_widget_input_int (data, Size);
if (data->apply)
gb_box_set_size (widget, size);
layout = gb_widget_input_choice (data, Layout);
if (data->apply)
{
for (i = 0; i < sizeof (GbLayoutValues) / sizeof (GbLayoutValues[0]); i
++)
{
if (!strcmp (layout, GbLayoutChoices[i])
|| !strcmp (layout, GbLayoutSymbols[i]))
{
gtk_button_box_set_layout (GTK_BUTTON_BOX (widget), GbLayoutValues
[i]);
queue_resize = TRUE;
break;
}
}
}
spacing = gb_widget_input_int (data, Spacing);
if (data->apply)
{
gtk_button_box_set_spacing (GTK_BUTTON_BOX (widget), spacing);
queue_resize = TRUE;
}
min_width = gb_widget_input_int (data, Width);
if (data->apply)
set_child_size = TRUE;
else
min_width = GTK_BUTTON_BOX (widget)->child_min_width;
min_height = gb_widget_input_int (data, Height);
if (data->apply)
set_child_size = TRUE;
else
min_height = GTK_BUTTON_BOX (widget)->child_min_height;
if (set_child_size)
{
gtk_button_box_set_child_size (GTK_BUTTON_BOX (widget),
min_width, min_height);
queue_resize = TRUE;
}
ipad_x = gb_widget_input_int (data, XPad);
if (data->apply)
set_child_padding = TRUE;
else
ipad_x = GTK_BUTTON_BOX (widget)->child_ipad_x;
ipad_y = gb_widget_input_int (data, YPad);
if (data->apply)
set_child_padding = TRUE;
else
ipad_y = GTK_BUTTON_BOX (widget)->child_ipad_y;
if (set_child_padding)
{
gtk_button_box_set_child_ipadding (GTK_BUTTON_BOX (widget),
ipad_x, ipad_y);
queue_resize = TRUE;
}
if (queue_resize)
gtk_widget_queue_resize (widget);
}
void
create_error (HWND hwnd, LPCSTR dsn, LPCSTR text, LPCSTR errmsg)
{
GtkWidget *error, *dialog_vbox1, *hbox1, *pixmap1, *vbox1;
GtkWidget *l_text, *l_error, *dialog_action_area1, *hbuttonbox1, *b_ok;
GtkAccelGroup *accel_group;
GdkPixmap *pixmap;
GdkBitmap *mask;
GtkStyle *style;
guint b_ok_key;
char msg[1024];
if (hwnd == NULL || !GTK_IS_WIDGET (hwnd))
return;
accel_group = gtk_accel_group_new ();
error = gtk_dialog_new ();
if (dsn)
sprintf (msg, "Error : %s", dsn);
else
sprintf (msg, "Error ...");
gtk_object_set_data (GTK_OBJECT (error), "error", error);
gtk_window_set_title (GTK_WINDOW (error), msg);
gtk_widget_set_size_request (error, 400, 150);
gtk_window_set_position (GTK_WINDOW (error), GTK_WIN_POS_CENTER);
gtk_window_set_modal (GTK_WINDOW (error), TRUE);
gtk_window_set_default_size (GTK_WINDOW (error), 400, 150);
gtk_window_set_type_hint (GTK_WINDOW (error), GDK_WINDOW_TYPE_HINT_DIALOG);
#if GTK_CHECK_VERSION(2,0,0)
gtk_widget_show (error);
#endif
dialog_vbox1 = GTK_DIALOG (error)->vbox;
gtk_object_set_data (GTK_OBJECT (error), "dialog_vbox1", dialog_vbox1);
gtk_widget_show (dialog_vbox1);
hbox1 = gtk_hbox_new (FALSE, 6);
gtk_widget_ref (hbox1);
gtk_object_set_data_full (GTK_OBJECT (error), "hbox1", hbox1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox1);
gtk_box_pack_start (GTK_BOX (dialog_vbox1), hbox1, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (hbox1), 6);
#if GTK_CHECK_VERSION(2,0,0)
style = gtk_widget_get_style (error);
pixmap =
gdk_pixmap_create_from_xpm_d (error->window, &mask,
&style->bg[GTK_STATE_NORMAL], (gchar **) error_xpm);
#else
style = gtk_widget_get_style (GTK_WIDGET (hwnd));
pixmap =
gdk_pixmap_create_from_xpm_d (GTK_WIDGET (hwnd)->window, &mask,
&style->bg[GTK_STATE_NORMAL], (gchar **) error_xpm);
#endif
pixmap1 = gtk_pixmap_new (pixmap, mask);
gtk_widget_ref (pixmap1);
gtk_object_set_data_full (GTK_OBJECT (error), "pixmap1", pixmap1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (pixmap1);
gtk_box_pack_start (GTK_BOX (hbox1), pixmap1, FALSE, FALSE, 0);
vbox1 = gtk_vbox_new (TRUE, 0);
gtk_widget_ref (vbox1);
gtk_object_set_data_full (GTK_OBJECT (error), "vbox1", vbox1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (vbox1);
gtk_box_pack_start (GTK_BOX (hbox1), vbox1, TRUE, TRUE, 0);
l_text = gtk_label_new ("");
gtk_label_parse_uline (GTK_LABEL (l_text), (text) ? text : "");
gtk_widget_ref (l_text);
gtk_object_set_data_full (GTK_OBJECT (error), "l_text", l_text,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (l_text);
gtk_box_pack_start (GTK_BOX (vbox1), l_text, FALSE, TRUE, 0);
gtk_label_set_justify (GTK_LABEL (l_text), GTK_JUSTIFY_LEFT);
gtk_label_set_line_wrap (GTK_LABEL (l_text), TRUE);
l_error = gtk_label_new ("");
gtk_label_parse_uline (GTK_LABEL (l_error), (errmsg) ? errmsg : "");
gtk_widget_ref (l_error);
gtk_object_set_data_full (GTK_OBJECT (error), "l_error", l_error,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (l_error);
gtk_box_pack_start (GTK_BOX (vbox1), l_error, FALSE, TRUE, 0);
gtk_label_set_justify (GTK_LABEL (l_error), GTK_JUSTIFY_LEFT);
gtk_label_set_line_wrap (GTK_LABEL (l_error), TRUE);
dialog_action_area1 = GTK_DIALOG (error)->action_area;
gtk_object_set_data (GTK_OBJECT (error), "dialog_action_area1",
dialog_action_area1);
gtk_widget_show (dialog_action_area1);
gtk_container_set_border_width (GTK_CONTAINER (dialog_action_area1), 5);
hbuttonbox1 = gtk_hbutton_box_new ();
gtk_widget_ref (hbuttonbox1);
gtk_object_set_data_full (GTK_OBJECT (error), "hbuttonbox1", hbuttonbox1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbuttonbox1);
gtk_box_pack_start (GTK_BOX (dialog_action_area1), hbuttonbox1, TRUE, TRUE,
0);
gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox1), GTK_BUTTONBOX_END);
gtk_button_box_set_spacing (GTK_BUTTON_BOX (hbuttonbox1), 10);
b_ok = gtk_button_new_from_stock ("gtk-ok");
gtk_widget_ref (b_ok);
gtk_object_set_data_full (GTK_OBJECT (error), "b_ok", b_ok,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (b_ok);
gtk_container_add (GTK_CONTAINER (hbuttonbox1), b_ok);
gtk_dialog_add_action_widget (GTK_DIALOG (error), b_ok, GTK_RESPONSE_OK);
GTK_WIDGET_SET_FLAGS (b_ok, GTK_CAN_DEFAULT);
/* Ok button events */
gtk_signal_connect (GTK_OBJECT (b_ok), "clicked",
GTK_SIGNAL_FUNC (error_ok_clicked), error);
/* Close window button events */
gtk_signal_connect (GTK_OBJECT (error), "delete_event",
GTK_SIGNAL_FUNC (delete_event), NULL);
gtk_signal_connect (GTK_OBJECT (error), "destroy",
GTK_SIGNAL_FUNC (gtk_main_quit), NULL);
gtk_window_add_accel_group (GTK_WINDOW (error), accel_group);
gtk_widget_show_all (error);
gtk_main ();
}
static int dialog_install_user(GtkWindow *main_window,
char *user, int user_len,
unsigned long *user_id)
{
GtkWidget *button, *label;
GtkWidget *user_entry, *ID_entry;
GtkWidget *install_user_dialog;
GtkWidget *vbox;
GtkWidget *hbox;
/* object data */
struct install_dialog_data data;
unsigned long id;
char s_id[32];
char *whoami;
data.button_hit=0;
install_user_dialog = gtk_widget_new(GTK_TYPE_WINDOW,
"type", GTK_WINDOW_TOPLEVEL,
"window_position", GTK_WIN_POS_MOUSE,
"title", _("Install User"),
NULL);
gtk_window_set_modal(GTK_WINDOW(install_user_dialog), TRUE);
if (main_window) {
gtk_window_set_transient_for(GTK_WINDOW(install_user_dialog), GTK_WINDOW(main_window));
}
gtk_signal_connect(GTK_OBJECT(install_user_dialog), "destroy",
GTK_SIGNAL_FUNC(cb_destroy_dialog), install_user_dialog);
gtk_object_set_data(GTK_OBJECT(install_user_dialog),
"install_dialog_data", &data);
vbox = gtk_vbox_new(FALSE, 5);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 5);
gtk_container_add(GTK_CONTAINER(install_user_dialog), vbox);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
label = gtk_label_new(_("A PalmOS(c) device needs a user name and a user ID in order to sync properly."));
gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT);
gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 2);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
label = gtk_label_new(_("If you want to sync more than 1 PalmOS(c) device each one should have a different ID and preferably a different user name."));
gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT);
gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 2);
srandom(time(NULL));
/* RAND_MAX is 32768 on Solaris machines for some reason.
* If someone knows how to fix this, let me know.
*/
if (RAND_MAX==32768) {
id = 1+(2000000000.0*random()/(2147483647+1.0));
} else {
id = 1+(2000000000.0*random()/(RAND_MAX+1.0));
}
g_snprintf(s_id, 30, "%ld", id);
/* User Name entry */
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
/* Instruction label */
label = gtk_label_new(_("Most people choose their name or nickname for the user name."));
gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT);
gtk_label_set_line_wrap(GTK_LABEL(label), FALSE);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 2);
/* User Name */
hbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 2);
label = gtk_label_new(_("User Name"));
user_entry = gtk_entry_new_with_max_length(128);
entry_set_multiline_truncate(GTK_ENTRY(user_entry), TRUE);
data.user_entry = user_entry;
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 2);
gtk_box_pack_start(GTK_BOX(hbox), user_entry, TRUE, TRUE, 2);
/* Instruction label */
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
label = gtk_label_new(_("The ID should be a random number."));
gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT);
gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 2);
/* User ID */
hbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 2);
label = gtk_label_new(_("User ID"));
ID_entry = gtk_entry_new_with_max_length(32);
entry_set_multiline_truncate(GTK_ENTRY(ID_entry), TRUE);
data.ID_entry = ID_entry;
gtk_entry_set_text(GTK_ENTRY(ID_entry), s_id);
whoami = jp_user_or_whoami();
if (whoami) {
gtk_entry_set_text(GTK_ENTRY(user_entry), whoami);
free(whoami);
}
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 2);
gtk_box_pack_start(GTK_BOX(hbox), ID_entry, TRUE, TRUE, 2);
/* Cancel/Install buttons */
hbox = gtk_hbutton_box_new();
gtk_button_box_set_layout(GTK_BUTTON_BOX (hbox), GTK_BUTTONBOX_END);
gtk_button_box_set_spacing(GTK_BUTTON_BOX(hbox), 6);
gtk_container_set_border_width(GTK_CONTAINER(hbox), 5);
gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 2);
button = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
gtk_signal_connect(GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(cb_install_user_button),
GINT_TO_POINTER(DIALOG_SAID_2));
gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 1);
button = gtk_button_new_with_label(_("Install User"));
gtk_signal_connect(GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(cb_install_user_button),
GINT_TO_POINTER(DIALOG_SAID_1));
gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 1);
GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
gtk_widget_grab_default(button);
gtk_widget_grab_focus(button);
gtk_widget_show_all(install_user_dialog);
gtk_main();
g_strlcpy(user, data.user, user_len);
*user_id = data.id;
return data.button_hit;
}
BOOL
create_confirm (HWND hwnd, LPCSTR dsn, LPCSTR text)
{
GtkWidget *confirm, *dialog_vbox1, *hbox1, *pixmap1, *l_text;
GtkWidget *dialog_action_area1, *hbuttonbox1, *b_yes, *b_no;
guint b_yes_key, b_no_key;
GdkPixmap *pixmap;
GdkBitmap *mask;
GtkStyle *style;
GtkAccelGroup *accel_group;
char msg[1024];
TCONFIRM confirm_t;
if (hwnd == NULL || !GTK_IS_WIDGET (hwnd))
return FALSE;
accel_group = gtk_accel_group_new ();
confirm = gtk_dialog_new ();
if (dsn)
sprintf (msg, "Confirm action/operation on %s", dsn);
else
sprintf (msg, "Confirm action/operation ...");
gtk_object_set_data (GTK_OBJECT (confirm), "confirm", confirm);
gtk_widget_set_size_request (confirm, 400, 150);
gtk_window_set_title (GTK_WINDOW (confirm), msg);
gtk_window_set_position (GTK_WINDOW (confirm), GTK_WIN_POS_CENTER);
gtk_window_set_modal (GTK_WINDOW (confirm), TRUE);
gtk_window_set_default_size (GTK_WINDOW (confirm), 400, 150);
gtk_window_set_type_hint (GTK_WINDOW (confirm), GDK_WINDOW_TYPE_HINT_DIALOG);
#if GTK_CHECK_VERSION(2,0,0)
gtk_widget_show (confirm);
#endif
dialog_vbox1 = GTK_DIALOG (confirm)->vbox;
gtk_object_set_data (GTK_OBJECT (confirm), "dialog_vbox1", dialog_vbox1);
gtk_widget_show (dialog_vbox1);
hbox1 = gtk_hbox_new (FALSE, 6);
gtk_widget_ref (hbox1);
gtk_object_set_data_full (GTK_OBJECT (confirm), "hbox1", hbox1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox1);
gtk_box_pack_start (GTK_BOX (dialog_vbox1), hbox1, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (hbox1), 6);
#if GTK_CHECK_VERSION(2,0,0)
style = gtk_widget_get_style (confirm);
pixmap =
gdk_pixmap_create_from_xpm_d (confirm->window, &mask,
&style->bg[GTK_STATE_NORMAL], (gchar **) question_xpm);
#else
style = gtk_widget_get_style (GTK_WIDGET (hwnd));
pixmap =
gdk_pixmap_create_from_xpm_d (GTK_WIDGET (hwnd)->window, &mask,
&style->bg[GTK_STATE_NORMAL], (gchar **) question_xpm);
#endif
pixmap1 = gtk_pixmap_new (pixmap, mask);
gtk_widget_ref (pixmap1);
gtk_object_set_data_full (GTK_OBJECT (confirm), "pixmap1", pixmap1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (pixmap1);
gtk_box_pack_start (GTK_BOX (hbox1), pixmap1, FALSE, FALSE, 0);
l_text = gtk_label_new ("");
gtk_label_parse_uline (GTK_LABEL (l_text), text);
gtk_widget_ref (l_text);
gtk_object_set_data_full (GTK_OBJECT (confirm), "l_text", l_text,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (l_text);
gtk_box_pack_start (GTK_BOX (hbox1), l_text, TRUE, TRUE, 0);
gtk_label_set_justify (GTK_LABEL (l_text), GTK_JUSTIFY_LEFT);
gtk_label_set_line_wrap (GTK_LABEL (l_text), TRUE);
dialog_action_area1 = GTK_DIALOG (confirm)->action_area;
gtk_object_set_data (GTK_OBJECT (confirm), "dialog_action_area1",
dialog_action_area1);
gtk_widget_show (dialog_action_area1);
gtk_container_set_border_width (GTK_CONTAINER (dialog_action_area1), 5);
hbuttonbox1 = gtk_hbutton_box_new ();
gtk_widget_ref (hbuttonbox1);
gtk_object_set_data_full (GTK_OBJECT (confirm), "hbuttonbox1", hbuttonbox1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbuttonbox1);
gtk_box_pack_start (GTK_BOX (dialog_action_area1), hbuttonbox1, TRUE, TRUE,
0);
gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox1), GTK_BUTTONBOX_END);
gtk_button_box_set_spacing (GTK_BUTTON_BOX (hbuttonbox1), 10);
b_yes = gtk_button_new_from_stock ("gtk-yes");
gtk_widget_ref (b_yes);
gtk_object_set_data_full (GTK_OBJECT (confirm), "b_yes", b_yes,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (b_yes);
gtk_container_add (GTK_CONTAINER (hbuttonbox1), b_yes);
gtk_dialog_add_action_widget (GTK_DIALOG (confirm), b_yes, GTK_RESPONSE_YES);
GTK_WIDGET_SET_FLAGS (b_yes, GTK_CAN_DEFAULT);
b_no = gtk_button_new_from_stock ("gtk-no");
gtk_widget_ref (b_no);
gtk_object_set_data_full (GTK_OBJECT (confirm), "b_no", b_no,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (b_no);
gtk_container_add (GTK_CONTAINER (hbuttonbox1), b_no);
gtk_dialog_add_action_widget (GTK_DIALOG (confirm), b_no, GTK_RESPONSE_NO);
GTK_WIDGET_SET_FLAGS (b_no, GTK_CAN_DEFAULT);
/* Yes button events */
gtk_signal_connect (GTK_OBJECT (b_yes), "clicked",
GTK_SIGNAL_FUNC (confirm_yes_clicked), &confirm_t);
/* No button events */
gtk_signal_connect (GTK_OBJECT (b_no), "clicked",
GTK_SIGNAL_FUNC (confirm_no_clicked), &confirm_t);
/* Close window button events */
gtk_signal_connect (GTK_OBJECT (confirm), "delete_event",
GTK_SIGNAL_FUNC (delete_event), &confirm_t);
gtk_signal_connect (GTK_OBJECT (confirm), "destroy",
GTK_SIGNAL_FUNC (gtk_main_quit), NULL);
gtk_window_add_accel_group (GTK_WINDOW (confirm), accel_group);
confirm_t.yes_no = FALSE;
confirm_t.mainwnd = confirm;
gtk_widget_show_all (confirm);
gtk_main ();
return confirm_t.yes_no;
}
static void playerout_configure(void)
{
char temp[10];
GtkWidget *server_hbox, *server_label;
GtkWidget *port_hbox, *port_label;
GtkWidget *index_hbox, *index_label;
GtkWidget *buffer_hbox, *buffer_label;
if(configure_win)
return;
configure_win = gtk_window_new(GTK_WINDOW_DIALOG);
gtk_signal_connect(GTK_OBJECT(configure_win), "destroy", GTK_SIGNAL_FUNC(configure_destroy), NULL);
gtk_signal_connect(GTK_OBJECT(configure_win), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &configure_win);
gtk_window_set_title(GTK_WINDOW(configure_win), "Player Output Configuration");
gtk_window_set_position(GTK_WINDOW(configure_win), GTK_WIN_POS_MOUSE);
gtk_container_set_border_width(GTK_CONTAINER(configure_win), 10);
configure_vbox = gtk_vbox_new(FALSE, 10);
gtk_container_add(GTK_CONTAINER(configure_win), configure_vbox);
server_hbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(configure_vbox), server_hbox, FALSE, FALSE, 0);
server_label = gtk_label_new("Server Address:");
gtk_box_pack_start(GTK_BOX(server_hbox), server_label, FALSE, FALSE, 0);
gtk_widget_show(server_label);
server_address_entry = gtk_entry_new();
if (server_address)
gtk_entry_set_text(GTK_ENTRY(server_address_entry), server_address);
gtk_widget_set_usize(server_address_entry, 200, -1);
gtk_box_pack_start(GTK_BOX(server_hbox), server_address_entry, TRUE, TRUE, 0);
gtk_widget_show(server_address_entry);
gtk_widget_show(server_hbox);
port_hbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(configure_vbox), port_hbox, FALSE, FALSE, 0);
port_label = gtk_label_new("Server Port:");
gtk_box_pack_start(GTK_BOX(port_hbox), port_label, FALSE, FALSE, 0);
gtk_widget_show(port_label);
server_port_entry = gtk_entry_new();
snprintf (temp, 9, "%d", server_port);
gtk_entry_set_text (GTK_ENTRY(server_port_entry), temp);
gtk_widget_set_usize(server_port_entry, 200, -1);
gtk_box_pack_start(GTK_BOX(port_hbox), server_port_entry, TRUE, TRUE, 0);
gtk_widget_show(server_port_entry);
gtk_widget_show(port_hbox);
index_hbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(configure_vbox), index_hbox, FALSE, FALSE, 0);
index_label = gtk_label_new("Proxy index:");
gtk_box_pack_start(GTK_BOX(index_hbox), index_label, FALSE, FALSE, 0);
gtk_widget_show(index_label);
server_index_entry = gtk_entry_new();
snprintf (temp, 9, "%d", server_index);
gtk_entry_set_text (GTK_ENTRY(server_index_entry), temp);
gtk_widget_set_usize(server_index_entry, 200, -1);
gtk_box_pack_start(GTK_BOX(index_hbox), server_index_entry, TRUE, TRUE, 0);
gtk_widget_show(server_index_entry);
gtk_widget_show(index_hbox);
buffer_hbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(configure_vbox), buffer_hbox, FALSE, FALSE, 0);
buffer_label = gtk_label_new("Buffer length (ms):");
gtk_box_pack_start(GTK_BOX(buffer_hbox), buffer_label, FALSE, FALSE, 0);
gtk_widget_show(buffer_label);
buffer_entry = gtk_entry_new();
snprintf (temp, 9, "%d", bufferTime);
gtk_entry_set_text (GTK_ENTRY(buffer_entry), temp);
gtk_widget_set_usize(buffer_entry, 200, -1);
gtk_box_pack_start(GTK_BOX(buffer_hbox), buffer_entry, TRUE, TRUE, 0);
gtk_widget_show(buffer_entry);
gtk_widget_show(buffer_hbox);
configure_separator = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(configure_vbox), configure_separator, FALSE, FALSE, 0);
gtk_widget_show(configure_separator);
configure_bbox = gtk_hbutton_box_new();
gtk_button_box_set_layout(GTK_BUTTON_BOX(configure_bbox), GTK_BUTTONBOX_END);
gtk_button_box_set_spacing(GTK_BUTTON_BOX(configure_bbox), 5);
gtk_box_pack_start(GTK_BOX(configure_vbox), configure_bbox, FALSE, FALSE, 0);
configure_ok = gtk_button_new_with_label("Ok");
gtk_signal_connect(GTK_OBJECT(configure_ok), "clicked", GTK_SIGNAL_FUNC(configure_ok_cb), NULL);
GTK_WIDGET_SET_FLAGS(configure_ok, GTK_CAN_DEFAULT);
gtk_box_pack_start(GTK_BOX(configure_bbox), configure_ok, TRUE, TRUE, 0);
gtk_widget_show(configure_ok);
gtk_widget_grab_default(configure_ok);
configure_cancel = gtk_button_new_with_label("Cancel");
gtk_signal_connect_object(GTK_OBJECT(configure_cancel), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT(configure_win));
GTK_WIDGET_SET_FLAGS(configure_cancel, GTK_CAN_DEFAULT);
gtk_box_pack_start(GTK_BOX(configure_bbox), configure_cancel, TRUE, TRUE, 0);
gtk_widget_show(configure_cancel);
gtk_widget_show(configure_bbox);
gtk_widget_show(configure_vbox);
gtk_widget_show(configure_win);
}
