def load_blank(self, blank_fn):
results = jwslib.read_file(blank_fn)
error = True
if results[0] == jwslib.JWS_ERROR_SUCCESS:
blank_header = results[1]
blank_channels = results[2]
if len(blank_channels) < 1:
self.error(_("Error: Blank has no channel data.\n"))
else:
error = False
elif results[0] == jwslib.JWS_ERROR_COULD_NOT_READ_FILE:
self.error( _("Error reading blank file %(#)s:\n%(##)s\n") % \
{'#':blank_fn, '##':results[1] } )
elif results[0] == jwslib.JWS_ERROR_INVALID_FILE:
self.error(
_("Invalid blank file %(#)s:\n%(##)s\n") % {
'#': blank_fn,
'##': results[1]
})
else:
self.error(_("Unknown error loading blank\n"))
if error:
return None
else:
return (blank_header, blank_channels)
def _ctrls_click(self, instance):
if instance.id in self.property('view_mode').options:
self.view_mode = instance.id
elif instance.id == self.CTRL_NEW_FOLDER:
XTextInput(title=_('Input folder name'),
text=_('New folder'),
on_dismiss=self._create_dir)
def _get_form(self):
layout = BoxLayout(orientation='vertical', spacing=5)
layout.add_widget(Widget())
pnl = BoxLayout(size_hint_y=None, height=metrics.dp(28), spacing=5)
pnl.add_widget(
Factory.XLabel(text=_('Login:'******'right',
size_hint_x=None, width=metrics.dp(80)))
pnl.add_widget(TextInput(id='login', multiline=False,
font_size=metrics.sp(14), text=self.login))
layout.add_widget(pnl)
pnl = BoxLayout(size_hint_y=None, height=metrics.dp(28), spacing=5)
pnl.add_widget(
Factory.XLabel(text=_('Password:'******'right',
size_hint_x=None, width=metrics.dp(80)))
pnl.add_widget(TextInput(id='password', multiline=False, font_size=14,
password=True, text=self.password))
layout.add_widget(pnl)
if self.autologin is not None:
pnl = BoxLayout(size_hint_y=None, height=metrics.dp(28), spacing=5)
pnl.add_widget(CheckBox(
id='autologin', size_hint_x=None, width=metrics.dp(80),
active=self.autologin))
pnl.add_widget(
Factory.XLabel(text=_('Login automatically'), halign='left'))
layout.add_widget(pnl)
layout.add_widget(Widget())
return layout
def _create_widgets(self):
gtk.VBox.__init__(self)
option1 = gtk.RadioButton(
label=_("Save only one file, with a single X column"))
option2 = gtk.RadioButton(
label=_("Save only one file, with multiple X columns"),
group=option1)
option3 = gtk.RadioButton(label=_("Save in multiple files"),
group=option1)
option4 = gtk.RadioButton(label=_("Don't save"), group=option1)
column_headers = gtk.CheckButton(_("Write the name of each column"))
column_headers.set_active(False)
self.get_column_headers_option = column_headers.get_active
self.pack_start(option1, False, False, 0)
self.pack_start(option2, False, False, 0)
self.pack_start(option3, False, False, 0)
self.pack_start(option4, False, False, 0)
self.pack_start(gtk.HSeparator(), False, False, 0)
self.pack_start(column_headers, False, False, 0)
self.show_all()
self.onefile_onex = option1
self.onefile_multiplex = option2
self.multiplefiles = option3
self.dontsave = option4
def __init__(self):
self.blank_msg = \
_("""The selected blank is among the files to be processed.
Do you really want to continue?""")
self.heterogeneus_xvalues_msg = \
_("""No every file has the same data pitch o data does
not always begin at the same wavelength. Do you want to
save data with a column for X values for each spectrum?
""")
self.intro_msg = \
_("""Welcome to jwsProcessor.
This assistant consists on four steps:
#1 Select the .jws files to be processed
#2 Choose the processing options
#3 Process of the files
#4 Save the results
""")
# Set Internal variables
self.options = ProcessOptions()
self.spc_list = []
self.processed_files = []
self.processed_list = []
self.success_count = 0
self.current_folder = config.get(CFGFILE_SECTION, LAST_DIR_STR)
self.__no_files_processed = False
self._create_widgets()
def error(self, errStr, cfgPath):
""" Error handler GUI implementation """
# it must handle two types of error cases:
# - yandex-disk is not installed (errStr=='' in that case) - just show error message and return
# - yandex-disk is not configured (errStr!='' in that case) - suggest to configure it and run ya-setup if needed
if errStr == '':
text1 = _('Yandex.Disk Indicator: daemon start failed')
buttons = Gtk.ButtonsType.OK
text2 = (_(
'Yandex.Disk utility is not installed.\n' +
'Visit www.yandex.ru, download and install Yandex.Disk daemon.'
))
else:
text1 = _('Yandex.Disk Indicator: daemon start failed')
buttons = Gtk.ButtonsType.OK_CANCEL
text2 = (_(
'Yandex.Disk daemon failed to start because it is not' +
' configured properly\n\n' + errStr + '\n\n' +
' To configure it up: press OK button.\n Press Cancel to exit.'
))
dialog = Gtk.MessageDialog(None, 0, Gtk.MessageType.INFO, buttons,
text1)
dialog.format_secondary_text(text2)
dialog.set_icon(APPLOGO)
response = dialog.run()
if errStr != '' and response == Gtk.ResponseType.OK: # Launch Set-up utility
LOGGER.debug('starting configuration utility')
retCode = call([pathJoin(APPINSTPATH, 'ya-setup'), cfgPath])
else:
retCode = 1
dialog.destroy()
return retCode # 0 when error is not critical or fixed (daemon has been configured via ya-setup)
class XFolder(XFilePopup):
"""XFolder class. See module documentation for more information.
"""
BUTTON_SELECT = _('Select')
TXT_ERROR_SELECTION = _('Maybe you should select a folders?')
title = StringProperty(_('Choose folder'))
'''Default title for the popup
'''
buttons = ListProperty([BUTTON_SELECT, XFilePopup.BUTTON_CANCEL])
'''Default button set for the popup
'''
def __init__(self, **kwargs):
super(XFolder, self).__init__(**kwargs)
# enabling the folder selection if multiselect is allowed
if self.multiselect:
self.dirselect = True
def dismiss(self, *largs, **kwargs):
"""Pre-validation before closing.
"""
if self.button_pressed == self.BUTTON_SELECT:
if not self.multiselect:
# setting current path as a selection
self.selection = [self.path]
self._filter_selection(files=False)
if len(self.selection) == 0:
# folders must be selected
XError(text=self.TXT_ERROR_SELECTION)
return self
return super(XFolder, self).dismiss(*largs, **kwargs)
def __init__(self):
self.blank_msg = \
_("""The selected blank is among the files to be processed.
Do you really want to continue?""")
self.heterogeneus_xvalues_msg = \
_("""No every file has the same data pitch o data does
not always begin at the same wavelength. Do you want to
save data with a column for X values for each spectrum?
""")
self.intro_msg = \
_("""Welcome to jwsProcessor.
This assistant consists on four steps:
#1 Select the .jws files to be processed
#2 Choose the processing options
#3 Process of the files
#4 Save the results
""")
# Set Internal variables
self.options = ProcessOptions()
self.spc_list = []
self.processed_files = []
self.processed_list = []
self.success_count = 0
self.current_folder = config.get(CFGFILE_SECTION, LAST_DIR_STR)
self.__no_files_processed = False
self._create_widgets()
def _ctrls_click(self, instance):
if instance.id in self.property('view_mode').options:
self.view_mode = instance.id
elif instance.id == self.CTRL_NEW_FOLDER:
XTextInput(title=_('Input folder name'),
text=_('New folder'),
on_dismiss=self._create_dir)
class XFileSave(XFilePopup):
"""XFileSave class. See module documentation for more information.
"""
BUTTON_SAVE = _('Save')
TXT_ERROR_FILENAME = _('Maybe you should enter a filename?')
filename = StringProperty(u'')
'''Represents entered file name. Can be used for setting default value.
'''
title = StringProperty(_('Save file'))
'''Default title for the popup
'''
buttons = ListProperty([BUTTON_SAVE, XFilePopup.BUTTON_CANCEL])
'''Default button set for the popup
'''
def _get_body(self):
txt = TextInput(id='filename',
text=self.filename,
multiline=False,
size_hint_y=None,
height=metrics.dp(30))
txt.bind(text=self.setter('filename'))
self.bind(filename=txt.setter('text'))
layout = super(XFileSave, self)._get_body()
layout.add_widget(txt)
return layout
def on_selection(self, *largs):
if len(self.selection) == 0:
return
if not self.browser.file_system.is_dir(self.selection[0]):
self.filename = self.selection[0].split(path.sep)[-1]
def dismiss(self, *largs, **kwargs):
"""Pre-validation before closing.
"""
if self.button_pressed == self.BUTTON_SAVE:
if self.filename == '':
# must be entered filename
XError(text=self.TXT_ERROR_FILENAME)
return self
return super(XFileSave, self).dismiss(*largs, **kwargs)
def get_full_name(self):
"""Returns full filename (including path)
"""
return self.path + path.sep + self.filename
def _ctrls_init(self):
pnl_controls = BoxLayout(size_hint_y=None, height=metrics.dp(25))
pnl_controls.add_widget(Factory.XButton(
text=_('Icons'), id=self.CTRL_VIEW_ICON,
on_release=self._ctrls_click))
pnl_controls.add_widget(Factory.XButton(
text=_('List'), id=self.CTRL_VIEW_LIST,
on_release=self._ctrls_click))
pnl_controls.add_widget(Factory.XButton(
text=_('New folder'), id=self.CTRL_NEW_FOLDER,
on_release=self._ctrls_click))
return pnl_controls
def __init__(self, session):
Screen.__init__(self, session)
self.onChangedEntry = [ ]
self.list = [ ]
ConfigListScreen.__init__(self, self.list, session = session, on_change = self.changedEntry)
self.setup_title = "Settings config"
self["key_green"] = Label(_("Save"))
self["key_red"] = Label(_("Cancel"))
self["key_blue"] = Label('VK')
self.iptvtools_GetGITversion = ''
try:
import tarfile
UpdateAvailable = True
except:
UpdateAvailable = False
if UpdateAvailable == True:
try:
from _version import version as wersja
from tools import GetGITversion as iptvtools_GetGITversion
self.iptvtools_GetGITversion = iptvtools_GetGITversion()
if iptvtools_GetGITversion() == wersja:
UpdateAvailable = False
except:
pass
if UpdateAvailable == True:
self["key_yellow"] = Label(_('Update'))
self["actions"] = ActionMap(["SetupActions", "ColorActions"],
{
"cancel": self.keyCancel,
"green": self.keySave,
"ok": self.keyOK,
"red": self.keyCancel,
"blue": self.keyVirtualKeyBoard,
"yellow": self.keyUpdate,
}, -2)
else:
self["key_yellow"] = Label(_('v. up-2-date'))
self["actions"] = ActionMap(["SetupActions", "ColorActions"],
{
"cancel": self.keyCancel,
"green": self.keySave,
"ok": self.keyOK,
"red": self.keyCancel,
"blue": self.keyVirtualKeyBoard,
}, -2)
self.runSetup()
self.onLayoutFinish.append(self.layoutFinished)
def _ctrls_init(self):
pnl_controls = BoxLayout(size_hint_y=None, height=metrics.dp(25))
pnl_controls.add_widget(
Factory.XButton(text=_('Icons'),
id=self.CTRL_VIEW_ICON,
on_release=self._ctrls_click))
pnl_controls.add_widget(
Factory.XButton(text=_('List'),
id=self.CTRL_VIEW_LIST,
on_release=self._ctrls_click))
pnl_controls.add_widget(
Factory.XButton(text=_('New folder'),
id=self.CTRL_NEW_FOLDER,
on_release=self._ctrls_click))
return pnl_controls
def __init__(self, parent=None):
self.parent_form = parent
self.loop_running = False
self.base_label_text = _("Processing files...")
gtk.Window.__init__(self)
self.create_widgets()
def _on_click(self, instance):
"""Pre-dismiss method.
Gathers widget values. Checks the required fields.
Ignores it all if the "Cancel" was pressed.
"""
if instance.id != self.BUTTON_CANCEL:
self.values = {}
required_errors = []
for widget in self._ui_form_container.walk(restrict=True):
t_id = widget.id
if t_id is not None:
if isinstance(widget, TextInput):
t_value = widget.text
if self.required_fields and\
t_id in self.required_fields.keys()\
and not t_value:
required_errors.append(self.required_fields[t_id])
elif isinstance(widget, Switch)\
or isinstance(widget, CheckBox):
t_value = widget.active
elif isinstance(widget, Slider):
t_value = widget.value
else:
t_value = 'Not supported: ' + widget.__class__.__name__
self.values[t_id] = t_value
if required_errors:
XError(text=_('Following fields are required:\n') +
', '.join(required_errors))
return
super(XForm, self)._on_click(instance)
def _on_click(self, instance):
"""Pre-dismiss method.
Gathers widget values. Checks the required fields.
Ignores it all if the "Cancel" was pressed.
"""
if instance.id != self.BUTTON_CANCEL:
self.values = {}
required_errors = []
for widget in self._ui_form_container.walk(restrict=True):
t_id = widget.id
if t_id is not None:
if isinstance(widget, TextInput):
t_value = widget.text
if self.required_fields and\
t_id in self.required_fields.keys()\
and not t_value:
required_errors.append(self.required_fields[t_id])
elif isinstance(widget, Switch)\
or isinstance(widget, CheckBox):
t_value = widget.active
elif isinstance(widget, Slider):
t_value = widget.value
else:
t_value = 'Not supported: ' + widget.__class__.__name__
self.values[t_id] = t_value
if required_errors:
XError(text=_('Following fields are required:\n') +
', '.join(required_errors))
return
super(XForm, self)._on_click(instance)
def __init__(self, parent=None):
self.parent_form = parent
self.loop_running = False
self.base_label_text = _("Processing files...")
gtk.Window.__init__(self)
self.create_widgets()
def __init__(self, path, ID):
# Create indicator notification engine
self.notify = Notification(_('Yandex.Disk ') + ID)
# Setup icons theme
self.setIconTheme(APPCONF['theme'])
# Create staff for icon animation support (don't start it here)
self._seqNum = 2 # Number current busy icon
def iconAnimation(
): # Changes busy icon by loop (triggered by self.timer)
# As it called from timer (main GUI thread) there is no need to use idle_add here
# Set next animation icon
self.ind.set_icon_full(
pathJoin(self.themePath,
'yd-busy' + str(self._seqNum) + '.png'), '')
# Calculate next icon number
self._seqNum = self._seqNum % 5 + 1 # 5 icon numbers in loop (1-2-3-4-5-1-2-3...)
return True # True required to continue triggering by timer
self.iconTimer = self.Timer(777, iconAnimation, start=False)
# Create App Indicator
self.ind = appIndicator.Indicator.new(
"yandex-disk-%s" % ID[1:-1], self.icon['paused'],
appIndicator.IndicatorCategory.APPLICATION_STATUS)
self.ind.set_status(appIndicator.IndicatorStatus.ACTIVE)
self.menu = self.Menu(self, ID) # Create menu for daemon
self.ind.set_menu(self.menu) # Attach menu to indicator
# Initialize Yandex.Disk daemon connection object
super().__init__(path, ID)
self.currentStatus = None # Current daemon status
def process_files(self, spectra_list, options):
''' Returns None if blank could not be loaded
Returns a tupple (process_dict, success_count)
* process_dict: a dictionary with processed files and the results
of the processing:
process_dict[filename] = (jws_header, channel_data_list)
or
process_dict[filename] = None
(if filename couldn't be processed)
* success_count: number of the files successfully processed
* report_failed: if False, process_dict will contain only files
sucessfully processed, i.e. all process_dict entries will have
as value a tuple (jws_header, cannel_data_list)
'''
self.start_loop()
if options.subtract_blank:
self.info(_("\n**Loading blank file: %s**\n") % options.blank_fn)
results = self.load_blank(options.blank_fn)
if results:
(blank_header, blank_channels) = results
else:
self.abort_loop(_("Blank could not be loaded"))
return None
else:
blank_header = None
blank_channels = None
processed_files = {}
processed_list = []
total = len(spectra_list)
counter = 0
success_count = 0
for input_fn, dilution_factor in spectra_list:
counter += 1
self.progress(counter, total)
self.info(_("\n**Processing %s**\n") % input_fn)
# process_file() returns a tuple (header, channels) or None if failed
results = self.process_file(input_fn, dilution_factor,
blank_header, blank_channels, options)
if results:
processed_files[input_fn] = results
processed_list.append(input_fn)
success_count += 1
self.finish_loop(_("\nSuccessfully processed %(#)d of %(#)d files\n") % \
{'#':success_count, '##':total})
return (processed_files, processed_list, success_count)
def _create_widgets(self):
def create_label(text):
label = gtk.Label(text)
label.show()
return label
self.smoothing_list = gtk.ListStore(str)
smoothing_types = ("Mean-movement", "Savitsky-Golay", _("No smoothing"))
for smt in smoothing_types:
self.smoothing_list.append([smt])
cell = gtk.CellRendererText()
self.smoothing_combo = gtk.ComboBox(self.smoothing_list)
self.smoothing_combo.pack_start(cell, True)
self.smoothing_combo.add_attribute(cell, 'text', 0)
self.smoothing_combo.show()
self.m_spinner = gtk.SpinButton()
self.m_spinner.set_range(5, 25)
self.m_spinner.set_increments(1,5)
self.m_spinner.show()
self.p_spinner = gtk.SpinButton()
self.p_spinner.set_range(1,6)
self.p_spinner.set_increments(1,1)
self.p_spinner.show()
sc_hbox = gtk.HBox()
sc_hbox.pack_start(create_label(_("Smoothing type:")), False, False, 0)
sc_hbox.pack_end(self.smoothing_combo, False, True, 0)
sc_hbox.show()
sm_hbox = gtk.HBox()
sm_hbox.pack_start(create_label(_("Smoothing level(m):")), False, False, 0)
sm_hbox.pack_end(self.m_spinner, False, False, 0)
sm_hbox.show()
sp_hbox = gtk.HBox()
sp_hbox.pack_start(create_label(_("S-G filter order (p):")), False, False, 0)
sp_hbox.pack_end(self.p_spinner, False, False, 0)
sp_hbox.show()
self.sp_hbox = sp_hbox
self.figure = Figure(figsize=(5,4))
self.canvas = FigureCanvas(self.figure)
self.canvas.show()
self.vbox.pack_start(sc_hbox, False, False, 0)
self.vbox.pack_start(sm_hbox, False, False, 0)
self.vbox.pack_start(sp_hbox, False, False, 0)
self.vbox.pack_start(self.canvas, True, True, 0)
self.set_default_size(400,400)
def process_files(self, spectra_list, options):
''' Returns None if blank could not be loaded
Returns a tupple (process_dict, success_count)
* process_dict: a dictionary with processed files and the results
of the processing:
process_dict[filename] = (jws_header, channel_data_list)
or
process_dict[filename] = None
(if filename couldn't be processed)
* success_count: number of the files successfully processed
* report_failed: if False, process_dict will contain only files
sucessfully processed, i.e. all process_dict entries will have
as value a tuple (jws_header, cannel_data_list)
'''
self.start_loop()
if options.subtract_blank:
self.info(_("\n**Loading blank file: %s**\n") % options.blank_fn)
results = self.load_blank(options.blank_fn)
if results:
(blank_header, blank_channels) = results
else:
self.abort_loop(_("Blank could not be loaded"))
return None
else:
blank_header = None
blank_channels = None
processed_files = {}
processed_list = []
total = len(spectra_list)
counter = 0
success_count = 0
for input_fn, dilution_factor in spectra_list:
counter += 1
self.progress(counter, total)
self.info(_("\n**Processing %s**\n") % input_fn)
# process_file() returns a tuple (header, channels) or None if failed
results = self.process_file(input_fn, dilution_factor, blank_header, blank_channels, options)
if results:
processed_files[input_fn] = results
processed_list.append(input_fn)
success_count += 1
self.finish_loop(_("\nSuccessfully processed %(#)d of %(#)d files\n") % \
{'#':success_count, '##':total})
return (processed_files, processed_list, success_count)
def update(self, vals, yddir): # Update information in menu
self.folder = yddir
# Update status data on first run or when status has changed
if vals['statchg'] or vals['laststatus'] == 'unknown':
self.status.set_label(
_('Status: ') + self.YD_STATUS[vals['status']] +
(vals['progress'] if vals['status'] == 'busy' else ' '.
join((':', vals['error'], shortPath(vals['path'])
)) if vals['status'] == 'error' else ''))
# Update pseudo-static items on first run or when daemon has stopped or started
if 'none' in (vals['status'], vals['laststatus']
) or vals['laststatus'] == 'unknown':
started = vals['status'] != 'none'
self.status.set_sensitive(started)
# zero-space UTF symbols are used to detect requered action without need to compare translated strings
self.daemon_ss.set_label((
'\u2060' +
_('Stop Yandex.Disk daemon')) if started else (
'\u200B' + _('Start Yandex.Disk daemon')))
if self.ID != '': # Set daemon identity row in multidaemon mode
self.yddir.set_label(self.ID + _(' Folder: ') +
(shortPath(yddir) if yddir else
'< NOT CONFIGURED >'))
self.open_folder.set_sensitive(
yddir !=
'') # Activate Open YDfolder if daemon configured
# Update sizes data on first run or when size data has changed
if vals['szchg'] or vals['laststatus'] == 'unknown':
self.used.set_label(
_('Used: ') + vals['used'] + '/' + vals['total'])
self.free.set_label(
_('Free: ') + vals['free'] + _(', trash: ') +
vals['trash'])
# Update last synchronized sub-menu on first run or when last data has changed
if vals['lastchg'] or vals['laststatus'] == 'unknown':
# Update last synchronized sub-menu
self.lastItems.destroy(
) # Disable showing synchronized sub menu while updating it - temp fix for #197
self.lastItems = Gtk.Menu() # Create new/empty Sub-menu:
for filePath in vals['lastitems']: # Create new sub-menu items
# Create menu label as file path (shorten it down to 50 symbols when path length > 50
# symbols), with replaced underscore (to disable menu acceleration feature of GTK menu).
widget = Gtk.MenuItem.new_with_label(shortPath(filePath))
filePath = pathJoin(yddir,
filePath) # Make full path to file
if pathExists(filePath):
widget.set_sensitive(
True) # If it exists then it can be opened
widget.connect("activate", self.openPath, filePath)
else:
widget.set_sensitive(
False) # Don't allow to open non-existing path
self.lastItems.append(widget)
self.last.set_submenu(self.lastItems)
# Switch off last items menu sensitivity if no items in list
self.last.set_sensitive(vals['lastitems'])
LOGGER.debug("Sub-menu 'Last synchronized' has %s items",
str(len(vals['lastitems'])))
self.show_all() # Renew menu
def _get_form(self):
layout = BoxLayout(orientation='vertical', spacing=5)
layout.add_widget(Widget())
pnl = BoxLayout(size_hint_y=None, height=metrics.dp(28), spacing=5)
pnl.add_widget(
Factory.XLabel(text=_('Login:'******'right',
size_hint_x=None,
width=metrics.dp(80)))
pnl.add_widget(
TextInput(id='login',
multiline=False,
font_size=metrics.sp(14),
text=self.login))
layout.add_widget(pnl)
pnl = BoxLayout(size_hint_y=None, height=metrics.dp(28), spacing=5)
pnl.add_widget(
Factory.XLabel(text=_('Password:'******'right',
size_hint_x=None,
width=metrics.dp(80)))
pnl.add_widget(
TextInput(id='password',
multiline=False,
font_size=14,
password=True,
text=self.password))
layout.add_widget(pnl)
if self.autologin is not None:
pnl = BoxLayout(size_hint_y=None, height=metrics.dp(28), spacing=5)
pnl.add_widget(
CheckBox(id='autologin',
size_hint_x=None,
width=metrics.dp(80),
active=self.autologin))
pnl.add_widget(
Factory.XLabel(text=_('Login automatically'), halign='left'))
layout.add_widget(pnl)
layout.add_widget(Widget())
return layout
def __init__(self, initial_params=ProteinInfo("C-LytA", 15840, 136),
parent=None):
gtk.Dialog.__init__(self, title=_("Calculate correction factor"),
parent=parent, flags=gtk.DIALOG_MODAL,
buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT,
gtk.STOCK_OK, gtk.RESPONSE_ACCEPT))
self._create_widgets()
self._configure_widgets(initial_params)
self.protein_info = initial_params
self.correction_factor = 0
def do_display(outText, widget):
# global APPLOGO
statusWindow = Gtk.Dialog(
_('Yandex.Disk daemon output message'))
statusWindow.set_icon(APPLOGO)
statusWindow.set_border_width(6)
statusWindow.add_button(_('Close'), Gtk.ResponseType.CLOSE)
textBox = Gtk.TextView(
) # Create text-box to display daemon output
# Set output buffer with daemon output in user language
textBox.get_buffer().set_text(outText)
textBox.set_editable(False)
# Put it inside the dialogue content area
statusWindow.get_content_area().pack_start(
textBox, True, True, 6)
statusWindow.show_all()
statusWindow.run()
statusWindow.destroy()
widget.set_sensitive(True) # Enable menu item
def addFolder(self, widget,
parent): # Add new path to list via FileChooserDialog
dialog = Gtk.FileChooserDialog(
_('Select catalogue to add to list'), parent,
Gtk.FileChooserAction.SELECT_FOLDER,
(_('Close'), Gtk.ResponseType.CANCEL, _('Select'),
Gtk.ResponseType.ACCEPT))
dialog.set_default_response(Gtk.ResponseType.CANCEL)
dialog.set_select_multiple(True)
rootDir = self.dconfig['dir']
dialog.set_current_folder(rootDir)
if dialog.run() == Gtk.ResponseType.ACCEPT:
for path in dialog.get_filenames():
if path.startswith(rootDir):
path = relativePath(path, start=rootDir)
if path not in self.dirset:
self.exList.append([False, path])
self.dirset.append(path)
self.dconfig.changed = True
dialog.destroy()
def _create_dir(self, instance):
"""Callback for create a new folder.
"""
if instance.is_canceled():
return
new_folder = self.path + path.sep + instance.get_value()
if path.exists(new_folder):
XError(text=_('Folder "%s" is already exist. Maybe you should '
'enter another name?') % instance.get_value())
return True
makedirs(new_folder)
self.browser.property('path').dispatch(self.browser)
def _create_dir(self, instance):
"""Callback for create a new folder.
"""
if instance.is_canceled():
return
new_folder = self.path + path.sep + instance.get_value()
if path.exists(new_folder):
XError(text=_('Folder "%s" is already exist. Maybe you should '
'enter another name?') % instance.get_value())
return True
makedirs(new_folder)
self.browser.property('path').dispatch(self.browser)
def print_header_info(self, header, fn):
header_info = _('''Information for file %(fn)s
-Channels %(chans)d
-Points: %(points)d
-From %(fp)f to %(lp)f
-Data pitch: %(dp)f\n''') % {'fn': fn,
'chans':header.channel_number,
'points':header.point_number,
'fp': header.x_for_first_point,
'lp':header.x_for_last_point,
'dp':header.x_increment }
self.info(header_info)
def do_change(vals, path):
""" Update information in menu """
self.menu.update(vals, path)
# Handle daemon status change by icon change
if vals['status'] != vals['laststatus']:
LOGGER.info('Status: %s -> %s', vals['laststatus'],
vals['status'])
self.updateIcon(vals['status']) # Update icon
# Create notifications for status change events
if APPCONF['notifications']:
if vals['laststatus'] == 'none': # Daemon has been started
self.notify.send(
_('Yandex.Disk daemon has been started'))
if vals['status'] == 'busy': # Just entered into 'busy'
self.notify.send(_('Synchronization started'))
elif vals['status'] == 'idle': # Just entered into 'idle'
if vals['laststatus'] == 'busy': # ...from 'busy' status
self.notify.send(
_('Synchronization has been completed'))
elif vals[
'status'] == 'paused': # Just entered into 'paused'
if vals['laststatus'] not in [
'none', 'unknown'
]: # ...not from 'none'/'unknown' status
self.notify.send(
_('Synchronization has been paused'))
elif vals[
'status'] == 'none': # Just entered into 'none' from some another status
if vals['laststatus'] != 'unknown': # ... not from 'unknown'
self.notify.send(
_('Yandex.Disk daemon has been stopped'))
else: # status is 'error' or 'no-net'
self.notify.send(_('Synchronization ERROR'))
# Remember current status (required for Preferences dialog)
self.currentStatus = vals['status']
class XNotifyBase(XBase):
"""XNotifyBase class. See module documentation for more information.
"""
text = StringProperty('')
'''This property represents text on the popup.
:attr:`text` is a :class:`~kivy.properties.StringProperty` and defaults to
''.
'''
dont_show_text = StringProperty(_('Do not show this message again'))
'''Use this property if you want to use custom text instead of
'Do not show this message'.
:attr:`text` is a :class:`~kivy.properties.StringProperty`.
'''
dont_show_value = BooleanProperty(None, allownone=True)
'''This property represents a state of checkbox 'Do not show this message'.
To enable checkbox, set this property to True or False.
.. versionadded:: 0.2.1
:attr:`dont_show_value` is a :class:`~kivy.properties.BooleanProperty` and
defaults to None.
'''
def __init__(self, **kwargs):
self._message = Factory.XLabel(text=self.text)
self.bind(text=self._message.setter('text'))
super(XNotifyBase, self).__init__(**kwargs)
def _get_body(self):
if self.dont_show_value is None:
return self._message
else:
pnl = BoxLayout(orientation='vertical')
pnl.add_widget(self._message)
pnl_cbx = BoxLayout(size_hint_y=None,
height=metrics.dp(35),
spacing=5)
cbx = CheckBox(active=self.dont_show_value,
size_hint_x=None,
width=metrics.dp(50))
cbx.bind(active=self.setter('dont_show_value'))
pnl_cbx.add_widget(cbx)
pnl_cbx.add_widget(
Factory.XLabel(text=self.dont_show_text, halign='left'))
pnl.add_widget(pnl_cbx)
return pnl
def _prepare_cb(self, assistant, page):
if page == self.options_page:
self.current_folder = self.selection_page.current_folder
self.options_page.current_folder = self.selection_page.current_folder
self.options_page.check_blank_options()
elif page == self.summary_page:
self.current_folder = self.options_page.current_folder
elif page == self.save_options_page:
pass
elif page == self.final_page:
if self.__no_files_processed:
self.final_page.set_text(_("No file could be processed."))
self.add_action_widget(self.restart_button)
def load_blank(self, blank_fn):
results = jwslib.read_file(blank_fn)
error = True
if results[0] == jwslib.JWS_ERROR_SUCCESS:
blank_header = results[1]
blank_channels = results[2]
if len(blank_channels) < 1:
self.error(_("Error: Blank has no channel data.\n"))
else:
error = False
elif results[0] == jwslib.JWS_ERROR_COULD_NOT_READ_FILE:
self.error( _("Error reading blank file %(#)s:\n%(##)s\n") % \
{'#':blank_fn, '##':results[1] } )
elif results[0] == jwslib.JWS_ERROR_INVALID_FILE:
self.error(_("Invalid blank file %(#)s:\n%(##)s\n") % {'#':blank_fn, '##':results[1]})
else:
self.error(_("Unknown error loading blank\n"))
if error:
return None
else:
return (blank_header, blank_channels)
def _prepare_cb(self, assistant, page):
if page == self.options_page:
self.current_folder = self.selection_page.current_folder
self.options_page.current_folder = self.selection_page.current_folder
self.options_page.check_blank_options()
elif page == self.summary_page:
self.current_folder = self.options_page.current_folder
elif page == self.save_options_page:
pass
elif page == self.final_page:
if self.__no_files_processed:
self.final_page.set_text(_("No file could be processed."))
self.add_action_widget(self.restart_button)
def __init__(self,
initial_params=ProteinInfo("C-LytA", 15840, 136),
parent=None):
gtk.Dialog.__init__(self,
title=_("Calculate correction factor"),
parent=parent,
flags=gtk.DIALOG_MODAL,
buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT,
gtk.STOCK_OK, gtk.RESPONSE_ACCEPT))
self._create_widgets()
self._configure_widgets(initial_params)
self.protein_info = initial_params
self.correction_factor = 0
def print_header_info(self, header, fn):
header_info = _('''Information for file %(fn)s
-Channels %(chans)d
-Points: %(points)d
-From %(fp)f to %(lp)f
-Data pitch: %(dp)f\n''') % {
'fn': fn,
'chans': header.channel_number,
'points': header.point_number,
'fp': header.x_for_first_point,
'lp': header.x_for_last_point,
'dp': header.x_increment
}
self.info(header_info)
def runSetup(self):
self.list.append(getConfigListEntry(_("Picons size:"), config.plugins.SparkWall.IconsSize))
#self.list.append(getConfigListEntry(_("Scale Picons? (slower)"), config.plugins.SparkWall.ScaleIcons))
self.list.append(getConfigListEntry(_("Zap mode:"), config.plugins.SparkWall.ZapMode))
self.list.append(getConfigListEntry(_("AutoPreview delay:"), config.plugins.SparkWall.usePIG))
self.list.append(getConfigListEntry(_("Show PIG (miniTV) window?"), config.plugins.SparkWall.usePIG))
self.list.append(getConfigListEntry(_("PIG size/Descr width:"), config.plugins.SparkWall.PIGSize))
self.list.append(getConfigListEntry(_("Show plugin on the Extensions menu?"), config.plugins.SparkWall.showinextensions))
self.list.append(getConfigListEntry(_("Show plugin in main menu?"), config.plugins.SparkWall.showinMainMenu))
self.list.append(getConfigListEntry(_("Enable DEBUG?"), config.plugins.SparkWall.debugprint))
self["config"].list = self.list
self["config"].setList(self.list)
def sl_add_button_cb(self, button, user_data=None):
fs_dialog = JwsFileChooserDialog( parent= self.assistant,
current_folder = self.current_folder,
title=_("Open spectra..."))
response = fs_dialog.run()
if response == gtk.RESPONSE_OK:
#En windows hay que recodificar los nombres de archivo!!
fns = [fn.decode('utf-8') for fn in fs_dialog.get_filenames()]
else:
fns = None
if fns:
self.spectra_db.append_files(fns)
self.current_folder = fs_dialog.get_current_folder().decode('utf-8')
fs_dialog.destroy()
def blank_open_cb(self, button, user_data=None):
fs_dialog = JwsFileChooserDialog( parent= self.assistant,
current_folder = self.current_folder,
title=_("Open spectrum..."))
fs_dialog.set_select_multiple(False)
response = fs_dialog.run()
if response == gtk.RESPONSE_OK:
fn = fs_dialog.get_filename().decode('utf-8')
header = jwslib.read_header(fn)
if header:
self.blank_entry.set_text(fn)
self.blank_header = header
self.current_folder = fs_dialog.get_current_folder().decode('utf-8')
fs_dialog.destroy()
def sl_add_button_cb(self, button, user_data=None):
fs_dialog = JwsFileChooserDialog(parent=self.assistant,
current_folder=self.current_folder,
title=_("Open spectra..."))
response = fs_dialog.run()
if response == gtk.RESPONSE_OK:
#En windows hay que recodificar los nombres de archivo!!
fns = [fn.decode('utf-8') for fn in fs_dialog.get_filenames()]
else:
fns = None
if fns:
self.spectra_db.append_files(fns)
self.current_folder = fs_dialog.get_current_folder().decode(
'utf-8')
fs_dialog.destroy()
class XFileOpen(XFilePopup):
"""XFileOpen class. See module documentation for more information.
"""
BUTTON_OPEN = _('Open')
TXT_ERROR_SELECTION = _('Maybe you should select a file?')
title = StringProperty(_('Open file'))
'''Default title for the popup
'''
buttons = ListProperty([BUTTON_OPEN, XFilePopup.BUTTON_CANCEL])
'''Default button set for the popup
'''
def dismiss(self, *largs, **kwargs):
"""Pre-validation before closing.
"""
if self.button_pressed == self.BUTTON_OPEN:
self._filter_selection(folders=False)
if len(self.selection) == 0:
# files must be selected
XError(text=self.TXT_ERROR_SELECTION)
return self
return super(XFileOpen, self).dismiss(*largs, **kwargs)
def __init__(self, input_fn, options=ProcessOptions(), parent=None):
results = jwslib.read_file(input_fn)
error = True
if results[0] == jwslib.JWS_ERROR_SUCCESS:
header = results[1]
channels = results[2]
if len(channels) > 0:
error = False
if error:
raise Exception, "File %s could not be loaded" % input_fn
(head, tail) = os.path.split(input_fn) # head=path; tail=nombre arch.
title = _("Showing %s") % tail
SmoothingSelectionDialog.__init__(self, header, channels, options,
parent, title,
(gtk.STOCK_CLOSE, gtk.RESPONSE_OK))
def __init__(self, widget, parent, dcofig): # show current list
self.dconfig = dcofig
self.parent = parent
Gtk.Dialog.__init__(
self,
title=_('Folders that are excluded from synchronization'),
parent=parent,
flags=1)
self.set_icon(APPLOGO)
self.set_size_request(400, 300)
self.add_button(_('Add catalogue'),
Gtk.ResponseType.APPLY).connect(
"clicked", self.addFolder, self)
self.add_button(_('Remove selected'),
Gtk.ResponseType.REJECT).connect(
"clicked", self.deleteSelected)
self.add_button(_('Close'), Gtk.ResponseType.CLOSE).connect(
"clicked", self.exitFromDialog)
self.exList = Gtk.ListStore(bool, str)
view = Gtk.TreeView(model=self.exList)
render = Gtk.CellRendererToggle()
render.connect("toggled", self.lineToggled)
view.append_column(Gtk.TreeViewColumn(" ", render, active=0))
view.append_column(
Gtk.TreeViewColumn(_('Path'), Gtk.CellRendererText(), text=1))
scroll = Gtk.ScrolledWindow()
scroll.add_with_viewport(view)
self.get_content_area().pack_start(scroll, True, True, 6)
# Populate list with paths from "exclude-dirs" property of daemon configuration
self.dirset = [
val for val in CVal(self.dconfig.get('exclude-dirs', None))
]
for val in self.dirset:
self.exList.append([False, val])
# LOGGER.debug(str(self.dirset))
self.show_all()
def _choose_folder_to_save(self):
return_value = None
buttons = ( gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
gtk.STOCK_SAVE, gtk.RESPONSE_OK )
fs_dialog = gtk.FileChooserDialog( title=_("Select a folder"),
action= gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER,
buttons= buttons )
fs_dialog.set_select_multiple(False)
fs_dialog.set_current_folder(self.selection_page.current_folder)
response = fs_dialog.run()
if response == gtk.RESPONSE_OK:
folder = fs_dialog.get_filename().decode('utf-8')
self.selection_page.current_folder = fs_dialog.get_current_folder().decode('utf-8')
return_value = folder
fs_dialog.destroy()
return return_value
class XConfirmation(XNotifyBase):
"""XConfirmation class. See module documentation for more information.
"""
buttons = ListProperty([XNotifyBase.BUTTON_YES, XNotifyBase.BUTTON_NO])
'''Default button set for class
'''
title = StringProperty(_('Confirmation'))
'''Default title for class
'''
def is_confirmed(self):
"""Check the `Yes` event
:return: True, if the button 'Yes' has been pressed
"""
return self.button_pressed == self.BUTTON_YES
def complete(self, text=_('Complete'), show_time=2):
"""
Sets the progress to 100%, hides the button(s) and automatically
closes the popup.
.. versionchanged:: 0.2.1
Added parameters 'text' and 'show_time'
:param text: text instead of 'Complete', optional
:param show_time: time-to-close (in seconds), optional
"""
self._complete = True
n = self.max
self.value = n
self.text = text
self.buttons = []
Clock.schedule_once(self.dismiss, show_time)
def complete(self, text=_('Complete'), show_time=2):
"""
Sets the progress to 100%, hides the button(s) and automatically
closes the popup.
.. versionchanged:: 0.2.1
Added parameters 'text' and 'show_time'
:param text: text instead of 'Complete', optional
:param show_time: time-to-close (in seconds), optional
"""
self._complete = True
n = self.max
self.value = n
self.text = text
self.buttons = []
Clock.schedule_once(self.dismiss, show_time)
def __init__(self, parent, current_folder=None, title=_("Open spectra...")):
gtk.FileChooserDialog.__init__(
self,
title=title,
parent=parent,
action=gtk.FILE_CHOOSER_ACTION_OPEN,
buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_ADD, gtk.RESPONSE_OK),
)
self.figure = Figure(figsize=(5, 4))
self.canvas = FigureCanvas(self.figure)
self.canvas.set_size_request(200, 200) # tamaño mínimo del widget
self.add_filter(ff_jws)
self.set_select_multiple(True)
if current_folder:
self.set_current_folder(current_folder)
self.set_preview_widget(self.canvas)
self.connect("selection-changed", self._update_preview_cb)
self.show_all()
def __init__(self, header, channels, options, parent=None,
title=_("Choose smoothing type"),
buttons=(gtk.STOCK_OK, gtk.RESPONSE_OK)):
gtk.Dialog.__init__(self,
title=title,
parent=parent,
flags=gtk.DIALOG_MODAL,
buttons=buttons)
self.header = header
self.channels = channels
self.options = options
self.xdata = arange(header.x_for_first_point, #start
header.x_for_last_point+header.x_increment, #end+incr.
header.x_increment) #increment
self.ellipticity = array(self.channels[0], float32)
self._create_widgets()
self._configure_widgets()
self._plot_spectrum()
def create_spectralist(self):
def new_column(name, data_attr, column_id, editable=False):
col = gtk.TreeViewColumn(name)
col.set_resizable(True)
col.set_clickable(True)
self.spectra_view.append_column(col)
#identificación de cada columna a la hora de ordenar:
col.set_sort_column_id(column_id)
cell = gtk.CellRendererText()
cell.set_property("editable", editable)
col.pack_start(cell, True)
col.add_attribute(cell, data_attr, column_id)
return col, cell
# [0=nombre (str), 1=nº puntos (int), 2=lamda inicial (float),
# 3=lambda final (float), 4=data pitch (float), 5=ruta (float),
# 6=nombre_completo (str), 7=dilución (float) ]
self.spectra_list = gtk.ListStore(str, int, float, float, float, str, str, float)
self.spectra_view = gtk.TreeView(self.spectra_list)
(col1, cell1) = new_column(_("Name"), "text", 0)
(dilution_column, dilution_cell) = new_column(_("Dilution"), "text", 7,
editable=True)
(col2, cell2) = new_column(_("Point no."), "text", 1)
(col3, cell3) = new_column(_("Initial λ"), "text", 2)
(col4, cell4) = new_column(_("Final λ"), "text", 3)
(col5, cell5) = new_column(_("Data pitch"), "text", 4)
(col6, cell6) = new_column(_("File path"), "text", 5)
dilution_cell.connect("edited", self._dilution_edited_cb)
self.spectra_view.props.reorderable = True
self.spectra_view.set_border_width(5)
self.spectra_sel = self.spectra_view.get_selection()
self.spectra_sel.set_mode(gtk.SELECTION_MULTIPLE)
self.spectra_sel.connect("changed", self._spectra_sel_changed_cb)
self.spectra_scroll = gtk.ScrolledWindow()
self.spectra_scroll.set_policy( gtk.POLICY_AUTOMATIC,
gtk.POLICY_AUTOMATIC )
self.spectra_scroll.add(self.spectra_view)
self.spectra_list.connect("row-inserted", self._sl_rowinserted_cb)
self.spectra_list.connect("row-deleted", self._sl_rowdeleted_cb)
def SelectorCallback(self, ret): # jako ret dostajemy nazwe wybranego itemu w 0
if ret:
if self.SubTreeSelected == False:
if ret[0] == "Clear picons folder":
self.deletePicons()
self.prepareListForSelector(self.SubTreesPath, "" , "Select picons size")
return
else:
maxwait = 1
while pathExists('/tmp/.PICONS.SYNCED') is False or maxwait < 10:
print "PiconSelector:SelectorCallback waiting for picons"
sleep(1)
maxwait += 1
self.SubTreeSelected = True
self.prepareListForSelector(self.myItemsPath, ret[0], "Select Picons shape")
return
else: # we have picons selected, time to download them
ArchiveURL = "http://hybrid.xunil.pl/picons/%s.tar.gz" % ret[0]
ArchiveFile=resolveFilename(SCOPE_SKIN_IMAGE, 'picon/%s.tar.gz' % ret[0])
self.session.openWithCallback(self.ArchiveDownloaded ,Screens_Console, title = _("Installing %s") % ret[0],
cmdlist = [ '%s/Downloader.sh "PICONS" "%s" "%s"' % (self.myPath, resolveFilename(SCOPE_SKIN_IMAGE, 'picon'), ArchiveURL) ])
self.close()
return
def Plugins(**kwargs):
list = [PluginDescriptor(name="PiconSelector", description=_("Graphical picons downloader"), where = [PluginDescriptor.WHERE_PLUGINMENU], icon="icons/logo.png", fnc=main)] # always show in plugin menu
return list
def _create_widgets(self):
def create_label(text):
label = gtk.Label(text)
label.show()
return label
#Blanco
self.subtract_blank_btn = gtk.CheckButton(_("Substract blank"))
self.blank_entry = gtk.Entry()
self.blank_entry.props.editable = False
self.blank_open_button = gtk.Button(stock=gtk.STOCK_OPEN)
#Multiplicar factores de dilución
self.dilution_btn = gtk.CheckButton(_("Multiply dilution factors"))
#Elipticidad a 260nm
self.subtract260_btn = gtk.CheckButton(_("Substract ellipticity at 260nm"))
#Smoothing
self.apply_smoothing_btn = gtk.CheckButton(_("Apply smoothing"))
self.smoothing_list = gtk.ListStore(str)
self.smoothing_list.append(["Mean-movement"])
self.smoothing_list.append(["Savitsky-Golay"])
cell = gtk.CellRendererText()
self.smoothing_combo = gtk.ComboBox(self.smoothing_list)
self.smoothing_combo.pack_start(cell, True)
self.smoothing_combo.add_attribute(cell, 'text', 0)
self.m_scale = gtk.HScale()
self.m_scale.set_range(2, 12)
self.m_scale.set_increments(1, 1)
self.m_scale.set_digits(0)
self.p_scale = gtk.HScale()
self.p_scale.set_range(2,6)
self.p_scale.set_increments(1,1)
self.p_scale.set_digits(0)
#Factor de corrección
self.apply_CF = gtk.CheckButton(_("Apply correction factor"))
self.CF_spinner = gtk.SpinButton()
self.CF_spinner.set_range(-1000000000000.0,1000000000000.0)
self.CF_spinner.set_digits(4)
self.CF_spinner.set_increments(1, 10)
self.calc_CF_btn = gtk.Button("Calcular...")
cf_hbox = gtk.HBox()
cf_hbox.pack_start(create_label(_("Correction factor:")), False, False, 0)
cf_hbox.pack_end(self.CF_spinner)
cfb_hbox = gtk.HBox()
cfb_hbox.pack_end(self.calc_CF_btn)
cf_vbox = gtk.VBox()
cf_vbox.pack_start(self.apply_CF, False, False, 0)
cf_vbox.pack_start(cf_hbox, False, False, 0)
cf_vbox.pack_start(cfb_hbox, False, False, 0)
cf_frame = gtk.Frame(_("Correction factor:"))
cf_frame.add(cf_vbox)
sc_hbox = gtk.HBox()
sc_hbox.pack_start(create_label(_("Smoothing type:")), False, False, 0)
sc_hbox.pack_end(self.smoothing_combo, False, True, 0)
sm_hbox = gtk.HBox()
sm_hbox.pack_start(create_label(_("Smoothing level(m):")), False, False, 0)
sm_hbox.pack_end(self.m_scale, True, True, 0)
sp_hbox = gtk.HBox()
sp_hbox.pack_start(create_label(_("S-G filter order (p):")), False, False, 0)
sp_hbox.pack_end(self.p_scale, True, True, 0)
self.sp_hbox = sp_hbox
so_vbox = gtk.VBox()
so_vbox.pack_start(sc_hbox, False, False, 0)
so_vbox.pack_start(sm_hbox, False, False, 0)
so_vbox.pack_start(sp_hbox, False, False, 0)
so_vbox.set_border_width(5)
smoothing_frame = gtk.Frame(_("Smoothing options"))
smoothing_frame.add(so_vbox)
blank_hbox = gtk.HBox()
blank_hbox.pack_start(self.blank_entry, True, True, 0)
blank_hbox.pack_end(self.blank_open_button, False, False, 0)
blank_vbox = gtk.VBox()
blank_vbox.pack_start(self.subtract_blank_btn, False, False, 0)
blank_vbox.pack_start(blank_hbox, False, False, 0)
blank_frame = gtk.Frame(_("Blank:"))
blank_frame.add(blank_vbox)
self.pack_start(blank_frame, False, False, 0)
self.pack_start(self.dilution_btn, False, False, 0)
self.pack_start(self.subtract260_btn, False, False, 0)
self.pack_start(self.apply_smoothing_btn, False, False, 0)
self.pack_start(smoothing_frame, False, False, 0)
self.pack_start(cf_frame, False, False, 0)
def layoutFinished(self):
self.setTitle(_("SparkWall config"))
def create_widgets(self):
gtk.HPaned.__init__(self)
self.create_spectralist()
self.sl_add_action = gtk.Action("sl_add",
None,
_("Add spectra"),
gtk.STOCK_ADD)
self.sl_add_action.connect("activate", self.sl_add_button_cb)
self.sl_remove_action = gtk.Action("sl_remove",
None,
_("Eliminate selected spectra"),
gtk.STOCK_REMOVE)
self.sl_remove_action.connect("activate", self.sl_remove_button_cb)
self.sl_remove_action.set_sensitive(False)
self.dil_paste_action = gtk.Action( "dil_paste",
None,
_("Paste dilution data"),
gtk.STOCK_PASTE)
self.dil_paste_action.connect("activate", self._request_targets)
self.dil_paste_action.set_sensitive(False)
self.dil_reset_action = gtk.Action("dil_reset",
None,
_("Erase dilution data"),
gtk.STOCK_CLEAR)
self.dil_reset_action.connect("activate", self.reset_dilution_button_cb)
self.show_preview_action = gtk.ToggleAction("show_preview_action",
_("Preview"),
_("Show a plot of the selected spectrum"),
gtk.STOCK_PRINT_PREVIEW)
self.show_preview_action.connect("toggled", self._show_preview_toggle_cb)
dil_menu = gtk.Menu()
dil_menu.insert(self.dil_paste_action.create_menu_item(),-1)
dil_menu.insert(self.dil_reset_action.create_menu_item(),-1)
dil_toolmenu = gtk.MenuToolButton( \
icon_widget = gtk.image_new_from_stock(gtk.STOCK_PASTE,
gtk.ICON_SIZE_SMALL_TOOLBAR),
label=_("Dilution data"))
dil_toolmenu.set_menu(dil_menu)
dil_toolmenu.connect("clicked", self.dilution_menutoolbutton_cb)
dil_toolmenu.set_tooltip(gtk.Tooltips(), _("Paste dilution factors"))
dil_toolmenu.set_is_important(True)
toolbar = gtk.Toolbar()
toolbar.insert(self.sl_add_action.create_tool_item(),-1)
toolbar.insert(self.sl_remove_action.create_tool_item(),-1)
toolbar.insert(gtk.SeparatorToolItem(), -1)
toolbar.insert(dil_toolmenu,-1)
toolbar.insert(gtk.SeparatorToolItem(), -1)
toolbar.insert(self.show_preview_action.create_tool_item(), -1)
toolbar.set_style(gtk.TOOLBAR_BOTH_HORIZ)
tv_vbox = gtk.VBox()
tv_vbox.pack_start(toolbar, False, False, 4)
tv_vbox.pack_start(self.spectra_scroll, True, True, 0)
tv_frame = gtk.Frame(_("Spectra to be processed:"))
tv_frame.add(tv_vbox)
self.spectrum_panel = ShowSpectrumPanel()
self.pack1(tv_frame, True, True)
self.clipboard = gtk.clipboard_get(selection="CLIPBOARD")
def keyVirtualKeyBoard(self):
try:
if isinstance( self["config"].getCurrent()[1], ConfigText ):
from Screens.VirtualKeyBoard import VirtualKeyBoard
text = self["config"].getCurrent()[1].value
self.session.openWithCallback(self.keyVirtualKeyBoardCallBack, VirtualKeyBoard, title = (_("Enter value")), text = text)
except:
pass
def _create_widgets(self):
gtk.Assistant.__init__(self)
# Page 0
ip = gtk.Label(self.intro_msg)
self.append_page(ip)
self.set_page_type(ip, gtk.ASSISTANT_PAGE_INTRO)
self.set_page_title(ip, _("jwsProcessor assistant"))
self.set_page_complete(ip, True)
self.intro_page = ip
# Page 1
sp = SelectionPage(self, self.current_folder)
self.append_page(sp)
self.set_page_type(sp, gtk.ASSISTANT_PAGE_CONTENT)
self.set_page_title(sp, _("#1 - Select spectra"))
self.set_page_complete(sp, False)
self.selection_page = sp
# Page 2
op = OptionsPage(options=self.options,
current_folder = sp.current_folder,
assistant=self)
self.append_page(op)
self.set_page_type(op, gtk.ASSISTANT_PAGE_CONFIRM)
self.set_page_title(op, _("#2 - Processing options"))
self.set_page_complete(op, False)
self.options_page = op
# Page 3
fp = SummaryPage(self)
self.append_page(fp)
self.set_page_title(fp, _("#3 - Results"))
self.set_page_complete(fp, False)
self.summary_page = fp
# Page 4
sop = SaveOptionsPage(self)
self.append_page(sop)
self.set_page_type(sop, gtk.ASSISTANT_PAGE_CONFIRM)
self.set_page_title(sop, _("#4 - Save results as..."))
self.set_page_complete(sop, True)
self.save_options_page = sop
# Page 5
fp = gtk.Label(_("Saving files..."))
self.append_page(fp)
self.set_page_type(fp, gtk.ASSISTANT_PAGE_SUMMARY)
self.set_page_title(fp, _("Summary"))
self.set_page_complete(fp, False)
self.final_page = fp
# Restart assistant button
self.restart_button = gtk.Button(_("Start again"))
self.restart_button.set_image(gtk.image_new_from_stock(gtk.STOCK_GOTO_FIRST,
gtk.ICON_SIZE_BUTTON) )
self.restart_button.connect("clicked", self._restart_clicked_cb)
self.restart_button.show_all()
# Configure window
self.set_title("jwsProcessor")
self.set_border_width(12)
self.set_position (gtk.WIN_POS_CENTER)
self.set_forward_page_func(self._fwd_page_func)
self.show_all()
self.connect("delete-event", self._close_cb)
self.connect("prepare", self._prepare_cb)
self.connect("apply", self._apply_cb)
self.connect("close", self._close_cb)
self.connect("cancel", self._close_cb)
