From 21b19924eab1d0a4d7ce2f83e8c10e2972ac7a3d Mon Sep 17 00:00:00 2001 From: Marco Pesenti Gritti Date: Thu, 7 Sep 2006 15:11:51 +0200 Subject: [PATCH] Implement the grid, regress UI a bit --- shell/frame/BottomPanel.py | 52 +++++------------ shell/frame/Frame.py | 74 ++++++++++++++++-------- shell/frame/Panel.py | 72 ----------------------- shell/frame/PanelWindow.py | 16 ++++++ sugar/canvas/GridLayout.py | 113 +++++++++++++++++++++++++++++++++---- sugar/canvas/IconItem.py | 11 ++-- 6 files changed, 187 insertions(+), 151 deletions(-) delete mode 100644 shell/frame/Panel.py create mode 100644 shell/frame/PanelWindow.py diff --git a/shell/frame/BottomPanel.py b/shell/frame/BottomPanel.py index 838430d4..937ffbcb 100644 --- a/shell/frame/BottomPanel.py +++ b/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, - color=IconColor('white'), size=size) + IconItem.__init__(self, icon_name=icon_name, color=IconColor('white')) 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): - def __init__(self, shell, invites, height): - goocanvas.Group.__init__(self) +class BottomPanel(GridGroup): + def __init__(self, shell, invites): + 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) - - icon_size = self._height - x = (icon_size + 6) * self.get_n_children() - item.set_property('x', x) - + constraints = GridConstraints(self.get_n_children() + 1, 0, 1, 1) + constraints.padding = 6 + self._layout.set_constraints(item, constraints) 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) diff --git a/shell/frame/Frame.py b/shell/frame/Frame.py index df80c92d..70873bab 100644 --- a/shell/frame/Frame.py +++ b/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) - panel.move(0, gtk.gdk.screen_height() - size) - panel.resize(gtk.gdk.screen_width(), size) - self._panels.append(panel) + layout.set_constraints(panel, constraints) + group.add_child(panel) - panel = RightPanel(shell, owner.get_friends()) - panel.move(gtk.gdk.screen_width() - size, size) - panel.resize(size, gtk.gdk.screen_height() - size * 2) - self._panels.append(panel) + # Top + constraints = GridConstraints(0, 0, 16, 1) + self._create_window(constraints) - panel = TopPanel(shell) - panel.set_position(size, 0) - panel.move(0, 0) - panel.resize(gtk.gdk.screen_width(), size) - self._panels.append(panel) + # Left + constraints = GridConstraints(0, 1, 1, 10) + self._create_window(constraints) - panel = Panel() - panel.move(0, size) - panel.resize(size, gtk.gdk.screen_height() - size * 2) - self._panels.append(panel) + # Right + constraints = GridConstraints(15, 1, 1, 10) + self._create_window(constraints) + + 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: diff --git a/shell/frame/Panel.py b/shell/frame/Panel.py deleted file mode 100644 index 17629841..00000000 --- a/shell/frame/Panel.py +++ /dev/null @@ -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() diff --git a/shell/frame/PanelWindow.py b/shell/frame/PanelWindow.py new file mode 100644 index 00000000..3c340269 --- /dev/null +++ b/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()) diff --git a/sugar/canvas/GridLayout.py b/sugar/canvas/GridLayout.py index 224f42cb..75f97396 100644 --- a/sugar/canvas/GridLayout.py +++ b/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 - 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] + return self.get_bounds(container, constraints) 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) diff --git a/sugar/canvas/IconItem.py b/sugar/canvas/IconItem.py index 3cbab008..5ed21c9f 100644 --- a/sugar/canvas/IconItem.py +++ b/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) - - handle.render_cairo(cr) + + if scale_factor != 0.0: + 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)