440 lines
15 KiB
Python
440 lines
15 KiB
Python
# Copyright (C) 2006-2007 Red Hat, Inc.
|
|
#
|
|
# This program is free software; you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation; either version 2 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# This program 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 General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program; if not, write to the Free Software
|
|
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
|
|
import colorsys
|
|
from gettext import gettext as _
|
|
import math
|
|
|
|
import hippo
|
|
import gobject
|
|
import gtk
|
|
|
|
from sugar.graphics.canvasicon import CanvasIcon
|
|
from sugar.graphics.palette import Palette
|
|
from sugar.graphics import style
|
|
from sugar.graphics import xocolor
|
|
from sugar import profile
|
|
|
|
# TODO: rgb_to_html and html_to_rgb are useful elsewhere
|
|
# we should put this in a common module
|
|
def rgb_to_html(r, g, b):
|
|
""" (r, g, b) tuple (in float format) -> #RRGGBB """
|
|
return '#%02x%02x%02x' % (int(r * 255), int(g * 255), int(b * 255))
|
|
|
|
def html_to_rgb(html_color):
|
|
""" #RRGGBB -> (r, g, b) tuple (in float format) """
|
|
html_color = html_color.strip()
|
|
if html_color[0] == '#':
|
|
html_color = html_color[1:]
|
|
if len(html_color) != 6:
|
|
raise ValueError, "input #%s is not in #RRGGBB format" % html_color
|
|
r, g, b = html_color[:2], html_color[2:4], html_color[4:]
|
|
r, g, b = [int(n, 16) for n in (r, g, b)]
|
|
r, g, b = (r / 255.0, g / 255.0, b / 255.0)
|
|
return (r, g, b)
|
|
|
|
class ActivityIcon(CanvasIcon):
|
|
_INTERVAL = 250
|
|
|
|
__gsignals__ = {
|
|
'resume': (gobject.SIGNAL_RUN_FIRST,
|
|
gobject.TYPE_NONE, ([])),
|
|
'stop': (gobject.SIGNAL_RUN_FIRST,
|
|
gobject.TYPE_NONE, ([]))
|
|
}
|
|
|
|
def __init__(self, activity):
|
|
icon_name = activity.get_icon_name()
|
|
self._orig_color = activity.get_icon_color()
|
|
self._icon_colors = self._compute_icon_colors()
|
|
|
|
self._direction = 0
|
|
self._level_max = len(self._icon_colors) - 1
|
|
self._level = self._level_max
|
|
color = self._icon_colors[self._level]
|
|
|
|
CanvasIcon.__init__(self, icon_name=icon_name, xo_color=color,
|
|
size=style.MEDIUM_ICON_SIZE, cache=True)
|
|
|
|
self._activity = activity
|
|
self._pulse_id = 0
|
|
|
|
palette = Palette(_('Starting...'))
|
|
self.set_palette(palette)
|
|
|
|
activity.connect('notify::launching', self._launching_changed_cb)
|
|
if activity.props.launching:
|
|
self._start_pulsing()
|
|
else:
|
|
self._setup_palette()
|
|
|
|
def _setup_palette(self):
|
|
palette = self.get_palette()
|
|
|
|
palette.set_primary_text(self._activity.get_title())
|
|
|
|
resume_menu_item = gtk.MenuItem(_('Resume'))
|
|
resume_menu_item.connect('activate', self._resume_activate_cb)
|
|
palette.menu.append(resume_menu_item)
|
|
resume_menu_item.show()
|
|
|
|
# FIXME: kludge
|
|
if self._activity.get_type() != "org.laptop.JournalActivity":
|
|
stop_menu_item = gtk.MenuItem(_('Stop'))
|
|
stop_menu_item.connect('activate', self._stop_activate_cb)
|
|
palette.menu.append(stop_menu_item)
|
|
stop_menu_item.show()
|
|
|
|
def _launching_changed_cb(self, activity, pspec):
|
|
if activity.props.launching:
|
|
self._start_pulsing()
|
|
else:
|
|
self._stop_pulsing()
|
|
self._setup_palette()
|
|
|
|
def __del__(self):
|
|
self._cleanup()
|
|
|
|
def _cleanup(self):
|
|
if self._pulse_id:
|
|
gobject.source_remove(self._pulse_id)
|
|
self._pulse_id = 0
|
|
# dispose of all rendered icons from launch feedback
|
|
self._clear_buffers()
|
|
|
|
def _compute_icon_colors(self):
|
|
_LEVEL_MAX = 1.6
|
|
_LEVEL_STEP = 0.16
|
|
_LEVEL_MIN = 0.0
|
|
icon_colors = {}
|
|
level = _LEVEL_MIN
|
|
for i in range(0, int(_LEVEL_MAX / _LEVEL_STEP)):
|
|
icon_colors[i] = self._get_icon_color_for_level(level)
|
|
level += _LEVEL_STEP
|
|
return icon_colors
|
|
|
|
def _get_icon_color_for_level(self, level):
|
|
factor = math.sin(level)
|
|
h, s, v = colorsys.rgb_to_hsv(*html_to_rgb(self._orig_color.get_fill_color()))
|
|
new_fill = rgb_to_html(*colorsys.hsv_to_rgb(h, s * factor, v))
|
|
h, s, v = colorsys.rgb_to_hsv(*html_to_rgb(self._orig_color.get_stroke_color()))
|
|
new_stroke = rgb_to_html(*colorsys.hsv_to_rgb(h, s * factor, v))
|
|
return xocolor.XoColor("%s,%s" % (new_stroke, new_fill))
|
|
|
|
def _pulse_cb(self):
|
|
if self._direction == 1:
|
|
self._level += 1
|
|
if self._level > self._level_max:
|
|
self._direction = 0
|
|
self._level = self._level_max
|
|
elif self._direction == 0:
|
|
self._level -= 1
|
|
if self._level <= 0:
|
|
self._direction = 1
|
|
self._level = 0
|
|
|
|
self.props.xo_color = self._icon_colors[self._level]
|
|
self.emit_paint_needed(0, 0, -1, -1)
|
|
return True
|
|
|
|
def _start_pulsing(self):
|
|
if self._pulse_id:
|
|
return
|
|
|
|
self._pulse_id = gobject.timeout_add(self._INTERVAL, self._pulse_cb)
|
|
|
|
def _stop_pulsing(self):
|
|
if not self._pulse_id:
|
|
return
|
|
|
|
self._cleanup()
|
|
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')
|
|
|
|
def _stop_activate_cb(self, menuitem):
|
|
self.emit('stop')
|
|
|
|
def get_activity(self):
|
|
return self._activity
|
|
|
|
class ActivitiesDonut(hippo.CanvasBox, hippo.CanvasItem):
|
|
__gtype_name__ = 'SugarActivitiesDonut'
|
|
def __init__(self, shell, **kwargs):
|
|
hippo.CanvasBox.__init__(self, **kwargs)
|
|
|
|
self._activities = []
|
|
self._shell = shell
|
|
self._angles = []
|
|
|
|
self._model = shell.get_model().get_home()
|
|
self._model.connect('activity-added', self._activity_added_cb)
|
|
self._model.connect('activity-removed', self._activity_removed_cb)
|
|
self._model.connect('pending-activity-changed', self._activity_changed_cb)
|
|
|
|
self.connect('button-release-event', self._button_release_event_cb)
|
|
|
|
def _get_icon_from_activity(self, activity):
|
|
for icon in self._activities:
|
|
if icon.get_activity().equals(activity):
|
|
return icon
|
|
|
|
def _activity_added_cb(self, model, activity):
|
|
self._add_activity(activity)
|
|
|
|
def _activity_removed_cb(self, model, activity):
|
|
self._remove_activity(activity)
|
|
|
|
def _activity_changed_cb(self, model, activity):
|
|
self.emit_paint_needed(0, 0, -1, -1)
|
|
|
|
def _remove_activity(self, activity):
|
|
icon = self._get_icon_from_activity(activity)
|
|
if icon:
|
|
self.remove(icon)
|
|
icon._cleanup()
|
|
self._activities.remove(icon)
|
|
|
|
def _add_activity(self, activity):
|
|
icon = ActivityIcon(activity)
|
|
icon.connect('resume', self._activity_icon_resumed_cb)
|
|
icon.connect('stop', self._activity_icon_stop_cb)
|
|
self.append(icon, hippo.PACK_FIXED)
|
|
|
|
self._activities.append(icon)
|
|
|
|
self.emit_paint_needed(0, 0, -1, -1)
|
|
|
|
def _activity_icon_resumed_cb(self, icon):
|
|
activity = icon.get_activity()
|
|
activity_host = self._shell.get_activity(activity.get_activity_id())
|
|
if activity_host:
|
|
activity_host.present()
|
|
else:
|
|
logging.error("Could not find ActivityHost for activity %s" %
|
|
activity.get_activity_id())
|
|
|
|
def _activity_icon_stop_cb(self, icon):
|
|
activity = icon.get_activity()
|
|
activity_host = self._shell.get_activity(activity.get_activity_id())
|
|
if activity_host:
|
|
activity_host.close()
|
|
else:
|
|
logging.error("Could not find ActivityHost for activity %s" %
|
|
activity.get_activity_id())
|
|
|
|
def _get_activity(self, x, y):
|
|
# Compute the distance from the center.
|
|
[width, height] = self.get_allocation()
|
|
x -= width / 2
|
|
y -= height / 2
|
|
r = math.hypot(x, y)
|
|
|
|
# Ignore the click if it's not inside the donut
|
|
if r < self._get_inner_radius() or r > self._get_radius():
|
|
return None
|
|
|
|
# Now figure out where in the donut the click was.
|
|
angle = math.atan2(-y, -x) + math.pi
|
|
|
|
# Unfortunately, _get_angles() doesn't count from 0 to 2pi, it
|
|
# counts from roughly pi/2 to roughly 5pi/2. So we have to
|
|
# compare its return values against both angle and angle+2pi
|
|
high_angle = angle + 2 * math.pi
|
|
|
|
for index, activity in enumerate(self._model):
|
|
[angle_start, angle_end] = self._get_angles(index)
|
|
if angle_start < angle and angle_end > angle:
|
|
return activity
|
|
elif angle_start < high_angle and angle_end > high_angle:
|
|
return activity
|
|
|
|
return None
|
|
|
|
def _button_release_event_cb(self, item, event):
|
|
activity = self._get_activity(event.x, event.y)
|
|
if activity is None:
|
|
return False
|
|
|
|
activity_host = self._shell.get_activity(activity.get_activity_id())
|
|
if activity_host:
|
|
activity_host.present()
|
|
return True
|
|
|
|
MAX_ACTIVITIES = 10
|
|
MIN_ACTIVITY_WEDGE_SIZE = 1.0 / MAX_ACTIVITIES
|
|
|
|
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 = {}
|
|
num_activities = {}
|
|
total_activity_size = 0
|
|
for activity in self._model:
|
|
pid = activity.get_pid()
|
|
if not pid:
|
|
# Still starting up, hasn't opened a window yet
|
|
continue
|
|
|
|
if process_size.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]
|
|
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)
|
|
|
|
# Next, see how much free memory is left.
|
|
try:
|
|
meminfo = open('/proc/meminfo')
|
|
meminfo.readline()
|
|
free_memory = int(meminfo.readline()[9:-3])
|
|
meminfo.close()
|
|
except IOError:
|
|
logging.warn('ActivitiesDonut: could not read /proc/meminfo')
|
|
except (IndexError, ValueError):
|
|
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 = total_activity_size + free_memory
|
|
|
|
activity_sizes = []
|
|
for activity in self._model:
|
|
percent = ActivitiesDonut.MIN_ACTIVITY_WEDGE_SIZE
|
|
pid = 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)
|
|
|
|
return activity_sizes
|
|
|
|
def _compute_angles(self):
|
|
percentages = self._get_activity_sizes()
|
|
self._angles = []
|
|
if len(percentages) == 0:
|
|
return
|
|
|
|
# The first wedge (Journal) should be centered at 6 o'clock
|
|
size = percentages[0] * 2 * math.pi
|
|
angle = (math.pi - size) / 2
|
|
self._angles.append(angle)
|
|
|
|
for size in percentages:
|
|
self._angles.append(self._angles[-1] + size * 2 * math.pi)
|
|
|
|
def _get_angles(self, index):
|
|
return [self._angles[index],
|
|
self._angles[(index + 1) % len(self._angles)]]
|
|
|
|
def _get_radius(self):
|
|
[width, height] = self.get_allocation()
|
|
return min(width, height) / 2
|
|
|
|
def _get_inner_radius(self):
|
|
return self._get_radius() * 0.5
|
|
|
|
def do_paint_below_children(self, cr, damaged_box):
|
|
[width, height] = self.get_allocation()
|
|
|
|
cr.translate(width / 2, height / 2)
|
|
|
|
radius = self._get_radius()
|
|
|
|
# Outer Ring
|
|
cr.set_source_rgb(0xf1 / 255.0, 0xf1 / 255.0, 0xf1 / 255.0)
|
|
cr.arc(0, 0, radius, 0, 2 * math.pi)
|
|
cr.fill()
|
|
|
|
# Selected Wedge
|
|
current_activity = self._model.get_pending_activity()
|
|
if current_activity is not None:
|
|
selected_index = self._model.index(current_activity)
|
|
[angle_start, angle_end] = self._get_angles(selected_index)
|
|
|
|
cr.new_path()
|
|
cr.move_to(0, 0)
|
|
cr.line_to(radius * math.cos(angle_start),
|
|
radius * math.sin(angle_start))
|
|
cr.arc(0, 0, radius, angle_start, angle_end)
|
|
cr.line_to(0, 0)
|
|
cr.set_source_rgb(1, 1, 1)
|
|
cr.fill()
|
|
|
|
# Edges
|
|
if len(self._model):
|
|
n_edges = len(self._model) + 1
|
|
else:
|
|
n_edges = 0
|
|
|
|
for i in range(0, n_edges):
|
|
cr.new_path()
|
|
cr.move_to(0, 0)
|
|
[angle, unused_angle] = self._get_angles(i)
|
|
cr.line_to(radius * math.cos(angle),
|
|
radius * math.sin(angle))
|
|
|
|
cr.set_source_rgb(0xe2 / 255.0, 0xe2 / 255.0, 0xe2 / 255.0)
|
|
cr.set_line_width(4)
|
|
cr.stroke_preserve()
|
|
|
|
# Inner Ring
|
|
cr.new_path()
|
|
cr.arc(0, 0, self._get_inner_radius(), 0, 2 * math.pi)
|
|
cr.set_source_rgb(0xe2 / 255.0, 0xe2 / 255.0, 0xe2 / 255.0)
|
|
cr.fill()
|
|
|
|
def do_allocate(self, width, height, origin_changed):
|
|
hippo.CanvasBox.do_allocate(self, width, height, origin_changed)
|
|
|
|
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
|
|
|
|
[icon_width, icon_height] = icon.get_allocation()
|
|
|
|
x = int(radius * math.cos(angle)) - icon_width / 2
|
|
y = int(radius * math.sin(angle)) - icon_height / 2
|
|
self.set_position(icon, x + width / 2, y + height / 2)
|