Exemple #1
0
static int open(GtkWidget* parent_window, gboolean not_import)
{
    GtkWidget* dialog;
    int val;
    const char* title;
    char* filter = file_ops_join_ext("*", dish_file_extension());
    global_settings* settings = settings_get();

    if (not_import)
        title = "Open bank";
    else
        title = "Import bank";

    dialog = gtk_file_chooser_dialog_new( title,
                                          GTK_WINDOW(parent_window),
                                          GTK_FILE_CHOOSER_ACTION_OPEN,
                                          GTK_STOCK_CANCEL,
                                          GTK_RESPONSE_CANCEL,
                                          GTK_STOCK_OPEN,
                                          GTK_RESPONSE_ACCEPT, NULL);

    if (dish_file_has_state())
    {
        const char* tmp = 0;
        tmp = dish_file_state_is_full() ? dish_file_state_parent_dir()
                                        : dish_file_state_bank_dir();
        gtk_file_chooser_select_filename(GTK_FILE_CHOOSER(dialog), tmp);
    }
    else
        gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog),
                                           settings->last_bank_dir);

    file_chooser_add_filter(dialog, "Petri-Foo files", filter);
    file_chooser_add_filter(dialog, "All files", "*");

    if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
    {

        char* name = (char*) gtk_file_chooser_get_filename(
                                        GTK_FILE_CHOOSER(dialog));

        val = (not_import)  ? dish_file_read(name)
                            : dish_file_import(name);
        if (val < 0)
        {
            GtkWidget* msg = gtk_message_dialog_new(GTK_WINDOW(dialog),
                                    GTK_DIALOG_MODAL,
                                    GTK_MESSAGE_ERROR,
                                    GTK_BUTTONS_CLOSE,
                                    "Failed to read bank %s\n.", name);

            g_signal_connect_swapped(G_OBJECT(msg), "response",
                                    G_CALLBACK(gtk_widget_destroy), msg);
            gtk_widget_show (msg);
        }
        else
        {
            if (recent_manager && not_import)
                gtk_recent_manager_add_item(recent_manager,
                                    g_filename_to_uri(name, NULL, NULL));

            if (settings->last_bank_dir)
                free(settings->last_bank_dir);

            settings->last_bank_dir = g_path_get_dirname(name);
        }
    }
    else
    {
        val = -1;
    }

    gtk_widget_destroy(dialog);

    free(filter);

    return val;
}
Exemple #2
0
/* Caller must g_free() the returned filename.*/
gchar *
ghid_dialog_file_select_open (gchar * title, gchar ** path, gchar * shortcuts)
{
  GtkWidget *dialog;
  gchar *result = NULL, *folder, *seed;
  GHidPort *out = &ghid_port;
  GtkFileFilter *no_filter;

  dialog = gtk_file_chooser_dialog_new (title,
					GTK_WINDOW (out->top_window),
					GTK_FILE_CHOOSER_ACTION_OPEN,
					GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
					GTK_STOCK_OK, GTK_RESPONSE_OK,
					NULL);

  gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);

  /* add a default filter for not filtering files */
  no_filter = gtk_file_filter_new ();
  gtk_file_filter_set_name (no_filter, "all");
  gtk_file_filter_add_pattern (no_filter, "*.*");
  gtk_file_filter_add_pattern (no_filter, "*");
  gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), no_filter);

  /* in case we have a dialog for loading a footprint file */
  if (strcmp (title, _("Load element to buffer")) == 0)
  {
    /* add a filter for footprint files */
    GtkFileFilter *fp_filter;
    fp_filter = gtk_file_filter_new ();
    gtk_file_filter_set_name (fp_filter, "fp");
    gtk_file_filter_add_mime_type (fp_filter, "application/x-pcb-footprint");
    gtk_file_filter_add_pattern (fp_filter, "*.fp");
    gtk_file_filter_add_pattern (fp_filter, "*.FP");
    gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), fp_filter);
  }

  /* in case we have a dialog for loading a layout file */
  if ((strcmp (title, _("Load layout file")) == 0)
    || (strcmp (title, _("Load layout file to buffer")) == 0))
  {
    /* add a filter for layout files */
    GtkFileFilter *pcb_filter;
    pcb_filter = gtk_file_filter_new ();
    gtk_file_filter_set_name (pcb_filter, "pcb");
    gtk_file_filter_add_mime_type (pcb_filter, "application/x-pcb-layout");
    gtk_file_filter_add_pattern (pcb_filter, "*.pcb");
    gtk_file_filter_add_pattern (pcb_filter, "*.PCB");
    gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), pcb_filter);
  }

  /* in case we have a dialog for loading a netlist file */
  if (strcmp (title, _("Load netlist file")) == 0)
  {
    /* add a filter for netlist files */
    GtkFileFilter *net_filter;
    net_filter = gtk_file_filter_new ();
    gtk_file_filter_set_name (net_filter, "netlist");
    gtk_file_filter_add_mime_type (net_filter, "application/x-pcb-netlist");
    gtk_file_filter_add_pattern (net_filter, "*.net");
    gtk_file_filter_add_pattern (net_filter, "*.NET");
    gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), net_filter);
  }

  if (path && *path)
    gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), *path);
  else
  {
	gchar *default_path;
	default_path = g_get_current_dir();
	gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), default_path);
	g_free(default_path);
  }

  if (shortcuts && *shortcuts)
    {
      folder = g_strdup (shortcuts);
      seed = folder;
      while ((folder = strtok (seed, ":")) != NULL)
	{
	  gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (dialog),
						folder, NULL);
	  seed = NULL;
	}
      g_free (folder);
    }

  if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_OK)
    {
      result = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
      folder =
	gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (dialog));
      if (folder && path)
	{
	  dup_string (path, folder);
	  g_free (folder);
	}
    }
  gtk_widget_destroy (dialog);


  return result;
}
Exemple #3
0
/* Caller must g_free() the returned filename. */
gchar *
ghid_dialog_file_select_save (gchar * title, gchar ** path, gchar * file,
			      gchar * shortcuts)
{
  GtkWidget *dialog;
  gchar *result = NULL, *folder, *seed;
  GHidPort *out = &ghid_port;

  dialog = gtk_file_chooser_dialog_new (title,
					GTK_WINDOW (out->top_window),
					GTK_FILE_CHOOSER_ACTION_SAVE,
					GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
					GTK_STOCK_OK, GTK_RESPONSE_OK,
					NULL);

  gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog),
                                                  TRUE);
  gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);

  if (path && *path && **path)
    gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), *path);
  else
  {
	gchar *default_path;
	default_path = g_get_current_dir();
	gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), default_path);
	g_free(default_path);
  }

  if (file && *file)
    {
      gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog),
                                         g_path_get_basename(file));
      gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog),
                                           g_path_get_dirname (file));
    }

  if (shortcuts && *shortcuts)
    {
      folder = g_strdup (shortcuts);
      seed = folder;
      while ((folder = strtok (seed, ":")) != NULL)
	{
	  gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (dialog),
						folder, NULL);
	  seed = NULL;
	}
      g_free (folder);
    }
  if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_OK)
    {
      result = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
      folder =
	gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (dialog));
      if (folder && path)
	{
	  dup_string (path, folder);
	  g_free (folder);
	}
    }
  gtk_widget_destroy (dialog);


  return result;
}
Exemple #4
0
bool wxGtkFileCtrl::Create( wxWindow *parent,
                            wxWindowID id,
                            const wxString& defaultDirectory,
                            const wxString& defaultFileName,
                            const wxString& wildCard,
                            long style,
                            const wxPoint& pos,
                            const wxSize& size,
                            const wxString& name )
{
    if ( !PreCreation( parent, pos, size ) ||
            !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ) )
    {
        wxFAIL_MSG( wxT( "wxGtkFileCtrl creation failed" ) );
        return false;
    }

    GtkFileChooserAction gtkAction = GTK_FILE_CHOOSER_ACTION_OPEN;

    if ( style & wxFC_SAVE )
        gtkAction = GTK_FILE_CHOOSER_ACTION_SAVE;

    m_widget =  gtk_alignment_new ( 0, 0, 1, 1 );
    g_object_ref(m_widget);
    m_fcWidget = GTK_FILE_CHOOSER( gtk_file_chooser_widget_new(gtkAction) );
    gtk_widget_show ( GTK_WIDGET( m_fcWidget ) );
    gtk_container_add ( GTK_CONTAINER ( m_widget ), GTK_WIDGET( m_fcWidget ) );

    m_focusWidget = GTK_WIDGET( m_fcWidget );

    g_signal_connect ( m_fcWidget, "file-activated",
                       G_CALLBACK ( gtkfilechooserwidget_file_activated_callback ),
                       this );

    g_signal_connect ( m_fcWidget, "current-folder-changed",
                       G_CALLBACK ( gtkfilechooserwidget_folder_changed_callback ),
                       this );

    g_signal_connect ( m_fcWidget, "selection-changed",
                       G_CALLBACK ( gtkfilechooserwidget_selection_changed_callback ),
                       this );

    m_fc.SetWidget( m_fcWidget );

    if ( style & wxFC_MULTIPLE )
        gtk_file_chooser_set_select_multiple( m_fcWidget, true );

    SetWildcard( wildCard );

    // if defaultDir is specified it should contain the directory and
    // defaultFileName should contain the default name of the file, however if
    // directory is not given, defaultFileName contains both
    wxFileName fn;
    if ( defaultDirectory.empty() )
        fn.Assign( defaultFileName );
    else if ( !defaultFileName.empty() )
        fn.Assign( defaultDirectory, defaultFileName );
    else
        fn.AssignDir( defaultDirectory );

    // set the initial file name and/or directory
    const wxString dir = fn.GetPath();
    if ( !dir.empty() )
    {
        gtk_file_chooser_set_current_folder( m_fcWidget,
                                             dir.fn_str() );
    }

    const wxString fname = fn.GetFullName();
    if ( style & wxFC_SAVE )
    {
        if ( !fname.empty() )
        {
            gtk_file_chooser_set_current_name( m_fcWidget,
                                               fname.fn_str() );
        }
    }
    else // wxFC_OPEN
    {
        if ( !fname.empty() )
        {
            gtk_file_chooser_set_filename( m_fcWidget,
                                           fn.GetFullPath().fn_str() );
        }
    }

    m_parent->DoAddChild( this );

    PostCreation( size );

    return TRUE;
}
JNIEXPORT jobject JNICALL Java_com_sun_glass_ui_gtk_GtkCommonDialogs__1showFileChooser
  (JNIEnv *env, jclass clazz, jlong parent, jstring folder, jstring name, jstring title,
   jint type, jboolean multiple, jobjectArray jFilters, jint default_filter_index) {

    jobjectArray jFileNames = NULL;
    char* filename;
    jstring jfilename;

    const char* chooser_folder;
    const char* chooser_filename;
    const char* chooser_title;
    const int chooser_type = type == 0 ? GTK_FILE_CHOOSER_ACTION_OPEN : GTK_FILE_CHOOSER_ACTION_SAVE;

    if (!jstring_to_utf_get(env, folder, &chooser_folder)) {
        return create_empty_result();
    }

    if (!jstring_to_utf_get(env, title, &chooser_title)) {
        jstring_to_utf_release(env, folder, chooser_folder);
        return create_empty_result();
    }

    if (!jstring_to_utf_get(env, name, &chooser_filename)) {
        jstring_to_utf_release(env, folder, chooser_folder);
        jstring_to_utf_release(env, title, chooser_title);
        return create_empty_result();
    }

    GtkWidget* chooser = gtk_file_chooser_dialog_new(chooser_title, gdk_window_handle_to_gtk(parent),
            static_cast<GtkFileChooserAction>(chooser_type),
            GTK_STOCK_CANCEL,
            GTK_RESPONSE_CANCEL,
            (chooser_type == GTK_FILE_CHOOSER_ACTION_OPEN ? GTK_STOCK_OPEN : GTK_STOCK_SAVE),
            GTK_RESPONSE_ACCEPT,
            NULL);
    
    if (chooser_type == GTK_FILE_CHOOSER_ACTION_SAVE) {
        gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(chooser), chooser_filename);
        gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER (chooser), TRUE);
    }

    gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(chooser), (JNI_TRUE == multiple));
    gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(chooser), chooser_folder);
    GSList* filters = setup_GtkFileFilters(GTK_FILE_CHOOSER(chooser), env, jFilters, default_filter_index);

    if (gtk_dialog_run(GTK_DIALOG(chooser)) == GTK_RESPONSE_ACCEPT) {
        GSList* fnames_gslist = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(chooser));
        guint fnames_list_len = g_slist_length(fnames_gslist);
        LOG1("FileChooser selected files: %d\n", fnames_list_len)

        if (fnames_list_len > 0) {
            jFileNames = env->NewObjectArray((jsize)fnames_list_len, jStringCls, NULL);
            for (guint i = 0; i < fnames_list_len; i++) {
                filename = (char*)g_slist_nth(fnames_gslist, i)->data;
                LOG1("Add [%s] into returned filenames\n", filename)
                jfilename = env->NewStringUTF(filename);
                env->SetObjectArrayElement(jFileNames, (jsize)i, jfilename);
            }
            g_slist_foreach(fnames_gslist, (GFunc) free_fname, NULL);
            g_slist_free(fnames_gslist);
        }
    }
