Implement the grid, regress UI a bit

shell/frame/BottomPanel.py

@@ -6,25 +6,25 @@ import conf
 from sugar.canvas.IconItem import IconItem
 from sugar.canvas.IconColor import IconColor
 from sugar.presence import PresenceService
-from frame.Panel import Panel
+from sugar.canvas.GridLayout import GridGroup
+from sugar.canvas.GridLayout import GridConstraints
 
 class ActivityItem(IconItem):
-	def __init__(self, activity, size):
+	def __init__(self, activity):
 		icon_name = activity.get_icon()
 		if not icon_name:
 			act_type = activity.get_type()
 			raise RuntimeError("Activity %s did not have an icon!" % act_type)
-		IconItem.__init__(self, icon_name=icon_name,
+		IconItem.__init__(self, icon_name=icon_name, color=IconColor('white'))
-						  color=IconColor('white'), size=size)
 		self._activity = activity
 
 	def get_bundle_id(self):
 		return self._activity.get_id()
 
 class InviteItem(IconItem):
-	def __init__(self, invite, size):
+	def __init__(self, invite):
 		IconItem.__init__(self, icon_name=invite.get_icon(),
-						  color=invite.get_color(), size=size)
+						  color=invite.get_color())
 		self._invite = invite
 
 	def get_activity_id(self):
@@ -33,12 +33,11 @@ class InviteItem(IconItem):
 	def get_bundle_id(self):
 		return self._invite.get_bundle_id()
 
-class ActivityBar(goocanvas.Group):
+class BottomPanel(GridGroup):
-	def __init__(self, shell, invites, height):
+	def __init__(self, shell, invites):
-		goocanvas.Group.__init__(self)
+		GridGroup.__init__(self, 16, 1)
 
 		self._shell = shell
-		self._height = height
 
 		registry = conf.get_activity_registry()
 		for activity in registry.list_activities():
@@ -66,37 +65,14 @@ class ActivityBar(goocanvas.Group):
 			logging.info("Activity %s did not have an icon.  Won't show it." % name)
 			return
 
-		item = ActivityItem(activity, self._height)
+		item = ActivityItem(activity)
 		item.connect('clicked', self.__activity_clicked_cb)
-
+		constraints = GridConstraints(self.get_n_children() + 1, 0, 1, 1)
-		icon_size = self._height
+		constraints.padding = 6
-		x = (icon_size + 6) * self.get_n_children()
+		self._layout.set_constraints(item, constraints)
-		item.set_property('x', x)
-
 		self.add_child(item)
 
 	def add_invite(self, invite):
-		item = InviteItem(invite, self._height)
+		item = InviteItem(invite)
 		item.connect('clicked', self.__invite_clicked_cb)
-
-		icon_size = self._height
-		x = (icon_size + 6) * self.get_n_children()
-		item.set_property('x', x)
-
 		self.add_child(item)
-
-class BottomPanel(Panel):
-	def __init__(self, shell, invites):
-		Panel.__init__(self)
-
-		self._shell = shell
-		self._invites = invites
-
-	def construct(self):
-		Panel.construct(self)
-
-		root = self.get_root()
-
-		activity_bar = ActivityBar(self._shell, self._invites,
-								   self.get_height())
-		root.add_child(activity_bar)

shell/frame/Frame.py

@@ -1,38 +1,66 @@
 import gtk
 import gobject
+import goocanvas
 
 from frame.BottomPanel import BottomPanel
 from frame.RightPanel import RightPanel
 from frame.TopPanel import TopPanel
-from frame.Panel import Panel
+from frame.PanelWindow import PanelWindow
+
+from sugar.canvas.ScreenContainer import ScreenContainer
+from sugar.canvas.GridLayout import GridLayout
+from sugar.canvas.GridLayout import GridConstraints
+from sugar.canvas.GridLayout import GridGroup
 
 class Frame:
 	def __init__(self, shell, owner):
-		size = 30
+		self._windows = []
 
-		self._panels = []
+		self._model = goocanvas.CanvasModelSimple()
+		item = goocanvas.Rect(x=0, y=0, width=800, height=600,
+							  line_width=0, fill_color="#4f4f4f")
+		self._model.get_root_item().add_child(item)
+
+		self._screen_layout = GridLayout()
+		self._screen_container = ScreenContainer(self._windows)
+
+		group = GridGroup()
+		group.props.width = 800
+		group.props.height = 600
+		layout = group.get_layout()
+
+		constraints = GridConstraints(0, 11, 16, 1)
+		self._create_window(constraints)
 
 		panel = BottomPanel(shell, owner.get_invites())
-		panel.set_position(size, 0)
+		layout.set_constraints(panel, constraints)
-		panel.move(0, gtk.gdk.screen_height() - size)
+		group.add_child(panel)
-		panel.resize(gtk.gdk.screen_width(), size)
-		self._panels.append(panel)
 
-		panel = RightPanel(shell, owner.get_friends())
+		# Top
-		panel.move(gtk.gdk.screen_width() - size, size)
+		constraints = GridConstraints(0, 0, 16, 1)
-		panel.resize(size, gtk.gdk.screen_height() - size * 2)
+		self._create_window(constraints)
-		self._panels.append(panel)
 
