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