Exemple #6
0
static void save_profile_to_file_cb(RoccatProfilePage *profile_page, gpointer user_data) {
	ArvoconfigWindow *window = ARVOCONFIG_WINDOW(user_data);
	ArvoconfigWindowPrivate *priv = window->priv;
	GtkWidget *dialog;
	gchar *filename, *path;
	gchar *temp_filename;
	GError *error = NULL;
	GtkFileFilter *windows_filter;
	GtkFileFilter *linux_filter;
	GtkFileFilter *all_filter;
	GtkFileFilter *filter;
	guint profile_index = roccat_config_window_get_page_index(ROCCAT_CONFIG_WINDOW(window), profile_page);
	ArvoRkp *rkp;

	rkp = arvoconfig_profile_page_get_rkp(ARVOCONFIG_PROFILE_PAGE(profile_page));

	dialog = gtk_file_chooser_dialog_new(_("Save profile"),
			GTK_WINDOW(window),
			GTK_FILE_CHOOSER_ACTION_SAVE,
			GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
			GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
			NULL);

	windows_filter = windows_file_filter_new();
	gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), windows_filter);
	linux_filter = linux_file_filter_new();
	gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), linux_filter);
	all_filter = all_file_filter_new();
	gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), all_filter);

	path = arvo_configuration_get_rkp_save_path(priv->config);
	gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), path);
	g_free(path);

	filename = arvo_create_filename_proposition(rkp, profile_index);
	gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), filename);
	g_free(filename);

	if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
		filter = gtk_file_chooser_get_filter(GTK_FILE_CHOOSER(dialog));
		filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
		temp_filename = roccat_create_filename_with_extension(filename, ROCCAT_KEYBOARD_PROFILE_EXTENSION);
		g_free(filename);

		path = g_path_get_dirname(temp_filename);
		arvo_configuration_set_rkp_save_path(priv->config, path);
		g_free(path);

		if (filter != linux_filter)
			arvo_linux_rkp_to_windows(rkp);

		arvo_rkp_write_with_path(temp_filename, rkp, &error);
		g_free(temp_filename);
		if (error) {
			roccat_warning_dialog(GTK_WINDOW(dialog), _("Could not save profile"), error->message);
			g_error_free(error);
		}
	}
	gtk_widget_destroy(dialog);
	arvo_rkp_free(rkp);
}
Exemple #7
0
char *
S9xOpenROMDialog ()
{
    GtkWidget     *dialog;
    GtkFileFilter *filter;
    char          *filename = NULL;
    gint          result;
    const char    *extensions[] =
    {
            "*.smc", "*.SMC", "*.fig", "*.FIG", "*.sfc", "*.SFC",
            "*.jma", "*.JMA", "*.zip", "*.ZIP", "*.gd3", "*.GD3",
            "*.swc", "*.SWC", "*.gz" , "*.GZ", "*.bs", "*.BS",
            NULL
    };

    top_level->pause_from_focus_change ();

    dialog = gtk_file_chooser_dialog_new (_("Open SNES ROM Image"),
                                          top_level->get_window (),
                                          GTK_FILE_CHOOSER_ACTION_OPEN,
                                          "gtk-cancel", GTK_RESPONSE_CANCEL,
                                          "gtk-open", GTK_RESPONSE_ACCEPT,
                                          NULL);

    filter = gtk_file_filter_new ();
    gtk_file_filter_set_name (filter, _("SNES ROM Images"));
    for (int i = 0; extensions[i]; i++)
    {
        gtk_file_filter_add_pattern (filter, extensions[i]);
    }
    gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);

    filter = gtk_file_filter_new ();
    gtk_file_filter_set_name (filter, _("All Files"));
    gtk_file_filter_add_pattern (filter, "*.*");
    gtk_file_filter_add_pattern (filter, "*");
    gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);

    if (!gui_config->last_directory.empty ())
    {
        gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog),
                                             gui_config->last_directory.c_str ());
    }

    result = gtk_dialog_run (GTK_DIALOG (dialog));
    gtk_widget_hide (dialog);

    if (result == GTK_RESPONSE_ACCEPT)
    {
        char *directory;

        filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
        directory =
            gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (dialog));
        if (directory)
        {
            gui_config->last_directory = directory;
            g_free (directory);
        }
    }

    else
    {
        filename = NULL;
    }

    gtk_widget_destroy (dialog);

    top_level->unpause_from_focus_change ();

    return filename;
}
static void
thunar_uca_editor_command_clicked (ThunarUcaEditor *uca_editor)
{
    GtkFileFilter *filter;
    GtkWidget     *chooser;
    gchar         *filename;
    gchar        **argv = NULL;
    gchar         *s;
    gint           argc;

    g_return_if_fail (THUNAR_UCA_IS_EDITOR (uca_editor));

    chooser = gtk_file_chooser_dialog_new (_("Select an Application"),
                                           GTK_WINDOW (uca_editor),
                                           GTK_FILE_CHOOSER_ACTION_OPEN,
                                           _("_Cancel"), GTK_RESPONSE_CANCEL,
                                           _("_Open"), GTK_RESPONSE_ACCEPT,
                                           NULL);
    gtk_dialog_set_default_response (GTK_DIALOG (chooser), GTK_RESPONSE_ACCEPT);
    gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (chooser), TRUE);

    /* add file chooser filters */
    filter = gtk_file_filter_new ();
    gtk_file_filter_set_name (filter, _("All Files"));
    gtk_file_filter_add_pattern (filter, "*");
    gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter);

    filter = gtk_file_filter_new ();
    gtk_file_filter_set_name (filter, _("Executable Files"));
    gtk_file_filter_add_mime_type (filter, "application/x-csh");
    gtk_file_filter_add_mime_type (filter, "application/x-executable");
    gtk_file_filter_add_mime_type (filter, "application/x-perl");
    gtk_file_filter_add_mime_type (filter, "application/x-python");
    gtk_file_filter_add_mime_type (filter, "application/x-ruby");
    gtk_file_filter_add_mime_type (filter, "application/x-shellscript");
    gtk_file_filter_add_pattern (filter, "*.pl");
    gtk_file_filter_add_pattern (filter, "*.py");
    gtk_file_filter_add_pattern (filter, "*.rb");
    gtk_file_filter_add_pattern (filter, "*.sh");
    gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter);
    gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (chooser), filter);

    filter = gtk_file_filter_new ();
    gtk_file_filter_set_name (filter, _("Perl Scripts"));
    gtk_file_filter_add_mime_type (filter, "application/x-perl");
    gtk_file_filter_add_pattern (filter, "*.pl");
    gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter);

    filter = gtk_file_filter_new ();
    gtk_file_filter_set_name (filter, _("Python Scripts"));
    gtk_file_filter_add_mime_type (filter, "application/x-python");
    gtk_file_filter_add_pattern (filter, "*.py");
    gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter);

    filter = gtk_file_filter_new ();
    gtk_file_filter_set_name (filter, _("Ruby Scripts"));
    gtk_file_filter_add_mime_type (filter, "application/x-ruby");
    gtk_file_filter_add_pattern (filter, "*.rb");
    gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter);

    filter = gtk_file_filter_new ();
    gtk_file_filter_set_name (filter, _("Shell Scripts"));
    gtk_file_filter_add_mime_type (filter, "application/x-csh");
    gtk_file_filter_add_mime_type (filter, "application/x-shellscript");
    gtk_file_filter_add_pattern (filter, "*.sh");
    gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter);

    /* use the bindir as default folder */
    gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (chooser), BINDIR);

    /* setup the currently selected file */
    filename = gtk_editable_get_chars (GTK_EDITABLE (uca_editor->command_entry), 0, -1);
    if (G_LIKELY (filename != NULL))
    {
        /* use only the first argument */
        s = strchr (filename, ' ');
        if (G_UNLIKELY (s != NULL))
            *s = '\0';

        /* check if we have a file name */
        if (G_LIKELY (*filename != '\0'))
        {
            /* check if the filename is not an absolute path */
            if (G_LIKELY (!g_path_is_absolute (filename)))
            {
                /* try to lookup the filename in $PATH */
                s = g_find_program_in_path (filename);
                if (G_LIKELY (s != NULL))
                {
                    /* use the absolute path instead */
                    g_free (filename);
                    filename = s;
                }
            }

            /* check if we have an absolute path now */
            if (G_LIKELY (g_path_is_absolute (filename)))
                gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (chooser), filename);
        }

        /* release the filename */
        g_free (filename);
    }

    /* run the chooser dialog */
    if (gtk_dialog_run (GTK_DIALOG (chooser)) == GTK_RESPONSE_ACCEPT)
    {
        /* determine the path to the selected file */
        filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (chooser));

        /* check if we need to quote the filename */
        if (!g_shell_parse_argv (filename, &argc, &argv, NULL) || argc > 1)
        {
            /* shell is unable to interpret properly without quoting */
            s = g_shell_quote (filename);
            g_free (filename);
            filename = s;
        }
        g_strfreev (argv);

        /* append %f to filename, user may change that afterwards */
        s = g_strconcat (filename, " %f", NULL);
        gtk_entry_set_text (GTK_ENTRY (uca_editor->command_entry), s);
        g_free (filename);
        g_free (s);
    }

    gtk_widget_destroy (chooser);
}
Exemple #9
0
/*****************************************************************************
 * run_session_load_dialog()
 *
 * Callback for running the 'Load Session' dialog from the main menu.
 *****************************************************************************/
void
run_session_load_dialog(GtkWidget *UNUSED(widget), gpointer UNUSED(data))
{
    SESSION         *session    = get_current_session();
    PATCH           *patch;
    DIR_LIST        *pdir       = session_dir_list;
    char            *directory;
    GSList          *file_list;
    GSList          *cur;
    GError          *error;
    unsigned int    sess_num    = session_io_start;
    unsigned int    part_num;

    /* create dialog if needed */
    if (session_load_dialog == NULL) {
        create_session_load_dialog();
    }

    gtk_widget_show(session_load_dialog);

    /* add all session directories to shortcuts */
    while (pdir != NULL) {
        if (!pdir->load_shortcut) {
            error = NULL;
            gtk_file_chooser_add_shortcut_folder(GTK_FILE_CHOOSER(session_load_dialog),
                                                 pdir->name, &error);
            if (error != NULL) {
                PHASEX_ERROR("Error %d: %s\n", error->code, error->message);
                g_error_free(error);
            }
            pdir->load_shortcut = 1;
        }
        pdir = pdir->next;
    }

    /* set filename and current directory */
    if ((session->directory != NULL) && (* (session->directory) != '\0')) {
        gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(session_load_dialog), session->directory);
    }
    else if ((session->parent_dir != NULL) && (* (session->parent_dir) != '\0')) {
        gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(session_load_dialog),
                                            session->parent_dir);
    }
    else {
        gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(session_load_dialog),
                                            user_session_dir);
    }

    /* set position in patch bank to start loading patches */
    session_io_start = visible_sess_num;
    gtk_adjustment_set_value(GTK_ADJUSTMENT(session_io_start_adj), (session_io_start + 1));

    /* run the dialog and load if necessary */
    if (gtk_dialog_run(GTK_DIALOG(session_load_dialog)) == GTK_RESPONSE_ACCEPT) {

        /* get list of selected files from chooser */
        file_list = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(session_load_dialog));
        if (file_list != NULL) {
            session_io_start =
                (unsigned int) gtk_adjustment_get_value(GTK_ADJUSTMENT(session_io_start_adj)) - 1;

            /* read in each session and increment session bank slot number */
            sess_num = session_io_start;
            session_load_in_progress = 1;
            cur = file_list;
            while (cur != NULL) {
                directory = (char *) cur->data;
                if (load_session(directory, sess_num) == 0) {
                    if (sess_num == visible_sess_num) {
                        for (part_num = 0; part_num < MAX_PARTS; part_num++) {
                            visible_prog_num[part_num] = 0;
                            patch = set_active_patch(visible_sess_num, part_num, 0);
                            init_patch_state(patch);
                            if (part_num == visible_part_num) {
                                update_gui_patch(patch, 0);
                            }
                        }
                    }
                    sess_num++;
                }
                if (sess_num >= SESSION_BANK_SIZE) {
                    break;
                }
                cur = g_slist_next(cur);
            }
            session_load_in_progress = 0;
            g_slist_free(file_list);

            update_gui_patch_name();
            update_gui_session_name();

            save_session_bank();
        }

    }

    /* save this widget for next time */
    gtk_widget_hide(session_load_dialog);
}
Exemple #10
0
static void
ui_choose_file_or_dir(gchar *title, const gchar *buttonName, gboolean saving, gboolean directory, fileChoosenCallback callback, const gchar *currentPath, const gchar *defaultFilename, const char *filterstring, const char *filtername, gpointer user_data)
{
	GtkWidget			*dialog;
	struct file_chooser_tuple	*tuple;
	GtkWidget			*button;
	gchar				*path = NULL;

	g_assert (!(saving & directory));
	g_assert (!(defaultFilename && !saving));

	if (!currentPath)
		conf_get_str_value (ENCLOSURE_DOWNLOAD_PATH, &path);
	else
		path = g_strdup (currentPath);

	dialog = gtk_file_chooser_dialog_new (title, GTK_WINDOW (liferea_shell_get_window ()),
	                                      (directory?GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER:
					       (saving ? GTK_FILE_CHOOSER_ACTION_SAVE : GTK_FILE_CHOOSER_ACTION_OPEN)),
	                                      GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
	                                      NULL);
	if (saving)
		gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE);
	gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
	
	tuple = g_new0 (struct file_chooser_tuple, 1);
	tuple->dialog = dialog;
	tuple->func = callback;
	tuple->user_data = user_data;

	button = gtk_dialog_add_button (GTK_DIALOG (dialog), buttonName, GTK_RESPONSE_ACCEPT);
	gtk_widget_set_can_default (button, TRUE);
	gtk_widget_grab_default (button);

	g_signal_connect (G_OBJECT (dialog), "response",
	                  G_CALLBACK (ui_choose_file_save_cb), tuple);
	                  
	if (path && g_file_test (path, G_FILE_TEST_EXISTS)) {
		if (directory || defaultFilename)
			gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), path);
		else
			gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (dialog), path);
	}
	if (defaultFilename)
		gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog), defaultFilename);

	if (filterstring && filtername) {
		GtkFileFilter *filter, *allfiles;

		filter = gtk_file_filter_new ();
		gtk_file_filter_add_pattern (filter, filterstring);
		gtk_file_filter_set_name (filter, filtername);
		gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);

		allfiles = gtk_file_filter_new ();
		gtk_file_filter_add_pattern (allfiles, "*");
		gtk_file_filter_set_name (allfiles, _("All Files"));
		gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), allfiles);
	}

	gtk_widget_show_all (dialog);
	g_free (path);
}
Exemple #11
0
int main(int argc, char **argv) {

    struct arguments argument;
    struct arguments *pargument = &argument;

    //InitOpenAL(); // potential memory leak
    source = 0;
    pargument->first = 1;
    pargument->endless_check = 0;
    pargument->continue_count = 0;
    pargument->offset = 0;
    pargument->elapsed = g_timer_new();
    GtkWidget *window, *hpaned, *pause_button, *bitrate_label, *chooser1, *chooser2, *chooser3, *vboxl, *vboxr, *check,
              *continue_check, *continue_label, *next_button, *button2, *spin_int, *progressbar, *button_hbox, *continue_hbox;
    GtkFileFilter *filter1, *filter2;

    gtk_init(&argc, &argv);

    //g_remove("list.txt");
    window = gtk_window_new(GTK_WINDOW_TOPLEVEL);

    pargument->adjust = (GtkAdjustment*)gtk_adjustment_new(0, 0, 100, 1, 1, 1);

#if GTK3
    progressbar = gtk_scale_new(GTK_ORIENTATION_HORIZONTAL, adjust);
#endif
    progressbar = gtk_hscale_new(pargument->adjust);
    gtk_scale_set_draw_value ((GtkScale*)progressbar, FALSE);
    gtk_window_set_title(GTK_WINDOW(window), "lelele player");
    pargument->label = gtk_label_new ("");
    pargument->title_label = gtk_label_new("");
    pargument->album_label = gtk_label_new("");
    pargument->artist_label = gtk_label_new("");
    gtk_label_set_line_wrap((GtkLabel*)pargument->title_label, TRUE);
    gtk_label_set_line_wrap((GtkLabel*)pargument->artist_label, TRUE);
    gtk_label_set_line_wrap((GtkLabel*)pargument->album_label, TRUE);
    continue_label = gtk_label_new("Number of songs played\n -1 to go endless");

    gtk_container_set_border_width(GTK_CONTAINER(window), 10);
    gtk_widget_set_size_request(window, 500, 250);
    hpaned = gtk_hpaned_new();

    spin_int = gtk_spin_button_new_with_range(-1, 10000, 1);
    gtk_spin_button_set_value ((GtkSpinButton*)spin_int, 1);
    pause_button = gtk_button_new_with_mnemonic("_Play/Pause");
    next_button = gtk_button_new_with_mnemonic("Next");
    check = gtk_check_button_new_with_label ("Endless mode.");
    //continue_check = gtk_check_button_new_with_label("Play this number of songs.");


    g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (destroy), NULL);
    g_signal_connect (G_OBJECT(pause_button), "clicked", G_CALLBACK(play), pargument);
    g_signal_connect (G_OBJECT(next_button), "clicked", G_CALLBACK(next), pargument);
    g_signal_connect (G_OBJECT(check), "toggled", G_CALLBACK(check_toggled), pargument);
    //g_signal_connect(G_OBJECT(continue_check), "toggled", G_CALLBACK(continue_check_toggled), spin_int);
    g_signal_connect(G_OBJECT(spin_int), "value-changed", G_CALLBACK(continue_spin_count), pargument);
    g_signal_connect(G_OBJECT(progressbar), "value-changed", G_CALLBACK(slider_changed), pargument);


    /* Create two buttons, one to select a folder and one to select a file. */

    chooser1 = gtk_file_chooser_button_new ("Chooser a Folder", GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
    chooser2 = gtk_file_chooser_button_new ("Chooser a Folder", GTK_FILE_CHOOSER_ACTION_OPEN);
    chooser3 = gtk_file_chooser_button_new ("Choose a folder for config (may take some time)", GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);

    /* Monitor when the selected folder or file are changed. */
    g_signal_connect (G_OBJECT (chooser2), "selection_changed", G_CALLBACK (file_changed), pargument);
    g_signal_connect (G_OBJECT (chooser1), "selection_changed", G_CALLBACK(folder_changed), pargument);
    g_signal_connect (G_OBJECT (chooser3), "selection_changed", G_CALLBACK (config_folder_changed), pargument);

    /* Set both file chooser buttons to the location of the user's home directory. */
    gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (chooser2), g_get_home_dir());

    gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (chooser1), g_get_home_dir());
    /* Provide a filter to show all files and one to shown only 3 types of images. */
    filter1 = gtk_file_filter_new ();
    filter2 = gtk_file_filter_new ();
    gtk_file_filter_set_name (filter1, "Audio Files");
    gtk_file_filter_set_name (filter2, "All Files");
    gtk_file_filter_add_pattern (filter1, "*.mp3");
    gtk_file_filter_add_pattern (filter1, "*.flac");
    gtk_file_filter_add_pattern (filter1, "*.aac");
    gtk_file_filter_add_pattern (filter2, "*");

    /* Add the both filters to the file chooser button that selects files. */
    gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser2), filter1);
    gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser2), filter2);


    //gtk_widget_set_sensitive(spin_int, FALSE);
    vboxl = gtk_vbox_new (TRUE, 5);
    vboxr = gtk_vbox_new (TRUE, 5);
    button_hbox = gtk_hbox_new (TRUE, 5);
    continue_hbox= gtk_hbox_new (TRUE, 5);

    gtk_box_set_homogeneous(GTK_BOX(vboxr), FALSE);
    gtk_box_set_homogeneous(GTK_BOX(continue_hbox), FALSE);

    gtk_box_pack_start_defaults (GTK_BOX (vboxl), chooser1);
    gtk_box_pack_start_defaults (GTK_BOX (vboxl), chooser2);