-		panel = TopPanel(shell)
+		# Left
-		panel.set_position(size, 0)
+		constraints = GridConstraints(0, 1, 1, 10)
-		panel.move(0, 0)
+		self._create_window(constraints)
-		panel.resize(gtk.gdk.screen_width(), size)
-		self._panels.append(panel)
 
-		panel = Panel()
+		# Right
-		panel.move(0, size)
+		constraints = GridConstraints(15, 1, 1, 10)
-		panel.resize(size, gtk.gdk.screen_height() - size * 2)
+		self._create_window(constraints)
-		self._panels.append(panel)
+
+		self._model.get_root_item().add_child(group)
+		self._screen_container.set_layout(self._screen_layout)
+
+	def _create_window(self, constraints):
+		layout = self._screen_layout
+
+		window = PanelWindow(self._model)
+		layout.set_constraints(window, constraints)
+		self._windows.append(window)
+
+		bounds = layout.get_bounds(self._screen_container, constraints)
+		window.get_view().set_bounds(bounds[0], bounds[1],
+									 bounds[2], bounds[3])
 
 	def __hide_timeout_cb(self):
 		self.hide()
@@ -43,15 +71,15 @@ class Frame:
 		gobject.timeout_add(seconds * 1000, self.__hide_timeout_cb)
 
 	def show(self):
-		for panel in self._panels:
+		for panel in self._windows:
 			panel.show()
 
 	def hide(self):
-		for panel in self._panels:
+		for panel in self._windows:
 			panel.hide()
 
 	def toggle_visibility(self):
-		for panel in self._panels:
+		for panel in self._windows:
 			if panel.props.visible:
 				panel.hide()
 			else:

shell/frame/Panel.py

@@ -1,72 +0,0 @@
-import gtk
-import goocanvas
-
-class PanelView(goocanvas.CanvasView):
-	BORDER = 4
-
-	def construct(self, x, y):
-		model = goocanvas.CanvasModelSimple()
-		root = model.get_root_item()
-
-		item = goocanvas.Rect(x=0, y=0,
-							  width=self.get_allocation().width,
-							  height=self.get_allocation().height,
-							  line_width=0, fill_color="#4f4f4f")
-		root.add_child(item)
-
-		self._group = goocanvas.Group()
-		root.add_child(self._group)
-		self._group.translate(x + PanelView.BORDER, y + PanelView.BORDER)
-
-		self.set_model(model)
-
-	def get_root_group(self):
-		return self._group
-
-class Panel(gtk.Window):
-	def __init__(self):
-		gtk.Window.__init__(self)
-		self._x = 0
-		self._y = 0
-		self._constructed = False
-
-		self._view = PanelView()
-		self.add(self._view)
-		self._view.show()
-
-		self.set_decorated(False)
-
-		self.realize()
-		self.window.set_type_hint(gtk.gdk.WINDOW_TYPE_HINT_DIALOG)
-		self.window.set_accept_focus(False)
-
-		screen = gtk.gdk.screen_get_default()
-		self.window.set_transient_for(screen.get_root_window())
-
-	def get_view(self):
-		return self._view
-
-	def get_root(self):
-		return self._view.get_root_group()
-
-	def get_height(self):
-		height = self._view.get_allocation().height
-		return height - PanelView.BORDER * 2
-
-	def get_width(self):
-		width = self._view.get_allocation().width
-		return width - PanelView.BORDER * 2
-
-	def set_position(self, x, y):
-		self._x = x
-		self._y = y
-
-	def construct(self):
-		self._view.construct(self._x, self._y)
-		self._constructed = True
-
-	def show(self):
-		gtk.Window.show(self)
-
-		if not self._constructed:
-			self.construct()

shell/frame/PanelWindow.py

@@ -0,0 +1,16 @@
+import gtk
+
+from sugar.canvas.CanvasWindow import CanvasWindow
+
+class PanelWindow(CanvasWindow):
+	def __init__(self, model):
+		CanvasWindow.__init__(self, model)
+
+		self.set_decorated(False)
+
+		self.realize()
+		self.window.set_type_hint(gtk.gdk.WINDOW_TYPE_HINT_DIALOG)
+		self.window.set_accept_focus(False)
+
+		screen = gtk.gdk.screen_get_default()
+		self.window.set_transient_for(screen.get_root_window())

sugar/canvas/GridLayout.py

@@ -1,40 +1,129 @@
+import gobject
+import goocanvas
+
 class GridConstraints:
-	def __init__(x, y, width, height):
+	def __init__(self, x, y, width, height):
 		self.x = x
 		self.y = y
 		self.width = width
 		self.height = height
+		self.padding = 0
 
 class GridLayout:
-	def __init__(self, rows, cols):
+	def __init__(self, rows=16, cols=12):
 		self._rows = rows
 		self._cols = cols
 
 		self._constraints = {}
 
