Ejemplo n.º 1
0
 def set_field(self, db, field):
     self._db = db
     self._field = field
     if self.child is not None and self.child.get_parent() is self:
         self.remove(self.child)
     if field.hidden:
         # Do nothing for hidden fields.
         return
     control = None
     change_cb = self._on_widget__value_changed
     for handler in self.set_field_handlers:
         cont, widget, control = handler(self, db, field, change_cb)
         if not cont:
             if control is None:
                 control = widget
             if field.fget or field.readonly:
                 if hasattr(control.props, 'editable'):
                     control.props.editable = False
                     # Make it appear insensitive even though it's
                     # just read-only.
                     style = control.get_style()
                     insensitive_bg = style.bg[gtk.STATE_INSENSITIVE]
                     control.modify_base(gtk.STATE_NORMAL, insensitive_bg)
                 if hasattr(control.props, 'can-focus'):
                     control.props.can_focus = False
                 if hasattr(control.props, 'has-focus'):
                     control.props.has_focus = False
             if gobject.signal_lookup('create-clicked', control):
                 control.connect(
                     'create-clicked', self._on_widget__create_clicked)
             if gobject.signal_lookup('update-clicked', control):
                 control.connect(
                     'update-clicked', self._on_widget__update_clicked)
             if gobject.signal_lookup('view-clicked', control):
                 control.connect(
                     'view-clicked', self._on_widget__view_clicked)
             widget.show()
             width, height = widget.size_request()
             # Restore normal height to large widgets.
             if height > self.props.height_request:
                 self.props.height_request = -1
             self.pack_start(widget)
             self.child = widget
             # Hide or show units label as appropriate.
             if field.units:
                 self._units_label.show()
                 self._units_label.set_text(field.units)
             else:
                 self._units_label.hide()
             return
     # We couldn't find an endpoint handler.
     raise ValueError(
         'Could not find an endpoint set_field handler for %r' % self.child)
Ejemplo n.º 2
0
    def __init__(self):
        gobject.GObject.__init__(self)
        # A signal all controls can emit when requesting to become active.
        # Right now this means getting control of the AudioControl
        if gobject.signal_lookup('control_request_active', Control) == 0:
            gobject.signal_new('control_request_active', Control,
                               gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, [])

        # The control wishes to close
        if gobject.signal_lookup('control_request_close', Control) == 0:
            gobject.signal_new('control_request_close', Control,
                               gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, [])
        self._is_active = False
Ejemplo n.º 3
0
    def __init__(self, shell):
        # make sure the replaygain elements are available
        missing = []
        required = ("rgvolume", "rglimiter")
        for e in required:
            if gst.element_factory_find(e) is None:
                missing.append(e)

        if len(missing) > 0:
            msg = _(
                "The GStreamer elements required for ReplayGain processing are not available. The missing elements are: %s"
            ) % ", ".join(missing)
            RB.error_dialog(shell.props.window,
                            _("ReplayGain GStreamer plugins not available"),
                            msg)
            raise Exception(msg)

        self.shell_player = shell.props.shell_player
        self.player = self.shell_player.props.player
        self.settings = Gio.Settings("org.gnome.rhythmbox.plugins.replaygain")

        self.settings.connect("changed::limiter", self.limiter_changed_cb)

        self.previous_gain = []
        self.fallback_gain = 0.0
        self.resetting_rgvolume = False

        # we use different means to hook into the playback pipeline depending on
        # the playback backend in use
        if gobject.signal_lookup("get-stream-filters", self.player):
            self.setup_xfade_mode()
            self.deactivate_backend = self.deactivate_xfade_mode
        else:
            self.setup_playbin2_mode()
            self.deactivate_backend = self.deactivate_playbin2_mode
Ejemplo n.º 4
0
    def __init__(self, name, format="%a %b %d %Y", parent_window=None):
        try:
            if not gobject.signal_lookup("on-change-cbcalendar", self):
                gobject.signal_new("on-change-cbcalendar", self,
                                   gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
                                   (float, ))
        except:
            pass

        self.format = format
        self._name = name
        self.parent_window = parent_window

        gtk.HBox.__init__(self)

        self.entry = gtk.Entry()
        self.button = gtk.Button()
        arrow = gtk.Arrow(gtk.ARROW_DOWN, gtk.SHADOW_IN)
        self.button.add(arrow)

        self.entry.set_editable(False)
        self.button.connect("pressed", self.show_calendar)

        self.pack_start(self.entry, False, False)
        self.pack_start(self.button, False, False)

        self._value = 0

        self.direction = 'down'

        self.show_all()
Ejemplo n.º 5
0
	def __init__(self, shell):
		# make sure the replaygain elements are available
		missing = []
		required = ("rgvolume", "rglimiter")
		for e in required:
			if gst.element_factory_find(e) is None:
				missing.append(e)

		if len(missing) > 0:
			msg = _("The GStreamer elements required for ReplayGain processing are not available. The missing elements are: %s") % ", ".join(missing)
			RB.error_dialog(shell.props.window, _("ReplayGain GStreamer plugins not available"), msg)
			raise Exception(msg)

		self.shell_player = shell.props.shell_player
		self.player = self.shell_player.props.player
		self.settings = Gio.Settings("org.gnome.rhythmbox.plugins.replaygain")

		self.settings.connect("changed::limiter", self.limiter_changed_cb)

		self.previous_gain = []
		self.fallback_gain = 0.0
		self.resetting_rgvolume = False

		# we use different means to hook into the playback pipeline depending on
		# the playback backend in use
		if gobject.signal_lookup("get-stream-filters", self.player):
			self.setup_xfade_mode()
			self.deactivate_backend = self.deactivate_xfade_mode
		else:
			self.setup_playbin2_mode()
			self.deactivate_backend = self.deactivate_playbin2_mode
Ejemplo n.º 6
0
	def __init__(self, shell):
		# make sure the replaygain elements are available
		missing = []
		required = ("rgvolume", "rglimiter")
		for e in required:
			if gst.element_factory_find(e) is None:
				missing.append(e)

		if len(missing) > 0:
			msg = _("The GStreamer elements required for ReplayGain processing are not available. The missing elements are: %s") % ", ".join(missing)
			rb.error_dialog(shell.props.window, _("ReplayGain GStreamer plugins not available"), msg)
			raise Exception(msg)

		self.shell_player = shell.props.shell_player
		self.player = self.shell_player.props.player
		self.gconf = gconf.client_get_default()

		self.gconf.add_dir(config.GCONF_DIR, preload=False)
		self.gconf.notify_add(config.GCONF_KEYS['limiter'], self.limiter_changed_cb)

		self.previous_gain = []
		self.fallback_gain = 0.0
		self.resetting_rgvolume = False

		# we use different means to hook into the playback pipeline depending on
		# the playback backend in use
		if gobject.signal_lookup("get-stream-filters", self.player):
			self.setup_xfade_mode()
			self.deactivate_backend = self.deactivate_xfade_mode
		else:
			self.setup_playbin2_mode()
			self.deactivate_backend = self.deactivate_playbin2_mode