//	gtk_box_pack_start_defaults (GTK_BOX (vboxl), chooser3);
    //gtk_box_pack_start_defaults (GTK_BOX (vboxl), check);

    gtk_box_pack_start_defaults (GTK_BOX (vboxl), continue_hbox);
    gtk_box_pack_start_defaults (GTK_BOX(continue_hbox), continue_label);
    gtk_box_pack_start_defaults (GTK_BOX(continue_hbox), spin_int);
    gtk_box_pack_start_defaults (GTK_BOX (vboxl), button_hbox);
    gtk_box_pack_start_defaults (GTK_BOX (button_hbox), pause_button);
    gtk_box_pack_start_defaults (GTK_BOX(button_hbox), next_button);
    gtk_box_pack_start_defaults (GTK_BOX(vboxl), progressbar);

    gtk_box_pack_start(GTK_BOX (vboxr), pargument->label, FALSE, FALSE, 1);
    gtk_box_pack_start(GTK_BOX (vboxr), pargument->title_label, FALSE, FALSE, 1);
    gtk_box_pack_start(GTK_BOX (vboxr), pargument->album_label, FALSE, FALSE, 1);
    gtk_box_pack_start(GTK_BOX (vboxr), pargument->artist_label, FALSE, FALSE, 1);

#ifdef GTK3
    vboxl = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
    vboxr = gtk_vboxr_new (GTK_ORIENTATION_VERTICAL, 5);
    gtk_box_pack_start (GTK_BOX (vboxl), chooser1, TRUE, TRUE, 3);
    gtk_box_pack_start (GTK_BOX (vboxl), chooser2, TRUE, TRUE, 3);
    gtk_box_pack_start (GTK_BOX (vboxl), pause_button, TRUE, TRUE, 3);
    gtk_box_pack_start (GTK_BOX(vboxl), next_button, TRUE, TRUE, 3);
    gtk_box_pack_start (GTK_BOX (vboxl), pargument->label, TRUE, TRUE, 3);
    gtk_box_pack_start (GTK_BOX (vboxl), check, TRUE, TRUE, 3);
    gtk_box_pack_start (GTK_BOX(vboxl), continue_check, TRUE, TRUE, 3);
    gtk_box_pack_start (GTK_BOX(vboxl), spin_int, TRUE, TRUE, 3);

    gtk_box_pack_start (GTK_BOX(vboxl), progressbar, TRUE, TRUE, 3);

    gtk_box_pack_start (GTK_BOX (vboxr), pargument->label, TRUE, TRUE, 3);
    gtk_box_pack_start_defaults (GTK_BOX (vboxr), pargument->title_label, TRUE, TRUE, 3);
    gtk_box_pack_start_defaults (GTK_BOX (vboxr), pargument->album_label, TRUE, TRUE, 3);
    gtk_box_pack_start_defaults (GTK_BOX (vboxr), pargument->artist_label, TRUE, TRUE, 3);

#endif

    gtk_paned_pack1(GTK_PANED(hpaned), vboxl, FALSE, FALSE);
    gtk_paned_pack2(GTK_PANED(hpaned), vboxr, TRUE, FALSE);
    gtk_container_add (GTK_CONTAINER (window), hpaned);

    gtk_widget_show_all(window);

    gtk_main();
    return 0;
}
Exemple #12
0
void
sample_save_as_cb(GtkWidget * widget, gpointer data)
{
  GtkWidget *dialog;
  gint win_width, win_height;
  sw_view * view = (sw_view *)data;
  sw_sample * sample;
  GtkWidget * save_options;
  GtkWidget * frame;
  GtkWidget * hbox;
  GtkWidget * label;
  GtkWidget * option_menu;
  GtkWidget * save_menu;
  struct stat statbuf;
  gchar *filename;
  gint retval;

  save_as_data * sd;

  char buf[512];

  win_width = gdk_screen_width () / 2;
  win_height = gdk_screen_height () / 2;

  sample = view->sample;

  dialog = gtk_file_chooser_dialog_new (_("Sweep: Save file"),
				      GTK_WINDOW(view->window),
				      GTK_FILE_CHOOSER_ACTION_SAVE,
				      GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
				      GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
				      NULL);


  //gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE);
  attach_window_close_accel(GTK_WINDOW(dialog));
  sweep_set_window_icon (GTK_WINDOW(dialog));

  save_options = gtk_hbox_new (TRUE, 1);

  frame = gtk_frame_new (_("Save Options"));
  gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
  gtk_box_pack_start (GTK_BOX (save_options), frame, TRUE, TRUE, 4);

  hbox = gtk_hbox_new (FALSE, 4);
  gtk_container_set_border_width (GTK_CONTAINER (hbox), 4);
  gtk_container_add (GTK_CONTAINER (frame), hbox);
  gtk_widget_show (hbox);

  label = gtk_label_new (_("Determine File Type:"));
  gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
  gtk_widget_show (label);

  option_menu = gtk_option_menu_new ();
  gtk_box_pack_start (GTK_BOX (hbox), option_menu, TRUE, TRUE, 0);
  gtk_widget_show (option_menu);

  save_menu = create_save_menu (sample);
  gtk_option_menu_set_menu (GTK_OPTION_MENU (option_menu), save_menu);

  gtk_widget_show (frame);

  /* pack the containing save_options hbox into the save-dialog */
  gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox),
		    save_options, FALSE, FALSE, 0);

  gtk_widget_show (save_options);

  gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER);
  gtk_widget_set_size_request (dialog, win_width, win_height);

  if (strcmp (g_path_get_dirname(sample->pathname), ".") == 0) {
    char last_save [512];

    prefs_get_string (LAST_SAVE_KEY, last_save, sizeof (last_save), "");

    if (last_save [0]) {
      gchar * last_save_dir = g_dirname (last_save);

	  gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER(dialog),
				      last_save_dir);
      gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER(dialog),
				      sample->pathname);

      g_free (last_save_dir);
    }
  } else {
     retval =  gtk_file_chooser_set_filename (GTK_FILE_CHOOSER(dialog),
				    sample->pathname);
        /* FIXME: bug (local only?) causes gtk_file_chooser_set_filename
           to fail silently in some cases*/
        filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
        //printf("filename pre: %s\n", filename);
        //printf("sample->pathname: %s\n", sample->pathname);

  }

  retval = gtk_dialog_run (GTK_DIALOG (dialog));

  filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
  //printf("filename post: %s\n", filename);
  sample = view->sample;
  sd = g_malloc (sizeof (save_as_data));
  sd->sample = sample;
  sd->pathname = filename;

  if (retval == GTK_RESPONSE_ACCEPT) {

    if (!sweep_dir_exists (filename)) {
      g_free (sd);
      g_free (filename);
      return;
    }

    if (stat (filename, &statbuf) == -1) {
      switch (errno) {
      case ENOENT:
        /* If it doesn't exist, it's ok to save as */
        overwrite_ok_cb (NULL, sd);
        break;
      default:
        sweep_perror (errno, filename);
        break;
      }
    } else {
      /* file exists */

      if (access(filename, W_OK) == -1) {
        sweep_perror (errno, _("You are not allowed to write to\n%s"), filename);
      } else {
        snprintf (buf, sizeof (buf), _("%s exists. Overwrite?"), filename);

        question_dialog_new (sample, _("File exists"), buf,
		  	   _("Overwrite"), _("Don't overwrite"),
			     G_CALLBACK (overwrite_ok_cb), sd, G_CALLBACK (overwrite_cancel_cb), sd,
			     SWEEP_EDIT_MODE_META);
      }
    }
    /* FIXME: wrapped this due to the above gtk_file_chooser_set_filename problem */
    } else if (sd->pathname != NULL) {
      gchar msg [1024];

      snprintf (msg, sizeof (msg), _("Save as %s cancelled"), g_path_get_basename (sd->pathname));
      sample_set_tmp_message (sd->sample, msg);
    } else {

    g_free (sd);
    g_free (filename);
    }
  gtk_widget_destroy (dialog);


}
Exemple #13
0
/*
 * Start the dialog that ask to the user where save the image
 * containing the screenshot.
 */
