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)
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 __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 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 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 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 __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)