sugarlabs/sugar-toolkit-gtk3
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge branch 'master' of git+ssh://dev.laptop.org/git/sugar

Browse Source
This commit is contained in:
Morgan Collett 2007-08-25 14:58:09 +01:00
commit fc4e4692d7
30 changed files with 846 additions and 530 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
NEWS
View File

@ -1,3 +1,4 @@
* Restore Icon's ability to load absolute file paths. (tomeu)
* #722 Show "charging" badge on battery. (danw)
* #2010 Remember state when scrubbing. (marco)

2
shell/intro/colorpicker.py
View File

@ -16,7 +16,7 @@
import hippo
from sugar.graphics.canvasicon import CanvasIcon
from sugar.graphics.icon import CanvasIcon
from sugar.graphics import style
from sugar.graphics.xocolor import XoColor

4
shell/intro/intro.py
View File

@ -26,8 +26,8 @@ import logging
from sugar import env
from sugar.graphics import style
from sugar.graphics.canvasbutton import CanvasButton
from sugar.graphics.canvasentry import CanvasEntry
from sugar.graphics.button import CanvasButton
from sugar.graphics.entry import CanvasEntry
import colorpicker

2
shell/view/BuddyIcon.py
View File

@ -14,7 +14,7 @@
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
from sugar.graphics.canvasicon import CanvasIcon
from sugar.graphics.icon import CanvasIcon
from sugar.graphics.palette import Palette
from view.BuddyMenu import BuddyMenu

2
shell/view/clipboardicon.py
View File

@ -20,7 +20,7 @@ from gettext import gettext as _
import gobject
from sugar.graphics.canvasicon import CanvasIcon
from sugar.graphics.icon import CanvasIcon
from view.clipboardmenu import ClipboardMenu
from sugar.graphics.xocolor import XoColor
from sugar.graphics import style

11
shell/view/devices/battery.py
View File

@ -17,7 +17,8 @@
import gtk
from gettext import gettext as _
from sugar.graphics import canvasicon
from sugar.graphics.icon import CanvasIcon
from sugar.graphics.icon import get_icon_state
from sugar.graphics import style
from sugar.graphics.palette import Palette
@ -27,9 +28,9 @@ _STATUS_CHARGING = 0
_STATUS_DISCHARGING = 1
_STATUS_FULLY_CHARGED = 2
class DeviceView(canvasicon.CanvasIcon):
class DeviceView(CanvasIcon):
def __init__(self, model):
canvasicon.CanvasIcon.__init__(self, size=style.MEDIUM_ICON_SIZE)
CanvasIcon.__init__(self, size=style.MEDIUM_ICON_SIZE)
self._model = model
self._palette = BatteryPalette(_('My Battery life'))
self.set_palette(self._palette)
@ -40,8 +41,8 @@ class DeviceView(canvasicon.CanvasIcon):
self._update_info()
def _update_info(self):
self.props.icon_name = canvasicon.get_icon_state(
_ICON_NAME, self._model.props.level)
name = get_icon_state(_ICON_NAME, self._model.props.level)
self.props.icon_name = name
# Update palette
if self._model.props.charging:

2
shell/view/devices/deviceview.py
View File

@ -14,7 +14,7 @@
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
from sugar.graphics.canvasicon import CanvasIcon
from sugar.graphics.icon import CanvasIcon
def create(model):
name = 'view.devices.' + model.get_type()

8
shell/view/devices/network/wireless.py
View File

@ -15,11 +15,12 @@
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
from sugar.graphics import canvasicon
from sugar.graphics.icon import get_icon_state
from sugar.graphics.icon import CanvasIcon
from sugar.graphics import style
from sugar.graphics import style
from model.devices.network import wireless
from sugar.graphics.canvasicon import CanvasIcon
from model.devices import device
_ICON_NAME = 'network-wireless'
@ -47,8 +48,7 @@ class DeviceView(CanvasIcon):
self._update_state()
def _update_icon(self):
icon_name = canvasicon.get_icon_state(
_ICON_NAME, self._model.props.strength)
icon_name = get_icon_state(_ICON_NAME, self._model.props.strength)
if icon_name:
self.props.icon_name = icon_name

2
shell/view/frame/FriendsBox.py
View File

@ -17,7 +17,7 @@
import hippo
from sugar.graphics.palette import Palette
from sugar.graphics.canvasicon import CanvasIcon
from sugar.graphics.icon import CanvasIcon
from sugar.graphics import style
from sugar.presence import presenceservice

2
shell/view/home/FriendView.py
View File

@ -17,7 +17,7 @@
import hippo
import gobject
from sugar.graphics.canvasicon import CanvasIcon
from sugar.graphics.icon import CanvasIcon
from sugar.graphics import style
from sugar.presence import presenceservice
from sugar import activity

2
shell/view/home/HomeBox.py
View File

@ -122,7 +122,7 @@ class HomeBox(hippo.CanvasBox, hippo.CanvasItem):
self._redraw_id = None
def _redraw_activity_ring(self):
self._donut.emit_request_changed()
self._donut.redraw()
return True
def has_activities(self):

1
shell/view/home/Makefile.am
View File

@ -8,5 +8,6 @@ sugar_PYTHON = \
HomeWindow.py \
MeshBox.py \
MyIcon.py \
proc_smaps.py \
snowflakelayout.py \
transitionbox.py

7
shell/view/home/MeshBox.py
View File

@ -21,10 +21,10 @@ import gobject
from gettext import gettext as _
from sugar.graphics.spreadlayout import SpreadLayout
from sugar.graphics.canvasicon import CanvasIcon
from sugar.graphics.icon import CanvasIcon
from sugar.graphics import style
from sugar.graphics import xocolor
from sugar.graphics import canvasicon
from sugar.graphics.icon import get_icon_state
from sugar.graphics import style
from sugar import profile
@ -86,8 +86,7 @@ class AccessPointView(PulsingIcon):
self.set_tooltip(self._model.props.name)
def _update_icon(self):
icon_name = canvasicon.get_icon_state(
_ICON_NAME, self._model.props.strength)
icon_name = get_icon_state(_ICON_NAME, self._model.props.strength)
if icon_name:
self.props.icon_name = icon_name

2
shell/view/home/MyIcon.py
View File

@ -14,7 +14,7 @@
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
from sugar.graphics.canvasicon import CanvasIcon
from sugar.graphics.icon import CanvasIcon
from sugar import profile
class MyIcon(CanvasIcon):

181
shell/view/home/activitiesdonut.py
View File