void
start_save_image_dialog (GtkToolButton *toolbutton,
                         GtkWindow     *parent)
{

  GtkWidget *preview = NULL;
  gint preview_width = 128;
  gint preview_height = 128;
  GdkPixbuf *preview_pixbuf = NULL;
  gchar  *filename = "";
  gchar *filename_copy = "";
  gchar *supported_extension = ".pdf";
  gint run_status = GTK_RESPONSE_NO;
  gboolean screenshot = FALSE;
  GdkPixbuf *buf = grab_screenshot ();

  GtkWidget *chooser = gtk_file_chooser_dialog_new (gettext ("Export as pdf"),
                                                    parent,
                                                    GTK_FILE_CHOOSER_ACTION_SAVE,
                                                    GTK_STOCK_CANCEL,
                                                    GTK_RESPONSE_CANCEL,
                                                    GTK_STOCK_SAVE_AS,
                                                    GTK_RESPONSE_ACCEPT,
                                                    NULL);

  gtk_window_set_modal (GTK_WINDOW (chooser), TRUE);
  gtk_window_set_keep_above (GTK_WINDOW (chooser), TRUE);

  gtk_window_set_title (GTK_WINDOW (chooser), gettext ("Choose a file"));

  /* Save the preview in a buffer. */
  preview = gtk_image_new ();
  preview_pixbuf = gdk_pixbuf_scale_simple (buf, preview_width, preview_height, GDK_INTERP_BILINEAR);
  gtk_image_set_from_pixbuf (GTK_IMAGE (preview), preview_pixbuf);
  
  gtk_file_chooser_set_preview_widget (GTK_FILE_CHOOSER (chooser), preview);
  g_object_unref (preview_pixbuf);
  preview_pixbuf = NULL;

  gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (chooser), get_project_dir ());

  filename = get_default_filename ();

  gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (chooser), filename);

  start_virtual_keyboard ();
  run_status = gtk_dialog_run (GTK_DIALOG (chooser));
  if (run_status == GTK_RESPONSE_ACCEPT)
    {
      g_free (filename);
      filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (chooser));
      filename_copy = g_strdup_printf ("%s", filename);

      screenshot = TRUE;
      supported_extension = ".png";

      if (!g_str_has_suffix (filename, supported_extension))
        {
          g_free (filename_copy);
          filename_copy = g_strdup_printf ("%s%s", filename, supported_extension);
        }

      g_free (filename);
      filename = filename_copy;

      if (file_exists (filename))
        {
          gint result = show_override_dialog (GTK_WINDOW (chooser));
          if ( result == GTK_RESPONSE_NO)
            {
              screenshot = FALSE;
            } 
        }
      else
        {
           FILE *stream = g_fopen (filename, "w");
           if (stream == NULL)
            {
              show_could_not_write_dialog (GTK_WINDOW (chooser));
            }
           else
            {
              fclose (stream);
            }
        }
    }
  stop_virtual_keyboard ();
  gtk_widget_destroy (preview);
  preview = NULL;
  if (chooser != NULL)
    {
      gtk_widget_destroy (chooser);
      chooser = NULL;
    }
  if (screenshot)
    {
      /* Store the buffer on file. */
      save_pixbuf_on_png_file (buf, filename);
      /* Add to the list of the artefacts created in the session. */
      add_artifact (filename);
    }

  g_free (filename);
  filename = NULL;
  g_object_unref (buf);
  buf = NULL;
}
Exemple #14
0
static int basic_save_as(GtkWidget* parent_window, gboolean not_export)
{
    GtkWidget *dialog;
    int val;
    const char* title;
    char* filter = file_ops_join_ext("*", dish_file_extension());
    char* untitled_dish = file_ops_join_ext(untitled_name,
                                            dish_file_extension());

    global_settings* settings = settings_get();

    if (not_export)
        title = "Basic Save bank as";
    else
        title = "Basic Export as";

    dialog = gtk_file_chooser_dialog_new(title,
                                    GTK_WINDOW(parent_window),
                                    GTK_FILE_CHOOSER_ACTION_SAVE,
                                    GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
                                    GTK_STOCK_SAVE_AS, GTK_RESPONSE_ACCEPT,
                                    NULL);

    gtk_file_chooser_set_do_overwrite_confirmation(
                                    GTK_FILE_CHOOSER(dialog), TRUE);
    if (!dish_file_has_state())
    {
        gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog),
                                            settings->last_bank_dir);
        gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog),
                                            untitled_dish);
    }
    else
    {
        const char* tmp = 0;
        char* fn = 0;
        char* pdir = 0; /* parent of session dir */

        if (dish_file_state_is_full())
        {
            tmp = dish_file_state_parent_dir();

            if (session_is_active()
             && (pdir = file_ops_parent_dir(tmp)) != 0)
            {
                tmp = pdir;
            }
        }
        else
            tmp = dish_file_state_bank_dir();

        debug("tmp:     '%s'\n", tmp);
        debug("parent:  '%s'\n", dish_file_state_parent_dir());
        debug("bank:    '%s'\n", dish_file_state_bank_dir());

        gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), tmp);
        fn = file_ops_join_ext( dish_file_state_bank_name(),
                                dish_file_extension());

        gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), fn);
        free(fn);
        free(pdir);
    }

    file_chooser_add_filter(dialog, "Petri-Foo files", filter);
    file_chooser_add_filter(dialog, "All files", "*");

    if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
    {
        char *name = (char *)
            gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));

        if ((val = dish_file_write_basic(name)) < 0)
        {
            GtkWidget* msg = gtk_message_dialog_new(GTK_WINDOW(dialog),
                                    GTK_DIALOG_MODAL,
                                    GTK_MESSAGE_ERROR,
                                    GTK_BUTTONS_CLOSE,
                                    "Failed to write file %s\n.", name);

            g_signal_connect_swapped(G_OBJECT(msg), "response",
                                    G_CALLBACK(gtk_widget_destroy), msg);
            gtk_widget_show (msg);
        }
        else
        {
            if (recent_manager && not_export)
                gtk_recent_manager_add_item (recent_manager, 
                    g_filename_to_uri(name, NULL, NULL));
        }
    }
    else
    {
        val = -1;
    }

    gtk_widget_destroy(dialog);

    free(filter);

    return val;
}
bool FileDialog::Create(wxWindow *parent, const wxString& message,
                           const wxString& defaultDir,
                           const wxString& defaultFileName,
                           const wxString& wildCard,
                           long style, const wxPoint& pos,
                           const wxSize& sz,
                           const wxString& name)
{
    parent = GetParentForModalDialog(parent, style);

    if (!FileDialogBase::Create(parent, message, defaultDir, defaultFileName,
                                  wildCard, style, pos, sz, name))
    {
        return false;
    }

    if (!PreCreation(parent, pos, wxDefaultSize) ||
        !CreateBase(parent, wxID_ANY, pos, wxDefaultSize, style,
                wxDefaultValidator, wxT("filedialog")))
    {
        wxFAIL_MSG( wxT("FileDialog creation failed") );
        return false;
    }

    GtkFileChooserAction gtk_action;
    GtkWindow* gtk_parent = NULL;
    if (parent)
        gtk_parent = GTK_WINDOW( gtk_widget_get_toplevel(parent->m_widget) );

    const gchar* ok_btn_stock;
    if ( style & wxFD_SAVE )
    {
        gtk_action = GTK_FILE_CHOOSER_ACTION_SAVE;
        ok_btn_stock = GTK_STOCK_SAVE;
    }
    else
    {
        gtk_action = GTK_FILE_CHOOSER_ACTION_OPEN;
        ok_btn_stock = GTK_STOCK_OPEN;
    }

    m_widget = gtk_file_chooser_dialog_new(
                   wxGTK_CONV(m_message),
                   gtk_parent,
                   gtk_action,
                   GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
                   ok_btn_stock, GTK_RESPONSE_ACCEPT,
                   NULL);
    g_object_ref(m_widget);
    GtkFileChooser* file_chooser = GTK_FILE_CHOOSER(m_widget);

    m_fc.SetWidget(file_chooser);

    gtk_dialog_set_default_response(GTK_DIALOG(m_widget), GTK_RESPONSE_ACCEPT);

    if ( style & wxFD_MULTIPLE )
        gtk_file_chooser_set_select_multiple(file_chooser, true);

    // local-only property could be set to false to allow non-local files to be
    // loaded. In that case get/set_uri(s) should be used instead of
    // get/set_filename(s) everywhere and the GtkFileChooserDialog should
    // probably also be created with a backend, e.g. "gnome-vfs", "default", ...
    // (gtk_file_chooser_dialog_new_with_backend). Currently local-only is kept
    // as the default - true:
    // gtk_file_chooser_set_local_only(GTK_FILE_CHOOSER(m_widget), true);

    g_signal_connect (m_widget, "response",
        G_CALLBACK (gtk_filedialog_response_callback), this);

    g_signal_connect (m_widget, "selection-changed",
        G_CALLBACK (gtk_filedialog_selchanged_callback), this);

    g_signal_connect (m_widget, "current-folder-changed",
         G_CALLBACK (gtk_filedialog_folderchanged_callback), this);

    g_signal_connect (m_widget, "notify::filter",
         G_CALLBACK (gtk_filedialog_filterchanged_callback), this);

    // deal with extensions/filters
    SetWildcard(wildCard);

    wxString defaultFileNameWithExt = defaultFileName;
    if ( !wildCard.empty() && !defaultFileName.empty() &&
            !wxFileName(defaultFileName).HasExt() )
    {
        // append the default extension, if any, to the initial file name: GTK
        // won't do it for us by default (unlike e.g. MSW)
        const wxFileName fnWC(m_fc.GetCurrentWildCard());
        if ( fnWC.HasExt() )
        {
            // Notice that we shouldn't append the extension if it's a wildcard
            // because this is not useful: the user would need to change it to use
            // some fixed extension anyhow.
            const wxString& ext = fnWC.GetExt();
            if ( ext.find_first_of("?*") == wxString::npos )
                defaultFileNameWithExt << "." << ext;
        }
    }


    // if defaultDir is specified it should contain the directory and
    // defaultFileName should contain the default name of the file, however if
    // directory is not given, defaultFileName contains both
    wxFileName fn;
    if ( defaultDir.empty() )
        fn.Assign(defaultFileNameWithExt);
    else if ( !defaultFileNameWithExt.empty() )
        fn.Assign(defaultDir, defaultFileNameWithExt);
    else
        fn.AssignDir(defaultDir);

    // set the initial file name and/or directory
    fn.MakeAbsolute(); // GTK+ needs absolute path
    const wxString dir = fn.GetPath();
    if ( !dir.empty() )
    {
        gtk_file_chooser_set_current_folder(file_chooser, wxGTK_CONV_FN(dir));
    }

    const wxString fname = fn.GetFullName();
    if ( style & wxFD_SAVE )
    {
        if ( !fname.empty() )
        {
            gtk_file_chooser_set_current_name(file_chooser, wxGTK_CONV_FN(fname));
        }

#if GTK_CHECK_VERSION(2,7,3)
        if ((style & wxFD_OVERWRITE_PROMPT)
#ifndef __WXGTK3__
            && gtk_check_version(2,7,3) == NULL
#endif
            )
        {
            gtk_file_chooser_set_do_overwrite_confirmation(file_chooser, true);
        }
#endif
    }
    else // wxFD_OPEN
    {
        if ( !fname.empty() )
        {
            gtk_file_chooser_set_filename(file_chooser,
                                          wxGTK_CONV_FN(fn.GetFullPath()));
        }
    }

    if ( style & wxFD_PREVIEW )
    {
        GtkWidget *previewImage = gtk_image_new();

        gtk_file_chooser_set_preview_widget(file_chooser, previewImage);
        g_signal_connect(m_widget, "update-preview",
                         G_CALLBACK(gtk_filedialog_update_preview_callback),
                         previewImage);
    }

    return true;
}
Exemple #16
0
/*****************************************************************************
 * create_session_save_dialog()
 *****************************************************************************/
void
create_session_save_dialog(void)
{
    GError          *error  = NULL;
    GtkWidget       *hbox;
    GtkWidget       *label;
    int             new_adj = (session_io_start_adj == NULL);

    /* this should only need to happen once */
    if (session_save_dialog == NULL) {

        /* create dialog */
        session_save_dialog = gtk_file_chooser_dialog_new("PHASEX - Save Session",
                              GTK_WINDOW(main_window),
                              GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
                              GTK_STOCK_CANCEL,
                              GTK_RESPONSE_CANCEL,
                              GTK_STOCK_SAVE,
                              GTK_RESPONSE_ACCEPT,
                              NULL);
        gtk_window_set_wmclass(GTK_WINDOW(session_save_dialog), "phasex", "phasex-save");
        gtk_window_set_role(GTK_WINDOW(session_save_dialog), "session-save");
        gtk_file_chooser_set_preview_widget_active
        (GTK_FILE_CHOOSER(session_save_dialog), FALSE);

        /* create spinbutton control of session number */
        hbox = gtk_hbox_new(FALSE, 8);
        label = gtk_label_new("Save into session #:");
        gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 8);

        if (new_adj) {
            session_io_start_adj = gtk_adjustment_new(0, 1, PATCH_BANK_SIZE, 1, 8, 0);
        }
        session_save_start_spin = gtk_spin_button_new(GTK_ADJUSTMENT(session_io_start_adj), 0, 0);
        gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(session_save_start_spin), TRUE);
        gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(session_save_start_spin),
                                          GTK_UPDATE_IF_VALID);
        gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(session_save_start_spin), TRUE);
        gtk_adjustment_set_value(GTK_ADJUSTMENT(session_io_start_adj), (session_io_start + 1));
        gtk_box_pack_start(GTK_BOX(hbox), session_save_start_spin, FALSE, FALSE, 8);

        if (new_adj) {
            g_signal_connect(GTK_OBJECT(session_save_start_spin), "value_changed",
                             GTK_SIGNAL_FUNC(set_session_io_start),
                             (gpointer) session_io_start_adj);
        }

        gtk_widget_show_all(hbox);
        gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(session_save_dialog), hbox);

        /* realize the file chooser before telling it about files */
        gtk_widget_realize(session_save_dialog);

#if GTK_CHECK_VERSION(2, 8, 0)
        /* this can go away once manual overwrite checks are proven to work properly */
        gtk_file_chooser_set_do_overwrite_confirmation
        (GTK_FILE_CHOOSER(session_save_dialog), TRUE);
#endif
#if GTK_CHECK_VERSION(2, 6, 0)
        gtk_file_chooser_set_show_hidden(GTK_FILE_CHOOSER(session_save_dialog), TRUE);
#endif

        /* add user session dir as shortcut folder (user cannot write to sys) */
        gtk_file_chooser_add_shortcut_folder(GTK_FILE_CHOOSER(session_save_dialog),
                                             user_session_dir, &error);
        if (error != NULL) {
            PHASEX_ERROR("Error %d: %s\n", error->code, error->message);
            g_error_free(error);
        }

        /* start in user session dir (usually ~/.phasex/user-sessions) */
        gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(session_save_dialog),
                                            user_session_dir);
    }
}
Exemple #17
0
/**
 * repository_ipod_init:
 *
 * Ask for the iPod model and mountpoint and then create the directory
 * structure on the iPod.
 *
 * @itdb: itdb from where to extract the mountpoint. After
 * initialisation the model number is set.
 */
gboolean repository_ipod_init(iTunesDB *itdb) {
    IpodInit *ii;
    gint response;
    gboolean result = FALSE;
    gchar *mountpoint, *new_mount, *name, *model;
    GError *error = NULL;
    gchar buf[PATH_MAX];
    GtkComboBox *cb;
    const IpodInfo *info;
    GtkTreeIter iter;

    g_return_val_if_fail (itdb, FALSE);

    /* Create window */
    ii = g_new0 (IpodInit, 1);
    ii->itdb = itdb;

    ii->builder = init_repository_builder();

    ii->window = gtkpod_builder_xml_get_widget(ii->builder, "ipod_init_dialog");
    g_return_val_if_fail (ii->window, FALSE);

    /* Set mountpoint */
    mountpoint = get_itdb_prefs_string(itdb, KEY_MOUNTPOINT);
    if (mountpoint) {
        gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(GET_WIDGET (ii->builder, IID_MOUNTPOINT_CHOOSER)), mountpoint);
    }

    /* Setup model number combo */
    cb = GTK_COMBO_BOX (GET_WIDGET (ii->builder, IID_MODEL_COMBO));
    repository_init_model_number_combo(cb);

    /* If available set current model number, otherwise indicate that
     none is available */
    info = itdb_device_get_ipod_info(itdb->device);
    if (info && (info->ipod_generation != ITDB_IPOD_GENERATION_UNKNOWN)) {
        g_snprintf(buf, PATH_MAX, "x%s", info->model_number);
    }
    else {
        model = get_itdb_prefs_string(itdb, KEY_IPOD_MODEL);
        if (model && (strlen(g_strstrip (model)) != 0)) {
            g_snprintf(buf, PATH_MAX, "%s", model);
            g_free(model);
        }
        else {
            g_snprintf(buf, PATH_MAX, "%s", gettext (SELECT_OR_ENTER_YOUR_MODEL));
        }
    }

    /* Try and set buf as the active selection in the combo box */
    _model_combo_set_active_iter(cb, buf);

    gtk_window_set_transient_for(GTK_WINDOW (ii->window), GTK_WINDOW (gtkpod_app));
    response = gtk_dialog_run(GTK_DIALOG (ii->window));

    switch (response) {
    case GTK_RESPONSE_OK:
        new_mount = g_strdup(gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(GET_WIDGET (ii->builder, IID_MOUNTPOINT_CHOOSER))));
        if (!new_mount || (strlen(new_mount) == 0)) {
            gtkpod_statusbar_message("No mount point has been selected");
            return FALSE;
        }

        if (!gtk_combo_box_get_has_entry(cb)) {
            gtkpod_statusbar_message("No model has been selected");
            return FALSE;
        }

        /* remove trailing '/' in case it's present. */
        if (mountpoint && (strlen(mountpoint) > 0)) {
            if (G_IS_DIR_SEPARATOR(mountpoint[strlen(mountpoint) - 1])) {
                mountpoint[strlen(mountpoint) - 1] = 0;
            }
        }
        if (new_mount && (strlen(new_mount) > 0)) {
            if (G_IS_DIR_SEPARATOR(new_mount[strlen(new_mount) - 1])) {
                new_mount[strlen(new_mount) - 1] = 0;
            }
        }
        if (!(mountpoint && new_mount && (strcmp(mountpoint, new_mount) == 0))) { /* mountpoint has changed */
            g_free(mountpoint);
            mountpoint = new_mount;
            new_mount = NULL;
            set_itdb_prefs_string(itdb, KEY_MOUNTPOINT, mountpoint);
            call_script("gtkpod.load", mountpoint, NULL);
            itdb_set_mountpoint(itdb, mountpoint);
        }
        else {
            g_free(new_mount);
            new_mount = NULL;
        }

        g_return_val_if_fail(gtk_combo_box_get_active_iter(cb, &iter), FALSE);
        gtk_tree_model_get(gtk_combo_box_get_model(cb), &iter, COL_STRING, &model, -1);
        g_return_val_if_fail(model, FALSE);

        if ((strcmp(model, gettext(SELECT_OR_ENTER_YOUR_MODEL)) == 0) || (strlen(model) == 0)) { /* User didn't choose a model */
            g_free(model);
            model = NULL;
        }

        /* Set model in the prefs system */
        set_itdb_prefs_string(itdb, KEY_IPOD_MODEL, model);

        name = get_itdb_prefs_string(itdb, "name");
        result = itdb_init_ipod(mountpoint, model, name, &error);

        /* Set the model in the sysinfo of the itdb */
        itdb_device_set_sysinfo(itdb->device, "ModelNumStr", model);

        if (!result) {
            if (error) {
                gtkpod_warning(_("Error initialising iPod: %s\n"), error->message);
                g_error_free(error);
                error = NULL;
            }
            else {
                gtkpod_warning(_("Error initialising iPod, unknown error\n"));
            }
        }
        else {
            /* Should write the extended info file */
            result = gp_create_extended_info(itdb);
        }

        g_free(name);
        g_free(model);
        break;
    default:
        /* canceled -- do nothing */
        break;
    }

    gtk_widget_destroy(ii->window);

    g_free(mountpoint);

    g_free(ii);

    return result;
}
Exemple #18
0
/*****************************************************************************
 * run_session_save_as_dialog()
 *****************************************************************************/
