static UI_CALLBACK(save_callback)
{
String name;
ui_popdown(cartridge_dialog);
XtVaGetValues(file_name_field, XtNstring, &name, NULL);
if (cartridge_save_image (name) < 0)
ui_error(_("Cannot write cartridge image file\n`%s'\n"), name);
}
/* Report a message to the user, allow different buttons. */
ui_jam_action_t ui_jam_dialog(const char *format, ...)
{
char str[1024];
va_list ap;
static GtkWidget *jam_dialog, *message;
gint res;
if (console_mode) {
va_start(ap, format);
vfprintf(stderr, format, ap);
va_end(ap);
exit(0);
}
vsync_suspend_speed_eval();
jam_dialog = gtk_dialog_new_with_buttons("", NULL, GTK_DIALOG_DESTROY_WITH_PARENT, _("Reset"), 0, _("Hard Reset"), 1, _("Monitor"), 2, _("Continue"), 3, NULL);
g_signal_connect(G_OBJECT(jam_dialog), "destroy", G_CALLBACK(gtk_widget_destroyed), &jam_dialog);
va_start(ap, format);
vsprintf(str, format, ap);
va_end(ap);
message = gtk_label_new(str);
gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(jam_dialog))), message, TRUE, TRUE, 0);
gtk_widget_show(message);
gtk_dialog_set_default_response(GTK_DIALOG(jam_dialog), 0);
ui_popup(jam_dialog, "VICE", FALSE);
res = gtk_dialog_run(GTK_DIALOG(jam_dialog));
ui_popdown(jam_dialog);
if (jam_dialog) {
gtk_widget_destroy(jam_dialog);
}
ui_dispatch_events();
switch (res) {
case 3:
return UI_JAM_NONE;
case 2:
ui_restore_mouse();
#ifdef HAVE_FULLSCREEN
fullscreen_suspend(0);
#endif
return UI_JAM_MONITOR;
case 1:
return UI_JAM_HARD_RESET;
case 0:
default:
return UI_JAM_RESET;
}
return 0;
}
void ui_netplay_dialog(void)
{
if (netplay_dialog) {
gdk_window_show(gtk_widget_get_window(netplay_dialog));
gdk_window_raise(gtk_widget_get_window(netplay_dialog));
gtk_widget_show(netplay_dialog);
netplay_update_status();
} else {
np_log = log_open("Netplay");
netplay_dialog = build_netplay_dialog();
g_signal_connect(G_OBJECT(netplay_dialog), "destroy", G_CALLBACK(gtk_widget_destroyed), &netplay_dialog);
}
ui_popup(netplay_dialog, "Netplay Dialog", FALSE);
(void) gtk_dialog_run(GTK_DIALOG(netplay_dialog));
ui_popdown(netplay_dialog);
}
ui_button_t ui_ask_yesno(const char *title, const char *text)
{
static GtkWidget *yesno_dialog = NULL, *yesno_dialog_message = NULL;
gint res;
vsync_suspend_speed_eval();
if (!yesno_dialog) {
yesno_dialog = build_yesno_dialog(&yesno_dialog_message);
g_signal_connect(G_OBJECT(yesno_dialog), "destroy", G_CALLBACK(gtk_widget_destroyed), &yesno_dialog);
}
gtk_label_set_text(GTK_LABEL(yesno_dialog_message),text);
ui_popup(yesno_dialog, title, FALSE);
res = gtk_dialog_run(GTK_DIALOG(yesno_dialog));
ui_popdown(yesno_dialog);
return (res == GTK_RESPONSE_YES) ? UI_BUTTON_YES : UI_BUTTON_NO;
}
/* Ask for a confirmation. */
ui_button_t ui_ask_confirmation(const char *title, const char *text)
{
static GtkWidget *confirm_dialog, *confirm_dialog_message;
gint res;
vsync_suspend_speed_eval();
if (!confirm_dialog) {
confirm_dialog = build_confirm_dialog(&confirm_dialog_message);
g_signal_connect(G_OBJECT(confirm_dialog), "destroy", G_CALLBACK(gtk_widget_destroyed), &confirm_dialog);
}
gtk_label_set_text(GTK_LABEL(confirm_dialog_message),text);
ui_popup(confirm_dialog, title, FALSE);
res = gtk_dialog_run(GTK_DIALOG(confirm_dialog));
ui_popdown(confirm_dialog);
return (res == GTK_RESPONSE_YES) ? UI_BUTTON_YES : (res == GTK_RESPONSE_NO) ? UI_BUTTON_NO : UI_BUTTON_CANCEL;
}
ui_button_t ui_change_dir(const char *title, const char *prompt, char *buf, unsigned int buflen)
{
GtkWidget *fc;
gint res;
gchar *fname = NULL;
ui_button_t r;
fc = gtk_file_chooser_dialog_new(title, GTK_WINDOW(get_active_toplevel()), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL);
ui_popup(fc, title, FALSE);
res = gtk_dialog_run(GTK_DIALOG(fc));
ui_popdown(fc);
if ((res == GTK_RESPONSE_ACCEPT) && (fname = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(fc)))) {
strncpy(buf, fname, buflen);
r = UI_BUTTON_OK;
} else {
r = UI_BUTTON_CANCEL;
}
g_free(fname);
return r;
}
/* Ask for a string. The user can confirm or cancel. */
ui_button_t ui_input_string(const char *title, const char *prompt, char *buf, unsigned int buflen)
{
GtkWidget *input_dialog, *entry, *label;
gint res;
ui_button_t ret;
vsync_suspend_speed_eval();
input_dialog = gtk_dialog_new_with_buttons(title, NULL, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL);
g_signal_connect(G_OBJECT(input_dialog), "destroy", G_CALLBACK(gtk_widget_destroyed), &input_dialog);
entry = gtk_entry_new();
label = gtk_label_new(prompt);
gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(input_dialog))), label, FALSE, FALSE, 0);
gtk_widget_show(label);
gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(input_dialog))), entry, FALSE, FALSE, 0);
gtk_entry_set_text(GTK_ENTRY(GTK_ENTRY(entry)), buf);
gtk_widget_show(entry);
gtk_dialog_set_default_response(GTK_DIALOG(input_dialog), GTK_RESPONSE_ACCEPT);
ui_popup(input_dialog, title, FALSE);
res = gtk_dialog_run(GTK_DIALOG(input_dialog));
ui_popdown(input_dialog);
if ((res == GTK_RESPONSE_ACCEPT) && input_dialog) {
strncpy(buf, gtk_entry_get_text(GTK_ENTRY(entry)), buflen);
ret = UI_BUTTON_OK;
} else {
ret = UI_BUTTON_CANCEL;
}
if (input_dialog) {
gtk_widget_destroy(input_dialog);
}
return ret;
}
void ui_cartridge_save_dialog(int type)
{
gint res;
char *name;
if (cartridge_dialog) {
gdk_window_show(gtk_widget_get_window(cartridge_dialog));
gdk_window_raise(gtk_widget_get_window(cartridge_dialog));
gtk_widget_show(cartridge_dialog);
} else {
uilib_file_filter_enum_t filter = UILIB_FILTER_ALL;
cartridge_dialog = vice_file_entry(_("Save cartridge image"), NULL, NULL, &filter, 1, UI_FC_SAVE);
g_signal_connect(G_OBJECT(cartridge_dialog), "destroy", G_CALLBACK(gtk_widget_destroyed), &cartridge_dialog);
}
ui_popup(cartridge_dialog, _("Save cartridge image"), FALSE);
res = gtk_dialog_run(GTK_DIALOG(cartridge_dialog));
ui_popdown(cartridge_dialog);
if (res != GTK_RESPONSE_ACCEPT) {
return;
}
name = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(cartridge_dialog));
if (!name) {
ui_error(_("Invalid filename"));
return;
}
if (cartridge_save_image (type, name) < 0) {
ui_error(_("Cannot write cartridge image file\n`%s'\n"), name);
} else {
ui_message(_("Successfully wrote `%s'"), name);
}
lib_free(name);
}
int ui_empty_disk_dialog(char *name)
{
gint res;
char *format_text;
char *fname;
const char *dname, *id;
int i, type = 0, ret = 0;
if (edisk_dialog)
{
gdk_window_show(edisk_dialog->window);
gdk_window_raise(edisk_dialog->window);
gtk_widget_show(edisk_dialog);
}
else
{
edisk_dialog = build_empty_disk_dialog();
g_signal_connect(G_OBJECT(edisk_dialog),
"destroy",
G_CALLBACK(gtk_widget_destroyed),
&edisk_dialog);
}
ui_popup(edisk_dialog, _("Create empty Diskimage"), FALSE);
res = gtk_dialog_run(GTK_DIALOG(edisk_dialog));
ui_popdown(edisk_dialog);
if (res != GTK_RESPONSE_ACCEPT)
return -1;
/* filename */
fname = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(fileentry));
if (!fname)
return -1;
strcpy(name, fname);
lib_free(fname);
/* format label */
dname = gtk_entry_get_text(GTK_ENTRY(diskname));
if (!dname)
dname = "";
/* disk ID */
id = gtk_entry_get_text(GTK_ENTRY(diskid));
if (!id)
id = "00";
/* type radio button */
for (i = 0; type_radio[i].label; i++)
if (GTK_TOGGLE_BUTTON(type_radio[i].w)->active)
{
type = type_radio[i].type;
break;
}
format_text = util_concat(dname, ",", id, NULL);
if (vdrive_internal_create_format_disk_image(name, format_text, type)
< 0) {
ui_error(_("Can't create image `%s'."));
ret = -1;
}
lib_free(format_text);
return ret;
}
int ui_screenshot_dialog(char *name, struct video_canvas_s *wid)
{
int res, i;
char *fn, *tmp;
const char *driver, *ext;
if (screenshot_dialog) {
gdk_window_show(screenshot_dialog->window);
gdk_window_raise(screenshot_dialog->window);
gtk_widget_show(screenshot_dialog);
} else {
screenshot_dialog = build_screenshot_dialog();
if (screenshot_dialog)
g_signal_connect(G_OBJECT(screenshot_dialog),
"destroy",
G_CALLBACK(gtk_widget_destroyed),
&screenshot_dialog);
else
return -1;
}
ui_popup(screenshot_dialog, _("Save Screenshot"), FALSE);
res = gtk_dialog_run(GTK_DIALOG(screenshot_dialog));
ui_popdown(screenshot_dialog);
if (res != GTK_RESPONSE_ACCEPT)
return -1;
fn = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(fileentry));
if (!fn) {
ui_error(_("Invalid filename"));
return -1;
}
i = gtk_combo_box_get_active(GTK_COMBO_BOX(drv_menu));
if (i < 0)
return -1;
driver = buttons[i].driver;
ext = buttons[i].ext;
#ifdef HAVE_FFMPEG
if (strcmp(driver, "FFMPEG") == 0)
{
int audio_bitrate, video_bitrate;
audio_bitrate = (int)
gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(ffmpg_audio));
resources_set_int("FFMPEGAudioBitrate", audio_bitrate);
video_bitrate = (int)
gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(ffmpg_video));
resources_set_int("FFMPEGVideoBitrate", video_bitrate);
resources_set_string("FFMPEGFormat", selected_driver);
resources_set_int("FFMPEGAudioCodec", selected_ac);
resources_set_int("FFMPEGVideoCodec", selected_vc);
log_message(LOG_DEFAULT, "FFMPEG: Driver: %s, ac: %d, vc: %d\n",
selected_driver, selected_ac, selected_vc);
}
#endif
tmp = lib_stralloc(fn);
lib_free(fn);
if (!util_get_extension(tmp))
util_add_extension(&tmp, ext);
if (screenshot_save(driver, tmp, wid) < 0) {
ui_error(_("Couldn't write screenshot to `%s' with driver `%s'."),
tmp, driver);
lib_free(tmp);
return -1;
} else {
if (screenshot_is_recording())
gtk_widget_show(video_ctrl_checkbox);
ui_message(_("Successfully wrote `%s'"), tmp);
lib_free(tmp);
}
return 0;
}
static UI_CALLBACK(cancel_callback)
{
ui_popdown(cartridge_dialog);
}
static UI_CALLBACK(save_callback)
{
int dtypes[] = {
DISK_IMAGE_TYPE_D64,
DISK_IMAGE_TYPE_D67,
DISK_IMAGE_TYPE_D71,
DISK_IMAGE_TYPE_D81,
DISK_IMAGE_TYPE_D80,
DISK_IMAGE_TYPE_D82,
DISK_IMAGE_TYPE_G64,
DISK_IMAGE_TYPE_X64,
};
char *filename;
String name;
String iname;
int type_cnt;
Boolean disk_type_flag;
ui_popdown(emptydisk_dialog);
type_cnt = 0;
XtVaGetValues(disk_type_d64_button, XtNstate, &disk_type_flag, NULL);
if (disk_type_flag == False) {
type_cnt ++;
XtVaGetValues(disk_type_d67_button, XtNstate, &disk_type_flag, NULL);
if (disk_type_flag == False) {
type_cnt ++;
XtVaGetValues(disk_type_d71_button, XtNstate, &disk_type_flag, NULL);
if (disk_type_flag == False) {
type_cnt ++;
XtVaGetValues(disk_type_d81_button, XtNstate, &disk_type_flag, NULL);
if (disk_type_flag == False) {
type_cnt ++;
XtVaGetValues(disk_type_d80_button, XtNstate, &disk_type_flag, NULL);
if (disk_type_flag == False) {
type_cnt ++;
XtVaGetValues(disk_type_d82_button, XtNstate, &disk_type_flag, NULL);
if (disk_type_flag == False) {
type_cnt ++;
XtVaGetValues(disk_type_g64_button, XtNstate, &disk_type_flag, NULL);
if (disk_type_flag == False) {
type_cnt ++;
XtVaGetValues(disk_type_x64_button, XtNstate, &disk_type_flag, NULL);
if (disk_type_flag == False) {
type_cnt ++;
}
}
}
}
}
}
}
}
if (type_cnt < 0 || type_cnt >= NR_FORMATS) {
return;
}
XtVaGetValues(file_name_field, XtNstring, &name, NULL);
XtVaGetValues(image_name_field, XtNstring, &iname, NULL);
filename = lib_stralloc(name);
util_add_extension(&filename, extensions[type_cnt]);
if (vdrive_internal_create_format_disk_image(filename, iname, dtypes[type_cnt]) < 0) {
ui_error(_("Couldn't create disk image"));
} else {
strcpy(edisk_file_name, filename);
}
lib_free(filename);
}
static UI_CALLBACK(cancel_callback)
{
ui_popdown(emptydisk_dialog);
}
