Big refactor of the directory structure and packages to
reflect private/public
This commit is contained in:
Marco Pesenti Gritti
@@ -1,5 +1,5 @@
|
||||
import os
|
||||
|
||||
data_basedir = os.path.dirname(os.path.dirname(__file__))
|
||||
data_dirs = [ 'sugar/browser', 'sugar/chat' ]
|
||||
data_dirs = [ 'activities/browser' ]
|
||||
activities_dir = ''
|
||||
|
||||
@@ -1,66 +0,0 @@
|
||||
import pygtk
|
||||
pygtk.require('2.0')
|
||||
import gtk
|
||||
|
||||
class AddressEntry(gtk.HBox):
|
||||
def __init__(self, callback):
|
||||
gtk.HBox.__init__(self)
|
||||
|
||||
self.callback = callback
|
||||
self.folded = True
|
||||
|
||||
label = gtk.Label("Open")
|
||||
self.pack_start(label, False)
|
||||
label.show()
|
||||
|
||||
self.button = gtk.Button()
|
||||
self.button.set_relief(gtk.RELIEF_NONE)
|
||||
self.button.connect("clicked", self.__button_clicked_cb)
|
||||
self.pack_start(self.button, False)
|
||||
self.button.show()
|
||||
|
||||
self.entry = gtk.Entry()
|
||||
self.entry.connect("activate", self.__activate_cb)
|
||||
self.pack_start(self.entry, False)
|
||||
self.entry.show()
|
||||
|
||||
self._update_folded_state()
|
||||
|
||||
def _update_folded_state(self):
|
||||
if self.folded:
|
||||
image = gtk.Image()
|
||||
image.set_from_icon_name('expand', gtk.ICON_SIZE_SMALL_TOOLBAR)
|
||||
self.button.set_image(image)
|
||||
image.show()
|
||||
|
||||
self.entry.hide()
|
||||
else:
|
||||
image = gtk.Image()
|
||||
image.set_from_icon_name('unexpand', gtk.ICON_SIZE_SMALL_TOOLBAR)
|
||||
self.button.set_image(image)
|
||||
image.show()
|
||||
|
||||
self.entry.show()
|
||||
self.entry.grab_focus()
|
||||
|
||||
def get_folded(self):
|
||||
return self.folded
|
||||
|
||||
def set_folded(self, folded):
|
||||
self.folded = folded
|
||||
self._update_folded_state()
|
||||
|
||||
def __button_clicked_cb(self, button):
|
||||
self.set_folded(not self.get_folded())
|
||||
|
||||
def __activate_cb(self, entry):
|
||||
self.callback(entry.get_text())
|
||||
self.set_folded(True)
|
||||
|
||||
class AddressItem(gtk.ToolItem):
|
||||
def __init__(self, callback):
|
||||
gtk.ToolItem.__init__(self)
|
||||
|
||||
address_entry = AddressEntry(callback)
|
||||
self.add(address_entry)
|
||||
address_entry.show()
|
||||
@@ -1,155 +0,0 @@
|
||||
import logging
|
||||
import xml.sax.saxutils
|
||||
|
||||
import pygtk
|
||||
pygtk.require('2.0')
|
||||
import gtk
|
||||
import geckoembed
|
||||
|
||||
from sugar.shell import activity
|
||||
from sugar.browser import NotificationBar
|
||||
from sugar.browser import NavigationToolbar
|
||||
from sugar.presence.PresenceService import PresenceService
|
||||
from sugar.p2p.model.LocalModel import LocalModel
|
||||
from sugar.p2p.model.RemoteModel import RemoteModel
|
||||
|
||||
_BROWSER_ACTIVITY_TYPE = "_web_olpc._udp"
|
||||
_SERVICE_URI_TAG = "URI"
|
||||
_SERVICE_TITLE_TAG = "Title"
|
||||
|
||||
class BrowserActivity(activity.Activity):
|
||||
SOLO = 1
|
||||
FOLLOWING = 2
|
||||
LEADING = 3
|
||||
|
||||
def __init__(self, uri, mode = SOLO):
|
||||
activity.Activity.__init__(self, _BROWSER_ACTIVITY_TYPE)
|
||||
self.uri = uri
|
||||
self._mode = mode
|
||||
|
||||
self._share_service = None
|
||||
self._model_service = None
|
||||
self._notif_service = None
|
||||
self._model = None
|
||||
|
||||
def _service_appeared_cb(self, pservice, buddy, service):
|
||||
# Make sure the service is for our activity
|
||||
if service.get_activity_uid() != self._activity_id:
|
||||
return
|
||||
|
||||
if service.get_type() == _BROWSER_ACTIVITY_TYPE:
|
||||
self._notif_service = service
|
||||
elif service.get_type() == LocalModel.SERVICE_TYPE:
|
||||
if self._mode != BrowserActivity.LEADING:
|
||||
self._model_service = service
|
||||
|
||||
if self._notif_service and self._model_service:
|
||||
self._model = RemoteModel(self._model_service, self._notif_service)
|
||||
self._model.add_listener(self.__shared_location_changed_cb)
|
||||
|
||||
def get_default_type(self):
|
||||
return _BROWSER_ACTIVITY_TYPE
|
||||
|
||||
def _update_shared_location(self):
|
||||
address = self.embed.get_address()
|
||||
self._model.set_value('address', address)
|
||||
title = self.embed.get_title()
|
||||
self._model.set_value('title', title)
|
||||
|
||||
def __notif_bar_action_cb(self, bar, action_id):
|
||||
print action_id
|
||||
if action_id == 'set_shared_location':
|
||||
self._update_shared_location()
|
||||
elif action_id == 'goto_shared_location':
|
||||
address = self._model.get_value("address")
|
||||
print address
|
||||
self.embed.load_address(address)
|
||||
self._notif_bar.hide()
|
||||
|
||||
def set_mode(self, mode):
|
||||
self._mode = mode
|
||||
if mode == BrowserActivity.LEADING:
|
||||
self._notif_bar.set_text('Share this page with the group.')
|
||||
self._notif_bar.set_action('set_shared_location', 'Share')
|
||||
self._notif_bar.set_icon('stock_shared-by-me')
|
||||
self._notif_bar.show()
|
||||
|
||||
def on_connected_to_shell(self):
|
||||
self.set_ellipsize_tab(True)
|
||||
self.set_can_close(True)
|
||||
self.set_tab_text("Web Page")
|
||||
self.set_tab_icon(name="web-browser")
|
||||
self.set_show_tab_icon(True)
|
||||
|
||||
vbox = gtk.VBox()
|
||||
|
||||
self._notif_bar = NotificationBar.NotificationBar()
|
||||
vbox.pack_start(self._notif_bar, False)
|
||||
self._notif_bar.connect('action', self.__notif_bar_action_cb)
|
||||
|
||||
self.embed = geckoembed.Embed()
|
||||
self.embed.connect("title", self.__title_cb)
|
||||
vbox.pack_start(self.embed)
|
||||
|
||||
self.embed.show()
|
||||
self.embed.load_address(self.uri)
|
||||
|
||||
nav_toolbar = NavigationToolbar.NavigationToolbar(self)
|
||||
vbox.pack_start(nav_toolbar, False)
|
||||
nav_toolbar.show()
|
||||
|
||||
plug = self.gtk_plug()
|
||||
plug.add(vbox)
|
||||
plug.show()
|
||||
|
||||
vbox.show()
|
||||
|
||||
logging.debug('Start presence service')
|
||||
self._pservice = PresenceService.get_instance()
|
||||
self._pservice.start()
|
||||
|
||||
logging.debug('Track browser activities')
|
||||
self._pservice.connect('service-appeared', self._service_appeared_cb)
|
||||
self._pservice.track_service_type(_BROWSER_ACTIVITY_TYPE)
|
||||
self._pservice.track_service_type(LocalModel.SERVICE_TYPE)
|
||||
|
||||
# Join the shared activity if we were started from one
|
||||
if self._initial_service:
|
||||
logging.debug("BrowserActivity joining shared activity %s" % self._initial_service.get_activity_uid())
|
||||
self._pservice.join_shared_activity(self._initial_service)
|
||||
|
||||
def get_embed(self):
|
||||
return self.embed
|
||||
|
||||
def publish(self):
|
||||
escaped_title = xml.sax.saxutils.escape(self.embed.get_title())
|
||||
escaped_url = xml.sax.saxutils.escape(self.embed.get_address())
|
||||
|
||||
# Publish ourselves on the network
|
||||
properties = {_SERVICE_URI_TAG: escaped_url, _SERVICE_TITLE_TAG: escaped_title}
|
||||
self._share_service = self._pservice.share_activity(self,
|
||||
stype=_BROWSER_ACTIVITY_TYPE, properties=properties)
|
||||
|
||||
# Create our activity-specific browser sharing service
|
||||
self._model = LocalModel(self, self._pservice, self._share_service)
|
||||
self._model.set_value('owner', self._pservice.get_owner().get_nick_name())
|
||||
self._update_shared_location()
|
||||
|
||||
self.set_mode(BrowserActivity.LEADING)
|
||||
|
||||
def __title_cb(self, embed):
|
||||
self.set_tab_text(embed.get_title())
|
||||
|
||||
def __shared_location_changed_cb(self, model, key):
|
||||
self.set_has_changes(True)
|
||||
self._notify_shared_location_change()
|
||||
|
||||
def _notify_shared_location_change(self):
|
||||
owner = self._model.get_value('owner')
|
||||
title = self._model.get_value('title')
|
||||
|
||||
text = '<b>' + owner + '</b> is reading <i>' + title + '</i>'
|
||||
self._notif_bar.set_text(text)
|
||||
self._notif_bar.set_action('goto_shared_location', 'Go There')
|
||||
self._notif_bar.set_icon('stock_right')
|
||||
self._notif_bar.show()
|
||||
@@ -1,51 +0,0 @@
|
||||
import dbus
|
||||
import geckoembed
|
||||
import pygtk
|
||||
pygtk.require('2.0')
|
||||
import gtk
|
||||
import gobject
|
||||
|
||||
import sugar.env
|
||||
|
||||
from sugar.browser.BrowserActivity import BrowserActivity
|
||||
from sugar.presence import Service
|
||||
|
||||
class BrowserShell(dbus.service.Object):
|
||||
def __init__(self, bus_name, object_path = '/com/redhat/Sugar/Browser'):
|
||||
dbus.service.Object.__init__(self, bus_name, object_path)
|
||||
|
||||
geckoembed.set_profile_path(sugar.env.get_user_dir())
|
||||
self.__browsers = []
|
||||
|
||||
def start(self):
|
||||
gtk.main()
|
||||
|
||||
@dbus.service.method('com.redhat.Sugar.BrowserShell')
|
||||
def get_links(self):
|
||||
links = []
|
||||
for browser in self.__browsers:
|
||||
embed = browser.get_embed()
|
||||
link = {}
|
||||
link['title'] = embed.get_title()
|
||||
link['address'] = embed.get_address()
|
||||
links.append(link)
|
||||
return links
|
||||
|
||||
def _start_browser_cb(self, browser, service):
|
||||
browser.connect_to_shell(service)
|
||||
|
||||
@dbus.service.method('com.redhat.Sugar.BrowserShell')
|
||||
def open_browser(self, uri, serialized_service=None):
|
||||
service = None
|
||||
if serialized_service is not None:
|
||||
service = Service.deserialize(serialized_service)
|
||||
browser = BrowserActivity(uri)
|
||||
self.__browsers.append(browser)
|
||||
gobject.idle_add(self._start_browser_cb, browser, service)
|
||||
|
||||
@dbus.service.method('com.redhat.Sugar.BrowserShell')
|
||||
def open_browser_from_service_foobar(self, uri, serialized_service):
|
||||
service = Service.deserialize(serialized_service)
|
||||
browser = BrowserActivity(uri)
|
||||
self.__browsers.append(browser)
|
||||
gobject.idle_add(self._start_browser_cb, browser, service)
|
||||
@@ -1,25 +0,0 @@
|
||||
sugardir = $(pythondir)/sugar/browser
|
||||
sugar_PYTHON = \
|
||||
__init__.py \
|
||||
browser.py \
|
||||
NotificationBar.py \
|
||||
BrowserShell.py \
|
||||
AddressItem.py \
|
||||
BrowserActivity.py \
|
||||
NavigationToolbar.py
|
||||
|
||||
icondir = $(pkgdatadir)
|
||||
icon_DATA = \
|
||||
fold.png \
|
||||
unfold.png
|
||||
|
||||
rcdir = $(pkgdatadir)
|
||||
rc_DATA = browser.rc
|
||||
|
||||
activitydir = $(pkgdatadir)/activities
|
||||
activity_DATA = browser.activity
|
||||
|
||||
EXTRA_DIST = \
|
||||
$(rc_DATA) \
|
||||
$(activity_DATA) \
|
||||
$(icon_DATA)
|
||||
@@ -1,62 +0,0 @@
|
||||
import pygtk
|
||||
pygtk.require('2.0')
|
||||
import gtk
|
||||
|
||||
from sugar.browser.AddressItem import AddressItem
|
||||
|
||||
class NavigationToolbar(gtk.Toolbar):
|
||||
def __init__(self, browser):
|
||||
gtk.Toolbar.__init__(self)
|
||||
self._browser = browser
|
||||
self._embed = self._browser.get_embed()
|
||||
|
||||
self.set_style(gtk.TOOLBAR_BOTH_HORIZ)
|
||||
|
||||
self.back = gtk.ToolButton(None, 'Back')
|
||||
self.back.set_icon_name('back')
|
||||
self.back.connect("clicked", self.__go_back_cb)
|
||||
self.insert(self.back, -1)
|
||||
self.back.show()
|
||||
|
||||
self.forward = gtk.ToolButton(None, 'Forward')
|
||||
self.forward.set_icon_name('forward')
|
||||
self.forward.connect("clicked", self.__go_forward_cb)
|
||||
self.insert(self.forward, -1)
|
||||
self.forward.show()
|
||||
|
||||
self.reload = gtk.ToolButton(None, 'Reload')
|
||||
self.reload.set_icon_name('reload')
|
||||
self.reload.connect("clicked", self.__reload_cb)
|
||||
self.insert(self.reload, -1)
|
||||
self.reload.show()
|
||||
|
||||
separator = gtk.SeparatorToolItem()
|
||||
self.insert(separator, -1)
|
||||
separator.show()
|
||||
|
||||
address_item = AddressItem(self.__open_address_cb)
|
||||
self.insert(address_item, -1)
|
||||
address_item.show()
|
||||
|
||||
self._update_sensitivity()
|
||||
|
||||
self._embed.connect("location", self.__location_changed)
|
||||
|
||||
def _update_sensitivity(self):
|
||||
self.back.set_sensitive(self._embed.can_go_back())
|
||||
self.forward.set_sensitive(self._embed.can_go_forward())
|
||||
|
||||
def __go_back_cb(self, button):
|
||||
self._embed.go_back()
|
||||
|
||||
def __go_forward_cb(self, button):
|
||||
self._embed.go_forward()
|
||||
|
||||
def __reload_cb(self, button):
|
||||
self._embed.reload()
|
||||
|
||||
def __location_changed(self, embed):
|
||||
self._update_sensitivity()
|
||||
|
||||
def __open_address_cb(self, address):
|
||||
self._embed.load_address(address)
|
||||
@@ -1,58 +0,0 @@
|
||||
import pygtk
|
||||
pygtk.require('2.0')
|
||||
import gtk
|
||||
import gobject
|
||||
|
||||
class NotificationBar(gtk.HBox):
|
||||
__gsignals__ = {
|
||||
'action': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
|
||||
([gobject.TYPE_STRING]))
|
||||
}
|
||||
|
||||
def __init__(self):
|
||||
gtk.HBox.__init__(self, False, 12)
|
||||
|
||||
self.set_name("notif bar")
|
||||
self.set_border_width(3)
|
||||
|
||||
self._icon = gtk.Image()
|
||||
self.pack_start(self._icon, False)
|
||||
|
||||
self._text_label = gtk.Label()
|
||||
self._text_label.set_alignment(0.0, 0.5)
|
||||
self.pack_start(self._text_label)
|
||||
self._text_label.show()
|
||||
|
||||
self._action_button = gtk.Button()
|
||||
self._action_button.connect('clicked', self.__button_clicked)
|
||||
self.pack_start(self._action_button, False)
|
||||
self._action_button.show()
|
||||
|
||||
self.connect('expose_event', self.expose)
|
||||
|
||||
def expose(self, widget, event):
|
||||
rect = self.get_allocation()
|
||||
ctx = widget.window.cairo_create()
|
||||
|
||||
ctx.new_path()
|
||||
ctx.rectangle(rect.x, rect.y, rect.width, rect.height)
|
||||
ctx.set_source_rgb(0.56 , 0.75 , 1)
|
||||
ctx.fill_preserve()
|
||||
ctx.set_source_rgb(0.16 , 0.35 , 0.6)
|
||||
ctx.stroke()
|
||||
|
||||
return False
|
||||
|
||||
def set_icon(self, icon_name):
|
||||
self._icon.set_from_icon_name(icon_name, gtk.ICON_SIZE_BUTTON)
|
||||
self._icon.show()
|
||||
|
||||
def set_text(self, text):
|
||||
self._text_label.set_markup(text)
|
||||
|
||||
def set_action(self, action_id, action_text):
|
||||
self._action_id = action_id
|
||||
self._action_button.set_label(action_text)
|
||||
|
||||
def __button_clicked(self, button):
|
||||
self.emit("action", self._action_id)
|
||||
@@ -1,2 +0,0 @@
|
||||
[Activity]
|
||||
python_class = sugar/browser/browser
|
||||
@@ -1,21 +0,0 @@
|
||||
#!/usr/bin/env python
|
||||
|
||||
import pygtk
|
||||
pygtk.require('2.0')
|
||||
import gtk
|
||||
import dbus
|
||||
|
||||
import sugar.env
|
||||
|
||||
from sugar.session.LogWriter import LogWriter
|
||||
from sugar.browser.BrowserShell import BrowserShell
|
||||
|
||||
log_writer = LogWriter("Web")
|
||||
log_writer.start()
|
||||
|
||||
gtk.rc_parse(sugar.env.get_data_file('browser.rc'))
|
||||
|
||||
session_bus = dbus.SessionBus()
|
||||
bus_name = dbus.service.BusName('com.redhat.Sugar.Browser', bus=session_bus)
|
||||
shell = BrowserShell(bus_name)
|
||||
shell.start()
|
||||
@@ -1,7 +0,0 @@
|
||||
style "NotificationBarButton" = "button"
|
||||
{
|
||||
xthickness = 0
|
||||
ythickness = 0
|
||||
}
|
||||
|
||||
widget "*.notif bar.*GtkButton*" style "NotificationBarButton"
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 156 B |
Binary file not shown.
|
Before Width: | Height: | Size: 157 B |
@@ -3,5 +3,4 @@ sugar_PYTHON = \
|
||||
__init__.py \
|
||||
AbstractModel.py \
|
||||
LocalModel.py \
|
||||
RemoteModel.py \
|
||||
Store.py
|
||||
RemoteModel.py
|
||||
|
||||
@@ -1,5 +0,0 @@
|
||||
sugardir = $(pythondir)/sugar/session
|
||||
sugar_PYTHON = \
|
||||
__init__.py \
|
||||
session.py \
|
||||
LogWriter.py
|
||||
@@ -1,59 +0,0 @@
|
||||
import os
|
||||
import signal
|
||||
from ConfigParser import ConfigParser
|
||||
|
||||
import pygtk
|
||||
pygtk.require('2.0')
|
||||
import gtk
|
||||
|
||||
from sugar.shell.shell import Shell
|
||||
from sugar import env
|
||||
|
||||
class Session:
|
||||
def __init__(self):
|
||||
self._activity_processes = {}
|
||||
|
||||
def start(self):
|
||||
shell = Shell()
|
||||
shell.connect('close', self._shell_close_cb)
|
||||
shell.start()
|
||||
|
||||
activities = []
|
||||
activities_dirs = []
|
||||
|
||||
for data_dir in env.get_data_dirs():
|
||||
act_dir = os.path.join(data_dir, env.get_activities_dir())
|
||||
activities_dirs.append(act_dir)
|
||||
|
||||
activities_dirs.append(os.path.join(env.get_user_dir(), 'activities'))
|
||||
|
||||
for activities_dir in activities_dirs:
|
||||
if os.path.isdir(activities_dir):
|
||||
for filename in os.listdir(activities_dir):
|
||||
if filename.endswith(".activity"):
|
||||
path = os.path.join(activities_dir, filename)
|
||||
cp = ConfigParser()
|
||||
cp.read([path])
|
||||
python_class = cp.get('Activity', "python_class")
|
||||
activities.append(python_class)
|
||||
|
||||
for activity in activities:
|
||||
args = [ 'python', '-m', activity ]
|
||||
pid = os.spawnvp(os.P_NOWAIT, 'python', args)
|
||||
self._activity_processes[activity] = pid
|
||||
|
||||
try:
|
||||
gtk.main()
|
||||
except KeyboardInterrupt:
|
||||
print 'Ctrl+C pressed, exiting...'
|
||||
self.shutdown()
|
||||
|
||||
def _shell_close_cb(self, shell):
|
||||
self.shutdown()
|
||||
|
||||
def shutdown(self):
|
||||
# FIXME Obviously we want to notify the activities to
|
||||
# shutt down rather then killing them down forcefully.
|
||||
for name in self._activity_processes.keys():
|
||||
print 'Shutting down %s' % (name)
|
||||
os.kill(self._activity_processes[name], signal.SIGTERM)
|
||||
@@ -1,8 +0,0 @@
|
||||
sugardir = $(pythondir)/sugar/shell
|
||||
sugar_PYTHON = \
|
||||
__init__.py \
|
||||
activity.py \
|
||||
shell.py \
|
||||
Owner.py \
|
||||
PresenceWindow.py \
|
||||
StartPage.py
|
||||
@@ -1,57 +0,0 @@
|
||||
import os
|
||||
import random
|
||||
import base64
|
||||
|
||||
from sugar import env
|
||||
from sugar.presence import Service
|
||||
from sugar.presence import Buddy
|
||||
from sugar.presence import PresenceService
|
||||
from sugar.p2p import Stream
|
||||
|
||||
class ShellOwner(object):
|
||||
"""Class representing the owner of this machine/instance. This class
|
||||
runs in the shell and serves up the buddy icon and other stuff. It's the
|
||||
server portion of the Owner, paired with the client portion in Buddy.py."""
|
||||
def __init__(self):
|
||||
nick = env.get_nick_name()
|
||||
user_dir = env.get_user_dir()
|
||||
if not os.path.exists(user_dir):
|
||||
try:
|
||||
os.makedirs(user_dir)
|
||||
except OSError:
|
||||
print "Could not create user directory."
|
||||
|
||||
self._icon = None
|
||||
for fname in os.listdir(user_dir):
|
||||
if not fname.startswith("buddy-icon."):
|
||||
continue
|
||||
fd = open(os.path.join(user_dir, fname), "r")
|
||||
self._icon = fd.read()
|
||||
fd.close()
|
||||
break
|
||||
|
||||
# Our presence service
|
||||
port = random.randint(40000, 65000)
|
||||
properties = {}
|
||||
self._service = Service.Service(nick, Buddy.PRESENCE_SERVICE_TYPE,
|
||||
domain="", address=None, port=port, properties=properties)
|
||||
print "Owner '%s' using port %d" % (nick, port)
|
||||
|
||||
self._icon_stream = Stream.Stream.new_from_service(self._service)
|
||||
self._icon_stream.register_reader_handler(self._handle_buddy_icon_request, "get_buddy_icon")
|
||||
|
||||
# Announce ourselves to the world
|
||||
self._pservice = PresenceService.PresenceService.get_instance()
|
||||
self._pservice.start()
|
||||
self._pservice.register_service(self._service)
|
||||
|
||||
def _handle_buddy_icon_request(self):
|
||||
"""XMLRPC method, return the owner's icon encoded with base64."""
|
||||
if self._icon:
|
||||
return base64.b64encode(self._icon)
|
||||
return ""
|
||||
|
||||
def set_icon(self, icon):
|
||||
"""Can only set icon in constructor for now."""
|
||||
pass
|
||||
|
||||
@@ -1,154 +0,0 @@
|
||||
import pygtk
|
||||
pygtk.require('2.0')
|
||||
import gtk
|
||||
import gobject
|
||||
|
||||
from sugar.presence.PresenceService import PresenceService
|
||||
|
||||
class PresenceWindow(gtk.Window):
|
||||
_MODEL_COL_NICK = 0
|
||||
_MODEL_COL_ICON = 1
|
||||
_MODEL_COL_BUDDY = 2
|
||||
_MODEL_COL_VISIBLE = 3
|
||||
|
||||
def __init__(self, activity_container):
|
||||
gtk.Window.__init__(self)
|
||||
|
||||
self._activity_container = activity_container
|
||||
self._activity = None
|
||||
|
||||
self._pservice = PresenceService.get_instance()
|
||||
self._pservice.connect("buddy-appeared", self._on_buddy_appeared_cb)
|
||||
self._pservice.connect("buddy-disappeared", self._on_buddy_disappeared_cb)
|
||||
self._pservice.set_debug(True)
|
||||
self._pservice.start()
|
||||
|
||||
self._setup_ui()
|
||||
|
||||
def _is_buddy_visible(self, buddy):
|
||||
if self._activity:
|
||||
activity_type = self._activity.get_default_type()
|
||||
service = buddy.get_service_of_type(activity_type, self._activity)
|
||||
return service is not None
|
||||
else:
|
||||
return True
|
||||
|
||||
def _update_buddies_visibility(self):
|
||||
for row in self._buddy_store:
|
||||
row[self._MODEL_COL_VISIBLE] = self._is_buddy_visible(row[self._MODEL_COL_BUDDY])
|
||||
|
||||
def set_activity(self, activity):
|
||||
self._activity = activity
|
||||
self._update_buddies_visibility()
|
||||
|
||||
def _setup_ui(self):
|
||||
vbox = gtk.VBox(False, 6)
|
||||
vbox.set_border_width(12)
|
||||
|
||||
label = gtk.Label("Who's around:")
|
||||
label.set_alignment(0.0, 0.5)
|
||||
vbox.pack_start(label, False)
|
||||
label.show()
|
||||
|
||||
self._buddy_store = gtk.ListStore(gobject.TYPE_STRING,
|
||||
gtk.gdk.Pixbuf,
|
||||
gobject.TYPE_PYOBJECT,
|
||||
bool)
|
||||
buddy_list_model = self._buddy_store.filter_new()
|
||||
buddy_list_model.set_visible_column(self._MODEL_COL_VISIBLE)
|
||||
|
||||
sw = gtk.ScrolledWindow()
|
||||
sw.set_shadow_type(gtk.SHADOW_IN)
|
||||
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
|
||||
|
||||
self._buddy_list_view = gtk.TreeView(buddy_list_model)
|
||||
self._buddy_list_view.set_headers_visible(False)
|
||||
self._buddy_list_view.connect("cursor-changed", self._on_buddyList_buddy_selected)
|
||||
self._buddy_list_view.connect("row-activated", self._on_buddyList_buddy_double_clicked)
|
||||
|
||||
sw.add(self._buddy_list_view)
|
||||
self._buddy_list_view.show()
|
||||
|
||||
renderer = gtk.CellRendererPixbuf()
|
||||
column = gtk.TreeViewColumn("", renderer, pixbuf=self._MODEL_COL_ICON)
|
||||
column.set_resizable(False)
|
||||
column.set_expand(False);
|
||||
self._buddy_list_view.append_column(column)
|
||||
|
||||
renderer = gtk.CellRendererText()
|
||||
column = gtk.TreeViewColumn("", renderer, text=self._MODEL_COL_NICK)
|
||||
column.set_resizable(True)
|
||||
column.set_sizing("GTK_TREE_VIEW_COLUMN_GROW_ONLY");
|
||||
column.set_expand(True);
|
||||
self._buddy_list_view.append_column(column)
|
||||
|
||||
vbox.pack_start(sw)
|
||||
sw.show()
|
||||
|
||||
button_box = gtk.HButtonBox()
|
||||
|
||||
share_button = gtk.Button('Share')
|
||||
share_button.connect('clicked', self._share_button_clicked_cb)
|
||||
button_box.pack_start(share_button)
|
||||
share_button.show()
|
||||
|
||||
vbox.pack_start(button_box, False)
|
||||
button_box.show()
|
||||
|
||||
self.add(vbox)
|
||||
vbox.show()
|
||||
|
||||
def _share_button_clicked_cb(self, button):
|
||||
self._activity_container.current_activity.publish()
|
||||
|
||||
def _on_buddyList_buddy_selected(self, view, *args):
|
||||
(model, aniter) = view.get_selection().get_selected()
|
||||
name = model.get(aniter, self._MODEL_COL_NICK)
|
||||
|
||||
def _on_buddyList_buddy_double_clicked(self, view, *args):
|
||||
""" Select the chat for this buddy or group """
|
||||
(model, aniter) = view.get_selection().get_selected()
|
||||
chat = None
|
||||
buddy = view.get_model().get_value(aniter, self._MODEL_COL_BUDDY)
|
||||
if buddy and not self._chats.has_key(buddy):
|
||||
#chat = BuddyChat(self, buddy)
|
||||
#self._chats[buddy] = chat
|
||||
#chat.connect_to_shell()
|
||||
pass
|
||||
|
||||
def __buddy_icon_changed_cb(self, buddy):
|
||||
it = self._get_iter_for_buddy(buddy)
|
||||
self._buddy_store.set(it, self._MODEL_COL_ICON, buddy.get_icon_pixbuf())
|
||||
|
||||
def _on_buddy_appeared_cb(self, pservice, buddy):
|
||||
if buddy.is_owner():
|
||||
# Do not show ourself in the buddy list
|
||||
return
|
||||
|
||||
aniter = self._buddy_store.append(None)
|
||||
self._buddy_store.set(aniter,
|
||||
self._MODEL_COL_NICK, buddy.get_nick_name(),
|
||||
self._MODEL_COL_BUDDY, buddy,
|
||||
self._MODEL_COL_VISIBLE, self._is_buddy_visible(buddy))
|
||||
buddy.connect('icon-changed', self.__buddy_icon_changed_cb)
|
||||
buddy.connect('service-added', self.__buddy_service_added_cb)
|
||||
buddy.connect('service-removed', self.__buddy_service_removed_cb)
|
||||
|
||||
def __buddy_service_added_cb(self, buddy, service):
|
||||
self._update_buddies_visibility()
|
||||
|
||||
def __buddy_service_removed_cb(self, buddy, service):
|
||||
self._update_buddies_visibility()
|
||||
|
||||
def _on_buddy_disappeared_cb(self, pservice, buddy):
|
||||
aniter = self._get_iter_for_buddy(buddy)
|
||||
if aniter:
|
||||
self._buddy_store.remove(aniter)
|
||||
|
||||
def _get_iter_for_buddy(self, buddy):
|
||||
aniter = self._buddy_store.get_iter_first()
|
||||
while aniter:
|
||||
list_buddy = self._buddy_store.get_value(aniter, self._MODEL_COL_BUDDY)
|
||||
if buddy == list_buddy:
|
||||
return aniter
|
||||
aniter = self._buddy_store.iter_next(aniter)
|
||||
@@ -1,294 +0,0 @@
|
||||
import pygtk
|
||||
pygtk.require('2.0')
|
||||
import gtk
|
||||
import pango
|
||||
import dbus
|
||||
import cgi
|
||||
import xml.sax.saxutils
|
||||
import gobject
|
||||
|
||||
import google
|
||||
from sugar.presence.PresenceService import PresenceService
|
||||
from sugar.browser import BrowserActivity
|
||||
|
||||
_COLUMN_TITLE = 0
|
||||
_COLUMN_ADDRESS = 1
|
||||
_COLUMN_SUBTITLE = 2
|
||||
_COLUMN_SERVICE = 3
|
||||
|
||||
class SearchHelper(object):
|
||||
def __init__(self, activity_uid):
|
||||
self.search_uid = activity_uid
|
||||
self.found = False
|
||||
|
||||
class SearchModel(gtk.ListStore):
|
||||
def __init__(self, activities_model, search_text):
|
||||
gtk.ListStore.__init__(self, gobject.TYPE_STRING, gobject.TYPE_STRING,
|
||||
gobject.TYPE_STRING, gobject.TYPE_PYOBJECT)
|
||||
|
||||
for row in activities_model:
|
||||
title = row[_COLUMN_TITLE]
|
||||
address = row[_COLUMN_ADDRESS]
|
||||
if title.find(search_text) >= 0 or address.find(search_text) >= 0:
|
||||
self.append([ title, address, row[_COLUMN_SUBTITLE], row[_COLUMN_SERVICE] ])
|
||||
|
||||
google.LICENSE_KEY = '1As9KaJQFHIJ1L0W5EZPl6vBOFvh/Vaf'
|
||||
data = google.doGoogleSearch(search_text)
|
||||
|
||||
for result in data.results:
|
||||
title = result.title
|
||||
|
||||
# FIXME what tags should we actually strip?
|
||||
title = title.replace('<b>', '')
|
||||
title = title.replace('</b>', '')
|
||||
|
||||
# FIXME I'm sure there is a better way to
|
||||
# unescape these.
|
||||
title = title.replace('"', '"')
|
||||
title = title.replace('&', '&')
|
||||
|
||||
self.append([ title, result.URL, None, None ])
|
||||
|
||||
class ActivitiesModel(gtk.ListStore):
|
||||
def __init__(self):
|
||||
gtk.ListStore.__init__(self, gobject.TYPE_STRING, gobject.TYPE_STRING,
|
||||
gobject.TYPE_STRING, gobject.TYPE_PYOBJECT)
|
||||
|
||||
def _filter_dupe_activities(self, model, path, it, user_data):
|
||||
"""Search the list of list rows for an existing service that
|
||||
has the activity ID we're looking for."""
|
||||
helper = user_data
|
||||
(service, ) = model.get(it, _COLUMN_SERVICE)
|
||||
if not service:
|
||||
return False
|
||||
if service.get_activity_uid() == helper.search_uid:
|
||||
helper.found = True
|
||||
return True
|
||||
return False
|
||||
|
||||
def add_activity(self, buddy, service):
|
||||
# Web Activity check
|
||||
activity_uid = service.get_activity_uid()
|
||||
if activity_uid is None:
|
||||
return
|
||||
# Don't show dupes
|
||||
helper = SearchHelper(activity_uid)
|
||||
self.foreach(self._filter_dupe_activities, helper)
|
||||
if helper.found == True:
|
||||
return
|
||||
|
||||
# Only accept browser activities for now
|
||||
if service.get_type() == BrowserActivity._BROWSER_ACTIVITY_TYPE:
|
||||
escaped_title = service.get_one_property('Title')
|
||||
escaped_uri = service.get_one_property('URI')
|
||||
if escaped_title and escaped_uri:
|
||||
title = xml.sax.saxutils.unescape(escaped_title)
|
||||
address = xml.sax.saxutils.unescape(escaped_uri)
|
||||
subtitle = 'Shared by %s' % buddy.get_nick_name()
|
||||
self.append([ title, address, subtitle, service ])
|
||||
|
||||
class ActivitiesView(gtk.TreeView):
|
||||
def __init__(self, model):
|
||||
gtk.TreeView.__init__(self, model)
|
||||
|
||||
self._owner = None
|
||||
|
||||
self.set_headers_visible(False)
|
||||
|
||||
theme = gtk.icon_theme_get_default()
|
||||
size = 48
|
||||
self._web_pixbuf = theme.load_icon('emblem-web', size, 0)
|
||||
self._share_pixbuf = theme.load_icon('emblem-people', size, 0)
|
||||
|
||||
column = gtk.TreeViewColumn('')
|
||||
self.append_column(column)
|
||||
|
||||
cell = gtk.CellRendererPixbuf()
|
||||
column.pack_start(cell, False)
|
||||
column.set_cell_data_func(cell, self._icon_cell_data_func)
|
||||
|
||||
cell = gtk.CellRendererText()
|
||||
column.pack_start(cell)
|
||||
column.set_cell_data_func(cell, self._cell_data_func)
|
||||
|
||||
self.connect('row-activated', self._row_activated_cb)
|
||||
|
||||
def _icon_cell_data_func(self, column, cell, model, it):
|
||||
if model.get_value(it, _COLUMN_SERVICE) == None:
|
||||
cell.set_property('pixbuf', self._web_pixbuf)
|
||||
else:
|
||||
cell.set_property('pixbuf', self._share_pixbuf)
|
||||
|
||||
def _cell_data_func(self, column, cell, model, it):
|
||||
title = model.get_value(it, _COLUMN_TITLE)
|
||||
subtitle = model.get_value(it, _COLUMN_SUBTITLE)
|
||||
if subtitle is None:
|
||||
subtitle = model.get_value(it, _COLUMN_ADDRESS)
|
||||
|
||||
markup = '<big><b>' + cgi.escape(title) + '</b></big>'
|
||||
markup += '\n' + cgi.escape(subtitle)
|
||||
|
||||
cell.set_property('markup', markup)
|
||||
cell.set_property('ellipsize', pango.ELLIPSIZE_END)
|
||||
|
||||
def set_owner(self, owner):
|
||||
self._owner = owner
|
||||
|
||||
def _row_activated_cb(self, treeview, path, column):
|
||||
bus = dbus.SessionBus()
|
||||
proxy_obj = bus.get_object('com.redhat.Sugar.Browser', '/com/redhat/Sugar/Browser')
|
||||
browser_shell = dbus.Interface(proxy_obj, 'com.redhat.Sugar.BrowserShell')
|
||||
|
||||
model = self.get_model()
|
||||
address = model.get_value(model.get_iter(path), _COLUMN_ADDRESS)
|
||||
service = model.get_value(model.get_iter(path), _COLUMN_SERVICE)
|
||||
|
||||
print 'Activated row %s' % address
|
||||
|
||||
if service is None:
|
||||
browser_shell.open_browser(address)
|
||||
else:
|
||||
if not self._owner:
|
||||
raise RuntimeError("We don't have an owner yet!")
|
||||
serialized_service = service.serialize(self._owner)
|
||||
browser_shell.open_browser(address, serialized_service)
|
||||
|
||||
class StartPage(gtk.HBox):
|
||||
def __init__(self, ac_signal_object):
|
||||
gtk.HBox.__init__(self)
|
||||
|
||||
self._ac_signal_object = ac_signal_object
|
||||
self._ac_signal_object.connect("local-activity-started",
|
||||
self._on_local_activity_started_cb)
|
||||
self._ac_signal_object.connect("local-activity-ended",
|
||||
self._on_local_activity_ended_cb)
|
||||
|
||||
self._pservice = PresenceService.get_instance()
|
||||
self._pservice.connect("activity-announced", self._on_activity_announced_cb)
|
||||
self._pservice.connect("new-service-adv", self._on_new_service_adv_cb)
|
||||
self._pservice.connect("buddy-appeared", self._on_buddy_appeared_cb)
|
||||
self._pservice.connect("buddy-disappeared", self._on_buddy_disappeared_cb)
|
||||
self._pservice.start()
|
||||
self._pservice.track_service_type(BrowserActivity._BROWSER_ACTIVITY_TYPE)
|
||||
if self._pservice.get_owner():
|
||||
self._on_buddy_appeared_cb(self._pservice, self._pservice.get_owner())
|
||||
|
||||
vbox = gtk.VBox()
|
||||
|
||||
search_box = gtk.HBox(False, 6)
|
||||
search_box.set_border_width(24)
|
||||
|
||||
self._search_entry = gtk.Entry()
|
||||
self._search_entry.connect('activate', self._search_entry_activate_cb)
|
||||
search_box.pack_start(self._search_entry)
|
||||
self._search_entry.show()
|
||||
|
||||
search_button = gtk.Button("Search")
|
||||
search_button.connect('clicked', self._search_button_clicked_cb)
|
||||
search_box.pack_start(search_button, False)
|
||||
search_button.show()
|
||||
|
||||
vbox.pack_start(search_box, False, True)
|
||||
search_box.show()
|
||||
|
||||
exp_space = gtk.Label('')
|
||||
vbox.pack_start(exp_space)
|
||||
exp_space.show()
|
||||
|
||||
self.pack_start(vbox)
|
||||
vbox.show()
|
||||
|
||||
vbox = gtk.VBox()
|
||||
|
||||
self._search_close_box = gtk.HBox()
|
||||
|
||||
self._search_close_label = gtk.Label()
|
||||
self._search_close_label.set_alignment(0.0, 0.5)
|
||||
self._search_close_box.pack_start(self._search_close_label)
|
||||
self._search_close_label.show()
|
||||
|
||||
close_image = gtk.Image()
|
||||
close_image.set_from_stock (gtk.STOCK_CLOSE, gtk.ICON_SIZE_MENU)
|
||||
close_image.show()
|
||||
|
||||
search_close_button = gtk.Button()
|
||||
rcstyle = gtk.RcStyle();
|
||||
rcstyle.xthickness = rcstyle.ythickness = 0;
|
||||
search_close_button.modify_style (rcstyle);
|
||||
search_close_button.add(close_image)
|
||||
search_close_button.set_relief(gtk.RELIEF_NONE)
|
||||
search_close_button.set_focus_on_click(False)
|
||||
search_close_button.connect("clicked", self.__search_close_button_clicked_cb)
|
||||
|
||||
self._search_close_box.pack_start(search_close_button, False)
|
||||
search_close_button.show()
|
||||
|
||||
vbox.pack_start(self._search_close_box, False)
|
||||
|
||||
sw = gtk.ScrolledWindow()
|
||||
sw.set_size_request(320, -1)
|
||||
sw.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
|
||||
|
||||
self._activities_model = ActivitiesModel()
|
||||
|
||||
owner = self._pservice.get_owner()
|
||||
self._activities = ActivitiesView(self._activities_model)
|
||||
sw.add(self._activities)
|
||||
self._activities.show()
|
||||
|
||||
vbox.pack_start(sw)
|
||||
sw.show()
|
||||
|
||||
self.pack_start(vbox)
|
||||
vbox.show()
|
||||
|
||||
def __search_close_button_clicked_cb(self, button):
|
||||
self._search(None)
|
||||
|
||||
def _on_local_activity_started_cb(self, helper, activity_container, activity_id):
|
||||
print "new local activity %s" % activity_id
|
||||
|
||||
def _on_local_activity_ended_cb(self, helper, activity_container, activity_id):
|
||||
print "local activity %s disappeared" % activity_id
|
||||
|
||||
def _on_new_service_adv_cb(self, pservice, activity_id, short_stype):
|
||||
if activity_id:
|
||||
self._pservice.track_service_type(short_stype)
|
||||
|
||||
def _on_buddy_appeared_cb(self, pservice, buddy):
|
||||
if buddy.is_owner():
|
||||
self._activities.set_owner(buddy)
|
||||
|
||||
def _on_buddy_disappeared_cb(self, pservice, buddy):
|
||||
if buddy.is_owner():
|
||||
self._activities.set_owner(None)
|
||||
|
||||
def _on_activity_announced_cb(self, pservice, service, buddy):
|
||||
print "Found new activity with type %s" % service.get_full_type()
|
||||
self._activities_model.add_activity(buddy, service)
|
||||
if self._activities.get_model() != self._activities_model:
|
||||
self._search(self._last_search)
|
||||
|
||||
def _search_entry_activate_cb(self, entry):
|
||||
self._search()
|
||||
self._search_entry.set_text('')
|
||||
|
||||
def _search_button_clicked_cb(self, button):
|
||||
self._search()
|
||||
self._search_entry.set_text('')
|
||||
|
||||
def _search(self, text = None):
|
||||
if text == None:
|
||||
text = self._search_entry.get_text()
|
||||
|
||||
if text == None or len(text) == 0:
|
||||
self._activities.set_model(self._activities_model)
|
||||
self._search_close_box.hide()
|
||||
else:
|
||||
search_model = SearchModel(self._activities_model, text)
|
||||
self._activities.set_model(search_model)
|
||||
|
||||
self._search_close_label.set_text('Search for %s' % (text))
|
||||
self._search_close_box.show()
|
||||
|
||||
self._last_search = text
|
||||
@@ -1,158 +0,0 @@
|
||||
import pygtk
|
||||
pygtk.require('2.0')
|
||||
import gtk
|
||||
import gobject
|
||||
|
||||
SM_SPACE_PROPORTIONAL = 0
|
||||
SM_STEP = 1
|
||||
|
||||
SLIDING_TIMEOUT = 50
|
||||
SLIDING_MODE = SM_SPACE_PROPORTIONAL
|
||||
|
||||
#SLIDING_TIMEOUT = 10
|
||||
#SLIDING_MODE = SM_STEP
|
||||
#SLIDING_STEP = 0.05
|
||||
|
||||
class WindowManager:
|
||||
__managers_list = []
|
||||
|
||||
CENTER = 0
|
||||
LEFT = 1
|
||||
RIGHT = 2
|
||||
TOP = 3
|
||||
BOTTOM = 4
|
||||
|
||||
ABSOLUTE = 0
|
||||
SCREEN_RELATIVE = 1
|
||||
|
||||
def __init__(self, window):
|
||||
self._window = window
|
||||
self._sliding_pos = 0
|
||||
|
||||
WindowManager.__managers_list.append(self)
|
||||
|
||||
window.connect("key-press-event", self.__key_press_event_cb)
|
||||
|
||||
def __key_press_event_cb(self, window, event):
|
||||
manager = None
|
||||
|
||||
if event.keyval == gtk.keysyms.Left and \
|
||||
event.state & gtk.gdk.CONTROL_MASK:
|
||||
for wm in WindowManager.__managers_list:
|
||||
if wm._position == WindowManager.LEFT:
|
||||
manager = wm
|
||||
|
||||
if event.keyval == gtk.keysyms.Up and \
|
||||
event.state & gtk.gdk.CONTROL_MASK:
|
||||
for wm in WindowManager.__managers_list:
|
||||
if wm._position == WindowManager.TOP:
|
||||
manager = wm
|
||||
|
||||
if manager and manager._window.get_property('visible'):
|
||||
manager.slide_window_out()
|
||||
elif manager:
|
||||
manager.slide_window_in()
|
||||
|
||||
def set_width(self, width, width_type):
|
||||
self._width = width
|
||||
self._width_type = width_type
|
||||
|
||||
def set_height(self, height, height_type):
|
||||
self._height = height
|
||||
self._height_type = height_type
|
||||
|
||||
def set_position(self, position):
|
||||
self._position = position
|
||||
|
||||
def _calc_size_and_position(self):
|
||||
screen_width = self._window.get_screen().get_width()
|
||||
screen_height = self._window.get_screen().get_height()
|
||||
|
||||
if self._width_type is WindowManager.ABSOLUTE:
|
||||
width = self._width
|
||||
elif self._width_type is WindowManager.SCREEN_RELATIVE:
|
||||
width = int(screen_width * self._width)
|
||||
|
||||
if self._height_type is WindowManager.ABSOLUTE:
|
||||
height = self._height
|
||||
elif self._height_type is WindowManager.SCREEN_RELATIVE:
|
||||
height = int(screen_height * self._height)
|
||||
|
||||
if self._position is WindowManager.CENTER:
|
||||
self._x = int((screen_width - width) / 2)
|
||||
self._y = int((screen_height - height) / 2)
|
||||
elif self._position is WindowManager.LEFT:
|
||||
self._x = - int((1.0 - self._sliding_pos) * width)
|
||||
self._y = int((screen_height - height) / 2)
|
||||
elif self._position is WindowManager.TOP:
|
||||
self._x = int((screen_width - width) / 2)
|
||||
self._y = - int((1.0 - self._sliding_pos) * height)
|
||||
|
||||
self._real_width = width
|
||||
self._real_height = height
|
||||
|
||||
def _update_size_and_position(self):
|
||||
self._calc_size_and_position()
|
||||
self._window.move(self._x, self._y)
|
||||
self._window.resize(self._real_width, self._real_height)
|
||||
|
||||
def _update_position(self):
|
||||
self._calc_size_and_position()
|
||||
self._window.move(self._x, self._y)
|
||||
|
||||
def __slide_in_timeout_cb(self):
|
||||
if self._sliding_pos == 0:
|
||||
self._window.show()
|
||||
|
||||
if SLIDING_MODE == SM_SPACE_PROPORTIONAL:
|
||||
space_to_go = 1.0 - self._sliding_pos
|
||||
self._sliding_pos += (space_to_go / 2)
|
||||
else:
|
||||
self._sliding_pos += SLIDING_STEP
|
||||
|
||||
if self._sliding_pos > .999:
|
||||
self._sliding_pos = 1.0
|
||||
|
||||
self._update_position()
|
||||
|
||||
if self._sliding_pos == 1.0:
|
||||
return False
|
||||
else:
|
||||
return True
|
||||
|
||||
def __slide_out_timeout_cb(self):
|
||||
self._window.show()
|
||||
|
||||
if SLIDING_MODE == SM_SPACE_PROPORTIONAL:
|
||||
space_to_go = self._sliding_pos
|
||||
self._sliding_pos -= (space_to_go / 2)
|
||||
else:
|
||||
self._sliding_pos -= SLIDING_STEP
|
||||
|
||||
if self._sliding_pos < .001:
|
||||
self._sliding_pos = 0
|
||||
|
||||
self._update_position()
|
||||
|
||||
if self._sliding_pos == 0:
|
||||
self._window.hide()
|
||||
return False
|
||||
else:
|
||||
return True
|
||||
|
||||
def slide_window_in(self):
|
||||
self._sliding_pos = 0
|
||||
gobject.timeout_add(SLIDING_TIMEOUT, self.__slide_in_timeout_cb)
|
||||
|
||||
def slide_window_out(self):
|
||||
self._sliding_pos = 1.0
|
||||
gobject.timeout_add(SLIDING_TIMEOUT, self.__slide_out_timeout_cb)
|
||||
|
||||
def show(self):
|
||||
self._window.show()
|
||||
|
||||
def update(self):
|
||||
self._update_size_and_position()
|
||||
|
||||
def manage(self):
|
||||
self._update_size_and_position()
|
||||
@@ -1,515 +0,0 @@
|
||||
import dbus
|
||||
import dbus.service
|
||||
import dbus.glib
|
||||
|
||||
import pygtk
|
||||
pygtk.require('2.0')
|
||||
import gtk
|
||||
import pango
|
||||
import gobject
|
||||
|
||||
import sugar.util
|
||||
from sugar.session.LogWriter import LogWriter
|
||||
from sugar.shell.PresenceWindow import PresenceWindow
|
||||
from sugar.chat.ChatWindow import ChatWindow
|
||||
from sugar.shell.Owner import ShellOwner
|
||||
from sugar.shell.StartPage import StartPage
|
||||
from sugar.shell.WindowManager import WindowManager
|
||||
from sugar.chat.GroupChat import GroupChat
|
||||
|
||||
class ActivityHost(dbus.service.Object):
|
||||
|
||||
def __init__(self, activity_container, activity_name, default_type, activity_id = None):
|
||||
self.activity_name = activity_name
|
||||
self.ellipsize_tab = False
|
||||
|
||||
self.activity_container = activity_container
|
||||
|
||||
if activity_id is None:
|
||||
self.activity_id = sugar.util.unique_id()
|
||||
else:
|
||||
self.activity_id = activity_id
|
||||
self._default_type = default_type
|
||||
|
||||
self.dbus_object_name = "/com/redhat/Sugar/Shell/Activities/%s" % self.activity_id
|
||||
|
||||
dbus.service.Object.__init__(self, activity_container.service, self.dbus_object_name)
|
||||
self.socket = gtk.Socket()
|
||||
self.socket.set_data("sugar-activity", self)
|
||||
self.socket.show()
|
||||
|
||||
hbox = gtk.HBox(False, 4);
|
||||
|
||||
self.tab_activity_image = gtk.Image()
|
||||
self.tab_activity_image.set_from_stock(gtk.STOCK_CONVERT, gtk.ICON_SIZE_MENU)
|
||||
hbox.pack_start(self.tab_activity_image)
|
||||
#self.tab_activity_image.show()
|
||||
|
||||
self.label_hbox = gtk.HBox(False, 4);
|
||||
self.label_hbox.connect("style-set", self.__tab_label_style_set_cb)
|
||||
hbox.pack_start(self.label_hbox)
|
||||
|
||||
self.tab_label = gtk.Label(self.activity_name)
|
||||
self.tab_label.set_single_line_mode(True)
|
||||
self.tab_label.set_alignment(0.0, 0.5)
|
||||
self.tab_label.set_padding(0, 0)
|
||||
self.tab_label.show()
|
||||
|
||||
close_image = gtk.Image()
|
||||
close_image.set_from_stock (gtk.STOCK_CLOSE, gtk.ICON_SIZE_MENU)
|
||||
close_image.show()
|
||||
|
||||
self.tab_close_button = gtk.Button()
|
||||
rcstyle = gtk.RcStyle();
|
||||
rcstyle.xthickness = rcstyle.ythickness = 0;
|
||||
self.tab_close_button.modify_style (rcstyle);
|
||||
self.tab_close_button.add(close_image)
|
||||
self.tab_close_button.set_relief(gtk.RELIEF_NONE)
|
||||
self.tab_close_button.set_focus_on_click(False)
|
||||
self.tab_close_button.connect("clicked", self.tab_close_button_clicked)
|
||||
|
||||
self.label_hbox.pack_start(self.tab_label)
|
||||
self.label_hbox.pack_start(self.tab_close_button, False, False, 0)
|
||||
self.label_hbox.show()
|
||||
|
||||
hbox.show()
|
||||
|
||||
self._create_chat()
|
||||
|
||||
notebook = self.activity_container.notebook
|
||||
index = notebook.append_page(self.socket, hbox)
|
||||
notebook.set_current_page(index)
|
||||
|
||||
def _create_chat(self):
|
||||
self._group_chat = GroupChat(self)
|
||||
|
||||
def get_chat(self):
|
||||
return self._group_chat
|
||||
|
||||
def get_default_type(self):
|
||||
return self._default_type
|
||||
|
||||
def __close_button_clicked_reply_cb(self):
|
||||
pass
|
||||
|
||||
def __close_button_clicked_error_cb(self, error):
|
||||
pass
|
||||
|
||||
def publish(self):
|
||||
self._group_chat.publish()
|
||||
self.peer_service.publish()
|
||||
|
||||
def tab_close_button_clicked(self, button):
|
||||
self.peer_service.close_from_user(reply_handler = self.__close_button_clicked_reply_cb, \
|
||||
error_handler = self.__close_button_clicked_error_cb)
|
||||
|
||||
@dbus.service.method("com.redhat.Sugar.Shell.ActivityHost", \
|
||||
in_signature="", \
|
||||
out_signature="t")
|
||||
def get_host_xembed_id(self):
|
||||
window_id = self.socket.get_id()
|
||||
#print "window_id = %d"%window_id
|
||||
return window_id
|
||||
|
||||
@dbus.service.method("com.redhat.Sugar.Shell.ActivityHost", \
|
||||
in_signature="ss", \
|
||||
out_signature="")
|
||||
def set_peer_service_name(self, peer_service_name, peer_object_name):
|
||||
#print "peer_service_name = %s, peer_object_name = %s"%(peer_service_name, peer_object_name)
|
||||
self.__peer_service_name = peer_service_name
|
||||
self.__peer_object_name = peer_object_name
|
||||
self.peer_service = dbus.Interface(self.activity_container.bus.get_object( \
|
||||
self.__peer_service_name, self.__peer_object_name), \
|
||||
"com.redhat.Sugar.Activity")
|
||||
|
||||
@dbus.service.method("com.redhat.Sugar.Shell.ActivityHost", \
|
||||
in_signature="b", \
|
||||
out_signature="")
|
||||
def set_ellipsize_tab(self, ellipsize):
|
||||
self.ellipsize_tab = True
|
||||
self.update_tab_size()
|
||||
|
||||
@dbus.service.method("com.redhat.Sugar.Shell.ActivityHost", \
|
||||
in_signature="b", \
|
||||
out_signature="")
|
||||
def set_can_close(self, can_close):
|
||||
if can_close:
|
||||
self.tab_close_button.show()
|
||||
else:
|
||||
self.tab_close_button.hide()
|
||||
|
||||
@dbus.service.method("com.redhat.Sugar.Shell.ActivityHost", \
|
||||
in_signature="b", \
|
||||
out_signature="")
|
||||
def set_tab_show_icon(self, show_icon):
|
||||
if show_icon:
|
||||
self.tab_activity_image.show()
|
||||
else:
|
||||
self.tab_activity_image.hide()
|
||||
|
||||
@dbus.service.method("com.redhat.Sugar.Shell.ActivityHost", \
|
||||
in_signature="b", \
|
||||
out_signature="")
|
||||
def set_has_changes(self, has_changes):
|
||||
if has_changes:
|
||||
attrs = pango.AttrList()
|
||||
attrs.insert(pango.AttrForeground(50000, 0, 0, 0, -1))
|
||||
attrs.insert(pango.AttrWeight(pango.WEIGHT_BOLD, 0, -1))
|
||||
self.tab_label.set_attributes(attrs)
|
||||
else:
|
||||
self.tab_label.set_attributes(pango.AttrList())
|
||||
|
||||
@dbus.service.method("com.redhat.Sugar.Shell.ActivityHost", \
|
||||
in_signature="s", \
|
||||
out_signature="")
|
||||
def set_tab_text(self, text):
|
||||
self.tab_label.set_text(text)
|
||||
|
||||
@dbus.service.method("com.redhat.Sugar.Shell.ActivityHost", \
|
||||
in_signature="ayibiiii", \
|
||||
out_signature="")
|
||||
def set_tab_icon(self, data, colorspace, has_alpha, bits_per_sample, width, height, rowstride):
|
||||
#print "width=%d, height=%d"%(width, height)
|
||||
#print " data = ", data
|
||||
pixstr = ""
|
||||
for c in data:
|
||||
# Work around for a bug in dbus < 0.61 where integers
|
||||
# are not correctly marshalled
|
||||
if c < 0:
|
||||
c += 256
|
||||
pixstr += chr(c)
|
||||
|
||||
pixbuf = gtk.gdk.pixbuf_new_from_data(pixstr, colorspace, has_alpha, bits_per_sample, width, height, rowstride)
|
||||
#print pixbuf
|
||||
self.tab_activity_image.set_from_pixbuf(pixbuf)
|
||||
|
||||
@dbus.service.method("com.redhat.Sugar.Shell.ActivityHost", \
|
||||
in_signature="", \
|
||||
out_signature="")
|
||||
def shutdown(self):
|
||||
#print "shutdown"
|
||||
for owner, activity in self.activity_container.activities[:]:
|
||||
if activity == self:
|
||||
self.activity_container.activities.remove((owner, activity))
|
||||
|
||||
for i in range(self.activity_container.notebook.get_n_pages()):
|
||||
child = self.activity_container.notebook.get_nth_page(i)
|
||||
if child == self.socket:
|
||||
#print "found child"
|
||||
self.activity_container.notebook.remove_page(i)
|
||||
break
|
||||
|
||||
del self
|
||||
|
||||
def get_host_activity_id(self):
|
||||
"""Real function that the shell should use for getting the
|
||||
activity's ID."""
|
||||
return self.activity_id
|
||||
|
||||
def get_id(self):
|
||||
"""Interface-type function to match activity.Activity's
|
||||
get_id() function."""
|
||||
return self.activity_id
|
||||
|
||||
def get_object_path(self):
|
||||
return self.dbus_object_name
|
||||
|
||||
def update_tab_size(self):
|
||||
if self.ellipsize_tab:
|
||||
self.tab_label.set_ellipsize(pango.ELLIPSIZE_END)
|
||||
|
||||
context = self.label_hbox.get_pango_context()
|
||||
font_desc = self.label_hbox.style.font_desc
|
||||
metrics = context.get_metrics(font_desc, context.get_language())
|
||||
char_width = metrics.get_approximate_digit_width()
|
||||
[w, h] = self.__get_close_icon_size()
|
||||
tab_width = 15 * pango.PIXELS(char_width) + 2 * w
|
||||
self.label_hbox.set_size_request(tab_width, -1);
|
||||
else:
|
||||
self.tab_label.set_ellipsize(pango.ELLIPSIZE_NONE)
|
||||
self.label_hbox.set_size_request(-1, -1)
|
||||
|
||||
def __get_close_icon_size(self):
|
||||
settings = self.label_hbox.get_settings()
|
||||
return gtk.icon_size_lookup_for_settings(settings, gtk.ICON_SIZE_MENU)
|
||||
|
||||
def __tab_label_style_set_cb(self, widget, previous_style):
|
||||
[w, h] = self.__get_close_icon_size()
|
||||
self.tab_close_button.set_size_request (w + 5, h + 2)
|
||||
self.update_tab_size()
|
||||
|
||||
class ActivityContainerSignalHelper(gobject.GObject):
|
||||
"""A gobject whose sole purpose is to distribute signals for
|
||||
an ActivityContainer object."""
|
||||
|
||||
__gsignals__ = {
|
||||
'local-activity-started': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
|
||||
([gobject.TYPE_PYOBJECT, gobject.TYPE_PYOBJECT])),
|
||||
'local-activity-ended': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
|
||||
([gobject.TYPE_PYOBJECT, gobject.TYPE_PYOBJECT]))
|
||||
}
|
||||
|
||||
def __init__(self, parent):
|
||||
gobject.GObject.__init__(self)
|
||||
self._parent = parent
|
||||
|
||||
def activity_started(self, activity_id):
|
||||
self.emit('local-activity-started', self._parent, activity_id)
|
||||
|
||||
def activity_ended(self, activity_id):
|
||||
self.emit('local-activity-ended', self._parent, activity_id)
|
||||
|
||||
class ActivityContainer(dbus.service.Object):
|
||||
|
||||
def __init__(self, service, bus):
|
||||
self.activities = []
|
||||
|
||||
self.bus = bus
|
||||
self.service = service
|
||||
|
||||
self._signal_helper = ActivityContainerSignalHelper(self)
|
||||
|
||||
dbus.service.Object.__init__(self, self.service, "/com/redhat/Sugar/Shell/ActivityContainer")
|
||||
bus.add_signal_receiver(self.name_owner_changed, dbus_interface = "org.freedesktop.DBus", signal_name = "NameOwnerChanged")
|
||||
|
||||
self.window = gtk.Window()
|
||||
self.window.connect("key-press-event", self.__key_press_event_cb)
|
||||
self.window.set_title("OLPC Sugar")
|
||||
|
||||
self._fullscreen = False
|
||||
|
||||
self.notebook = gtk.Notebook()
|
||||
|
||||
tab_label = gtk.Label("Everyone")
|
||||
self._start_page = StartPage(self._signal_helper)
|
||||
self.notebook.append_page(self._start_page, tab_label)
|
||||
self._start_page.show()
|
||||
|
||||
self.notebook.show()
|
||||
self.notebook.connect("switch-page", self.notebook_tab_changed)
|
||||
self.window.add(self.notebook)
|
||||
|
||||
self.window.connect("destroy", lambda w: gtk.main_quit())
|
||||
|
||||
self.current_activity = None
|
||||
|
||||
# Create our owner service
|
||||
self._owner = ShellOwner()
|
||||
|
||||
self._presence_window = PresenceWindow(self)
|
||||
self._presence_window.set_transient_for(self.window)
|
||||
self._presence_window.set_decorated(False)
|
||||
self._presence_window.set_type_hint(gtk.gdk.WINDOW_TYPE_HINT_DOCK)
|
||||
self._presence_window.set_skip_taskbar_hint(True)
|
||||
|
||||
wm = WindowManager(self._presence_window)
|
||||
|
||||
wm.set_width(0.15, WindowManager.SCREEN_RELATIVE)
|
||||
wm.set_height(1.0, WindowManager.SCREEN_RELATIVE)
|
||||
wm.set_position(WindowManager.LEFT)
|
||||
wm.manage()
|
||||
|
||||
self._chat_window = ChatWindow()
|
||||
self._chat_window.set_transient_for(self.window)
|
||||
self._chat_window.set_type_hint(gtk.gdk.WINDOW_TYPE_HINT_DOCK)
|
||||
self._chat_window.set_decorated(False)
|
||||
self._chat_window.set_skip_taskbar_hint(True)
|
||||
|
||||
self._chat_wm = WindowManager(self._chat_window)
|
||||
|
||||
self._chat_wm.set_width(0.5, WindowManager.SCREEN_RELATIVE)
|
||||
self._chat_wm.set_height(0.5, WindowManager.SCREEN_RELATIVE)
|
||||
self._chat_wm.set_position(WindowManager.TOP)
|
||||
self._chat_wm.manage()
|
||||
|
||||
def show(self):
|
||||
self.window.show()
|
||||
|
||||
def __focus_reply_cb(self):
|
||||
pass
|
||||
|
||||
def __focus_error_cb(self, error):
|
||||
pass
|
||||
|
||||
def set_current_activity(self, activity):
|
||||
self.current_activity = activity
|
||||
self._presence_window.set_activity(activity)
|
||||
|
||||
if activity:
|
||||
host_chat = activity.get_chat()
|
||||
self._chat_window.set_chat(host_chat)
|
||||
|
||||
# For some reason the substitution screw up window position
|
||||
self._chat_wm.update()
|
||||
|
||||
def notebook_tab_changed(self, notebook, page, page_number):
|
||||
new_activity = notebook.get_nth_page(page_number).get_data("sugar-activity")
|
||||
|
||||
if self.current_activity != None:
|
||||
if self.has_activity(self.current_activity):
|
||||
self.current_activity.peer_service.lost_focus(reply_handler = self.__focus_reply_cb, error_handler = self.__focus_error_cb)
|
||||
|
||||
#if self.has_activity(new_activity):
|
||||
self.set_current_activity(new_activity)
|
||||
|
||||
if self.current_activity != None:
|
||||
if self.has_activity(self.current_activity):
|
||||
self.current_activity.peer_service.got_focus(reply_handler = self.__focus_reply_cb, error_handler = self.__focus_error_cb)
|
||||
|
||||
|
||||
def has_activity(self, activity_to_check_for):
|
||||
for owner, activity in self.activities[:]:
|
||||
if activity_to_check_for == activity:
|
||||
return True
|
||||
return False
|
||||
|
||||
|
||||
def name_owner_changed(self, service_name, old_service_name, new_service_name):
|
||||
#print "in name_owner_changed: svc=%s oldsvc=%s newsvc=%s"%(service_name, old_service_name, new_service_name)
|
||||
for owner, activity in self.activities[:]:
|
||||
if owner == old_service_name:
|
||||
activity_id = activity.get_host_activity_id()
|
||||
self._signal_helper.activity_ended(activity_id)
|
||||
self.activities.remove((owner, activity))
|
||||
#self.__print_activities()
|
||||
|
||||
|
||||
@dbus.service.method("com.redhat.Sugar.Shell.ActivityContainer", \
|
||||
in_signature="ss", \
|
||||
out_signature="s", \
|
||||
sender_keyword="sender")
|
||||
def add_activity(self, activity_name, default_type, sender):
|
||||
#print "hello world, activity_name = '%s', sender = '%s'"%(activity_name, sender)
|
||||
activity = ActivityHost(self, activity_name, default_type)
|
||||
self.activities.append((sender, activity))
|
||||
|
||||
activity_id = activity.get_host_activity_id()
|
||||
self._signal_helper.activity_started(activity_id)
|
||||
|
||||
self.current_activity = activity
|
||||
return activity_id
|
||||
|
||||
@dbus.service.method("com.redhat.Sugar.Shell.ActivityContainer", \
|
||||
in_signature="sss", \
|
||||
sender_keyword="sender")
|
||||
def add_activity_with_id(self, activity_name, default_type, activity_id, sender):
|
||||
activity = ActivityHost(self, activity_name, default_type, activity_id)
|
||||
self.activities.append((sender, activity))
|
||||
activity_id = activity.get_host_activity_id()
|
||||
self._signal_helper.activity_started(activity_id)
|
||||
self.current_activity = activity
|
||||
|
||||
def __print_activities(self):
|
||||
print "__print_activities: %d activities registered" % len(self.activities)
|
||||
i = 0
|
||||
for owner, activity in self.activities:
|
||||
print " %d: owner=%s activity_object_name=%s" % (i, owner, activity.dbus_object_name)
|
||||
i += 1
|
||||
|
||||
def __key_press_event_cb(self, window, event):
|
||||
if event.keyval == gtk.keysyms.F11:
|
||||
if self._fullscreen:
|
||||
window.unfullscreen()
|
||||
self._fullscreen = False
|
||||
else:
|
||||
window.fullscreen()
|
||||
self._fullscreen = True
|
||||
|
||||
class ConsoleLogger(dbus.service.Object):
|
||||
def __init__(self):
|
||||
session_bus = dbus.SessionBus()
|
||||
bus_name = dbus.service.BusName('com.redhat.Sugar.Logger', bus=session_bus)
|
||||
object_path = '/com/redhat/Sugar/Logger'
|
||||
dbus.service.Object.__init__(self, bus_name, object_path)
|
||||
|
||||
self._window = gtk.Window()
|
||||
self._window.set_title("Console")
|
||||
self._window.set_default_size(640, 480)
|
||||
self._window.connect("delete_event", lambda w, e: w.hide_on_delete())
|
||||
|
||||
self._nb = gtk.Notebook()
|
||||
self._window.add(self._nb)
|
||||
self._nb.show()
|
||||
|
||||
self._consoles = {}
|
||||
|
||||
def set_parent_window(self, window):
|
||||
window.connect("key-press-event", self.__key_press_event_cb)
|
||||
self._window.connect("key-press-event", self.__key_press_event_cb)
|
||||
|
||||
def __key_press_event_cb(self, window, event):
|
||||
if event.keyval == gtk.keysyms.d and \
|
||||
event.state & gtk.gdk.CONTROL_MASK:
|
||||
if self._window.get_property('visible'):
|
||||
self._window.hide()
|
||||
else:
|
||||
self._window.show()
|
||||
|
||||
def _create_console(self, application):
|
||||
sw = gtk.ScrolledWindow()
|
||||
sw.set_policy(gtk.POLICY_AUTOMATIC,
|
||||
gtk.POLICY_AUTOMATIC)
|
||||
|
||||
console = gtk.TextView()
|
||||
console.set_wrap_mode(gtk.WRAP_WORD)
|
||||
|
||||
sw.add(console)
|
||||
console.show()
|
||||
|
||||
self._nb.append_page(sw, gtk.Label(application))
|
||||
sw.show()
|
||||
|
||||
return console
|
||||
|
||||
@dbus.service.method('com.redhat.Sugar.Logger')
|
||||
def log(self, application, message):
|
||||
if self._consoles.has_key(application):
|
||||
console = self._consoles[application]
|
||||
else:
|
||||
console = self._create_console(application)
|
||||
self._consoles[application] = console
|
||||
|
||||
buf = console.get_buffer()
|
||||
buf.insert(buf.get_end_iter(), message)
|
||||
|
||||
class Shell(gobject.GObject):
|
||||
__gsignals__ = {
|
||||
'close': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
|
||||
([])),
|
||||
}
|
||||
|
||||
def __init__(self):
|
||||
gobject.GObject.__init__(self)
|
||||
|
||||
def start(self):
|
||||
console = ConsoleLogger()
|
||||
|
||||
log_writer = LogWriter("Shell", False)
|
||||
log_writer.start()
|
||||
|
||||
session_bus = dbus.SessionBus()
|
||||
service = dbus.service.BusName("com.redhat.Sugar.Shell", bus=session_bus)
|
||||
|
||||
activity_container = ActivityContainer(service, session_bus)
|
||||
activity_container.window.connect('destroy', self.__activity_container_destroy_cb)
|
||||
activity_container.show()
|
||||
|
||||
wm = WindowManager(activity_container.window)
|
||||
wm.set_width(640, WindowManager.ABSOLUTE)
|
||||
wm.set_height(480, WindowManager.ABSOLUTE)
|
||||
wm.set_position(WindowManager.CENTER)
|
||||
wm.show()
|
||||
wm.manage()
|
||||
|
||||
console.set_parent_window(activity_container.window)
|
||||
|
||||
def __activity_container_destroy_cb(self, activity_container):
|
||||
self.emit('close')
|
||||
|
||||
if __name__ == "__main__":
|
||||
shell = Shell()
|
||||
shell.start()
|
||||
try:
|
||||
gtk.main()
|
||||
except KeyboardInterrupt:
|
||||
print 'Ctrl+c pressed, exiting...'
|
||||
-85
@@ -1,85 +0,0 @@
|
||||
#!/usr/bin/python
|
||||
|
||||
import sys
|
||||
import os
|
||||
import pwd
|
||||
import random
|
||||
|
||||
import pygtk
|
||||
pygtk.require('2.0')
|
||||
import gobject
|
||||
|
||||
def add_to_python_path(path):
|
||||
sys.path.insert(0, path)
|
||||
if os.environ.has_key('PYTHONPATH'):
|
||||
os.environ['PYTHONPATH'] += ':' + path
|
||||
else:
|
||||
os.environ['PYTHONPATH'] = path
|
||||
|
||||
def start_dbus():
|
||||
curdir = os.path.dirname(__file__)
|
||||
args = "/bin/dbus-daemon --session --print-address".split()
|
||||
(dbus_pid, ign1, dbus_stdout, ign3) = gobject.spawn_async(args, flags=gobject.SPAWN_STDERR_TO_DEV_NULL, standard_output=True)
|
||||
dbus_file = os.fdopen(dbus_stdout)
|
||||
addr = dbus_file.readline()
|
||||
addr = addr.strip()
|
||||
print "dbus-daemon pid is %d, session bus address is %s" % (dbus_pid, addr)
|
||||
dbus_file.close()
|
||||
|
||||
os.environ["DBUS_SESSION_BUS_ADDRESS"] = addr
|
||||
|
||||
return dbus_pid
|
||||
|
||||
def stop_dbus(dbus_pid):
|
||||
try:
|
||||
print 'Closing dbus-daemon, pid %d' % (dbus_pid)
|
||||
os.kill(dbus_pid, 9)
|
||||
except OSError:
|
||||
pass
|
||||
|
||||
i = 0
|
||||
dbus_daemon_pid = None
|
||||
for arg in sys.argv:
|
||||
if arg == '--test-user':
|
||||
user = sys.argv[i + 1]
|
||||
user_dir = os.path.expanduser('~/.sugar-' + user)
|
||||
os.environ['SUGAR_NICK_NAME'] = user
|
||||
os.environ['SUGAR_USER_DIR'] = user_dir
|
||||
dbus_daemon_pid = start_dbus()
|
||||
started_dbus = True
|
||||
i += 1
|
||||
|
||||
if not os.environ.has_key("SUGAR_NICK_NAME"):
|
||||
nick = pwd.getpwuid(os.getuid())[0]
|
||||
if not nick or not len(nick):
|
||||
nick = "Guest %d" % random.randint(1, 10000)
|
||||
os.environ['SUGAR_NICK_NAME'] = nick
|
||||
os.environ['SUGAR_USER_DIR'] = os.path.expanduser('~/.sugar')
|
||||
|
||||
curdir = os.path.dirname(__file__)
|
||||
if curdir == '.':
|
||||
basedir = os.path.dirname(os.getcwd())
|
||||
else:
|
||||
basedir = os.path.dirname(curdir)
|
||||
|
||||
if os.path.isfile(os.path.join(curdir, '__uninstalled__.py')):
|
||||
if basedir == '':
|
||||
print 'Running sugar from current directory...'
|
||||
else:
|
||||
print 'Running sugar from ' + basedir + ' ...'
|
||||
add_to_python_path(basedir)
|
||||
add_to_python_path(os.path.join(basedir, 'cut-n-paste'))
|
||||
else:
|
||||
print 'Running the installed sugar...'
|
||||
|
||||
add_to_python_path(os.path.expanduser('~/.sugar/activities'))
|
||||
|
||||
print 'Redirecting output to the console, press ctrl+d to open it.'
|
||||
|
||||
from sugar.session.session import Session
|
||||
|
||||
session = Session()
|
||||
session.start()
|
||||
|
||||
if dbus_daemon_pid:
|
||||
stop_dbus(dbus_daemon_pid)
|
||||
Reference in New Issue
Block a user