Ejemplo n.º 7
0
 def __init__(self, settings = {}, number_of_settings=1, hidden_on_load=False):
     self.title = None
     self.gobject = gobject.GObject()
     if gobject.signal_lookup('settings-changed', self.gobject) == 0:
         gobject.signal_new(
             "settings-changed",
             gobject.GObject,
             gobject.SIGNAL_ACTION,
             gobject.TYPE_NONE,
             (str, gobject.TYPE_PYOBJECT, gobject.TYPE_PYOBJECT))
     if gobject.signal_lookup('loading-settings', self.gobject) == 0:
         gobject.signal_new(
             "loading-settings",
             gobject.GObject,
             gobject.SIGNAL_ACTION,
             gobject.TYPE_NONE,
             (int,))
     if gobject.signal_lookup('settings-changed', self.gobject) == 0:
         gobject.signal_new(
             "settings-changed",
             gobject.GObject,
             gobject.SIGNAL_ACTION,
             gobject.TYPE_NONE,
             (str, gobject.TYPE_PYOBJECT, gobject.TYPE_PYOBJECT))
     if gobject.signal_lookup('settings-loaded', self.gobject) == 0:
         gobject.signal_new(
             "settings-loaded",
             gobject.GObject,
             gobject.SIGNAL_ACTION,
             gobject.TYPE_NONE,
             (str, gobject.TYPE_PYOBJECT))
     self.gobject.loading = True
     self.gobject.__loaded = False
     self.__gui_initialized = False
     self.gobject.number_of_settings = number_of_settings
     if 'hidden_on_load' not in dir(self):
         self.hidden_on_load = hidden_on_load
     self.threading = async.ThreadedClass()
     self.settings = settings
     gtk.VBox.__init__(self)
     self.set_spacing(0)
     if '_build_interface' in dir(self):
         self.__build_interface_real = self._build_interface
         self._build_interface = self.__build_interface_wrapper
     else:
         self.__gui_initialized = True
Ejemplo n.º 8
0
    def supportsSignal(self, signalName):
        """
        Checks to see if a GTK object supports a signal.

        Checks to see if a GTK object supports a signal, via the
        gobject.signal_lookup method.  Returns True if it is supported,
        false otherwise.
        """
        return gobject.signal_lookup(signalName, self.widget.__class__) != 0
Ejemplo n.º 9
0
  def register_callbacks(self, signals):
    '''
    Called by any class that is interested in receiving events from this
    object to register callbacks.

    Return: dict of bound signals. Use it to unregister your class, once no longer required.
    '''
    handlers = {}
    for key in signals.keys():
      if gobject.signal_lookup(key, self.__class__):
        handlers[key] = self.connect(key, signals[key])
    return handlers
Ejemplo n.º 10
0
 def __init__(self,
              settings={},
              number_of_settings=1,
              hidden_on_load=False):
     self.title = None
     self.gobject = gobject.GObject()
     if gobject.signal_lookup('settings-changed', self.gobject) == 0:
         gobject.signal_new(
             "settings-changed", gobject.GObject, gobject.SIGNAL_ACTION,
             gobject.TYPE_NONE,
             (str, gobject.TYPE_PYOBJECT, gobject.TYPE_PYOBJECT))
     if gobject.signal_lookup('loading-settings', self.gobject) == 0:
         gobject.signal_new("loading-settings", gobject.GObject,
                            gobject.SIGNAL_ACTION, gobject.TYPE_NONE,
                            (int, ))
     if gobject.signal_lookup('settings-changed', self.gobject) == 0:
         gobject.signal_new(
             "settings-changed", gobject.GObject, gobject.SIGNAL_ACTION,
             gobject.TYPE_NONE,
             (str, gobject.TYPE_PYOBJECT, gobject.TYPE_PYOBJECT))
     if gobject.signal_lookup('settings-loaded', self.gobject) == 0:
         gobject.signal_new("settings-loaded", gobject.GObject,
                            gobject.SIGNAL_ACTION, gobject.TYPE_NONE,
                            (str, gobject.TYPE_PYOBJECT))
     self.gobject.loading = True
     self.gobject._loaded = False
     self._gui_initialized = False
     self.gobject.number_of_settings = number_of_settings
     if 'hidden_on_load' not in dir(self):
         self.hidden_on_load = hidden_on_load
     self.threading = async .ThreadedClass()
     self.settings = settings
     gtk.VBox.__init__(self)
     self.set_spacing(0)
     if '_build_interface' in dir(self):
         self._build_interface_real = self._build_interface
         self._build_interface = self._build_interface_wrapper
     else:
         self._gui_initialized = True
Ejemplo n.º 11
0
    def do_setup_pipeline(self):
        self.src = gst.element_make_from_uri(gst.URI_SRC, self.fromuri)
        self.remuxbin = RemuxBin(self.start_time, self.stop_time)
        self.sink = gst.element_make_from_uri(gst.URI_SINK, self.touri)
        self.resolution = UNKNOWN

        if gobject.signal_lookup('allow-overwrite', self.sink.__class__):
            self.sink.connect('allow-overwrite', lambda *x: True)

        self.add(self.src, self.remuxbin, self.sink)

        self.src.link(self.remuxbin)
        self.remuxbin.link(self.sink)
