static GtkWidget *toolbar_add_zoom(GtkWidget *box) // Add zoom combo box
{
int i;
static char *txt[] = { "10%", "20%", "25%", "33%", "50%", "100%",
"200%", "300%", "400%", "800%", "1200%", "1600%", "2000%", NULL };
GtkWidget *combo, *combo_entry;
GList *combo_list = NULL;
combo = gtk_combo_new();
gtk_combo_set_value_in_list (GTK_COMBO (combo), FALSE, FALSE);
gtk_widget_show (combo);
combo_entry = GTK_COMBO (combo)->entry;
GTK_WIDGET_UNSET_FLAGS (combo_entry, GTK_CAN_FOCUS);
gtk_widget_set_usize(GTK_COMBO(combo)->button, 18, -1);
#if GTK_MAJOR_VERSION == 1
gtk_widget_set_usize(combo, 75, -1);
#else /* #if GTK_MAJOR_VERSION == 2 */
gtk_entry_set_width_chars(GTK_ENTRY(combo_entry), 6);
#endif
gtk_entry_set_editable( GTK_ENTRY(combo_entry), FALSE );
for ( i=0; txt[i]; i++ ) combo_list = g_list_append( combo_list, txt[i] );
gtk_combo_set_popdown_strings( GTK_COMBO(combo), combo_list );
g_list_free( combo_list );
gtk_entry_set_text( GTK_ENTRY(combo_entry), "100%" );
pack(box, combo);
return (combo);
}
_HYPlatformPullDown::_HYPlatformPullDown(void)
{
_HYPullDown * parent = (_HYPullDown*)this;
theMenu = gtk_combo_new ();
backFill = HYColorToGDKColor((_HYColor) {
255,255,255
});
gtk_combo_set_value_in_list (GTK_COMBO(theMenu),true,false);
gtk_container_add(GTK_CONTAINER(parent->parentWindow),theMenu);
gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(theMenu)->entry),false);
GList* children = gtk_container_get_children(GTK_CONTAINER(theMenu));
g_signal_connect (GTK_WIDGET(children->next->data),"event",(GCallback)hy_pulldown_selection_start_callback_event,(_HYPullDown*)this);
g_signal_connect (GTK_COMBO(theMenu)->entry,"changed",(GCallback)hy_pulldown_selection_callback,(_HYPullDown*)this);
g_signal_connect (GTK_COMBO(theMenu)->popwin,"hide",(GCallback)hy_pulldown_unmap_event,(_HYPullDown*)this);
g_list_free (children);
//gtk_container_set_resize_mode(GTK_CONTAINER(theMenu), GTK_RESIZE_IMMEDIATE);
selection = 0;
cbSelection = -1;
if (!defaultPullDownFontPD) {
defaultPullDownFontPD = pango_font_description_new();
defaultPullDownFont.size = defaultPullDownFont.size*fontConversionFactor;
HYFont2PangoFontDesc (defaultPullDownFont,defaultPullDownFontPD);
}
gtk_widget_modify_font (theMenu, defaultPullDownFontPD);
gtk_widget_modify_font (GTK_COMBO(theMenu)->entry, defaultPullDownFontPD);
gtk_widget_show (theMenu);
//g_signal_connect (GTK_COMBO(theMenu)->entry,"changed",hy_pulldown_selection_callback,(_HYPullDown*)this);
}
GtkWidget *
make_families_menu ()
{
GtkWidget *combo;
int n_families;
PangoFontFamily **families;
GList *family_list = NULL;
int i;
pango_context_list_families (context, &families, &n_families);
qsort (families, n_families, sizeof(char *), cmp_families);
for (i=0; i<n_families; i++)
family_list = g_list_prepend (family_list, pango_font_family_get_name (families[i]));
family_list = g_list_reverse (family_list);
combo = gtk_combo_new ();
gtk_combo_set_popdown_strings (GTK_COMBO (combo), family_list);
gtk_combo_set_value_in_list (GTK_COMBO (combo), TRUE, FALSE);
gtk_editable_set_editable (GTK_EDITABLE (GTK_COMBO (combo)->entry), FALSE);
gtk_entry_set_text (GTK_ENTRY (GTK_COMBO (combo)->entry), pango_font_description_get_family(font_description));
gtk_signal_connect (GTK_OBJECT (GTK_COMBO (combo)->entry), "changed",
GTK_SIGNAL_FUNC (set_family), NULL);
g_list_free (family_list);
return combo;
}
void
gb_label_create_standard_properties (GtkWidget * widget,
GbWidgetCreateArgData * data,
const char *label_p,
const char *use_underline_p,
const char *use_markup_p,
const char *justify_p,
const char *wrap_p,
const char *selectable_p,
const char *xalign_p,
const char *yalign_p,
const char *xpad_p,
const char *ypad_p,
const char *focus_target_p)
{
GtkWidget *combo;
property_add_text (label_p, _("Label:"), _("The text to display"), 2);
property_add_bool (use_underline_p, _("Use Underline:"),
_("If the text includes an underlined accelerator character"));
property_add_bool (use_markup_p, _("Use Markup:"),
_("If the text includes pango markup"));
property_add_choice (justify_p, _("Justify:"),
_("The justification of the lines of the label"),
GbJustifyChoices);
property_add_bool (wrap_p, _("Wrap Text:"),
_("If the text is wrapped to fit within the width of the label"));
property_add_bool (selectable_p, _("Selectable:"),
_("If the label text can be selected with the mouse"));
property_add_float_range (xalign_p, _("X Align:"),
_("The horizontal alignment of the entire label"),
0, 1, 0.01, 0.1, 0.01, 2);
property_add_float_range (yalign_p, _("Y Align:"),
_("The vertical alignment of the entire label"),
0, 1, 0.01, 0.1, 0.01, 2);
property_add_int_range (xpad_p, _("X Pad:"), _("The horizontal padding"),
0, 1000, 1, 10, 1);
property_add_int_range (ypad_p, _("Y Pad:"), _("The vertical padding"),
0, 1000, 1, 10, 1);
property_add_combo (focus_target_p, _("Focus Target:"),
_("The widget to set the keyboard focus to when the underlined accelerator key is used"),
NULL);
combo = property_get_value_widget (focus_target_p);
gtk_editable_set_editable (GTK_EDITABLE (GTK_COMBO (combo)->entry), FALSE);
gtk_combo_set_value_in_list (GTK_COMBO (combo), TRUE, TRUE);
}
static GtkWidget *
make_styles_combo ()
{
GtkWidget *combo;
combo = gtk_combo_new ();
gtk_combo_set_value_in_list (GTK_COMBO (combo), TRUE, FALSE);
gtk_editable_set_editable (GTK_EDITABLE (GTK_COMBO (combo)->entry), FALSE);
gtk_signal_connect (GTK_OBJECT (GTK_COMBO (combo)->entry), "changed",
GTK_SIGNAL_FUNC (set_style), NULL);
styles_combo = combo;
fill_styles_combo (combo);
return combo;
}
static void
limited_int_build(node_gui_t *ng, gboolean ishex)
{
unsigned long i;
GtkWidget *listw;
const GList *list;
ng->combo = gtk_combo_new();
gtk_combo_set_value_in_list(GTK_COMBO(ng->combo), TRUE, FALSE);
gtk_combo_set_use_arrows(GTK_COMBO(ng->combo), FALSE);
ng->entry = GTK_COMBO(ng->combo)->entry;
gtk_entry_set_editable(GTK_ENTRY(ng->entry), FALSE);
gtk_signal_connect(GTK_OBJECT(ng->entry), "changed",
GTK_SIGNAL_FUNC(on_limited_int_combo_changed), ng);
listw = GTK_COMBO(ng->combo)->list;
gtk_list_clear_items(GTK_LIST(listw), 0, -1);
list = cml_node_get_enumdefs(ng->node);
if (list != 0)
{
for ( ; list != 0 ; list = list->next)
{
cml_enumdef *ed = (cml_enumdef *)list->data;
add_list_entry(listw, cml_node_get_banner(ed->symbol), ed->value);
}
}
else
{
for (list = cml_node_get_range(ng->node) ; list != 0 ; list = list->next)
{
cml_subrange *sr = (cml_subrange *)list->data;
for (i = sr->begin ; i <= sr->end ; i++)
{
char valuebuf[32];
sprintf(valuebuf, (ishex ? "0x%lX" : "%ld"), i);
add_list_entry(listw, valuebuf, i);
}
}
}
node_gui_attach_widget(ng, ng->combo, VALUE);
}
/* the text in the entry must be or not be in the list */
int
clip_GTK_COMBOSETVALUEINLIST(ClipMachine * ClipMachineMemory)
{
C_widget *ccmb = _fetch_cw_arg(ClipMachineMemory);
gint val = _clip_parl(ClipMachineMemory, 2);
gint ok_if_empty = _clip_parl(ClipMachineMemory, 3);
CHECKCWID(ccmb, GTK_IS_COMBO);
CHECKOPT(2, LOGICAL_type_of_ClipVarType);
CHECKOPT(2, LOGICAL_type_of_ClipVarType);
if (_clip_parinfo(ClipMachineMemory, 2) == UNDEF_type_of_ClipVarType)
val = TRUE;
if (_clip_parinfo(ClipMachineMemory, 3) == UNDEF_type_of_ClipVarType)
ok_if_empty = FALSE;
gtk_combo_set_value_in_list(GTK_COMBO(ccmb->widget), val, ok_if_empty);
return 0;
err:
return 1;
}
static GtkWidget *
create_others_note(void)
{
static const char *sasi_drive_str[16] = {
"0", "1", "2", "3", "4", "5", "6", "7", "8",
"9", "10", "11", "12", "13", "14", "15",
};
static sasi_hdd_t sasi_hdd = { 0, 0 };
GtkWidget *w;
GtkWidget *frame;
GtkWidget *align;
GtkWidget *table;
GtkWidget *label;
GtkWidget *combo;
GtkWidget *entry;
GtkWidget *button;
GList *items;
int i;
w = gtk_vbox_new(FALSE, 3);
frame = gtk_frame_new("HDD (SASI) Drive");
gtk_box_pack_start(GTK_BOX(w), frame, FALSE, FALSE, 0);
gtk_widget_show(frame);
align = gtk_alignment_new(0.5, 0.5, 0.9, 0.9);
gtk_container_add(GTK_CONTAINER(frame), align);
gtk_widget_show(align);
table = gtk_table_new(2, 5, FALSE);
gtk_container_add(GTK_CONTAINER(align), table);
gtk_widget_show(table);
label = gtk_label_new("Drive #:");
gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 0, 1);
gtk_widget_show(label);
combo = gtk_combo_new();
gtk_combo_set_value_in_list(GTK_COMBO(combo), TRUE, TRUE);
gtk_combo_set_use_arrows_always(GTK_COMBO(combo), TRUE);
for (items = 0, i = 0; i < NELEMENTS(sasi_drive_str); ++i)
items = g_list_append(items, (gpointer)sasi_drive_str[i]);
gtk_combo_set_popdown_strings(GTK_COMBO(combo), items);
g_list_free(items);
gtk_table_attach_defaults(GTK_TABLE(table), combo, 1, 2, 0, 1);
gtk_widget_show(combo);
entry = GTK_COMBO(combo)->entry;
gtk_entry_set_editable(GTK_ENTRY(entry), FALSE);
gtk_signal_connect(GTK_OBJECT(entry), "changed",
GTK_SIGNAL_FUNC(others_sasi_hdd_index_entry_changed),
&sasi_hdd);
gtk_widget_show(entry);
button = gtk_button_new_with_label("Remove");
gtk_container_set_border_width(GTK_CONTAINER(button), 5);
gtk_table_attach_defaults(GTK_TABLE(table), button, 3, 4, 0, 1);
gtk_signal_connect(GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(others_sasi_hdd_remove_button_clicked),
&sasi_hdd);
gtk_widget_show(button);
button = gtk_button_new_with_label("New");
gtk_container_set_border_width(GTK_CONTAINER(button), 5);
gtk_table_attach_defaults(GTK_TABLE(table), button, 4, 5, 0, 1);
gtk_signal_connect(GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(others_sasi_hdd_new_button_clicked),
&sasi_hdd);
#if 1
gtk_widget_set_sensitive(button, FALSE);
#endif
gtk_widget_show(button);
label = gtk_label_new("Filename:");
gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 1, 2);
gtk_widget_show(label);
sasi_hdd.entry = entry = gtk_entry_new();
gtk_entry_set_max_length(GTK_ENTRY(entry), MAX_PATH - 1);
gtk_entry_set_editable(GTK_ENTRY(entry), FALSE);
gtk_table_attach_defaults(GTK_TABLE(table), entry, 1, 4, 1, 2);
gtk_widget_show(entry);
gtk_entry_set_text(GTK_ENTRY(entry), Config.HDImage[0]);
button = gtk_button_new_with_label("Browse...");
gtk_container_set_border_width(GTK_CONTAINER(button), 5);
gtk_table_attach_defaults(GTK_TABLE(table), button, 4, 5, 1, 2);
gtk_signal_connect(GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(others_sasi_hdd_browse_button_clicked),
&sasi_hdd);
gtk_widget_show(button);
button = gtk_check_button_new_with_label("Show FDD status");
gtk_container_set_border_width(GTK_CONTAINER(button), 5);
gtk_box_pack_start(GTK_BOX(w), button, FALSE, FALSE, 0);
gtk_signal_connect(GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(others_show_fdd_status_button_clicked), 0);
#if 1
gtk_widget_set_sensitive(button, FALSE);
#else
if (Config.WindowFDDStat)
gtk_signal_emit_by_name(GTK_OBJECT(button), "clicked");
#endif
gtk_widget_show(button);
button = gtk_check_button_new_with_label("Enable SRAM virus warning");
gtk_container_set_border_width(GTK_CONTAINER(button), 5);
gtk_box_pack_start(GTK_BOX(w), button, FALSE, FALSE, 0);
gtk_signal_connect(GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(others_enable_virus_button_clicked), 0);
if (Config.SRAMWarning)
gtk_signal_emit_by_name(GTK_OBJECT(button), "clicked");
gtk_widget_show(button);
return w;
}
void FLAC_XMMS__configure(void)
{
GtkWidget *title_frame, *title_tag_vbox, *title_tag_label;
GtkWidget *replaygain_frame, *resolution_frame, *output_vbox, *resolution_normal_frame, *resolution_replaygain_frame;
GtkWidget *replaygain_vbox, *resolution_hbox, *resolution_normal_vbox, *resolution_replaygain_vbox;
GtkWidget *resolution_replaygain_noise_shaping_vbox;
GtkWidget *resolution_replaygain_bps_out_vbox;
GtkWidget *label, *hbox;
GtkWidget *bbox, *ok, *cancel;
GList *list;
GtkWidget *streaming_vbox;
GtkWidget *streaming_buf_frame, *streaming_buf_hbox;
GtkWidget *streaming_size_box, *streaming_size_label, *streaming_size_spin;
GtkWidget *streaming_pre_box, *streaming_pre_label, *streaming_pre_spin;
GtkWidget *streaming_proxy_frame, *streaming_proxy_vbox;
GtkWidget *streaming_proxy_port_label, *streaming_proxy_host_label;
GtkWidget *streaming_save_frame, *streaming_save_vbox;
GtkWidget *streaming_save_label, *streaming_save_browse;
#ifdef FLAC_ICECAST
GtkWidget *streaming_cast_frame, *streaming_cast_vbox;
#endif
char *temp;
if (flac_configurewin != NULL) {
gdk_window_raise(flac_configurewin->window);
return;
}
flac_configurewin = gtk_window_new(GTK_WINDOW_DIALOG);
gtk_signal_connect(GTK_OBJECT(flac_configurewin), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &flac_configurewin);
gtk_signal_connect(GTK_OBJECT(flac_configurewin), "destroy", GTK_SIGNAL_FUNC(configure_destroy), &flac_configurewin);
gtk_window_set_title(GTK_WINDOW(flac_configurewin), _("Flac Configuration"));
gtk_window_set_policy(GTK_WINDOW(flac_configurewin), FALSE, FALSE, FALSE);
gtk_container_border_width(GTK_CONTAINER(flac_configurewin), 10);
vbox = gtk_vbox_new(FALSE, 10);
gtk_container_add(GTK_CONTAINER(flac_configurewin), vbox);
notebook = gtk_notebook_new();
gtk_box_pack_start(GTK_BOX(vbox), notebook, TRUE, TRUE, 0);
/* Title config.. */
title_frame = gtk_frame_new(_("Tag Handling"));
gtk_container_border_width(GTK_CONTAINER(title_frame), 5);
title_tag_vbox = gtk_vbox_new(FALSE, 10);
gtk_container_border_width(GTK_CONTAINER(title_tag_vbox), 5);
gtk_container_add(GTK_CONTAINER(title_frame), title_tag_vbox);
/* Convert Char Set */
convert_char_set = gtk_check_button_new_with_label(_("Convert Character Set"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(convert_char_set), flac_cfg.title.convert_char_set);
gtk_signal_connect(GTK_OBJECT(convert_char_set), "clicked", convert_char_set_cb, NULL);
gtk_box_pack_start(GTK_BOX(title_tag_vbox), convert_char_set, FALSE, FALSE, 0);
/* Combo boxes... */
hbox = gtk_hbox_new(FALSE,4);
gtk_container_add(GTK_CONTAINER(title_tag_vbox),hbox);
label = gtk_label_new(_("Convert character set from :"));
gtk_box_pack_start(GTK_BOX(hbox),label,FALSE,FALSE,0);
fileCharacterSetEntry = gtk_combo_new();
gtk_box_pack_start(GTK_BOX(hbox),fileCharacterSetEntry,TRUE,TRUE,0);
label = gtk_label_new (_("to :"));
gtk_box_pack_start(GTK_BOX(hbox),label,FALSE,FALSE,0);
userCharacterSetEntry = gtk_combo_new();
gtk_box_pack_start(GTK_BOX(hbox),userCharacterSetEntry,TRUE,TRUE,0);
gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(fileCharacterSetEntry)->entry),FALSE);
gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(userCharacterSetEntry)->entry),FALSE);
gtk_combo_set_value_in_list(GTK_COMBO(fileCharacterSetEntry),TRUE,FALSE);
gtk_combo_set_value_in_list(GTK_COMBO(userCharacterSetEntry),TRUE,FALSE);
list = Charset_Create_List();
gtk_combo_set_popdown_strings(GTK_COMBO(fileCharacterSetEntry),Charset_Create_List_UTF8_Only());
gtk_combo_set_popdown_strings(GTK_COMBO(userCharacterSetEntry),list);
gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(userCharacterSetEntry)->entry),Charset_Get_Title_From_Name(flac_cfg.title.user_char_set));
gtk_widget_set_sensitive(fileCharacterSetEntry, FALSE);
gtk_widget_set_sensitive(userCharacterSetEntry, flac_cfg.title.convert_char_set);
/* Override Tagging Format */
title_tag_override = gtk_check_button_new_with_label(_("Override generic titles"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(title_tag_override), flac_cfg.title.tag_override);
gtk_signal_connect(GTK_OBJECT(title_tag_override), "clicked", title_tag_override_cb, NULL);
gtk_box_pack_start(GTK_BOX(title_tag_vbox), title_tag_override, FALSE, FALSE, 0);
title_tag_box = gtk_hbox_new(FALSE, 5);
gtk_widget_set_sensitive(title_tag_box, flac_cfg.title.tag_override);
gtk_box_pack_start(GTK_BOX(title_tag_vbox), title_tag_box, FALSE, FALSE, 0);
title_tag_label = gtk_label_new(_("Title format:"));
gtk_box_pack_start(GTK_BOX(title_tag_box), title_tag_label, FALSE, FALSE, 0);
title_tag_entry = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(title_tag_entry), flac_cfg.title.tag_format);
gtk_box_pack_start(GTK_BOX(title_tag_box), title_tag_entry, TRUE, TRUE, 0);
title_desc = xmms_titlestring_descriptions("pafFetnygc", 2);
gtk_widget_set_sensitive(title_desc, flac_cfg.title.tag_override);
gtk_box_pack_start(GTK_BOX(title_tag_vbox), title_desc, FALSE, FALSE, 0);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), title_frame, gtk_label_new(_("Title")));
/* Output config.. */
output_vbox = gtk_vbox_new(FALSE, 10);
gtk_container_border_width(GTK_CONTAINER(output_vbox), 5);
/* replaygain */
replaygain_frame = gtk_frame_new(_("ReplayGain"));
gtk_container_border_width(GTK_CONTAINER(replaygain_frame), 5);
gtk_box_pack_start(GTK_BOX(output_vbox), replaygain_frame, TRUE, TRUE, 0);
replaygain_vbox = gtk_vbox_new(FALSE, 10);
gtk_container_border_width(GTK_CONTAINER(replaygain_vbox), 5);
gtk_container_add(GTK_CONTAINER(replaygain_frame), replaygain_vbox);
replaygain_enable = gtk_check_button_new_with_label(_("Enable ReplayGain processing"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(replaygain_enable), flac_cfg.output.replaygain.enable);
gtk_signal_connect(GTK_OBJECT(replaygain_enable), "clicked", replaygain_enable_cb, NULL);
gtk_box_pack_start(GTK_BOX(replaygain_vbox), replaygain_enable, FALSE, FALSE, 0);
replaygain_album_mode = gtk_check_button_new_with_label(_("Album mode"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(replaygain_album_mode), flac_cfg.output.replaygain.album_mode);
gtk_signal_connect(GTK_OBJECT(replaygain_album_mode), "clicked", replaygain_album_mode_cb, NULL);
gtk_box_pack_start(GTK_BOX(replaygain_vbox), replaygain_album_mode, FALSE, FALSE, 0);
hbox = gtk_hbox_new(FALSE,3);
gtk_container_add(GTK_CONTAINER(replaygain_vbox),hbox);
label = gtk_label_new(_("Preamp:"));
gtk_box_pack_start(GTK_BOX(hbox),label,FALSE,FALSE,0);
replaygain_preamp = gtk_adjustment_new(flac_cfg.output.replaygain.preamp, -24.0, +24.0, 1.0, 6.0, 0.0);
gtk_signal_connect(GTK_OBJECT(replaygain_preamp), "value-changed", replaygain_preamp_cb, NULL);
replaygain_preamp_hscale = gtk_hscale_new(GTK_ADJUSTMENT(replaygain_preamp));
gtk_scale_set_draw_value(GTK_SCALE(replaygain_preamp_hscale), FALSE);
gtk_box_pack_start(GTK_BOX(hbox),replaygain_preamp_hscale,TRUE,TRUE,0);
replaygain_preamp_label = gtk_label_new(_("0 dB"));
gtk_box_pack_start(GTK_BOX(hbox),replaygain_preamp_label,FALSE,FALSE,0);
gtk_adjustment_value_changed(GTK_ADJUSTMENT(replaygain_preamp));
replaygain_hard_limit = gtk_check_button_new_with_label(_("6dB hard limiting"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(replaygain_hard_limit), flac_cfg.output.replaygain.hard_limit);
gtk_signal_connect(GTK_OBJECT(replaygain_hard_limit), "clicked", replaygain_hard_limit_cb, NULL);
gtk_box_pack_start(GTK_BOX(replaygain_vbox), replaygain_hard_limit, FALSE, FALSE, 0);
replaygain_enable_cb(replaygain_enable, NULL);
/* resolution */
resolution_frame = gtk_frame_new(_("Resolution"));
gtk_container_border_width(GTK_CONTAINER(resolution_frame), 5);
gtk_box_pack_start(GTK_BOX(output_vbox), resolution_frame, TRUE, TRUE, 0);
resolution_hbox = gtk_hbox_new(FALSE, 10);
gtk_container_border_width(GTK_CONTAINER(resolution_hbox), 5);
gtk_container_add(GTK_CONTAINER(resolution_frame), resolution_hbox);
resolution_normal_frame = gtk_frame_new(_("Without ReplayGain"));
gtk_container_border_width(GTK_CONTAINER(resolution_normal_frame), 5);
gtk_box_pack_start(GTK_BOX(resolution_hbox), resolution_normal_frame, TRUE, TRUE, 0);
resolution_normal_vbox = gtk_vbox_new(FALSE, 10);
gtk_container_border_width(GTK_CONTAINER(resolution_normal_vbox), 5);
gtk_container_add(GTK_CONTAINER(resolution_normal_frame), resolution_normal_vbox);
resolution_normal_dither_24_to_16 = gtk_check_button_new_with_label(_("Dither 24bps to 16bps"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(resolution_normal_dither_24_to_16), flac_cfg.output.resolution.normal.dither_24_to_16);
gtk_signal_connect(GTK_OBJECT(resolution_normal_dither_24_to_16), "clicked", resolution_normal_dither_24_to_16_cb, NULL);
gtk_box_pack_start(GTK_BOX(resolution_normal_vbox), resolution_normal_dither_24_to_16, FALSE, FALSE, 0);
resolution_replaygain_frame = gtk_frame_new(_("With ReplayGain"));
gtk_container_border_width(GTK_CONTAINER(resolution_replaygain_frame), 5);
gtk_box_pack_start(GTK_BOX(resolution_hbox), resolution_replaygain_frame, TRUE, TRUE, 0);
resolution_replaygain_vbox = gtk_vbox_new(FALSE, 10);
gtk_container_border_width(GTK_CONTAINER(resolution_replaygain_vbox), 5);
gtk_container_add(GTK_CONTAINER(resolution_replaygain_frame), resolution_replaygain_vbox);
resolution_replaygain_dither = gtk_check_button_new_with_label(_("Enable dithering"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(resolution_replaygain_dither), flac_cfg.output.resolution.replaygain.dither);
gtk_signal_connect(GTK_OBJECT(resolution_replaygain_dither), "clicked", resolution_replaygain_dither_cb, NULL);
gtk_box_pack_start(GTK_BOX(resolution_replaygain_vbox), resolution_replaygain_dither, FALSE, FALSE, 0);
hbox = gtk_hbox_new(FALSE, 10);
gtk_container_border_width(GTK_CONTAINER(hbox), 5);
gtk_box_pack_start(GTK_BOX(resolution_replaygain_vbox), hbox, TRUE, TRUE, 0);
resolution_replaygain_noise_shaping_frame = gtk_frame_new(_("Noise shaping"));
gtk_container_border_width(GTK_CONTAINER(resolution_replaygain_noise_shaping_frame), 5);
gtk_box_pack_start(GTK_BOX(hbox), resolution_replaygain_noise_shaping_frame, TRUE, TRUE, 0);
resolution_replaygain_noise_shaping_vbox = gtk_vbutton_box_new();
gtk_container_border_width(GTK_CONTAINER(resolution_replaygain_noise_shaping_vbox), 5);
gtk_container_add(GTK_CONTAINER(resolution_replaygain_noise_shaping_frame), resolution_replaygain_noise_shaping_vbox);
resolution_replaygain_noise_shaping_radio_none = gtk_radio_button_new_with_label(NULL, _("none"));
if(flac_cfg.output.resolution.replaygain.noise_shaping == 0)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(resolution_replaygain_noise_shaping_radio_none), TRUE);
gtk_signal_connect(GTK_OBJECT(resolution_replaygain_noise_shaping_radio_none), "clicked", resolution_replaygain_noise_shaping_cb, NULL);
gtk_container_add(GTK_CONTAINER(resolution_replaygain_noise_shaping_vbox), resolution_replaygain_noise_shaping_radio_none);
resolution_replaygain_noise_shaping_radio_low = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(resolution_replaygain_noise_shaping_radio_none), _("low"));
if(flac_cfg.output.resolution.replaygain.noise_shaping == 1)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(resolution_replaygain_noise_shaping_radio_low), TRUE);
gtk_signal_connect(GTK_OBJECT(resolution_replaygain_noise_shaping_radio_low), "clicked", resolution_replaygain_noise_shaping_cb, NULL);
gtk_container_add(GTK_CONTAINER(resolution_replaygain_noise_shaping_vbox), resolution_replaygain_noise_shaping_radio_low);
resolution_replaygain_noise_shaping_radio_medium = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(resolution_replaygain_noise_shaping_radio_none), _("medium"));
if(flac_cfg.output.resolution.replaygain.noise_shaping == 2)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(resolution_replaygain_noise_shaping_radio_medium), TRUE);
gtk_signal_connect(GTK_OBJECT(resolution_replaygain_noise_shaping_radio_medium), "clicked", resolution_replaygain_noise_shaping_cb, NULL);
gtk_container_add(GTK_CONTAINER(resolution_replaygain_noise_shaping_vbox), resolution_replaygain_noise_shaping_radio_medium);
resolution_replaygain_noise_shaping_radio_high = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(resolution_replaygain_noise_shaping_radio_none), _("high"));
if(flac_cfg.output.resolution.replaygain.noise_shaping == 3)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(resolution_replaygain_noise_shaping_radio_high), TRUE);
gtk_signal_connect(GTK_OBJECT(resolution_replaygain_noise_shaping_radio_high), "clicked", resolution_replaygain_noise_shaping_cb, NULL);
gtk_container_add(GTK_CONTAINER(resolution_replaygain_noise_shaping_vbox), resolution_replaygain_noise_shaping_radio_high);
resolution_replaygain_bps_out_frame = gtk_frame_new(_("Dither to"));
gtk_container_border_width(GTK_CONTAINER(resolution_replaygain_bps_out_frame), 5);
gtk_box_pack_start(GTK_BOX(hbox), resolution_replaygain_bps_out_frame, FALSE, FALSE, 0);
resolution_replaygain_bps_out_vbox = gtk_vbutton_box_new();
gtk_container_border_width(GTK_CONTAINER(resolution_replaygain_bps_out_vbox), 0);
gtk_container_add(GTK_CONTAINER(resolution_replaygain_bps_out_frame), resolution_replaygain_bps_out_vbox);
resolution_replaygain_bps_out_radio_16bps = gtk_radio_button_new_with_label(NULL, _("16 bps"));
if(flac_cfg.output.resolution.replaygain.bps_out == 16)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(resolution_replaygain_bps_out_radio_16bps), TRUE);
gtk_signal_connect(GTK_OBJECT(resolution_replaygain_bps_out_radio_16bps), "clicked", resolution_replaygain_bps_out_cb, NULL);
gtk_container_add(GTK_CONTAINER(resolution_replaygain_bps_out_vbox), resolution_replaygain_bps_out_radio_16bps);
resolution_replaygain_bps_out_radio_24bps = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(resolution_replaygain_bps_out_radio_16bps), _("24 bps"));
if(flac_cfg.output.resolution.replaygain.bps_out == 24)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(resolution_replaygain_bps_out_radio_24bps), TRUE);
gtk_signal_connect(GTK_OBJECT(resolution_replaygain_bps_out_radio_24bps), "clicked", resolution_replaygain_bps_out_cb, NULL);
gtk_container_add(GTK_CONTAINER(resolution_replaygain_bps_out_vbox), resolution_replaygain_bps_out_radio_24bps);
resolution_replaygain_dither_cb(resolution_replaygain_dither, NULL);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), output_vbox, gtk_label_new(_("Output")));
/* Streaming */
streaming_vbox = gtk_vbox_new(FALSE, 0);
streaming_buf_frame = gtk_frame_new(_("Buffering:"));
gtk_container_set_border_width(GTK_CONTAINER(streaming_buf_frame), 5);
gtk_box_pack_start(GTK_BOX(streaming_vbox), streaming_buf_frame, FALSE, FALSE, 0);
streaming_buf_hbox = gtk_hbox_new(TRUE, 5);
gtk_container_set_border_width(GTK_CONTAINER(streaming_buf_hbox), 5);
gtk_container_add(GTK_CONTAINER(streaming_buf_frame), streaming_buf_hbox);
streaming_size_box = gtk_hbox_new(FALSE, 5);
/*gtk_table_attach_defaults(GTK_TABLE(streaming_buf_table),streaming_size_box,0,1,0,1); */
gtk_box_pack_start(GTK_BOX(streaming_buf_hbox), streaming_size_box, TRUE, TRUE, 0);
streaming_size_label = gtk_label_new(_("Buffer size (kb):"));
gtk_box_pack_start(GTK_BOX(streaming_size_box), streaming_size_label, FALSE, FALSE, 0);
streaming_size_adj = gtk_adjustment_new(flac_cfg.stream.http_buffer_size, 4, 4096, 4, 4, 4);
streaming_size_spin = gtk_spin_button_new(GTK_ADJUSTMENT(streaming_size_adj), 8, 0);
gtk_widget_set_usize(streaming_size_spin, 60, -1);
gtk_box_pack_start(GTK_BOX(streaming_size_box), streaming_size_spin, FALSE, FALSE, 0);
streaming_pre_box = gtk_hbox_new(FALSE, 5);
/*gtk_table_attach_defaults(GTK_TABLE(streaming_buf_table),streaming_pre_box,1,2,0,1); */
gtk_box_pack_start(GTK_BOX(streaming_buf_hbox), streaming_pre_box, TRUE, TRUE, 0);
streaming_pre_label = gtk_label_new(_("Pre-buffer (percent):"));
gtk_box_pack_start(GTK_BOX(streaming_pre_box), streaming_pre_label, FALSE, FALSE, 0);
streaming_pre_adj = gtk_adjustment_new(flac_cfg.stream.http_prebuffer, 0, 90, 1, 1, 1);
streaming_pre_spin = gtk_spin_button_new(GTK_ADJUSTMENT(streaming_pre_adj), 1, 0);
gtk_widget_set_usize(streaming_pre_spin, 60, -1);
gtk_box_pack_start(GTK_BOX(streaming_pre_box), streaming_pre_spin, FALSE, FALSE, 0);
/*
* Proxy config.
*/
streaming_proxy_frame = gtk_frame_new(_("Proxy:"));
gtk_container_set_border_width(GTK_CONTAINER(streaming_proxy_frame), 5);
gtk_box_pack_start(GTK_BOX(streaming_vbox), streaming_proxy_frame, FALSE, FALSE, 0);
streaming_proxy_vbox = gtk_vbox_new(FALSE, 5);
gtk_container_set_border_width(GTK_CONTAINER(streaming_proxy_vbox), 5);
gtk_container_add(GTK_CONTAINER(streaming_proxy_frame), streaming_proxy_vbox);
streaming_proxy_use = gtk_check_button_new_with_label(_("Use proxy"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(streaming_proxy_use), flac_cfg.stream.use_proxy);
gtk_signal_connect(GTK_OBJECT(streaming_proxy_use), "clicked", GTK_SIGNAL_FUNC(proxy_use_cb), NULL);
gtk_box_pack_start(GTK_BOX(streaming_proxy_vbox), streaming_proxy_use, FALSE, FALSE, 0);
streaming_proxy_hbox = gtk_hbox_new(FALSE, 5);
gtk_widget_set_sensitive(streaming_proxy_hbox, flac_cfg.stream.use_proxy);
gtk_box_pack_start(GTK_BOX(streaming_proxy_vbox), streaming_proxy_hbox, FALSE, FALSE, 0);
streaming_proxy_host_label = gtk_label_new(_("Host:"));
gtk_box_pack_start(GTK_BOX(streaming_proxy_hbox), streaming_proxy_host_label, FALSE, FALSE, 0);
streaming_proxy_host_entry = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(streaming_proxy_host_entry), flac_cfg.stream.proxy_host);
gtk_box_pack_start(GTK_BOX(streaming_proxy_hbox), streaming_proxy_host_entry, TRUE, TRUE, 0);
streaming_proxy_port_label = gtk_label_new(_("Port:"));
gtk_box_pack_start(GTK_BOX(streaming_proxy_hbox), streaming_proxy_port_label, FALSE, FALSE, 0);
streaming_proxy_port_entry = gtk_entry_new();
gtk_widget_set_usize(streaming_proxy_port_entry, 50, -1);
temp = g_strdup_printf("%d", flac_cfg.stream.proxy_port);
gtk_entry_set_text(GTK_ENTRY(streaming_proxy_port_entry), temp);
g_free(temp);
gtk_box_pack_start(GTK_BOX(streaming_proxy_hbox), streaming_proxy_port_entry, FALSE, FALSE, 0);
streaming_proxy_auth_use = gtk_check_button_new_with_label(_("Use authentication"));
gtk_widget_set_sensitive(streaming_proxy_auth_use, flac_cfg.stream.use_proxy);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(streaming_proxy_auth_use), flac_cfg.stream.proxy_use_auth);
gtk_signal_connect(GTK_OBJECT(streaming_proxy_auth_use), "clicked", GTK_SIGNAL_FUNC(proxy_auth_use_cb), NULL);
gtk_box_pack_start(GTK_BOX(streaming_proxy_vbox), streaming_proxy_auth_use, FALSE, FALSE, 0);
streaming_proxy_auth_hbox = gtk_hbox_new(FALSE, 5);
gtk_widget_set_sensitive(streaming_proxy_auth_hbox, flac_cfg.stream.use_proxy && flac_cfg.stream.proxy_use_auth);
gtk_box_pack_start(GTK_BOX(streaming_proxy_vbox), streaming_proxy_auth_hbox, FALSE, FALSE, 0);
streaming_proxy_auth_user_label = gtk_label_new(_("Username:"******"Password:"******"Save stream to disk:"));
gtk_container_set_border_width(GTK_CONTAINER(streaming_save_frame), 5);
gtk_box_pack_start(GTK_BOX(streaming_vbox), streaming_save_frame, FALSE, FALSE, 0);
streaming_save_vbox = gtk_vbox_new(FALSE, 5);
gtk_container_set_border_width(GTK_CONTAINER(streaming_save_vbox), 5);
gtk_container_add(GTK_CONTAINER(streaming_save_frame), streaming_save_vbox);
streaming_save_use = gtk_check_button_new_with_label(_("Save stream to disk"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(streaming_save_use), flac_cfg.stream.save_http_stream);
gtk_signal_connect(GTK_OBJECT(streaming_save_use), "clicked", GTK_SIGNAL_FUNC(streaming_save_use_cb), NULL);
gtk_box_pack_start(GTK_BOX(streaming_save_vbox), streaming_save_use, FALSE, FALSE, 0);
streaming_save_hbox = gtk_hbox_new(FALSE, 5);
gtk_widget_set_sensitive(streaming_save_hbox, flac_cfg.stream.save_http_stream);
gtk_box_pack_start(GTK_BOX(streaming_save_vbox), streaming_save_hbox, FALSE, FALSE, 0);
streaming_save_label = gtk_label_new(_("Path:"));
gtk_box_pack_start(GTK_BOX(streaming_save_hbox), streaming_save_label, FALSE, FALSE, 0);
streaming_save_entry = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(streaming_save_entry), flac_cfg.stream.save_http_path);
gtk_box_pack_start(GTK_BOX(streaming_save_hbox), streaming_save_entry, TRUE, TRUE, 0);
streaming_save_browse = gtk_button_new_with_label(_("Browse"));
gtk_signal_connect(GTK_OBJECT(streaming_save_browse), "clicked", GTK_SIGNAL_FUNC(streaming_save_browse_cb), NULL);
gtk_box_pack_start(GTK_BOX(streaming_save_hbox), streaming_save_browse, FALSE, FALSE, 0);
#ifdef FLAC_ICECAST
streaming_cast_frame = gtk_frame_new(_("SHOUT/Icecast:"));
gtk_container_set_border_width(GTK_CONTAINER(streaming_cast_frame), 5);
gtk_box_pack_start(GTK_BOX(streaming_vbox), streaming_cast_frame, FALSE, FALSE, 0);
streaming_cast_vbox = gtk_vbox_new(5, FALSE);
gtk_container_add(GTK_CONTAINER(streaming_cast_frame), streaming_cast_vbox);
streaming_cast_title = gtk_check_button_new_with_label(_("Enable SHOUT/Icecast title streaming"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(streaming_cast_title), flac_cfg.stream.cast_title_streaming);
gtk_box_pack_start(GTK_BOX(streaming_cast_vbox), streaming_cast_title, FALSE, FALSE, 0);
streaming_udp_title = gtk_check_button_new_with_label(_("Enable Icecast Metadata UDP Channel"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(streaming_udp_title), flac_cfg.stream.use_udp_channel);
gtk_box_pack_start(GTK_BOX(streaming_cast_vbox), streaming_udp_title, FALSE, FALSE, 0);
#endif
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), streaming_vbox, gtk_label_new(_("Streaming")));
/* Buttons */
bbox = gtk_hbutton_box_new();
gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END);
gtk_button_box_set_spacing(GTK_BUTTON_BOX(bbox), 5);
gtk_box_pack_start(GTK_BOX(vbox), bbox, FALSE, FALSE, 0);
ok = gtk_button_new_with_label(_("Ok"));
gtk_signal_connect(GTK_OBJECT(ok), "clicked", GTK_SIGNAL_FUNC(flac_configurewin_ok), NULL);
GTK_WIDGET_SET_FLAGS(ok, GTK_CAN_DEFAULT);
gtk_box_pack_start(GTK_BOX(bbox), ok, TRUE, TRUE, 0);
gtk_widget_grab_default(ok);
cancel = gtk_button_new_with_label(_("Cancel"));
gtk_signal_connect_object(GTK_OBJECT(cancel), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT(flac_configurewin));
GTK_WIDGET_SET_FLAGS(cancel, GTK_CAN_DEFAULT);
gtk_box_pack_start(GTK_BOX(bbox), cancel, TRUE, TRUE, 0);
gtk_widget_show_all(flac_configurewin);
}
static void
TPCCTableProps_init (TPCCTableProps * dlg)
{
char *szNames[] = {
"WAREHOUSE",
"DISTRICT",
"CUSTOMER",
"THISTORY",
"NEW_ORDER",
"ORDERS",
"ORDER_LINE",
"ITEM",
"STOCK"
};
int i;
GtkWidget *table, *label, *remotes, *dsn_btn, *frame;
GtkObject *adj;
GtkWidget *vbox;
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (dlg), vbox);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
table = gtk_hbox_new (TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox), table, TRUE, TRUE, 10);
gtk_widget_show (table);
label = gtk_label_new ("Number of warehouses");
gtk_box_pack_start (GTK_BOX (table), label, FALSE, FALSE, 0);
gtk_widget_show (label);
adj = gtk_adjustment_new (1, 1, 300, 1, 10, 10);
dlg->n_ware = gtk_spin_button_new (GTK_ADJUSTMENT (adj), 0.5, 0);
gtk_box_pack_start (GTK_BOX (table), dlg->n_ware, TRUE, TRUE, 0);
gtk_widget_show (dlg->n_ware);
frame = gtk_frame_new ("Table destinations");
gtk_widget_show (frame);
gtk_container_set_border_width (GTK_CONTAINER (frame), 5);
gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0);
table = gtk_table_new (10, 3, TRUE);
gtk_widget_show (table);
gtk_container_set_border_width (GTK_CONTAINER (table), 5);
gtk_container_add (GTK_CONTAINER (frame), table);
dsn_btn = gtk_button_new_with_label ("DSNs ...");
gtk_widget_show (dsn_btn);
gtk_signal_connect_object (GTK_OBJECT (dsn_btn), "clicked",
GTK_SIGNAL_FUNC (show_server_data_sources_dialog), GTK_OBJECT (dlg));
gtk_table_attach_defaults (GTK_TABLE (table), dsn_btn, 2, 3, 0, 1);
gtk_widget_set_sensitive (dsn_btn, FALSE);
remotes = gtk_check_button_new_with_label ("Remote tables");
gtk_widget_show (remotes);
gtk_table_attach_defaults (GTK_TABLE (table), remotes, 1, 2, 0, 1);
gtk_signal_connect (GTK_OBJECT (remotes), "clicked",
GTK_SIGNAL_FUNC (enable_widget_as), dsn_btn);
for (i = 0; i < 9; i++)
{
label = gtk_label_new (szNames[i]);
gtk_widget_show (label);
gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, 1 + i,
2 + i);
dlg->combos[i] = gtk_combo_new ();
gtk_widget_show (dlg->combos[i]);
gtk_combo_set_value_in_list (GTK_COMBO (dlg->combos[i]), TRUE, TRUE);
gtk_table_attach_defaults (GTK_TABLE (table), dlg->combos[i], 1, 3,
1 + i, 2 + i);
gtk_widget_set_sensitive (GTK_WIDGET (dlg->combos[i]),
GTK_TOGGLE_BUTTON (remotes)->active > 0);
gtk_entry_set_text (GTK_ENTRY (GTK_COMBO (dlg->combos[i])->entry), "");
gtk_signal_connect (GTK_OBJECT (remotes), "clicked",
GTK_SIGNAL_FUNC (enable_widget_as), dlg->combos[i]);
}
}
void
sp_text_edit_dialog (void)
{
if (!dlg) {
gchar title[500];
sp_ui_dialog_title_string (Inkscape::Verb::get(SP_VERB_DIALOG_TEXT), title);
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
dlg = sp_window_new (title, TRUE);
if (x == -1000 || y == -1000) {
x = prefs->getInt(prefs_path + "x", -1000);
y = prefs->getInt(prefs_path + "y", -1000);
}
if (w ==0 || h == 0) {
w = prefs->getInt(prefs_path + "w", 0);
h = prefs->getInt(prefs_path + "h", 0);
}
// if (x<0) x=0;
// if (y<0) y=0;
if (w && h)
gtk_window_resize ((GtkWindow *) dlg, w, h);
if (x >= 0 && y >= 0 && (x < (gdk_screen_width()-MIN_ONSCREEN_DISTANCE)) && (y < (gdk_screen_height()-MIN_ONSCREEN_DISTANCE))) {
gtk_window_move ((GtkWindow *) dlg, x, y);
} else {
gtk_window_set_position(GTK_WINDOW(dlg), GTK_WIN_POS_CENTER);
}
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_text_edit_dialog_destroy), dlg );
gtk_signal_connect ( GTK_OBJECT (dlg), "delete_event", G_CALLBACK (sp_text_edit_dialog_delete), dlg );
g_signal_connect ( G_OBJECT (INKSCAPE), "shut_down", G_CALLBACK (sp_text_edit_dialog_delete), dlg );
g_signal_connect ( G_OBJECT (INKSCAPE), "dialogs_hide", G_CALLBACK (sp_dialog_hide), dlg );
g_signal_connect ( G_OBJECT (INKSCAPE), "dialogs_unhide", G_CALLBACK (sp_dialog_unhide), dlg );
gtk_window_set_policy (GTK_WINDOW (dlg), TRUE, TRUE, FALSE);
GtkTooltips *tt = gtk_tooltips_new();
// box containing the notebook and the bottom buttons
GtkWidget *mainvb = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (dlg), mainvb);
// notebook
GtkWidget *nb = gtk_notebook_new ();
gtk_box_pack_start (GTK_BOX (mainvb), nb, TRUE, TRUE, 0);
g_object_set_data (G_OBJECT (dlg), "notebook", nb);
// Font tab
{
GtkWidget *l = gtk_label_new (_("Font"));
GtkWidget *vb = gtk_vbox_new (FALSE, VB_MARGIN);
gtk_container_set_border_width (GTK_CONTAINER (vb), VB_MARGIN);
gtk_notebook_append_page (GTK_NOTEBOOK (nb), vb, l);
/* HBox containing font selection and layout */
GtkWidget *hb = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (vb), hb, TRUE, TRUE, 0);
// font and style selector
GtkWidget *fontsel = sp_font_selector_new ();
g_signal_connect ( G_OBJECT (fontsel), "font_set", G_CALLBACK (sp_text_edit_dialog_font_changed), dlg );
g_signal_connect_swapped ( G_OBJECT (g_object_get_data (G_OBJECT(fontsel), "family-treeview")),
"row-activated",
G_CALLBACK (gtk_window_activate_default),
dlg);
gtk_box_pack_start (GTK_BOX (hb), fontsel, TRUE, TRUE, 0);
g_object_set_data (G_OBJECT (dlg), "fontsel", fontsel);
// Layout
{
GtkWidget *f = gtk_frame_new (_("Layout"));
gtk_box_pack_start (GTK_BOX (hb), f, FALSE, FALSE, 4);
GtkWidget *l_vb = gtk_vbox_new (FALSE, VB_MARGIN);
gtk_container_add (GTK_CONTAINER (f), l_vb);
{
GtkWidget *row = gtk_hbox_new (FALSE, VB_MARGIN);
GtkWidget *group;
// align left
{
// TODO - replace with Inkscape-specific call
GtkWidget *px = gtk_image_new_from_stock ( GTK_STOCK_JUSTIFY_LEFT, GTK_ICON_SIZE_LARGE_TOOLBAR );
GtkWidget *b = group = gtk_radio_button_new (NULL);
gtk_tooltips_set_tip (tt, b, _("Align lines left"), NULL);
gtk_button_set_relief (GTK_BUTTON (b), GTK_RELIEF_NONE);
g_signal_connect ( G_OBJECT (b), "toggled", G_CALLBACK (sp_text_edit_dialog_any_toggled), dlg);
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE );
gtk_container_add (GTK_CONTAINER (b), px);
gtk_box_pack_start (GTK_BOX (row), b, FALSE, FALSE, 0);
g_object_set_data (G_OBJECT (dlg), "text_anchor_start", b);
}
// align center
{
// TODO - replace with Inkscape-specific call
GtkWidget *px = gtk_image_new_from_stock ( GTK_STOCK_JUSTIFY_CENTER, GTK_ICON_SIZE_LARGE_TOOLBAR );
GtkWidget *b = gtk_radio_button_new (gtk_radio_button_group (GTK_RADIO_BUTTON (group)));
/* TRANSLATORS: `Center' here is a verb. */
gtk_tooltips_set_tip (tt, b, _("Center lines"), NULL);
gtk_button_set_relief (GTK_BUTTON (b), GTK_RELIEF_NONE);
g_signal_connect ( G_OBJECT (b), "toggled", G_CALLBACK (sp_text_edit_dialog_any_toggled), dlg );
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE);
gtk_container_add (GTK_CONTAINER (b), px);
gtk_box_pack_start (GTK_BOX (row), b, FALSE, FALSE, 0);
g_object_set_data (G_OBJECT (dlg), "text_anchor_middle", b);
}
// align right
{
// TODO - replace with Inkscape-specific call
GtkWidget *px = gtk_image_new_from_stock ( GTK_STOCK_JUSTIFY_RIGHT, GTK_ICON_SIZE_LARGE_TOOLBAR );
GtkWidget *b = gtk_radio_button_new (gtk_radio_button_group (GTK_RADIO_BUTTON (group)));
gtk_tooltips_set_tip (tt, b, _("Align lines right"), NULL);
gtk_button_set_relief (GTK_BUTTON (b), GTK_RELIEF_NONE);
g_signal_connect ( G_OBJECT (b), "toggled", G_CALLBACK (sp_text_edit_dialog_any_toggled), dlg );
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE);
gtk_container_add (GTK_CONTAINER (b), px);
gtk_box_pack_start (GTK_BOX (row), b, FALSE, FALSE, 0);
g_object_set_data (G_OBJECT (dlg), "text_anchor_end", b);
}
// align justify
{
// TODO - replace with Inkscape-specific call
GtkWidget *px = gtk_image_new_from_stock ( GTK_STOCK_JUSTIFY_FILL, GTK_ICON_SIZE_LARGE_TOOLBAR );
GtkWidget *b = gtk_radio_button_new (gtk_radio_button_group (GTK_RADIO_BUTTON (group)));
gtk_tooltips_set_tip (tt, b, _("Justify lines"), NULL);
gtk_button_set_relief (GTK_BUTTON (b), GTK_RELIEF_NONE);
g_signal_connect ( G_OBJECT (b), "toggled", G_CALLBACK (sp_text_edit_dialog_any_toggled), dlg );
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE);
gtk_container_add (GTK_CONTAINER (b), px);
gtk_box_pack_start (GTK_BOX (row), b, FALSE, FALSE, 0);
g_object_set_data (G_OBJECT (dlg), "text_anchor_justify", b);
}
gtk_box_pack_start (GTK_BOX (l_vb), row, FALSE, FALSE, 0);
}
{
GtkWidget *row = gtk_hbox_new (FALSE, VB_MARGIN);
GtkWidget *group;
// horizontal
{
GtkWidget *px = sp_icon_new( Inkscape::ICON_SIZE_LARGE_TOOLBAR,
INKSCAPE_STOCK_WRITING_MODE_LR );
GtkWidget *b = group = gtk_radio_button_new (NULL);
gtk_tooltips_set_tip (tt, b, _("Horizontal text"), NULL);
gtk_button_set_relief (GTK_BUTTON (b), GTK_RELIEF_NONE);
g_signal_connect ( G_OBJECT (b), "toggled", G_CALLBACK (sp_text_edit_dialog_any_toggled), dlg );
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE);
gtk_container_add (GTK_CONTAINER (b), px);
gtk_box_pack_start (GTK_BOX (row), b, FALSE, FALSE, 0);
g_object_set_data (G_OBJECT (dlg), INKSCAPE_STOCK_WRITING_MODE_LR, b);
}
// vertical
{
GtkWidget *px = sp_icon_new( Inkscape::ICON_SIZE_LARGE_TOOLBAR,
INKSCAPE_STOCK_WRITING_MODE_TB );
GtkWidget *b = gtk_radio_button_new (gtk_radio_button_group (GTK_RADIO_BUTTON (group)));
gtk_tooltips_set_tip (tt, b, _("Vertical text"), NULL);
gtk_button_set_relief (GTK_BUTTON (b), GTK_RELIEF_NONE);
g_signal_connect ( G_OBJECT (b), "toggled", G_CALLBACK (sp_text_edit_dialog_any_toggled), dlg );
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE);
gtk_container_add (GTK_CONTAINER (b), px);
gtk_box_pack_start (GTK_BOX (row), b, FALSE, FALSE, 0);
g_object_set_data (G_OBJECT (dlg), INKSCAPE_STOCK_WRITING_MODE_TB, b);
}
gtk_box_pack_start (GTK_BOX (l_vb), row, FALSE, FALSE, 0);
}
{
GtkWidget *row = gtk_hbox_new (FALSE, VB_MARGIN);
l = gtk_label_new (_("Line spacing:"));
gtk_misc_set_alignment (GTK_MISC (l), 1.0, 0.5);
gtk_box_pack_start (GTK_BOX (row), l, FALSE, FALSE, VB_MARGIN);
gtk_box_pack_start (GTK_BOX (l_vb), row, FALSE, FALSE, 0);
}
{
GtkWidget *row = gtk_hbox_new (FALSE, VB_MARGIN);
GtkWidget *c = gtk_combo_new ();
gtk_combo_set_value_in_list ((GtkCombo *) c, FALSE, FALSE);
gtk_combo_set_use_arrows ((GtkCombo *) c, TRUE);
gtk_combo_set_use_arrows_always ((GtkCombo *) c, TRUE);
gtk_widget_set_size_request (c, 90, -1);
{ /* Setup strings */
GList *sl = NULL;
for (int i = 0; spacings[i]; i++) {
sl = g_list_prepend (sl, (void *) spacings[i]);
}
sl = g_list_reverse (sl);
gtk_combo_set_popdown_strings ((GtkCombo *) c, sl);
g_list_free (sl);
}
g_signal_connect ( (GObject *) ((GtkCombo *) c)->entry,
"changed",
(GCallback) sp_text_edit_dialog_line_spacing_changed,
dlg );
gtk_box_pack_start (GTK_BOX (row), c, FALSE, FALSE, VB_MARGIN);
g_object_set_data (G_OBJECT (dlg), "line_spacing", c);
gtk_box_pack_start (GTK_BOX (l_vb), row, FALSE, FALSE, VB_MARGIN);
}
}
/* Font preview */
GtkWidget *preview = sp_font_preview_new ();
gtk_box_pack_start (GTK_BOX (vb), preview, TRUE, TRUE, 4);
g_object_set_data (G_OBJECT (dlg), "preview", preview);
}
// Text tab
{
GtkWidget *l = gtk_label_new (_("Text"));
GtkWidget *vb = gtk_vbox_new (FALSE, VB_MARGIN);
gtk_container_set_border_width (GTK_CONTAINER (vb), VB_MARGIN);
gtk_notebook_append_page (GTK_NOTEBOOK (nb), vb, l);
GtkWidget *scroller = gtk_scrolled_window_new ( NULL, NULL );
gtk_scrolled_window_set_policy ( GTK_SCROLLED_WINDOW (scroller),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC );
gtk_scrolled_window_set_shadow_type ( GTK_SCROLLED_WINDOW(scroller), GTK_SHADOW_IN );
gtk_widget_show (scroller);
GtkTextBuffer *tb = gtk_text_buffer_new (NULL);
GtkWidget *txt = gtk_text_view_new_with_buffer (tb);
gtk_text_view_set_wrap_mode ((GtkTextView *) txt, GTK_WRAP_WORD);
#ifdef WITH_GTKSPELL
GError *error = NULL;
char *errortext = NULL;
/* todo: Use computed xml:lang attribute of relevant element, if present, to specify the
language (either as 2nd arg of gtkspell_new_attach, or with explicit
gtkspell_set_language call in; see advanced.c example in gtkspell docs).
sp_text_edit_dialog_read_selection looks like a suitable place. */
if (gtkspell_new_attach(GTK_TEXT_VIEW(txt), NULL, &error) == NULL) {
g_print("gtkspell error: %s\n", error->message);
errortext = g_strdup_printf("GtkSpell was unable to initialize.\n"
"%s", error->message);
g_error_free(error);
}
#endif
gtk_widget_set_size_request (txt, -1, 64);
gtk_text_view_set_editable (GTK_TEXT_VIEW (txt), TRUE);
gtk_container_add (GTK_CONTAINER (scroller), txt);
gtk_box_pack_start (GTK_BOX (vb), scroller, TRUE, TRUE, 0);
g_signal_connect ( G_OBJECT (tb), "changed",
G_CALLBACK (sp_text_edit_dialog_text_changed), dlg );
g_signal_connect (G_OBJECT (txt), "focus-in-event", G_CALLBACK (text_view_focus_in), dlg);
g_signal_connect (G_OBJECT (txt), "focus-out-event", G_CALLBACK (text_view_focus_out), dlg);
g_object_set_data (G_OBJECT (dlg), "text", tb);
g_object_set_data (G_OBJECT (dlg), "textw", txt);
}
/* Buttons */
GtkWidget *hb = gtk_hbox_new (FALSE, VB_MARGIN);
gtk_container_set_border_width (GTK_CONTAINER (hb), 4);
gtk_box_pack_start (GTK_BOX (mainvb), hb, FALSE, FALSE, 0);
{
GtkWidget *b = gtk_button_new_with_label (_("Set as default"));
g_signal_connect ( G_OBJECT (b), "clicked",
G_CALLBACK (sp_text_edit_dialog_set_default),
dlg );
gtk_box_pack_start (GTK_BOX (hb), b, FALSE, FALSE, 0);
g_object_set_data (G_OBJECT (dlg), "default", b);
}
{
GtkWidget *b = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
g_signal_connect ( G_OBJECT (b), "clicked",
G_CALLBACK (sp_text_edit_dialog_close), dlg );
gtk_box_pack_end (GTK_BOX (hb), b, FALSE, FALSE, 0);
}
{
GtkWidget *b = gtk_button_new_from_stock (GTK_STOCK_APPLY);
GTK_WIDGET_SET_FLAGS (b, GTK_CAN_DEFAULT | GTK_HAS_DEFAULT);
g_signal_connect ( G_OBJECT (b), "clicked",
G_CALLBACK (sp_text_edit_dialog_apply), dlg );
gtk_box_pack_end ( GTK_BOX (hb), b, FALSE, FALSE, 0 );
g_object_set_data (G_OBJECT (dlg), "apply", b);
}
g_signal_connect ( G_OBJECT (INKSCAPE), "modify_selection",
G_CALLBACK (sp_text_edit_dialog_selection_modified), dlg);
g_signal_connect ( G_OBJECT (INKSCAPE), "change_selection",
G_CALLBACK (sp_text_edit_dialog_selection_changed), dlg);
g_signal_connect (INKSCAPE, "change_subselection", G_CALLBACK (sp_text_edit_dialog_subselection_changed), dlg);
gtk_widget_show_all (dlg);
sp_text_edit_dialog_read_selection (dlg, TRUE, TRUE);
}
gtk_window_present ((GtkWindow *) dlg);
} // end of sp_text_edit_dialog()
void
sp_text_edit_dialog (void)
{
if (!dlg) {
GtkWidget *mainvb, *nb, *vb, *hb, *txt, *fontsel, *preview, *f, *tbl, *l, *px, *c, *b, *hs;
GtkTextBuffer *tb;
GList *sl;
int i;
gchar title[500];
sp_ui_dialog_title_string (SP_VERB_DIALOG_TEXT, 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_text_edit_dialog_destroy), dlg);
gtk_signal_connect (GTK_OBJECT (dlg), "delete_event", G_CALLBACK (sp_text_edit_dialog_delete), dlg);
g_signal_connect (G_OBJECT (INKSCAPE), "shut_down", G_CALLBACK (sp_text_edit_dialog_delete), dlg);
gtk_window_set_policy (GTK_WINDOW (dlg), TRUE, TRUE, FALSE);
mainvb = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (dlg), mainvb);
nb = gtk_notebook_new ();
gtk_container_set_border_width (GTK_CONTAINER (nb), 4);
gtk_box_pack_start (GTK_BOX (mainvb), nb, TRUE, TRUE, 0);
g_object_set_data (G_OBJECT (dlg), "notebook", nb);
/* Vbox inside notebook */
vb = gtk_vbox_new (FALSE, 0);
/* Textview */
f = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (f), GTK_SHADOW_IN);
tb = gtk_text_buffer_new (NULL);
txt = gtk_text_view_new_with_buffer (tb);
gtk_widget_set_size_request (txt, -1, 64);
gtk_text_view_set_editable (GTK_TEXT_VIEW (txt), TRUE);
gtk_container_add (GTK_CONTAINER (f), txt);
gtk_box_pack_start (GTK_BOX (vb), f, TRUE, TRUE, 0);
g_signal_connect (G_OBJECT (tb), "changed", G_CALLBACK (sp_text_edit_dialog_text_changed), dlg);
g_object_set_data (G_OBJECT (dlg), "text", tb);
g_object_set_data (G_OBJECT (dlg), "textw", txt);
/* HBox containing font selection and layout */
hb = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (vb), hb, TRUE, TRUE, 0);
fontsel = sp_font_selector_new ();
g_signal_connect (G_OBJECT (fontsel), "font_set", G_CALLBACK (sp_text_edit_dialog_font_changed), dlg);
gtk_box_pack_start (GTK_BOX (hb), fontsel, TRUE, TRUE, 0);
g_object_set_data (G_OBJECT (dlg), "fontsel", fontsel);
/* Layout */
f = gtk_frame_new (_("Layout"));
gtk_box_pack_start (GTK_BOX (hb), f, FALSE, FALSE, 4);
tbl = gtk_table_new (3, 4, FALSE);
gtk_table_set_row_spacings (GTK_TABLE (tbl), 4);
gtk_table_set_col_spacings (GTK_TABLE (tbl), 4);
gtk_container_add (GTK_CONTAINER (f), tbl);
l = gtk_label_new (_("Alignment:"));
gtk_misc_set_alignment (GTK_MISC (l), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (tbl), l, 0, 1, 0, 1, (GtkAttachOptions)0, (GtkAttachOptions)0, 4, 0);
px = gtk_image_new_from_stock (GTK_STOCK_JUSTIFY_LEFT, GTK_ICON_SIZE_LARGE_TOOLBAR);
b = gtk_radio_button_new (NULL);
g_signal_connect (G_OBJECT (b), "toggled", G_CALLBACK (sp_text_edit_dialog_any_toggled), dlg);
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE);
gtk_container_add (GTK_CONTAINER (b), px);
gtk_table_attach (GTK_TABLE (tbl), b, 1, 2, 0, 1, (GtkAttachOptions)0, (GtkAttachOptions)0, 0, 0);
g_object_set_data (G_OBJECT (dlg), "text_anchor_start", b);
px = gtk_image_new_from_stock (GTK_STOCK_JUSTIFY_CENTER, GTK_ICON_SIZE_LARGE_TOOLBAR);
b = gtk_radio_button_new (gtk_radio_button_group (GTK_RADIO_BUTTON (b)));
g_signal_connect (G_OBJECT (b), "toggled", G_CALLBACK (sp_text_edit_dialog_any_toggled), dlg);
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE);
gtk_container_add (GTK_CONTAINER (b), px);
gtk_table_attach (GTK_TABLE (tbl), b, 2, 3, 0, 1, (GtkAttachOptions)0, (GtkAttachOptions)0, 0, 0);
g_object_set_data (G_OBJECT (dlg), "text_anchor_middle", b);
px = gtk_image_new_from_stock (GTK_STOCK_JUSTIFY_RIGHT, GTK_ICON_SIZE_LARGE_TOOLBAR);
b = gtk_radio_button_new (gtk_radio_button_group (GTK_RADIO_BUTTON (b)));
g_signal_connect (G_OBJECT (b), "toggled", G_CALLBACK (sp_text_edit_dialog_any_toggled), dlg);
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE);
gtk_container_add (GTK_CONTAINER (b), px);
gtk_table_attach (GTK_TABLE (tbl), b, 3, 4, 0, 1, (GtkAttachOptions)0, (GtkAttachOptions)0, 0, 0);
g_object_set_data (G_OBJECT (dlg), "text_anchor_end", b);
l = gtk_label_new (_("Orientation:"));
gtk_misc_set_alignment (GTK_MISC (l), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (tbl), l, 0, 1, 1, 2, (GtkAttachOptions)0, (GtkAttachOptions)0, 4, 0);
px = gtk_image_new_from_stock (INKSCAPE_STOCK_WRITING_MODE_LR, GTK_ICON_SIZE_LARGE_TOOLBAR);
b = gtk_radio_button_new (NULL);
g_signal_connect (G_OBJECT (b), "toggled", G_CALLBACK (sp_text_edit_dialog_any_toggled), dlg);
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE);
gtk_container_add (GTK_CONTAINER (b), px);
gtk_table_attach (GTK_TABLE (tbl), b, 1, 2, 1, 2, (GtkAttachOptions)0, (GtkAttachOptions)0, 0, 0);
g_object_set_data (G_OBJECT (dlg), "writing_mode_lr", b);
px = gtk_image_new_from_stock (INKSCAPE_STOCK_WRITING_MODE_TB, GTK_ICON_SIZE_LARGE_TOOLBAR);
b = gtk_radio_button_new (gtk_radio_button_group (GTK_RADIO_BUTTON (b)));
g_signal_connect (G_OBJECT (b), "toggled", G_CALLBACK (sp_text_edit_dialog_any_toggled), dlg);
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE);
gtk_container_add (GTK_CONTAINER (b), px);
gtk_table_attach (GTK_TABLE (tbl), b, 2, 3, 1, 2, (GtkAttachOptions)0, (GtkAttachOptions)0, 0, 0);
g_object_set_data (G_OBJECT (dlg), "writing_mode_tb", b);
l = gtk_label_new (_("Line spacing:"));
gtk_misc_set_alignment (GTK_MISC (l), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (tbl), l, 0, 1, 2, 3, (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), (GtkAttachOptions)0, 4, 0);
c = gtk_combo_new ();
gtk_combo_set_value_in_list ((GtkCombo *) c, FALSE, FALSE);
gtk_combo_set_use_arrows ((GtkCombo *) c, TRUE);
gtk_combo_set_use_arrows_always ((GtkCombo *) c, TRUE);
gtk_widget_set_size_request (c, 64, -1);
/* Setup strings */
sl = NULL;
for (i = 0; spacings[i]; i++) {
sl = g_list_prepend (sl, (void *) spacings[i]);
}
sl = g_list_reverse (sl);
gtk_combo_set_popdown_strings ((GtkCombo *) c, sl);
g_list_free (sl);
g_signal_connect ((GObject *) ((GtkCombo *) c)->entry, "changed", (GCallback) sp_text_edit_dialog_line_spacing_changed, dlg);
gtk_table_attach (GTK_TABLE (tbl), c, 1, 4, 2, 3, (GtkAttachOptions)0, (GtkAttachOptions)0, 4, 0);
g_object_set_data (G_OBJECT (dlg), "line_spacing", c);
/* Font preview */
preview = sp_font_preview_new ();
gtk_box_pack_start (GTK_BOX (vb), preview, TRUE, TRUE, 4);
g_object_set_data (G_OBJECT (dlg), "preview", preview);
l = gtk_label_new (_("Text and font"));
gtk_notebook_append_page (GTK_NOTEBOOK (nb), vb, l);
/* Buttons */
hs = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (mainvb), hs, FALSE, FALSE, 0);
hb = gtk_hbox_new (FALSE, 4);
gtk_container_set_border_width (GTK_CONTAINER (hb), 4);
gtk_box_pack_start (GTK_BOX (mainvb), hb, FALSE, FALSE, 0);
b = gtk_button_new_with_label (_("Set as default"));
g_signal_connect (G_OBJECT (b), "clicked", G_CALLBACK (sp_text_edit_dialog_set_default), dlg);
gtk_box_pack_start (GTK_BOX (hb), b, FALSE, FALSE, 0);
g_object_set_data (G_OBJECT (dlg), "default", b);
b = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
g_signal_connect (G_OBJECT (b), "clicked", G_CALLBACK (sp_text_edit_dialog_close), dlg);
gtk_box_pack_end (GTK_BOX (hb), b, FALSE, FALSE, 0);
b = gtk_button_new_from_stock (GTK_STOCK_APPLY);
g_signal_connect (G_OBJECT (b), "clicked", G_CALLBACK (sp_text_edit_dialog_apply), dlg);
gtk_box_pack_end (GTK_BOX (hb), b, FALSE, FALSE, 0);
g_object_set_data (G_OBJECT (dlg), "apply", b);
g_signal_connect (G_OBJECT (INKSCAPE), "modify_selection", G_CALLBACK (sp_text_edit_dialog_modify_selection), dlg);
g_signal_connect (G_OBJECT (INKSCAPE), "change_selection", G_CALLBACK (sp_text_edit_dialog_change_selection), dlg);
sp_text_edit_dialog_read_selection (dlg, TRUE, TRUE);
gtk_widget_show_all (dlg);
}
gtk_window_present ((GtkWindow *) dlg);
}
// modified this to have 3 columns so we can display variable type
void FreeVarsWindowInitGtk( )
{
GtkWidget * hboxfreevars[ NBR_FREE_VAR_SPY ], *vboxMain;
char * VarName= NULL;
long ColumnVar;
int NumVarSpy,NumEntry,i=NBR_FREE_VAR_SPY;
GList *DisplayFormatItems = NULL;
SpyFreeVarsWindow = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title ((GtkWindow *)SpyFreeVarsWindow, "Watch Window");
vboxMain = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (SpyFreeVarsWindow), vboxMain);
gtk_widget_show (vboxMain);
DisplayFormatItems = g_list_append(DisplayFormatItems,"Dec");
DisplayFormatItems = g_list_append(DisplayFormatItems,"Hex");
DisplayFormatItems = g_list_append(DisplayFormatItems,"Bin");
if ( NBR_WORDS < NBR_FREE_VAR_SPY) { i=NBR_WORDS ;}
for(NumVarSpy=0; NumVarSpy<i; NumVarSpy++)
{
hboxfreevars[ NumVarSpy ] = gtk_hbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (vboxMain), hboxfreevars[ NumVarSpy ]);
gtk_widget_show (hboxfreevars[ NumVarSpy ]);
for(ColumnVar=0; ColumnVar<3; ColumnVar++)
{
NumEntry = NumVarSpy+ColumnVar*NBR_FREE_VAR_SPY;
if ( ColumnVar==0)
{
LabelFreeVars[NumEntry] = gtk_label_new(NULL);
gtk_widget_set_usize((GtkWidget *)LabelFreeVars[NumEntry],100,0);
gtk_box_pack_start (GTK_BOX (hboxfreevars[ NumVarSpy ]), LabelFreeVars[NumEntry], FALSE, FALSE, 0);
gtk_widget_show (LabelFreeVars[NumEntry]);
}
if ( ColumnVar==1)
{
EntryVarSpy[ NumEntry ] = gtk_entry_new();
gtk_widget_show(EntryVarSpy[NumEntry]);
gtk_box_pack_start (GTK_BOX( hboxfreevars[ NumVarSpy ] ), EntryVarSpy[ NumEntry ], TRUE, TRUE, 0);
gtk_widget_set_usize((GtkWidget *)EntryVarSpy[ NumEntry ],(ColumnVar==1)?80:110,0);
VarName = CreateVarName(VarSpy[NumVarSpy][0],VarSpy[NumVarSpy][1]);
TooltipsEntryVarSpy[ NumVarSpy ] = gtk_tooltips_new();
gtk_entry_set_text((GtkEntry *)EntryVarSpy[ NumEntry ],VarName);
gtk_signal_connect(GTK_OBJECT (EntryVarSpy[ NumEntry ]), "activate",
(GtkSignalFunc) EntryVarSpy_activate_event, (void *)NumVarSpy);
}
if ( ColumnVar==2)
{
EntryVarSpy[ NumEntry ] = gtk_entry_new();
gtk_widget_show(EntryVarSpy[NumEntry]);
gtk_box_pack_start (GTK_BOX( hboxfreevars[ NumVarSpy ] ), EntryVarSpy[ NumEntry ], TRUE, TRUE, 0);
gtk_widget_set_usize((GtkWidget *)EntryVarSpy[ NumEntry ],(ColumnVar==2)?80:110,0);
}
}
DisplayFormatVarSpy[NumVarSpy] = gtk_combo_new();
gtk_combo_set_value_in_list(GTK_COMBO(DisplayFormatVarSpy[NumVarSpy]), TRUE /*val*/, FALSE /*ok_if_empty*/);
gtk_combo_set_popdown_strings(GTK_COMBO(DisplayFormatVarSpy[NumVarSpy]), DisplayFormatItems);
gtk_widget_set_usize((GtkWidget *)DisplayFormatVarSpy[NumVarSpy],65,0);
gtk_box_pack_start (GTK_BOX(hboxfreevars[ NumVarSpy ]), DisplayFormatVarSpy[NumVarSpy], FALSE, FALSE, 0);
gtk_widget_show(DisplayFormatVarSpy[NumVarSpy]);
}
gtk_signal_connect( GTK_OBJECT(SpyFreeVarsWindow), "delete_event",
(GtkSignalFunc)FreeVarsWindowDeleteEvent, 0 );
}
static void
make_sub_controls (TPCATableProps * tableloader)
{
GtkWidget *CreateTablesFrame, *LoadTablesFrame, *IndexesFrame,
*RecordsToInsertFrame;
GtkWidget *main_hbox, *first_vbox, *second_vbox, *remotes = NULL;
GtkWidget *helper, *label;
GList *list = NULL;
int i, ofs;
do_login (tableloader->ptest);
tableloader->pDSN = (ServerDSN *) ServerDSN_new (tableloader->ptest);
if (tableloader->ptest->tpc.a.uwDrvIdx == -1)
{
tableloader->ptest->tpc.a.uwDrvIdx =
getDriverTypeIndex (tableloader->ptest->szDBMS);
tableloader->ptest->is_dirty = 1;
}
gtk_signal_connect (GTK_OBJECT (tableloader->pDSN), "dsns_changed",
GTK_SIGNAL_FUNC (set_dsn_combos), GTK_OBJECT (tableloader));
gtk_container_border_width (GTK_CONTAINER (&tableloader->parent), 10);
main_hbox = gtk_hbox_new (FALSE, 10);
gtk_container_add (GTK_CONTAINER (tableloader), main_hbox);
first_vbox = gtk_vbox_new (FALSE, 10);
gtk_box_pack_start (GTK_BOX (main_hbox), first_vbox, TRUE, TRUE, 0);
CreateTablesFrame = gtk_frame_new ("Create Tables");
gtk_box_pack_start (GTK_BOX (first_vbox), CreateTablesFrame, TRUE, TRUE, 0);
helper =
gtk_table_new (tableloader->pDSN->isVirtuoso ? 5 : 4,
tableloader->pDSN->isVirtuoso ? 3 : 1, TRUE);
gtk_container_border_width (GTK_CONTAINER (helper), 5);
gtk_container_add (GTK_CONTAINER (CreateTablesFrame), helper);
if (tableloader->pDSN->isVirtuoso)
{
GtkWidget *dsn_btn = gtk_button_new_with_label ("DSNs ...");
gtk_signal_connect (GTK_OBJECT (dsn_btn), "clicked",
GTK_SIGNAL_FUNC (show_server_data_sources_dialog), tableloader);
gtk_table_attach_defaults (GTK_TABLE (helper), dsn_btn, 2, 3, 0, 1);
gtk_widget_set_sensitive (dsn_btn, FALSE);
remotes = gtk_check_button_new_with_label ("Remote tables");
gtk_table_attach_defaults (GTK_TABLE (helper), remotes, 1, 2, 0, 1);
gtk_signal_connect (GTK_OBJECT (remotes), "clicked",
GTK_SIGNAL_FUNC (enable_widget_as), dsn_btn);
ofs = 1;
}
else
ofs = 0;
tableloader->create_branch = gtk_check_button_new_with_label ("Branch");
gtk_table_attach_defaults (GTK_TABLE (helper), tableloader->create_branch,
0, 1, ofs, ofs + 1);
tableloader->create_teller = gtk_check_button_new_with_label ("Teller");
gtk_table_attach_defaults (GTK_TABLE (helper), tableloader->create_teller,
0, 1, ofs + 1, ofs + 2);
tableloader->create_account = gtk_check_button_new_with_label ("Account");
gtk_table_attach_defaults (GTK_TABLE (helper), tableloader->create_account,
0, 1, ofs + 2, ofs + 3);
tableloader->create_history = gtk_check_button_new_with_label ("History");
gtk_table_attach_defaults (GTK_TABLE (helper), tableloader->create_history,
0, 1, ofs + 3, ofs + 4);
tableloader->branch_dsn = gtk_combo_new ();
gtk_combo_set_value_in_list (GTK_COMBO (tableloader->branch_dsn), TRUE,
TRUE);
gtk_entry_set_text (GTK_ENTRY (GTK_COMBO (tableloader->branch_dsn)->entry),
"");
if (tableloader->pDSN->isVirtuoso)
{
if (tableloader->pDSN->dsn_info.dsns)
gtk_combo_set_popdown_strings (GTK_COMBO (tableloader->branch_dsn),
tableloader->pDSN->dsn_info.dsns);
gtk_table_attach_defaults (GTK_TABLE (helper), tableloader->branch_dsn,
1, 3, ofs + 0, ofs + 1);
gtk_widget_set_sensitive (tableloader->branch_dsn, FALSE);
gtk_signal_connect (GTK_OBJECT (remotes), "clicked",
GTK_SIGNAL_FUNC (enable_widget_as), tableloader->branch_dsn);
}
tableloader->teller_dsn = gtk_combo_new ();
gtk_combo_set_value_in_list (GTK_COMBO (tableloader->teller_dsn), TRUE,
TRUE);
gtk_entry_set_text (GTK_ENTRY (GTK_COMBO (tableloader->teller_dsn)->entry),
"");
if (tableloader->pDSN->isVirtuoso)
{
if (tableloader->pDSN->dsn_info.dsns)
gtk_combo_set_popdown_strings (GTK_COMBO (tableloader->teller_dsn),
tableloader->pDSN->dsn_info.dsns);
gtk_table_attach_defaults (GTK_TABLE (helper), tableloader->teller_dsn,
1, 3, ofs + 1, ofs + 2);
gtk_widget_set_sensitive (tableloader->teller_dsn, FALSE);
gtk_signal_connect (GTK_OBJECT (remotes), "clicked",
GTK_SIGNAL_FUNC (enable_widget_as), tableloader->teller_dsn);
}
tableloader->account_dsn = gtk_combo_new ();
gtk_combo_set_value_in_list (GTK_COMBO (tableloader->account_dsn), TRUE,
TRUE);
gtk_entry_set_text (GTK_ENTRY (GTK_COMBO (tableloader->account_dsn)->entry),
"");
if (tableloader->pDSN->isVirtuoso)
{
if (tableloader->pDSN->dsn_info.dsns)
gtk_combo_set_popdown_strings (GTK_COMBO (tableloader->account_dsn),
tableloader->pDSN->dsn_info.dsns);
gtk_table_attach_defaults (GTK_TABLE (helper), tableloader->account_dsn,
1, 3, ofs + 2, ofs + 3);
gtk_widget_set_sensitive (tableloader->account_dsn, FALSE);
gtk_signal_connect (GTK_OBJECT (remotes), "clicked",
GTK_SIGNAL_FUNC (enable_widget_as), tableloader->account_dsn);
}
tableloader->history_dsn = gtk_combo_new ();
gtk_combo_set_value_in_list (GTK_COMBO (tableloader->history_dsn), TRUE,
TRUE);
gtk_entry_set_text (GTK_ENTRY (GTK_COMBO (tableloader->history_dsn)->entry),
"");
if (tableloader->pDSN->isVirtuoso)
{
if (tableloader->pDSN->dsn_info.dsns)
gtk_combo_set_popdown_strings (GTK_COMBO (tableloader->history_dsn),
tableloader->pDSN->dsn_info.dsns);
gtk_table_attach_defaults (GTK_TABLE (helper), tableloader->history_dsn,
1, 3, ofs + 3, ofs + 4);
gtk_widget_set_sensitive (tableloader->history_dsn, FALSE);
gtk_signal_connect (GTK_OBJECT (remotes), "clicked",
GTK_SIGNAL_FUNC (enable_widget_as), tableloader->history_dsn);
}
LoadTablesFrame = gtk_frame_new ("Load Tables");
gtk_container_border_width (GTK_CONTAINER (LoadTablesFrame), 5);
gtk_box_pack_start (GTK_BOX (first_vbox), LoadTablesFrame, TRUE, TRUE, 0);
helper = gtk_table_new (3, 1, TRUE);
gtk_container_border_width (GTK_CONTAINER (helper), 5);
gtk_container_add (GTK_CONTAINER (LoadTablesFrame), helper);
tableloader->load_branch = gtk_check_button_new_with_label ("Branch");
gtk_table_attach_defaults (GTK_TABLE (helper), tableloader->load_branch, 0,
1, 0, 1);
tableloader->load_teller = gtk_check_button_new_with_label ("Teller");
gtk_table_attach_defaults (GTK_TABLE (helper), tableloader->load_teller, 0,
1, 1, 2);
tableloader->load_account = gtk_check_button_new_with_label ("Account");
gtk_table_attach_defaults (GTK_TABLE (helper), tableloader->load_account, 0,
1, 2, 3);
second_vbox = gtk_vbox_new (FALSE, 10);
gtk_box_pack_start (GTK_BOX (main_hbox), second_vbox, TRUE, TRUE, 0);
IndexesFrame = gtk_frame_new ("Indices");
gtk_container_border_width (GTK_CONTAINER (IndexesFrame), 5);
gtk_box_pack_start (GTK_BOX (second_vbox), IndexesFrame, TRUE, TRUE, 0);
helper = gtk_hbox_new (TRUE, 10);
gtk_container_border_width (GTK_CONTAINER (helper), 5);
gtk_container_add (GTK_CONTAINER (IndexesFrame), helper);
tableloader->create_indexes =
gtk_check_button_new_with_label ("Create Indices");
gtk_box_pack_start (GTK_BOX (helper), tableloader->create_indexes, TRUE,
TRUE, 0);
tableloader->create_procedures =
gtk_check_button_new_with_label ("Create Procedures");
gtk_box_pack_start (GTK_BOX (helper), tableloader->create_procedures, TRUE,
TRUE, 0);
RecordsToInsertFrame = gtk_frame_new ("Records to Insert");
gtk_container_border_width (GTK_CONTAINER (RecordsToInsertFrame), 5);
gtk_box_pack_start (GTK_BOX (second_vbox), RecordsToInsertFrame, TRUE, TRUE,
0);
helper = gtk_table_new (3, 2, FALSE);
gtk_container_border_width (GTK_CONTAINER (helper), 5);
gtk_container_add (GTK_CONTAINER (RecordsToInsertFrame), helper);
label = gtk_label_new ("Number of branches");
gtk_table_attach_defaults (GTK_TABLE (helper), label, 0, 1, 0, 1);
tableloader->num_branches = gtk_entry_new_with_max_length (10);
gtk_table_attach_defaults (GTK_TABLE (helper), tableloader->num_branches, 1,
2, 0, 1);
label = gtk_label_new ("Number of Tellers");
gtk_table_attach_defaults (GTK_TABLE (helper), label, 0, 1, 1, 2);
tableloader->num_tellers = gtk_entry_new_with_max_length (10);
gtk_table_attach_defaults (GTK_TABLE (helper), tableloader->num_tellers, 1,
2, 1, 2);
label = gtk_label_new ("Number of Accounts");
gtk_table_attach_defaults (GTK_TABLE (helper), label, 0, 1, 2, 3);
tableloader->num_accounts = gtk_entry_new_with_max_length (10);
gtk_table_attach_defaults (GTK_TABLE (helper), tableloader->num_accounts, 1,
2, 2, 3);
helper = gtk_vbox_new (TRUE, 0);
gtk_container_border_width (GTK_CONTAINER (helper), 5);
gtk_box_pack_start (GTK_BOX (second_vbox), helper, TRUE, TRUE, 0);
label = gtk_label_new ("Schema for DBMS");
gtk_box_pack_start (GTK_BOX (helper), label, TRUE, TRUE, 0);
for (i = 0; i < getDriverMapSize (); i++)
list = g_list_append (list, getDriverDBMSName (i));
tableloader->dbmstype = gtk_combo_new ();
gtk_combo_set_popdown_strings (GTK_COMBO (tableloader->dbmstype), list);
gtk_box_pack_start (GTK_BOX (helper), tableloader->dbmstype, TRUE, TRUE, 0);
gtk_widget_show_all (main_hbox);
}
int main (int argc, char *argv[])
{
GtkWidget *load_button;
GtkWidget *table;
GtkWidget *pixmapwid;
GtkStyle *style;
GdkPixmap *pixmap;
GdkBitmap *mask;
GtkWidget *label_core;
GList *glist_gfx = NULL;
GtkWidget *label_gfx;
GtkWidget *config_gfx_button;
GtkWidget *test_gfx_button;
GtkWidget *about_gfx_button;
GList *glist_audio = NULL;
GtkWidget *label_audio;
GtkWidget *config_audio_button;
GtkWidget *test_audio_button;
GtkWidget *about_audio_button;
GList *glist_input = NULL;
GtkWidget *label_input;
GtkWidget *config_input_button;
GtkWidget *test_input_button;
GtkWidget *about_input_button;
GList *glist_RSP = NULL;
GtkWidget *label_RSP;
GtkWidget *config_RSP_button;
GtkWidget *test_RSP_button;
GtkWidget *about_RSP_button;
#ifdef DBG
if (!g_thread_supported())
g_thread_init(NULL);
else
{
fprintf(stderr, "mupen64 will certainly have problems with GTK threads.\n");
fprintf(stderr, "Check your GLIB/GDK/GTK installation for thread support.\n");
}
#endif
gtk_init(&argc, &argv);
if (argv[0][0] != '/')
{
getcwd(cwd, 1024);
strcat(cwd, "/");
strcat(cwd, argv[0]);
}
else
strcpy(cwd, argv[0]);
while(cwd[strlen(cwd)-1] != '/') cwd[strlen(cwd)-1] = '\0';
// création de la fenêtre
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_container_set_border_width(GTK_CONTAINER(window), 10);
gtk_widget_show(window);
// création du bouton Load rom
load_button = gtk_button_new_with_label("Load rom...");
gtk_widget_show(load_button);
// création du logo
style = gtk_widget_get_style(window);
pixmap = gdk_pixmap_create_from_xpm_d(window->window, &mask,
&style->bg[GTK_STATE_NORMAL],
(gchar **)logo_xpm);
pixmapwid = gtk_pixmap_new(pixmap, mask);
gtk_widget_show(pixmapwid);
// création de la selection du mode d'émulation
label_core = gtk_frame_new("cpu core : ");
gtk_widget_show(label_core);
interp = gtk_radio_button_new_with_label(NULL, "interpreter");
gtk_widget_show(interp);
dynam = gtk_radio_button_new_with_label(gtk_radio_button_group(GTK_RADIO_BUTTON(interp)),
"dynamic compiler");
gtk_widget_show(dynam);
pure_interp = gtk_radio_button_new_with_label(gtk_radio_button_group(GTK_RADIO_BUTTON(interp)),
"pure interpreter");
gtk_widget_show(pure_interp);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dynam), TRUE);
// création de l'option 'debugger'
#ifdef DBG
button_debug = gtk_check_button_new_with_label("debugger mode");
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button_debug), FALSE);
gtk_widget_show(button_debug);
#endif
// recherche des plugins
plugin_scan_directory(cwd);
while(plugin_type() != -1)
switch (plugin_type())
{
case PLUGIN_TYPE_GFX:
glist_gfx = g_list_append(glist_gfx, plugin_next());
break;
case PLUGIN_TYPE_AUDIO:
glist_audio = g_list_append(glist_audio, plugin_next());
break;
case PLUGIN_TYPE_CONTROLLER:
glist_input = g_list_append(glist_input, plugin_next());
break;
case PLUGIN_TYPE_RSP:
glist_RSP = g_list_append(glist_RSP, plugin_next());
break;
}
label_gfx = gtk_frame_new("gfx plugin : ");
gtk_widget_show(label_gfx);
combo_gfx = gtk_combo_new();
gtk_combo_set_popdown_strings(GTK_COMBO(combo_gfx), glist_gfx);
gtk_combo_set_value_in_list(GTK_COMBO(combo_gfx), TRUE, FALSE);
gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(combo_gfx)->entry), FALSE);
gtk_widget_show(combo_gfx);
config_gfx_button = gtk_button_new_with_label("Config");
gtk_widget_show(config_gfx_button);
test_gfx_button = gtk_button_new_with_label("Test");
gtk_widget_show(test_gfx_button);
about_gfx_button = gtk_button_new_with_label("About");
gtk_widget_show(about_gfx_button);
label_audio = gtk_frame_new("audio plugin : ");
gtk_widget_show(label_audio);
combo_audio = gtk_combo_new();
gtk_combo_set_popdown_strings(GTK_COMBO(combo_audio), glist_audio);
gtk_combo_set_value_in_list(GTK_COMBO(combo_audio), TRUE, FALSE);
gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(combo_audio)->entry), FALSE);
gtk_widget_show(combo_audio);
config_audio_button = gtk_button_new_with_label("Config");
gtk_widget_show(config_audio_button);
test_audio_button = gtk_button_new_with_label("Test");
gtk_widget_show(test_audio_button);
about_audio_button = gtk_button_new_with_label("About");
gtk_widget_show(about_audio_button);
label_input = gtk_frame_new("input plugin : ");
gtk_widget_show(label_input);
combo_input = gtk_combo_new();
gtk_combo_set_popdown_strings(GTK_COMBO(combo_input), glist_input);
gtk_combo_set_value_in_list(GTK_COMBO(combo_input), TRUE, FALSE);
gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(combo_input)->entry), FALSE);
gtk_widget_show(combo_input);
config_input_button = gtk_button_new_with_label("Config");
gtk_widget_show(config_input_button);
test_input_button = gtk_button_new_with_label("Test");
gtk_widget_show(test_input_button);
about_input_button = gtk_button_new_with_label("About");
gtk_widget_show(about_input_button);
label_RSP = gtk_frame_new("RSP plugin : ");
gtk_widget_show(label_RSP);
combo_RSP = gtk_combo_new();
gtk_combo_set_popdown_strings(GTK_COMBO(combo_RSP), glist_RSP);
gtk_combo_set_value_in_list(GTK_COMBO(combo_RSP), TRUE, FALSE);
gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(combo_RSP)->entry), FALSE);
gtk_widget_show(combo_RSP);
config_RSP_button = gtk_button_new_with_label("Config");
gtk_widget_show(config_RSP_button);
test_RSP_button = gtk_button_new_with_label("Test");
gtk_widget_show(test_RSP_button);
about_RSP_button = gtk_button_new_with_label("About");
gtk_widget_show(about_RSP_button);
// mise en place des évenements
gtk_signal_connect(GTK_OBJECT(window), "delete_event",
GTK_SIGNAL_FUNC(delete_event), NULL);
gtk_signal_connect(GTK_OBJECT(window), "destroy",
GTK_SIGNAL_FUNC(destroy), NULL);
gtk_signal_connect(GTK_OBJECT(load_button), "clicked",
GTK_SIGNAL_FUNC(load), NULL);
gtk_signal_connect(GTK_OBJECT(config_gfx_button), "clicked",
GTK_SIGNAL_FUNC(config_gfx), NULL);
gtk_signal_connect(GTK_OBJECT(test_gfx_button), "clicked",
GTK_SIGNAL_FUNC(test_gfx), NULL);
gtk_signal_connect(GTK_OBJECT(about_gfx_button), "clicked",
GTK_SIGNAL_FUNC(about_gfx), NULL);
gtk_signal_connect(GTK_OBJECT(config_audio_button), "clicked",
GTK_SIGNAL_FUNC(config_audio), NULL);
gtk_signal_connect(GTK_OBJECT(test_audio_button), "clicked",
GTK_SIGNAL_FUNC(test_audio), NULL);
gtk_signal_connect(GTK_OBJECT(about_audio_button), "clicked",
GTK_SIGNAL_FUNC(about_audio), NULL);
gtk_signal_connect(GTK_OBJECT(config_input_button), "clicked",
GTK_SIGNAL_FUNC(config_input), NULL);
gtk_signal_connect(GTK_OBJECT(test_input_button), "clicked",
GTK_SIGNAL_FUNC(test_input), NULL);
gtk_signal_connect(GTK_OBJECT(about_input_button), "clicked",
GTK_SIGNAL_FUNC(about_input), NULL);
gtk_signal_connect(GTK_OBJECT(config_RSP_button), "clicked",
GTK_SIGNAL_FUNC(config_RSP), NULL);
gtk_signal_connect(GTK_OBJECT(test_RSP_button), "clicked",
GTK_SIGNAL_FUNC(test_RSP), NULL);
gtk_signal_connect(GTK_OBJECT(about_RSP_button), "clicked",
GTK_SIGNAL_FUNC(about_RSP), NULL);
// mise en page
table = gtk_table_new(55, 30, TRUE);
gtk_widget_show(table);
gtk_container_add(GTK_CONTAINER(window), table);
gtk_table_attach_defaults(GTK_TABLE(table), load_button, 0, 10, 0, 3);
gtk_table_attach_defaults(GTK_TABLE(table), label_core, 0, 10, 5, 15);
gtk_table_attach_defaults(GTK_TABLE(table), pixmapwid, 10, 30, 0, 10);
gtk_table_attach_defaults(GTK_TABLE(table), interp, 1, 10, 6, 9);
gtk_table_attach_defaults(GTK_TABLE(table), dynam, 1, 10, 9, 12);
gtk_table_attach_defaults(GTK_TABLE(table), pure_interp, 1, 10, 12, 15);
#ifdef DBG
gtk_table_attach_defaults(GTK_TABLE(table), button_debug, 15, 25, 12, 15);
#endif
gtk_table_attach_defaults(GTK_TABLE(table), label_gfx, 0, 30, 15, 25);
gtk_table_attach_defaults(GTK_TABLE(table), combo_gfx, 1, 29, 17, 22);
gtk_table_attach_defaults(GTK_TABLE(table), config_gfx_button, 1, 10, 22, 24);
gtk_table_attach_defaults(GTK_TABLE(table), test_gfx_button, 10, 20, 22, 24);
gtk_table_attach_defaults(GTK_TABLE(table), about_gfx_button, 20, 29, 22, 24);
gtk_table_attach_defaults(GTK_TABLE(table), label_audio, 0, 30, 25, 35);
gtk_table_attach_defaults(GTK_TABLE(table), combo_audio, 1, 29, 27, 32);
gtk_table_attach_defaults(GTK_TABLE(table), config_audio_button, 1, 10, 32, 34);
gtk_table_attach_defaults(GTK_TABLE(table), test_audio_button, 10, 20, 32, 34);
gtk_table_attach_defaults(GTK_TABLE(table), about_audio_button, 20, 29, 32, 34);
gtk_table_attach_defaults(GTK_TABLE(table), label_input, 0, 30, 35, 45);
gtk_table_attach_defaults(GTK_TABLE(table), combo_input, 1, 29, 37, 42);
gtk_table_attach_defaults(GTK_TABLE(table), config_input_button, 1, 10, 42, 44);
gtk_table_attach_defaults(GTK_TABLE(table), test_input_button, 10, 20, 42, 44);
gtk_table_attach_defaults(GTK_TABLE(table), about_input_button, 20, 29, 42, 44);
gtk_table_attach_defaults(GTK_TABLE(table), label_RSP, 0, 30, 45, 55);
gtk_table_attach_defaults(GTK_TABLE(table), combo_RSP, 1, 29, 47, 52);
gtk_table_attach_defaults(GTK_TABLE(table), config_RSP_button, 1, 10, 52, 54);
gtk_table_attach_defaults(GTK_TABLE(table), test_RSP_button, 10, 20, 52, 54);
gtk_table_attach_defaults(GTK_TABLE(table), about_RSP_button, 20, 29, 52, 54);
gtk_main();
return 0;
}
static void
create_changeDialogs()
{
GtkWidget *button;
// integer dialog
m_IntegerDialog.dialog = gtk_dialog_new();
gtk_container_set_border_width( GTK_CONTAINER(m_IntegerDialog.dialog), 10 );
gtk_window_set_title( GTK_WINDOW(m_IntegerDialog.dialog), tr("Change") );
gtk_signal_connect(GTK_OBJECT(m_IntegerDialog.dialog), "delete_event",
GTK_SIGNAL_FUNC(delete_question_event), (gpointer)NULL );
gtk_signal_connect(GTK_OBJECT(m_IntegerDialog.dialog), "hide",
GTK_SIGNAL_FUNC(callback_changeDialogHidden), (gpointer)NULL );
m_IntegerDialog.entry = gtk_entry_new();
gtk_box_pack_start( GTK_BOX(GTK_DIALOG(m_IntegerDialog.dialog)->vbox), m_IntegerDialog.entry, TRUE, TRUE, 0 );
button = gtk_button_new_with_label( tr("Ok") );
gtk_box_pack_start( GTK_BOX(GTK_DIALOG(m_IntegerDialog.dialog)->action_area), button, TRUE, TRUE, 0 );
gtk_signal_connect( GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(callback_integerChangeOkClicked), (gpointer)NULL );
button = gtk_button_new_with_label( tr("Cancel") );
gtk_box_pack_start( GTK_BOX(GTK_DIALOG(m_IntegerDialog.dialog)->action_area), button, TRUE, TRUE, 0 );
gtk_signal_connect_object( GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(gtk_widget_hide), GTK_OBJECT(m_IntegerDialog.dialog) );
// string dialog
m_StringDialog.dialog = gtk_dialog_new();
gtk_container_set_border_width( GTK_CONTAINER(m_StringDialog.dialog), 10 );
gtk_window_set_title( GTK_WINDOW(m_StringDialog.dialog), tr("Change") );
gtk_signal_connect(GTK_OBJECT(m_StringDialog.dialog), "delete_event",
GTK_SIGNAL_FUNC(delete_question_event), (gpointer)NULL );
gtk_signal_connect(GTK_OBJECT(m_StringDialog.dialog), "hide",
GTK_SIGNAL_FUNC(callback_changeDialogHidden), (gpointer)NULL );
m_StringDialog.entry = gtk_entry_new();
gtk_box_pack_start( GTK_BOX(GTK_DIALOG(m_StringDialog.dialog)->vbox), m_StringDialog.entry, TRUE, TRUE, 0 );
button = gtk_button_new_with_label( tr("Ok") );
gtk_box_pack_start( GTK_BOX(GTK_DIALOG(m_StringDialog.dialog)->action_area), button, TRUE, TRUE, 0 );
gtk_signal_connect( GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(callback_stringChangeOkClicked), (gpointer)NULL );
button = gtk_button_new_with_label( tr("Cancel") );
gtk_box_pack_start( GTK_BOX(GTK_DIALOG(m_StringDialog.dialog)->action_area), button, TRUE, TRUE, 0 );
gtk_signal_connect_object( GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(gtk_widget_hide), GTK_OBJECT(m_StringDialog.dialog) );
// select dialog
m_SelectDialog.dialog = gtk_dialog_new();
gtk_container_set_border_width( GTK_CONTAINER(m_SelectDialog.dialog), 10 );
gtk_window_set_title( GTK_WINDOW(m_SelectDialog.dialog), tr("Change") );
gtk_signal_connect(GTK_OBJECT(m_SelectDialog.dialog), "delete_event",
GTK_SIGNAL_FUNC(delete_question_event), (gpointer)NULL );
gtk_signal_connect(GTK_OBJECT(m_SelectDialog.dialog), "hide",
GTK_SIGNAL_FUNC(callback_changeDialogHidden), (gpointer)NULL );
m_SelectDialog.combo = gtk_combo_new();
gtk_combo_set_value_in_list( GTK_COMBO(m_SelectDialog.combo), TRUE, FALSE );
gtk_box_pack_start( GTK_BOX(GTK_DIALOG(m_SelectDialog.dialog)->vbox), m_SelectDialog.combo, TRUE, TRUE, 0 );
button = gtk_button_new_with_label( tr("Ok") );
gtk_box_pack_start( GTK_BOX(GTK_DIALOG(m_SelectDialog.dialog)->action_area), button, TRUE, TRUE, 0 );
gtk_signal_connect( GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(callback_selectChangeOkClicked), (gpointer)NULL );
button = gtk_button_new_with_label( tr("Cancel") );
gtk_box_pack_start( GTK_BOX(GTK_DIALOG(m_SelectDialog.dialog)->action_area), button, TRUE, TRUE, 0 );
gtk_signal_connect_object( GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(gtk_widget_hide), GTK_OBJECT(m_SelectDialog.dialog) );
}
static GtkWidget *
create_midi_note(void)
{
GtkWidget *vbox;
GtkWidget *button;
GtkWidget *enable_button;
GtkWidget *mimpi_button;
GtkWidget *label;
GtkWidget *combo;
GtkWidget *entry;
GtkWidget *hbox;
static midi_init_item_t mii;
GList *items;
int i;
vbox = gtk_vbox_new(FALSE, 4);
hbox = gtk_hbox_new(FALSE, 3);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show(hbox);
enable_button = gtk_check_button_new_with_label(
"Enable MIDI");
gtk_container_set_border_width(GTK_CONTAINER(enable_button), 5);
gtk_box_pack_start(GTK_BOX(hbox), enable_button, FALSE, FALSE, 0);
gtk_widget_show(enable_button);
mii.init_combo = combo = gtk_combo_new();
gtk_container_set_border_width(GTK_CONTAINER(combo), 5);
gtk_combo_set_value_in_list(GTK_COMBO(combo), TRUE, TRUE);
gtk_combo_set_use_arrows_always(GTK_COMBO(combo), TRUE);
for (items = 0, i = 0; i < NELEMENTS(MIDI_TYPE_NAME); ++i)
items = g_list_append(items, (gpointer)MIDI_TYPE_NAME[i]);
gtk_combo_set_popdown_strings(GTK_COMBO(combo), items);
g_list_free(items);
gtk_box_pack_end(GTK_BOX(hbox), combo, FALSE, FALSE, 0);
gtk_widget_show(combo);
entry = GTK_COMBO(combo)->entry;
gtk_entry_set_editable(GTK_ENTRY(entry), FALSE);
gtk_signal_connect(GTK_OBJECT(entry), "changed",
GTK_SIGNAL_FUNC(midi_init_entry_changed), 0);
gtk_widget_show(entry);
mii.init_label = label = gtk_label_new(
"- MIDI initialized method:");
gtk_box_pack_end(GTK_BOX(hbox), label, TRUE, TRUE, 0);
gtk_widget_show(label);
mii.reset_button = button = gtk_check_button_new_with_label(
"Send initialize command when X68k is reseted");
gtk_container_set_border_width(GTK_CONTAINER(button), 5);
gtk_box_pack_start(GTK_BOX(vbox), button, FALSE, FALSE, 0);
gtk_signal_connect(GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(midi_send_reset_button_clicked), 0);
gtk_widget_show(button);
if (Config.MIDI_Reset)
gtk_signal_emit_by_name(GTK_OBJECT(button), "clicked");
mii.mimpi_button = mimpi_button = gtk_check_button_new_with_label(
"Use MIMPI tone map");
gtk_container_set_border_width(GTK_CONTAINER(mimpi_button), 5);
gtk_box_pack_start(GTK_BOX(vbox), mimpi_button, FALSE, FALSE, 0);
gtk_widget_show(mimpi_button);
hbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show(hbox);
mii.mimpi_entry = entry = gtk_entry_new();
gtk_entry_set_max_length(GTK_ENTRY(entry), MAX_PATH - 1);
gtk_entry_set_editable(GTK_ENTRY(entry), FALSE);
gtk_box_pack_start(GTK_BOX(hbox), entry, TRUE, TRUE, 10);
gtk_widget_show(entry);
mii.mimpi_browse_button = button = gtk_button_new_with_label(
"Browse...");
gtk_container_set_border_width(GTK_CONTAINER(button), 5);
gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_signal_connect(GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(midi_mimpi_browse_button_clicked),
(gpointer)&mii);
gtk_widget_show(button);
/* MIMPI ToneMap */
gtk_signal_connect(GTK_OBJECT(mimpi_button), "clicked",
GTK_SIGNAL_FUNC(midi_mimpi_button_clicked),
(gpointer)&mii);
if (!Config.ToneMap)
gtk_signal_emit_by_name(GTK_OBJECT(mimpi_button), "clicked");
gtk_signal_emit_by_name(GTK_OBJECT(mimpi_button), "clicked");
/* Enable MIDI */
gtk_signal_connect(GTK_OBJECT(enable_button), "clicked",
GTK_SIGNAL_FUNC(midi_enable_button_clicked),
(gpointer)&mii);
if (!Config.MIDI_SW)
gtk_signal_emit_by_name(GTK_OBJECT(enable_button), "clicked");
gtk_signal_emit_by_name(GTK_OBJECT(enable_button), "clicked");
return vbox;
}
static int Config_CreateWindow()
{
GtkWidget *okButton, *cancelButton;
GtkWidget *displayFrame, *texturesFrame;
GtkWidget *displayTable, *texturesTable;
// GtkWidget *fullscreenModeLabel, *windowedModeLabel;
GtkWidget *videoModeLabel;
// GtkWidget *bitdepthLabel, *resolutionLabel;
GtkWidget *resolutionLabel;
GtkWidget *textureDepthLabel;
GtkWidget *textureCacheLabel;
GList *resolutionList = NULL, *textureDepthList = NULL;
//SDL_Rect **modes;
//static char modeBuf[20][20];
int i;
// create dialog
configWindow = gtk_dialog_new();
gtk_signal_connect_object( GTK_OBJECT(configWindow), "delete-event",
GTK_SIGNAL_FUNC(gtk_widget_hide_on_delete), GTK_OBJECT(configWindow) );
gtk_signal_connect_object( GTK_OBJECT(configWindow), "show",
GTK_SIGNAL_FUNC(configWindow_show), NULL );
gtk_window_set_title( GTK_WINDOW(configWindow), pluginName );
// ok button
okButton = gtk_button_new_with_label( "Ok" );
gtk_signal_connect_object( GTK_OBJECT(okButton), "clicked",
GTK_SIGNAL_FUNC(okButton_clicked), NULL );
gtk_container_add( GTK_CONTAINER(GTK_DIALOG(configWindow)->action_area), okButton );
// cancel button
cancelButton = gtk_button_new_with_label( "Cancel" );
gtk_signal_connect_object( GTK_OBJECT(cancelButton), "clicked",
GTK_SIGNAL_FUNC(cancelButton_clicked), NULL );
gtk_container_add( GTK_CONTAINER(GTK_DIALOG(configWindow)->action_area), cancelButton );
// display frame
displayFrame = gtk_frame_new( "Display" );
gtk_container_set_border_width( GTK_CONTAINER(displayFrame), 7 );
gtk_container_add( GTK_CONTAINER(GTK_DIALOG(configWindow)->vbox), displayFrame );
displayTable = gtk_table_new( 6, 3, FALSE );
gtk_container_set_border_width( GTK_CONTAINER(displayTable), 7 );
gtk_table_set_col_spacings( GTK_TABLE(displayTable), 3 );
gtk_table_set_row_spacings( GTK_TABLE(displayTable), 3 );
gtk_container_add( GTK_CONTAINER(displayFrame), displayTable );
/* fullscreenModeLabel = gtk_label_new( "Fullscreen mode" );
windowedModeLabel = gtk_label_new( "Windowed mode" );
bitdepthLabel = gtk_label_new( "Bit depth" );*/
videoModeLabel = gtk_label_new( "Video mode" );
resolutionLabel = gtk_label_new( "Resolution" );
/* for (i = 0; i < 2; i++)
{
static GList *bitdepthList = NULL;
if (!bitdepthList)
{
bitdepthList = g_list_append( bitdepthList, "Desktop" );
bitdepthList = g_list_append( bitdepthList, "16 bit" );
bitdepthList = g_list_append( bitdepthList, "32 bit" );
}
bitdepthCombo[i] = gtk_combo_new();
gtk_combo_set_value_in_list( GTK_COMBO(bitdepthCombo[i]), TRUE, FALSE );
gtk_combo_set_popdown_strings( GTK_COMBO(bitdepthCombo[i]), bitdepthList );
resolutionCombo[i] = gtk_combo_new();
gtk_combo_set_value_in_list( GTK_COMBO(resolutionCombo[i]), TRUE, FALSE );
}*/
// get video mode list
/* modes = SDL_ListModes( NULL, SDL_HWSURFACE );//SDL_OPENGL | SDL_GL_DOUBLEBUFFER | SDL_HWPALETTE | SDL_HWSURFACE | SDL_HWACCEL );
if (modes == (SDL_Rect **)0)
{
printf( "glNintendo64: No modes available!\n" );
}
else if (modes == (SDL_Rect **)-1)
{
printf( "glNintendo64: All resolutions available.\n" );
}
else
{
char buf[200];
for (i = 0; modes[i]; i++)// ++i)
{
sprintf( modeBuf[i], "%d x %d", modes[i]->w, modes[i]->h );
resolutionList = g_list_append( resolutionList, modeBuf[i] );
}
}*/
resolutionList = g_list_append( resolutionList, (void *)"320 x 240" );
resolutionList = g_list_append( resolutionList, (void *)"400 x 300" );
resolutionList = g_list_append( resolutionList, (void *)"480 x 360" );
resolutionList = g_list_append( resolutionList, (void *)"640 x 480" );
resolutionList = g_list_append( resolutionList, (void *)"800 x 600" );
resolutionList = g_list_append( resolutionList, (void *)"960 x 720" );
resolutionList = g_list_append( resolutionList, (void *)"1024 x 768" );
resolutionList = g_list_append( resolutionList, (void *)"1152 x 864" );
resolutionList = g_list_append( resolutionList, (void *)"1280 x 960" );
resolutionList = g_list_append( resolutionList, (void *)"1280 x 1024" );
resolutionList = g_list_append( resolutionList, (void *)"1440 x 1080" );
resolutionList = g_list_append( resolutionList, (void *)"1600 x 1200" );
resolutionCombo = gtk_combo_new();
gtk_combo_set_value_in_list( GTK_COMBO(resolutionCombo), TRUE, FALSE );
gtk_combo_set_popdown_strings( GTK_COMBO(resolutionCombo), resolutionList );
enableAnisotropicFilteringCheck = gtk_check_button_new_with_label( "Enable anisotropic filtering" );
enable2xSAICheck = gtk_check_button_new_with_label( "Enable 2xSAI texture scaling" );
forceBilinearCheck = gtk_check_button_new_with_label( "Force bilinear filtering" );
enableFogCheck = gtk_check_button_new_with_label( "Enable fog" );
enablePolygonStippleCheck = gtk_check_button_new_with_label( "Enable dithered alpha testing" );
/* // row 0
gtk_table_attach_defaults( GTK_TABLE(displayTable), bitdepthLabel, 1, 2, 0, 1 );
gtk_table_attach_defaults( GTK_TABLE(displayTable), resolutionLabel, 2, 3, 0, 1 );
// row 1
gtk_table_attach_defaults( GTK_TABLE(displayTable), fullscreenModeLabel, 0, 1, 1, 2 );
gtk_table_attach_defaults( GTK_TABLE(displayTable), bitdepthCombo[0], 1, 2, 1, 2 );
gtk_table_attach_defaults( GTK_TABLE(displayTable), resolutionCombo[0], 2, 3, 1, 2 );
// row 2
gtk_table_attach_defaults( GTK_TABLE(displayTable), windowedModeLabel, 0, 1, 2, 3 );
gtk_table_attach_defaults( GTK_TABLE(displayTable), bitdepthCombo[1], 1, 2, 2, 3 );
gtk_table_attach_defaults( GTK_TABLE(displayTable), resolutionCombo[1], 2, 3, 2, 3 );
*/
// row 0
gtk_table_attach_defaults( GTK_TABLE(displayTable), resolutionLabel, 2, 3, 0, 1 );
// row 1
gtk_table_attach_defaults( GTK_TABLE(displayTable), videoModeLabel, 0, 1, 1, 2 );
gtk_table_attach_defaults( GTK_TABLE(displayTable), resolutionCombo, 2, 3, 1, 2 );
// row 3
gtk_table_attach_defaults( GTK_TABLE(displayTable), enableFogCheck, 0, 1, 3, 4 );
gtk_table_attach_defaults( GTK_TABLE(displayTable), forceBilinearCheck, 1, 2, 3, 4 );
// row 4
gtk_table_attach_defaults( GTK_TABLE(displayTable), enable2xSAICheck, 0, 1, 4, 5 );
gtk_table_attach_defaults( GTK_TABLE(displayTable), enablePolygonStippleCheck, 1, 2, 4, 5 );
// row 5
gtk_table_attach_defaults( GTK_TABLE(displayTable), enableAnisotropicFilteringCheck, 0, 1, 5, 6);
// textures frame
texturesFrame = gtk_frame_new( "Textures" );
gtk_container_set_border_width( GTK_CONTAINER(texturesFrame), 7 );
gtk_container_add( GTK_CONTAINER(GTK_DIALOG(configWindow)->vbox), texturesFrame );
texturesTable = gtk_table_new( 3, 2, FALSE );
gtk_container_set_border_width( GTK_CONTAINER(texturesTable), 7 );
gtk_table_set_col_spacings( GTK_TABLE(texturesTable), 3 );
gtk_table_set_row_spacings( GTK_TABLE(texturesTable), 3 );
gtk_container_add( GTK_CONTAINER(texturesFrame), texturesTable );
textureDepthLabel = gtk_label_new( "Texture bit depth" );
textureDepthCombo = gtk_combo_new();
if (!textureDepthList)
{
i = 0;
while (textureBitDepth[i] != 0)
{
textureDepthList = g_list_append( textureDepthList, (void *)textureBitDepth[i] );
i++;
}
}
gtk_combo_set_popdown_strings( GTK_COMBO(textureDepthCombo), textureDepthList );
gtk_combo_set_value_in_list( GTK_COMBO(textureDepthCombo), TRUE, FALSE );
textureCacheLabel = gtk_label_new( "Texture cache size (MB)" );
textureCacheEntry = gtk_entry_new();
gtk_entry_set_text( GTK_ENTRY(textureCacheEntry), "0" );
enableHardwareFBCheck = gtk_check_button_new_with_label( "HW framebuffer textures (experimental)" );
// row 0
gtk_table_attach_defaults( GTK_TABLE(texturesTable), textureDepthLabel, 0, 1, 0, 1 );
gtk_table_attach_defaults( GTK_TABLE(texturesTable), textureDepthCombo, 1, 2, 0, 1 );
// row 1
gtk_table_attach_defaults( GTK_TABLE(texturesTable), textureCacheLabel, 0, 1, 1, 2 );
gtk_table_attach_defaults( GTK_TABLE(texturesTable), textureCacheEntry, 1, 2, 1, 2 );
// row 2
gtk_table_attach_defaults( GTK_TABLE(texturesTable), enableHardwareFBCheck, 0, 2, 2, 3 );
return 0;
}
GtkWidget*
create_app (void)
{
GtkWidget *app;
GtkWidget *dock1;
GtkWidget *toolbar1;
GtkWidget *tmp_toolbar_icon;
GtkWidget *button_new;
GtkWidget *button_open;
GtkWidget *button_save;
GtkWidget *button_save_as;
GtkWidget *hexentry;
GtkWidget *button_upload;
GtkWidget *radiobutton_spline;
GtkWidget *radiobutton_linear;
GtkWidget *radiobutton_free;
GtkWidget *vbox1;
GtkWidget *hbox1;
GtkWidget *vbox2;
GtkWidget *table1;
GtkWidget *label1;
GtkWidget *label2;
GtkWidget *label3;
GtkWidget *label4;
GtkWidget *label5;
GtkWidget *label6;
GtkObject *minx_adj;
GtkWidget *minx;
GtkWidget *type;
GList *type_items = NULL;
GtkWidget *typeentry;
GtkObject *maxx_adj;
GtkWidget *maxx;
GtkObject *miny_adj;
GtkWidget *miny;
GtkObject *maxy_adj;
GtkWidget *maxy;
GtkObject *count_adj;
GtkWidget *count;
GtkWidget *label10;
GtkWidget *label11;
GtkWidget *label12;
GtkObject *scale_adj;
GtkWidget *scale;
GtkObject *base_adj;
GtkWidget *base;
GtkWidget *label13;
GtkWidget *scrolledwindow1;
GtkWidget *clist;
GtkWidget *label8;
GtkWidget *label9;
GtkWidget *toolbar2;
GtkWidget *list_open;
GtkWidget *list_save;
GtkWidget *list_add;
GtkWidget *list_remove;
GtkWidget *list_use;
GtkWidget *curve;
GtkWidget *appbar1;
app = gnome_app_new ("Curvegen", _("PSXDEV Curve Generator"));
gtk_object_set_data (GTK_OBJECT (app), "app", app);
dock1 = GNOME_APP (app)->dock;
gtk_widget_ref (dock1);
gtk_object_set_data_full (GTK_OBJECT (app), "dock1", dock1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (dock1);
gnome_app_create_menus (GNOME_APP (app), menubar1_uiinfo);
gtk_widget_ref (menubar1_uiinfo[0].widget);
gtk_object_set_data_full (GTK_OBJECT (app), "file1",
menubar1_uiinfo[0].widget,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_ref (file1_menu_uiinfo[0].widget);
gtk_object_set_data_full (GTK_OBJECT (app), "exit1",
file1_menu_uiinfo[0].widget,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_ref (menubar1_uiinfo[1].widget);
gtk_object_set_data_full (GTK_OBJECT (app), "help1",
menubar1_uiinfo[1].widget,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_ref (help1_menu_uiinfo[0].widget);
gtk_object_set_data_full (GTK_OBJECT (app), "about1",
help1_menu_uiinfo[0].widget,
(GtkDestroyNotify) gtk_widget_unref);
toolbar1 = gtk_toolbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_BOTH);
gtk_widget_ref (toolbar1);
gtk_object_set_data_full (GTK_OBJECT (app), "toolbar1", toolbar1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (toolbar1);
gnome_app_add_toolbar (GNOME_APP (app), GTK_TOOLBAR (toolbar1), "toolbar1",
GNOME_DOCK_ITEM_BEH_EXCLUSIVE,
GNOME_DOCK_TOP, 1, 0, 0);
gtk_container_set_border_width (GTK_CONTAINER (toolbar1), 1);
gtk_toolbar_set_space_size (GTK_TOOLBAR (toolbar1), 16);
gtk_toolbar_set_space_style (GTK_TOOLBAR (toolbar1), GTK_TOOLBAR_SPACE_LINE);
gtk_toolbar_set_button_relief (GTK_TOOLBAR (toolbar1), GTK_RELIEF_NONE);
tmp_toolbar_icon = gnome_stock_pixmap_widget (app, GNOME_STOCK_PIXMAP_NEW);
button_new = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar1),
GTK_TOOLBAR_CHILD_BUTTON,
NULL,
_("New"),
_("New File"), NULL,
tmp_toolbar_icon, NULL, NULL);
gtk_widget_ref (button_new);
gtk_object_set_data_full (GTK_OBJECT (app), "button_new", button_new,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (button_new);
tmp_toolbar_icon = gnome_stock_pixmap_widget (app, GNOME_STOCK_PIXMAP_OPEN);
button_open = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar1),
GTK_TOOLBAR_CHILD_BUTTON,
NULL,
_("Open"),
_("Open File"), NULL,
tmp_toolbar_icon, NULL, NULL);
gtk_widget_ref (button_open);
gtk_object_set_data_full (GTK_OBJECT (app), "button_open", button_open,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (button_open);
gtk_widget_set_sensitive (button_open, FALSE);
tmp_toolbar_icon = gnome_stock_pixmap_widget (app, GNOME_STOCK_PIXMAP_SAVE);
button_save = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar1),
GTK_TOOLBAR_CHILD_BUTTON,
NULL,
_("Save"),
_("Save File"), NULL,
tmp_toolbar_icon, NULL, NULL);
gtk_widget_ref (button_save);
gtk_object_set_data_full (GTK_OBJECT (app), "button_save", button_save,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (button_save);
tmp_toolbar_icon = gnome_stock_pixmap_widget (app, GNOME_STOCK_PIXMAP_SAVE_AS);
button_save_as = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar1),
GTK_TOOLBAR_CHILD_BUTTON,
NULL,
_("Save As"),
NULL, NULL,
tmp_toolbar_icon, NULL, NULL);
gtk_widget_ref (button_save_as);
gtk_object_set_data_full (GTK_OBJECT (app), "button_save_as", button_save_as,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (button_save_as);
hexentry = gtk_entry_new ();
gtk_widget_ref (hexentry);
gtk_object_set_data_full (GTK_OBJECT (app), "hexentry", hexentry,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hexentry);
gtk_toolbar_append_widget (GTK_TOOLBAR (toolbar1), hexentry, _("Address of curve in PlayStation memory..."), NULL);
tmp_toolbar_icon = gnome_stock_pixmap_widget (app, GNOME_STOCK_PIXMAP_MAIL_FWD);
button_upload = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar1),
GTK_TOOLBAR_CHILD_BUTTON,
NULL,
_("Upload"),
NULL, NULL,
tmp_toolbar_icon, NULL, NULL);
gtk_widget_ref (button_upload);
gtk_object_set_data_full (GTK_OBJECT (app), "button_upload", button_upload,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (button_upload);
gtk_toolbar_append_space (GTK_TOOLBAR (toolbar1));
tmp_toolbar_icon = gnome_stock_pixmap_widget (app, GNOME_STOCK_PIXMAP_CONVERT);
radiobutton_spline = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar1),
GTK_TOOLBAR_CHILD_RADIOBUTTON,
NULL,
_("SPLINE"),
NULL, NULL,
tmp_toolbar_icon, NULL, NULL);
gtk_widget_ref (radiobutton_spline);
gtk_object_set_data_full (GTK_OBJECT (app), "radiobutton_spline", radiobutton_spline,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (radiobutton_spline);
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (radiobutton_spline), FALSE);
tmp_toolbar_icon = gnome_stock_pixmap_widget (app, GNOME_STOCK_PIXMAP_CONVERT);
radiobutton_linear = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar1),
GTK_TOOLBAR_CHILD_RADIOBUTTON,
radiobutton_spline,
_("LINEAR"),
NULL, NULL,
tmp_toolbar_icon, NULL, NULL);
gtk_widget_ref (radiobutton_linear);
gtk_object_set_data_full (GTK_OBJECT (app), "radiobutton_linear", radiobutton_linear,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (radiobutton_linear);
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (radiobutton_linear), FALSE);
tmp_toolbar_icon = gnome_stock_pixmap_widget (app, GNOME_STOCK_PIXMAP_CONVERT);
radiobutton_free = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar1),
GTK_TOOLBAR_CHILD_RADIOBUTTON,
radiobutton_spline,
_("FREE"),
NULL, NULL,
tmp_toolbar_icon, NULL, NULL);
gtk_widget_ref (radiobutton_free);
gtk_object_set_data_full (GTK_OBJECT (app), "radiobutton_free", radiobutton_free,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (radiobutton_free);
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (radiobutton_free), FALSE);
vbox1 = gtk_vbox_new (FALSE, 0);
gtk_widget_ref (vbox1);
gtk_object_set_data_full (GTK_OBJECT (app), "vbox1", vbox1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (vbox1);
gnome_app_set_contents (GNOME_APP (app), vbox1);
hbox1 = gtk_hbox_new (FALSE, 0);
gtk_widget_ref (hbox1);
gtk_object_set_data_full (GTK_OBJECT (app), "hbox1", hbox1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox1);
gtk_box_pack_start (GTK_BOX (vbox1), hbox1, TRUE, TRUE, 0);
vbox2 = gtk_vbox_new (FALSE, 0);
gtk_widget_ref (vbox2);
gtk_object_set_data_full (GTK_OBJECT (app), "vbox2", vbox2,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (vbox2);
gtk_box_pack_start (GTK_BOX (hbox1), vbox2, FALSE, TRUE, 0);
table1 = gtk_table_new (10, 2, FALSE);
gtk_widget_ref (table1);
gtk_object_set_data_full (GTK_OBJECT (app), "table1", table1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (table1);
gtk_box_pack_start (GTK_BOX (vbox2), table1, FALSE, FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (table1), 4);
gtk_table_set_row_spacings (GTK_TABLE (table1), 1);
gtk_table_set_col_spacings (GTK_TABLE (table1), 2);
label1 = gtk_label_new (_("Min X"));
gtk_widget_ref (label1);
gtk_object_set_data_full (GTK_OBJECT (app), "label1", label1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label1);
gtk_table_attach (GTK_TABLE (table1), label1, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label1), 7.45058e-09, 0.5);
label2 = gtk_label_new (_("Max X"));
gtk_widget_ref (label2);
gtk_object_set_data_full (GTK_OBJECT (app), "label2", label2,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label2);
gtk_table_attach (GTK_TABLE (table1), label2, 0, 1, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label2), 7.45058e-09, 0.5);
label3 = gtk_label_new (_("Min Y"));
gtk_widget_ref (label3);
gtk_object_set_data_full (GTK_OBJECT (app), "label3", label3,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label3);
gtk_table_attach (GTK_TABLE (table1), label3, 0, 1, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label3), 7.45058e-09, 0.5);
label4 = gtk_label_new (_("Max Y"));
gtk_widget_ref (label4);
gtk_object_set_data_full (GTK_OBJECT (app), "label4", label4,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label4);
gtk_table_attach (GTK_TABLE (table1), label4, 0, 1, 4, 5,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label4), 7.45058e-09, 0.5);
label5 = gtk_label_new (_("Count"));
gtk_widget_ref (label5);
gtk_object_set_data_full (GTK_OBJECT (app), "label5", label5,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label5);
gtk_table_attach (GTK_TABLE (table1), label5, 0, 1, 8, 9,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label5), 0, 0.5);
label6 = gtk_label_new (_("Type"));
gtk_widget_ref (label6);
gtk_object_set_data_full (GTK_OBJECT (app), "label6", label6,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label6);
gtk_table_attach (GTK_TABLE (table1), label6, 0, 1, 9, 10,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label6), 0, 0.5);
minx_adj = gtk_adjustment_new (0, -1e+13, 1e+13, 1, 10, 10);
minx = gtk_spin_button_new (GTK_ADJUSTMENT (minx_adj), 1, 4);
gtk_widget_ref (minx);
gtk_object_set_data_full (GTK_OBJECT (app), "minx", minx,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (minx);
gtk_table_attach (GTK_TABLE (table1), minx, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (minx), TRUE);
type = gtk_combo_new ();
gtk_widget_ref (type);
gtk_object_set_data_full (GTK_OBJECT (app), "type", type,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (type);
gtk_table_attach (GTK_TABLE (table1), type, 1, 2, 9, 10,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_combo_set_value_in_list (GTK_COMBO (type), TRUE, FALSE);
gtk_combo_set_use_arrows_always (GTK_COMBO (type), TRUE);
type_items = g_list_append (type_items, _("u_char"));
type_items = g_list_append (type_items, _("char"));
type_items = g_list_append (type_items, _("u_short"));
type_items = g_list_append (type_items, _("short"));
type_items = g_list_append (type_items, _("u_long"));
type_items = g_list_append (type_items, _("long"));
type_items = g_list_append (type_items, _("float"));
type_items = g_list_append (type_items, _("double"));
type_items = g_list_append (type_items, _("fixed (4+12)"));
gtk_combo_set_popdown_strings (GTK_COMBO (type), type_items);
g_list_free (type_items);
typeentry = GTK_COMBO (type)->entry;
gtk_widget_ref (typeentry);
gtk_object_set_data_full (GTK_OBJECT (app), "typeentry", typeentry,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (typeentry);
gtk_entry_set_editable (GTK_ENTRY (typeentry), FALSE);
gtk_entry_set_text (GTK_ENTRY (typeentry), _("u_char"));
maxx_adj = gtk_adjustment_new (1, -1e+13, 1e+13, 1, 10, 10);
maxx = gtk_spin_button_new (GTK_ADJUSTMENT (maxx_adj), 1, 4);
gtk_widget_ref (maxx);
gtk_object_set_data_full (GTK_OBJECT (app), "maxx", maxx,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (maxx);
gtk_table_attach (GTK_TABLE (table1), maxx, 1, 2, 2, 3,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (maxx), TRUE);
miny_adj = gtk_adjustment_new (0, -1e+13, 1e+13, 1, 10, 10);
miny = gtk_spin_button_new (GTK_ADJUSTMENT (miny_adj), 1, 4);
gtk_widget_ref (miny);
gtk_object_set_data_full (GTK_OBJECT (app), "miny", miny,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (miny);
gtk_table_attach (GTK_TABLE (table1), miny, 1, 2, 3, 4,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (miny), TRUE);
maxy_adj = gtk_adjustment_new (1, -1e+13, 1e+13, 1, 10, 10);
maxy = gtk_spin_button_new (GTK_ADJUSTMENT (maxy_adj), 1, 4);
gtk_widget_ref (maxy);
gtk_object_set_data_full (GTK_OBJECT (app), "maxy", maxy,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (maxy);
gtk_table_attach (GTK_TABLE (table1), maxy, 1, 2, 4, 5,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (maxy), TRUE);
count_adj = gtk_adjustment_new (1, 1, 1e+22, 1, 10, 10);
count = gtk_spin_button_new (GTK_ADJUSTMENT (count_adj), 1, 0);
gtk_widget_ref (count);
gtk_object_set_data_full (GTK_OBJECT (app), "count", count,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (count);
gtk_table_attach (GTK_TABLE (table1), count, 1, 2, 8, 9,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
label10 = gtk_label_new (_("Curve Interval:"));
gtk_widget_ref (label10);
gtk_object_set_data_full (GTK_OBJECT (app), "label10", label10,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label10);
gtk_table_attach (GTK_TABLE (table1), label10, 0, 2, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label10), 7.45058e-09, 0.5);
label11 = gtk_label_new (_("Datatype:"));
gtk_widget_ref (label11);
gtk_object_set_data_full (GTK_OBJECT (app), "label11", label11,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label11);
gtk_table_attach (GTK_TABLE (table1), label11, 0, 2, 5, 6,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label11), 7.45058e-09, 0.5);
label12 = gtk_label_new (_("Scale"));
gtk_widget_ref (label12);
gtk_object_set_data_full (GTK_OBJECT (app), "label12", label12,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label12);
gtk_table_attach (GTK_TABLE (table1), label12, 0, 1, 6, 7,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label12), 0, 0.5);
scale_adj = gtk_adjustment_new (1, 1, 1e+22, 1, 10, 10);
scale = gtk_spin_button_new (GTK_ADJUSTMENT (scale_adj), 1, 0);
gtk_widget_ref (scale);
gtk_object_set_data_full (GTK_OBJECT (app), "scale", scale,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (scale);
gtk_table_attach (GTK_TABLE (table1), scale, 1, 2, 6, 7,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
base_adj = gtk_adjustment_new (0, 0, 1e+22, 1, 10, 10);
base = gtk_spin_button_new (GTK_ADJUSTMENT (base_adj), 1, 0);
gtk_widget_ref (base);
gtk_object_set_data_full (GTK_OBJECT (app), "base", base,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (base);
gtk_table_attach (GTK_TABLE (table1), base, 1, 2, 7, 8,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
label13 = gtk_label_new (_("Base"));
gtk_widget_ref (label13);
gtk_object_set_data_full (GTK_OBJECT (app), "label13", label13,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label13);
gtk_table_attach (GTK_TABLE (table1), label13, 0, 1, 7, 8,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label13), 0, 0.5);
scrolledwindow1 = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_ref (scrolledwindow1);
gtk_object_set_data_full (GTK_OBJECT (app), "scrolledwindow1", scrolledwindow1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (scrolledwindow1);
gtk_box_pack_start (GTK_BOX (vbox2), scrolledwindow1, TRUE, TRUE, 0);
gtk_widget_set_sensitive (scrolledwindow1, FALSE);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow1), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
clist = gtk_clist_new (2);
gtk_widget_ref (clist);
gtk_object_set_data_full (GTK_OBJECT (app), "clist", clist,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (clist);
gtk_container_add (GTK_CONTAINER (scrolledwindow1), clist);
gtk_clist_set_column_width (GTK_CLIST (clist), 0, 28);
gtk_clist_set_column_width (GTK_CLIST (clist), 1, 80);
gtk_clist_column_titles_show (GTK_CLIST (clist));
label8 = gtk_label_new (_("Type"));
gtk_widget_ref (label8);
gtk_object_set_data_full (GTK_OBJECT (app), "label8", label8,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label8);
gtk_clist_set_column_widget (GTK_CLIST (clist), 0, label8);
label9 = gtk_label_new (_("Name"));
gtk_widget_ref (label9);
gtk_object_set_data_full (GTK_OBJECT (app), "label9", label9,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label9);
gtk_clist_set_column_widget (GTK_CLIST (clist), 1, label9);
toolbar2 = gtk_toolbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_BOTH);
gtk_widget_ref (toolbar2);
gtk_object_set_data_full (GTK_OBJECT (app), "toolbar2", toolbar2,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (toolbar2);
gtk_box_pack_start (GTK_BOX (vbox2), toolbar2, FALSE, FALSE, 0);
gtk_widget_set_sensitive (toolbar2, FALSE);
tmp_toolbar_icon = gnome_stock_pixmap_widget (app, GNOME_STOCK_PIXMAP_OPEN);
list_open = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar2),
GTK_TOOLBAR_CHILD_BUTTON,
NULL,
_("Open"),
NULL, NULL,
tmp_toolbar_icon, NULL, NULL);
gtk_widget_ref (list_open);
gtk_object_set_data_full (GTK_OBJECT (app), "list_open", list_open,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (list_open);
tmp_toolbar_icon = gnome_stock_pixmap_widget (app, GNOME_STOCK_PIXMAP_SAVE);
list_save = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar2),
GTK_TOOLBAR_CHILD_BUTTON,
NULL,
_("Save"),
NULL, NULL,
tmp_toolbar_icon, NULL, NULL);
gtk_widget_ref (list_save);
gtk_object_set_data_full (GTK_OBJECT (app), "list_save", list_save,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (list_save);
tmp_toolbar_icon = gnome_stock_pixmap_widget (app, GNOME_STOCK_PIXMAP_ADD);
list_add = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar2),
GTK_TOOLBAR_CHILD_BUTTON,
NULL,
_("Add"),
NULL, NULL,
tmp_toolbar_icon, NULL, NULL);
gtk_widget_ref (list_add);
gtk_object_set_data_full (GTK_OBJECT (app), "list_add", list_add,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (list_add);
tmp_toolbar_icon = gnome_stock_pixmap_widget (app, GNOME_STOCK_PIXMAP_REMOVE);
list_remove = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar2),
GTK_TOOLBAR_CHILD_BUTTON,
NULL,
_("Remove"),
NULL, NULL,
tmp_toolbar_icon, NULL, NULL);
gtk_widget_ref (list_remove);
gtk_object_set_data_full (GTK_OBJECT (app), "list_remove", list_remove,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (list_remove);
tmp_toolbar_icon = gnome_stock_pixmap_widget (app, GNOME_STOCK_PIXMAP_EXEC);
list_use = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar2),
GTK_TOOLBAR_CHILD_BUTTON,
NULL,
_("Use"),
NULL, NULL,
tmp_toolbar_icon, NULL, NULL);
gtk_widget_ref (list_use);
gtk_object_set_data_full (GTK_OBJECT (app), "list_use", list_use,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (list_use);
curve = gtk_curve_new ();
gtk_widget_ref (curve);
gtk_object_set_data_full (GTK_OBJECT (app), "curve", curve,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (curve);
gtk_box_pack_start (GTK_BOX (hbox1), curve, TRUE, TRUE, 0);
gtk_widget_set_usize (curve, 256, 256);
gtk_curve_set_range (GTK_CURVE (curve), 0, 1, 0, 1);
appbar1 = gnome_appbar_new (FALSE, TRUE, GNOME_PREFERENCES_NEVER);
gtk_widget_ref (appbar1);
gtk_object_set_data_full (GTK_OBJECT (app), "appbar1", appbar1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (appbar1);
gnome_app_set_statusbar (GNOME_APP (app), appbar1);
gtk_signal_connect (GTK_OBJECT (app), "delete_event",
GTK_SIGNAL_FUNC (on_app_delete_event),
NULL);
gtk_signal_connect (GTK_OBJECT (button_new), "clicked",
GTK_SIGNAL_FUNC (on_button_new_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (button_open), "clicked",
GTK_SIGNAL_FUNC (on_button_open_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (button_save), "clicked",
GTK_SIGNAL_FUNC (on_button_save_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (button_save_as), "clicked",
GTK_SIGNAL_FUNC (on_button_save_as_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (button_upload), "clicked",
GTK_SIGNAL_FUNC (on_button_upload_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (radiobutton_spline), "clicked",
GTK_SIGNAL_FUNC (on_radiobutton_spline_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (radiobutton_linear), "clicked",
GTK_SIGNAL_FUNC (on_radiobutton_linear_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (radiobutton_free), "clicked",
GTK_SIGNAL_FUNC (on_radiobutton_free_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (minx), "changed",
GTK_SIGNAL_FUNC (on_minx_changed),
NULL);
gtk_signal_connect (GTK_OBJECT (maxx), "changed",
GTK_SIGNAL_FUNC (on_maxx_changed),
NULL);
gtk_signal_connect (GTK_OBJECT (miny), "changed",
GTK_SIGNAL_FUNC (on_miny_changed),
NULL);
gtk_signal_connect (GTK_OBJECT (maxy), "changed",
GTK_SIGNAL_FUNC (on_maxy_changed),
NULL);
gtk_signal_connect (GTK_OBJECT (list_open), "clicked",
GTK_SIGNAL_FUNC (on_list_open_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (list_save), "clicked",
GTK_SIGNAL_FUNC (on_list_save_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (list_add), "clicked",
GTK_SIGNAL_FUNC (on_list_add_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (list_remove), "clicked",
GTK_SIGNAL_FUNC (on_list_remove_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (list_use), "clicked",
GTK_SIGNAL_FUNC (on_list_use_clicked),
NULL);
return app;
}
void AddSectionWindowInit( )
{
GtkWidget *vbox;
GtkWidget * ButtonOk;
GtkWidget * hbox[ 3 ];
GtkWidget * Lbl[ 3 ];
GList *LangageItems = NULL;
GList *SubRoutinesNbrItems = NULL;
int NumSub;
char * ArrayNumSub[ ] = { "SR0", "SR1", "SR2", "SR3", "SR4", "SR5", "SR6", "SR7", "SR8", "SR9" };
int Line;
LangageItems = g_list_append( LangageItems, _("Ladder") );
#ifdef SEQUENTIAL_SUPPORT
LangageItems = g_list_append( LangageItems, _("Sequential") );
#endif
SubRoutinesNbrItems = g_list_append( SubRoutinesNbrItems, _("Main") );
for ( NumSub=0; NumSub<10; NumSub++ )
{
SubRoutinesNbrItems = g_list_append( SubRoutinesNbrItems, ArrayNumSub[ NumSub ] );
}
AddSectionWindow = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title ((GtkWindow *)AddSectionWindow, _("Add a section..."));
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (AddSectionWindow), vbox);
gtk_widget_show (vbox);
for ( Line = 0; Line<3; Line++ )
{
char * text;
hbox[ Line ] = gtk_hbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (vbox), hbox[ Line ]);
gtk_widget_show (hbox[ Line ]);
switch( Line )
{
case 1 : text = _("Language"); break;
case 2 : text = _("Main/Sub-Routine"); break;
default: text = _("Name"); break;
}
Lbl[ Line ] = gtk_label_new( text );
gtk_box_pack_start (GTK_BOX (hbox[ Line ]), Lbl[ Line ], FALSE, FALSE, 0);
gtk_widget_show ( Lbl[ Line ]);
switch( Line )
{
case 0:
EditName = gtk_entry_new();
gtk_entry_set_max_length( GTK_ENTRY(EditName),LGT_SECTION_NAME-1 );
gtk_box_pack_start (GTK_BOX (hbox[Line]), EditName, TRUE, TRUE, 0);
gtk_widget_show( EditName );
break;
case 1:
CycleLanguage = gtk_combo_new();
gtk_combo_set_value_in_list(GTK_COMBO(CycleLanguage), TRUE /*val*/, FALSE /*ok_if_empty*/);
gtk_combo_set_popdown_strings(GTK_COMBO(CycleLanguage),LangageItems);
gtk_box_pack_start (GTK_BOX (hbox[Line]), CycleLanguage, TRUE, TRUE, 0);
gtk_widget_show( CycleLanguage );
break;
case 2:
CycleSubRoutineNbr = gtk_combo_new();
gtk_combo_set_value_in_list(GTK_COMBO(CycleSubRoutineNbr), TRUE /*val*/, FALSE /*ok_if_empty*/);
gtk_combo_set_popdown_strings(GTK_COMBO(CycleSubRoutineNbr),SubRoutinesNbrItems);
gtk_box_pack_start (GTK_BOX (hbox[Line]), CycleSubRoutineNbr, TRUE, TRUE, 0);
gtk_widget_show( CycleSubRoutineNbr );
break;
}
}
ButtonOk = gtk_button_new_with_label(_("Ok"));
gtk_box_pack_start (GTK_BOX (vbox), ButtonOk, TRUE, FALSE, 0);
gtk_signal_connect(GTK_OBJECT (ButtonOk), "clicked",
(GtkSignalFunc)ButtonAddSectionDoneClickSignal, 0);
gtk_widget_show (ButtonOk);
gtk_window_set_modal(GTK_WINDOW(AddSectionWindow),TRUE);
gtk_window_set_position(GTK_WINDOW(AddSectionWindow),GTK_WIN_POS_CENTER);
gtk_signal_connect( GTK_OBJECT(AddSectionWindow), "delete_event",
(GtkSignalFunc)AddSectionWindowDeleteEvent, 0 );
}
void addParams (GtkNotebook *notebook, PluginParameters *params) {
int n;
GtkWidget *table = gtk_table_new (params->nbParams, 2, FALSE);
gtk_container_set_border_width (GTK_CONTAINER (table), 11);
gtk_table_set_row_spacings (GTK_TABLE (table), 6);
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
for (n=0;n<params->nbParams;++n) {
if (params->params[n] == 0) {
GtkWidget *hseparator = gtk_hseparator_new ();
gtk_widget_show (hseparator);
gtk_table_attach (GTK_TABLE (table), hseparator, 0, 2, n, n+1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 5);
} else {
PluginParam *p = params->params[n];
if (p->type != PARAM_BOOLVAL) {
GtkWidget *label4 = gtk_label_new (p->name);
gtk_widget_show (label4);
gtk_table_attach (GTK_TABLE (table), label4, 0, 1, n, n+1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify (GTK_LABEL (label4), GTK_JUSTIFY_RIGHT);
gtk_misc_set_alignment (GTK_MISC (label4), 0, 0.5);
}
switch (p->type) {
case PARAM_INTVAL: {
GtkWidget *spinbutton_adj,*spinbutton;
spinbutton_adj = (GtkWidget*)gtk_adjustment_new (
p->param.ival.value,
p->param.ival.min, p->param.ival.max,
p->param.ival.step, p->param.ival.step*10,
p->param.ival.step*10);
spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (spinbutton_adj), 1, 0);
gtk_widget_show (spinbutton);
gtk_table_attach (GTK_TABLE (table), spinbutton, 1, 2, n, n+1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 1);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton), TRUE);
gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (spinbutton),
GTK_UPDATE_IF_VALID);
p->user_data = spinbutton;
gtk_object_set_data (GTK_OBJECT(spinbutton),"param",(void*)p);
p->change_listener = my_int_listener;
gtk_signal_connect (GTK_OBJECT (spinbutton), "changed",
GTK_SIGNAL_FUNC (on_spinbutton_int_changed),
NULL);
break;
}
case PARAM_FLOATVAL: {
GtkWidget *progress,*prog_adj;
prog_adj = (GtkWidget*)gtk_adjustment_new (
p->param.fval.value,
p->param.fval.min, p->param.fval.max,
p->param.fval.step, p->param.fval.step*10,
p->param.fval.step*10);
progress = gtk_progress_bar_new_with_adjustment(GTK_ADJUSTMENT(prog_adj));
gtk_widget_show(progress);
gtk_table_attach (GTK_TABLE (table), progress, 1, 2, n, n+1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 1);
p->user_data = progress;
p->change_listener = my_float_listener;
break;
}
case PARAM_LISTVAL: {
int i;
GList *combo_winsize_items = NULL;
GtkWidget *combo_entry_winsize = NULL;
GtkWidget *combo_winsize = gtk_combo_new ();
gtk_widget_show (combo_winsize);
gtk_table_attach (GTK_TABLE (table), combo_winsize, 1, 2, n, n+1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_combo_set_value_in_list (GTK_COMBO (combo_winsize), TRUE, TRUE);
for (i=0;i<p->param.slist.nbChoices;++i)
combo_winsize_items = g_list_append (combo_winsize_items,
p->param.slist.choices[i]);
gtk_combo_set_popdown_strings (GTK_COMBO (combo_winsize), combo_winsize_items);
g_list_free (combo_winsize_items);
combo_entry_winsize = GTK_COMBO (combo_winsize)->entry;
gtk_widget_show (combo_entry_winsize);
gtk_entry_set_editable (GTK_ENTRY (combo_entry_winsize), FALSE);
gtk_entry_set_text (GTK_ENTRY (combo_entry_winsize), LVAL(*p));
p->change_listener = my_list_listener;
p->user_data = combo_entry_winsize;
gtk_object_set_data (GTK_OBJECT(combo_entry_winsize),"param",(void*)p);
gtk_signal_connect (GTK_OBJECT (combo_entry_winsize), "changed",
GTK_SIGNAL_FUNC (on_list_changed),
NULL);
break;
}
case PARAM_BOOLVAL: {
GtkWidget *checkbutton_double =
gtk_check_button_new_with_label (p->name);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton_double),BVAL(*p));
gtk_widget_show (checkbutton_double);
gtk_table_attach (GTK_TABLE (table), checkbutton_double, 1, 2, n, n+1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_signal_connect (GTK_OBJECT (checkbutton_double), "toggled",
GTK_SIGNAL_FUNC (on_bool_toggled),
NULL);
gtk_object_set_data (GTK_OBJECT(checkbutton_double),"param",(void*)p);
p->user_data = checkbutton_double;
p->change_listener = my_bool_listener;
break;
}
}
}
}
gtk_widget_show_all(GTK_WIDGET(table));
gtk_container_add(GTK_CONTAINER(notebook),table);
gtk_notebook_set_tab_label_text(notebook,GTK_WIDGET(table),params->name);
}
/*****************************************************************************
** create dialog
**/
int
create_vcrCompDialog( void )
{
int i;
GtkWidget *button;
GtkWidget *label;
GtkWidget *attribFrame, *attribVbox;
GtkWidget *hbox;
g_VcrCompDialog.videoAttribGList = 0;
g_VcrCompDialog.videoCodecGList = 0;
for (i = 0; i < VCRComp_numVideoCodecs(); i++)
g_VcrCompDialog.videoCodecGList = g_list_append( g_VcrCompDialog.videoCodecGList,
(gchar*)VCRComp_videoCodecName( i ) );
g_VcrCompDialog.audioAttribGList = 0;
g_VcrCompDialog.audioCodecGList = 0;
for (i = 0; i < VCRComp_numAudioCodecs(); i++)
g_VcrCompDialog.audioCodecGList = g_list_append( g_VcrCompDialog.audioCodecGList,
(gchar*)VCRComp_audioCodecName( i ) );
// create window
g_VcrCompDialog.dialog = gtk_dialog_new();
gtk_container_set_border_width( GTK_CONTAINER(g_VcrCompDialog.dialog), 10 );
gtk_window_set_title( GTK_WINDOW(g_VcrCompDialog.dialog), tr("Configure VCR") );
gtk_signal_connect( GTK_OBJECT(g_VcrCompDialog.dialog), "show",
GTK_SIGNAL_FUNC(callback_dialogShow), (gpointer)NULL );
gtk_signal_connect(GTK_OBJECT(g_VcrCompDialog.dialog), "delete_event",
GTK_SIGNAL_FUNC(delete_question_event), (gpointer)NULL );
// create ok/cancel button
button = gtk_button_new_with_label( tr("Ok") );
gtk_box_pack_start( GTK_BOX(GTK_DIALOG(g_VcrCompDialog.dialog)->action_area), button, TRUE, TRUE, 0 );
gtk_signal_connect( GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(callback_okClicked), (gpointer)NULL );
button = gtk_button_new_with_label( tr("Cancel") );
gtk_box_pack_start( GTK_BOX(GTK_DIALOG(g_VcrCompDialog.dialog)->action_area), button, TRUE, TRUE, 0 );
gtk_signal_connect( GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(callback_cancelClicked), (gpointer)NULL );
// create notebook
g_VcrCompDialog.notebook = gtk_notebook_new();
gtk_notebook_set_tab_pos( GTK_NOTEBOOK(g_VcrCompDialog.notebook), GTK_POS_TOP );
gtk_box_pack_start( GTK_BOX(GTK_DIALOG(g_VcrCompDialog.dialog)->vbox), g_VcrCompDialog.notebook, TRUE, TRUE, 0 );
// create video page
label = gtk_label_new( tr("Video") );
g_VcrCompDialog.videoPage = gtk_vbox_new( FALSE, 5 );
gtk_container_set_border_width( GTK_CONTAINER(g_VcrCompDialog.videoPage), 10 );
gtk_notebook_append_page( GTK_NOTEBOOK(g_VcrCompDialog.notebook), g_VcrCompDialog.videoPage, label );
label = gtk_label_new( tr("Select codec:") );
gtk_box_pack_start( GTK_BOX(g_VcrCompDialog.videoPage), label, FALSE, FALSE, 0 );
g_VcrCompDialog.videoCodecCombo = gtk_combo_new();
if (g_VcrCompDialog.videoCodecGList)
gtk_combo_set_popdown_strings( GTK_COMBO(g_VcrCompDialog.videoCodecCombo), g_VcrCompDialog.videoCodecGList );
else
gtk_widget_set_sensitive( g_VcrCompDialog.videoCodecCombo, FALSE );
gtk_combo_set_value_in_list( GTK_COMBO(g_VcrCompDialog.videoCodecCombo), TRUE, FALSE );
gtk_box_pack_start( GTK_BOX(g_VcrCompDialog.videoPage), g_VcrCompDialog.videoCodecCombo, FALSE, FALSE, 0 );
attribFrame = gtk_frame_new( tr("Codec attributes:") );
gtk_box_pack_start( GTK_BOX(g_VcrCompDialog.videoPage), attribFrame, FALSE, FALSE, 0 );
attribVbox = gtk_vbox_new( FALSE, 5 );
gtk_container_add( GTK_CONTAINER(attribFrame), attribVbox );
g_VcrCompDialog.videoAttribCombo = gtk_combo_new();
gtk_combo_set_value_in_list( GTK_COMBO(g_VcrCompDialog.videoAttribCombo), TRUE, FALSE );
gtk_box_pack_start( GTK_BOX(attribVbox), g_VcrCompDialog.videoAttribCombo, FALSE, FALSE, 0 );
hbox = gtk_hbox_new( FALSE, 5 );
label = gtk_label_new( tr("Current value:") );
gtk_box_pack_start( GTK_BOX(hbox), label, FALSE, FALSE, 0 );
g_VcrCompDialog.videoAttribEntry = gtk_entry_new();
gtk_entry_set_editable( GTK_ENTRY(g_VcrCompDialog.videoAttribEntry), FALSE );
gtk_box_pack_start( GTK_BOX(hbox), g_VcrCompDialog.videoAttribEntry, FALSE, FALSE, 0 );
gtk_box_pack_start( GTK_BOX(attribVbox), hbox, FALSE, FALSE, 0 );
g_VcrCompDialog.videoAttribChangeButton = gtk_button_new_with_label( tr("Change") );
gtk_box_pack_start( GTK_BOX(attribVbox), g_VcrCompDialog.videoAttribChangeButton, TRUE, TRUE, 0 );
gtk_signal_connect( GTK_OBJECT(GTK_COMBO(g_VcrCompDialog.videoCodecCombo)->entry), "changed",
GTK_SIGNAL_FUNC(callback_videoCodecChanged), (gpointer)NULL );
gtk_signal_connect( GTK_OBJECT(GTK_COMBO(g_VcrCompDialog.videoAttribCombo)->entry), "changed",
GTK_SIGNAL_FUNC(callback_videoAttribChanged), (gpointer)NULL );
gtk_signal_connect( GTK_OBJECT(g_VcrCompDialog.videoAttribChangeButton), "clicked",
GTK_SIGNAL_FUNC(callback_videoAttribChangeClicked), (gpointer)NULL );
callback_videoCodecChanged( NULL, NULL );
// create audio page
label = gtk_label_new( tr("Audio") );
g_VcrCompDialog.audioPage = gtk_vbox_new( FALSE, 5 );
gtk_container_set_border_width( GTK_CONTAINER(g_VcrCompDialog.audioPage), 10 );
gtk_notebook_append_page( GTK_NOTEBOOK(g_VcrCompDialog.notebook), g_VcrCompDialog.audioPage, label );
label = gtk_label_new( tr("Select codec:") );
gtk_box_pack_start( GTK_BOX(g_VcrCompDialog.audioPage), label, FALSE, FALSE, 0 );
g_VcrCompDialog.audioCodecCombo = gtk_combo_new();
if (g_VcrCompDialog.audioCodecGList)
gtk_combo_set_popdown_strings( GTK_COMBO(g_VcrCompDialog.audioCodecCombo), g_VcrCompDialog.audioCodecGList );
else
gtk_widget_set_sensitive( g_VcrCompDialog.audioCodecCombo, FALSE );
gtk_combo_set_value_in_list( GTK_COMBO(g_VcrCompDialog.audioCodecCombo), TRUE, FALSE );
gtk_box_pack_start( GTK_BOX(g_VcrCompDialog.audioPage), g_VcrCompDialog.audioCodecCombo, FALSE, FALSE, 0 );
attribFrame = gtk_frame_new( tr("Codec attributes:") );
gtk_box_pack_start( GTK_BOX(g_VcrCompDialog.audioPage), attribFrame, FALSE, FALSE, 0 );
attribVbox = gtk_vbox_new( FALSE, 5 );
gtk_container_add( GTK_CONTAINER(attribFrame), attribVbox );
g_VcrCompDialog.audioAttribCombo = gtk_combo_new();
gtk_combo_set_value_in_list( GTK_COMBO(g_VcrCompDialog.audioAttribCombo), TRUE, FALSE );
gtk_box_pack_start( GTK_BOX(attribVbox), g_VcrCompDialog.audioAttribCombo, FALSE, FALSE, 0 );
hbox = gtk_hbox_new( FALSE, 5 );
label = gtk_label_new( tr("Current value:") );
gtk_box_pack_start( GTK_BOX(hbox), label, FALSE, FALSE, 0 );
g_VcrCompDialog.audioAttribEntry = gtk_entry_new();
gtk_entry_set_editable( GTK_ENTRY(g_VcrCompDialog.audioAttribEntry), FALSE );
gtk_box_pack_start( GTK_BOX(hbox), g_VcrCompDialog.audioAttribEntry, FALSE, FALSE, 0 );
gtk_box_pack_start( GTK_BOX(attribVbox), hbox, FALSE, FALSE, 0 );
g_VcrCompDialog.audioAttribChangeButton = gtk_button_new_with_label( tr("Change") );
gtk_box_pack_start( GTK_BOX(attribVbox), g_VcrCompDialog.audioAttribChangeButton, TRUE, TRUE, 0 );
gtk_signal_connect( GTK_OBJECT(GTK_COMBO(g_VcrCompDialog.audioCodecCombo)->entry), "changed",
GTK_SIGNAL_FUNC(callback_audioCodecChanged), (gpointer)NULL );
gtk_signal_connect( GTK_OBJECT(GTK_COMBO(g_VcrCompDialog.audioAttribCombo)->entry), "changed",
GTK_SIGNAL_FUNC(callback_audioAttribChanged), (gpointer)NULL );
gtk_signal_connect( GTK_OBJECT(g_VcrCompDialog.audioAttribChangeButton), "clicked",
GTK_SIGNAL_FUNC(callback_audioAttribChangeClicked), (gpointer)NULL );
callback_audioCodecChanged( NULL, NULL );
// create dialogs
create_changeDialogs();
return 0;
}
void PropertiesInitGtk()
{
GtkWidget *vbox;
GtkWidget *hbox[NBR_PARAMS_PER_OBJ + 1];
int NumParam;
GList *BaseItems = NULL;
GList *TimersModesItems = NULL;
int ScanBase = 0;
int ScanTimerMode = 0;
do
{
BaseItems = g_list_append(BaseItems,CorresDatasForBase[ScanBase++].ParamSelect);
}
while(ScanBase<NBR_TIMEBASES);
do
{
TimersModesItems = g_list_append(TimersModesItems,TimersModesStrings[ScanTimerMode++]);
}
while(ScanTimerMode<NBR_TIMERSMODES);
PropertiesWindow = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title ((GtkWindow *)PropertiesWindow, "Properties");
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (PropertiesWindow), vbox);
gtk_widget_show (vbox);
for (NumParam = 0 ; NumParam<NBR_PARAMS_PER_OBJ ; NumParam++)
{
hbox[NumParam] = gtk_hbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (vbox), hbox[NumParam]);
gtk_widget_show (hbox[NumParam]);
PropLabelParam[NumParam] = gtk_label_new("Parameter");
gtk_widget_set_usize((GtkWidget *)PropLabelParam[NumParam],85,0);
gtk_box_pack_start (GTK_BOX (hbox[NumParam]), PropLabelParam[NumParam], FALSE, FALSE, 0);
gtk_widget_show (PropLabelParam[NumParam]);
/* For numbers */
PropEntryParam[NumParam] = gtk_entry_new();
// gtk_widget_set_usize((GtkWidget *)PropEntryParam[NumParam],85,0);
gtk_box_pack_start (GTK_BOX (hbox[NumParam]), PropEntryParam[NumParam], TRUE, TRUE, 0);
gtk_widget_show (PropEntryParam[NumParam]);
gtk_signal_connect(GTK_OBJECT (PropEntryParam[NumParam]), "activate",
(GtkSignalFunc) SaveElementProperties, NULL);
/* For time base */
PropEntryBaseParam[NumParam] = gtk_combo_new();
gtk_combo_set_value_in_list(GTK_COMBO(PropEntryBaseParam[NumParam]), TRUE /*val*/, FALSE /*ok_if_empty*/);
gtk_combo_set_popdown_strings(GTK_COMBO(PropEntryBaseParam[NumParam]),BaseItems);
// gtk_widget_set_usize((GtkWidget *)PropEntryBaseParam[NumParam],85,0);
gtk_box_pack_start (GTK_BOX (hbox[NumParam]), PropEntryBaseParam[NumParam], FALSE, FALSE, 0);
/* For timer mode */
PropEntryTimerModeParam[NumParam] = gtk_combo_new();
gtk_combo_set_value_in_list(GTK_COMBO(PropEntryTimerModeParam[NumParam]), TRUE /*val*/, FALSE /*ok_if_empty*/);
gtk_combo_set_popdown_strings(GTK_COMBO(PropEntryTimerModeParam[NumParam]),TimersModesItems);
// gtk_widget_set_usize((GtkWidget *)PropEntryTimerModeParam[NumParam],85,0);
gtk_box_pack_start (GTK_BOX (hbox[NumParam]), PropEntryTimerModeParam[NumParam], FALSE, FALSE, 0);
}
/* for apply button... */
hbox[NumParam] = gtk_hbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (vbox), hbox[NumParam]);
gtk_widget_show (hbox[NumParam]);
ButtonApplyProperties = gtk_button_new_with_label("Apply");
gtk_box_pack_start (GTK_BOX (hbox[NumParam]), ButtonApplyProperties, TRUE, FALSE, 0);
gtk_signal_connect(GTK_OBJECT (ButtonApplyProperties), "clicked",
(GtkSignalFunc) SaveElementProperties, 0);
// gtk_widget_show (PropertiesWindow);
gtk_signal_connect( GTK_OBJECT(PropertiesWindow), "delete_event",
(GtkSignalFunc)PropertiesWindowDeleteEvent, 0 );
}
