# FileChooserDialog (Python)

Marta Maria Casetti
mmcasetti@gmail.com 2012
A dialog suitable for "Open" and "Save" commands
Mario Blättermann
mario.blaettermann@gmail.com 2011, 2013, 2016, 2018

# FileChooserDialog

This FileChooserDialog saves a text document, which can be opened or written from scratch in a TextView (see below).

It is also possible to call a FileChooserDialog to open a new document.

# Steps to recreate the example

Create a file .ui to describe an app-menu with items "New", "Open", "Save", "Save as", and "Quit". This can be done with Glade or in a text editor. See

Create a Python program for a Gtk.TextView with a Gtk.Buffer `self.buffer`, and a `self.file` which will be a Gio.File and we set initially as `None`.

In this program, create also the actions corresponding to the items in the app-menu, connect them to callback functions, and import the menu in the `do_startup()` method with a Gtk.Builder.

"New" and "Quit" actions and callback functions are quite straightforward, see . See for a more detailed explanation of signals and callback functions.

"Open" callback should create and open a Gtk.FileChooserDialog for "Open", connected with another callback function for each of the two "Open" and "Cancel" buttons of the FileChooserDialog.

"Save as" works basically as "Open", but the callback function of the "Save" button depends on a more complex method `save_to_file()`.

"Save" can be reduced to the case where the file is `None`, that is the case where `self.file` is a new file, which in turn is the case "Save as"; and to the case where the file is not `None`, which in turn is reduced to `save_to_file()`.

Finally, the method `save_to_file()`: see , lines 146 - 175.

# XML file which creates the app-menu

<?xml version="1.0"?> <interface> <menu id="appmenu"> <section> <item> <attribute name="label">New</attribute> <attribute name="action">win.new</attribute> </item> <item> <attribute name="label">Open</attribute> <attribute name="action">win.open</attribute> </item> </section> <section> <item> <attribute name="label">Save</attribute> <attribute name="action">win.save</attribute> </item> <item> <attribute name="label">Save As...</attribute> <attribute name="action">win.save-as</attribute> </item> </section> <section> <item> <attribute name="label">Quit</attribute> <attribute name="action">app.quit</attribute> </item> </section> </menu> </interface>

# Code used to generate this example

from gi.repository import Gtk from gi.repository import Gdk from gi.repository import Gio from gi.repository import GObject import sys

class MyWindow(Gtk.ApplicationWindow):

def __init__(self, app): Gtk.Window.__init__( self, title="FileChooserDialog Example", application=app) self.set_default_size(400, 400)

# the actions for the window menu, connected to the callback functions new_action = Gio.SimpleAction.new("new", None) new_action.connect("activate", self.new_callback) self.add_action(new_action)

open_action = Gio.SimpleAction.new("open", None) open_action.connect("activate", self.open_callback) self.add_action(open_action)

save_action = Gio.SimpleAction.new("save", None) save_action.connect("activate", self.save_callback) self.add_action(save_action)

save_as_action = Gio.SimpleAction.new("save-as", None) save_as_action.connect("activate", self.save_as_callback) self.add_action(save_as_action)

# the file self.file = None

# the textview with the buffer self.buffer = Gtk.TextBuffer() textview = Gtk.TextView(buffer=self.buffer) textview.set_wrap_mode(Gtk.WrapMode.WORD)

# a scrolled window for the textview self.scrolled_window = Gtk.ScrolledWindow() self.scrolled_window.set_policy( Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) self.scrolled_window.add(textview) self.scrolled_window.set_border_width(5)

# add the scrolled window to the window self.add(self.scrolled_window)

# callback for new def new_callback(self, action, parameter): self.buffer.set_text("") print("New file created")

# callback for open def open_callback(self, action, parameter): # create a filechooserdialog to open: # the arguments are: title of the window, parent_window, action, # (buttons, response) open_dialog = Gtk.FileChooserDialog("Pick a file", self, Gtk.FileChooserAction.OPEN, (Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_OPEN, Gtk.ResponseType.ACCEPT))

# not only local files can be selected in the file selector open_dialog.set_local_only(False) # dialog always on top of the textview window open_dialog.set_modal(True) # connect the dialog with the callback function open_response_cb() open_dialog.connect("response", self.open_response_cb) # show the dialog open_dialog.show()

# callback function for the dialog open_dialog def open_response_cb(self, dialog, response_id): open_dialog = dialog # if response is "ACCEPT" (the button "Open" has been clicked) if response_id == Gtk.ResponseType.ACCEPT: # self.file is the file that we get from the FileChooserDialog self.file = open_dialog.get_file() # an empty string (provisionally) content = "" try: # load the content of the file into memory: # success is a boolean depending on the success of the operation # content is self-explanatory # etags is an entity tag (can be used to quickly determine if the # file has been modified from the version on the file system) [success, content, etags] = self.file.load_contents(None) except GObject.GError as e: print("Error: " + e.message) # set the content as the text into the buffer self.buffer.set_text(content, len(content)) print("opened: " + open_dialog.get_filename()) # if response is "CANCEL" (the button "Cancel" has been clicked) elif response_id == Gtk.ResponseType.CANCEL: print("cancelled: FileChooserAction.OPEN") # destroy the FileChooserDialog dialog.destroy()