Ejemplo n.º 12
0
    def do_setup_pipeline(self):
        self.src = gst.element_make_from_uri(gst.URI_SRC, self.fromuri)
        self.remuxbin = RemuxBin(self.start_time, self.stop_time)
        self.sink = gst.element_make_from_uri(gst.URI_SINK, self.touri)
        self.resolution = UNKNOWN

        if gobject.signal_lookup('allow-overwrite', self.sink.__class__):
            self.sink.connect('allow-overwrite', lambda *x: True)

        self.add(self.src, self.remuxbin, self.sink)

        self.src.link(self.remuxbin)
        self.remuxbin.link(self.sink)
    def __init__(self, initial_value=0, parent_window=None):
        gtk.Dialog.__init__(self)
        try:
            if not gobject.signal_lookup("on-change-calendar-window", self):
                gobject.signal_new("on-change-calendar-window",
                                   self,
                                   gobject.SIGNAL_RUN_LAST,
                                   gobject.TYPE_NONE,
                                   (float,))
        except:
            pass

        self.set_modal(True)
        
        if parent_window:
            parent_window.set_transient_for(self)

        hbox = gtk.HBox()
        self.calendar = gtk.Calendar()
        buttonCurrent = gtk.Button()
        buttonDelete  = gtk.Button()

        buttonCurrent.add(gtk.Label("Current"))
        buttonDelete.add(gtk.Label("Delete"))

        hbox.pack_start(buttonCurrent)
        hbox.pack_start(buttonDelete)

        self.vbox.pack_start(self.calendar, False, False)
        self.vbox.pack_start(hbox)

        self.set_decorated(False)
        self.set_position(gtk.WIN_POS_NONE)
        self.set_property("skip-taskbar-hint", True)

        buttonCurrent.connect("pressed", self.do_select_current)
        buttonDelete.connect("pressed", self.do_select_none)
        self.calendar.connect("day-selected-double-click", self.do_select_day)

        self.connect("focus-out-event", self.do_hide_calendar)

        self.value = initial_value

        # if there are a value, select the day
        if self.value:
            year, month, day, hour, minute, second, dow, doy, isdst = time.localtime(self.value)
            self.calendar.select_month(month-1, year)
            self.calendar.select_day(day)

        self.show_all()
        self.action_area.hide()
    def __init__(self, initial_value=0, parent_window=None):
        gtk.Dialog.__init__(self)
        try:
            if not gobject.signal_lookup("on-change-calendar-window", self):
                gobject.signal_new("on-change-calendar-window", self,
                                   gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
                                   (float, ))
        except:
            pass

        self.set_modal(True)

        if parent_window:
            parent_window.set_transient_for(self)

        hbox = gtk.HBox()
        self.calendar = gtk.Calendar()
        buttonCurrent = gtk.Button()
        buttonDelete = gtk.Button()

        buttonCurrent.add(gtk.Label("Current"))
        buttonDelete.add(gtk.Label("Delete"))

        hbox.pack_start(buttonCurrent)
        hbox.pack_start(buttonDelete)

        self.vbox.pack_start(self.calendar, False, False)
        self.vbox.pack_start(hbox)

        self.set_decorated(False)
        self.set_position(gtk.WIN_POS_NONE)
        self.set_property("skip-taskbar-hint", True)

        buttonCurrent.connect("pressed", self.do_select_current)
        buttonDelete.connect("pressed", self.do_select_none)
        self.calendar.connect("day-selected-double-click", self.do_select_day)

        self.connect("focus-out-event", self.do_hide_calendar)

        self.value = initial_value

        # if there are a value, select the day
        if self.value:
            year, month, day, hour, minute, second, dow, doy, isdst = time.localtime(
                self.value)
            self.calendar.select_month(month - 1, year)
            self.calendar.select_day(day)

        self.show_all()
        self.action_area.hide()
Ejemplo n.º 15
0
    def add_action_widget(self, child, response_id):
        if not gobject.type_is_a(child, gtk.Widget):
            print 'Not a Widget' #FIXME:
            return

        print '#TODO: add response data'
        print child

        if type(child) is gtk.Button:
            signal_id = gobject.signal_lookup('clicked', type(child))
        else:
            signal_id = gobject.signal_lookup('activate', type(child))
            
        if signal_id:
            print 'TODO: check if this is correct.'
            signal = gobject.signal_name(signal_id)
            child.connect(signal, MessageArea.__action_widget_activated, self) #FIXME:
        else:
            print "Only 'activatable' widgets can be packed into the action area of a MessageArea"

        if response_id != gtk.RESPONSE_HELP:
            self.action_area.pack_start(child, False, False, 0)
        else:
            self.action_area.pack_end(child, False, False, 0)
Ejemplo n.º 16
0
  def _handle_clipboard(self, widget, signal):
    """
    This finds the currently focused widget.
    If no widget is focused or the focused widget doesn't support 
    the given clipboard operation use the treeview (False), otherwise
    signal the widget to handel the clipboard operation (True).
    """
    widget = self._get_focus_widget(self)

    if widget is None or widget is self.treeview:
      return False

    if gobject.signal_lookup(signal + "-clipboard", widget):
      widget.emit(signal + "-clipboard")
      return True
    else:
      return False
Ejemplo n.º 17
0
    def __init__(self, offline=False):
        logging.basicConfig(level=defs.log_level)
        gobject.GObject.__init__(self)
        self.builder = gtk.Builder()

        ui_file = "%s/notification.ui" % defs.WALLBOX_DATA_DIR

        self.builder.add_from_file(ui_file)
        self.builder.connect_signals(self, None)
        self.window = self.builder.get_object("notification_window")
        self.window.connect("configure-event", self.on_window_resize)
        self.entry_status = self.builder.get_object("entry_status")
        self.scrolledwindow = self.builder.get_object("scrolledwindow")
        self.comments = {}
        self.comment_handler_id = None
        self.progressbar_refresh = self.builder.get_object(
            "progressbar_refresh")

        if gobject.signal_lookup("has-unread", Notification) == 0:
            gobject.signal_new \
                ("has-unread", Notification, gobject.SIGNAL_RUN_LAST, \
                gobject.TYPE_NONE, (gobject.TYPE_INT,))

        bus = dbus.SessionBus()
        obj = bus.get_object ("org.wallbox.PostOfficeService", \
            "/org/wallbox/PostOfficeObject")

        self.office = dbus.Interface \
            (obj, "org.wallbox.PostOfficeInterface")

        self.office.connect_to_signal \
            ("status_changed", self.on_office_status_changed, \
            dbus_interface="org.wallbox.PostOfficeInterface")
        self.office.connect_to_signal \
            ("refresh_status_changed", self.on_refresh_status_changed, \
            dbus_interface="org.wallbox.PostOfficeInterface")

        self.init_view()
        self.office.refresh()
        self.on_office_status_changed(1)
        self.view_refresh()
