static UI_MENU_CALLBACK(save_movie_callback)
{
char *name = NULL;
int width;
int height;
if (activated) {
if (!ffmpeg_drv) {
ui_error("FFMPEG not available.");
return NULL;
}
name = sdl_ui_file_selection_dialog("Choose movie file", FILEREQ_MODE_SAVE_FILE);
if (name != NULL) {
width = sdl_active_canvas->draw_buffer->draw_buffer_width;
height = sdl_active_canvas->draw_buffer->draw_buffer_height;
memcpy(sdl_active_canvas->draw_buffer->draw_buffer, sdl_ui_get_draw_buffer(), width * height);
util_add_extension(&name, ffmpeg_drv->default_extension);
if (screenshot_save("FFMPEG", name, sdl_active_canvas) < 0) {
ui_error("Cannot save movie.");
}
lib_free(name);
return sdl_menu_text_exit_ui;
}
}
return NULL;
}
int palette_load(const char *file_name, palette_t *palette_return)
{
palette_t *tmp_palette;
char *complete_path;
FILE *f;
int rc;
f = sysfile_open(file_name, &complete_path, MODE_READ_TEXT);
if (f == NULL) {
/* Try to add the extension. */
char *tmp = lib_stralloc(file_name);
util_add_extension(&tmp, "vpl");
f = sysfile_open(tmp, &complete_path, MODE_READ_TEXT);
lib_free(tmp);
if (f == NULL)
return -1;
}
log_message(palette_log, "Loading palette `%s'.", complete_path);
lib_free(complete_path);
tmp_palette = palette_create(palette_return->num_entries, NULL);
rc = palette_load_core(f, file_name, tmp_palette, palette_return);
fclose(f);
palette_free(tmp_palette);
return rc;
}
static UI_MENU_CALLBACK(start_recording_callback)
{
char *parameter = (char *)param;
if (activated) {
resources_set_string("SoundRecordDeviceName", "");
if (parameter != NULL) {
char *name = NULL;
name = sdl_ui_file_selection_dialog("Choose audio file to record to", FILEREQ_MODE_CHOOSE_FILE);
if (name != NULL) {
util_add_extension(&name, parameter);
resources_set_string("SoundRecordDeviceArg", name);
resources_set_string("SoundRecordDeviceName", parameter);
lib_free(name);
}
}
} else {
if (parameter != NULL) {
const char *w;
resources_get_string("SoundRecordDeviceName", &w);
if (!strcmp(w, parameter)) {
return sdl_menu_text_tick;
}
}
}
return NULL;
}
static UI_MENU_CALLBACK(save_screenshot_callback)
{
char title[20];
char *name = NULL;
int width;
int height;
gfxoutputdrv_t *selected_driver = NULL;
if (activated) {
sprintf(title, "Choose %s file", (char *)param);
name = sdl_ui_file_selection_dialog(title, FILEREQ_MODE_SAVE_FILE);
if (name != NULL) {
width = sdl_active_canvas->draw_buffer->draw_buffer_width;
height = sdl_active_canvas->draw_buffer->draw_buffer_height;
memcpy(sdl_active_canvas->draw_buffer->draw_buffer, sdl_ui_get_draw_buffer(), width * height);
selected_driver = gfxoutput_get_driver((char *)param);
util_add_extension(&name, selected_driver->default_extension);
if (screenshot_save((char *)param, name, sdl_active_canvas) < 0) {
ui_error("Cannot save screenshot.");
}
lib_free(name);
}
}
return NULL;
}
static void dump_mapping(HWND hwnd)
{
TCHAR *st_name;
if ((st_name = uilib_select_file(hwnd, translate_text(IDS_SAVE_KEYMAP_FILE), UILIB_FILTER_KEYMAP, UILIB_SELECTOR_TYPE_FILE_SAVE, UILIB_SELECTOR_STYLE_DEFAULT)) != NULL) {
char *name;
name = system_wcstombs_alloc(st_name);
util_add_extension(&name, "vkm");
if (keyboard_keymap_dump(name) != 0) {
ui_error(translate_text(IDS_CANNOT_WRITE_KEYMAP_FILE));
}
system_wcstombs_free(name);
lib_free(st_name);
}
}
static void sound_record_start(char *format, char *extension)
{
ui_button_t button;
char *s;
vsync_suspend_speed_eval();
resources_set_string("SoundRecordDeviceName", "");
s = ui_select_file(_("Record sound to file"), NULL, 0, 0, NULL,
extension, &button, 0, NULL);
if (button == UI_BUTTON_OK && s != NULL)
{
util_add_extension(&s, format);
resources_set_string("SoundRecordDeviceArg", s);
resources_set_string("SoundRecordDeviceName", format);
resources_set_int("Sound", 1);
lib_free(s);
ui_display_statustext(_("Sound Recording started..."),10);
}
}
static void sound_record_start(char *format, uilib_file_filter_enum_t extension)
{
ui_button_t button;
char *s;
char *retval;
vsync_suspend_speed_eval();
resources_set_string("SoundRecordDeviceName", "");
s = ui_select_file(_("Record sound to file"), NULL, 0, soundrecordpath, &extension, 1, &button, 0, NULL, UI_FC_SAVE);
if (button == UI_BUTTON_OK && s != NULL) {
lib_free(soundrecordpath);
util_fname_split(s, &soundrecordpath, NULL);
util_add_extension(&s, format);
resources_set_string("SoundRecordDeviceArg", s);
resources_set_string("SoundRecordDeviceName", format);
resources_set_int("Sound", 1);
lib_free(s);
retval = util_concat(_("Sound Recording started"), "...", NULL);
ui_display_statustext(retval, 10);
lib_free(retval);
}
}
static char *screenshot_filename(char *screenshot_save_msg, char *screenshot_save_file_msg, char *screenshot_filter, char *screenshot_extension)
{
char new_file_name[PATH_MAX];
if (file_name == NULL) {
memset(new_file_name, 0, PATH_MAX);
} else {
strcpy(new_file_name, file_name);
}
while (tui_input_string(screenshot_save_msg, "Enter file name:", new_file_name, PATH_MAX) != -1) {
util_remove_spaces(new_file_name);
if (*new_file_name == 0) {
char *tmp;
tmp = screenshot_selector(screenshot_save_file_msg, screenshot_filter);
if (tmp != NULL) {
strcpy(new_file_name, tmp);
lib_free(tmp);
}
} else {
char *extension;
char *last_dot;
last_dot = strrchr(new_file_name, '.');
if (last_dot == NULL) {
extension = screenshot_extension;
} else {
char *last_slash, *last_backslash, *last_path_separator;
last_slash = strrchr(new_file_name, '/');
last_backslash = strrchr(new_file_name, '\\');
if (last_slash == NULL) {
last_path_separator = last_backslash;
} else if (last_backslash == NULL) {
last_path_separator = last_slash;
} else if (last_backslash < last_slash) {
last_path_separator = last_slash;
} else {
last_path_separator = last_backslash;
}
if (last_path_separator == NULL || last_path_separator < last_dot) {
extension = "";
} else {
extension = screenshot_extension;
}
}
if (file_name == NULL) {
file_name = util_concat(new_file_name, ".", extension, NULL);
} else {
lib_free(file_name);
file_name = lib_stralloc(new_file_name);
util_add_extension(&file_name, extension);
}
break;
}
}
return file_name;
}
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(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);
}
