def nodeParent (self, node):
#print "nodeparent %s" % node
if isinstance (node, Annotation):
parent = node.type
elif isinstance (node, Relation):
parent = node.type
elif isinstance (node, RelationType):
parent = node.schema
elif isinstance (node, AnnotationType):
parent = node.schema
elif isinstance (node, Schema):
parent = node.rootPackage.schemas
elif isinstance (node, View):
if node.id.startswith('_'):
parent=self.virtual['admin']
else:
t=helper.get_view_type(node)
parent=self.virtual[t]
elif isinstance (node, Query):
parent = node.rootPackage.queries
elif isinstance (node, Package):
parent = None
elif isinstance (node, AbstractBundle):
parent = node.rootPackage
elif isinstance (node, Resources):
parent = node.parent
elif isinstance (node, ResourceData):
parent = node.parent
elif node in (self.virtual['static'], self.virtual['dynamic'], self.virtual['adhoc'], self.virtual['admin']):
parent = self.virtual['views']
elif node == self.virtual['views']:
parent=node.rootPackage
else:
parent = None
return parent
def get_target_types(el):
"""Return DND target types for element.
"""
targets = []
if isinstance(el, Annotation):
targets.extend(config.data.get_target_types('annotation', 'timestamp', 'tag'))
elif isinstance(el, Relation):
targets.extend(config.data.get_target_types('relation'))
elif isinstance(el, View):
if helper.get_view_type(el) == 'adhoc':
targets.extend(config.data.get_target_types('adhoc-view'))
else:
targets.extend(config.data.get_target_types('view'))
elif isinstance(el, AnnotationType):
targets.extend(config.data.get_target_types('annotation-type'))
elif isinstance(el, RelationType):
targets.extend(config.data.get_target_types('relation-type'))
elif isinstance(el, Query):
targets.extend(config.data.get_target_types('query'))
elif isinstance(el, Schema):
targets.extend(config.data.get_target_types('schema'))
elif isinstance(el, int):
targets.extend(config.data.get_target_types('timestamp'))
# FIXME: Resource
targets.extend(config.data.get_target_types('uri-list',
'text-plain',
'TEXT',
'STRING'))
return targets
def __init__(self, controller, destination='/tmp/n', views=None, max_depth=3, progress_callback=None, video_url=None):
self.controller=controller
# Directory creation/checks
self.destination=destination
self.imgdir=os.path.join(self.destination, 'imagecache')
if os.path.exists(self.destination) and not os.path.isdir(self.destination):
self.log(_("%s exists but is not a directory. Cancelling website export") % self.destination)
return
elif not os.path.exists(self.destination):
helper.recursive_mkdir(self.destination)
if not os.path.isdir(self.destination):
self.log(_("%s does not exist") % self.destination)
return
if views is None:
views=[ v
for v in self.controller.package.views
if (not v.id.startswith('_')
and v.matchFilter['class'] == 'package'
and helper.get_view_type(v) == 'static')
]
self.views=views
self.max_depth=max_depth
if progress_callback is not None:
# Override dummy progress_callback
self.progress_callback=progress_callback
self.video_url=video_url
self.video_player=self.find_video_player(video_url)
self.url_translation={}
def get_target_types(el):
"""Return DND target types for element.
"""
targets = []
if isinstance(el, Annotation):
targets.extend(config.data.drag_type['annotation'] +
config.data.drag_type['timestamp'] +
config.data.drag_type['tag'])
elif isinstance(el, Relation):
targets.extend(config.data.drag_type['relation'])
elif isinstance(el, View):
if helper.get_view_type(el) == 'adhoc':
targets.extend(config.data.drag_type['adhoc-view'])
else:
targets.extend(config.data.drag_type['view'])
elif isinstance(el, AnnotationType):
targets.extend(config.data.drag_type['annotation-type'])
elif isinstance(el, RelationType):
targets.extend(config.data.drag_type['relation-type'])
elif isinstance(el, Query):
targets.extend(config.data.drag_type['query'])
elif isinstance(el, Schema):
targets.extend(config.data.drag_type['schema'])
elif isinstance(el, (int, long)):
targets.extend(config.data.drag_type['timestamp'])
# FIXME: Resource
targets.extend(config.data.drag_type['uri-list'] +
config.data.drag_type['text-plain'] +
config.data.drag_type['TEXT'] +
config.data.drag_type['STRING'])
return targets
def __init__(self, controller, destination='/tmp/n', views=None, max_depth=3, progress_callback=None, video_url=None):
self.controller=controller
# Directory creation/checks
self.destination=destination
self.imgdir=os.path.join(self.destination, 'imagecache')
if os.path.exists(self.destination) and not os.path.isdir(self.destination):
self.log(_("%s exists but is not a directory. Cancelling website export") % self.destination)
return
elif not os.path.exists(self.destination):
helper.recursive_mkdir(self.destination)
if not os.path.isdir(self.destination):
self.log(_("%s does not exist") % self.destination)
return
if views is None:
views=[ v
for v in self.controller.package.views
if (not v.id.startswith('_')
and v.matchFilter['class'] == 'package'
and helper.get_view_type(v) == 'static')
]
self.views=views
self.max_depth=max_depth
if progress_callback is not None:
# Override dummy progress_callback
self.progress_callback=progress_callback
self.video_url=video_url
self.video_player=self.find_video_player(video_url)
self.url_translation={}
def get_target_types(el):
"""Return DND target types for element.
"""
targets = []
if isinstance(el, Annotation):
targets.extend(config.data.get_target_types('annotation', 'timestamp', 'tag'))
elif isinstance(el, Relation):
targets.extend(config.data.get_target_types('relation'))
elif isinstance(el, View):
if helper.get_view_type(el) == 'adhoc':
targets.extend(config.data.get_target_types('adhoc-view'))
else:
targets.extend(config.data.get_target_types('view'))
elif isinstance(el, AnnotationType):
targets.extend(config.data.get_target_types('annotation-type'))
elif isinstance(el, RelationType):
targets.extend(config.data.get_target_types('relation-type'))
elif isinstance(el, Query):
targets.extend(config.data.get_target_types('query'))
elif isinstance(el, Schema):
targets.extend(config.data.get_target_types('schema'))
elif isinstance(el, int):
targets.extend(config.data.get_target_types('timestamp'))
# FIXME: Resource
targets.extend(config.data.get_target_types('uri-list',
'text-plain',
'TEXT',
'STRING'))
return targets
def get_target_types(el):
"""Return DND target types for element.
"""
targets = []
if isinstance(el, Annotation):
targets.extend(config.data.drag_type['annotation']
+ config.data.drag_type['timestamp']
+ config.data.drag_type['tag'])
elif isinstance(el, Relation):
targets.extend(config.data.drag_type['relation'])
elif isinstance(el, View):
if helper.get_view_type(el) == 'adhoc':
targets.extend(config.data.drag_type['adhoc-view'])
else:
targets.extend(config.data.drag_type['view'])
elif isinstance(el, AnnotationType):
targets.extend(config.data.drag_type['annotation-type'])
elif isinstance(el, RelationType):
targets.extend(config.data.drag_type['relation-type'])
elif isinstance(el, Query):
targets.extend(config.data.drag_type['query'])
elif isinstance(el, Schema):
targets.extend(config.data.drag_type['schema'])
elif isinstance(el, (int, long)):
targets.extend(config.data.drag_type['timestamp'])
# FIXME: Resource
targets.extend(config.data.drag_type['uri-list']
+ config.data.drag_type['text-plain']
+ config.data.drag_type['TEXT']
+ config.data.drag_type['STRING'])
return targets
def OpenStaticView_predefined(self, controller):
"""Return the predefined values.
"""
return { 'viewid': [ ('string:%s' % v.id, controller.get_title(v))
for v in controller.package.views
if helper.get_view_type(v) == 'static'
and v.matchFilter['class'] in ('package', '*') ] }
def OpenStaticView_predefined(self, controller):
"""Return the predefined values.
"""
# FIXME: find the appropriate constraint (toplevel)
return { 'viewid': [ ('string:%s' % v.id, controller.get_title(v))
for v in controller.package.all.views
if helper.get_view_type(v) == 'static' ] }
def action_open_view(self, context, parameters):
"""Event Handler for the OpenView action.
The parameters should have a 'id' key.
"""
view = parameters['id']
v = self.controller.package.get_element_by_id(view)
t = helper.get_view_type(v)
if t == 'static':
# Static view. If it can be applied to the package, then
# apply it. Else open the view itself.
if v.matchFilter['class'] in ('package', '*'):
ctx = self.controller.build_context()
url = ctx.evaluateValue('here/view/%s/absolute_url' % v.id)
else:
ctx = self.controller.build_context(here=v)
url = ctx.evaluateValue('here/absolute_url')
if url:
self.controller.open_url(url)
elif t == 'dynamic':
self.controller.activate_stbv(v)
p = self.controller.player
if p.status != p.PlayingStatus:
self.controller.update_status('start')
elif t == 'adhoc':
self.controller.gui.open_adhoc_view(v, 'south')
else:
self.log(_("Element %s does not look like a view") % view)
return True
def update(self, node=None):
self.node = node
self.element = self.node
self.label['title'].set_markup(
_("View <b>%(title)s</b>\nId: %(id)s") % {
'title':
self.controller.get_title(self.element).replace('<', '<'),
'id':
self.element.id
})
t = helper.get_view_type(self.element)
self.label['activate'].set_sensitive(True)
if t == 'static':
self.label['activate'].set_label(_("Open in webbrowser"))
self.label['info'].set_markup(
_("View applied to %s\n") % self.element.matchFilter['class'])
if not self.element.matchFilter['class'] in ('package', '*'):
self.label['activate'].set_sensitive(False)
elif t == 'dynamic':
self.label['info'].set_text('')
self.label['activate'].set_label(_("Activate"))
elif t == 'adhoc':
self.label['info'].set_text('')
self.label['activate'].set_label(_("Open in GUI"))
else:
self.label['activate'].set_label(_("Unknown type of view??"))
self.label['activate'].set_sensitive(False)
return True
def action_open_view (self, context, parameters):
"""Event Handler for the OpenView action.
The parameters should have a 'id' key.
"""
view=parameters['id']
v=self.controller.package.get_element_by_id(view)
t=helper.get_view_type(v)
if t == 'static':
# Static view. If it can be applied to the package, then
# apply it. Else open the view itself.
if v.matchFilter['class'] in ('package', '*'):
ctx=self.controller.build_context()
url=ctx.evaluateValue('here/view/%s/absolute_url' % v.id)
else:
ctx=self.controller.build_context(here=v)
url=ctx.evaluateValue('here/absolute_url')
if url:
self.controller.open_url(url)
elif t == 'dynamic':
self.controller.activate_stbv(v)
p=self.controller.player
if p.status != p.PlayingStatus:
self.controller.update_status('start')
elif t == 'adhoc':
self.controller.gui.open_adhoc_view(v, 'south')
else:
self.log(_("Element %s does not look like a view") % view)
return True
def update(self, node=None):
self.node=node
self.element=self.node[DetailedTreeModel.COLUMN_ELEMENT]
self.label['title'].set_markup(_("View <b>%(title)s</b>\nId: %(id)s") % {
'title': self.controller.get_title(self.element).replace('<', '<'),
'id': self.element.id })
t=helper.get_view_type(self.element)
self.label['activate'].set_sensitive(True)
if t == 'static':
self.label['activate'].set_label(_("Open in webbrowser"))
self.label['info'].set_markup(_("View applied to %s\n") % self.element.matchFilter['class'])
if not self.element.matchFilter['class'] in ('package', '*'):
self.label['activate'].set_sensitive(False)
elif t == 'dynamic':
self.label['info'].set_text('')
self.label['activate'].set_label(_("Activate"))
elif t == 'adhoc':
self.label['info'].set_text('')
self.label['activate'].set_label(_("Open in GUI"))
else:
self.label['activate'].set_label(_("Unknown type of view??"))
self.label['activate'].set_sensitive(False)
return True
def ActivateSTBV_predefined(self, controller):
"""Return the predefined values.
"""
return {
'viewid': [('string:%s' % v.id, controller.get_title(v))
for v in controller.package.views
if helper.get_view_type(v) == 'dynamic']
}
def nodeChildren (self, node):
#logger.warn("nodechildren %s %s", type(node), node)
children = []
if isinstance (node, Annotation):
children = []
elif isinstance (node, Relation):
children = []
elif isinstance (node, AnnotationType):
if not node in self.childrencache:
self.childrencache[node] = node.annotations
children = self.childrencache[node]
elif isinstance (node, RelationType):
if not node in self.childrencache:
self.childrencache[node] = node.relations
children = self.childrencache[node]
elif isinstance (node, Schema):
# Do not cache these elements
l=list(node.annotationTypes)
l.extend(node.relationTypes)
children = l
elif isinstance (node, View):
children = []
elif isinstance (node, Query):
children = []
elif isinstance (node, Package):
if not node in self.childrencache:
self.childrencache[node] = [node.schemas, self.virtual['views'], node.queries, node.resources or _("No resources") ]
children = self.childrencache[node]
elif isinstance (node, AbstractBundle):
children = node
elif isinstance (node, Resources):
if not node in self.childrencache:
self.childrencache[node] = node.children()
children = self.childrencache[node]
elif isinstance (node, ResourceData):
children = []
elif node == self.virtual['views']:
children=[ self.virtual['static'], self.virtual['dynamic'], self.virtual['adhoc'], self.virtual['admin'] ]
elif node is []:
children = [ self.get_package() ]
else:
children = []
if node == self.virtual['admin']:
children=sorted([ v
for v in node.rootPackage.views
if v.id.startswith('_') ],
key=lambda e: (e.title or e.id).lower())
else:
for t in ('static', 'dynamic', 'adhoc'):
if node == self.virtual[t]:
children=sorted([ v
for v in node.rootPackage.views
if not v.id.startswith('_')
and helper.get_view_type(v) == t ],
key=lambda e: (e.title or e.id).lower())
break
return children
def refresh(self):
self.store.clear()
l = [
v for v in self.controller.package.views
if helper.get_view_type(v) == 'dynamic'
]
for v in l:
self.store.append(
[v, self.controller.get_title(v), v.id, v.id in self.model])
def refresh(self):
self.store.clear()
l=[ v
for v in self.controller.package.views
if helper.get_view_type(v) == 'dynamic' ]
for v in l:
self.store.append([ v,
self.controller.get_title(v),
v.id,
v.id in self.model ])
def row_activated_cb(self, widget, path, view_column):
"""Edit the element on Return or double click
"""
node = self.get_selected_node (widget)
if node is not None:
# If node is an adhoc-view, then open it.
if isinstance(node, View) and helper.get_view_type(node) == 'adhoc':
self.controller.gui.open_adhoc_view(node)
else:
self.controller.gui.edit_element(node)
return True
return False
def activate(self, *p):
"""Action to be executed.
"""
t=helper.get_view_type(self.element)
if t == 'static':
c=self.controller.build_context()
url=c.evaluateValue('here/view/%s/absolute_url' % self.element.id)
self.controller.open_url(url)
elif t == 'dynamic':
self.controller.activate_stbv(self.element)
elif t == 'adhoc':
self.controller.gui.open_adhoc_view(self.element, destination='east')
return True
def row_activated_cb(self, widget, path, view_column):
"""Edit the element on Return or double click
"""
node = self.get_selected_node(widget)
if node is not None:
# If node is an adhoc-view, then open it.
if isinstance(node,
View) and helper.get_view_type(node) == 'adhoc':
self.controller.gui.open_adhoc_view(node)
else:
self.controller.gui.edit_element(node)
return True
return False
def drag_data_get_cb(button, context, selection, targetType, timestamp):
if targetType == config.data.target_type['adhoc-view']:
if not isinstance(self.element, View):
return False
if helper.get_view_type(self.element) != 'adhoc':
return False
selection.set(selection.target, 8,
urllib.urlencode( {
'id': self.element.id,
} ).encode('utf8'))
return True
else:
print "Unknown target type for drag: %d" % targetType
return True
def activate(self, *p):
"""Action to be executed.
"""
t = helper.get_view_type(self.element)
if t == 'static':
c = self.controller.build_context()
url = c.evaluateValue('here/view/%s/absolute_url' %
self.element.id)
self.controller.open_url(url)
elif t == 'dynamic':
self.controller.activate_stbv(self.element)
elif t == 'adhoc':
self.controller.gui.open_adhoc_view(self.element,
destination='east')
return True
def activate(self, *p):
"""Action to be executed.
"""
t=helper.get_view_type(self.element)
if t == 'static':
c=self.controller.build_context()
try:
url=c.evaluateValue('here/view/%s/absolute_url' % self.element.id)
self.controller.open_url(url)
except:
logger.warn("Cannot open static view: error when trying to get its url", exc_info=True)
elif t == 'dynamic':
self.controller.activate_stbv(self.element)
elif t == 'adhoc':
self.controller.gui.open_adhoc_view(self.element, destination='east')
return True
def drag_data_get_cb(button, context, selection, targetType,
timestamp):
if targetType == config.data.target_type['adhoc-view']:
if not isinstance(self.element, View):
return False
if helper.get_view_type(self.element) != 'adhoc':
return False
selection.set(
selection.get_target(), 8,
urllib.parse.urlencode({
'id': self.element.id,
}).encode('utf8'))
return True
else:
logger.warning("Unknown target type for drag: %d", targetType)
return True
def make_view_menu(self, element, menu):
def open_in_browser(i, v):
c=self.controller.build_context()
url=c.evaluateValue('here/view/%s/absolute_url' % v.id)
self.controller.open_url(url)
return True
def add_item(*p, **kw):
self.add_menuitem(menu, *p, **kw)
t=helper.get_view_type(element)
if t == 'dynamic':
add_item(_('Activate view'), self.activate_stbv, element)
elif t == 'adhoc':
add_item(_('Open adhoc view'), self.open_adhoc_view, element)
elif t == 'static' and element.matchFilter['class'] in ('package', '*'):
add_item(_('Open in web browser'), open_in_browser, element)
return
def check_requirements(self):
self.output = Path(self.output)
self.imgdir = self.output / 'imagecache'
if self.callback is None:
self.callback = lambda progress, message: True
if self.output.exists() and not self.output.is_dir():
self.log(_("%s exists but is not a directory. Cancelling website export") % self.output)
return
elif not self.output.exists():
self.output.mkdir(parents=True)
# Last check, to be sure
if not self.output.is_dir():
self.log(_("%s does not exist") % self.output)
return
if self.views:
# Specified view ids, should be a list of string, convert them to a list of views
viewlist = [ (v.strip(), self.controller.package.get_element_by_id(v)) for v in self.views.split(",") ]
missing_views = [ n[0] for n in viewlist if n[1] is None ]
if missing_views:
logger.error(_("The following views do not exist: %s"), ", ".join(missing_views))
views = [ n[1] for n in viewlist if n[1] is not None ]
else:
# Empty, use all views
views = [ v
for v in self.controller.package.views
if (not v.id.startswith('_') # Do not include admin views
and v.matchFilter['class'] == 'package'
and helper.get_view_type(v) == 'static')
]
defaultview = self.controller.package.getMetaData(config.data.namespace, 'default_utbv')
v = self.controller.package.views.get_by_id(defaultview)
if v is not None and v not in views:
# The specified default view is not present in views
# (probably because it starts with _). Add it.
views.append(v)
self.views = views
self.video_player = self.find_video_player(self.video_url)
self.url_translation = {}
def activate(self, *p):
"""Action to be executed.
"""
t = helper.get_view_type(self.element)
if t == 'static':
c = self.controller.build_context()
try:
url = c.evaluateValue('here/view/%s/absolute_url' %
self.element.id)
self.controller.open_url(url)
except:
logger.warning(
"Cannot open static view: error when trying to get its url",
exc_info=True)
elif t == 'dynamic':
self.controller.activate_stbv(self.element)
elif t == 'adhoc':
self.controller.gui.open_adhoc_view(self.element,
destination='east')
return True
def update(self, node=None):
self.node=node
self.element=self.node.element
self.label['title'].set_markup(_("View <b>%(title)s</b>\nId: %(id)s") % {
'title': self.controller.get_title(self.element).replace('<', '<'),
'id': self.element.id })
t=helper.get_view_type(self.element)
self.label['activate'].set_sensitive(True)
if t == 'static':
self.label['activate'].set_label(_("Open in webbrowser"))
# FIXME: check toplevel metadata
#if not self.element.matchFilter['class'] in ('package', '*'):
# self.label['activate'].set_sensitive(False)
elif t == 'dynamic':
self.label['activate'].set_label(_("Activate"))
elif t == 'adhoc':
self.label['activate'].set_label(_("Open in GUI"))
else:
self.label['activate'].set_label(_("Unknown type of view??"))
self.label['activate'].set_sensitive(False)
return True
def nodeParent(self, node):
#logger.warning("nodeparent %s", node)
if isinstance(node, Annotation):
parent = node.type
elif isinstance(node, Relation):
parent = node.type
elif isinstance(node, RelationType):
parent = node.schema
elif isinstance(node, AnnotationType):
parent = node.schema
elif isinstance(node, Schema):
parent = node.rootPackage.schemas
elif isinstance(node, View):
if node.id.startswith('_'):
parent = self.virtual['admin']
else:
t = helper.get_view_type(node)
parent = self.virtual[t]
elif isinstance(node, Query):
parent = node.rootPackage.queries
elif isinstance(node, Package):
parent = None
elif isinstance(node, AbstractBundle):
parent = node.rootPackage
elif isinstance(node, Resources):
parent = node.parent
elif isinstance(node, ResourceData):
parent = node.parent
elif node in (self.virtual['static'], self.virtual['dynamic'],
self.virtual['adhoc'], self.virtual['admin']):
parent = self.virtual['views']
elif node == self.virtual['views']:
parent = node.rootPackage
else:
parent = None
return parent
def drag_received(self, widget, context, x, y, selection, targetType,
time):
def create_and_open_view(sources):
v = self.controller.create_static_view(elements=sources)
p = get_edit_popup(v, controller=self.controller)
self.add_view(p,
name=_("Edit %s") %
self.controller.get_title(v, max_size=40))
# FIXME: put focus on edit window
return True
def edit_annotation(a):
p = get_edit_popup(a, controller=self.controller)
self.add_view(p,
name=_("Edit %s") %
self.controller.get_title(a, max_size=40))
return True
def edit_selection(sources):
"""Edit the selected elements in an edit accumulator.
"""
v = self.controller.gui.open_adhoc_view('editaccumulator',
destination=self.location)
if v is not None:
for a in sources:
v.edit(a)
return True
if targetType == config.data.target_type['adhoc-view']:
data = decode_drop_parameters(selection.data)
label = None
view = None
if 'id' in data:
# Saved parametered view. Get the view itself.
ident = data['id']
v = helper.get_id(self.controller.package.views, ident)
# Get the view_id
if v is None:
self.log(_("Cannot find the view %s") % ident)
return True
name = v
label = v.title
view = self.controller.gui.open_adhoc_view(name,
label=label,
destination=None)
if view is not None:
self.add_view(view, name=view.view_name)
elif 'name' in data:
name = data['name']
if name == 'comment':
saved = [
v for v in self.controller.package.views
if helper.get_view_type(v) == 'static'
and v.matchFilter['class'] == 'package'
and not v.id.startswith('_')
]
else:
saved = [
v for v in self.controller.package.views
if v.content.mimetype ==
'application/x-advene-adhoc-view' and ET.parse(
v.content.stream).getroot().attrib['id'] == name
]
if name == 'transcription':
menu = gtk.Menu()
i = gtk.MenuItem(_("Open a new transcription for..."))
menu.append(i)
sm = gtk.Menu()
i.set_submenu(sm)
for at in self.controller.package.annotationTypes:
title = self.controller.get_title(at, max_size=40)
i = gtk.MenuItem(title, use_underline=False)
i.connect(
'activate', lambda i, s, t: self.controller.gui.
open_adhoc_view(name,
source=s,
label=t,
destination=self.location),
"here/annotationTypes/%s/annotations/sorted" %
at.id, title)
sm.append(i)
elif saved:
menu = gtk.Menu()
if name == 'comment':
i = gtk.MenuItem(_("Create a new comment view"))
else:
i = gtk.MenuItem(_("Open a new view"))
i.connect(
'activate',
lambda i: self.controller.gui.open_adhoc_view(
name, label=label, destination=self.location))
menu.append(i)
else:
menu = None
if menu is not None:
if saved:
i = gtk.MenuItem(_("Open a saved view"))
menu.append(i)
sm = gtk.Menu()
i.set_submenu(sm)
for v in saved:
i = gtk.MenuItem(v.title, use_underline=False)
if name == 'comment':
i.connect(
'activate',
lambda i, vv: self.controller.gui.
open_adhoc_view('edit',
element=vv,
destination=self.location),
v)
else:
i.connect(
'activate',
lambda i, vv: self.controller.gui.
open_adhoc_view(vv,
label=vv.title,
destination=self.location),
v)
sm.append(i)
menu.show_all()
menu.popup(None, None, None, 0,
gtk.get_current_event_time())
else:
view = self.controller.gui.open_adhoc_view(
name, label=label, destination=None)
if view is not None:
self.add_view(view, name=view.view_name)
else:
# Bug
self.log("Cannot happen")
return True
if 'master' in data and view is not None:
# A master view has been specified. Connect it to
# the created view.
master = self.controller.gui.get_adhoc_view_instance_from_id(
data['master'])
view.set_master_view(master)
return True
elif targetType == config.data.target_type['adhoc-view-instance']:
v = self.controller.gui.get_adhoc_view_instance_from_id(
selection.data)
if v is not None:
wid = v.widget
self.add_view(v, name=v._label)
if hasattr(v, 'reparent_done'):
v.reparent_done()
else:
print "Cannot find view ", selection.data
return True
elif targetType == config.data.target_type['view']:
v = self.controller.package.views.get(
unicode(selection.data, 'utf8'))
if helper.get_view_type(v) in ('static', 'dynamic'):
# Edit the view.
self.controller.gui.open_adhoc_view('edit',
element=v,
destination=self.location)
else:
print "Unhandled case in viewbook: targetType=view"
return True
elif targetType == config.data.target_type['query']:
v = self.controller.package.queries.get(
unicode(selection.data, 'utf8'))
if v is not None:
self.controller.gui.open_adhoc_view('edit',
element=v,
destination=self.location)
return True
elif targetType == config.data.target_type['schema']:
v = self.controller.package.schemas.get(
unicode(selection.data, 'utf8'))
if v is not None:
self.controller.gui.open_adhoc_view('edit',
element=v,
destination=self.location)
return True
elif targetType == config.data.target_type['relation']:
v = self.controller.package.relations.get(
unicode(selection.data, 'utf8'))
if v is not None:
self.controller.gui.open_adhoc_view('edit',
element=v,
destination=self.location)
return True
elif targetType == config.data.target_type['annotation-type']:
at = self.controller.package.annotationTypes.get(
unicode(selection.data, 'utf8'))
# Propose a menu to open various views for the annotation-type:
menu = gtk.Menu()
title = self.controller.get_title(at, max_size=40)
i = gtk.MenuItem(_("Use annotation-type %s :") % title,
use_underline=False)
menu.append(i)
for label, action in (
(_("to edit it"),
lambda i: self.controller.gui.open_adhoc_view(
'edit', element=at, destination=self.location)),
(_("to create a new static view"),
lambda i: create_and_open_view([at])),
(_("as a transcription"),
lambda i: self.controller.gui.open_adhoc_view(
'transcription',
source='here/annotationTypes/%s/annotations/sorted' % at.
id,
destination=self.location,
label=title)),
(_("in a timeline"), lambda i: self.controller.gui.
open_adhoc_view('timeline',
elements=at.annotations,
annotationtypes=[at],
destination=self.location,
label=title)),
(_("as a montage"), lambda i: self.controller.gui.
open_adhoc_view('montage',
elements=at.annotations,
destination=self.location,
label=title)),
(_("in a table"), lambda i: self.controller.gui.
open_adhoc_view('table',
elements=at.annotations,
destination=self.location,
label=title)),
(_("in a query"), lambda i: self.controller.gui.
open_adhoc_view('interactivequery',
here=at,
destination=self.location,
label=_("Query %s") % title)),
(_("in the TALES browser"), lambda i: self.controller.gui.
open_adhoc_view('browser',
element=at,
destination=self.location,
label=_("Browsing %s") % title)),
):
i = gtk.MenuItem(u" " + label, use_underline=False)
i.connect('activate', action)
menu.append(i)
menu.show_all()
menu.popup(None, None, None, 0, gtk.get_current_event_time())
return True
elif targetType == config.data.target_type['annotation']:
sources = [
self.controller.package.annotations.get(uri)
for uri in unicode(selection.data, 'utf8').split('\n')
]
# Propose a menu to open various views for the annotation:
menu = gtk.Menu()
if len(sources) == 1:
a = sources[0]
title = self.controller.get_title(a, max_size=40)
i = gtk.MenuItem(_("Use annotation %s :") % title,
use_underline=False)
menu.append(i)
for label, action in (
(_("to edit it"), lambda i: edit_annotation(a)),
(_("to create a new static view"),
lambda i: create_and_open_view(sources)),
(_("in a query"), lambda i: self.controller.gui.
open_adhoc_view('interactivequery',
here=a,
destination=self.location,
label=_("Query %s") % title)),
(_("in the TALES browser"), lambda i: self.controller.gui.
open_adhoc_view('browser',
element=a,
destination=self.location,
label=_("Browse %s") % title)),
(_("to display its contents"), lambda i: self.controller.
gui.open_adhoc_view('annotationdisplay',
annotation=a,
destination=self.location,
label=_("%s") % title)),
(_("as a bookmark"), lambda i: self.controller.gui.
open_adhoc_view('activebookmarks',
elements=[a.fragment.begin],
destination=self.location)),
):
i = gtk.MenuItem(u" " + label, use_underline=False)
i.connect('activate', action)
menu.append(i)
def apply_query(m, q):
ctx = self.controller.build_context(here=a)
res, qexpr = self.controller.evaluate_query(q, context=ctx)
self.controller.gui.open_adhoc_view(
'interactiveresult',
query=q,
result=res,
destination=self.location)
return True
if self.controller.package.queries:
sm = gtk.Menu()
for q in self.controller.package.queries:
i = gtk.MenuItem(self.controller.get_title(
q, max_size=40),
use_underline=False)
i.connect('activate', apply_query, q)
sm.append(i)
i = gtk.MenuItem(u" " +
_("as the context for the query..."),
use_underline=False)
i.set_submenu(sm)
menu.append(i)
else:
title = _("Set of annotations")
i = gtk.MenuItem(_("Use annotations:"), use_underline=False)
menu.append(i)
for label, action in (
(_("to edit them"), lambda i: edit_selection(sources)),
(_("in a table"), lambda i: self.controller.gui.
open_adhoc_view('table', elements=sources)),
(_("to create a new static view"),
lambda i: create_and_open_view(sources)),
(_("as bookmarks"),
lambda i: self.controller.gui.open_adhoc_view(
'activebookmarks',
elements=[a.fragment.begin for a in sources],
destination=self.location)),
):
i = gtk.MenuItem(u" " + label, use_underline=False)
i.connect('activate', action)
menu.append(i)
menu.show_all()
menu.popup(None, None, None, 0, gtk.get_current_event_time())
return True
elif targetType == config.data.target_type['timestamp']:
data = decode_drop_parameters(selection.data)
v = self.controller.gui.open_adhoc_view('activebookmarks',
destination=self.location)
v.append(long(data['timestamp']), comment=data.get('comment', ''))
return True
else:
print "Unknown drag target received ", targetType
return False
def nodeChildren(self, node):
#logger.warning("nodechildren %s %s", type(node), node)
children = []
if isinstance(node, Annotation):
children = []
elif isinstance(node, Relation):
children = []
elif isinstance(node, AnnotationType):
if not node in self.childrencache:
self.childrencache[node] = node.annotations
children = self.childrencache[node]
elif isinstance(node, RelationType):
if not node in self.childrencache:
self.childrencache[node] = node.relations
children = self.childrencache[node]
elif isinstance(node, Schema):
# Do not cache these elements
l = list(node.annotationTypes)
l.extend(node.relationTypes)
children = l
elif isinstance(node, View):
children = []
elif isinstance(node, Query):
children = []
elif isinstance(node, Package):
if not node in self.childrencache:
self.childrencache[node] = [
node.schemas, self.virtual['views'], node.queries,
node.resources or _("No resources")
]
children = self.childrencache[node]
elif isinstance(node, AbstractBundle):
children = node
elif isinstance(node, Resources):
if not node in self.childrencache:
self.childrencache[node] = node.children()
children = self.childrencache[node]
elif isinstance(node, ResourceData):
children = []
elif node == self.virtual['views']:
children = [
self.virtual['static'], self.virtual['dynamic'],
self.virtual['adhoc'], self.virtual['admin']
]
elif isinstance(node, list) and len(node) == 0:
children = [self.get_package()]
else:
children = []
if node == self.virtual['admin']:
children = sorted([
v for v in node.rootPackage.views if v.id.startswith('_')
],
key=lambda e: (e.title or e.id).lower())
else:
for t in ('static', 'dynamic', 'adhoc'):
if node == self.virtual[t]:
children = sorted([
v for v in node.rootPackage.views
if not v.id.startswith('_')
and helper.get_view_type(v) == t
],
key=lambda e:
(e.title or e.id).lower())
break
return children
def children(self):
yield ListNode( [ v for v in self.element if helper.get_view_type(v) == 'static' and not v.id.startswith('_') and not v.id.startswith(':') ], _("Static views"))
yield ListNode( [ v for v in self.element if helper.get_view_type(v) == 'dynamic' and not v.id.startswith('_') ], _("Dynamic views"))
yield ListNode( [ v for v in self.element if helper.get_view_type(v) == 'adhoc' and not v.id.startswith('_') ], _("Adhoc views"))
yield ListNode( [ v for v in self.element if v.id.startswith('_') ], _("Admin views"))
yield ListNode( [ v for v in self.element if helper.get_view_type(v) == 'static' and v.id.startswith(':')], _("Constraint views"))
def ActivateSTBV_predefined(self, controller):
"""Return the predefined values.
"""
return { 'viewid': [ ('string:%s' % v.id, controller.get_title(v))
for v in controller.package.views
if helper.get_view_type(v) == 'dynamic' ] }
def drag_data_get_cb(widget, context, selection, targetType, timestamp, controller):
"""Generic drag-data-get handler.
It is used by the origin widget of a drag action, when the
destination widget queries for the DND data.
Usage information:
this method must be connected passing the controller as user data:
widget.connect('drag-data-get', drag_data_get_cb, controller)
and the context must have a _element attribute (defined in a
'drag-begin' handler for instance).
"""
typ=config.data.target_type
el = context._element
# FIXME: think about the generalisation of the notion of container
# selection (for timestamp lists for instance)
widgets = None
try:
c = widget.container
except (AttributeError, RuntimeError):
# No container. Note that getattr(widget, 'container', None)
# would anyway raise a RuntimeError (container is some kind of
# reserved in gtk).
c = None
if c:
try:
widgets = c.get_selected_annotation_widgets()
if not widget in widgets:
widgets = None
except AttributeError:
logger.error("Cannot get_selected_annotation_widgets", exc_info=True)
d={ typ['annotation']: Annotation,
typ['annotation-type']: AnnotationType,
typ['relation']: Relation,
typ['relation-type']: RelationType,
typ['view']: View,
typ['query']: Query,
typ['schema']: Schema }
if targetType in d:
# Directly pass URIs for Annotation, types and views
if not isinstance(el, d[targetType]):
return False
if widgets:
selection.set(selection.get_target(), 8, "\n".join( w.annotation.uri for w in widgets ).encode('utf8'))
else:
selection.set(selection.get_target(), 8, el.uri.encode('utf8'))
return True
elif targetType == typ['adhoc-view']:
if helper.get_view_type(el) != 'adhoc':
return False
selection.set(selection.get_target(), 8, encode_drop_parameters(id=el.id))
return True
elif targetType == typ['uri-list']:
if widgets:
selection.set(selection.get_target(), 8, "\n".join( controller.build_context(here=w.annotation).evaluateValue('here/absolute_url') for w in widgets ).encode('utf8'))
else:
try:
uri=controller.build_context(here=el).evaluateValue('here/absolute_url')
except:
uri="No URI for " + str(el)
selection.set(selection.get_target(), 8, uri.encode('utf8'))
elif targetType == typ['timestamp']:
if isinstance(el, int):
selection.set(selection.get_target(), 8, encode_drop_parameters(timestamp=el))
elif isinstance(el, Annotation):
selection.set(selection.get_target(), 8, encode_drop_parameters(timestamp=el.fragment.begin,
comment=controller.get_title(el)))
else:
logger.error("Inconsistent DND target %s", targetType)
return True
elif targetType in (typ['text-plain'], typ['STRING']):
selection.set(selection.get_target(), 8, controller.get_title(el).encode('utf8'))
else:
logger.warn("Unknown target type for drag: %d" % targetType)
return True
def drag_received(self, widget, context, x, y, selection, targetType, time):
def create_and_open_view(sources):
v=self.controller.create_static_view(elements=sources)
p=get_edit_popup(v, controller=self.controller)
self.add_view(p, name=_("Edit %s") % self.controller.get_title(v, max_size=40))
# FIXME: put focus on edit window
return True
def edit_annotation(a):
p=get_edit_popup(a, controller=self.controller)
self.add_view(p, name=_("Edit %s") % self.controller.get_title(a, max_size=40))
return True
def edit_selection(sources):
"""Edit the selected elements in an edit accumulator.
"""
v=self.controller.gui.open_adhoc_view('editaccumulator',
destination=self.location)
if v is not None:
for a in sources:
v.edit(a)
return True
if targetType == config.data.target_type['adhoc-view']:
data=decode_drop_parameters(selection.data)
label=None
view=None
if 'id' in data:
# Saved parametered view. Get the view itself.
ident=data['id']
v=self.controller.package.get(ident)
# Get the view_id
if v is None:
self.log(_("Cannot find the view %s") % ident)
return True
name=v
label=v.title
view=self.controller.gui.open_adhoc_view(name, label=label, destination=None)
self.add_view(view, name=view.view_name)
elif 'name' in data:
name=data['name']
def stbv_name(v):
f=v.content.as_file
try:
n=ET.parse(f).getroot().attrib.get('id')
except:
n=None
f.close()
return n
saved=[ v
for v in self.controller.package.all.views
if v.content.mimetype == 'application/x-advene-adhoc-view'
and stbv_name(v) == name ]
if name == 'transcription':
menu=gtk.Menu()
i=gtk.MenuItem(_("Open a new transcription for..."))
menu.append(i)
sm=gtk.Menu()
i.set_submenu(sm)
for at in self.controller.package.all.annotation_types:
title=self.controller.get_title(at)
i=gtk.MenuItem(title, use_underline=False)
i.connect('activate', lambda i, s, t: self.controller.gui.open_adhoc_view(name, source=s, label=t, destination=self.location), "here/all/annotation_types/%s/annotations/sorted" % at.id, title)
sm.append(i)
elif saved:
menu=gtk.Menu()
if name == 'comment':
i=gtk.MenuItem(_("Create a new comment view"))
else:
i=gtk.MenuItem(_("Open a new view"))
i.connect('activate', lambda i: self.controller.gui.open_adhoc_view(name, label=label, destination=self.location))
menu.append(i)
else:
menu=None
if menu is not None:
if saved:
i=gtk.MenuItem(_("Open a saved view"))
menu.append(i)
sm=gtk.Menu()
i.set_submenu(sm)
for v in saved:
i=gtk.MenuItem(v.title, use_underline=False)
if name == 'comment':
i.connect('activate', lambda i, vv: self.controller.gui.open_adhoc_view('edit', element=vv, destination=self.location), v)
else:
i.connect('activate', lambda i, vv: self.controller.gui.open_adhoc_view(vv, label=vv.title, destination=self.location), v)
sm.append(i)
menu.show_all()
menu.popup(None, None, None, 0, gtk.get_current_event_time())
else:
view=self.controller.gui.open_adhoc_view(name, label=label, destination=None)
if view is not None:
self.add_view(view, name=view.view_name)
else:
# Bug
self.log("Cannot happen")
return True
if 'master' in data and view is not None:
# A master view has been specified. Connect it to
# the created view.
master=self.controller.gui.get_adhoc_view_instance_from_id(data['master'])
view.set_master_view(master)
return True
elif targetType == config.data.target_type['adhoc-view-instance']:
v=self.controller.gui.get_adhoc_view_instance_from_id(selection.data)
if v is not None:
wid=v.widget
self.add_view(v, name=v._label)
if hasattr(v, 'reparent_done'):
v.reparent_done()
else:
print "Cannot find view ", selection.data
return True
elif targetType == config.data.target_type['view']:
v=self.controller.package.views.get(unicode(selection.data, 'utf8'))
if helper.get_view_type(v) in ('static', 'dynamic'):
# Edit the view.
self.controller.gui.open_adhoc_view('edit', element=v, destination=self.location)
else:
print "Unhandled case in viewbook: targetType=view"
return True
elif targetType == config.data.target_type['query']:
v=self.controller.package.queries.get(unicode(selection.data, 'utf8'))
if v is not None:
self.controller.gui.open_adhoc_view('edit', element=v, destination=self.location)
return True
elif targetType == config.data.target_type['schema']:
v=self.controller.package.get(unicode(selection.data, 'utf8'))
if v is not None:
self.controller.gui.open_adhoc_view('edit', element=v, destination=self.location)
return True
elif targetType == config.data.target_type['relation']:
v=self.controller.package.relations.get(unicode(selection.data, 'utf8'))
if v is not None:
self.controller.gui.open_adhoc_view('edit', element=v, destination=self.location)
return True
elif targetType == config.data.target_type['annotation-type']:
at=self.controller.package.get(unicode(selection.data, 'utf8'))
# Propose a menu to open various views for the annotation-type:
menu=gtk.Menu()
title=self.controller.get_title(at, max_size=40)
i=gtk.MenuItem(_("Use annotation-type %s :") % title, use_underline=False)
menu.append(i)
for label, action in (
(_("to edit it"), lambda i :self.controller.gui.open_adhoc_view('edit', element=at, destination=self.location)),
(_("to create a new static view"), lambda i: create_and_open_view([ at ])),
(_("as a transcription"), lambda i: self.controller.gui.open_adhoc_view('transcription', source='here/annotation_types/%s/annotations' % at.id, destination=self.location, label=title)),
(_("in a timeline"), lambda i: self.controller.gui.open_adhoc_view('timeline', elements=at.annotations, annotationtypes=[ at ], destination=self.location, label=title)),
(_("as a montage"), lambda i: self.controller.gui.open_adhoc_view('montage', elements=at.annotations, destination=self.location, label=title)),
(_("in a table"), lambda i: self.controller.gui.open_adhoc_view('table', elements=at.annotations, destination=self.location, label=title)),
(_("in a query"), lambda i: self.controller.gui.open_adhoc_view('interactivequery', here=at, destination=self.location, label=_("Query %s") % title)),
(_("in the TALES browser"), lambda i: self.controller.gui.open_adhoc_view('browser', element=at, destination=self.location, label=_("Browsing %s") % title)),
):
i=gtk.MenuItem(u" " + label, use_underline=False)
i.connect('activate', action)
menu.append(i)
menu.show_all()
menu.popup(None, None, None, 0, gtk.get_current_event_time())
return True
elif targetType == config.data.target_type['annotation']:
sources=[ self.controller.package.get(uri) for uri in unicode(selection.data, 'utf8').split('\n') ]
# Propose a menu to open various views for the annotation:
menu=gtk.Menu()
if len(sources) == 1:
a=sources[0]
title=self.controller.get_title(a, max_size=40)
i=gtk.MenuItem(_("Use annotation %s :") % title, use_underline=False)
menu.append(i)
for label, action in (
(_("to edit it"), lambda i: edit_annotation(a)),
(_("to create a new static view"), lambda i: create_and_open_view(sources)),
(_("in a query"), lambda i: self.controller.gui.open_adhoc_view('interactivequery', here=a, destination=self.location, label=_("Query %s") % title)),
(_("in the TALES browser"), lambda i: self.controller.gui.open_adhoc_view('browser', element=a, destination=self.location, label=_("Browse %s") % title)),
(_("to display its contents"), lambda i: self.controller.gui.open_adhoc_view('annotationdisplay', annotation=a, destination=self.location, label=_("%s") % title)) ,
(_("as a bookmark"), lambda i: self.controller.gui.open_adhoc_view('activebookmarks', elements=[ a.begin ], destination=self.location)),
):
i=gtk.MenuItem(u" " + label, use_underline=False)
i.connect('activate', action)
menu.append(i)
def apply_query(m, q):
ctx=self.controller.build_context(here=a)
res, qexpr=self.controller.evaluate_query(q, context=ctx)
self.controller.gui.open_adhoc_view('interactiveresult', query=q, result=res, destination=self.location)
return True
if self.controller.package.all.queries:
sm=gtk.Menu()
for q in self.controller.package.queries:
i=gtk.MenuItem(self.controller.get_title(q, max_size=40), use_underline=False)
i.connect('activate', apply_query, q)
sm.append(i)
i=gtk.MenuItem(u" " + _("as the context for the query..."), use_underline=False)
i.set_submenu(sm)
menu.append(i)
else:
title=_("Set of annotations")
i=gtk.MenuItem(_("Use annotations:"), use_underline=False)
menu.append(i)
for label, action in (
(_("to edit them"), lambda i: edit_selection(sources)),
(_("in a table"), lambda i: self.controller.gui.open_adhoc_view('table', elements=sources)),
(_("to create a new static view"), lambda i: create_and_open_view(sources)),
(_("as bookmarks"), lambda i: self.controller.gui.open_adhoc_view('activebookmarks', elements=[ a.begin for a in sources ], destination=self.location)),
):
i=gtk.MenuItem(u" " + label, use_underline=False)
i.connect('activate', action)
menu.append(i)
menu.show_all()
menu.popup(None, None, None, 0, gtk.get_current_event_time())
return True
elif targetType == config.data.target_type['timestamp']:
data=decode_drop_parameters(selection.data)
v=self.controller.gui.open_adhoc_view('activebookmarks', destination=self.location)
v.append(long(data['timestamp']), comment=data.get('comment', ''))
return True
else:
print "Unknown drag target received ", targetType
return False
def drag_data_get_cb(widget, context, selection, targetType, timestamp, controller):
"""Generic drag-data-get handler.
It is used by the origin widget of a drag action, when the
destination widget queries for the DND data.
Usage information:
this method must be connected passing the controller as user data:
widget.connect('drag-data-get', drag_data_get_cb, controller)
and the context must have a _element attribute (defined in a
'drag-begin' handler for instance).
"""
typ=config.data.target_type
el = context._element
# FIXME: think about the generalisation of the notion of container
# selection (for timestamp lists for instance)
widgets = None
try:
c = widget.container
except (AttributeError, RuntimeError):
# No container. Note that getattr(widget, 'container', None)
# would anyway raise a RuntimeError (container is some kind of
# reserved in gtk).
c = None
if c:
try:
widgets = c.get_selected_annotation_widgets()
if not widget in widgets:
widgets = None
except AttributeError:
logger.error("Cannot get_selected_annotation_widgets", exc_info=True)
d={ typ['annotation']: Annotation,
typ['annotation-type']: AnnotationType,
typ['relation']: Relation,
typ['relation-type']: RelationType,
typ['view']: View,
typ['query']: Query,
typ['schema']: Schema }
if targetType in d:
# Directly pass URIs for Annotation, types and views
if not isinstance(el, d[targetType]):
return False
if widgets:
selection.set(selection.get_target(), 8, "\n".join( w.annotation.uri for w in widgets ).encode('utf8'))
else:
selection.set(selection.get_target(), 8, el.uri.encode('utf8'))
return True
elif targetType == typ['adhoc-view']:
if helper.get_view_type(el) != 'adhoc':
return False
selection.set(selection.get_target(), 8, encode_drop_parameters(id=el.id))
return True
elif targetType == typ['uri-list']:
if widgets:
selection.set(selection.get_target(), 8, "\n".join( controller.build_context(here=w.annotation).evaluateValue('here/absolute_url') for w in widgets ).encode('utf8'))
else:
try:
uri=controller.build_context(here=el).evaluateValue('here/absolute_url')
except:
uri="No URI for " + str(el)
selection.set(selection.get_target(), 8, uri.encode('utf8'))
elif targetType == typ['timestamp']:
if isinstance(el, int):
selection.set(selection.get_target(), 8, encode_drop_parameters(timestamp=el))
elif isinstance(el, Annotation):
selection.set(selection.get_target(), 8, encode_drop_parameters(timestamp=el.fragment.begin,
comment=controller.get_title(el)))
else:
logger.error("Inconsistent DND target %s", targetType)
return True
elif targetType in (typ['text-plain'], typ['STRING']):
selection.set(selection.get_target(), 8, controller.get_title(el).encode('utf8'))
else:
logger.warning("Unknown target type for drag: %d", targetType)
return True
def drag_data_get_cb(widget, context, selection, targetType, timestamp, controller):
"""Generic drag-data-get handler.
Usage information:
this method must be connected passing the controller as user data:
widget.connect('drag-data-get', drag_data_get_cb, controller)
and the context must has a _element attribute (defined in a
'drag-begin' handler for instance).
"""
typ=config.data.target_type
el = context._element
# FIXME: think about the generalisation of the notion of container
# selection (for timestamp lists for instance)
try:
widgets = widget.container.get_selected_annotation_widgets()
if not widget in widgets:
widgets = None
except AttributeError:
widgets=None
d={ typ['annotation']: Annotation,
typ['annotation-type']: AnnotationType,
typ['relation']: Relation,
typ['relation-type']: RelationType,
typ['view']: View,
typ['query']: Query,
typ['schema']: Schema }
if targetType in d:
# Directly pass URIs for Annotation, types and views
if not isinstance(el, d[targetType]):
return False
if widgets:
selection.set(selection.target, 8, "\n".join( w.annotation.uriref for w in widgets ).encode('utf8'))
else:
selection.set(selection.target, 8, el.uriref.encode('utf8'))
return True
elif targetType == typ['adhoc-view']:
if helper.get_view_type(el) != 'adhoc':
return False
selection.set(selection.target, 8, encode_drop_parameters(id=el.id))
return True
elif targetType == typ['uri-list']:
if widgets:
selection.set(selection.target, 8, "\n".join( controller.build_context(here=w.annotation).evaluate('here/absolute_url') for w in widgets ).encode('utf8'))
else:
try:
uri=controller.build_context(here=el).evaluate('here/absolute_url')
except:
uri="No URI for " + unicode(el)
selection.set(selection.target, 8, uri.encode('utf8'))
elif targetType == typ['timestamp']:
if isinstance(el, (int, long)):
selection.set(selection.target, 8, encode_drop_parameters(timestamp=el))
elif isinstance(el, Annotation):
selection.set(selection.target, 8, encode_drop_parameters(timestamp=el.begin,
comment=controller.get_title(el)))
else:
print "Inconsistent DND target"
return True
elif targetType in (typ['text-plain'], typ['STRING']):
selection.set(selection.target, 8, controller.get_title(el).encode('utf8'))
else:
print "Unknown target type for drag: %d" % targetType
return True
def drag_data_get_cb(widget, context, selection, targetType, timestamp,
controller):
"""Generic drag-data-get handler.
Usage information:
this method must be connected passing the controller as user data:
widget.connect('drag-data-get', drag_data_get_cb, controller)
and the context must has a _element attribute (defined in a
'drag-begin' handler for instance).
"""
typ = config.data.target_type
el = context._element
# FIXME: think about the generalisation of the notion of container
# selection (for timestamp lists for instance)
try:
widgets = widget.container.get_selected_annotation_widgets()
if not widget in widgets:
widgets = None
except AttributeError:
widgets = None
d = {
typ['annotation']: Annotation,
typ['annotation-type']: AnnotationType,
typ['relation']: Relation,
typ['relation-type']: RelationType,
typ['view']: View,
typ['query']: Query,
typ['schema']: Schema
}
if targetType in d:
# Directly pass URIs for Annotation, types and views
if not isinstance(el, d[targetType]):
return False
if widgets:
selection.set(
selection.target, 8,
"\n".join(w.annotation.uri for w in widgets).encode('utf8'))
else:
selection.set(selection.target, 8, el.uri.encode('utf8'))
return True
elif targetType == typ['adhoc-view']:
if helper.get_view_type(el) != 'adhoc':
return False
selection.set(selection.target, 8, encode_drop_parameters(id=el.id))
return True
elif targetType == typ['uri-list']:
if widgets:
selection.set(
selection.target, 8, "\n".join(
controller.build_context(here=w.annotation.uri).
evaluateValue('here/absolute_url')
for w in widgets).encode('utf8'))
else:
try:
uri = controller.build_context(
here=el).evaluateValue('here/absolute_url')
except:
uri = "No URI for " + unicode(el)
selection.set(selection.target, 8, uri.encode('utf8'))
elif targetType == typ['timestamp']:
if isinstance(el, (int, long)):
selection.set(selection.target, 8,
encode_drop_parameters(timestamp=el))
elif isinstance(el, Annotation):
selection.set(
selection.target, 8,
encode_drop_parameters(timestamp=el.fragment.begin,
comment=controller.get_title(el)))
else:
print "Inconsistent DND target"
return True
elif targetType in (typ['text-plain'], typ['STRING']):
selection.set(selection.target, 8,
controller.get_title(el).encode('utf8'))
else:
print "Unknown target type for drag: %d" % targetType
return True