Ejemplo n.º 18
0
    def add_field(self, labelText, fieldWidget):
        self.fields.append(fieldWidget)
        if self.autoUpdate:
            fieldWidget.connect("new-value", self.emit_search_updated)
        else:
            if gobject.signal_lookup("activate", fieldWidget.get_widget()):
                fieldWidget.get_widget().connect("activate",
                                                 self.emit_search_updated)

        label = gtk.Label(labelText)
        label.set_alignment(0.0, 0.5)

        currentNRows = self.get_property("n-rows")
        nColumns = self.get_property("n-columns")

        self.attach(label, nColumns - 2, nColumns - 1, currentNRows - 1,
                    currentNRows, gtk.FILL)
        self.attach(fieldWidget.widget, nColumns - 1, nColumns - 0,
                    currentNRows - 1, currentNRows, gtk.EXPAND | gtk.FILL)
        self.resize(currentNRows + 1, nColumns)
        self.show_all()
Ejemplo n.º 19
0
    def __init__ (self, offline=False):
        logging.basicConfig (level=defs.log_level)
        gobject.GObject.__init__(self)
        self.builder = gtk.Builder ()

        ui_file =  "%s/notification.ui" % defs.WALLBOX_DATA_DIR

        self.builder.add_from_file (ui_file)
        self.builder.connect_signals (self, None)
        self.window = self.builder.get_object ("notification_window")
        self.window.connect ("configure-event", self.on_window_resize)
        self.entry_status = self.builder.get_object ("entry_status")
        self.scrolledwindow = self.builder.get_object ("scrolledwindow")
        self.comments = {}
        self.comment_handler_id = None
        self.progressbar_refresh = self.builder.get_object ("progressbar_refresh")

        if gobject.signal_lookup ("has-unread", Notification) == 0:
            gobject.signal_new \
                ("has-unread", Notification, gobject.SIGNAL_RUN_LAST, \
                gobject.TYPE_NONE, (gobject.TYPE_INT,))

        bus = dbus.SessionBus ()
        obj = bus.get_object ("org.wallbox.PostOfficeService", \
            "/org/wallbox/PostOfficeObject")

        self.office = dbus.Interface \
            (obj, "org.wallbox.PostOfficeInterface")

        self.office.connect_to_signal \
            ("status_changed", self.on_office_status_changed, \
            dbus_interface="org.wallbox.PostOfficeInterface")
        self.office.connect_to_signal \
            ("refresh_status_changed", self.on_refresh_status_changed, \
            dbus_interface="org.wallbox.PostOfficeInterface")

        self.init_view ()
        self.office.refresh ()
        self.on_office_status_changed (1)
        self.view_refresh ()
Ejemplo n.º 20
0
    def __init__(self, shell):
        # make sure the replaygain elements are available
        missing = []
        required = ("rgvolume", "rglimiter")
        for e in required:
            if gst.element_factory_find(e) is None:
                missing.append(e)

        if len(missing) > 0:
            msg = _(
                "The GStreamer elements required for ReplayGain processing are not available. The missing elements are: %s"
            ) % ", ".join(missing)
            rb.error_dialog(shell.props.window,
                            _("ReplayGain GStreamer plugins not available"),
                            msg)
            raise Exception(msg)

        self.shell_player = shell.props.shell_player
        self.player = self.shell_player.props.player
        self.gconf = gconf.client_get_default()

        self.gconf.add_dir(config.GCONF_DIR, preload=False)
        self.gconf.notify_add(config.GCONF_KEYS['limiter'],
                              self.limiter_changed_cb)

        self.previous_gain = []
        self.fallback_gain = 0.0
        self.resetting_rgvolume = False

        # we use different means to hook into the playback pipeline depending on
        # the playback backend in use
        if gobject.signal_lookup("get-stream-filters", self.player):
            self.setup_xfade_mode()
            self.deactivate_backend = self.deactivate_xfade_mode
        else:
            self.setup_playbin2_mode()
            self.deactivate_backend = self.deactivate_playbin2_mode
Ejemplo n.º 21
0
    def on_activate(self, widget):
        if 'plugins' not in gajim.interface.instances:
            return
        if hasattr(self, 'page_num'):
            # 'Available' tab exists
            return
        self.installed_plugins_model = gajim.interface.instances[
            'plugins'].installed_plugins_model
        self.notebook = gajim.interface.instances['plugins'].plugins_notebook
        id_ = self.notebook.connect('switch-page', self.on_notebook_switch_page)
        self.connected_ids[id_] = self.notebook
        self.window = gajim.interface.instances['plugins'].window
        id_ = self.window.connect('destroy', self.on_win_destroy)
        self.connected_ids[id_] = self.window
        self.GTK_BUILDER_FILE_PATH = self.local_file_path('config_dialog.ui')
        self.xml = gtk.Builder()
        self.xml.set_translation_domain('gajim_plugins')
        self.xml.add_objects_from_file(self.GTK_BUILDER_FILE_PATH, ['hpaned2',
            'image1'])
        self.hpaned = self.xml.get_object('hpaned2')
        self.page_num = self.notebook.append_page(self.hpaned,
            gtk.Label(_('Available')))

        widgets_to_extract = ('plugin_name_label1',
        'available_treeview', 'progressbar', 'inslall_upgrade_button',
        'plugin_authors_label1', 'plugin_authors_label1',
        'plugin_homepage_linkbutton1')

        for widget_name in widgets_to_extract:
            setattr(self, widget_name, self.xml.get_object(widget_name))

        attr_list = pango.AttrList()
        attr_list.insert(pango.AttrWeight(pango.WEIGHT_BOLD, 0, -1))
        self.plugin_name_label1.set_attributes(attr_list)

        self.available_plugins_model = gtk.ListStore(gtk.gdk.Pixbuf,
            gobject.TYPE_PYOBJECT, gobject.TYPE_STRING, gobject.TYPE_STRING,
            gobject.TYPE_STRING, gobject.TYPE_BOOLEAN, gobject.TYPE_PYOBJECT,
            gobject.TYPE_PYOBJECT, gobject.TYPE_PYOBJECT)
        self.available_treeview.set_model(self.available_plugins_model)
        self.available_treeview.set_rules_hint(True)
        self.available_plugins_model.set_sort_column_id(2, gtk.SORT_ASCENDING)

        self.progressbar.set_property('no-show-all', True)
        renderer = gtk.CellRendererText()
        col = gtk.TreeViewColumn(_('Plugin'))
        cell = gtk.CellRendererPixbuf()
        col.pack_start(cell, False)
        col.add_attribute(cell, 'pixbuf', C_PIXBUF)
        col.pack_start(renderer, True)
        col.add_attribute(renderer, 'text', C_NAME)
        col.set_resizable(True)
        col.set_property('expand', True)
        col.set_sizing(gtk.TREE_VIEW_COLUMN_GROW_ONLY)
        self.available_treeview.append_column(col)
        col = gtk.TreeViewColumn(_('Installed\nversion'), renderer,
            text=C_LOCAL_VERSION)
        self.available_treeview.append_column(col)
        col = gtk.TreeViewColumn(_('Available\nversion'), renderer,
            text=C_VERSION)
        col.set_property('expand', False)
        self.available_treeview.append_column(col)

        renderer = gtk.CellRendererToggle()
        renderer.set_property('activatable', True)
        renderer.connect('toggled', self.available_plugins_toggled_cb)
        col = gtk.TreeViewColumn(_('Install /\nUpgrade'), renderer,
            active=C_UPGRADE)
        self.available_treeview.append_column(col)

        if gobject.signal_lookup('error_signal', self.window) is 0:
            gobject.signal_new('error_signal', self.window,
                gobject.SIGNAL_RUN_LAST, gobject.TYPE_STRING,
                (gobject.TYPE_STRING,))
            gobject.signal_new('plugin_downloaded', self.window,
                gobject.SIGNAL_RUN_LAST, gobject.TYPE_STRING,
                (gobject.TYPE_PYOBJECT,))
        id_ = self.window.connect('error_signal', self.on_some_ftp_error)
        self.connected_ids[id_] = self.window
        id_ = self.window.connect('plugin_downloaded',
            self.on_plugin_downloaded)
        self.connected_ids[id_] = self.window

        selection = self.available_treeview.get_selection()
        selection.connect('changed',
            self.available_plugins_treeview_selection_changed)
        selection.set_mode(gtk.SELECTION_SINGLE)

        self._clear_available_plugin_info()

        self.plugin_description_textview = HtmlTextView()
        sw = self.xml.get_object('scrolledwindow1')
        sw.add(self.plugin_description_textview)

        self.xml.connect_signals(self)
        self.window.show_all()