void
run_session_save_as_dialog(GtkWidget *UNUSED(widget), gpointer data)
{
    SESSION         *session        = get_current_session();
    char            *directory      = (char *) data;
    char            *session_dir;
    DIR_LIST        *pdir           = session_dir_list;
    GError          *error;

    /* create dialog if needed */
    if (session_save_dialog == NULL) {
        create_session_save_dialog();
    }

    /* add all session dirs as shortcut folders */
    while (pdir != NULL) {
        if ((!pdir->save_shortcut)) {
            error = NULL;
            gtk_file_chooser_add_shortcut_folder(GTK_FILE_CHOOSER(session_save_dialog),
                                                 pdir->name, &error);
            if (error != NULL) {
                PHASEX_ERROR("Error %d: %s\n", error->code, error->message);
                g_error_free(error);
            }
            pdir->save_shortcut = 1;
        }
        pdir = pdir->next;
    }

    /* set filename and current directory */
    if ((directory == NULL) || (*directory == '\0')) {
        directory = session->directory;
    }

    /* if we have a directory, and it's not the sessiondump, set and select it */
    if ((directory != NULL) && (strcmp(directory, user_session_dump_dir) != 0)) {
        gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(session_save_dialog), directory);
    }

    /* if there is no filename, try to set the current directory */
    else if ((session->parent_dir != NULL) && (* (session->parent_dir) != '\0')) {
        gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(session_save_dialog),
                                            session->parent_dir);
    }
    else {
        gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(session_save_dialog),
                                            user_session_dir);
    }

    /* set position in session bank to save session */
    /* session_io_start should already be set properly at this point. */
    gtk_spin_button_set_value(GTK_SPIN_BUTTON(session_save_start_spin), (session_io_start + 1));

    /* run the dialog and save if necessary */
    if (gtk_dialog_run(GTK_DIALOG(session_save_dialog)) == GTK_RESPONSE_ACCEPT) {
        session_dir = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(session_save_dialog));

        session_io_start =
            (unsigned int) gtk_spin_button_get_value(GTK_SPIN_BUTTON(session_save_start_spin)) - 1;

        /* hide dialog and save session */
        gtk_widget_hide(session_save_dialog);
        switch (setting_bank_mem_mode) {
        case BANK_MEM_AUTOSAVE:
            /* save session without overwrite protection */
            if (save_session(session_dir, session_io_start) == 0) {
                update_gui_session_name();
                save_session_bank();
            }
            break;
        case BANK_MEM_WARN:
        case BANK_MEM_PROTECT:
            /* save session with overwrite protection */
            if (!check_session_overwrite(session_dir)) {
                if (save_session(session_dir, session_io_start) == 0) {
                    update_gui_session_name();
                    save_session_bank();
                }
            }
            break;
        }

        g_free(session_dir);
    }
    else {
        /* save this widget for next time */
        gtk_widget_hide(session_save_dialog);
    }
}
Exemple #19
0
char* get_save_filename( GtkWindow* parent, const char* cwd, char** type )
{
    char* file = NULL;
    GtkFileChooser* dlg = (GtkFileChooser*)gtk_file_chooser_dialog_new( NULL, parent,
            GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL,
            GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_OK, NULL );
    GSList* modules, *module;
    GtkFileFilter *filter;

    gtk_file_chooser_set_current_folder( dlg, cwd );

    GtkWidget* img = gtk_image_new();
    gtk_widget_set_size_request( img, 128, 128 );
    gtk_file_chooser_set_preview_widget( dlg, img );
    g_signal_connect( dlg, "update-preview", G_CALLBACK(on_update_preview), img );
    g_signal_connect( dlg, "notify::filter", G_CALLBACK(on_file_save_filter_changed), NULL );

    /*
    /// TODO: determine file type from file name
    filter = gtk_file_filter_new();
    gtk_file_filter_set_name( filter, _("Determined by File Name") );
    gtk_file_filter_add_pixbuf_formats( filter );
    gtk_file_chooser_add_filter( dlg, filter );
    */

    modules = gdk_pixbuf_get_formats();
    for( module = modules; module; module = module->next )
    {
        char *name, *desc, *tmp;
        char **exts, **mimes, **mime;

        GdkPixbufFormat* format = (GdkPixbufFormat*)module->data;
        if( ! gdk_pixbuf_format_is_writable( format ) )
            continue;

        filter = gtk_file_filter_new();

        name = gdk_pixbuf_format_get_name( format );
        desc = gdk_pixbuf_format_get_description( format );
        exts = gdk_pixbuf_format_get_extensions( format );
        mimes = gdk_pixbuf_format_get_mime_types( format );
        tmp = g_strdup_printf( "%s (*.%s)", desc, exts[0], NULL );

        g_object_set_data_full(G_OBJECT(filter), "type", name, (GDestroyNotify)g_free);
        g_strfreev(exts);
        g_free( desc );
        gtk_file_filter_set_name( filter, tmp );
        g_free( tmp );

        for( mime  = mimes; *mime ; ++mime )
            gtk_file_filter_add_mime_type( filter, *mime );
        g_strfreev( mimes );
        gtk_file_chooser_add_filter( dlg, filter );
    }
    g_slist_free( modules );

    int initial_jpg_quality = pref.jpg_quality;
    int initial_png_compression = pref.png_compression;

    if( gtk_dialog_run( (GtkDialog*)dlg ) == GTK_RESPONSE_OK )
    {
        filter = gtk_file_chooser_get_filter( dlg );
        file = gtk_file_chooser_get_filename( dlg );
        *type = g_object_steal_data(G_OBJECT(filter), "type");

        if( !*type )   // auto detection
        {
            /// TODO: auto file type
        }
        else
        {
            /* TODO: append appropriate extension if needed. */
        }
    }
    gtk_widget_destroy( (GtkWidget*)dlg );

    if ((initial_jpg_quality != pref.jpg_quality) || (initial_png_compression != pref.png_compression))
        save_preferences();

    return file;
}
GtkWindow* LLFilePickerBase::buildFilePicker(bool is_save, bool is_folder, std::string const& folder)
{
	if (LLWindowSDL::ll_try_gtk_init())
	{
		GtkWidget *win = NULL;
		GtkFileChooserAction pickertype =
			is_save?
			(is_folder?
			 GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER :
			 GTK_FILE_CHOOSER_ACTION_SAVE) :
			(is_folder?
			 GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER :
			 GTK_FILE_CHOOSER_ACTION_OPEN);

		win = gtk_file_chooser_dialog_new(NULL, NULL,
						  pickertype,
						  GTK_STOCK_CANCEL,
						   GTK_RESPONSE_CANCEL,
						  is_folder ?
						  GTK_STOCK_APPLY :
						  (is_save ? 
						   GTK_STOCK_SAVE :
						   GTK_STOCK_OPEN),
						   GTK_RESPONSE_ACCEPT,
						  (gchar *)NULL);

		if (!folder.empty())
		{
			PLS_DEBUGS << "Calling gtk_file_chooser_set_current_folder(\"" << folder << "\")." << PLS_ENDL;
			gtk_file_chooser_set_current_folder
				(GTK_FILE_CHOOSER(win),
				 folder.c_str());
		}

#  if LL_X11
		// Make GTK tell the window manager to associate this
		// dialog with our non-GTK raw X11 window, which should try
		// to keep it on top etc.
		if (mX11WindowID != None)
		{
			gtk_widget_realize(GTK_WIDGET(win)); // so we can get its gdkwin
			GdkWindow *gdkwin = gdk_window_foreign_new(mX11WindowID);
			gdk_window_set_transient_for(GTK_WIDGET(win)->window, gdkwin);
		}
#  endif //LL_X11

		g_signal_connect (GTK_FILE_CHOOSER(win),
				  "response",
				  G_CALLBACK(LLFilePickerBase::chooser_responder),
				  this);

		PLS_FLUSH;
		gtk_window_set_modal(GTK_WINDOW(win), TRUE);

		/* GTK 2.6: if (is_folder)
			gtk_file_chooser_set_show_hidden(GTK_FILE_CHOOSER(win),
			TRUE); */

		return GTK_WINDOW(win);
	}
	else
	{
		return NULL;
	}
}
Exemple #21
0
void ConfigurePlugins() {
	if (!UseGui) {
		/* How do we get here if we're not running the GUI? */
		/* Ryan: we're going to imagine that someday, there will be a way
		 * to configure plugins from the commandline */
		printf("ERROR: Plugins cannot be configured without the GUI.");
		return;
	}

	GtkWidget *widget;

	gchar *path;

	UpdatePluginsBIOS();

	builder = gtk_builder_new();
	if (!gtk_builder_add_from_resource(builder, "/org/pcsxr/gui/pcsxr.ui", NULL)) {
		g_warning("Error: interface could not be loaded!");
		return;
	}

	UpdatePluginsBIOS_UpdateGUI(builder);

	ConfDlg = GTK_WIDGET(gtk_builder_get_object(builder, "ConfDlg"));
	
	gtk_window_set_title(GTK_WINDOW(ConfDlg), _("Configure PCSXR"));
	gtk_widget_show (ConfDlg);

	/* Set the paths in the file choosers to be based on the saved configurations */
	widget = GTK_WIDGET(gtk_builder_get_object(builder, "GtkFileChooser_Bios"));
	gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (widget), Config.BiosDir);

	widget = GTK_WIDGET(gtk_builder_get_object(builder, "GtkFileChooser_Plugin"));
	gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (widget), Config.PluginsDir);

	if (strlen(Config.PluginsDir) == 0) {
		if((path = gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (widget))) != NULL) {
			strcpy(Config.PluginsDir, path);
			g_free(path);
		}
	}

	widget = GTK_WIDGET(gtk_builder_get_object(builder, "btn_ConfGpu"));
	g_signal_connect_data(G_OBJECT(widget), "clicked",
			G_CALLBACK(on_configure_plugin), GINT_TO_POINTER(PSE_LT_GPU), NULL, G_CONNECT_AFTER);

	widget = GTK_WIDGET(gtk_builder_get_object(builder, "btn_ConfSpu"));
	g_signal_connect_data(G_OBJECT(widget), "clicked",
			G_CALLBACK(on_configure_plugin), GINT_TO_POINTER(PSE_LT_SPU), NULL, G_CONNECT_AFTER);

	/* ADB TODO Does pad 1 and 2 need to be different? */
	widget = GTK_WIDGET(gtk_builder_get_object(builder, "btn_ConfPad1"));
	g_signal_connect_data(G_OBJECT(widget), "clicked",
						  G_CALLBACK(OnConfConf_Pad1Conf), builder, NULL, G_CONNECT_AFTER);

	widget = GTK_WIDGET(gtk_builder_get_object(builder, "btn_ConfPad2"));
	g_signal_connect_data(G_OBJECT(widget), "clicked",
			G_CALLBACK(OnConfConf_Pad2Conf), builder, NULL, G_CONNECT_AFTER);

	widget = GTK_WIDGET(gtk_builder_get_object(builder, "btn_ConfCdr"));
	g_signal_connect_data(G_OBJECT(widget), "clicked",
			G_CALLBACK(on_configure_plugin), GINT_TO_POINTER(PSE_LT_CDR), NULL, G_CONNECT_AFTER);
#ifdef ENABLE_SIO1API
	widget = GTK_WIDGET(gtk_builder_get_object(builder, "btn_ConfSio1"));
	g_signal_connect_data(G_OBJECT(widget), "clicked",
			G_CALLBACK(on_configure_plugin), (gpointer) PSE_LT_SIO1, NULL, G_CONNECT_AFTER);
#else
	widget = GTK_WIDGET(gtk_builder_get_object(builder, "label18"));
	gtk_widget_set_sensitive(widget, FALSE);
	widget = GTK_WIDGET(gtk_builder_get_object(builder, "GtkCombo_Sio1"));
	gtk_widget_set_sensitive(widget, FALSE);
	widget = GTK_WIDGET(gtk_builder_get_object(builder, "btn_ConfSio1"));
	gtk_widget_set_sensitive(widget, FALSE);
	widget = GTK_WIDGET(gtk_builder_get_object(builder, "btn_AboutSio1"));
	gtk_widget_set_sensitive(widget, FALSE);
#endif
	widget = GTK_WIDGET(gtk_builder_get_object(builder, "btn_AboutGpu"));
	g_signal_connect_data(G_OBJECT(widget), "clicked",
			G_CALLBACK(on_about_plugin), GINT_TO_POINTER(PSE_LT_GPU), NULL, G_CONNECT_AFTER);

	widget = GTK_WIDGET(gtk_builder_get_object(builder, "btn_AboutSpu"));
	g_signal_connect_data(G_OBJECT(widget), "clicked",
			G_CALLBACK(on_about_plugin), GINT_TO_POINTER(PSE_LT_SPU), NULL, G_CONNECT_AFTER);

	widget = GTK_WIDGET(gtk_builder_get_object(builder, "btn_AboutPad1"));
	g_signal_connect_data(G_OBJECT(widget), "clicked",
			G_CALLBACK(OnConfConf_Pad1About), builder, NULL, G_CONNECT_AFTER);

	widget = GTK_WIDGET(gtk_builder_get_object(builder, "btn_AboutPad2"));
	g_signal_connect_data(G_OBJECT(widget), "clicked",
			G_CALLBACK(OnConfConf_Pad2About), builder, NULL, G_CONNECT_AFTER);

	widget = GTK_WIDGET(gtk_builder_get_object(builder, "btn_AboutCdr"));
	g_signal_connect_data(G_OBJECT(widget), "clicked",
			G_CALLBACK(on_about_plugin), GINT_TO_POINTER(PSE_LT_CDR), NULL, G_CONNECT_AFTER);
#ifdef ENABLE_SIO1API
	widget = GTK_WIDGET(gtk_builder_get_object(builder, "btn_AboutSio1"));
	g_signal_connect_data(G_OBJECT(widget), "clicked",
			G_CALLBACK(on_about_plugin), (gpointer) PSE_LT_SIO1, NULL, G_CONNECT_AFTER);
#endif
	widget = GTK_WIDGET(gtk_builder_get_object(builder, "GtkFileChooser_Bios"));
	g_signal_connect_data(G_OBJECT(widget), "current_folder_changed",
			G_CALLBACK(OnBiosPath_Changed), builder, NULL, G_CONNECT_AFTER);

	widget = GTK_WIDGET(gtk_builder_get_object(builder, "GtkFileChooser_Plugin"));
	g_signal_connect_data(G_OBJECT(widget), "current_folder_changed",
			G_CALLBACK(OnPluginPath_Changed), builder, NULL, G_CONNECT_AFTER);

	g_signal_connect_data(G_OBJECT(ConfDlg), "response",
			G_CALLBACK(OnConf_Clicked), builder, (GClosureNotify)g_object_unref, G_CONNECT_AFTER);
}
Exemple #22
0
/*!
  \brief pops up a Filechooser dialog to select a file
  \param data is a pointer to a MtxFileIO structure which contains important
  bits like the path to start, the filter, default filename and so on
  \see MtxFileIO
  \returns the path to the file or NULL if cancelled
  */
