More work on the window management refactor
This commit is contained in:
Marco Pesenti Gritti
+42
-228
@@ -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])
|
||||
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
Reference in New Issue
Block a user