Ejemplo n.º 22
0
def addShortcut(accelGroup, widget, shortcut, callback, *args):
	"""
		Adds a shortcut identified by a string
		to the widget and sets the callback
		to the shortcut.

		The shortcut string looks like this:
		<ctrl><shift>2 => (l/r)-CTRL + (l/r)-shift + 2

		There are max. 3 modifier (ctrl/shift/alt/...) allowed.
	"""

	match = shortExp.match(shortcut)

	if not match:
		logging.error("addShortcut: No pattern match for %s" % (shortcut))
		return None

	vGroups = [g for g in match.groups() if g]

	if not vGroups:
		logging.error("addShortcut: No filled groups for %s" % (shortcut))
		return None

	mask = 0

	for group in vGroups[:-1]:
		if group == "<ctrl>":
			mask |= CONTROL_MASK
		if group == "<shift>":
			mask |= SHIFT_MASK
		if group == "<alt>":
			mask |= MOD1_MASK

	key = vGroups[-1]

	if len(key) > 1:
		keyval = keyval_from_name(key)

		if not keyval:
			logging.error("addShortcut: Too much chars for (%s)." % (key))
			return None
	else:
		keyval = ord(key)

	# name like shortCut_ctrl_shift_2
	signame = "shortCut_"+"_".join([i.strip("<>") for i in vGroups])


	if not signal_lookup(signame, widget):
		signal_new(signame, widget, SIGNAL_ACTION, None, ())

	widget.add_accelerator(
		signame,
		accelGroup,
		keyval,
		mask,
		ACCEL_VISIBLE)

	handler = widget.connect(signame, callback, shortcut, *args)

	if not regmap.has_key(accelGroup):
		regmap[accelGroup] = {}

	if not regmap[accelGroup].has_key(widget):
		regmap[accelGroup][widget]=[ (handler,vGroups,keyval,mask) ]
	else:
		regmap[accelGroup][widget].append( (handler,vGroups,keyval,mask) )

	return handler
Ejemplo n.º 23
0
    def __init__(self, headers=None, rows=None, types=None, combos=None, combotypes=None, selection_type=None):
        if gobject.signal_lookup('toggled', self) == 0:
            gobject.signal_new(
                "toggled",
                self,
                gobject.SIGNAL_ACTION,
                gobject.TYPE_NONE,
                (
                    gobject.TYPE_PYOBJECT,
                    gobject.TYPE_PYOBJECT,
                    gobject.TYPE_PYOBJECT
                ))
        if gobject.signal_lookup('changed', self) == 0:
            gobject.signal_new(
                "changed",
                self,
                gobject.SIGNAL_ACTION,
                gobject.TYPE_NONE,
                (
                    gobject.TYPE_PYOBJECT,
                    gobject.TYPE_PYOBJECT,
                    gobject.TYPE_PYOBJECT
                ))
        if gobject.signal_lookup('right-click', self) == 0:
            gobject.signal_new(
                'right-click',
                self, gobject.SIGNAL_ACTION,
                gobject.TYPE_NONE,
                (
                    gobject.TYPE_OBJECT,
                    gobject.TYPE_PYOBJECT,
                    gobject.TYPE_PYOBJECT,
                    gtk.gdk.Event
                ))
        if gobject.signal_lookup('double-click', self) == 0:
            gobject.signal_new(
                'double-click',
                self, gobject.SIGNAL_ACTION,
                gobject.TYPE_NONE,
                (
                    gobject.TYPE_OBJECT,
                    gobject.TYPE_PYOBJECT,
                    gobject.TYPE_PYOBJECT,
                    gtk.gdk.Event
                ))
        self._fallback_pixbuf = None

        # Remember: First cell is index
        if rows is None:
            rows = []

        if len(rows):
            self.rows = self.__failsafe_rows(rows)
            if types is None:
                self._cell_types, self._render_types = self.__convert_rows_to_types(self.rows)
            else:
                self._cell_types, self._render_types = self.__convert_rows_to_types([types])
        elif types is not None:
            self.rows = rows
            self._cell_types, self._render_types = self.__convert_rows_to_types([types])
        else:
            raise(ValueError, "You need to supply either rows or types.")

        number_of_combocols = len([
            col for col in self._cell_types
            if col is list
        ])
        if combos is not None:
            if type(combos[0][0]) not in (tuple, list):
                self._combos = [
                    [
                        [row] for row in combo
                    ]
                    for combo
                    in combos
                ]
            else:
                self._combos = combos
            if combotypes is not None:
                self._combocols = combotypes
            else:
                self._combocols = []
                for combo in self._combos:
                    if type(combo[0]) in (list, tuple):
                        self._combocols.append([str] * len(combo[0]))
                    else:
                        self._combocols.append([str])
            self._combomodels = [
                gtk.ListStore(*column)
                for column
                in self._combocols
            ]
            for combo_nr, combo in enumerate(self._combos):
                for row in combo:
                    self._combomodels[combo_nr].append(
                        self._create_model_row_from_row(row, self._combocols[combo_nr])
                    )
        else:
            if number_of_combocols:
                raise(ValueError, "When using Combo renderers, you need to assign the comborows.")

        if headers is None:
            headers = [ '' for i in range(len(self._cell_types)-1) ]

        self.headers = headers

        self.selection_type = selection_type

        gtk.VBox.__init__(self)

        self._create_widgets()
        self._create_headers()
        self.fill()