gchar * choose_file(MtxFileIO *data)
{
	GtkWidget *dialog = NULL;
	GtkFileFilter *filter = NULL;
	GSList *filters = NULL;
	gchar *path = NULL;
	gchar *defdir = NULL;
	gchar *filename = NULL;
	gchar *tmpbuf = NULL;
	gchar **vector = NULL;
	const gchar *project = NULL;
	gint response = 0;
	gboolean res = FALSE;
	guint i = 0;

	ENTER();
	if (!GTK_IS_WINDOW(data->parent))
		data->parent = NULL;
	/*
	printf("choose_file\n");
	printf("parent %p\n",(void *)data->parent);
	printf("on_top %s\n",data->on_top? "TRUE":"FALSE");
	printf("filter %s\n",data->filter);
	printf("filename %s\n",data->filename);
	printf("default_filename %s\n",data->default_filename);
	printf("default_extension %s\n",data->default_extension);
	printf("absolute_path %s\n",data->absolute_path);
	printf("default_path %s\n",data->default_path);
	printf("external_path %s\n",data->external_path);
	printf("shortcut_folders %s\n",data->shortcut_folders);
	printf("project %s\n",data->project);
	printf("title %s\n",data->title);
	*/
	if (data->project)
		project = data->project;
	else
		project = DEFAULT_PROJECT;

	if (!data->title)
		data->title = g_strdup("Open File");

	if ((data->action == GTK_FILE_CHOOSER_ACTION_OPEN) || 
			(data->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER))
	{
		/*printf("ACTION_OPEN before gtk_file_chooser_dialog_new\n");*/
		dialog = gtk_file_chooser_dialog_new(data->title,
				/*GTK_WINDOW(data->parent), */
				0,
				data->action,
				GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
				GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
				NULL);
		/*printf("after gtk_file_chooser_dialog_new\n");*/
		if ((data->on_top) && (GTK_IS_WIDGET(data->parent)))
			gtk_window_set_transient_for(GTK_WINDOW(gtk_widget_get_toplevel(dialog)),GTK_WINDOW(data->parent));

		if ((data->absolute_path) && (!data->default_path))
			gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER(dialog),data->absolute_path);
		else if (data->default_path)
		{
			/*printf("should be using system path + %s\n",data->default_path);*/
			path = g_build_filename(MTXSYSDATA,data->default_path,NULL);
			if (!g_file_test(path,G_FILE_TEST_IS_DIR))
			{
				g_free(path);
				path = g_build_filename(HOME(),"mtx",data->project,data->default_path, NULL);
				/*printf("System path is not found, falling back to user path %s\n",path);*/
			}
			gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER(dialog),path);
			g_free(path);
		}
	}
	else if (data->action == GTK_FILE_CHOOSER_ACTION_SAVE)
	{
		/*printf("ACTION_SAVE calling gtk_file_chooser_dialog_new\n");*/
		dialog = gtk_file_chooser_dialog_new(data->title,
				/*GTK_WINDOW(data->parent), */
				0,
				data->action,
				GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
				GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
				NULL);	
		/*printf("after gtk_file_chooser_dialog_new\n");*/

		/*		if ((data->on_top) && (GTK_IS_WIDGET(data->parent)))
					gtk_window_set_transient_for(GTK_WINDOW(gtk_widget_get_toplevel(dialog)),GTK_WINDOW(data->parent));
		*/

		if (data->default_path)
		{
			defdir = g_build_filename(HOME(),"mtx",data->project,data->default_path, NULL);
			if (!g_file_test(defdir,G_FILE_TEST_IS_DIR))
				g_mkdir(defdir,0755);
		}
		else
			defdir = g_build_filename(HOME(),"mtx",data->project, NULL);
		/* If filename passed check/adj path  */
		if (data->filename)
		{
			if (g_strrstr(data->filename,DATA_DIR) != NULL)
			{
				vector = g_strsplit(data->filename,PSEP,-1);
				tmpbuf = g_strconcat(defdir,PSEP,vector[g_strv_length(vector)-1],NULL);
				gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog),defdir);
				gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog),vector[g_strv_length(vector)-1]);
				g_strfreev(vector);
				g_free(tmpbuf);
			}
			else
				gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog),data->filename);
		}
		else
		{
			gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog),defdir);
			gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog), data->default_filename );
		}
		g_free(defdir);

	}
	else
	{
		EXIT();
		return NULL;
	}
	/* Add shortcut folders...  */
	if (data->shortcut_folders)
	{
		vector = g_strsplit(data->shortcut_folders,",",-1);
		for (i=0;i<g_strv_length(vector);i++)
		{
			path = g_build_filename(MTXSYSDATA,vector[i],NULL);
			gtk_file_chooser_add_shortcut_folder(GTK_FILE_CHOOSER(dialog),path,NULL);
			g_free(path);
			path = g_build_filename(HOME(),"mtx",data->project,vector[i],NULL);
			gtk_file_chooser_add_shortcut_folder(GTK_FILE_CHOOSER(dialog),path,NULL);
			g_free(path);
		}
		g_strfreev(vector);
	}
	
	/* If default path switch to that place  */
	if ((data->external_path) && (!(data->default_path)))
	{
		/*printf("external path with no default path\n");*/
		path = g_build_filename(HOME(),"mtx",data->project,data->external_path,NULL);
		if (!g_file_test(path,G_FILE_TEST_IS_DIR))
			g_mkdir(path,0755);
		gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER(dialog),path);
		g_free(path);

	}

	/* If filters, assign them 
	  CAUSES SEGFAULTS???
	  */
	/*
	if (data->filter)
	{
		printf("data->filter is set to \"%s\"\n",data->filter);
		vector = g_strsplit(data->filter,",",-1);
		if (g_strv_length(vector)%2 > 0)
			goto afterfilter;
		for (i=0;i<g_strv_length(vector);i+=2)
		{
			filter = gtk_file_filter_new();
			gtk_file_filter_add_pattern(GTK_FILE_FILTER(filter),vector[i]);
			printf("Filter glob is set to \"%s\"\n",vector[i]);
			gtk_file_filter_set_name(GTK_FILE_FILTER(filter),vector[i+1]);
			printf("Filter name is set to \"%s\"\n",vector[i+1]);
			gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog),filter);
		}
		gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog),filter);
		g_strfreev(vector);
	}
	*/
afterfilter:
	/* Turn on overwriteconfirmation  */
	gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE);
	g_signal_connect(G_OBJECT(dialog),"confirm-overwrite",
			G_CALLBACK (confirm_overwrite_callback), NULL);
	if (data->action == GTK_FILE_CHOOSER_ACTION_OPEN)
	{
		if (data->default_filename)
		{
			/*printf("data->default_filename is set to \"%s\"\n",data->default_filename);*/
			gtk_file_chooser_select_filename(GTK_FILE_CHOOSER(dialog),data->default_filename);
		}
	}

	/*printf("initiating dialog to run\n");*/
	response = gtk_dialog_run (GTK_DIALOG (dialog));
	/*printf("it returned \n");*/
	if (response == GTK_RESPONSE_ACCEPT)
	{
		tmpbuf = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
		if ((data->action == GTK_FILE_CHOOSER_ACTION_SAVE) && (data->default_extension))
		{
			if(!g_str_has_suffix (tmpbuf,data->default_extension))
				filename = g_strjoin(".",tmpbuf,data->default_extension,NULL);
			else
				filename = g_strdup(tmpbuf);
		}
		else
			filename = g_strdup(tmpbuf);
		g_free(tmpbuf);
	}
	filters = gtk_file_chooser_list_filters(GTK_FILE_CHOOSER(dialog));
	if (filters)
	{
		g_slist_foreach(filters, remove_filter ,dialog);
		g_slist_free(filters);
	}

	gtk_widget_destroy (dialog);
	EXIT();
	return (filename);
}
Exemple #23
0
GtkWidget*
gtr_torrent_options_dialog_new( GtkWindow * parent, TrCore * core, tr_ctor * ctor )
{
    int              row;
    int              col;
    const char *     str;
    GtkWidget *      w;
    GtkWidget *      d;
    GtkWidget *      t;
    GtkWidget *      l;
    GtkWidget *      grab;
    GtkWidget *      source_chooser;
    struct OpenData * data;
    uint8_t          flag;
    GSList *         list;
    GSList *         walk;

    /* make the dialog */
    d = gtk_dialog_new_with_buttons( _( "Torrent Options" ), parent,
                                     GTK_DIALOG_DESTROY_WITH_PARENT,
                                     NULL );
    gtk_dialog_add_button( GTK_DIALOG( d ), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL );
    grab = gtk_dialog_add_button( GTK_DIALOG( d ), GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT );
    gtk_dialog_set_default_response( GTK_DIALOG( d ),
                                     GTK_RESPONSE_ACCEPT );
    gtk_dialog_set_alternative_button_order( GTK_DIALOG( d ),
                                             GTK_RESPONSE_ACCEPT,
                                             GTK_RESPONSE_CANCEL,
                                             -1 );

    if( tr_ctorGetDownloadDir( ctor, TR_FORCE, &str ) )
        g_assert_not_reached( );
    g_assert( str );

    data = g_new0( struct OpenData, 1 );
    data->core = core;
    data->ctor = ctor;
    data->filename = g_strdup( tr_ctorGetSourceFile( ctor ) );
    data->downloadDir = g_strdup( str );
    data->file_list = gtr_file_list_new( core, 0 );
    str = _( "Mo_ve .torrent file to the trash" );
    data->trash_check = gtk_check_button_new_with_mnemonic( str );
    str = _( "_Start when added" );
    data->run_check = gtk_check_button_new_with_mnemonic( str );

    w = data->priority_combo = gtr_priority_combo_new( );
    gtr_priority_combo_set_value( GTK_COMBO_BOX( w ), TR_PRI_NORMAL );

    g_signal_connect( G_OBJECT( d ), "response",
                      G_CALLBACK( addResponseCB ), data );

    t = gtk_table_new( 6, 2, FALSE );
    gtk_container_set_border_width( GTK_CONTAINER( t ), GUI_PAD_BIG );
    gtk_table_set_row_spacings( GTK_TABLE( t ), GUI_PAD );
    gtk_table_set_col_spacings( GTK_TABLE( t ), GUI_PAD_BIG );

    row = col = 0;
    l = gtk_label_new_with_mnemonic( _( "_Torrent file:" ) );
    gtk_misc_set_alignment( GTK_MISC( l ), 0.0f, 0.5f );
    gtk_table_attach( GTK_TABLE( t ), l, col, col + 1, row, row + 1, GTK_FILL, 0, 0, 0 );
    ++col;
    w = gtk_file_chooser_button_new( _( "Select Source File" ),
                                     GTK_FILE_CHOOSER_ACTION_OPEN );
    source_chooser = w;
    gtk_table_attach( GTK_TABLE( t ), w, col, col + 1, row, row + 1, ~0, 0, 0, 0 );
    gtk_label_set_mnemonic_widget( GTK_LABEL( l ), w );
    addTorrentFilters( GTK_FILE_CHOOSER( w ) );
    g_signal_connect( w, "selection-changed",
                      G_CALLBACK( sourceChanged ), data );

    ++row;
    col = 0;
    l = gtk_label_new_with_mnemonic( _( "_Destination folder:" ) );
    gtk_misc_set_alignment( GTK_MISC( l ), 0.0f, 0.5f );
    gtk_table_attach( GTK_TABLE( t ), l, col, col + 1, row, row + 1, GTK_FILL, 0, 0, 0 );
    ++col;
    w = gtk_file_chooser_button_new( _( "Select Destination Folder" ),
                                     GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER );
    if( !gtk_file_chooser_set_current_folder( GTK_FILE_CHOOSER( w ),
                                              data->downloadDir ) )
        g_warning( "couldn't select '%s'", data->downloadDir );
    list = get_recent_destinations( );
    for( walk = list; walk; walk = walk->next )
        gtk_file_chooser_add_shortcut_folder( GTK_FILE_CHOOSER( w ), walk->data, NULL );
    g_slist_free( list );
    gtk_table_attach( GTK_TABLE( t ), w, col, col + 1, row, row + 1, ~0, 0, 0, 0 );
    gtk_label_set_mnemonic_widget( GTK_LABEL( l ), w );
    g_signal_connect( w, "selection-changed",
                      G_CALLBACK( downloadDirChanged ), data );

    ++row;
    col = 0;
    w = data->file_list;
    gtk_widget_set_size_request ( w, 466u, 300u );
    gtk_table_attach_defaults( GTK_TABLE( t ), w, col, col + 2, row, row + 1 );

    ++row;
    col = 0;
    w = gtk_label_new_with_mnemonic( _( "Torrent _priority:" ) );
    gtk_misc_set_alignment( GTK_MISC( w ), 0.0f, 0.5f );
    gtk_table_attach( GTK_TABLE( t ), w, col, col + 1, row, row + 1, ~0, 0, 0, 0 );
    ++col;
    gtk_table_attach( GTK_TABLE( t ), data->priority_combo, col, col + 1, row, row + 1, ~0, 0, 0, 0 );
    gtk_label_set_mnemonic_widget( GTK_LABEL( w ), data->priority_combo );

    ++row;
    col = 0;
    w = data->run_check;
    if( tr_ctorGetPaused( ctor, TR_FORCE, &flag ) )
        g_assert_not_reached( );
    gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( w ), !flag );
    gtk_table_attach( GTK_TABLE( t ), w, col, col + 2, row, row + 1, GTK_FILL, 0, 0, 0 );

    ++row;
    col = 0;
    w = data->trash_check;
    if( tr_ctorGetDeleteSource( ctor, &flag ) )
        g_assert_not_reached( );
    gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( w ), flag );
    gtk_table_attach( GTK_TABLE( t ), w, col, col + 2, row, row + 1, GTK_FILL, 0, 0, 0 );

    /* trigger sourceChanged, either directly or indirectly,
     * so that it creates the tor/gtor objects */
    w = source_chooser;
    if( data->filename )
        gtk_file_chooser_set_filename( GTK_FILE_CHOOSER( w ), data->filename );
    else
        sourceChanged( GTK_FILE_CHOOSER_BUTTON( w ), data );

    gtr_dialog_set_content( GTK_DIALOG( d ), t );
    gtk_widget_grab_focus( grab );
    return d;
}
NedMidiImportDialog::NedMidiImportDialog(GtkWindow *parent, char **folder, char **filename) : m_with_triplets(true),
	m_tempo_change_density(20), m_volume_change_density(20), m_last_folder(folder), m_filename(filename) {
	GtkWidget *dialog;
	GtkWidget *tempo_sensity_frame;
	GtkWidget *volume_sensity_frame;

	GtkWidget *main_vbox;

	GtkWidget *main_hbox;
	GtkWidget *left_vbox;
	GtkWidget *right_vbox;

	dialog = gtk_dialog_new_with_buttons(_("MIDI import"), parent, (GtkDialogFlags) (GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT),
		GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL);

	g_signal_connect(dialog, "response", G_CALLBACK (OnClose), (void *) this);

	m_file_chooser = gtk_file_chooser_widget_new(GTK_FILE_CHOOSER_ACTION_OPEN);
	if (*m_last_folder != NULL) {
		gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(m_file_chooser), *m_last_folder);
	}
	if (*m_filename != NULL) {
		gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(m_file_chooser), *m_filename);
	}
	GtkFileFilter *file_filter1 = gtk_file_filter_new();
	gtk_file_filter_set_name(file_filter1, ".mid,.midi (MIDI-Files)");
	gtk_file_filter_add_pattern(file_filter1, "*.mid");
	gtk_file_filter_add_pattern(file_filter1, "*.midi");

	GtkFileFilter *file_filter2 = gtk_file_filter_new();
	gtk_file_filter_set_name(file_filter2, "* (All Files)");
	gtk_file_filter_add_pattern(file_filter2, "*");

	gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(m_file_chooser), file_filter1);
	gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(m_file_chooser), file_filter2);

	left_vbox = gtk_vbox_new(FALSE, 2);
	right_vbox = gtk_vbox_new(FALSE, 2);

	m_with_triplet_button = gtk_toggle_button_new_with_label(_("triplet recognition"));
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_with_triplet_button), TRUE);
	m_sort_instruments_button = gtk_toggle_button_new_with_label(_("sort instruments"));
	m_force_piano_button = gtk_toggle_button_new_with_label(_("force piano"));
	m_dont_split_button = gtk_toggle_button_new_with_label(_("don't split tracks"));
	g_signal_connect(m_force_piano_button, "toggled", G_CALLBACK (OnPianoForcePressed), (void *) this);
	g_signal_connect(m_dont_split_button, "toggled", G_CALLBACK (OnDontSplitPressed), (void *) this);

	gtk_container_add (GTK_CONTAINER(left_vbox), m_with_triplet_button);
	gtk_container_add (GTK_CONTAINER(left_vbox), m_sort_instruments_button);
	gtk_container_add (GTK_CONTAINER(left_vbox), m_force_piano_button);
	gtk_container_add (GTK_CONTAINER(left_vbox), m_dont_split_button);

	tempo_sensity_frame = gtk_frame_new(_("tempo density"));

	m_tempo_change_density_scale = gtk_hscale_new_with_range(0.0, 100.0, 1.0);
	gtk_range_set_value(GTK_RANGE(m_tempo_change_density_scale), 20.0);
	gtk_container_add (GTK_CONTAINER(tempo_sensity_frame), m_tempo_change_density_scale);

	volume_sensity_frame = gtk_frame_new(_("volume density"));

	m_volume_change_density_scale = gtk_hscale_new_with_range(0.0, 100.0, 1.0);
	gtk_range_set_value(GTK_RANGE(m_volume_change_density_scale), 20.0);
	gtk_container_add (GTK_CONTAINER(volume_sensity_frame), m_volume_change_density_scale);


	gtk_box_pack_start(GTK_BOX(right_vbox), tempo_sensity_frame, FALSE, TRUE, 0);
	gtk_box_pack_start(GTK_BOX(right_vbox), volume_sensity_frame, FALSE, TRUE, 0);

	main_hbox = gtk_hbox_new(FALSE, 2);

	gtk_box_pack_start(GTK_BOX(main_hbox), left_vbox, TRUE, TRUE, 0);
	gtk_box_pack_start(GTK_BOX(main_hbox), right_vbox, TRUE, TRUE, 0);

	main_vbox = gtk_vbox_new(FALSE, 2);

	gtk_box_pack_start (GTK_BOX(main_vbox), main_hbox, FALSE, FALSE, 0);
	gtk_box_pack_start (GTK_BOX(main_vbox), m_file_chooser, TRUE, TRUE, 0);

	gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox), main_vbox);
	gtk_window_set_default_size (GTK_WINDOW (dialog), MIDIIMPORT_DIALOG_WIDTH, MIDIIMPORT_DIALOG_HEIGHT);
	gtk_widget_show_all (dialog);
	gtk_dialog_run(GTK_DIALOG(dialog));

}
Exemple #25
0
static int gtkFileDlgPopup(Ihandle* ih, int x, int y)
{
  InativeHandle* parent = iupDialogGetNativeParent(ih);
  GtkWidget* dialog;
  GtkWidget* preview_canvas = NULL;
  GtkFileChooserAction action;
  IFnss file_cb;
  char* value;
  int response, filter_count = 0;

  iupAttribSetInt(ih, "_IUPDLG_X", x);   /* used in iupDialogUpdatePosition */
  iupAttribSetInt(ih, "_IUPDLG_Y", y);

  value = iupAttribGetStr(ih, "DIALOGTYPE");
  if (iupStrEqualNoCase(value, "SAVE"))
    action = GTK_FILE_CHOOSER_ACTION_SAVE;
  else if (iupStrEqualNoCase(value, "DIR"))
    action = GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER;
  else
    action = GTK_FILE_CHOOSER_ACTION_OPEN;

  value = iupAttribGet(ih, "TITLE");
  if (!value)
  {
    GtkStockItem item;

    if (action == GTK_FILE_CHOOSER_ACTION_SAVE)
      value = GTK_STOCK_SAVE_AS;
    else
      value = GTK_STOCK_OPEN;

    gtk_stock_lookup(value, &item);
    value = item.label;

    iupAttribStoreStr(ih, "TITLE", iupgtkStrConvertFromUTF8(value));
    value = iupAttribGet(ih, "TITLE");
    iupStrRemoveChar(value, '_');
  }

  dialog = gtk_file_chooser_dialog_new(iupgtkStrConvertToUTF8(value), (GtkWindow*)parent, action, 
                                       GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, 
                                       NULL);
  if (!dialog)
    return IUP_ERROR;

  if (action == GTK_FILE_CHOOSER_ACTION_SAVE)
    gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_SAVE, GTK_RESPONSE_OK);
  else if (action == GTK_FILE_CHOOSER_ACTION_OPEN)
    gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_OPEN, GTK_RESPONSE_OK);
  else
    gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_OK, GTK_RESPONSE_OK);

  if (IupGetCallback(ih, "HELP_CB"))
    gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_HELP, GTK_RESPONSE_HELP);

