def on_openfile(self, widget=None):
file_open_dialog = gtk.FileChooserDialog(
title="Open UPPAAL model",
action=gtk.FILE_CHOOSER_ACTION_OPEN,
buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OPEN,
gtk.RESPONSE_OK))
filter = gtk.FileFilter()
filter.set_name("UPPAAL models")
filter.add_pattern("*.xml")
filter.add_mime_type("application/xml")
file_open_dialog.add_filter(filter)
filter = gtk.FileFilter()
filter.set_name("All files")
filter.add_pattern("*")
file_open_dialog.add_filter(filter)
if file_open_dialog.run() == gtk.RESPONSE_OK:
filename = file_open_dialog.get_filename()
self.loadFile(filename)
file_open_dialog.destroy()
else:
file_open_dialog.destroy()
def open_file(self, widget):
dialog = gtk.FileChooserDialog(title=None,action=gtk.FILE_CHOOSER_ACTION_OPEN,
buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OPEN, gtk.RESPONSE_OK))
dialog.set_default_response(gtk.RESPONSE_OK)
dialog.set_current_folder(SCRIPTS_DIR)
ff = gtk.FileFilter()
ff.set_name("python")
ff.add_pattern("*.py")
dialog.add_filter(ff)
if dialog.run() == gtk.RESPONSE_OK:
self._load_file(dialog.get_filename())
dialog.destroy()
def register(self, factory, extension, description):
self.__global_filter.add_pattern("*" + extension)
filter = gtk.FileFilter()
filter.set_name(description)
filter.add_pattern("*" + extension)
self.file_filters.append(filter)
for listener in self.listeners:
listener.on_registred(factory, extension, description)
self.__factories[extension] = factory
self.__global_filter.add_pattern("*" + extension)
def do_dialog(dialog, suffix, load_save_folder):
''' Open a file dialog. '''
result = None
file_filter = gtk.FileFilter()
file_filter.add_pattern('*' + suffix)
file_filter.set_name('Turtle Art')
dialog.add_filter(file_filter)
dialog.set_current_folder(load_save_folder)
response = dialog.run()
if response == gtk.RESPONSE_OK:
result = dialog.get_filename()
load_save_folder = dialog.get_current_folder()
dialog.destroy()
return result, load_save_folder
def __export_connection_button_cb(self, widget, data):
treeselection = self.connections_treeview.get_selection()
(model, iter) = treeselection.get_selected()
p = False
while p == False:
dlg = gtk.FileChooserDialog(
title=_("Export connection"),
action=gtk.FILE_CHOOSER_ACTION_SAVE,
parent=self._parent,
buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_SAVE,
gtk.RESPONSE_OK))
window_icon_path = self.theme_manager.get_icon(
'icons', 'settings_taskbar.png')
dlg.set_icon_from_file(window_icon_path)
dlg.set_current_folder(os.environ["HOME"])
dlg.set_current_name(
model.get_value(iter, 1).replace("/", "_") + ".tgcm")
dlg_filter = gtk.FileFilter()
dlg_filter.set_name(_("TGCM files"))
dlg_filter.add_pattern("*.tgcm")
dlg.add_filter(dlg_filter)
dlg.set_do_overwrite_confirmation(True)
ret = dlg.run()
if ret == gtk.RESPONSE_OK:
if not dlg.get_filename().endswith(".tgcm"):
msg = gtk.MessageDialog(type=gtk.MESSAGE_WARNING,
buttons=gtk.BUTTONS_CLOSE,
parent=self._parent)
window_icon_path = self.theme_manager.get_icon(
'icons', 'settings_taskbar.png')
msg.set_icon_from_file(window_icon_path)
msg.set_markup(_("<b>The file must have an extension</b>"))
msg.format_secondary_markup(
_("The files that you save must have extension .tgcm"))
msg.run()
msg.destroy()
dlg.destroy()
else:
p = True
else:
dlg.destroy()
return
conn_settings = model.get_value(iter, 4)
self.conn_manager.export_connection(conn_settings, dlg.get_filename())
dlg.destroy()
def __accion_menu(self, playerlist, lista, accion, _iter):
if lista and accion and _iter:
uri = lista.get_model().get_value(_iter, 2)
if accion == "Quitar" or accion == "Borrar":
dialog = gtk.Dialog(parent=self.get_toplevel(),
title="Alerta",
buttons=("Si", gtk.RESPONSE_ACCEPT, "No",
gtk.RESPONSE_CANCEL))
dialog.set_border_width(15)
dialog.modify_bg(gtk.STATE_NORMAL, get_colors("window"))
texto = uri
if len(texto) > 30:
texto = " . . . " + str(texto[len(texto) - 30:-1])
label = gtk.Label("¿%s: %s?" % (accion, texto))
label.show()
dialog.vbox.pack_start(label, True, True, 5)
if dialog.run() == gtk.RESPONSE_ACCEPT:
self.stop()
path = lista.get_model().get_path(_iter)
path = (path[0], )
lista.get_model().remove(_iter)
self.__reselect(lista, path)
if accion == "Quitar":
pass
elif accion == "Borrar":
if os.path.isfile(uri):
borrar(uri)
dialog.destroy()
elif accion == "Subtitulos":
dialog = gtk.FileChooserDialog(
title="Cargar Subtitulos",
parent=self.get_toplevel(),
action=gtk.FILE_CHOOSER_ACTION_OPEN,
buttons=("Abrir", gtk.RESPONSE_ACCEPT, "Salir",
gtk.RESPONSE_CANCEL))
dialog.set_border_width(15)
dialog.modify_bg(gtk.STATE_NORMAL, get_colors("window"))
dialog.set_current_folder_uri("file://%s" %
os.path.dirname(uri))
dialog.set_select_multiple(False)
filtro = gtk.FileFilter()
filtro.set_name("text")
filtro.add_mime_type("text/*")
dialog.add_filter(filtro)
if dialog.run() == gtk.RESPONSE_ACCEPT:
self.player.player.set_property(
"suburi", "file://" + dialog.get_filename())
self.player.player.set_property("subtitle-font-desc",
"sans bold 18")
dialog.destroy()
def savecsvdlg(title=u'', parent=None, hintfile=None, lpath=None):
ret = None
dlg = gtk.FileChooserDialog(title, parent, gtk.FILE_CHOOSER_ACTION_SAVE,
(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
gtk.STOCK_SAVE, gtk.RESPONSE_OK))
cfilt = gtk.FileFilter()
cfilt.set_name('CSV Files')
cfilt.add_mime_type('text/csv')
cfilt.add_pattern('*.csv')
dlg.add_filter(cfilt)
cfilt = gtk.FileFilter()
cfilt.set_name('All Files')
cfilt.add_pattern("*")
dlg.add_filter(cfilt)
if lpath:
dlg.set_current_folder(lpath)
if hintfile:
dlg.set_current_name(hintfile)
response = dlg.run()
if response == gtk.RESPONSE_OK:
ret = dlg.get_filename().decode('utf-8')
dlg.destroy()
return ret
def file_chooser(self):
dialog = gtk.FileChooserDialog("Open..",
None,
gtk.FILE_CHOOSER_ACTION_OPEN,
(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
gtk.STOCK_OPEN, gtk.RESPONSE_OK))
dialog.set_default_response(gtk.RESPONSE_OK)
filter = gtk.FileFilter()
filter.set_name("All files")
filter.add_pattern("*")
dialog.add_filter(filter)
filter = gtk.FileFilter()
filter.set_name("scripts")
filter.add_mime_type("text/plain")
filter.add_pattern("*.txt")
dialog.add_filter(filter)
response = dialog.run()
if response == gtk.RESPONSE_OK:
self.script_to_load = dialog.get_filename(), 'selected'
elif response == gtk.RESPONSE_CANCEL:
self.script_to_load = ""
dialog.destroy()
def _get_filters_from_list(filter_list):
import gtk
result = []
for one_filter in filter_list:
current_filter = gtk.FileFilter()
current_filter.set_name(one_filter[0])
file_extensions = one_filter[1]
if not isinstance(file_extensions, (list, tuple)):
file_extensions = [file_extensions]
for ext in file_extensions:
current_filter.add_pattern(
pycam.Utils.get_case_insensitive_file_pattern(ext))
result.append(current_filter)
return result
def outputselect(self, widget):
dialog1 = gtk.FileChooserDialog("Name Output File", None,
gtk.FILE_CHOOSER_ACTION_SAVE,
(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
gtk.STOCK_OPEN, gtk.RESPONSE_OK))
dialog1.set_default_response(gtk.RESPONSE_OK)
filter = gtk.FileFilter()
filter.set_name("djvu Files")
filter.add_pattern("*.djvu")
dialog1.add_filter(filter)
response = dialog1.run()
self.outputfilename = dialog1.get_filename()
self.out2 = self.outputfilename.split('/')[-1]
dialog1.destroy()
def Execute(self):
"""
This function gets the blocks chain and saves as a .png file by print screen.
"""
if gtk.gtk_version < (2, 4, 0):
t_oFilesel = gtk.FileSelection(
'Exportar cadeia para imagem tipo .png')
else:
t_oFilesel = gtk.FileChooserDialog(
title='Exportar cadeia para imagem tipo .png',
action=gtk.FILE_CHOOSER_ACTION_SAVE,
buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_SAVE,
gtk.RESPONSE_OK))
#Scotti
if os.name == 'posix':
t_oFilesel.set_current_folder(os.path.expanduser("~"))
#Scotti
t_oFilter = gtk.FileFilter()
t_oFilter.set_name(_("PNG Image (*.png)"))
t_oFilter.add_pattern("*.png")
t_oFilesel.add_filter(t_oFilter)
t_oFilter = gtk.FileFilter()
t_oFilter.set_name(_("Todos os arquivos"))
t_oFilter.add_pattern("*")
t_oFilesel.add_filter(t_oFilter)
t_oResponse = t_oFilesel.run()
t_sFilename = t_oFilesel.get_filename()
t_oFilesel.destroy()
print t_sFilename
def open_file(self, data=None):
textbuffer = self.textview.get_buffer()
if textbuffer.get_modified():
a = self.confirm_dialog()
if a == 0:
return
dialog = gtk.FileChooserDialog("Open..",
None,
gtk.FILE_CHOOSER_ACTION_OPEN,
(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
gtk.STOCK_OPEN, gtk.RESPONSE_OK))
dialog.set_default_response(gtk.RESPONSE_OK)
filter = gtk.FileFilter()
filter.set_name("All files")
filter.add_pattern("*")
dialog.add_filter(filter)
filter = gtk.FileFilter()
filter.set_name("Text")
filter.add_mime_type("text/data")
filter.add_pattern("*.txt")
dialog.add_filter(filter)
response = dialog.run()
if response == gtk.RESPONSE_OK:
self.filename = dialog.get_filename()
print "Opened file: " + self.filename
index = self.filename.replace("\\","/").rfind("/") + 1
self.window.set_title(self.filename[index:] + " - PyPad")
file = open(self.filename, "r")
text = file.read()
textbuffer.set_text(text)
file.close()
textbuffer.set_modified(False)
dialog.destroy()
def save_csv_file(path=None):
"""Opens a filechooser dialog to choose where to save a csv file"""
title = _("Save as ...")
chooser_dialog = gtk.FileChooserDialog(title,
action=gtk.FILE_CHOOSER_ACTION_SAVE,
buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
gtk.STOCK_SAVE, gtk.RESPONSE_OK))
chooser_dialog.set_default_response(gtk.RESPONSE_OK)
filter_ = gtk.FileFilter()
filter_.set_name(_("Csv files"))
filter_.add_mime_type("text/xml")
filter_.add_pattern("*csv")
chooser_dialog.add_filter(filter_)
filter_ = gtk.FileFilter()
filter_.set_name(_("All files"))
filter_.add_pattern("*")
chooser_dialog.add_filter(filter_)
if path:
chooser_dialog.set_filename(os.path.abspath(path))
if chooser_dialog.run() == gtk.RESPONSE_OK:
resp = chooser_dialog.get_filename()
if os.path.isfile(resp):
# requests to confirm overwrite:
overwrite = show_warning_request_cancel_ok(
_('Overwrite "%s"?') % os.path.basename(resp),
_("""A file with this name already exists.
If you choose to overwrite this file, the contents will be lost."""))
if not overwrite:
resp = None
else:
resp = None
chooser_dialog.destroy()
return resp
def on_import_ncd(self, window, notebook):
"""Callback from gui for importing an ncd file"""
if notebook is None:
self.app.error("Must have notebook open to import.")
return None
"""Imports NoteCase free version ncd file"""
dialog = gtk.FileChooserDialog(
"import ncd file",
None,
action=gtk.FILE_CHOOSER_ACTION_OPEN,
buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OPEN,
gtk.RESPONSE_OK))
file_filter = gtk.FileFilter()
file_filter.add_pattern("*.ncd")
file_filter.set_name("NoteCase free version 1.9.8(*.ncd)")
dialog.add_filter(file_filter)
file_filter = gtk.FileFilter()
file_filter.add_pattern("*")
file_filter.set_name("All files (*.*)")
dialog.add_filter(file_filter)
response = dialog.run()
if response == gtk.RESPONSE_OK:
if dialog.get_filename():
ncd_file = dialog.get_filename()
if notebook is not None:
import_ncd_file(window, ncd_file)
else:
print(
"WARNING: you need an notebook before you can import")
# self.close_notebook()
dialog.destroy()
def __init__(self):
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_title("Upgrade Tool")
self.window.connect("delete_event", self.delete_event)
self.window.connect("destroy", self.destroy)
self.window.set_border_width(3)
self.window.set_size_request(550, -1)
self.mainloop = MainloopThread()
self.mainloop.start()
self.vbox = gtk.VBox()
self.vbox.set_spacing(3)
self.selector = EyetrackerSelector(self.mainloop, self._on_selected)
self.file_filter = gtk.FileFilter()
self.file_filter.set_name("Tobii Upgrade Packages")
self.file_filter.add_pattern("*.tobiipkg")
self.chooser = gtk.FileChooserButton(title="Select Firmware File")
self.chooser.add_filter(self.file_filter)
self.chooser.connect('file-set', self._on_file_selected)
self.hbox1 = gtk.HBox()
self.hbox1.pack_start(self.selector)
self.hbox1.pack_end(self.chooser)
self.progress = gtk.ProgressBar()
self.cancel = gtk.Button("Cancel")
self.cancel.set_sensitive(False)
self.start = gtk.Button("Start Upgrade")
self.start.set_sensitive(False)
self.start.connect('clicked', self._start_upgrade)
self.hbox2 = gtk.HBox()
self.hbox2.pack_start(self.progress)
self.hbox2.pack_end(self.cancel, expand=False)
self.hbox2.pack_end(self.start, expand=False)
self.vbox.pack_start(self.hbox1, expand=False)
self.vbox.pack_end(self.hbox2, expand=False)
self.window.add(self.vbox)
self.window.show_all()
self.upgrading_device = None
self.selected_file = None
self.upgrade_started = False
def on_treeview_button_press_event(self, treeview, event):
if not event.button == 1:
return
info = treeview.get_path_at_pos(int(event.x), int(event.y))
if info is None:
return
path, column, cell_x, cell_y = info
store = treeview.get_model()
if column == self.column_relative_path:
if not user_settings.server_path:
show_error(_("Please, set path to game server"), self)
return
relative_path = store[path][MissionsDialog.COLUMNS.RELATIVE_PATH]
chooser = gtk.FileChooserDialog(
title=_("Select IL-2 FB mission"),
action=gtk.FILE_CHOOSER_ACTION_OPEN,
buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OPEN,
gtk.RESPONSE_OK))
if relative_path is None:
chooser.set_current_folder(MissionManager.get_root_path())
else:
file_name = MissionManager.absolute_path(relative_path)
chooser.set_filename(file_name)
f_filter = gtk.FileFilter()
f_filter.set_name("IL-2 FB missions (*.mis)")
f_filter.add_pattern("*.mis")
chooser.add_filter(f_filter)
response = chooser.run()
relative_path = chooser.get_filename()
chooser.destroy()
if response != gtk.RESPONSE_OK:
return
try:
relative_path = \
MissionManager.short_relative_path(relative_path)
except ValueError as e:
show_error(unicode(e))
else:
store[path][MissionsDialog.COLUMNS.RELATIVE_PATH] = \
relative_path
def __init__(self, iso_path=None):
APP = "mintstick"
DIR = "/usr/share/locale"
gettext.bindtextdomain(APP, DIR)
gettext.textdomain(APP)
gtk.glade.bindtextdomain(APP, DIR)
gtk.glade.textdomain(APP)
# get glade tree
self.gladefile = "/usr/share/mintstick/mintstick.glade"
self.wTree = gtk.glade.XML(self.gladefile)
# make sure we have a target device
self.get_devices()
# get globally needed widgets
self.window = self.wTree.get_widget("main_dialog")
self.devicelist = self.wTree.get_widget("device_combobox")
self.logview = self.wTree.get_widget("detail_text")
self.log = self.logview.get_buffer()
self.ddpid = 0
# set default file filter to *.img
self.chooser = self.wTree.get_widget("filechooserbutton")
filt = gtk.FileFilter()
filt.add_pattern("*.img")
filt.add_pattern("*.iso")
self.chooser.set_filter(filt)
# set callbacks
dict = {
"on_main_dialog_destroy": self.close,
"on_cancel_button_clicked": self.close,
"on_emergency_button_clicked": self.close,
"on_failauth_button_clicked": self.close,
"on_success_button_clicked": self.close,
"on_filechooserbutton_file_set": self.activate_devicelist,
"on_detail_expander_activate": self.expander_control,
"on_device_combobox_changed": self.device_selected,
"on_write_button_clicked": self.do_write
}
self.wTree.signal_autoconnect(dict)
if iso_path is not None:
self.chooser.set_filename(iso_path)
self.activate_devicelist(self.chooser)
self.window.show_all()
def FileChooser(self, widget, data=None):
DlgFileChooserGlade = gtk.glade.XML(Global.GUIPath + "freebus.glade",
"DlgFileChooser")
DlgFileChooser = DlgFileChooserGlade.get_widget("DlgFileChooser")
#create file-filter depending on the choosen import type
filter = gtk.FileFilter()
#get the current choosen item
curItem = self.__cbImportType.get_active() #_text()
self.__choosenImportType = curItem
#VD* (Original)
if (curItem == 0):
filter.add_pattern("*.vd[1-4]")
filter.set_name("VD* Produktdaten")
#VD_ (pre-unzipped via ETS)
elif (curItem == 1):
filter.add_pattern("*.vd_")
filter.set_name("VD_ Produktdaten")
#converted XML
elif (curItem == 2):
filter.add_pattern("*.xml")
filter.set_name("XML Produktdaten")
else:
filter.add_pattern("*.vd[1-4]\*.vd_\*.xml")
filter.set_name("Produktdaten")
DlgFileChooser.add_filter(filter)
response = DlgFileChooser.run()
if (response == gtk.RESPONSE_OK):
self.__SelFolder = DlgFileChooser.get_current_folder()
self.__SelectedFile = DlgFileChooser.get_filename()
#split SelFile (get_filename return complete path + filename)
List = self.__SelectedFile.split("\\")
tFileName = List[len(List) - 1]
tFileName = tFileName.split(".")
#Folder and Filename complete
self.__txtSourceFile.set_text(self.__SelectedFile)
DlgFileChooser.destroy()
else:
DlgFileChooser.destroy()
def fwpath_clicked(self, widget):
fw_entry = self.builder.get_object("fw_entry")
dialog = gtk.FileChooserDialog(title=None,action=gtk.FILE_CHOOSER_ACTION_OPEN,
buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OPEN, gtk.RESPONSE_OK))
dialog.set_default_response(gtk.RESPONSE_OK)
dialog.set_current_folder(SCRIPTS_PATH)
ff = gtk.FileFilter()
ff.set_name("dfu")
ff.add_pattern("*.bin") #TODO change to DFU
dialog.add_filter(ff)
if dialog.run() == gtk.RESPONSE_OK:
fw_entry.set_text(dialog.get_filename())
dialog.destroy()
def __init__(self, path="ExportXML.ui", root="frmExportXML", domain="LibreShot", project=None, **kwargs):
SimpleGtkBuilderApp.__init__(self, os.path.join(project.UI_DIR, path), root, domain, **kwargs)
self.project = project
self.form = self.project.form
# Add language support
_ = Language_Init.Translator(project).lang.gettext
# set a file type filter (to limit the files to only valid files)
OSPfilter = gtk.FileFilter()
OSPfilter.add_pattern("*.mlt")
OSPfilter.set_name(_("MLT XML (*.mlt)"))
self.frmExportXML.add_filter(OSPfilter)
self.frmExportXML.set_current_folder_uri("file://%s" % self.project.DESKTOP)
def add_image_filters(self):
"""Add images filters to the filechooser.
"""
ffilter = gtk.FileFilter()
ffilter.set_name(_('All images'))
self.filechooser.add_filter(ffilter)
supported_formats = image_tools.get_supported_formats()
for name in sorted(supported_formats):
mime_types, extensions = supported_formats[name]
patterns = ['*.%s' % ext for ext in extensions]
self.add_filter(_('%s images') % name, mime_types, patterns)
for mime in mime_types:
ffilter.add_mime_type(mime)
for pat in patterns:
ffilter.add_pattern(pat)
def on_infile_button_press_event(self, button, event):
self.outLabel.set_text('')
dlg = gtk.FileChooserDialog("Open..", None,
gtk.FILE_CHOOSER_ACTION_OPEN,
(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
gtk.STOCK_OPEN, gtk.RESPONSE_OK))
if self.inSheetcam.get_active():
filter = gtk.FileFilter()
filter.set_name("SheetCam Tool File (*.tools)")
filter.add_pattern("*.[Tt][Oo][Oo][Ll][Ss]")
dlg.add_filter(filter)
elif self.inFusion.get_active():
filter = gtk.FileFilter()
filter.set_name("Fusion360 Tool File (*.json)")
filter.add_pattern("*.[Jj][Ss][Oo][Nn]")
dlg.add_filter(filter)
response = dlg.run()
if response == gtk.RESPONSE_OK:
self.inFile.set_text(dlg.get_filename())
self.inFileName = dlg.get_filename()
else:
self.inFile.set_text('')
self.inFileName = ''
dlg.destroy()
def sig_select(self, widget=None):
try:
# Add the filename from the field with the filename attribute in the view
filters = []
if not self.filters:
filter_file = gtk.FileFilter()
filter_file.set_name(_('All Files'))
filter_file.add_pattern('*')
filters.append(filter_file)
else:
for pat in self.filters:
filter_file = gtk.FileFilter()
filter_file.set_name(str(pat))
filter_file.add_pattern(pat)
filters.append(filter_file)
filename = common.file_selection(_('Select a file...'), parent=self._window,filters=filters)
if filename:
self.model_field.set_client(self._view.model, base64.encodestring(file(filename, 'rb').read()))
if self.has_filename:
self._view.model.set({self.has_filename: os.path.basename(filename)}, modified=True)
self._view.display(self._view.model)
except Exception, ex:
common.message(_('Error reading the file: %s') % str(ex))
def _get_save_fiters():
result = []
typelist = ARGS['filetypes'].split('@')
for item in typelist:
item = item.strip()
if item:
descr, extensions = item.split('|')
extensions = extensions.split()
file_filter = gtk.FileFilter()
file_filter.set_name(descr)
for ext in extensions:
file_filter.add_pattern(ext)
file_filter.add_pattern(ext.upper())
result.append(file_filter)
return result
def get_cfg_file_open(self):
temp_file = ""
dialog = gtk.FileChooserDialog("Choose animation...", None,
gtk.FILE_CHOOSER_ACTION_OPEN,
(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
gtk.STOCK_OPEN, gtk.RESPONSE_OK))
dialog.set_default_response(gtk.RESPONSE_OK)
#----setting filters---------
filter = gtk.FileFilter()
filter.set_name("gnofract4d animation files (*.fcta)")
filter.add_pattern("*.fcta")
dialog.add_filter(filter)
filter = gtk.FileFilter()
filter.set_name("All files")
filter.add_pattern("*")
dialog.add_filter(filter)
#----------------------------
response = dialog.run()
if response == gtk.RESPONSE_OK:
temp_file = dialog.get_filename()
#elif response == gtk.RESPONSE_CANCEL:
# print 'Closed, no files selected'
dialog.destroy()
return temp_file
def __init__(self):
self._parent = None
self.dialog = gtk.FileChooserDialog(
_("Import Certificates"), None, gtk.FILE_CHOOSER_ACTION_OPEN,
(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, _("Import"),
gtk.RESPONSE_OK))
self.dialog.set_default_response(gtk.RESPONSE_OK)
self.dialog.set_modal(True)
self.dialog.set_local_only(True)
self.dialog.set_select_multiple(True)
afilter = gtk.FileFilter()
afilter.set_name(_("Certificates"))
afilter.add_pattern("*.pem")
self.dialog.add_filter(afilter)
afilter = gtk.FileFilter()
afilter.set_name(_("All files"))
afilter.add_pattern("*")
self.dialog.add_filter(afilter)
self.dialog.connect("response", self._on_dialog_response)
def on_save_as_clicked(self, widget):
save_as_dlg = self.builder.get_object('save_as_dialog')
save_as_dlg.set_current_folder(self.cd_saveas)
save_as_dlg.set_current_name('iverplot.png')
if len(save_as_dlg.list_filters()) == 0:
all_filter = gtk.FileFilter()
all_filter.set_name('All files')
all_filter.add_pattern('*')
save_as_dlg.add_filter(all_filter)
img_filter = gtk.FileFilter()
img_filter.set_name('All images')
img_filter.add_pattern('*.png')
img_filter.add_pattern('*.jpg')
img_filter.add_pattern('*.pdf')
save_as_dlg.add_filter(img_filter)
response = save_as_dlg.run()
if response == gtk.RESPONSE_OK:
fname = save_as_dlg.get_filename()
self.fig.savefig(fname, dpi=self.fig.dpi)
self.cd_saveas = os.path.dirname(fname)
save_as_dlg.hide()
def _create_file_chooser_dialog(self, save=True):
if save:
action = gtk.FILE_CHOOSER_ACTION_SAVE
ok_button = gtk.STOCK_SAVE_AS
title = _('Export Rules')
else:
action = gtk.FILE_CHOOSER_ACTION_OPEN
ok_button = gtk.STOCK_OPEN
title = _('Import Rules')
buttons = (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
ok_button, gtk.RESPONSE_OK)
dlg = gtk.FileChooserDialog(title, self.ui.main_window, action, buttons)
# Shell scripts filter
f = gtk.FileFilter()
f.set_name('Shell scripts')
f.add_mime_type('application/x-sh')
f.add_pattern('*.sh')
dlg.add_filter(f)
# All files filter
f = gtk.FileFilter()
f.set_name('All files')
f.add_pattern('*')
dlg.add_filter(f)
return dlg
def callback_input(self, widget, callback_data=None):
#name = self.entry.get_text()
#print name
dialog = gtk.FileChooserDialog("Open..", None,
gtk.FILE_CHOOSER_ACTION_OPEN,
(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
gtk.STOCK_OPEN, gtk.RESPONSE_OK))
dialog.set_default_response(gtk.RESPONSE_OK)
filter = gtk.FileFilter()
filter.set_name("All files")
filter.add_pattern("*")
dialog.add_filter(filter)
filter = gtk.FileFilter()
filter.set_name("Images")
filter.add_mime_type("image/png")
filter.add_mime_type("image/jpeg")
filter.add_mime_type("image/gif")
filter.add_pattern("*.png")
filter.add_pattern("*.jpg")
filter.add_pattern("*.gif")
filter.add_pattern("*.tif")
filter.add_pattern("*.xpm")
dialog.add_filter(filter)
dialog.set_current_folder("~/")
response = dialog.run()
if response == gtk.RESPONSE_OK:
global inputfile
inputfile = dialog.get_filename()
#inputfile = inputfile.replace(" ", "\ ")
#print inputfile
#elif response == gtk.RESPONSE_CANCEL:
#print 'Closed, no files selected'
dialog.destroy()
def save_ffmpeg_opts_dialog(callback, opts_extension):
dialog = gtk.FileChooserDialog(
_("Save Render Args As"), None, gtk.FILE_CHOOSER_ACTION_SAVE,
(_("Cancel").encode('utf-8'), gtk.RESPONSE_REJECT,
_("Save").encode('utf-8'), gtk.RESPONSE_ACCEPT), None)
dialog.set_action(gtk.FILE_CHOOSER_ACTION_SAVE)
dialog.set_current_name("untitled" + opts_extension)
dialog.set_do_overwrite_confirmation(True)
dialog.set_select_multiple(False)
file_filter = gtk.FileFilter()
file_filter.set_name(opts_extension + " files")
file_filter.add_pattern("*" + opts_extension)
dialog.add_filter(file_filter)
dialog.connect('response', callback)
dialog.show()