@ -18,17 +18,19 @@ import colorsys
from gettext import gettext as _
import logging
import math
import os
import hippo
import gobject
import gtk
from sugar.graphics.canvasicon import CanvasIcon
from sugar.graphics.icon import CanvasIcon
from sugar.graphics.menuitem import MenuItem
from sugar.graphics.palette import Palette
from sugar.graphics import style
from sugar.graphics import xocolor
from sugar import profile
from proc_smaps import ProcSmaps
# TODO: rgb_to_html and html_to_rgb are useful elsewhere
# we should put this in a common module
@ -48,6 +50,9 @@ def html_to_rgb(html_color):
r, g, b = (r / 255.0, g / 255.0, b / 255.0)
return (r, g, b)
_MAX_ACTIVITIES = 10
_MIN_WEDGE_SIZE = 1.0 / _MAX_ACTIVITIES
class ActivityIcon(CanvasIcon):
_INTERVAL = 250
@ -74,6 +79,8 @@ class ActivityIcon(CanvasIcon):
self._activity = activity
self._pulse_id = 0
self.size = _MIN_WEDGE_SIZE
palette = Palette(_('Starting...'))
self.set_palette(palette)
@ -101,11 +108,9 @@ class ActivityIcon(CanvasIcon):
stop_menu_item.show()
def _launching_changed_cb(self, activity, pspec):
if activity.props.launching:
self._start_pulsing()
else:
if not activity.props.launching:
self._stop_pulsing()
self._setup_palette()
self._setup_palette()
def __del__(self):
self._cleanup()
@ -166,10 +171,6 @@ class ActivityIcon(CanvasIcon):
self._level = 100.0
self.props.xo_color = self._orig_color
# Force the donut to redraw now that we know how much memory
# the activity is using.
self.emit_request_changed()
def _resume_activate_cb(self, menuitem):
self.emit('resume')
@ -215,6 +216,7 @@ class ActivitiesDonut(hippo.CanvasBox, hippo.CanvasItem):
self.remove(icon)
icon._cleanup()
self._activities.remove(icon)
self._compute_angles()
def _add_activity(self, activity):
icon = ActivityIcon(activity)
@ -223,8 +225,7 @@ class ActivitiesDonut(hippo.CanvasBox, hippo.CanvasItem):
self.append(icon, hippo.PACK_FIXED)
self._activities.append(icon)
self.emit_paint_needed(0, 0, -1, -1)
self._compute_angles()
def _activity_icon_resumed_cb(self, icon):
activity = icon.get_activity()
@ -282,43 +283,72 @@ class ActivitiesDonut(hippo.CanvasBox, hippo.CanvasItem):
activity_host.present()
return True
MAX_ACTIVITIES = 10
MIN_ACTIVITY_WEDGE_SIZE = 1.0 / MAX_ACTIVITIES
def _update_activity_sizes(self):
# First, get the shell's memory mappings; this memory won't be
# counted against the memory used by activities, since it
# would still be in use even if all activities exited.
shell_mappings = {}
try:
shell_smaps = ProcSmaps(os.getpid())
for mapping in shell_smaps.mappings:
if mapping.shared_clean > 0 or mapping.shared_dirty > 0:
shell_mappings[mapping.name] = mapping
except Exception, e:
logging.warn('ActivitiesDonut: could not read own smaps: %r' % e)
def _get_activity_sizes(self):
# First get the size of each process that hosts an activity,
# and the number of activities it hosts.
process_size = {}
# Get the memory mappings of each process that hosts an
# activity, and count how many activity instances each
# activity process hosts, and how many processes are mapping
# each shared library, etc
process_smaps = {}
num_activities = {}
total_activity_size = 0
num_mappings = {}
unknown_size_activities = 0
for activity in self._model:
pid = activity.get_pid()
if not pid:
# Still starting up, hasn't opened a window yet
unknown_size_activities += 1
continue
if process_size.has_key(pid):
if num_activities.has_key(pid):
num_activities[pid] += 1
continue
try:
statm = open('/proc/%s/statm' % pid)
# We use "RSS" (the second field in /proc/PID/statm)
# for the activity size because that's what ps and top
# use for calculating "%MEM". We multiply by 4 to
# convert from pages to kb.
process_size[pid] = int(statm.readline().split()[1]) * 4
total_activity_size += process_size[pid]
smaps = ProcSmaps(pid)
_subtract_mappings(smaps, shell_mappings)
for mapping in smaps.mappings:
if mapping.shared_clean > 0 or mapping.shared_dirty > 0:
if num_mappings.has_key(mapping.name):
num_mappings[mapping.name] += 1
else:
num_mappings[mapping.name] = 1
process_smaps[pid] = smaps
num_activities[pid] = 1
statm.close()
except IOError:
logging.warn('ActivitiesDonut: could not read /proc/%s/statm' %
pid)
except (IndexError, ValueError):
logging.warn('ActivitiesDonut: /proc/%s/statm was not in ' +
'expected format' % pid)
except Exception, e:
logging.warn('ActivitiesDonut: could not read /proc/%s/smaps: %r'
% (pid, e))
# Next, see how much free memory is left.
# Compute total memory used per process
process_size = {}
total_activity_size = 0
for activity in self._model:
pid = activity.get_pid()
if not process_smaps.has_key(pid):
continue
smaps = process_smaps[pid]
size = 0
for mapping in smaps.mappings:
size += mapping.private_clean + mapping.private_dirty
if mapping.shared_clean + mapping.shared_dirty > 0:
num = num_mappings[mapping.name]
size += (mapping.shared_clean + mapping.shared_dirty) / num
process_size[pid] = size
total_activity_size += size / num_activities[pid]
# Now, see how much free memory is left.
free_memory = 0
try:
meminfo = open('/proc/meminfo')
@ -332,39 +362,85 @@ class ActivitiesDonut(hippo.CanvasBox, hippo.CanvasItem):
logging.warn('ActivitiesDonut: /proc/meminfo was not in ' +
'expected format')
# Each activity starts with MIN_ACTIVITY_WEDGE_SIZE. The
# remaining space in the donut is allocated proportionately
# among the activities-of-known-size and the free space
used_space = ActivitiesDonut.MIN_ACTIVITY_WEDGE_SIZE * len(self._model)
remaining_space = max(0.0, 1.0 - used_space)
total_memory = float(total_activity_size + free_memory)
total_memory = total_activity_size + free_memory
# Each activity has an ideal size of:
# process_size[pid] / num_activities[pid] / total_memory
# (And the free memory wedge is ideally free_memory /
# total_memory) However, no activity wedge is allowed to be
# smaller than _MIN_WEDGE_SIZE. This means the small
# activities will use up extra space, which would make the
# ring overflow. We fix that by reducing the large activities
# and the free space proportionately. If there are activities
# of unknown size, they are simply carved out of the free
# space.
free_percent = free_memory / total_memory
activity_sizes = []
for activity in self._model:
percent = ActivitiesDonut.MIN_ACTIVITY_WEDGE_SIZE
pid = activity.get_pid()
overflow = 0.0
reducible = free_percent
for icon in self._activities:
pid = icon.get_activity().get_pid()
if process_size.has_key(pid):
size = process_size[pid] / num_activities[pid]
percent += remaining_space * size / total_memory
activity_sizes.append(percent)
icon.size = (process_size[pid] / num_activities[pid] /
total_memory)
if icon.size < _MIN_WEDGE_SIZE:
overflow += _MIN_WEDGE_SIZE - icon.size
icon.size = _MIN_WEDGE_SIZE
else:
reducible += icon.size - _MIN_WEDGE_SIZE
else:
icon.size = _MIN_WEDGE_SIZE
return activity_sizes
if reducible > 0.0:
reduction = overflow / reducible
if unknown_size_activities > 0:
unknown_percent = _MIN_WEDGE_SIZE * unknown_size_activities
if (free_percent * (1 - reduction) < unknown_percent):
# The free wedge won't be large enough to fit the
# unknown-size activities. So adjust things
overflow += unknown_percent - free_percent
reducible -= free_percent
reduction = overflow / reducible
if reduction > 0.0:
for icon in self._activities:
if icon.size > _MIN_WEDGE_SIZE:
icon.size -= (icon.size - _MIN_WEDGE_SIZE) * reduction
def _subtract_mappings(smaps, mappings_to_remove):
for mapping in smaps.mappings:
if mappings_to_remove.has_key(mapping.name):
mapping.shared_clean = 0
mapping.shared_dirty = 0
def _compute_angles(self):
percentages = self._get_activity_sizes()
self._angles = []
if len(percentages) == 0:
if len(self._activities) == 0:
return
# Normally we don't _update_activity_sizes() when launching a
# new activity; but if the new wedge would overflow the ring
# then we have no choice.
total = reduce(lambda s1,s2: s1 + s2,
[icon.size for icon in self._activities])
if total > 1.0:
self._update_activity_sizes()
# The first wedge (Journal) should be centered at 6 o'clock
size = percentages[0] * 2 * math.pi
angle = (math.pi - size) / 2
size = self._activities[0].size or _MIN_WEDGE_SIZE
angle = (math.pi - size * 2 * math.pi) / 2
self._angles.append(angle)
for size in percentages:
for icon in self._activities:
size = icon.size or _MIN_WEDGE_SIZE
self._angles.append(self._angles[-1] + size * 2 * math.pi)
def redraw(self):
self._update_activity_sizes()
self._compute_angles()
self.emit_request_changed()
def _get_angles(self, index):
return [self._angles[index],
self._angles[(index + 1) % len(self._angles)]]
@ -431,7 +507,6 @@ class ActivitiesDonut(hippo.CanvasBox, hippo.CanvasItem):
radius = (self._get_inner_radius() + self._get_radius()) / 2
self._compute_angles()
for i, icon in enumerate(self._activities):
[angle_start, angle_end] = self._get_angles(i)
angle = angle_start + (angle_end - angle_start) / 2

