def __export_png_cb(self, event):
x, y, w, h, bitdepth = self._main_area.window.get_geometry()
cmap = self._main_area.window.get_colormap()
maxx, maxy = self._main_area.get_max_area()
true_width = int(maxx)
true_height = int(maxy)
# Create the new journal entry
fileObject = datastore.create()
act_meta = self.metadata
fileObject.metadata['title'] = act_meta['title'] + ' (PNG)'
fileObject.metadata['title_set_by_user'] = \
act_meta['title_set_by_user']
fileObject.metadata['mime_type'] = 'image/png'
fileObject.metadata['icon-color'] = act_meta['icon-color']
fileObject.file_path = os.path.join(self.get_activity_root(),
'instance', '%i' % time.time())
filename = fileObject.file_path
pixmap = gtk.gdk.Pixmap(None, true_width, true_height, bitdepth)
pixmap.set_colormap(cmap)
self._main_area.export(pixmap.cairo_create(), true_width, true_height,
False)
pb = gtk.gdk.Pixbuf.get_from_drawable(
gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, True, 8, true_width,
true_height),
pixmap, gtk.gdk.colormap_get_system(), 0, 0, 0, 0, true_width,
true_height)
pb.save(filename, 'png')
datastore.write(fileObject, transfer_ownership=True)
fileObject.destroy()
del fileObject
def __export_pdf_cb(self, event):
maxx, maxy = self._main_area.get_max_area()
true_width = int(maxx)
true_height = int(maxy)
# Create the new journal entry
fileObject = datastore.create()
act_meta = self.metadata
fileObject.metadata['title'] = act_meta['title'] + ' (PDF)'
fileObject.metadata['title_set_by_user'] = \
act_meta['title_set_by_user']
fileObject.metadata['mime_type'] = 'application/pdf'
# TODO: add text thoughts into fulltext metadata
# fileObject.metadata['fulltext'] = ...
fileObject.metadata['icon-color'] = act_meta['icon-color']
fileObject.file_path = os.path.join(self.get_activity_root(),
'instance', '%i' % time.time())
filename = fileObject.file_path
surface = cairo.PDFSurface(filename, true_width, true_height)
cairo_context = cairo.Context(surface)
context = pangocairo.CairoContext(cairo_context)
self._main_area.export(context, true_width, true_height, False)
surface.finish()
datastore.write(fileObject, transfer_ownership=True)
fileObject.destroy()
del fileObject
def saveFile(self, _widget):
fullPath= _widget.value;
if self.script.journal:
if type(fullPath.actualValue) == str:
dsObject= datastore.create()
print dir(dsObject.metadata)
dsObject.metadata.get_dictionary().update(self.autogenerateMetadata())
dsObject.metadata['title']= fullPath.actualValue
self.script.saveFile(directories['instance'] + 'temp.bdw')
dsObject.set_file_path(self.script.filepath)
datastore.write(dsObject)
self.script.filepath = dsObject
else:
dsObject= fullPath.actualValue
self.script.saveFile(directories['instance'] + 'temp.bdw')
dsObject.set_file_path(self.script.filepath)
datastore.write(dsObject)
self.script.filepath = fullPath.actualValue
self.refreshPanel();
else:
fileName, fileExtension= os.path.splitext(fullPath);
if fileExtension != information['filetype']:
fullPath+= information['filetype'];
if os.path.isfile(fullPath):
self.confirmActionDialog(_("Overwrite?"),
[ _("This file already exists:"),
os.path.basename(fullPath),
_("Are you sure you want to overwrite it?")],
okayFunction= self.script.saveFile,
arguments=fullPath);
else:
self.script.saveFile(fullPath);
def _file_part_receiver(self, target, filename, part, numparts,
bytes, title=None, color=None, sender=None):
# ignore my own signal
if sender == self._tube.get_unique_name():
return
if not (target == 'all' or target == self._tube.get_unique_name()):
return
# first chunk
if part == 1:
tmp_root = join(environ['SUGAR_ACTIVITY_ROOT'], 'instance')
temp_dir = tempfile.mkdtemp(dir=tmp_root)
chmod(temp_dir, 0777)
self.temp_file = join(temp_dir, 'game.zip')
self.files[filename] = self.temp_file
self.f = open(self.temp_file, 'a+b')
self.f.write(bytes)
percentage = int(float(part) / float(numparts) * 100.0)
self.game.set_load_mode(_('Receiving game') + ': '
+ str(percentage) + '% ' + _('done') + '.')
# last chunk
if part == numparts:
self.f.close()
#file = self.files[filename]
# Saves the zip in datastore
gameObject = datastore.create()
gameObject.metadata['title'] = title
gameObject.metadata['mime_type'] = 'application/x-memorize-project'
gameObject.metadata['icon-color'] = color
gameObject.file_path = self.temp_file
datastore.write(gameObject)
def change_name(old_name, new_name):
dsobjects, num = datastore.find({'title': old_name, 'TimeLapse': 'yes'})
for dsobject in dsobjects:
dsobject.metadata['title'] = new_name
dsobject.metadata['TimeLapsetitle'] = new_name
datastore.write(dsobject)
dsobject.destroy()
def install(self):
if os.environ.has_key('SUGAR_ACTIVITY_ROOT'):
install_dir = os.path.join(os.environ['SUGAR_ACTIVITY_ROOT'],
'instance')
else:
install_dir = tempfile.gettempdir()
uid = self.get_entry_id()
bundle_dir = os.path.join(install_dir, uid)
self._unzip(install_dir)
try:
metadata = self.get_metadata()
jobject = datastore.create()
try:
for key, value in metadata.iteritems():
jobject.metadata[key] = value
preview = self.get_preview()
if preview != '':
jobject.metadata['preview'] = dbus.ByteArray(preview)
jobject.metadata['uid'] = ''
if jobject.metadata.has_key('mountpoint'):
del jobject.metadata['mountpoint']
os.chmod(bundle_dir, RWXR_XR_X)
if (os.path.exists(os.path.join(bundle_dir, uid))):
jobject.file_path = os.path.join(bundle_dir, uid)
os.chmod(jobject.file_path, RW_R__R__)
datastore.write(jobject)
finally:
jobject.destroy()
finally:
shutil.rmtree(bundle_dir, ignore_errors=True)
def view_source(self):
"""Implement the 'view source' key by saving pippy_app.py to the
datastore, and then telling the Journal to view it."""
if self.__source_object_id is None:
from sugar import profile
from sugar.datastore import datastore
from sugar.activity.activity \
import get_bundle_name, get_bundle_path
from gettext import gettext as _
import os.path
jobject = datastore.create()
metadata = {
'title': _('%s Source') % get_bundle_name(),
'title_set_by_user': '******',
'suggested_filename': 'pippy_app.py',
'icon-color': profile.get_color().to_string(),
'mime_type': 'text/x-python',
}
for k, v in metadata.items():
jobject.metadata[k] = v # dict.update method is missing =(
jobject.file_path = os.path.join(get_bundle_path(), 'pippy_app.py')
datastore.write(jobject)
self.__source_object_id = jobject.object_id
jobject.destroy()
self.journal_show_object(self.__source_object_id)
def _save_dsobject(self,
filename,
content,
mime_type=None,
description=None):
parent_dir = os.path.join(self.get_activity_root(), 'tmp')
try:
os.makedirs(parent_dir)
except OSError:
pass
fd, tmp_filename = tempfile.mkstemp(dir=parent_dir,
suffix=filename,
prefix='tmp')
try:
os.write(fd, content)
except:
raise
else:
dsobject = datastore.create()
dsobject.metadata['title'] = filename
if mime_type is None:
mime_type = mime.get_for_file(tmp_filename)
dsobject.metadata['mime_type'] = mime_type
if description is None:
description = _('From: %s') % (self.metadata['title'], )
dsobject.metadata['description'] = description
dsobject.set_file_path(tmp_filename)
datastore.write(dsobject)
finally:
os.close(fd)
os.unlink(tmp_filename)
return dsobject
def open_url(self, url):
"""Ask the journal to open an URL for us."""
from sugar import profile
from shutil import rmtree
from sugar.datastore import datastore
from sugar.activity.activity import show_object_in_journal
from tempfile import mkdtemp
tmpfolder = mkdtemp('.tmp', 'url', os.path.join(self.get_activity_root(), 'instance'))
tmpfilepath = os.path.join(tmpfolder, 'url')
try:
tmpfile = open(tmpfilepath, 'w')
tmpfile.write(url)
tmpfile.close()
os.chmod(tmpfolder, 0755)
os.chmod(tmpfilepath, 0755)
jobject = datastore.create()
metadata = {
'title': url,
'title_set_by_user': '******',
'buddies': '',
'preview': '',
'icon-color': profile.get_color().to_string(),
'mime_type': 'text/uri-list',
}
for k, v in metadata.items():
jobject.metadata[k] = v # the dict.update method is missing =(
jobject.file_path = tmpfilepath
datastore.write(jobject)
show_object_in_journal(jobject.object_id)
jobject.destroy()
finally:
rmtree(tmpfilepath, ignore_errors=True) # clean up!
def install(self):
if os.environ.has_key('SUGAR_ACTIVITY_ROOT'):
install_dir = os.path.join(os.environ['SUGAR_ACTIVITY_ROOT'], 'instance')
else:
install_dir = tempfile.gettempdir()
uid = self.get_entry_id()
bundle_dir = os.path.join(install_dir, uid)
self._unzip(install_dir)
try:
metadata = self.get_metadata()
jobject = datastore.create()
try:
for key, value in metadata.iteritems():
jobject.metadata[key] = value
preview = self.get_preview()
if preview != '':
jobject.metadata['preview'] = dbus.ByteArray(preview)
jobject.metadata['uid'] = ''
if jobject.metadata.has_key('mountpoint'):
del jobject.metadata['mountpoint']
os.chmod(bundle_dir, RWXR_XR_X)
if( os.path.exists( os.path.join(bundle_dir, uid) ) ):
jobject.file_path = os.path.join(bundle_dir, uid)
os.chmod(jobject.file_path, RW_R__R__)
datastore.write(jobject)
finally:
jobject.destroy()
finally:
shutil.rmtree(bundle_dir, ignore_errors=True)
def myblock(tw, title):
''' Save heap to journal (Sugar only) '''
import os.path
from gettext import gettext as _
from sugar.activity import activity
from sugar.datastore import datastore
from sugar import profile
from TurtleArt.tautils import get_path, data_to_file
# Save JSON-encoded heap to temporary file
heap_file = os.path.join(get_path(activity, 'instance'),
str(title) + '.txt')
data_to_file(tw.lc.heap, heap_file)
# Create a datastore object
dsobject = datastore.create()
# Write any metadata (specifically set the title of the file
# and specify that this is a plain text file).
dsobject.metadata['title'] = str(title)
dsobject.metadata['icon-color'] = profile.get_color().to_string()
dsobject.metadata['mime_type'] = 'text/plain'
dsobject.set_file_path(heap_file)
datastore.write(dsobject)
dsobject.destroy()
def _install_update(self, bundle_update, local_file_path):
total = self._total_bundles_to_update
current = total - len(self._bundles_to_update) - 0.5
self.emit('progress', UpdateModel.ACTION_UPDATING,
bundle_update.bundle.get_name(),
current, total)
# TODO: Should we first expand the zip async so we can provide progress
# and only then copy to the journal?
jobject = datastore.create()
try:
title = '%s-%s' % (bundle_update.bundle.get_name(),
bundle_update.version)
jobject.metadata['title'] = title
jobject.metadata['mime_type'] = ActivityBundle.MIME_TYPE
jobject.file_path = local_file_path
datastore.write(jobject, transfer_ownership=True)
finally:
jobject.destroy()
self.emit('progress', UpdateModel.ACTION_UPDATING,
bundle_update.bundle.get_name(),
current + 0.5, total)
if self._bundles_to_update:
# do it in idle so the UI has a chance to refresh
gobject.idle_add(self._download_next_update)
def saveFile(self, _widget):
fullPath = _widget.value
if self.script.journal:
if type(fullPath.actualValue) == str:
dsObject = datastore.create()
print dir(dsObject.metadata)
dsObject.metadata.get_dictionary().update(
self.autogenerateMetadata())
dsObject.metadata['title'] = fullPath.actualValue
self.script.saveFile(directories['instance'] + 'temp.bdw')
dsObject.set_file_path(self.script.filepath)
datastore.write(dsObject)
self.script.filepath = dsObject
else:
dsObject = fullPath.actualValue
self.script.saveFile(directories['instance'] + 'temp.bdw')
dsObject.set_file_path(self.script.filepath)
datastore.write(dsObject)
self.script.filepath = fullPath.actualValue
self.refreshPanel()
else:
fileName, fileExtension = os.path.splitext(fullPath)
if fileExtension != information['filetype']:
fullPath += information['filetype']
if os.path.isfile(fullPath):
self.confirmActionDialog(_("Overwrite?"), [
_("This file already exists:"),
os.path.basename(fullPath),
_("Are you sure you want to overwrite it?")
],
okayFunction=self.script.saveFile,
arguments=fullPath)
else:
self.script.saveFile(fullPath)
def _show_via_journal(self, url):
"""Ask the journal to display a URL"""
import os
import time
from sugar import profile
from sugar.activity.activity import show_object_in_journal
from sugar.datastore import datastore
logger.debug('Create journal entry for URL: %s', url)
jobject = datastore.create()
metadata = {
'title': "%s: %s" % (_('URL from Chat'), url),
'title_set_by_user': '******',
'icon-color': profile.get_color().to_string(),
'mime_type': 'text/uri-list',
}
for k, v in metadata.items():
jobject.metadata[k] = v
file_path = os.path.join(get_activity_root(), 'instance',
'%i_' % time.time())
open(file_path, 'w').write(url + '\r\n')
os.chmod(file_path, 0755)
jobject.set_file_path(file_path)
datastore.write(jobject)
show_object_in_journal(jobject.object_id)
jobject.destroy()
os.unlink(file_path)
def exportFile(self, _widget, fancy, amount, dialog):
fullPath = _widget.value
dialog.close()
if self.script.journal:
dsObject = datastore.create()
print dir(dsObject.metadata)
dsObject.metadata.get_dictionary().update(
self.autogenerateMetadata())
dsObject.metadata['title'] = fullPath.actualValue
if fancy == "Fancy":
dsObject.metadata['mime_type'] = 'text/html'
else:
dsObject.metadata['mime_type'] = 'text/plain'
fullPath = directories['instance'] + 'temp.bdw'
self.script.export(
(directories['instance'] + 'temp.bdw', fancy, amount))
dsObject.set_file_path(fullPath)
datastore.write(dsObject)
else:
fileName, fileExtension = os.path.splitext(fullPath)
if fancy == "Fancy" and fileExtension != ".html":
fullPath += ".html"
elif fancy == "Plain" and fileExtension != ".txt":
fullPath += ".txt"
if os.path.isfile(fullPath):
self.confirmActionDialog(_("Overwrite?"), [
_("This file already exists:"),
os.path.basename(fullPath),
_("Are you sure you want to overwrite it?")
],
okayFunction=self.script.export,
arguments=(fullPath, fancy, amount))
else:
self.script.export((fullPath, fancy, amount))
def __export_png_cb(self, event):
x, y, w, h, bitdepth = self._main_area.window.get_geometry()
cmap = self._main_area.window.get_colormap()
maxx, maxy = self._main_area.get_max_area()
true_width = int(maxx)
true_height = int(maxy)
# Create the new journal entry
fileObject = datastore.create()
act_meta = self.metadata
fileObject.metadata['title'] = act_meta['title'] + ' (PNG)'
fileObject.metadata['title_set_by_user'] = \
act_meta['title_set_by_user']
fileObject.metadata['mime_type'] = 'image/png'
fileObject.metadata['icon-color'] = act_meta['icon-color']
fileObject.file_path = os.path.join(self.get_activity_root(),
'instance', '%i' % time.time())
filename = fileObject.file_path
pixmap = gtk.gdk.Pixmap(None, true_width, true_height, bitdepth)
pixmap.set_colormap(cmap)
self._main_area.export(pixmap.cairo_create(), true_width, true_height,
False)
pb = gtk.gdk.Pixbuf.get_from_drawable(
gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, True, 8,
true_width, true_height), pixmap,
gtk.gdk.colormap_get_system(), 0, 0, 0, 0, true_width, true_height)
pb.save(filename, 'png')
datastore.write(fileObject, transfer_ownership=True)
fileObject.destroy()
del fileObject
def _save_recording(self):
if os.path.exists(os.path.join(self.datapath, 'output.ogg')):
_logger.debug('Saving recording to Journal...')
obj_id = self._get_audio_obj_id()
copyfile(os.path.join(self.datapath, 'output.ogg'),
os.path.join(self.datapath, '%s.ogg' % (obj_id)))
dsobject = self._search_for_audio_note(obj_id)
if dsobject is None:
dsobject = datastore.create()
if dsobject is not None:
_logger.debug(self.dsobjects[self.i].metadata['title'])
dsobject.metadata['title'] = _('Audio recording by %s') % \
(self.metadata['title'])
dsobject.metadata['icon-color'] = \
profile.get_color().to_string()
dsobject.metadata['tags'] = obj_id
dsobject.metadata['mime_type'] = 'audio/ogg'
dsobject.set_file_path(
os.path.join(self.datapath, '%s.ogg' % (obj_id)))
datastore.write(dsobject)
dsobject.destroy()
self._add_playback_button(
profile.get_nick_name(), self.colors,
os.path.join(self.datapath, '%s.ogg' % (obj_id)))
if hasattr(self, 'chattube') and self.chattube is not None:
self._share_audio()
else:
_logger.debug('Nothing to save...')
return
def award(self, name, description):
"""
Awards a badge in an activity
:type name: string
:param name: The name of the badge
:type description: string
:param description: The description of the badge
"""
badge_json = json.loads(self._list.metadata['badge_list'])
# Check if the badge has already been acquired
if not name in badge_json.keys():
# Generate the badge's info
today = date.today()
badge_info = {
'name': name,
'criteria': description,
'time': today.strftime("%m/%d/%y"),
'bundle_id': self._id
}
badge_json[name] = badge_info
# Save the new badge info to the DS object
self._list.metadata['badge_list'] = json.dumps(badge_json)
datastore.write(self._list)
def __notify_state_cb(self, file_transfer, pspec):
if file_transfer.props.state == filetransfer.FT_STATE_OPEN:
logging.debug('__notify_state_cb OPEN')
self._ds_object.metadata['title'] = file_transfer.title
self._ds_object.metadata['description'] = file_transfer.description
self._ds_object.metadata['progress'] = '0'
self._ds_object.metadata['keep'] = '0'
self._ds_object.metadata['buddies'] = ''
self._ds_object.metadata['preview'] = ''
self._ds_object.metadata['icon-color'] = \
file_transfer.buddy.props.color.to_string()
self._ds_object.metadata['mime_type'] = file_transfer.mime_type
elif file_transfer.props.state == filetransfer.FT_STATE_COMPLETED:
logging.debug('__notify_state_cb COMPLETED')
self._ds_object.metadata['progress'] = '100'
self._ds_object.file_path = file_transfer.destination_path
datastore.write(self._ds_object, transfer_ownership=True,
reply_handler=self.__reply_handler_cb,
error_handler=self.__error_handler_cb)
elif file_transfer.props.state == filetransfer.FT_STATE_CANCELLED:
logging.debug('__notify_state_cb CANCELLED')
object_id = self._ds_object.object_id
if object_id is not None:
self._ds_object.destroy()
datastore.delete(object_id)
self._ds_object = None
def resize_button_press_event_cb(self, entry, event):
jobject = self.selected_journal_entry
filename = jobject.get_file_path()
im = pygame.image.load(filename)
image_width, image_height = im.get_size()
resize_to_width = int(self.resize_width_entry.get_text())
if (image_width < resize_to_width):
self.alert(_('Error'), _('Image cannot be made larger, only smaller.'))
return
tempfile = os.path.join(self.get_activity_root(), 'instance',
'tmp%i' % time.time())
try:
scaled_pixbuf = gtk.gdk.pixbuf_new_from_file_at_size(filename, resize_to_width, ARBITRARY_LARGE_HEIGHT)
scaled_pixbuf.save(tempfile, "jpeg", {"quality":"%d" % JPEG_QUALITY})
except:
print 'File could not be converted'
return
jobject.file_path = tempfile
jobject.metadata['mime_type'] = 'image/jpeg'
im = pygame.image.load(tempfile)
image_width, image_height = im.get_size()
self.dimension_label.set_text(str(image_width) + "x" + str(image_height))
self.dimension_label.show()
datastore.write(jobject, update_mtime=False,
reply_handler=self.datastore_write_cb,
error_handler=self.datastore_write_error_cb)
title = jobject.metadata.get('title', None)
self.update_log_entries += '\n' + _('Entry %s resized.') % title
def update_entry(self):
needs_update = False
if self.selected_journal_entry is None:
return
object_id = self.selected_journal_entry.object_id
jobject = datastore.get(object_id)
old_title = jobject.metadata.get('title', None)
if old_title != self.title_entry.props.text:
jobject.metadata['title'] = self.title_entry.props.text
jobject.metadata['title_set_by_user'] = '******'
self.update_log_entries += '\n' + _('Entry title changed to %s') % self.title_entry.props.text
needs_update = True
old_tags = jobject.metadata.get('tags', None)
new_tags = self.tags_textview.props.buffer.props.text
if old_tags != new_tags:
jobject.metadata['tags'] = new_tags
self.update_log_entries += '\n' + _('Entry %s tags updated.') % self.title_entry.props.text
needs_update = True
old_description = jobject.metadata.get('description', None)
new_description = self.description_textview.props.buffer.props.text
if old_description != new_description:
jobject.metadata['description'] = new_description
self.update_log_entries += '\n' + _('Entry %s description updated.') % self.title_entry.props.text
needs_update = True
if needs_update:
datastore.write(jobject, update_mtime=False,
reply_handler=self.datastore_write_cb,
error_handler=self.datastore_write_error_cb)
self.btn_save.props.sensitive = False
def __init__(self, handle):
activity.Activity.__init__(self, handle)
""" Create the official Sugar toolbox at the top of the screen"""
toolbox = activity.ActivityToolbox(self)
self.set_toolbox(toolbox)
toolbox.show()
file_location = activity.get_activity_root() + \
"/data/reckonprimer_report.txt"
file_handle = open(file_location, 'w')
file_handle.write("Report: " + profile.get_nick_name() + \
strftime(" %Y-%m-%d %H:%M:%S") + "\n")
file_handle.close()
title = "Report: " + profile.get_nick_name() + \
strftime(" %Y-%m-%d %H:%M:%S")
mime = "text/plain"
file_path = activity.get_activity_root() + \
"/data/reckonprimer_report.txt"
favorite = "1"
tags = "ReckonPrimer"
journal_object = datastore.create()
journal_object.metadata['title'] = title
journal_object.metadata['mime_type'] = mime
journal_object.file_path = file_path
journal_object.metadata['keep'] = favorite
journal_object.metadata['tags'] = tags
journal_object.metadata['icon-color'] = '#AFD600,#5B615C'
datastore.write( journal_object )
journal_object.destroy()
self.run_session()
def __activate_cb(self, menu_item, activity, abi, format):
logger.debug("exporting file: %r" % format)
exp_props = format["exp_props"]
# special case HTML export to set the activity name as the HTML title
if format["mime_type"] == "text/html":
exp_props += " title:" + activity.metadata["title"] + ";"
# create a new journal item
fileObject = datastore.create()
act_meta = activity.metadata
fileObject.metadata["title"] = act_meta["title"] + " (" + format["jpostfix"] + ")"
fileObject.metadata["title_set_by_user"] = act_meta["title_set_by_user"]
fileObject.metadata["mime_type"] = format["mime_type"]
fileObject.metadata["fulltext"] = abi.get_content(extension_or_mimetype=".txt")[:3000]
fileObject.metadata["icon-color"] = act_meta["icon-color"]
fileObject.metadata["activity"] = act_meta["activity"]
fileObject.metadata["keep"] = act_meta["keep"]
preview = activity.get_preview()
if preview is not None:
fileObject.metadata["preview"] = dbus.ByteArray(preview)
fileObject.metadata["share-scope"] = act_meta["share-scope"]
# write out the document contents in the requested format
fileObject.file_path = os.path.join(activity.get_activity_root(), "instance", "%i" % time.time())
abi.save("file://" + fileObject.file_path, format["mime_type"], exp_props)
# store the journal item
datastore.write(fileObject, transfer_ownership=True)
fileObject.destroy()
del fileObject
def write_file(self, file_path):
""" Write data to journal on quit """
if hasattr(self, 'ji') and len(self.ji.temp_buffer) > 0:
# Append new data to Journal entry
writer = csv.writer(open(file_path, 'ab'))
# Also output to a separate file as a workaround to Ticket 2127
tmp_file_path = join(environ['SUGAR_ACTIVITY_ROOT'], 'instance',
'sensor_data' + '.csv')
log.debug('saving sensor data to %s' % (tmp_file_path))
writer2 = csv.writer(open(tmp_file_path, 'ab'))
for datum in self.ji.temp_buffer:
writer.writerow([datum])
writer2.writerow([datum])
# Set the mimetype so that the file can be read by other Activities
self.metadata['mime_type'] = 'text/csv'
jobject = datastore.create()
jobject.metadata['title'] = _('Measure Log')
jobject.metadata['keep'] = '0'
jobject.metadata['buddies'] = ''
jobject.metadata['preview'] = ''
jobject.metadata['icon-color'] = self.icon_colors
jobject.metadata['mime_type'] = 'text/csv'
jobject.file_path = tmp_file_path
datastore.write(jobject)
jobject.destroy()
del jobject
remove(tmp_file_path)
def generate_bundle(nick, new_basename):
"""Generate a new .xo bundle for the activity and copy it into the
Journal.
"""
new_activity_name = _customize_activity_info(
nick, new_basename)
user_activities_path = get_user_activities_path()
if os.path.exists(os.path.join(user_activities_path, new_basename,
'dist')):
for path in glob.glob(os.path.join(user_activities_path, new_basename,
'dist', '*')):
os.remove(path)
config = bundlebuilder.Config(source_dir=os.path.join(
user_activities_path, new_basename),
dist_name='%s-1.xo' % (new_activity_name))
bundlebuilder.cmd_dist_xo(config, None)
dsobject = datastore.create()
dsobject.metadata['title'] = '%s-1.xo' % (new_activity_name)
dsobject.metadata['mime_type'] = 'application/vnd.olpc-sugar'
dsobject.set_file_path(os.path.join(
user_activities_path, new_basename, 'dist',
'%s-1.xo' % (new_activity_name)))
datastore.write(dsobject)
dsobject.destroy()
def open_url(self, url):
"""Ask the journal to open an URL for us."""
from sugar import profile
from shutil import rmtree
from sugar.datastore import datastore
from sugar.activity.activity import show_object_in_journal
from tempfile import mkdtemp
tmpfolder = mkdtemp('.tmp', 'url',
os.path.join(self.get_activity_root(), 'instance'))
tmpfilepath = os.path.join(tmpfolder, 'url')
try:
tmpfile = open(tmpfilepath, 'w')
tmpfile.write(url)
tmpfile.close()
os.chmod(tmpfolder, 0755)
os.chmod(tmpfilepath, 0755)
jobject = datastore.create()
metadata = {
'title': url,
'title_set_by_user': '******',
'buddies': '',
'preview': '',
'icon-color': profile.get_color().to_string(),
'mime_type': 'text/uri-list',
}
for k, v in metadata.items():
jobject.metadata[k] = v # the dict.update method is missing =(
jobject.file_path = tmpfilepath
datastore.write(jobject)
show_object_in_journal(jobject.object_id)
jobject.destroy()
finally:
rmtree(tmpfilepath, ignore_errors=True) # clean up!
def create_journal_entry(self, widget, data=None):
filename = self._filechooser.get_filename()
journal_entry = datastore.create()
journal_entry.metadata['title'] = self.make_new_filename(filename)
journal_entry.metadata['title_set_by_user'] = '******'
journal_entry.metadata['keep'] = '0'
file_mimetype = mime.get_for_file(filename)
if not file_mimetype is None:
journal_entry.metadata['mime_type'] = file_mimetype
journal_entry.metadata['buddies'] = ''
if file_mimetype.startswith('image/') and file_mimetype != 'image/vnd.djvu':
preview = self.create_preview_metadata(filename)
elif file_mimetype == 'application/x-cbz':
fname = self.extract_image(filename)
preview = self.create_preview_metadata(fname)
os.remove(fname)
else:
preview = ''
if not preview == '':
journal_entry.metadata['preview'] = dbus.ByteArray(preview)
else:
journal_entry.metadata['preview'] = ''
journal_entry.file_path = filename
datastore.write(journal_entry)
self.update_log_entries += '\n' + _('File %s copied to the Journal.') % filename
self.alert(_('Success'), _('%s added to Journal.')
% self.make_new_filename(filename))
def exportFile(self, _widget, fancy, amount, dialog):
fullPath= _widget.value;
dialog.close()
if self.script.journal:
dsObject= datastore.create()
print dir(dsObject.metadata)
dsObject.metadata.get_dictionary().update(self.autogenerateMetadata())
dsObject.metadata['title']= fullPath.actualValue
if fancy == "Fancy":
dsObject.metadata['mime_type'] = 'text/html'
else:
dsObject.metadata['mime_type'] = 'text/plain'
fullPath = directories['instance'] + 'temp.bdw'
self.script.export((directories['instance'] + 'temp.bdw', fancy, amount));
dsObject.set_file_path(fullPath)
datastore.write(dsObject)
else:
fileName, fileExtension= os.path.splitext(fullPath);
if fancy == "Fancy" and fileExtension != ".html":
fullPath+= ".html"
elif fancy == "Plain" and fileExtension != ".txt":
fullPath+= ".txt"
if os.path.isfile(fullPath):
self.confirmActionDialog(_("Overwrite?"),
[ _("This file already exists:"),
os.path.basename(fullPath),
_("Are you sure you want to overwrite it?")],
okayFunction= self.script.export,
arguments=(fullPath,fancy, amount));
else:
self.script.export((fullPath, fancy, amount));
def __export_pdf_cb(self, event):
maxx, maxy = self._main_area.get_max_area()
true_width = int(maxx)
true_height = int(maxy)
# Create the new journal entry
fileObject = datastore.create()
act_meta = self.metadata
fileObject.metadata['title'] = act_meta['title'] + ' (PDF)'
fileObject.metadata['title_set_by_user'] = \
act_meta['title_set_by_user']
fileObject.metadata['mime_type'] = 'application/pdf'
# TODO: add text thoughts into fulltext metadata
# fileObject.metadata['fulltext'] = ...
fileObject.metadata['icon-color'] = act_meta['icon-color']
fileObject.file_path = os.path.join(self.get_activity_root(),
'instance', '%i' % time.time())
filename = fileObject.file_path
surface = cairo.PDFSurface(filename, true_width, true_height)
cairo_context = cairo.Context(surface)
context = pangocairo.CairoContext(cairo_context)
self._main_area.export(context, true_width, true_height, False)
surface.finish()
datastore.write(fileObject, transfer_ownership=True)
fileObject.destroy()
del fileObject
def _license_cb(self,widget,uri):
if not self._jobject:
ll.set_default(uri)
self.refresh()
else:
ll.write(self._jobject.get_file_path(),uri)
self._jobject.metadata['license'] = uri
datastore.write(self._jobject, update_mtime=False)
def get_new_dsobject(self):
jobject = datastore.create()
jobject.metadata['title'] = 'PyDebug'
jobject.metadata['activity'] = 'org.laptop.PyDebug'
jobject.metadata['keep'] = '1'
jobject.metadata['preview'] = ''
datastore.write(jobject)
return jobject
def export(self, widget, data):
jobject = datastore.create()
jobject.metadata['title'] = self.metadata['title']
mime_type = data[1]
jobject.metadata['mime_type'] = mime_type
file_path = tempfile.mktemp()
self.canvas.exports[mime_type](file_path)
jobject.set_file_path(file_path)
datastore.write(jobject)
def store_data(entry_title, mime_type, file_path):
file_dsobject = datastore.create()
file_dsobject.metadata['TimeLapse'] = 'yes'
file_dsobject.metadata['TimeLapsetitle'] = entry_title
file_dsobject.metadata['title'] = entry_title
file_dsobject.metadata['mime_type'] = mime_type
file_dsobject.metadata['description'] = ''
file_dsobject.set_file_path(file_path)
datastore.write(file_dsobject)
file_dsobject.destroy()
def copiar_al_diario(self, widget):
descripcion = utils.describe_archivo(utils.Archivos)
mime = utils.describe_mime(utils.Archivos)
if not 'directory' in descripcion:
acopiar = datastore.create()
acopiar.metadata['title'] = utils.Archivos
acopiar.metadata['mime_type'] = mime
acopiar.set_file_path(os.getcwd() + "/" + utils.Archivos)
datastore.write(acopiar)
acopiar.destroy()
def handle_key_press(key):
tmp_dir = os.path.join(env.get_profile_path(), 'data')
fd, file_path = tempfile.mkstemp(dir=tmp_dir)
os.close(fd)
window = gtk.gdk.get_default_root_window()
width, height = window.get_size()
x_orig, y_orig = window.get_origin()
screenshot = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, has_alpha=False,
bits_per_sample=8, width=width,
height=height)
screenshot.get_from_drawable(window, window.get_colormap(), x_orig,
y_orig, 0, 0, width, height)
screenshot.save(file_path, 'png')
client = gconf.client_get_default()
color = client.get_string('/desktop/sugar/user/color')
content_title = None
shell_model = shell.get_model()
zoom_level = shell_model.zoom_level
# TRANS: Nouns of what a screenshot contains
if zoom_level == shell_model.ZOOM_MESH:
content_title = _('Mesh')
elif zoom_level == shell_model.ZOOM_GROUP:
content_title = _('Group')
elif zoom_level == shell_model.ZOOM_HOME:
content_title = _('Home')
elif zoom_level == shell_model.ZOOM_ACTIVITY:
activity = shell_model.get_active_activity()
if activity != None:
content_title = activity.get_title()
if content_title == None:
content_title = _('Activity')
if content_title is None:
title = _('Screenshot')
else:
title = _('Screenshot of \"%s\"') % content_title
jobject = datastore.create()
try:
jobject.metadata['title'] = title
jobject.metadata['keep'] = '0'
jobject.metadata['buddies'] = ''
jobject.metadata['preview'] = _get_preview_data(screenshot)
jobject.metadata['icon-color'] = color
jobject.metadata['mime_type'] = 'image/png'
jobject.file_path = file_path
datastore.write(jobject, transfer_ownership=True)
finally:
jobject.destroy()
del jobject
def show_in_journal(self):
'''send the generated .xo bundle to the journal'''
jobject = datastore.create()
jobject.metadata['title'] = self.title
jobject.metadata['mime_type'] = 'application/vnd.olpc-sugar'
jobject.metadata['icon-color'] = profile.get_color().to_string()
jobject.file_path = self.xo_path
datastore.write(jobject)
activity.show_object_in_journal(jobject.object_id)
def _save_as_image(self, widget):
if self.current_chart:
jobject = datastore.create()
jobject.metadata['title'] = self.metadata["title"]
jobject.metadata['mime_type'] = "image/png"
self.current_chart.as_png(_CHART_FILE)
jobject.set_file_path(_CHART_FILE)
datastore.write(jobject)
def _save_descriptions_cb(self, button=None):
''' Find the object in the datastore and write out the changes
to the decriptions. '''
for s in self.slides:
if not s.owner:
continue
jobject = datastore.get(s.uid)
jobject.metadata['description'] = s.desc
datastore.write(jobject, update_mtime=False,
reply_handler=self.datastore_write_cb,
error_handler=self.datastore_write_error_cb)
def _save_as_image(self, widget):
if self.current_chart:
jobject = datastore.create()
jobject.metadata['title'] = self.metadata["title"]
jobject.metadata['mime_type'] = "image/png"
self.current_chart.as_png(_CHART_FILE)
jobject.set_file_path(_CHART_FILE)
datastore.write(jobject)
def save_byte_array(self, path, title= None, color= None):
if color == None:
color = profile.get_color().to_string()
_logger.debug('Save new game in datastore')
# Saves the zip in datastore
gameObject = datastore.create()
gameObject.metadata['title'] = title
gameObject.metadata['mime_type'] = 'application/x-memorize-project'
gameObject.metadata['icon-color'] = color
gameObject.file_path = path
datastore.write(gameObject)
def save_image(self,image):
journalobj = datastore.create()
journalobj.metadata['title'] = _('Pointillism')
journalobj.metadata['mime_type'] = 'image/jpeg'
file_path = os.path.join(os.environ['SUGAR_ACTIVITY_ROOT'], 'data', 'pointillism.jpg')
pygame.image.save(image,file_path)
journalobj.set_file_path(file_path)
datastore.write(journalobj)
journalobj.destroy()
def __save_to_journal_clicked_cb(self, gobject):
filename = self._images[self._pic_index]['name']
imgpath = os.path.join(self._instance_directory, filename)
journal_entry = datastore.create()
journal_entry.metadata['title'] =\
self._images[self._pic_index]['title']
journal_entry.metadata['mime_type'] = 'image/jpeg'
journal_entry.metadata['tags'] = 'XoScope'
journal_entry.set_file_path(imgpath)
datastore.write(journal_entry)
journal_entry.destroy()
def save_image(self,image):
journalobj = datastore.create()
journalobj.metadata['title'] = _('Panorama')
journalobj.metadata['mime_type'] = 'image/jpeg'
file_path = os.path.join(os.environ['SUGAR_ACTIVITY_ROOT'], 'data', 'panorama.jpg')
pygame.image.save(image,file_path)
journalobj.set_file_path(file_path)
datastore.write(journalobj)
journalobj.destroy()
def _save_recording_cb(self, button=None):
savename = self._sounds[self._selected_sound].lower() + '.ogg'
if os.path.exists(os.path.join(self.datapath, 'output.ogg')):
dsobject = datastore.create()
dsobject.metadata['title'] = savename
dsobject.metadata['icon-color'] = \
profile.get_color().to_string()
dsobject.metadata['mime_type'] = 'audio/ogg'
dsobject.set_file_path(os.path.join(self.datapath, 'output.ogg'))
datastore.write(dsobject)
dsobject.destroy()
return
def save(self):
"""Request that the activity is saved to the Journal.
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
own implementation of write_file() to save your Activity specific data.
"""
if self._jobject is None:
logging.debug('Cannot save, no journal object.')
return
logging.debug('Activity.save: %r', self._jobject.object_id)
if self._updating_jobject:
logging.info('Activity.save: still processing a previous request.')
return
buddies_dict = self._get_buddies()
if buddies_dict:
self.metadata['buddies_id'] = json.dumps(buddies_dict.keys())
self.metadata['buddies'] = json.dumps(self._get_buddies())
preview = self.get_preview()
if preview is not None:
self.metadata['preview'] = dbus.ByteArray(preview)
if not self.metadata.get('activity_id', ''):
self.metadata['activity_id'] = self.get_id()
file_path = os.path.join(get_activity_root(), 'instance',
'%i' % time.time())
try:
self.write_file(file_path)
except NotImplementedError:
logging.debug('Activity.write_file is not implemented.')
else:
if os.path.exists(file_path):
self._owns_file = True
self._jobject.file_path = file_path
# Cannot call datastore.write async for creates:
# https://dev.laptop.org/ticket/3071
if self._jobject.object_id is None:
datastore.write(self._jobject, transfer_ownership=True)
else:
self._updating_jobject = True
datastore.write(self._jobject,
transfer_ownership=True,
reply_handler=self.__save_cb,
error_handler=self.__save_error_cb)
def save(self):
"""Request that the activity is saved to the Journal.
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
own implementation of write_file() to save your Activity specific data.
"""
if self._jobject is None:
logging.debug('Cannot save, no journal object.')
return
logging.debug('Activity.save: %r' % self._jobject.object_id)
if self._updating_jobject:
logging.info('Activity.save: still processing a previous request.')
return
buddies_dict = self._get_buddies()
if buddies_dict:
self.metadata['buddies_id'] = cjson.encode(buddies_dict.keys())
self.metadata['buddies'] = cjson.encode(self._get_buddies())
preview = self.get_preview()
if preview is not None:
self.metadata['preview'] = dbus.ByteArray(preview)
if not self.metadata.get('activity_id', ''):
self.metadata['activity_id'] = self.get_id()
file_path = os.path.join(self.get_activity_root(), 'instance',
'%i' % time.time())
try:
self.write_file(file_path)
except NotImplementedError:
logging.debug('Activity.write_file is not implemented.')
else:
if os.path.exists(file_path):
self._owns_file = True
self._jobject.file_path = file_path
# Cannot call datastore.write async for creates:
# https://dev.laptop.org/ticket/3071
if self._jobject.object_id is None:
datastore.write(self._jobject, transfer_ownership=True)
else:
self._updating_jobject = True
datastore.write(self._jobject,
transfer_ownership=True,
reply_handler=self.__save_cb,
error_handler=self.__save_error_cb)
def save_document(sftp, subject, document, mimetype):
path = os.path.join(MYFILES, document)
sftp.get(os.path.join(subject, document), path)
jobject = datastore.create()
jobject.metadata['title'] = document
jobject.metadata['icon-color'] = \
profile.get_color().to_string()
jobject.metadata['mime_type'] = mimetype
jobject.file_path = path
datastore.write(jobject)
save_log(sftp, 'Saving document: %s' % (document))
def _export_turtleblocks(self, alert):
data = self.game.tu.current
step = 75
first = data[0] * step
second = data[1] * step
third = data[2] * step
fourth = data[3] * step
fifth = data[4] * step
turtle_data = (
'[[0, ["start", 219], 248, 92, [null, 1]],'
+ '[1, ["repeat", 189], 266, 138, [0, 2, 3, null]],'
+ '[2, ["number", 4], 322, 138, [1, null]],'
+ '[3, "forward", 284, 180, [1, 4, 5]],'
+ ('[4, ["number", %s], 348, 180, [3, null]],' % first)
+ '[5, "right", 284, 222, [3, 6, 7]],'
+ '[6, ["number", 90], 342, 222, [5, null]],'
+ '[7, "forward", 284, 264, [5, 8, 9]],'
+ ('[8, ["number", %s], 348, 264, [7, null]],' % second)
+ '[9, "right", 284, 306, [7, 10, 11]],'
+ '[10, ["number", 90], 342, 306, [9, null]],'
+ '[11, "forward", 284, 348, [9, 12, 13]],'
+ ('[12, ["number", %s], 348, 348, [11, null]],' % third)
+ '[13, "right", 284, 390, [11, 14, 15]],'
+ '[14, ["number", 90], 342, 390, [13, null]],'
+ '[15, "forward", 284, 432, [13, 16, 17]],'
+ ('[16, ["number", %s], 348, 432, [15, null]],' % fourth)
+ '[17, "right", 284, 474, [15, 18, 19]],'
+ '[18, ["number", 90], 342, 474, [17, null]],'
+ '[19, "forward", 284, 516, [17, 20, 21]],'
+ ('[20, ["number", %s], 348, 516, [19, null]],' % fifth)
+ '[21, "right", 284, 558, [19, 22, null]],'
+ '[22, ["number", 90], 342, 558, [21, null]]]'
)
file_path = os.path.join(self.datapath, "output.tb")
with open(file_path, "w") as file:
file.write(turtle_data)
dsobject = datastore.create()
dsobject.metadata["title"] = "%s %s" % (self.metadata["title"], _("TurtleBlocks"))
dsobject.metadata["icon-color"] = profile.get_color().to_string()
dsobject.metadata["mime_type"] = "application/x-turtle-art"
dsobject.metadata["activity"] = "org.laptop.TurtleArtActivity"
dsobject.set_file_path(file_path)
datastore.write(dsobject)
dsobject.destroy()
os.remove(file_path)
gobject.timeout_add(1000, self._remove_alert, alert)
def write_file(self, file_path):
''' Write data to journal, if there is any data to write '''
# Check to see if there are any new instruments to save
if hasattr(self, 'new_instrument_toolbar'):
for i, instrument in enumerate(
self.new_instrument_toolbar.new_instruments):
log.debug('saving %s' % (instrument))
notes = ''
for i, note in enumerate(INSTRUMENT_DICT[instrument]):
notes += '%0.3f' % note
if i < len(INSTRUMENT_DICT[instrument]) - 1:
notes += ' '
self.metadata['%s%s' % (PREFIX, instrument)] = notes
# FIXME: Don't use ""s around data
if hasattr(self, 'data_logger') and \
self.new_recording and \
len(self.data_logger.data_buffer) > 0:
# Append new data to Journal entry
fd = open(file_path, 'ab')
writer = csv.writer(fd)
# Also output to a separate file as a workaround to Ticket 2127
# (the assumption being that this file will be opened by the user)
tmp_data_file = os.path.join(os.environ['SUGAR_ACTIVITY_ROOT'],
'instance', 'sensor_data' + '.csv')
log.debug('saving sensor data to %s' % (tmp_data_file))
if self._dsobject is None: # first time, so create
fd2 = open(tmp_data_file, 'wb')
else: # we've been here before, so append
fd2 = open(tmp_data_file, 'ab')
writer2 = csv.writer(fd2)
# Pop data off start of buffer until it is empty
for i in range(len(self.data_logger.data_buffer)):
datum = self.data_logger.data_buffer.pop(0)
writer.writerow([datum])
writer2.writerow([datum])
fd.close()
fd2.close()
# Set the proper mimetype
self.metadata['mime_type'] = 'text/csv'
if os.path.exists(tmp_data_file):
if self._dsobject is None:
self._dsobject = datastore.create()
self._dsobject.metadata['title'] = _('Measure Log')
self._dsobject.metadata['icon-color'] = self.icon_colors
self._dsobject.metadata['mime_type'] = 'text/csv'
self._dsobject.set_file_path(tmp_data_file)
datastore.write(self._dsobject)
def _copy(self, path):
os.chdir('/tmp/')
pp = self.nombre.get_text() + '.xo'
file = open(pp, 'w')
file.close()
self.compress(path, pp)
acopiar = datastore.create()
acopiar.metadata['title'] = pp
acopiar.metadata['mime_type'] = 'application/vnd.olpc-sugar'
acopiar.set_file_path('/tmp/' + pp)
datastore.write(acopiar)
acopiar.destroy()
shutil.rmtree(path)
os.remove(pp)
def openSaveDialog(self):
if self.script.filepath is not None:
if self.script.journal:
dsObject= self.script.filepath
self.script.saveFile(directories['instance'] + 'temp.bdw')
dsObject.set_file_path(self.script.filepath)
datastore.write(dsObject)
else:
self.script.saveFile(self.script.filepath)
self.script.controls["file-button-save"].disabled= not self.script.unsaved
self.script.controls["file-button-save"].blur()
self.script.controls["file-button-save"].repaint()
else:
self.openSaveAsDialog();
def _export_turtleblocks(self, alert):
data = self.game.tu.current
step = 75
first = data[0] * step
second = data[1] * step
third = data[2] * step
fourth = data[3] * step
fifth = data[4] * step
turtle_data = '[[0, ["start", 219], 248, 92, [null, 1]],' +\
'[1, ["repeat", 189], 266, 138, [0, 2, 3, null]],' +\
'[2, ["number", 4], 322, 138, [1, null]],' +\
'[3, "forward", 284, 180, [1, 4, 5]],' +\
('[4, ["number", %s], 348, 180, [3, null]],' % first) +\
'[5, "right", 284, 222, [3, 6, 7]],' +\
'[6, ["number", 90], 342, 222, [5, null]],' +\
'[7, "forward", 284, 264, [5, 8, 9]],' +\
('[8, ["number", %s], 348, 264, [7, null]],' % second) +\
'[9, "right", 284, 306, [7, 10, 11]],' +\
'[10, ["number", 90], 342, 306, [9, null]],' +\
'[11, "forward", 284, 348, [9, 12, 13]],' +\
('[12, ["number", %s], 348, 348, [11, null]],'% third) +\
'[13, "right", 284, 390, [11, 14, 15]],' +\
'[14, ["number", 90], 342, 390, [13, null]],' +\
'[15, "forward", 284, 432, [13, 16, 17]],' +\
('[16, ["number", %s], 348, 432, [15, null]],'% fourth) +\
'[17, "right", 284, 474, [15, 18, 19]],' +\
'[18, ["number", 90], 342, 474, [17, null]],' +\
'[19, "forward", 284, 516, [17, 20, 21]],' +\
('[20, ["number", %s], 348, 516, [19, null]],'% fifth) +\
'[21, "right", 284, 558, [19, 22, null]],' +\
'[22, ["number", 90], 342, 558, [21, null]]]'
file_path = os.path.join(self.datapath, 'output.tb')
with open(file_path, "w") as file:
file.write(turtle_data)
dsobject = datastore.create()
dsobject.metadata['title'] = '%s %s' % (self.metadata['title'],
_('TurtleBlocks'))
dsobject.metadata['icon-color'] = profile.get_color().to_string()
dsobject.metadata['mime_type'] = 'application/x-turtle-art'
dsobject.metadata['activity'] = 'org.laptop.TurtleArtActivity'
dsobject.set_file_path(file_path)
datastore.write(dsobject)
dsobject.destroy()
os.remove(file_path)
gobject.timeout_add(1000, self._remove_alert, alert)
def onProgressChange64(self, web_progress, request, cur_self_progress,
max_self_progress, cur_total_progress,
max_total_progress):
percent = (cur_self_progress * 100) / max_self_progress
if (time.time() - self._last_update_time) < _MIN_TIME_UPDATE and \
(percent - self._last_update_percent) < _MIN_PERCENT_UPDATE:
return
self._last_update_time = time.time()
self._last_update_percent = percent
if percent < 100:
self.dl_jobject.metadata['progress'] = str(percent)
datastore.write(self.dl_jobject)
def onStateChange(self, web_progress, request, state_flags, status):
if state_flags & interfaces.nsIWebProgressListener.STATE_START:
self._create_journal_object()
self._object_id = self.dl_jobject.object_id
alert = TimeoutAlert(9)
alert.props.title = _('Download started')
alert.props.msg = _('%s' % self._get_file_name())
self._activity.add_alert(alert)
alert.connect('response', self.__start_response_cb)
alert.show()
global _active_downloads
_active_downloads.append(self)
elif state_flags & interfaces.nsIWebProgressListener.STATE_STOP:
if NS_FAILED(status): # download cancelled
return
self._stop_alert = Alert()
self._stop_alert.props.title = _('Download completed')
self._stop_alert.props.msg = _('%s' % self._get_file_name())
open_icon = Icon(icon_name='zoom-activity')
self._stop_alert.add_button(gtk.RESPONSE_APPLY,
_('Show in Journal'), open_icon)
open_icon.show()
ok_icon = Icon(icon_name='dialog-ok')
self._stop_alert.add_button(gtk.RESPONSE_OK, _('Ok'), ok_icon)
ok_icon.show()
self._activity.add_alert(self._stop_alert)
self._stop_alert.connect('response', self.__stop_response_cb)
self._stop_alert.show()
self.dl_jobject.metadata['title'] = _('File %s from %s.') % \
(self._get_file_name(), self._source.spec)
self.dl_jobject.metadata['progress'] = '100'
self.dl_jobject.file_path = self._target_file.path
if self._mime_type in ['application/octet-stream',
'application/x-zip']:
sniffed_mime_type = mime.get_for_file(self._target_file.path)
self.dl_jobject.metadata['mime_type'] = sniffed_mime_type
datastore.write(self.dl_jobject,
transfer_ownership=True,
reply_handler=self._internal_save_cb,
error_handler=self._internal_save_error_cb,
timeout=360 * DBUS_PYTHON_TIMEOUT_UNITS_PER_SECOND)
def _copy_to_journal(self):
formats = self._cb_object.get_formats().keys()
most_significant_mime_type = mime.choose_most_significant(formats)
format_ = self._cb_object.get_formats()[most_significant_mime_type]
transfer_ownership = False
if most_significant_mime_type == 'text/uri-list':
uris = mime.split_uri_list(format_.get_data())
if len(uris) == 1 and uris[0].startswith('file://'):
parsed_url = urlparse.urlparse(uris[0])
file_path = parsed_url.path # pylint: disable=E1101
transfer_ownership = False
mime_type = mime.get_for_file(file_path)
else:
file_path = self._write_to_temp_file(format_.get_data())
transfer_ownership = True
mime_type = 'text/uri-list'
else:
if format_.is_on_disk():
parsed_url = urlparse.urlparse(format_.get_data())
file_path = parsed_url.path # pylint: disable=E1101
transfer_ownership = False
mime_type = mime.get_for_file(file_path)
else:
file_path = self._write_to_temp_file(format_.get_data())
transfer_ownership = True
sniffed_mime_type = mime.get_for_file(file_path)
if sniffed_mime_type == 'application/octet-stream':
mime_type = most_significant_mime_type
else:
mime_type = sniffed_mime_type
jobject = datastore.create()
jobject.metadata['title'] = self._cb_object.get_name()
jobject.metadata['keep'] = '0'
jobject.metadata['buddies'] = ''
jobject.metadata['preview'] = ''
client = gconf.client_get_default()
color = client.get_string('/desktop/sugar/user/color')
jobject.metadata['icon-color'] = color
jobject.metadata['mime_type'] = mime_type
jobject.file_path = file_path
datastore.write(jobject, transfer_ownership=transfer_ownership)
return jobject
def update_file_entry(self, archive_name):
self._logger.debug("Sending %s to Journal", self._jobject.object_id)
self.metadata['mime_type'] = "application/x-zip"
self.metadata['title'] = "[PACKED]" + self.metadata['title']
self._logger.debug("Archive_name = %s", archive_name);
file_name = os.path.split(archive_name)[1]
filepath = os.path.join(self.get_activity_root(), 'instance', file_name)
self._logger.debug("Saving to %s", archive_name);
#shutil.copy(archive_name, filepath)
try:
os.chmod(archive_name, 0744)
self._logger.debug("Trying to put %s in journal", archive_name)
self._jobject.file_path = archive_name
datastore.write(self._jobject, transfer_ownership=True)
self._logger.debug("Written to datastore");
except Exception, e:
self._logger.error("Write to datastore failed: %s", str(e))
def __keep_in_journal_cb(self, menu_item):
mime_type = mime.get_from_file_name(self._document_path)
if mime_type == 'application/octet-stream':
mime_type = mime.get_for_file(self._document_path)
self._jobject = datastore.create()
title = _('Source') + ': ' + self._title
self._jobject.metadata['title'] = title
self._jobject.metadata['keep'] = '0'
self._jobject.metadata['buddies'] = ''
self._jobject.metadata['preview'] = ''
self._jobject.metadata['icon-color'] = self._color
self._jobject.metadata['mime_type'] = mime_type
self._jobject.metadata['source'] = '1'
self._jobject.file_path = self._document_path
datastore.write(self._jobject, transfer_ownership=True,
reply_handler=self.__internal_save_cb,
error_handler=self.__internal_save_error_cb)
