More work on the window management refactor

3 files changed, 61 insertions, 246 deletions

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()