-	def set_constraints(component, constraints):
+	def set_constraints(self, component, constraints):
 		self._constraints[component] = constraints
 
 	def _get_geometry(self, container, component):
 		constraints = self._constraints[component]
 		if constraints:
-			x = constraints.x * component.props.width / self._rows
+			return self.get_bounds(container, constraints)
-			y = constraints.y * component.props.height / self._cols
-			width = constraints.width * component.props.width / self._rows
-			height = constraints.height * component.props.height / self._cols
-
-			return [x, y, width, height]
 		else:
 			return [0, 0, 0, 0]
 
-	def layout_canvas_group(group):
+	def get_bounds(self, container, constraints):
+		w = container.props.width
+		h = container.props.height
+		padding = constraints.padding
+
+		x = constraints.x * w / self._rows + padding
+		y = constraints.y * h / self._cols + padding
+
+		width = constraints.width * w / self._rows - padding * 2
+		height = constraints.height * h / self._cols + padding * 2
+
+		return [x, y, width, height]
+
+	def layout_canvas_group(self, group):
 		i = 0
 		while i < group.get_n_children():
 			item = group.get_child(i)
 
 			[x, y, width, height] = self._get_geometry(group, item)
 
+			print item
+			print [x, y, width, height]
+			print group.props.width
+
 			item.props.x = x
 			item.props.y = y
-			item.props.width = width
+
-			item.props.height = height
+			try:
+				item.props.width = width
+				item.props.height = height
+			except:
+				item.props.size = width
+
+			i += 1
+
+	def layout_screen(self, screen):
+		for window in screen.get_windows():
+			[x, y, width, height] = self._get_geometry(screen, window)
+			window.move(x, y)
+			window.resize(width, height)
+
+class GridGroup(goocanvas.Group):
+	__gproperties__ = {
+		'x'    	   : (int, None, None, 0, 1600, 800,
+					  gobject.PARAM_READWRITE),
+		'y'        : (int, None, None, 0, 1200, 600,
+					  gobject.PARAM_READWRITE),
+		'width'    : (int, None, None, 0, 1600, 800,
+					  gobject.PARAM_READWRITE),
+		'height'   : (int, None, None, 0, 1200, 600,
+					  gobject.PARAM_READWRITE)
+	}
+
+	def _update_position(self):
+		if self._x != 0 or self._y != 0:
+			self.translate(self._x, self._y)
+
+	def do_set_property(self, pspec, value):
+		if pspec.name == 'width':
+			self._width = value
+			self._layout.layout_canvas_group(self)
+		elif pspec.name == 'height':
+			self._height = value
+			self._layout.layout_canvas_group(self)
+		elif pspec.name == 'x':
+			self._x = value
+			self._update_position()
+		elif pspec.name == 'y':
+			self._y = value
+			self._update_position()
+
+	def do_get_property(self, pspec):
+		if pspec.name == 'width':
+			return self._width
+		elif pspec.name == 'height':
+			return self._height
+		elif pspec.name == 'x':
+			return self._x
+		elif pspec.name == 'x':
+			return self._x
+
+	def __init__(self, rows=-1, cols=-1):
+		self._x = 0
+		self._y = 0
+		self._width = 0
+		self._height = 0
+
+		goocanvas.Group.__init__(self)
+
+		if rows < 0 and cols < 0:
+			self._layout = GridLayout()
+		else:
+			self._layout = GridLayout(rows, cols)
+
+		self.connect('child-added', self.__child_added_cb)
+
+	def get_layout(self):
+		return self._layout
+
+	def __child_added_cb(self, child, position):
+		self._layout.layout_canvas_group(self)

sugar/canvas/IconItem.py

@@ -119,9 +119,10 @@ class IconView(goocanvas.ItemViewSimple, goocanvas.ItemView):
 
 		cr.translate(self.item.x, self.item.y)
 		scale_factor = float(self.item.size) / float(_ICON_SIZE)
-		cr.scale(scale_factor, scale_factor)
+
-		
+		if scale_factor != 0.0:
-		handle.render_cairo(cr)
+			cr.scale(scale_factor, scale_factor)		
+			handle.render_cairo(cr)
 
 		cr.restore()
 
@@ -139,20 +140,18 @@ class IconItem(goocanvas.ItemSimple, goocanvas.Item):
 		'y'        : (float, None, None, -10e6, 10e6, 0,
 					  gobject.PARAM_READWRITE),
 		'icon-name': (str, None, None, None,
-					  gobject.PARAM_CONSTRUCT_ONLY |
 					  gobject.PARAM_READWRITE),
 		'color'    : (object, None, None,
-					  gobject.PARAM_CONSTRUCT_ONLY |
 					  gobject.PARAM_READWRITE),
 		'size'     : (int, None, None,
 					  0, 1024, 24,
-					  gobject.PARAM_CONSTRUCT_ONLY |
 					  gobject.PARAM_READWRITE)
 	}
 
 	def __init__(self, **kwargs):
 		self.x = 0.0
 		self.y = 0.0
+		self.size = 24
 
 		goocanvas.ItemSimple.__init__(self, **kwargs)