CExpressDlg::CExpressDlg(GtkWindow *pParent):m_pParent(pParent), m_ConvertBtn(NULL), m_ChannelCombo(NULL),
m_TimeCorrBtn(NULL), m_SecondsEdit(NULL), m_SecondsBtn(NULL), m_BiasCorrBtn(NULL),
m_BiasFrameEdit(NULL), m_BiasFrameBtn(NULL), m_DarkCorrBtn(NULL), m_DarkFrameEdit(NULL),
m_DarkFrameBtn(NULL), m_FlatCorrBtn(NULL), m_FlatFrameEdit(NULL), m_FlatFrameBtn(NULL),
m_PhotometryBtn(NULL), m_MatchingBtn(NULL), m_RefBtn(NULL), m_RefFrameCombo(NULL),
m_RefFrameBtn(NULL), m_CatBtn(NULL), m_CatFrameEdit(NULL), m_CatFrameBtn(NULL), m_TimeCorr(0),
m_Updating(false), m_Matching(false)
{
int row = 0;
tProjectType type = g_Project->ProjectType();
GtkWidget *table;
GSList *group;
GtkCellRenderer *renderer;
GtkTreeIter iter;
memset(&m_Params, 0, sizeof(tProcParams));
m_Channels = gtk_list_store_new(2, GTK_TYPE_INT, GTK_TYPE_STRING);
for (int i=0; RAWChannels[i].caption; i++) {
if (!RAWChannels[i].debug || type==PROJECT_TEST) {
gtk_list_store_append(m_Channels, &iter);
gtk_list_store_set(m_Channels, &iter, 0, RAWChannels[i].type, 1, RAWChannels[i].caption, -1);
}
}
m_Frames = gtk_list_store_new(2, G_TYPE_INT, G_TYPE_STRING);
// Dialog with buttons
m_pDlg = gtk_dialog_new_with_buttons("Express reduction", pParent,
(GtkDialogFlags)(GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT),
GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
GTK_STOCK_HELP, GTK_RESPONSE_HELP, NULL);
gtk_dialog_widget_standard_tooltips(GTK_DIALOG(m_pDlg));
gtk_dialog_set_tooltip_by_response(GTK_DIALOG(m_pDlg), GTK_RESPONSE_ACCEPT, "Start the process");
g_signal_connect(G_OBJECT(m_pDlg), "response", G_CALLBACK(response_dialog), this);
// Dialog icon
gchar *icon = get_icon_file("reduction");
gtk_window_set_icon(GTK_WINDOW(m_pDlg), gdk_pixbuf_new_from_file(icon, NULL));
g_free(icon);
// Dialog layout
table = gtk_table_new(4, 3, FALSE);
gtk_widget_set_size_request(table, 360, -1);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(m_pDlg)->vbox), table, TRUE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(table), 8);
gtk_table_set_row_spacings(GTK_TABLE(table), 4);
gtk_table_set_col_spacings(GTK_TABLE(table), 4);
gtk_table_set_row_spacing(GTK_TABLE(table), 2, 12);
gtk_table_set_col_spacing(GTK_TABLE(table), 0, 16);
// All frames / selected frames
GtkWidget *label = gtk_label_new(NULL);
gtk_label_set_markup(GTK_LABEL(label), "<b>Process</b>");
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 3, row, row+1);
m_AllBtn = gtk_radio_button_new_with_label(NULL, "all files in current project");
gtk_widget_set_tooltip_text(m_AllBtn, "Process all frames in the current project");
g_signal_connect(G_OBJECT(m_AllBtn), "toggled", G_CALLBACK(button_toggled), this);
gtk_table_attach_defaults(GTK_TABLE(table), m_AllBtn, 0, 3, row+1, row+2);
group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(m_AllBtn));
m_SelBtn = gtk_radio_button_new_with_label(group, "selected files only");
gtk_widget_set_tooltip_text(m_SelBtn, "Process frames that are selected in the main window");
g_signal_connect(G_OBJECT(m_SelBtn), "toggled", G_CALLBACK(button_toggled), this);
gtk_table_attach_defaults(GTK_TABLE(table), m_SelBtn, 0, 3, row+2, row+3);
row += 3;
// Actions
label = gtk_label_new(NULL);
gtk_label_set_markup(GTK_LABEL(label), "<b>Execute</b>");
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 3, row, row+1);
row++;
// Fetch / convert
m_ConvertBtn = gtk_check_button_new_with_label("Fetch/convert files");
gtk_widget_set_tooltip_text(m_ConvertBtn, "Start reduction with a fresh copy of the source frames");
g_signal_connect(G_OBJECT(m_ConvertBtn), "toggled", G_CALLBACK(button_toggled), this);
gtk_table_attach_defaults(GTK_TABLE(table), m_ConvertBtn, 0, 3, row, row+1);
m_ChannelCombo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(m_Channels));
gtk_widget_set_tooltip_text(m_ChannelCombo, "Color to grayscale conversion mode");
renderer = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(m_ChannelCombo), renderer, TRUE);
gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(m_ChannelCombo), renderer, "text", 1);
gtk_table_attach(GTK_TABLE(table), m_ChannelCombo, 1, 2, row+1, row+2,
(GtkAttachOptions)(GTK_FILL | GTK_SHRINK), GTK_FILL, 0, 0);
row+=2;
// Time correction
if (type==PROJECT_REDUCE || type==PROJECT_COMBINING || type==PROJECT_TEST) {
m_TimeCorrBtn = gtk_check_button_new_with_label("Time correction");
gtk_widget_set_tooltip_text(m_TimeCorrBtn, "Adjust the date and time of observation (time correction)");
g_signal_connect(G_OBJECT(m_TimeCorrBtn), "toggled", G_CALLBACK(button_toggled), this);
gtk_table_attach_defaults(GTK_TABLE(table), m_TimeCorrBtn, 0, 3, row, row+1);
m_SecondsEdit = gtk_entry_new();
gtk_entry_set_editable(GTK_ENTRY(m_SecondsEdit), false);
gtk_table_attach(GTK_TABLE(table), m_SecondsEdit, 1, 2, row+1, row+2,
(GtkAttachOptions)(GTK_FILL | GTK_SHRINK), GTK_FILL, 0, 0);
m_SecondsBtn = gtk_button_new_with_label("More");
gtk_widget_set_tooltip_text(m_SecondsBtn, "Specify time correction in a separate dialog");
g_signal_connect(G_OBJECT(m_SecondsBtn), "clicked", G_CALLBACK(button_clicked), this);
gtk_table_attach(GTK_TABLE(table), m_SecondsBtn, 2, 3, row+1, row+2,
(GtkAttachOptions)(GTK_FILL | GTK_SHRINK), GTK_FILL, 0, 0);
row+=2;
}
// Bias correction
if (g_Project->Profile()->GetBool(CProfile::ADVANCED_CALIBRATION)) {
if (type==PROJECT_MASTER_DARK || type==PROJECT_MASTER_FLAT || type==PROJECT_REDUCE || type==PROJECT_COMBINING || type==PROJECT_TEST) {
m_BiasCorrBtn = gtk_check_button_new_with_label("Bias-frame correction");
gtk_widget_set_tooltip_text(m_BiasCorrBtn, "Apply the bias correction");
g_signal_connect(G_OBJECT(m_BiasCorrBtn), "toggled", G_CALLBACK(button_toggled), this);
gtk_table_attach_defaults(GTK_TABLE(table), m_BiasCorrBtn, 0, 3, row, row+1);
m_BiasFrameEdit = gtk_entry_new();
gtk_widget_set_tooltip_text(m_BiasFrameEdit, "Path to the bias frame");
gtk_table_attach(GTK_TABLE(table), m_BiasFrameEdit, 1, 2, row+1, row+2,
(GtkAttachOptions)(GTK_FILL | GTK_EXPAND), GTK_FILL, 0, 0);
m_BiasFrameBtn = gtk_button_new_with_label("Browse");
gtk_widget_set_tooltip_text(m_BiasCorrBtn, "Choose a bias frame in a separate dialog");
g_signal_connect(G_OBJECT(m_BiasFrameBtn), "clicked", G_CALLBACK(button_clicked), this);
gtk_table_attach(GTK_TABLE(table), m_BiasFrameBtn, 2, 3, row+1, row+2,
(GtkAttachOptions)(GTK_FILL | GTK_SHRINK), GTK_FILL, 0, 0);
row+=2;
}
}
// Dark correction
if (type==PROJECT_MASTER_FLAT || type==PROJECT_REDUCE || type==PROJECT_COMBINING || type==PROJECT_TEST) {
m_DarkCorrBtn = gtk_check_button_new_with_label("Dark-frame correction");
gtk_widget_set_tooltip_text(m_DarkCorrBtn, "Apply the dark correction");
g_signal_connect(G_OBJECT(m_DarkCorrBtn), "toggled", G_CALLBACK(button_toggled), this);
gtk_table_attach_defaults(GTK_TABLE(table), m_DarkCorrBtn, 0, 3, row, row+1);
m_DarkFrameEdit = gtk_entry_new();
gtk_widget_set_tooltip_text(m_DarkFrameEdit, "Path to the dark frame");
gtk_table_attach(GTK_TABLE(table), m_DarkFrameEdit, 1, 2, row+1, row+2,
(GtkAttachOptions)(GTK_FILL | GTK_EXPAND), GTK_FILL, 0, 0);
m_DarkFrameBtn = gtk_button_new_with_label("Browse");
gtk_widget_set_tooltip_text(m_DarkFrameBtn, "Choose a dark frame in a separate dialog");
g_signal_connect(G_OBJECT(m_DarkFrameBtn), "clicked", G_CALLBACK(button_clicked), this);
gtk_table_attach(GTK_TABLE(table), m_DarkFrameBtn, 2, 3, row+1, row+2,
(GtkAttachOptions)(GTK_FILL | GTK_SHRINK), GTK_FILL, 0, 0);
row+=2;
}
// Flat correction
if (type==PROJECT_REDUCE || type==PROJECT_COMBINING || type==PROJECT_TEST) {
m_FlatCorrBtn = gtk_check_button_new_with_label("Flat-frame correction");
gtk_widget_set_tooltip_text(m_FlatCorrBtn, "Apply the flat correction");
g_signal_connect(G_OBJECT(m_FlatCorrBtn), "toggled", G_CALLBACK(button_toggled), this);
gtk_table_attach_defaults(GTK_TABLE(table), m_FlatCorrBtn, 0, 3, row, row+1);
m_FlatFrameEdit = gtk_entry_new();
gtk_widget_set_tooltip_text(m_FlatFrameEdit, "Path to the flat frame");
gtk_table_attach(GTK_TABLE(table), m_FlatFrameEdit, 1, 2, row+1, row+2,
(GtkAttachOptions)(GTK_FILL | GTK_EXPAND), GTK_FILL, 0, 0);
m_FlatFrameBtn = gtk_button_new_with_label("Browse");
gtk_widget_set_tooltip_text(m_FlatFrameBtn, "Choose a flat frame in a separate dialog");
g_signal_connect(G_OBJECT(m_FlatFrameBtn), "clicked", G_CALLBACK(button_clicked), this);
gtk_table_attach(GTK_TABLE(table), m_FlatFrameBtn, 2, 3, row+1, row+2,
(GtkAttachOptions)(GTK_FILL | GTK_SHRINK), GTK_FILL, 0, 0);
row+=2;
}
// Photometry
if (type==PROJECT_REDUCE || type==PROJECT_COMBINING || type==PROJECT_TEST) {
m_PhotometryBtn = gtk_check_button_new_with_label("Photometry");
gtk_widget_set_tooltip_text(m_PhotometryBtn, "Run photometry");
g_signal_connect(G_OBJECT(m_PhotometryBtn), "toggled", G_CALLBACK(button_toggled), this);
gtk_table_attach_defaults(GTK_TABLE(table), m_PhotometryBtn, 0, 3, row, row+1);
row++;
}
// Matching
if (type==PROJECT_REDUCE || type==PROJECT_COMBINING || type==PROJECT_TEST) {
m_MatchingBtn = gtk_check_button_new_with_label("Matching");
gtk_widget_set_tooltip_text(m_MatchingBtn, "Run matching");
g_signal_connect(G_OBJECT(m_MatchingBtn), "toggled", G_CALLBACK(button_toggled), this);
gtk_table_attach_defaults(GTK_TABLE(table), m_MatchingBtn, 0, 3, row, row+1);
m_RefBtn = gtk_radio_button_new_with_label(NULL, "using reference frame");
gtk_widget_set_tooltip_text(m_RefBtn, "Use one of the source frames as a reference frame");
g_signal_connect(G_OBJECT(m_RefBtn), "toggled", G_CALLBACK(button_toggled), this);
gtk_table_attach_defaults(GTK_TABLE(table), m_RefBtn, 1, 3, row+1, row+2);
m_RefFrameCombo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(m_Frames));
gtk_widget_set_tooltip_text(m_RefFrameCombo, "A frame that shall be used as a reference frame");
renderer = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(m_RefFrameCombo), renderer, TRUE);
gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(m_RefFrameCombo), renderer, "text", 1);
gtk_table_attach(GTK_TABLE(table), m_RefFrameCombo, 1, 2, row+2, row+3,
(GtkAttachOptions)(GTK_FILL | GTK_EXPAND), GTK_FILL, 0, 0);
m_RefFrameBtn = gtk_button_new_with_label("Browse");
gtk_widget_set_tooltip_text(m_RefFrameBtn, "Choose a reference frame in a separate dialog");
g_signal_connect(G_OBJECT(m_RefFrameBtn), "clicked", G_CALLBACK(button_clicked), this);
gtk_table_attach(GTK_TABLE(table), m_RefFrameBtn, 2, 3, row+2, row+3,
(GtkAttachOptions)(GTK_FILL | GTK_SHRINK), GTK_FILL, 0, 0);
group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(m_RefBtn));
m_CatBtn = gtk_radio_button_new_with_label(group, "using catalog file");
gtk_widget_set_tooltip_text(m_CatBtn, "Use a catalog file as a reference frame");
g_signal_connect(G_OBJECT(m_CatBtn), "toggled", G_CALLBACK(button_toggled), this);
gtk_table_attach_defaults(GTK_TABLE(table), m_CatBtn, 1, 3, row+3, row+4);
m_CatFrameEdit = gtk_entry_new();
gtk_widget_set_tooltip_text(m_CatFrameEdit, "Path to the catalog file that shall be used as a reference frame");
gtk_table_attach(GTK_TABLE(table), m_CatFrameEdit, 1, 2, row+4, row+5,
(GtkAttachOptions)(GTK_FILL | GTK_EXPAND), GTK_FILL, 0, 0);
m_CatFrameBtn = gtk_button_new_with_label("Browse");
gtk_widget_set_tooltip_text(m_CatFrameBtn, "Choose a catalog file in a separate dialog");
g_signal_connect(G_OBJECT(m_CatFrameBtn), "clicked", G_CALLBACK(button_clicked), this);
gtk_table_attach(GTK_TABLE(table), m_CatFrameBtn, 2, 3, row+4, row+5,
(GtkAttachOptions)(GTK_FILL | GTK_SHRINK), GTK_FILL, 0, 0);
row+=5;
}
gtk_widget_show_all(GTK_DIALOG(m_pDlg)->vbox);
}
int DoLoadPortalFileDialog(){
GtkWidget *dlg, *vbox, *hbox, *button, *entry, *check2d, *check3d;
int loop = 1, ret = IDCANCEL;
dlg = gtk_window_new( GTK_WINDOW_TOPLEVEL );
gtk_window_set_title( GTK_WINDOW( dlg ), "Load .prt" );
gtk_signal_connect( GTK_OBJECT( dlg ), "delete_event",
GTK_SIGNAL_FUNC( dialog_delete_callback ), NULL );
gtk_signal_connect( GTK_OBJECT( dlg ), "destroy",
GTK_SIGNAL_FUNC( gtk_widget_destroy ), NULL );
g_object_set_data( G_OBJECT( dlg ), "loop", &loop );
g_object_set_data( G_OBJECT( dlg ), "ret", &ret );
vbox = gtk_vbox_new( FALSE, 5 );
gtk_widget_show( vbox );
gtk_container_add( GTK_CONTAINER( dlg ), vbox );
gtk_container_set_border_width( GTK_CONTAINER( vbox ), 5 );
entry = gtk_entry_new();
gtk_widget_show( entry );
gtk_entry_set_editable( GTK_ENTRY( entry ), FALSE );
gtk_box_pack_start( GTK_BOX( vbox ), entry, FALSE, FALSE, 0 );
hbox = gtk_hbox_new( FALSE, 5 );
gtk_widget_show( hbox );
gtk_box_pack_start( GTK_BOX( vbox ), hbox, FALSE, FALSE, 0 );
check3d = gtk_check_button_new_with_label( "Show 3D" );
gtk_widget_show( check3d );
gtk_box_pack_start( GTK_BOX( hbox ), check3d, FALSE, FALSE, 0 );
check2d = gtk_check_button_new_with_label( "Show 2D" );
gtk_widget_show( check2d );
gtk_box_pack_start( GTK_BOX( hbox ), check2d, FALSE, FALSE, 0 );
button = gtk_button_new_with_label( "Change" );
gtk_widget_show( button );
gtk_box_pack_end( GTK_BOX( hbox ), button, FALSE, FALSE, 0 );
gtk_signal_connect( GTK_OBJECT( button ), "clicked", GTK_SIGNAL_FUNC( change_clicked ), entry );
gtk_widget_set_usize( button, 60, -2 );
hbox = gtk_hbox_new( FALSE, 5 );
gtk_widget_show( hbox );
gtk_box_pack_start( GTK_BOX( vbox ), hbox, FALSE, FALSE, 0 );
button = gtk_button_new_with_label( "Cancel" );
gtk_widget_show( button );
gtk_box_pack_end( GTK_BOX( hbox ), button, FALSE, FALSE, 0 );
gtk_signal_connect( GTK_OBJECT( button ), "clicked",
GTK_SIGNAL_FUNC( dialog_button_callback ), GINT_TO_POINTER( IDCANCEL ) );
gtk_widget_set_usize( button, 60, -2 );
button = gtk_button_new_with_label( "OK" );
gtk_widget_show( button );
gtk_box_pack_end( GTK_BOX( hbox ), button, FALSE, FALSE, 0 );
gtk_signal_connect( GTK_OBJECT( button ), "clicked",
GTK_SIGNAL_FUNC( dialog_button_callback ), GINT_TO_POINTER( IDOK ) );
gtk_widget_set_usize( button, 60, -2 );
char *fn = g_FuncTable.m_pfnGetMapName();
strcpy( portals.fn, fn );
fn = strrchr( portals.fn, '.' );
if ( fn != NULL ) {
*fn = '\0';
strcat( portals.fn, ".prt" );
}
gtk_entry_set_text( GTK_ENTRY( entry ), portals.fn );
gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( check2d ), portals.show_2d );
gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( check3d ), portals.show_3d );
gtk_grab_add( dlg );
gtk_widget_show( dlg );
while ( loop )
gtk_main_iteration();
if ( ret == IDOK ) {
portals.Purge();
portals.show_3d = gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( check3d ) ) ? true : false;
portals.show_2d = gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( check2d ) ) ? true : false;
}
gtk_grab_remove( dlg );
gtk_widget_destroy( dlg );
return ret;
}
void wxComboBox::SetEditable( bool editable )
{
GtkWidget *entry = GTK_COMBO(m_widget)->entry;
gtk_entry_set_editable( GTK_ENTRY(entry), editable );
}
/*----------------------------------------------------------------------------------------------------------------------*/
void FileOpenNew(gchar *Title,GtkWidget *Parent,gint X,gint Y,gboolean OpenToRead,gchar *StartPath,gchar *Mask,
gboolean MaskEditable,void (*CallBack)(GtkWidget *,gpointer),gboolean Persist)
/* Must have FileX=g_new(struct FileSelectType,1) just before reference to FileOpenNew
Title=Window title, Parent=Window wrt to which the file browser will be set_transient (keep NULL if not needed)
X,Y=Window position, OpenToRead=TRUE to open file for read or FALSE to open file for write
StartPath=initial directory, eg. "." or "/home/lamps/lamps"
Mask eg. ".ban" (limited to 3 chars); "" will give all files; "d" will give all files ending in 'd'
MaskEditable=TRUE allows the user to change the Mask
CallBack=name of callback routine eg. &ReadFile, must g_free(FileX) in this except if Persist=TRUE
Persist=TRUE keeps the browser open after selection and the "Cancel" button is replaced by "Dismiss"
in this case do not g_free(FileX) in CallBack */
{
GtkWidget *VBox,*HBox,*But,*ScrollW,*Label,*Arrow,*PxW;
#include "Home.xpm"
GdkBitmap *Msk; GdkPixmap *PxMp; GtkStyle *St;
gint i,StatOut;
struct stat StatBuf;
gchar L2Str[LONG_TEXT_FIELD];
static GdkColor Red = {0,0xFFFF,0x0000,0x0000};
static GdkColor Blue = {0,0x0000,0x0000,0xFFFF};
GtkStyle *RedStyle,*BlueStyle;
RedStyle=gtk_style_copy(gtk_widget_get_default_style());
RedStyle->fg[0]=RedStyle->text[0]=Red;
BlueStyle=gtk_style_copy(gtk_widget_get_default_style());
BlueStyle->fg[0]=BlueStyle->text[0]=Blue;
strcpy(FileX->Mask,Mask); FileX->Index=-1; FileX->N=0;
for (i=0;i<MAX_DIR_ENTRIES;++i) strcpy(FileX->Names[i],"");
FileX->Win=gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_grab_add(FileX->Win);
if (Parent) gtk_window_set_transient_for(GTK_WINDOW(FileX->Win),GTK_WINDOW(Parent));
gtk_window_set_title(GTK_WINDOW(FileX->Win),Title);
gtk_signal_connect(GTK_OBJECT(FileX->Win),"delete_event",GTK_SIGNAL_FUNC(FileOpenDelete),NULL);
gtk_container_set_border_width(GTK_CONTAINER(FileX->Win),10);
gtk_widget_set_usize(GTK_WIDGET(FileX->Win),500,466);
gtk_widget_set_uposition(GTK_WIDGET(FileX->Win),X,Y);
gtk_widget_show(FileX->Win);
St=gtk_widget_get_style(FileX->Win);
VBox=gtk_vbox_new(FALSE,0); gtk_container_add(GTK_CONTAINER(FileX->Win),VBox);
HBox=gtk_hbox_new(FALSE,0); gtk_box_pack_start(GTK_BOX(VBox),HBox,FALSE,FALSE,10);
if (OpenToRead) Label=gtk_label_new("Look in:"); else Label=gtk_label_new("Save in:");
gtk_box_pack_start(GTK_BOX(HBox),Label,FALSE,FALSE,10);
if (!strcmp(StartPath,".")) getcwd(FileX->Path,LONG_TEXT_FIELD); else strcpy(FileX->Path,StartPath);
StatOut=stat(FileX->Path,&StatBuf); //Check if the supplied StartPath is a valid directory
if (StatOut==-1) getcwd(FileX->Path,LONG_TEXT_FIELD); //stat in error
else if (!S_ISDIR(StatBuf.st_mode)) getcwd(FileX->Path,LONG_TEXT_FIELD); //Not a directory
FileX->PEntry=gtk_entry_new_with_max_length(LONG_TEXT_FIELD); gtk_entry_set_text(GTK_ENTRY(FileX->PEntry),FileX->Path);
gtk_widget_set_usize(GTK_WIDGET(FileX->PEntry),320,24);
gtk_box_pack_start(GTK_BOX(HBox),FileX->PEntry,FALSE,FALSE,0);
But=gtk_button_new(); gtk_box_pack_start(GTK_BOX(HBox),But,FALSE,FALSE,0);
Arrow=gtk_arrow_new(GTK_ARROW_UP,GTK_SHADOW_IN); gtk_container_add (GTK_CONTAINER(But),Arrow);
gtk_signal_connect(GTK_OBJECT(But),"clicked",GTK_SIGNAL_FUNC(FileOpenUp),NULL);
But=gtk_button_new(); gtk_box_pack_start(GTK_BOX(HBox),But,FALSE,FALSE,0);
gtk_signal_connect(GTK_OBJECT(But),"clicked",GTK_SIGNAL_FUNC(FileOpenHome),NULL);
PxMp=gdk_pixmap_create_from_xpm_d((FileX->Win)->window,&Msk,&St->bg[GTK_STATE_NORMAL],(gchar **)Home_xpm);
PxW=gtk_pixmap_new(PxMp,Msk); gtk_container_add(GTK_CONTAINER(But),PxW);
But=gtk_button_new_with_label("Rescan"); gtk_box_pack_start(GTK_BOX(HBox),But,FALSE,FALSE,0);
gtk_signal_connect(GTK_OBJECT(But),"clicked",GTK_SIGNAL_FUNC(FileOpenReScan),NULL);
ScrollW=gtk_scrolled_window_new(NULL,NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(ScrollW),GTK_POLICY_NEVER,GTK_POLICY_ALWAYS);
gtk_box_pack_start(GTK_BOX(VBox),ScrollW,FALSE,FALSE,0);
gtk_widget_set_usize(GTK_WIDGET(ScrollW),0,340);
FileX->Table=gtk_table_new(1,3,FALSE);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(ScrollW),FileX->Table);
gtk_table_set_row_spacings(GTK_TABLE(FileX->Table),0); gtk_table_set_col_spacings(GTK_TABLE(FileX->Table),0);
DisplayFiles();
HBox=gtk_hbox_new(FALSE,0); gtk_box_pack_start(GTK_BOX(VBox),HBox,FALSE,FALSE,10);
Label=gtk_label_new("File Name:"); gtk_box_pack_start(GTK_BOX(HBox),Label,FALSE,FALSE,0);
gtk_widget_set_usize(GTK_WIDGET(Label),100,0);
FileX->FEntry=gtk_entry_new_with_max_length(LONG_TEXT_FIELD);
gtk_box_pack_start(GTK_BOX(HBox),FileX->FEntry,FALSE,FALSE,0);
gtk_widget_set_usize(GTK_WIDGET(FileX->FEntry),160,0);
gtk_signal_connect(GTK_OBJECT(FileX->FEntry),"changed",GTK_SIGNAL_FUNC(FileChanged),NULL);
FileX->Label1=gtk_label_new(""); gtk_box_pack_start(GTK_BOX(HBox),FileX->Label1,FALSE,FALSE,0);
SetStyleRecursively(FileX->Label1,RedStyle); gtk_widget_set_usize(GTK_WIDGET(FileX->Label1),170,0);
if (OpenToRead) FileX->But=gtk_button_new_with_label("Open"); else FileX->But=gtk_button_new_with_label("Save");
gtk_box_pack_start(GTK_BOX(HBox),FileX->But,FALSE,FALSE,0);
gtk_widget_set_usize(GTK_WIDGET(FileX->But),50,0); gtk_widget_set_sensitive(FileX->But,FALSE);
gtk_signal_connect(GTK_OBJECT(FileX->But),"clicked",GTK_SIGNAL_FUNC(CallBack),NULL);
if (!Persist) gtk_signal_connect_object(GTK_OBJECT(FileX->But),"clicked",GTK_SIGNAL_FUNC(gtk_widget_destroy),
GTK_OBJECT(FileX->Win));
HBox=gtk_hbox_new(FALSE,0); gtk_box_pack_start(GTK_BOX(VBox),HBox,FALSE,FALSE,0);
if (OpenToRead) Label=gtk_label_new("Files of type:"); else Label=gtk_label_new("Save as type:");
gtk_box_pack_start(GTK_BOX(HBox),Label,FALSE,FALSE,0);
gtk_widget_set_usize(GTK_WIDGET(Label),100,0);
FileX->MEntry=gtk_entry_new_with_max_length(4);
gtk_box_pack_start(GTK_BOX(HBox),FileX->MEntry,FALSE,FALSE,0);
gtk_entry_set_text(GTK_ENTRY(FileX->MEntry),Mask);
gtk_widget_set_usize(GTK_WIDGET(FileX->MEntry),110,0);
if (MaskEditable) gtk_entry_set_editable(GTK_ENTRY(FileX->MEntry),TRUE);
else gtk_entry_set_editable(GTK_ENTRY(FileX->MEntry),FALSE);
gtk_signal_connect(GTK_OBJECT(FileX->MEntry),"changed",GTK_SIGNAL_FUNC(MaskChanged),NULL);
But=gtk_button_new_with_label("Rescan"); gtk_box_pack_start(GTK_BOX(HBox),But,FALSE,FALSE,0);
sprintf(L2Str,"%d files found",FileX->Files);
FileX->Label2=gtk_label_new(L2Str); gtk_box_pack_start(GTK_BOX(HBox),FileX->Label2,FALSE,FALSE,0);
gtk_widget_set_usize(GTK_WIDGET(FileX->Label2),170,0);
gtk_signal_connect(GTK_OBJECT(But),"clicked",GTK_SIGNAL_FUNC(FileOpenReScan),NULL);
SetStyleRecursively(FileX->Label2,BlueStyle); gtk_widget_set_usize(GTK_WIDGET(But),50,0);
if (Persist) But=gtk_button_new_with_label("Dismiss");
else But=gtk_button_new_with_label("Cancel");
gtk_box_pack_start(GTK_BOX(HBox),But,FALSE,FALSE,0);
gtk_signal_connect(GTK_OBJECT(But),"clicked",GTK_SIGNAL_FUNC(FileOpenCancel),FileX->Win);
gtk_widget_set_usize(GTK_WIDGET(But),50,0);
gtk_widget_show_all(FileX->Win);
gtk_style_unref(RedStyle); gtk_style_unref(BlueStyle);
}
bool wxTextCtrl::Create( wxWindow *parent,
wxWindowID id,
const wxString &value,
const wxPoint &pos,
const wxSize &size,
long style,
const wxValidator& validator,
const wxString &name )
{
m_needParent = true;
m_acceptsFocus = true;
if (!PreCreation( parent, pos, size ) ||
!CreateBase( parent, id, pos, size, style, validator, name ))
{
wxFAIL_MSG( wxT("wxTextCtrl creation failed") );
return false;
}
m_vScrollbarVisible = false;
bool multi_line = (style & wxTE_MULTILINE) != 0;
if (multi_line)
{
// create our control ...
m_text = gtk_text_new( NULL, NULL );
// ... and put into the upper left hand corner of the table
bool bHasHScrollbar = false;
m_widget = gtk_table_new(bHasHScrollbar ? 2 : 1, 2, FALSE);
GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
gtk_table_attach( GTK_TABLE(m_widget), m_text, 0, 1, 0, 1,
(GtkAttachOptions)(GTK_FILL | GTK_EXPAND | GTK_SHRINK),
(GtkAttachOptions)(GTK_FILL | GTK_EXPAND | GTK_SHRINK),
0, 0);
// always wrap words
gtk_text_set_word_wrap( GTK_TEXT(m_text), TRUE );
// finally, put the vertical scrollbar in the upper right corner
m_vScrollbar = gtk_vscrollbar_new( GTK_TEXT(m_text)->vadj );
GTK_WIDGET_UNSET_FLAGS( m_vScrollbar, GTK_CAN_FOCUS );
gtk_table_attach(GTK_TABLE(m_widget), m_vScrollbar, 1, 2, 0, 1,
GTK_FILL,
(GtkAttachOptions)(GTK_EXPAND | GTK_FILL | GTK_SHRINK),
0, 0);
}
else
{
// a single-line text control: no need for scrollbars
m_widget =
m_text = gtk_entry_new();
}
m_parent->DoAddChild( this );
m_focusWidget = m_text;
PostCreation(size);
if (multi_line)
gtk_widget_show(m_text);
if (multi_line)
{
gtk_signal_connect(GTK_OBJECT(GTK_TEXT(m_text)->vadj), "changed",
(GtkSignalFunc) gtk_scrollbar_changed_callback, (gpointer) this );
// only initialize gs_gtk_text_draw once, starting from the next the
// klass::draw will already be wxgtk_text_draw
if ( !gs_gtk_text_draw )
{
GtkDrawCallback&
draw = GTK_WIDGET_CLASS(GTK_OBJECT(m_text)->klass)->draw;
gs_gtk_text_draw = draw;
draw = wxgtk_text_draw;
}
}
if (!value.empty())
{
#if !GTK_CHECK_VERSION(1, 2, 0)
// if we don't realize it, GTK 1.0.6 dies with a SIGSEGV in
// gtk_editable_insert_text()
gtk_widget_realize(m_text);
#endif // GTK 1.0
gint tmp = 0;
#if wxUSE_UNICODE
wxWX2MBbuf val = value.mbc_str();
gtk_editable_insert_text( GTK_EDITABLE(m_text), val, strlen(val), &tmp );
#else
gtk_editable_insert_text( GTK_EDITABLE(m_text), value, value.length(), &tmp );
#endif
if (multi_line)
{
// Bring editable's cursor uptodate. Bug in GTK.
SET_EDITABLE_POS(m_text, gtk_text_get_point( GTK_TEXT(m_text) ));
}
}
if (style & wxTE_PASSWORD)
{
if (!multi_line)
gtk_entry_set_visibility( GTK_ENTRY(m_text), FALSE );
}
if (style & wxTE_READONLY)
{
if (!multi_line)
gtk_entry_set_editable( GTK_ENTRY(m_text), FALSE );
}
else
{
if (multi_line)
gtk_text_set_editable( GTK_TEXT(m_text), 1 );
}
// We want to be notified about text changes.
gtk_signal_connect( GTK_OBJECT(m_text), "changed",
GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this);
m_cursor = wxCursor( wxCURSOR_IBEAM );
wxTextAttr attrDef(GetForegroundColour(), GetBackgroundColour(), GetFont());
SetDefaultStyle( attrDef );
return true;
}
/*!
\brief add_slider() creates the slider from the passed data, and attaches
it the the gui.
\param ctrl_name is the name of the slider as defined in the config file
\param tbl is the table number to bind this slider to
\param table_num is the table_num from the firmware that this slider is
bound to. (used for the sliders on the 3D view)
\param row is the row of the table (tbl) that this slider goes on
\param source is the data source for this slider
\param ident is the enumeration of the page this slider goes on
\returns a Struct Rt_Slider *
*/
G_MODULE_EXPORT Rt_Slider * add_slider(gchar *ctrl_name, gint tbl, gint table_num, gint row, gchar *source, TabIdent ident)
{
Rt_Slider *slider = NULL;
GtkWidget *label = NULL;
GtkWidget *pbar = NULL;
GtkWidget *table = NULL;
GtkWidget *hbox = NULL;
gchar * name = NULL;
Rtv_Map *rtv_map = NULL;
gconstpointer *object = NULL;
rtv_map = (Rtv_Map *)DATA_GET(global_data,"rtv_map");
object = (gconstpointer *)g_hash_table_lookup(rtv_map->rtv_hash,source);
if (!(object))
{
MTXDBG(CRITICAL,_("Request to create slider for non-existant datasource \"%s\"\n"),source);
return NULL;
}
if (ident == RUNTIME_TAB)
name = g_strdup_printf("runtime_rt_table%i",tbl);
else if (ident == WARMUP_WIZ_TAB)
name = g_strdup_printf("ww_rt_table%i",tbl);
else if (ident == VE3D_VIEWER_TAB)
name = g_strdup_printf("ve3d_rt_table%i_%i",tbl,table_num);
else
{
MTXDBG(CRITICAL,_("Page ident passed is not handled, ERROR, widget add aborted\n"));
return NULL;
}
table = lookup_widget(name);
if (!table)
{
MTXDBG(CRITICAL,_("Table \"%s\" was not found, RuntimeSlider map or runtime datamap has a typo\n"),name);
g_free(name);
return NULL;
}
g_free(name);
slider = (Rt_Slider *)g_malloc0(sizeof(Rt_Slider));
slider->ctrl_name = g_strdup(ctrl_name);
slider->tbl = tbl;
slider->table_num = table_num;
slider->row = row;
slider->last = 0.0;
slider->type = MTX_PROGRESS;
slider->friendly_name = (gchar *) DATA_GET(object,"dlog_gui_name");
slider->temp_dep = (GBOOLEAN)DATA_GET(object,"temp_dep");
if ((gchar *)DATA_GET(object,"real_lower"))
slider->lower = (GINT)strtol((gchar *)DATA_GET(object,"real_lower"),NULL,10);
else
MTXDBG(CRITICAL,_("No \"real_lower\" value defined for control name %s, datasource %s\n"),ctrl_name,source);
if ((gchar *)DATA_GET(object,"real_upper"))
slider->upper = (GINT)strtol((gchar *)DATA_GET(object,"real_upper"),NULL,10);
else
MTXDBG(CRITICAL,_("No \"real_upper\" value defined for control name %s, datasource %s\n"),ctrl_name,source);
slider->history = (GArray *) DATA_GET(object,"history");
slider->object = object;
hbox = gtk_hbox_new(FALSE,5);
label = gtk_label_new(NULL);
slider->label = label;
gtk_label_set_markup(GTK_LABEL(label),slider->friendly_name);
gtk_misc_set_alignment(GTK_MISC(label),0.0,0.5);
gtk_box_pack_start(GTK_BOX(hbox),label,TRUE,TRUE,0);
label = gtk_entry_new();
gtk_entry_set_has_frame(GTK_ENTRY(label),FALSE);
gtk_entry_set_width_chars(GTK_ENTRY(label),6);
gtk_entry_set_alignment(GTK_ENTRY(label),1);
gtk_entry_set_editable(GTK_ENTRY(label),FALSE);
/* PRELIGHT seems to not give the box as NORMAL does, not sure why */
gtk_widget_modify_base(GTK_WIDGET(label),GTK_STATE_NORMAL,>k_widget_get_style(slider->label)->bg[GTK_STATE_PRELIGHT]);
slider->textval = label;
gtk_box_pack_start(GTK_BOX(hbox),label,FALSE,FALSE,0);
if ((ident == RUNTIME_TAB) || (ident == VE3D_VIEWER_TAB))
{
if (((tbl+1) % 2) == 0)
gtk_size_group_add_widget(size_group_right,hbox);
else
gtk_size_group_add_widget(size_group_left,hbox);
}
gtk_table_attach (GTK_TABLE (table),hbox,
0,2,slider->row,(slider->row)+1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
pbar = mtx_progress_bar_new();
/* 1.1 Seconds peak hold time */
mtx_progress_bar_set_hold_time(MTX_PROGRESS_BAR(pbar),1100);
gtk_progress_bar_set_orientation(GTK_PROGRESS_BAR(pbar),
GTK_PROGRESS_LEFT_TO_RIGHT);
gtk_table_attach (GTK_TABLE (table),pbar,
2,3,slider->row,(slider->row)+1,
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND|GTK_SHRINK),
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND|GTK_SHRINK), 0, 0);
slider->pbar = pbar;
slider->parent = table;
gtk_widget_show_all(slider->parent);
return slider;
}
/* when a cell is activated, we set the label and entry above the sheet
*/
static gint
activate_sheet_cell(GtkWidget *widget, gint row, gint column, Register_Window *rw)
{
GtkSheet *sheet;
GtkEntry *sheet_entry;
char cell[100],*n;
char *text;
GtkSheetCellAttr attributes;
int regnumber = rw->row_to_address[row]+column;
sheet=rw->register_sheet;
if(widget==NULL || row>sheet->maxrow || row<0||
column>sheet->maxcol || column<0 || rw==NULL)
{
printf("Warning activate_sheet_cell(%x,%x,%x,%x)\n",(unsigned int)widget,row,column,(unsigned int)rw);
return 0;
}
// this statement need gtksheet-next-version
// RegWindow_select_symbol_regnumber(rw,rw->row_to_address[row]+column);
// RegWindow_select_register(rw,rw->row_to_address[row]+column);
// FIXME, use RegWindow_select_register instead
sheet_entry = GTK_ENTRY(gtk_sheet_get_entry(sheet));
cell[0] = 0;
if(((GUI_Object*)rw)->gp)
{
if(column < REGISTERS_PER_ROW) {
if(((GUI_Object*)rw)->gp->pic_id != 0)
{
n = gpsim_get_register_name(((GUI_Object*)rw)->gp->pic_id, rw->type, regnumber);
if(n==NULL)
n="INVALID REGISTER";
}
else
n = "00"; // FIXME
strncpy(cell,n,100);
}
else
sprintf(cell," ascii ");
}
else
{
puts("Warning not gp in activate_sheet_cell()?");
sprintf(cell," 0x%02x ", regnumber);
}
gtk_label_set(GTK_LABEL(rw->location), cell);
gtk_entry_set_max_length(GTK_ENTRY(rw->entry),
GTK_ENTRY(sheet_entry)->text_max_length);
if((text=gtk_entry_get_text(GTK_ENTRY(gtk_sheet_get_entry(sheet)))))
gtk_entry_set_text(GTK_ENTRY(rw->entry), text);
else
gtk_entry_set_text(GTK_ENTRY(rw->entry), "");
gtk_sheet_get_attributes(sheet,sheet->active_cell.row,
sheet->active_cell.col, &attributes);
gtk_entry_set_editable(GTK_ENTRY(rw->entry), attributes.is_editable);
gtk_sheet_range_set_justification(sheet, sheet->range, GTK_JUSTIFY_RIGHT);
return TRUE;
}
bool createch(void)
{
struct gchan *object;
GtkWidget *fixed;
GtkWidget *frami1;
GtkWidget *vbox, *htast, *hbot;
GtkObject *adj, *adj1;
GtkWidget *playmenu, *playmenuopt;
GtkWidget *tmpwid, *tmpwid1, *dock;
GtkWidget *progress;
GtkWidget *volume;
GtkWidget *scrollwin;
GtkWidget *table, *rmit/*, *file, *http*/;
GtkWidget *piddi;
GtkTreeSelection *select;
GtkListStore *store;
GtkWidget *tree;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkTargetEntry target_entry[3];
gchar numchan[16];
unsigned int pos=0;
unsigned int idx=1;
dock=rmit=NULL;
while(( object = (struct gchan *) list_get_data(listachan, idx, 0) ))
idx++;
if(idx > MAX_CHANNELS)
return FALSE;
func(_("GTK_GUI::createch(%u)"), idx);
object = (struct gchan *) g_malloc (sizeof(struct gchan));
object->idx = idx;
object->channel = 0; /* nothing */
func(_("GTK_GUI::createch : chan[%u] is at %p"), idx, object);
mixer->create_channel(idx-1);
snprintf(numchan, 16, _("Channel[%u]"), object->idx);
frami1 = gtk_frame_new(numchan);
object->frami = frami1;
gtk_frame_set_shadow_type(GTK_FRAME(frami1), GTK_SHADOW_ETCHED_OUT);
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(frami1), vbox);
/* at the moment pos is 0 function */
list_add(&listachan, (void *) object, pos, idx, object->frami);
htast = gtk_hbox_new(TRUE, 0); /* same dimension */
fixed = gtk_fixed_new();
gtk_fixed_put(GTK_FIXED(fixed), htast, 0, 0);
gtk_box_pack_start(GTK_BOX(vbox), fixed, FALSE, FALSE, 0);
/* addiamo il coso del tempo */
tmpwid = gtk_entry_new_with_max_length(9);
object->ptime = tmpwid;
gtk_widget_set_size_request(tmpwid, 55, 22);
gtk_entry_set_text(GTK_ENTRY(tmpwid), "00:00:00");
gtk_entry_set_editable(GTK_ENTRY(tmpwid), FALSE);
gtk_box_pack_start(GTK_BOX(htast), tmpwid, FALSE, FALSE, 0);
/* enjoy ourselves with buttons */
tmpwid = createpixmap(window, tmpwid, play_xpm,
_("Play Channel"), TRUE);
object->play = tmpwid;
g_signal_connect(G_OBJECT(tmpwid), "pressed",
G_CALLBACK(gcb_play_channel), object);
gtk_box_pack_start(GTK_BOX(htast), tmpwid, FALSE, TRUE, 0);
tmpwid = createpixmap(window, tmpwid, stop_xpm,
_("Stop Channel"), FALSE);
g_signal_connect(G_OBJECT(tmpwid), "pressed",
G_CALLBACK(gcb_stop_channel), object);
gtk_box_pack_start(GTK_BOX(htast), tmpwid, FALSE, TRUE, 0);
tmpwid = createpixmap(window, tmpwid, pause_xpm,
_("Pause Channel"), TRUE);
object->pause = tmpwid;
g_signal_connect(G_OBJECT(tmpwid), "clicked",
G_CALLBACK(gcb_pause_channel), object);
gtk_box_pack_start(GTK_BOX(htast), tmpwid, FALSE, TRUE, 0);
tmpwid = createpixmap(window, tmpwid, rewind_xpm,
_("Rewind Channel"), FALSE);
g_signal_connect(G_OBJECT(tmpwid), "clicked",
G_CALLBACK(gcb_begin_channel), object);
gtk_box_pack_start(GTK_BOX(htast), tmpwid, FALSE, TRUE, 0);
tmpwid = createpixmap(window, tmpwid, forward_xpm,
_("Forward Channel"), FALSE);
g_signal_connect(G_OBJECT(tmpwid), "clicked",
G_CALLBACK(gcb_end_channel), object);
gtk_box_pack_start(GTK_BOX(htast), tmpwid, FALSE, TRUE, 0);
/* second part */
adj = gtk_adjustment_new(0.0, 0.0, 1.0, 0.1, 0.1, 0.0);
object->adjprog = adj;
progress = gtk_hscale_new(GTK_ADJUSTMENT(adj));
gtk_range_set_update_policy(GTK_RANGE(progress),GTK_UPDATE_DELAYED);
gtk_scale_set_digits(GTK_SCALE(progress), 6);
object->progress = progress;
gtk_scale_set_draw_value(GTK_SCALE(progress), FALSE);
/*
g_signal_connect(G_OBJECT(progress), "button_press_event",
G_CALLBACK(gcb_event_pause_channel), object);
g_signal_connect(G_OBJECT(progress), "button_release_event",
G_CALLBACK(gcb_event_set_position), object);
*/
/* here there is a problem: the position sticks to the mouse
maybe there is a way to say to unfocus the widget after moving it? */
g_signal_connect(G_OBJECT(progress), "button_release_event",
G_CALLBACK(gcb_event_set_position), object);
gtk_box_pack_start(GTK_BOX(vbox), progress, FALSE, FALSE, 0);
hbot = gtk_hbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(vbox), hbot);
/* volume adjustment */
adj1 = gtk_adjustment_new(0.0, 0.0, 1.0, 0.01, 0.01, 0.0);
object->adjvol = adj1;
object->volid = g_signal_connect(G_OBJECT(adj1), "value_changed",
G_CALLBACK(gcb_set_volume), object);
#ifdef WITH_SPEED
/* speed adjustment */
object->adjspeed = gtk_adjustment_new(1.0, 0.0, 1.0, 0.1, 0.1, 0.0);
g_signal_connect(G_OBJECT(object->adjspeed), "value_changed",
G_CALLBACK(gcb_set_speed), object);
#endif
volume = gtk_vscale_new(GTK_ADJUSTMENT(adj1));
gtk_scale_set_draw_value(GTK_SCALE(volume), FALSE);
tmpwid = gtk_table_new(2, 1, FALSE);
gtk_box_pack_start(GTK_BOX(hbot), tmpwid, FALSE, FALSE, 0);
tmpwid1 = gtk_vbox_new(FALSE, 0);
object->vol_lab = gtk_label_new(_("VOL"));
gtk_box_pack_start(GTK_BOX(tmpwid1), object->vol_lab, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(tmpwid1), volume, TRUE, TRUE, 0);
object->vol_lab=gtk_label_new(_("100"));
gtk_box_pack_start(GTK_BOX(tmpwid1), object->vol_lab, FALSE, FALSE, 0);
gtk_table_attach_defaults(GTK_TABLE(tmpwid), tmpwid1, 0, 1, 1, 2);
#ifdef WITH_SPEED
/* speed widget */
// tmpwid1=gtk_vbox_new(FALSE, 0);
object->speed=gtk_tx_dial_new(GTK_ADJUSTMENT(object->adjspeed));
set_tip(object->speed, _("Speed"));
gtk_box_pack_start(GTK_BOX(tmpwid1), object->speed, FALSE, FALSE, 0);
object->speed_lab=gtk_label_new(_("100"));
gtk_box_pack_start(GTK_BOX(tmpwid1), object->speed_lab, FALSE, FALSE, 0);
gtk_table_attach_defaults(GTK_TABLE(tmpwid), tmpwid1, 0, 1, 0, 1);
#endif
scrollwin = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_set_size_request(scrollwin, 90, 140);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwin),
GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
store = gtk_list_store_new(N_COLUMNS, G_TYPE_STRING);
tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
g_object_unref(store);
object->tree = tree;
//gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tree), TRUE);
/* DND stuff */
target_entry[0].target = (gchar *)DRAG_TAR_NAME_0;
target_entry[0].flags = 0;
target_entry[0].info = DRAG_TAR_INFO_0;
target_entry[1].target = (gchar *)DRAG_TAR_NAME_1;
target_entry[1].flags = 0;
target_entry[1].info = DRAG_TAR_INFO_1;
target_entry[2].target = (gchar *)DRAG_TAR_NAME_2;
target_entry[2].flags = 0;
target_entry[2].info = DRAG_TAR_INFO_2;
gtk_drag_dest_set(
tree,
(GtkDestDefaults)(GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_HIGHLIGHT |
GTK_DEST_DEFAULT_DROP),
target_entry,sizeof(target_entry) / sizeof(GtkTargetEntry),
GDK_ACTION_MOVE);
g_signal_connect(G_OBJECT(tree), "drag_motion",
G_CALLBACK(DND_data_motion), object);
gtk_drag_source_set(
tree,
(GdkModifierType) (GDK_BUTTON1_MASK | GDK_BUTTON2_MASK),
target_entry, sizeof(target_entry) / sizeof(GtkTargetEntry),
GDK_ACTION_MOVE);
g_signal_connect(G_OBJECT(tree), "drag_begin",
G_CALLBACK(DND_begin), object);
g_signal_connect(G_OBJECT(tree), "drag_end",
G_CALLBACK(DND_end), object);
g_signal_connect(G_OBJECT(tree), "drag_data_get",
G_CALLBACK(DND_data_get), object);
g_signal_connect(G_OBJECT(tree), "drag_data_received",
G_CALLBACK(DND_data_received), object);
g_signal_connect(G_OBJECT(tree), "drag_data_delete",
G_CALLBACK(DND_data_delete), object);
/* end*/
select = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree));
gtk_tree_selection_set_mode (select, GTK_SELECTION_MULTIPLE);
/*g_signal_connect(G_OBJECT(select), "changed",
G_CALLBACK(gcb_set_channel), object);
*/
g_signal_connect(G_OBJECT(tree), "button_press_event",
G_CALLBACK(gcb_event_view_popup), object);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Nick",
renderer, "text", TITLE, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tree), FALSE);
gtk_container_add(GTK_CONTAINER(scrollwin), tree);
gtk_box_pack_start(GTK_BOX(hbot), scrollwin, TRUE, TRUE, 0);
/* playmode menu */
playmenu = gtk_menu_new();
tmpwid = gtk_menu_item_new_with_label(_("single play"));
gtk_menu_append(GTK_MENU(playmenu), tmpwid);
tmpwid=gtk_menu_item_new_with_label(_("loop"));
gtk_menu_append(GTK_MENU(playmenu), tmpwid);
tmpwid=gtk_menu_item_new_with_label(_("continuous"));
gtk_menu_append(GTK_MENU(playmenu), tmpwid);
playmenuopt = gtk_option_menu_new();
gtk_option_menu_set_menu(GTK_OPTION_MENU(playmenuopt), playmenu);
g_signal_connect(G_OBJECT(playmenuopt), "changed",
G_CALLBACK(gcb_set_playmode), object);
rmit = gtk_button_new();
tmpwid = gtk_image_new_from_stock(GTK_STOCK_CANCEL,
GTK_ICON_SIZE_LARGE_TOOLBAR);
gtk_container_add(GTK_CONTAINER(rmit), tmpwid);
object->rmit = rmit;
g_signal_connect(G_OBJECT(object->rmit),"clicked",
G_CALLBACK(gcb_deletech), object);
dock = createpixmap(window, dock, dock_xpm,
_("Undock Channel"), FALSE);
object->dock = dock;
g_signal_connect(G_OBJECT(object->dock), "clicked",
G_CALLBACK(dockchan), object);
piddi = gtk_hbox_new(FALSE, 0);
object->hbox = piddi;
gtk_box_pack_start(GTK_BOX(piddi), rmit, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(piddi), dock, FALSE, FALSE, 0);
table = gtk_table_new(1, 4, TRUE);
object->table = table;
gtk_table_attach_defaults(GTK_TABLE(table), piddi, 0, 1, 0, 1);
gtk_table_attach_defaults(GTK_TABLE(table), playmenuopt, 3, 5, 0, 1);
gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, FALSE, 0);
object->playmode = 0;
/* pack_chan_insert and pos update */
pos = pack_chan_insert(object->frami);
return TRUE;
}
gint tag_edit_dialog(struct tags *otag, struct tags *ntag, gchar *file,
struct con_win *cwin)
{
GtkWidget *dialog;
GtkWidget *tag_table;
GtkWidget *label_title, *label_artist, *label_album, *label_genre, *label_tno, *label_year, *label_comment, *label_file;
GtkWidget *chk_title, *chk_artist, *chk_album, *chk_genre, *chk_tno, *chk_year, *chk_comment;
GtkWidget *entry_title, *entry_artist, *entry_album, *entry_genre, *entry_tno, *entry_year, *entry_comment, *entry_file;
GtkWidget *hbox_title, *hbox_artist, *hbox_album, *hbox_genre, *hbox_tno, *hbox_year, *hbox_comment;
GtkWidget *hbox_spins, *comment_view_scroll, *chk_alignment;
GtkTextBuffer *buffer;
GtkTextIter start, end;
gpointer storage;
gint location_id, result, changed = 0;
struct musicobject *mobj = NULL;
gchar *uri = NULL;
/*Create table*/
tag_table = gtk_table_new(8, 2, FALSE);
gtk_table_set_col_spacings(GTK_TABLE(tag_table), 5);
gtk_table_set_row_spacings(GTK_TABLE(tag_table), 5);
gtk_container_set_border_width(GTK_CONTAINER(tag_table), 5);
/* Create labels */
label_title = gtk_label_new(_("Title"));
label_artist = gtk_label_new(_("Artist"));
label_album = gtk_label_new(_("Album"));
label_genre = gtk_label_new(_("Genre"));
label_tno = gtk_label_new(_("Track No"));
label_year = gtk_label_new(_("Year"));
label_comment = gtk_label_new(_("Comment"));
label_file = gtk_label_new(_("File"));
gtk_misc_set_alignment(GTK_MISC (label_title), 1, 0.5);
gtk_misc_set_alignment(GTK_MISC (label_artist), 1, 0.5);
gtk_misc_set_alignment(GTK_MISC (label_album), 1, 0.5);
gtk_misc_set_alignment(GTK_MISC (label_genre), 1, 0.5);
gtk_misc_set_alignment(GTK_MISC (label_tno), 1, 0.5);
gtk_misc_set_alignment(GTK_MISC (label_year), 1, 0.5);
gtk_misc_set_alignment(GTK_MISC (label_comment), 1, 0);
gtk_misc_set_alignment(GTK_MISC (label_file), 1, 0.5);
/* Create entry fields */
entry_title = gtk_entry_new();
entry_artist = gtk_entry_new();
entry_album = gtk_entry_new();
entry_genre = gtk_entry_new();
entry_tno = gtk_spin_button_new_with_range (0, 2030, 1);
entry_year = gtk_spin_button_new_with_range (0, 2030, 1);
entry_comment = gtk_text_view_new();
gtk_text_view_set_accepts_tab (GTK_TEXT_VIEW (entry_comment), FALSE);
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (entry_comment));
entry_file = gtk_entry_new();
gtk_entry_set_max_length(GTK_ENTRY(entry_title), TAG_MAX_LEN);
gtk_entry_set_max_length(GTK_ENTRY(entry_artist), TAG_MAX_LEN);
gtk_entry_set_max_length(GTK_ENTRY(entry_album), TAG_MAX_LEN);
gtk_entry_set_max_length(GTK_ENTRY(entry_genre), TAG_MAX_LEN);
gtk_entry_set_completion(GTK_ENTRY(entry_artist), cwin->completion[0]);
gtk_entry_set_completion(GTK_ENTRY(entry_album), cwin->completion[1]);
gtk_entry_set_completion(GTK_ENTRY(entry_genre), cwin->completion[2]);
gtk_entry_set_icon_from_stock (GTK_ENTRY(entry_title), GTK_ENTRY_ICON_SECONDARY, GTK_STOCK_CLEAR);
gtk_entry_set_icon_from_stock (GTK_ENTRY(entry_artist), GTK_ENTRY_ICON_SECONDARY, GTK_STOCK_CLEAR);
gtk_entry_set_icon_from_stock (GTK_ENTRY(entry_album), GTK_ENTRY_ICON_SECONDARY, GTK_STOCK_CLEAR);
gtk_entry_set_icon_from_stock (GTK_ENTRY(entry_genre), GTK_ENTRY_ICON_SECONDARY, GTK_STOCK_CLEAR);
gtk_entry_set_icon_from_stock (GTK_ENTRY(entry_file), GTK_ENTRY_ICON_PRIMARY, GTK_STOCK_DIRECTORY);
gtk_entry_set_icon_from_stock (GTK_ENTRY(entry_file), GTK_ENTRY_ICON_SECONDARY, GTK_STOCK_JUMP_TO);
gtk_entry_set_editable (GTK_ENTRY(entry_file), FALSE);
/* Create checkboxes */
chk_title = gtk_check_button_new();
chk_artist = gtk_check_button_new();
chk_album = gtk_check_button_new();
chk_genre = gtk_check_button_new();
chk_year = gtk_check_button_new();
chk_tno = gtk_check_button_new();
chk_comment = gtk_check_button_new();
hbox_title = gtk_hbox_new(FALSE, 0);
hbox_artist = gtk_hbox_new(FALSE, 0);
hbox_album = gtk_hbox_new(FALSE, 0);
hbox_genre = gtk_hbox_new(FALSE, 0);
hbox_year = gtk_hbox_new(FALSE, 0);
hbox_tno = gtk_hbox_new(FALSE, 0);
hbox_comment = gtk_hbox_new(FALSE, 0);
hbox_spins = gtk_hbox_new(FALSE, 5);
/* Create hobxs(ENTRY CHECHK) and attach in table */
gtk_box_pack_start(GTK_BOX(hbox_title),
entry_title,
TRUE,
TRUE,
0);
gtk_box_pack_start(GTK_BOX(hbox_title),
chk_title,
FALSE,
FALSE,
0);
gtk_table_attach(GTK_TABLE (tag_table), label_title,
0, 1, 0, 1,
GTK_FILL, GTK_SHRINK,
0, 0);
gtk_table_attach(GTK_TABLE (tag_table), hbox_title,
1, 2, 0, 1,
GTK_FILL|GTK_EXPAND, GTK_SHRINK,
0, 0);
gtk_box_pack_start(GTK_BOX(hbox_artist),
entry_artist,
TRUE,
TRUE,
0);
gtk_box_pack_start(GTK_BOX(hbox_artist),
chk_artist,
FALSE,
FALSE,
0);
gtk_table_attach(GTK_TABLE (tag_table), label_artist,
0, 1, 1, 2,
GTK_FILL, GTK_SHRINK,
0, 0);
gtk_table_attach(GTK_TABLE (tag_table), hbox_artist,
1, 2, 1, 2,
GTK_FILL|GTK_EXPAND, GTK_SHRINK,
0, 0);
gtk_box_pack_start(GTK_BOX(hbox_album),
entry_album,
TRUE,
TRUE,
0);
gtk_box_pack_start(GTK_BOX(hbox_album),
chk_album,
FALSE,
FALSE,
0);
gtk_table_attach(GTK_TABLE (tag_table), label_album,
0, 1, 2, 3,
GTK_FILL, GTK_SHRINK,
0, 0);
gtk_table_attach(GTK_TABLE (tag_table), hbox_album,
1, 2, 2, 3,
GTK_FILL|GTK_EXPAND, GTK_SHRINK,
0, 0);
gtk_box_pack_start(GTK_BOX(hbox_genre),
entry_genre,
TRUE,
TRUE,
0);
gtk_box_pack_start(GTK_BOX(hbox_genre),
chk_genre,
FALSE,
FALSE,
0);
gtk_table_attach(GTK_TABLE (tag_table), label_genre,
0, 1, 3, 4,
GTK_FILL, GTK_SHRINK,
0, 0);
gtk_table_attach(GTK_TABLE (tag_table), hbox_genre,
1, 2, 3, 4,
GTK_FILL|GTK_EXPAND, GTK_SHRINK,
0, 0);
gtk_box_pack_start(GTK_BOX(hbox_tno),
entry_tno,
TRUE,
TRUE,
0);
gtk_box_pack_start(GTK_BOX(hbox_tno),
chk_tno,
FALSE,
FALSE,
0);
gtk_box_pack_start(GTK_BOX(hbox_year),
label_year,
FALSE,
FALSE,
5);
gtk_box_pack_start(GTK_BOX(hbox_year),
entry_year,
TRUE,
TRUE,
0);
gtk_box_pack_start(GTK_BOX(hbox_year),
chk_year,
FALSE,
FALSE,
0);
gtk_box_pack_start(GTK_BOX(hbox_spins),
hbox_tno,
TRUE,
TRUE,
0);
gtk_box_pack_start(GTK_BOX(hbox_spins),
hbox_year,
TRUE,
TRUE,
0);
gtk_table_attach(GTK_TABLE (tag_table), label_tno,
0, 1, 4, 5,
GTK_FILL, GTK_SHRINK,
0, 0);
gtk_table_attach(GTK_TABLE (tag_table), hbox_spins,
1, 2, 4, 5,
GTK_FILL|GTK_EXPAND, GTK_SHRINK,
0, 0);
comment_view_scroll = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(comment_view_scroll),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW(comment_view_scroll),
GTK_SHADOW_IN);
gtk_container_add(GTK_CONTAINER(comment_view_scroll), entry_comment);
chk_alignment = gtk_alignment_new(0.5, 0, 0, 0);
gtk_container_add(GTK_CONTAINER(chk_alignment), chk_comment);
gtk_box_pack_start(GTK_BOX(hbox_comment),
comment_view_scroll,
TRUE,
TRUE,
0);
gtk_box_pack_start(GTK_BOX(hbox_comment),
chk_alignment,
FALSE,
FALSE,
0);
gtk_table_attach(GTK_TABLE (tag_table), label_comment,
0, 1, 5, 7,
GTK_FILL, GTK_FILL|GTK_EXPAND,
0, 0);
gtk_table_attach(GTK_TABLE (tag_table), hbox_comment,
1, 2, 5, 7,
GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND,
0, 0);
gtk_table_attach(GTK_TABLE (tag_table), label_file,
0, 1, 7, 8,
GTK_FILL, GTK_SHRINK,
0, 0);
gtk_table_attach(GTK_TABLE (tag_table), entry_file,
1, 2, 7, 8,
GTK_FILL|GTK_EXPAND, GTK_SHRINK,
0, 0);
/* The main edit dialog */
dialog = gtk_dialog_new_with_buttons(_("Edit tags"),
GTK_WINDOW(cwin->mainwindow),
GTK_DIALOG_MODAL,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL,
GTK_STOCK_OK,
GTK_RESPONSE_OK,
NULL);
gtk_window_set_default_size(GTK_WINDOW (dialog), 450, -1);
/* Add to the dialog's main vbox */
gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), tag_table);
/* Fill in initial entries */
if (otag->title)
gtk_entry_set_text(GTK_ENTRY(entry_title), otag->title);
if (otag->artist)
gtk_entry_set_text(GTK_ENTRY(entry_artist), otag->artist);
if (otag->album)
gtk_entry_set_text(GTK_ENTRY(entry_album), otag->album);
if (otag->genre)
gtk_entry_set_text(GTK_ENTRY(entry_genre), otag->genre);
if (otag->track_no > 0)
gtk_spin_button_set_value(GTK_SPIN_BUTTON(entry_tno), (int)otag->track_no);
if (otag->year > 0)
gtk_spin_button_set_value(GTK_SPIN_BUTTON(entry_year), (int)otag->year);
if (otag->comment)
gtk_text_buffer_set_text (buffer, otag->comment, -1);
if (file) {
gtk_entry_set_text(GTK_ENTRY(entry_file), file);
gtk_editable_set_position(GTK_EDITABLE(entry_file), strlen(file));
gtk_dialog_add_button(GTK_DIALOG(dialog), _("Details"), GTK_RESPONSE_HELP);
}
else
gtk_widget_set_sensitive(GTK_WIDGET(entry_file), FALSE);
/* Connect to check the save changes when change the entry. */
g_signal_connect(G_OBJECT(entry_title),
"changed",
G_CALLBACK(check_entry),
chk_title);
g_signal_connect(G_OBJECT(entry_artist),
"changed",
G_CALLBACK(check_entry),
chk_artist);
g_signal_connect(G_OBJECT(entry_album),
"changed",
G_CALLBACK(check_entry),
chk_album);
g_signal_connect(G_OBJECT(entry_genre),
"changed",
G_CALLBACK(check_entry),
chk_genre);
g_signal_connect(G_OBJECT(entry_tno),
"changed",
G_CALLBACK(check_entry),
chk_tno);
g_signal_connect(G_OBJECT(entry_year),
"changed",
G_CALLBACK(check_entry),
chk_year);
g_signal_connect(G_OBJECT(buffer),
"changed",
G_CALLBACK(check_entry),
chk_comment);
/* Save changes when press enter. */
gtk_entry_set_activates_default (GTK_ENTRY(entry_title), TRUE);
gtk_entry_set_activates_default (GTK_ENTRY(entry_artist), TRUE);
gtk_entry_set_activates_default (GTK_ENTRY(entry_album), TRUE);
gtk_entry_set_activates_default (GTK_ENTRY(entry_genre), TRUE);
gtk_entry_set_activates_default (GTK_ENTRY(entry_tno), TRUE);
gtk_entry_set_activates_default (GTK_ENTRY(entry_year), TRUE);
/* Connect to set clear check when click the icon. */
g_signal_connect (G_OBJECT(entry_title),
"icon-press",
G_CALLBACK (clear_pressed),
NULL);
g_signal_connect (G_OBJECT(entry_artist),
"icon-press",
G_CALLBACK (clear_pressed),
NULL);
g_signal_connect (G_OBJECT(entry_album),
"icon-press",
G_CALLBACK (clear_pressed),
NULL);
g_signal_connect (G_OBJECT(entry_genre),
"icon-press",
G_CALLBACK (clear_pressed),
NULL);
g_signal_connect (G_OBJECT(entry_file),
"icon-press",
G_CALLBACK (directory_pressed),
file);
/* Genereate storage of gtk_entry and cwin,
* and add popup menu to copy selection to tags. */
storage = g_object_new(G_TYPE_OBJECT, NULL);
g_object_set_data(storage, "entry_title", entry_title);
g_object_set_data(storage, "entry_artist", entry_artist);
g_object_set_data(storage, "entry_album", entry_album);
g_object_set_data(storage, "entry_genre", entry_genre);
g_object_set_data(storage, "entry_comment", entry_comment);
g_object_set_data(storage, "entry_file", entry_file);
g_object_set_data(storage, "cwin", cwin);
g_signal_connect (G_OBJECT(entry_file),
"populate-popup",
G_CALLBACK (file_entry_populate_popup),
storage);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
gtk_widget_show_all(dialog);
while ((result = gtk_dialog_run (GTK_DIALOG (dialog))) &&
(result != GTK_RESPONSE_CANCEL) &&
(result != GTK_RESPONSE_OK) &&
(result != GTK_RESPONSE_DELETE_EVENT)) {
if(result == GTK_RESPONSE_HELP){
if (g_str_has_prefix(file, "cdda://"))
mobj = new_musicobject_from_cdda(cwin, otag->track_no);
else {
uri = sanitize_string_sqlite3(file);
if ((location_id = find_location_db(uri, cwin)))
mobj = new_musicobject_from_db(location_id, cwin);
else
mobj = new_musicobject_from_file(file);
}
track_properties(mobj, cwin);
}
}
switch (result)
{
case GTK_RESPONSE_OK:
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(chk_tno))) {
ntag->track_no =
gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON(entry_tno));
changed |= TAG_TNO_CHANGED;
}
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(chk_title))) {
ntag->title =
g_strdup(gtk_entry_get_text(GTK_ENTRY(entry_title)));
changed |= TAG_TITLE_CHANGED;
}
if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(chk_artist))) {
ntag->artist =
g_strdup(gtk_entry_get_text(GTK_ENTRY(entry_artist)));
changed |= TAG_ARTIST_CHANGED;
}
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(chk_album))) {
ntag->album =
g_strdup(gtk_entry_get_text(GTK_ENTRY(entry_album)));
changed |= TAG_ALBUM_CHANGED;
}
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(chk_genre))) {
ntag->genre =
g_strdup(gtk_entry_get_text(GTK_ENTRY(entry_genre)));
changed |= TAG_GENRE_CHANGED;
}
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(chk_year))) {
ntag->year =
gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON(entry_year));
changed |= TAG_YEAR_CHANGED;
}
if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(chk_comment))) {
gtk_text_buffer_get_start_iter (buffer, &start);
gtk_text_buffer_get_end_iter (buffer, &end);
ntag->comment = g_strdup(gtk_text_buffer_get_text (buffer, &start, &end, FALSE));
changed |= TAG_COMMENT_CHANGED;
}
break;
case GTK_RESPONSE_DELETE_EVENT:
break;
case GTK_RESPONSE_CANCEL:
break;
default:
break;
}
gtk_widget_destroy(dialog);
if (mobj)
delete_musicobject(mobj);
g_free(uri);
return changed;
}
void TextBox::setEditable(bool editable) {
gtk_entry_set_editable(GTK_ENTRY(object->widget), editable);
}
void
menu_about (GtkWidget * wid, gpointer sess)
{
GtkWidget *vbox, *label, *hbox;
GtkStyle *about_style;
GtkStyle *head_style;
char buf[512];
if (about)
{
gdk_window_show (about->window);
return;
}
head_style = gtk_style_new ();
#ifndef WIN32
gdk_font_unref (head_style->font);
head_style->font = gdk_font_load ("-*-times-bold-i-*-*-*-240-*");
if (!head_style->font)
head_style->font = gdk_font_load ("fixed");
#endif
head_style->fg[GTK_STATE_NORMAL] = colors[2];
about_style = gtk_style_new ();
gdk_font_unref (about_style->font);
about_style->font = gdk_font_load ("fixed");
about = gtk_window_new (GTK_WINDOW_DIALOG);
gtk_window_position (GTK_WINDOW (about), GTK_WIN_POS_CENTER);
gtk_window_set_title (GTK_WINDOW (about), _("About X-Chat"));
gtk_container_set_border_width (GTK_CONTAINER (about), 6);
gtk_signal_connect (GTK_OBJECT (about), "destroy",
GTK_SIGNAL_FUNC (about_close), 0);
gtk_widget_realize (about);
vbox = gtk_vbox_new (0, 2);
gtk_container_add (GTK_CONTAINER (about), vbox);
/*gtk_widget_show (vbox);*/
label = gtk_entry_new ();
gtk_entry_set_editable (GTK_ENTRY (label), FALSE);
gtk_entry_set_text (GTK_ENTRY (label), "X-Chat " VERSION);
gtk_widget_set_style (label, head_style);
gtk_style_unref (head_style);
gtk_container_add (GTK_CONTAINER (vbox), label);
snprintf (buf, sizeof (buf),
_("(C) 1998-2001 Peter Zelezny <*****@*****.**>\n\n"
"An IRC Client for UNIX.\n\n"
"This binary was compiled on "__DATE__"\n"
"Using GTK %d.%d.%d X %d\n"
"Running on %s\n"),
gtk_major_version, gtk_minor_version, gtk_micro_version,
#ifdef USE_XLIB
VendorRelease (GDK_DISPLAY ()), get_cpu_str());
#else
666, get_cpu_str());
#endif
label = gtk_label_new (buf);
gtk_container_add (GTK_CONTAINER (vbox), label);
gtk_widget_set_style (label, about_style);
gtk_style_unref (about_style);
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
wid = gtk_hseparator_new ();
gtk_container_add (GTK_CONTAINER (vbox), wid);
hbox = gtk_hbox_new (0, 2);
gtk_container_add (GTK_CONTAINER (vbox), hbox);
wid = gtk_button_new_with_label (" Continue ");
gtk_container_set_border_width (GTK_CONTAINER (hbox), 2);
GTK_WIDGET_SET_FLAGS (GTK_WIDGET (wid), GTK_CAN_DEFAULT);
gtk_box_pack_end (GTK_BOX (hbox), wid, 0, 0, 0);
gtk_widget_grab_default (wid);
gtk_signal_connect (GTK_OBJECT (wid), "clicked",
GTK_SIGNAL_FUNC (gtkutil_destroy), about);
gtk_widget_show_all (about);
}
GtkWidget*
create_wspec (void)
{
GtkWidget *wspec;
GtkWidget *vbox1;
GtkWidget *hbox1;
GtkWidget *label1;
GtkWidget *specfreqpointer;
GtkWidget *label2;
GtkWidget *specfreqmark;
GtkWidget *label3;
GtkWidget *specfreqspace;
GtkWidget *frame1;
GtkWidget *hbox2;
GSList *hbox2_group = NULL;
GtkWidget *shift170;
GtkWidget *shift200;
GtkWidget *shift425;
GtkWidget *shift800;
GtkWidget *shiftother;
GtkWidget *frame4;
GtkWidget *table9;
GtkWidget *spec;
GtkWidget *hruler1;
GtkWidget *squelch_vruler;
GtkAccelGroup *spec_accels;
wspec = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_widget_set_name (wspec, "wspec");
gtk_object_set_data (GTK_OBJECT (wspec), "wspec", wspec);
gtk_window_set_title (GTK_WINDOW (wspec), _("Frequency Spectrum"));
gtk_window_set_policy (GTK_WINDOW (wspec), FALSE, FALSE, FALSE);
gtk_window_set_wmclass (GTK_WINDOW (wspec), "hfterm", "hfterm");
spec_accels = gtk_accel_group_new ();
gtk_accel_group_attach(spec_accels, GTK_OBJECT(wspec));
vbox1 = gtk_vbox_new (FALSE, 0);
gtk_widget_set_name (vbox1, "vbox1");
gtk_widget_ref (vbox1);
gtk_object_set_data_full (GTK_OBJECT (wspec), "vbox1", vbox1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (vbox1);
gtk_container_add (GTK_CONTAINER (wspec), vbox1);
hbox1 = gtk_hbox_new (FALSE, 0);
gtk_widget_set_name (hbox1, "hbox1");
gtk_widget_ref (hbox1);
gtk_object_set_data_full (GTK_OBJECT (wspec), "hbox1", hbox1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox1);
gtk_box_pack_start (GTK_BOX (vbox1), hbox1, FALSE, TRUE, 3);
gtk_container_set_border_width (GTK_CONTAINER (hbox1), 1);
label1 = gtk_label_new (_("Pointer"));
gtk_widget_set_name (label1, "label1");
gtk_widget_ref (label1);
gtk_object_set_data_full (GTK_OBJECT (wspec), "label1", label1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label1);
gtk_box_pack_start (GTK_BOX (hbox1), label1, FALSE, FALSE, 0);
specfreqpointer = gtk_entry_new ();
gtk_widget_set_name (specfreqpointer, "specfreqpointer");
gtk_widget_ref (specfreqpointer);
gtk_object_set_data_full (GTK_OBJECT (wspec), "specfreqpointer", specfreqpointer,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (specfreqpointer);
gtk_box_pack_start (GTK_BOX (hbox1), specfreqpointer, FALSE, TRUE, 4);
gtk_widget_set_usize (specfreqpointer, 60, -2);
GTK_WIDGET_UNSET_FLAGS (specfreqpointer, GTK_CAN_FOCUS);
gtk_entry_set_editable (GTK_ENTRY (specfreqpointer), FALSE);
label2 = gtk_label_new (_("Mark"));
gtk_widget_set_name (label2, "label2");
gtk_widget_ref (label2);
gtk_object_set_data_full (GTK_OBJECT (wspec), "label2", label2,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label2);
gtk_box_pack_start (GTK_BOX (hbox1), label2, FALSE, FALSE, 0);
specfreqmark = gtk_entry_new ();
gtk_widget_set_name (specfreqmark, "specfreqmark");
gtk_widget_ref (specfreqmark);
gtk_object_set_data_full (GTK_OBJECT (wspec), "specfreqmark", specfreqmark,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (specfreqmark);
gtk_box_pack_start (GTK_BOX (hbox1), specfreqmark, FALSE, TRUE, 4);
gtk_widget_set_usize (specfreqmark, 60, -2);
GTK_WIDGET_UNSET_FLAGS (specfreqmark, GTK_CAN_FOCUS);
gtk_entry_set_editable (GTK_ENTRY (specfreqmark), FALSE);
label3 = gtk_label_new (_("Space"));
gtk_widget_set_name (label3, "label3");
gtk_widget_ref (label3);
gtk_object_set_data_full (GTK_OBJECT (wspec), "label3", label3,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label3);
gtk_box_pack_start (GTK_BOX (hbox1), label3, FALSE, FALSE, 0);
specfreqspace = gtk_entry_new ();
gtk_widget_set_name (specfreqspace, "specfreqspace");
gtk_widget_ref (specfreqspace);
gtk_object_set_data_full (GTK_OBJECT (wspec), "specfreqspace", specfreqspace,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (specfreqspace);
gtk_box_pack_start (GTK_BOX (hbox1), specfreqspace, FALSE, TRUE, 4);
gtk_widget_set_usize (specfreqspace, 60, -2);
GTK_WIDGET_UNSET_FLAGS (specfreqspace, GTK_CAN_FOCUS);
gtk_entry_set_editable (GTK_ENTRY (specfreqspace), FALSE);
frame1 = gtk_frame_new (_("Shift"));
gtk_widget_set_name (frame1, "frame1");
gtk_widget_ref (frame1);
gtk_object_set_data_full (GTK_OBJECT (wspec), "frame1", frame1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (frame1);
gtk_box_pack_end (GTK_BOX (hbox1), frame1, FALSE, TRUE, 0);
hbox2 = gtk_hbox_new (FALSE, 0);
gtk_widget_set_name (hbox2, "hbox2");
gtk_widget_ref (hbox2);
gtk_object_set_data_full (GTK_OBJECT (wspec), "hbox2", hbox2,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox2);
gtk_container_add (GTK_CONTAINER (frame1), hbox2);
shift170 = gtk_radio_button_new_with_label (hbox2_group, _("170"));
hbox2_group = gtk_radio_button_group (GTK_RADIO_BUTTON (shift170));
gtk_widget_set_name (shift170, "shift170");
gtk_widget_ref (shift170);
gtk_object_set_data_full (GTK_OBJECT (wspec), "shift170", shift170,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (shift170);
gtk_box_pack_start (GTK_BOX (hbox2), shift170, FALSE, FALSE, 0);
shift200 = gtk_radio_button_new_with_label (hbox2_group, _("200"));
hbox2_group = gtk_radio_button_group (GTK_RADIO_BUTTON (shift200));
gtk_widget_set_name (shift200, "shift200");
gtk_widget_ref (shift200);
gtk_object_set_data_full (GTK_OBJECT (wspec), "shift200", shift200,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (shift200);
gtk_box_pack_start (GTK_BOX (hbox2), shift200, FALSE, FALSE, 0);
shift425 = gtk_radio_button_new_with_label (hbox2_group, _("425"));
hbox2_group = gtk_radio_button_group (GTK_RADIO_BUTTON (shift425));
gtk_widget_set_name (shift425, "shift425");
gtk_widget_ref (shift425);
gtk_object_set_data_full (GTK_OBJECT (wspec), "shift425", shift425,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (shift425);
gtk_box_pack_start (GTK_BOX (hbox2), shift425, FALSE, FALSE, 0);
shift800 = gtk_radio_button_new_with_label (hbox2_group, _("800"));
hbox2_group = gtk_radio_button_group (GTK_RADIO_BUTTON (shift800));
gtk_widget_set_name (shift800, "shift800");
gtk_widget_ref (shift800);
gtk_object_set_data_full (GTK_OBJECT (wspec), "shift800", shift800,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (shift800);
gtk_box_pack_start (GTK_BOX (hbox2), shift800, FALSE, FALSE, 0);
shiftother = gtk_radio_button_new_with_label (hbox2_group, _("other"));
hbox2_group = gtk_radio_button_group (GTK_RADIO_BUTTON (shiftother));
gtk_widget_set_name (shiftother, "shiftother");
gtk_widget_ref (shiftother);
gtk_object_set_data_full (GTK_OBJECT (wspec), "shiftother", shiftother,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (shiftother);
gtk_box_pack_start (GTK_BOX (hbox2), shiftother, FALSE, FALSE, 0);
frame4 = gtk_frame_new (_("Spectrum"));
gtk_widget_set_name (frame4, "frame4");
gtk_widget_ref (frame4);
gtk_object_set_data_full (GTK_OBJECT (wspec), "frame4", frame4,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (frame4);
gtk_box_pack_start (GTK_BOX (vbox1), frame4, FALSE, FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (frame4), 1);
table9 = gtk_table_new (2, 2, FALSE);
gtk_widget_set_name (table9, "table9");
gtk_widget_ref (table9);
gtk_object_set_data_full (GTK_OBJECT (wspec), "table9", table9,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (table9);
gtk_container_add (GTK_CONTAINER (frame4), table9);
spec = spectrum_new ("spec", NULL, NULL, 0, 0);
gtk_widget_set_name (spec, "spec");
gtk_widget_ref (spec);
gtk_object_set_data_full (GTK_OBJECT (wspec), "spec", spec,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (spec);
gtk_table_attach (GTK_TABLE (table9), spec, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
gtk_widget_set_usize (spec, 512, 384);
GTK_WIDGET_SET_FLAGS (spec, GTK_CAN_FOCUS);
GTK_WIDGET_UNSET_FLAGS (spec, GTK_CAN_DEFAULT);
gtk_widget_set_events (spec, GDK_POINTER_MOTION_MASK | GDK_BUTTON_PRESS_MASK);
hruler1 = gtk_hruler_new ();
gtk_widget_set_name (hruler1, "hruler1");
gtk_widget_ref (hruler1);
gtk_object_set_data_full (GTK_OBJECT (wspec), "hruler1", hruler1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hruler1);
gtk_table_attach (GTK_TABLE (table9), hruler1, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
gtk_ruler_set_range (GTK_RULER (hruler1), 0, 4000, 5.91797, 10);
squelch_vruler = gtk_vruler_new ();
gtk_widget_set_name (squelch_vruler, "squelch_vruler");
gtk_widget_ref (squelch_vruler);
gtk_object_set_data_full (GTK_OBJECT (wspec), "squelch_vruler", squelch_vruler,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (squelch_vruler);
gtk_table_attach (GTK_TABLE (table9), squelch_vruler, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
gtk_ruler_set_range (GTK_RULER (squelch_vruler), 0, 10, 4.24479, 10);
gtk_signal_connect (GTK_OBJECT (wspec), "delete_event",
GTK_SIGNAL_FUNC (on_wspec_delete_event),
NULL);
gtk_widget_add_accelerator(wspec, "hide", spec_accels,
GDK_f, GDK_SHIFT_MASK,
GTK_ACCEL_VISIBLE);
gtk_widget_add_accelerator(wspec, "hide", spec_accels,
GDK_Escape, 0,
GTK_ACCEL_VISIBLE);
gtk_signal_connect (GTK_OBJECT (spec), "button_press_event",
GTK_SIGNAL_FUNC (on_spec_button_press_event),
NULL);
gtk_signal_connect (GTK_OBJECT (spec), "motion_notify_event",
GTK_SIGNAL_FUNC (on_spec_motion_event),
NULL);
return wspec;
}
GtkWidget *
gtkam_chooser_new (void)
{
GtkamChooser *chooser;
GtkWidget *table, *label, *button, *combo, *vbox, *hbox, *check, *expander;
chooser = g_object_new (GTKAM_TYPE_CHOOSER, NULL);
chooser->priv->tooltips = gtk_tooltips_new ();
g_object_ref (G_OBJECT (chooser->priv->tooltips));
gtk_object_sink (GTK_OBJECT (chooser->priv->tooltips));
gp_abilities_list_new (&(chooser->priv->al));
gp_abilities_list_load (chooser->priv->al, NULL);
gp_port_info_list_new (&(chooser->priv->il));
gp_port_info_list_load (chooser->priv->il);
gtk_window_set_title (GTK_WINDOW (chooser), _("Add Camera"));
gtk_container_set_border_width (GTK_CONTAINER (chooser), 5);
vbox = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox);
gtk_box_pack_start (GTK_BOX (GTKAM_DIALOG (chooser)->vbox),
vbox, FALSE, FALSE, 0);
table = gtk_table_new (3, 3, FALSE);
gtk_table_set_row_spacings (GTK_TABLE (table), 5);
gtk_table_set_col_spacings (GTK_TABLE (table), 5);
gtk_widget_show (table);
gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
chooser->priv->table = table;
label = gtk_label_new (_("Model:"));
gtk_widget_show (label);
gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, 0, 1);
combo = gtk_combo_new ();
gtk_widget_show (combo);
gtk_table_attach_defaults (GTK_TABLE (table), combo, 1, 2, 0, 1);
chooser->priv->combo_model = GTK_COMBO (combo);
chooser->priv->entry_model = GTK_ENTRY (GTK_COMBO (combo)->entry);
#if 0
gtk_entry_set_editable (chooser->priv->entry_model, FALSE);
#endif
button = gtk_button_new_with_label (_("Detect"));
gtk_widget_show (button);
gtk_table_attach_defaults (GTK_TABLE (table), button, 2, 3, 0, 1);
g_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (on_detect_clicked), chooser);
gtk_tooltips_set_tip (chooser->priv->tooltips, button,
_("Detect USB camera"), NULL);
label = gtk_label_new (_("Port:"));
gtk_widget_show (label);
gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, 1, 2);
combo = gtk_combo_new ();
gtk_widget_show (combo);
gtk_table_attach_defaults (GTK_TABLE (table), combo, 1, 3, 1, 2);
gtk_widget_set_sensitive (combo, FALSE);
chooser->priv->entry_port = GTK_ENTRY (GTK_COMBO (combo)->entry);
chooser->priv->combo_port = GTK_COMBO (combo);
#if 0
gtk_entry_set_editable (chooser->priv->entry_port, FALSE);
#endif
button = gtk_button_new_from_stock (GTK_STOCK_ADD);
gtk_widget_set_sensitive (button, FALSE);
gtk_table_attach_defaults (GTK_TABLE (table), button, 2, 3, 1, 2);
g_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (on_add_clicked), chooser);
chooser->priv->button_add = button;
label = gtk_label_new (_("Speed:"));
gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, 2, 3);
chooser->priv->label_speed = label;
combo = gtk_combo_new ();
gtk_table_attach_defaults (GTK_TABLE (table), combo, 1, 3, 2, 3);
gtk_widget_set_sensitive (combo, FALSE);
chooser->priv->entry_speed = GTK_ENTRY (GTK_COMBO (combo)->entry);
gtk_entry_set_text (chooser->priv->entry_speed, _("Best"));
chooser->priv->combo_speed = GTK_COMBO (combo);
#if 0
gtk_entry_set_editable (chooser->priv->entry_speed, FALSE);
#endif
check = gtk_check_button_new_with_label (_("Allow multiple frontends"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), FALSE);
gtk_table_attach_defaults (GTK_TABLE (table), check, 0, 2, 3, 4);
g_signal_connect (GTK_OBJECT (check), "toggled",
GTK_SIGNAL_FUNC (on_multi_toggled), chooser);
chooser->priv->check_multi = check;
expander = gtk_expander_new (_("Enhanced"));
gtk_widget_show (expander);
gtk_box_pack_start (GTK_BOX (vbox), expander, FALSE, FALSE, 0);
vbox = gtk_vbox_new (TRUE, 6);
gtk_widget_show (vbox);
gtk_container_add (GTK_CONTAINER (expander), vbox);
hbox = gtk_hbox_new (FALSE, 6);
gtk_widget_show (hbox);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 6);
label = gtk_label_new (_("Speed:"));
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 6);
chooser->priv->label_speed = label;
combo = gtk_combo_new ();
gtk_widget_show (combo);
gtk_box_pack_start (GTK_BOX (hbox), combo, TRUE, TRUE, 6);
gtk_widget_set_sensitive (combo, FALSE);
chooser->priv->entry_speed = GTK_ENTRY (GTK_COMBO (combo)->entry);
gtk_entry_set_text (chooser->priv->entry_speed, _("Best"));
chooser->priv->combo_speed = GTK_COMBO (combo);
#if 0
gtk_entry_set_editable (chooser->priv->entry_speed, FALSE);
#endif
check = gtk_check_button_new_with_label (_("Allow multiple frontends"));
gtk_widget_show (check);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), FALSE);
gtk_box_pack_start (GTK_BOX (vbox), check, TRUE, TRUE, 6);
g_signal_connect (GTK_OBJECT (check), "toggled",
GTK_SIGNAL_FUNC (on_multi_toggled), chooser);
chooser->priv->check_multi = check;
button = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
gtk_widget_show (button);
gtk_container_add (GTK_CONTAINER (GTK_DIALOG (chooser)->action_area),
button);
g_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (on_cancel_clicked), chooser);
chooser->apply_button = gtk_button_new_from_stock (GTK_STOCK_APPLY);
gtk_widget_show (chooser->apply_button);
gtk_widget_set_sensitive (chooser->apply_button, FALSE);
gtk_container_add (GTK_CONTAINER (GTK_DIALOG (chooser)->action_area),
chooser->apply_button);
g_signal_connect (GTK_OBJECT (chooser->apply_button), "clicked",
GTK_SIGNAL_FUNC (on_apply_clicked), chooser);
button = gtk_button_new_from_stock (GTK_STOCK_OK);
gtk_widget_show (button);
gtk_container_add (GTK_CONTAINER (GTK_DIALOG (chooser)->action_area),
button);
g_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (on_ok_clicked), chooser);
gtk_widget_grab_focus (button);
chooser->priv->ok = button;
/* Fill the model combo with all models */
gtkam_chooser_set_camera_mask (chooser, GP_OPERATION_NONE);
g_signal_connect (G_OBJECT (chooser->priv->entry_model), "changed",
G_CALLBACK (on_model_changed), chooser);
g_signal_connect (G_OBJECT (chooser->priv->entry_port), "changed",
G_CALLBACK (on_port_changed), chooser);
g_signal_connect (G_OBJECT (chooser->priv->entry_speed), "changed",
G_CALLBACK (on_speed_changed), chooser);
gtkam_chooser_update_for_model (chooser);
chooser->priv->needs_update = TRUE;
gtk_widget_set_sensitive (chooser->apply_button, TRUE);
return (GTK_WIDGET (chooser));
}
GtkWidget*
create_app (void)
{
GtkWidget *app;
GtkWidget *dock1;
GtkWidget *toolbar1;
GtkWidget *tmp_toolbar_icon;
GtkWidget *button_new;
GtkWidget *button_open;
GtkWidget *button_save;
GtkWidget *button_save_as;
GtkWidget *hexentry;
GtkWidget *button_upload;
GtkWidget *radiobutton_spline;
GtkWidget *radiobutton_linear;
GtkWidget *radiobutton_free;
GtkWidget *vbox1;
GtkWidget *hbox1;
GtkWidget *vbox2;
GtkWidget *table1;
GtkWidget *label1;
GtkWidget *label2;
GtkWidget *label3;
GtkWidget *label4;
GtkWidget *label5;
GtkWidget *label6;
GtkObject *minx_adj;
GtkWidget *minx;
GtkWidget *type;
GList *type_items = NULL;
GtkWidget *typeentry;
GtkObject *maxx_adj;
GtkWidget *maxx;
GtkObject *miny_adj;
GtkWidget *miny;
GtkObject *maxy_adj;
GtkWidget *maxy;
GtkObject *count_adj;
GtkWidget *count;
GtkWidget *label10;
GtkWidget *label11;
GtkWidget *label12;
GtkObject *scale_adj;
GtkWidget *scale;
GtkObject *base_adj;
GtkWidget *base;
GtkWidget *label13;
GtkWidget *scrolledwindow1;
GtkWidget *clist;
GtkWidget *label8;
GtkWidget *label9;
GtkWidget *toolbar2;
GtkWidget *list_open;
GtkWidget *list_save;
GtkWidget *list_add;
GtkWidget *list_remove;
GtkWidget *list_use;
GtkWidget *curve;
GtkWidget *appbar1;
app = gnome_app_new ("Curvegen", _("PSXDEV Curve Generator"));
gtk_object_set_data (GTK_OBJECT (app), "app", app);
dock1 = GNOME_APP (app)->dock;
gtk_widget_ref (dock1);
gtk_object_set_data_full (GTK_OBJECT (app), "dock1", dock1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (dock1);
gnome_app_create_menus (GNOME_APP (app), menubar1_uiinfo);
gtk_widget_ref (menubar1_uiinfo[0].widget);
gtk_object_set_data_full (GTK_OBJECT (app), "file1",
menubar1_uiinfo[0].widget,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_ref (file1_menu_uiinfo[0].widget);
gtk_object_set_data_full (GTK_OBJECT (app), "exit1",
file1_menu_uiinfo[0].widget,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_ref (menubar1_uiinfo[1].widget);
gtk_object_set_data_full (GTK_OBJECT (app), "help1",
menubar1_uiinfo[1].widget,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_ref (help1_menu_uiinfo[0].widget);
gtk_object_set_data_full (GTK_OBJECT (app), "about1",
help1_menu_uiinfo[0].widget,
(GtkDestroyNotify) gtk_widget_unref);
toolbar1 = gtk_toolbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_BOTH);
gtk_widget_ref (toolbar1);
gtk_object_set_data_full (GTK_OBJECT (app), "toolbar1", toolbar1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (toolbar1);
gnome_app_add_toolbar (GNOME_APP (app), GTK_TOOLBAR (toolbar1), "toolbar1",
GNOME_DOCK_ITEM_BEH_EXCLUSIVE,
GNOME_DOCK_TOP, 1, 0, 0);
gtk_container_set_border_width (GTK_CONTAINER (toolbar1), 1);
gtk_toolbar_set_space_size (GTK_TOOLBAR (toolbar1), 16);
gtk_toolbar_set_space_style (GTK_TOOLBAR (toolbar1), GTK_TOOLBAR_SPACE_LINE);
gtk_toolbar_set_button_relief (GTK_TOOLBAR (toolbar1), GTK_RELIEF_NONE);
tmp_toolbar_icon = gnome_stock_pixmap_widget (app, GNOME_STOCK_PIXMAP_NEW);
button_new = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar1),
GTK_TOOLBAR_CHILD_BUTTON,
NULL,
_("New"),
_("New File"), NULL,
tmp_toolbar_icon, NULL, NULL);
gtk_widget_ref (button_new);
gtk_object_set_data_full (GTK_OBJECT (app), "button_new", button_new,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (button_new);
tmp_toolbar_icon = gnome_stock_pixmap_widget (app, GNOME_STOCK_PIXMAP_OPEN);
button_open = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar1),
GTK_TOOLBAR_CHILD_BUTTON,
NULL,
_("Open"),
_("Open File"), NULL,
tmp_toolbar_icon, NULL, NULL);
gtk_widget_ref (button_open);
gtk_object_set_data_full (GTK_OBJECT (app), "button_open", button_open,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (button_open);
gtk_widget_set_sensitive (button_open, FALSE);
tmp_toolbar_icon = gnome_stock_pixmap_widget (app, GNOME_STOCK_PIXMAP_SAVE);
button_save = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar1),
GTK_TOOLBAR_CHILD_BUTTON,
NULL,
_("Save"),
_("Save File"), NULL,
tmp_toolbar_icon, NULL, NULL);
gtk_widget_ref (button_save);
gtk_object_set_data_full (GTK_OBJECT (app), "button_save", button_save,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (button_save);
tmp_toolbar_icon = gnome_stock_pixmap_widget (app, GNOME_STOCK_PIXMAP_SAVE_AS);
button_save_as = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar1),
GTK_TOOLBAR_CHILD_BUTTON,
NULL,
_("Save As"),
NULL, NULL,
tmp_toolbar_icon, NULL, NULL);
gtk_widget_ref (button_save_as);
gtk_object_set_data_full (GTK_OBJECT (app), "button_save_as", button_save_as,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (button_save_as);
hexentry = gtk_entry_new ();
gtk_widget_ref (hexentry);
gtk_object_set_data_full (GTK_OBJECT (app), "hexentry", hexentry,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hexentry);
gtk_toolbar_append_widget (GTK_TOOLBAR (toolbar1), hexentry, _("Address of curve in PlayStation memory..."), NULL);
tmp_toolbar_icon = gnome_stock_pixmap_widget (app, GNOME_STOCK_PIXMAP_MAIL_FWD);
button_upload = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar1),
GTK_TOOLBAR_CHILD_BUTTON,
NULL,
_("Upload"),
NULL, NULL,
tmp_toolbar_icon, NULL, NULL);
gtk_widget_ref (button_upload);
gtk_object_set_data_full (GTK_OBJECT (app), "button_upload", button_upload,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (button_upload);
gtk_toolbar_append_space (GTK_TOOLBAR (toolbar1));
tmp_toolbar_icon = gnome_stock_pixmap_widget (app, GNOME_STOCK_PIXMAP_CONVERT);
radiobutton_spline = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar1),
GTK_TOOLBAR_CHILD_RADIOBUTTON,
NULL,
_("SPLINE"),
NULL, NULL,
tmp_toolbar_icon, NULL, NULL);
gtk_widget_ref (radiobutton_spline);
gtk_object_set_data_full (GTK_OBJECT (app), "radiobutton_spline", radiobutton_spline,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (radiobutton_spline);
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (radiobutton_spline), FALSE);
tmp_toolbar_icon = gnome_stock_pixmap_widget (app, GNOME_STOCK_PIXMAP_CONVERT);
radiobutton_linear = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar1),
GTK_TOOLBAR_CHILD_RADIOBUTTON,
radiobutton_spline,
_("LINEAR"),
NULL, NULL,
tmp_toolbar_icon, NULL, NULL);
gtk_widget_ref (radiobutton_linear);
gtk_object_set_data_full (GTK_OBJECT (app), "radiobutton_linear", radiobutton_linear,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (radiobutton_linear);
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (radiobutton_linear), FALSE);
tmp_toolbar_icon = gnome_stock_pixmap_widget (app, GNOME_STOCK_PIXMAP_CONVERT);
radiobutton_free = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar1),
GTK_TOOLBAR_CHILD_RADIOBUTTON,
radiobutton_spline,
_("FREE"),
NULL, NULL,
tmp_toolbar_icon, NULL, NULL);
gtk_widget_ref (radiobutton_free);
gtk_object_set_data_full (GTK_OBJECT (app), "radiobutton_free", radiobutton_free,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (radiobutton_free);
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (radiobutton_free), FALSE);
vbox1 = gtk_vbox_new (FALSE, 0);
gtk_widget_ref (vbox1);
gtk_object_set_data_full (GTK_OBJECT (app), "vbox1", vbox1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (vbox1);
gnome_app_set_contents (GNOME_APP (app), vbox1);
hbox1 = gtk_hbox_new (FALSE, 0);
gtk_widget_ref (hbox1);
gtk_object_set_data_full (GTK_OBJECT (app), "hbox1", hbox1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox1);
gtk_box_pack_start (GTK_BOX (vbox1), hbox1, TRUE, TRUE, 0);
vbox2 = gtk_vbox_new (FALSE, 0);
gtk_widget_ref (vbox2);
gtk_object_set_data_full (GTK_OBJECT (app), "vbox2", vbox2,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (vbox2);
gtk_box_pack_start (GTK_BOX (hbox1), vbox2, FALSE, TRUE, 0);
table1 = gtk_table_new (10, 2, FALSE);
gtk_widget_ref (table1);
gtk_object_set_data_full (GTK_OBJECT (app), "table1", table1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (table1);
gtk_box_pack_start (GTK_BOX (vbox2), table1, FALSE, FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (table1), 4);
gtk_table_set_row_spacings (GTK_TABLE (table1), 1);
gtk_table_set_col_spacings (GTK_TABLE (table1), 2);
label1 = gtk_label_new (_("Min X"));
gtk_widget_ref (label1);
gtk_object_set_data_full (GTK_OBJECT (app), "label1", label1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label1);
gtk_table_attach (GTK_TABLE (table1), label1, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label1), 7.45058e-09, 0.5);
label2 = gtk_label_new (_("Max X"));
gtk_widget_ref (label2);
gtk_object_set_data_full (GTK_OBJECT (app), "label2", label2,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label2);
gtk_table_attach (GTK_TABLE (table1), label2, 0, 1, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label2), 7.45058e-09, 0.5);
label3 = gtk_label_new (_("Min Y"));
gtk_widget_ref (label3);
gtk_object_set_data_full (GTK_OBJECT (app), "label3", label3,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label3);
gtk_table_attach (GTK_TABLE (table1), label3, 0, 1, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label3), 7.45058e-09, 0.5);
label4 = gtk_label_new (_("Max Y"));
gtk_widget_ref (label4);
gtk_object_set_data_full (GTK_OBJECT (app), "label4", label4,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label4);
gtk_table_attach (GTK_TABLE (table1), label4, 0, 1, 4, 5,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label4), 7.45058e-09, 0.5);
label5 = gtk_label_new (_("Count"));
gtk_widget_ref (label5);
gtk_object_set_data_full (GTK_OBJECT (app), "label5", label5,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label5);
gtk_table_attach (GTK_TABLE (table1), label5, 0, 1, 8, 9,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label5), 0, 0.5);
label6 = gtk_label_new (_("Type"));
gtk_widget_ref (label6);
gtk_object_set_data_full (GTK_OBJECT (app), "label6", label6,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label6);
gtk_table_attach (GTK_TABLE (table1), label6, 0, 1, 9, 10,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label6), 0, 0.5);
minx_adj = gtk_adjustment_new (0, -1e+13, 1e+13, 1, 10, 10);
minx = gtk_spin_button_new (GTK_ADJUSTMENT (minx_adj), 1, 4);
gtk_widget_ref (minx);
gtk_object_set_data_full (GTK_OBJECT (app), "minx", minx,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (minx);
gtk_table_attach (GTK_TABLE (table1), minx, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (minx), TRUE);
type = gtk_combo_new ();
gtk_widget_ref (type);
gtk_object_set_data_full (GTK_OBJECT (app), "type", type,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (type);
gtk_table_attach (GTK_TABLE (table1), type, 1, 2, 9, 10,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_combo_set_value_in_list (GTK_COMBO (type), TRUE, FALSE);
gtk_combo_set_use_arrows_always (GTK_COMBO (type), TRUE);
type_items = g_list_append (type_items, _("u_char"));
type_items = g_list_append (type_items, _("char"));
type_items = g_list_append (type_items, _("u_short"));
type_items = g_list_append (type_items, _("short"));
type_items = g_list_append (type_items, _("u_long"));
type_items = g_list_append (type_items, _("long"));
type_items = g_list_append (type_items, _("float"));
type_items = g_list_append (type_items, _("double"));
type_items = g_list_append (type_items, _("fixed (4+12)"));
gtk_combo_set_popdown_strings (GTK_COMBO (type), type_items);
g_list_free (type_items);
typeentry = GTK_COMBO (type)->entry;
gtk_widget_ref (typeentry);
gtk_object_set_data_full (GTK_OBJECT (app), "typeentry", typeentry,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (typeentry);
gtk_entry_set_editable (GTK_ENTRY (typeentry), FALSE);
gtk_entry_set_text (GTK_ENTRY (typeentry), _("u_char"));
maxx_adj = gtk_adjustment_new (1, -1e+13, 1e+13, 1, 10, 10);
maxx = gtk_spin_button_new (GTK_ADJUSTMENT (maxx_adj), 1, 4);
gtk_widget_ref (maxx);
gtk_object_set_data_full (GTK_OBJECT (app), "maxx", maxx,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (maxx);
gtk_table_attach (GTK_TABLE (table1), maxx, 1, 2, 2, 3,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (maxx), TRUE);
miny_adj = gtk_adjustment_new (0, -1e+13, 1e+13, 1, 10, 10);
miny = gtk_spin_button_new (GTK_ADJUSTMENT (miny_adj), 1, 4);
gtk_widget_ref (miny);
gtk_object_set_data_full (GTK_OBJECT (app), "miny", miny,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (miny);
gtk_table_attach (GTK_TABLE (table1), miny, 1, 2, 3, 4,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (miny), TRUE);
maxy_adj = gtk_adjustment_new (1, -1e+13, 1e+13, 1, 10, 10);
maxy = gtk_spin_button_new (GTK_ADJUSTMENT (maxy_adj), 1, 4);
gtk_widget_ref (maxy);
gtk_object_set_data_full (GTK_OBJECT (app), "maxy", maxy,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (maxy);
gtk_table_attach (GTK_TABLE (table1), maxy, 1, 2, 4, 5,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (maxy), TRUE);
count_adj = gtk_adjustment_new (1, 1, 1e+22, 1, 10, 10);
count = gtk_spin_button_new (GTK_ADJUSTMENT (count_adj), 1, 0);
gtk_widget_ref (count);
gtk_object_set_data_full (GTK_OBJECT (app), "count", count,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (count);
gtk_table_attach (GTK_TABLE (table1), count, 1, 2, 8, 9,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
label10 = gtk_label_new (_("Curve Interval:"));
gtk_widget_ref (label10);
gtk_object_set_data_full (GTK_OBJECT (app), "label10", label10,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label10);
gtk_table_attach (GTK_TABLE (table1), label10, 0, 2, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label10), 7.45058e-09, 0.5);
label11 = gtk_label_new (_("Datatype:"));
gtk_widget_ref (label11);
gtk_object_set_data_full (GTK_OBJECT (app), "label11", label11,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label11);
gtk_table_attach (GTK_TABLE (table1), label11, 0, 2, 5, 6,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label11), 7.45058e-09, 0.5);
label12 = gtk_label_new (_("Scale"));
gtk_widget_ref (label12);
gtk_object_set_data_full (GTK_OBJECT (app), "label12", label12,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label12);
gtk_table_attach (GTK_TABLE (table1), label12, 0, 1, 6, 7,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label12), 0, 0.5);
scale_adj = gtk_adjustment_new (1, 1, 1e+22, 1, 10, 10);
scale = gtk_spin_button_new (GTK_ADJUSTMENT (scale_adj), 1, 0);
gtk_widget_ref (scale);
gtk_object_set_data_full (GTK_OBJECT (app), "scale", scale,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (scale);
gtk_table_attach (GTK_TABLE (table1), scale, 1, 2, 6, 7,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
base_adj = gtk_adjustment_new (0, 0, 1e+22, 1, 10, 10);
base = gtk_spin_button_new (GTK_ADJUSTMENT (base_adj), 1, 0);
gtk_widget_ref (base);
gtk_object_set_data_full (GTK_OBJECT (app), "base", base,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (base);
gtk_table_attach (GTK_TABLE (table1), base, 1, 2, 7, 8,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
label13 = gtk_label_new (_("Base"));
gtk_widget_ref (label13);
gtk_object_set_data_full (GTK_OBJECT (app), "label13", label13,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label13);
gtk_table_attach (GTK_TABLE (table1), label13, 0, 1, 7, 8,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label13), 0, 0.5);
scrolledwindow1 = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_ref (scrolledwindow1);
gtk_object_set_data_full (GTK_OBJECT (app), "scrolledwindow1", scrolledwindow1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (scrolledwindow1);
gtk_box_pack_start (GTK_BOX (vbox2), scrolledwindow1, TRUE, TRUE, 0);
gtk_widget_set_sensitive (scrolledwindow1, FALSE);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow1), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
clist = gtk_clist_new (2);
gtk_widget_ref (clist);
gtk_object_set_data_full (GTK_OBJECT (app), "clist", clist,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (clist);
gtk_container_add (GTK_CONTAINER (scrolledwindow1), clist);
gtk_clist_set_column_width (GTK_CLIST (clist), 0, 28);
gtk_clist_set_column_width (GTK_CLIST (clist), 1, 80);
gtk_clist_column_titles_show (GTK_CLIST (clist));
label8 = gtk_label_new (_("Type"));
gtk_widget_ref (label8);
gtk_object_set_data_full (GTK_OBJECT (app), "label8", label8,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label8);
gtk_clist_set_column_widget (GTK_CLIST (clist), 0, label8);
label9 = gtk_label_new (_("Name"));
gtk_widget_ref (label9);
gtk_object_set_data_full (GTK_OBJECT (app), "label9", label9,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label9);
gtk_clist_set_column_widget (GTK_CLIST (clist), 1, label9);
toolbar2 = gtk_toolbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_BOTH);
gtk_widget_ref (toolbar2);
gtk_object_set_data_full (GTK_OBJECT (app), "toolbar2", toolbar2,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (toolbar2);
gtk_box_pack_start (GTK_BOX (vbox2), toolbar2, FALSE, FALSE, 0);
gtk_widget_set_sensitive (toolbar2, FALSE);
tmp_toolbar_icon = gnome_stock_pixmap_widget (app, GNOME_STOCK_PIXMAP_OPEN);
list_open = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar2),
GTK_TOOLBAR_CHILD_BUTTON,
NULL,
_("Open"),
NULL, NULL,
tmp_toolbar_icon, NULL, NULL);
gtk_widget_ref (list_open);
gtk_object_set_data_full (GTK_OBJECT (app), "list_open", list_open,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (list_open);
tmp_toolbar_icon = gnome_stock_pixmap_widget (app, GNOME_STOCK_PIXMAP_SAVE);
list_save = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar2),
GTK_TOOLBAR_CHILD_BUTTON,
NULL,
_("Save"),
NULL, NULL,
tmp_toolbar_icon, NULL, NULL);
gtk_widget_ref (list_save);
gtk_object_set_data_full (GTK_OBJECT (app), "list_save", list_save,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (list_save);
tmp_toolbar_icon = gnome_stock_pixmap_widget (app, GNOME_STOCK_PIXMAP_ADD);
list_add = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar2),
GTK_TOOLBAR_CHILD_BUTTON,
NULL,
_("Add"),
NULL, NULL,
tmp_toolbar_icon, NULL, NULL);
gtk_widget_ref (list_add);
gtk_object_set_data_full (GTK_OBJECT (app), "list_add", list_add,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (list_add);
tmp_toolbar_icon = gnome_stock_pixmap_widget (app, GNOME_STOCK_PIXMAP_REMOVE);
list_remove = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar2),
GTK_TOOLBAR_CHILD_BUTTON,
NULL,
_("Remove"),
NULL, NULL,
tmp_toolbar_icon, NULL, NULL);
gtk_widget_ref (list_remove);
gtk_object_set_data_full (GTK_OBJECT (app), "list_remove", list_remove,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (list_remove);
tmp_toolbar_icon = gnome_stock_pixmap_widget (app, GNOME_STOCK_PIXMAP_EXEC);
list_use = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar2),
GTK_TOOLBAR_CHILD_BUTTON,
NULL,
_("Use"),
NULL, NULL,
tmp_toolbar_icon, NULL, NULL);
gtk_widget_ref (list_use);
gtk_object_set_data_full (GTK_OBJECT (app), "list_use", list_use,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (list_use);
curve = gtk_curve_new ();
gtk_widget_ref (curve);
gtk_object_set_data_full (GTK_OBJECT (app), "curve", curve,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (curve);
gtk_box_pack_start (GTK_BOX (hbox1), curve, TRUE, TRUE, 0);
gtk_widget_set_usize (curve, 256, 256);
gtk_curve_set_range (GTK_CURVE (curve), 0, 1, 0, 1);
appbar1 = gnome_appbar_new (FALSE, TRUE, GNOME_PREFERENCES_NEVER);
gtk_widget_ref (appbar1);
gtk_object_set_data_full (GTK_OBJECT (app), "appbar1", appbar1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (appbar1);
gnome_app_set_statusbar (GNOME_APP (app), appbar1);
gtk_signal_connect (GTK_OBJECT (app), "delete_event",
GTK_SIGNAL_FUNC (on_app_delete_event),
NULL);
gtk_signal_connect (GTK_OBJECT (button_new), "clicked",
GTK_SIGNAL_FUNC (on_button_new_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (button_open), "clicked",
GTK_SIGNAL_FUNC (on_button_open_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (button_save), "clicked",
GTK_SIGNAL_FUNC (on_button_save_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (button_save_as), "clicked",
GTK_SIGNAL_FUNC (on_button_save_as_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (button_upload), "clicked",
GTK_SIGNAL_FUNC (on_button_upload_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (radiobutton_spline), "clicked",
GTK_SIGNAL_FUNC (on_radiobutton_spline_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (radiobutton_linear), "clicked",
GTK_SIGNAL_FUNC (on_radiobutton_linear_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (radiobutton_free), "clicked",
GTK_SIGNAL_FUNC (on_radiobutton_free_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (minx), "changed",
GTK_SIGNAL_FUNC (on_minx_changed),
NULL);
gtk_signal_connect (GTK_OBJECT (maxx), "changed",
GTK_SIGNAL_FUNC (on_maxx_changed),
NULL);
gtk_signal_connect (GTK_OBJECT (miny), "changed",
GTK_SIGNAL_FUNC (on_miny_changed),
NULL);
gtk_signal_connect (GTK_OBJECT (maxy), "changed",
GTK_SIGNAL_FUNC (on_maxy_changed),
NULL);
gtk_signal_connect (GTK_OBJECT (list_open), "clicked",
GTK_SIGNAL_FUNC (on_list_open_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (list_save), "clicked",
GTK_SIGNAL_FUNC (on_list_save_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (list_add), "clicked",
GTK_SIGNAL_FUNC (on_list_add_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (list_remove), "clicked",
GTK_SIGNAL_FUNC (on_list_remove_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (list_use), "clicked",
GTK_SIGNAL_FUNC (on_list_use_clicked),
NULL);
return app;
}
void GUIShowMainWindow()
{
gui.windows.main = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(gui.windows.main), "rcracki_mt-GUI");
gtk_window_set_default_size(GTK_WINDOW(gui.windows.main), 740, 540);
gtk_window_set_icon(GTK_WINDOW(gui.windows.main), gdk_pixbuf_new_from_file("icon.png", NULL));
gui.fixed.main = gtk_fixed_new();
gtk_container_add(GTK_CONTAINER(gui.windows.main), gui.fixed.main);
/* Menu bar */
gui.menu.bar = gtk_menu_bar_new();
gtk_widget_set_size_request(gui.menu.bar, 740, 28);
gui.menu.filemenu = gtk_menu_new();
gui.menu.settingsmenu = gtk_menu_new();
gui.menu.helpmenu = gtk_menu_new();
gui.menu.file = gtk_menu_item_new_with_mnemonic("_File");
gui.menu.tables = gtk_menu_item_new_with_label("Add tables");
gui.menu.hashes = gtk_menu_item_new_with_label("Add hashes");
gui.menu.session = gtk_menu_item_new_with_label("Load session");
gui.menu.quit = gtk_menu_item_new_with_label("Quit");
gui.menu.settings = gtk_menu_item_new_with_mnemonic("_Settings");
gui.menu.preferences = gtk_menu_item_new_with_label("Preferences");
gui.menu.help = gtk_menu_item_new_with_mnemonic("_Help");
gui.menu.info = gtk_menu_item_new_with_label("About");
gui.menu.seperator = gtk_separator_menu_item_new();
gtk_menu_item_set_submenu(GTK_MENU_ITEM(gui.menu.file), gui.menu.filemenu);
gtk_menu_shell_append(GTK_MENU_SHELL(gui.menu.filemenu), gui.menu.tables);
gtk_menu_shell_append(GTK_MENU_SHELL(gui.menu.filemenu), gui.menu.hashes);
gtk_menu_shell_append(GTK_MENU_SHELL(gui.menu.filemenu), gui.menu.session);
gtk_menu_shell_append(GTK_MENU_SHELL(gui.menu.filemenu), gui.menu.seperator);
gtk_menu_shell_append(GTK_MENU_SHELL(gui.menu.filemenu), gui.menu.quit);
gtk_menu_shell_append(GTK_MENU_SHELL(gui.menu.bar), gui.menu.file);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(gui.menu.settings), gui.menu.settingsmenu);
gtk_menu_shell_append(GTK_MENU_SHELL(gui.menu.settingsmenu), gui.menu.preferences);
gtk_menu_shell_append(GTK_MENU_SHELL(gui.menu.bar), gui.menu.settings);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(gui.menu.help), gui.menu.helpmenu);
gtk_menu_shell_append(GTK_MENU_SHELL(gui.menu.helpmenu), gui.menu.info);
gtk_menu_shell_append(GTK_MENU_SHELL(gui.menu.bar), gui.menu.help);
gtk_fixed_put(GTK_FIXED(gui.fixed.main), gui.menu.bar, 0, 0);
/* Control buttons */
gui.buttons.run = gtk_button_new_with_label("Run");
gtk_widget_set_size_request(gui.buttons.run, 64, 32);
gtk_fixed_put(GTK_FIXED(gui.fixed.main), gui.buttons.run, 8, 56);
gui.buttons.pause = gtk_button_new_with_label("Pause");
gtk_widget_set_size_request(gui.buttons.pause, 64, 32);
gtk_widget_set_sensitive(gui.buttons.pause, false);
gtk_fixed_put(GTK_FIXED(gui.fixed.main), gui.buttons.pause, 88, 56);
gui.buttons.abort = gtk_button_new_with_label("Abort");
gtk_widget_set_size_request(gui.buttons.abort, 64, 32);
gtk_widget_set_sensitive(gui.buttons.abort, false);
gtk_fixed_put(GTK_FIXED(gui.fixed.main), gui.buttons.abort, 168, 56);
gui.buttons.clear = gtk_button_new_with_label("Clear");
gtk_widget_set_size_request(gui.buttons.clear, 64, 32);
gtk_widget_set_tooltip_text(gui.buttons.clear, "Clear all messages");
gtk_fixed_put(GTK_FIXED(gui.fixed.main), gui.buttons.clear, 248, 56);
/* Message view */
GtkWidget *scroll = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gui.frame = gtk_aspect_frame_new("Messages", 0.1, 0.1, 10, true);
gtk_widget_set_size_request(gui.frame, 740, 165);
gtk_fixed_put(GTK_FIXED(gui.fixed.main), gui.frame, 5, 100);
gui.txtview.msg = gtk_text_view_new();
gtk_widget_set_size_request(gui.txtview.msg, 712, 140);
gtk_text_view_set_left_margin(GTK_TEXT_VIEW(gui.txtview.msg), 5);
gtk_text_view_set_editable(GTK_TEXT_VIEW(gui.txtview.msg), false);
gui.txtview.msg_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(gui.txtview.msg));
gtk_container_add(GTK_CONTAINER(scroll), gui.txtview.msg);
gtk_fixed_put(GTK_FIXED(gui.fixed.main), scroll, 8, 120);
/* Plaintext view */
scroll = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gui.frame = gtk_aspect_frame_new("Plaintexts", 0.0, 0.0, 10, true);
gtk_widget_set_size_request(gui.frame, 740, 165);
gtk_fixed_put(GTK_FIXED(gui.fixed.main), gui.frame, 5, 280);
gui.txtview.hashes = gtk_text_view_new();
gtk_widget_set_size_request(gui.txtview.hashes, 712, 140);
gtk_text_view_set_left_margin(GTK_TEXT_VIEW(gui.txtview.hashes), 5);
gtk_text_view_set_editable(GTK_TEXT_VIEW(gui.txtview.hashes), false);
gui.txtview.hashes_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(gui.txtview.hashes));
gtk_container_add(GTK_CONTAINER(scroll), gui.txtview.hashes);
gtk_fixed_put(GTK_FIXED(gui.fixed.main), scroll, 8, 300);
gtk_text_buffer_get_iter_at_offset(gui.txtview.msg_buffer, &gui.txtview.msg_iter, 0);
gtk_text_buffer_get_iter_at_offset(gui.txtview.hashes_buffer, &gui.txtview.hashes_iter, 0);
GdkColor color;
gdk_color_parse("red", &color);
gtk_text_buffer_create_tag(gui.txtview.msg_buffer, "col-red", "foreground-gdk", &color, NULL);
gdk_color_parse("darkblue", &color);
gtk_text_buffer_create_tag(gui.txtview.msg_buffer, "col-blue", "foreground-gdk", &color, NULL);
gdk_color_parse("grey", &color);
gtk_text_buffer_create_tag(gui.txtview.msg_buffer, "col-grey", "foreground-gdk", &color, NULL);
gdk_color_parse("black", &color);
gtk_text_buffer_create_tag(gui.txtview.msg_buffer, "col-black", "foreground-gdk", &color, NULL);
gdk_color_parse("darkgreen", &color);
gtk_text_buffer_create_tag(gui.txtview.msg_buffer, "col-green", "foreground-gdk", &color, NULL);
color.red = color.green = color.blue = 12000;
gtk_text_buffer_create_tag(gui.txtview.msg_buffer, "col-darkgrey", "foreground-gdk", &color, NULL);
/* Progress bar */
gui.progbar = gtk_progress_bar_new();
gtk_widget_set_size_request(gui.progbar, 735, 32);
gtk_fixed_put(GTK_FIXED(gui.fixed.main), gui.progbar, 8, 450);
/* Information bar */
gui.label = gtk_label_new("Current:");
gtk_fixed_put(GTK_FIXED(gui.fixed.main), gui.label, 20, 510);
gui.entries.current = gtk_entry_new();
gtk_entry_set_editable(GTK_ENTRY(gui.entries.current), false);
gtk_entry_set_text(GTK_ENTRY(gui.entries.current), "None");
gtk_widget_set_tooltip_text(gui.entries.current, "Current action");
gtk_widget_set_size_request(gui.entries.current, 120, 24);
gtk_fixed_put(GTK_FIXED(gui.fixed.main), gui.entries.current, 90, 505);
gui.label = gtk_label_new("Found:");
gtk_fixed_put(GTK_FIXED(gui.fixed.main), gui.label, 250, 510);
gui.entries.found = gtk_entry_new();
gtk_entry_set_editable(GTK_ENTRY(gui.entries.found), false);
gtk_widget_set_tooltip_text(gui.entries.found, "Cracked hashes");
gtk_widget_set_size_request(gui.entries.found, 120, 24);
gtk_fixed_put(GTK_FIXED(gui.fixed.main), gui.entries.found, 320, 505);
gui.label = gtk_label_new("Elapsed time:");
gtk_fixed_put(GTK_FIXED(gui.fixed.main), gui.label, 470, 510);
gui.entries.time= gtk_entry_new();
gtk_entry_set_editable(GTK_ENTRY(gui.entries.time), false);
gtk_widget_set_tooltip_text(gui.entries.time, "Elapsed time since start");
gtk_widget_set_size_request(gui.entries.time, 120, 24);
gtk_fixed_put(GTK_FIXED(gui.fixed.main), gui.entries.time, 570, 505);
gtk_widget_show_all(gui.windows.main);
g_signal_connect(gui.windows.main, "destroy", G_CALLBACK(QuitApplication), NULL);
g_signal_connect(gui.windows.main, "delete-event", G_CALLBACK(QuitApplication), NULL);
g_signal_connect(gui.menu.hashes, "activate", G_CALLBACK(ShowHashWindow), NULL);
g_signal_connect(gui.menu.tables, "activate", G_CALLBACK(GUIShowTableWindow), NULL);
g_signal_connect(gui.menu.preferences, "activate", G_CALLBACK(GUIShowSettingsWindow), NULL);
g_signal_connect(gui.buttons.run, "clicked", G_CALLBACK(StartSession), NULL);
g_signal_connect(gui.buttons.clear, "clicked", G_CALLBACK(ClearMessages), NULL);
g_signal_connect(gui.menu.session, "activate", G_CALLBACK(BrowseSessionFile), NULL);
g_signal_connect(gui.buttons.pause, "clicked", G_CALLBACK(PauseResumeSession), NULL);
g_signal_connect(gui.buttons.abort, "clicked", G_CALLBACK(AbortSession), NULL);
g_signal_connect(gui.menu.quit, "activate", G_CALLBACK(QuitApplication), NULL);
g_signal_connect(gui.menu.info, "activate", G_CALLBACK(GUIShowInfo), NULL);
}
/* Make the user pick a DiscDB genre on submit*/
static void GetDiscDBGenre(GripInfo *ginfo)
{
GtkWidget *dialog;
GtkWidget *label;
GtkWidget *submit_button;
GtkWidget *cancel_button;
GtkWidget *hbox;
GtkWidget *genre_combo;
GtkWidget *item;
int genre;
dialog=gtk_dialog_new();
gtk_window_set_title(GTK_WINDOW(dialog),_("Genre selection"));
gtk_container_border_width(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox),5);
label=gtk_label_new(_("Submission requires a genre other than 'unknown'\n"
"Please select a DiscDB genre below"));
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox),label,TRUE,TRUE,0);
gtk_widget_show(label);
genre_combo=gtk_combo_new();
gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(genre_combo)->entry),FALSE);
hbox=gtk_hbox_new(FALSE,3);
label=gtk_label_new(_("DiscDB genre"));
gtk_box_pack_start(GTK_BOX(hbox),label,FALSE,FALSE,0);
gtk_widget_show(label);
for(genre=0;genre<12;genre++) {
item=gtk_list_item_new_with_label(DiscDBGenre(genre));
gtk_object_set_user_data(GTK_OBJECT(item),
(gpointer)genre);
gtk_signal_connect(GTK_OBJECT(item), "select",
GTK_SIGNAL_FUNC(DiscDBGenreChanged),(gpointer)ginfo);
gtk_container_add(GTK_CONTAINER(GTK_COMBO(genre_combo)->list),item);
gtk_widget_show(item);
}
gtk_box_pack_start(GTK_BOX(hbox),genre_combo,TRUE,TRUE,0);
gtk_widget_show(genre_combo);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox),hbox,TRUE,TRUE,0);
gtk_widget_show(hbox);
submit_button=gtk_button_new_with_label(_("Submit"));
gtk_signal_connect(GTK_OBJECT(submit_button),"clicked",
(gpointer)SubmitEntryCB,(gpointer)ginfo);
gtk_signal_connect_object(GTK_OBJECT(submit_button),"clicked",
GTK_SIGNAL_FUNC(gtk_widget_destroy),
GTK_OBJECT(dialog));
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area),submit_button,
TRUE,TRUE,0);
gtk_widget_show(submit_button);
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(dialog));
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area),cancel_button,
TRUE,TRUE,0);
gtk_widget_show(cancel_button);
gtk_widget_show(dialog);
gtk_grab_add(dialog);
}
int
main(int argc, char **argv)
{
// support standard gtk options
gtk_init(&argc, &argv);
// check other options
if (argc == 2 && strcmp(argv[1], "-v") == 0) verbose = true;
// get get some color in the world
GdkColor yellow;
gdk_color_parse("yellow", &yellow);
GdkColor red;
gdk_color_parse("red", &red);
GdkColor darkgray;
gdk_color_parse("dark gray", &darkgray);
GdkColor blue;
gdk_color_parse("blue", &blue);
GdkColor lightblue;
gdk_color_parse("light blue", &lightblue);
GdkColor lightgreen;
gdk_color_parse("light green", &lightgreen);
GdkColor magenta;
gdk_color_parse("magenta", &magenta);
GdkColor orange;
gdk_color_parse("orange", &orange);
GdkColor violet;
gdk_color_parse("violet", &violet);
// create main window and add trimmings
GtkWidget *window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_widget_modify_bg(window, GTK_STATE_NORMAL, &blue);
gtk_window_set_default_size(GTK_WINDOW(window), 400, 200);
gtk_window_set_title(GTK_WINDOW(window), "GCALC");
gtk_container_set_border_width(GTK_CONTAINER(window), 20);
// always handle exits
g_signal_connect(window, "destroy", G_CALLBACK(gtk_main_quit), NULL);
g_signal_connect(window, "delete-event", G_CALLBACK(delete_event), NULL);
// use a table to organize
GtkWidget *table = gtk_table_new(10, 9, FALSE);
gtk_container_add(GTK_CONTAINER(window), table);
gtk_table_set_row_spacings(GTK_TABLE(table), 2);
gtk_table_set_col_spacings(GTK_TABLE(table), 2);
// add text box at row 0
text_entry = gtk_entry_new();
gtk_entry_set_max_length(GTK_ENTRY(text_entry), 400);
gtk_entry_set_editable(GTK_ENTRY(text_entry), editable);
gtk_entry_set_alignment(GTK_ENTRY(text_entry), 0);
gtk_table_attach_defaults(GTK_TABLE(table), text_entry, 0, 10, 0, 1);
// add lines of separation
GtkWidget *horizontal_line = gtk_hseparator_new();
gtk_table_attach_defaults(GTK_TABLE(table), horizontal_line, 0, 10, 1, 2);
GtkWidget *vertical_line = gtk_vseparator_new();
gtk_table_attach_defaults(GTK_TABLE(table), vertical_line, 5, 6, 1, 10);
// add row 1 buttons
// add_button_at("quit", table, VOIDFN(gtk_main_quit), 1, 2, 2, 3, &darkgray);
add_button_at("quit", table, VOIDFN(gtk_main_quit), 1, 2, 2, 3, &red);
#if 0
add_button_at("(", table, VOIDFN(button_callback), 2, 3, 2, 3);
add_button_at(")", table, VOIDFN(button_callback), 3, 4, 2, 3);
#endif
add_button_at("swap", table, VOIDFN(swap_button_callback), 2, 3, 2, 3, &darkgray);
add_button_at("C", table, VOIDFN(clear_button_callback), 3, 4, 2, 3, &darkgray);
add_button_at("AC", table, VOIDFN(allclear_button_callback), 4, 5, 2, 3, &darkgray);
add_button_at("MC", table, VOIDFN(memory_button_callback), 6, 7, 2, 3, &orange);
add_button_at("M+", table, VOIDFN(memory_button_callback), 7, 8, 2, 3, &orange);
add_button_at("M-", table, VOIDFN(memory_button_callback), 8, 9, 2, 3, &orange);
add_button_at("MR", table, VOIDFN(memory_button_callback), 9, 10, 2, 3, &orange);
// add row 2 buttons
add_button_at("1/x", table, VOIDFN(unaryop_button_callback), 1, 2, 3, 4, &magenta);
add_button_at("x^2", table, VOIDFN(unaryop_button_callback), 2, 3, 3, 4, &magenta);
add_button_at("x^3", table, VOIDFN(unaryop_button_callback), 3, 4, 3, 4, &magenta);
add_button_at("y^x", table, VOIDFN(binaryop_button_callback), 4, 5, 3, 4, &lightgreen);
add_button_at("%", table, VOIDFN(unaryop_button_callback), 6, 7, 3, 4, &magenta);
add_button_at("+/-", table, VOIDFN(unaryop_button_callback), 7, 8, 3, 4, &magenta);
add_button_at("/", table, VOIDFN(binaryop_button_callback), 8, 9, 3, 4, &lightgreen);
add_button_at("x", table, VOIDFN(binaryop_button_callback), 9, 10, 3, 4, &lightgreen);
// add row 3 buttons
add_button_at("x!", table, VOIDFN(unaryop_button_callback), 1, 2, 4, 5, &magenta);
add_button_at("sqrt", table, VOIDFN(unaryop_button_callback), 2, 3, 4, 5, &magenta);
add_button_at("y^1/x", table, VOIDFN(binaryop_button_callback), 3, 4, 4, 5, &lightgreen);
add_button_at("log10", table, VOIDFN(unaryop_button_callback), 4, 5, 4, 5, &magenta);
add_button_at("7", table, VOIDFN(number_button_callback), 6, 7, 4, 5, &yellow);
add_button_at("8", table, VOIDFN(number_button_callback), 7, 8, 4, 5, &yellow);
add_button_at("9", table, VOIDFN(number_button_callback), 8, 9, 4, 5, &yellow);
add_button_at("-", table, VOIDFN(binaryop_button_callback), 9, 10, 4, 5, &lightgreen);
// add row 4 buttons
add_button_at("sin", table, VOIDFN(unaryop_button_callback), 1, 2, 5, 6, &magenta);
add_button_at("cos", table, VOIDFN(unaryop_button_callback), 2, 3, 5, 6, &magenta);
add_button_at("tan", table, VOIDFN(unaryop_button_callback), 3, 4, 5, 6, &magenta);
add_button_at("ln", table, VOIDFN(unaryop_button_callback), 4, 5, 5, 6, &magenta);
add_button_at("4", table, VOIDFN(number_button_callback), 6, 7, 5, 6, &yellow);
add_button_at("5", table, VOIDFN(number_button_callback), 7, 8, 5, 6, &yellow);
add_button_at("6", table, VOIDFN(number_button_callback), 8, 9, 5, 6, &yellow);
add_button_at("+", table, VOIDFN(binaryop_button_callback), 9, 10, 5, 6, &lightgreen);
// add row 5 buttons
add_button_at("sinh", table, VOIDFN(unaryop_button_callback), 1, 2, 6, 7, &magenta);
add_button_at("cosh", table, VOIDFN(unaryop_button_callback), 2, 3, 6, 7, &magenta);
add_button_at("tanh", table, VOIDFN(unaryop_button_callback), 3, 4, 6, 7, &magenta);
add_button_at("e^x", table, VOIDFN(unaryop_button_callback), 4, 5, 6, 7, &magenta);
add_button_at("1", table, VOIDFN(number_button_callback), 6, 7, 6, 7, &yellow);
add_button_at("2", table, VOIDFN(number_button_callback), 7, 8, 6, 7, &yellow);
add_button_at("3", table, VOIDFN(number_button_callback), 8, 9, 6, 7, &yellow);
add_button_at("=", table, VOIDFN(equal_button_callback), 9, 10, 6, 8, &lightblue);
// add row 6 buttons
add_button_at("asin", table, VOIDFN(unaryop_button_callback), 1, 2, 7, 8, &magenta);
add_button_at("acos", table, VOIDFN(unaryop_button_callback), 2, 3, 7, 8, &magenta);
add_button_at("atan", table, VOIDFN(unaryop_button_callback), 3, 4, 7, 8, &magenta);
add_button_at("log2", table, VOIDFN(unaryop_button_callback), 4, 5, 7, 8, &magenta);
add_button_at("0", table, VOIDFN(number_button_callback), 6, 8, 7, 8, &yellow);
add_button_at(".", table, VOIDFN(number_button_callback), 8, 9, 7, 8, &lightblue);
// add row 7 buttons
add_button_at("asinh", table, VOIDFN(unaryop_button_callback), 1, 2, 8, 9, &magenta);
add_button_at("acosh", table, VOIDFN(unaryop_button_callback), 2, 3, 8, 9, &magenta);
add_button_at("atanh", table, VOIDFN(unaryop_button_callback), 3, 4, 8, 9, &magenta);
add_button_at("2^x", table, VOIDFN(unaryop_button_callback), 4, 5, 8, 9, &magenta);
// add row 8 buttons
GSList *group = add_radio_button_at("rad", table, NULL, TRUE, VOIDFN(angle_button_callback), 1, 2, 9, 10, &violet);
add_radio_button_at("deg", table, group, FALSE, VOIDFN(angle_button_callback), 2, 3, 9, 10, &violet);
add_button_at("pi", table, VOIDFN(constant_button_callback), 3, 4, 9, 10, &violet);
add_button_at("EE", table, VOIDFN(button_callback), 4, 5, 9, 10, &violet);
#if 0
// add debug button
add_button_at("dbg", table, VOIDFN(debug_button_callback), 9, 10, 9, 10, &violet);
#else
// add menu item with choices to activate
GtkWidget *menubar = gtk_menu_bar_new();
GtkWidget *options = gtk_menu_item_new_with_label("options");
gtk_menu_bar_append(GTK_MENU_BAR(menubar), options);
GtkWidget *submenu= gtk_menu_new();
gtk_menu_item_set_submenu(GTK_MENU_ITEM(options), submenu);
GtkWidget *dbgitem = gtk_check_menu_item_new_with_label("dbg");
gtk_menu_append(GTK_MENU(submenu), dbgitem);
g_signal_connect(G_OBJECT(dbgitem), "activate",
G_CALLBACK(checked_callback), (gpointer)"dbg");
GtkWidget *edtitem = gtk_check_menu_item_new_with_label("edt");
gtk_menu_append(GTK_MENU(submenu), edtitem);
g_signal_connect(G_OBJECT(edtitem), "activate",
G_CALLBACK(checked_callback), (gpointer)"edt");
gtk_table_attach_defaults(GTK_TABLE(table), menubar, 8, 10, 9, 10);
#endif
// show main window and anything it contains
gtk_widget_show_all(window);
// start up main event loop
gtk_main();
// all done
return 0;
}
static GtkWidget *
get_config_frame(PurplePlugin *plugin)
{
GString
*base_dir_name= NULL,
*lang_dir_name= NULL;
GtkObject *stretch_duration_adjustment;
GtkObject *maxlength_adjustment;
GtkWidget
*parent,
*config_vbox, *voices_vbox, *stretch_duration_hbox, *maxlength_hbox,
*frame,
*radio_button,
*message_label,
*stretch_duration_spinbutton,
*maxlength_spinbutton,
*prepend_who_checkbutton,
*replace_url_checkbutton,
*announce_events_checkbutton;
GSList *radio_group=NULL;
DIR *dir, *lang_dir;
struct dirent *next_lang, *next_voice;
int count_lang, count_voices;
int can_activate_voice= FALSE;
parent = gtk_vbox_new(FALSE,5);
gtk_container_set_border_width(GTK_CONTAINER(parent), 12);
config_vbox = (GtkWidget *) pidgin_make_frame(parent, _("Festival"));
gtk_container_set_border_width(GTK_CONTAINER(config_vbox), 5);
/*--------------- Available Voices -----------*/
base_dir_name= g_string_new(FESTIVAL_VOICES_PATH);
lang_dir_name= g_string_new("");
message_label= gtk_label_new(_("Availables voices:"));
gtk_box_pack_start(GTK_BOX(config_vbox),message_label,FALSE,TRUE,3);
//Examine directory for voices
dir= opendir(base_dir_name->str);
if(!dir) {
GString *error_name;
error_name= g_string_new("");
g_string_printf(error_name, _("Error opening voices directory: %s"), base_dir_name->str);
message_label= gtk_label_new(error_name->str);
g_string_free(error_name,TRUE);
gtk_box_pack_start(GTK_BOX(config_vbox),message_label,FALSE,TRUE,3);
}
else {
count_lang=0;
while( ( next_lang = readdir(dir) ) !=0 ) {
/* hide hidden files */
if( *next_lang->d_name == '.' )
continue;
frame= gtk_frame_new(next_lang->d_name);
gtk_box_pack_start(GTK_BOX(config_vbox),frame,FALSE,TRUE,3);
voices_vbox= gtk_vbox_new(FALSE,5);
gtk_container_set_border_width(GTK_CONTAINER(voices_vbox), 5);
gtk_container_add(GTK_CONTAINER(frame),voices_vbox);
g_string_printf(lang_dir_name,"%s/%s",base_dir_name->str,next_lang->d_name);
lang_dir= opendir(lang_dir_name->str);
if(!lang_dir) {
GString *error_name;
error_name= g_string_new("");
g_string_printf( error_name, _("Error opening voice directory: %s"), lang_dir_name->str);
message_label= gtk_label_new(error_name->str);
g_string_free(error_name,TRUE);
gtk_box_pack_start( GTK_BOX(voices_vbox), message_label, FALSE, TRUE, 3);
break;
}
count_voices=0;
while( ( next_voice = readdir(lang_dir) )!=0 ) {
GString *voice_name;
/* hide hidden files */
if( *next_voice->d_name == '.' )
continue;
radio_button= gtk_radio_button_new_with_label(radio_group,next_voice->d_name);
if( purple_prefs_get_string("/plugins/gtk/festival/speaker/voice") &&
strcmp(purple_prefs_get_string("/plugins/gtk/festival/speaker/voice"),next_voice->d_name ) == 0) {
gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(radio_button),TRUE );
can_activate_voice= TRUE;
}
voice_name= g_string_new(next_voice->d_name);
g_signal_connect(GTK_OBJECT(radio_button),"clicked", G_CALLBACK(on_radio_clicked), voice_name);
g_signal_connect(GTK_OBJECT(radio_button),"destroy", G_CALLBACK(on_radio_destroy), voice_name);
gtk_box_pack_start(GTK_BOX(voices_vbox), radio_button, FALSE, TRUE, 3);
radio_group= gtk_radio_button_get_group( GTK_RADIO_BUTTON(radio_button) );
}
closedir(lang_dir);
}
closedir(dir);
}
g_string_free(base_dir_name,TRUE);
g_string_free(lang_dir_name,TRUE);
/*--------------- Replace URL -----------*/
replace_url_checkbutton = gtk_check_button_new_with_label( _("Replace \"http://www.someurl.com\" with URL"));
if(purple_prefs_get_bool("/plugins/gtk/festival/speaker/replace_url"))
gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(replace_url_checkbutton), TRUE);
g_signal_connect(G_OBJECT(replace_url_checkbutton), "clicked",
G_CALLBACK(on_replace_url_checkbutton_clicked), NULL);
gtk_box_pack_end(GTK_BOX(config_vbox),replace_url_checkbutton,FALSE,TRUE,3);
/*--------------- Prepend Alias -----------*/
prepend_who_checkbutton = gtk_check_button_new_with_label(_("Prepend Buddy Name (Alias) to message"));
if(purple_prefs_get_bool("/plugins/gtk/festival/speaker/prepend_who"))
gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(prepend_who_checkbutton), TRUE);
g_signal_connect(G_OBJECT(prepend_who_checkbutton), "clicked",
G_CALLBACK(on_prepend_who_checkbutton_clicked), NULL);
gtk_box_pack_end(GTK_BOX(config_vbox),prepend_who_checkbutton,FALSE,TRUE,3);
/*--------------- Announce Events -----------*/
announce_events_checkbutton = gtk_check_button_new_with_label(_("Announce events"));
if(purple_prefs_get_bool("/plugins/gtk/festival/speaker/announce_events"))
gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(announce_events_checkbutton), TRUE);
g_signal_connect(G_OBJECT(announce_events_checkbutton), "clicked",
G_CALLBACK(on_announce_events_checkbutton_clicked), NULL);
gtk_box_pack_end(GTK_BOX(config_vbox),announce_events_checkbutton,FALSE,TRUE,3);
/*--------------- Duration -----------*/
stretch_duration_hbox= gtk_hbox_new(FALSE,3);
stretch_duration_adjustment= gtk_adjustment_new(1.0,0.3,10.0,0.1,1.0,1.0);
stretch_duration_spinbutton= gtk_spin_button_new(GTK_ADJUSTMENT(stretch_duration_adjustment),0.1,1);
g_signal_connect(G_OBJECT(stretch_duration_spinbutton), "value_changed",
G_CALLBACK(on_stretch_duration_spinbutton_changed), NULL);
gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(stretch_duration_spinbutton),GTK_UPDATE_IF_VALID);
gtk_entry_set_editable(GTK_ENTRY(stretch_duration_spinbutton),FALSE);
gtk_box_pack_start(GTK_BOX(stretch_duration_hbox),gtk_label_new(_("Pitch")),FALSE,FALSE,3);
gtk_box_pack_start(GTK_BOX(stretch_duration_hbox),stretch_duration_spinbutton,FALSE,FALSE,3);
gtk_box_pack_end(GTK_BOX(config_vbox),stretch_duration_hbox,FALSE,TRUE,3);
gtk_spin_button_set_value( GTK_SPIN_BUTTON(stretch_duration_spinbutton),
atof (purple_prefs_get_string("/plugins/gtk/festival/speaker/duration")));
/*--------------- Max Length -----------*/
maxlength_hbox= gtk_hbox_new(FALSE,3);
maxlength_adjustment= gtk_adjustment_new(256,0,1000,1,256,256);
maxlength_spinbutton= gtk_spin_button_new(GTK_ADJUSTMENT(maxlength_adjustment),1,0);
g_signal_connect(G_OBJECT(maxlength_spinbutton), "value_changed",
G_CALLBACK(on_maxlength_spinbutton_changed), NULL);
gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(maxlength_spinbutton),GTK_UPDATE_IF_VALID);
gtk_entry_set_editable(GTK_ENTRY(maxlength_spinbutton),FALSE);
gtk_box_pack_start(GTK_BOX(maxlength_hbox),gtk_label_new(_("Max Length")),FALSE,FALSE,3);
gtk_box_pack_start(GTK_BOX(maxlength_hbox),maxlength_spinbutton,FALSE,FALSE,3);
gtk_box_pack_end(GTK_BOX(config_vbox),maxlength_hbox,FALSE,TRUE,3);
gtk_spin_button_set_value( GTK_SPIN_BUTTON(maxlength_spinbutton),
purple_prefs_get_int("/plugins/gtk/festival/speaker/maxlength"));
if(!can_activate_voice && radio_group) {
GtkRadioButton *default_radio;
default_radio= GTK_RADIO_BUTTON( g_slist_nth(radio_group,0)->data );
gtk_button_clicked( GTK_BUTTON(default_radio) );
}
gtk_widget_show_all(parent);
return parent;
}
void
fill_proto_field_info(proto_type type, unsigned int pid, unsigned int seq_id)
{
uint i = 0;
protocol val;
unsigned int size;
port_info_t *info = NULL;
pkt_seq_t *pkt = NULL;
info = &pktgen.info[pid];
pkt = &info->seq_pkt[seq_id];
char buff[50];
g_return_if_fail(packet_info != NULL);
if (pkt == NULL)/* Update with default values */
pkt = &info->seq_pkt[SINGLE_PKT];
if (type == TYPE_ETH) {
struct ether_addr *eaddr = &pkt->eth_dst_addr;
val.name = g_strdup(pktgen_ethernet_fields[i++]);
snprintf(buff, sizeof(buff), "%02x%02x%02x%02x%02x%02x",
eaddr->addr_bytes[0], eaddr->addr_bytes[1],
eaddr->addr_bytes[2], eaddr->addr_bytes[3],
eaddr->addr_bytes[4], eaddr->addr_bytes[5]);
val.value = g_strdup(buff);
g_array_append_vals(packet_info, &val, 1);
val.name = g_strdup(pktgen_ethernet_fields[i++]);
eaddr = &pkt->eth_src_addr;
snprintf(buff, sizeof(buff), "%02x%02x%02x%02x%02x%02x",
eaddr->addr_bytes[0], eaddr->addr_bytes[1],
eaddr->addr_bytes[2], eaddr->addr_bytes[3],
eaddr->addr_bytes[4], eaddr->addr_bytes[5]);
val.value = g_strdup(buff);
g_array_append_vals(packet_info, &val, 1);
val.name = g_strdup(pktgen_ethernet_fields[i++]);
val.value = g_strdup("IPv4");
g_array_append_vals(packet_info, &val, 1);
if (rte_atomic32_read(&info->port_flags) & SEND_VLAN_ID)
g_object_set(G_OBJECT(stream_l2_vlan), "active", TRUE,
NULL);
else
g_object_set(G_OBJECT(stream_l2_vlan), "active", FALSE,
NULL);
sprintf(buff, "%d", pkt->vlanid);
val.name = g_strdup(pktgen_ethernet_fields[i++]);
val.value = g_strdup(buff);
g_array_append_vals(packet_info, &val, 1);
size = (pkt->pktSize + FCS_SIZE);
sprintf(buff, "%d", size);
gtk_entry_set_text(GTK_ENTRY(pktsize_entry), buff);
sprintf(buff, "%x", pkt->ipProto);
gtk_entry_set_text(GTK_ENTRY(ip_proto_entry), buff);
gtk_entry_set_editable(GTK_ENTRY(ip_proto_entry), FALSE);
} else if (type == TYPE_IPv4) {
val.name = g_strdup(pktgen_ipv4_fields[i++]);
val.value = g_strdup("IPv4");
g_array_append_vals(packet_info, &val, 1);
val.name = g_strdup(pktgen_ipv4_fields[i++]);
val.value = g_strdup("<auto>");
g_array_append_vals(packet_info, &val, 1);
val.name = g_strdup(pktgen_ipv4_fields[i++]);
val.value = g_strdup("<auto>");
g_array_append_vals(packet_info, &val, 1);
val.name = g_strdup(pktgen_ipv4_fields[i++]);
val.value = g_strdup("<auto>");
g_array_append_vals(packet_info, &val, 1);
val.name = g_strdup(pktgen_ipv4_fields[i++]);
val.value = g_strdup("<auto>");
g_array_append_vals(packet_info, &val, 1);
val.name = g_strdup(pktgen_ipv4_fields[i++]);
val.value = g_strdup("<auto>");
g_array_append_vals(packet_info, &val, 1);
val.name = g_strdup(pktgen_ipv4_fields[i++]);
val.value = g_strdup("<auto>");
g_array_append_vals(packet_info, &val, 1);
val.name = g_strdup(pktgen_ipv4_fields[i++]);
val.value = g_strdup(
(pkt->ipProto ==
PG_IPPROTO_UDP) ? "UDP" : "User Defined");
g_array_append_vals(packet_info, &val, 1);
val.name = g_strdup(pktgen_ipv4_fields[i++]);
val.value = g_strdup("<auto>");
g_array_append_vals(packet_info, &val, 1);
val.name = g_strdup(pktgen_ipv4_fields[i++]);
val.value =
g_strdup(inet_ntop4(buff, sizeof(buff),
ntohl(pkt->ip_src_addr.addr.ipv4.
s_addr),
0xFFFFFFFF));
g_array_append_vals(packet_info, &val, 1);
val.name = g_strdup(pktgen_ipv4_fields[i++]);
val.value =
g_strdup(inet_ntop4(buff, sizeof(buff),
ntohl(pkt->ip_dst_addr.addr.ipv4.
s_addr),
0xFFFFFFFF));
g_array_append_vals(packet_info, &val, 1);
} else if (type == TYPE_UDP) {
sprintf(buff, "%d", pkt->sport);
val.name = g_strdup(pktgen_udp_fields[i++]);
val.value = g_strdup(buff);
g_array_append_vals(packet_info, &val, 1);
sprintf(buff, "%d", pkt->dport);
val.name = g_strdup(pktgen_udp_fields[i++]);
val.value = g_strdup(buff);
g_array_append_vals(packet_info, &val, 1);
val.name = g_strdup(pktgen_udp_fields[i++]);
val.value = g_strdup("<auto>");
g_array_append_vals(packet_info, &val, 1);
val.name = g_strdup(pktgen_udp_fields[i++]);
val.value = g_strdup("<auto>");
g_array_append_vals(packet_info, &val, 1);
}
}
GtkWidget*
create_rs232 (void)
{
GtkWidget *rs232;
GtkWidget *eventbox1;
GtkWidget *vbox1;
GtkWidget *hbox5;
GtkWidget *exit;
GtkWidget *swap;
GtkWidget *clean_data_area;
GtkWidget *label7;
GtkWidget *label8;
GtkWidget *hseparator5;
GtkWidget *hbox3;
GtkWidget *vbox2;
GtkWidget *hbox18;
GtkWidget *label1;
GtkWidget *combo1;
GList *combo1_items = NULL;
GtkWidget *combo_entry_baudrate;
GtkWidget *hbox24;
GtkWidget *label2;
GtkWidget *entry5;
GtkWidget *label20;
GtkWidget *hbox19;
GtkWidget *label3;
GtkWidget *hbox25;
GtkWidget *combo3;
GList *combo3_items = NULL;
GtkWidget *combo_entry_port;
GtkWidget *hbox26;
GtkWidget *label4;
GtkWidget *entry2;
GtkWidget *label21;
GtkWidget *hbox27;
GtkWidget *togglebutton1;
GtkWidget *save_as_numeral;
GtkWidget *entry1;
GtkWidget *scrolledwindow1;
GtkWidget *text1;
GtkWidget *scrolledwindow2;
GtkWidget *text2;
GtkWidget *hseparator4;
GtkWidget *hbox4;
GtkWidget *label22;
GSList *_4_group = NULL;
GtkWidget *radiobutton1;
guint radiobutton2_key;
GtkWidget *radiobutton2;
GtkWidget *hseparator6;
GtkWidget *hbox29;
GtkWidget *spectrum;
GtkWidget *inspect;
GtkWidget *hbox30;
GtkWidget *big_spectrum;
GtkWidget *optionmenu1;
GtkWidget *optionmenu1_menu;
GtkWidget *glade_menuitem;
GtkWidget *print_spectrum;
GtkWidget *label19;
GtkWidget *printer_name;
GtkWidget *hbox17;
GtkWidget *label18;
GtkWidget *point;
GtkWidget *save_as_eps;
GtkWidget *entry4;
GtkWidget *hseparator1;
GtkWidget *hbox9;
GtkWidget *label9;
GSList *_1_group = NULL;
GtkWidget *specification_on;
GtkWidget *coefficient_on;
GtkWidget *hseparator3;
GtkWidget *hbox6;
GtkWidget *label11;
GSList *_2_group = NULL;
GtkWidget *move_average;
GtkWidget *window;
GtkWidget *butterworth;
GtkWidget *chebyshev;
GtkWidget *hbox8;
GtkWidget *fs_label;
GtkWidget *fs;
GtkWidget *pass_edge_label;
GtkWidget *pass_edge;
GtkWidget *stop_edge_label;
GtkWidget *stop_edge;
GtkWidget *pass_ripple_label;
GtkWidget *pass_ripple;
GtkWidget *stop_ripple_label;
GtkWidget *stop_ripple;
GtkWidget *hseparator2;
GtkWidget *hbox10;
GtkWidget *label12;
GSList *_3_group = NULL;
GtkWidget *fir_input_coefficient;
GtkWidget *iir_input_coefficient;
GtkWidget *identify_stability;
GtkWidget *hbox14;
GtkWidget *label16;
GtkWidget *a_value;
GtkWidget *label17;
GtkWidget *b_value;
GtkWidget *appbar1;
GtkWidget *hbox28;
GtkWidget *statusbar1;
GtkWidget *progressbar1;
GtkAccelGroup *accel_group;
GtkTooltips *tooltips;
tooltips = gtk_tooltips_new ();
accel_group = gtk_accel_group_new ();
rs232 = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_object_set_data (GTK_OBJECT (rs232), "rs232", rs232);
gtk_window_set_title (GTK_WINDOW (rs232), _("\246\263\255\255\257\337\275\304\305T\300\263 FIR \244\316\265L\255\255\257\337\275\304\305T\300\263 IIR \252\272\300W\303\320\244\300\252R\300\263\245\316"));
gtk_window_set_policy (GTK_WINDOW (rs232), FALSE, FALSE, TRUE);
eventbox1 = gtk_event_box_new ();
gtk_widget_ref (eventbox1);
gtk_object_set_data_full (GTK_OBJECT (rs232), "eventbox1", eventbox1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (eventbox1);
gtk_container_add (GTK_CONTAINER (rs232), eventbox1);
vbox1 = gtk_vbox_new (FALSE, 0);
gtk_widget_ref (vbox1);
gtk_object_set_data_full (GTK_OBJECT (rs232), "vbox1", vbox1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (vbox1);
gtk_container_add (GTK_CONTAINER (eventbox1), vbox1);
hbox5 = gtk_hbox_new (FALSE, 0);
gtk_widget_ref (hbox5);
gtk_object_set_data_full (GTK_OBJECT (rs232), "hbox5", hbox5,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox5);
gtk_box_pack_start (GTK_BOX (vbox1), hbox5, TRUE, TRUE, 10);
exit = gtk_button_new_with_label (_("\302\367\266}"));
gtk_widget_ref (exit);
gtk_object_set_data_full (GTK_OBJECT (rs232), "exit", exit,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (exit);
gtk_box_pack_start (GTK_BOX (hbox5), exit, FALSE, FALSE, 10);
gtk_widget_set_usize (exit, 100, -2);
swap = gtk_button_new_with_label (_("\261\265\246\254"));
gtk_widget_ref (swap);
gtk_object_set_data_full (GTK_OBJECT (rs232), "swap", swap,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (swap);
gtk_box_pack_start (GTK_BOX (hbox5), swap, FALSE, FALSE, 10);
gtk_widget_set_usize (swap, 100, -2);
gtk_tooltips_set_tip (tooltips, swap, _("\245i\261\265\246\254\245\321\246\352\246C\260\360\251\322\260e\250\323\252\272\270\352\256\306"), NULL);
clean_data_area = gtk_button_new_with_label (_("\262M\260\243\270\352\256\306\261\265\246\254\260\317"));
gtk_widget_ref (clean_data_area);
gtk_object_set_data_full (GTK_OBJECT (rs232), "clean_data_area", clean_data_area,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (clean_data_area);
gtk_box_pack_start (GTK_BOX (hbox5), clean_data_area, FALSE, FALSE, 10);
label7 = gtk_label_new (_("\255\354\251l\270\352\256\306"));
gtk_widget_ref (label7);
gtk_object_set_data_full (GTK_OBJECT (rs232), "label7", label7,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label7);
gtk_box_pack_start (GTK_BOX (hbox5), label7, FALSE, FALSE, 89);
label8 = gtk_label_new (_("\274\306\255\310\270\352\256\306"));
gtk_widget_ref (label8);
gtk_object_set_data_full (GTK_OBJECT (rs232), "label8", label8,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label8);
gtk_box_pack_start (GTK_BOX (hbox5), label8, FALSE, FALSE, 52);
hseparator5 = gtk_hseparator_new ();
gtk_widget_ref (hseparator5);
gtk_object_set_data_full (GTK_OBJECT (rs232), "hseparator5", hseparator5,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hseparator5);
gtk_box_pack_start (GTK_BOX (vbox1), hseparator5, TRUE, TRUE, 5);
hbox3 = gtk_hbox_new (FALSE, 0);
gtk_widget_ref (hbox3);
gtk_object_set_data_full (GTK_OBJECT (rs232), "hbox3", hbox3,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox3);
gtk_box_pack_start (GTK_BOX (vbox1), hbox3, TRUE, TRUE, 5);
vbox2 = gtk_vbox_new (FALSE, 0);
gtk_widget_ref (vbox2);
gtk_object_set_data_full (GTK_OBJECT (rs232), "vbox2", vbox2,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (vbox2);
gtk_box_pack_start (GTK_BOX (hbox3), vbox2, TRUE, TRUE, 0);
hbox18 = gtk_hbox_new (FALSE, 0);
gtk_widget_ref (hbox18);
gtk_object_set_data_full (GTK_OBJECT (rs232), "hbox18", hbox18,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox18);
gtk_box_pack_start (GTK_BOX (vbox2), hbox18, TRUE, TRUE, 5);
label1 = gtk_label_new (_("\266\307\277\351\300j\262v"));
gtk_widget_ref (label1);
gtk_object_set_data_full (GTK_OBJECT (rs232), "label1", label1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label1);
gtk_box_pack_start (GTK_BOX (hbox18), label1, FALSE, FALSE, 10);
combo1 = gtk_combo_new ();
gtk_widget_ref (combo1);
gtk_object_set_data_full (GTK_OBJECT (rs232), "combo1", combo1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (combo1);
gtk_box_pack_start (GTK_BOX (hbox18), combo1, TRUE, TRUE, 10);
gtk_widget_set_usize (combo1, 1, -2);
combo1_items = g_list_append (combo1_items, (gpointer) _("2400"));
combo1_items = g_list_append (combo1_items, (gpointer) _("4800"));
combo1_items = g_list_append (combo1_items, (gpointer) _("9600"));
combo1_items = g_list_append (combo1_items, (gpointer) _("19200"));
combo1_items = g_list_append (combo1_items, (gpointer) _("38400"));
combo1_items = g_list_append (combo1_items, (gpointer) _("57600"));
combo1_items = g_list_append (combo1_items, (gpointer) _("115200"));
gtk_combo_set_popdown_strings (GTK_COMBO (combo1), combo1_items);
g_list_free (combo1_items);
combo_entry_baudrate = GTK_COMBO (combo1)->entry;
gtk_widget_ref (combo_entry_baudrate);
gtk_object_set_data_full (GTK_OBJECT (rs232), "combo_entry_baudrate", combo_entry_baudrate,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (combo_entry_baudrate);
gtk_entry_set_editable (GTK_ENTRY (combo_entry_baudrate), FALSE);
gtk_entry_set_text (GTK_ENTRY (combo_entry_baudrate), _("4800"));
hbox24 = gtk_hbox_new (FALSE, 0);
gtk_widget_ref (hbox24);
gtk_object_set_data_full (GTK_OBJECT (rs232), "hbox24", hbox24,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox24);
gtk_box_pack_start (GTK_BOX (hbox18), hbox24, TRUE, TRUE, 0);
label2 = gtk_label_new (_("\270\352\256\306\252\370\253\327"));
gtk_widget_ref (label2);
gtk_object_set_data_full (GTK_OBJECT (rs232), "label2", label2,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label2);
gtk_box_pack_start (GTK_BOX (hbox24), label2, FALSE, FALSE, 15);
entry5 = gtk_entry_new ();
gtk_widget_ref (entry5);
gtk_object_set_data_full (GTK_OBJECT (rs232), "entry5", entry5,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (entry5);
gtk_box_pack_start (GTK_BOX (hbox24), entry5, TRUE, TRUE, 10);
gtk_widget_set_usize (entry5, 1, -2);
gtk_tooltips_set_tip (tooltips, entry5, _("\263\346\246\354\254O\246\354\244\270\262\325"), NULL);
gtk_entry_set_text (GTK_ENTRY (entry5), _("16"));
label20 = gtk_label_new (_("\246\354\244\270\262\325\274\306"));
gtk_widget_ref (label20);
gtk_object_set_data_full (GTK_OBJECT (rs232), "label20", label20,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label20);
gtk_box_pack_start (GTK_BOX (hbox24), label20, FALSE, FALSE, 10);
hbox19 = gtk_hbox_new (FALSE, 0);
gtk_widget_ref (hbox19);
gtk_object_set_data_full (GTK_OBJECT (rs232), "hbox19", hbox19,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox19);
gtk_box_pack_start (GTK_BOX (vbox2), hbox19, TRUE, TRUE, 5);
label3 = gtk_label_new (_("\266\307\277\351\247\307\246C"));
gtk_widget_ref (label3);
gtk_object_set_data_full (GTK_OBJECT (rs232), "label3", label3,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label3);
gtk_box_pack_start (GTK_BOX (hbox19), label3, FALSE, FALSE, 10);
hbox25 = gtk_hbox_new (FALSE, 0);
gtk_widget_ref (hbox25);
gtk_object_set_data_full (GTK_OBJECT (rs232), "hbox25", hbox25,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox25);
gtk_box_pack_start (GTK_BOX (hbox19), hbox25, TRUE, TRUE, 0);
combo3 = gtk_combo_new ();
gtk_widget_ref (combo3);
gtk_object_set_data_full (GTK_OBJECT (rs232), "combo3", combo3,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (combo3);
gtk_box_pack_start (GTK_BOX (hbox25), combo3, TRUE, TRUE, 10);
gtk_widget_set_usize (combo3, 1, -2);
combo3_items = g_list_append (combo3_items, (gpointer) _("1"));
combo3_items = g_list_append (combo3_items, (gpointer) _("2"));
gtk_combo_set_popdown_strings (GTK_COMBO (combo3), combo3_items);
g_list_free (combo3_items);
combo_entry_port = GTK_COMBO (combo3)->entry;
gtk_widget_ref (combo_entry_port);
gtk_object_set_data_full (GTK_OBJECT (rs232), "combo_entry_port", combo_entry_port,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (combo_entry_port);
gtk_entry_set_editable (GTK_ENTRY (combo_entry_port), FALSE);
gtk_entry_set_text (GTK_ENTRY (combo_entry_port), _("1"));
hbox26 = gtk_hbox_new (FALSE, 0);
gtk_widget_ref (hbox26);
gtk_object_set_data_full (GTK_OBJECT (rs232), "hbox26", hbox26,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox26);
gtk_box_pack_start (GTK_BOX (hbox25), hbox26, TRUE, TRUE, 0);
label4 = gtk_label_new (_("\270\352\256\306\301`\274\306"));
gtk_widget_ref (label4);
gtk_object_set_data_full (GTK_OBJECT (rs232), "label4", label4,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label4);
gtk_box_pack_start (GTK_BOX (hbox26), label4, FALSE, FALSE, 15);
entry2 = gtk_entry_new ();
gtk_widget_ref (entry2);
gtk_object_set_data_full (GTK_OBJECT (rs232), "entry2", entry2,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (entry2);
gtk_box_pack_start (GTK_BOX (hbox26), entry2, TRUE, TRUE, 10);
gtk_widget_set_usize (entry2, 1, -2);
gtk_entry_set_text (GTK_ENTRY (entry2), _("5"));
label21 = gtk_label_new (_("\265\247\270\352\256\306\274\306"));
gtk_widget_ref (label21);
gtk_object_set_data_full (GTK_OBJECT (rs232), "label21", label21,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label21);
gtk_box_pack_start (GTK_BOX (hbox26), label21, FALSE, FALSE, 10);
hbox27 = gtk_hbox_new (FALSE, 0);
gtk_widget_ref (hbox27);
gtk_object_set_data_full (GTK_OBJECT (rs232), "hbox27", hbox27,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox27);
gtk_box_pack_start (GTK_BOX (vbox2), hbox27, FALSE, FALSE, 5);
togglebutton1 = gtk_toggle_button_new_with_label (_("\261j\250\356\274g\244J\300\311\256\327"));
gtk_widget_ref (togglebutton1);
gtk_object_set_data_full (GTK_OBJECT (rs232), "togglebutton1", togglebutton1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (togglebutton1);
gtk_box_pack_start (GTK_BOX (hbox27), togglebutton1, FALSE, FALSE, 10);
gtk_tooltips_set_tip (tooltips, togglebutton1, _("\244\243\272\336\253\374\251w\252\272\300\311\256\327\270\364\256|\244\247\300\311\246W\246s\246b\273P\247_\241A\244@\253\337\261j\250\356\274g\244J"), NULL);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (togglebutton1), TRUE);
save_as_numeral = gtk_button_new_with_label (_("\300\311\256\327\270\364\256|"));
gtk_widget_ref (save_as_numeral);
gtk_object_set_data_full (GTK_OBJECT (rs232), "save_as_numeral", save_as_numeral,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (save_as_numeral);
gtk_box_pack_start (GTK_BOX (hbox27), save_as_numeral, FALSE, FALSE, 0);
entry1 = gtk_entry_new ();
gtk_widget_ref (entry1);
gtk_object_set_data_full (GTK_OBJECT (rs232), "entry1", entry1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (entry1);
gtk_box_pack_start (GTK_BOX (hbox27), entry1, TRUE, TRUE, 10);
gtk_widget_set_usize (entry1, 1, -2);
gtk_entry_set_text (GTK_ENTRY (entry1), _("/home/allways/numeral.txt"));
scrolledwindow1 = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_ref (scrolledwindow1);
gtk_object_set_data_full (GTK_OBJECT (rs232), "scrolledwindow1", scrolledwindow1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (scrolledwindow1);
gtk_box_pack_start (GTK_BOX (hbox3), scrolledwindow1, TRUE, TRUE, 5);
gtk_widget_set_usize (scrolledwindow1, 1, -2);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow1), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
text1 = gtk_text_new (NULL, NULL);
gtk_widget_ref (text1);
gtk_object_set_data_full (GTK_OBJECT (rs232), "text1", text1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (text1);
gtk_container_add (GTK_CONTAINER (scrolledwindow1), text1);
gtk_tooltips_set_tip (tooltips, text1, _("\261q\246\352\246C\260\360\266\307\250\323\252\272\247\271\276\343\270\352\256\306"), NULL);
scrolledwindow2 = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_ref (scrolledwindow2);
gtk_object_set_data_full (GTK_OBJECT (rs232), "scrolledwindow2", scrolledwindow2,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (scrolledwindow2);
gtk_box_pack_start (GTK_BOX (hbox3), scrolledwindow2, TRUE, TRUE, 5);
gtk_widget_set_usize (scrolledwindow2, 1, -2);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow2), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
text2 = gtk_text_new (NULL, NULL);
gtk_widget_ref (text2);
gtk_object_set_data_full (GTK_OBJECT (rs232), "text2", text2,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (text2);
gtk_container_add (GTK_CONTAINER (scrolledwindow2), text2);
gtk_tooltips_set_tip (tooltips, text2, _("\261q\247\271\276\343\270\352\256\306\251\322\261o\250\354\252\272\257\302\274\306\255\310\270\352\256\306"), NULL);
hseparator4 = gtk_hseparator_new ();
gtk_widget_ref (hseparator4);
gtk_object_set_data_full (GTK_OBJECT (rs232), "hseparator4", hseparator4,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hseparator4);
gtk_box_pack_start (GTK_BOX (vbox1), hseparator4, TRUE, TRUE, 5);
hbox4 = gtk_hbox_new (FALSE, 0);
gtk_widget_ref (hbox4);
gtk_object_set_data_full (GTK_OBJECT (rs232), "hbox4", hbox4,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox4);
gtk_box_pack_start (GTK_BOX (vbox1), hbox4, TRUE, TRUE, 5);
label22 = gtk_label_new (_("\250\317\245\316\245\273\263n\305\351\244\247\302o\252i\276\271"));
gtk_widget_ref (label22);
gtk_object_set_data_full (GTK_OBJECT (rs232), "label22", label22,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label22);
gtk_box_pack_start (GTK_BOX (hbox4), label22, FALSE, FALSE, 10);
radiobutton1 = gtk_radio_button_new_with_label (_4_group, _("\254O"));
_4_group = gtk_radio_button_group (GTK_RADIO_BUTTON (radiobutton1));
gtk_widget_ref (radiobutton1);
gtk_object_set_data_full (GTK_OBJECT (rs232), "radiobutton1", radiobutton1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (radiobutton1);
gtk_box_pack_start (GTK_BOX (hbox4), radiobutton1, FALSE, FALSE, 0);
radiobutton2 = gtk_radio_button_new_with_label (_4_group, "");
radiobutton2_key = gtk_label_parse_uline (GTK_LABEL (GTK_BIN (radiobutton2)->child),
_("\247_"));
gtk_widget_add_accelerator (radiobutton2, "clicked", accel_group,
radiobutton2_key, GDK_MOD1_MASK, (GtkAccelFlags) 0);
_4_group = gtk_radio_button_group (GTK_RADIO_BUTTON (radiobutton2));
gtk_widget_ref (radiobutton2);
gtk_object_set_data_full (GTK_OBJECT (rs232), "radiobutton2", radiobutton2,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (radiobutton2);
gtk_box_pack_start (GTK_BOX (hbox4), radiobutton2, FALSE, FALSE, 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radiobutton2), TRUE);
hseparator6 = gtk_hseparator_new ();
gtk_widget_ref (hseparator6);
gtk_object_set_data_full (GTK_OBJECT (rs232), "hseparator6", hseparator6,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hseparator6);
gtk_box_pack_start (GTK_BOX (vbox1), hseparator6, TRUE, TRUE, 5);
hbox29 = gtk_hbox_new (FALSE, 0);
gtk_widget_ref (hbox29);
gtk_object_set_data_full (GTK_OBJECT (rs232), "hbox29", hbox29,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox29);
gtk_box_pack_start (GTK_BOX (vbox1), hbox29, TRUE, TRUE, 5);
spectrum = gtk_button_new_with_label (_("\266}\251l\303\270\273s\302o\252i\276\271\300W\303\320\271\317"));
gtk_widget_ref (spectrum);
gtk_object_set_data_full (GTK_OBJECT (rs232), "spectrum", spectrum,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (spectrum);
gtk_box_pack_start (GTK_BOX (hbox29), spectrum, FALSE, FALSE, 10);
gtk_tooltips_set_tip (tooltips, spectrum, _("\267\355\246U\260\321\274\306\244\316\263]\251w\246n\244F\244\247\253\341\241A\264N\245i\245H\253\366\246\271\266s\250\323\303\270\273s\271\317\247\316\244F"), NULL);
inspect = gtk_button_new_with_label (_("\300\313\265\370\271\317\300\311"));
gtk_widget_ref (inspect);
gtk_object_set_data_full (GTK_OBJECT (rs232), "inspect", inspect,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (inspect);
gtk_box_pack_start (GTK_BOX (hbox29), inspect, FALSE, FALSE, 0);
gtk_tooltips_set_tip (tooltips, inspect, _("\245i\244\243\254O A \271\317\263\341\241I\254O\300W\303\320\271\317\260\325\241I"), NULL);
hbox30 = gtk_hbox_new (FALSE, 0);
gtk_widget_ref (hbox30);
gtk_object_set_data_full (GTK_OBJECT (rs232), "hbox30", hbox30,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox30);
gtk_box_pack_start (GTK_BOX (vbox1), hbox30, TRUE, TRUE, 5);
big_spectrum = gtk_toggle_button_new_with_label (_("\244j\261i\252\272\300W\303\320\271\317"));
gtk_widget_ref (big_spectrum);
gtk_object_set_data_full (GTK_OBJECT (rs232), "big_spectrum", big_spectrum,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (big_spectrum);
gtk_box_pack_start (GTK_BOX (hbox30), big_spectrum, FALSE, FALSE, 10);
optionmenu1 = gtk_option_menu_new ();
gtk_widget_ref (optionmenu1);
gtk_object_set_data_full (GTK_OBJECT (rs232), "optionmenu1", optionmenu1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (optionmenu1);
gtk_box_pack_start (GTK_BOX (hbox30), optionmenu1, FALSE, FALSE, 10);
optionmenu1_menu = gtk_menu_new ();
glade_menuitem = gtk_menu_item_new_with_label (_(" \300W\303\320\271\317\252\355\245\334\244\350\252k"));
gtk_widget_show (glade_menuitem);
gtk_menu_append (GTK_MENU (optionmenu1_menu), glade_menuitem);
glade_menuitem = gtk_menu_item_new_with_label (_("X \266b\241G\274\306\246\354\300W\262v Y\241G\275u\251\312\274W\257q"));
gtk_widget_show (glade_menuitem);
gtk_menu_append (GTK_MENU (optionmenu1_menu), glade_menuitem);
glade_menuitem = gtk_menu_item_new_with_label (_("X \266b\241G\274\306\246\354\300W\262v Y\241G\244\300\250\251\274W\257q"));
gtk_widget_show (glade_menuitem);
gtk_menu_append (GTK_MENU (optionmenu1_menu), glade_menuitem);
glade_menuitem = gtk_menu_item_new_with_label (_("X \266b\241G\303\376\244\361\300W\262v Y\241G\275u\251\312\274W\257q"));
gtk_widget_show (glade_menuitem);
gtk_menu_append (GTK_MENU (optionmenu1_menu), glade_menuitem);
glade_menuitem = gtk_menu_item_new_with_label (_("X \266b\241G\303\376\244\361\300W\262v Y\241G\244\300\250\251\274W\257q"));
gtk_widget_show (glade_menuitem);
gtk_menu_append (GTK_MENU (optionmenu1_menu), glade_menuitem);
gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu1), optionmenu1_menu);
print_spectrum = gtk_toggle_button_new_with_label (_("\300W\303\320\271\317\245\316\246L\252\355\276\367\246L\245X"));
gtk_widget_ref (print_spectrum);
gtk_object_set_data_full (GTK_OBJECT (rs232), "print_spectrum", print_spectrum,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (print_spectrum);
gtk_box_pack_start (GTK_BOX (hbox30), print_spectrum, FALSE, FALSE, 0);
gtk_tooltips_set_tip (tooltips, print_spectrum, _("\300W\303\320\271\317\273\335\255n\245\316\246L\252\355\276\367\303\270\273s\245X\250\323\252\272\256\311\255\324\241A\250\317\244\247\244U\250H\241A\260O\261o\246L\252\355\276\367\252\272\246W\272\331\255n\245[\263\341\241I"), NULL);
label19 = gtk_label_new (_("\246L\252\355\276\367\252\272\271q\270\243\246W\272\331"));
gtk_widget_ref (label19);
gtk_object_set_data_full (GTK_OBJECT (rs232), "label19", label19,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label19);
gtk_box_pack_start (GTK_BOX (hbox30), label19, FALSE, FALSE, 10);
printer_name = gtk_entry_new ();
gtk_widget_ref (printer_name);
gtk_object_set_data_full (GTK_OBJECT (rs232), "printer_name", printer_name,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (printer_name);
gtk_box_pack_start (GTK_BOX (hbox30), printer_name, TRUE, TRUE, 10);
gtk_widget_set_usize (printer_name, 1, -2);
gtk_tooltips_set_tip (tooltips, printer_name, _("\264N\254O\246b\272\364\270\364\244W\246L\252\355\276\367\252\272\246W\246r\241A\245i\244\243\254O\245L\252\272\241\247\262\243\253~\246W\246r\241\250\263\341"), NULL);
gtk_entry_set_text (GTK_ENTRY (printer_name), _("hp"));
hbox17 = gtk_hbox_new (FALSE, 0);
gtk_widget_ref (hbox17);
gtk_object_set_data_full (GTK_OBJECT (rs232), "hbox17", hbox17,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox17);
gtk_box_pack_start (GTK_BOX (vbox1), hbox17, TRUE, TRUE, 5);
label18 = gtk_label_new (_("\300W\303\320\271\317\245\255\267\306\253\327( X \266b )"));
gtk_widget_ref (label18);
gtk_object_set_data_full (GTK_OBJECT (rs232), "label18", label18,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label18);
gtk_box_pack_start (GTK_BOX (hbox17), label18, FALSE, FALSE, 10);
point = gtk_entry_new ();
gtk_widget_ref (point);
gtk_object_set_data_full (GTK_OBJECT (rs232), "point", point,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (point);
gtk_box_pack_start (GTK_BOX (hbox17), point, TRUE, TRUE, 0);
gtk_widget_set_usize (point, 1, -2);
gtk_tooltips_set_tip (tooltips, point, _("\264N\254O\247A\247\306\261\346 X \266b\257\340\260\367\244\300\246\250\264X\255\323\265\245\244\300\251O\241H"), NULL);
gtk_entry_set_text (GTK_ENTRY (point), _("200"));
save_as_eps = gtk_button_new_with_label (_("eps\241Bps\241Bpdf \300\311\300x\246s\270\364\256|\241A\275\320\245[\244W\260\306\300\311\246W"));
gtk_widget_ref (save_as_eps);
gtk_object_set_data_full (GTK_OBJECT (rs232), "save_as_eps", save_as_eps,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (save_as_eps);
gtk_box_pack_start (GTK_BOX (hbox17), save_as_eps, FALSE, FALSE, 10);
entry4 = gtk_entry_new ();
gtk_widget_ref (entry4);
gtk_object_set_data_full (GTK_OBJECT (rs232), "entry4", entry4,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (entry4);
gtk_box_pack_start (GTK_BOX (hbox17), entry4, TRUE, TRUE, 10);
gtk_widget_set_usize (entry4, 1, -2);
gtk_tooltips_set_tip (tooltips, entry4, _("\275\320\260O\261o\244@\251w\261o\247\342\271\317\300\311\252\272\260\306\300\311\246W\246\333\246\346\245[\244J\241C\246p eps ps pdf"), NULL);
gtk_entry_set_text (GTK_ENTRY (entry4), _("/home/allways/spectrum.eps"));
hseparator1 = gtk_hseparator_new ();
gtk_widget_ref (hseparator1);
gtk_object_set_data_full (GTK_OBJECT (rs232), "hseparator1", hseparator1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hseparator1);
gtk_box_pack_start (GTK_BOX (vbox1), hseparator1, TRUE, TRUE, 5);
hbox9 = gtk_hbox_new (FALSE, 0);
gtk_widget_ref (hbox9);
gtk_object_set_data_full (GTK_OBJECT (rs232), "hbox9", hbox9,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox9);
gtk_box_pack_start (GTK_BOX (vbox1), hbox9, TRUE, TRUE, 5);
label9 = gtk_label_new (_("\302o\252i\276\271\252\272\300W\303\320\271\317\262\243\245\315\244\350\246\241\241G"));
gtk_widget_ref (label9);
gtk_object_set_data_full (GTK_OBJECT (rs232), "label9", label9,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label9);
gtk_box_pack_start (GTK_BOX (hbox9), label9, FALSE, FALSE, 5);
specification_on = gtk_radio_button_new_with_label (_1_group, _("\302o\252i\276\271\251\372\262\323\263W\256\346"));
_1_group = gtk_radio_button_group (GTK_RADIO_BUTTON (specification_on));
gtk_widget_ref (specification_on);
gtk_object_set_data_full (GTK_OBJECT (rs232), "specification_on", specification_on,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (specification_on);
gtk_box_pack_start (GTK_BOX (hbox9), specification_on, FALSE, FALSE, 5);
gtk_tooltips_set_tip (tooltips, specification_on, _("\247A\245i\245H\246\333\246\346\245\321\302o\252i\276\271\252\272\246U\255\323\260\321\274\306\244@\244@\277\351\244J\247A\255n\252\272\300W\261a\275d\263\362"), NULL);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (specification_on), TRUE);
coefficient_on = gtk_radio_button_new_with_label (_1_group, _("\260\262\263]\244\247\253Y\274\306\261a\244J\302\340\262\276\250\347\246\241"));
_1_group = gtk_radio_button_group (GTK_RADIO_BUTTON (coefficient_on));
gtk_widget_ref (coefficient_on);
gtk_object_set_data_full (GTK_OBJECT (rs232), "coefficient_on", coefficient_on,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (coefficient_on);
gtk_box_pack_start (GTK_BOX (hbox9), coefficient_on, FALSE, FALSE, 5);
gtk_tooltips_set_tip (tooltips, coefficient_on, _("\247A\245i\245H\245\321\265\352\300\300\244@\255\323\302\340\262\276\250\347\274\306\252\272\253Y\274\306\250\323\261o\250\354\247A\255n\252\272\300W\303\320\271\317\241A\265\245\250\354\271\272\245X\250\323\252\272\256\311\255\324\241A\246A\245h\255\327\245\277\247A\252\272\253Y\274\306\241A\244]\254O\244@\272\330\244\350\252k"), NULL);
hseparator3 = gtk_hseparator_new ();
gtk_widget_ref (hseparator3);
gtk_object_set_data_full (GTK_OBJECT (rs232), "hseparator3", hseparator3,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hseparator3);
gtk_box_pack_start (GTK_BOX (vbox1), hseparator3, TRUE, TRUE, 5);
hbox6 = gtk_hbox_new (FALSE, 0);
gtk_widget_ref (hbox6);
gtk_object_set_data_full (GTK_OBJECT (rs232), "hbox6", hbox6,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox6);
gtk_box_pack_start (GTK_BOX (vbox1), hbox6, TRUE, TRUE, 5);
label11 = gtk_label_new (_("\302o\252i\276\271\251\372\262\323\263W\256\346\241G"));
gtk_widget_ref (label11);
gtk_object_set_data_full (GTK_OBJECT (rs232), "label11", label11,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label11);
gtk_box_pack_start (GTK_BOX (hbox6), label11, FALSE, FALSE, 5);
move_average = gtk_radio_button_new_with_label (_2_group, _("FIR\241G\262\276\260\312\245\255\247\241\302o\252i\276\271"));
_2_group = gtk_radio_button_group (GTK_RADIO_BUTTON (move_average));
gtk_widget_ref (move_average);
gtk_object_set_data_full (GTK_OBJECT (rs232), "move_average", move_average,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (move_average);
gtk_box_pack_start (GTK_BOX (hbox6), move_average, FALSE, FALSE, 0);
window = gtk_radio_button_new_with_label (_2_group, _("FIR\241G\265\370\265\241\302o\252i\276\271"));
_2_group = gtk_radio_button_group (GTK_RADIO_BUTTON (window));
gtk_widget_ref (window);
gtk_object_set_data_full (GTK_OBJECT (rs232), "window", window,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (window);
gtk_box_pack_start (GTK_BOX (hbox6), window, FALSE, FALSE, 0);
butterworth = gtk_radio_button_new_with_label (_2_group, _("IIR\241G\245\244\252o\255\310\261o\302o\252i\276\271"));
_2_group = gtk_radio_button_group (GTK_RADIO_BUTTON (butterworth));
gtk_widget_ref (butterworth);
gtk_object_set_data_full (GTK_OBJECT (rs232), "butterworth", butterworth,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (butterworth);
gtk_box_pack_start (GTK_BOX (hbox6), butterworth, FALSE, FALSE, 0);
gtk_tooltips_set_tip (tooltips, butterworth, _("\250\344\271\352\264N\254O\244\332\257S\250U\264\376\260\325\241I"), NULL);
chebyshev = gtk_radio_button_new_with_label (_2_group, _("IIR\241G\253\264\244\361\263\267\244\322\302o\252i\276\271"));
_2_group = gtk_radio_button_group (GTK_RADIO_BUTTON (chebyshev));
gtk_widget_ref (chebyshev);
gtk_object_set_data_full (GTK_OBJECT (rs232), "chebyshev", chebyshev,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (chebyshev);
gtk_box_pack_start (GTK_BOX (hbox6), chebyshev, FALSE, FALSE, 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (chebyshev), TRUE);
hbox8 = gtk_hbox_new (FALSE, 0);
gtk_widget_ref (hbox8);
gtk_object_set_data_full (GTK_OBJECT (rs232), "hbox8", hbox8,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox8);
gtk_box_pack_start (GTK_BOX (vbox1), hbox8, TRUE, TRUE, 5);
fs_label = gtk_label_new (_("\250\372\274\313\300W\262v"));
gtk_widget_ref (fs_label);
gtk_object_set_data_full (GTK_OBJECT (rs232), "fs_label", fs_label,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (fs_label);
gtk_box_pack_start (GTK_BOX (hbox8), fs_label, FALSE, FALSE, 10);
fs = gtk_entry_new ();
gtk_widget_ref (fs);
gtk_object_set_data_full (GTK_OBJECT (rs232), "fs", fs,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (fs);
gtk_box_pack_start (GTK_BOX (hbox8), fs, TRUE, TRUE, 0);
gtk_widget_set_usize (fs, 1, -2);
gtk_tooltips_set_tip (tooltips, fs, _("\263\346\246\354\254\260\273\256\257\367"), NULL);
gtk_entry_set_text (GTK_ENTRY (fs), _("20000"));
pass_edge_label = gtk_label_new (_("\263q\261a\272I\244\356\300W\262v"));
gtk_widget_ref (pass_edge_label);
gtk_object_set_data_full (GTK_OBJECT (rs232), "pass_edge_label", pass_edge_label,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (pass_edge_label);
gtk_box_pack_start (GTK_BOX (hbox8), pass_edge_label, FALSE, FALSE, 10);
pass_edge = gtk_entry_new ();
gtk_widget_ref (pass_edge);
gtk_object_set_data_full (GTK_OBJECT (rs232), "pass_edge", pass_edge,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (pass_edge);
gtk_box_pack_start (GTK_BOX (hbox8), pass_edge, TRUE, TRUE, 0);
gtk_widget_set_usize (pass_edge, 1, -2);
gtk_tooltips_set_tip (tooltips, pass_edge, _("\263\346\246\354\254\260\273\256\257\367"), NULL);
gtk_entry_set_text (GTK_ENTRY (pass_edge), _("5000"));
stop_edge_label = gtk_label_new (_("\244\356\261a\272I\244\356\300W\262v"));
gtk_widget_ref (stop_edge_label);
gtk_object_set_data_full (GTK_OBJECT (rs232), "stop_edge_label", stop_edge_label,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (stop_edge_label);
gtk_box_pack_start (GTK_BOX (hbox8), stop_edge_label, FALSE, FALSE, 10);
stop_edge = gtk_entry_new ();
gtk_widget_ref (stop_edge);
gtk_object_set_data_full (GTK_OBJECT (rs232), "stop_edge", stop_edge,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (stop_edge);
gtk_box_pack_start (GTK_BOX (hbox8), stop_edge, TRUE, TRUE, 0);
gtk_widget_set_usize (stop_edge, 1, -2);
gtk_tooltips_set_tip (tooltips, stop_edge, _("\263\346\246\354\254\260\273\256\257\367"), NULL);
gtk_entry_set_text (GTK_ENTRY (stop_edge), _("7500"));
pass_ripple_label = gtk_label_new (_("\263q\261a\272\247\252i"));
gtk_widget_ref (pass_ripple_label);
gtk_object_set_data_full (GTK_OBJECT (rs232), "pass_ripple_label", pass_ripple_label,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (pass_ripple_label);
gtk_box_pack_start (GTK_BOX (hbox8), pass_ripple_label, FALSE, FALSE, 10);
pass_ripple = gtk_entry_new ();
gtk_widget_ref (pass_ripple);
gtk_object_set_data_full (GTK_OBJECT (rs232), "pass_ripple", pass_ripple,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (pass_ripple);
gtk_box_pack_start (GTK_BOX (hbox8), pass_ripple, TRUE, TRUE, 0);
gtk_widget_set_usize (pass_ripple, 1, -2);
gtk_tooltips_set_tip (tooltips, pass_ripple, _("\263\346\246\354\254\260\244\300\250\251\274W\257q"), NULL);
gtk_entry_set_text (GTK_ENTRY (pass_ripple), _("1"));
stop_ripple_label = gtk_label_new (_("\244\356\261a\272\247\252i"));
gtk_widget_ref (stop_ripple_label);
gtk_object_set_data_full (GTK_OBJECT (rs232), "stop_ripple_label", stop_ripple_label,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (stop_ripple_label);
gtk_box_pack_start (GTK_BOX (hbox8), stop_ripple_label, FALSE, FALSE, 10);
stop_ripple = gtk_entry_new ();
gtk_widget_ref (stop_ripple);
gtk_object_set_data_full (GTK_OBJECT (rs232), "stop_ripple", stop_ripple,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (stop_ripple);
gtk_box_pack_start (GTK_BOX (hbox8), stop_ripple, TRUE, TRUE, 10);
gtk_widget_set_usize (stop_ripple, 1, -2);
gtk_tooltips_set_tip (tooltips, stop_ripple, _("\263\346\246\354\254\260\244\300\250\251\274W\257q"), NULL);
gtk_entry_set_text (GTK_ENTRY (stop_ripple), _("32"));
hseparator2 = gtk_hseparator_new ();
gtk_widget_ref (hseparator2);
gtk_object_set_data_full (GTK_OBJECT (rs232), "hseparator2", hseparator2,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hseparator2);
gtk_box_pack_start (GTK_BOX (vbox1), hseparator2, TRUE, TRUE, 5);
hbox10 = gtk_hbox_new (FALSE, 0);
gtk_widget_ref (hbox10);
gtk_object_set_data_full (GTK_OBJECT (rs232), "hbox10", hbox10,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox10);
gtk_box_pack_start (GTK_BOX (vbox1), hbox10, TRUE, TRUE, 5);
label12 = gtk_label_new (_("\260\262\263]\244\247\253Y\274\306\261a\244J\302\340\262\276\250\347\246\241\241G"));
gtk_widget_ref (label12);
gtk_object_set_data_full (GTK_OBJECT (rs232), "label12", label12,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label12);
gtk_box_pack_start (GTK_BOX (hbox10), label12, FALSE, FALSE, 5);
fir_input_coefficient = gtk_radio_button_new_with_label (_3_group, _("\246\263\255\255\257\337\275\304 FIR \302o\252i\276\271"));
_3_group = gtk_radio_button_group (GTK_RADIO_BUTTON (fir_input_coefficient));
gtk_widget_ref (fir_input_coefficient);
gtk_object_set_data_full (GTK_OBJECT (rs232), "fir_input_coefficient", fir_input_coefficient,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (fir_input_coefficient);
gtk_box_pack_start (GTK_BOX (hbox10), fir_input_coefficient, FALSE, FALSE, 10);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (fir_input_coefficient), TRUE);
iir_input_coefficient = gtk_radio_button_new_with_label (_3_group, _("\265L\255\255\257\337\275\304 IIR \302o\252i\276\271"));
_3_group = gtk_radio_button_group (GTK_RADIO_BUTTON (iir_input_coefficient));
gtk_widget_ref (iir_input_coefficient);
gtk_object_set_data_full (GTK_OBJECT (rs232), "iir_input_coefficient", iir_input_coefficient,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (iir_input_coefficient);
gtk_box_pack_start (GTK_BOX (hbox10), iir_input_coefficient, FALSE, FALSE, 10);
identify_stability = gtk_button_new_with_label (_("IIR \302o\252i\276\271\303\255\251w\253\327\305\262\251w(\245\274\247\271\246\250)"));
gtk_widget_ref (identify_stability);
gtk_object_set_data_full (GTK_OBJECT (rs232), "identify_stability", identify_stability,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (identify_stability);
gtk_box_pack_start (GTK_BOX (hbox10), identify_stability, FALSE, FALSE, 10);
gtk_tooltips_set_tip (tooltips, identify_stability, _("\246]\254\260\247A\252\272\302\340\262\276\250\347\274\306\254O\260\262\263]\252\272\255\310\241A\251\322\245H\303\255\244\243\303\255\251w\247A\244]\244\243\275T\251w\241A\246\271\266s\245i\245H\247P\302_\244@\244U\241A\246]\254\260 FIR \244@\251w\254O\303\255\251w\252\272\241A\251\322\245H\244\243\245\316\264\372\244F\241C"), NULL);
hbox14 = gtk_hbox_new (FALSE, 0);
gtk_widget_ref (hbox14);
gtk_object_set_data_full (GTK_OBJECT (rs232), "hbox14", hbox14,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox14);
gtk_box_pack_start (GTK_BOX (vbox1), hbox14, TRUE, TRUE, 5);
label16 = gtk_label_new (_("\302\340\262\276\250\347\274\306\244\300\245\300 Y( n ) "));
gtk_widget_ref (label16);
gtk_object_set_data_full (GTK_OBJECT (rs232), "label16", label16,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label16);
gtk_box_pack_start (GTK_BOX (hbox14), label16, FALSE, FALSE, 10);
a_value = gtk_entry_new ();
gtk_widget_ref (a_value);
gtk_object_set_data_full (GTK_OBJECT (rs232), "a_value", a_value,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (a_value);
gtk_box_pack_start (GTK_BOX (hbox14), a_value, TRUE, TRUE, 10);
gtk_widget_set_usize (a_value, 1, -2);
gtk_tooltips_set_tip (tooltips, a_value, _("\264N\254O\302\340\262\276\250\347\274\306\244\244\252\272\244\300\245\300\263\241\245\367\241A\267\355\265M\263o\245u\246\263 IIR \244~\267|\246\263\252\272"), NULL);
gtk_entry_set_text (GTK_ENTRY (a_value), _("1 -0.7757"));
label17 = gtk_label_new (_("\302\340\262\276\250\347\274\306\244\300\244l X( n )"));
gtk_widget_ref (label17);
gtk_object_set_data_full (GTK_OBJECT (rs232), "label17", label17,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label17);
gtk_box_pack_start (GTK_BOX (hbox14), label17, FALSE, FALSE, 10);
b_value = gtk_entry_new ();
gtk_widget_ref (b_value);
gtk_object_set_data_full (GTK_OBJECT (rs232), "b_value", b_value,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (b_value);
gtk_box_pack_start (GTK_BOX (hbox14), b_value, TRUE, TRUE, 10);
gtk_widget_set_usize (b_value, 1, -2);
gtk_entry_set_text (GTK_ENTRY (b_value), _("4.7 2.2 3.6 2.2 4.7"));
appbar1 = gnome_appbar_new (TRUE, TRUE, GNOME_PREFERENCES_NEVER);
gtk_widget_ref (appbar1);
gtk_object_set_data_full (GTK_OBJECT (rs232), "appbar1", appbar1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (appbar1);
gtk_box_pack_start (GTK_BOX (vbox1), appbar1, TRUE, TRUE, 0);
hbox28 = gtk_hbox_new (FALSE, 0);
gtk_widget_ref (hbox28);
gtk_object_set_data_full (GTK_OBJECT (rs232), "hbox28", hbox28,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox28);
gtk_box_pack_start (GTK_BOX (vbox1), hbox28, TRUE, TRUE, 0);
statusbar1 = gtk_statusbar_new ();
gtk_widget_ref (statusbar1);
gtk_object_set_data_full (GTK_OBJECT (rs232), "statusbar1", statusbar1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (statusbar1);
gtk_box_pack_start (GTK_BOX (hbox28), statusbar1, FALSE, FALSE, 0);
gtk_widget_set_usize (statusbar1, 629, -2);
progressbar1 = gtk_progress_bar_new ();
gtk_widget_ref (progressbar1);
gtk_object_set_data_full (GTK_OBJECT (rs232), "progressbar1", progressbar1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (progressbar1);
gtk_box_pack_start (GTK_BOX (hbox28), progressbar1, FALSE, FALSE, 0);
gtk_progress_set_show_text (GTK_PROGRESS (progressbar1), TRUE);
gtk_progress_set_format_string (GTK_PROGRESS (progressbar1), _("%P %% \247\271\246\250"));
gtk_signal_connect (GTK_OBJECT (rs232), "delete_event",
GTK_SIGNAL_FUNC (on_rs232_delete_event),
NULL);
gtk_signal_connect (GTK_OBJECT (rs232), "show",
GTK_SIGNAL_FUNC (on_rs232_show),
NULL);
gtk_signal_connect (GTK_OBJECT (exit), "clicked",
GTK_SIGNAL_FUNC (on_exit_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (swap), "clicked",
GTK_SIGNAL_FUNC (on_swap_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (clean_data_area), "clicked",
GTK_SIGNAL_FUNC (on_clean_data_area_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (combo_entry_baudrate), "changed",
GTK_SIGNAL_FUNC (on_combo_entry_baudrate_changed),
NULL);
gtk_signal_connect (GTK_OBJECT (combo_entry_port), "changed",
GTK_SIGNAL_FUNC (on_combo_entry_port_changed),
NULL);
gtk_signal_connect (GTK_OBJECT (save_as_numeral), "clicked",
GTK_SIGNAL_FUNC (on_save_as_numeral_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (spectrum), "clicked",
GTK_SIGNAL_FUNC (on_spectrum_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (inspect), "clicked",
GTK_SIGNAL_FUNC (on_inspect_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (print_spectrum), "toggled",
GTK_SIGNAL_FUNC (on_print_spectrum_toggled),
NULL);
gtk_signal_connect (GTK_OBJECT (save_as_eps), "clicked",
GTK_SIGNAL_FUNC (on_save_as_eps_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (specification_on), "clicked",
GTK_SIGNAL_FUNC (on_specification_on_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (coefficient_on), "clicked",
GTK_SIGNAL_FUNC (on_coefficient_on_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (move_average), "clicked",
GTK_SIGNAL_FUNC (on_move_average_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (window), "clicked",
GTK_SIGNAL_FUNC (on_window_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (butterworth), "clicked",
GTK_SIGNAL_FUNC (on_butterworth_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (chebyshev), "clicked",
GTK_SIGNAL_FUNC (on_chebyshev_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (fir_input_coefficient), "clicked",
GTK_SIGNAL_FUNC (on_fir_input_coefficient_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (iir_input_coefficient), "clicked",
GTK_SIGNAL_FUNC (on_iir_input_coefficient_clicked),
NULL);
gtk_object_set_data (GTK_OBJECT (rs232), "tooltips", tooltips);
gtk_window_add_accel_group (GTK_WINDOW (rs232), accel_group);
return rs232;
}
/*
static void
do_quit_app(GtkWidget *widget)
{
exit_gpsim();
}
*/
void RegWindow_select_register(Register_Window *rw, int regnumber)
{
GtkSheet *sheet;
GtkEntry *sheet_entry;
char cell[100],*n;
char *text;
GtkSheetCellAttr attributes;
GtkSheetRange range;
int row, col;
if(rw == NULL || regnumber > MAX_REGISTERS || regnumber<0)
{
printf("Warning RegWindow_select_register(%x,%x)\n",(unsigned int)rw,regnumber);
return;
}
if(rw->registers[regnumber] == NULL)
return;
row=rw->registers[regnumber]->row;
col=rw->registers[regnumber]->col;
range.row0=range.rowi=row;
range.col0=range.coli=col;
gtk_sheet_select_range(GTK_SHEET(rw->register_sheet),&range);
if(GTK_SHEET(rw->register_sheet)->view.col0>range.col0 ||
GTK_SHEET(rw->register_sheet)->view.coli<range.coli ||
GTK_SHEET(rw->register_sheet)->view.row0>range.row0 ||
GTK_SHEET(rw->register_sheet)->view.rowi<range.rowi)
gtk_sheet_moveto(GTK_SHEET(rw->register_sheet),row,col,0.5,0.5);
sheet=rw->register_sheet;
sheet_entry = GTK_ENTRY(gtk_sheet_get_entry(sheet));
cell[0] = 0;
if(((GUI_Object*)rw)->gp)
{
n = gpsim_get_register_name(((GUI_Object*)rw)->gp->pic_id, rw->type, regnumber);
if(n==NULL)
puts("Warning n==NULL in RegWindow_select_register");
else
strncpy(cell,n,100);
}
gtk_label_set(GTK_LABEL(rw->location), cell);
gtk_entry_set_max_length(GTK_ENTRY(rw->entry),
GTK_ENTRY(sheet_entry)->text_max_length);
if((text=gtk_entry_get_text(GTK_ENTRY(gtk_sheet_get_entry(sheet)))))
gtk_entry_set_text(GTK_ENTRY(rw->entry), text);
else
gtk_entry_set_text(GTK_ENTRY(rw->entry), "");
gtk_sheet_get_attributes(sheet,sheet->active_cell.row,
sheet->active_cell.col, &attributes);
gtk_entry_set_editable(GTK_ENTRY(rw->entry), attributes.is_editable);
gtk_sheet_range_set_justification(sheet, sheet->range, GTK_JUSTIFY_RIGHT);
}
bool wxComboBox::Create( wxWindow *parent, wxWindowID id, const wxString& value,
const wxPoint& pos, const wxSize& size,
int n, const wxString choices[],
long style, const wxValidator& validator,
const wxString& name )
{
m_ignoreNextUpdate = false;
m_needParent = true;
m_acceptsFocus = true;
m_prevSelection = 0;
if (!PreCreation( parent, pos, size ) ||
!CreateBase( parent, id, pos, size, style, validator, name ))
{
wxFAIL_MSG( wxT("wxComboBox creation failed") );
return false;
}
#ifdef __WXGTK24__
if (!gtk_check_version(2,4,0))
{
m_widget = gtk_combo_box_entry_new_text();
GtkComboBox* combobox = GTK_COMBO_BOX( m_widget );
gtk_entry_set_editable( GTK_ENTRY( GTK_BIN(m_widget)->child ), TRUE );
for (int i = 0; i < n; i++)
{
gtk_combo_box_append_text( combobox, wxGTK_CONV( choices[i] ) );
m_clientDataList.Append( (wxObject*)NULL );
m_clientObjectList.Append( (wxObject*)NULL );
}
}
else
#endif
{
m_widget = gtk_combo_new();
GtkCombo* combo = GTK_COMBO(m_widget);
// Disable GTK's broken events ...
g_signal_handler_disconnect (combo->entry, combo->entry_change_id);
// ... and add surrogate handler.
combo->entry_change_id = g_signal_connect (combo->entry, "changed",
G_CALLBACK (gtkcombo_dummy_callback),
combo);
// make it more useable
gtk_combo_set_use_arrows_always( GTK_COMBO(m_widget), TRUE );
// and case-sensitive
gtk_combo_set_case_sensitive( GTK_COMBO(m_widget), TRUE );
if (style & wxNO_BORDER)
g_object_set (combo->entry, "has-frame", FALSE, NULL );
GtkWidget *list = combo->list;
for (int i = 0; i < n; i++)
{
GtkWidget *list_item = gtk_list_item_new_with_label( wxGTK_CONV( choices[i] ) );
m_clientDataList.Append( (wxObject*)NULL );
m_clientObjectList.Append( (wxObject*)NULL );
gtk_container_add( GTK_CONTAINER(list), list_item );
gtk_widget_show( list_item );
}
}
m_parent->DoAddChild( this );
GtkEntry *entry = NULL;
#ifdef __WXGTK24__
if (!gtk_check_version(2,4,0))
entry = GTK_ENTRY( GTK_BIN(m_widget)->child );
else
#endif
entry = GTK_ENTRY( GTK_COMBO(m_widget)->entry );
m_focusWidget = GTK_WIDGET( entry );
PostCreation(size);
#ifdef __WXGTK24__
if (!gtk_check_version(2,4,0))
ConnectWidget( m_widget );
else
#endif
ConnectWidget( GTK_COMBO(m_widget)->button );
#ifdef __WXGTK24__
if (!gtk_check_version(2,4,0))
{
gtk_entry_set_text( entry, wxGTK_CONV(value) );
if (style & wxCB_READONLY)
gtk_entry_set_editable( entry, FALSE );
g_signal_connect_after (entry, "changed",
G_CALLBACK (gtkcombobox_text_changed_callback), this);
g_signal_connect_after (m_widget, "changed",
G_CALLBACK (gtkcombobox_changed_callback), this);
}
else
#endif
{
GtkCombo *combo = GTK_COMBO(m_widget);
// MSW's combo box shows the value and the selection is -1
gtk_entry_set_text( entry, wxGTK_CONV(value) );
gtk_list_unselect_all( GTK_LIST(combo->list) );
if (style & wxCB_READONLY)
gtk_entry_set_editable( entry, FALSE );
// "show" and "hide" events are generated when user click on the combobox button which popups a list
// this list is the "popwin" gtk widget
g_signal_connect (GTK_COMBO(combo)->popwin, "hide",
G_CALLBACK (gtkcombo_popup_hide_callback), this);
g_signal_connect (GTK_COMBO(combo)->popwin, "show",
G_CALLBACK (gtkcombo_popup_show_callback), this);
g_signal_connect_after (combo->list, "select-child",
G_CALLBACK (gtkcombo_combo_select_child_callback),
this);
g_signal_connect_after (entry, "changed",
G_CALLBACK (gtkcombo_text_changed_callback), this);
// This is required for tool bar support
// Doesn't currently work
// wxSize setsize = GetSize();
// gtk_widget_set_size_request( m_widget, setsize.x, setsize.y );
}
SetInitialSize(size); // need this too because this is a wxControlWithItems
return true;
}
struct encdata *enc_new(const char *text)
{
GtkWidget *verbox, *tabbola;
GtkWidget *tmpbar, *tmplabel;
GtkWidget *tmpbox;
GtkWidget *scaled;
GtkWidget *ok;
/*gchar *text;*/
bool lame = true;
struct encdata *enc = NULL;
GList *listola = NULL; /* recycling */
/* init area */
enc = (struct encdata *) g_malloc(sizeof(struct encdata));
/* init area end */
if(!(strcmp(text, "Lame"))) {
lame = true;
lameid = mixer->create_enc(MP3);
enc->outchan = mixer->get_enc(lameid);
tmplabel = gtk_label_new(_("Configure Lame Encoder"));
} else {
oggid = mixer->create_enc(OGG);
enc->outchan = mixer->get_enc(oggid);
tmplabel= gtk_label_new(_("Configure Ogg/Vorbis Encoder"));
}
enc->outchan->start();
verbox = gtk_vbox_new(FALSE, 12);
gtk_box_pack_start(GTK_BOX(verbox), tmplabel, FALSE, FALSE, 0);
enc->verbox = verbox;
/*tmplabel = GTK_BIN(w)->child;
gtk_label_get(GTK_LABEL(tmplabel), &text);*/
/*winenc = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_container_set_border_width(GTK_CONTAINER(winenc), 7);
gtk_window_set_policy(GTK_WINDOW(winenc), TRUE, TRUE, TRUE);
gtk_signal_connect(GTK_OBJECT(winenc), "destroy",
(GtkSignalFunc) gtk_widget_destroyed, &winenc);*/
tmpbox = gtk_hbox_new(FALSE, 6);
gtk_box_pack_start(GTK_BOX(verbox), tmpbox, FALSE, FALSE, 0);
tmplabel = gtk_label_new(_("Quality: (low)"));
gtk_box_pack_start(GTK_BOX(tmpbox), tmplabel, FALSE, FALSE, 0);
enc->adj1 = gtk_adjustment_new(0.0, 1.0, 9.0, 1.0, 1.0, 0.0);
g_signal_connect(G_OBJECT(enc->adj1), "value_changed",
G_CALLBACK(gcb_enc_set_quality), enc);
scaled = gtk_hscale_new(GTK_ADJUSTMENT(enc->adj1));
gtk_range_set_update_policy(GTK_RANGE(scaled), GTK_UPDATE_CONTINUOUS);
gtk_scale_set_draw_value(GTK_SCALE(scaled), FALSE);
gtk_widget_set_size_request(scaled, 100, 30);
gtk_box_pack_start(GTK_BOX(tmpbox), scaled, FALSE, FALSE, 0);
tmplabel = gtk_label_new(_("(high)"));
gtk_box_pack_start(GTK_BOX(tmpbox), tmplabel, FALSE, FALSE, 0);
tmplabel = gtk_label_new(_(" Mode"));
gtk_box_pack_start(GTK_BOX(tmpbox), tmplabel, FALSE, FALSE, 0);
enc->mode = gtk_combo_new();
listola = g_list_append(listola, (void *) _("mono"));
listola = g_list_append(listola, (void *) _("stereo"));
gtk_combo_set_popdown_strings(GTK_COMBO(enc->mode), listola);
gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(enc->mode)->entry), FALSE);
g_list_free(listola);
listola = NULL;
gtk_widget_set_size_request(enc->mode, 70, 22);
gtk_box_pack_start(GTK_BOX(tmpbox), enc->mode, FALSE, FALSE, 0);
enc->adj_lab = gtk_label_new("");
gtk_box_pack_start(GTK_BOX(verbox), enc->adj_lab, FALSE, FALSE, 0);
gtk_adjustment_set_value(GTK_ADJUSTMENT(enc->adj1), 2.0);
/* hidden info */
tabbola = gtk_table_new(3, 4, FALSE);
gtk_table_set_row_spacings(GTK_TABLE(tabbola), 12);
gtk_table_set_col_spacings(GTK_TABLE(tabbola), 12);
gtk_box_pack_start(GTK_BOX(verbox), tabbola, FALSE, FALSE, 0);
enc->tabbola = tabbola;
tmplabel = gtk_label_new(_("bitrate"));
gtk_table_attach_defaults(GTK_TABLE(tabbola), tmplabel, 0, 1, 0, 1);
enc->bitrate = gtk_combo_new();
listola = g_list_append(listola, (void *) "16");
listola = g_list_append(listola, (void *) "24");
listola = g_list_append(listola, (void *) "32");
listola = g_list_append(listola, (void *) "48");
listola = g_list_append(listola, (void *) "56");
listola = g_list_append(listola, (void *) "64");
listola = g_list_append(listola, (void *) "96");
listola = g_list_append(listola, (void *) "128");
gtk_combo_set_popdown_strings(GTK_COMBO(enc->bitrate), listola);
gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(enc->bitrate)->entry), FALSE);
g_list_free(listola);
listola = NULL;
gtk_widget_set_size_request(enc->bitrate, 70, 22);
gtk_table_attach_defaults(GTK_TABLE(tabbola), enc->bitrate, 1, 2, 0, 1);
tmplabel = gtk_label_new(_("frequency filtering"));
gtk_table_attach_defaults(GTK_TABLE(tabbola), tmplabel, 2, 3, 0, 1);
enc->freqfil = gtk_combo_new();
listola = g_list_append(listola, (void *) _("auto"));
listola = g_list_append(listola, (void *) _("none"));
listola = g_list_append(listola, (void *) _("manual"));
gtk_combo_set_popdown_strings(GTK_COMBO(enc->freqfil), listola);
g_list_free(listola);
listola = NULL;
g_signal_connect(G_OBJECT(GTK_COMBO(enc->freqfil)->entry),
"changed", G_CALLBACK(gcb_set_pass), enc);
gtk_widget_set_size_request(enc->freqfil, 70, 22);
gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(enc->freqfil)->entry),
FALSE);
gtk_table_attach_defaults(GTK_TABLE(tabbola), enc->freqfil, 3, 4, 0, 1);
tmplabel=gtk_label_new(_("frequency"));
gtk_table_attach_defaults(GTK_TABLE(tabbola), tmplabel, 0, 1, 1, 2);
enc->freq = gtk_combo_new();
listola = g_list_append(listola, (void *) "auto");
listola = g_list_append(listola, (void *) "11000");
listola = g_list_append(listola, (void *) "16000");
listola = g_list_append(listola, (void *) "22050");
listola = g_list_append(listola, (void *) "44100");
gtk_combo_set_popdown_strings(GTK_COMBO(enc->freq), listola);
g_list_free(listola);
listola = NULL;
gtk_widget_set_size_request(enc->freq, 70, 22);
gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(enc->freq)->entry), FALSE);
gtk_table_attach_defaults(GTK_TABLE(tabbola), enc->freq, 1, 2, 1, 2);
tmplabel = gtk_label_new(_("lowpass Hz"));
gtk_table_attach_defaults(GTK_TABLE(tabbola), tmplabel, 2, 3, 1, 2);
enc->lowps = gtk_entry_new();
gtk_entry_set_editable(GTK_ENTRY(enc->lowps), FALSE);
gtk_entry_set_text(GTK_ENTRY(enc->lowps), _("guessed"));
gtk_widget_set_size_request(enc->lowps, 70, 22);
gtk_table_attach_defaults(GTK_TABLE(tabbola), enc->lowps, 3, 4, 1, 2);
tmplabel = gtk_label_new(_("highpass Hz"));
gtk_table_attach_defaults(GTK_TABLE(tabbola), tmplabel, 2, 3, 2, 3);
enc->highps = gtk_entry_new();
gtk_entry_set_editable(GTK_ENTRY(enc->highps), FALSE);
gtk_entry_set_text(GTK_ENTRY(enc->highps), _("guessed"));
gtk_widget_set_size_request(enc->highps, 70, 22);
gtk_table_attach_defaults(GTK_TABLE(tabbola), enc->highps, 3, 4, 2, 3);
/* end of hidden info */
enc->tasti = gtk_vbox_new(FALSE, 5);
enc->expert = gtk_toggle_button_new_with_label(_("I'm Expert..."));
g_signal_connect(G_OBJECT(enc->expert), "toggled",
G_CALLBACK(expert_mode), tabbola);
gtk_box_pack_start(GTK_BOX(enc->tasti), enc->expert, FALSE, FALSE, 0);
/* profile menu */
tmpbar = gtk_menu_bar_new();
gtk_box_pack_start(GTK_BOX(enc->tasti), tmpbar, FALSE, FALSE, 0);
enc->profroot = gtk_menu_item_new_with_label(_("Profile..."));
gtk_menu_bar_append(GTK_MENU_BAR(tmpbar), enc->profroot);
if(enc->outchan->tipo == MP3)
profile_lame_load();
else
profile_vorbis_load();
enc_profmenu(enc);
/* profile menu end */
ok = gtk_button_new_with_label(_("Apply"));
gtk_button_set_relief(GTK_BUTTON(ok), GTK_RELIEF_HALF);
g_signal_connect(G_OBJECT(ok), "clicked",
G_CALLBACK(gcb_set_enc), enc);
gtk_box_pack_start(GTK_BOX(enc->tasti), ok, FALSE, FALSE, 0);
/* set value from core */
enc_put(enc);
gtk_widget_show_all(verbox);
gtk_widget_hide_on_delete(tabbola);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(enc->expert), FALSE);
return enc;
}
void addParams (GtkNotebook *notebook, PluginParameters *params) {
int n;
GtkWidget *table = gtk_table_new (params->nbParams, 2, FALSE);
gtk_container_set_border_width (GTK_CONTAINER (table), 11);
gtk_table_set_row_spacings (GTK_TABLE (table), 6);
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
for (n=0;n<params->nbParams;++n) {
if (params->params[n] == 0) {
GtkWidget *hseparator = gtk_hseparator_new ();
gtk_widget_show (hseparator);
gtk_table_attach (GTK_TABLE (table), hseparator, 0, 2, n, n+1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 5);
} else {
PluginParam *p = params->params[n];
if (p->type != PARAM_BOOLVAL) {
GtkWidget *label4 = gtk_label_new (p->name);
gtk_widget_show (label4);
gtk_table_attach (GTK_TABLE (table), label4, 0, 1, n, n+1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify (GTK_LABEL (label4), GTK_JUSTIFY_RIGHT);
gtk_misc_set_alignment (GTK_MISC (label4), 0, 0.5);
}
switch (p->type) {
case PARAM_INTVAL: {
GtkWidget *spinbutton_adj,*spinbutton;
spinbutton_adj = (GtkWidget*)gtk_adjustment_new (
p->param.ival.value,
p->param.ival.min, p->param.ival.max,
p->param.ival.step, p->param.ival.step*10,
p->param.ival.step*10);
spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (spinbutton_adj), 1, 0);
gtk_widget_show (spinbutton);
gtk_table_attach (GTK_TABLE (table), spinbutton, 1, 2, n, n+1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 1);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton), TRUE);
gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (spinbutton),
GTK_UPDATE_IF_VALID);
p->user_data = spinbutton;
gtk_object_set_data (GTK_OBJECT(spinbutton),"param",(void*)p);
p->change_listener = my_int_listener;
gtk_signal_connect (GTK_OBJECT (spinbutton), "changed",
GTK_SIGNAL_FUNC (on_spinbutton_int_changed),
NULL);
break;
}
case PARAM_FLOATVAL: {
GtkWidget *progress,*prog_adj;
prog_adj = (GtkWidget*)gtk_adjustment_new (
p->param.fval.value,
p->param.fval.min, p->param.fval.max,
p->param.fval.step, p->param.fval.step*10,
p->param.fval.step*10);
progress = gtk_progress_bar_new_with_adjustment(GTK_ADJUSTMENT(prog_adj));
gtk_widget_show(progress);
gtk_table_attach (GTK_TABLE (table), progress, 1, 2, n, n+1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 1);
p->user_data = progress;
p->change_listener = my_float_listener;
break;
}
case PARAM_LISTVAL: {
int i;
GList *combo_winsize_items = NULL;
GtkWidget *combo_entry_winsize = NULL;
GtkWidget *combo_winsize = gtk_combo_new ();
gtk_widget_show (combo_winsize);
gtk_table_attach (GTK_TABLE (table), combo_winsize, 1, 2, n, n+1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_combo_set_value_in_list (GTK_COMBO (combo_winsize), TRUE, TRUE);
for (i=0;i<p->param.slist.nbChoices;++i)
combo_winsize_items = g_list_append (combo_winsize_items,
p->param.slist.choices[i]);
gtk_combo_set_popdown_strings (GTK_COMBO (combo_winsize), combo_winsize_items);
g_list_free (combo_winsize_items);
combo_entry_winsize = GTK_COMBO (combo_winsize)->entry;
gtk_widget_show (combo_entry_winsize);
gtk_entry_set_editable (GTK_ENTRY (combo_entry_winsize), FALSE);
gtk_entry_set_text (GTK_ENTRY (combo_entry_winsize), LVAL(*p));
p->change_listener = my_list_listener;
p->user_data = combo_entry_winsize;
gtk_object_set_data (GTK_OBJECT(combo_entry_winsize),"param",(void*)p);
gtk_signal_connect (GTK_OBJECT (combo_entry_winsize), "changed",
GTK_SIGNAL_FUNC (on_list_changed),
NULL);
break;
}
case PARAM_BOOLVAL: {
GtkWidget *checkbutton_double =
gtk_check_button_new_with_label (p->name);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton_double),BVAL(*p));
gtk_widget_show (checkbutton_double);
gtk_table_attach (GTK_TABLE (table), checkbutton_double, 1, 2, n, n+1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_signal_connect (GTK_OBJECT (checkbutton_double), "toggled",
GTK_SIGNAL_FUNC (on_bool_toggled),
NULL);
gtk_object_set_data (GTK_OBJECT(checkbutton_double),"param",(void*)p);
p->user_data = checkbutton_double;
p->change_listener = my_bool_listener;
break;
}
}
}
}
gtk_widget_show_all(GTK_WIDGET(table));
gtk_container_add(GTK_CONTAINER(notebook),table);
gtk_notebook_set_tab_label_text(notebook,GTK_WIDGET(table),params->name);
}
static void Operator_modify(GtkWidget * UNUSED(button), GtkTreeView * treeview) {
GtkTreeModel * model = gtk_tree_view_get_model(treeview);
GtkTreeSelection * selection = gtk_tree_view_get_selection(treeview);
GtkTreeIter iter;
if (gtk_tree_selection_get_selected(selection, NULL, &iter)) {
gint i;
GtkTreePath *path;
OperatorTable * optable;
path = gtk_tree_model_get_path(model, &iter);
i = gtk_tree_path_get_indices(path)[0];
optable = OperatorTable_loadFromFile(OPERATORDB_FILENAME);
if (optable != NULL) {
GtkWidget *dialog;
GtkWidget *hbox;
GtkWidget *table;
GtkWidget *name_entry;
GtkWidget *password_entry;
GtkWidget *label;
gint response;
dialog = gtk_dialog_new_with_buttons("Edition d'un opérateur", NULL, GTK_DIALOG_MODAL
| GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_OK, GTK_RESPONSE_OK,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL);
hbox = gtk_hbox_new(FALSE, 8);
gtk_container_set_border_width(GTK_CONTAINER (hbox), 8);
gtk_box_pack_start(GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox, FALSE, FALSE, 0);
table = gtk_table_new(2, 2, FALSE);
gtk_table_set_row_spacings(GTK_TABLE (table), 4);
gtk_table_set_col_spacings(GTK_TABLE (table), 4);
gtk_box_pack_start(GTK_BOX (hbox), table, TRUE, TRUE, 0);
label = gtk_label_new("Nom :");
gtk_table_attach_defaults(GTK_TABLE (table), label, 0, 1, 0, 1);
name_entry = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY (name_entry), OperatorTable_getName(optable, i));
gtk_entry_set_editable(GTK_ENTRY (name_entry), FALSE);
gtk_table_attach_defaults(GTK_TABLE (table), name_entry, 1, 2, 0, 1);
gtk_label_set_mnemonic_widget(GTK_LABEL (label), name_entry);
label = gtk_label_new("Mot de passe");
gtk_table_attach_defaults(GTK_TABLE (table), label, 0, 1, 1, 2);
password_entry = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY (password_entry), OperatorTable_getPassword(optable, i));
gtk_table_attach_defaults(GTK_TABLE (table), password_entry, 1, 2, 1, 2);
gtk_label_set_mnemonic_widget(GTK_LABEL (label), password_entry);
gtk_widget_show_all(hbox);
response = gtk_dialog_run(GTK_DIALOG (dialog));
if (response == GTK_RESPONSE_OK) {
GtkListStore * store =
GTK_LIST_STORE(gtk_tree_model_sort_get_model(GTK_TREE_MODEL_SORT (model)));
OperatorTable_setOperator(optable, gtk_entry_get_text(GTK_ENTRY (name_entry)),
gtk_entry_get_text(GTK_ENTRY (password_entry)));
OperatorTable_saveToFile(optable, OPERATORDB_FILENAME);
gtk_list_store_clear(store);
for (i = 0; i < OperatorTable_getRecordCount(optable); ++i) {
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter, 0, OperatorTable_getName(optable, i), -1);
}
}
gtk_widget_destroy(dialog);
OperatorTable_destroy(optable);
}
gtk_tree_path_free(path);
}
}
GtkWidget * create_FileSelect( void )
{
GtkWidget * vbox4;
GtkWidget * hbox4;
GtkWidget * vseparator1;
GtkWidget * hbox6;
GtkWidget * fsFNameListWindow;
GtkWidget * hbuttonbox3;
GtkWidget * uppixmapwid;
GdkPixmap * uppixmap;
GdkBitmap * upmask;
GtkStyle * upstyle;
fsFileSelect=gtk_window_new( GTK_WINDOW_TOPLEVEL );
gtk_widget_set_name( fsFileSelect,"fsFileSelect" );
gtk_object_set_data( GTK_OBJECT( fsFileSelect ),"fsFileSelect",fsFileSelect );
gtk_widget_set_usize( fsFileSelect,512,300 );
GTK_WIDGET_SET_FLAGS( fsFileSelect,GTK_CAN_DEFAULT );
gtk_widget_set_events( fsFileSelect,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( fsFileSelect ),MSGTR_FileSelect );
gtk_window_set_position( GTK_WINDOW( fsFileSelect ),GTK_WIN_POS_CENTER );
gtk_window_set_policy( GTK_WINDOW( fsFileSelect ),TRUE,TRUE,TRUE );
gtk_window_set_wmclass( GTK_WINDOW( fsFileSelect ),"FileSelect","MPlayer" );
fsColorMap=gdk_colormap_get_system();
gtk_widget_realize( fsFileSelect );
gtkAddIcon( fsFileSelect );
style=gtk_widget_get_style( fsFileSelect );
dpixmap=gdk_pixmap_colormap_create_from_xpm_d( fsFileSelect->window,fsColorMap,&dmask,&style->bg[GTK_STATE_NORMAL],(gchar **)dir_xpm );
fpixmap=gdk_pixmap_colormap_create_from_xpm_d( fsFileSelect->window,fsColorMap,&fmask,&style->bg[GTK_STATE_NORMAL],(gchar **)file_xpm );
vbox4=AddVBox( AddDialogFrame( fsFileSelect ),0 );
hbox4=AddHBox( vbox4,1 );
fsCombo4=gtk_combo_new();
gtk_widget_set_name( fsCombo4,"fsCombo4" );
gtk_widget_show( fsCombo4 );
gtk_box_pack_start( GTK_BOX( hbox4 ),fsCombo4,TRUE,TRUE,0 );
gtk_widget_set_usize( fsCombo4,-2,20 );
fsPathCombo=GTK_COMBO( fsCombo4 )->entry;
gtk_widget_set_name( fsPathCombo,"fsPathCombo" );
gtk_widget_show( fsPathCombo );
gtk_widget_set_usize( fsPathCombo,-2,20 );
vseparator1=gtk_vseparator_new();
gtk_widget_set_name( vseparator1,"vseparator1" );
gtk_widget_show( vseparator1 );
gtk_box_pack_start( GTK_BOX( hbox4 ),vseparator1,FALSE,TRUE,0 );
gtk_widget_set_usize( vseparator1,7,20 );
upstyle=gtk_widget_get_style( fsFileSelect );
uppixmap=gdk_pixmap_colormap_create_from_xpm_d( fsFileSelect->window,fsColorMap,&upmask,&upstyle->bg[GTK_STATE_NORMAL],(gchar **)up_xpm );
uppixmapwid=gtk_pixmap_new( uppixmap,upmask );
gtk_widget_show( uppixmapwid );
fsUp=gtk_button_new();
gtk_container_add( GTK_CONTAINER(fsUp ),uppixmapwid );
gtk_widget_show( fsUp );
gtk_box_pack_start( GTK_BOX( hbox4 ),fsUp,FALSE,FALSE,0 );
gtk_widget_set_usize( fsUp,65,15 );
AddHSeparator( vbox4 );
hbox6=AddHBox( NULL,0 );
gtk_box_pack_start( GTK_BOX( vbox4 ),hbox6,TRUE,TRUE,0 );
fsFNameListWindow=gtk_scrolled_window_new( NULL,NULL );
gtk_widget_set_name( fsFNameListWindow,"fsFNameListWindow" );
gtk_widget_show( fsFNameListWindow );
gtk_box_pack_start( GTK_BOX( hbox6 ),fsFNameListWindow,TRUE,TRUE,0 );
gtk_widget_set_usize( fsFNameListWindow,-2,145 );
gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( fsFNameListWindow ),GTK_POLICY_NEVER,GTK_POLICY_AUTOMATIC );
fsFNameList=gtk_clist_new( 2 );
gtk_widget_set_name( fsFNameList,"fsFNameList" );
gtk_container_add( GTK_CONTAINER( fsFNameListWindow ),fsFNameList );
gtk_clist_set_column_width( GTK_CLIST( fsFNameList ),0,80 );
gtk_clist_set_selection_mode( GTK_CLIST( fsFNameList ),GTK_SELECTION_BROWSE );
gtk_clist_column_titles_hide( GTK_CLIST( fsFNameList ) );
gtk_clist_set_shadow_type( GTK_CLIST( fsFNameList ),GTK_SHADOW_ETCHED_OUT );
AddHSeparator( vbox4 );
List=gtk_combo_new();
gtk_widget_set_name( List,"List" );
gtk_widget_ref( List );
gtk_object_set_data_full( GTK_OBJECT( fsFileSelect ),"List",List,(GtkDestroyNotify)gtk_widget_unref );
gtk_widget_show( List );
gtk_box_pack_start( GTK_BOX( vbox4 ),List,FALSE,FALSE,0 );
gtk_widget_set_usize( List,-2,20 );
fsFilterCombo=GTK_COMBO( List )->entry;
gtk_widget_set_name( fsFilterCombo,"fsFilterCombo" );
gtk_widget_show( fsFilterCombo );
gtk_entry_set_editable (GTK_ENTRY( fsFilterCombo ),FALSE );
AddHSeparator( vbox4 );
hbuttonbox3=AddHButtonBox( vbox4 );
gtk_button_box_set_layout( GTK_BUTTON_BOX( hbuttonbox3 ),GTK_BUTTONBOX_END );
gtk_button_box_set_spacing( GTK_BUTTON_BOX( hbuttonbox3 ),10 );
fsOk=AddButton( MSGTR_Ok,hbuttonbox3 );
fsCancel=AddButton( MSGTR_Cancel,hbuttonbox3 );
gtk_signal_connect( GTK_OBJECT( fsFileSelect ),"destroy",GTK_SIGNAL_FUNC( WidgetDestroy ),&fsFileSelect );
gtk_signal_connect( GTK_OBJECT( fsFileSelect ),"key_release_event",GTK_SIGNAL_FUNC( on_FileSelect_key_release_event ),NULL );
gtk_signal_connect( GTK_OBJECT( fsFilterCombo ),"changed",GTK_SIGNAL_FUNC( fs_fsFilterCombo_changed ),fsFilterCombo );
gtk_signal_connect( GTK_OBJECT( fsFilterCombo ),"activate",GTK_SIGNAL_FUNC( fs_fsFilterCombo_activate ),fsFilterCombo );
gtk_signal_connect( GTK_OBJECT( fsPathCombo ),"changed",GTK_SIGNAL_FUNC( fs_fsPathCombo_changed ),fsPathCombo );
gtk_signal_connect( GTK_OBJECT( fsPathCombo ),"activate",GTK_SIGNAL_FUNC( fs_fsPathCombo_activate ),fsPathCombo );
gtk_signal_connect( GTK_OBJECT( fsUp ),"released",GTK_SIGNAL_FUNC( fs_Up_released ),fsFNameList );
gtk_signal_connect( GTK_OBJECT( fsOk ),"released",GTK_SIGNAL_FUNC( fs_Ok_released ),fsCombo4 );
gtk_signal_connect( GTK_OBJECT( fsCancel ),"released",GTK_SIGNAL_FUNC( fs_Cancel_released ),NULL );
gtk_signal_connect( GTK_OBJECT( fsFNameList ),"select_row",(GtkSignalFunc)fs_fsFNameList_select_row,NULL );
gtk_widget_grab_focus( fsFNameList );
return fsFileSelect;
}
bool wxComboBox::Create( wxWindow *parent, wxWindowID id, const wxString& value,
const wxPoint& pos, const wxSize& size,
int n, const wxString choices[],
long style, const wxValidator& validator,
const wxString& name )
{
m_ignoreNextUpdate = false;
m_needParent = true;
m_acceptsFocus = true;
m_prevSelection = 0;
if (!PreCreation( parent, pos, size ) ||
!CreateBase( parent, id, pos, size, style, validator, name ))
{
wxFAIL_MSG( wxT("wxComboBox creation failed") );
return false;
}
m_widget = gtk_combo_new();
GtkCombo *combo = GTK_COMBO(m_widget);
// Disable GTK's broken events ...
gtk_signal_disconnect( GTK_OBJECT(combo->entry), combo->entry_change_id );
// ... and add surrogate handler.
combo->entry_change_id = gtk_signal_connect (GTK_OBJECT (combo->entry), "changed",
(GtkSignalFunc) gtk_dummy_callback, combo);
// make it more useable
gtk_combo_set_use_arrows_always( GTK_COMBO(m_widget), TRUE );
// and case-sensitive
gtk_combo_set_case_sensitive( GTK_COMBO(m_widget), TRUE );
GtkWidget *list = GTK_COMBO(m_widget)->list;
// gtk_list_set_selection_mode( GTK_LIST(list), GTK_SELECTION_MULTIPLE );
for (int i = 0; i < n; i++)
{
GtkWidget *list_item = gtk_list_item_new_with_label( wxGTK_CONV( choices[i] ) );
m_clientDataList.Append( NULL );
m_clientObjectList.Append( NULL );
gtk_container_add( GTK_CONTAINER(list), list_item );
gtk_widget_show( list_item );
}
m_parent->DoAddChild( this );
m_focusWidget = combo->entry;
PostCreation(size);
ConnectWidget( combo->button );
// MSW's combo box shows the value and the selection is -1
gtk_entry_set_text( GTK_ENTRY(combo->entry), wxGTK_CONV(value) );
gtk_list_unselect_all( GTK_LIST(combo->list) );
if (style & wxCB_READONLY)
gtk_entry_set_editable( GTK_ENTRY( combo->entry ), FALSE );
// "show" and "hide" events are generated when user click on the combobox button which popups a list
// this list is the "popwin" gtk widget
gtk_signal_connect( GTK_OBJECT(GTK_COMBO(combo)->popwin), "hide",
GTK_SIGNAL_FUNC(gtk_popup_hide_callback), (gpointer)this );
gtk_signal_connect( GTK_OBJECT(GTK_COMBO(combo)->popwin), "show",
GTK_SIGNAL_FUNC(gtk_popup_show_callback), (gpointer)this );
gtk_signal_connect_after( GTK_OBJECT(combo->entry), "changed",
GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this );
gtk_signal_connect_after( GTK_OBJECT(combo->list), "select-child",
GTK_SIGNAL_FUNC(gtk_combo_select_child_callback), (gpointer)this );
SetInitialSize(size); // need this too because this is a wxControlWithItems
// This is required for tool bar support
// wxSize setsize = GetSize();
// gtk_widget_set_usize( m_widget, setsize.x, setsize.y );
return true;
}
void StringOptionView::_setActive(bool active) {
gtk_entry_set_editable(myLineEdit, active);
}
static void init_control_page(GuiInfo *gui, GtkNotebook *window_notebook) {
GtkWidget *controlhbox;
GtkWidget *controlvbox1;
GtkWidget *controlvbox2;
GtkWidget *controltablabel;
GtkWidget *bat_speed_label;
GtkWidget *bat_speed_hbox;
GtkObject *bat_speed_adjustment;
GtkWidget *bat_speed_sbutton;
GtkWidget *method_frame;
GtkWidget *method_vbox;
GtkWidget *method_mouse_radio;
GtkWidget *method_keyboard_radio;
GtkWidget *keyb_frame;
GtkWidget *keyb_vbox;
GtkWidget *keyb_left_hbox;
GtkWidget *keyb_left_label;
GtkWidget *keyb_left_entry;
GtkWidget *keyb_right_hbox;
GtkWidget *keyb_right_label;
GtkWidget *keyb_right_entry;
GtkWidget *keyb_fire1_hbox;
GtkWidget *keyb_fire1_label;
GtkWidget *keyb_fire1_entry;
GtkWidget *keyb_fire2_hbox;
GtkWidget *keyb_fire2_label;
GtkWidget *keyb_fire2_entry;
/* Init the vbox */
controlhbox = gtk_hbox_new(TRUE, GNOME_PAD);
controlvbox1 = gtk_vbox_new(TRUE, GNOME_PAD);
controlvbox2 = gtk_vbox_new(TRUE, GNOME_PAD);
controltablabel = gtk_label_new(_("Control"));
gtk_box_pack_start(GTK_BOX(controlhbox), controlvbox1, TRUE, TRUE, GNOME_PAD);
gtk_box_pack_start(GTK_BOX(controlhbox), controlvbox2, TRUE, TRUE, GNOME_PAD);
gtk_widget_show(controlhbox);
gtk_widget_show(controlvbox1);
gtk_widget_show(controlvbox2);
/* Method Frame and Radio Buttons */
method_frame = gtk_frame_new(_("Method"));
gtk_frame_set_shadow_type(GTK_FRAME(method_frame), GTK_SHADOW_ETCHED_IN);
method_vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(method_frame), method_vbox);
method_keyboard_radio = gtk_radio_button_new_with_label(NULL, _("Keyboard"));
method_mouse_radio = gtk_radio_button_new_with_label_from_widget(
GTK_RADIO_BUTTON(method_keyboard_radio), _("Mouse"));
gtk_box_pack_start_defaults(GTK_BOX(method_vbox),
method_keyboard_radio);
gtk_box_pack_start_defaults(GTK_BOX(method_vbox),
method_mouse_radio);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(method_mouse_radio),
newflags->mouse_control);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(method_keyboard_radio),
newflags->keyboard_control);
gtk_box_pack_start(GTK_BOX(controlvbox1), method_frame, TRUE, TRUE, GNOME_PAD);
gtk_widget_show(method_frame);
gtk_widget_show(method_vbox);
gtk_widget_show(method_keyboard_radio);
gtk_widget_show(method_mouse_radio);
g_signal_connect(GTK_OBJECT(method_keyboard_radio), "toggled",
GTK_SIGNAL_FUNC(cb_ctrl_key), NULL);
g_signal_connect(GTK_OBJECT(method_mouse_radio), "toggled",
GTK_SIGNAL_FUNC(cb_ctrl_mouse), NULL);
/* Bat speed */
bat_speed_label = gtk_label_new(_("Bat speed: "));
bat_speed_hbox = gtk_hbox_new(FALSE, GNOME_PAD);
bat_speed_adjustment = gtk_adjustment_new((gfloat) newflags->bat_speed,
(gfloat) MIN_BATSPEED, (gfloat) MAX_BATSPEED,
1.0, 5.0, 1.0);
bat_speed_sbutton = gtk_spin_button_new(
GTK_ADJUSTMENT(bat_speed_adjustment), 1.0, 0);
gtk_spin_button_set_digits(GTK_SPIN_BUTTON(bat_speed_sbutton), 0);
gtk_spin_button_set_wrap(GTK_SPIN_BUTTON(bat_speed_sbutton), FALSE);
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(bat_speed_sbutton), TRUE);
gtk_box_pack_start_defaults(GTK_BOX(bat_speed_hbox), bat_speed_label);
gtk_box_pack_start_defaults(GTK_BOX(bat_speed_hbox), bat_speed_sbutton);
gtk_box_pack_start(GTK_BOX(controlvbox1), bat_speed_hbox, TRUE, FALSE, GNOME_PAD);
gtk_widget_show(bat_speed_label);
gtk_widget_show(bat_speed_hbox);
gtk_widget_show(bat_speed_sbutton);
g_signal_connect(GTK_OBJECT(bat_speed_adjustment), "value_changed",
GTK_SIGNAL_FUNC(cb_bat_speed), bat_speed_sbutton);
/* Keybindings Frame */
keyb_frame = gtk_frame_new(_("Keybindings"));
gtk_frame_set_shadow_type(GTK_FRAME(keyb_frame), GTK_SHADOW_ETCHED_IN);
keyb_vbox = gtk_vbox_new(TRUE, GNOME_PAD);
gtk_container_add(GTK_CONTAINER(keyb_frame), keyb_vbox);
gtk_box_pack_start(GTK_BOX(controlvbox2), keyb_frame, TRUE, TRUE, GNOME_PAD);
gtk_widget_show(keyb_vbox);
gtk_widget_show(keyb_frame);
/* KB: Left */
keyb_left_hbox = gtk_hbox_new(FALSE, GNOME_PAD);
keyb_left_label = gtk_label_new(_("Left:"));
gtk_misc_set_alignment(GTK_MISC(keyb_left_label), 0.0, 0.5);
keyb_left_entry = gtk_entry_new();
gtk_entry_set_editable(GTK_ENTRY(keyb_left_entry), FALSE);
gtk_entry_set_text(GTK_ENTRY(keyb_left_entry),
gdk_keyval_name(newflags->left_key));
gtk_box_pack_start_defaults(GTK_BOX(keyb_left_hbox), keyb_left_label);
gtk_box_pack_start_defaults(GTK_BOX(keyb_left_hbox), keyb_left_entry);
gtk_box_pack_start(GTK_BOX(keyb_vbox), keyb_left_hbox, TRUE, TRUE, GNOME_PAD);
gtk_widget_show(keyb_left_label);
gtk_widget_show(keyb_left_entry);
gtk_widget_show(keyb_left_hbox);
g_signal_connect(GTK_OBJECT(keyb_left_entry), "key_press_event",
GTK_SIGNAL_FUNC(cb_key_left), NULL);
/* KB: Right */
keyb_right_hbox = gtk_hbox_new(FALSE, GNOME_PAD);
keyb_right_label = gtk_label_new(_("Right:"));
gtk_misc_set_alignment(GTK_MISC(keyb_right_label), 0.0, 0.5);
keyb_right_entry = gtk_entry_new();
gtk_entry_set_editable(GTK_ENTRY(keyb_right_entry), FALSE);
gtk_entry_set_text(GTK_ENTRY(keyb_right_entry),
gdk_keyval_name(newflags->right_key));
gtk_box_pack_start_defaults(GTK_BOX(keyb_right_hbox), keyb_right_label);
gtk_box_pack_start_defaults(GTK_BOX(keyb_right_hbox), keyb_right_entry);
gtk_box_pack_start(GTK_BOX(keyb_vbox), keyb_right_hbox, TRUE, TRUE, GNOME_PAD);
gtk_widget_show(keyb_right_label);
gtk_widget_show(keyb_right_entry);
gtk_widget_show(keyb_right_hbox);
g_signal_connect(GTK_OBJECT(keyb_right_entry), "key_press_event",
GTK_SIGNAL_FUNC(cb_key_right), NULL);
/* KB: Fire1 */
keyb_fire1_hbox = gtk_hbox_new(FALSE, GNOME_PAD);
keyb_fire1_label = gtk_label_new(_("Fire One:"));
gtk_misc_set_alignment(GTK_MISC(keyb_fire1_label), 0.0, 0.5);
keyb_fire1_entry = gtk_entry_new();
gtk_entry_set_editable(GTK_ENTRY(keyb_fire1_entry), FALSE);
gtk_entry_set_text(GTK_ENTRY(keyb_fire1_entry),
gdk_keyval_name(newflags->fire1_key));
gtk_box_pack_start_defaults(GTK_BOX(keyb_fire1_hbox), keyb_fire1_label);
gtk_box_pack_start_defaults(GTK_BOX(keyb_fire1_hbox), keyb_fire1_entry);
gtk_box_pack_start(GTK_BOX(keyb_vbox), keyb_fire1_hbox, TRUE, TRUE, GNOME_PAD);
gtk_widget_show(keyb_fire1_label);
gtk_widget_show(keyb_fire1_entry);
gtk_widget_show(keyb_fire1_hbox);
g_signal_connect(GTK_OBJECT(keyb_fire1_entry), "key_press_event",
GTK_SIGNAL_FUNC(cb_key_fire1), NULL);
/* KB: Fire2 */
keyb_fire2_hbox = gtk_hbox_new(FALSE, GNOME_PAD);
keyb_fire2_label = gtk_label_new(_("Fire Two:"));
gtk_misc_set_alignment(GTK_MISC(keyb_fire2_label), 0.0, 0.5);
keyb_fire2_entry = gtk_entry_new();
gtk_entry_set_editable(GTK_ENTRY(keyb_fire2_entry), FALSE);
gtk_entry_set_text(GTK_ENTRY(keyb_fire2_entry),
gdk_keyval_name(newflags->fire2_key));
gtk_box_pack_start_defaults(GTK_BOX(keyb_fire2_hbox), keyb_fire2_label);
gtk_box_pack_start_defaults(GTK_BOX(keyb_fire2_hbox), keyb_fire2_entry);
gtk_box_pack_start(GTK_BOX(keyb_vbox), keyb_fire2_hbox, TRUE, TRUE, GNOME_PAD);
gtk_widget_show(keyb_fire2_label);
gtk_widget_show(keyb_fire2_entry);
gtk_widget_show(keyb_fire2_hbox);
g_signal_connect(GTK_OBJECT(keyb_fire2_entry), "key_press_event",
GTK_SIGNAL_FUNC(cb_key_fire2), NULL);
/* Add it to the dialog */
gtk_notebook_append_page(GTK_NOTEBOOK(window_notebook),
controlhbox, controltablabel);
}
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? 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? 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);
}
