def load_from_journal(self, journal_data):
for card in self._card_data:
alphabet = card[0]
if alphabet in journal_data:
for images in journal_data[alphabet]:
imagedataobject = datastore.get(images[0])
audiodataobject = datastore.get(images[1])
if imagedataobject and audiodataobject:
imagepath = imagedataobject.get_file_path()
pixbuf = image_file_to_pixbuf(imagepath, self._card_width,
self._card_height)
audiopath = audiodataobject.get_file_path()
s = Sprite(self._sprites, 0, 0, pixbuf)
self._image_data[alphabet].append((s, audiopath))
self._pictures.append(s)
def _setup_canvas(self):
''' Create a canvas in a Gtk.Fixed '''
self.fixed = Gtk.Fixed()
self.fixed.connect('size-allocate', self._fixed_resize_cb)
self.fixed.show()
self.set_canvas(self.fixed)
self._vbox = Gtk.VBox(False, 0)
self._vbox.set_size_request(Gdk.Screen.width(), Gdk.Screen.height())
self.fixed.put(self._vbox, 0, 0)
self._vbox.show()
self._canvas = Gtk.DrawingArea()
self._canvas.set_size_request(int(Gdk.Screen.width()),
int(Gdk.Screen.height()))
self._canvas.show()
self.show_all()
self._vbox.pack_end(self._canvas, True, True, 0)
self._vbox.show()
self.show_all()
self.vmw = Game(self._canvas, self)
self.vmw.level = self._play_level
LEVEL_BUTTONS[self._play_level].set_active(True)
self.vmw.card_type = self._card_type
self.vmw.robot = False
self.vmw.robot_time = self._robot_time
self.vmw.low_score = self._low_score
self.vmw.all_scores = self._all_scores
self.vmw.numberO = self._numberO
# NUMBER_O_BUTTONS[self._numberO].set_active(True)
self.vmw.numberC = self._numberC
# NUMBER_C_BUTTONS[self._numberC].set_active(True)
self.vmw.matches = self._matches
self.vmw.robot_matches = self._robot_matches
self.vmw.total_time = self._total_time
self.vmw.buddies = []
self.vmw.word_lists = self._word_lists
self.vmw.editing_word_list = self._editing_word_list
if hasattr(self, '_custom_object') and self._custom_object is not None:
self.vmw._find_custom_paths(datastore.get(self._custom_object))
for i in range(9):
if hasattr(self, '_custom_jobject') and \
self._custom_jobject[i] is not None:
self.vmw.custom_paths[i] = datastore.get(
self._custom_jobject[i])
return self._canvas
def _photo_created_cb(self, fb_photo, fb_object_id, tmp_file):
logging.debug("_photo_created_cb")
if os.path.exists(tmp_file):
os.unlink(tmp_file)
metadata = self._get_metadata()
comment = ''
if 'title' in metadata:
comment += '%s:' % str(metadata['title'])
if 'description' in metadata:
comment += str(metadata['description'])
fb_photo.connect('comment-added', self._comment_added_cb)
fb_photo.connect('comment-add-failed', self._comment_add_failed_cb)
fb_photo.add_comment(comment)
try:
ds_object = datastore.get(metadata['uid'])
ds_object.metadata['fb_object_id'] = fb_object_id
datastore.write(ds_object, update_mtime=False)
except Exception as ex:
logging.debug("_photo_created_cb failed to write to datastore: " %
str(ex))
def load_file(self, jobject, title=None):
if isinstance(jobject, datastore.RawObject):
logging.debug('Loading a datastore.RawObject')
file_path = mime_path = jobject.file_path
title = jobject.metadata['title']
elif isinstance(jobject, datastore.DSObject):
# This file is stored in the Journal (datastore)
logging.debug('Loading a datastore.DSObject')
file_path = 'journal://' + jobject.object_id
mime_path = datastore.get(jobject.object_id).file_path
title = jobject.metadata['title']
else:
logging.debug('Loading a %s', type(jobject))
file_path = mime_path = jobject
mimetype = mime.get_for_file('file://' + mime_path)
logging.info('read_file mime %s', mimetype)
if mimetype == 'audio/x-mpegurl':
# is a M3U playlist:
self._load_m3u_playlist(file_path)
else:
# is not a M3U playlist
self._load_stream(file_path, title)
missing_tracks = self._get_missing_tracks()
if len(missing_tracks) > 0:
logging.info('%s tracks not found', len(missing_tracks))
self.emit('missing-tracks', missing_tracks)
# set the focus in the first row
self._set_cursor(0)
def _comment_activate_cb(self, entry):
text = entry.props.text
if not "comments" in self._reflection.data:
self._reflection.data["comments"] = []
data = {
"nick": profile.get_nick_name(),
"color": self._reflection.activity.fg_color.get_html(),
"comment": text,
}
self._reflection.data["comments"].append(data)
self.add_new_comment(data)
# Send the comment
if self._reflection.activity.sharing:
self._reflection.activity.send_event(
"%s|%s|%s|%s|%s"
% (COMMENT_CMD, self._reflection.data["obj_id"], data["nick"], data["color"], data["comment"])
)
entry.set_text("")
# Update journal entry
dsobj = datastore.get(self._reflection.data["obj_id"])
if "comments" in dsobj.metadata:
data = json.loads(dsobj.metadata["comments"])
else:
data = []
data.append({"from": profile.get_nick_name(), "message": text, "icon-color": profile.get_color().to_string()})
dsobj.metadata["comments"] = json.dumps(data)
datastore.write(
dsobj,
update_mtime=False,
reply_handler=self.datastore_write_cb,
error_handler=self.datastore_write_error_cb,
)
def _process_tags(self, text_buffer, text):
""" process tag data from textview """
self._reflection.data["tags"] = []
label = ""
tags = text.split()
for tag in tags:
if len(label) > 0:
label += ", "
tag = tag.rstrip(",")
tag = tag.rstrip(";")
if tag[0] == "#":
self._reflection.data["tags"].append(tag)
label += tag
else:
self._reflection.data["tags"].append("#" + tag)
label += "#" + tag
text_buffer.set_text(label.replace("\12", ""))
if self._reflection.activity.sharing:
data = json.dumps(self._reflection.data["tags"])
self._reflection.activity.send_event("%s|%s|%s" % (TAG_CMD, self._reflection.data["obj_id"], data))
self._reflection.set_modification_time()
# Update journal entry
dsobj = datastore.get(self._reflection.data["obj_id"])
logging.error("setting tags to %s" % label)
dsobj.metadata["tags"] = label
datastore.write(
dsobj,
update_mtime=False,
reply_handler=self.datastore_write_cb,
error_handler=self.datastore_write_error_cb,
)
def _image_file_from_metadata(self, image_path):
""" Load a pixbuf from a Journal object. """
try:
metadata = self._get_metadata()
if 'mime_type' in metadata and 'image' in metadata['mime_type']:
ds_object = datastore.get(metadata['uid'])
pixbuf = GdkPixbuf.Pixbuf.new_from_file(ds_object.file_path)
else:
pixbufloader = \
GdkPixbuf.PixbufLoader.new_with_mime_type('image/png')
pixbufloader.set_size(300, 225)
pixbufloader.write(metadata['preview'])
pixbuf = pixbufloader.get_pixbuf()
pixbufloader.close()
except Exception as ex:
logging.error("_image_file_from_metadata: %s" % (str(ex)))
return False
try:
pixbuf.savev(image_path, 'png', [], [])
logging.debug('_image_file_from_metadata: success %s' %
(image_path))
return True
except Exception as ex:
logging.error("_image_file_from_metadata: %s" % (str(ex)))
return False
def create_preview(self, object_id):
jobject = datastore.get(object_id)
if 'preview' in jobject.metadata:
preview = jobject.metadata['preview']
if preview is None or preview == '' or preview == 'None':
if jobject.metadata['mime_type'] .startswith('image/') and \
jobject.metadata['mime_type'] != 'image/vnd.djvu':
filename = jobject.get_file_path()
self.show_image(filename)
return
if jobject.metadata['mime_type'] == 'application/x-cbz':
filename = jobject.get_file_path()
fname = self.extract_image(filename)
self.show_image(fname)
os.remove(fname)
return
self.show_image('xoimage.jpg')
return
if 'preview' in jobject.metadata and \
len(jobject.metadata['preview']) > 4:
preview_data = jobject.metadata['preview']
loader = GdkPixbuf.PixbufLoader()
loader.write(preview_data)
scaled_buf = loader.get_pixbuf()
loader.close()
self.image.set_from_pixbuf(scaled_buf)
self.image.show()
else:
self.image.clear()
self.image.show()
def _process_tags(self, text_buffer, text):
''' process tag data from textview '''
self._reflection.data['tags'] = []
label = ''
tags = text.split()
for tag in tags:
if len(label) > 0:
label += ', '
tag = tag.rstrip(',')
tag = tag.rstrip(';')
if tag[0] == '#':
self._reflection.data['tags'].append(tag)
label += tag
else:
self._reflection.data['tags'].append('#' + tag)
label += '#' + tag
text_buffer.set_text(label.replace('\12', ''))
if self._reflection.activity.sharing:
data = json.dumps(self._reflection.data['tags'])
self._reflection.activity.send_event(
TAG_CMD, {
"obj_id": self._refelection.data["ob_id"],
"reflection": data
})
self._reflection.set_modification_time()
# Update journal entry
dsobj = datastore.get(self._reflection.data['obj_id'])
logging.error('setting tags to %s' % label)
dsobj.metadata['tags'] = label
datastore.write(dsobj,
update_mtime=False,
reply_handler=self.datastore_write_cb,
error_handler=self.datastore_write_error_cb)
def get_bundle(bundle_id=None, object_id=None):
if bundle_id is None and object_id is None:
logging.error('At least one parameter has to be passed')
return None
if bundle_id is None:
obj = datastore.get(object_id)
if obj.metadata['mime_type'] is None:
return None
mime_type = str(obj.metadata['mime_type'])
activities = get_activities_for_mime(mime_type)
if not activities:
logging.warning('No activity can start object with type, %s.',
mime_type)
return None
return activities[0]
else:
bundle = bundleregistry.get_registry().get_bundle(bundle_id)
if bundle is None:
logging.warning('Activity with the bundle_id %s was not found',
mime_type)
return None
return bundle
def _comment_activate_cb(self, entry):
text = entry.props.text
if 'comments' not in self._reflection.data:
self._reflection.data['comments'] = []
data = {
'nick': profile.get_nick_name(),
'color': self._reflection.activity.fg_color.get_html(),
'comment': text
}
self._reflection.data['comments'].append(data)
self.add_new_comment(data)
# Send the comment
if self._reflection.activity.sharing:
send_data = data.copy()
send_data["obj_id"] = self._reflection.data["obj_id"]
self._reflection.activity.send_event(COMMENT_CMD, send_data)
entry.set_text('')
# Update journal entry
dsobj = datastore.get(self._reflection.data['obj_id'])
if 'comments' in dsobj.metadata:
data = json.loads(dsobj.metadata['comments'])
else:
data = []
data.append({
'from': profile.get_nick_name(),
'message': text,
'icon-color': profile.get_color().to_string()
})
dsobj.metadata['comments'] = json.dumps(data)
datastore.write(dsobj,
update_mtime=False,
reply_handler=self.datastore_write_cb,
error_handler=self.datastore_write_error_cb)
def create_preview(self, object_id, col, id):
jobject = datastore.get(object_id)
if jobject.metadata.has_key('preview'):
preview = jobject.metadata['preview']
if preview is None or preview == '' or preview == 'None':
if (jobject.metadata['mime_type'].startswith('image/')):
# or (jobject.metadata['mime_type'].startswith('video')):
filename = jobject.get_file_path()
self.show_image(filename, col, id)
return
if jobject.metadata.has_key('preview') and \
len(jobject.metadata['preview']) > 4:
if jobject.metadata['preview'][1:4] == 'PNG':
preview_data = jobject.metadata['preview']
else:
import base64
preview_data = base64.b64decode(jobject.metadata['preview'])
loader = Gdk.PixbufLoader()
loader.write(preview_data)
scaled_buf = loader.get_pixbuf()
loader.close()
self.image[col][id].set_from_pixbuf(scaled_buf)
self.image[col][id].show()
else:
self.image[col][id].clear()
self.image[col][id].show()
def create_preview(self, object_id):
jobject = datastore.get(object_id)
if 'preview' in jobject.metadata:
preview = jobject.metadata['preview']
if preview is None or preview == '' or preview == 'None':
if jobject.metadata['mime_type'] .startswith('image/') and \
jobject.metadata['mime_type'] != 'image/vnd.djvu':
filename = jobject.get_file_path()
self.show_image(filename)
return
if jobject.metadata['mime_type'] == 'application/x-cbz':
filename = jobject.get_file_path()
fname = self.extract_image(filename)
self.show_image(fname)
os.remove(fname)
return
self.show_image('xoimage.jpg')
return
if 'preview' in jobject.metadata and \
len(jobject.metadata['preview']) > 4:
preview_data = jobject.metadata['preview']
loader = GdkPixbuf.PixbufLoader()
loader.write(preview_data)
scaled_buf = loader.get_pixbuf()
loader.close()
self.image.set_from_pixbuf(scaled_buf)
self.image.show()
else:
self.image.clear()
self.image.show()
def _get_data(self, metadata=None):
if not metadata:
metadata = self._get_metadata()
jobject = datastore.get(metadata['uid'])
path = str(jobject.file_path)
return path
def selection_journal_cb(self, selection):
self.btn_delete.props.sensitive = True
tv = selection.get_tree_view()
model = tv.get_model()
sel = selection.get_selected()
if sel:
model, iter = sel
jobject = model.get_value(iter, COLUMN_JOBJECT)
jobject = datastore.get(jobject.object_id)
self.selected_journal_entry = jobject
self.set_form_fields(jobject)
if jobject.metadata['mime_type'] .startswith('image/') \
and jobject.metadata['mime_type'] != 'image/vnd.djvu':
self.btn_resize.show()
self.resize_width_entry.show()
filename = jobject.get_file_path()
im = pygame.image.load(filename)
image_width, image_height = im.get_size()
self.dimension_label.set_text(
str(image_width) + "x" + str(image_height))
self.dimension_label.show()
else:
self.btn_resize.hide()
self.resize_width_entry.hide()
self.dimension_label.hide()
self.selected_path = model.get_path(iter)
def _set_view_url(self, tube_id):
if self._account.url_cache is None:
chan = self._shared_activity.telepathy_tubes_chan
iface = chan[telepathy.CHANNEL_TYPE_TUBES]
addr = iface.AcceptStreamTube(
tube_id,
telepathy.SOCKET_ADDRESS_TYPE_IPV4,
telepathy.SOCKET_ACCESS_CONTROL_LOCALHOST,
0,
utf8_strings=True)
logging.debug('Accepted stream tube: listening address is %r',
addr)
# SOCKET_ADDRESS_TYPE_IPV4 is defined to have addresses of
# type '(sq)'
assert isinstance(addr, dbus.Struct)
assert len(addr) == 2
assert isinstance(addr[0], str)
assert isinstance(addr[1], (int, long))
assert addr[1] > 0 and addr[1] < 65536
ip = addr[0]
port = int(addr[1])
logging.debug('http://%s:%d/web/index.html' % (ip, port))
metadata = self._get_metadata()
self._jobject = datastore.get(metadata['uid'])
# Add the information about the user uploading this object
user_data = get_user_data()
self._jobject.metadata['shared_by'] = json.dumps(user_data)
# And add a comment to the Journal entry
if 'comments' in self._jobject.metadata:
comments = json.loads(self._jobject.metadata['comments'])
else:
comments = []
comments.append({
'from':
user_data['from'],
'message':
_('I shared this.'),
'icon-color':
'[%s,%s]' % (user_data['icon'][0], user_data['icon'][1])
})
self._jobject.metadata['comments'] = json.dumps(comments)
if self._jobject and self._jobject.file_path:
tmp_path = '/tmp'
packaged_file_path = package_ds_object(self._jobject, tmp_path)
if self._account.url_cache is None:
url = 'ws://%s:%d/websocket/upload' % (ip, port)
self._account.url_cache = url
else:
url = self._account.url_cache
logging.debug('url is %s' % (url))
uploader = Uploader(packaged_file_path, url)
uploader.connect('uploaded', self.__uploaded_cb)
self.emit('transfer-state-changed', _('Upload started'))
uploader.start()
return False
def _fb_comments_downloaded_cb(self, fb_photo, comments):
logging.debug('_fb_comments_downloaded_cb')
ds_object = datastore.get(self._metadata['uid'])
if not COMMENTS in ds_object.metadata:
ds_comments = []
else:
ds_comments = json.loads(ds_object.metadata[COMMENTS])
if not COMMENT_IDS in ds_object.metadata:
ds_comment_ids = []
else:
ds_comment_ids = json.loads(ds_object.metadata[COMMENT_IDS])
new_comment = False
for comment in comments:
if comment['id'] not in ds_comment_ids:
# TODO: get avatar icon and add it to icon_theme
ds_comments.append({'from': comment['from'],
'message': comment['message'],
'icon': 'facebook-share'})
ds_comment_ids.append(comment['id'])
new_comment = True
if new_comment:
ds_object.metadata[COMMENTS] = json.dumps(ds_comments)
ds_object.metadata[COMMENT_IDS] = json.dumps(ds_comment_ids)
self.emit('comments-changed', ds_object.metadata[COMMENTS])
datastore.write(ds_object, update_mtime=False)
def __init__(self, sugaractivity, handle, rsrc, base="/nfs/show"):
GObject.GObject.__init__(self)
self.__handle = handle
if self.__handle.object_id is None:
print 'slideshow - from home view'
else:
obj = datastore.get(self.__handle.object_id)
print 'object:', obj.get_file_path()
self.__logger = logging.getLogger('Deck')
self.__base = base
self.__rsrc = rsrc
self.__activity = sugaractivity
self.__is_initiating = True
self.__nav_locked = False
self.__active_sub = -1
self.__self_text = ""
self.__text_tag = None
self.__xmlpath = os.path.join(base, "deck.xml")
# we always create a new presentation and copy over it on resume
if path(base).exists():
# we can't have permissions.info for this to work
subprocess.call("cp -r " + base + " " +
os.path.expanduser("~/save"),
shell=True)
subprocess.call("rm -rf " + base + '/*', shell=True)
else:
path.mkdir(base)
path.copy(self.__rsrc / 'deck.xml', base / 'deck.xml')
path.copy(self.__rsrc / 'title.html', base / 'title.html')
path.copy(self.__rsrc / 'title_thumb.png', base / 'title_thumb.png')
self.reload()
self.set_title('New')
def load_file(self, jobject, title=None):
if isinstance(jobject, datastore.RawObject):
logging.debug('Loading a datastore.RawObject')
file_path = mime_path = jobject.file_path
title = jobject.metadata['title']
elif isinstance(jobject, datastore.DSObject):
# This file is stored in the Journal (datastore)
logging.debug('Loading a datastore.DSObject')
file_path = 'journal://' + jobject.object_id
mime_path = datastore.get(jobject.object_id).file_path
title = jobject.metadata['title']
else:
logging.debug('Loading a %s', type(jobject))
file_path = mime_path = jobject
mimetype = mime.get_for_file('file://' + mime_path)
logging.info('read_file mime %s', mimetype)
if mimetype == 'audio/x-mpegurl':
# is a M3U playlist:
self._load_m3u_playlist(file_path)
else:
# is not a M3U playlist
self._load_stream(file_path, title)
missing_tracks = self._get_missing_tracks()
if len(missing_tracks) > 0:
logging.info('%s tracks not found', len(missing_tracks))
self.emit('missing-tracks', missing_tracks)
# set the focus in the first row
self._set_cursor(0)
def insert_comment(self, obj_id, comment):
for item in self._reflections:
if item.obj_id == obj_id:
item.graphics.add_new_comment(comment)
item.graphics.notify_button.show()
# Update journal entry
if obj_id[0:4] == "obj-":
break
try:
dsobj = datastore.get(obj_id)
except Exception as e:
logging.error("Could not open %s: %e" % (obj_id, e))
break
if "comments" in dsobj.metadata:
data = json.loads(dsobj.metadata["comments"])
else:
data = []
data.append(
{
"from": comment["nick"],
"message": comment["comment"],
"icon-color": "%s,%s" % (comment["color"], comment["color"]),
}
)
dsobj.metadata["comments"] = json.dumps(data)
datastore.write(
dsobj,
update_mtime=False,
reply_handler=self.datastore_write_cb,
error_handler=self.datastore_write_error_cb,
)
break
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 selection_journal_cb(self, selection):
self.btn_delete.props.sensitive = True
tv = selection.get_tree_view()
model = tv.get_model()
sel = selection.get_selected()
if sel:
model, iter = sel
jobject = model.get_value(iter,COLUMN_JOBJECT)
jobject = datastore.get(jobject.object_id)
self.selected_journal_entry = jobject
self.set_form_fields(jobject)
if jobject.metadata['mime_type'] .startswith('image/') \
and jobject.metadata['mime_type'] != 'image/vnd.djvu':
self.btn_resize.show()
self.resize_width_entry.show()
filename = jobject.get_file_path()
im = pygame.image.load(filename)
image_width, image_height = im.get_size()
self.dimension_label.set_text(str(image_width) + "x" + str(image_height))
self.dimension_label.show()
else:
self.btn_resize.hide()
self.resize_width_entry.hide()
self.dimension_label.hide()
self.selected_path = model.get_path(iter)
def get_bundle(bundle_id=None, object_id=None):
if bundle_id is None and object_id is None:
logging.error('At least one parameter has to be passed')
return None
if bundle_id is None:
obj = datastore.get(object_id)
if obj.metadata['mime_type'] is None:
return None
mime_type = str(obj.metadata['mime_type'])
activities = get_activities_for_mime(mime_type)
if not activities:
logging.warning('No activity can start object with type, %s.',
mime_type)
return None
return activities[0]
bundle = bundleregistry.get_registry().get_bundle(bundle_id)
if bundle is None:
logging.warning('Activity with the bundle_id %s was not found',
mime_type)
return None
return bundle
def _get_data(self, metadata=None):
if not metadata:
metadata = self._get_metadata()
jobject = datastore.get(metadata['uid'])
path = str(jobject.file_path)
return path
def insert_comment(self, obj_id, comment):
for item in self._reflections:
if item.obj_id == obj_id:
item.graphics.add_new_comment(comment)
item.graphics.notify_button.show()
# Update journal entry
if obj_id[0:4] == 'obj-':
break
try:
dsobj = datastore.get(obj_id)
except Exception as e:
logging.error('Could not open %s: %e' % (obj_id, e))
break
if 'comments' in dsobj.metadata:
data = json.loads(dsobj.metadata['comments'])
else:
data = []
data.append({'from': comment['nick'],
'message': comment['comment'],
'icon-color': '%s,%s' % (
comment['color'], comment['color'])
})
dsobj.metadata['comments'] = json.dumps(data)
datastore.write(dsobj,
update_mtime=False,
reply_handler=self.datastore_write_cb,
error_handler=self.datastore_write_error_cb)
break
def _process_tags(self, text_buffer, text):
''' process tag data from textview '''
self._reflection.data['tags'] = []
label = ''
tags = text.split()
for tag in tags:
if len(label) > 0:
label += ', '
tag = tag.rstrip(',')
tag = tag.rstrip(';')
if tag[0] == '#':
self._reflection.data['tags'].append(tag)
label += tag
else:
self._reflection.data['tags'].append('#' + tag)
label += '#' + tag
text_buffer.set_text(label.replace('\12', ''))
if self._reflection.activity.sharing:
data = json.dumps(self._reflection.data['tags'])
self._reflection.activity.send_event(TAG_CMD,
{"obj_id": self._refelection.data["ob_id"],
"reflection": data})
self._reflection.set_modification_time()
# Update journal entry
dsobj = datastore.get(self._reflection.data['obj_id'])
logging.error('setting tags to %s' % label)
dsobj.metadata['tags'] = label
datastore.write(dsobj,
update_mtime=False,
reply_handler=self.datastore_write_cb,
error_handler=self.datastore_write_error_cb)
def _comment_activate_cb(self, entry):
text = entry.props.text
if not 'comments' in self._reflection.data:
self._reflection.data['comments'] = []
data = {'nick': profile.get_nick_name(),
'color': self._reflection.activity.fg_color.get_html(),
'comment': text}
self._reflection.data['comments'].append(data)
self.add_new_comment(data)
# Send the comment
if self._reflection.activity.sharing:
send_data = data.copy()
send_data["obj_id"] = self._reflection.data["obj_id"]
self._reflection.activity.send_event(COMMENT_CMD, send_data)
entry.set_text('')
# Update journal entry
dsobj = datastore.get(self._reflection.data['obj_id'])
if 'comments' in dsobj.metadata:
data = json.loads(dsobj.metadata['comments'])
else:
data = []
data.append({'from': profile.get_nick_name(),
'message': text,
'icon-color': profile.get_color().to_string()})
dsobj.metadata['comments'] = json.dumps(data)
datastore.write(dsobj,
update_mtime=False,
reply_handler=self.datastore_write_cb,
error_handler=self.datastore_write_error_cb)
def insert_comment(self, obj_id, comment):
for item in self._reflections:
if item.obj_id == obj_id:
item.graphics.add_new_comment(comment)
item.graphics.notify_button.show()
# Update journal entry
if obj_id[0:4] == 'obj-':
break
try:
dsobj = datastore.get(obj_id)
except Exception as e:
logging.error('Could not open %s: %e' % (obj_id, e))
break
if 'comments' in dsobj.metadata:
data = json.loads(dsobj.metadata['comments'])
else:
data = []
data.append({
'from':
comment['nick'],
'message':
comment['comment'],
'icon-color':
'%s,%s' % (comment['color'], comment['color'])
})
dsobj.metadata['comments'] = json.dumps(data)
datastore.write(dsobj,
update_mtime=False,
reply_handler=self.datastore_write_cb,
error_handler=self.datastore_write_error_cb)
break
def _setup_canvas(self):
''' Create a canvas in a Gtk.Fixed '''
self.fixed = Gtk.Fixed()
self.fixed.connect('size-allocate', self._fixed_resize_cb)
self.fixed.show()
self.set_canvas(self.fixed)
self._vbox = Gtk.VBox(False, 0)
self._vbox.set_size_request(Gdk.Screen.width(), Gdk.Screen.height())
self.fixed.put(self._vbox, 0, 0)
self._vbox.show()
self._canvas = Gtk.DrawingArea()
self._canvas.set_size_request(int(Gdk.Screen.width()),
int(Gdk.Screen.height()))
self._canvas.show()
self.show_all()
self._vbox.pack_end(self._canvas, True, True, 0)
self._vbox.show()
self.show_all()
self.vmw = Game(self._canvas, parent=self, card_type=MODE)
self.vmw.level = self._play_level
LEVEL_BUTTONS[self._play_level].set_active(True)
self.vmw.card_type = self._card_type
self.vmw.robot = False
self.vmw.robot_time = self._robot_time
self.vmw.low_score = self._low_score
self.vmw.all_scores = self._all_scores
self.vmw.numberO = self._numberO
self.vmw.numberC = self._numberC
self.vmw.matches = self._matches
self.vmw.robot_matches = self._robot_matches
self.vmw.total_time = self._total_time
self.vmw.buddies = []
self.vmw.word_lists = self._word_lists
self.vmw.editing_word_list = self._editing_word_list
if hasattr(self, '_custom_object') and self._custom_object is not None:
self.vmw._find_custom_paths(datastore.get(self._custom_object))
for i in range(9):
if hasattr(self, '_custom_jobject') and \
self._custom_jobject[i] is not None:
self.vmw.custom_paths[i] = datastore.get(
self._custom_jobject[i])
self.button_custom.set_sensitive(True)
return self._canvas
def get_media_from_datastore(id):
media_object = None
try:
media_object = datastore.get(id)
except BaseException:
pass
return media_object
def do_custom_skin_cb(self, button=None):
for piece in list(PIECES.keys()):
for color in ['white', 'black']:
name = '%s_%s' % (color, piece)
if name in self.metadata:
id = self.metadata[name]
jobject = datastore.get(id)
if jobject is not None and jobject.file_path is not None:
self._do_reskin(name, jobject.file_path)
def _status_updated_cb(self, status, data, tmp_file):
if os.path.exists(tmp_file):
os.unlink(tmp_file)
try:
ds_object = datastore.get(self._metadata['uid'])
ds_object.metadata['twr_object_id'] = status._status_id
datastore.write(ds_object, update_mtime=False)
except Exception as e:
logging.debug('_status_updated_cb failed to write: %s', str(e))
def _datastore_updated_cb(self, uid):
logging.debug('_datastore_updated_cb: %r' % uid)
if uid in self._dict:
jobject = datastore.get(uid)
index = self._array.index(self._dict[uid])
self._array[index].destroy()
self._array[index] = jobject
self._dict[uid] = jobject
self.emit('modified')
def get_journal_entry_cover_image(self, object_id):
ds_object = datastore.get(object_id)
if 'cover_image' in ds_object.metadata:
cover_data = ds_object.metadata['cover_image']
return base64.b64decode(cover_data)
elif 'preview' in ds_object.metadata:
return ds_object.metadata['preview']
else:
return ""
def get_journal_entry_cover_image(self, object_id):
ds_object = datastore.get(object_id)
if 'cover_image' in ds_object.metadata:
cover_data = ds_object.metadata['cover_image']
return base64.b64decode(cover_data)
elif 'preview' in ds_object.metadata:
return ds_object.metadata['preview']
else:
return ""
def get_media_from_datastore(id):
media_object = None
try:
media_object = datastore.get(id)
except:
pass
return media_object
def upload_completed(self, widget, link):
metadata = self._get_metadata()
tags = '%s %s' % (metadata.get('tags', ''), link)
ds_object = datastore.get(metadata['uid'])
ds_object.metadata['tags'] = tags
datastore.write(ds_object, update_mtime=False)
self.emit('transfer-state-changed', _('Google drive'),
_('Upload finished. Link saved in tags of entry.'))
def datastore_created_cb(self, uid):
new_jobject = datastore.get(uid)
iter = self.ls_journal.append()
title = new_jobject.metadata['title']
self.ls_journal.set(iter, COLUMN_TITLE, title)
mime = new_jobject.metadata['mime_type']
self.ls_journal.set(iter, COLUMN_MIME, mime)
self.ls_journal.set(iter, COLUMN_JOBJECT, new_jobject)
size = self.get_size(new_jobject) / 1024
self.ls_journal.set(iter, COLUMN_SIZE, size)
def upload_completed(self, widget, link):
metadata = self._get_metadata()
tags = '%s %s' % (metadata.get('tags', ''), link)
ds_object = datastore.get(metadata['uid'])
ds_object.metadata['tags'] = tags
datastore.write(ds_object, update_mtime=False)
self.emit('transfer-state-changed', _('Google drive'),
_('Upload finished. Link saved in tags of entry.'))
def datastore_created_cb(self, uid):
new_jobject = datastore.get(uid)
iter = self.ls_journal.append()
title = new_jobject.metadata['title']
self.ls_journal.set(iter, COLUMN_TITLE, title)
mime = new_jobject.metadata['mime_type']
self.ls_journal.set(iter, COLUMN_MIME, mime)
self.ls_journal.set(iter, COLUMN_JOBJECT, new_jobject)
size = self.get_size(new_jobject) / 1024
self.ls_journal.set(iter, COLUMN_SIZE, size)
def _get_data(self):
data = None
metadata = self._get_metadata()
if metadata.get('mime_type', '').startswith('text/'):
jobject = datastore.get(metadata['uid'])
with open(jobject.file_path, 'r') as jfile:
data = jfile.read()
return data
def _set_view_url(self, tube_id):
if self._account.url_cache is None:
chan = self._shared_activity.telepathy_tubes_chan
iface = chan[telepathy.CHANNEL_TYPE_TUBES]
addr = iface.AcceptStreamTube(
tube_id,
telepathy.SOCKET_ADDRESS_TYPE_IPV4,
telepathy.SOCKET_ACCESS_CONTROL_LOCALHOST, 0,
utf8_strings=True)
logging.debug('Accepted stream tube: listening address is %r',
addr)
# SOCKET_ADDRESS_TYPE_IPV4 is defined to have addresses of
# type '(sq)'
assert isinstance(addr, dbus.Struct)
assert len(addr) == 2
assert isinstance(addr[0], str)
assert isinstance(addr[1], (int, long))
assert addr[1] > 0 and addr[1] < 65536
ip = addr[0]
port = int(addr[1])
logging.debug('http://%s:%d/web/index.html' % (ip, port))
metadata = self._get_metadata()
self._jobject = datastore.get(metadata['uid'])
# Add the information about the user uploading this object
user_data = get_user_data()
self._jobject.metadata['shared_by'] = json.dumps(user_data)
# And add a comment to the Journal entry
if 'comments' in self._jobject.metadata:
comments = json.loads(self._jobject.metadata['comments'])
else:
comments = []
comments.append({'from': user_data['from'],
'message': _('I shared this.'),
'icon-color': '[%s,%s]' % (
user_data['icon'][0], user_data['icon'][1])})
self._jobject.metadata['comments'] = json.dumps(comments)
if self._jobject and self._jobject.file_path:
tmp_path = '/tmp'
packaged_file_path = package_ds_object(self._jobject, tmp_path)
if self._account.url_cache is None:
url = 'ws://%s:%d/websocket/upload' % (ip, port)
self._account.url_cache = url
else:
url = self._account.url_cache
logging.debug('url is %s' % (url))
uploader = Uploader(packaged_file_path, url)
uploader.connect('uploaded', self.__uploaded_cb)
self.emit('transfer-state-changed', _('Upload started'))
uploader.start()
return False
def get_selected_object(self):
"""
Gets the object selected using the object chooser.
Returns:
object, the object selected
"""
if self._object_id is None:
return None
else:
return datastore.get(self._object_id)
def _create_model(self):
tuxstamps = '/usr/share/tuxpaint/stamps'
store = Gtk.ListStore(GdkPixbuf.Pixbuf, str)
tuxavailable = True
if not os.path.exists(tuxstamps):
tuxavailable = False
filepaths = []
for object_id in JOURNAL_IMAGES:
if os.path.exists(object_id) and os.path.isfile(object_id):
filepaths.append(object_id)
continue
try:
obj = datastore.get(object_id)
fpath = obj.file_path
if os.path.exists(fpath):
filepaths.append(fpath)
except Exception:
pass
pixbuf = GdkPixbuf.Pixbuf.new_from_file_at_size(
'icons/loadfromjournal.svg',
50,
50)
store.append([pixbuf, 'loadfromjournal'])
for f in filepaths:
pixbuf = GdkPixbuf.Pixbuf.new_from_file_at_size(
f,
50,
50)
store.append([pixbuf, f])
if tuxavailable:
categories = []
dirs = os.listdir(tuxstamps)
for d in dirs:
d = os.path.join(tuxstamps, d)
if os.path.isdir(d):
categories.append(d)
for cat in categories:
patron = os.path.join(tuxstamps, cat)
for x in range(5):
patron = patron + "/*"
files = glob.iglob(patron + '.png')
for f in files:
pixbuf = GdkPixbuf.Pixbuf.new_from_file_at_size(
f,
50,
50)
store.append([pixbuf, f])
return store
def get_selected_object(self):
"""
Gets the object selected using the object chooser.
Returns:
object, the object selected
"""
if self._object_id is None:
return None
else:
return datastore.get(self._object_id)
def __completed_cb(self, paste, info):
url = paste.CREATE_URL + paste.id
metadata = self._get_metadata()
tags = '%s %s' % (metadata.get('tags', ''), url)
ds_object = datastore.get(metadata['uid'])
ds_object.metadata['tags'] = tags
datastore.write(ds_object, update_mtime=False)
self.emit('transfer-state-changed',
_('Successfully pasted to %s') % url)
def __project_chooser_response_cb(self, project_chooser, response_value,
metadata_to_send):
if response_value == Gtk.ResponseType.DELETE_EVENT:
project_chooser.destroy()
return
object_id = project_chooser.get_selected_object_id()
metadata = model.get(object_id)
jobject_to_send = datastore.get(metadata_to_send['uid'])
datastore.delete(metadata_to_send['uid'])
jobject_to_send.metadata['project_id'] = metadata['uid']
datastore.write(jobject_to_send)
project_chooser.destroy()
def getMediaFromDatastore(recd):
if not recd.datastoreId:
return None
if recd.datastoreOb:
# already have the object
return recd.datastoreOb
mediaObject = None
try:
mediaObject = datastore.get(recd.datastoreId)
finally:
return mediaObject
def __project_chooser_response_cb(self, project_chooser, response_value,
metadata_to_send):
if response_value == Gtk.ResponseType.DELETE_EVENT:
project_chooser.destroy()
return
object_id = project_chooser.get_selected_object_id()
metadata = model.get(object_id)
jobject_to_send = datastore.get(metadata_to_send['uid'])
datastore.delete(metadata_to_send['uid'])
jobject_to_send.metadata['project_id'] = metadata['uid']
datastore.write(jobject_to_send)
project_chooser.destroy()
def __set_file_idle_cb(self, object_id):
dsobj = datastore.get(object_id)
self._tempfile = dsobj.file_path
""" This method is used when join a collaboration session """
self.view.set_file_location(self._tempfile)
try:
zoom = int(self.metadata.get('zoom', '0'))
if zoom > 0:
self.view.set_zoom(zoom)
except Exception:
pass
self.set_canvas(self.scrolled_window)
self.scrolled_window.show_all()
return False
def __set_file_idle_cb(self, object_id):
dsobj = datastore.get(object_id)
self._tempfile = dsobj.file_path
""" This method is used when join a collaboration session """
self.view.set_file_location(self._tempfile)
try:
zoom = int(self.metadata.get('zoom', '0'))
if zoom > 0:
self.view.set_zoom(zoom)
except Exception:
pass
self.set_canvas(self.scrolled_window)
self.scrolled_window.show_all()
return False
def chooser_response_cb(self, chooser, response_id):
if response_id == Gtk.ResponseType.ACCEPT:
object_id = chooser.get_selected_object_id()
selected_object = datastore.get(object_id)
image_path = selected_object.file_path
fh = open(image_path)
string = fh.read()
fh.close()
encoded_string = base64.b64encode(string)
chooser.destroy()
self.parent._client.send_result(self.request, encoded_string)
else:
chooser.destroy()
self.parent._client.send_result(self.request, encoded_string)
def on_activated(self, widget, row, col):
model = widget.get_model()
print 'row', model[row][0], model[row][1], model[row][2], model[row][3]
title = model[row][1]
mime_type = model[row][2]
timestamp = model[row][3]
object = datastore.get(model[row][0])
fn = object.file_path
print 'object filename', path(fn).exists(), fn
self.deck.addSlide(fn)
self.deck.reload()
object.destroy()
self.activity.set_screen(0)
def on_activated(self, widget, row, col):
print 'cpxo on_activated'
model = widget.get_model()
print 'row', model[row][0], model[row][1], model[row][2]
title = model[row][1]
timestamp = model[row][2]
object = datastore.get(model[row][0])
fn = object.file_path
print 'object filename', path(fn).exists(), fn
# open slideshow, set Navigation toolbar current
self.activity.read_file(fn)
for object in ds_objects:
object.destroy()
self.activity.set_screen(0)
def _prepare_shared_items(self):
results = []
if not self._shared_items:
return json.dumps(results)
if self._shared_items == ['*']:
dsobjects, _nobjects = datastore.find({'keep': '1'})
else:
dsobjects = []
for object_id in self._shared_items:
dsobjects.append(datastore.get(object_id))
for dsobj in dsobjects:
title = ''
desc = ''
comment = []
shared_by = {}
downloaded_by = []
object_id = dsobj.object_id
if hasattr(dsobj, 'metadata'):
if 'title' in dsobj.metadata:
title = dsobj.metadata['title']
if 'description' in dsobj.metadata:
desc = dsobj.metadata['description']
if 'comments' in dsobj.metadata:
try:
comment = json.loads(dsobj.metadata['comments'])
except:
comment = []
if 'shared_by' in dsobj.metadata:
shared_by = json.loads(dsobj.metadata['shared_by'])
if 'downloaded_by' in dsobj.metadata:
downloaded_by = json.loads(dsobj.metadata['downloaded_by'])
else:
logging.debug('dsobj has no metadata')
utils.package_ds_object(dsobj, self._instance_path)
results.append({
'title': str(title),
'desc': str(desc),
'comment': comment,
'id': str(object_id),
'shared_by': shared_by,
'downloaded_by': downloaded_by
})
logging.error(results)
return json.dumps(results)
def _add_label(string):
if isinstance(string, str) and string[0:8] in ['#smedia_', '#saudio_',
'#svideo_', '#sdescr_']:
string = string[8:]
dsobject = datastore.get(string[8:])
if 'title' in dsobject.metadata:
string = dsobject.metadata['title']
else:
string = str(string)
if string[0:2] == '#s':
string = string[2:]
string = '"' + string
if string.count(' ') > 0:
return 'label sentence %s\n' % (string.replace(' ', ' "'))
else:
return 'label %s' % (string.replace(' ', '_'))
def datastore_updated_cb(self, uid):
new_jobject = datastore.get(uid)
iter = self.ls_journal.get_iter_first()
for row in self.ls_journal:
jobject = row[COLUMN_JOBJECT]
if jobject.object_id == uid:
title = jobject.metadata['title']
self.ls_journal.set(iter, COLUMN_TITLE, title)
mime = jobject.metadata['mime_type']
self.ls_journal.set(iter, COLUMN_MIME, mime)
size = self.get_size(jobject) / 1024
self.ls_journal.set(iter, COLUMN_SIZE, size)
iter = self.ls_journal.iter_next(iter)
object_id = self.selected_journal_entry.object_id
if object_id == uid:
self.set_form_fields(new_jobject)
def _photo_created_cb(self, fb_photo, fb_object_id, tmp_file):
logging.debug("_photo_created_cb")
if os.path.exists(tmp_file):
os.unlink(tmp_file)
fb_photo.connect('comment-added', self._comment_added_cb)
fb_photo.connect('comment-add-failed', self._comment_add_failed_cb)
fb_photo.add_comment(str(self._comment))
try:
ds_object = datastore.get(self._metadata['uid'])
ds_object.metadata['fb_object_id'] = fb_object_id
datastore.write(ds_object, update_mtime=False)
except Exception as ex:
logging.debug("_photo_created_cb failed to write to datastore: " %
str(ex))