#if GTK_CHECK_VERSION(2, 6, 0)
  if (iupAttribGetBoolean(ih, "SHOWHIDDEN"))
    gtk_file_chooser_set_show_hidden(GTK_FILE_CHOOSER(dialog), TRUE);
#endif

  if (iupAttribGetBoolean(ih, "MULTIPLEFILES") && action == GTK_FILE_CHOOSER_ACTION_OPEN)
    gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dialog), TRUE);

#if GTK_CHECK_VERSION(2, 8, 0)
  if (!iupAttribGetBoolean(ih, "NOOVERWRITEPROMPT") && action == GTK_FILE_CHOOSER_ACTION_SAVE)
    gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(dialog), TRUE);
#endif

  /* just check for the path inside FILE */
  value = iupAttribGet(ih, "FILE");
  if (value && (value[0] == '/' || value[1] == ':'))
  {
    char* dir = iupStrFileGetPath(value);
    int len = strlen(dir);
    iupAttribStoreStr(ih, "DIRECTORY", dir);
    free(dir);
    iupAttribStoreStr(ih, "FILE", value+len);
  }

  value = iupAttribGet(ih, "DIRECTORY");
  if (value)
    gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), iupgtkStrConvertToFilename(value));

  value = iupAttribGet(ih, "FILE");
  if (value)
  {
    if (action == GTK_FILE_CHOOSER_ACTION_SAVE)
      gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), iupgtkStrConvertToFilename(value));
    else
    {
      if (iupdrvIsFile(value))  /* check if file exists */
        gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog), iupgtkStrConvertToFilename(value));
    }
  }

  value = iupAttribGet(ih, "EXTFILTER");
  if (value)
  {
    char *name, *pattern, *filters = iupStrDup(value), *p;
    char atrib[30];
    int i;
    int filter_index = iupAttribGetInt(ih, "FILTERUSED");
    if (!filter_index)
      filter_index = 1;

    filter_count = iupStrReplace(filters, '|', 0) / 2;

    p = filters;
    for (i=0; i<filter_count; i++)
    {
      GtkFileFilter *filter = gtk_file_filter_new();

      gtkFileDlgGetNextFilter(&p, &name, &pattern);

      gtk_file_filter_set_name(filter, iupgtkStrConvertToUTF8(name));
      gtk_file_filter_add_pattern(filter, pattern);
      gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filter);

      sprintf(atrib, "_IUPDLG_FILTER%d", i+1);
      iupAttribSetStr(ih, atrib, (char*)filter);

      if (i+1 == filter_index)
        gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog), filter);
    }

    free(filters);
  }
  else 
  {
    value = iupAttribGet(ih, "FILTER");
    if (value)
    {
      GtkFileFilter *filter = gtk_file_filter_new();
      char* info = iupAttribGet(ih, "FILTERINFO");
      if (!info)
        info = value;

      gtk_file_filter_set_name(filter, iupgtkStrConvertToUTF8(info));
      gtk_file_filter_add_pattern(filter, value);
      gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filter);
    }
  }

  file_cb = (IFnss)IupGetCallback(ih, "FILE_CB");
  if (file_cb && action != GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER)
  {
    g_signal_connect(GTK_FILE_CHOOSER(dialog), "update-preview", G_CALLBACK(gtkFileDlgUpdatePreview), ih);
    g_signal_connect(dialog, "realize", G_CALLBACK(gtkFileDlgRealize), ih);

    if (iupAttribGetBoolean(ih, "SHOWPREVIEW"))
    {
      GtkWidget* frame = gtk_frame_new(NULL);
      gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_ETCHED_IN);
      gtk_widget_set_size_request(frame, 180, 150);

      preview_canvas = gtk_drawing_area_new();
      gtk_widget_set_double_buffered(preview_canvas, FALSE);
      gtk_container_add(GTK_CONTAINER(frame), preview_canvas);
      gtk_widget_show(preview_canvas);

      g_signal_connect(preview_canvas, "configure-event", G_CALLBACK(gtkFileDlgPreviewConfigureEvent), ih);
      g_signal_connect(preview_canvas, "expose-event", G_CALLBACK(gtkFileDlgPreviewExposeEvent), ih);
      g_signal_connect(preview_canvas, "realize", G_CALLBACK(gtkFileDlgPreviewRealize), ih);

      iupAttribSetStr(ih, "_IUPDLG_FILE_CHOOSER", (char*)dialog);

      gtk_file_chooser_set_preview_widget(GTK_FILE_CHOOSER(dialog), frame);
    }
  }
  
  /* initialize the widget */
  gtk_widget_realize(GTK_WIDGET(dialog));
  
  ih->handle = GTK_WIDGET(dialog);
  iupDialogUpdatePosition(ih);
  ih->handle = NULL;  /* reset handle */

  do 
  {
    response = gtk_dialog_run(GTK_DIALOG(dialog));

    if (response == GTK_RESPONSE_HELP)
    {
      Icallback cb = IupGetCallback(ih, "HELP_CB");
      if (cb && cb(ih) == IUP_CLOSE)
        response = GTK_RESPONSE_CANCEL;
    }
    else if (response == GTK_RESPONSE_OK)
    {
      char *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
      int file_exist = iupdrvIsFile(filename);
      int dir_exist = iupdrvIsDirectory(filename);
      g_free(filename);

      if (action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER)
      {
        if (!dir_exist)
        {
          iupStrMessageShowError(ih, "IUP_INVALIDDIR");
          response = GTK_RESPONSE_HELP; /* to leave the dialog open */
          continue;
        }
      }
      else if (!iupAttribGetBoolean(ih, "MULTIPLEFILES"))
      {
        if (dir_exist)
        {
          iupStrMessageShowError(ih, "IUP_FILEISDIR");
          response = GTK_RESPONSE_HELP; /* to leave the dialog open */
          continue;
        }

        if (!file_exist)  /* if do not exist check ALLOWNEW */
        {
          value = iupAttribGet(ih, "ALLOWNEW");
          if (!value)
          {
            if (action == GTK_FILE_CHOOSER_ACTION_SAVE)
              value = "YES";
            else
              value = "NO";
          }

          if (!iupStrBoolean(value))
          {
            iupStrMessageShowError(ih, "IUP_FILENOTEXIST");
            response = GTK_RESPONSE_HELP; /* to leave the dialog open */
            continue;
          }
        }

        if (file_cb)
        {
          char *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
          int ret = file_cb(ih, iupgtkStrConvertFromFilename(filename), "OK");
          g_free(filename);
          
          if (ret == IUP_IGNORE)
          {
            response = GTK_RESPONSE_HELP; /* to leave the dialog open */
            continue;
          }
        }
      }
    }
  } while (response == GTK_RESPONSE_HELP);

  if (file_cb)
  {
    if (iupAttribGetBoolean(ih, "SHOWPREVIEW"))
      iupgtkReleaseNativeGraphicsContext(preview_canvas, (void*)iupAttribGet(ih, "PREVIEWDC"));

    file_cb(ih, NULL, "FINISH");
  }

  if (response == GTK_RESPONSE_OK)
  {
    int file_exist, dir_exist;

    if (filter_count)
    {
      int i;
      char atrib[30];
      GtkFileFilter* filter = gtk_file_chooser_get_filter(GTK_FILE_CHOOSER(dialog));

      for (i=0; i<filter_count; i++)
      {
        sprintf(atrib, "_IUPDLG_FILTER%d", i+1);
        if (filter == (GtkFileFilter*)iupAttribGet(ih, atrib))
          iupAttribSetInt(ih, "FILTERUSED", i+1);
      }
    }

    if (iupAttribGetBoolean(ih, "MULTIPLEFILES"))
    {
      GSList* file_list = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(dialog));

      if (file_list->next) /* if more than one file */
        gtkFileDlgGetMultipleFiles(ih, file_list);
      else
      {
        char* filename = (char*)file_list->data;
        iupAttribStoreStr(ih, "VALUE", iupgtkStrConvertFromFilename(filename));
        g_free(filename);

        /* store the DIRECTORY */
        {
          char* dir = iupStrFileGetPath(iupAttribGet(ih, "VALUE"));
          iupAttribStoreStr(ih, "DIRECTORY", dir);
          free(dir);
        }
      }

      g_slist_free(file_list);
      file_exist = 1;
      dir_exist = 0;
    }
    else
    {
      char *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
      iupAttribStoreStr(ih, "VALUE", iupgtkStrConvertFromFilename(filename));
      file_exist = iupdrvIsFile(filename);
      dir_exist = iupdrvIsDirectory(filename);

      if (file_exist)
      {
        char* dir = iupStrFileGetPath(filename);
        iupAttribStoreStr(ih, "DIRECTORY", dir);
        free(dir);
      }

      g_free(filename);
    }

    if (dir_exist)
    {
      iupAttribSetStr(ih, "FILEEXIST", NULL);
      iupAttribSetStr(ih, "STATUS", "0");
    }
    else
    {
      if (file_exist)  /* check if file exists */
      {
        iupAttribSetStr(ih, "FILEEXIST", "YES");
        iupAttribSetStr(ih, "STATUS", "0");
      }
      else
      {
        iupAttribSetStr(ih, "FILEEXIST", "NO");
        iupAttribSetStr(ih, "STATUS", "1");
      }
    }

    if (action != GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER && !iupAttribGetBoolean(ih, "NOCHANGEDIR"))  /* do change the current directory */
    {
      /* GtkFileChooser does not change the current directory */
      char* dir = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(dialog));
      if (dir) 
      {
        iupdrvSetCurrentDirectory(dir);
        g_free(dir);
      }
    }
  }
  else
  {
    iupAttribSetStr(ih, "FILTERUSED", NULL);
    iupAttribSetStr(ih, "VALUE", NULL);
    iupAttribSetStr(ih, "FILEEXIST", NULL);
    iupAttribSetStr(ih, "STATUS", "-1");
  }

  gtk_widget_destroy(GTK_WIDGET(dialog));  

  return IUP_NOERROR;
}
Exemple #26
0
static void
_lib_geotagging_gpx_callback(GtkWidget *widget, dt_lib_module_t *self)
{
  dt_lib_geotagging_t *d = (dt_lib_geotagging_t*)self->data;
  /* bring a filechooser to select the gpx file to apply to selection */
  GtkWidget *win = dt_ui_main_window(darktable.gui->ui);
  GtkWidget *filechooser = gtk_file_chooser_dialog_new(_("open GPX file"),
                           GTK_WINDOW (win),
                           GTK_FILE_CHOOSER_ACTION_OPEN,
                           GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
                           GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
                           (char *)NULL);

  char *last_directory = dt_conf_get_string("ui_last/gpx_last_directory");
  if(last_directory != NULL)
    gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER (filechooser), last_directory);

  GtkFileFilter *filter;
  filter = GTK_FILE_FILTER(gtk_file_filter_new());
  gtk_file_filter_add_pattern(filter, "*.gpx");
  gtk_file_filter_set_name(filter, _("GPS data exchange format"));
  gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(filechooser), filter);

  filter = GTK_FILE_FILTER(gtk_file_filter_new());
  gtk_file_filter_add_pattern(filter, "*");
  gtk_file_filter_set_name(filter, _("all files"));
  gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(filechooser), filter);

  // add time zone selection
  GtkWidget *extra_box = gtk_hbox_new(FALSE, 5);
  GtkWidget *label = gtk_label_new(_("camera time zone"));
  g_object_set(G_OBJECT(label), "tooltip-text", _("most cameras don't store the time zone in EXIF. give the correct time zone so the GPX data can be correctly matched"), (char *)NULL);
  GtkWidget *tz_selection = gtk_combo_box_text_new();
  gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(tz_selection), "UTC");
  gtk_combo_box_set_active(GTK_COMBO_BOX(tz_selection), 0);

  GList *iter = d->timezones;
  int i = 0;
  gchar *old_tz= dt_conf_get_string("plugins/lighttable/geotagging/tz");
  if(iter)
  {
    do
    {
      i++;
      gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(tz_selection), (gchar*)iter->data);
      if(!strcmp((gchar*)iter->data, old_tz))
        gtk_combo_box_set_active(GTK_COMBO_BOX(tz_selection), i);
    }
    while( (iter = g_list_next(iter)) != NULL);
  }

  gtk_box_pack_start(GTK_BOX(extra_box), label, FALSE, FALSE, 0);
  gtk_box_pack_start(GTK_BOX(extra_box), tz_selection, FALSE, FALSE, 0);
  gtk_widget_show_all(extra_box);
  gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(filechooser), extra_box);

  if(gtk_dialog_run(GTK_DIALOG (filechooser)) == GTK_RESPONSE_ACCEPT)
  {
    dt_conf_set_string("ui_last/gpx_last_directory", gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER (filechooser)));
    gchar *tz = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(tz_selection));
    dt_conf_set_string("plugins/lighttable/geotagging/tz", tz);
    gchar *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER (filechooser));
    dt_control_gpx_apply(filename, -1, tz);
    g_free(filename);
    g_free(tz);
  }

  gtk_widget_destroy(extra_box);
  gtk_widget_destroy(filechooser);
