Implement the grid, regress UI a bit

This commit is contained in:
Marco Pesenti Gritti 2006-09-07 15:11:51 +02:00
parent 61058e0110
commit 21b19924ea
6 changed files with 187 additions and 151 deletions

View File

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

View File

@ -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:

View File

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

View File

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

View File

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

View File

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