# callback function for save_as def save_as_callback(self, action, parameter): # create a filechooserdialog to save: # the arguments are: title of the window, parent_window, action, # (buttons, response) save_dialog = Gtk.FileChooserDialog("Pick a file", self, Gtk.FileChooserAction.SAVE, (Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_SAVE, Gtk.ResponseType.ACCEPT)) # the dialog will present a confirmation dialog if the user types a file name that # already exists save_dialog.set_do_overwrite_confirmation(True) # dialog always on top of the textview window save_dialog.set_modal(True) # if self.file has already been saved if self.file is not None: try: # set self.file as the current filename for the file chooser save_dialog.set_file(self.file) except GObject.GError as e: print("Error: " + e.message) # connect the dialog to the callback function save_response_cb() save_dialog.connect("response", self.save_response_cb) # show the dialog save_dialog.show()

# callback function for the dialog save_dialog def save_response_cb(self, dialog, response_id): save_dialog = dialog # if response is "ACCEPT" (the button "Save" has been clicked) if response_id == Gtk.ResponseType.ACCEPT: # self.file is the currently selected file self.file = save_dialog.get_file() # save to file (see below) self.save_to_file() # if response is "CANCEL" (the button "Cancel" has been clicked) elif response_id == Gtk.ResponseType.CANCEL: print("cancelled: FileChooserAction.SAVE") # destroy the FileChooserDialog dialog.destroy()

# callback function for save def save_callback(self, action, parameter): # if self.file is not already there if self.file is not None: self.save_to_file() # self.file is a new file else: # use save_as self.save_as_callback(action, parameter)

# save_to_file def save_to_file(self): # get the content of the buffer, without hidden characters [start, end] = self.buffer.get_bounds() current_contents = self.buffer.get_text(start, end, False) # if there is some content if current_contents != "": # set the content as content of self.file. # arguments: contents, etags, make_backup, flags, GError try: self.file.replace_contents(current_contents, None, False, Gio.FileCreateFlags.NONE, None) print("saved: " + self.file.get_path()) except GObject.GError as e: print("Error: " + e.message) # if the contents are empty else: # create (if the file does not exist) or overwrite the file in readwrite mode. # arguments: etags, make_backup, flags, GError try: self.file.replace_readwrite(None, False, Gio.FileCreateFlags.NONE, None) print("saved: " + self.file.get_path()) except GObject.GError as e: print("Error: " + e.message)

class MyApplication(Gtk.Application):

def __init__(self): Gtk.Application.__init__(self)

def do_activate(self): win = MyWindow(self) win.show_all()

def do_startup(self): Gtk.Application.do_startup(self)

# app action quit, connected to the callback function quit_action = Gio.SimpleAction.new("quit", None) quit_action.connect("activate", self.quit_callback) self.add_action(quit_action)

# get the menu from the ui file with a builder builder = Gtk.Builder() try: builder.add_from_file("filechooserdialog.ui") except: print("file not found") sys.exit() menu = builder.get_object("appmenu") self.set_app_menu(menu)

# callback function for quit def quit_callback(self, action, parameter): self.quit()

app = MyApplication() exit_status = app.run(sys.argv) sys.exit(exit_status)

# Useful methods for a FileChooserDialog

Note that the action of the FileChooserDialog can be one of the following: `Gtk.FileChooserAction.OPEN` (the file chooser will only let the user pick an existing file) `Gtk.FileChooserAction.SAVE` (the file chooser will let the user pick an existing file, or type in a new filename), `Gtk.FileChooserAction.SELECT_FOLDER` (the file chooser will let the user pick an existing folder), `Gtk.FileChooserAction.CREATE_FOLDER` (the file chooser will let the user name an existing or new folder).

Besides the methods used in the , we have:

`set_show_hidden(True)` is used to display hidden files and folders.

`set_select_multiple(True)` sets that multiple files can be selected. This is only relevant if the mode is `Gtk.FileChooserAction.OPEN` or `Gtk.FileChooserAction.SELECT_FOLDER`.

In a "Save as" dialog, `set_current_name(current_name)` sets `current_name` in the file selector, as if entered by the user; `current_name` can be something like Untitled.txt. This method should not be used except in a "Save as" dialog.

The default current folder is "recent items". To set another folder use `set_current_folder_uri(uri)`; but note you should use this method and cause the file chooser to show a specific folder only when you are doing a "Save as" command and you already have a file saved somewhere.

# API-Referenzen

In this sample we used the following:

GtkFileChooserDialog

GtkFileChooser

GtkWindow

GtkTextView

GtkTextBuffer

GtkScrolledWindow

GFile

GSimpleAction

GtkBuilder