def import_datasets(self, filenames, importer, progresslist=None, undolist=None):
if undolist is None:
undolist = self.journal
if isinstance(importer, basestring):
importer = ImporterRegistry.new_instance(importer)
elif not isinstance(importer, Importer):
raise TypeError("'importer' needs to be a key or a valid Importer instance.")
# To ensure a proper undo, the Datasets are imported one by one
# to a temporary dict. When finished, they are added as a whole.
new_datasets = list()
progresslist = progresslist or self.app.progresslist
pl = progresslist(filenames)
for filename in pl:
try:
tbl = importer.read_table_from_file(filename)
except ImportError, msg:
pl.fail(msg)
continue
ds = Dataset(key=basename(filename), data=tbl)
ds.metadata["Import-Source"] = unicode(filename)
ds.metadata["Import-Filter"] = unicode(importer.blurb)
new_datasets.append(ds)
pl.succeed()
def __init__(self, filename):
WizardPage.__init__(self)
# construct ui from glade file
tree = gtk.glade.XML(self.gladefile, 'wizard_page_1')
page = tree.get_widget('wizard_page_1')
page.show()
self.add(page)
# Set up import object which hold the options and
# create the connection to the GUI.
self.importer = ImporterRegistry.new_instance('ASCII')
cf = pwglade.ConnectorFactory()
self.connectors = cf.create_from_glade_tree(self.importer, tree)
pwglade.check_in(self.connectors)
self.header_lines = 0
def update_header_lines(sender, event):
try: self.header_lines = int(sender.get_text())
except: self.header_lines = 0
self.treeview.queue_draw()
widget = self.connectors['header_lines'].widget
widget.connect('focus-out-event', update_header_lines)
# populate treeview
self.treeview = tree.get_widget('treeview_preview')
self.prepare_treeview()
self.populate_preview(filename)
def import_datasets(self, project, filenames, importer, undolist=None):
if undolist is None:
undolist = project.journal
if isinstance(importer, basestring):
importer = ImporterRegistry.new_instance(importer)
elif not isinstance(importer, Importer):
raise TypeError("'importer' needs to be a key or a valid Importer instance.")
# To ensure a proper undo, the Datasets are imported one by one
# to a temporary dict. When finished, they are added as a whole.
new_datasets = list()
n = 0.0
N = len(filenames)
for filename in filenames:
yield ("Importing %s" % filename, n/N)
try:
tbl = importer.read_table_from_file(filename)
except ImportError, msg:
self.error_message(msg)
continue
except error.UserCancel:
self.error_message("Import aborted by user")
continue
def quick_xps_import(self, filename, ranges, undolist=None):
project = self.app.project
if undolist is None:
undolist = project.journal
importer = ImporterRegistry.new_instance('XPS')
table = importer.read_table_from_file(filename, ranges=ranges)
ds = Dataset(key=basename(filename), data=table)
ds.metadata['Import-Source'] = unicode(filename)
ds.metadata['Import-Filter'] = unicode('XPS')
ul = UndoList().describe("Quick import Dataset(s)")
project.add_datasets([ds], undolist=ul)
undolist.append(ul)
def __init__(self, filenames):
gtk.Dialog.__init__(self, "Import Wizard", None,
gtk.DIALOG_MODAL|gtk.DIALOG_DESTROY_WITH_PARENT,
(gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT,
gtk.STOCK_OK, gtk.RESPONSE_ACCEPT))
self.set_size_request(480,320)
self.treeview = self.construct_treeview()
self.populate_preview(filenames[0])
sw = uihelper.add_scrollbars(self.treeview)
self.treeview.show()
self.vbox.pack_end(sw, True, True)
sw.show()
self.importer = ImporterRegistry.new_instance('ASCII')
frame = gtk.Frame()
def redisplay(sender, event, treeview):
treeview.queue_draw()
pw_skip, box_skip = propwidgets.construct_pw_in_box(self.importer, 'skip')
pw_skip.widget.connect('focus-out-event', redisplay, self.treeview)
self.pw_skip = pw_skip
box_skip.show()
pw_designations, box_designations = propwidgets.construct_pw_in_box(self.importer, 'designations')
#pw_designations.connect('
box_designations.show()
hbox = gtk.HBox()
hbox.pack_start(box_skip)
hbox.pack_start(box_designations)
hbox.show()
frame.add(hbox)
self.vbox.pack_start(frame, False, True)
frame.show()
def _cb_import_dataset(self, action):
pj = self._check_project()
# allow user to choose files for import
chooser = gtk.FileChooserDialog(
title="Import Dataset from file",
action=gtk.FILE_CHOOSER_ACTION_OPEN,
buttons=(gtk.STOCK_CANCEL,
gtk.RESPONSE_CANCEL,
gtk.STOCK_OPEN,
gtk.RESPONSE_OK))
chooser.set_default_response(gtk.RESPONSE_OK)
chooser.set_current_folder(const.internal_path(const.PATH_DATA))
chooser.set_select_multiple(True)
filter_keys = {} # used for reference later on
# add 'All Files' filter
blurb_all_files = "All Files"
filter = gtk.FileFilter()
filter.set_name(blurb_all_files)
filter.add_pattern("*")
chooser.add_filter(filter)
chooser.set_filter(filter)
filter_keys[blurb_all_files] = 'auto' # default if nothing else specified
# create file filters
for (key, importer) in ImporterRegistry.iteritems():
extensions = ';'.join(map(lambda ext: '*.'+ext, importer.extensions))
blurb = "%s (%s)" % (importer.blurb, extensions)
filter = gtk.FileFilter()
filter.set_name(blurb)
for ext in importer.extensions:
filter.add_pattern("*."+ext.lower())
filter.add_pattern("*."+ext.upper())
chooser.add_filter(filter)
filter_keys[blurb] = key
# add shortcut folder to example path, if such exists
shortcut_folder = const.internal_path(const.PATH_EXAMPLE)
if os.path.exists(shortcut_folder):
chooser.add_shortcut_folder(shortcut_folder)
#
# prepare extra widget
#
# The custom widget `combobox` lets the user choose,
# which Importer is to be used.
# model: key, blurb
model = gtk.ListStore(str, str)
# add 'Same as Filter' as first choice, then add all importers
model.append( (None, "Auto") )
for key, importer in ImporterRegistry.iteritems():
model.append( (key, importer.blurb) )
combobox = gtk.ComboBox(model)
cell = gtk.CellRendererText()
combobox.pack_start(cell, True)
combobox.add_attribute(cell, 'text', 1)
combobox.set_active(0)
combobox.show()
label = gtk.Label("Importer")
label.show()
hbox = gtk.HBox()
hbox.pack_end(combobox,False)
hbox.pack_end(label,False)
hbox.show()
# The progress bar display which file is currently being imported.
pbar = gtk.ProgressBar()
vbox = gtk.VBox()
vbox.pack_start(hbox,False)
vbox.pack_start(pbar,False)
vbox.show()
chooser.set_extra_widget(vbox)
#
# run dialog
#
try:
response = chooser.run()
if response == gtk.RESPONSE_OK:
filenames = chooser.get_filenames()
if len(filenames) == 0:
return
importer_key = model[combobox.get_active()][0]
if importer_key is None: # auto
f = chooser.get_filter()
importer_key = filter_keys[f.get_name()]
if importer_key is 'auto':
matches = importer_from_filename(filenames[0])
if len(matches) > 0:
importer_key = matches[0]
else:
importer_key = 'ASCII'
else:
return
# TODO
#chooser.set_active(False)
pbar.show()
# request import options
importer = ImporterRegistry[importer_key]()
try:
dialog = OptionsDialog(importer, parent=self.window)
except NoOptionsError:
pass
else:
# If there are any options, construct a
# preview widget to help the user.
view = gtk.TextView()
buffer = view.get_buffer()
view.set_editable(False)
view.show()
tag_main = buffer.create_tag(family="Courier")
tag_linenr = buffer.create_tag(family="Courier", weight=pango.WEIGHT_HEAVY)
# fill preview buffer with at most 100 lines
preview_file = filenames[0]
try:
fd = open(preview_file, 'r')
except IOError:
raise RuntimeError("Could not open file %s for preview!" % preview_file)
iter = buffer.get_start_iter()
try:
for j in range(100):
line = fd.readline()
if len(line) == 0:
break
buffer.insert_with_tags(iter, u"%3d\t" % j, tag_linenr)
try:
buffer.insert_with_tags(iter, unicode(line), tag_main)
except UnicodeDecodeError:
buffer.insert_with_tags(iter, u"<unreadable line>\n", tag_main)
finally:
fd.close()
preview_widget = uihelper.add_scrollbars(view)
preview_widget.show()
dialog.vbox.add(preview_widget)
dialog.set_size_request(480,320)
try:
result = dialog.run()
if result == gtk.RESPONSE_ACCEPT:
dialog.check_out
else:
return
finally:
dialog.destroy()
def set_text(queue):
while True:
try:
text, fraction = queue.get()
if text == -1:
pbar.hide()
elif text is not None:
pbar.set_text(text)
if fraction is not None:
pbar.set_fraction(fraction)
except QueueEmpty:
pass
yield None
queue = Queue()
thread_progress = GIdleThread(set_text(queue))
thread_progress.start()
thread_import = GIdleThread(self.import_datasets(pj, filenames, importer), queue)
thread_import.start()
thread_import.wait()
finally:
chooser.destroy()
