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); }