Ejemplo n.º 24
0
 def on_copy_tree(self):
     """Callback for copy on whole tree"""
     widget = self._main_window.get_focus()
     if gobject.signal_lookup("copy-tree-clipboard", widget) != 0:
         widget.emit("copy-tree-clipboard")
Ejemplo n.º 25
0
    def __init__(self, frame, message="", default_text='',
                 textview=None, modal=True):

        gtk.Dialog.__init__(self)

        # Test if the signal is already binded since we do not clear it
        # when we destroy FindDialog
        if not gobject.signal_lookup("find-click", gtk.Window):
            gobject.signal_new(
                "find-click",
                gtk.Window,
                gobject.SIGNAL_RUN_LAST,
                gobject.TYPE_NONE,
                (gobject.TYPE_STRING,)
            )

        self.textview = textview
        self.nicotine = frame

        self.connect("delete-event", self.quit)

        # The destroy event shoul clean up the reference to FindDialog
        # in the NicotineFrame object
        self.connect("destroy", self.destroy)

        self.nextPosition = None
        self.currentPosition = None
        self.lastdirection = "next"

        if modal:
            self.set_modal(True)

        box = gtk.VBox(spacing=10)
        box.set_border_width(10)
        self.vbox.pack_start(box)
        box.show()

        if message:
            label = gtk.Label(message)
            box.pack_start(label, False, False)
            label.set_line_wrap(True)
            label.show()

        self.entry = gtk.Entry()

        box.pack_start(self.entry, False, False)
        self.entry.show()
        self.entry.grab_focus()
        self.entry.connect("activate", self.next)

        Cancelbutton = self.nicotine.CreateIconButton(
            gtk.STOCK_CANCEL,
            "stock",
            self.quit,
            _("Cancel")
        )
        Cancelbutton.set_flags(gtk.CAN_DEFAULT)
        self.action_area.pack_start(Cancelbutton)

        Previousbutton = self.nicotine.CreateIconButton(
            gtk.STOCK_GO_BACK,
            "stock",
            self.previous,
            _("Previous")
        )
        Previousbutton.set_flags(gtk.CAN_DEFAULT)
        self.action_area.pack_start(Previousbutton)

        Nextbutton = self.nicotine.CreateIconButton(
            gtk.STOCK_GO_FORWARD,
            "stock",
            self.next,
            _("Next")
        )
        Nextbutton.set_flags(gtk.CAN_DEFAULT)
        self.action_area.pack_start(Nextbutton)
        Nextbutton.grab_default()
Ejemplo n.º 26
0
 def widgetHasSignal(widget, signalName):
     if widget.isInstanceOf(gtk.TreeView):
         # Ignore this for treeviews: as they have no title/label they can't really get confused with other stuff
         return widget.get_model() is not None
     else:
         return gobject.signal_lookup(signalName, widget.widget) != 0
Ejemplo n.º 27
0
    def __init__(cls, name, bases, dict):
        gobject.GObjectMeta.__init__(cls, name, bases, dict)

        # merge all the properties from the base classes
        properties = []
        properties_by_name = {}
        for base in bases + (cls,):
            if hasattr(base, "properties"):
                for p in base.properties:
                    existing_p = properties_by_name.get(p.name)
                    if existing_p is None:
                        tmp = copy.copy(p)
                        properties.append(tmp)
                        properties_by_name[p.name] = tmp
                    else:
                        if existing_p.default is not None:
                            p.default = existing_p.default
                        if existing_p.fset is not None:
                            p.fset = existing_p.fset
                        if existing_p.fget is not None:
                            p.fget = existing_p.fget
        for p in properties:
            p.signal = False
            p.signal_name = None
        if "properties" in dict:
            for p in cls.properties:
                properties_by_name[p.name].signal = p.signal
        cls.properties = properties
        cls.properties_by_name = properties_by_name

        # create signals
        for p in cls.properties:
            if p.signal:
                # a signal is only created when explicitly mentioned in the
                # class itself (and not when it is inherited).
                p.signal_name = ("on-%s-changed" % p.name).replace("_", "-")
                # avoid signals to be created twice. This happes when a plugin
                # is loaded twice. (for example in the unittests)
                if gobject.signal_lookup(p.signal_name, cls) == 0:
                    gobject.signal_new(p.signal_name, cls, gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, ())

        # assign the derived default, get and set functions
        for p in cls.properties:
            # default
            if p.fdefault is not None:
                derived_fdefault = dict.get(p.fdefault.__name__)
                if derived_fdefault is not None:
                    p.fdefault = derived_fdefault
            # get
            derived_fget = dict.get(p.fget.__name__)
            if derived_fget is not None:
                p.fget = derived_fget
            # set
            derived_fset = dict.get(p.fset.__name__)
            if derived_fset is not None:
                p.fset = derived_fset

        # merge the edit fields with those from the ancestors
        if not hasattr(cls, "dialog_fields"):
            cls.dialog_fields = set([])
        for base in bases:
            if hasattr(base, "dialog_fields"):
                cls.dialog_fields |= base.dialog_fields

        # create a nodeinfo if needed
        if not hasattr(cls, "info"):
            from node import NodeInfo
            cls.info = NodeInfo()
        # merge the node info with that from the ancestors
        d = {}
        for base in bases:
            if hasattr(base, "info"):
                d.update(base.info.__dict__)
        d.update(cls.info.__dict__)
        cls.info.__dict__ = d