149
shell/view/home/proc_smaps.py Normal file
View File

@ -0,0 +1,149 @@
####################################################################
# This class open the /proc/PID/maps and /proc/PID/smaps files
# to get useful information about the real memory usage
####################################################################
import os
import logging
_smaps_has_references = None
# Parse the /proc/PID/smaps file
class ProcSmaps:
mappings = [] # Devices information
def __init__(self, pid):
global _smaps_has_references
if _smaps_has_references is None:
_smaps_has_references = os.path.isfile('/proc/%s/clear_refs' %
os.getpid())
smapfile = "/proc/%s/smaps" % pid
self.mappings = []
# Coded by Federico Mena (script)
infile = open(smapfile, "r")
input = infile.read()
infile.close()
lines = input.splitlines()
num_lines = len (lines)
line_idx = 0
# 08065000-08067000 rw-p 0001c000 03:01 147613 /opt/gnome/bin/evolution-2.6
# Size: 8 kB
# Rss: 8 kB
# Shared_Clean: 0 kB
# Shared_Dirty: 0 kB
# Private_Clean: 8 kB
# Private_Dirty: 0 kB
# Referenced: 4 kb -> Introduced in kernel 2.6.22
while num_lines > 0:
fields = lines[line_idx].split (" ", 5)
if len (fields) == 6:
(offsets, permissions, bin_permissions, device, inode, name) = fields
else:
(offsets, permissions, bin_permissions, device, inode) = fields
name = ""
size = self.parse_smaps_size_line (lines[line_idx + 1])
rss = self.parse_smaps_size_line (lines[line_idx + 2])
shared_clean = self.parse_smaps_size_line (lines[line_idx + 3])
shared_dirty = self.parse_smaps_size_line (lines[line_idx + 4])
private_clean = self.parse_smaps_size_line (lines[line_idx + 5])
private_dirty = self.parse_smaps_size_line (lines[line_idx + 6])
if _smaps_has_references:
referenced = self.parse_smaps_size_line (lines[line_idx + 7])
else:
referenced = None
name = name.strip ()
mapping = Mapping (size, rss, shared_clean, shared_dirty, \
private_clean, private_dirty, referenced, permissions, name)
self.mappings.append (mapping)
if _smaps_has_references:
num_lines -= 8
line_idx += 8
else:
num_lines -= 7
line_idx += 7
if _smaps_has_references:
self._clear_reference(pid)
def _clear_reference(self, pid):
os.system("echo 1 > /proc/%s/clear_refs" % pid)
# Parses a line of the form "foo: 42 kB" and returns an integer for the "42" field
def parse_smaps_size_line (self, line):
# Rss: 8 kB
fields = line.split ()
return int(fields[1])
class Mapping:
def __init__ (self, size, rss, shared_clean, shared_dirty, \
private_clean, private_dirty, referenced, permissions, name):
self.size = size
self.rss = rss
self.shared_clean = shared_clean
self.shared_dirty = shared_dirty
self.private_clean = private_clean
self.private_dirty = private_dirty
self.referenced = referenced
self.permissions = permissions
self.name = name
# Parse /proc/PID/maps file to get the clean memory usage by process,
# we avoid lines with backed-files
class ProcMaps:
clean_size = 0
def __init__(self, pid):
mapfile = "/proc/%s/maps" % pid
try:
infile = open(mapfile, "r")
except:
print "Error trying " + mapfile
return None
sum = 0
to_data_do = {
"[anon]": self.parse_size_line,
"[heap]": self.parse_size_line
}
for line in infile:
arr = line.split()
# Just parse writable mapped areas
if arr[1][1] != "w":
continue
if len(arr) == 6:
# if we got a backed-file we skip this info
if os.path.isfile(arr[5]):
continue
else:
line_size = to_data_do.get(arr[5], self.skip)(line)
sum += line_size
else:
line_size = self.parse_size_line(line)
sum += line_size
infile.close()
self.clean_size = sum
def skip(self, line):
return 0
# Parse a maps line and return the mapped size
def parse_size_line(self, line):
start, end = line.split()[0].split('-')
size = int(end, 16) - int(start, 16)
return size

