uint8_t DIA_XVCDParam(char *title,COMPRESSION_MODE * mode, uint32_t * qz, uint32_t * br,uint32_t *fsize,FFcodecSetting *conf) { GtkWidget *dialog; gchar *str; char string[200]; int ret; gint r,b; #define WID(x) lookup_widget(dialog,#x) #define CHECK_GET(x,y) {y=gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(WID(x)));} #define CHECK_SET(x,y) {gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(WID(x)),y);} ret=-1; while(ret==-1) { dialog=create_dialog1(); // gtk_transient(dialog); gtk_register_dialog(dialog); gtk_window_set_title (GTK_WINDOW (dialog), title); // set the right select button switch (*mode) { case COMPRESS_CBR: RADIO_SET(radioCBR,1); b=*br/1000; gtk_write_entry(WID(entryCBR),(int)b); break; case COMPRESS_2PASS: RADIO_SET(radio2Pass,1); gtk_write_entry(WID(entry2Pass),(int)*fsize); break; case COMPRESS_CQ: RADIO_SET(radioCQ,1); gtk_write_entry(WID(entryCQ),(int)*qz); break; } gtk_write_entry(WID(entry_min),(int) (conf->minBitrate *8)/1000); gtk_write_entry(WID(entry_max),(int) (conf->maxBitrate *8)/1000); gtk_option_menu_set_history (GTK_OPTION_MENU (WID(optionmenu1)),conf->user_matrix); gtk_option_menu_set_history (GTK_OPTION_MENU (WID(optionmenu1)),conf->user_matrix); gtk_spin_button_set_value(GTK_SPIN_BUTTON(WID(spinbutton1)),(float)conf->gop_size) ; CHECK_SET(checkbuttonxvid,conf->use_xvid_ratecontrol); if(gtk_dialog_run(GTK_DIALOG(dialog))==GTK_RESPONSE_OK) { int r,value=0; ret=1; conf->minBitrate=(gtk_read_entry(WID(entry_min))*1000)>>3; conf->maxBitrate=(gtk_read_entry(WID(entry_max))*1000)>>3; conf->user_matrix= getRangeInMenu(WID(optionmenu1)); conf->gop_size= gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(WID(spinbutton1))); CHECK_GET(checkbuttonxvid,conf->use_xvid_ratecontrol); r=RADIO_GET(radioCQ)+(2*RADIO_GET(radioCBR))+(4*RADIO_GET(radio2Pass)); printf("\n r: %d \n",r); switch(r) { case 2: *mode = COMPRESS_CBR; value = gtk_read_entry(WID(entryCBR)); if (value < 9000) { value *= 1000; } if (value > 16 && value < 9000000) { *br = value; ret = 1; } else ret = -1; break; case 1: *mode = COMPRESS_CQ; value = gtk_read_entry(WID(entryCQ)); if (value >= 2 && value <= 32) { *qz = value; ret = 1; } else { printf("\n incorrect Q parameter\n"); ret =-1; } break; case 4: *mode = COMPRESS_2PASS; value = gtk_read_entry(WID(entry2Pass)); if((value>0)&&(value<4000)) { *fsize=value; ret=1; } else ret=-1; break; default: ADM_assert(0); } } else
void DoConfigDialog(){ GtkWidget *dlg, *hbox, *vbox, *vbox2, *button, *table, *frame; GtkWidget *lw3slider, *lw3label, *lw2slider, *lw2label, *zlist, *menu, *item; GtkWidget *aa2check, *aa3check, *depthcheck, *linescheck, *polyscheck; GtkWidget *transslider, *translabel, *clipslider, *cliplabel; GtkWidget *show2check, *show3check, *portalcheck; int loop = 1, ret = IDCANCEL; GtkObject *adj; dlg = gtk_window_new( GTK_WINDOW_TOPLEVEL ); gtk_window_set_title( GTK_WINDOW( dlg ), _( "Portal Viewer Configuration" ) ); 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 ); frame = gtk_frame_new( _( "3D View" ) ); gtk_widget_show( frame ); gtk_box_pack_start( GTK_BOX( vbox ), frame, TRUE, TRUE, 0 ); vbox2 = gtk_vbox_new( FALSE, 5 ); gtk_widget_show( vbox2 ); gtk_container_add( GTK_CONTAINER( frame ), vbox2 ); gtk_container_set_border_width( GTK_CONTAINER( vbox2 ), 5 ); hbox = gtk_hbox_new( FALSE, 5 ); gtk_widget_show( hbox ); gtk_box_pack_start( GTK_BOX( vbox2 ), hbox, TRUE, TRUE, 0 ); adj = gtk_adjustment_new( portals.width_3d, 2, 40, 1, 1, 1 ); lw3slider = gtk_hscale_new( GTK_ADJUSTMENT( adj ) ); gtk_widget_show( lw3slider ); gtk_box_pack_start( GTK_BOX( hbox ), lw3slider, TRUE, TRUE, 0 ); gtk_scale_set_draw_value( GTK_SCALE( lw3slider ), FALSE ); lw3label = gtk_label_new( "" ); gtk_widget_show( lw3label ); gtk_box_pack_start( GTK_BOX( hbox ), lw3label, FALSE, TRUE, 0 ); gtk_signal_connect( adj, "value_changed", GTK_SIGNAL_FUNC( OnScroll3d ), lw3label ); table = gtk_table_new( 2, 4, FALSE ); gtk_widget_show( table ); gtk_box_pack_start( GTK_BOX( vbox2 ), table, TRUE, TRUE, 0 ); gtk_table_set_row_spacings( GTK_TABLE( table ), 5 ); gtk_table_set_col_spacings( GTK_TABLE( table ), 5 ); button = gtk_button_new_with_label( _( "Color" ) ); gtk_widget_show( button ); gtk_table_attach( GTK_TABLE( table ), button, 0, 1, 0, 1, (GtkAttachOptions) ( GTK_FILL ), (GtkAttachOptions) ( 0 ), 0, 0 ); gtk_signal_connect( GTK_OBJECT( button ), "clicked", GTK_SIGNAL_FUNC( OnColor3d ), NULL ); button = gtk_button_new_with_label( _( "Depth Color" ) ); gtk_widget_show( button ); gtk_table_attach( GTK_TABLE( table ), button, 0, 1, 1, 2, (GtkAttachOptions) ( GTK_FILL ), (GtkAttachOptions) ( 0 ), 0, 0 ); gtk_signal_connect( GTK_OBJECT( button ), "clicked", GTK_SIGNAL_FUNC( OnColorFog ), NULL ); aa3check = gtk_check_button_new_with_label( "Anti-Alias (May not work on some video cards)" ); gtk_widget_show( aa3check ); gtk_table_attach( GTK_TABLE( table ), aa3check, 1, 4, 0, 1, (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), (GtkAttachOptions) ( 0 ), 0, 0 ); gtk_signal_connect( GTK_OBJECT( aa3check ), "toggled", GTK_SIGNAL_FUNC( OnAntiAlias3d ), NULL ); depthcheck = gtk_check_button_new_with_label( _( "Depth Cue" ) ); gtk_widget_show( depthcheck ); gtk_table_attach( GTK_TABLE( table ), depthcheck, 1, 2, 1, 2, (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), (GtkAttachOptions) ( 0 ), 0, 0 ); gtk_signal_connect( GTK_OBJECT( depthcheck ), "toggled", GTK_SIGNAL_FUNC( OnFog ), NULL ); linescheck = gtk_check_button_new_with_label( _( "Lines" ) ); gtk_widget_show( linescheck ); gtk_table_attach( GTK_TABLE( table ), linescheck, 2, 3, 1, 2, (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), (GtkAttachOptions) ( 0 ), 0, 0 ); gtk_signal_connect( GTK_OBJECT( linescheck ), "toggled", GTK_SIGNAL_FUNC( OnLines ), NULL ); polyscheck = gtk_check_button_new_with_label( _( "Polygons" ) ); gtk_widget_show( polyscheck ); gtk_table_attach( GTK_TABLE( table ), polyscheck, 3, 4, 1, 2, (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), (GtkAttachOptions) ( 0 ), 0, 0 ); gtk_signal_connect( GTK_OBJECT( polyscheck ), "toggled", GTK_SIGNAL_FUNC( OnPoly ), NULL ); zlist = gtk_option_menu_new(); gtk_widget_show( zlist ); gtk_box_pack_start( GTK_BOX( vbox2 ), zlist, TRUE, FALSE, 0 ); menu = gtk_menu_new(); gtk_widget_show( menu ); gtk_option_menu_set_menu( GTK_OPTION_MENU( zlist ), menu ); item = gtk_menu_item_new_with_label( _( "Z-Buffer Test and Write (recommended for solid or no polygons)" ) ); gtk_widget_show( item ); gtk_signal_connect( GTK_OBJECT( item ), "activate", GTK_SIGNAL_FUNC( OnSelchangeZbuffer ), GINT_TO_POINTER( 0 ) ); gtk_menu_append( GTK_MENU( menu ), item ); item = gtk_menu_item_new_with_label( _( "Z-Buffer Test Only (recommended for transparent polygons)" ) ); gtk_widget_show( item ); gtk_signal_connect( GTK_OBJECT( item ), "activate", GTK_SIGNAL_FUNC( OnSelchangeZbuffer ), GINT_TO_POINTER( 1 ) ); gtk_menu_append( GTK_MENU( menu ), item ); item = gtk_menu_item_new_with_label( _( "Z-Buffer Off" ) ); gtk_widget_show( item ); gtk_signal_connect( GTK_OBJECT( item ), "activate", GTK_SIGNAL_FUNC( OnSelchangeZbuffer ), GINT_TO_POINTER( 2 ) ); gtk_menu_append( GTK_MENU( menu ), item ); table = gtk_table_new( 2, 2, FALSE ); gtk_widget_show( table ); gtk_box_pack_start( GTK_BOX( vbox2 ), table, TRUE, TRUE, 0 ); gtk_table_set_row_spacings( GTK_TABLE( table ), 5 ); gtk_table_set_col_spacings( GTK_TABLE( table ), 5 ); adj = gtk_adjustment_new( portals.trans_3d, 0, 100, 1, 1, 1 ); transslider = gtk_hscale_new( GTK_ADJUSTMENT( adj ) ); gtk_widget_show( transslider ); gtk_table_attach( GTK_TABLE( table ), transslider, 0, 1, 0, 1, (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), (GtkAttachOptions) ( 0 ), 0, 0 ); gtk_scale_set_draw_value( GTK_SCALE( transslider ), FALSE ); translabel = gtk_label_new( "" ); gtk_widget_show( translabel ); gtk_table_attach( GTK_TABLE( table ), translabel, 1, 2, 0, 1, (GtkAttachOptions) ( GTK_FILL ), (GtkAttachOptions) ( 0 ), 0, 0 ); gtk_misc_set_alignment( GTK_MISC( translabel ), 0.0, 0.0 ); gtk_signal_connect( adj, "value_changed", GTK_SIGNAL_FUNC( OnScrollTrans ), translabel ); adj = gtk_adjustment_new( portals.clip_range, 1, 128, 1, 1, 1 ); clipslider = gtk_hscale_new( GTK_ADJUSTMENT( adj ) ); gtk_widget_show( clipslider ); gtk_table_attach( GTK_TABLE( table ), clipslider, 0, 1, 1, 2, (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), (GtkAttachOptions) ( 0 ), 0, 0 ); gtk_scale_set_draw_value( GTK_SCALE( clipslider ), FALSE ); cliplabel = gtk_label_new( "" ); gtk_widget_show( cliplabel ); gtk_table_attach( GTK_TABLE( table ), cliplabel, 1, 2, 1, 2, (GtkAttachOptions) ( GTK_FILL ), (GtkAttachOptions) ( 0 ), 0, 0 ); gtk_misc_set_alignment( GTK_MISC( cliplabel ), 0.0, 0.0 ); gtk_signal_connect( adj, "value_changed", GTK_SIGNAL_FUNC( OnScrollClip ), cliplabel ); hbox = gtk_hbox_new( TRUE, 5 ); gtk_widget_show( hbox ); gtk_box_pack_start( GTK_BOX( vbox2 ), hbox, TRUE, FALSE, 0 ); show3check = gtk_check_button_new_with_label( _( "Show" ) ); gtk_widget_show( show3check ); gtk_box_pack_start( GTK_BOX( hbox ), show3check, TRUE, TRUE, 0 ); gtk_signal_connect( GTK_OBJECT( show3check ), "toggled", GTK_SIGNAL_FUNC( OnConfig3d ), NULL ); portalcheck = gtk_check_button_new_with_label( _( "Portal cubic clipper" ) ); gtk_widget_show( portalcheck ); gtk_box_pack_start( GTK_BOX( hbox ), portalcheck, TRUE, TRUE, 0 ); gtk_signal_connect( GTK_OBJECT( portalcheck ), "toggled", GTK_SIGNAL_FUNC( OnClip ), NULL ); frame = gtk_frame_new( _( "2D View" ) ); gtk_widget_show( frame ); gtk_box_pack_start( GTK_BOX( vbox ), frame, TRUE, TRUE, 0 ); vbox2 = gtk_vbox_new( FALSE, 5 ); gtk_widget_show( vbox2 ); gtk_container_add( GTK_CONTAINER( frame ), vbox2 ); gtk_container_set_border_width( GTK_CONTAINER( vbox2 ), 5 ); hbox = gtk_hbox_new( FALSE, 5 ); gtk_widget_show( hbox ); gtk_box_pack_start( GTK_BOX( vbox2 ), hbox, TRUE, FALSE, 0 ); adj = gtk_adjustment_new( portals.width_2d, 2, 40, 1, 1, 1 ); lw2slider = gtk_hscale_new( GTK_ADJUSTMENT( adj ) ); gtk_widget_show( lw2slider ); gtk_box_pack_start( GTK_BOX( hbox ), lw2slider, TRUE, TRUE, 0 ); gtk_scale_set_draw_value( GTK_SCALE( lw2slider ), FALSE ); lw2label = gtk_label_new( "" ); gtk_widget_show( lw2label ); gtk_box_pack_start( GTK_BOX( hbox ), lw2label, FALSE, TRUE, 0 ); gtk_signal_connect( adj, "value_changed", GTK_SIGNAL_FUNC( OnScroll2d ), lw2label ); hbox = gtk_hbox_new( FALSE, 5 ); gtk_widget_show( hbox ); gtk_box_pack_start( GTK_BOX( vbox2 ), hbox, TRUE, FALSE, 0 ); button = gtk_button_new_with_label( _( "Color" ) ); gtk_widget_show( button ); gtk_box_pack_start( GTK_BOX( hbox ), button, FALSE, FALSE, 0 ); gtk_signal_connect( GTK_OBJECT( button ), "clicked", GTK_SIGNAL_FUNC( OnColor2d ), NULL ); gtk_widget_set_usize( button, 60, -2 ); aa2check = gtk_check_button_new_with_label( _( "Anti-Alias (May not work on some video cards)" ) ); gtk_widget_show( aa2check ); gtk_box_pack_start( GTK_BOX( hbox ), aa2check, TRUE, TRUE, 0 ); gtk_signal_connect( GTK_OBJECT( aa2check ), "toggled", GTK_SIGNAL_FUNC( OnAntiAlias2d ), NULL ); hbox = gtk_hbox_new( FALSE, 5 ); gtk_widget_show( hbox ); gtk_box_pack_start( GTK_BOX( vbox2 ), hbox, TRUE, FALSE, 0 ); show2check = gtk_check_button_new_with_label( _( "Show" ) ); gtk_widget_show( show2check ); gtk_box_pack_start( GTK_BOX( hbox ), show2check, FALSE, FALSE, 0 ); gtk_signal_connect( GTK_OBJECT( show2check ), "toggled", GTK_SIGNAL_FUNC( OnConfig2d ), NULL ); 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( _( "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 ); // initialize dialog gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( show2check ), portals.show_2d ); gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( aa2check ), portals.aa_2d ); Set2DText( lw2label ); gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( show3check ), portals.show_3d ); gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( depthcheck ), portals.fog ); gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( polyscheck ), portals.polygons ); gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( linescheck ), portals.lines ); gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( aa3check ), portals.aa_3d ); gtk_option_menu_set_history( GTK_OPTION_MENU( zlist ), portals.zbuffer ); gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( portalcheck ), portals.clip ); Set3DText( lw3label ); Set3DTransText( translabel ); SetClipText( cliplabel ); gtk_grab_add( dlg ); gtk_widget_show( dlg ); while ( loop ) gtk_main_iteration(); gtk_grab_remove( dlg ); gtk_widget_destroy( dlg ); }
void qcad_clock_combo_set_clock (QCADClockCombo *qcc, int clock) { g_object_set_data (G_OBJECT (qcc->widget), "clock", (gpointer)(clock = CLAMP (clock, 0, 3))) ; gtk_option_menu_set_history (GTK_OPTION_MENU (qcc->widget), clock) ; }
int main(int argc, char **argv) { GtkWidget *widget; gchar *glade_xml_file; gtk_init(&argc, &argv); set_font(); get_asf_share_dir_with_argv0(argv[0]); set_tiff_warning_handler(); asfPrintStatus("\nASF MapReady:\n"); const char *share_dir = get_asf_share_dir(); if (!share_dir) // this actually should never happen with the current implementation // of get_asf_share_dir() -- always sets the share dir to something // even if it is a bad guess... in which case the next check will fail asfPrintError("Could not find the ASF share directory!\n"); glade_xml_file = (gchar *)find_in_share("mapready.glade"); if (!glade_xml_file) asfPrintError("Could not find the mapready.glade file!\n" "It should be in the share files directory, here:\n" " %s\n", share_dir); glade_xml = glade_xml_new(glade_xml_file, NULL, NULL); if (!glade_xml) asfPrintError("Could not load the mapready.glade file!\n" "This file may be corrupt. mapready.glade was found in:\n" " %s\n", share_dir); g_free(glade_xml_file); asfPrintStatus("Using share files directory: %s\n\n", share_dir); /* thumbnails supported in GTK 2.4 or greater */ #ifdef G_THREADS_ENABLED use_thumbnails = gtk_major_version >= 2 && gtk_minor_version >= 4; #else use_thumbnails = FALSE; #endif #ifdef win32 // On windows, ensure that our installed sh.exe is the one that is found, // by severely restricting the path. char pathenv[1024]; sprintf(pathenv, "PATH=%s", get_asf_bin_dir()); putenv(pathenv); #endif if (!use_thumbnails) { printf("GTK Version < 2.4 -- output thumbnails disabled.\n"); } else { // We will want to load thumbnails in other threads. if ( !g_thread_supported () ) { g_thread_init (NULL); } } /* allow FOPEN, FREAD, FWRITE to fail without aborting */ caplib_behavior_on_error = BEHAVIOR_ON_ERROR_CONTINUE; /* add version number to window title, request a default size */ char gtitle [256]; sprintf (gtitle, "ASF MapReady: Version %s", MAPREADY_VERSION_STRING); widget = get_widget_checked("asf_convert"); gtk_window_set_title(GTK_WINDOW(widget), gtitle); // commenting this out - now supported within glade //gtk_window_resize(GTK_WINDOW(widget), 1000, 700); /* select defaults for dropdowns & buttons & labeling */ widget = get_widget_checked("scaling_method_combobox"); set_combo_box_item(widget, SCALING_METHOD_SIGMA); widget = get_widget_checked("import_checkbutton"); gtk_widget_set_sensitive(widget, FALSE); widget = get_widget_checked("input_data_type_combobox"); set_combo_box_item(widget, INPUT_TYPE_AMP); widget = get_widget_checked("resample_option_menu"); set_combo_box_item(widget, RESAMPLE_BILINEAR); // Populate the colormap drop-downs on both the import tab and in the // browse dialog populate_polsarpro_classification_optionmenu(); widget = get_widget_checked("browse_select_colormap_optionmenu"); gtk_option_menu_set_history(GTK_OPTION_MENU(widget), 0); widget = get_widget_checked("output_format_combobox"); set_combo_box_item(widget, OUTPUT_FORMAT_JPEG); widget = get_widget_checked("geocode_checkbutton"); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), TRUE); geocode_options_changed(); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), FALSE); widget = get_widget_checked("about_dialog_copyright_label"); gtk_label_set_text(GTK_LABEL(widget), ASF_COPYRIGHT_STRING); // Hide latitude selection stuff until we start supporting // swath products (level 0) again widget = get_widget_checked("latitude_checkbutton"); gtk_widget_hide(widget); widget = get_widget_checked("latitude_low_label"); gtk_widget_hide(widget); widget = get_widget_checked("latitude_hi_label"); gtk_widget_hide(widget); widget = get_widget_checked("latitude_low_entry"); gtk_widget_hide(widget); widget = get_widget_checked("latitude_hi_entry"); gtk_widget_hide(widget); // For now, do not allow manual offsets show_widget("hbox_tc_matching", FALSE); // This option is deprecated -- we always apply the fix now // and don't give the user the option of turning it off. Probably // we can just delete all code associated with it, but for now we // just turn it on, and hide it. set_checked("apply_metadata_fix_checkbutton", TRUE); widget = get_widget_checked("apply_metadata_fix_checkbutton"); gtk_widget_hide(widget); // Muck with the fonts in the About dialog widget = get_widget_checked("about_dialog_mapready_label"); gchar *str = gtitle; gchar *text; PangoAttrList *attrs; sprintf(gtitle, "\n<b>ASF MapReady</b>\n" "<i>Remote Sensing Toolkit</i>\n" "ver. %s", MAPREADY_VERSION_STRING); if (strlen(SVN_REV)>0) sprintf(gtitle, "%s (build %s)", gtitle, SVN_REV); else strcat(gtitle, " (custom build)"); pango_parse_markup(str, -1, 0, &attrs, &text, NULL, NULL); gtk_label_set_attributes(GTK_LABEL(widget), attrs); gtk_label_set_text(GTK_LABEL(widget), text); PangoFontDescription *font_desc = pango_font_description_from_string("Sans 12"); gtk_widget_modify_font(widget, font_desc); // Muck with the "Select Processing Steps" label widget = get_widget_checked("select_processing_steps_label"); str = gtitle; sprintf(gtitle, "<b><i> Select Processing Steps:</i></b>"); pango_parse_markup(str, -1, 0, &attrs, &text, NULL, NULL); gtk_label_set_attributes(GTK_LABEL(widget), attrs); gtk_label_set_text(GTK_LABEL(widget), text); font_desc = pango_font_description_from_string("Sans 12"); gtk_widget_modify_font(widget, font_desc); /* fire handlers for hiding/showing stuff */ output_format_combobox_changed(); input_data_type_changed(); geocode_options_changed(); load_external_commands(); external_settings_changed(); set_toolbar_images(); show_execute_button(TRUE); /* build columns in the files section */ show_full_paths = FALSE; // Set before setup_files_list(), default to FALSE widget = get_widget_checked("show_full_path_names_checkbutton"); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), FALSE); setup_files_list(); /* allow multiple selects */ widget = get_widget_checked("input_file_selection"); gtk_file_selection_set_select_multiple(GTK_FILE_SELECTION(widget), TRUE); /* drag-n-drop setup */ setup_dnd(); /* right-click menu setup */ setup_popup_menu(); /* bands dropdown setup*/ setup_band_comboboxes(); current_naming_scheme = naming_scheme_default(); /* set initial vpanel setting */ //widget = get_widget_checked("vertical_pane"); //gtk_paned_set_position(GTK_PANED(widget), 240); /* Connect signal handlers. */ glade_xml_signal_autoconnect (glade_xml); /* initial flag settings */ processing = FALSE; settings_on_execute = NULL; /* explicit call to the function that refreshes the "summary" */ /* section when options are changed, so get the settings */ /* initially in there */ input_data_formats_changed(); input_data_type_combobox_changed(); default_to_terrcorr_on(); default_to_keep_temp(); terrcorr_options_changed(); init_browse_format_combobox(); /* For some reason, it did not work to set this via glade */ /* So, we have to select our default faraday rotation style here */ rb_select("rb_fr_global", TRUE); polarimetry_settings_changed(); /* put files on the command-line into the files section */ populate_files_list(argc, argv); /* set up the rgb stuff on the export tab */ rgb_combo_box_setup(); /* enters the main GTK loop */ gtk_main (); /* clean up, application has been closed */ if (settings_on_execute) settings_delete(settings_on_execute); if (output_directory) g_free(output_directory); if (current_naming_scheme) naming_scheme_delete(current_naming_scheme); release_predefined_projections(); exit (EXIT_SUCCESS); }
static VALUE rg_set_history(VALUE self, VALUE index) { gtk_option_menu_set_history(GTK_OPTION_MENU(RVAL2GOBJ(self)), NUM2INT(index)); return self; }
static void eyes_create_options(Control *control, GtkContainer *container, GtkWidget *done) { const gchar *entry; t_eyes *eyes; GtkBox *vbox; GtkMenu *m; /* the menu of the option menu */ int sel; /* "selected" index in the option menu */ int i; /* current index in the option menu */ char *current; /* currently used theme */ GDir *dir; eyes = (t_eyes *)control->data; eyes->dialog = gtk_widget_get_toplevel(done); /* if (eyes->revert.theme != NULL) g_free(eyes->revert.theme); if (eyes->options.theme != NULL) eyes->revert.theme = g_strdup(eyes->options.theme); else eyes->revert.theme = NULL; */ current = (eyes->options.theme) ? eyes->options.theme : DEFAULTTHEME; m = GTK_MENU(gtk_menu_new()); sel = 0; if ((dir = g_dir_open(THEMESDIR, 0, NULL)) == NULL) { /* * fall back to default theme */ menu_add_string(m, g_strdup(DEFAULTTHEME)); } else { for (i = 0; (entry = g_dir_read_name(dir)) != NULL; i++) { menu_add_string(m, g_strdup(entry)); if (strcmp(entry, current) == 0) { sel = i; } } g_dir_close(dir); } vbox = GTK_BOX(gtk_vbox_new(FALSE, 5)); gtk_widget_show(GTK_WIDGET(vbox)); gtk_container_add(GTK_CONTAINER(container), GTK_WIDGET(vbox)); eyes->theme_om = GTK_WIDGET(gtk_option_menu_new()); gtk_option_menu_set_menu(GTK_OPTION_MENU(eyes->theme_om),GTK_WIDGET(m)); gtk_widget_show(eyes->theme_om); gtk_option_menu_set_history(GTK_OPTION_MENU(eyes->theme_om), sel); gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(eyes->theme_om), FALSE, FALSE, 0); g_signal_connect(GTK_WIDGET(eyes->theme_om), "changed", G_CALLBACK(theme_changed_cb), eyes); }
long SaveFileWithPopUp (_String& fileName, _String& prompt, _String& defFileName, _String& listLabel, _List& menuOptions) { static _String lastOpenFilePath; long optionChoice = 0; if (!argFileName) { argFileName = new _String; } else { *argFileName = empty; } GtkWidget * fileSelector = gtk_file_selection_new (prompt.sData); _String fName = lastOpenFilePath & defFileName; gtk_file_selection_set_filename (GTK_FILE_SELECTION (fileSelector), fName.sData); gtk_file_selection_set_select_multiple (GTK_FILE_SELECTION (fileSelector),false); GtkWidget * fileFormatOptions = gtk_menu_new (); for (long k = 0; k<menuOptions.lLength; k++) { GtkWidget * optionWidget = gtk_menu_item_new_with_label (((_String*)menuOptions(k))->sData); gtk_menu_shell_append (GTK_MENU_SHELL (fileFormatOptions), optionWidget); gtk_widget_show (optionWidget); } GtkWidget * fpd = gtk_option_menu_new (); gtk_option_menu_set_menu (GTK_OPTION_MENU (fpd), fileFormatOptions); gtk_option_menu_set_history(GTK_OPTION_MENU (fpd), 0); gtk_widget_show (fpd); GtkWidget* secLabel = gtk_label_new (listLabel.sData); GtkWidget* newBox = gtk_hbox_new (true,0); gtk_box_pack_start(GTK_BOX(newBox),secLabel,false,false,0); gtk_box_pack_start(GTK_BOX(newBox),fpd,true,false,0); gtk_widget_show (secLabel); gtk_widget_show (newBox); gtk_box_pack_end(GTK_BOX(GTK_DIALOG(fileSelector)->vbox),newBox,true,true,0); //gtk_button_box_set_child_secondary (GTK_BUTTON_BOX(GTK_DIALOG(fileSelector)->action_area),newBox,true); g_signal_connect (GTK_FILE_SELECTION (fileSelector)->ok_button, "clicked", G_CALLBACK (hyphy_store_filename), fileSelector); g_signal_connect (fpd, "changed", G_CALLBACK (hyphy_grab_option), &optionChoice); g_signal_connect (GTK_FILE_SELECTION (fileSelector)->cancel_button, "clicked", G_CALLBACK (hyphy_kill_dialog_and_exit), fileSelector); g_signal_connect_swapped (fileSelector, "close", G_CALLBACK (hyphy_exit_loop), fileSelector); gtk_widget_show (fileSelector); gtk_window_set_modal (GTK_WINDOW(fileSelector),true); gtk_main (); fileName = *argFileName; if (argFileName->sLength) { lastOpenFilePath = argFileName->Cut(0,argFileName->FindBackwards('/',0,-1)); } if (argFileName->sLength) { return optionChoice; } return -1; }
/** * gimp_unit_menu_set_unit: * @menu: The unit menu you want to set the unit for. * @unit: The new unit. * * Sets a new #GimpUnit for the specified #GimpUnitMenu. **/ void gimp_unit_menu_set_unit (GimpUnitMenu *menu, GimpUnit unit) { GtkWidget *menuitem = NULL; GList *items; gint user_unit; g_return_if_fail (GIMP_IS_UNIT_MENU (menu)); g_return_if_fail (((unit >= GIMP_UNIT_PIXEL) && ((unit > GIMP_UNIT_PIXEL) || menu->show_pixels) && (unit < gimp_unit_get_number_of_units ())) || ((unit == GIMP_UNIT_PERCENT) && menu->show_percent)); if (unit == menu->unit) return; items = GTK_MENU_SHELL (GTK_OPTION_MENU (menu)->menu)->children; user_unit = (GIMP_UNIT_END + (((menu->show_pixels || menu->show_percent) ? 2 : 0) + ((menu->show_pixels && menu->show_percent) ? 1 : 0))); if ((unit >= GIMP_UNIT_END) && (unit != GIMP_UNIT_PERCENT)) { gchar *string; if ((g_list_length (items) - 3) >= user_unit) { gtk_widget_destroy (GTK_WIDGET (g_list_nth_data (items, user_unit - 1))); gtk_widget_destroy (GTK_WIDGET (g_list_nth_data (items, user_unit - 1))); } menuitem = gtk_menu_item_new (); gtk_menu_shell_append (GTK_MENU_SHELL (GTK_OPTION_MENU (menu)->menu), menuitem); gtk_widget_set_sensitive (menuitem, FALSE); gtk_menu_reorder_child (GTK_MENU (GTK_OPTION_MENU (menu)->menu), menuitem, user_unit - 1); gtk_widget_show (menuitem); string = gimp_unit_format_string (menu->format, unit); menuitem = gtk_menu_item_new_with_label (string); g_free (string); gtk_menu_shell_append (GTK_MENU_SHELL (GTK_OPTION_MENU (menu)->menu), menuitem); g_object_set_data (G_OBJECT (menuitem), "gimp_unit_menu", GINT_TO_POINTER (unit)); gtk_menu_reorder_child (GTK_MENU (GTK_OPTION_MENU (menu)->menu), menuitem, user_unit); gtk_widget_show (menuitem); g_signal_connect (menuitem, "activate", G_CALLBACK (gimp_unit_menu_callback), menu); } menu->unit = unit; gtk_option_menu_set_history (GTK_OPTION_MENU (menu), (unit == GIMP_UNIT_PIXEL) ? 0 : ((unit == GIMP_UNIT_PERCENT) ? (menu->show_pixels ? 1 : 0) : (((menu->show_pixels || menu->show_percent) ? 2 : 0) + ((menu->show_pixels && menu->show_percent) ? 1 : 0) + ((unit < GIMP_UNIT_END) ? (unit - 1) : GIMP_UNIT_END)))); g_signal_emit (menu, gimp_unit_menu_signals[UNIT_CHANGED], 0); }
void set_predefined_projections(int is_source, int projection) { GtkWidget * predefined_projection_option_menu; GtkWidget * menu = NULL; /* looking through all the files can be slow, skip it if we can */ if (projection == previous_projection) return; if (previous_projection == -1) { /* populate all the predefined projection menus */ source_utm_menu = populate_predefined_projections(PROJ_UTM); target_utm_menu = populate_predefined_projections(PROJ_UTM); source_latlon_menu = populate_predefined_projections(PROJ_LATLON); target_latlon_menu = populate_predefined_projections(PROJ_LATLON); source_ps_menu = populate_predefined_projections(PROJ_PS); target_ps_menu = populate_predefined_projections(PROJ_PS); source_lamcc_menu = populate_predefined_projections(PROJ_LAMCC); target_lamcc_menu = populate_predefined_projections(PROJ_LAMCC); source_lamaz_menu = populate_predefined_projections(PROJ_LAMAZ); target_lamaz_menu = populate_predefined_projections(PROJ_LAMAZ); source_albers_menu = populate_predefined_projections(PROJ_ALBERS); target_albers_menu = populate_predefined_projections(PROJ_ALBERS); g_object_ref(source_latlon_menu); g_object_ref(source_utm_menu); g_object_ref(source_ps_menu); g_object_ref(source_lamcc_menu); g_object_ref(source_lamaz_menu); g_object_ref(source_albers_menu); g_object_ref(target_latlon_menu); g_object_ref(target_utm_menu); g_object_ref(target_ps_menu); g_object_ref(target_lamcc_menu); g_object_ref(target_lamaz_menu); g_object_ref(target_albers_menu); } predefined_projection_option_menu = is_source ? get_widget_checked("source_predefined_projection_option_menu") : get_widget_checked("target_predefined_projection_option_menu"); switch (projection) { case PROJ_UTM: menu = is_source ? source_utm_menu : target_utm_menu; break; case PROJ_LATLON: menu = is_source ? source_latlon_menu : target_latlon_menu; break; case PROJ_PS: menu = is_source ? source_ps_menu : target_ps_menu; break; case PROJ_LAMCC: menu = is_source ? source_lamcc_menu : target_lamcc_menu; break; case PROJ_LAMAZ: menu = is_source ? source_lamaz_menu : target_lamaz_menu; break; case PROJ_ALBERS: menu = is_source ? source_albers_menu : target_albers_menu; break; } g_assert(menu); previous_projection = projection; gtk_option_menu_set_menu( GTK_OPTION_MENU(predefined_projection_option_menu), menu); gtk_option_menu_set_history( GTK_OPTION_MENU(predefined_projection_option_menu), 0); gtk_widget_show(menu); gtk_widget_show(predefined_projection_option_menu); }
void CreateAudioDialog (void) { GtkWidget* hbox; GtkWidget* vbox; GtkWidget* hbox2; GtkWidget* label; GtkWidget* button; const char *audioEncoder; SDL_LockMutex(dialog_mutex); if (dialog != NULL) { SDL_UnlockMutex(dialog_mutex); return; } SDL_UnlockMutex(dialog_mutex); pAudioCaps = MyConfig->m_audioCapabilities; dialog = gtk_dialog_new(); gtk_signal_connect(GTK_OBJECT(dialog), "destroy", GTK_SIGNAL_FUNC(on_destroy_dialog), &dialog); gtk_window_set_title(GTK_WINDOW(dialog), "Audio Settings"); gtk_window_set_modal(GTK_WINDOW(dialog), TRUE); hbox = gtk_hbox_new(FALSE, 1); gtk_widget_show(hbox); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox, FALSE, FALSE, 5); vbox = gtk_vbox_new(TRUE, 1); gtk_widget_show(vbox); gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 5); label = gtk_label_new(" Source:"); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_widget_show(label); gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0); input_label = gtk_label_new(" Input Port:"); gtk_misc_set_alignment(GTK_MISC(input_label), 0.0, 0.5); gtk_box_pack_start(GTK_BOX(vbox), input_label, FALSE, FALSE, 0); track_label = gtk_label_new(" Track:"); gtk_misc_set_alignment(GTK_MISC(track_label), 0.0, 0.5); gtk_box_pack_start(GTK_BOX(vbox), track_label, FALSE, FALSE, 0); label = gtk_label_new(" Output:"); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_widget_show(label); gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0); label = gtk_label_new(" Encoding :"); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_widget_show(label); gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0); label = gtk_label_new(" Channels:"); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_widget_show(label); gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0); label = gtk_label_new(" Sampling Rate (Hz):"); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_widget_show(label); gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0); label = gtk_label_new(" Bit Rate (bps):"); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_widget_show(label); gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0); vbox = gtk_vbox_new(TRUE, 1); gtk_widget_show(vbox); gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 5); hbox2 = gtk_hbox_new(FALSE, 1); gtk_widget_show(hbox2); gtk_box_pack_start(GTK_BOX(vbox), hbox2, FALSE, FALSE, 0); source_type = MyConfig->GetStringValue(CONFIG_AUDIO_SOURCE_TYPE); // source entry free(source_name); source_name = strdup(MyConfig->GetStringValue(CONFIG_AUDIO_SOURCE_NAME)); source_modified = false; source_combo = CreateFileCombo(source_name); source_entry = GTK_COMBO(source_combo)->entry; SetEntryValidator(GTK_OBJECT(source_entry), GTK_SIGNAL_FUNC(on_source_entry_changed), GTK_SIGNAL_FUNC(on_source_leave)); source_list = GTK_COMBO(source_combo)->list; gtk_signal_connect(GTK_OBJECT(source_list), "select_child", GTK_SIGNAL_FUNC(on_source_list_changed), NULL); gtk_widget_show(source_combo); gtk_box_pack_start(GTK_BOX(hbox2), source_combo, TRUE, TRUE, 0); // browse button browse_button = gtk_button_new_with_label(" Browse... "); gtk_signal_connect(GTK_OBJECT(browse_button), "clicked", GTK_SIGNAL_FUNC(on_source_browse_button), NULL); gtk_widget_show(browse_button); gtk_box_pack_start(GTK_BOX(hbox2), browse_button, FALSE, FALSE, 5); // input menu inputIndex = 0; for (u_int8_t i = 0; i < sizeof(inputValues) / sizeof(u_int8_t); i++) { if (!strcasecmp(MyConfig->GetStringValue(CONFIG_AUDIO_INPUT_NAME), inputValues[i])) { inputIndex = i; break; } } input_menu = CreateOptionMenu (NULL, inputNames, sizeof(inputNames) / sizeof(char*), inputIndex, GTK_SIGNAL_FUNC(on_input_menu_activate)); gtk_box_pack_start(GTK_BOX(vbox), input_menu, TRUE, TRUE, 0); // track menu track_menu = NULL; track_menu = CreateTrackMenu( track_menu, 'A', gtk_entry_get_text(GTK_ENTRY(source_entry)), &trackIndex, &trackNumber, &trackValues); trackIndex = 0; for (u_int8_t i = 0; i < trackNumber; i++) { if (MyConfig->GetIntegerValue(CONFIG_AUDIO_SOURCE_TRACK) == trackValues[i]) { trackIndex = i; break; } } gtk_box_pack_start(GTK_BOX(vbox), track_menu, FALSE, FALSE, 0); // spacer label = gtk_label_new(" "); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_widget_show(label); gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0); encodingNames = (char **)malloc(sizeof(char *) * audio_encoder_table_size); audioEncoder = MyConfig->GetStringValue(CONFIG_AUDIO_ENCODER); for (uint32_t ix = 0; ix < audio_encoder_table_size; ix++) { encodingNames[ix] = strdup(audio_encoder_table[ix]->dialog_selection_name); if ((strcasecmp(audioEncoder, audio_encoder_table[ix]->audio_encoder) == 0) && (strcasecmp(MyConfig->GetStringValue(CONFIG_AUDIO_ENCODING), audio_encoder_table[ix]->audio_encoding) == 0)) { encodingIndex = ix; } } encoding_menu = CreateOptionMenu (NULL, encodingNames, audio_encoder_table_size, encodingIndex, GTK_SIGNAL_FUNC(on_encoding_menu_activate)); gtk_box_pack_start(GTK_BOX(vbox), encoding_menu, TRUE, TRUE, 0); // channel menu channel_menu = NULL; CreateChannelMenu(MyConfig->GetIntegerValue(CONFIG_AUDIO_CHANNELS)); gtk_box_pack_start(GTK_BOX(vbox), channel_menu, TRUE, TRUE, 0); sampling_rate_menu = NULL; CreateSamplingRateMenu(pAudioCaps); gtk_box_pack_start(GTK_BOX(vbox), sampling_rate_menu, TRUE, TRUE, 0); // set sampling rate value based on MyConfig SetSamplingRate(MyConfig->GetIntegerValue(CONFIG_AUDIO_SAMPLE_RATE)); bit_rate_menu = NULL; CreateBitRateMenu(MyConfig->GetIntegerValue(CONFIG_AUDIO_BIT_RATE)); gtk_box_pack_start(GTK_BOX(vbox), bit_rate_menu, TRUE, TRUE, 0); // set bit rate value based on MyConfig for (u_int8_t i = 0; i < bitRateNumber; i++) { if (MyConfig->GetIntegerValue(CONFIG_AUDIO_BIT_RATE) == bitRateValues[i]) { bitRateIndex = i; break; } } gtk_option_menu_set_history( GTK_OPTION_MENU(bit_rate_menu), bitRateIndex); // Add standard buttons at bottom button = AddButtonToDialog(dialog, " OK ", GTK_SIGNAL_FUNC(on_ok_button)); GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT); AddButtonToDialog(dialog, " Cancel ", GTK_SIGNAL_FUNC(on_cancel_button)); ShowSourceSpecificSettings(); gtk_widget_show(dialog); }
/** * gimp_unit_menu_new: * @format: A printf-like format string which is used to create the unit * strings. * @unit: The initially selected unit. * @show_pixels: %TRUE if the unit menu should contain an item for * GIMP_UNIT_PIXEL. * @show_percent: %TRUE in the unit menu should contain an item for * GIMP_UNIT_PERCENT. * @show_custom: %TRUE if the unit menu should contain a "More..." item for * opening the user-defined-unit selection dialog. * * Creates a new #GimpUnitMenu widget. * * For the @format string's possible expansions, see gimp_unit_format_string(). * * Returns: A pointer to the new #GimpUnitMenu widget. **/ GtkWidget * gimp_unit_menu_new (const gchar *format, GimpUnit unit, gboolean show_pixels, gboolean show_percent, gboolean show_custom) { GimpUnitMenu *unit_menu; GtkWidget *menu; GtkWidget *menuitem; gchar *string; GimpUnit u; g_return_val_if_fail (((unit >= GIMP_UNIT_PIXEL) && (unit < gimp_unit_get_number_of_units ())) || (unit == GIMP_UNIT_PERCENT), NULL); if ((unit >= gimp_unit_get_number_of_built_in_units ()) && (unit != GIMP_UNIT_PERCENT)) show_custom = TRUE; unit_menu = g_object_new (GIMP_TYPE_UNIT_MENU, NULL); unit_menu->format = g_strdup (format); unit_menu->show_pixels = show_pixels; unit_menu->show_percent = show_percent; menu = gtk_menu_new (); for (u = show_pixels ? GIMP_UNIT_PIXEL : GIMP_UNIT_INCH; u < gimp_unit_get_number_of_built_in_units (); u++) { /* special cases "pixels" and "percent" */ if (u == GIMP_UNIT_INCH) { if (show_percent) { string = gimp_unit_format_string (format, GIMP_UNIT_PERCENT); menuitem = gtk_menu_item_new_with_label (string); g_free (string); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); g_object_set_data (G_OBJECT (menuitem), "gimp_unit_menu", GINT_TO_POINTER (GIMP_UNIT_PERCENT)); gtk_widget_show (menuitem); g_signal_connect (menuitem, "activate", G_CALLBACK (gimp_unit_menu_callback), unit_menu); } if (show_pixels || show_percent) { menuitem = gtk_menu_item_new (); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); gtk_widget_set_sensitive (menuitem, FALSE); gtk_widget_show (menuitem); } } string = gimp_unit_format_string (format, u); menuitem = gtk_menu_item_new_with_label (string); g_free (string); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); g_object_set_data (G_OBJECT (menuitem), "gimp_unit_menu", GINT_TO_POINTER (u)); gtk_widget_show (menuitem); g_signal_connect (menuitem, "activate", G_CALLBACK (gimp_unit_menu_callback), unit_menu); } if ((unit >= gimp_unit_get_number_of_built_in_units ()) && (unit != GIMP_UNIT_PERCENT)) { menuitem = gtk_menu_item_new (); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); gtk_widget_set_sensitive (menuitem, FALSE); gtk_widget_show (menuitem); string = gimp_unit_format_string (format, unit); menuitem = gtk_menu_item_new_with_label (string); g_free (string); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); g_object_set_data (G_OBJECT (menuitem), "gimp_unit_menu", GINT_TO_POINTER (unit)); gtk_widget_show (menuitem); g_signal_connect (menuitem, "activate", G_CALLBACK (gimp_unit_menu_callback), unit_menu); } if (show_custom) { menuitem = gtk_menu_item_new (); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); gtk_widget_set_sensitive (menuitem, FALSE); gtk_widget_show (menuitem); menuitem = gtk_menu_item_new_with_label (_("More...")); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); g_object_set_data (G_OBJECT (menuitem), "gimp_unit_menu", GINT_TO_POINTER (GIMP_UNIT_PERCENT + 1)); gtk_widget_show (menuitem); g_signal_connect (menuitem, "activate", G_CALLBACK (gimp_unit_menu_callback), unit_menu); } gtk_option_menu_set_menu (GTK_OPTION_MENU (unit_menu), menu); unit_menu->unit = unit; gtk_option_menu_set_history (GTK_OPTION_MENU (unit_menu), (unit == GIMP_UNIT_PIXEL) ? 0 : ((unit == GIMP_UNIT_PERCENT) ? (show_pixels ? 1 : 0) : (((show_pixels || show_percent) ? 2 : 0) + ((show_pixels && show_percent) ? 1 : 0) + ((unit < GIMP_UNIT_END) ? (unit - 1) : GIMP_UNIT_END)))); return GTK_WIDGET (unit_menu); }
int GUI_subtitleParam(char *font,char *sub,int *charset,int *size,uint32_t *baseline, int32_t *coly,int32_t *colu,int32_t *colv) { int ret=0; gint answer; #define WID(x) lookup_widget(dialog,#x) dialog = create_dialog1(); if(sub) strcpy( subString, sub); if(font) strcpy( fontString, font); myY=*coly; myU=*colu; myV=*colv; gtk_label_set_text(GTK_LABEL(WID(label_sub)),sub); gtk_label_set_text(GTK_LABEL(WID(label_font)),font); gtk_spin_button_set_value(GTK_SPIN_BUTTON(WID(spinbutton_fontsize)),(gfloat)*size) ; int nb=sizeof(names)/sizeof(unicd); GtkWidget *w; for(uint32_t j=1;j<(uint32_t)nb;j++) { w = gtk_menu_item_new_with_mnemonic ( names[j].display ); gtk_widget_show (w); gtk_container_add (GTK_CONTAINER (WID(menu1)),w); } gtk_option_menu_set_history (GTK_OPTION_MENU (WID(optionmenu1)), *charset); gtk_signal_connect(GTK_OBJECT(WID(button_sub)), "clicked", GTK_SIGNAL_FUNC(on_callback_sub), (void *) 1); gtk_signal_connect(GTK_OBJECT(WID(button_font)), "clicked", GTK_SIGNAL_FUNC(on_callback_font), (void *) 1); gtk_signal_connect(GTK_OBJECT(WID(button_color)), "clicked", GTK_SIGNAL_FUNC(on_callback_color), (void *) 1); // Draw a green square to show where it's gonna be CHECKSPIN( WID(spinbutton_fontsize),glob_font); drawing=WID(drawingarea1); gtk_widget_set_usize(drawing, _w,_h); gtk_widget_show(dialog); glob_font=*size; glob_base=*baseline; sliderAdjustment=gtk_range_get_adjustment (GTK_RANGE(WID(vscale1))); gtk_adjustment_set_value( GTK_ADJUSTMENT(sliderAdjustment),( gdouble ) glob_base ); /*-------*/ gtk_signal_connect(GTK_OBJECT(sliderAdjustment),"value_changed", \ GTK_SIGNAL_FUNC(on_slider), NULL); /*-------*/ update(*baseline); draw(); gtk_signal_connect(GTK_OBJECT(WID(drawingarea1)), "expose_event", GTK_SIGNAL_FUNC(gui_draw), NULL); ret=0; while( (answer=gtk_dialog_run(GTK_DIALOG(dialog)))==GTK_RESPONSE_APPLY) { read(); update(glob_base); draw(); } if(answer==GTK_RESPONSE_OK) { strcpy(sub,subString); strcpy(font,fontString); *charset= getRangeInMenu(WID(optionmenu1));; read(); *size=glob_font; *baseline=glob_base; *coly=myY; *colu=myU; *colv=myV; ret=1; } gtk_widget_destroy(dialog); dialog=NULL; return ret; }
GtkWidget * gr_vector_list (SPDesktop *desktop, bool selection_empty, SPGradient *gr_selected, bool gr_multi) { SPDocument *document = sp_desktop_document (desktop); GtkWidget *om = gtk_option_menu_new (); GtkWidget *m = gtk_menu_new (); GSList *gl = NULL; const GSList *gradients = sp_document_get_resource_list (document, "gradient"); for (const GSList *i = gradients; i != NULL; i = i->next) { if (SP_GRADIENT_HAS_STOPS (i->data)) { gl = g_slist_prepend (gl, i->data); } } gl = g_slist_reverse (gl); guint pos = 0; guint idx = 0; if (!gl) { GtkWidget *l = gtk_label_new(""); gtk_label_set_markup (GTK_LABEL(l), _("<small>No gradients</small>")); GtkWidget *i = gtk_menu_item_new (); gtk_container_add (GTK_CONTAINER (i), l); gtk_widget_show (i); gtk_menu_append (GTK_MENU (m), i); gtk_widget_set_sensitive (om, FALSE); } else if (selection_empty) { GtkWidget *l = gtk_label_new(""); gtk_label_set_markup (GTK_LABEL(l), _("<small>Nothing selected</small>")); GtkWidget *i = gtk_menu_item_new (); gtk_container_add (GTK_CONTAINER (i), l); gtk_widget_show (i); gtk_menu_append (GTK_MENU (m), i); gtk_widget_set_sensitive (om, FALSE); } else { if (gr_selected == NULL) { GtkWidget *l = gtk_label_new(""); gtk_label_set_markup (GTK_LABEL(l), _("<small>No gradients in selection</small>")); GtkWidget *i = gtk_menu_item_new (); gtk_container_add (GTK_CONTAINER (i), l); gtk_widget_show (i); gtk_menu_append (GTK_MENU (m), i); } if (gr_multi) { GtkWidget *l = gtk_label_new(""); gtk_label_set_markup (GTK_LABEL(l), _("<small>Multiple gradients</small>")); GtkWidget *i = gtk_menu_item_new (); gtk_container_add (GTK_CONTAINER (i), l); gtk_widget_show (i); gtk_menu_append (GTK_MENU (m), i); } while (gl) { SPGradient *gradient = SP_GRADIENT (gl->data); gl = g_slist_remove (gl, gradient); GtkWidget *i = gtk_menu_item_new (); g_object_set_data (G_OBJECT (i), "gradient", gradient); g_signal_connect (G_OBJECT (i), "activate", G_CALLBACK (gr_item_activate), desktop); GtkWidget *image = sp_gradient_image_new (gradient); GtkWidget *hb = gtk_hbox_new (FALSE, 4); GtkWidget *l = gtk_label_new (""); gchar *label = gr_prepare_label (SP_OBJECT(gradient)); gtk_label_set_markup (GTK_LABEL(l), label); g_free (label); gtk_misc_set_alignment (GTK_MISC (l), 1.0, 0.5); gtk_box_pack_start (GTK_BOX (hb), l, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (hb), image, FALSE, FALSE, 0); gtk_widget_show_all (i); gtk_container_add (GTK_CONTAINER (i), hb); gtk_menu_append (GTK_MENU (m), i); if (gradient == gr_selected) { pos = idx; } idx ++; } gtk_widget_set_sensitive (om, TRUE); } gtk_option_menu_set_menu (GTK_OPTION_MENU (om), m); /* Select the current gradient, or the Multi/Nothing line */ if (gr_multi || gr_selected == NULL) gtk_option_menu_set_history (GTK_OPTION_MENU (om), 0); else gtk_option_menu_set_history (GTK_OPTION_MENU (om), pos); return om; }
gint main (gint argc, gchar **argv) { GtkWidget *window, *toolbar, *table, *treeview, *scrolled_window; GtkWidget *hbox, *hbox1, *hbox2, *checkbox, *option_menu, *menu; gint i; static const gchar *toolbar_styles[] = { "icons", "text", "both (vertical)", "both (horizontal)" }; GtkToolItem *item; GtkListStore *store; GtkWidget *image; GtkWidget *menuitem; GtkWidget *button; GtkWidget *label; GIcon *gicon; GSList *group; gtk_init (&argc, &argv); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); g_signal_connect (window, "destroy", G_CALLBACK(gtk_main_quit), NULL); table = gtk_table_new (4, 2, FALSE); gtk_container_add (GTK_CONTAINER (window), table); toolbar = gtk_toolbar_new (); gtk_table_attach (GTK_TABLE (table), toolbar, 0,2, 0,1, GTK_FILL|GTK_EXPAND, GTK_FILL, 0, 0); hbox1 = gtk_hbox_new (FALSE, 3); gtk_container_set_border_width (GTK_CONTAINER (hbox1), 5); gtk_table_attach (GTK_TABLE (table), hbox1, 1,2, 1,2, GTK_FILL|GTK_EXPAND, GTK_FILL, 0, 0); hbox2 = gtk_hbox_new (FALSE, 2); gtk_container_set_border_width (GTK_CONTAINER (hbox2), 5); gtk_table_attach (GTK_TABLE (table), hbox2, 1,2, 2,3, GTK_FILL|GTK_EXPAND, GTK_FILL, 0, 0); checkbox = gtk_check_button_new_with_mnemonic("_Vertical"); gtk_box_pack_start (GTK_BOX (hbox1), checkbox, FALSE, FALSE, 0); g_signal_connect (checkbox, "toggled", G_CALLBACK (change_orientation), toolbar); checkbox = gtk_check_button_new_with_mnemonic("_Show Arrow"); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbox), TRUE); gtk_box_pack_start (GTK_BOX (hbox1), checkbox, FALSE, FALSE, 0); g_signal_connect (checkbox, "toggled", G_CALLBACK (change_show_arrow), toolbar); checkbox = gtk_check_button_new_with_mnemonic("_Set Toolbar Style:"); g_signal_connect (checkbox, "toggled", G_CALLBACK (set_toolbar_style_toggled), toolbar); gtk_box_pack_start (GTK_BOX (hbox1), checkbox, FALSE, FALSE, 0); option_menu = gtk_option_menu_new(); gtk_widget_set_sensitive (option_menu, FALSE); g_object_set_data (G_OBJECT (checkbox), "option-menu", option_menu); menu = gtk_menu_new(); for (i = 0; i < G_N_ELEMENTS (toolbar_styles); i++) { GtkWidget *menuitem; menuitem = gtk_menu_item_new_with_label (toolbar_styles[i]); gtk_container_add (GTK_CONTAINER (menu), menuitem); gtk_widget_show (menuitem); } gtk_option_menu_set_menu (GTK_OPTION_MENU (option_menu), menu); gtk_option_menu_set_history (GTK_OPTION_MENU (option_menu), GTK_TOOLBAR (toolbar)->style); gtk_box_pack_start (GTK_BOX (hbox2), option_menu, FALSE, FALSE, 0); g_signal_connect (option_menu, "changed", G_CALLBACK (change_toolbar_style), toolbar); checkbox = gtk_check_button_new_with_mnemonic("_Set Icon Size:"); g_signal_connect (checkbox, "toggled", G_CALLBACK (set_icon_size_toggled), toolbar); gtk_box_pack_start (GTK_BOX (hbox2), checkbox, FALSE, FALSE, 0); option_menu = gtk_option_menu_new(); g_object_set_data (G_OBJECT (checkbox), "option-menu", option_menu); gtk_widget_set_sensitive (option_menu, FALSE); menu = gtk_menu_new(); menuitem = gtk_menu_item_new_with_label ("small toolbar"); g_object_set_data (G_OBJECT (menuitem), "value-id", GINT_TO_POINTER (GTK_ICON_SIZE_SMALL_TOOLBAR)); gtk_container_add (GTK_CONTAINER (menu), menuitem); gtk_widget_show (menuitem); menuitem = gtk_menu_item_new_with_label ("large toolbar"); g_object_set_data (G_OBJECT (menuitem), "value-id", GINT_TO_POINTER (GTK_ICON_SIZE_LARGE_TOOLBAR)); gtk_container_add (GTK_CONTAINER (menu), menuitem); gtk_widget_show (menuitem); gtk_option_menu_set_menu (GTK_OPTION_MENU (option_menu), menu); gtk_box_pack_start (GTK_BOX (hbox2), option_menu, FALSE, FALSE, 0); g_signal_connect (option_menu, "changed", G_CALLBACK (icon_size_history_changed), toolbar); scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_table_attach (GTK_TABLE (table), scrolled_window, 1,2, 3,4, GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 0, 0); store = create_items_list (&treeview); gtk_container_add (GTK_CONTAINER (scrolled_window), treeview); item = gtk_tool_button_new_from_stock (GTK_STOCK_NEW); gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Custom label"); gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), NULL); add_item_to_list (store, item, "New"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); gdk_threads_add_timeout (3000, (GSourceFunc) timeout_cb, item); gtk_tool_item_set_expand (item, TRUE); menu = gtk_menu_new (); for (i = 0; i < 20; i++) { char *text; text = g_strdup_printf ("Menuitem %d", i); menuitem = gtk_menu_item_new_with_label (text); g_free (text); gtk_widget_show (menuitem); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); } item = gtk_menu_tool_button_new_from_stock (GTK_STOCK_OPEN); gtk_menu_tool_button_set_menu (GTK_MENU_TOOL_BUTTON (item), menu); add_item_to_list (store, item, "Open"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); gdk_threads_add_timeout (3000, (GSourceFunc) timeout_cb1, item); menu = gtk_menu_new (); for (i = 0; i < 20; i++) { char *text; text = g_strdup_printf ("A%d", i); menuitem = gtk_menu_item_new_with_label (text); g_free (text); gtk_widget_show (menuitem); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); } item = gtk_menu_tool_button_new_from_stock (GTK_STOCK_GO_BACK); gtk_menu_tool_button_set_menu (GTK_MENU_TOOL_BUTTON (item), menu); add_item_to_list (store, item, "BackWithHistory"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); item = gtk_separator_tool_item_new (); add_item_to_list (store, item, "-----"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); item = gtk_tool_button_new_from_stock (GTK_STOCK_REFRESH); add_item_to_list (store, item, "Refresh"); g_signal_connect (item, "clicked", G_CALLBACK (reload_clicked), NULL); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_WARNING, GTK_ICON_SIZE_DIALOG); item = gtk_tool_item_new (); gtk_widget_show (image); gtk_container_add (GTK_CONTAINER (item), image); add_item_to_list (store, item, "(Custom Item)"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); item = gtk_tool_button_new_from_stock (GTK_STOCK_GO_BACK); add_item_to_list (store, item, "Back"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); item = gtk_separator_tool_item_new (); add_item_to_list (store, item, "-----"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); item = gtk_tool_button_new_from_stock (GTK_STOCK_GO_FORWARD); add_item_to_list (store, item, "Forward"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); item = gtk_toggle_tool_button_new_from_stock (GTK_STOCK_BOLD); g_signal_connect (item, "toggled", G_CALLBACK (bold_toggled), NULL); add_item_to_list (store, item, "Bold"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); gtk_widget_set_sensitive (GTK_WIDGET (item), FALSE); item = gtk_separator_tool_item_new (); add_item_to_list (store, item, "-----"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); gtk_tool_item_set_expand (item, TRUE); gtk_separator_tool_item_set_draw (GTK_SEPARATOR_TOOL_ITEM (item), FALSE); g_assert (gtk_toolbar_get_nth_item (GTK_TOOLBAR (toolbar), 0) != 0); item = gtk_radio_tool_button_new_from_stock (NULL, GTK_STOCK_JUSTIFY_LEFT); group = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (item)); add_item_to_list (store, item, "Left"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); item = gtk_radio_tool_button_new_from_stock (group, GTK_STOCK_JUSTIFY_CENTER); make_prop_editor (G_OBJECT (item)); group = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (item)); add_item_to_list (store, item, "Center"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); item = gtk_radio_tool_button_new_from_stock (group, GTK_STOCK_JUSTIFY_RIGHT); add_item_to_list (store, item, "Right"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); item = gtk_tool_button_new (gtk_image_new_from_file ("apple-red.png"), "_Apple"); add_item_to_list (store, item, "Apple"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); gtk_tool_button_set_use_underline (GTK_TOOL_BUTTON (item), TRUE); gicon = g_content_type_get_icon ("video/ogg"); image = gtk_image_new_from_gicon (gicon, GTK_ICON_SIZE_LARGE_TOOLBAR); g_object_unref (gicon); item = gtk_tool_button_new (image, "Video"); add_item_to_list (store, item, "Video"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); image = gtk_image_new_from_icon_name ("utility-terminal", GTK_ICON_SIZE_LARGE_TOOLBAR); item = gtk_tool_button_new (image, "Terminal"); add_item_to_list (store, item, "Terminal"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); hbox = gtk_hbox_new (FALSE, 5); gtk_container_set_border_width (GTK_CONTAINER (hbox), 5); gtk_table_attach (GTK_TABLE (table), hbox, 1,2, 4,5, GTK_FILL|GTK_EXPAND, GTK_FILL, 0, 0); button = gtk_button_new_with_label ("Drag me to the toolbar"); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); label = gtk_label_new ("Drop index:"); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); label = gtk_label_new (""); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); checkbox = gtk_check_button_new_with_mnemonic("_Right to left"); if (gtk_widget_get_default_direction () == GTK_TEXT_DIR_RTL) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbox), TRUE); else gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbox), FALSE); g_signal_connect (checkbox, "toggled", G_CALLBACK (rtl_toggled), NULL); gtk_box_pack_end (GTK_BOX (hbox), checkbox, FALSE, FALSE, 0); gtk_drag_source_set (button, GDK_BUTTON1_MASK, target_table, G_N_ELEMENTS (target_table), GDK_ACTION_MOVE); gtk_drag_dest_set (toolbar, GTK_DEST_DEFAULT_DROP, target_table, G_N_ELEMENTS (target_table), GDK_ACTION_MOVE); g_signal_connect (toolbar, "drag_motion", G_CALLBACK (toolbar_drag_motion), NULL); g_signal_connect (toolbar, "drag_leave", G_CALLBACK (toolbar_drag_leave), NULL); g_signal_connect (toolbar, "drag_drop", G_CALLBACK (toolbar_drag_drop), label); gtk_widget_show_all (window); make_prop_editor (G_OBJECT (toolbar)); g_signal_connect (window, "delete_event", G_CALLBACK (gtk_main_quit), NULL); g_signal_connect (toolbar, "popup_context_menu", G_CALLBACK (popup_context_menu), NULL); gtk_main (); return 0; }
static void wireless_applet_properties_dialog (BonoboUIComponent *uic, WirelessApplet *applet) { static GtkWidget *global_property_box = NULL, *glade_property_box = NULL; GtkWidget *pct, *dialog, *device; g_return_if_fail (PANEL_IS_APPLET (PANEL_APPLET (applet))); if (applet->prefs != NULL) { gtk_widget_show (applet->prefs); gtk_window_present (GTK_WINDOW (applet->prefs)); return; } if (global_property_box == NULL) { xml = glade_xml_new (glade_file, NULL, NULL); glade_property_box = glade_xml_get_widget (xml,"dialog1"); } applet->prefs = glade_property_box; gtk_window_set_resizable (GTK_WINDOW (applet->prefs), FALSE); pct = glade_xml_get_widget (xml, "pct_check_button"); dialog = glade_xml_get_widget (xml, "dialog_check_button"); device = glade_xml_get_widget (xml, "device_menu"); /* Set the show-percent thingy */ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pct), applet->show_percent); g_signal_connect (GTK_OBJECT (pct), "toggled", GTK_SIGNAL_FUNC (wireless_applet_option_change), applet); gtk_object_set_data (GTK_OBJECT (applet->prefs), "show-percent-button", pct); /* Set the device menu */ gtk_option_menu_remove_menu (GTK_OPTION_MENU (device)); { GtkWidget *menu; GtkWidget *item; GList *d; int idx = 0, choice = 0; menu = gtk_menu_new (); for (d = applet->devices; d != NULL; d = g_list_next (d)) { item = gtk_menu_item_new_with_label ((char*)d->data); gtk_menu_shell_append (GTK_MENU_SHELL (menu),item); gtk_object_set_data_full (GTK_OBJECT (item), "device-selected", g_strdup (d->data), g_free); g_signal_connect (GTK_OBJECT (item), "activate", GTK_SIGNAL_FUNC (wireless_applet_option_change), applet); if ((applet->device != NULL) && (d->data != NULL) && strcmp (applet->device, d->data)==0) { choice = idx; } idx++; } if (applet->devices == NULL) { char *markup; GtkWidget *label; label = gtk_label_new (NULL); markup = g_strdup_printf ("<i>%s</i>", _("No Wireless Devices")); gtk_label_set_markup (GTK_LABEL (label), markup); g_free (markup); item = gtk_menu_item_new (); gtk_container_add (GTK_CONTAINER (item), label); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); } gtk_option_menu_set_menu (GTK_OPTION_MENU (device), menu); gtk_option_menu_set_history (GTK_OPTION_MENU (device), choice); } gtk_object_set_data (GTK_OBJECT (applet->prefs), "device-menu", device); g_signal_connect (GTK_OBJECT (applet->prefs), "response", G_CALLBACK (prefs_response_cb), NULL); g_signal_connect (GTK_OBJECT (applet->prefs), "destroy", GTK_SIGNAL_FUNC (gtk_widget_destroy), NULL); g_object_add_weak_pointer (G_OBJECT (applet->prefs), (void**)&(applet->prefs)); gtk_window_set_screen (GTK_WINDOW (applet->prefs), gtk_widget_get_screen (GTK_WIDGET (applet))); gtk_widget_show_all (applet->prefs); }
void sp_display_dialog (void) { GtkWidget *nb, *l, *vb, *hb, *om, *m, *i, *sb; GtkObject *a; if (!dlg) { gchar title[500]; sp_ui_dialog_title_string (SP_VERB_DIALOG_DISPLAY, title); dlg = sp_window_new (title, TRUE); if (x == -1000 || y == -1000) { x = prefs_get_int_attribute (prefs_path, "x", 0); y = prefs_get_int_attribute (prefs_path, "y", 0); } if (w ==0 || h == 0) { w = prefs_get_int_attribute (prefs_path, "w", 0); h = prefs_get_int_attribute (prefs_path, "h", 0); } if (x != 0 || y != 0) gtk_window_move ((GtkWindow *) dlg, x, y); else gtk_window_set_position(GTK_WINDOW(dlg), GTK_WIN_POS_CENTER); if (w && h) gtk_window_resize ((GtkWindow *) dlg, w, h); sp_transientize (dlg); wd.win = dlg; wd.stop = 0; g_signal_connect (G_OBJECT (INKSCAPE), "activate_desktop", G_CALLBACK (sp_transientize_callback), &wd); gtk_signal_connect (GTK_OBJECT (dlg), "event", GTK_SIGNAL_FUNC (sp_dialog_event_handler), dlg); gtk_signal_connect (GTK_OBJECT (dlg), "destroy", G_CALLBACK (sp_display_dialog_destroy), dlg); gtk_signal_connect (GTK_OBJECT (dlg), "delete_event", G_CALLBACK (sp_display_dialog_delete), dlg); g_signal_connect (G_OBJECT (INKSCAPE), "shut_down", G_CALLBACK (sp_display_dialog_delete), dlg); nb = gtk_notebook_new (); gtk_widget_show (nb); gtk_container_add (GTK_CONTAINER (dlg), nb); /* Rendering settings */ /* Notebook tab */ l = gtk_label_new (_("Rendering")); gtk_widget_show (l); vb = gtk_vbox_new (FALSE, 4); gtk_widget_show (vb); gtk_container_set_border_width (GTK_CONTAINER (vb), 4); gtk_notebook_append_page (GTK_NOTEBOOK (nb), vb, l); /* Oversampling menu */ hb = gtk_hbox_new (FALSE, 4); gtk_widget_show (hb); gtk_box_pack_start (GTK_BOX (vb), hb, FALSE, FALSE, 0); l = gtk_label_new (_("Oversample bitmaps:")); gtk_misc_set_alignment (GTK_MISC (l), 1.0, 0.5); gtk_widget_show (l); gtk_box_pack_start (GTK_BOX (hb), l, FALSE, FALSE, 0); om = gtk_option_menu_new (); gtk_widget_show (om); gtk_box_pack_start (GTK_BOX (hb), om, TRUE, TRUE, 0); m = gtk_menu_new (); gtk_widget_show (m); i = gtk_menu_item_new_with_label (_("None")); gtk_signal_connect (GTK_OBJECT (i), "activate", GTK_SIGNAL_FUNC (sp_display_dialog_set_oversample), GINT_TO_POINTER (0)); gtk_widget_show (i); gtk_menu_append (GTK_MENU (m), i); i = gtk_menu_item_new_with_label (_("2x2")); gtk_signal_connect (GTK_OBJECT (i), "activate", GTK_SIGNAL_FUNC (sp_display_dialog_set_oversample), GINT_TO_POINTER (1)); gtk_widget_show (i); gtk_menu_append (GTK_MENU (m), i); i = gtk_menu_item_new_with_label (_("4x4")); gtk_signal_connect (GTK_OBJECT (i), "activate", GTK_SIGNAL_FUNC (sp_display_dialog_set_oversample), GINT_TO_POINTER (2)); gtk_widget_show (i); gtk_menu_append (GTK_MENU (m), i); i = gtk_menu_item_new_with_label (_("8x8")); gtk_signal_connect (GTK_OBJECT (i), "activate", GTK_SIGNAL_FUNC (sp_display_dialog_set_oversample), GINT_TO_POINTER (3)); gtk_widget_show (i); gtk_menu_append (GTK_MENU (m), i); i = gtk_menu_item_new_with_label (_("16x16")); gtk_signal_connect (GTK_OBJECT (i), "activate", GTK_SIGNAL_FUNC (sp_display_dialog_set_oversample), GINT_TO_POINTER (4)); gtk_widget_show (i); gtk_menu_append (GTK_MENU (m), i); gtk_option_menu_set_menu (GTK_OPTION_MENU (om), m); gtk_option_menu_set_history (GTK_OPTION_MENU (om), nr_arena_image_x_sample); /* Input settings */ /* Notebook tab */ l = gtk_label_new (_("Input")); gtk_widget_show (l); vb = gtk_vbox_new (FALSE, 4); gtk_widget_show (vb); gtk_container_set_border_width (GTK_CONTAINER (vb), 4); gtk_notebook_append_page (GTK_NOTEBOOK (nb), vb, l); hb = gtk_hbox_new (FALSE, 4); gtk_widget_show (hb); gtk_box_pack_start (GTK_BOX (vb), hb, FALSE, FALSE, 0); l = gtk_label_new (_("Default cursor tolerance:")); gtk_misc_set_alignment (GTK_MISC (l), 1.0, 0.5); gtk_widget_show (l); gtk_box_pack_start (GTK_BOX (hb), l, FALSE, FALSE, 0); a = gtk_adjustment_new (0.0, 0.0, 10.0, 0.1, 1.0, 1.0); gtk_adjustment_set_value (GTK_ADJUSTMENT (a), nr_arena_global_delta); sb = gtk_spin_button_new (GTK_ADJUSTMENT (a), 0.1, 1); gtk_widget_show (sb); gtk_box_pack_start (GTK_BOX (hb), sb, TRUE, TRUE, 0); gtk_signal_connect (GTK_OBJECT (a), "value_changed", GTK_SIGNAL_FUNC (sp_display_dialog_cursor_tolerance_changed), NULL); } gtk_window_present ((GtkWindow *) dlg); }
GtkWidget * make_menu2(char *selected) { int i; struct state state; #ifdef USE_COMBOBOX GtkTreeStore *store = gtk_tree_store_new(N_COLUMNS, /* Total number of columns */ G_TYPE_STRING); /* Timezone */ GtkWidget *tree; GtkCellRenderer *renderer; GtkTreeIter iter1, iter2; gtk_tree_store_append(store, &iter1, NULL); /* Acquire an iterator */ gtk_tree_store_set(store, &iter1, STRING_COLUMN, DISABLED_STRING, -1); gtk_tree_store_append(store, &iter1, NULL); /* Acquire an iterator */ gtk_tree_store_set(store, &iter1, STRING_COLUMN, DEFAULT_STRING, -1); gtk_tree_store_append(store, &iter2, &iter1); gtk_tree_store_set(store, &iter1, STRING_COLUMN, MORE_STRING, -1); state.store = store; state.extra = &iter1; #else GtkWidget *menu; GtkWidget *optionmenu, *menuitem, *selection; menu = gtk_menu_new(); menuitem = gtk_menu_item_new_with_label(selected); gtk_menu_append(menu, menuitem); selection = menuitem; menuitem = gtk_menu_item_new_with_label(DISABLED_STRING); g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(menu_select_cb), menu); gtk_menu_append(menu, menuitem); menuitem = gtk_menu_item_new_with_label(DEFAULT_STRING); g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(menu_select_cb), menu); gtk_menu_append(menu, menuitem); menuitem = gtk_menu_item_new_with_label(MORE_STRING); gtk_menu_append(menu, menuitem); state.base = menu; state.extra = gtk_menu_new(); gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), state.extra); #endif state.currdepth = 0; recurse_directory("/usr/share/zoneinfo", (DirRecurseMatch) make_menu_cb, &state); for (i = 0; i < state.currdepth; i++) g_free(state.stack[i].string); #ifdef USE_COMBOBOX tree = gtk_combo_box_new_with_model(GTK_TREE_MODEL(store)); renderer = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(tree), renderer, TRUE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(tree), renderer, "text", 0, NULL); gtk_widget_show_all(tree); return tree; #else optionmenu = gtk_option_menu_new(); gtk_option_menu_set_menu(GTK_OPTION_MENU(optionmenu), menu); gtk_widget_show_all(optionmenu); if(strcmp(selected, "") == 0) { gtk_option_menu_set_history(GTK_OPTION_MENU(optionmenu), 2); gtk_widget_hide(selection); } else if(strcmp(selected, "none") == 0) { gtk_option_menu_set_history(GTK_OPTION_MENU(optionmenu), 1); gtk_widget_hide(selection); } else { gtk_option_menu_set_history(GTK_OPTION_MENU(optionmenu), 0); } return optionmenu; #endif }
/* * GetFilename * * Show a dialog with a title and if "Ok" is selected * call the function with the name of the file. */ void GetFilename (char *sTitle, void (*callback) (char *),char *selected, char *filter, int opid) { typFileSelectionData *data; GtkWidget *filterbutton; GtkWidget *optionmenu1, *optionmenu1_menu, *menuitem; filew=NULL; tbflag=TRUE; /* --- Create a new file selection widget --- */ filew = gtk_file_selection_new (sTitle); gtk_file_selection_show_fileop_buttons(GTK_FILE_SELECTION(filew)); data = g_malloc (sizeof (typFileSelectionData)); data->func = callback; data->filesel = filew; data->opid = opid; gtk_file_selection_set_filename(GTK_FILE_SELECTION(filew),selected); gtk_signal_connect (GTK_OBJECT (filew), "destroy", (GtkSignalFunc) destroy, data); ///////////////////////////////////////////////////////////////// *filt=0; strcat(filt, "show only "); strcat(filt, filter); strcat(filt, " files / show all"); if (strcmp(filter,"*.ats")==0) { filterbutton= gtk_button_new_with_label (filt); *filt=0; filt = g_strdup (filter); gtk_box_pack_start (GTK_BOX(GTK_FILE_SELECTION(filew)->action_area), filterbutton, TRUE, TRUE, 0); gtk_widget_show(filterbutton); gtk_signal_connect (GTK_OBJECT (filterbutton), "clicked",GTK_SIGNAL_FUNC(set_filter),(char *)filt); } if (strcmp(filter,"*.apf")==0) { filterbutton= gtk_button_new_with_label (filt); *filt=0; filt = g_strdup (filter); gtk_box_pack_start (GTK_BOX(GTK_FILE_SELECTION(filew)->action_area), filterbutton, TRUE, TRUE, 0); gtk_widget_show(filterbutton); gtk_signal_connect (GTK_OBJECT (filterbutton), "clicked",GTK_SIGNAL_FUNC(set_filter),(char *)filt); } if (strcmp(filter,"*.wav")==0 || strcmp(filter,"*.aif")==0 || strcmp(filter,"*.snd")==0 ) { if(opid!=RES_OUTSEL) { ////////OPTION MENU/////////////////////////////////////// optionmenu1 = gtk_option_menu_new (); gtk_widget_ref (optionmenu1); gtk_object_set_data_full (GTK_OBJECT (filew), "optionmenu1", optionmenu1, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (optionmenu1); gtk_box_pack_start (GTK_BOX(GTK_FILE_SELECTION(filew)->action_area),optionmenu1, TRUE, TRUE, 0); optionmenu1_menu = gtk_menu_new (); menuitem = create_men_snd("16 bits shorts WAV file", 0, optionmenu1_menu); menuitem = create_men_snd("32 bits floats WAV file", 1, optionmenu1_menu); menuitem = create_men_snd("16 bits shorts AIF file", 2, optionmenu1_menu); menuitem = create_men_snd("16 bits shorts SND file", 3, optionmenu1_menu); gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu1), optionmenu1_menu); gtk_option_menu_set_history (GTK_OPTION_MENU (optionmenu1), (int)outype); gtk_widget_set_usize (optionmenu1, 100, 25); } else { //residual output soundfile can only be WAV filterbutton= gtk_button_new_with_label (filt); *filt=0; filt = g_strdup (filter); gtk_box_pack_start (GTK_BOX(GTK_FILE_SELECTION(filew)->action_area), filterbutton, TRUE, TRUE, 0); gtk_widget_show(filterbutton); gtk_signal_connect (GTK_OBJECT (filterbutton), "clicked",GTK_SIGNAL_FUNC(set_filter),(char *)filt); } } //////////////////////////////////////////////////////////// slabel= gtk_label_new (selected); gtk_box_pack_start (GTK_BOX(GTK_FILE_SELECTION(filew)->action_area), slabel, TRUE, TRUE, 0); gtk_widget_show(slabel); /* --- Connect the "ok" button --- */ gtk_signal_connect(GTK_OBJECT (GTK_FILE_SELECTION (filew)->ok_button), "clicked", (GtkSignalFunc) FileOk, data); /* --- Connect the cancel button --- */ gtk_signal_connect_object ( GTK_OBJECT (GTK_FILE_SELECTION (filew)->cancel_button), "clicked", (GtkSignalFunc) gtk_widget_destroy, (gpointer) filew); gtk_window_set_position(GTK_WINDOW(filew),GTK_WIN_POS_CENTER); /* --- Show the dialog --- */ gtk_widget_show (filew); /* --- Grab the focus. --- */ gtk_grab_add (filew); }
void layer_dialog_update_diagram_list(void) { GtkWidget *new_menu; GtkWidget *menu_item; GList *dia_list; Diagram *dia; char *filename; int i; int current_nr; if (layer_dialog == NULL || layer_dialog->dialog == NULL) { if (!dia_open_diagrams()) return; /* shortcut; maybe session end w/o this dialog */ else create_layer_dialog(); } /* oh this options: here integrated UI ;( */ if (!layer_dialog->diagram_omenu) return; new_menu = gtk_menu_new(); current_nr = -1; i = 0; dia_list = dia_open_diagrams(); while (dia_list != NULL) { dia = (Diagram *) dia_list->data; if (dia == layer_dialog->diagram) { current_nr = i; } filename = strrchr(dia->filename, G_DIR_SEPARATOR); if (filename==NULL) { filename = dia->filename; } else { filename++; } menu_item = gtk_menu_item_new_with_label(filename); g_signal_connect (GTK_OBJECT (menu_item), "activate", (GtkSignalFunc) layer_dialog_select_diagram_callback, (gpointer) dia); gtk_menu_append( GTK_MENU(new_menu), menu_item); gtk_widget_show (menu_item); dia_list = g_list_next(dia_list); i++; } if (dia_open_diagrams()==NULL) { menu_item = gtk_menu_item_new_with_label (_("none")); g_signal_connect (GTK_OBJECT (menu_item), "activate", (GtkSignalFunc) layer_dialog_select_diagram_callback, (gpointer) NULL); gtk_menu_append( GTK_MENU(new_menu), menu_item); gtk_widget_show (menu_item); } gtk_option_menu_remove_menu(GTK_OPTION_MENU(layer_dialog->diagram_omenu)); gtk_option_menu_set_menu(GTK_OPTION_MENU(layer_dialog->diagram_omenu), new_menu); gtk_option_menu_set_history(GTK_OPTION_MENU(layer_dialog->diagram_omenu), current_nr); gtk_menu_set_active(GTK_MENU(new_menu), current_nr); if (current_nr == -1) { dia = NULL; if (dia_open_diagrams()!=NULL) { dia = (Diagram *) dia_open_diagrams()->data; } layer_dialog_set_diagram(dia); } }
void sheets_optionmenu_create(GtkWidget *option_menu, GtkWidget *wrapbox, gchar *sheet_name) { GtkWidget *optionmenu_menu; GSList *sheets_list; GList *menu_item_list; /* Delete the contents, if any, of this optionemnu first */ optionmenu_menu = gtk_option_menu_get_menu(GTK_OPTION_MENU(option_menu)); gtk_container_foreach(GTK_CONTAINER(optionmenu_menu), (GtkCallback)gtk_widget_destroy, NULL); for (sheets_list = sheets_mods_list; sheets_list; sheets_list = g_slist_next(sheets_list)) { SheetMod *sheet_mod; GtkWidget *menu_item; gchar *tip; sheet_mod = sheets_list->data; /* We don't display sheets which have been deleted prior to Apply */ if (sheet_mod->mod == SHEETMOD_MOD_DELETED) continue; { menu_item = gtk_menu_item_new_with_label(gettext(sheet_mod->sheet.name)); gtk_menu_append(GTK_MENU(optionmenu_menu), menu_item); if (sheet_mod->sheet.scope == SHEET_SCOPE_SYSTEM) tip = g_strdup_printf(_("%s\nSystem sheet"), sheet_mod->sheet.description); else tip = g_strdup_printf(_("%s\nUser sheet"), sheet_mod->sheet.description); gtk_widget_set_tooltip_text(menu_item, tip); g_free(tip); } gtk_widget_show(menu_item); g_object_set_data(G_OBJECT(menu_item), "wrapbox", wrapbox); g_signal_connect(G_OBJECT(menu_item), "activate", G_CALLBACK(on_sheets_dialog_optionmenu_activate), (gpointer)sheet_mod); } menu_item_list = gtk_container_get_children(GTK_CONTAINER(optionmenu_menu)); /* If we were passed a sheet_name, then make the optionmenu point to that name after creation */ if (sheet_name) { gint index = 0; GList *list; list = g_list_find_custom(menu_item_list, sheet_name, menu_item_compare_labels); if (list) index = g_list_position(menu_item_list, list); gtk_option_menu_set_history(GTK_OPTION_MENU(option_menu), index); gtk_menu_item_activate(GTK_MENU_ITEM(g_list_nth_data(menu_item_list, index))); } else { gtk_option_menu_set_history(GTK_OPTION_MENU(option_menu), 0); gtk_menu_item_activate(GTK_MENU_ITEM(menu_item_list->data)); } g_list_free(menu_item_list); }
static void netselect_dlg_show() { struct netselect_dlg * dlg; GtkWidget * main_vbox, * scrolled, * button_box, * manual_hbox, * hbox, * vbox, * frame, * settings_vbox; GtkTreeViewColumn * column; gchar * text; if(main_netselect_dlg) { /* dialog is shown already */ gtk_window_present(GTK_WINDOW(dlg->dlg_w)); return; } dlg = main_netselect_dlg = g_new(struct netselect_dlg, 1); dlg->detect_timeout_id = 0; dlg->dlg_w = gtk_dialog_new_with_buttons( _("Network detection and configuration"), gui_get_main_window(), 0, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); g_signal_connect(G_OBJECT(dlg->dlg_w), "response", G_CALLBACK(dlg_response), (gpointer)dlg); g_signal_connect(G_OBJECT(dlg->dlg_w), "delete-event", G_CALLBACK(gtk_true), NULL); /* upper vertical box for list and port range controls */ main_vbox = gtk_vbox_new(FALSE, 4); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dlg->dlg_w)->vbox), main_vbox, TRUE, TRUE, 0); frame = gtk_frame_new(_("Detected networks")); gtk_container_set_border_width(GTK_CONTAINER(frame), 2); gtk_box_pack_start(GTK_BOX(main_vbox), frame, TRUE, TRUE, 0); dlg->list = gtk_list_store_new( NETLISTCOL_NUM, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_BOOLEAN); dlg->tree_w = gtk_tree_view_new_with_model(GTK_TREE_MODEL(dlg->list)); g_signal_connect(G_OBJECT(dlg->tree_w), "row-activated", G_CALLBACK(list_row_activated), (gpointer)dlg); g_signal_connect(G_OBJECT(dlg->tree_w), "cursor-changed", G_CALLBACK(list_cursor_changed), (gpointer)dlg); gtk_tree_view_insert_column_with_attributes( GTK_TREE_VIEW(dlg->tree_w), -1, prefs_description(PREFS_NET_TYPE), gtk_cell_renderer_text_new(), "text", NETLISTCOL_TYPE_STR, NULL); column = gtk_tree_view_get_column(GTK_TREE_VIEW(dlg->tree_w), 0); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_insert_column_with_attributes( GTK_TREE_VIEW(dlg->tree_w), -1, prefs_description(PREFS_NET_PORT), gtk_cell_renderer_text_new(), "text", NETLISTCOL_PORT_STR, NULL); column = gtk_tree_view_get_column(GTK_TREE_VIEW(dlg->tree_w), 1); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_insert_column_with_attributes( GTK_TREE_VIEW(dlg->tree_w), -1, prefs_description(PREFS_NET_USE_MULTICAST), gtk_cell_renderer_text_new(), "text", NETLISTCOL_USE_MULTICAST_STR, NULL); gtk_tree_view_column_set_resizable(column, TRUE); scrolled = gtk_scrolled_window_new(NULL, NULL); gtk_widget_set_size_request(scrolled, -1, LIST_MIN_HEIGHT); gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled), dlg->tree_w); gtk_container_add(GTK_CONTAINER(frame), scrolled); /* Make hbox for lower control frames */ manual_hbox = gtk_hbox_new(FALSE, 2); gtk_box_pack_start(GTK_BOX(main_vbox), manual_hbox, FALSE, FALSE, 0); /* * "Automatic scan" frame */ frame = gtk_frame_new(_("Automatic scan")); gtk_container_set_border_width(GTK_CONTAINER(frame), 2); gtk_box_pack_start(GTK_BOX(manual_hbox), frame, TRUE, TRUE, 0); /* vbox inside the frame */ vbox = gtk_vbox_new(FALSE, 4); gtk_container_set_border_width(GTK_CONTAINER(vbox), 4); gtk_container_add(GTK_CONTAINER(frame), vbox); /* progress bar */ dlg->detect_progress = gtk_progress_bar_new(); gtk_box_pack_start(GTK_BOX(vbox), dlg->detect_progress, FALSE, FALSE, 0); /* the 'reset' and 'refresh' buttons */ hbox = gtk_hbox_new(FALSE, 4); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0); button_box = gtk_hbutton_box_new(); gtk_box_pack_end(GTK_BOX(hbox), button_box, FALSE, FALSE, 0); dlg->detect_btn = gtk_button_new_from_stock(GTK_STOCK_REFRESH); g_signal_connect(G_OBJECT(dlg->detect_btn), "clicked", G_CALLBACK(detect_button_clicked), (gpointer)dlg); gtk_box_pack_start(GTK_BOX(button_box), dlg->detect_btn, FALSE, FALSE, 0); dlg->detect_stop_btn = gtk_button_new_from_stock(GTK_STOCK_STOP); g_signal_connect(G_OBJECT(dlg->detect_stop_btn), "clicked", G_CALLBACK(detect_button_clicked), (gpointer)dlg); gtk_box_pack_start(GTK_BOX(button_box), dlg->detect_stop_btn, FALSE, FALSE, 0); /* settings vbox */ settings_vbox = gtk_vbox_new(FALSE, 4); /* port range start spin */ hbox = gtk_hbox_new(FALSE, 4); gtk_box_pack_start(GTK_BOX(settings_vbox), hbox, FALSE, FALSE, 0); dlg->detect_begin_spin = gtk_spin_button_new_with_range(1024, 65535, 1); gtk_spin_button_set_value( GTK_SPIN_BUTTON(dlg->detect_begin_spin), DEFAULT_DETECT_RANGE_BEGIN); gtk_box_pack_end(GTK_BOX(hbox), dlg->detect_begin_spin, FALSE, FALSE, 0); gtk_box_pack_end(GTK_BOX(hbox), gtk_label_new(_("Scan UDP ports from")), FALSE, FALSE, 0); g_signal_connect(G_OBJECT(dlg->detect_begin_spin), "value-changed", G_CALLBACK(detect_range_spin_value_changed), (gpointer)dlg); /* port range end spin */ hbox = gtk_hbox_new(FALSE, 4); gtk_box_pack_start(GTK_BOX(settings_vbox), hbox, FALSE, FALSE, 0); dlg->detect_end_spin = gtk_spin_button_new_with_range(1024, 65535, 1); gtk_spin_button_set_value( GTK_SPIN_BUTTON(dlg->detect_end_spin), DEFAULT_DETECT_RANGE_END); gtk_box_pack_end(GTK_BOX(hbox), dlg->detect_end_spin, FALSE, FALSE, 0); gtk_box_pack_end(GTK_BOX(hbox), gtk_label_new(_("to (including)")), FALSE, FALSE, 0); g_signal_connect(G_OBJECT(dlg->detect_end_spin), "value-changed", G_CALLBACK(detect_range_spin_value_changed), (gpointer)dlg); /* broadcast mask */ hbox = gtk_hbox_new(FALSE, 4); gtk_box_pack_start(GTK_BOX(settings_vbox), hbox, FALSE, FALSE, 0); dlg->detect_broadcast_mask_w = gtk_entry_new(); gtk_entry_set_text( GTK_ENTRY(dlg->detect_broadcast_mask_w), text = util_inet_ntoa(prefs_int(PREFS_NET_BROADCAST_MASK))); g_free(text); gtk_box_pack_end(GTK_BOX(hbox), dlg->detect_broadcast_mask_w, FALSE, FALSE, 0); gtk_box_pack_end(GTK_BOX(hbox), gtk_label_new(prefs_description(PREFS_NET_BROADCAST_MASK)), FALSE, FALSE, 0); /* multicast mask */ hbox = gtk_hbox_new(FALSE, 4); gtk_box_pack_start(GTK_BOX(settings_vbox), hbox, FALSE, FALSE, 0); dlg->detect_multicast_addr_w = gtk_entry_new(); gtk_entry_set_text( GTK_ENTRY(dlg->detect_multicast_addr_w), text = util_inet_ntoa(prefs_int(PREFS_NET_MULTICAST_ADDR))); g_free(text); gtk_box_pack_end(GTK_BOX(hbox), dlg->detect_multicast_addr_w, FALSE, FALSE, 0); gtk_box_pack_end(GTK_BOX(hbox), gtk_label_new(prefs_description(PREFS_NET_MULTICAST_ADDR)), FALSE, FALSE, 0); /* pack settings vbox in to the window (through the expander widget) */ #if(HAVE_EXPANDER_WIDGET) dlg->detect_expander_w = gtk_expander_new_with_mnemonic(_("Detection settings")); gtk_container_add(GTK_CONTAINER(dlg->detect_expander_w), settings_vbox); gtk_box_pack_start(GTK_BOX(vbox), dlg->detect_expander_w, FALSE, FALSE, 0); #else gtk_box_pack_start(GTK_BOX(vbox), gtk_hseparator_new(), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), settings_vbox, FALSE, FALSE, 0); #endif /* * Manual port/network entry frame */ frame = gtk_frame_new(_("Network settings")); gtk_container_set_border_width(GTK_CONTAINER(frame), 2); gtk_box_pack_start(GTK_BOX(manual_hbox), frame, TRUE, TRUE, 0); /* vbox inside the frame */ vbox = gtk_vbox_new(FALSE, 4); gtk_container_set_border_width(GTK_CONTAINER(vbox), 4); gtk_container_add(GTK_CONTAINER(frame), vbox); /* use multicast toggle */ dlg->net_use_multicast_w = gtk_check_button_new_with_label( prefs_description(PREFS_NET_USE_MULTICAST)); gtk_widget_set_sensitive( dlg->net_use_multicast_w, prefs_int(PREFS_NET_TYPE)==NET_TYPE_VYPRESS); gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(dlg->net_use_multicast_w), prefs_int(PREFS_NET_TYPE)==NET_TYPE_VYPRESS ? prefs_bool(PREFS_NET_USE_MULTICAST): FALSE); /* network type option */ hbox = gtk_hbox_new(FALSE, 4); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0); dlg->net_type_option = util_net_type_option( (util_option_changed_cb)dlg_net_type_option_changed, (gpointer)dlg); gtk_box_pack_end(GTK_BOX(hbox), dlg->net_type_option, FALSE, FALSE, 0); gtk_box_pack_end(GTK_BOX(hbox), gtk_label_new(prefs_description(PREFS_NET_TYPE)), FALSE, FALSE, 0); gtk_option_menu_set_history( GTK_OPTION_MENU(dlg->net_type_option), prefs_int(PREFS_NET_TYPE)); /* network port number */ hbox = gtk_hbox_new(FALSE, 4); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0); dlg->net_port_spin = gtk_spin_button_new_with_range(1024, 65535, 1); gtk_box_pack_end(GTK_BOX(hbox), dlg->net_port_spin, FALSE, FALSE, 0); gtk_box_pack_end(GTK_BOX(hbox), gtk_label_new(prefs_description(PREFS_NET_PORT)), FALSE, FALSE, 0); gtk_spin_button_set_value( GTK_SPIN_BUTTON(dlg->net_port_spin), prefs_int(PREFS_NET_PORT)); /* append the multicast toggle */ gtk_box_pack_start(GTK_BOX(vbox), dlg->net_use_multicast_w, FALSE, FALSE, 0); /* show dialog to the user */ dlg_search_mode(dlg, FALSE); gtk_widget_show_all(dlg->dlg_w); gtk_window_present(GTK_WINDOW(dlg->dlg_w)); }
/** * Callback used when a payment method is selected in payment methods * list. * * \param selection the tree selection * \param tree_view * * \return FALSE */ gboolean gsb_payment_method_config_select ( GtkTreeSelection *selection, GtkWidget *tree_view ) { GtkTreeIter iter; gboolean good; good = gtk_tree_selection_get_selected (selection, NULL, &iter); if (good) { GtkTreeModel *model; gint payment_number; model = gtk_tree_view_get_model (GTK_TREE_VIEW (tree_view)); gtk_tree_model_get (model, &iter, PAYMENT_METHODS_NUMBER_COLUMN, &payment_number, -1 ); if (payment_number ) { gtk_widget_set_sensitive ( details_paddingbox, TRUE ); /* Filling entries */ gsb_autofunc_entry_set_value ( payment_name_entry, gsb_data_payment_get_name (payment_number), payment_number ); gsb_autofunc_spin_set_value ( payment_last_number_entry, gsb_data_payment_get_last_number_to_int ( payment_number ), payment_number ); gsb_autofunc_checkbutton_set_value ( button_show_entry, gsb_data_payment_get_show_entry (payment_number), payment_number ); gsb_autofunc_checkbutton_set_value ( button_auto_numbering, gsb_data_payment_get_automatic_numbering (payment_number), payment_number ); gtk_option_menu_set_history ( GTK_OPTION_MENU ( payment_sign_button ), gsb_data_payment_get_sign (payment_number)); /* Activating widgets */ gtk_widget_set_sensitive ( button_auto_numbering, gsb_data_payment_get_show_entry (payment_number)); gtk_widget_set_sensitive ( payment_last_number_entry, gsb_data_payment_get_automatic_numbering (payment_number)); /* We can remove this entry */ gtk_widget_set_sensitive ( payment_remove_button, TRUE ); } else { /* Blanking entries */ gsb_autofunc_entry_set_value ( payment_name_entry, NULL, 0); gsb_autofunc_spin_set_value ( payment_last_number_entry, 0, 0 ); gsb_autofunc_checkbutton_set_value ( button_show_entry, FALSE, 0 ); gsb_autofunc_checkbutton_set_value ( button_auto_numbering, FALSE, 0 ); /* Some widgets are useless */ gtk_widget_set_sensitive ( button_auto_numbering, FALSE ); gtk_widget_set_sensitive ( payment_last_number_entry, FALSE ); /* We set menu to "Neutral" as a default*/ gtk_option_menu_set_history ( GTK_OPTION_MENU ( payment_sign_button ), 0); /* Nothing to remove */ gtk_widget_set_sensitive ( payment_remove_button, TRUE ); gtk_widget_set_sensitive ( details_paddingbox, FALSE ); } } else { /* Blanking entries */ gsb_autofunc_entry_set_value ( payment_name_entry, NULL, 0); gsb_autofunc_spin_set_value ( payment_last_number_entry, 0, 0 ); gsb_autofunc_checkbutton_set_value ( button_show_entry, FALSE, 0 ); gsb_autofunc_checkbutton_set_value ( button_auto_numbering, FALSE, 0 ); /* Some widgets are useless */ gtk_widget_set_sensitive ( button_auto_numbering, FALSE ); gtk_widget_set_sensitive ( payment_last_number_entry, FALSE ); /* We set menu to "Neutral" as a default*/ gtk_option_menu_set_history ( GTK_OPTION_MENU ( payment_sign_button ), 0); /* Nothing to remove */ gtk_widget_set_sensitive ( payment_remove_button, TRUE ); gtk_widget_set_sensitive ( details_paddingbox, FALSE ); } return ( FALSE ); }
// Populate both the drop-down on the import tab and within the file browse dialog void populate_polsarpro_classification_optionmenu() { // Set up the menus (one on the import tab, the other on the input file browse dialog GtkWidget *browse_menu = NULL; GtkWidget *browse_option_menu = get_widget_checked("browse_select_colormap_optionmenu"); if (browse_option_menu) { browse_menu = gtk_option_menu_get_menu(GTK_OPTION_MENU(browse_option_menu)); if (browse_menu) { gtk_option_menu_remove_menu(GTK_OPTION_MENU(browse_option_menu)); } } browse_menu = gtk_menu_new(); GtkWidget *browse_item = gtk_menu_item_new_with_label("None"); gtk_menu_append(GTK_MENU(browse_menu), browse_item); gtk_widget_show(browse_item); browse_item = gtk_separator_menu_item_new(); gtk_menu_append(GTK_MENU(browse_menu), browse_item); gtk_widget_show(browse_item); char lut_loc[1024]; sprintf(lut_loc, "%s%clook_up_tables", get_asf_share_dir(), DIR_SEPARATOR); if (g_polsarpro_classification_optionmenu_ht == NULL) { g_polsarpro_classification_optionmenu_ht = g_hash_table_new(g_str_hash,g_str_equal); } // Open up the share dir's look up tables list, populate dropdown // from the files in that directory. GDir *lut_dir = g_dir_open(lut_loc, 0, NULL); if (lut_dir) { unsigned int i, n=0; char **names = (char**)MALLOC(sizeof(char*)*MAX_LUTS); while (1) { const char *name = (char*)g_dir_read_name(lut_dir); if (name) { char *name_dup = STRDUP(name); char *p = findExt(name_dup); if (p && strcmp(p, ".pal") == 0 && is_jasc_palette_lut(name)) { *p = '\0'; // don't show ".pal" extension in menu names[n++] = name_dup; // quit when we get too many if (n > MAX_LUTS) break; } } else break; } g_dir_close(lut_dir); // alphabetize qsort(names, n, sizeof(char*), my_strcmp); // now populate the menus for (i=0; i<n; ++i) { browse_item = gtk_menu_item_new_with_label(names[i]); g_object_set_data(G_OBJECT(browse_item), "file", (gpointer)names[i]); g_object_set_data(G_OBJECT(browse_item), "index", GUINT_TO_POINTER(i+2)); gtk_menu_append(GTK_MENU(browse_menu), browse_item); gtk_widget_show(browse_item); g_hash_table_insert(g_polsarpro_classification_optionmenu_ht, (gpointer)g_strdup(names[i]), GUINT_TO_POINTER(i+2)); } } browse_option_menu = get_widget_checked("browse_select_colormap_optionmenu"); gtk_option_menu_set_menu(GTK_OPTION_MENU(browse_option_menu), browse_menu); gtk_option_menu_set_history(GTK_OPTION_MENU(browse_option_menu), 0); gtk_widget_show(browse_menu); gtk_widget_show(browse_option_menu); }
void pp_units_set_unit(pp_Units *ob,enum Units unit) { gtk_option_menu_set_history(GTK_OPTION_MENU(ob->unitselector),unit); }
int main (int argc, char **argv) { static GtkWidget *window = NULL; GtkWidget *box1; GtkWidget *box2; GtkWidget *button; GtkWidget *optionmenu; GtkWidget *separator; gtk_init (&argc, &argv); if (!window) { GtkWidget *menubar; GtkWidget *menu; GtkWidget *submenu; GtkWidget *menuitem; GtkAccelGroup *accel_group; window = gtk_window_new (GTK_WINDOW_TOPLEVEL); g_signal_connect (window, "destroy", G_CALLBACK(gtk_main_quit), NULL); g_signal_connect (window, "delete-event", G_CALLBACK (gtk_true), NULL); accel_group = gtk_accel_group_new (); gtk_window_add_accel_group (GTK_WINDOW (window), accel_group); gtk_window_set_title (GTK_WINDOW (window), "menus"); gtk_container_set_border_width (GTK_CONTAINER (window), 0); box1 = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (window), box1); gtk_widget_show (box1); menubar = gtk_menu_bar_new (); gtk_box_pack_start (GTK_BOX (box1), menubar, FALSE, TRUE, 0); gtk_widget_show (menubar); menu = create_menu (2, TRUE); menuitem = gtk_menu_item_new_with_label ("test\nline2"); gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu); gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem); gtk_widget_show (menuitem); menuitem = gtk_menu_item_new_with_label ("dynamic"); submenu = create_menu (3, TRUE); gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu); gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem); gtk_widget_show (menuitem); g_timeout_add (250, change_item, submenu); menuitem = gtk_menu_item_new_with_label ("bar"); gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (4, TRUE)); gtk_menu_item_set_right_justified (GTK_MENU_ITEM (menuitem), TRUE); gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem); gtk_widget_show (menuitem); box2 = gtk_vbox_new (FALSE, 10); gtk_container_set_border_width (GTK_CONTAINER (box2), 10); gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0); gtk_widget_show (box2); menu = create_menu (1, FALSE); gtk_menu_set_accel_group (GTK_MENU (menu), accel_group); menuitem = gtk_separator_menu_item_new (); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); gtk_widget_show (menuitem); menuitem = gtk_check_menu_item_new_with_label ("Accelerate Me"); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); gtk_widget_show (menuitem); gtk_widget_add_accelerator (menuitem, "activate", accel_group, GDK_F1, 0, GTK_ACCEL_VISIBLE); menuitem = gtk_check_menu_item_new_with_label ("Accelerator Locked"); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); gtk_widget_show (menuitem); gtk_widget_add_accelerator (menuitem, "activate", accel_group, GDK_F2, 0, GTK_ACCEL_VISIBLE | GTK_ACCEL_LOCKED); menuitem = gtk_check_menu_item_new_with_label ("Accelerators Frozen"); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); gtk_widget_show (menuitem); gtk_widget_add_accelerator (menuitem, "activate", accel_group, GDK_F2, 0, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator (menuitem, "activate", accel_group, GDK_F3, 0, GTK_ACCEL_VISIBLE); optionmenu = gtk_option_menu_new (); gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu), menu); gtk_option_menu_set_history (GTK_OPTION_MENU (optionmenu), 3); gtk_box_pack_start (GTK_BOX (box2), optionmenu, TRUE, TRUE, 0); gtk_widget_show (optionmenu); separator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0); gtk_widget_show (separator); box2 = gtk_vbox_new (FALSE, 10); gtk_container_set_border_width (GTK_CONTAINER (box2), 10); gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0); gtk_widget_show (box2); button = gtk_button_new_with_label ("close"); g_signal_connect_swapped (button, "clicked", G_CALLBACK(gtk_widget_destroy), window); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); gtk_widget_grab_default (button); gtk_widget_show (button); } if (!GTK_WIDGET_VISIBLE (window)) { gtk_widget_show (window); } else { gtk_widget_destroy (window); window = NULL; } gtk_main (); return 0; }
void create_PreferencesDialog(void) { GtkWidget *PreferencesDialog; GtkWidget *dialog_vbox9; GtkWidget *notebook1; GtkWidget *GenericTable; GtkWidget *label173; GtkObject *LogLevelSpinner_adj; GtkWidget *LogLevelSpinner; GtkWidget *DebugCheckButton; GtkWidget *label174; GtkWidget *StreamDirectoryHbox; GtkWidget *StreamDirectory; GtkWidget *StreamDirectoryButton; GtkWidget *alignment24; GtkWidget *hbox84; GtkWidget *image24; GtkWidget *label175; GtkWidget *label176; GtkWidget *ProfileDirectoryHbox; GtkWidget *ProfileDirectory; GtkWidget *ProfileDirectoryButton; GtkWidget *alignment25; GtkWidget *hbox86; GtkWidget *image25; GtkWidget *label177; GtkWidget *label169; GtkWidget *NetworkVbox; GtkWidget *NetworkTable; GtkWidget *label178; GtkWidget *label179; GtkWidget *MulticastTtlMenu; GtkWidget *menu16; GtkWidget *ttl_lan; GtkWidget *ttl_organization; GtkWidget *ttl_regional; GtkWidget *ttl_worldwide; GtkObject *MtuSpinButton_adj; GtkWidget *MtuSpinButton; GtkWidget *vbox39; GtkWidget *hbox89; GtkWidget *AllowRtcpCheck; GtkWidget *hbox87; GtkWidget *AllowSSMCheck; GtkWidget *label170; GtkWidget *MP4FileSettingsVbox; GtkWidget *FileStatusFrame; GtkWidget *FileStatusVbox; GtkWidget *hbox90; GtkWidget *FileStatus1; GSList *FileStatus1_group = NULL; GtkWidget *hbox91; GtkWidget *FileStatus2; GtkWidget *hbox92; GtkWidget *FileStatus3; GtkWidget *label180; GtkWidget *hbox93; GtkWidget *RecordHintTrackButton; GtkWidget *hbox94; GtkWidget *OptimizeMP4FileButton; GtkWidget *hbox95; GtkWidget *RecordRawDataButton; GtkWidget *RawFileName; GtkWidget *RawFileNameBrowse; GtkWidget *alignment26; GtkWidget *hbox96; GtkWidget *image26; GtkWidget *label181; GtkWidget *label171; GtkWidget *dialog_action_area8; GtkWidget *cancelbutton6; GtkWidget *okbutton8; GtkTooltips *tooltips; tooltips = gtk_tooltips_new(); PreferencesDialog = gtk_dialog_new(); gtk_window_set_title(GTK_WINDOW(PreferencesDialog), _("Preferences")); gtk_window_set_modal(GTK_WINDOW(PreferencesDialog), TRUE); gtk_window_set_resizable(GTK_WINDOW(PreferencesDialog), FALSE); gtk_window_set_transient_for(GTK_WINDOW(PreferencesDialog), GTK_WINDOW(MainWindow)); dialog_vbox9 = GTK_DIALOG(PreferencesDialog)->vbox; gtk_widget_show(dialog_vbox9); notebook1 = gtk_notebook_new(); gtk_widget_show(notebook1); gtk_box_pack_start(GTK_BOX(dialog_vbox9), notebook1, TRUE, TRUE, 0); GenericTable = gtk_table_new(4, 2, FALSE); gtk_widget_show(GenericTable); gtk_container_add(GTK_CONTAINER(notebook1), GenericTable); gtk_table_set_row_spacings(GTK_TABLE(GenericTable), 9); gtk_table_set_col_spacings(GTK_TABLE(GenericTable), 36); label173 = gtk_label_new(_("Log Level")); gtk_widget_show(label173); gtk_table_attach(GTK_TABLE(GenericTable), label173, 0, 1, 1, 2, (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0); gtk_misc_set_alignment(GTK_MISC(label173), 0, 0.5); LogLevelSpinner_adj = gtk_adjustment_new(MyConfig->GetIntegerValue(CONFIG_APP_LOGLEVEL), 0, 7, 1, 10, 10); LogLevelSpinner = gtk_spin_button_new(GTK_ADJUSTMENT(LogLevelSpinner_adj), 1, 0); gtk_widget_show(LogLevelSpinner); gtk_table_attach(GTK_TABLE(GenericTable), LogLevelSpinner, 1, 2, 1, 2, (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), (GtkAttachOptions)(0), 0, 0); DebugCheckButton = gtk_check_button_new_with_mnemonic(_("Debug")); gtk_widget_show(DebugCheckButton); gtk_table_attach(GTK_TABLE(GenericTable), DebugCheckButton, 0, 2, 0, 1, (GtkAttachOptions)(0), (GtkAttachOptions)(0), 0, 0); label174 = gtk_label_new(_("Stream Directory")); gtk_widget_show(label174); gtk_table_attach(GTK_TABLE(GenericTable), label174, 0, 1, 2, 3, (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0); gtk_misc_set_alignment(GTK_MISC(label174), 0, 0.5); StreamDirectoryHbox = gtk_hbox_new(FALSE, 0); gtk_widget_show(StreamDirectoryHbox); gtk_table_attach(GTK_TABLE(GenericTable), StreamDirectoryHbox, 1, 2, 2, 3, (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL), 0, 0); StreamDirectory = gtk_entry_new(); gtk_widget_show(StreamDirectory); gtk_box_pack_start(GTK_BOX(StreamDirectoryHbox), StreamDirectory, TRUE, TRUE, 0); StreamDirectoryButton = gtk_button_new(); gtk_widget_show(StreamDirectoryButton); gtk_box_pack_start(GTK_BOX(StreamDirectoryHbox), StreamDirectoryButton, FALSE, FALSE, 0); alignment24 = gtk_alignment_new(0.5, 0.5, 0, 0); gtk_widget_show(alignment24); gtk_container_add(GTK_CONTAINER(StreamDirectoryButton), alignment24); hbox84 = gtk_hbox_new(FALSE, 2); gtk_widget_show(hbox84); gtk_container_add(GTK_CONTAINER(alignment24), hbox84); image24 = gtk_image_new_from_stock("gtk-open", GTK_ICON_SIZE_BUTTON); gtk_widget_show(image24); gtk_box_pack_start(GTK_BOX(hbox84), image24, FALSE, FALSE, 0); label175 = gtk_label_new_with_mnemonic(_("Browse")); gtk_widget_show(label175); gtk_box_pack_start(GTK_BOX(hbox84), label175, FALSE, FALSE, 0); label176 = gtk_label_new(_("Profiles Directory")); gtk_widget_show(label176); gtk_table_attach(GTK_TABLE(GenericTable), label176, 0, 1, 3, 4, (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0); gtk_misc_set_alignment(GTK_MISC(label176), 0, 0.5); ProfileDirectoryHbox = gtk_hbox_new(FALSE, 0); gtk_widget_show(ProfileDirectoryHbox); gtk_table_attach(GTK_TABLE(GenericTable), ProfileDirectoryHbox, 1, 2, 3, 4, (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL), 0, 0); ProfileDirectory = gtk_entry_new(); gtk_widget_show(ProfileDirectory); gtk_box_pack_start(GTK_BOX(ProfileDirectoryHbox), ProfileDirectory, TRUE, TRUE, 0); ProfileDirectoryButton = gtk_button_new(); gtk_widget_show(ProfileDirectoryButton); gtk_box_pack_start(GTK_BOX(ProfileDirectoryHbox), ProfileDirectoryButton, FALSE, FALSE, 0); alignment25 = gtk_alignment_new(0.5, 0.5, 0, 0); gtk_widget_show(alignment25); gtk_container_add(GTK_CONTAINER(ProfileDirectoryButton), alignment25); hbox86 = gtk_hbox_new(FALSE, 2); gtk_widget_show(hbox86); gtk_container_add(GTK_CONTAINER(alignment25), hbox86); image25 = gtk_image_new_from_stock("gtk-open", GTK_ICON_SIZE_BUTTON); gtk_widget_show(image25); gtk_box_pack_start(GTK_BOX(hbox86), image25, FALSE, FALSE, 0); label177 = gtk_label_new_with_mnemonic(_("Browse")); gtk_widget_show(label177); gtk_box_pack_start(GTK_BOX(hbox86), label177, FALSE, FALSE, 0); label169 = gtk_label_new(_("Generic")); gtk_widget_show(label169); gtk_notebook_set_tab_label(GTK_NOTEBOOK(notebook1), gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook1), 0), label169); NetworkVbox = gtk_vbox_new(FALSE, 0); gtk_widget_show(NetworkVbox); gtk_container_add(GTK_CONTAINER(notebook1), NetworkVbox); NetworkTable = gtk_table_new(2, 2, TRUE); gtk_widget_show(NetworkTable); gtk_box_pack_start(GTK_BOX(NetworkVbox), NetworkTable, FALSE, TRUE, 6); gtk_table_set_row_spacings(GTK_TABLE(NetworkTable), 7); label178 = gtk_label_new(_("Multicast TTL")); gtk_widget_show(label178); gtk_table_attach(GTK_TABLE(NetworkTable), label178, 0, 1, 0, 1, (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0); gtk_misc_set_alignment(GTK_MISC(label178), 0, 0.5); label179 = gtk_label_new(_("MTU")); gtk_widget_show(label179); gtk_table_attach(GTK_TABLE(NetworkTable), label179, 0, 1, 1, 2, (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0); gtk_misc_set_alignment(GTK_MISC(label179), 0, 0.5); MulticastTtlMenu = gtk_option_menu_new(); gtk_widget_show(MulticastTtlMenu); gtk_table_attach(GTK_TABLE(NetworkTable), MulticastTtlMenu, 1, 2, 0, 1, (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0); menu16 = gtk_menu_new(); ttl_lan = gtk_menu_item_new_with_mnemonic(_("LAN - 1")); gtk_widget_show(ttl_lan); gtk_container_add(GTK_CONTAINER(menu16), ttl_lan); ttl_organization = gtk_menu_item_new_with_mnemonic(_("Organization - 15")); gtk_widget_show(ttl_organization); gtk_container_add(GTK_CONTAINER(menu16), ttl_organization); ttl_regional = gtk_menu_item_new_with_mnemonic(_("Regional - 63")); gtk_widget_show(ttl_regional); gtk_container_add(GTK_CONTAINER(menu16), ttl_regional); ttl_worldwide = gtk_menu_item_new_with_mnemonic(_("Worldwide -127")); gtk_widget_show(ttl_worldwide); gtk_container_add(GTK_CONTAINER(menu16), ttl_worldwide); gtk_option_menu_set_menu(GTK_OPTION_MENU(MulticastTtlMenu), menu16); MtuSpinButton_adj = gtk_adjustment_new(MyConfig->GetIntegerValue(CONFIG_RTP_PAYLOAD_SIZE), 256, 65535, 1, 100, 100); MtuSpinButton = gtk_spin_button_new(GTK_ADJUSTMENT (MtuSpinButton_adj), 1, 0); gtk_widget_show(MtuSpinButton); gtk_table_attach(GTK_TABLE (NetworkTable), MtuSpinButton, 1, 2, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_spin_button_set_numeric(GTK_SPIN_BUTTON (MtuSpinButton), TRUE); vbox39 = gtk_vbox_new(FALSE, 4); gtk_widget_show(vbox39); gtk_box_pack_start(GTK_BOX(NetworkVbox), vbox39, FALSE, FALSE, 5); hbox89 = gtk_hbox_new(FALSE, 0); gtk_widget_show(hbox89); gtk_box_pack_start(GTK_BOX(vbox39), hbox89, TRUE, TRUE, 4); AllowRtcpCheck = gtk_check_button_new_with_mnemonic(_("Allow Clients to Send RTCP")); gtk_widget_show(AllowRtcpCheck); gtk_box_pack_start(GTK_BOX(hbox89), AllowRtcpCheck, FALSE, FALSE, 94); gtk_tooltips_set_tip(tooltips, AllowRtcpCheck, _("Allow clients to send RTCP - default off"), NULL); hbox87 = gtk_hbox_new(FALSE, 0); gtk_widget_show(hbox87); gtk_box_pack_start(GTK_BOX(vbox39), hbox87, TRUE, TRUE, 0); AllowSSMCheck = gtk_check_button_new_with_mnemonic(_("Use Single Source Multicast")); gtk_widget_show(AllowSSMCheck); gtk_box_pack_start(GTK_BOX(hbox87), AllowSSMCheck, TRUE, FALSE, 0); gtk_widget_set_sensitive(AllowSSMCheck, FALSE); label170 = gtk_label_new(_("Network Settings")); gtk_widget_show(label170); gtk_notebook_set_tab_label(GTK_NOTEBOOK(notebook1), gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook1), 1), label170); MP4FileSettingsVbox = gtk_vbox_new(FALSE, 0); gtk_widget_show(MP4FileSettingsVbox); gtk_container_add(GTK_CONTAINER(notebook1), MP4FileSettingsVbox); gtk_notebook_set_tab_label_packing(GTK_NOTEBOOK(notebook1), MP4FileSettingsVbox, FALSE, FALSE, GTK_PACK_START); FileStatusFrame = gtk_frame_new(NULL); gtk_widget_show(FileStatusFrame); gtk_box_pack_start(GTK_BOX(MP4FileSettingsVbox), FileStatusFrame, TRUE, TRUE, 0); FileStatusVbox = gtk_vbox_new(FALSE, 0); gtk_widget_show(FileStatusVbox); gtk_container_add(GTK_CONTAINER(FileStatusFrame), FileStatusVbox); hbox90 = gtk_hbox_new(FALSE, 0); gtk_widget_show(hbox90); gtk_box_pack_start(GTK_BOX(FileStatusVbox), hbox90, TRUE, TRUE, 0); FileStatus1 = gtk_radio_button_new_with_mnemonic(NULL, _("Always overwrite existing file")); gtk_widget_show(FileStatus1); gtk_box_pack_start(GTK_BOX(hbox90), FileStatus1, TRUE, TRUE, 46); gtk_radio_button_set_group(GTK_RADIO_BUTTON(FileStatus1), FileStatus1_group); FileStatus1_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(FileStatus1)); hbox91 = gtk_hbox_new(FALSE, 0); gtk_widget_show(hbox91); gtk_box_pack_start(GTK_BOX(FileStatusVbox), hbox91, FALSE, FALSE, 0); FileStatus2 = gtk_radio_button_new_with_mnemonic(NULL, _("Append to file")); gtk_widget_show(FileStatus2); gtk_box_pack_start(GTK_BOX(hbox91), FileStatus2, TRUE, TRUE, 46); gtk_radio_button_set_group(GTK_RADIO_BUTTON(FileStatus2), FileStatus1_group); FileStatus1_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(FileStatus2)); hbox92 = gtk_hbox_new(FALSE, 0); gtk_widget_show(hbox92); gtk_box_pack_start(GTK_BOX(FileStatusVbox), hbox92, FALSE, FALSE, 0); FileStatus3 = gtk_radio_button_new_with_mnemonic(NULL, _("Create new file based on name")); gtk_widget_show(FileStatus3); gtk_box_pack_start(GTK_BOX(hbox92), FileStatus3, FALSE, FALSE, 46); gtk_radio_button_set_group(GTK_RADIO_BUTTON(FileStatus3), FileStatus1_group); FileStatus1_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(FileStatus3)); label180 = gtk_label_new(_("File Status")); gtk_widget_show(label180); gtk_frame_set_label_widget(GTK_FRAME(FileStatusFrame), label180); hbox93 = gtk_hbox_new(FALSE, 0); gtk_widget_show(hbox93); gtk_box_pack_start(GTK_BOX(MP4FileSettingsVbox), hbox93, TRUE, TRUE, 4); RecordHintTrackButton = gtk_check_button_new_with_mnemonic(_("Record Hint Tracks when Finished")); gtk_widget_show(RecordHintTrackButton); gtk_box_pack_start(GTK_BOX(hbox93), RecordHintTrackButton, TRUE, FALSE, 0); gtk_tooltips_set_tip(tooltips, RecordHintTrackButton, _("If set, this can cause application to appear to freeze when finished"), NULL); hbox94 = gtk_hbox_new(FALSE, 0); gtk_widget_show(hbox94); gtk_box_pack_start(GTK_BOX(MP4FileSettingsVbox), hbox94, TRUE, TRUE, 4); OptimizeMP4FileButton = gtk_check_button_new_with_mnemonic(_("Optimize When Finished")); gtk_widget_show(OptimizeMP4FileButton); gtk_box_pack_start(GTK_BOX(hbox94), OptimizeMP4FileButton, FALSE, FALSE, 79); hbox95 = gtk_hbox_new(FALSE, 0); gtk_widget_show(hbox95); gtk_box_pack_start(GTK_BOX(MP4FileSettingsVbox), hbox95, TRUE, TRUE, 0); RecordRawDataButton = gtk_check_button_new_with_mnemonic(_("Record Raw Data ")); gtk_widget_show(RecordRawDataButton); gtk_box_pack_start(GTK_BOX(hbox95), RecordRawDataButton, FALSE, FALSE, 0); RawFileName = gtk_entry_new(); gtk_widget_show(RawFileName); gtk_box_pack_start(GTK_BOX(hbox95), RawFileName, TRUE, TRUE, 0); gtk_tooltips_set_tip(tooltips, RawFileName, _("Raw Data MP4 File Name"), NULL); RawFileNameBrowse = gtk_button_new(); gtk_widget_show(RawFileNameBrowse); gtk_box_pack_start(GTK_BOX(hbox95), RawFileNameBrowse, FALSE, FALSE, 0); alignment26 = gtk_alignment_new(0.5, 0.5, 0, 0); gtk_widget_show(alignment26); gtk_container_add(GTK_CONTAINER(RawFileNameBrowse), alignment26); hbox96 = gtk_hbox_new(FALSE, 2); gtk_widget_show(hbox96); gtk_container_add(GTK_CONTAINER(alignment26), hbox96); image26 = gtk_image_new_from_stock("gtk-open", GTK_ICON_SIZE_BUTTON); gtk_widget_show(image26); gtk_box_pack_start(GTK_BOX(hbox96), image26, FALSE, FALSE, 0); label181 = gtk_label_new_with_mnemonic(_("Browse")); gtk_widget_show(label181); gtk_box_pack_start(GTK_BOX(hbox96), label181, FALSE, FALSE, 0); label171 = gtk_label_new(_("MP4 File Settings")); gtk_widget_show(label171); gtk_notebook_set_tab_label(GTK_NOTEBOOK(notebook1), gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook1), 2), label171); dialog_action_area8 = GTK_DIALOG(PreferencesDialog)->action_area; gtk_widget_show(dialog_action_area8); gtk_button_box_set_layout(GTK_BUTTON_BOX(dialog_action_area8), GTK_BUTTONBOX_END); cancelbutton6 = gtk_button_new_from_stock("gtk-cancel"); gtk_widget_show(cancelbutton6); gtk_dialog_add_action_widget(GTK_DIALOG(PreferencesDialog), cancelbutton6, GTK_RESPONSE_CANCEL); GTK_WIDGET_SET_FLAGS(cancelbutton6, GTK_CAN_DEFAULT); okbutton8 = gtk_button_new_from_stock("gtk-ok"); gtk_widget_show(okbutton8); gtk_dialog_add_action_widget(GTK_DIALOG(PreferencesDialog), okbutton8, GTK_RESPONSE_OK); GTK_WIDGET_SET_FLAGS(okbutton8, GTK_CAN_DEFAULT); g_signal_connect((gpointer) PreferencesDialog, "response", G_CALLBACK(on_PreferencesDialog_response), NULL); g_signal_connect((gpointer)StreamDirectoryButton, "clicked", G_CALLBACK(on_stream_directory_clicked), PreferencesDialog); g_signal_connect((gpointer)ProfileDirectoryButton, "clicked", G_CALLBACK(on_profile_directory_clicked), PreferencesDialog); g_signal_connect((gpointer)RawFileNameBrowse, "clicked", G_CALLBACK(on_raw_file_clicked), PreferencesDialog); /* Store pointers to all widgets, for use by lookup_widget(). */ GLADE_HOOKUP_OBJECT_NO_REF(PreferencesDialog, PreferencesDialog, "PreferencesDialog"); GLADE_HOOKUP_OBJECT_NO_REF(PreferencesDialog, dialog_vbox9, "dialog_vbox9"); GLADE_HOOKUP_OBJECT(PreferencesDialog, notebook1, "notebook1"); GLADE_HOOKUP_OBJECT(PreferencesDialog, GenericTable, "GenericTable"); GLADE_HOOKUP_OBJECT(PreferencesDialog, label173, "label173"); GLADE_HOOKUP_OBJECT(PreferencesDialog, LogLevelSpinner, "LogLevelSpinner"); GLADE_HOOKUP_OBJECT(PreferencesDialog, DebugCheckButton, "DebugCheckButton"); GLADE_HOOKUP_OBJECT(PreferencesDialog, label174, "label174"); GLADE_HOOKUP_OBJECT(PreferencesDialog, StreamDirectoryHbox, "StreamDirectoryHbox"); GLADE_HOOKUP_OBJECT(PreferencesDialog, StreamDirectory, "StreamDirectory"); GLADE_HOOKUP_OBJECT(PreferencesDialog, StreamDirectoryButton, "StreamDirectoryButton"); GLADE_HOOKUP_OBJECT(PreferencesDialog, alignment24, "alignment24"); GLADE_HOOKUP_OBJECT(PreferencesDialog, hbox84, "hbox84"); GLADE_HOOKUP_OBJECT(PreferencesDialog, image24, "image24"); GLADE_HOOKUP_OBJECT(PreferencesDialog, label175, "label175"); GLADE_HOOKUP_OBJECT(PreferencesDialog, label176, "label176"); GLADE_HOOKUP_OBJECT(PreferencesDialog, ProfileDirectoryHbox, "ProfileDirectoryHbox"); GLADE_HOOKUP_OBJECT(PreferencesDialog, ProfileDirectory, "ProfileDirectory"); GLADE_HOOKUP_OBJECT(PreferencesDialog, ProfileDirectoryButton, "ProfileDirectoryButton"); GLADE_HOOKUP_OBJECT(PreferencesDialog, alignment25, "alignment25"); GLADE_HOOKUP_OBJECT(PreferencesDialog, hbox86, "hbox86"); GLADE_HOOKUP_OBJECT(PreferencesDialog, image25, "image25"); GLADE_HOOKUP_OBJECT(PreferencesDialog, label177, "label177"); GLADE_HOOKUP_OBJECT(PreferencesDialog, label169, "label169"); GLADE_HOOKUP_OBJECT(PreferencesDialog, NetworkVbox, "NetworkVbox"); GLADE_HOOKUP_OBJECT(PreferencesDialog, NetworkTable, "NetworkTable"); GLADE_HOOKUP_OBJECT(PreferencesDialog, label178, "label178"); GLADE_HOOKUP_OBJECT(PreferencesDialog, label179, "label179"); GLADE_HOOKUP_OBJECT(PreferencesDialog, MulticastTtlMenu, "MulticastTtlMenu"); GLADE_HOOKUP_OBJECT(PreferencesDialog, menu16, "menu16"); GLADE_HOOKUP_OBJECT(PreferencesDialog, ttl_lan, "ttl_lan"); GLADE_HOOKUP_OBJECT(PreferencesDialog, ttl_organization, "ttl_organization"); GLADE_HOOKUP_OBJECT(PreferencesDialog, ttl_regional, "ttl_regional"); GLADE_HOOKUP_OBJECT(PreferencesDialog, ttl_worldwide, "ttl_worldwide"); GLADE_HOOKUP_OBJECT (PreferencesDialog, MtuSpinButton, "MtuSpinButton"); GLADE_HOOKUP_OBJECT(PreferencesDialog, vbox39, "vbox39"); GLADE_HOOKUP_OBJECT(PreferencesDialog, hbox89, "hbox89"); GLADE_HOOKUP_OBJECT(PreferencesDialog, AllowRtcpCheck, "AllowRtcpCheck"); GLADE_HOOKUP_OBJECT(PreferencesDialog, hbox87, "hbox87"); GLADE_HOOKUP_OBJECT(PreferencesDialog, AllowSSMCheck, "AllowSSMCheck"); GLADE_HOOKUP_OBJECT(PreferencesDialog, label170, "label170"); GLADE_HOOKUP_OBJECT(PreferencesDialog, MP4FileSettingsVbox, "MP4FileSettingsVbox"); GLADE_HOOKUP_OBJECT(PreferencesDialog, FileStatusFrame, "FileStatusFrame"); GLADE_HOOKUP_OBJECT(PreferencesDialog, FileStatusVbox, "FileStatusVbox"); GLADE_HOOKUP_OBJECT(PreferencesDialog, hbox90, "hbox90"); GLADE_HOOKUP_OBJECT(PreferencesDialog, FileStatus1, "FileStatus1"); GLADE_HOOKUP_OBJECT(PreferencesDialog, hbox91, "hbox91"); GLADE_HOOKUP_OBJECT(PreferencesDialog, FileStatus2, "FileStatus2"); GLADE_HOOKUP_OBJECT(PreferencesDialog, hbox92, "hbox92"); GLADE_HOOKUP_OBJECT(PreferencesDialog, FileStatus3, "FileStatus3"); GLADE_HOOKUP_OBJECT(PreferencesDialog, label180, "label180"); GLADE_HOOKUP_OBJECT(PreferencesDialog, hbox93, "hbox93"); GLADE_HOOKUP_OBJECT(PreferencesDialog, RecordHintTrackButton, "RecordHintTrackButton"); GLADE_HOOKUP_OBJECT(PreferencesDialog, hbox94, "hbox94"); GLADE_HOOKUP_OBJECT(PreferencesDialog, OptimizeMP4FileButton, "OptimizeMP4FileButton"); GLADE_HOOKUP_OBJECT(PreferencesDialog, hbox95, "hbox95"); GLADE_HOOKUP_OBJECT(PreferencesDialog, RecordRawDataButton, "RecordRawDataButton"); GLADE_HOOKUP_OBJECT(PreferencesDialog, RawFileName, "RawFileName"); GLADE_HOOKUP_OBJECT(PreferencesDialog, RawFileNameBrowse, "RawFileNameBrowse"); GLADE_HOOKUP_OBJECT(PreferencesDialog, alignment26, "alignment26"); GLADE_HOOKUP_OBJECT(PreferencesDialog, hbox96, "hbox96"); GLADE_HOOKUP_OBJECT(PreferencesDialog, image26, "image26"); GLADE_HOOKUP_OBJECT(PreferencesDialog, label181, "label181"); GLADE_HOOKUP_OBJECT(PreferencesDialog, label171, "label171"); GLADE_HOOKUP_OBJECT_NO_REF(PreferencesDialog, dialog_action_area8, "dialog_action_area8"); GLADE_HOOKUP_OBJECT(PreferencesDialog, cancelbutton6, "cancelbutton6"); GLADE_HOOKUP_OBJECT(PreferencesDialog, okbutton8, "okbutton8"); GLADE_HOOKUP_OBJECT_NO_REF(PreferencesDialog, tooltips, "tooltips"); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(DebugCheckButton), MyConfig->GetBoolValue(CONFIG_APP_DEBUG)); const char *dir; char dirname[PATH_MAX]; dir = MyConfig->GetStringValue(CONFIG_APP_STREAM_DIRECTORY); if (dir != NULL) { gtk_entry_set_text(GTK_ENTRY(StreamDirectory), dir); } else { GetHomeDirectory(dirname); strcat(dirname, ".mp4live_d/Streams/"); gtk_entry_set_text(GTK_ENTRY(StreamDirectory), dirname); } dir = MyConfig->GetStringValue(CONFIG_APP_PROFILE_DIRECTORY); if (dir != NULL) { gtk_entry_set_text(GTK_ENTRY(ProfileDirectory), dir); } else { GetHomeDirectory(dirname); strcat(dirname, ".mp4live_d/"); gtk_entry_set_text(GTK_ENTRY(ProfileDirectory), dirname); } uint ttl = MyConfig->GetIntegerValue(CONFIG_RTP_MCAST_TTL); uint index; if (ttl <= 1) { index = 0; } else if (ttl <= 15) { index = 1; } else if (ttl <= 64) { index = 2; } else index = 3; gtk_option_menu_set_history(GTK_OPTION_MENU(MulticastTtlMenu), index); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(AllowRtcpCheck), MyConfig->GetBoolValue(CONFIG_RTP_NO_B_RR_0)); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(AllowSSMCheck), MyConfig->GetBoolValue(CONFIG_RTP_USE_SSM)); uint fstatus = MyConfig->GetIntegerValue(CONFIG_RECORD_MP4_FILE_STATUS); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(FileStatus1), fstatus == FILE_MP4_OVERWRITE); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(FileStatus2), fstatus == FILE_MP4_APPEND); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(FileStatus3), fstatus == FILE_MP4_CREATE_NEW); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(RecordHintTrackButton), MyConfig->GetBoolValue(CONFIG_RECORD_MP4_HINT_TRACKS)); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(OptimizeMP4FileButton), MyConfig->GetBoolValue(CONFIG_RECORD_MP4_OPTIMIZE)); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(RecordRawDataButton), MyConfig->GetBoolValue(CONFIG_RECORD_RAW_IN_MP4)); gtk_entry_set_text(GTK_ENTRY(RawFileName), MyConfig->GetStringValue(CONFIG_RECORD_RAW_MP4_FILE_NAME)); gtk_widget_show(PreferencesDialog); }
/** * gimp_option_menu_new: * @menu_only: %TRUE if the function should return a #GtkMenu only. * @...: A %NULL-terminated @va_list describing the menu items. * * Convenience function to create a #GtkOptionMenu or a #GtkMenu. * * Returns: A #GtkOptionMenu or a #GtkMenu (depending on @menu_only). **/ GtkWidget * gimp_option_menu_new (gboolean menu_only, /* specify menu items as va_list: * const gchar *label, * GCallback callback, * gpointer callback_data, * gpointer item_data, * GtkWidget **widget_ptr, * gboolean active */ ...) { GtkWidget *menu; GtkWidget *menuitem; /* menu item variables */ const gchar *label; GCallback callback; gpointer callback_data; gpointer item_data; GtkWidget **widget_ptr; gboolean active; va_list args; gint i; gint initial_index; menu = gtk_menu_new (); /* create the menu items */ initial_index = 0; va_start (args, menu_only); label = va_arg (args, const gchar *); for (i = 0; label; i++) { callback = va_arg (args, GCallback); callback_data = va_arg (args, gpointer); item_data = va_arg (args, gpointer); widget_ptr = va_arg (args, GtkWidget **); active = va_arg (args, gboolean); if (strcmp (label, "---")) { menuitem = gtk_menu_item_new_with_label (label); g_signal_connect (menuitem, "activate", callback, callback_data); if (item_data) { g_object_set_data (G_OBJECT (menuitem), "gimp-item-data", item_data); /* backward compat */ g_object_set_data (G_OBJECT (menuitem), "user_data", item_data); } } else { menuitem = gtk_menu_item_new (); gtk_widget_set_sensitive (menuitem, FALSE); } gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); if (widget_ptr) *widget_ptr = menuitem; gtk_widget_show (menuitem); /* remember the initial menu item */ if (active) initial_index = i; label = va_arg (args, const gchar *); } va_end (args); if (! menu_only) { GtkWidget *optionmenu; optionmenu = gtk_option_menu_new (); gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu), menu); /* select the initial menu item */ gtk_option_menu_set_history (GTK_OPTION_MENU (optionmenu), initial_index); return optionmenu; } return menu; }
void key_dialog_show () { GtkWidget *vbox, *hbox, *list, *vbox2, *wid, *wid2, *wid3, *hbox2; struct key_binding *kb; gchar *titles[] = { NULL, NULL, NULL, "1", "2" }; char temp[32]; int i; titles[0] = _("Mod"); titles[1] = _("Key"); titles[2] = _("Action"); if (key_dialog) { mg_bring_tofront (key_dialog); return; } key_dialog = mg_create_generic_tab ("editkeys", _(DISPLAY_NAME": Keyboard Shortcuts"), TRUE, FALSE, key_dialog_close, NULL, 560, 330, &vbox, 0); hbox = gtk_hbox_new (0, 2); gtk_box_pack_start (GTK_BOX (vbox), hbox, 1, 1, 0); list = gtkutil_clist_new (5, titles, hbox, 0, key_dialog_sel_row, 0, NULL, 0, GTK_SELECTION_SINGLE); gtk_widget_set_usize (list, 400, 0); key_dialog_kb_clist = list; gtk_widget_show (hbox); kb = keys_root; gtk_clist_set_column_width (GTK_CLIST (list), 1, 50); gtk_clist_set_column_width (GTK_CLIST (list), 2, 120); gtk_clist_set_column_width (GTK_CLIST (list), 3, 50); gtk_clist_set_column_width (GTK_CLIST (list), 4, 50); while (kb) { titles[0] = key_make_mod_str (kb->mod, temp); titles[1] = kb->keyname; if (kb->action < 0 || kb->action > KEY_MAX_ACTIONS) titles[2] = _("<none>"); else titles[2] = key_actions[kb->action].name; if (kb->data1) titles[3] = kb->data1; else titles[3] = _("<none>"); if (kb->data2) titles[4] = kb->data2; else titles[4] = _("<none>"); gtk_clist_set_row_data (GTK_CLIST (list), gtk_clist_append (GTK_CLIST (list), titles), kb); kb = kb->next; } vbox2 = gtk_vbox_new (0, 2); gtk_box_pack_end (GTK_BOX (hbox), vbox2, 1, 1, 0); wid = gtk_button_new_with_label (_("Add New")); gtk_box_pack_start (GTK_BOX (vbox2), wid, 0, 0, 0); gtk_signal_connect (GTK_OBJECT (wid), "clicked", GTK_SIGNAL_FUNC (key_dialog_add_new), list); gtk_widget_show (wid); wid = gtk_button_new_with_label (_("Delete")); gtk_box_pack_start (GTK_BOX (vbox2), wid, 0, 0, 0); gtk_signal_connect (GTK_OBJECT (wid), "clicked", GTK_SIGNAL_FUNC (key_dialog_delete), list); gtk_widget_show (wid); gtk_widget_show (vbox2); wid = gtk_option_menu_new (); wid2 = gtk_menu_new (); for (i = 0; i <= KEY_MAX_ACTIONS; i++) { wid3 = gtk_menu_item_new_with_label (_(key_actions[i].name)); gtk_widget_show (wid3); gtk_menu_shell_append (GTK_MENU_SHELL (wid2), wid3); gtk_signal_connect (GTK_OBJECT (wid3), "activate", GTK_SIGNAL_FUNC (key_dialog_sel_act), GINT_TO_POINTER (i)); } gtk_option_menu_set_menu (GTK_OPTION_MENU (wid), wid2); gtk_option_menu_set_history (GTK_OPTION_MENU (wid), 0); gtk_box_pack_end (GTK_BOX (vbox2), wid, 0, 0, 0); gtk_widget_show (wid); key_dialog_act_menu = wid; key_dialog_tog_s = key_dialog_make_toggle (_("Shift"), key_dialog_tog_key, (void *) STATE_SHIFT, vbox2); key_dialog_tog_a = key_dialog_make_toggle (_("Alt"), key_dialog_tog_key, (void *) STATE_ALT, vbox2); key_dialog_tog_c = key_dialog_make_toggle (_("Ctrl"), key_dialog_tog_key, (void *) STATE_CTRL, vbox2); key_dialog_ent_key = key_dialog_make_entry (_("Key"), "key_press_event", key_dialog_set_key, NULL, vbox2); key_dialog_ent_d1 = key_dialog_make_entry (_("Data 1"), "activate", key_dialog_set_data, NULL, vbox2); key_dialog_ent_d2 = key_dialog_make_entry (_("Data 2"), "activate", key_dialog_set_data, (void *) 1, vbox2); hbox2 = gtk_hbox_new (0, 2); gtk_box_pack_end (GTK_BOX (vbox), hbox2, 0, 0, 1); wid = gtk_xtext_new (colors, 0); gtk_xtext_set_tint (GTK_XTEXT (wid), prefs.tint_red, prefs.tint_green, prefs.tint_blue); gtk_xtext_set_background (GTK_XTEXT (wid), channelwin_pix, prefs.transparent); gtk_widget_set_usize (wid, 0, 75); gtk_box_pack_start (GTK_BOX (hbox2), wid, 1, 1, 1); gtk_xtext_set_font (GTK_XTEXT (wid), prefs.font_normal); gtk_widget_show (wid); wid2 = gtk_vscrollbar_new (GTK_XTEXT (wid)->adj); gtk_box_pack_start (GTK_BOX (hbox2), wid2, 0, 0, 0); gtk_widget_show (wid2); gtk_widget_show (hbox2); key_dialog_text = wid; gtk_widget_show_all (key_dialog); }
/* * ctk_dithering_controls_setup() - Setup routine for dithering attributes. Used * in DFP setup stage as well as for updating the GUI when there is change in * dithering mode or config (enabled/disabled). */ void ctk_dithering_controls_setup(CtkDitheringControls *ctk_dithering_controls) { GtkWidget *menu, *menu_item = NULL; gint val, i; if (!ctk_dithering_controls) { return; } /* dithering */ if (NvCtrlSuccess != NvCtrlGetAttribute(ctk_dithering_controls->handle, NV_CTRL_DITHERING, &val)) { val = NV_CTRL_DITHERING_AUTO; } g_signal_handlers_block_by_func (G_OBJECT(ctk_dithering_controls->dithering_config_menu), G_CALLBACK(dithering_config_menu_changed), (gpointer) ctk_dithering_controls); gtk_option_menu_set_history (GTK_OPTION_MENU(ctk_dithering_controls->dithering_config_menu), val); g_signal_handlers_unblock_by_func (G_OBJECT(ctk_dithering_controls->dithering_config_menu), G_CALLBACK(dithering_config_menu_changed), (gpointer) ctk_dithering_controls); /* setup dithering modes */ build_dithering_mode_table(ctk_dithering_controls); /* populate dropdown list for dithering modes */ menu = gtk_menu_new(); for (i = 0; i < ctk_dithering_controls->dithering_mode_table_size; i++) { switch (ctk_dithering_controls->dithering_mode_table[i]) { case NV_CTRL_DITHERING_MODE_DYNAMIC_2X2: menu_item = gtk_menu_item_new_with_label("Dynamic 2x2"); break; case NV_CTRL_DITHERING_MODE_STATIC_2X2: menu_item = gtk_menu_item_new_with_label("Static 2x2"); break; case NV_CTRL_DITHERING_MODE_TEMPORAL: menu_item = gtk_menu_item_new_with_label("Temporal"); break; default: case NV_CTRL_DITHERING_MODE_AUTO: menu_item = gtk_menu_item_new_with_label("Auto"); break; } gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item); gtk_widget_show(menu_item); } g_signal_handlers_block_by_func (G_OBJECT(ctk_dithering_controls->dithering_mode_menu), G_CALLBACK(dithering_mode_menu_changed), (gpointer) ctk_dithering_controls); gtk_option_menu_set_menu (GTK_OPTION_MENU(ctk_dithering_controls->dithering_mode_menu), menu); g_signal_handlers_unblock_by_func (G_OBJECT(ctk_dithering_controls->dithering_mode_menu), G_CALLBACK(dithering_mode_menu_changed), (gpointer) ctk_dithering_controls); if (!update_dithering_info((gpointer)ctk_dithering_controls)) { gtk_widget_hide(ctk_dithering_controls->dithering_controls_box); } else { gtk_widget_show(ctk_dithering_controls->dithering_controls_box); } setup_reset_button(ctk_dithering_controls); } /* ctk_dithering_controls_setup() */
static void setup_romaji_theme_menu (GtkOptionMenu *omenu) { GtkWidget *menu = gtk_menu_new (); gtk_option_menu_set_menu (GTK_OPTION_MENU (omenu), menu); gtk_widget_show (menu); // create menu items GtkWidget *menuitem = gtk_menu_item_new_with_label (_("User defined")); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); menuitem = gtk_menu_item_new_with_label (_("Default")); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); gtk_widget_show (menuitem); StyleFiles::iterator it; unsigned int i; for (i = 0, it = __style_list.begin (); it != __style_list.end (); i++, it++) { StyleLines section; if (!it->get_entry_list (section, __romaji_fund_table)) continue; menuitem = gtk_menu_item_new_with_label (_(it->get_title().c_str())); g_object_set_data (G_OBJECT (menuitem), INDEX_KEY, GINT_TO_POINTER (i)); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); gtk_widget_show (menuitem); } // set default value g_signal_handlers_block_by_func ( G_OBJECT (omenu), (gpointer) (on_romaji_theme_menu_changed), NULL); gtk_option_menu_set_history (GTK_OPTION_MENU (omenu), ROMAJI_THEME_INDEX_DEFAULT); if (__config_romaji_theme_file == __user_style_file.get_file_name ()) { gtk_option_menu_set_history (GTK_OPTION_MENU (omenu), ROMAJI_THEME_INDEX_USER_DEFINED); } else { GList *node, *list = gtk_container_get_children (GTK_CONTAINER (menu)); for (i = 2, node = g_list_next (g_list_next (list)); node; i++, node = g_list_next (node)) { gint idx = GPOINTER_TO_INT ( g_object_get_data (G_OBJECT (node->data), INDEX_KEY)); if (__style_list[idx].get_file_name () == __config_romaji_theme_file) { gtk_option_menu_set_history (GTK_OPTION_MENU (omenu), i); break; } } } g_signal_handlers_unblock_by_func ( G_OBJECT (omenu), (gpointer) (on_romaji_theme_menu_changed), NULL); }