Ejemplo n.º 28
0
    def __init__(self, headers=None, rows=None, types=None, combos=None, combotypes=None, selection_type=None):
        if gobject.signal_lookup('toggled', self) == 0:
            gobject.signal_new(
                "toggled",
                self,
                gobject.SIGNAL_ACTION,
                gobject.TYPE_NONE,
                (
                    gobject.TYPE_PYOBJECT,
                    gobject.TYPE_PYOBJECT,
                    gobject.TYPE_PYOBJECT
                ))
        if gobject.signal_lookup('changed', self) == 0:
            gobject.signal_new(
                "changed",
                self,
                gobject.SIGNAL_ACTION,
                gobject.TYPE_NONE,
                (
                    gobject.TYPE_PYOBJECT,
                    gobject.TYPE_PYOBJECT,
                    gobject.TYPE_PYOBJECT
                ))
        if gobject.signal_lookup('right-click', self) == 0:
            gobject.signal_new(
                'right-click',
                self, gobject.SIGNAL_ACTION,
                gobject.TYPE_NONE,
                (
                    gobject.TYPE_OBJECT,
                    gobject.TYPE_PYOBJECT,
                    gobject.TYPE_PYOBJECT,
                    gtk.gdk.Event
                ))
        if gobject.signal_lookup('double-click', self) == 0:
            gobject.signal_new(
                'double-click',
                self, gobject.SIGNAL_ACTION,
                gobject.TYPE_NONE,
                (
                    gobject.TYPE_OBJECT,
                    gobject.TYPE_PYOBJECT,
                    gobject.TYPE_PYOBJECT,
                    gtk.gdk.Event
                ))
        self._fallback_pixbuf = None

        # Remember: First cell is index
        if rows is None:
            rows = []

        if len(rows):
            self.rows = self._failsafe_rows(rows)
            if types is None:
                self._cell_types, self._render_types = self._convert_rows_to_types(self.rows)
            else:
                self._cell_types, self._render_types = self._convert_rows_to_types([types])
        elif types is not None:
            self.rows = rows
            self._cell_types, self._render_types = self._convert_rows_to_types([types])
        else:
            raise(ValueError, "You need to supply either rows or types.")

        number_of_combocols = len([
            col for col in self._cell_types
            if col is list
        ])
        if combos is not None:
            if type(combos[0][0]) not in (tuple, list):
                self._combos = [
                    [
                        [row] for row in combo
                    ]
                    for combo
                    in combos
                ]
            else:
                self._combos = combos
            if combotypes is not None:
                self._combocols = combotypes
            else:
                self._combocols = []
                for combo in self._combos:
                    if type(combo[0]) in (list, tuple):
                        self._combocols.append([str] * len(combo[0]))
                    else:
                        self._combocols.append([str])
            self._combomodels = [
                gtk.ListStore(*column)
                for column
                in self._combocols
            ]
            for combo_nr, combo in enumerate(self._combos):
                for row in combo:
                    self._combomodels[combo_nr].append(
                        self._create_model_row_from_row(row, self._combocols[combo_nr])
                    )
        else:
            if number_of_combocols:
                raise(ValueError, "When using Combo renderers, you need to assign the comborows.")

        if headers is None:
            headers = [ '' for i in range(len(self._cell_types)-1) ]

        self.headers = headers

        self.selection_type = selection_type

        gtk.VBox.__init__(self)

        self._create_widgets()
        self._create_headers()
        self.fill()
