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
