static void
playlist_op(GtkWidget *widget, guint data)
{
int i;
const gchar *filename[2];
gchar action, *rowdata, fname[BUFSIZ], *tmp;
FILE *plfp;
gtk_widget_hide(plfilesel);
if(!data)
return;
action = GPOINTER_TO_INT(gtk_object_get_user_data(GTK_OBJECT(plfilesel)));
filename[0] = gtk_file_selection_get_filename(GTK_FILE_SELECTION(plfilesel));
if(action == 'l') {
if((plfp = fopen(filename[0], "r")) == NULL) {
g_error("Can't open %s for reading.", filename[0]);
return;
}
while(fgets(fname, BUFSIZ, plfp) != NULL) {
gchar *filename[2];
if(fname[strlen(fname) - 1] == '\n')
fname[strlen(fname) - 1] = '\0';
filename[0] = fname;
filename[1] = NULL;
gtk_clist_append(GTK_CLIST(clist), filename);
}
fclose(plfp);
gtk_clist_columns_autosize(GTK_CLIST(clist));
}
else if(action == 's') {
if((plfp = fopen(filename[0], "w")) == NULL) {
g_error("Can't open %s for writing.", filename[0]);
return;
}
for(i = 0; i < GTK_CLIST(clist)->rows; i++) {
gtk_clist_get_text(GTK_CLIST(clist), i, 0, &rowdata);
/* Make sure we have an absolute path. */
if(*rowdata != '/') {
tmp = g_get_current_dir();
rowdata = g_strconcat(tmp, "/", rowdata, NULL);
fprintf(plfp, "%s\n", rowdata);
g_free(rowdata);
g_free(tmp);
}
else {
fprintf(plfp, "%s\n", rowdata);
}
}
fclose(plfp);
}
else {
g_error("Invalid playlist action!.");
}
} /* playlist_op */
void FileSelec(GtkButton* button)
{
GtkWidget *selec;
selec = gtk_file_selection_new("File Selection");
// gtk_signal_connect(selec,"destroy",G_CALLBACK(gtk_main_quit), NULL);
gtk_signal_connect(GTK_OBJECT(GTK_FILE_SELECTION(selec)->ok_button),"clicked", G_CALLBACK(file_ok_sel), selec);
gtk_widget_show(selec);
}
void fileselbox(char *title, char **filesel_path, GtkSignalFunc func)
{
fileselbox_text=filesel_path;
filesel_ok=0;
cleanup=func;
fs=gtk_file_selection_new(title);
gtk_signal_connect(GTK_OBJECT(fs), "destroy", (GtkSignalFunc) destroy_callback, NULL);
gtk_signal_connect(GTK_OBJECT(GTK_FILE_SELECTION(fs)->ok_button),
"clicked", (GtkSignalFunc) enter_callback, GTK_OBJECT(fs));
gtk_signal_connect_object(GTK_OBJECT(GTK_FILE_SELECTION(fs)->cancel_button),
"clicked", (GtkSignalFunc) cancel_callback, GTK_OBJECT(fs));
gtk_file_selection_hide_fileop_buttons(GTK_FILE_SELECTION(fs));
if(*fileselbox_text) gtk_file_selection_set_filename(GTK_FILE_SELECTION(fs), *fileselbox_text);
gtk_grab_add(fs);
gtk_widget_show(fs);
}
void on_save_as1_activate(GtkMenuItem * menuitem, gpointer user_data)
{
GtkWidget *fs;
fs = gtk_file_selection_new(_("Save file as..."));
g_signal_connect(GTK_OBJECT(GTK_FILE_SELECTION(fs)->ok_button),
"clicked",
G_CALLBACK(store_filename), (gpointer) fs);
g_signal_connect_swapped(GTK_OBJECT
(GTK_FILE_SELECTION(fs)->ok_button),
"clicked", G_CALLBACK(gtk_widget_destroy),
(gpointer) fs);
g_signal_connect_swapped(GTK_OBJECT
(GTK_FILE_SELECTION(fs)->cancel_button),
"clicked", G_CALLBACK(gtk_widget_destroy),
(gpointer) fs);
gtk_widget_show(fs);
}
void
on_fileselect_ok (GtkButton *button,
gpointer user_data)
{
GtkWidget *filesel, *window3D, *save_procedure;
gint what;
gchar *filename;
v5d_info *info;
int hires;
filesel = gtk_widget_get_toplevel (GTK_WIDGET (button));
filename = gtk_file_selection_get_filename (GTK_FILE_SELECTION (filesel));
what = GPOINTER_TO_INT(gtk_object_get_data(GTK_OBJECT(filesel), "OpenWhat"));
window3D = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(filesel), "window3D"));
if(window3D==NULL) {
fprintf(stderr,"Could not find window3D widget\n");
exit ;
}
info = (v5d_info *) lookup_widget(window3D,"v5d_info");
switch(what) {
case DATA_FILE:
load_data_file(window3D,filename);
break;
case TOPO_FILE:
hires = vis5d_graphics_mode(info->v5d_display_context,VIS5D_HIRESTOPO,VIS5D_GET);
vis5d_init_topo(info->v5d_display_context,filename,hires);
vis5d_load_topo_and_map(info->v5d_display_context);
break;
case MAP_FILE:
vis5d_init_map(info->v5d_display_context,filename);
vis5d_load_topo_and_map(info->v5d_display_context);
break;
case PROCEDURE_FILE:
if(info->ProcedureDialog)
gtk_widget_destroy(info->ProcedureDialog);
info->ProcedureDialog = new_ProcedureDialog(info, filename);
gtk_window_set_transient_for(GTK_WINDOW(info->ProcedureDialog),GTK_WINDOW(window3D));
break;
case SAVE_PROCEDURE_FILE:
if(! info->ProcedureDialog) {
printf("Error: ProcedureDialog not defined\n");
return;
}
save_procedure = lookup_widget(info->ProcedureDialog, "saveProcedure");
on_saveProcedure_activate(GTK_MENU_ITEM(save_procedure), filename);
break;
default:
g_print("open what ? %d\n",what);
}
gtk_widget_hide (filesel);
/* This is the only window that should accept input */
gtk_grab_remove(filesel);
}
static void
cb_startup_dir_browse_ok (GtkWidget * widget, gpointer data)
{
gtk_entry_set_text (GTK_ENTRY (prefs_win.startup_dir_entry),
gtk_file_selection_get_filename (GTK_FILE_SELECTION
(data)));
gtk_widget_destroy (data);
}
PRIVATE void choose_clicked(GtkWidget *choose_button, Generator *g) {
GtkWidget *fs = gtk_file_selection_new("Open Sample File");
Data *data = g->data;
gtk_object_set_data(GTK_OBJECT(fs), "Generator", g);
gtk_object_set_data(GTK_OBJECT(fs), "FilenameLabel",
gtk_object_get_data(GTK_OBJECT(choose_button), "FilenameLabel"));
if (data->filename)
gtk_file_selection_set_filename(GTK_FILE_SELECTION(fs), data->filename);
gtk_signal_connect(GTK_OBJECT(GTK_FILE_SELECTION(fs)->ok_button), "clicked",
GTK_SIGNAL_FUNC(load_new_sample), fs);
gtk_signal_connect_object(GTK_OBJECT(GTK_FILE_SELECTION(fs)->cancel_button), "clicked",
GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT(fs));
gtk_window_set_modal(GTK_WINDOW(fs), TRUE);
gtk_widget_show(fs);
}
gint DeviceBoxBrowseEvent(GtkWidget *widget, GdkEvent event, gpointer data)
{
DeviceBoxUnfocus();
// Transfer file name to file selection
gtk_file_selection_set_filename(GTK_FILE_SELECTION(selectionbox.window),
gtk_entry_get_text(GTK_ENTRY(devicebox.file)));
selectionbox.wherefrom = 2; // From the Device Window
SelectionBoxRefocus();
return (TRUE);
} // END DeviceBoxBrowseEvent()
void save_file_dlg(NKEdit *doc)
{
file_dlg = gtk_file_selection_new(_("Numakiti: Save as..."));
gtk_window_set_modal(GTK_WINDOW(file_dlg), TRUE);
GTK_WINDOW(file_dlg)->type = GTK_WINDOW_DIALOG;
gtk_signal_connect_object(GTK_OBJECT(file_dlg), "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroy),
GTK_OBJECT(file_dlg));
gtk_signal_connect(GTK_OBJECT(GTK_FILE_SELECTION(file_dlg)->ok_button),
"clicked", GTK_SIGNAL_FUNC(save_dlg_ok),
doc);
gtk_signal_connect_object(GTK_OBJECT(
GTK_FILE_SELECTION(file_dlg)->cancel_button),
"clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
GTK_OBJECT(file_dlg));
gtk_widget_show(file_dlg);
return;
}
void executable_filename (GtkWidget *widget, gpointer user_data) {
const gchar *selected_filename;
selected_filename = gtk_file_selection_get_filename (
GTK_FILE_SELECTION (file_selector));
ap_prefs_set_string ((struct widget *) user_data, "command",
selected_filename);
gtk_entry_set_text (GTK_ENTRY (file_entry), selected_filename);
}
static void
dnj_koj_frame_mantra_scene_set (GtkWidget *button, struct drqmj_koji_mantra *info) {
char buf[BUFFERLEN];
// fix compiler warning
(void)button;
strncpy(buf,gtk_file_selection_get_filename(GTK_FILE_SELECTION(info->fsscene)),BUFFERLEN-1);
gtk_entry_set_text (GTK_ENTRY(info->escene),buf);
}
void saveDialog(GtkWidget * widget, gpointer image) {
GtkWidget * fileSelection = gtk_file_selection_new("Save an image");
_saveData * data = (_saveData *)malloc(sizeof(_saveData));
data->fs = fileSelection;
data->image = (GtkImage *)image;
/* Connect the ok_button to file_ok_sel function */
g_signal_connect (G_OBJECT (GTK_FILE_SELECTION (fileSelection)->ok_button),
"clicked", G_CALLBACK (saveFileSignal), data);
/* Connect the cancel_button to destroy the widget */
g_signal_connect_swapped (G_OBJECT (GTK_FILE_SELECTION (fileSelection)->cancel_button),
"clicked", G_CALLBACK (gtk_widget_destroy),
G_OBJECT (fileSelection));
gtk_widget_show(fileSelection);
}
static int
file_selected(GtkWidget * nul,
GtkWidget * filew)
{
char * fname = (char*)gtk_file_selection_get_filename(GTK_FILE_SELECTION(filew));
gtk_widget_hide(filew);
comm_plugin_upload(fname);
return 0;
}
gint open(GtkWidget *widget, gpointer data) {
if (!really(widget,data))
return TRUE;
GtkFileSelection *fsel = GTK_FILE_SELECTION(gtk_file_selection_new("Open"));
gtk_signal_connect(GTK_OBJECT(fsel->ok_button), "clicked", GTK_SIGNAL_FUNC(openok), fsel);
gtk_signal_connect_object(GTK_OBJECT(fsel->cancel_button), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT(fsel));
gtk_window_set_transient_for(GTK_WINDOW(fsel), GTK_WINDOW(mainwin->getWidget()));
gtk_widget_show(GTK_WIDGET(fsel));
return TRUE;
}
void
nsSetupTypeDlg::SelectFolder(GtkWidget *aWidget, gpointer aData)
{
DUMP("SelectFolder");
GtkWidget *fileSel = NULL;
char *selDir = gCtx->opt->mDestination;
fileSel = gtk_file_selection_new(gCtx->Res("SELECT_DIR"));
gtk_window_set_modal(GTK_WINDOW(fileSel), TRUE);
gtk_file_selection_set_filename(GTK_FILE_SELECTION(fileSel), selDir);
gtk_signal_connect(GTK_OBJECT(GTK_FILE_SELECTION(fileSel)->ok_button),
"clicked", (GtkSignalFunc) SelectFolderOK, fileSel);
gtk_signal_connect_object(GTK_OBJECT(
GTK_FILE_SELECTION(fileSel)->cancel_button),
"clicked", (GtkSignalFunc) SelectFolderCancel,
GTK_OBJECT(fileSel));
gtk_widget_show(fileSel);
}
static void load(GtkWidget *widget, gpointer data)
{
if (!file_selection_launched)
{
GtkWidget *load_dialog;
load_dialog = gtk_file_selection_new("Choose a N64 rom file : ");
gtk_signal_connect(GTK_OBJECT(load_dialog), "destroy",
GTK_SIGNAL_FUNC(destroy_load), NULL);
gtk_signal_connect(GTK_OBJECT(GTK_FILE_SELECTION(load_dialog)->ok_button),
"clicked", GTK_SIGNAL_FUNC(launch_rom), load_dialog);
gtk_signal_connect(GTK_OBJECT(GTK_FILE_SELECTION(load_dialog)->cancel_button),
"clicked", GTK_SIGNAL_FUNC(cancel_load), load_dialog);
gtk_file_selection_set_filename(GTK_FILE_SELECTION(load_dialog),
".");
gtk_widget_show(load_dialog);
file_selection_launched = 1;
}
}
/** ok callback for file_dialog that sets the selected filename in the
* textentry that was passed as user data to file_dialog()
*/
static void file_dialog_ok_set_textentry (GtkWidget *widget, gpointer textentry) {
const char *filename = NULL;
GtkWidget* filesel = topmost_parent(widget);
filename = gtk_file_selection_get_filename (GTK_FILE_SELECTION (filesel));
if (!filename)
return;
gtk_entry_set_text (GTK_ENTRY (textentry), filename);
}
void file_selected( GtkWidget* w, GtkFileSelection* fs )
{
rom_file romfile;
int system_type;
strncpy( rom_name, gtk_file_selection_get_filename( GTK_FILE_SELECTION( fs ) ), 127 );
gtk_widget_destroy( GTK_WIDGET( fs ) );
romfile = read_romimage(rom_name);
system_type = guess_system(romfile);
activate_system( system_type, romfile);
}
static void
fdsn_choosen(GtkWidget *widget, TFDRIVERCHOOSER *choose_t)
{
if (choose_t)
{
gtk_entry_set_text (GTK_ENTRY (choose_t->dsn_entry),
gtk_file_selection_get_filename (GTK_FILE_SELECTION (choose_t->
browse_sel)));
choose_t->browse_sel = NULL;
}
}
void filedump_set_entry(GtkWidget *w, GtkWidget *entry)
{
const gchar *pd;
pd = gtk_file_selection_get_filename(
GTK_FILE_SELECTION(gtk_widget_get_toplevel(w)));
gtk_entry_set_text(GTK_ENTRY(entry),
g_filename_to_utf8(pd, -1, NULL, NULL, NULL));
gtk_widget_destroy(gtk_widget_get_toplevel(w));
}
static void on_load_from_image (GtkWidget *widget, Explorer* self) {
GtkWidget *dialog, *image;
GError *error = NULL;
gchar *filename = NULL;
#if (GTK_CHECK_VERSION(2, 4, 0))
dialog = gtk_file_chooser_dialog_new ("Open Image Parameters",
GTK_WINDOW (glade_xml_get_widget (self->xml, "explorer_window")),
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
image = gtk_image_new ();
gtk_file_chooser_set_preview_widget (GTK_FILE_CHOOSER (dialog), image);
g_signal_connect (G_OBJECT (dialog), "update-preview", G_CALLBACK (update_image_preview), image);
if (file_location)
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), file_location);
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_OK) {
filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
histogram_imager_load_image_file (HISTOGRAM_IMAGER (self->map), filename, &error);
if (file_location)
g_free (file_location);
file_location = gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (dialog));
}
#else
dialog = gtk_file_selection_new ("Open Image Parameters");
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_OK) {
filename = gtk_file_selection_get_filename (GTK_FILE_SELECTION (dialog));
histogram_imager_load_image_file (HISTOGRAM_IMAGER (self->map), filename, &error);
}
#endif
gtk_widget_destroy (dialog);
if (error) {
GtkWidget *dialog, *label;
gchar *text;
dialog = glade_xml_get_widget (self->xml, "error dialog");
label = glade_xml_get_widget (self->xml, "error label");
text = g_strdup_printf ("<span weight=\"bold\" size=\"larger\">Could not load \"%s\"</span>\n\n%s", filename, error->message);
gtk_label_set_markup (GTK_LABEL (label), text);
g_free (text);
g_error_free (error);
gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_hide (dialog);
}
g_free (filename);
}
void saveFileSignal(GtkWidget * widget, gpointer data) {
// Get extension to determine image type
std::string filepath(gtk_file_selection_get_filename (GTK_FILE_SELECTION (((_saveData *)data)->fs)));
gdk_pixbuf_save(gtk_image_get_pixbuf(
((_saveData *)data)->image),
filepath.c_str(),
filepath.substr(filepath.rfind('.')+1).c_str(),
NULL, "quality", "100", NULL);
gtk_widget_destroy(GTK_WIDGET(((_saveData *)data)->fs));
}
void readFromStock(int c ){
USEWEBCAM = 0;
resetERIExpression();
CHANGESOURCE = true;
NEWFILE = true;
if(c == 0){
use_webcam(1);}
if(c == 1){
use_webcam(0);
filew = gtk_file_selection_new ("File selection");
g_signal_connect (GTK_FILE_SELECTION (filew)->ok_button,
"clicked", G_CALLBACK (file_ok_sel), (gpointer) filew);
g_signal_connect_swapped (GTK_FILE_SELECTION (filew)->cancel_button,
"clicked", G_CALLBACK (gtk_widget_destroy),filew);
/* Lets set the filename, as if this were a save dialog, and we are giving
a default filename */
gtk_file_selection_set_filename (GTK_FILE_SELECTION(filew), "../videos/" );
gtk_widget_show (filew);}
if(c == 2){
use_webcam(0);
inputfile = "../videos/dreamy3.avi";}
if(c == 3){
use_webcam(0);
inputfile = "../videos/comfortable0.avi";}
if(c == 4){
use_webcam(0);
inputfile = "../videos/shocked2.avi";}
if(c == 5){
use_webcam(0);
inputfile = "../videos/heartbroken2.avi";}
cout << "Loading Video File..... " << endl;
g_print ("%s\n", inputfile);
}
void select_file (gchar *title, GtkSignalFunc func)
{
GtkWidget *ok_button;
GtkWidget *cancel_button;
if (fileselection==NULL)
{
fileselection = gtk_file_selection_new (title);
}
ok_button = GTK_FILE_SELECTION (fileselection)->ok_button;
cancel_button = GTK_FILE_SELECTION (fileselection)->cancel_button;
gtk_signal_connect (GTK_OBJECT (ok_button), "clicked",
GTK_SIGNAL_FUNC (func), NULL);
gtk_signal_connect (GTK_OBJECT (cancel_button), "clicked",
GTK_SIGNAL_FUNC (close_dialog), fileselection);
gtk_widget_show (fileselection);
}
static void
dnj_koj_frame_xsi_script_search (GtkWidget *button, struct drqmj_koji_xsi *info) {
GtkWidget *dialog;
// fix compiler warning
(void)button;
dialog = gtk_file_selection_new ("Please select a script directory");
info->fsscript = dialog;
gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION(dialog)->ok_button),
"clicked", GTK_SIGNAL_FUNC (dnj_koj_frame_xsi_script_set), info);
gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION(dialog)->ok_button),
"clicked", GTK_SIGNAL_FUNC (gtk_widget_destroy),
(gpointer) dialog);
gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION(dialog)->cancel_button),
"clicked", GTK_SIGNAL_FUNC (gtk_widget_destroy),
(gpointer) dialog);
gtk_widget_show (dialog);
gtk_window_set_modal (GTK_WINDOW(dialog),TRUE);
}
void file_load_cb(GtkWidget *w,
GtkFileSelection *fs )
{
char command[PATH_MAX+32];
sprintf(command,"ui.tree_load('%s')",
gtk_file_selection_get_filename (GTK_FILE_SELECTION (fs)));
gtk_widget_destroy(GTK_WIDGET(fs));
RUN_LUA_COMMAND(command);
}
void save_dlg_ok(GtkWidget *widget, NKEdit *doc)
{
gchar filename[PATH_MAX];
g_snprintf(filename, sizeof(filename), "%s",
gtk_file_selection_get_filename(GTK_FILE_SELECTION(file_dlg)));
if(filename) {
nk_save_file(doc, filename);
}
return;
}
static void ExportSpeedDial(void)
{
static GtkWidget *fileDialog = NULL;
if (speedDialInitialized) {
if (fileDialog == NULL) {
fileDialog = gtk_file_selection_new(_("Export to file"));
gtk_signal_connect(GTK_OBJECT(fileDialog), "delete_event",
GTK_SIGNAL_FUNC(DeleteEvent), NULL);
gtk_signal_connect(GTK_OBJECT(GTK_FILE_SELECTION(fileDialog)->ok_button),
"clicked", GTK_SIGNAL_FUNC(OkExportDialog),
(gpointer) fileDialog);
gtk_signal_connect(GTK_OBJECT
(GTK_FILE_SELECTION(fileDialog)->cancel_button),
"clicked", GTK_SIGNAL_FUNC(CancelDialog),
(gpointer) fileDialog);
}
gtk_widget_show(fileDialog);
}
}
void zoom_bookmark_load_requestor()
{
GtkWidget *file_selector;
file_selector = gtk_file_selection_new("Select a bookmark file to load");
gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION(file_selector)->ok_button),
"clicked", GTK_SIGNAL_FUNC (zoom_bookmark_load_doit),
(gpointer) file_selector);
/* Ensure that the dialog box is destroyed when the user clicks a button. */
gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION(file_selector)->ok_button),
"clicked", GTK_SIGNAL_FUNC (gtk_widget_destroy),
(gpointer) file_selector);
gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION(file_selector)->cancel_button),
"clicked", GTK_SIGNAL_FUNC (gtk_widget_destroy),
(gpointer) file_selector);
/* Display that dialog */
gtk_widget_show (file_selector);
}
static void edit_vcard_file_select( void ) {
gchar *sFile;
if (! vcard_file_selector.fileSelector )
edit_vcard_file_select_create( & vcard_file_selector );
sFile = gtk_editable_get_chars( GTK_EDITABLE(vcardedit.file_entry), 0, -1 );
gtk_file_selection_set_filename( GTK_FILE_SELECTION( vcard_file_selector.fileSelector ), sFile );
g_free( sFile );
gtk_widget_show( vcard_file_selector.fileSelector );
gtk_grab_add( vcard_file_selector.fileSelector );
}