//   dt_control_queue_redraw_center();
}
Exemple #27
0
/* Caller must g_slist_free() the returned list .*/
GSList *
ghid_dialog_file_select_multiple(gchar * title, gchar ** path, gchar * shortcuts)
{
  GtkWidget *dialog;
  GSList *result = NULL;
  gchar *folder, *seed;
  GHidPort *out = &ghid_port;
  GtkFileFilter *no_filter;

  dialog = gtk_file_chooser_dialog_new (title,
					GTK_WINDOW (out->top_window),
					GTK_FILE_CHOOSER_ACTION_OPEN,
					GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
					GTK_STOCK_OK, GTK_RESPONSE_OK,
					NULL);

  gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);

  gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER (dialog), TRUE);

  /* add a default filter for not filtering files */
  no_filter = gtk_file_filter_new ();
  gtk_file_filter_set_name (no_filter, "all");
  gtk_file_filter_add_pattern (no_filter, "*.*");
  gtk_file_filter_add_pattern (no_filter, "*");
  gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), no_filter);

  /* in case we have a dialog for loading schematic files */
  if (strcmp (title, _("Load schematics")) == 0)
  {
    /* add a filter for schematic files */
    GtkFileFilter *sch_filter;
    sch_filter = gtk_file_filter_new ();
    gtk_file_filter_set_name (sch_filter, "sch");
    gtk_file_filter_add_mime_type (sch_filter, "application/x-geda-schematic");
    gtk_file_filter_add_pattern (sch_filter, "*.sch");
    gtk_file_filter_add_pattern (sch_filter, "*.SCH");
    gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), sch_filter);
  }

  if (path && *path)
    gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), *path);
  else
  {
	gchar *default_path;
	default_path = g_get_current_dir();
	gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), default_path);
	g_free(default_path);
  }

  if (shortcuts && *shortcuts)
    {
      folder = g_strdup (shortcuts);
      seed = folder;
      while ((folder = strtok (seed, ":")) != NULL)
	{
	  gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (dialog),
						folder, NULL);
	  seed = NULL;
	}
      g_free (folder);
    }

  if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_OK)
    {
      result = gtk_file_chooser_get_filenames (GTK_FILE_CHOOSER (dialog));
      folder =
	gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (dialog));
      if (folder && path)
	{
	  dup_string (path, folder);
	  g_free (folder);
	}
    }
  gtk_widget_destroy (dialog);


  return result;
}
void crypt_dock_create_new_stash ()
{
    gboolean disgardStash = FALSE;
    CryptItem *pStashItem;
    cd_message ("%s enter to the function", __func__);
    pStashItem = g_new0 (CryptItem, 1);
    disgardStash = FALSE;
    for (int i=0; i < 4; i++) {
        switch (i)  {
            case PHASE_ENTER_NEW_FOLDER:
                {
                GtkWidget* pFileChooserDialog = gtk_file_chooser_dialog_new (
                    _("(1/4) Select an new clean and/or empty folder (eg ~/.crypt)"),
                    GTK_WINDOW (myContainer->pWidget),
                    GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
                    GTK_STOCK_OK,
                    GTK_RESPONSE_OK,
                    GTK_STOCK_CANCEL,
                    GTK_RESPONSE_CANCEL,
                    NULL);

                gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (pFileChooserDialog), g_get_home_dir());
                gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (pFileChooserDialog), FALSE);

                gtk_widget_show (pFileChooserDialog);
                int answer = gtk_dialog_run (GTK_DIALOG (pFileChooserDialog));
                gboolean valid = FALSE;
                if (answer == GTK_RESPONSE_OK)	{
                    pStashItem->cCryptFolder = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (pFileChooserDialog));
                    valid = _cryptdock_stash_check_encfs_validity(pStashItem->cCryptFolder);
                }
                else  {
                    disgardStash = TRUE;
                }

                gtk_widget_destroy (pFileChooserDialog);
                if (valid == FALSE )  {
                        cairo_dock_show_dialog_and_wait ( D_("The selected folder is not an EncFS encrypted folder"),
                            myIcon,
                            myContainer,
                            NULL,
                            NULL);
                        disgardStash = TRUE;
                    }
                }
                break;
            case PHASE_SELECT_MOUNT_FOLDER:
                {
                char *blah=NULL;
                char *last_slash;
                // Choose the name and location at which you want the EncFS folder to be mounted
                GtkWidget* pFileChooserDialog = gtk_file_chooser_dialog_new (
                    _("(2/4) Choose the name and location at which you want the EncFS folder to be mounted"),
                    GTK_WINDOW (myContainer->pWidget),
                    GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER,
                    GTK_STOCK_OK,
                    GTK_RESPONSE_OK,
                    GTK_STOCK_CANCEL,
                    GTK_RESPONSE_CANCEL,
                    NULL);

                blah = g_strdup(pStashItem->cCryptFolder);
                last_slash = strrchr (blah, '/');
                if (last_slash)
                    *last_slash = '\0';

                gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (pFileChooserDialog), blah);
                gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (pFileChooserDialog), FALSE);

                gtk_widget_show (pFileChooserDialog);
                int answer = gtk_dialog_run (GTK_DIALOG (pFileChooserDialog));
                if (answer == GTK_RESPONSE_OK)	{
                    pStashItem->cMountFolder = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (pFileChooserDialog));
                } else {
                    disgardStash = TRUE;
                    cairo_dock_show_dialog_and_wait ( D_("You must enter a name"),
                        myIcon,
                        myContainer,
                        NULL,
                        NULL);
                }
                gtk_widget_destroy (pFileChooserDialog);

                }
                break;
            case PHASE_ENTER_NAME:
                {
                GtkWidget *editbox = gtk_entry_new();
                int selection = cairo_dock_show_dialog_and_wait ( D_("(3/4) Enter name of stash (visible in list)"),
                        myIcon,
                        myContainer,
                        NULL,
                        editbox);

                if (selection == STASH_NAME_BUTTON_OK)  {		// user select Ok or check mark
                    pStashItem->cVisibleName = g_strdup(gtk_entry_get_text(GTK_ENTRY(editbox)));
                }
                else  {
                    disgardStash = TRUE;
                  }
                gtk_widget_destroy (editbox);
                }
                break;
             case PHASE_ENTER_PASSWORD:
				{
                GtkWidget *editbox = gtk_entry_new();
                gtk_entry_set_visibility (GTK_ENTRY(editbox), FALSE);
                int selection = cairo_dock_show_dialog_and_wait ( D_("(4/4) Enter name of stash (visible in list)"),
                        myIcon,
                        myContainer,
                        NULL,
                        editbox);
                gchar * password=NULL;
                if (selection == STASH_NAME_BUTTON_OK)  {		// user select Ok or check mark
                    password = g_strdup(gtk_entry_get_text(GTK_ENTRY(editbox)));
                    if (password)  {
                        int done = encfs_stash_new (pStashItem->cCryptFolder, pStashItem->cMountFolder, password);
                        g_free (password);
                        if (done==0)  {
                            crypt_save_stash_to_settings(pStashItem);
                            g_ptr_array_add (myData.pStashArray, pStashItem);
                            crypt_show_notification_dialog (D_("New encfs mountpoint created."));
                            // passed
                        } else {
                            crypt_show_notification_dialog (D_("Unable to create new encfs mount."));
                            crypt_free_stashitem (pStashItem);
                            // not passed ...
                        }
                    }
				} 
				else {
                    crypt_show_notification_dialog (D_("Unable to create new encfs mount."));
                }
                gtk_widget_destroy (editbox);
				}
           break;
       }
   }
    return;
}
Exemple #29
0
/* Caller must g_free() the returned filename. */
gchar *
ghid_fileselect (const char *title, const char *descr,
                 char *default_file, char *default_ext,
		 const char *history_tag, int flags)
{
  GtkWidget *dialog;
  gchar *result = NULL;
  GHidPort *out = &ghid_port;
  gchar *path = NULL, *base = NULL;
  int history_pool = -1;
  int i;

  if (history_tag && *history_tag)
    {
      /* 
       * I used a simple linear search here because the number of
       * entries in the array is likely to be quite small (5, maybe 10 at
       * the absolute most) and this function is used when pulling up
       * a file dialog box instead of something called over and over
       * again as part of moving elements or autorouting.  So, keep it
       * simple....
       */
      history_pool = 0;
      while (history_pool < n_recent_dirs &&
	     strcmp (recent_dirs[history_pool].id, history_tag) != 0)
	{
	  history_pool++;
	}
      
      /*
       * If we counted all the way to n_recent_dirs, that means we
       * didn't find our entry
       */
      if (history_pool >= n_recent_dirs)
	{
	  n_recent_dirs++;

	  recent_dirs = (ghid_file_history *)realloc (recent_dirs, 
				  n_recent_dirs * sizeof (ghid_file_history));

	  if (recent_dirs == NULL)
	    {
	      fprintf (stderr, "%s():  realloc failed\n", __FUNCTION__);
	      exit (1);
	    }
	  
	  recent_dirs[history_pool].id = strdup (history_tag);

	  /* Initialize the entries in our history list to all be NULL */
	  for (i = 0; i < NHIST; i++)
	    {
	      recent_dirs[history_pool].history[i] = NULL;
	    }
	}
    }

  if (default_file && *default_file)
    {
      path = g_path_get_dirname (default_file);
      base = g_path_get_basename (default_file);
    }

  dialog = gtk_file_chooser_dialog_new (title,
					GTK_WINDOW (out->top_window),
					(flags & HID_FILESELECT_READ) ? 
					GTK_FILE_CHOOSER_ACTION_OPEN : 
					GTK_FILE_CHOOSER_ACTION_SAVE,
					GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
					GTK_STOCK_OK, GTK_RESPONSE_OK,
					NULL);

  gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);

  if (path && *path )
    {
      gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), path);
      g_free (path);
    }
  else
	{
	  gchar *default_path;
	  default_path = g_get_current_dir();
	  gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), default_path);
	  g_free(default_path);
	}

  if (base && *base)
    {
      /* default file is only supposed to be for writing, not reading */
      if (!(flags & HID_FILESELECT_READ))
	{
	  gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog), base);
	}
      g_free (base);
    }

  for (i = 0; i < NHIST && recent_dirs[history_pool].history[i] != NULL ; i++)
    {
      gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (dialog),
					    recent_dirs[history_pool].history[i], 
					    NULL);
    }

  if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_OK)
    {
      result = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
      if (result != NULL)
	path = g_path_get_dirname (result);
      else
	path = NULL;

      /* update the history list */
      if (path != NULL)
	{
	  char *tmps, *tmps2;
	  int k = 0;

	  /* 
	   * Put this at the top of the list and bump everything else
	   * down but skip any old entry of this directory
	   *
	   */
	  while ( k < NHIST &&
		 recent_dirs[history_pool].history[k] != NULL &&
		 strcmp ( recent_dirs[history_pool].history[k], path) == 0)
	    {
	      k++;
	    }
	  tmps = recent_dirs[history_pool].history[k];
	  recent_dirs[history_pool].history[0] = path;
	  for (i = 1 ; i < NHIST ; i++)
	    {
	      /* store our current entry, but skip duplicates */
	      while (i + k < NHIST &&
		     recent_dirs[history_pool].history[i + k] != NULL &&
		     strcmp ( recent_dirs[history_pool].history[i + k], path) == 0)
		{
		  k++;
		}
		     
	      if (i + k < NHIST)
		tmps2 = recent_dirs[history_pool].history[i + k];
	      else
		tmps2 = NULL;

	      /* move down the one we stored last time */
	      recent_dirs[history_pool].history[i] = tmps;

	      /* and remember the displace entry */
	      tmps = tmps2;
	    }

	  /* 
	   * the last one has fallen off the end of the history list
	   * so we need to free() it.
	   */
	  if (tmps)
	    {
	      free (tmps);
	    }
	}
      
#ifdef DEBUG
      printf ("\n\n-----\n\n");
      for (i = 0 ; i < NHIST ; i++)
	{
	  printf ("After update recent_dirs[%d].history[%d] = \"%s\"\n",
		  history_pool, i, recent_dirs[history_pool].history[i] != NULL ?
		  recent_dirs[history_pool].history[i] : "NULL");
	}
#endif

    }
  gtk_widget_destroy (dialog);


  return result;
}
Exemple #30
0
static void
on_choosebutton_activate (GtkButton *button, gpointer user_data)
{
	GSQL_TRACE_FUNC;
	
	GtkDialog *dialog;
	GtkWidget *target = user_data;
	static gchar *folder = NULL;
	GtkWidget *chooser;
	static gchar *uri = NULL;
	gchar *file = NULL;
	gint ret;
	
	chooser = gtk_file_chooser_dialog_new (N_("Target filename..."),
					       NULL,
					       GTK_FILE_CHOOSER_ACTION_SAVE,
					       GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
					       GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
					       NULL);
	gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER(chooser), 
													TRUE);
	if (folder)
		gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER(chooser), 
											 folder);
	if (uri)
		g_free (uri); 

	gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (chooser), FALSE);
	
	uri = g_strdup(gtk_entry_get_text (GTK_ENTRY (target)));
	
	if (uri)
	{
		GSQL_DEBUG ("Export: [uri=%s]", uri);
		file = g_filename_display_basename (uri);
		if (gtk_file_chooser_set_filename (GTK_FILE_CHOOSER(chooser), 
									   uri))
			gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER(chooser), 
											   file);
		
		g_free (file);
		file = NULL;
	}
	
	gtk_window_set_transient_for (GTK_WINDOW (chooser), GTK_WINDOW (gsql_window));

	ret = gtk_dialog_run (GTK_DIALOG (chooser));
	if (ret == GTK_RESPONSE_ACCEPT)
	{
		file = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (chooser));
		if (folder) 
			g_free (folder);

		folder = gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (chooser));
		GSQL_DEBUG ("Export target: [file=%s]", file);
		
		if (file)
		{
			gtk_entry_set_text (GTK_ENTRY (target), file);
			g_free (file);
		}
	}
	
	gtk_widget_destroy (chooser);
	

}