2
shell/view/pulsingicon.py
View File

@ -16,7 +16,7 @@
import gobject
from sugar.graphics.canvasicon import CanvasIcon
from sugar.graphics.icon import CanvasIcon
class PulsingIcon(CanvasIcon):
__gproperties__ = {

9
sugar/activity/registry.py
View File

@ -50,10 +50,11 @@ class ActivityRegistry(gobject.GObject):
bus = dbus.SessionBus()
# FIXME: Is follow_name_owner_changes what we really want?
# It speeds up the start time by about 2 seconds
# but is really a side effect of starting a proxy
# in this state (i.e. we don't block in the constructor)
# NOTE: We need to follow_name_owner_changes here
# because we can not connect to a signal unless
# we follow the changes or we start the service
# before we connect. Starting the service here
# causes a major bottleneck during startup
bus_object = bus.get_object(_ACTIVITY_REGISTRY_SERVICE_NAME,
_ACTIVITY_REGISTRY_PATH,
follow_name_owner_changes = True)

9
sugar/clipboard/clipboardservice.py
View File

@ -82,7 +82,14 @@ class ClipboardService(gobject.GObject):
"""Connect dbus signals to our GObject signal generating callbacks"""
bus = dbus.SessionBus()
if not self._connected:
proxy_obj = bus.get_object(DBUS_SERVICE, DBUS_PATH)
# NOTE: We need to follow_name_owner_changes here
# because we can not connect to a signal unless
# we follow the changes or we start the service
# before we connect. Starting the service here
# causes a major bottleneck during startup
proxy_obj = bus.get_object(DBUS_SERVICE,
DBUS_PATH,
follow_name_owner_changes=True)
self._dbus_service = dbus.Interface(proxy_obj, DBUS_SERVICE)
self._dbus_service.connect_to_signal('object_added',
self._object_added_cb)

7
sugar/graphics/Makefile.am
View File

@ -2,11 +2,9 @@ sugardir = $(pythondir)/sugar/graphics
sugar_PYTHON = \
__init__.py \
animator.py \
canvasbutton.py \
canvasicon.py \
canvasentry.py \
canvasroundbox.py \
button.py \
combobox.py \
entry.py \
icon.py \
iconbutton.py \
iconentry.py \
@ -17,6 +15,7 @@ sugar_PYTHON = \
palette.py \
palettegroup.py \
panel.py \
roundbox.py \
spreadlayout.py \
style.py \
toggletoolbutton.py \

0
sugar/graphics/canvasbutton.py → sugar/graphics/button.py
View File

435
sugar/graphics/canvasicon.py
View File

@ -1,435 +0,0 @@
# Copyright (C) 2006-2007 Red Hat, Inc.
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the
# Free Software Foundation, Inc., 59 Temple Place - Suite 330,
# Boston, MA 02111-1307, USA.
import logging
import re
import gobject
import gtk
import hippo
import rsvg
import cairo
import time
from sugar.graphics.xocolor import XoColor
from sugar.graphics import style
from sugar.graphics.palette import Palette, CanvasInvoker
_ICON_REQUEST_SIZE = 50
_BADGE_SIZE = 0.45
class _IconCacheIcon:
def __init__(self, name, fill_color, stroke_color, now):
self.last_used = now
self.usage_count = 1
self.badge_x = 1.0 - _BADGE_SIZE / 2
self.badge_y = 1.0 - _BADGE_SIZE / 2
if name[0:6] == "theme:":
info = gtk.icon_theme_get_default().lookup_icon(
name[6:], _ICON_REQUEST_SIZE, 0)
if not info:
raise ValueError("Icon '" + name + "' not found.")
fname = info.get_filename()
attach_points = info.get_attach_points()
if attach_points is not None:
self.badge_x = float(attach_points[0][0]) / _ICON_REQUEST_SIZE
self.badge_y = float(attach_points[0][1]) / _ICON_REQUEST_SIZE
del info
else:
fname = name
self.handle = self._read_icon_data(fname, fill_color, stroke_color)
def _read_icon_data(self, filename, fill_color, stroke_color):
icon_file = open(filename, 'r')
data = icon_file.read()
icon_file.close()
if fill_color:
entity = '<!ENTITY fill_color "%s">' % fill_color
data = re.sub('<!ENTITY fill_color .*>', entity, data)
if stroke_color:
entity = '<!ENTITY stroke_color "%s">' % stroke_color
data = re.sub('<!ENTITY stroke_color .*>', entity, data)
self.data_size = len(data)
return rsvg.Handle(data=data)
class _IconCache:
_CACHE_MAX = 50000 # in bytes
def __init__(self):
self._icons = {}
self._cache_size = 0
def _cache_cleanup(self, key, now):
while self._cache_size > self._CACHE_MAX:
evict_key = None
oldest_key = None
oldest_time = now
for icon_key, icon in self._icons.items():
# Don't evict the icon we are about to use if it's in the cache
if icon_key == key:
continue
# evict large icons first
if icon.data_size > self._CACHE_MAX:
evict_key = icon_key
break
# evict older icons next; those used over 2 minutes ago
if icon.last_used < now - 120:
evict_key = icon_key
break
# otherwise, evict the oldest
if oldest_time > icon.last_used:
oldest_time = icon.last_used
oldest_key = icon_key
# If there's nothing specific to evict, try evicting
# the oldest thing
if not evict_key:
if not oldest_key:
break
evict_key = oldest_key
self._cache_size -= self._icons[evict_key].data_size
del self._icons[evict_key]
def get_icon(self, name, fill_color, stroke_color):
if not name:
return None
if fill_color or stroke_color:
key = (name, fill_color, stroke_color)
else:
key = name
# If we're over the cache limit, evict something from the cache
now = time.time()
self._cache_cleanup(key, now)
if self._icons.has_key(key):
icon = self._icons[key]
icon.usage_count += 1
icon.last_used = now
else:
icon = _IconCacheIcon(name, fill_color, stroke_color, now)
self._icons[key] = icon
self._cache_size += icon.data_size
return icon
class CanvasIcon(hippo.CanvasBox, hippo.CanvasItem):
__gtype_name__ = 'CanvasIcon'
__gproperties__ = {
'icon-name' : (str, None, None, None,
gobject.PARAM_READWRITE),
'xo-color' : (object, None, None,
gobject.PARAM_WRITABLE),
'fill-color' : (object, None, None,
gobject.PARAM_READWRITE),
'stroke-color' : (object, None, None,
gobject.PARAM_READWRITE),
'size' : (int, None, None, 0, 1024, 0,
gobject.PARAM_READWRITE),
'scale' : (int, None, None, 0, 1024, 0,
gobject.PARAM_READWRITE),
'cache' : (bool, None, None, False,
gobject.PARAM_READWRITE),
'active' : (bool, None, None, True,
gobject.PARAM_READWRITE),
'badge-name' : (str, None, None, None,
gobject.PARAM_READWRITE)
}
_cache = _IconCache()
def __init__(self, **kwargs):
self._buffers = {}
self._cur_buffer = None
self._size = 0
self._scale = 0
self._fill_color = None
self._stroke_color = None
self._icon_name = None
self._cache = False
self._icon = None
self._active = True
self._palette = None
self._badge_name = None
self._badge_icon = None
hippo.CanvasBox.__init__(self, **kwargs)
self.connect_after('motion-notify-event', self._motion_notify_event_cb)
def _clear_buffers(self):
icon_key = self._get_current_buffer_key(self._icon_name)
badge_key = None
if self._badge_name:
badge_key = self._get_current_buffer_key(self._badge_name)
for key in self._buffers.keys():
if key != icon_key:
if not badge_key or (key != badge_key):
del self._buffers[key]
self._buffers = {}
def do_set_property(self, pspec, value):
if pspec.name == 'icon-name':
if self._icon_name != value and not self._cache:
self._clear_buffers()
self._icon_name = value
self._icon = None
self.emit_paint_needed(0, 0, -1, -1)
elif pspec.name == 'xo-color':
self.props.fill_color = style.Color(value.get_fill_color())
self.props.stroke_color = style.Color(value.get_stroke_color())
elif pspec.name == 'fill-color':
if self._fill_color != value:
if not self._cache:
self._clear_buffers()
self._fill_color = value
self._icon = None
self._badge_icon = None
self.emit_paint_needed(0, 0, -1, -1)
elif pspec.name == 'stroke-color':
if self._stroke_color != value:
if not self._cache:
self._clear_buffers()
self._stroke_color = value
self._icon = None
self._badge_icon = None
self.emit_paint_needed(0, 0, -1, -1)
elif pspec.name == 'size':
if self._size != value and not self._cache:
self._clear_buffers()
self._size = value
self.emit_request_changed()
elif pspec.name == 'scale':
if self._scale != value and not self._cache:
self._clear_buffers()
self._scale = value
self.emit_request_changed()
elif pspec.name == 'cache':
self._cache = value
elif pspec.name == 'active':
if self._active != value:
if not self._cache:
self._clear_buffers()
self._active = value
self._icon = None
self.emit_paint_needed(0, 0, -1, -1)
elif pspec.name == 'badge-name':
if self._badge_name != value and not self._cache:
self._clear_buffers()
self._badge_name = value
self._badge_icon = None
self.emit_paint_needed(0, 0, -1, -1)
def _choose_colors(self):
fill_color = None
stroke_color = None
if self._active:
if self._fill_color:
fill_color = self._fill_color.get_svg()
if self._stroke_color:
stroke_color = self._stroke_color.get_svg()
else:
stroke_color = color.ICON_STROKE_INACTIVE.get_svg()
if self._fill_color:
fill_color = self._fill_color.get_svg()
return [fill_color, stroke_color]
def _get_icon_from_cache(self, name, icon):
if not icon:
cache = CanvasIcon._cache
[fill_color, stroke_color] = self._choose_colors()
icon = cache.get_icon(name, fill_color, stroke_color)
return icon
def _get_icon(self):
self._icon = self._get_icon_from_cache(self._icon_name, self._icon)
return self._icon
def _get_badge_icon(self):
self._badge_icon = self._get_icon_from_cache(self._badge_name,
self._badge_icon)
return self._badge_icon
def _get_current_buffer_key(self, name):
[fill_color, stroke_color] = self._choose_colors()
return (name, fill_color, stroke_color, self._size)
def do_get_property(self, pspec):
if pspec.name == 'size':
return self._size
elif pspec.name == 'icon-name':
return self._icon_name
elif pspec.name == 'fill-color':
return self._fill_color
elif pspec.name == 'stroke-color':
return self._stroke_color
elif pspec.name == 'cache':
return self._cache
elif pspec.name == 'active':
return self._active
elif pspec.name == 'badge-name':
return self._badge_name
elif pspec.name == 'scale':
return self._scale
def _get_icon_size(self, icon):
if icon:
dimensions = icon.handle.get_dimension_data()
return int(dimensions[0]), int(dimensions[1])
else:
return [0, 0]
def _get_size(self, icon):
width, height = self._get_icon_size(icon)
if self._scale != 0:
width = int(width * self._scale)
height = int(height * self._scale)
elif self._size != 0:
width = height = self._size
return [width, height]
def _get_buffer(self, cr, name, icon, scale_factor=None):
"""Return a cached cairo surface for the SVG icon, or if none exists,
create a new cairo surface with the right size."""
buf = None
key = self._get_current_buffer_key(name)
if self._buffers.has_key(key):
buf = self._buffers[key]
else:
[icon_w, icon_h] = self._get_icon_size(icon)
[target_w, target_h] = self._get_size(icon)
if scale_factor:
target_w = int(target_w * scale_factor)
target_h = int(target_h * scale_factor)
print "icon %s is %d x %d (at scale %r)" % (name, target_w, target_h, scale_factor)
target = cr.get_target()
buf = target.create_similar(cairo.CONTENT_COLOR_ALPHA,
target_w, target_h)
ctx = cairo.Context(buf)
ctx.scale(float(target_w) / float(icon_w),
float(target_h) / float(icon_h))
icon.handle.render_cairo(ctx)
del ctx
self._buffers[key] = buf
return buf
def do_paint_below_children(self, cr, damaged_box):
icon = self._get_icon()
if icon is None:
return
icon_buf = self._get_buffer(cr, self._icon_name, icon)
[width, height] = self.get_allocation()
icon_x = (width - icon_buf.get_width()) / 2
icon_y = (height - icon_buf.get_height()) / 2
cr.set_source_surface(icon_buf, icon_x, icon_y)
cr.paint()
if self._badge_name:
badge_icon = self._get_badge_icon()
if badge_icon:
badge_buf = self._get_buffer(cr, self._badge_name, badge_icon, _BADGE_SIZE)
badge_x = (icon_x + icon.badge_x * icon_buf.get_width() -
badge_buf.get_width() / 2)
badge_y = (icon_y + icon.badge_y * icon_buf.get_height() -
badge_buf.get_height() / 2)
cr.set_source_surface(badge_buf, badge_x, badge_y)
cr.paint()
def do_get_content_width_request(self):
icon = self._get_icon()
[width, height] = self._get_size(icon)
if self._badge_name is not None:
# If the badge goes outside the bounding box, add space
# on *both* sides (to keep the main icon centered)
if icon.badge_x < 0.0:
width = int(width * 2 * (1.0 - icon.badge_x))
elif icon.badge_x + _BADGE_SIZE > 1.0:
width = int(width * 2 * (icon.badge_x + _BADGE_SIZE - 1.0))
return (width, width)
def do_get_content_height_request(self, for_width):
icon = self._get_icon()
[width, height] = self._get_size(icon)
if self._badge_name is not None:
if icon.badge_y < 0.0:
height = int(height * 2 * (1.0 - icon.badge_y))
elif icon.badge_y + _BADGE_SIZE > 1.0:
height = int(height * 2 * (icon.badge_y + _BADGE_SIZE - 1.0))
return (height, height)
def do_button_press_event(self, event):
self.emit_activated()
return True
def _motion_notify_event_cb(self, button, event):
if event.detail == hippo.MOTION_DETAIL_ENTER:
self.prelight(True)
elif event.detail == hippo.MOTION_DETAIL_LEAVE:
self.prelight(False)
return False
def prelight(self, enter):
"""
Override this method for adding prelighting behavior.
"""
pass
def get_palette(self):
return self._palette
def set_palette(self, palette):
self._palette = palette
if not self._palette.props.invoker:
self._palette.props.invoker = CanvasInvoker(self)
def set_tooltip(self, text):
self.set_palette(Palette(text))
palette = property(get_palette, set_palette)
def get_icon_state(base_name, perc):
step = 5
strength = round(perc / step) * step
icon_theme = gtk.icon_theme_get_default()
while strength <= 100:
icon_name = '%s-%03d' % (base_name, strength)
if icon_theme.has_icon(icon_name):
return 'theme:' + icon_name
strength = strength + step

0
sugar/graphics/canvasentry.py → sugar/graphics/entry.py
View File

435
sugar/graphics/icon.py
View File

@ -16,11 +16,20 @@
# Boston, MA 02111-1307, USA.
import os
import re
import time
import logging
import gobject
import gtk
import re
import hippo
import rsvg
import cairo
from sugar.graphics.style import Color
from sugar.graphics.xocolor import XoColor
from sugar.graphics import style
from sugar.graphics.palette import Palette, CanvasInvoker
class Icon(gtk.Image):
__gtype_name__ = 'SugarIcon'
@ -66,15 +75,25 @@ class Icon(gtk.Image):
icon_theme = gtk.icon_theme_get_for_screen(self.get_screen())
icon_set = gtk.IconSet()
if icon_theme.has_icon(self._icon_name):
if icon_theme.has_icon(self._icon_name) or os.path.exists(self._icon_name):
source = gtk.IconSource()
source.set_icon_name(self._icon_name)
if os.path.exists(self._icon_name):
source.set_filename(self._icon_name)
else:
source.set_icon_name(self._icon_name)
icon_set.add_source(source)
inactive_name = self._icon_name + '-inactive'
if icon_theme.has_icon(inactive_name):
if icon_theme.has_icon(inactive_name) or os.path.exists(inactive_name):
source = gtk.IconSource()
source.set_icon_name(inactive_name)
if os.path.exists(inactive_name):
source.set_filename(inactive_name)
else:
source.set_icon_name(inactive_name)
source.set_state(gtk.STATE_INSENSITIVE)
icon_set.add_source(source)
@ -109,6 +128,9 @@ class Icon(gtk.Image):
self.set_from_pixbuf(pixbuf)
def _get_real_name(self, name):
if os.path.exists(name):
return name
info = self._theme.lookup_icon(name, self.props.icon_size, 0)
if not info:
raise ValueError("Icon '" + name + "' not found.")
@ -139,3 +161,406 @@ class Icon(gtk.Image):
return self._stroke_color
else:
return gtk.Image.do_get_property(self, pspec)
_ICON_REQUEST_SIZE = 50
_BADGE_SIZE = 0.45
class _IconCacheIcon:
def __init__(self, name, fill_color, stroke_color, now):
self.last_used = now
self.usage_count = 1
self.badge_x = 1.0 - _BADGE_SIZE / 2
self.badge_y = 1.0 - _BADGE_SIZE / 2
if name[0:6] == "theme:":
info = gtk.icon_theme_get_default().lookup_icon(
name[6:], _ICON_REQUEST_SIZE, 0)
if not info:
raise ValueError("Icon '" + name + "' not found.")
fname = info.get_filename()
attach_points = info.get_attach_points()
if attach_points is not None:
self.badge_x = float(attach_points[0][0]) / _ICON_REQUEST_SIZE
self.badge_y = float(attach_points[0][1]) / _ICON_REQUEST_SIZE
del info
else:
fname = name
self.handle = self._read_icon_data(fname, fill_color, stroke_color)
def _read_icon_data(self, filename, fill_color, stroke_color):
icon_file = open(filename, 'r')
data = icon_file.read()
icon_file.close()
if fill_color:
entity = '<!ENTITY fill_color "%s">' % fill_color
data = re.sub('<!ENTITY fill_color .*>', entity, data)
if stroke_color:
entity = '<!ENTITY stroke_color "%s">' % stroke_color
data = re.sub('<!ENTITY stroke_color .*>', entity, data)
self.data_size = len(data)
return rsvg.Handle(data=data)
class _IconCache:
_CACHE_MAX = 50000 # in bytes
def __init__(self):
self._icons = {}
self._cache_size = 0
def _cache_cleanup(self, key, now):
while self._cache_size > self._CACHE_MAX:
evict_key = None
oldest_key = None
oldest_time = now
for icon_key, icon in self._icons.items():
# Don't evict the icon we are about to use if it's in the cache
if icon_key == key:
continue
# evict large icons first
if icon.data_size > self._CACHE_MAX:
evict_key = icon_key
break
# evict older icons next; those used over 2 minutes ago
if icon.last_used < now - 120:
evict_key = icon_key
break
# otherwise, evict the oldest
if oldest_time > icon.last_used:
oldest_time = icon.last_used
oldest_key = icon_key
# If there's nothing specific to evict, try evicting
# the oldest thing
if not evict_key:
if not oldest_key:
break
evict_key = oldest_key
self._cache_size -= self._icons[evict_key].data_size
del self._icons[evict_key]
def get_icon(self, name, fill_color, stroke_color):
if not name:
return None
if fill_color or stroke_color:
key = (name, fill_color, stroke_color)
else:
key = name
# If we're over the cache limit, evict something from the cache
now = time.time()
self._cache_cleanup(key, now)
if self._icons.has_key(key):
icon = self._icons[key]
icon.usage_count += 1
icon.last_used = now
else:
icon = _IconCacheIcon(name, fill_color, stroke_color, now)
self._icons[key] = icon
self._cache_size += icon.data_size
return icon
class CanvasIcon(hippo.CanvasBox, hippo.CanvasItem):
__gtype_name__ = 'CanvasIcon'
__gproperties__ = {
'icon-name' : (str, None, None, None,
gobject.PARAM_READWRITE),
'xo-color' : (object, None, None,
gobject.PARAM_WRITABLE),
'fill-color' : (object, None, None,
gobject.PARAM_READWRITE),
'stroke-color' : (object, None, None,
gobject.PARAM_READWRITE),
'size' : (int, None, None, 0, 1024, 0,
gobject.PARAM_READWRITE),
'scale' : (int, None, None, 0, 1024, 0,
gobject.PARAM_READWRITE),
'cache' : (bool, None, None, False,
gobject.PARAM_READWRITE),
'active' : (bool, None, None, True,
gobject.PARAM_READWRITE),
'badge-name' : (str, None, None, None,
gobject.PARAM_READWRITE)
}
_cache = _IconCache()
def __init__(self, **kwargs):
self._buffers = {}
self._cur_buffer = None
self._size = 0
self._scale = 0
self._fill_color = None
self._stroke_color = None
self._icon_name = None
self._cache = False
self._icon = None
self._active = True
self._palette = None
self._badge_name = None
self._badge_icon = None
hippo.CanvasBox.__init__(self, **kwargs)
self.connect_after('motion-notify-event', self._motion_notify_event_cb)
def _clear_buffers(self):
icon_key = self._get_current_buffer_key(self._icon_name)
badge_key = None
if self._badge_name:
badge_key = self._get_current_buffer_key(self._badge_name)
for key in self._buffers.keys():
if key != icon_key:
if not badge_key or (key != badge_key):
del self._buffers[key]
self._buffers = {}
def do_set_property(self, pspec, value):
if pspec.name == 'icon-name':
if self._icon_name != value and not self._cache:
self._clear_buffers()
self._icon_name = value
self._icon = None
self.emit_paint_needed(0, 0, -1, -1)
elif pspec.name == 'xo-color':
self.props.fill_color = style.Color(value.get_fill_color())
self.props.stroke_color = style.Color(value.get_stroke_color())
elif pspec.name == 'fill-color':
if self._fill_color != value:
if not self._cache:
self._clear_buffers()
self._fill_color = value
self._icon = None
self._badge_icon = None
self.emit_paint_needed(0, 0, -1, -1)
elif pspec.name == 'stroke-color':
if self._stroke_color != value:
if not self._cache:
self._clear_buffers()
self._stroke_color = value
self._icon = None
self._badge_icon = None
self.emit_paint_needed(0, 0, -1, -1)
elif pspec.name == 'size':
if self._size != value and not self._cache:
self._clear_buffers()
self._size = value
self.emit_request_changed()
elif pspec.name == 'scale':
if self._scale != value and not self._cache:
self._clear_buffers()
self._scale = value
self.emit_request_changed()
elif pspec.name == 'cache':
self._cache = value
elif pspec.name == 'active':
if self._active != value:
if not self._cache:
self._clear_buffers()
self._active = value
self._icon = None
self.emit_paint_needed(0, 0, -1, -1)
elif pspec.name == 'badge-name':
if self._badge_name != value and not self._cache:
self._clear_buffers()
self._badge_name = value
self._badge_icon = None
self.emit_paint_needed(0, 0, -1, -1)
def _choose_colors(self):
fill_color = None
stroke_color = None
if self._active:
if self._fill_color:
fill_color = self._fill_color.get_svg()
if self._stroke_color:
stroke_color = self._stroke_color.get_svg()
else:
stroke_color = color.ICON_STROKE_INACTIVE.get_svg()
if self._fill_color:
fill_color = self._fill_color.get_svg()
return [fill_color, stroke_color]
def _get_icon_from_cache(self, name, icon):
if not icon:
cache = CanvasIcon._cache
[fill_color, stroke_color] = self._choose_colors()
icon = cache.get_icon(name, fill_color, stroke_color)
return icon
def _get_icon(self):
self._icon = self._get_icon_from_cache(self._icon_name, self._icon)
return self._icon
def _get_badge_icon(self):
self._badge_icon = self._get_icon_from_cache(self._badge_name,
self._badge_icon)
return self._badge_icon
def _get_current_buffer_key(self, name):
[fill_color, stroke_color] = self._choose_colors()
return (name, fill_color, stroke_color, self._size)
def do_get_property(self, pspec):
if pspec.name == 'size':
return self._size
elif pspec.name == 'icon-name':
return self._icon_name
elif pspec.name == 'fill-color':
return self._fill_color
elif pspec.name == 'stroke-color':
return self._stroke_color
elif pspec.name == 'cache':
return self._cache
elif pspec.name == 'active':
return self._active
elif pspec.name == 'badge-name':
return self._badge_name
elif pspec.name == 'scale':
return self._scale
def _get_icon_size(self, icon):
if icon:
dimensions = icon.handle.get_dimension_data()
return int(dimensions[0]), int(dimensions[1])
else:
return [0, 0]
def _get_size(self, icon):
width, height = self._get_icon_size(icon)
if self._scale != 0:
width = int(width * self._scale)
height = int(height * self._scale)
elif self._size != 0:
width = height = self._size
return [width, height]
def _get_buffer(self, cr, name, icon, scale_factor=None):
"""Return a cached cairo surface for the SVG icon, or if none exists,
create a new cairo surface with the right size."""
buf = None
key = self._get_current_buffer_key(name)
if self._buffers.has_key(key):
buf = self._buffers[key]
else:
[icon_w, icon_h] = self._get_icon_size(icon)
[target_w, target_h] = self._get_size(icon)
if scale_factor:
target_w = int(target_w * scale_factor)
target_h = int(target_h * scale_factor)
target = cr.get_target()
buf = target.create_similar(cairo.CONTENT_COLOR_ALPHA,
target_w, target_h)
ctx = cairo.Context(buf)
ctx.scale(float(target_w) / float(icon_w),
float(target_h) / float(icon_h))
icon.handle.render_cairo(ctx)
del ctx
self._buffers[key] = buf
return buf
def do_paint_below_children(self, cr, damaged_box):
icon = self._get_icon()
if icon is None:
return
icon_buf = self._get_buffer(cr, self._icon_name, icon)
[width, height] = self.get_allocation()
icon_x = (width - icon_buf.get_width()) / 2
icon_y = (height - icon_buf.get_height()) / 2
cr.set_source_surface(icon_buf, icon_x, icon_y)
cr.paint()
if self._badge_name:
badge_icon = self._get_badge_icon()
if badge_icon:
badge_buf = self._get_buffer(cr, self._badge_name, badge_icon, _BADGE_SIZE)
badge_x = (icon_x + icon.badge_x * icon_buf.get_width() -
badge_buf.get_width() / 2)
badge_y = (icon_y + icon.badge_y * icon_buf.get_height() -
badge_buf.get_height() / 2)
cr.set_source_surface(badge_buf, badge_x, badge_y)
cr.paint()
def do_get_content_width_request(self):
icon = self._get_icon()
[width, height] = self._get_size(icon)
if self._badge_name is not None:
# If the badge goes outside the bounding box, add space
# on *both* sides (to keep the main icon centered)
if icon.badge_x < 0.0:
width = int(width * 2 * (1.0 - icon.badge_x))
elif icon.badge_x + _BADGE_SIZE > 1.0:
width = int(width * 2 * (icon.badge_x + _BADGE_SIZE - 1.0))
return (width, width)
def do_get_content_height_request(self, for_width):
icon = self._get_icon()
[width, height] = self._get_size(icon)
if self._badge_name is not None:
if icon.badge_y < 0.0:
height = int(height * 2 * (1.0 - icon.badge_y))
elif icon.badge_y + _BADGE_SIZE > 1.0:
height = int(height * 2 * (icon.badge_y + _BADGE_SIZE - 1.0))
return (height, height)
def do_button_press_event(self, event):
self.emit_activated()
return True
def _motion_notify_event_cb(self, button, event):
if event.detail == hippo.MOTION_DETAIL_ENTER:
self.prelight(True)
elif event.detail == hippo.MOTION_DETAIL_LEAVE:
self.prelight(False)
return False
def prelight(self, enter):
"""
Override this method for adding prelighting behavior.
"""
pass
def get_palette(self):
return self._palette
def set_palette(self, palette):
self._palette = palette
if not self._palette.props.invoker:
self._palette.props.invoker = CanvasInvoker(self)
def set_tooltip(self, text):
self.set_palette(Palette(text))
palette = property(get_palette, set_palette)
def get_icon_state(base_name, perc):
step = 5
strength = round(perc / step) * step
icon_theme = gtk.icon_theme_get_default()
while strength <= 100:
icon_name = '%s-%03d' % (base_name, strength)
if icon_theme.has_icon(icon_name):
return 'theme:' + icon_name
strength = strength + step

2
sugar/graphics/iconbutton.py
View File

@ -24,7 +24,7 @@ import sys
import gobject
import hippo
from sugar.graphics.canvasicon import CanvasIcon
from sugar.graphics.icon import CanvasIcon
from sugar.graphics import style
class IconButton(CanvasIcon, hippo.CanvasItem):

4
sugar/graphics/objectchooser.py
View File

@ -24,9 +24,9 @@ import hippo
from sugar.activity.bundle import Bundle
from sugar.date import Date
from sugar.graphics import style
from sugar.graphics.canvasicon import CanvasIcon
from sugar.graphics.icon import CanvasIcon
from sugar.graphics.xocolor import XoColor
from sugar.graphics.canvasroundbox import CanvasRoundBox
from sugar.graphics.roundbox import CanvasRoundBox
from sugar.datastore import datastore
from sugar import activity
from sugar.objects import objecttype

0
sugar/graphics/canvasroundbox.py → sugar/graphics/roundbox.py
View File

9
sugar/presence/presenceservice.py
View File

@ -108,8 +108,15 @@ class PresenceService(gobject.GObject):
"""
if not self._ps_:
try:
# NOTE: We need to follow_name_owner_changes here
# because we can not connect to a signal unless
# we follow the changes or we start the service
# before we connect. Starting the service here
# causes a major bottleneck during startup
ps = dbus.Interface(
self._bus.get_object(DBUS_SERVICE,DBUS_PATH),
self._bus.get_object(DBUS_SERVICE,
DBUS_PATH,
follow_name_owner_changes=True),
DBUS_INTERFACE
)
except dbus.exceptions.DBusException, err:

38
tests/graphics/ticket2999.py Normal file
View File

@ -0,0 +1,38 @@
# Copyright (C) 2007, One Laptop Per Child
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the
# Free Software Foundation, Inc., 59 Temple Place - Suite 330,
# Boston, MA 02111-1307, USA.
"""
Spec in ticket #2999.
"""
import gtk
from sugar.graphics.palette import Palette
from sugar.graphics.icon import Icon
import common
test = common.Test()
test.set_border_width(60)
text_view = gtk.TextView()
text_view.props.buffer.props.text = 'Blah blah blah, blah blah blah.'
test.pack_start(text_view)
text_view.show()
if __name__ == "__main__":
common.main(test)

48
tests/graphics/ticket3000.py Normal file
View File

@ -0,0 +1,48 @@
# Copyright (C) 2007, One Laptop Per Child
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the
# Free Software Foundation, Inc., 59 Temple Place - Suite 330,
# Boston, MA 02111-1307, USA.
"""
Spec in ticket #3000.
"""
import gtk
from sugar.graphics.toolbutton import ToolButton
import common
test = common.Test()
toolbar = gtk.Toolbar()
test.pack_start(toolbar, False)
toolbar.show()
button = ToolButton('go-previous')
toolbar.insert(button, -1)
button.show()
separator = gtk.SeparatorToolItem()
toolbar.add(separator)
separator.show()
button = ToolButton('go-next')
toolbar.insert(button, -1)
button.show()
if __name__ == "__main__":
common.main(test)