From 1cc14e406a62a015067446976d149a1f60de5197 Mon Sep 17 00:00:00 2001 From: Marco Pesenti Gritti Date: Sun, 09 Jul 2006 15:37:54 +0000 Subject: More work on the window management refactor --- (limited to 'sugar') diff --git a/sugar/activity/Activity.py b/sugar/activity/Activity.py index faae27e..afdd621 100644 --- a/sugar/activity/Activity.py +++ b/sugar/activity/Activity.py @@ -9,6 +9,8 @@ pygtk.require('2.0') import gtk, gobject from sugar.LogWriter import LogWriter +from sugar import keybindings +import sugar.util SHELL_SERVICE_NAME = "com.redhat.Sugar.Shell" SHELL_SERVICE_PATH = "/com/redhat/Sugar/Shell" @@ -16,12 +18,6 @@ SHELL_SERVICE_PATH = "/com/redhat/Sugar/Shell" ACTIVITY_SERVICE_NAME = "com.redhat.Sugar.Activity" ACTIVITY_SERVICE_PATH = "/com/redhat/Sugar/Activity" -ON_CONNECTED_TO_SHELL_CB = "connected_to_shell" -ON_DISCONNECTED_FROM_SHELL_CB = "disconnected_from_shell" -ON_RECONNECTED_TO_SHELL_CB = "reconnected_to_shell" -ON_CLOSE_FROM_USER_CB = "close_from_user" -ON_LOST_FOCUS_CB = "lost_focus" -ON_GOT_FOCUS_CB = "got_focus" ON_PUBLISH_CB = "publish" def get_path(activity_name): @@ -65,15 +61,11 @@ class ActivityFactory(dbus.service.Object): service = Service.deserialize(serialized_service) activity = self._class(args) - gobject.idle_add(self._start_activity_cb, activity, service) @dbus.service.method("com.redhat.Sugar.ActivityFactory") def create(self): self.create_with_service(None, []) - def _start_activity_cb(self, activity, service): - activity.connect_to_shell(service) - def create(activity_name, service = None, args = None): """Create a new activity from his name.""" bus = dbus.SessionBus() @@ -118,29 +110,19 @@ class ActivityDbusService(dbus.service.Object): The dbus service is separate from the actual Activity object so that we can tightly control what stuff passes through the dbus python bindings.""" - _ALLOWED_CALLBACKS = [ON_CONNECTED_TO_SHELL_CB, ON_DISCONNECTED_FROM_SHELL_CB, \ - ON_RECONNECTED_TO_SHELL_CB, ON_CLOSE_FROM_USER_CB, ON_LOST_FOCUS_CB, \ - ON_GOT_FOCUS_CB, ON_PUBLISH_CB] + _ALLOWED_CALLBACKS = [ON_PUBLISH_CB] - def __init__(self, activity): + def __init__(self, xid, activity): self._activity = activity - self._activity_id = None - self._activity_object = None - self._service = None - self._bus = dbus.SessionBus() - self._bus.add_signal_receiver(self.name_owner_changed, dbus_interface = "org.freedesktop.DBus", signal_name = "NameOwnerChanged") self._callbacks = {} for cb in self._ALLOWED_CALLBACKS: self._callbacks[cb] = None - - def __del__(self): - if self._activity_id: - del self._service - del self._activity_container - del self._activity_conainer_object - del self._activity_object - self._bus.remove_signal_receiver(self.name_owner_changed, dbus_interface="org.freedesktop.DBus", signal_name="NameOwnerChanged") - del self._bus + + bus = dbus.SessionBus() + service_name = ACTIVITY_SERVICE_NAME + "%s" % xid + object_path = ACTIVITY_SERVICE_PATH + "/%s" % xid + service = dbus.service.BusName(service_name, bus=bus) + dbus.service.Object.__init__(self, service, object_path) def register_callback(self, name, callback): if name not in self._ALLOWED_CALLBACKS: @@ -159,98 +141,33 @@ class ActivityDbusService(dbus.service.Object): if name in self._ALLOWED_CALLBACKS and self._callbacks[name]: gobject.idle_add(self._call_callback_cb, self._callbacks[name], *args) - def connect_to_shell(self, service=None): - """Register with the shell via dbus, getting an activity ID and - and XEMBED window ID in which to display the Activity.""" - self._activity_container_object = self._bus.get_object(SHELL_SERVICE_NAME, \ - SHELL_SERVICE_PATH + "/ActivityContainer") - self._activity_container = dbus.Interface(self._activity_container_object, \ - SHELL_SERVICE_NAME + ".ActivityContainer") - - if service is None: - self._activity_id = self._activity_container.add_activity(self._activity.default_type()) - else: - self._activity_id = service.get_activity_id() - self._activity_container.add_activity_with_id(self._activity.default_type(), self._activity_id) - - self._object_path = SHELL_SERVICE_PATH + "/Activities/%s" % self._activity_id - - print "ActivityDbusService: object path is '%s'" % self._object_path - - self._activity_object = dbus.Interface(self._bus.get_object(SHELL_SERVICE_NAME, self._object_path), \ - SHELL_SERVICE_NAME + ".ActivityHost") - - # Now let us register a peer service so the Shell can poke it - self._peer_service_name = ACTIVITY_SERVICE_NAME + "%s" % self._activity_id - self._peer_object_path = ACTIVITY_SERVICE_PATH + "/%s" % self._activity_id - self._service = dbus.service.BusName(self._peer_service_name, bus=self._bus) - dbus.service.Object.__init__(self, self._service, self._peer_object_path) - - self._activity_object.set_peer_service_name(self._peer_service_name, self._peer_object_path) - - self._call_callback(ON_CONNECTED_TO_SHELL_CB, self._activity_object, self._activity_id, service) - - def _shutdown_reply_cb(self): - """Shutdown was successful, tell the Activity that we're disconnected.""" - self._call_callback(ON_DISCONNECTED_FROM_SHELL_CB) - - def _shutdown_error_cb(self, error): - print "ActivityDbusService: error during shutdown - '%s'" % error - - def shutdown(self): - """Notify the shell that we are shutting down.""" - self._activity_object.shutdown(reply_handler=self._shutdown_reply_cb, error_handler=self._shutdown_error_cb) - - def name_owner_changed(self, service_name, old_service_name, new_service_name): - """Handle dbus NameOwnerChanged signals.""" - if not self._activity_id: - # Do nothing if we're not connected yet - return - - if service_name == SHELL_SERVICE_NAME and not len(new_service_name): - self._call_callback(ON_DISCONNECTED_FROM_SHELL_CB) - elif service_name == SHELL_SERVICE_NAME and not len(old_service_name): - self._call_callback(ON_RECONNECTED_TO_SHELL_CB) - - @dbus.service.method(ACTIVITY_SERVICE_NAME) - def lost_focus(self): - """Called by the shell to notify us that we've lost focus.""" - self._call_callback(ON_LOST_FOCUS_CB) - - @dbus.service.method(ACTIVITY_SERVICE_NAME) - def got_focus(self): - """Called by the shell to notify us that the user gave us focus.""" - self._call_callback(ON_GOT_FOCUS_CB) - - @dbus.service.method(ACTIVITY_SERVICE_NAME) - def close_from_user(self): - """Called by the shell to notify us that the user closed us.""" - self._call_callback(ON_CLOSE_FROM_USER_CB) - @dbus.service.method(ACTIVITY_SERVICE_NAME) def publish(self): """Called by the shell to request the activity to publish itself on the network.""" self._call_callback(ON_PUBLISH_CB) - @dbus.service.signal(ACTIVITY_SERVICE_NAME) - def ActivityShared(self): - pass + @dbus.service.method(ACTIVITY_SERVICE_NAME) + def get_id(self): + """Get the activity identifier""" + self._activity.get_id() + + @dbus.service.method(ACTIVITY_SERVICE_NAME) + def get_shared(self): + """Get the activity identifier""" + return self._activity.get_shared() class Activity(gtk.Window): """Base Activity class that all other Activities derive from.""" - def __init__(self, default_type): + def __init__(self, default_type, activity_id = None): gtk.Window.__init__(self) - self._dbus_service = self._get_new_dbus_service() - self._dbus_service.register_callback(ON_CONNECTED_TO_SHELL_CB, self._internal_on_connected_to_shell_cb) - self._dbus_service.register_callback(ON_DISCONNECTED_FROM_SHELL_CB, self._internal_on_disconnected_from_shell_cb) - self._dbus_service.register_callback(ON_RECONNECTED_TO_SHELL_CB, self._internal_on_reconnected_to_shell_cb) - self._dbus_service.register_callback(ON_CLOSE_FROM_USER_CB, self._internal_on_close_from_user_cb) - self._dbus_service.register_callback(ON_PUBLISH_CB, self._internal_on_publish_cb) - self._dbus_service.register_callback(ON_LOST_FOCUS_CB, self._internal_on_lost_focus_cb) - self._dbus_service.register_callback(ON_GOT_FOCUS_CB, self._internal_on_got_focus_cb) - self._has_focus = False + if activity_id is None: + self._activity_id = sugar.util.unique_id() + else: + self._activity_id = activity_id + + self._dbus_service = None self._initial_service = None self._activity_object = None self._shared = False @@ -258,6 +175,20 @@ class Activity(gtk.Window): raise ValueError("Default type must be a valid string.") self._default_type = default_type + keybindings.setup_global_keys(self) + + self.connect('realize', self.__realize) + + self.show() + + def __realize(self, window): + if not self._dbus_service: + self._register_service() + + def _register_service(self): + self._dbus_service = self._get_new_dbus_service() + self._dbus_service.register_callback(ON_PUBLISH_CB, self._internal_on_publish_cb) + def _cleanup(self): if self._dbus_service: del self._dbus_service @@ -269,7 +200,7 @@ class Activity(gtk.Window): def _get_new_dbus_service(self): """Create and return a new dbus service object for this Activity. Allows subclasses to use their own dbus service object if they choose.""" - return ActivityDbusService(self) + return ActivityDbusService(self.window.xid, self) def default_type(self): return self._default_type @@ -280,113 +211,20 @@ class Activity(gtk.Window): self._shared = True self._dbus_service.ActivityShared() - def shared(self): + def get_shared(self): return self._shared def has_focus(self): """Return whether or not this Activity is visible to the user.""" return self._has_focus - def connect_to_shell(self, service = None): - """Called by our controller to tell us to initialize and connect - to the shell.""" - self.show() - self._dbus_service.connect_to_shell(service) - - def _internal_on_connected_to_shell_cb(self, activity_object, activity_id, service=None): - """Callback when the dbus service object has connected to the shell.""" - self._activity_object = activity_object - self._activity_id = activity_id - self._initial_service = service - if service: - self.set_shared() - self.on_connected_to_shell() - - def _internal_on_disconnected_from_shell_cb(self): - """Callback when the dbus service object has disconnected from the shell.""" - self._cleanup() - self.on_disconnected_from_shell() - - def _internal_on_reconnected_to_shell_cb(self): - """Callback when the dbus service object has reconnected to the shell.""" - self.on_reconnected_to_shell() - - def _internal_on_close_from_user_cb(self): - """Callback when the dbus service object tells us the user has closed our activity.""" - self.shutdown() - self.on_close_from_user() - def _internal_on_publish_cb(self): """Callback when the dbus service object tells us the user has closed our activity.""" self.publish() - def _internal_on_lost_focus_cb(self): - """Callback when the dbus service object tells us we have lost focus.""" - self._has_focus = False - self.on_lost_focus() - - def _internal_on_got_focus_cb(self): - """Callback when the dbus service object tells us we have gotten focus.""" - self._has_focus = True - self.set_has_changes(False) - self.on_got_focus() - - def set_ellipsize_tab(self, ellipsize): - """Sets this Activity's tab text to be ellipsized or not.""" - self._activity_object.set_ellipsize_tab(ellipsize) - - def set_tab_text(self, text): - """Sets this Activity's tab text.""" - self._activity_object.set_tab_text(text) - - def set_can_close(self, can_close): - """Sets whether or not this Activity can be closed by the user.""" - self._activity_object.set_can_close(can_close) - - def set_show_tab_icon(self, show_icon): - """Sets whether or not an icon is shown in this Activity's tab.""" - self._activity_object.set_tab_show_icon(show_icon) - - def set_tab_icon(self, pixbuf=None, name=None): - """Set the Activity's tab icon, either from pixbuf data - or by an icon theme icon name.""" - if name: - icon_theme = gtk.icon_theme_get_default() - icon_info = icon_theme.lookup_icon(name, gtk.ICON_SIZE_MENU, 0) - if icon_info: - orig_pixbuf = icon_info.load_icon() - pixbuf = orig_pixbuf.scale_simple(16, 16, gtk.gdk.INTERP_BILINEAR) - - if pixbuf: - # Dump the pixel data into an array and shove it through dbus - pixarray = [] - pixstr = pixbuf.get_pixels(); - for c in pixstr: - pixarray.append(c) - self._activity_object.set_tab_icon(pixarray, \ - pixbuf.get_colorspace(), \ - pixbuf.get_has_alpha(), \ - pixbuf.get_bits_per_sample(), \ - pixbuf.get_width(), \ - pixbuf.get_height(), \ - pixbuf.get_rowstride()) - - def set_has_changes(self, has_changes): - """Marks this Activity as having changes. This usually means - that this Activity's tab turns a red color or something else - to notify the user that this Activity needs attention.""" - if not self.has_focus() and has_changes: - self._activity_object.set_has_changes(True) - else: - self._activity_object.set_has_changes(False) - def get_id(self): return self._activity_id - def shutdown(self): - """Disconnect from the shell and clean up.""" - self._dbus_service.shutdown() - ############################################################# # Pure Virtual methods that subclasses may/may not implement ############################################################# @@ -395,29 +233,5 @@ class Activity(gtk.Window): """Called to request the activity to publish itself on the network.""" pass - def on_lost_focus(self): - """Triggered when this Activity loses focus.""" - pass - - def on_got_focus(self): - """Triggered when this Activity gets focus.""" - pass - - def on_disconnected_from_shell(self): - """Triggered when we disconnect from the shell.""" - pass - - def on_reconnected_to_shell(self): - """Triggered when the shell's service comes back.""" - pass - - def on_connected_to_shell(self): - """Triggered when this Activity has successfully connected to the shell.""" - pass - - def on_close_from_user(self): - """Triggered when this Activity is closed by the user.""" - pass - if __name__ == "__main__": main(sys.argv[1], sys.argv[2]) diff --git a/sugar/chat/ChatWindow.py b/sugar/chat/ChatWindow.py deleted file mode 100644 index b06175d..0000000 --- a/sugar/chat/ChatWindow.py +++ /dev/null @@ -1,18 +0,0 @@ -import pygtk -pygtk.require('2.0') -import gtk - -from sugar.chat.Chat import Chat - -class ChatWindow(gtk.Window): - def __init__(self): - gtk.Window.__init__(self) - self._chat = None - - def set_chat(self, chat): - if self._chat != None: - self.remove(self._chat) - - self._chat = chat - self.add(self._chat) - self._chat.show() diff --git a/sugar/keybindings.py b/sugar/keybindings.py new file mode 100644 index 0000000..bb4b07d --- /dev/null +++ b/sugar/keybindings.py @@ -0,0 +1,19 @@ +import gtk +import dbus + +# FIXME These should be handled by the wm, but it's incovenient +# to do that with matchbox at the moment + +def setup_global_keys(window, shell = None): + if not shell: + bus = dbus.SessionBus() + proxy_obj = bus.get_object('com.redhat.Sugar.Shell', '/com/redhat/Sugar/Shell') + shell = dbus.Interface(proxy_obj, 'com.redhat.Sugar.Shell') + + window.connect("key-press-event", __key_press_event_cb, shell) + +def __key_press_event_cb(window, event, shell): + if event.keyval == gtk.keysyms.F2: + shell.toggle_people() + if event.keyval == gtk.keysyms.F3: + shell.toggle_console() -- cgit v0.9.1