Python Bus.connect方法代码示例

# 需要导入模块: from bus import Bus [as 别名]
# 或者: from bus.Bus import connect [as 别名]
    class TestWindow(gtk.Window):
        def __init__(self):
            super(TestWindow,self).__init__()

            self.__bus = Bus()
            print self.__bus.get_name()
            self.__bus.connect("disconnected", gtk.main_quit)
            context_path = self.__bus.create_input_context("Test")
            print context_path
            self.__context = InputContext(self.__bus, context_path)
            self.__context.set_capabilities (9)

            self.__context.connect("commit-text", self.__commit_text_cb)
            self.__context.connect("update-preedit-text", self.__update_preedit_text_cb)
            self.__context.connect("show-preedit-text", self.__show_preedit_text_cb)
            self.__context.connect("update-auxiliary-text", self.__update_auxiliary_text_cb)
            self.__context.connect("update-lookup-table", self.__update_lookup_table_cb)

            self.set_events(gtk.gdk.KEY_PRESS_MASK | gtk.gdk.KEY_RELEASE_MASK | gtk.gdk.FOCUS_CHANGE_MASK)

            self.connect("key-press-event", self.__key_press_event_cb)
            self.connect("key-release-event", self.__key_release_event_cb)
            self.connect("delete-event", gtk.main_quit)
            self.connect("focus-in-event", lambda *args: self.__context.focus_in())
            self.connect("focus-out-event", lambda *args: self.__context.focus_out())

            self.show_all()

        def __commit_text_cb(self, context, text):
            print "commit-text:", text.text

        def __update_preedit_text_cb(self, context, text, cursor_pos, visible):
            print "preedit-text:", text.text, cursor_pos, visible

        def __show_preedit_text_cb(self, context):
            print "show-preedit-text"

        def __hide_preedit_text_cb(self, context):
            print "hide-preedit-text"

        def __update_auxiliary_text_cb(self, context, text, visible):
            print "auxiliary-text:", text.text, visible

        def __update_lookup_table_cb(self, context, table, visible):
            print "update-lookup-table:", visible

        def __key_press_event_cb(self, widget, event):
            self.__context.process_key_event(event.keyval, event.state)

        def __key_release_event_cb(self, widget, event):
            self.__context.process_key_event(event.keyval, event.state | modifier.RELEASE_MASK)

# 需要导入模块: from bus import Bus [as 别名]
# 或者: from bus.Bus import connect [as 别名]
    class TestPanel(PanelBase):
        def __init__(self):
            self.__bus = Bus()
            self.__bus.connect("disconnected", gtk.main_quit)
            super(TestPanel, self).__init__(self.__bus)
            self.__bus.request_name(IBUS_SERVICE_PANEL, 0)

        def focus_in(self, ic):
            print "focus-in:", ic
            context = InputContext(self.__bus, ic)
            info = context.get_factory_info()
            print "factory:", info.name

        def focus_out(self, ic):
            print "focus-out:", ic

        def update_auxiliary_text(self, text, visible):
            print "update-auxiliary-text:", text.text

        def update_lookup_table(self, table, visible):
            print "update-lookup-table", table

# 需要导入模块: from bus import Bus [as 别名]
# 或者: from bus.Bus import connect [as 别名]
class Peer(object):
    def __init__(self, share_path, host=None, port=None):
        self.host, self.port = (host or ALL), (port or PORT)
        self.db = dal.DB("sqlite://")
        self.db.define_table("config", dal.Field("key", key=True), dal.Field("value"))
        if "peerid" not in self.db.config:
            self.db.config["peerid"] = hex(random.getrandbits(48))[2:14]
        self.db.define_table(
            "peers",
            dal.Field("peerid"),
            dal.Field(
                "address",
                serialize=lambda x: "%s:%i" % x,
                convert=lambda x: tuple(f(a) for f, a in zip((str, int), x.rsplit(":", 1))),
            ),
            dal.Field("ignore", default=False),
        )
        self.db.define_table("resources", dal.Field("path", key=True), dal.Field("age", int), dal.Field("real_path"))
        if os.path.isdir(share_path) and share_path[-1] != "/":
            share_path += "/"
        for path in find(os.path.abspath(share_path)):
            short_path = path[len(share_path) :]
            print path, short_path
            self.db.resources.insert(path=short_path, age=mod_time(os.stat(path)), real_path=path)
        self.bus = Bus()
        self.bus.connect(MessageType.HeardFromPeer, self.introduce)
        self.bus.connect(MessageType.Request, self.notify)
        self.bus.connect(MessageType.RemoteUpdate, self.remote_update)
        self.public = Broadcaster(self.bus, self.db.config["peerid"], (self.host, self.port))
        self.private = Whisperer(self.bus, (self.host, self.port))

    def start(self):
        self.bus.start()
        self.public.start()
        self.private.start()

    def announce(self):
        self.broadcaster.send("Hello?")

    def remote_update(self, message):
        if self.filter(message.path):
            self.private.retrieve(message.address, message.path)

    def introduce(self, message):
        print message
        self.db.peers.insert(**message)

    def notify(self, message):
        print message
        self.public.send(self.db.resources[message.path].age)

    def stop(self):
        self.private.stop()
        self.public.stop()
        self.bus.stop()