Ejemplo n.º 29
0
    def event_central(self, obj, event):
        ## This routine runs many times. Once for every kind
        ## of event the actor is getting.

        ## filter out only the mouse events.
        if event.type not in Mouserizer.__clutter_mouse_event_types:
            return Mouserizer.YES_CONTINUE_EMITTING

        ## filter out buttons we are NOT going to deal with
        if hasattr(event, "button"):
            b = 1 << (event.button - 1)
            #print bin(b)," vs ", bin(self.buttons)
            if not(b & self.buttons !=0 ):
                return Mouserizer.NO_STOP_EMITTING # is this wise?

        ## event_central ONLY runs when cursor is
        ## over the actor -- thus ENTER is implied.

        ## Make a note of PRESS/RELEASE
        if event.type==clutter.BUTTON_PRESS:
            self.ui_state = self.ui_state | Mouserizer.__FLAG_PRESSING # set bit
        if event.type==clutter.BUTTON_RELEASE:
            self.ui_state = self.ui_state | Mouserizer.__FLAG_RELEASING # set bit

        ## Make a note of MOTION
        ## First, clear it.
        self.ui_state = self.ui_state & ~Mouserizer.__FLAG_MOVING # clear bit
        if event.type==clutter.MOTION:
            self.ui_state = self.ui_state | Mouserizer.__FLAG_MOVING # set bit

        ## Now, what kinds of stuff is this actor interested in?

        ## DO META EVENTS - "More than" events. e.g. 'Click' is press, then release.
        if (self.ui & Mouserizer.CLICKABLE) != 0: # test bit
            if self.ui_state == Mouserizer.__PATTERN_CLICK:
                if event.click_count > 1:
                    self.emit('double-click', event)
                else:
                    ## A single click is fired just before double-click...!
                    self.emit('single-click', event)

        if (self.ui & Mouserizer.DRAGABLE) !=0: # test bit
            if self.ui_state == Mouserizer.__PATTERN_DRAG_START:
                self.ui_state=self.ui_state | Mouserizer.__FLAG_DRAGGING # set bit
                self.draglet = DragEnvelope( self, event )
                ## Phew! I thought I was fcuked! In order to get dragging to
                ## work when the pointer is NOT ON the Actor, I had to revert
                ## to grab_pointer* -- and that needs connecting. I connected the
                ## two appropriate event to *this* same function! And it works :D
                ##
                ## * grab_pointer causes the entire window (stage?) to focus on the
                ##   Actor passed -- so I get all motion and release events even where
                ##   the Actor aint.
                ##   ! Not sure what kind of recursive issues this may throw at me :(
                clutter.grab_pointer( self )
                self.connect('motion-event', self.event_central)
                self.connect('button-release-event', self.event_central)
                self.emit('drag-start', self.draglet )
            elif self.ui_state == Mouserizer.__PATTERN_DRAG:
                self.draglet.calcPos( event ) # A 'draglet' is a little wrapper containing the event and some tricks.
                ## Who is under me? Only do if PICK_UNDER flag is set.
                if self.__PICK_UNDER:
                    self.hide()
                    a = self.stage.get_actor_at_pos(clutter.PICK_REACTIVE, int(event.x),int(event.y))
                    self.show()
                    ## a is!
                    ## Only emit if a has a drag-over signal:
                    if gobject.signal_lookup('drag-over', a ):
                        print a, " under me"
                        a.emit('drag-over', self.draglet)
                self.emit('dragging', self.draglet)

            elif self.ui_state == Mouserizer.__PATTERN_DROP:
                self.draglet.calcPos( event )
                self.ui_state= self.ui_state & ~Mouserizer.__FLAG_DRAGGING # clear bit
                clutter.ungrab_pointer()
                self.emit("drop", self.draglet)
                del(self.draglet)

        ## META EVENTS are done.

        ## Flip opposites off.
        if event.type==clutter.BUTTON_PRESS:
            self.ui_state = self.ui_state & ~Mouserizer.__FLAG_RELEASING # clear bit
        if event.type==clutter.BUTTON_RELEASE:
            self.ui_state = self.ui_state & ~Mouserizer.__FLAG_PRESSING # clear bit
            self.ui_state = self.ui_state & ~Mouserizer.__FLAG_RELEASING # clear bit
            self.ui_state = self.ui_state & ~Mouserizer.__FLAG_DRAGGING # clear bit

        return Mouserizer.YES_CONTINUE_EMITTING
    def __init__(self,
                 frame,
                 message="",
                 default_text='',
                 textview=None,
                 modal=True):

        gtk.Dialog.__init__(self)

        # Test if the signal is already binded since we do not clear it
        # when we destroy FindDialog
        if not gobject.signal_lookup("find-click", gtk.Window):
            gobject.signal_new("find-click", gtk.Window,
                               gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
                               (gobject.TYPE_STRING, ))

        self.textview = textview
        self.nicotine = frame

        self.connect("delete-event", self.quit)

        # The destroy event shoul clean up the reference to FindDialog
        # in the NicotineFrame object
        self.connect("destroy", self.destroy)

        self.nextPosition = None
        self.currentPosition = None
        self.lastdirection = "next"

        if modal:
            self.set_modal(True)

        box = gtk.VBox(spacing=10)
        box.set_border_width(10)
        self.vbox.pack_start(box)
        box.show()

        if message:
            label = gtk.Label(message)
            box.pack_start(label, False, False)
            label.set_line_wrap(True)
            label.show()

        self.entry = gtk.Entry()

        box.pack_start(self.entry, False, False)
        self.entry.show()
        self.entry.grab_focus()
        self.entry.connect("activate", self.next)

        Previousbutton = self.nicotine.CreateIconButton(
            gtk.STOCK_GO_BACK, "stock", self.previous, _("Previous"))
        Previousbutton.set_flags(gtk.CAN_DEFAULT)
        self.action_area.pack_start(Previousbutton)

        Nextbutton = self.nicotine.CreateIconButton(gtk.STOCK_GO_FORWARD,
                                                    "stock", self.next,
                                                    _("Next"))
        Nextbutton.set_flags(gtk.CAN_DEFAULT)
        self.action_area.pack_start(Nextbutton)
        Nextbutton.grab_default()

        Cancelbutton = self.nicotine.CreateIconButton(gtk.STOCK_CANCEL,
                                                      "stock", self.quit,
                                                      _("Cancel"))
        Cancelbutton.set_flags(gtk.CAN_DEFAULT)
        self.action_area.pack_start(Cancelbutton)
Ejemplo n.º 31
0
 def on_copy_tree(self):
     """Callback for copy on whole tree"""
     widget = self._main_window.get_focus()
     if gobject.signal_lookup("copy-tree-clipboard", widget) != 0:
         widget.emit("copy-tree-clipboard")
Ejemplo n.º 32
0
 def install_signal(self, signal):
     if not gobject.signal_lookup(signal, self.__class__):
         gobject.signal_new(signal, self.__class__, gobject.SIGNAL_RUN_LAST,
                            gobject.TYPE_NONE, (gobject.TYPE_PYOBJECT, ))
Ejemplo n.º 33
0
 def install_signal(self, signal):
     if not gobject.signal_lookup(signal, self.__class__):
         gobject.signal_new(signal, self.__class__, gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
             (gobject.TYPE_PYOBJECT,))
Ejemplo n.º 34
-1
 def __init__(self):
     if not gobject.signal_lookup("output", ShellCommandJob):
         gobject.signal_new("output", ShellCommandJob, \
                 gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, \
                 [str])
     if not gtk.main_level():
         gtk.gdk.threads_init()  # _DEBE_ llamarse _ANTES_ del gtk.main por temas del GIL.
Ejemplo n.º 35
-1
    def __init__(self, parent, englabel=None, userdict={}, 
                    timeout=10):
        """
        The PTK engine class for embedding in gtk applications. 
        To use create an instance of this or a subclass. 
        It uses the parent object for signals. 
        engine.disconnect() should also be called before the application exits.
        
        Important. 
        It uses the a the gtk mainloop to post/bind events and starts a 
        communications thread, therefore gtk.gdk.threads_init() must be called 
        before the main loop is started!

            gtk.gdk.threads_init()  
            gtk.main()

        Signals to use:
        'engine_disconnect' -  sent went the engine disconnects.

        Methods/attributes you might want to overload:
        _get_welcome()  - Returns a string welcome message.
        self.eng_prompts - these are the prompts used by the controlling console.
        """
        self.parent = parent
        
        #add the engine disconnect signal
        if gobject.signal_lookup("engine_disconnect", self.parent) == 0:
            gobject.signal_new("engine_disconnect", self.parent, 
                               gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,())
        Engine.__init__(self, englabel, userdict, timeout)
    def __init__(self, name, format="%a %b %d %Y", parent_window=None):
        try:
            if not gobject.signal_lookup("on-change-cbcalendar", self):
                gobject.signal_new("on-change-cbcalendar",
                                   self,
                                   gobject.SIGNAL_RUN_LAST,
                                   gobject.TYPE_NONE,
                                   (float,))
        except:
            pass

        self.format = format
        self._name = name
        self.parent_window = parent_window

        gtk.HBox.__init__(self)

        self.entry = gtk.Entry()
        self.button = gtk.Button()
        arrow = gtk.Arrow(gtk.ARROW_DOWN, gtk.SHADOW_IN)
        self.button.add(arrow)
        
        self.entry.set_editable(False)
        self.button.connect("pressed", self.show_calendar)
        
        self.pack_start(self.entry, False, False)
        self.pack_start(self.button, False, False)

        self._value = 0
        
        self.direction = 'down'
        
        self.show_all()