2015-08-11 17:24:07 +02:00
|
|
|
'''
|
|
|
|
Base class for activities written in Python
|
|
|
|
===========================================
|
2007-04-10 04:47:37 +02:00
|
|
|
|
2009-08-25 19:55:48 +02:00
|
|
|
This is currently the only definitive reference for what an
|
2007-04-10 04:47:37 +02:00
|
|
|
activity must do to participate in the Sugar desktop.
|
2007-10-28 16:56:05 +01:00
|
|
|
|
2015-08-11 17:24:07 +02:00
|
|
|
A Basic Activity
|
|
|
|
----------------
|
2007-10-28 16:56:05 +01:00
|
|
|
|
|
|
|
All activities must implement a class derived from 'Activity' in this class.
|
|
|
|
The convention is to call it ActivitynameActivity, but this is not required as
|
|
|
|
the activity.info file associated with your activity will tell the sugar-shell
|
|
|
|
which class to start.
|
|
|
|
|
2009-08-25 19:55:48 +02:00
|
|
|
For example the most minimal Activity:
|
|
|
|
|
2015-08-11 17:24:07 +02:00
|
|
|
.. code-block:: python
|
2007-10-28 16:56:05 +01:00
|
|
|
|
2011-10-29 10:44:18 +02:00
|
|
|
from sugar3.activity import activity
|
2009-08-25 19:55:48 +02:00
|
|
|
|
2007-10-28 16:56:05 +01:00
|
|
|
class ReadActivity(activity.Activity):
|
|
|
|
pass
|
|
|
|
|
|
|
|
To get a real, working activity, you will at least have to implement:
|
2015-08-11 17:24:07 +02:00
|
|
|
|
|
|
|
__init__(), :func:`sugar3.activity.activity.Activity.read_file()` and
|
|
|
|
:func:`sugar3.activity.activity.Activity.write_file()`
|
2007-10-28 16:56:05 +01:00
|
|
|
|
|
|
|
Aditionally, you will probably need a at least a Toolbar so you can have some
|
|
|
|
interesting buttons for the user, like for example 'exit activity'
|
|
|
|
|
|
|
|
See the methods of the Activity class below for more information on what you
|
|
|
|
will need for a real activity.
|
2008-10-28 14:19:01 +01:00
|
|
|
|
2015-08-11 17:24:07 +02:00
|
|
|
.. note:: This API is STABLE.
|
|
|
|
'''
|
2007-06-24 14:43:48 +02:00
|
|
|
# Copyright (C) 2006-2007 Red Hat, Inc.
|
2009-01-18 16:30:53 +01:00
|
|
|
# Copyright (C) 2007-2009 One Laptop Per Child
|
2010-08-12 16:20:14 +02:00
|
|
|
# Copyright (C) 2010 Collabora Ltd. <http://www.collabora.co.uk/>
|
2006-10-15 01:08:44 +02:00
|
|
|
#
|
|
|
|
# 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.
|
|
|
|
|
2008-02-09 12:27:22 +01:00
|
|
|
import gettext
|
2006-08-11 17:05:06 +02:00
|
|
|
import logging
|
2007-02-22 17:27:00 +01:00
|
|
|
import os
|
2007-05-10 11:01:32 +02:00
|
|
|
import time
|
2007-08-21 12:12:13 +02:00
|
|
|
from hashlib import sha1
|
2010-07-15 10:50:05 +02:00
|
|
|
from functools import partial
|
2012-03-14 17:37:23 +01:00
|
|
|
import StringIO
|
|
|
|
import cairo
|
2012-03-22 17:58:07 +01:00
|
|
|
import json
|
2006-08-09 18:29:33 +02:00
|
|
|
|
2011-11-15 19:29:07 +01:00
|
|
|
from gi.repository import Gtk
|
2011-10-29 12:20:30 +02:00
|
|
|
from gi.repository import Gdk
|
2011-11-15 19:29:07 +01:00
|
|
|
from gi.repository import GObject
|
2007-06-15 18:03:17 +02:00
|
|
|
import dbus
|
2008-01-31 20:48:03 +01:00
|
|
|
import dbus.service
|
2010-07-15 10:50:05 +02:00
|
|
|
from dbus import PROPERTIES_IFACE
|
|
|
|
from telepathy.server import DBusProperties
|
2010-08-12 15:53:28 +02:00
|
|
|
from telepathy.interfaces import CHANNEL, \
|
2013-05-17 07:16:36 +02:00
|
|
|
CHANNEL_TYPE_TEXT, \
|
|
|
|
CLIENT, \
|
|
|
|
CLIENT_HANDLER
|
2010-07-15 10:50:05 +02:00
|
|
|
from telepathy.constants import CONNECTION_HANDLE_TYPE_CONTACT
|
2011-06-09 16:53:18 +02:00
|
|
|
from telepathy.constants import CONNECTION_HANDLE_TYPE_ROOM
|
2007-06-27 23:12:32 +02:00
|
|
|
|
2011-10-29 15:55:20 +02:00
|
|
|
from sugar3 import util
|
2013-12-27 16:00:22 +01:00
|
|
|
from sugar3 import power
|
2016-04-17 07:57:07 +02:00
|
|
|
from sugar3.profile import get_nick_name, get_color
|
2011-10-29 10:44:18 +02:00
|
|
|
from sugar3.presence import presenceservice
|
|
|
|
from sugar3.activity.activityservice import ActivityService
|
|
|
|
from sugar3.graphics import style
|
|
|
|
from sugar3.graphics.window import Window
|
|
|
|
from sugar3.graphics.alert import Alert
|
|
|
|
from sugar3.graphics.icon import Icon
|
|
|
|
from sugar3.datastore import datastore
|
2014-04-30 19:57:57 +02:00
|
|
|
from sugar3.bundle.activitybundle import get_bundle_instance
|
2015-07-02 21:07:23 +02:00
|
|
|
from sugar3.bundle.helpers import bundle_from_dir
|
2016-04-17 07:57:07 +02:00
|
|
|
from sugar3 import env
|
|
|
|
from errno import EEXIST
|
|
|
|
|
2012-08-24 12:23:17 +02:00
|
|
|
from gi.repository import SugarExt
|
2009-07-30 17:08:55 +02:00
|
|
|
|
2013-09-11 16:02:47 +02:00
|
|
|
_ = lambda msg: gettext.dgettext('sugar-toolkit-gtk3', msg)
|
2008-02-09 12:27:22 +01:00
|
|
|
|
2010-10-15 21:14:59 +02:00
|
|
|
SCOPE_PRIVATE = 'private'
|
|
|
|
SCOPE_INVITE_ONLY = 'invite' # shouldn't be shown in UI, it's implicit
|
|
|
|
SCOPE_NEIGHBORHOOD = 'public'
|
2007-07-24 11:29:14 +02:00
|
|
|
|
2007-12-19 13:02:16 +01:00
|
|
|
J_DBUS_SERVICE = 'org.laptop.Journal'
|
|
|
|
J_DBUS_PATH = '/org/laptop/Journal'
|
|
|
|
J_DBUS_INTERFACE = 'org.laptop.Journal'
|
|
|
|
|
2014-03-08 01:12:44 +01:00
|
|
|
N_BUS_NAME = 'org.freedesktop.Notifications'
|
|
|
|
N_OBJ_PATH = '/org/freedesktop/Notifications'
|
|
|
|
N_IFACE_NAME = 'org.freedesktop.Notifications'
|
|
|
|
|
2010-07-15 10:50:05 +02:00
|
|
|
CONN_INTERFACE_ACTIVITY_PROPERTIES = 'org.laptop.Telepathy.ActivityProperties'
|
2009-08-25 21:12:40 +02:00
|
|
|
|
2013-02-04 15:47:04 +01:00
|
|
|
PREVIEW_SIZE = style.zoom(300), style.zoom(225)
|
|
|
|
|
2010-10-15 19:53:25 +02:00
|
|
|
|
2011-11-15 19:29:07 +01:00
|
|
|
class _ActivitySession(GObject.GObject):
|
2009-08-25 21:12:40 +02:00
|
|
|
|
2008-08-06 23:04:00 +02:00
|
|
|
__gsignals__ = {
|
2011-11-15 19:29:07 +01:00
|
|
|
'quit-requested': (GObject.SignalFlags.RUN_FIRST, None, ([])),
|
|
|
|
'quit': (GObject.SignalFlags.RUN_FIRST, None, ([])),
|
2008-08-06 23:04:00 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
def __init__(self):
|
2011-11-15 19:29:07 +01:00
|
|
|
GObject.GObject.__init__(self)
|
2008-08-06 23:04:00 +02:00
|
|
|
|
2013-08-30 19:44:07 +02:00
|
|
|
self._xsmp_client = SugarExt.ClientXSMP()
|
2009-08-25 21:12:40 +02:00
|
|
|
self._xsmp_client.connect('quit-requested',
|
2013-05-17 07:16:36 +02:00
|
|
|
self.__sm_quit_requested_cb)
|
2008-08-06 23:04:00 +02:00
|
|
|
self._xsmp_client.connect('quit', self.__sm_quit_cb)
|
|
|
|
self._xsmp_client.startup()
|
|
|
|
|
|
|
|
self._activities = []
|
|
|
|
self._will_quit = []
|
|
|
|
|
|
|
|
def register(self, activity):
|
|
|
|
self._activities.append(activity)
|
|
|
|
|
|
|
|
def unregister(self, activity):
|
|
|
|
self._activities.remove(activity)
|
|
|
|
|
|
|
|
if len(self._activities) == 0:
|
|
|
|
logging.debug('Quitting the activity process.')
|
2011-11-15 19:29:07 +01:00
|
|
|
Gtk.main_quit()
|
2008-08-06 23:04:00 +02:00
|
|
|
|
|
|
|
def will_quit(self, activity, will_quit):
|
|
|
|
if will_quit:
|
|
|
|
self._will_quit.append(activity)
|
|
|
|
|
|
|
|
# We can quit only when all the instances agreed to
|
|
|
|
for activity in self._activities:
|
|
|
|
if activity not in self._will_quit:
|
|
|
|
return
|
|
|
|
|
|
|
|
self._xsmp_client.will_quit(True)
|
|
|
|
else:
|
|
|
|
self._will_quit = []
|
|
|
|
self._xsmp_client.will_quit(False)
|
|
|
|
|
|
|
|
def __sm_quit_requested_cb(self, client):
|
|
|
|
self.emit('quit-requested')
|
|
|
|
|
|
|
|
def __sm_quit_cb(self, client):
|
|
|
|
self.emit('quit')
|
|
|
|
|
2009-08-25 21:12:40 +02:00
|
|
|
|
2011-11-15 19:29:07 +01:00
|
|
|
class Activity(Window, Gtk.Container):
|
2015-08-11 17:24:07 +02:00
|
|
|
'''
|
|
|
|
This is the base Activity class that all other Activities derive from.
|
|
|
|
This is where your activity starts.
|
2009-08-25 19:55:48 +02:00
|
|
|
|
2007-10-28 16:56:05 +01:00
|
|
|
To get a working Activity:
|
|
|
|
0. Derive your Activity from this class:
|
2015-08-11 17:24:07 +02:00
|
|
|
|
|
|
|
.. code-block:: python
|
|
|
|
|
|
|
|
class MyActivity(activity.Activity):
|
|
|
|
...
|
2009-08-25 19:55:48 +02:00
|
|
|
|
2007-10-28 16:56:05 +01:00
|
|
|
1. implement an __init__() method for your Activity class.
|
2009-08-25 19:55:48 +02:00
|
|
|
|
2015-08-11 17:24:07 +02:00
|
|
|
Use your init method to create your own ToolbarBox.
|
|
|
|
This is the code to make a basic toolbar with the activity
|
|
|
|
toolbar and a stop button.
|
2014-01-27 01:15:28 +01:00
|
|
|
|
2015-08-11 17:24:07 +02:00
|
|
|
.. code-block:: python
|
|
|
|
|
|
|
|
from sugar3.graphics.toolbarbox import ToolbarBox
|
|
|
|
from sugar3.activity.widgets import ActivityToolbarButton
|
|
|
|
from sugar3.activity.widgets import StopButton
|
|
|
|
|
|
|
|
def __init__(self, handle):
|
|
|
|
activity.Activity.__init__(self, handle)
|
2014-01-27 01:15:28 +01:00
|
|
|
|
|
|
|
toolbar_box = ToolbarBox()
|
|
|
|
activity_button = ActivityToolbarButton(self)
|
|
|
|
toolbar_box.toolbar.insert(activity_button, 0)
|
|
|
|
activity_button.show()
|
|
|
|
|
|
|
|
... Your toolbars ...
|
|
|
|
|
|
|
|
separator = Gtk.SeparatorToolItem(draw=False)
|
|
|
|
separator.set_expand(True)
|
|
|
|
toolbar_box.toolbar.insert(separator, -1)
|
|
|
|
separator.show()
|
|
|
|
|
|
|
|
stop_button = StopButton(self)
|
|
|
|
toolbar_box.toolbar.insert(stop_button, -1)
|
|
|
|
stop_button.show()
|
|
|
|
|
|
|
|
self.set_toolbar_box(toolbar_box)
|
|
|
|
toolbar_box.show()
|
2009-08-25 19:55:48 +02:00
|
|
|
|
2015-08-11 17:24:07 +02:00
|
|
|
Add extra Toolbars to your toolbox.
|
2009-08-25 19:55:48 +02:00
|
|
|
|
2015-08-11 17:24:07 +02:00
|
|
|
You should setup Activity sharing here too.
|
2009-08-25 19:55:48 +02:00
|
|
|
|
2015-08-11 17:24:07 +02:00
|
|
|
Finaly, your Activity may need some resources which you can claim
|
|
|
|
here too.
|
2009-08-25 19:55:48 +02:00
|
|
|
|
2015-08-11 17:24:07 +02:00
|
|
|
The __init__() method is also used to make the distinction between
|
|
|
|
being resumed from the Journal, or starting with a blank document.
|
2009-08-25 19:55:48 +02:00
|
|
|
|
2015-08-11 17:24:07 +02:00
|
|
|
2. Implement :func:`sugar3.activity.activity.Activity.read_file()` and
|
|
|
|
:func:`sugar3.activity.activity.Activity.write_file()`
|
|
|
|
Most activities revolve around creating and storing Journal entries.
|
|
|
|
For example, Write: You create a document, it is saved to the
|
|
|
|
Journal and then later you resume working on the document.
|
2009-08-25 19:55:48 +02:00
|
|
|
|
2015-08-11 17:24:07 +02:00
|
|
|
:func:`sugar3.activity.activity.Activity.read_file()` and
|
|
|
|
:func:`sugar3.activity.activity.Activity.write_file()`
|
|
|
|
will be called by sugar to tell your
|
|
|
|
Activity that it should load or save the document the user is
|
|
|
|
working on.
|
2009-08-25 19:55:48 +02:00
|
|
|
|
2007-10-28 16:56:05 +01:00
|
|
|
3. Implement our Activity Toolbars.
|
2009-08-25 19:55:48 +02:00
|
|
|
|
2015-08-11 17:24:07 +02:00
|
|
|
The Toolbars are added to your Activity in step 1 (the toolbox), but
|
|
|
|
you need to implement them somewhere. Now is a good time.
|
2009-08-25 19:55:48 +02:00
|
|
|
|
2015-08-11 17:24:07 +02:00
|
|
|
There are a number of standard Toolbars. The most basic one, the one
|
|
|
|
your almost absolutely MUST have is the ActivityToolbar. Without
|
|
|
|
this, you're not really making a proper Sugar Activity (which may be
|
|
|
|
okay, but you should really stop and think about why not!) You do
|
|
|
|
this with the ActivityToolbox(self) call in step 1.
|
2014-01-27 01:15:28 +01:00
|
|
|
|
2015-08-11 17:24:07 +02:00
|
|
|
Usually, you will also need the standard EditToolbar. This is the
|
|
|
|
one which has the standard copy and paste buttons. You need to
|
|
|
|
derive your own EditToolbar class from
|
|
|
|
:class:`sugar3.activity.widgets.EditToolbar`:
|
2009-08-25 19:55:48 +02:00
|
|
|
|
2015-08-11 17:24:07 +02:00
|
|
|
.. code-block:: python
|
2009-08-25 19:55:48 +02:00
|
|
|
|
2015-08-11 17:24:07 +02:00
|
|
|
from sugar3.activity.widgets import EditToolbar
|
|
|
|
|
|
|
|
class MyEditToolbar(EditToolbar):
|
|
|
|
...
|
|
|
|
|
|
|
|
See EditToolbar for the methods you should implement in your class.
|
|
|
|
|
|
|
|
Finaly, your Activity will very likely need some activity specific
|
|
|
|
buttons and options you can create your own toolbars by deriving a
|
|
|
|
class from :class:`Gtk.Toolbar`:
|
|
|
|
|
|
|
|
.. code-block:: python
|
|
|
|
|
|
|
|
class MySpecialToolbar(Gtk.Toolbar):
|
|
|
|
...
|
2009-08-25 19:55:48 +02:00
|
|
|
|
2007-10-28 16:56:05 +01:00
|
|
|
4. Use your creativity. Make your Activity something special and share
|
|
|
|
it with your friends!
|
2009-08-25 19:55:48 +02:00
|
|
|
|
2015-08-11 17:24:07 +02:00
|
|
|
Read through the methods of the Activity class below, to learn more
|
|
|
|
about how to make an Activity work.
|
2009-08-25 19:55:48 +02:00
|
|
|
|
2015-08-11 17:24:07 +02:00
|
|
|
Hint: A good and simple Activity to learn from is the Read activity.
|
|
|
|
To create your own activity, you may want to copy it and use it as a
|
|
|
|
template.
|
|
|
|
'''
|
2009-08-25 21:12:40 +02:00
|
|
|
|
2007-02-27 15:05:44 +01:00
|
|
|
__gtype_name__ = 'SugarActivity'
|
2007-04-27 22:07:38 +02:00
|
|
|
|
|
|
|
__gsignals__ = {
|
2011-11-15 19:29:07 +01:00
|
|
|
'shared': (GObject.SignalFlags.RUN_FIRST, None, ([])),
|
|
|
|
'joined': (GObject.SignalFlags.RUN_FIRST, None, ([])),
|
2011-06-20 17:48:51 +02:00
|
|
|
# For internal use only, use can_close() if you want to perform extra
|
|
|
|
# checks before actually closing
|
2011-11-15 19:29:07 +01:00
|
|
|
'_closing': (GObject.SignalFlags.RUN_FIRST, None, ([])),
|
2007-04-27 22:07:38 +02:00
|
|
|
}
|
|
|
|
|
2007-05-10 11:01:32 +02:00
|
|
|
def __init__(self, handle, create_jobject=True):
|
2015-08-11 17:24:07 +02:00
|
|
|
'''
|
|
|
|
Initialise the Activity
|
|
|
|
|
|
|
|
Args:
|
2009-08-25 19:55:48 +02:00
|
|
|
|
2015-08-11 17:24:07 +02:00
|
|
|
handle (sugar3.activity.activityhandle.ActivityHandle)
|
2009-08-25 19:55:48 +02:00
|
|
|
instance providing the activity id and access to the
|
|
|
|
presence service which *may* provide sharing for this
|
2007-04-10 04:47:37 +02:00
|
|
|
application
|
2015-08-11 17:24:07 +02:00
|
|
|
create_jobject (boolean)
|
2015-10-05 05:41:21 +02:00
|
|
|
DEPRECATED: define if it should create a journal object if we are
|
|
|
|
not resuming. The parameter is ignored, and always will
|
|
|
|
be created a object in the Journal.
|
2007-05-10 11:01:32 +02:00
|
|
|
|
2009-08-25 19:55:48 +02:00
|
|
|
Side effects:
|
|
|
|
|
|
|
|
Sets the gdk screen DPI setting (resolution) to the
|
2007-04-10 04:47:37 +02:00
|
|
|
Sugar screen resolution.
|
2009-08-25 19:55:48 +02:00
|
|
|
|
2007-04-10 04:47:37 +02:00
|
|
|
Connects our "destroy" message to our _destroy_cb
|
|
|
|
method.
|
2009-08-25 19:55:48 +02:00
|
|
|
|
2011-11-15 19:29:07 +01:00
|
|
|
Creates a base Gtk.Window within this window.
|
2009-08-25 19:55:48 +02:00
|
|
|
|
2007-04-10 04:47:37 +02:00
|
|
|
Creates an ActivityService (self._bus) servicing
|
|
|
|
this application.
|
2009-08-25 19:55:48 +02:00
|
|
|
|
|
|
|
Usage:
|
2007-10-28 16:56:05 +01:00
|
|
|
If your Activity implements __init__(), it should call
|
|
|
|
the base class __init()__ before doing Activity specific things.
|
2009-08-25 19:55:48 +02:00
|
|
|
|
2015-08-11 17:24:07 +02:00
|
|
|
'''
|
|
|
|
|
sugar-activity: import and make independent of sugar-toolkit GTK versions
As we move to adding support for a second UI toolkit (GTK+ 3.x),
the sugar-activity binary used by all activities must become
backend-toolkit-independent. It would be wasteful to have two backend
toolkits loaded in memory, and in the GTK2/GTK3 case, it is impossible
(importing both results in an instant crash).
To achieve this, we split the existing sugar-toolkit activity/main.py:main()
functionality into two parts, moving it into the sugar-activity binary and
the Activity class as follows:
1. All toolkit-specific stuff is moved into the Activity class (i.e.
everything that interacts with GTK)
2. Everything that can be reasonably/easily moved into the Activity class
is also moved.
3. What remains is the stuff that is inherently involved with the
construction of the Activity object, not related to UI toolkits. This
is moved into the sugar-activity binary.
main.py is then removed from sugar-toolkit, and sugar-activity is moved
from sugar to sugar-toolkit-gtk3 in order to keep toolkit-related code
with the toolkit itself.
With this work done, the one remaining question is how to invoke the main
loop. An optional run_main_loop() method is added to the activity class,
for GTK2 this will run the GTK2 main loop, for GTK3 the GTK3 main loop will
be run, etc.
Signed-off-by: Daniel Drake <dsd@laptop.org>
2011-12-13 20:47:33 +01:00
|
|
|
# Stuff that needs to be done early
|
|
|
|
icons_path = os.path.join(get_bundle_path(), 'icons')
|
|
|
|
Gtk.IconTheme.get_default().append_search_path(icons_path)
|
|
|
|
|
2011-12-07 19:52:25 +01:00
|
|
|
sugar_theme = 'sugar-72'
|
|
|
|
if 'SUGAR_SCALING' in os.environ:
|
|
|
|
if os.environ['SUGAR_SCALING'] == '100':
|
|
|
|
sugar_theme = 'sugar-100'
|
|
|
|
|
sugar-activity: import and make independent of sugar-toolkit GTK versions
As we move to adding support for a second UI toolkit (GTK+ 3.x),
the sugar-activity binary used by all activities must become
backend-toolkit-independent. It would be wasteful to have two backend
toolkits loaded in memory, and in the GTK2/GTK3 case, it is impossible
(importing both results in an instant crash).
To achieve this, we split the existing sugar-toolkit activity/main.py:main()
functionality into two parts, moving it into the sugar-activity binary and
the Activity class as follows:
1. All toolkit-specific stuff is moved into the Activity class (i.e.
everything that interacts with GTK)
2. Everything that can be reasonably/easily moved into the Activity class
is also moved.
3. What remains is the stuff that is inherently involved with the
construction of the Activity object, not related to UI toolkits. This
is moved into the sugar-activity binary.
main.py is then removed from sugar-toolkit, and sugar-activity is moved
from sugar to sugar-toolkit-gtk3 in order to keep toolkit-related code
with the toolkit itself.
With this work done, the one remaining question is how to invoke the main
loop. An optional run_main_loop() method is added to the activity class,
for GTK2 this will run the GTK2 main loop, for GTK3 the GTK3 main loop will
be run, etc.
Signed-off-by: Daniel Drake <dsd@laptop.org>
2011-12-13 20:47:33 +01:00
|
|
|
# This code can be removed when we grow an xsettings daemon (the GTK+
|
|
|
|
# init routines will then automatically figure out the font settings)
|
|
|
|
settings = Gtk.Settings.get_default()
|
2011-12-07 19:52:25 +01:00
|
|
|
settings.set_property('gtk-theme-name', sugar_theme)
|
2011-10-29 14:46:59 +02:00
|
|
|
settings.set_property('gtk-icon-theme-name', 'sugar')
|
sugar-activity: import and make independent of sugar-toolkit GTK versions
As we move to adding support for a second UI toolkit (GTK+ 3.x),
the sugar-activity binary used by all activities must become
backend-toolkit-independent. It would be wasteful to have two backend
toolkits loaded in memory, and in the GTK2/GTK3 case, it is impossible
(importing both results in an instant crash).
To achieve this, we split the existing sugar-toolkit activity/main.py:main()
functionality into two parts, moving it into the sugar-activity binary and
the Activity class as follows:
1. All toolkit-specific stuff is moved into the Activity class (i.e.
everything that interacts with GTK)
2. Everything that can be reasonably/easily moved into the Activity class
is also moved.
3. What remains is the stuff that is inherently involved with the
construction of the Activity object, not related to UI toolkits. This
is moved into the sugar-activity binary.
main.py is then removed from sugar-toolkit, and sugar-activity is moved
from sugar to sugar-toolkit-gtk3 in order to keep toolkit-related code
with the toolkit itself.
With this work done, the one remaining question is how to invoke the main
loop. An optional run_main_loop() method is added to the activity class,
for GTK2 this will run the GTK2 main loop, for GTK3 the GTK3 main loop will
be run, etc.
Signed-off-by: Daniel Drake <dsd@laptop.org>
2011-12-13 20:47:33 +01:00
|
|
|
settings.set_property('gtk-font-name',
|
|
|
|
'%s %f' % (style.FONT_FACE, style.FONT_SIZE))
|
|
|
|
|
2007-02-27 15:05:44 +01:00
|
|
|
Window.__init__(self)
|
2006-12-04 20:12:24 +01:00
|
|
|
|
2010-10-15 20:18:15 +02:00
|
|
|
if 'SUGAR_ACTIVITY_ROOT' in os.environ:
|
2009-09-01 10:11:59 +02:00
|
|
|
# If this activity runs inside Sugar, we want it to take all the
|
|
|
|
# screen. Would be better if it was the shell to do this, but we
|
2009-09-05 18:40:15 +02:00
|
|
|
# haven't found yet a good way to do it there. See #1263.
|
|
|
|
self.connect('window-state-event', self.__window_state_event_cb)
|
2011-11-15 19:29:07 +01:00
|
|
|
screen = Gdk.Screen.get_default()
|
2009-09-01 10:11:59 +02:00
|
|
|
screen.connect('size-changed', self.__screen_size_changed_cb)
|
|
|
|
self._adapt_window_to_screen()
|
|
|
|
|
2007-06-27 23:12:32 +02:00
|
|
|
# process titles will only show 15 characters
|
|
|
|
# but they get truncated anyway so if more characters
|
|
|
|
# are supported in the future we will get a better view
|
|
|
|
# of the processes
|
2010-10-15 21:14:59 +02:00
|
|
|
proc_title = '%s <%s>' % (get_bundle_name(), handle.activity_id)
|
2007-06-27 23:12:32 +02:00
|
|
|
util.set_proc_title(proc_title)
|
|
|
|
|
2007-10-16 15:51:48 +02:00
|
|
|
self.connect('realize', self.__realize_cb)
|
2007-10-15 23:47:02 +02:00
|
|
|
self.connect('delete-event', self.__delete_event_cb)
|
2006-12-04 20:12:24 +01:00
|
|
|
|
2007-05-16 21:30:49 +02:00
|
|
|
self._active = False
|
2014-06-06 17:12:39 +02:00
|
|
|
self._active_time = None
|
|
|
|
self._spent_time = 0
|
2007-02-22 00:57:49 +01:00
|
|
|
self._activity_id = handle.activity_id
|
2008-09-07 22:07:49 +02:00
|
|
|
self.shared_activity = None
|
2007-05-03 05:25:15 +02:00
|
|
|
self._join_id = None
|
2007-07-23 13:45:46 +02:00
|
|
|
self._updating_jobject = False
|
|
|
|
self._closing = False
|
2008-07-21 19:20:22 +02:00
|
|
|
self._quit_requested = False
|
2007-10-15 23:47:02 +02:00
|
|
|
self._deleting = False
|
2014-04-30 19:57:57 +02:00
|
|
|
self._max_participants = None
|
2007-09-11 19:59:40 +02:00
|
|
|
self._invites_queue = []
|
2008-06-26 16:20:27 +02:00
|
|
|
self._jobject = None
|
2009-03-27 12:26:57 +01:00
|
|
|
self._read_file_called = False
|
2007-05-03 05:25:15 +02:00
|
|
|
|
2008-08-06 23:04:00 +02:00
|
|
|
self._session = _get_session()
|
|
|
|
self._session.register(self)
|
|
|
|
self._session.connect('quit-requested',
|
|
|
|
self.__session_quit_requested_cb)
|
|
|
|
self._session.connect('quit', self.__session_quit_cb)
|
2008-06-06 19:13:10 +02:00
|
|
|
|
2011-11-15 19:29:07 +01:00
|
|
|
accel_group = Gtk.AccelGroup()
|
2012-06-04 17:45:30 +02:00
|
|
|
self.sugar_accel_group = accel_group
|
2008-04-01 11:52:11 +02:00
|
|
|
self.add_accel_group(accel_group)
|
|
|
|
|
2007-02-21 20:15:39 +01:00
|
|
|
self._bus = ActivityService(self)
|
2007-07-20 19:50:49 +02:00
|
|
|
self._owns_file = False
|
2006-12-04 20:12:24 +01:00
|
|
|
|
2007-09-01 19:07:49 +02:00
|
|
|
share_scope = SCOPE_PRIVATE
|
|
|
|
|
2007-05-10 11:01:32 +02:00
|
|
|
if handle.object_id:
|
2009-08-25 19:55:48 +02:00
|
|
|
self._jobject = datastore.get(handle.object_id)
|
|
|
|
|
2010-10-15 20:18:15 +02:00
|
|
|
if 'share-scope' in self._jobject.metadata:
|
2008-04-19 11:10:03 +02:00
|
|
|
share_scope = self._jobject.metadata['share-scope']
|
2007-08-28 23:07:57 +02:00
|
|
|
|
2012-10-04 14:38:45 +02:00
|
|
|
if 'launch-times' in self._jobject.metadata:
|
|
|
|
self._jobject.metadata['launch-times'] += ', %d' % \
|
|
|
|
int(time.time())
|
|
|
|
else:
|
|
|
|
self._jobject.metadata['launch-times'] = \
|
|
|
|
str(int(time.time()))
|
|
|
|
|
2014-06-06 17:12:39 +02:00
|
|
|
if 'spent-times' in self._jobject.metadata:
|
|
|
|
self._jobject.metadata['spent-times'] += ', 0'
|
|
|
|
else:
|
|
|
|
self._jobject.metadata['spent-times'] = '0'
|
|
|
|
|
2010-07-15 10:50:05 +02:00
|
|
|
self.shared_activity = None
|
|
|
|
self._join_id = None
|
|
|
|
|
2015-10-05 05:41:21 +02:00
|
|
|
if handle.object_id is None:
|
2011-07-24 15:16:40 +02:00
|
|
|
logging.debug('Creating a jobject.')
|
|
|
|
self._jobject = self._initialize_journal_object()
|
|
|
|
|
2010-08-16 17:27:10 +02:00
|
|
|
if handle.invited:
|
2011-11-15 19:29:07 +01:00
|
|
|
wait_loop = GObject.MainLoop()
|
2010-07-15 10:50:05 +02:00
|
|
|
self._client_handler = _ClientHandler(
|
2013-05-17 07:16:36 +02:00
|
|
|
self.get_bundle_id(),
|
|
|
|
partial(self.__got_channel_cb, wait_loop))
|
2010-08-17 12:00:45 +02:00
|
|
|
# FIXME: The current API requires that self.shared_activity is set
|
|
|
|
# before exiting from __init__, so we wait until we have got the
|
|
|
|
# shared activity. http://bugs.sugarlabs.org/ticket/2168
|
2010-07-15 10:50:05 +02:00
|
|
|
wait_loop.run()
|
|
|
|
else:
|
|
|
|
pservice = presenceservice.get_instance()
|
|
|
|
mesh_instance = pservice.get_activity(self._activity_id,
|
|
|
|
warn_if_none=False)
|
|
|
|
self._set_up_sharing(mesh_instance, share_scope)
|
|
|
|
|
2011-07-24 15:16:40 +02:00
|
|
|
if self.shared_activity is not None:
|
|
|
|
self._jobject.metadata['title'] = self.shared_activity.props.name
|
|
|
|
self._jobject.metadata['icon-color'] = \
|
|
|
|
self.shared_activity.props.color
|
2011-08-18 17:17:00 +02:00
|
|
|
else:
|
2011-07-24 19:19:04 +02:00
|
|
|
self._jobject.metadata.connect('updated',
|
|
|
|
self.__jobject_updated_cb)
|
2011-09-19 15:46:39 +02:00
|
|
|
self.set_title(self._jobject.metadata['title'])
|
2010-08-17 12:00:45 +02:00
|
|
|
|
2016-04-17 07:57:07 +02:00
|
|
|
if 'SUGAR_VERSION' not in os.environ:
|
|
|
|
bundle = get_bundle_instance(get_bundle_path())
|
|
|
|
self.set_icon_from_file(bundle.get_icon())
|
|
|
|
|
|
|
|
|
sugar-activity: import and make independent of sugar-toolkit GTK versions
As we move to adding support for a second UI toolkit (GTK+ 3.x),
the sugar-activity binary used by all activities must become
backend-toolkit-independent. It would be wasteful to have two backend
toolkits loaded in memory, and in the GTK2/GTK3 case, it is impossible
(importing both results in an instant crash).
To achieve this, we split the existing sugar-toolkit activity/main.py:main()
functionality into two parts, moving it into the sugar-activity binary and
the Activity class as follows:
1. All toolkit-specific stuff is moved into the Activity class (i.e.
everything that interacts with GTK)
2. Everything that can be reasonably/easily moved into the Activity class
is also moved.
3. What remains is the stuff that is inherently involved with the
construction of the Activity object, not related to UI toolkits. This
is moved into the sugar-activity binary.
main.py is then removed from sugar-toolkit, and sugar-activity is moved
from sugar to sugar-toolkit-gtk3 in order to keep toolkit-related code
with the toolkit itself.
With this work done, the one remaining question is how to invoke the main
loop. An optional run_main_loop() method is added to the activity class,
for GTK2 this will run the GTK2 main loop, for GTK3 the GTK3 main loop will
be run, etc.
Signed-off-by: Daniel Drake <dsd@laptop.org>
2011-12-13 20:47:33 +01:00
|
|
|
def run_main_loop(self):
|
|
|
|
Gtk.main()
|
|
|
|
|
2010-08-17 12:00:45 +02:00
|
|
|
def _initialize_journal_object(self):
|
|
|
|
title = _('%s Activity') % get_bundle_name()
|
2016-04-17 07:57:07 +02:00
|
|
|
|
|
|
|
icon_color = get_color().to_string()
|
2010-08-17 12:00:45 +02:00
|
|
|
|
|
|
|
jobject = datastore.create()
|
|
|
|
jobject.metadata['title'] = title
|
|
|
|
jobject.metadata['title_set_by_user'] = '0'
|
|
|
|
jobject.metadata['activity'] = self.get_bundle_id()
|
|
|
|
jobject.metadata['activity_id'] = self.get_id()
|
|
|
|
jobject.metadata['keep'] = '0'
|
|
|
|
jobject.metadata['preview'] = ''
|
|
|
|
jobject.metadata['share-scope'] = SCOPE_PRIVATE
|
|
|
|
jobject.metadata['icon-color'] = icon_color
|
2012-10-04 14:38:45 +02:00
|
|
|
jobject.metadata['launch-times'] = str(int(time.time()))
|
2014-06-06 17:12:39 +02:00
|
|
|
jobject.metadata['spent-times'] = '0'
|
2010-08-17 12:00:45 +02:00
|
|
|
jobject.file_path = ''
|
|
|
|
|
|
|
|
# FIXME: We should be able to get an ID synchronously from the DS,
|
|
|
|
# then call async the actual create.
|
|
|
|
# http://bugs.sugarlabs.org/ticket/2169
|
|
|
|
datastore.write(jobject)
|
|
|
|
|
|
|
|
return jobject
|
2010-07-15 10:50:05 +02:00
|
|
|
|
2011-07-24 18:42:48 +02:00
|
|
|
def __jobject_updated_cb(self, jobject):
|
|
|
|
if self.get_title() == jobject['title']:
|
|
|
|
return
|
|
|
|
self.set_title(jobject['title'])
|
|
|
|
|
2010-07-15 10:50:05 +02:00
|
|
|
def _set_up_sharing(self, mesh_instance, share_scope):
|
2007-09-01 19:07:49 +02:00
|
|
|
# handle activity share/join
|
2013-12-25 10:14:10 +01:00
|
|
|
logging.debug('*** Act %s, mesh instance %r, scope %s' %
|
2014-03-29 20:25:34 +01:00
|
|
|
(self._activity_id, mesh_instance, share_scope))
|
2007-10-17 13:53:24 +02:00
|
|
|
if mesh_instance is not None:
|
2007-09-01 19:07:49 +02:00
|
|
|
# There's already an instance on the mesh, join it
|
2013-12-25 10:14:10 +01:00
|
|
|
logging.debug('*** Act %s joining existing mesh instance %r' %
|
2014-03-29 20:25:34 +01:00
|
|
|
(self._activity_id, mesh_instance))
|
2008-09-07 22:07:49 +02:00
|
|
|
self.shared_activity = mesh_instance
|
|
|
|
self.shared_activity.connect('notify::private',
|
|
|
|
self.__privacy_changed_cb)
|
2010-10-15 21:14:59 +02:00
|
|
|
self._join_id = self.shared_activity.connect('joined',
|
2008-09-07 23:57:27 +02:00
|
|
|
self.__joined_cb)
|
2008-09-07 22:07:49 +02:00
|
|
|
if not self.shared_activity.props.joined:
|
|
|
|
self.shared_activity.join()
|
2007-09-01 19:07:49 +02:00
|
|
|
else:
|
2008-09-07 22:07:49 +02:00
|
|
|
self.__joined_cb(self.shared_activity, True, None)
|
2007-09-01 19:07:49 +02:00
|
|
|
elif share_scope != SCOPE_PRIVATE:
|
2009-08-24 12:54:02 +02:00
|
|
|
logging.debug('*** Act %s no existing mesh instance, but used to '
|
2013-12-25 10:14:10 +01:00
|
|
|
'be shared, will share' % self._activity_id)
|
2007-09-01 19:07:49 +02:00
|
|
|
# no existing mesh instance, but activity used to be shared, so
|
|
|
|
# restart the share
|
|
|
|
if share_scope == SCOPE_INVITE_ONLY:
|
|
|
|
self.share(private=True)
|
|
|
|
elif share_scope == SCOPE_NEIGHBORHOOD:
|
|
|
|
self.share(private=False)
|
|
|
|
else:
|
2013-12-25 10:14:10 +01:00
|
|
|
logging.debug('Unknown share scope %r' % share_scope)
|
2007-09-01 19:07:49 +02:00
|
|
|
|
2011-06-09 16:53:18 +02:00
|
|
|
def __got_channel_cb(self, wait_loop, connection_path, channel_path,
|
|
|
|
handle_type):
|
2010-07-15 10:50:05 +02:00
|
|
|
logging.debug('Activity.__got_channel_cb')
|
2011-06-09 16:53:18 +02:00
|
|
|
pservice = presenceservice.get_instance()
|
2008-06-26 16:20:27 +02:00
|
|
|
|
2011-06-09 16:53:18 +02:00
|
|
|
if handle_type == CONNECTION_HANDLE_TYPE_ROOM:
|
|
|
|
connection_name = connection_path.replace('/', '.')[1:]
|
|
|
|
bus = dbus.SessionBus()
|
|
|
|
channel = bus.get_object(connection_name, channel_path)
|
|
|
|
room_handle = channel.Get(CHANNEL, 'TargetHandle')
|
|
|
|
mesh_instance = pservice.get_activity_by_handle(connection_path,
|
|
|
|
room_handle)
|
|
|
|
else:
|
|
|
|
mesh_instance = pservice.get_activity(self._activity_id,
|
|
|
|
warn_if_none=False)
|
2010-07-15 10:50:05 +02:00
|
|
|
|
|
|
|
self._set_up_sharing(mesh_instance, SCOPE_PRIVATE)
|
|
|
|
wait_loop.quit()
|
2008-06-26 16:20:27 +02:00
|
|
|
|
2008-08-11 01:10:02 +02:00
|
|
|
def get_active(self):
|
|
|
|
return self._active
|
2007-05-16 21:30:49 +02:00
|
|
|
|
2014-06-06 17:12:39 +02:00
|
|
|
def _update_spent_time(self):
|
|
|
|
if self._active is True and self._active_time is None:
|
|
|
|
self._active_time = time.time()
|
|
|
|
elif self._active is False and self._active_time is not None:
|
|
|
|
self._spent_time += time.time() - self._active_time
|
|
|
|
self._active_time = None
|
|
|
|
elif self._active is True and self._active_time is not None:
|
|
|
|
current = time.time()
|
|
|
|
self._spent_time += current - self._active_time
|
|
|
|
self._active_time = current
|
|
|
|
|
2008-08-11 01:10:02 +02:00
|
|
|
def set_active(self, active):
|
|
|
|
if self._active != active:
|
|
|
|
self._active = active
|
2014-06-06 17:12:39 +02:00
|
|
|
self._update_spent_time()
|
2008-08-11 01:10:02 +02:00
|
|
|
if not self._active and self._jobject:
|
|
|
|
self.save()
|
|
|
|
|
2011-11-15 19:29:07 +01:00
|
|
|
active = GObject.property(
|
2008-08-11 01:10:02 +02:00
|
|
|
type=bool, default=False, getter=get_active, setter=set_active)
|
|
|
|
|
|
|
|
def get_max_participants(self):
|
2015-08-11 17:24:07 +02:00
|
|
|
'''
|
|
|
|
Returns:
|
|
|
|
int: the max number of users than can share a instance of the
|
|
|
|
activity. Should be configured in the activity.info file.
|
|
|
|
'''
|
2014-04-30 19:57:57 +02:00
|
|
|
# If max_participants has not been set in the activity, get it
|
|
|
|
# from the bundle.
|
|
|
|
if self._max_participants is None:
|
|
|
|
bundle = get_bundle_instance(get_bundle_path())
|
|
|
|
self._max_participants = bundle.get_max_participants()
|
2008-08-11 01:10:02 +02:00
|
|
|
return self._max_participants
|
|
|
|
|
|
|
|
def set_max_participants(self, participants):
|
|
|
|
self._max_participants = participants
|
|
|
|
|
2011-11-15 19:29:07 +01:00
|
|
|
max_participants = GObject.property(
|
2013-05-17 07:16:36 +02:00
|
|
|
type=int, default=0, getter=get_max_participants,
|
|
|
|
setter=set_max_participants)
|
2007-05-16 21:30:49 +02:00
|
|
|
|
2007-06-03 22:12:47 +02:00
|
|
|
def get_id(self):
|
2015-08-11 17:24:07 +02:00
|
|
|
'''
|
|
|
|
Returns:
|
|
|
|
|
|
|
|
int: the activity id of the current instance of your activity.
|
|
|
|
|
|
|
|
The activity id is sort-of-like the unix process id (PID). However,
|
2015-10-05 05:41:21 +02:00
|
|
|
unlike PIDs it is only different for each new instance
|
|
|
|
and stays the same everytime a user
|
2015-08-11 17:24:07 +02:00
|
|
|
resumes an activity. This is also the identity of your Activity to
|
|
|
|
other XOs for use when sharing.
|
|
|
|
'''
|
2007-06-03 22:12:47 +02:00
|
|
|
return self._activity_id
|
|
|
|
|
2007-10-09 13:15:06 +02:00
|
|
|
def get_bundle_id(self):
|
2015-08-11 17:24:07 +02:00
|
|
|
'''
|
|
|
|
Returns:
|
|
|
|
int: the bundle_id from the activity.info file
|
|
|
|
'''
|
2007-10-16 14:29:38 +02:00
|
|
|
return os.environ['SUGAR_BUNDLE_ID']
|
2007-06-03 22:12:47 +02:00
|
|
|
|
2010-03-08 11:55:07 +01:00
|
|
|
def get_canvas(self):
|
2015-08-11 17:24:07 +02:00
|
|
|
'''
|
|
|
|
Returns:
|
|
|
|
:class:`Gtk.Widget`: the widget used as canvas
|
|
|
|
'''
|
2010-03-08 11:55:07 +01:00
|
|
|
return Window.get_canvas(self)
|
|
|
|
|
2007-05-29 15:53:58 +02:00
|
|
|
def set_canvas(self, canvas):
|
2015-08-11 17:24:07 +02:00
|
|
|
'''
|
|
|
|
Sets the 'work area' of your activity with the canvas of your choice.
|
2009-08-25 19:55:48 +02:00
|
|
|
|
2011-11-15 19:29:07 +01:00
|
|
|
One commonly used canvas is Gtk.ScrolledWindow
|
2015-08-11 17:24:07 +02:00
|
|
|
|
|
|
|
Args:
|
|
|
|
canvas (:class:`Gtk.Widget`): the widget used as canvas
|
|
|
|
'''
|
|
|
|
|
2007-05-29 15:53:58 +02:00
|
|
|
Window.set_canvas(self, canvas)
|
2009-03-27 12:26:57 +01:00
|
|
|
if not self._read_file_called:
|
|
|
|
canvas.connect('map', self.__canvas_map_cb)
|
2007-05-29 15:53:58 +02:00
|
|
|
|
2010-03-08 11:55:07 +01:00
|
|
|
canvas = property(get_canvas, set_canvas)
|
|
|
|
|
2009-09-01 10:11:59 +02:00
|
|
|
def __screen_size_changed_cb(self, screen):
|
|
|
|
self._adapt_window_to_screen()
|
|
|
|
|
2009-09-05 18:40:15 +02:00
|
|
|
def __window_state_event_cb(self, window, event):
|
|
|
|
self.move(0, 0)
|
|
|
|
|
2009-09-01 10:11:59 +02:00
|
|
|
def _adapt_window_to_screen(self):
|
2011-11-15 19:29:07 +01:00
|
|
|
screen = Gdk.Screen.get_default()
|
2016-04-17 07:57:07 +02:00
|
|
|
workarea = screen.get_monitor_workarea(screen.get_number())
|
2011-10-29 12:20:30 +02:00
|
|
|
geometry = Gdk.Geometry()
|
|
|
|
geometry.max_width = geometry.base_width = geometry.min_width = \
|
2016-04-17 07:57:07 +02:00
|
|
|
workarea.width
|
2011-10-29 12:20:30 +02:00
|
|
|
geometry.max_height = geometry.base_height = geometry.min_height = \
|
2016-04-17 07:57:07 +02:00
|
|
|
workarea.height
|
2011-10-29 12:20:30 +02:00
|
|
|
geometry.width_inc = geometry.height_inc = geometry.min_aspect = \
|
|
|
|
geometry.max_aspect = 1
|
|
|
|
hints = Gdk.WindowHints(Gdk.WindowHints.ASPECT |
|
|
|
|
Gdk.WindowHints.BASE_SIZE |
|
|
|
|
Gdk.WindowHints.MAX_SIZE |
|
|
|
|
Gdk.WindowHints.MIN_SIZE)
|
|
|
|
self.set_geometry_hints(None, geometry, hints)
|
2009-09-01 10:11:59 +02:00
|
|
|
|
2008-08-06 23:04:00 +02:00
|
|
|
def __session_quit_requested_cb(self, session):
|
2008-07-21 19:20:22 +02:00
|
|
|
self._quit_requested = True
|
|
|
|
|
2009-09-29 20:33:13 +02:00
|
|
|
if self._prepare_close() and not self._updating_jobject:
|
2008-08-06 23:04:00 +02:00
|
|
|
session.will_quit(self, True)
|
2008-06-06 19:13:10 +02:00
|
|
|
|
2008-08-06 23:04:00 +02:00
|
|
|
def __session_quit_cb(self, client):
|
2008-07-21 19:20:22 +02:00
|
|
|
self._complete_close()
|
2008-06-06 19:13:10 +02:00
|
|
|
|
2009-03-27 12:14:42 +01:00
|
|
|
def __canvas_map_cb(self, canvas):
|
2009-03-27 12:26:57 +01:00
|
|
|
logging.debug('Activity.__canvas_map_cb')
|
|
|
|
if self._jobject and self._jobject.file_path and \
|
|
|
|
not self._read_file_called:
|
2007-05-29 15:53:58 +02:00
|
|
|
self.read_file(self._jobject.file_path)
|
2009-03-27 12:26:57 +01:00
|
|
|
self._read_file_called = True
|
|
|
|
canvas.disconnect_by_func(self.__canvas_map_cb)
|
2007-05-29 15:53:58 +02:00
|
|
|
|
2007-10-16 15:51:48 +02:00
|
|
|
def __jobject_create_cb(self):
|
2007-05-16 06:41:45 +02:00
|
|
|
pass
|
|
|
|
|
2007-10-16 15:51:48 +02:00
|
|
|
def __jobject_error_cb(self, err):
|
2013-12-25 10:14:10 +01:00
|
|
|
logging.debug('Error creating activity datastore object: %s' % err)
|
2007-05-16 06:41:45 +02:00
|
|
|
|
2007-08-13 21:14:25 +02:00
|
|
|
def get_activity_root(self):
|
2015-08-11 17:24:07 +02:00
|
|
|
'''
|
|
|
|
Deprecated. This part of the API has been moved
|
2007-12-03 22:10:14 +01:00
|
|
|
out of this class to the module itself
|
|
|
|
|
2015-08-11 17:24:07 +02:00
|
|
|
Returns:
|
|
|
|
str: a path for saving Activity specific preferences, etc.
|
2009-08-25 19:55:48 +02:00
|
|
|
|
2007-10-28 16:56:05 +01:00
|
|
|
Returns a path to the location in the filesystem where the activity can
|
|
|
|
store activity related data that doesn't pertain to the current
|
|
|
|
execution of the activity and thus cannot go into the DataStore.
|
2009-08-25 19:55:48 +02:00
|
|
|
|
2008-04-19 11:10:03 +02:00
|
|
|
Currently, this will return something like
|
|
|
|
~/.sugar/default/MyActivityName/
|
2009-08-25 19:55:48 +02:00
|
|
|
|
2007-10-28 16:56:05 +01:00
|
|
|
Activities should ONLY save settings, user preferences and other data
|
2009-08-25 21:12:40 +02:00
|
|
|
which isn't specific to a journal item here. If (meta-)data is in
|
|
|
|
anyway specific to a journal entry, it MUST be stored in the DataStore.
|
2015-08-11 17:24:07 +02:00
|
|
|
'''
|
2010-10-15 20:18:15 +02:00
|
|
|
if os.environ.get('SUGAR_ACTIVITY_ROOT'):
|
2007-08-13 21:14:25 +02:00
|
|
|
return os.environ['SUGAR_ACTIVITY_ROOT']
|
|
|
|
else:
|
2016-04-17 07:57:07 +02:00
|
|
|
return get_activity_root()
|
2007-08-13 21:14:25 +02:00
|
|
|
|
2007-05-29 15:53:58 +02:00
|
|
|
def read_file(self, file_path):
|
2015-08-11 17:24:07 +02:00
|
|
|
'''
|
2007-05-10 11:01:32 +02:00
|
|
|
Subclasses implement this method if they support resuming objects from
|
2007-05-29 15:53:58 +02:00
|
|
|
the journal. 'file_path' is the file to read from.
|
2009-08-25 19:55:48 +02:00
|
|
|
|
2007-10-28 16:56:05 +01:00
|
|
|
You should immediately open the file from the file_path, because the
|
|
|
|
file_name will be deleted immediately after returning from read_file().
|
|
|
|
Once the file has been opened, you do not have to read it immediately:
|
|
|
|
After you have opened it, the file will only be really gone when you
|
|
|
|
close it.
|
2009-08-25 19:55:48 +02:00
|
|
|
|
2007-10-28 16:56:05 +01:00
|
|
|
Although not required, this is also a good time to read all meta-data:
|
2009-08-25 21:12:40 +02:00
|
|
|
the file itself cannot be changed externally, but the title,
|
|
|
|
description and other metadata['tags'] may change. So if it is
|
|
|
|
important for you to notice changes, this is the time to record the
|
|
|
|
originals.
|
2015-08-11 17:24:07 +02:00
|
|
|
|
|
|
|
Args:
|
|
|
|
str: the file path to read
|
|
|
|
'''
|
2007-05-10 11:01:32 +02:00
|
|
|
raise NotImplementedError
|
|
|
|
|
2007-05-29 15:53:58 +02:00
|
|
|
def write_file(self, file_path):
|
2015-08-11 17:24:07 +02:00
|
|
|
'''
|
2007-05-10 11:01:32 +02:00
|
|
|
Subclasses implement this method if they support saving data to objects
|
2007-05-29 15:53:58 +02:00
|
|
|
in the journal. 'file_path' is the file to write to.
|
2009-08-25 19:55:48 +02:00
|
|
|
|
2007-10-28 16:56:05 +01:00
|
|
|
If the user did make changes, you should create the file_path and save
|
|
|
|
all document data to it.
|
2009-08-25 19:55:48 +02:00
|
|
|
|
2007-10-28 16:56:05 +01:00
|
|
|
Additionally, you should also write any metadata needed to resume your
|
2009-08-25 21:12:40 +02:00
|
|
|
activity. For example, the Read activity saves the current page and
|
|
|
|
zoom level, so it can display the page.
|
2009-08-25 19:55:48 +02:00
|
|
|
|
2007-10-28 16:56:05 +01:00
|
|
|
Note: Currently, the file_path *WILL* be different from the one you
|
2009-08-25 21:12:40 +02:00
|
|
|
received in file_read(). Even if you kept the file_path from
|
|
|
|
file_read() open until now, you must still write the entire file to
|
|
|
|
this file_path.
|
2015-08-11 17:24:07 +02:00
|
|
|
|
|
|
|
Args:
|
|
|
|
file_path (str): complete path of the file to write
|
|
|
|
'''
|
2007-05-10 11:01:32 +02:00
|
|
|
raise NotImplementedError
|
|
|
|
|
2014-03-08 01:12:44 +01:00
|
|
|
def notify_user(self, summary, body):
|
2015-08-11 17:24:07 +02:00
|
|
|
'''
|
2014-03-08 01:12:44 +01:00
|
|
|
Display a notification with the given summary and body.
|
|
|
|
The notification will go under the activities icon in the frame.
|
2015-08-11 17:24:07 +02:00
|
|
|
'''
|
2014-04-30 19:57:57 +02:00
|
|
|
bundle = get_bundle_instance(get_bundle_path())
|
2014-03-08 01:12:44 +01:00
|
|
|
icon = bundle.get_icon()
|
|
|
|
|
|
|
|
bus = dbus.SessionBus()
|
|
|
|
notify_obj = bus.get_object(N_BUS_NAME, N_OBJ_PATH)
|
|
|
|
notifications = dbus.Interface(notify_obj, N_IFACE_NAME)
|
|
|
|
|
|
|
|
notifications.Notify(self.get_id(), 0, '', summary, body, [],
|
|
|
|
{'x-sugar-icon-file-name': icon}, -1)
|
|
|
|
|
2007-10-16 15:51:48 +02:00
|
|
|
def __save_cb(self):
|
|
|
|
logging.debug('Activity.__save_cb')
|
2007-07-23 13:45:46 +02:00
|
|
|
self._updating_jobject = False
|
2008-07-21 19:20:22 +02:00
|
|
|
if self._quit_requested:
|
2008-08-06 23:04:00 +02:00
|
|
|
self._session.will_quit(self, True)
|
2008-07-21 19:20:22 +02:00
|
|
|
elif self._closing:
|
|
|
|
self._complete_close()
|
2007-05-16 06:41:45 +02:00
|
|
|
|
2007-10-16 15:51:48 +02:00
|
|
|
def __save_error_cb(self, err):
|
|
|
|
logging.debug('Activity.__save_error_cb')
|
2007-07-23 13:45:46 +02:00
|
|
|
self._updating_jobject = False
|
2008-07-21 19:20:22 +02:00
|
|
|
if self._quit_requested:
|
2008-08-06 23:04:00 +02:00
|
|
|
self._session.will_quit(self, False)
|
2007-07-23 13:45:46 +02:00
|
|
|
if self._closing:
|
2008-07-21 19:20:22 +02:00
|
|
|
self._show_keep_failed_dialog()
|
|
|
|
self._closing = False
|
2013-12-25 10:14:10 +01:00
|
|
|
raise RuntimeError('Error saving activity object to datastore: %s' %
|
2010-10-15 20:04:34 +02:00
|
|
|
err)
|
2007-05-16 06:41:45 +02:00
|
|
|
|
2007-07-23 13:45:46 +02:00
|
|
|
def _cleanup_jobject(self):
|
|
|
|
if self._jobject:
|
|
|
|
if self._owns_file and os.path.isfile(self._jobject.file_path):
|
2013-12-25 10:14:10 +01:00
|
|
|
logging.debug('_cleanup_jobject: removing %r' %
|
2013-05-17 07:16:36 +02:00
|
|
|
self._jobject.file_path)
|
2007-07-23 13:45:46 +02:00
|
|
|
os.remove(self._jobject.file_path)
|
|
|
|
self._owns_file = False
|
|
|
|
self._jobject.destroy()
|
|
|
|
self._jobject = None
|
|
|
|
|
2009-02-25 16:09:06 +01:00
|
|
|
def get_preview(self):
|
2015-08-11 17:24:07 +02:00
|
|
|
'''
|
|
|
|
Returns:
|
|
|
|
str: with data ready to save with an image representing the state
|
|
|
|
of the activity. Generally this is what the user is seeing in
|
|
|
|
this moment.
|
2008-11-11 17:34:34 +01:00
|
|
|
|
2009-02-25 16:09:06 +01:00
|
|
|
Activities can override this method, which should return a str with the
|
2013-02-04 15:47:04 +01:00
|
|
|
binary content of a png image with a width of PREVIEW_SIZE pixels.
|
2012-03-14 17:37:23 +01:00
|
|
|
|
|
|
|
The method does create a cairo surface similar to that of the canvas'
|
|
|
|
window and draws on that. Then we create a cairo image surface with
|
|
|
|
the desired preview size and scale the canvas surface on that.
|
2015-08-11 17:24:07 +02:00
|
|
|
'''
|
2012-03-14 17:37:23 +01:00
|
|
|
if self.canvas is None or not hasattr(self.canvas, 'get_window'):
|
2007-07-11 11:02:43 +02:00
|
|
|
return None
|
2007-06-15 18:03:17 +02:00
|
|
|
|
2012-03-14 17:37:23 +01:00
|
|
|
window = self.canvas.get_window()
|
|
|
|
alloc = self.canvas.get_allocation()
|
|
|
|
|
|
|
|
dummy_cr = Gdk.cairo_create(window)
|
|
|
|
target = dummy_cr.get_target()
|
|
|
|
canvas_width, canvas_height = alloc.width, alloc.height
|
|
|
|
screenshot_surface = target.create_similar(cairo.CONTENT_COLOR,
|
|
|
|
canvas_width, canvas_height)
|
|
|
|
del dummy_cr, target
|
|
|
|
|
|
|
|
cr = cairo.Context(screenshot_surface)
|
|
|
|
r, g, b, a_ = style.COLOR_PANEL_GREY.get_rgba()
|
|
|
|
cr.set_source_rgb(r, g, b)
|
|
|
|
cr.paint()
|
|
|
|
self.canvas.draw(cr)
|
|
|
|
del cr
|
|
|
|
|
2013-02-04 15:47:04 +01:00
|
|
|
preview_width, preview_height = PREVIEW_SIZE
|
2012-03-14 17:37:23 +01:00
|
|
|
preview_surface = cairo.ImageSurface(cairo.FORMAT_ARGB32,
|
|
|
|
preview_width, preview_height)
|
|
|
|
cr = cairo.Context(preview_surface)
|
|
|
|
|
|
|
|
scale_w = preview_width * 1.0 / canvas_width
|
|
|
|
scale_h = preview_height * 1.0 / canvas_height
|
|
|
|
scale = min(scale_w, scale_h)
|
|
|
|
|
|
|
|
translate_x = int((preview_width - (canvas_width * scale)) / 2)
|
|
|
|
translate_y = int((preview_height - (canvas_height * scale)) / 2)
|
|
|
|
|
|
|
|
cr.translate(translate_x, translate_y)
|
|
|
|
cr.scale(scale, scale)
|
|
|
|
|
|
|
|
cr.set_source_rgba(1, 1, 1, 0)
|
|
|
|
cr.set_operator(cairo.OPERATOR_SOURCE)
|
|
|
|
cr.paint()
|
|
|
|
cr.set_source_surface(screenshot_surface)
|
|
|
|
cr.paint()
|
|
|
|
|
|
|
|
preview_str = StringIO.StringIO()
|
|
|
|
preview_surface.write_to_png(preview_str)
|
|
|
|
return preview_str.getvalue()
|
2007-06-29 20:24:22 +02:00
|
|
|
|
|
|
|
def _get_buddies(self):
|
2008-09-07 22:07:49 +02:00
|
|
|
if self.shared_activity is not None:
|
2007-08-21 12:12:13 +02:00
|
|
|
buddies = {}
|
2008-09-07 22:07:49 +02:00
|
|
|
for buddy in self.shared_activity.get_joined_buddies():
|
2007-08-21 12:12:13 +02:00
|
|
|
if not buddy.props.owner:
|
|
|
|
buddy_id = sha1(buddy.props.key).hexdigest()
|
|
|
|
buddies[buddy_id] = [buddy.props.nick, buddy.props.color]
|
|
|
|
return buddies
|
|
|
|
else:
|
|
|
|
return {}
|
2007-06-29 20:24:22 +02:00
|
|
|
|
|
|
|
def save(self):
|
2015-08-11 17:24:07 +02:00
|
|
|
'''
|
|
|
|
Request that the activity is saved to the Journal.
|
2009-08-25 19:55:48 +02:00
|
|
|
|
2007-10-28 16:56:05 +01:00
|
|
|
This method is called by the close() method below. In general,
|
|
|
|
activities should not override this method. This method is part of the
|
|
|
|
public API of an Acivity, and should behave in standard ways. Use your
|
2009-08-25 19:55:48 +02:00
|
|
|
own implementation of write_file() to save your Activity specific data.
|
2015-08-11 17:24:07 +02:00
|
|
|
'''
|
2007-07-23 13:45:46 +02:00
|
|
|
|
2008-07-21 19:20:22 +02:00
|
|
|
if self._jobject is None:
|
|
|
|
logging.debug('Cannot save, no journal object.')
|
|
|
|
return
|
|
|
|
|
2013-12-25 10:14:10 +01:00
|
|
|
logging.debug('Activity.save: %r' % self._jobject.object_id)
|
2007-08-31 15:43:38 +02:00
|
|
|
|
2007-07-23 13:45:46 +02:00
|
|
|
if self._updating_jobject:
|
2007-09-10 17:58:01 +02:00
|
|
|
logging.info('Activity.save: still processing a previous request.')
|
2007-07-23 13:45:46 +02:00
|
|
|
return
|
|
|
|
|
2007-08-21 12:12:13 +02:00
|
|
|
buddies_dict = self._get_buddies()
|
|
|
|
if buddies_dict:
|
2012-03-22 17:58:07 +01:00
|
|
|
self.metadata['buddies_id'] = json.dumps(buddies_dict.keys())
|
|
|
|
self.metadata['buddies'] = json.dumps(self._get_buddies())
|
2007-08-21 12:12:13 +02:00
|
|
|
|
2014-06-06 17:12:39 +02:00
|
|
|
# update spent time before saving
|
|
|
|
self._update_spent_time()
|
|
|
|
|
|
|
|
def set_last_value(values_list, new_value):
|
|
|
|
if ', ' not in values_list:
|
|
|
|
return '%d' % new_value
|
|
|
|
else:
|
|
|
|
partial_list = ', '.join(values_list.split(', ')[:-1])
|
|
|
|
return partial_list + ', %d' % new_value
|
|
|
|
|
|
|
|
self.metadata['spent-times'] = set_last_value(
|
|
|
|
self.metadata['spent-times'], self._spent_time)
|
|
|
|
|
2009-02-25 16:09:06 +01:00
|
|
|
preview = self.get_preview()
|
2008-11-11 17:34:34 +01:00
|
|
|
if preview is not None:
|
2007-11-04 17:00:48 +01:00
|
|
|
self.metadata['preview'] = dbus.ByteArray(preview)
|
2007-08-21 12:12:13 +02:00
|
|
|
|
2009-09-19 19:02:04 +02:00
|
|
|
if not self.metadata.get('activity_id', ''):
|
|
|
|
self.metadata['activity_id'] = self.get_id()
|
|
|
|
|
2016-04-17 07:57:07 +02:00
|
|
|
file_path = os.path.join(get_activity_root(), 'instance',
|
2009-02-05 12:43:50 +01:00
|
|
|
'%i' % time.time())
|
2007-05-10 11:01:32 +02:00
|
|
|
try:
|
2007-11-09 15:43:54 +01:00
|
|
|
self.write_file(file_path)
|
2007-05-10 11:01:32 +02:00
|
|
|
except NotImplementedError:
|
2008-04-19 11:10:03 +02:00
|
|
|
logging.debug('Activity.write_file is not implemented.')
|
2009-02-05 12:43:50 +01:00
|
|
|
else:
|
|
|
|
if os.path.exists(file_path):
|
|
|
|
self._owns_file = True
|
|
|
|
self._jobject.file_path = file_path
|
2007-09-10 17:58:01 +02:00
|
|
|
|
2008-04-19 11:10:03 +02:00
|
|
|
# Cannot call datastore.write async for creates:
|
|
|
|
# https://dev.laptop.org/ticket/3071
|
2007-09-10 17:58:01 +02:00
|
|
|
if self._jobject.object_id is None:
|
|
|
|
datastore.write(self._jobject, transfer_ownership=True)
|
|
|
|
else:
|
|
|
|
self._updating_jobject = True
|
|
|
|
datastore.write(self._jobject,
|
2013-05-17 07:16:36 +02:00
|
|
|
transfer_ownership=True,
|
|
|
|
reply_handler=self.__save_cb,
|
|
|
|
error_handler=self.__save_error_cb)
|
2007-05-10 11:01:32 +02:00
|
|
|
|
2007-08-31 15:43:38 +02:00
|
|
|
def copy(self):
|
2015-08-11 17:24:07 +02:00
|
|
|
'''
|
|
|
|
Request that the activity 'Keep in Journal' the current state
|
|
|
|
of the activity.
|
2009-08-25 19:55:48 +02:00
|
|
|
|
2007-10-28 16:56:05 +01:00
|
|
|
Activities should not override this method. Instead, like save() do any
|
|
|
|
copy work that needs to be done in write_file()
|
2015-08-11 17:24:07 +02:00
|
|
|
'''
|
2013-12-25 10:14:10 +01:00
|
|
|
logging.debug('Activity.copy: %r' % self._jobject.object_id)
|
2007-08-31 15:43:38 +02:00
|
|
|
self.save()
|
|
|
|
self._jobject.object_id = None
|
|
|
|
|
2007-10-16 15:51:48 +02:00
|
|
|
def __privacy_changed_cb(self, shared_activity, param_spec):
|
2013-12-25 10:14:10 +01:00
|
|
|
logging.debug('__privacy_changed_cb %r' %
|
|
|
|
shared_activity.props.private)
|
2007-09-24 13:02:51 +02:00
|
|
|
if shared_activity.props.private:
|
|
|
|
self._jobject.metadata['share-scope'] = SCOPE_INVITE_ONLY
|
|
|
|
else:
|
|
|
|
self._jobject.metadata['share-scope'] = SCOPE_NEIGHBORHOOD
|
|
|
|
|
2007-10-16 15:51:48 +02:00
|
|
|
def __joined_cb(self, activity, success, err):
|
2007-05-03 05:25:15 +02:00
|
|
|
"""Callback when join has finished"""
|
2013-12-25 10:14:10 +01:00
|
|
|
logging.debug('Activity.__joined_cb %r' % success)
|
2008-09-07 22:07:49 +02:00
|
|
|
self.shared_activity.disconnect(self._join_id)
|
2007-05-03 05:25:15 +02:00
|
|
|
self._join_id = None
|
|
|
|
if not success:
|
2013-12-25 10:14:10 +01:00
|
|
|
logging.debug('Failed to join activity: %s' % err)
|
2007-05-03 05:25:15 +02:00
|
|
|
return
|
2007-09-12 13:35:39 +02:00
|
|
|
|
2013-12-27 16:00:22 +01:00
|
|
|
power_manager = power.get_power_manager()
|
|
|
|
if power_manager.suspend_breaks_collaboration():
|
|
|
|
power_manager.inhibit_suspend()
|
|
|
|
|
2009-09-29 20:33:13 +02:00
|
|
|
self.reveal()
|
2007-05-03 05:25:15 +02:00
|
|
|
self.emit('joined')
|
2008-09-07 22:07:49 +02:00
|
|
|
self.__privacy_changed_cb(self.shared_activity, None)
|
2007-05-03 05:25:15 +02:00
|
|
|
|
2008-07-28 16:13:59 +02:00
|
|
|
def get_shared_activity(self):
|
2015-08-11 17:24:07 +02:00
|
|
|
'''
|
|
|
|
Returns:
|
|
|
|
an instance of the shared Activity or None
|
2008-07-28 16:13:59 +02:00
|
|
|
|
2011-10-29 10:44:18 +02:00
|
|
|
The shared activity is of type sugar3.presence.activity.Activity
|
2015-08-11 17:24:07 +02:00
|
|
|
'''
|
2012-01-11 17:51:37 +01:00
|
|
|
return self.shared_activity
|
2008-07-28 16:13:59 +02:00
|
|
|
|
2006-12-04 20:12:24 +01:00
|
|
|
def get_shared(self):
|
2015-08-11 17:24:07 +02:00
|
|
|
'''
|
|
|
|
Returns:
|
|
|
|
bool: True if the activity is shared on the mesh.
|
|
|
|
'''
|
2008-09-07 22:07:49 +02:00
|
|
|
if not self.shared_activity:
|
2007-05-03 05:25:15 +02:00
|
|
|
return False
|
2008-09-07 22:07:49 +02:00
|
|
|
return self.shared_activity.props.joined
|
2006-12-04 20:12:24 +01:00
|
|
|
|
2007-10-16 15:51:48 +02:00
|
|
|
def __share_cb(self, ps, success, activity, err):
|
2007-05-03 05:25:15 +02:00
|
|
|
if not success:
|
2013-12-25 10:14:10 +01:00
|
|
|
logging.debug('Share of activity %s failed: %s.' %
|
2014-03-29 20:25:34 +01:00
|
|
|
(self._activity_id, err))
|
2007-05-03 05:25:15 +02:00
|
|
|
return
|
2007-09-11 19:59:40 +02:00
|
|
|
|
2013-12-25 10:14:10 +01:00
|
|
|
logging.debug('Share of activity %s successful, PS activity is %r.' %
|
|
|
|
(self._activity_id, activity))
|
2007-08-31 11:37:42 +02:00
|
|
|
|
|
|
|
activity.props.name = self._jobject.metadata['title']
|
|
|
|
|
2013-12-27 16:00:22 +01:00
|
|
|
power_manager = power.get_power_manager()
|
|
|
|
if power_manager.suspend_breaks_collaboration():
|
|
|
|
power_manager.inhibit_suspend()
|
|
|
|
|
2008-09-07 22:07:49 +02:00
|
|
|
self.shared_activity = activity
|
|
|
|
self.shared_activity.connect('notify::private',
|
2013-05-17 07:16:36 +02:00
|
|
|
self.__privacy_changed_cb)
|
2007-04-27 22:07:38 +02:00
|
|
|
self.emit('shared')
|
2008-09-07 22:07:49 +02:00
|
|
|
self.__privacy_changed_cb(self.shared_activity, None)
|
2007-09-11 19:59:40 +02:00
|
|
|
|
|
|
|
self._send_invites()
|
2006-12-20 00:53:27 +01:00
|
|
|
|
2007-09-11 17:53:27 +02:00
|
|
|
def _invite_response_cb(self, error):
|
|
|
|
if error:
|
2009-08-24 12:54:02 +02:00
|
|
|
logging.error('Invite failed: %s', error)
|
2007-09-11 17:53:27 +02:00
|
|
|
|
2007-09-11 19:59:40 +02:00
|
|
|
def _send_invites(self):
|
|
|
|
while self._invites_queue:
|
2010-07-08 17:20:51 +02:00
|
|
|
account_path, contact_id = self._invites_queue.pop()
|
|
|
|
pservice = presenceservice.get_instance()
|
|
|
|
buddy = pservice.get_buddy(account_path, contact_id)
|
2007-09-11 19:59:40 +02:00
|
|
|
if buddy:
|
2008-09-07 22:07:49 +02:00
|
|
|
self.shared_activity.invite(
|
2013-05-17 07:16:36 +02:00
|
|
|
buddy, '', self._invite_response_cb)
|
2007-09-11 19:59:40 +02:00
|
|
|
else:
|
2010-08-12 16:20:14 +02:00
|
|
|
logging.error('Cannot invite %s %s, no such buddy',
|
|
|
|
account_path, contact_id)
|
2007-09-11 19:59:40 +02:00
|
|
|
|
2010-07-08 17:20:51 +02:00
|
|
|
def invite(self, account_path, contact_id):
|
2015-08-11 17:24:07 +02:00
|
|
|
'''
|
|
|
|
Invite a buddy to join this Activity.
|
|
|
|
|
|
|
|
Args:
|
|
|
|
account_path
|
|
|
|
contact_id
|
2009-08-25 19:55:48 +02:00
|
|
|
|
2007-10-28 16:56:05 +01:00
|
|
|
Side Effects:
|
|
|
|
Calls self.share(True) to privately share the activity if it wasn't
|
2009-08-25 19:55:48 +02:00
|
|
|
shared before.
|
2015-08-11 17:24:07 +02:00
|
|
|
'''
|
2010-07-08 17:20:51 +02:00
|
|
|
self._invites_queue.append((account_path, contact_id))
|
2007-09-11 17:53:27 +02:00
|
|
|
|
2008-09-07 22:07:49 +02:00
|
|
|
if (self.shared_activity is None
|
2013-05-17 07:16:36 +02:00
|
|
|
or not self.shared_activity.props.joined):
|
2007-09-11 19:59:40 +02:00
|
|
|
self.share(True)
|
2007-09-11 17:53:27 +02:00
|
|
|
else:
|
2007-09-11 19:59:40 +02:00
|
|
|
self._send_invites()
|
2007-09-11 17:53:27 +02:00
|
|
|
|
2007-08-22 16:54:12 +02:00
|
|
|
def share(self, private=False):
|
2015-08-11 17:24:07 +02:00
|
|
|
'''
|
|
|
|
Request that the activity be shared on the network.
|
2009-08-25 19:55:48 +02:00
|
|
|
|
2015-08-11 17:24:07 +02:00
|
|
|
Args:
|
|
|
|
private (bool): True to share by invitation only,
|
2007-08-22 16:54:12 +02:00
|
|
|
False to advertise as shared to everyone.
|
2007-08-30 13:13:31 +02:00
|
|
|
|
|
|
|
Once the activity is shared, its privacy can be changed by setting
|
|
|
|
its 'private' property.
|
2015-08-11 17:24:07 +02:00
|
|
|
'''
|
2008-09-07 22:07:49 +02:00
|
|
|
if self.shared_activity and self.shared_activity.props.joined:
|
2010-10-15 21:14:59 +02:00
|
|
|
raise RuntimeError('Activity %s already shared.' %
|
2007-08-22 16:54:12 +02:00
|
|
|
self._activity_id)
|
|
|
|
verb = private and 'private' or 'public'
|
2013-12-25 10:14:10 +01:00
|
|
|
logging.debug('Requesting %s share of activity %s.' % (verb,
|
|
|
|
self._activity_id))
|
2010-06-28 16:42:23 +02:00
|
|
|
pservice = presenceservice.get_instance()
|
|
|
|
pservice.connect('activity-shared', self.__share_cb)
|
|
|
|
pservice.share_activity(self, private=private)
|
2006-12-04 20:12:24 +01:00
|
|
|
|
2008-07-21 19:20:22 +02:00
|
|
|
def _show_keep_failed_dialog(self):
|
2007-11-13 15:59:24 +01:00
|
|
|
alert = Alert()
|
|
|
|
alert.props.title = _('Keep error')
|
|
|
|
alert.props.msg = _('Keep error: all changes will be lost')
|
|
|
|
|
|
|
|
cancel_icon = Icon(icon_name='dialog-cancel')
|
2013-05-17 07:16:36 +02:00
|
|
|
alert.add_button(Gtk.ResponseType.CANCEL, _('Don\'t stop'),
|
|
|
|
cancel_icon)
|
2007-11-13 15:59:24 +01:00
|
|
|
|
|
|
|
stop_icon = Icon(icon_name='dialog-ok')
|
2011-11-15 19:29:07 +01:00
|
|
|
alert.add_button(Gtk.ResponseType.OK, _('Stop anyway'), stop_icon)
|
2007-11-13 15:59:24 +01:00
|
|
|
|
|
|
|
self.add_alert(alert)
|
|
|
|
alert.connect('response', self._keep_failed_dialog_response_cb)
|
|
|
|
|
2009-09-29 20:33:13 +02:00
|
|
|
self.reveal()
|
2008-07-21 19:27:26 +02:00
|
|
|
|
2007-11-13 15:59:24 +01:00
|
|
|
def _keep_failed_dialog_response_cb(self, alert, response_id):
|
|
|
|
self.remove_alert(alert)
|
2011-11-15 19:29:07 +01:00
|
|
|
if response_id == Gtk.ResponseType.OK:
|
2007-11-13 15:59:24 +01:00
|
|
|
self.close(skip_save=True)
|
2009-09-29 20:33:13 +02:00
|
|
|
if self._quit_requested:
|
|
|
|
self._session.will_quit(self, True)
|
|
|
|
elif self._quit_requested:
|
|
|
|
self._session.will_quit(self, False)
|
2007-11-13 15:59:24 +01:00
|
|
|
|
2008-01-10 17:55:57 +01:00
|
|
|
def can_close(self):
|
2015-08-11 17:24:07 +02:00
|
|
|
'''
|
|
|
|
Activities should override this function if they want to perform
|
|
|
|
extra checks before actually closing.
|
|
|
|
'''
|
2008-01-10 17:55:57 +01:00
|
|
|
|
|
|
|
return True
|
|
|
|
|
2008-07-21 19:20:22 +02:00
|
|
|
def _prepare_close(self, skip_save=False):
|
|
|
|
if not skip_save:
|
|
|
|
try:
|
|
|
|
self.save()
|
2009-03-03 15:22:54 +01:00
|
|
|
except:
|
2010-10-15 21:47:41 +02:00
|
|
|
# pylint: disable=W0702
|
2010-02-06 13:11:22 +01:00
|
|
|
logging.exception('Error saving activity object to datastore')
|
2008-07-21 19:20:22 +02:00
|
|
|
self._show_keep_failed_dialog()
|
|
|
|
return False
|
|
|
|
|
|
|
|
self._closing = True
|
|
|
|
|
|
|
|
return True
|
|
|
|
|
|
|
|
def _complete_close(self):
|
|
|
|
self.destroy()
|
|
|
|
|
2009-09-07 13:17:57 +02:00
|
|
|
if self.shared_activity:
|
|
|
|
self.shared_activity.leave()
|
|
|
|
|
|
|
|
self._cleanup_jobject()
|
|
|
|
|
2008-07-21 19:20:22 +02:00
|
|
|
# Make the exported object inaccessible
|
|
|
|
dbus.service.Object.remove_from_connection(self._bus)
|
|
|
|
|
2008-08-06 23:04:00 +02:00
|
|
|
self._session.unregister(self)
|
2013-12-27 16:00:22 +01:00
|
|
|
power.get_power_manager().shutdown()
|
2008-08-06 23:04:00 +02:00
|
|
|
|
2008-07-21 19:20:22 +02:00
|
|
|
def close(self, skip_save=False):
|
2015-08-11 17:24:07 +02:00
|
|
|
'''
|
|
|
|
Request that the activity be stopped and saved to the Journal
|
2009-08-25 19:55:48 +02:00
|
|
|
|
2008-04-19 11:10:03 +02:00
|
|
|
Activities should not override this method, but should implement
|
|
|
|
write_file() to do any state saving instead. If the application wants
|
|
|
|
to control wether it can close, it should override can_close().
|
2015-08-11 17:24:07 +02:00
|
|
|
|
|
|
|
Args:
|
|
|
|
skip_save (bool)
|
|
|
|
'''
|
2008-07-21 19:20:22 +02:00
|
|
|
if not self.can_close():
|
2007-11-13 15:59:24 +01:00
|
|
|
return
|
2007-07-23 13:45:46 +02:00
|
|
|
|
2012-05-30 11:56:34 +02:00
|
|
|
self.get_window().set_cursor(Gdk.Cursor(Gdk.CursorType.WATCH))
|
2011-06-20 17:48:51 +02:00
|
|
|
self.emit('_closing')
|
|
|
|
|
2012-01-31 22:42:51 +01:00
|
|
|
if not self._closing:
|
|
|
|
if not self._prepare_close(skip_save):
|
|
|
|
return
|
2007-10-15 23:47:02 +02:00
|
|
|
|
2012-01-31 22:42:51 +01:00
|
|
|
if not self._updating_jobject:
|
|
|
|
self._complete_close()
|
2008-01-31 20:48:03 +01:00
|
|
|
|
2007-10-16 15:51:48 +02:00
|
|
|
def __realize_cb(self, window):
|
2012-08-24 12:23:17 +02:00
|
|
|
xid = window.get_window().get_xid()
|
|
|
|
SugarExt.wm_set_bundle_id(xid, self.get_bundle_id())
|
|
|
|
SugarExt.wm_set_activity_id(xid, str(self._activity_id))
|
2007-10-15 23:47:02 +02:00
|
|
|
|
|
|
|
def __delete_event_cb(self, widget, event):
|
|
|
|
self.close()
|
|
|
|
return True
|
2007-04-27 22:07:38 +02:00
|
|
|
|
2007-05-29 15:53:58 +02:00
|
|
|
def get_metadata(self):
|
2015-08-11 17:24:07 +02:00
|
|
|
'''
|
|
|
|
Returns:
|
|
|
|
|
|
|
|
dict: the jobject metadata or None if there is no jobject.
|
2009-08-25 19:55:48 +02:00
|
|
|
|
|
|
|
Activities can set metadata in write_file() using:
|
2015-08-11 17:24:07 +02:00
|
|
|
|
|
|
|
.. code-block:: python
|
|
|
|
|
2010-10-15 21:14:59 +02:00
|
|
|
self.metadata['MyKey'] = 'Something'
|
2009-08-25 19:55:48 +02:00
|
|
|
|
|
|
|
and retrieve metadata in read_file() using:
|
2015-08-11 17:24:07 +02:00
|
|
|
|
|
|
|
.. code-block:: python
|
|
|
|
|
2007-10-28 16:56:05 +01:00
|
|
|
self.metadata.get('MyKey', 'aDefaultValue')
|
2009-08-25 19:55:48 +02:00
|
|
|
|
2007-10-28 16:56:05 +01:00
|
|
|
Note: Make sure your activity works properly if one or more of the
|
|
|
|
metadata items is missing. Never assume they will all be present.
|
2015-08-11 17:24:07 +02:00
|
|
|
'''
|
2007-05-29 15:53:58 +02:00
|
|
|
if self._jobject:
|
|
|
|
return self._jobject.metadata
|
|
|
|
else:
|
|
|
|
return None
|
|
|
|
|
|
|
|
metadata = property(get_metadata, None)
|
|
|
|
|
2008-11-07 16:23:54 +01:00
|
|
|
def handle_view_source(self):
|
2015-08-11 17:24:07 +02:00
|
|
|
'''
|
|
|
|
A developer can impleement this method to show aditional information
|
|
|
|
in the View Source window. Example implementations are available
|
|
|
|
on activities Browse or TurtleArt.
|
|
|
|
'''
|
2008-11-07 16:23:54 +01:00
|
|
|
raise NotImplementedError
|
|
|
|
|
|
|
|
def get_document_path(self, async_cb, async_err_cb):
|
|
|
|
async_err_cb(NotImplementedError())
|
|
|
|
|
2010-07-15 10:50:05 +02:00
|
|
|
|
|
|
|
class _ClientHandler(dbus.service.Object, DBusProperties):
|
|
|
|
def __init__(self, bundle_id, got_channel_cb):
|
|
|
|
self._interfaces = set([CLIENT, CLIENT_HANDLER, PROPERTIES_IFACE])
|
|
|
|
self._got_channel_cb = got_channel_cb
|
|
|
|
|
|
|
|
bus = dbus.Bus()
|
|
|
|
name = CLIENT + '.' + bundle_id
|
|
|
|
bus_name = dbus.service.BusName(name, bus=bus)
|
|
|
|
|
|
|
|
path = '/' + name.replace('.', '/')
|
|
|
|
dbus.service.Object.__init__(self, bus_name, path)
|
|
|
|
DBusProperties.__init__(self)
|
|
|
|
|
|
|
|
self._implement_property_get(CLIENT, {
|
|
|
|
'Interfaces': lambda: list(self._interfaces),
|
2013-05-17 07:16:36 +02:00
|
|
|
})
|
2010-07-15 10:50:05 +02:00
|
|
|
self._implement_property_get(CLIENT_HANDLER, {
|
|
|
|
'HandlerChannelFilter': self.__get_filters_cb,
|
2013-05-17 07:16:36 +02:00
|
|
|
})
|
2010-07-15 10:50:05 +02:00
|
|
|
|
|
|
|
def __get_filters_cb(self):
|
|
|
|
logging.debug('__get_filters_cb')
|
|
|
|
filters = {
|
2010-10-15 20:38:45 +02:00
|
|
|
CHANNEL + '.ChannelType': CHANNEL_TYPE_TEXT,
|
2010-07-15 10:50:05 +02:00
|
|
|
CHANNEL + '.TargetHandleType': CONNECTION_HANDLE_TYPE_CONTACT,
|
2013-05-17 07:16:36 +02:00
|
|
|
}
|
2010-07-15 10:50:05 +02:00
|
|
|
filter_dict = dbus.Dictionary(filters, signature='sv')
|
2013-12-25 10:14:10 +01:00
|
|
|
logging.debug('__get_filters_cb %r' % dbus.Array([filter_dict],
|
|
|
|
signature='a{sv}'))
|
2010-07-15 10:50:05 +02:00
|
|
|
return dbus.Array([filter_dict], signature='a{sv}')
|
|
|
|
|
|
|
|
@dbus.service.method(dbus_interface=CLIENT_HANDLER,
|
|
|
|
in_signature='ooa(oa{sv})aota{sv}', out_signature='')
|
|
|
|
def HandleChannels(self, account, connection, channels, requests_satisfied,
|
2013-05-17 07:16:36 +02:00
|
|
|
user_action_time, handler_info):
|
2013-12-25 10:14:10 +01:00
|
|
|
logging.debug('HandleChannels\n\t%r\n\t%r\n\t%r\n\t%r\n\t%r\n\t%r' %
|
|
|
|
(account, connection, channels, requests_satisfied,
|
|
|
|
user_action_time, handler_info))
|
2010-07-15 10:50:05 +02:00
|
|
|
try:
|
2011-06-09 16:53:18 +02:00
|
|
|
for object_path, properties in channels:
|
|
|
|
channel_type = properties[CHANNEL + '.ChannelType']
|
|
|
|
handle_type = properties[CHANNEL + '.TargetHandleType']
|
|
|
|
if channel_type == CHANNEL_TYPE_TEXT:
|
|
|
|
self._got_channel_cb(connection, object_path, handle_type)
|
2010-07-15 10:50:05 +02:00
|
|
|
except Exception, e:
|
|
|
|
logging.exception(e)
|
2009-08-25 21:12:40 +02:00
|
|
|
|
2008-08-06 23:04:00 +02:00
|
|
|
_session = None
|
|
|
|
|
2009-08-25 21:12:40 +02:00
|
|
|
|
2008-08-06 23:04:00 +02:00
|
|
|
def _get_session():
|
|
|
|
global _session
|
|
|
|
|
|
|
|
if _session is None:
|
|
|
|
_session = _ActivitySession()
|
|
|
|
|
|
|
|
return _session
|
|
|
|
|
2009-08-25 21:12:40 +02:00
|
|
|
|
2007-05-14 19:56:06 +02:00
|
|
|
def get_bundle_name():
|
2015-08-11 17:24:07 +02:00
|
|
|
'''
|
|
|
|
Returns:
|
|
|
|
str: the bundle name for the current process' bundle
|
|
|
|
'''
|
2007-10-16 14:29:38 +02:00
|
|
|
return os.environ['SUGAR_BUNDLE_NAME']
|
2009-08-25 19:55:48 +02:00
|
|
|
|
2009-08-25 21:12:40 +02:00
|
|
|
|
2007-02-22 15:55:07 +01:00
|
|
|
def get_bundle_path():
|
2015-08-11 17:24:07 +02:00
|
|
|
'''
|
|
|
|
Returns:
|
|
|
|
str: the bundle path for the current process' bundle
|
|
|
|
'''
|
2007-02-23 17:08:37 +01:00
|
|
|
return os.environ['SUGAR_BUNDLE_PATH']
|
2007-06-27 23:12:32 +02:00
|
|
|
|
2009-08-25 21:12:40 +02:00
|
|
|
|
2007-12-03 22:10:14 +01:00
|
|
|
def get_activity_root():
|
2015-08-11 17:24:07 +02:00
|
|
|
'''
|
|
|
|
Returns:
|
|
|
|
str: a path for saving Activity specific preferences, etc.
|
|
|
|
'''
|
2010-10-15 20:18:15 +02:00
|
|
|
if os.environ.get('SUGAR_ACTIVITY_ROOT'):
|
2007-12-03 22:10:14 +01:00
|
|
|
return os.environ['SUGAR_ACTIVITY_ROOT']
|
|
|
|
else:
|
2016-04-17 07:57:07 +02:00
|
|
|
activity_root = env.get_profile_path(os.environ['SUGAR_BUNDLE_ID'])
|
|
|
|
try:
|
|
|
|
os.mkdir(activity_root)
|
|
|
|
except OSError, e:
|
|
|
|
if e.errno != EEXIST:
|
|
|
|
raise e
|
|
|
|
return activity_root
|
2007-12-19 13:02:16 +01:00
|
|
|
|
2009-08-25 21:12:40 +02:00
|
|
|
|
2007-12-19 13:02:16 +01:00
|
|
|
def show_object_in_journal(object_id):
|
|
|
|
bus = dbus.SessionBus()
|
|
|
|
obj = bus.get_object(J_DBUS_SERVICE, J_DBUS_PATH)
|
|
|
|
journal = dbus.Interface(obj, J_DBUS_INTERFACE)
|
|
|
|
journal.ShowObject(object_id)
|
2015-05-06 13:43:30 +02:00
|
|
|
|
|
|
|
|
|
|
|
def launch_bundle(bundle_id='', object_id=''):
|
|
|
|
bus = dbus.SessionBus()
|
|
|
|
obj = bus.get_object(J_DBUS_SERVICE, J_DBUS_PATH)
|
|
|
|
bundle_launcher = dbus.Interface(obj, J_DBUS_INTERFACE)
|
|
|
|
return bundle_launcher.LaunchBundle(bundle_id, object_id)
|
2015-07-02 21:07:23 +02:00
|
|
|
|
|
|
|
|
|
|
|
def get_bundle(bundle_id='', object_id=''):
|
|
|
|
bus = dbus.SessionBus()
|
|
|
|
obj = bus.get_object(J_DBUS_SERVICE, J_DBUS_PATH)
|
|
|
|
journal = dbus.Interface(obj, J_DBUS_INTERFACE)
|
|
|
|
bundle_path = journal.GetBundlePath(bundle_id, object_id)
|
|
|
|
if bundle_path:
|
|
|
|
return bundle_from_dir(bundle_path)
|
|
|
|
else:
|
|
|
|
return None
|