class LBV_ToggleAction_Run(_LBV_ToggleAction, LBV_Action_Run): __gtype_name__ = 'LBV_ToggleAction_Run' program_start_line = gobject.property(type=int, default=0, minimum=0, nick='Restart line', blurb='Restart line number-Usually 0 - program start') reset_line = gobject.property(type=int, default=0, minimum=0, nick='Restart line after restarting once', blurb='Line number that will be set afterthe next restart. -usually 0 - program start') def _hal_init(self): _LBV_ToggleAction._hal_init(self) self.set_active_safe(False) self.set_sensitive(False) self.gstat.connect('state-off', lambda w: self.set_sensitive(False)) self.gstat.connect('state-estop', lambda w: self.set_sensitive(False)) self.gstat.connect( 'interp-idle', lambda w: self.set_sensitive( self.machine_on() and ( self.is_all_homed() or self.no_home_required() ) and self.is_file_loaded() ) ) self.gstat.connect('interp-idle', lambda w: self.set_active_safe(False)) self.gstat.connect('interp-run', lambda w: self.set_sensitive(False)) self.gstat.connect('interp-run', lambda w: self.set_active_safe(True)) self.gstat.connect('all-homed', lambda w: self.set_sensitive( self.machine_on() and self.is_file_loaded() )) self.gstat.connect('file-loaded', self.file_loaded_check) def file_loaded_check(self,widget,filename): self.set_sensitive( self.machine_on() and (self.is_all_homed() or self.no_home_required()) ) def set_restart_line(self,line,resetline=0): self.program_start_line = line self.reset_line = resetline def on_toggled(self, w): if self.get_active(): return self.on_activate(w)
class LBV_Action_Home(_LBV_Action): __gtype_name__ = 'LBV_Action_Home' axis = gobject.property(type=int, default=-1, minimum=-1, nick='Axis', blurb='Axis to home. -1 to home all') confirm_homed = gobject.property(type=bool, default=False, nick='Confirm rehoming', blurb='Ask user if axis is already homed') def _hal_init(self): _LBV_Action._hal_init(self) self.set_sensitive(False) self.gstat.connect('state-off', lambda w: self.set_sensitive(False)) self.gstat.connect('state-estop', lambda w: self.set_sensitive(False)) self.gstat.connect('interp-idle', lambda w: self.set_sensitive(self.machine_on())) self.gstat.connect('interp-run', lambda w: self.set_sensitive(False)) def homed(self): if self.axis != -1: return self.stat.homed[self.axis] for i,h in enumerate(self.stat.homed): if h and self.stat.axis_mask & (1<<i): return True def on_activate(self, w): #if not manual_ok(): return ensure_mode(self.stat, self.labvcnc, labvcnc.MODE_MANUAL) if self.confirm_homed and self.homed(): if not prompt_areyousure(gtk.MESSAGE_WARNING, _("Axis is already homed, are you sure you want to re-home?")): return self.labvcnc.teleop_enable(False) self.labvcnc.home(self.axis)
class EMC_Action_Run(_EMC_Action): __gtype_name__ = 'EMC_Action_Run' program_start_line = gobject.property( type=int, default=0, minimum=0, nick='Restart line', blurb='Restart line number-Usually 0 - program start') reset_line = gobject.property( type=int, default=0, minimum=0, nick='Restart line after restarting once', blurb= 'Line number that will be set afterthe next restart. -usually 0 - program start' ) def set_restart_line(self, line, resetline=0): self.program_start_line = line self.reset_line = resetline def on_activate(self, w): ensure_mode(self.stat, self.linuxcnc, linuxcnc.MODE_AUTO) self.linuxcnc.auto(linuxcnc.AUTO_RUN, self.program_start_line) self.program_start_line = self.reset_line
class NotebookFile(gobject.GObject): NONE = 0 NEEDS_EXECUTE = 1 EXECUTING = 2 EXECUTE_SUCCESS = 3 ERROR = 4 active = gobject.property(type=bool, default=False) modified = gobject.property(type=bool, default=False) state = gobject.property(type=int, default=NONE) worksheet = gobject.property(type=gobject.TYPE_PYOBJECT) # Having this here in the core code is completely random, however it doesn't actually # require importing GTK+, it's just returning a string. @staticmethod def stock_id_for_state(state): """Get the GTK+ stock ID to use for a particular state.""" if state == NotebookFile.NONE: return None elif state == NotebookFile.NEEDS_EXECUTE: return 'gtk-ok' elif state == NotebookFile.EXECUTING: return 'gtk-refresh' elif state == NotebookFile.EXECUTE_SUCCESS: return 'gtk-apply' elif state == NotebookFile.ERROR: return 'gtk-dialog-error' def __init__(self, path): if not isinstance(path, unicode): raise ValueError("path argument must be unicode") gobject.GObject.__init__(self) self.path = path
class EMC_Action_Home(_EMC_Action): __gtype_name__ = 'EMC_Action_Home' axis = gobject.property(type=int, default=-1, minimum=-1, nick='Axis', blurb='Axis to home. -1 to home all') confirm_homed = gobject.property(type=bool, default=False, nick='Confirm rehoming', blurb='Ask user if axis is already homed') def homed(self): if self.axis != -1: return self.stat.homed[self.axis] for i, h in enumerate(self.stat.homed): if h and self.stat.axis_mask & (1 << i): return True def on_activate(self, w): #if not manual_ok(): return ensure_mode(self.stat, self.linuxcnc, linuxcnc.MODE_MANUAL) if self.confirm_homed and self.homed(): if not prompt_areyousure( gtk.MESSAGE_WARNING, _("Axis is already homed, are you sure you want to re-home?" )): return self.linuxcnc.home(self.axis)
class PaymentMethodField(ChoiceField): #: The type of the payment used to get creatable methods. #: See :meth:`stoqlib.lib.interfaces.IPaymentOperation.creatable` #: for more information payment_type = gobject.property(type=object, default=None) #: If this is being created separated from a |sale| / |purchase| #: See :meth:`stoqlib.lib.interfaces.IPaymentOperation.creatable` #: for more information separate = gobject.property(type=bool, default=True) # Field def populate(self, value): from stoqlib.domain.payment.method import PaymentMethod assert self.payment_type is not None store = get_store_for_field(self) methods = set(PaymentMethod.get_creatable_methods( store, self.payment_type, separate=self.separate)) # Add the current value, just in case the payment method is not # currently creatable methods.add(value) self.widget.prefill(api.for_combo(methods)) if value is not None: self.widget.select(value)
class ProxyColorButton(gtk.ColorButton, ProxyWidgetMixin): __gtype_name__ = 'ProxyColorButton' data_type = gobject.property(getter=ProxyWidgetMixin.get_data_type, setter=ProxyWidgetMixin.set_data_type, type=str, blurb='Data Type') model_attribute = gobject.property(type=str, blurb='Model attribute') gsignal('content-changed') gsignal('validation-changed', bool) gsignal('validate', object, retval=object) allowed_data_types = (basestring, ) def __init__(self, color=gtk.gdk.Color(0, 0, 0)): ProxyWidgetMixin.__init__(self) gtk.ColorButton.__init__(self, color) gsignal('color-set', 'override') def do_color_set(self): self.emit('content-changed') self.chain() def read(self): color = self.get_color() return self._from_string( '#%02x%02x%02x' % (color.red / 256, color.green / 256, color.blue / 256)) def update(self, data): if data is ValueUnset or data is None: data = 'black' color = gtk.gdk.color_parse(data) self.set_color(color)
class CellColorRenderer(gtk.GenericCellRenderer): "Draw filled rectangle with color from three components: red, green and blue" red = gobject.property(type=int, default=0) # GObject properties green = gobject.property(type=int, default=0) blue = gobject.property(type=int, default=0) def __init__(self): gtk.GenericCellRenderer.__init__(self) self.gc = None def on_get_size(self, widget, cell_area): return (0, 0, 24 * 2, 24) def on_render(self, window, widget, background_area, cell_area, expose_area, flags): if self.gc is None: self.gc = gtk.gdk.GC(window) # fill color = gtk.gdk.Color(red=self.red * 256, green=self.green * 256, blue=self.blue * 256) self.gc.set_rgb_fg_color(color) window.draw_rectangle(self.gc, True, cell_area[0], cell_area[1], cell_area[2], cell_area[3]) # draw outline self.gc.set_rgb_fg_color(gtk.gdk.Color()) window.draw_rectangle(self.gc, False, cell_area[0], cell_area[1], cell_area[2], cell_area[3])
class ProxyRadioButton(gtk.RadioButton, ProxyWidgetMixin): __gtype_name__ = 'ProxyRadioButton' allowed_data_types = object, data_value = gobject.property(type=str, nick='Data Value') data_type = gobject.property(getter=ProxyWidgetMixin.get_data_type, setter=ProxyWidgetMixin.set_data_type, type=str, blurb='Data Type') model_attribute = gobject.property(type=str, blurb='Model attribute') gsignal('content-changed') gsignal('validation-changed', bool) gsignal('validate', object, retval=object) def __init__(self, group=None, label=None, use_underline=True): gtk.RadioButton.__init__(self, None, label, use_underline) if group: self.set_group(group) ProxyWidgetMixin.__init__(self) self.connect('group-changed', self._on_group_changed) def _on_radio__toggled(self, radio): self.emit('content-changed') def _on_group_changed(self, radio): for radio in radio.get_group(): radio.connect('toggled', self._on_radio__toggled) def get_selected(self): """ Get the currently selected radiobutton. :returns: The selected :class:`RadioButton` or None if there are no selected radiobuttons. """ for button in self.get_group(): if button.get_active(): return button def read(self): button = self.get_selected() if button is None: return ValueUnset return self._from_string(button.data_value) def update(self, data): if data is None or data is ValueUnset: # In a group of radiobuttons, the only widget which is in # the proxy is ourself, the other buttons do not get their # update() method called, so the default value is activate # ourselves when the model is empty self.set_active(True) return data = self._as_string(data) for rb in self.get_group(): if rb.get_property('data-value') == data: rb.set_active(True)
class ComboDetailsCellRenderer(gtk.GenericCellRenderer): """A Cell Renderer for ComboEntry inspired by firefox's awesome bar To show some details on each entry of the popup, you should call the method ComboEntry.set_details_callback with a callable that expects an object. This will be the object that the entry represents if the ComboEntry mode is DATA and will be None if the mode is STRING (in which case, details don't make sense). """ label = gobject.property(type=str, default="") data = gobject.property(type=object) def __init__(self): label = gtk.Label() self._label_layout = label.create_pango_layout('') self._details_callback = None gtk.GenericCellRenderer.__init__(self) def set_details_callback(self, callable): self._details_callback = callable def on_render(self, window, widget, background_area, cell_area, expose_area, flags): x_offset, y_offset, width, height = self.on_get_size(widget, cell_area) # Center the label y_offset = cell_area.height / 2 - height / 2 # Draws label widget.style.paint_layout(window, gtk.STATE_ACTIVE, False, cell_area, widget, "", cell_area.x + x_offset, cell_area.y + y_offset, self._label_layout) if not self._details_callback: return # Draw a separator to easily distinguish between options widget.style.paint_hline(window, gtk.STATE_ACTIVE, cell_area, widget, "", cell_area.x, cell_area.x + cell_area.width, cell_area.y + cell_area.height - 1) def on_get_size(self, widget, cell_area): text = quote(self.label) if self._details_callback: details = self._details_callback(self.data) mark_up = '%s\n<span foreground="%s">%s</span>' color = gdk_color_to_string(widget.style.fg[gtk.STATE_NORMAL]) text = mark_up % (self.label, color, details) self._label_layout.set_markup(text) width, height = self._label_layout.get_pixel_size() return 0, 0, width, height + 2
class PropertyObject(GObject): normal = gobject.property(type=str) construct = gobject.property(type=str, flags=PARAM_READWRITE | PARAM_CONSTRUCT, default='default') construct_only = gobject.property(type=str, flags=PARAM_READWRITE | PARAM_CONSTRUCT_ONLY) uint64 = gobject.property(type=TYPE_UINT64, flags=PARAM_READWRITE | PARAM_CONSTRUCT)
class Image(hippo.CanvasWidget): def __init__(self, palette=None, tooltip=None, pixbuf=None, **kwargs): self.image = gtk.Image() self._invoker = CanvasInvoker() hippo.CanvasBox.__init__(self, widget=self.image, **kwargs) self._invoker._position_hint = self._invoker.AT_CURSOR self._invoker.attach(self) self.connect('destroy', self._destroy_cb) if palette: self.palette = palette if tooltip: self.tooltip = tooltip if pixbuf: self.pixbuf = pixbuf def _destroy_cb(self, widget): if self._invoker is not None: self._invoker.detach() def create_palette(self): return None def get_palette(self): return self._invoker.palette def set_palette(self, palette): self._invoker.palette = palette palette = gobject.property(type=object, setter=set_palette, getter=get_palette) palette = property(get_palette, set_palette) def get_tooltip(self): return self._invoker.palette and self._invoker.palette.primary_text def set_tooltip(self, text): self.set_palette(Palette(text)) tooltip = gobject.property(type=str, setter=set_tooltip, getter=get_tooltip) tooltip = property(get_tooltip, set_tooltip) def set_pixbuf(self, value): self.image.set_from_pixbuf(value) self.props.box_width = value.get_width() self.props.box_height = value.get_height() pixbuf = gobject.property(type=object, setter=set_pixbuf, getter=None) pixbuf = property(None, set_pixbuf)
class SearchColumn(Column): """ I am a column that should be used in conjunction with :class:`stoqlib.gui.search.searchslave.SearchSlave` :param long_title: The title to display in the combo for this field. This is usefull if you need to display a small description on the column header, but still want a full description on the advanced search. :param valid_values: This should be a list of touples (display value, db value). If provided, then a combo with only this values will be shown, instead of a free text entry. :param search_attribute: Use this if the name of the db column that should be searched is different than the attribute of the model. """ #: overrides the function that generates the query to process the search search_func = gobject.property(type=object, default=None) #: names the search interface differently from the column search_label = gobject.property(type=object, default=None) #: use the query on the *having* part instead of the *where*'s on use_having = gobject.property(type=bool, default=False) def __init__(self, attribute, title=None, data_type=None, long_title=None, valid_values=None, search_attribute=None, **kwargs): """ """ self.long_title = long_title # FIXME: This is not being used at the moment self.valid_values = valid_values self.search_attribute = search_attribute self.sensitive = True Column.__init__(self, attribute, title, data_type, **kwargs) search_func = kwargs.get('search_func') if search_func and not callable(search_func): raise TypeError("search_func must be callable") def get_search_label(self): """Get the search label for this column. This is normally used when constructing a search filter for this column. :returns: the search label """ return self.search_label or self.long_title or self.title
class Context(GObject): __gsignals__ = { 'init' : (SIGNAL_RUN_FIRST, None, []), 'tags-updated' : (SIGNAL_RUN_FIRST, None, 2*[TYPE_PYOBJECT]), 'objects-updated': (SIGNAL_RUN_FIRST, None, []) } def get_sources(self): return self._sources def set_sources(self, sources): for i in set(sources) - set(self._sources): i.emiter = self self._sources = sources def get_tags(self): result = [] for i in range(TAGS_LAST): result.append({}) for i in self._sources: for j in range(TAGS_LAST): result[j].append(i[j]) return result sources = property(type=object, getter=get_sources, setter=set_sources) tags = property(type=object, getter=get_tags, setter=None) def query(self, filter): def fetch_cb(oid, object): self.emit('object-added', oid, object) return True countdown = [len(self._sources)] def query_cb(status): if not status: logging.error('query_cb') return countdown[0] -= 1 if countdown[0]: return self.emit('init') for i in self._sources: i.fetch(fetch_cb) for i in self._sources: i.query(filter, query_cb) def __init__(self): GObject.__init__(self) self._sources = []
class BaseBuddyModel(gobject.GObject): __gtype_name__ = 'SugarBaseBuddyModel' def __init__(self, **kwargs): self._key = None self._nick = None self._color = None self._tags = None self._current_activity = None gobject.GObject.__init__(self, **kwargs) def get_nick(self): return self._nick def set_nick(self, nick): self._nick = nick nick = gobject.property(type=object, getter=get_nick, setter=set_nick) def get_key(self): return self._key def set_key(self, key): self._key = key key = gobject.property(type=object, getter=get_key, setter=set_key) def get_color(self): return self._color def set_color(self, color): self._color = color color = gobject.property(type=object, getter=get_color, setter=set_color) def get_tags(self): return self._tags tags = gobject.property(type=object, getter=get_tags) def get_current_activity(self): return self._current_activity def set_current_activity(self, current_activity): if self._current_activity != current_activity: self._current_activity = current_activity self.notify('current-activity') current_activity = gobject.property(type=object, getter=get_current_activity, setter=set_current_activity) def is_owner(self): raise NotImplementedError
class MyObject(gobject.GObject): foo = gobject.property(type=str, default='bar') boolprop = gobject.property(type=bool, default=False) def __init__(self): gobject.GObject.__init__(self) @gobject.property def readonly(self): return 'readonly'
class ToolWidget(gtk.ToolItem): def __init__(self, **kwargs): self._widget = None self._label = None self._label_text = None self._box = gtk.HBox(False, style.DEFAULT_SPACING) gobject.GObject.__init__(self, **kwargs) self.props.border_width = style.DEFAULT_PADDING self._box.show() self.add(self._box) if self.label is None: self.label = gtk.Label() def get_label_text(self): return self._label_text def set_label_text(self, value): self._label_text = value if self.label is not None and value: self.label.set_text(self._label_text) label_text = gobject.property(getter=get_label_text, setter=set_label_text) def get_label(self): return self._label def set_label(self, label): if self._label is not None: self._box.remove(self._label) self._label = label self._box.pack_start(label, False) self._box.reorder_child(label, 0) label.show() self.set_label_text(self._label_text) label = gobject.property(getter=get_label, setter=set_label) def get_widget(self): return self._widget def set_widget(self, widget): if self._widget is not None: self._box.remove(self._widget) self._widget = widget self._box.pack_end(widget) widget.show() widget = gobject.property(getter=get_widget, setter=set_widget)
class NadMixer(gst.Element, gst.ImplementsInterface, gst.interfaces.Mixer): __gstdetails__ = ('NadMixer', 'Mixer', 'Mixer to control NAD amplifiers using a serial link', 'Stein Magnus Jodal') port = gobject.property(type=str, default='/dev/ttyUSB0') source = gobject.property(type=str) speakers_a = gobject.property(type=str) speakers_b = gobject.property(type=str) def __init__(self): gst.Element.__init__(self) self._volume_cache = 0 self._nad_talker = None def list_tracks(self): track = create_track(label='Master', initial_volume=0, min_volume=0, max_volume=100, num_channels=1, flags=(gst.interfaces.MIXER_TRACK_MASTER | gst.interfaces.MIXER_TRACK_OUTPUT)) return [track] def get_volume(self, track): return [self._volume_cache] def set_volume(self, track, volumes): if len(volumes): volume = volumes[0] self._volume_cache = volume self._nad_talker.set_volume(volume) def set_mute(self, track, mute): self._nad_talker.mute(mute) def do_change_state(self, transition): if transition == gst.STATE_CHANGE_NULL_TO_READY: if serial is None: logger.warning(u'nadmixer dependency python-serial not found') return gst.STATE_CHANGE_FAILURE self._start_nad_talker() return gst.STATE_CHANGE_SUCCESS def _start_nad_talker(self): self._nad_talker = NadTalker.start(port=self.port, source=self.source or None, speakers_a=self.speakers_a or None, speakers_b=self.speakers_b or None).proxy()
class ProxyTextView(gtk.TextView, ValidatableProxyWidgetMixin): __gtype_name__ = 'ProxyTextView' data_value = gobject.property(type=str, nick='Data Value') data_type = gobject.property( getter=ValidatableProxyWidgetMixin.get_data_type, setter=ValidatableProxyWidgetMixin.set_data_type, type=str, blurb='Data Type') mandatory = gobject.property(type=bool, default=False) model_attribute = gobject.property(type=str, blurb='Model attribute') gsignal('content-changed') gsignal('validation-changed', bool) gsignal('validate', object, retval=object) allowed_data_types = (basestring, datetime.date) + number def __init__(self): self._is_unset = True gtk.TextView.__init__(self) self.props.data_type = str ValidatableProxyWidgetMixin.__init__(self) self._textbuffer = gtk.TextBuffer() self._textbuffer.connect('changed', self._on_textbuffer__changed) self.set_buffer(self._textbuffer) def _on_textbuffer__changed(self, textbuffer): self._is_unset = False self.emit('content-changed') self.read() def read(self): if self._is_unset: return ValueUnset textbuffer = self._textbuffer data = textbuffer.get_text(textbuffer.get_start_iter(), textbuffer.get_end_iter()) return self._from_string(data) def update(self, data): if data is ValueUnset: self._textbuffer.set_text("") self._is_unset = True return elif data is None: text = "" else: self.is_unset = False text = self._as_string(data) self._textbuffer.set_text(text)
class GlobalSettings(gobject.GObject): dialogs_dir = _unicode_property('dialogs_dir') examples_dir = _unicode_property('examples_dir') config_dir = _unicode_property('config_dir') icon_file = _unicode_property('icon_file') notebooks_dir = _unicode_property('notebooks_dir') mini_mode = gobject.property(type=bool, default=False) main_menu_mode = gobject.property(type=bool, default=False) version = gobject.property(type=str) editor_font_is_custom = _bool_property('editor_font_is_custom', default=False) editor_font_name = _string_property('editor_font_name', default="Monospace 12") doc_tooltip_font_is_custom = _bool_property('doc_tooltip_font_is_custom', default=False) doc_tooltip_font_name = _string_property('doc_tooltip_font_name', default="Sans 11") autocomplete = _bool_property('autocomplete', default=True) def __init__(self): gobject.GObject.__init__(self) if sys.platform == 'win32': self.config_dir = os.path.join( os.getenv('APPDATA').decode('mbcs'), 'Reinteract') else: self.config_dir = os.path.expanduser(u"~/.reinteract") try: # Added in pygobject-2.18 documents_dir = glib.get_user_special_dir( glib.USER_DIRECTORY_DOCUMENTS).decode("UTF-8") except AttributeError, e: # In a shocking example of cross-platform convergence, ~/Documents # is the documents directory on OS X, Windows, and Linux, except # when localized documents_dir = os.path.expanduser(u"~/Documents") self.notebooks_dir = os.path.join(documents_dir, 'Reinteract') if not os.path.isdir(self.notebooks_dir): os.makedirs(self.notebooks_dir) config_location = os.path.join(self.config_dir, 'reinteract.conf') self.config = ConfigFile(config_location) self.__watches = [] self.connect('notify', self.on_notify)
class TrayIcon(gtk.ToolItem): __gtype_name__ = 'SugarTrayIcon' def __init__(self, icon_name=None, xo_color=None): gtk.ToolItem.__init__(self) self._icon_widget = _IconWidget(icon_name, xo_color) self.add(self._icon_widget) self._icon_widget.show() self._palette_invoker = ToolInvoker(self) self.set_size_request(style.GRID_CELL_SIZE, style.GRID_CELL_SIZE) self.connect('destroy', self.__destroy_cb) def __destroy_cb(self, icon): if self._palette_invoker is not None: self._palette_invoker.detach() def create_palette(self): return None def get_palette(self): return self._palette_invoker.palette def set_palette(self, palette): self._palette_invoker.palette = palette palette = gobject.property(type=object, setter=set_palette, getter=get_palette) def get_palette_invoker(self): return self._palette_invoker def set_palette_invoker(self, palette_invoker): self._palette_invoker.detach() self._palette_invoker = palette_invoker palette_invoker = gobject.property(type=object, setter=set_palette_invoker, getter=get_palette_invoker) def get_icon(self): return self._icon_widget.get_icon() icon = property(get_icon, None)
class CellHexColorRenderer(gtk.CellRendererText): "Display HTML color description in form #rrggbb from three components" red = gobject.property(type=int, default=0) # GObject properties green = gobject.property(type=int, default=0) blue = gobject.property(type=int, default=0) def __init__(self): gtk.CellRendererText.__init__(self) def do_render(self, *args): # set text property with text self.set_property('text', "#%02x%02x%02x" % (self.red, self.green, self.blue)) gtk.CellRendererText.do_render(self, *args)
class ProxyVScale(_ProxyScale, ProxyWidgetMixin, gtk.VScale): __gtype_name__ = 'ProxyVScale' data_type = gobject.property( getter=ProxyWidgetMixin.get_data_type, setter=ProxyWidgetMixin.set_data_type, type=str, blurb='Data Type') model_attribute = gobject.property(type=str, blurb='Model attribute') gsignal('content-changed') gsignal('validation-changed', bool) gsignal('validate', object, retval=object) def __init__(self): gtk.VScale.__init__(self) ProxyWidgetMixin.__init__(self) self.props.data_type = float
class PaymentCategoryField(DomainChoiceField): #: This is the type of payment category we will display in this field, it #: it should either be PaymentCategory.TYPE_PAYABLE or #: PaymentCategory.TYPE_RECEIVABLE category_type = gobject.property(type=object, default=None) # Field def populate(self, value): from stoqlib.domain.payment.category import PaymentCategory store = get_store_for_field(self) categories = PaymentCategory.get_by_type(store, self.category_type) values = api.for_combo(categories, empty=_('No category'), attr='name') self.prefill(values, value) # FIXME: Move to noun self.add_button.set_tooltip_text(_("Add a new payment category")) self.edit_button.set_tooltip_text( _("Edit the selected payment category")) def run_dialog(self, store, category): from stoqlib.gui.editors.paymentcategoryeditor import PaymentCategoryEditor from stoqlib.gui.base.dialogs import run_dialog return run_dialog(PaymentCategoryEditor, self.toplevel, store, category, self.category_type, visual_mode=not self.can_edit)
class EMC_Action_Open(_EMC_Action, _EMC_FileChooser): __gtype_name__ = 'EMC_Action_Open' fixed_file = gobject.property(type=str, default='', nick='Fixed file name') def _hal_init(self): _EMC_FileChooser._hal_init(self) _EMC_Action._hal_init(self) self.currentfolder = os.path.expanduser("~/linuxcnc/nc_files") self.gstat.connect('interp-run', lambda w: self.set_sensitive(False)) self.gstat.connect('interp-idle', lambda w: self.set_sensitive(True)) def _load_filters(self, ini): pass def on_activate(self, w): if self.fixed_file: self.load_file(self.fixed_file) return dialog = EMC_FileChooserDialog(title="Open File",action=gtk.FILE_CHOOSER_ACTION_OPEN, buttons=(gtk.STOCK_CANCEL,gtk.RESPONSE_CANCEL,gtk.STOCK_OPEN,gtk.RESPONSE_OK)) dialog.set_current_folder(self.currentfolder) dialog.show() r = dialog.run() fn = dialog.get_filename() dialog.hide() if r == gtk.RESPONSE_OK: dialog.load_file(fn) self.currentfolder = os.path.dirname(fn) dialog.destroy()
def testRange(self): maxint64 = 2 ** 62 - 1 minint64 = -2 ** 62 - 1 maxuint64 = 2 ** 63 - 1 types = [ (TYPE_INT, G_MININT, G_MAXINT), (TYPE_UINT, 0, G_MAXUINT), (TYPE_LONG, G_MINLONG, G_MAXLONG), (TYPE_ULONG, 0, G_MAXULONG), (TYPE_INT64, minint64, maxint64), (TYPE_UINT64, 0, maxuint64), ] for gtype, min, max in types: # Normal, everything is alright prop = gobject.property(type=gtype, minimum=min, maximum=max) subtype = type('', (gobject.GObject,), dict(prop=prop)) self.assertEqual(subtype.props.prop.minimum, min) self.assertEqual(subtype.props.prop.maximum, max) # Lower than minimum self.assertRaises(TypeError, gobject.property, type=gtype, minimum=min-1, maximum=max) # Higher than maximum self.assertRaises(TypeError, gobject.property, type=gtype, minimum=min, maximum=max+1)
class TextView(hippo.CanvasWidget): def __init__(self, text=None, **kwargs): hippo.CanvasWidget.__init__(self, **kwargs) self.view = gtk.TextView() self.view.props.left_margin = style.DEFAULT_SPACING self.view.props.right_margin = style.DEFAULT_SPACING self.view.props.wrap_mode = gtk.WRAP_WORD self.view.props.accepts_tab = False self.view.show() scrolled_window = gtk.ScrolledWindow() scrolled_window.set_shadow_type(gtk.SHADOW_OUT) scrolled_window.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC) scrolled_window.add(self.view) self.props.widget = scrolled_window if text: self.text = text def get_text(self): return self.view.props.buffer.props.text def set_text(self, value): self.view.props.buffer.props.text = text text = gobject.property(type=str, setter=set_text, getter=get_text) text = property(get_text, set_text)
class CellRendererBuddy(CellRendererIcon): __gtype_name__ = 'JournalCellRendererBuddy' def __init__(self, tree_view, column_index): CellRendererIcon.__init__(self, tree_view) self.props.width = style.STANDARD_ICON_SIZE self.props.height = style.STANDARD_ICON_SIZE self.props.size = style.STANDARD_ICON_SIZE self.props.mode = gtk.CELL_RENDERER_MODE_ACTIVATABLE self.tree_view = tree_view self._model_column_index = column_index def create_palette(self): tree_model = self.tree_view.get_model() row = tree_model[self.props.palette_invoker.path] if row[self._model_column_index] is not None: nick, xo_color = row[self._model_column_index] return BuddyPalette((nick, xo_color.to_string())) else: return None def set_buddy(self, buddy): if buddy is None: self.props.icon_name = None else: nick_, xo_color = buddy self.props.icon_name = 'computer-xo' self.props.xo_color = xo_color buddy = gobject.property(type=object, setter=set_buddy)
class EMC_Action_Home(_EMC_Action): __gtype_name__ = 'EMC_Action_Unhome' axis = gobject.property(type=int, default=-1, minimum=-1, nick='Axis', blurb='Axis to unhome. -1 to unhome all') def on_activate(self, w): ensure_mode(self.stat, self.linuxcnc, linuxcnc.MODE_MANUAL) self.linuxcnc.unhome(self.axis)
class EMC_ToggleAction_MDI(_EMC_ToggleAction, EMC_Action_MDI): __gtype_name__ = 'EMC_ToggleAction_MDI' __gsignals__ = { 'mdi-command-start': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ()), 'mdi-command-stop': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ()), } command = gobject.property(type=str, default='', nick='MDI Command') def _hal_init(self): _EMC_ToggleAction._hal_init(self) EMC_Action_MDI._hal_init(self) def on_toggled(self, w): if not self.get_active(): return self.set_sensitive(False) self.emit('mdi-command-start') self.on_activate(w) gobject.timeout_add(100, self.wait_complete) def wait_complete(self): if self.linuxcnc.wait_complete(0) in [-1, linuxcnc.RCS_EXEC]: return True self.emit('mdi-command-stop') self.set_active_safe(False) self.set_sensitive(self.machine_on()) return False
def testRange(self): maxint64 = 2**62 - 1 minint64 = -2**62 - 1 maxuint64 = 2**63 - 1 types = [ (TYPE_INT, G_MININT, G_MAXINT), (TYPE_UINT, 0, G_MAXUINT), (TYPE_LONG, G_MINLONG, G_MAXLONG), (TYPE_ULONG, 0, G_MAXULONG), (TYPE_INT64, minint64, maxint64), (TYPE_UINT64, 0, maxuint64), ] for gtype, min, max in types: # Normal, everything is alright prop = gobject.property(type=gtype, minimum=min, maximum=max) subtype = type('', (gobject.GObject, ), dict(prop=prop)) self.assertEqual(subtype.props.prop.minimum, min) self.assertEqual(subtype.props.prop.maximum, max) # Lower than minimum self.assertRaises(TypeError, gobject.property, type=gtype, minimum=min - 1, maximum=max) # Higher than maximum self.assertRaises(TypeError, gobject.property, type=gtype, minimum=min, maximum=max + 1)
def _string_property(name, default=None): def getter(self): return self.config.get_string('Reinteract', name, default) def setter(self, value): self.config.set_string('Reinteract', name, value) return gobject.property(getter=getter, setter=setter, type=str, default=default)
def _bool_property(name, default): def getter(self): return self.config.get_bool('Reinteract', name, default) def setter(self, value): self.config.set_bool('Reinteract', name, value) return gobject.property(getter=getter, setter=setter, type=bool, default=default)
def test_create_pointer_property(): """ Check that it is possible to create a property of type ``gobject.TYPE_POINTER``. :bug: #539355 """ prop = gobject.property(type=gobject.TYPE_POINTER) assert prop.type == gobject.TYPE_POINTER type, nick, blurb, flags = prop.get_pspec_args()
def test_default_attributes(): prop = gobject.property() assert not prop.default assert not prop.name assert not prop.maximum assert not prop.minimum assert prop.nick == "" assert prop.blurb == "" assert prop.type == gobject.TYPE_PYOBJECT assert prop.flags == gobject.PARAM_READWRITE type, s1, s2, flags = prop.get_pspec_args() assert type == gobject.TYPE_PYOBJECT # What does these three items mean? assert s1 == "" assert s2 == "" assert flags == gobject.PARAM_READWRITE
def scaled_property(name): name = "_" + name return gobject.property(scaled_getter(name), scaled_setter(name), type=float)
audioconvert = gst.element_factory_make("audioconvert") capsfilter = gst.element_factory_make("capsfilter") bin = gst.Bin() bin.add(capsfilter, self._pitch_elt, audioconvert, sink) gst.element_link_many(self._pitch_elt, audioconvert, sink) capsfilter.link_pads("src", self._pitch_elt, "sink") pad = capsfilter.get_pad("sink") bin.add_pad(gst.GhostPad("sink", pad)) self._pipeline.set_property('audio-sink', bin) self._audiosink = sink audio_sink = gobject.property(getter=get_audio_sink, setter=set_audio_sink,type=str) def get_audio_sink_options(self): return self._audio_sink_options def set_audio_sink_options(self, options): self._audio_sink_options = options sink = self._pipeline.get_property('audio-sink') for prop in options: sink.set_property(prop.name, prop.value) audio_sink_options = property(fget=get_audio_sink_options, fset=set_audio_sink_options) def set_volume(self, volume): self._pipeline.set_property('volume', volume)
self._prop_completion = value completion = gobject.property(getter=_prop_get_completion, setter=_prop_set_completion, type=bool, default=False) def _get_mask(self): return self._mask def _set_mask(self, value): try: self.set_mask(value) return self.get_mask() except MaskError, e: pass mask = gobject.property(getter=_get_mask, setter=_set_mask, type=str, default='') # Public API def set_text(self, text): completion = self.get_completion() if isinstance(completion, KiwiEntryCompletion): self.handler_block(completion.changed_id) gtk.Entry.set_text(self, text) if GTK_2_18: self._do_2_18_workaround(text) if isinstance(completion, KiwiEntryCompletion):
def testDefaults(self): p1 = gobject.property(type=bool, default=True) p2 = gobject.property(type=bool, default=False)
def test_float_min(self): gobject.property(type=float, minimum=-1) gobject.property(type=gobject.TYPE_FLOAT, minimum=-1) gobject.property(type=gobject.TYPE_DOUBLE, minimum=-1)
def monkey_patch_gobject_property(): p = gobject.property() if hasattr(p, '_values'): gobject.propertyhelper.property._default_setter = fixed_default_setter gobject.propertyhelper.property._default_getter = fixed_default_getter