Filewatcher File Search File Search
Content Search
» » » » advene_1.0.orig.tar.gz » Content »
pkg://advene_1.0.orig.tar.gz:2047617/advene-1.0/doc/  info  downloads


* QRcode extractor

* Have webcherry listen on both ipv4/ipv6

* advene.js:  adapt behaviour (modify video url, display warning) based on jquery.browser

* advene.js: generate <video> <source...> with .x264 + .ogg references

* online video URLs: use quvi

* Shortcuts FCP: cf mail YP 2010/12/14

* example SVG + lien -> json

* Update default-fps value when data is available from player

* feature extraction: check against filename encoding

* pymecavideo: see opencv example

* finder: in Static view/dynamic view columns, add a "+" item

* finder: filter (global or by column), grouping (by column)

* finder: implement set_current_element method

* gst spectrum videoanalyse

* display clock cursor for lengthy actions (timeline update)

* snapshotter: bug for (look for "silver beach")

* Implement a "security" option to disable/enable on demand python: expressions in TAL

* Optional feature: automatically pause when  creating an annotation ?

* Undo: implement Redo

* Undo: history stack display

* Cut Adjustment: use image *before* the cut (like in FCP)

* Annotation bound adjust: open as adhoc-view

* Default caption dynamic view: make non-admin (remove _)

* MacOSX: use Cmd modifier equiv. as control

* Import youtube annotations ( )

* gstreamer pipeline (videomixer) to generate 1-pixel-column sum-up of video:
gst-launch -e filesrc location=/data/video/Bataille.avi ! decodebin ! videoscale ! ffmpegcolorspace ! video/x-raw-rgb,width=320,pixel-aspect-ratio=\(fraction\)1/1 ! videocrop left=158 right=160 ! progressreport update-freq=1 ! pngenc snapshot=false ! multifilesink location=%05d.png
montage -tile x1 -mode Concatenate 0*g final.png

* montage: video export

* transcribe: allow search/replace

* quick edit: integrate EntryCompletion on attributes

* add PyDiscoverer interface, to get movie details ASAP

* trace replay mode of video navigation (replay video based on navigation events) -> trace player with controlled video player

* Customizable shortcuts

* Save current workspace: display option in Save dialog

* Ldt ZIP importer

* Screen overlay interface: define a grid with sensitive areas + event
   -> need to implement player.get_dimensions() method

* implement a "Stream record" feature in the player (tee+encode before imagesink)

* Generic subprocess registration (prononce, tts...) to make sure that we terminate them at Advene exit.

* table view: keyword occurrences + stats

* gstrecorder: option to specify wether to record from webcam
   (autovideosrc) or from screen (ximagesrc/dshowvideosrc...) or

* content.parsed: define/use a PATH syntax for accessing XML elements
   (better than handyxml)

* propose template when transmuting from any (esp.text/plain) to SVG

* controller.update_status: accept annotation as parameter, to allow
   more precise notification

* gstreamer: multiple video syntax: path;path -> videobox

* gui.edit.rules: SimpleQuery edition will fail since TALESEntry does
   not handle multiple sources

* Fix autocompletion of attribute names for annotations (should
   record key=value strings)

* Shortcut for edit element validation

* webcherry: use content negociation for invoking appropriate views

* Utilisation npt:/

* transcribe: use textbuffer.get_modified/set_modified

* gui.main: simple click on Adhocview icon -> share code with viewbook
   (menu New/open existing).

* EditElementPopup: if destination != popup, add scrolledwidget around

* timeline: fix continous scrolling. Set zoom 96%, 0h59 in Nosferatu

* tabular adhoc view, with customizable columns and options to export as HTML

* HTMLeditor: implement basic css parsing (cf python-cssutils)

* htmleditor: when suppressing a tag with tal: instructions (define,
   ...), recreate it ? Or delete the whole block ?

* Undo for activebookmarks

* Import dialog: use a standard fileselector with a import-filter list

* When DND rule in STBV editing, use the current edited rule and not
   the saved one -> hard

* Revamp player API (player.position, player.duration, ...)

* Bug in Advene2 export -> resources

* Template: in _package_view, propose to Open adhoc views

* Imagemap/SVG

* improve search results navigation (cf PA post on May 2 2008)

* Montage: double-click -> goto annotation

* Auto-pause in montage view

* Put Montage view in dynamic views menu

* timeline popup menu on annotation: offer access to possibly
   overlapping annotations

* Synchronise transcribe with annotations/timeline
 * create new type. On view rename -> set new type title
 * create/fusion/delete annotations when modifying timestamps

* make all simple selections (annotation, timestamp, etc) able to get
   multiline data to represent element list

* Selection: extend-to-next ?

* Global timeline with frame to represent "overview + detail" (p174)

* Dynamic queries/filters (p.178)

* Data brushing p.181 -> selection in a view, highlight in others

* timeline: memorize zoom level and position when changing package
   (needs a timeline.zoom_level[package_uri] structure)

* allow to change mimetype when editing resource

* shapewidget: complete support for <image> element. How to deal with
   images as resources ?

* adhoc view: imagemap, with DND of annotation to the image

* fix timeline relation lines display

* write a ContentHandler for x-advene-quicksearch

* shotdetect: allow to specify begin/end times, to allow to redo a segmentation with a new threshold

* Assistant for generating HTML views from annotations (propose some
   common layouts: plain TOC, illustrated TOC, etc)

* view creation (static/dynamic): step by step wizard

* AdveneTypes a la XSD

* gtk locale in win32

* transcription: option to display timestamp marks and allow to modify

* Montage: extend with 2nd video (cf bout-a-bout) ?

* package merge: group items by categories (views, annotations, schemas...)

* annotation highlight: other representation (red thick border ?)

* editaccumulator: distinguish incomplete annotations (missing entidtime)

* Convert event names from strings to objects (faster comparison?)

* Allow to lock workspace modifications (to propose a read-only version)

* interactive result: allow to DND the icon for new visualisations
   (timeline...) [hard because of the transmission of the parameters
   in DND and anyway buttons are now in a toolbar, which prevents DND]

* slave view: record master view id in options when saving

* highlight: blink (wait for gtk.Transition in 2.12?)

* zippackage: implement a 'serialize'/'freeze' method, to save the data to the temp. directory (w/o overwriting the .azp package). This would allow regular backups of the data.

* controller.get_url_for_alias: use correct baseurl from cherrypy request when possible

* timeline

** Deactivate autoscroll when moving in the timeline

** timeline: reimplement with a proper canvas (goocanvas?)

** Make relation lines clickable (cf goocanvas)

** timeline: allow view-local tags/color to allow to define a specific color for various annotations for a given timeline (display a point of view, specific to the view)

** timeline parameters: use TALES expressions for each line instead of annotation types (-> we can use queries and also have multiple packages in the same timeline)

** timeline: allow to group annotation types with tags

** timeline: Center on related annotation

** timeline: find a way to render overlapping buttons (cf goocanvas)

* transcribe: add a small timeline on the top that displays the
position of current marks in the video (with small lines) [cf linkmap
   in /usr/lib/meld/ ]

* Importers

** rewrite importers with ElementTree

* Main GUI

** new signal: CurrentAnnotation

* New views

** Tag cloud view

* Players

** write a flashplayer plugin using ctypes + gnash/swfdec - or

** video plugin: ffmpeg

** MacOS X: write a qtplayer using the Carbon.Qt functionalities (cf


** Rewrite admin templates with AJAX functionalities

** write advene helpers for pyjamas to write wysiwyg code

* Interactive query 

** search result: if different types (or different than annotations), display a tree with the selected elements, one branch per type (annotation, schema, view...)

* Use JSON for structured content + simple schema described in JSON
  (name, type, constraints) :
[ {'name': 'foo', 'type': 'int', 'constraints': { 'lower': 0, 'upper': 256 } },
  {'name': 'bar', 'type': 'str', 'constraints': { 'regexp': '^[a-z]+$' } },
Cf for implementations comparison

* Hook to define new events (spatial events: EnterZone, LeaveZone... for instance)

* Save dynamic view rendering: ~/src/vlc-dev/vlc --plugin-path ~/src/vlc-dev jurannessic_320x192.mpg :sout='#transcode{vcodec=mp1v,vb=4096,acodec=mpga,ab=192,scale=1,channels=2,deinterlace,audio-sync}:std{access=file,mux=ps,url="foo.mpg"}'

* import MIT video lectures

* reuse MIT video lecture javascript code

* website: write the Advene roadmap

* Keep /application, or use /action for everything ?

* make most admin views return XML + XSL stylesheets (action, methods...)

* /packages: convert to XML/XSL + offer the possibility to activate a package

* note-taking: integrate Gobby component

* Fix DND to webbrowser on windows
* 'auto-import-types': if empty, default to views, schemas, queries. Could also add annotations/relations.

* load/save hooks

* Convention: is_illustrated_by relation-type. In snapshot_url, if a
  relation exists, use it to get the snapshot. Else use the begin

* define a virtual "global" package that will iterate and forward methods (annotations, relation...) over all loaded packages

* transtyping: preserve/recreate relations

* VerticalList : equiv. navigation history parameterized with 2 tales expressions: item list, representation [ history / annotation/fragment/formatted/duration ]

* component "scroller" below the vout. Parameters: text, href (optional), past duration, current
  duration, future duration [ | past | current | future | ]  

* Audio commentaries : add a "Record" button. While pressed, it
   records. Upon release, it creates an annotation with the correct

* import fixer: allow to edit imports without loading the package
   (which fails if imported package is not accessible).

* allow to edit the path of imported packages, to allow relative paths

* notification of new popups when embedded (flash tab)

* allow to specify the browser for open_url in preferences

* Define a ParameteredQuery which takes a single parameter in the path, e.g.:
  (use a wrapper similar to the one used for views. Maybe we can
  generalize this principle).

* Implement transmission of elements between different applications (esp. transmission of annotations [bounds + content] between 2 timelines) -> new target type + element xml repr.

* allow i18n of template.xml

* Pb (QName related) when importing a package importing another one
   (try importing wrong-trousers):
p.imports[0].package.views[1]._getParent().uri, p.imports[1].package.uri
that should return the same URI. The proposed solution is to enforce the importing package to explicitly import the second level imported ones. Pb: namespace clash

* Write a advene-openoffice binding to automate video/presentation sync.

* New action: translate ?

* webserver: implement a wiki-like syntax in views that dynamically generates links to Advene elements/TALES expressions (define a application/x-advene-wiki that will get converted into a TAL template)

* handle wiki syntax in transcriptionedit, so that we can do simple notetaking with some markup easily.

* make navigation history accessible from TALES (/options/history ?)

* keep a viewed_segments structure to propose a view "Not yet viewed sequences"

* Advene tutorial in advene, with a video capture of an interaction session

* New action: display a fragment of a video then continue from the
position where the link was activated. Parameters: fragment to play,
return position, or display in a new video window

* navigation history: put 2 snapshots (origin, destination) to contextualize

* controller.update: implement a future_approaching and a
future_leaving to implement a -2 seconds before / +2 seconds after
annotation event.

* Add a "release" script that updates the version number in:
  lib/advene/core/ (+ date)
 + wget Twiki:AdveneUserGuide to doc/user.html (cf scripts/update_doc)

* browser: select base element (annotation, package, ...)

* Item File->statistics : element count (ann, rel, etc)

* Implement "copy/paste" on elements

* In Context (or the GUI), catch AdveneTalesException that happens
when there is a syntax error in a TALES expression (missing string orbadly written symbol) and display a meaningful message

* Annotation song: lyrics / refrain /couplet + UTBV/STBV (transcription)

* Create a 'shapes' package which will define various SVG shapes
  (moon, sun, triangle, etc) as views

* Edit element popup: check that the data was not modified before closing

* Model related:

** Model: Implement copy/rename of id for all elements

** Allow to specify preferred package (bootstrap) for default views

** error ?? Cf (ElanImporter)

** Bug in util.uri.urljoin if pkg_uri == 'dummy:1' (get does not work
in bundles). To exhibit: in ElanImporter, change the uri of the new
package to 'dummy:1'

** The model should check the data validity (no duplicated id, valid id syntax, etc)

** Model: proper handling of exceptions (for instance, a view is
imported and its id changes in the imported package -> KeyError

** Model: annotations should be sorted according to fragment.begin

** Before that, implement a hook for LoadPackage and AnnotationEditEnd
which sorts the annotations upon package load.

** Clean the mediafile handling. It should be stored in fragments, or
at least all fragments should be scanned upon package loading to
determine the available stream(s) and propose them to the user.

** Make some attributes inherited (esp. author for annotations, media for fragments)

** The view method should return a Content object, so that we can get
 its mimetype. *or* return a specialized class derived from (str,
 object) that adds a mimetype property

** Create a ContextualizedBundle which understands namespaces

** Fix package generation: upon loading, we discard the initial
processing instruction (<?xml version="1.0" encoding="UTF-8"?>) from
the DOM and do not restore it before saving, so it gets lost.

** Find a way to override standard advene elements with new methods
(for instance, snapshot_url and media_control for annotations) in
order to avoid using too many global methods.

** Import elements GUI: implement "Add/Remove package" -> ready, but need the corresponding method in the model to remove

** Model: Pb in imported packages:
  [ s.title for s in p.imports[1].package.schemas ] works but
  [ for s in p.imports[1].package.schemas ] does not:

 File "advene/model/", line 185, in getId
  File "/usr/local/src/advene-project/lib/advene/model/", line 258, in getQnamePrefix
    raise AdveneException ("item %s has no QName prefix in %s" %
AdveneException: item Package (english_teacher.xml) has no QName prefix in Package (../examples/unicode.xml

** Model: Implement importElement methods (or at least, document the existing ones and add an importPackage() to be able to specify the package's alias)

** Model: implement relationtype.members R/W (and make that a list of
AnnotationTypes rather than their ids) -> DONE for R/W.

** model: implement a data PATH variable to look for packages. Insert
the current package's pwd first as default.

* Treeview: add the elements attributes as annotation/relation children.

* Content: how to represent structured data ? Cf MPEG7 DS ? (hackingly
  half DONE, grep source for application/x-advene-structured). Or (XML-Schema) Or SOAPy

* Assistants:
  - voice recognition
  - relation creation (based on criteria like "shot in sequence" -> isPartOf)

* Timeline:
  - copy/paste paradigm
  - concurrent annotation representation
  - annotation alignment (=~ arrange/align in Impress)
  - ability to specify line order and which types to display

* Make the annotation interface as On-Screen Display over the video window

* Display the data in the form of a graph (annotation=Nodes, relations=Arcs or nodes)

* Style setting:
style "green_button"
  fg[PRELIGHT] = { 1.0, 1.0, 1.0 }
  bg[PRELIGHT] = { 0, 0.75, 0 }
widget "sendmail.*.Send*" style "green_button"

style "blue_text"
  text[NORMAL] = { 0, 0, 0.75 }
widget "sendmail.*.mail" style "blue_text"

------------------------------------ Archive ------------------------------------------
* Write the correct VLC/Python module -> DONE

* Use gettext to internationalize the application (cf for glade) -> DONE

* The advene python modules should be in /usr/lib/advene (with subdirectories advenetool, advene, util), cf below -> DONE in Debian package

* Build a debian package. Cf -> DONE (badly)

* Needed method: package.findMatchingRelation(source_ann, dest_ann) -> DONE

*** Create a RelationBox view plugin -> DONE

* Restructure code (and take the opportunity to move to another
  versioning system [arch or svn for instance]) :
Cf for migration hints.

  advenelib/advene -> advene/model/...
                  /util -> advene/model/util/

  advenetool -> 
                  (GUI independant parts of advenetool)
                  (utilities with very small dependencies)
                 (ex. advenetool, w/o controller)
                      (generic edit classes)
                      (edit Advene elements [generic], ex.
                      (edit annotation (specific), ex.
                      (edit Advene rules, ex.
                      (edit Advene configuration)
 (edit TALES expressions)
                    (main engine)
                    (default actions)
                           html/... (epydoc generated)

* Add sound_set_volume and sound_get_volume to MediaControl.idl -> DONE

* Rules: add a "internal" flag to indicate whether to save/edit or not
  the rule (internal=True by default) -> DONE (rule.origin)
  But we do not use it : instead, the ecaengine uses multiple rulesets
  ('default', 'internal' and 'user' by default)

* Implement attributes first and last in bundles (easy) -> DONE (in global_methods)

* Put relations in a <relations></relations> container, so that we
  have a consistent package/relations/ access (else, relation/absolute_url
  returns annotations/id, which is misleading) -> half DONE (absolute_url fixed)

* Add a /config directory, holding config values for the user (esp.
  edit window width and height) and implement PUT method on it
  through a /options/config dict in TALES -> DONE

* Correct all edit plugins (to correctly update values) -> DONE
  * Add self.model everywhere
  * Add self.editlist everywhere, to register edit plugins inside
    the self edit plugin.  update_value will be called upon these.

* Adveneserver: implement PUT (to please epoz) -> DONE

* Incorporate EPOZ :
  * add a['web'] = dir variable -> DONE
  * Handle the /data URL (picks data in config['web']) -> DONE
  * Add epoz in config['web'] -> DONE
  * Add epoz for add-view

* EPOZ: implement parent search for defines/repeat -> DONE (TALContext)

* Ruleset editing ( : give the possibility to edit only a
subset (according to rule.origin) -> DONE (filter parameter)
  Re-DONE : cf note on ecaengine before

* Implement an 'advene browser' � la NextStep file manager -> DONE
* browser: focus on the currently selected column -> DONE

* Rules: define independant rulesets in packages -> DONE

* Rule: add an "ViewActivation" event, to define actions to be taken on STBV activation -> DONE

* Metadata : cache the stream duration (for GUI purposes) -> DONE

* Debian package: add python-xml python-simpletal dependencies -> DONE

* Implement an ApproximateImageCache with a ic.epsilon value -> DONE

* The content object should provide a "dom tree" access method -> DONE (content.getModel) 
  but not cleanly

* Adveneserver: use logging.Logger to log HTTP accesses -> DONE

* Add /usr/share/doc/... for all debian packages (and
  examples/ for vlc-plugin-corba) -> DONE

* debian package: fix web/web not in the right directory, default_rules.xml -> DONE

* Remove gtk dependency from vlclib (so that we can start adveneserver
without DISPLAY) -> DONE

* Create a GUI to be able to select and preview the right
  chapter/title for a DVD (in order to correctly initialize the property) -> DONE

* Make a UTBV view using CSS displaying annotations and screenshots on a timeline -> DONE

* Idea: make a snapshot everytime a new position is given, so that we
can build a history of navigation -> DONE

* Fix the simpletal problem: all string values should be unicode ->
seems to work OK. To check... -> DONE

* Advenelib: implement AnnotationType and RelationType creation methods. -> DONE

* ! Handle unicode correctly and everywhere (GUI, adveneserver, XML,
  ...) -> DONE

* Tree view : implement "Add/Remove" option in popup menus (Add new view, Add new type, ...) -> DONE

* Propagate AnnotationEditEnd and RelationEditEnd events in active views -> DONE

* Add a "Edit" button next to the STBV optionmenu -> DONE

* Fix the UpdateElement problem in tree view when creating a new
element (maybe we should have AnnotationCreate and AnnotationEdit
events) -> DONE

* gui.main should catch the information about a new view being defined and update the
  interface accordingly (for instance, a new annotation type or a new
  dynamic view created) -> DONE 

* More quickly : STBV Optionmenu should only have a reference to the STBV id, so that
  the new version is taken into account when edited. -> useless

* Implement a representation meta-attribute that gives a TALES
  expression whose evaluation will return the representation string of
  the element (useful for parsed elements for instance) -> DONE (meta 'display')

* Query language: either python-based (very generic) or reusing the
  rules framework (conditions) -> DONE

* Implement query in global_methods -> DONE

* Clean-up the player interface (which is now spread across
  advene.util.vlclib.VLCPlayer and advene.core.mediacontrol.MediaControl) -> half DONE
  (everything is in mediacontrol now, but we should unify this and provide a clean API
   to ease portability across different players). Idea: provide a
   PlayerFactory which returns a Player instance (more flexible).

* Add a notebook view in the place of the defunct HTML widget -> treeview

* Conditions: implement regexp match -> DONE

* webserver: /media/play?position=... : return the referer page -> DONE

* Envoyer package et infos � Denis pour portage windows -> DONE

* Write document on TALES syntax and root elements -> DONE (doc/user.txt)

* actions: convert messages from unicode to str. DONE: report CORBA bug

* Offer a python command-line to access/modify the package -> DONE (C-e)

* Move gui.edit.annotation into gui.edit.element.EditAnnotationPopup -> DONE

* New actions: GotoPopup (display a message and propose to go to another position) and InfoPopup (display information) -> DONE
* In AnnotationTypes edit popup, give access to the "display" meta attribute -> DONE

* When choosing a video file or DVD, update the package mediafile property -> DONE

* New action: DisplayMarker (shape, color, position, duration) -> DONE

* PopupMenu: add access to browser on current element -> DONE

* Control-Return: validate annotation and begin editing a new one -> DONE

* Italic/Bold face for annotations with relations -> DONE

* Help: display user.txt -> DONE (user.html)

* build share/web/user.html from doc/user.txt -> DONE

* webserver: implement /media/stbv -> DONE

* Fix bug in queries: the context is not inherited by the query method, so
  here gets reset to another value -> DONE

* Fix slider update (movie duration)  -> DONE

* Popup menu for annotations: add a subtree to access relations and
  related annotations -> DONE

* Timeadjustment: 
  Button "Play from here" to visualize current time
  Button "Use current time" on begin/end to set to the current time
  Button "Update snapshot" -> DONE

* Architecture generique d'import d'annotations externes (annotations, schemas) -> DONE

* Find a way to specify the version number in the sources and use it in  -> DONE

* Check id validity (no spaces) when creating elements (views) -> DONE

* ELAN converter ( -> DONE

* Add numbers in valid identifiers -> DONE

* Conditions: implement Allen's relations -> DONE

* Segmentation fault upon quitting with window manager button -> DONE

* Specify mimetype in view editing window -> DONE

* In create popup, link "Return" to validation -> DONE

* Return a "204 No content" in webserver upon /media/play... actions
  instead of a redirect -> DONE

* gui.popup should have a reference to the main gui, so that it can call
  register_view and close_view_cb -> DONE (in controller)

* Make import work -> DONE

** The package/annotationTypes should have an 'ids' method, to be able
to retrieve ids as keys (all bundles in fact) -> HACKED in bundles

* Action: ActivateSTBV -> DONE

* Views should memorize their position/size (idea: have a
gui.size_cache dict, indexed with window names ("edit", "timeline",
"tree", ...) and containing sizes). It should be saved upon quitting
-> create a .advene_prefs file with a pickle of a prefs dictionary -> DONE

* timeline: implement a popup method that creates the toplevel window -> DONE

* Action: DisplayPopup2, DisplayPopup3, DisplayPopup4 with additional
parameters (general message + message1,position1 + message2,position2,
...) -> DONE

* Define a gui.SingletonPopup with timeout  -> DONE

* Define a generic popup method in view-plugin -> DONE

* GUI for advene.util.importer -> DONE

* Interface to edit imports -> DONE

* RelationTypeEditPopup: allow to specify the annotation types -> DONE
(but support missing in model)

* gui.edit.element: Implement EditElementListForm, based on ListStore?
or ButtonBox?, to allow the edition of members of relations and
members of relationtypes. Parameters: field, membertypes or memberids -> DONE

* Element editing: add description field and edit content-type attribute -> DONE

* Generic for views: add a .popup() method opening a window -> DONE

* STBV: implement at least one level undo on action parameters -> DONE (action parameters are cached when changing action name)

* Create 2 Popup widgets: a singleton one (that is always visible and
  is reused across different invocations) and an accumulator one (with
  a size limit and a timeout) -> DONE

* Window to confirm quitting: use "Save package? Yes No Cancel" -> DONE

* View: display transcription with highlighting of active fragments -> DONE

* Make the annotation edit entry a multiline entry. -> DONE

* ECA: implement a position heap memorizing jump positions (in order
to implement a "Return to last position") -> DONE (navigation history)

* Transcription: access to options: display timestamps, select
separator, display marks, apply expression (for structured content) -> DONE

* Implement an image-based timestamp chooser (with all_snapshots()) -> DONE

* when creating a new dynamic view, create also the first rule -> DONE

* Transcription view: add a "Save as" button -> DONE

* bootstrap: Implement queries next and next_global that return the next
annotation of the same type, or global -> DONE

* Organize action names and conditions along categories -> DONE

* export.xml -> export_views.xml -> DONE

* edit DC description for packages -> DONE

* bootstrap: supprimer stbv pause after annotation -> DONE

* views should return a TypedString(unicode) with a contenttype or mimetype attribute -> DONE

* Test if relations exist when deleting annotations

* Make the main buttonbox of the main window a toolbar -> DONE

* Logwindow: add a close button  -> DONE

* Logwindow: catch the destroy event and hide the window -> DONE

* Add a file operations toolbar (new/open/save, import, etc) -> DONE

* fix on_get_iter (cf tutorial) -> DONE

* Fix fileselector bug -> DONE (use FileChooser)

* Preview in fileselector to open package: display description and number of elements -> DONE

* display DC description for packages on import -> DONE

* Upgrade to gtk2.4 (fix DeprecationWarnings) -> DONE

* Upgrade simpletal support to 3.9 -> DONE

* player: implement vlchttp -> DONE (too slow)

* Improve path settings on Windows -> Done

* Player API: get DVD device from libvlc.configGetPsz("dvd") -> DONE

* player: implement dvd_uri(chapter, title, uri?) that returns a
valid DVD uri for the given player -> DONE

* Add new action: open new ad-hoc view -> DONE

* Importer: mark the imported package as non_saved

* EditTranscription: view for editing a transcription and putting timestamps (live) in it, in order to generate annotations. -> DONE

* timeline (362): remove deprecated OptionMenu -> DONE

* main: implement a get_control_toolbar() method -> DONE

* Dig into freevo to find out how they control mplayer with python -> DONE (cf player/

* DND on annotations in timeline : offer menu: Align annotations/Create relation. If same type, only offer "Extend to reach this annotation" ? -> DONE

Other possibility: add a buttonbox on the side with functionalities (create links, align begin, align end, etc)

* gui.edit.elements: add "modal" parameter to edit() -> DONE

* implement default_stbv that gets activated on package load. -> DONE

* TranscriptionEdit: add a player control toolbar (in fact, the player
control toolbar should be available in all views) -> DONE

* Element id generation: use an incremented index and check that it is
not already used (will create more friendly ids). Will be best
implemented by a singleton IdGenerator that caches the last index for
each type. -> cf advene.core.idgenerator

* Implement copy/paste for rules/rulesets -> implemented DnD

* Add access to media duration from TALES -> player/cached_duration

* To embed windows in gtk, use widget.window.xid (in X11) and
  widget.window.handle (in Win32) -> DONE

* Create a CellRenderer for time values (with time adjustment integrated) -> DONE

* Create a unique logger in controller and use exclusively this one in all modules -> DONE

* Timeline: clone an annotation to another type by DND on the type -> DONE

* Activation of rules: not immediate -> DONE

* transcribe: ability to mark some text as "ignored" -> DONE

* fix bug (segmentation fault) when an annotation.begin == 0 (cf event handler) -> DONE

* Edit metadata: fix empty metadata pb (UTF8 newline) -> hacked
  related to: GUI: do not put newline in representation field when
  editing annotation types, model related problem (XML Pretty Printer messes output)

* Create a TALES evaluator/editor widget (from browser?) -> DONE

* TALES : offer a validity checking -> DONE

* TranscriptionEdit: when saving and loading, handle [[xx:xx:xx]]
timestamps marks -> DONE 

* Timeline: add the possibility to add new annotations by clicking on the type -> DONE

* Check the encoding of get_default_media (seems to be incorrect wrt utf8)

* transcribe: 
   * Add Save/Save as functionality + Control-S shortcut
   * Handle ignored annotations in load/save

* popups : fixed sized for popups. -> DONE

* popups : add context (timecode + snapshot) + title frame -> DONE

* Importer: add "Converted from ..." in generated package description -> DONE

* notify: handle 'immediate' param -> DONE

* Fix STBV activation from webserver (implement an action queue in
controller and register actions in it, which are run in idle gtk loop) -> DONE

* GUI: implement Recent Files functionality (using the convention?) -> DONE

* Merge gui.edit.timechooser and gui.views.history -> removed timechooser

* Implement completion in TALES fields -> cf tales.TALESEntry

* webserver: should move query parameters to "request" root element instead of "options" -> DONE

* -> DONE

* Make the request object accessible in AdveneContext -> DONE

* website: developpers wanted: -> DONE
    - frame-precise positionning
    - handle position parameters for start/stop/pause/snapshot
    - fix snapshot (timestamps)
  Player: implement support for other players
    - develop new admin views
    - integrate kupu

* webserver: implement /application/stbv/Nom (instead of /media/stbv)
                       /application/adhoc/(tree|timeline|transcription) -> DONE

* transcribe: handle 0 mark -> DONE

* InteractiveQuery, display results in a timeline (use _interactive query id) -> DONE

* transcribe: make timing offset a editable field -> popup menu only
displays "-offset / +offset" -> DONE

* export-views: excel-export view (CSV) -> DONE

* Main GUI: crash when creating annotations on the fly ?? -> DONE

* pyvlc: find the bug triggered when no option is given to MediaControl (stack corruption?) -> DONE

* Windows: package libsnapshot_plugin.dll (with MediaControl ?) -> DONE

* To build vlcmodule:  cf Makefile
gcc -pthread -shared build/temp.linux-i686-2.3/vlcmodule.o build/temp.linux-i686-2.3/mediacontrol-init.o build/temp.linux-i686-2.3/mediacontrol-core.o /usr/lib/libtheora.a /usr/local/lib/libx264.a -L/usr/lib/vlc -L/usr/lib -lvlc -lrt -ldl -lpthread -lm -li420_rgb_mmx -li420_yuy2_mmx -li420_ymga_mmx -li422_yuy2_mmx -lfaad -lavcodec -lavformat -lhal -ldbus-1 -ltheora -lx264 -lfaad -lmux_ts -ldvbpsi -lpostproc -lmemcpymmx -lmemcpymmxext -lmemcpy3dn /usr/local/lib/libfaad.a /usr/lib/libtheora.a /usr/local/lib/libx264.a -lavcodec -o build/lib.linux-i686-2.3/ -fpic -fPIC

* transcribe: note taking facility (enter text, when clicking on
ctrl-enter insert a timestamp mark) -> DONE

* Fix moviepath (_ does not seem to work) -> DONE

* timeline: add init parameter "whole package" (or None: if self.list is None, use self.controller.package.annotations) -> DONE

* EditContent: add button "External editor" -> Implemented Open/Save/Reload

* Implement "Search" on annotations. Could be done as a pre-filled
filter that is displayed in a treeview -> should modify TreeWidget to
accomodate a FilteredDataModel

* web site: list current features (import, etc) -> DONE

* corba: Add the 'repeat' property on all items in the playlist -> cf repeat config in vlcrc -> DONE

* Bug in queries (rest not empty even if applied to 1-element lists) -> DONE

* STBV action: display an activable link -> DONE

* The transcribe view would be better in the place of the popups widget -> DONE

* Transcribe: add Ctrl-PageUp/Down to jump from 1 timestamp to the other. -> DONE

* Rename "Import a transcription" into "Take notes on the fly" -> DONE

* Package properties: add file browser for associated media

* Project hosting: -> DONE

* Menu: add a File/Associate video file item

* Put an example package on the web site and a video of an example interaction

* transcribe: add screenshots to marks context menu

* GUI: use STOCK_MEDIA_* icons introduced in gtk 2.6 -> DONE

* Move GUI-actions from main to gui.actions -> DONE (in gui.plugins)

* Check windows registry paths for 'vlc', 'plugins', 'locale' that are bad in Italian (Programmi)

* plugins Implementation : cf for
   a start -> DONE (cf advene.core.plugin)

* Data toolbar: with creation buttons (schema, annotation/relation
   type, view, query) -> DONE

* webserver: log access/error log to either a file or a window -> DONE

* webserver: handle full html documents (with headings) either by
using a specific mimetype (text/x-full-html) or if
res.startswith('<html>') [useful for Kupu]

* On player restart, redo set_visual

* plugin infrastructure is not compatible with pyinstaller. -> DONE

** model: rewrite the model with a new format (.zip) using ? -> DONE (.azp)

* AZP: make work on win32 (urllib.pathname2url) -> DONE

* ecaengine: sort actions to execute according to a priority parameter
   (which would be 200 for internal rules, 100 for default rules, and
   between 0 and 100 for user rules) -> DONE

* evaluator: implement expression history save -> DONE

* webserver: offer a /action/??? method to allow interaction through
  the standard actions framework

* In on_exit, first stop the event handler -> DONE

* put timeline/css from unicode in export_views

* Prevent the reuse of the same id

* allow to edit[] (maybe put them in
   data.preferences ?)

* add default extension to filenames when saving

* In content editor (for TAL views), add a button to invoke the
  package browser to insert paths or values.

* viewbook: on add_view, make the new view as default visible

* implement support for global_methods definiion in user plugins

* view.transcription: replace bottom buttons by preferences panel

* replace the popup widget by a notebook, with timeline +
   popupaccumulator + transcribe window + gtkmozembed

* create a gtkmozembed view -> DONE

* On timeline.update_model, check package media file duration. If
   changed, update scale -> DONE

* option parsing: move to core.config, allow standard options (--help,
   --version, --config)

* tooltips are not displayed in action parameters

* use 2 viewbooks on the RHS of the video

* webserver: in /actions, add links and automatically generate forms
   with action parameters

* Search everywhere for imagecache, idgenerator, modified -> package attributes

* Make the Advene GUI able to grok multiple packages. Focus (for
   events) is defined for 1 specific package.

* implement close package

* fix multiple file loading on command line

* implement check of packages._modified in on_exit

* fix cached_duration when switching packages

* timeline: redraw marks on update_model if necessary

* webserver: use controller.build_context

* Build packages menu on-demand to be able to display modified status

* webserver: implement a loop to process dynamic events when
   standalone (in fact, we should use controller and invoke
   controller.update) -> self_loop

* create_popup: allow to directly insert a file (add a file...)

* Implement a new action: Enter information -> fill an attribute of an
  annotation (pause the stream, enter the answer)

* resource creation: allow to create non-text  resources (specify the

* transcription : catch the AnnotationEditEnd event and update the

* transcription: handle annotation content modification (on window close)

* Transcription: complete annotation edition

* gui.popup: allow to insert a resource directory

* gui.popup: allow to remove resources

* annotationtype,relationtype: propose common mimetypes at creation

* timeline: allow to specify annotation types (2 lists: available,
   present + > < buttons), or reuse gui.edit.elements.EditElementListForm

* Linux-installer (one file executable):

* gui/plugins/actions: fix action_open_view

* content encoding bug in query when passing accents in query
   parameters -> OK (rev. 2069)

* treeview: update on CreateResource -> OK

* timeline: allow to specify  default height

* on notification, check that controller.package ==
   element.rootPackage to make sure that we update properly the

* Rename advene.util.vlclib to something more meaningful (advene.util.helper)

* save player preferences

* handle unicode query strings : cf

* GUI: use icons and graphic files from openclipart, to alleviate any
copyright problems

* STBV Parameters: add interesting default values

* Transcribe: add an "Import from annotation type" button

* Do not add player control toolbars when embedding views

* transcribe: on export, ask if we should remove existing annotations of the same annotation type

* Transcribe: use ctrl + scroll wheel to adjust mark timestamp

* GenericContentHandler: add "Open with..." functionality: NO: it
   would prevent from signalling that the content has changed.

* Timeline: offer a "Divide annotation" feature

* timeline: popup menu: "Create a new annotation" with a default duration

* timeline: ctrl+scroll on annotation widget => move begin/end or
   whole annotation

* EditFragmentPopup: handle DND of annotation widgets to set begin/end time

* initial preferences: offer to specify the content of S, E viewbooks
   [through an expression with the same syntax as webserver adhoc views]

* adhoc views action: add 'position' parameter to specify the destination of
  the new adhoc view (popup, viewpopup S or E).

* timeline: add "CenterCurrentTime" option, to scroll the whole widget
  around the current time mark

* transcribe: when control+scroll, go to the new position on button release

* timeline: with epidemic package, bug in initial display

* timeline: directly create annotations from timeline

* Annotation resize in timeline -> Hack (right button). Should
reimplement a native widget for annotations or use DiaCanvas -> Re-hacked through DND of the annotation bound

* timeline: a shortcut to quickly edit a one-line annotation (popup a gtk.Entry)

* edit.elements: focus on content window on open

* update_imports script that ensures that all elements of specified
   type from a given package are imported in a list of packages, and
   adds them if necessary -> not necessary with the future new model,
   where a package import will allow to access all its elements

* fix bug in snapshot when vout == x11?

* transcribe: offset on marks must be followed by goto

* : use Tabs

* timeadjustment: improve the text entry behaviour

* timeline: Pb scrolling continuous with zoom = 100% and position around the end.

* timeadjustment: click on image -> play, coontrol  + clic -> set  
current time,  timestamp: use spinbutton

* EditAccumulator: component holding reduced edition windows for annotations

* editaccumulator: "Apply", "Close", "Set end time to current time and
  close" buttons should be in the frame title ? And/or shortcuts?

* timeline: quick edit: should handle simple representation expressions

* timeline: duration not updated after a package import.

* add a "color" metainformation to annotation types

* popup: tooltip on popup title (close popup)

* ask on application close if screenshots should be saved

* allow to suppress invalid screenshots

* timeline relations: use arrows/lines to display

* timeline: display link type (+content?) ?

* timeline : display arrows (at beginning and end)

* pb affichage ressource image (cf Nosferatu)

* timeline: control+scroll = zoom in background

* timeline: type displayed selection: allow multiple selection

* history: remove minimum size specification

* timeline: do not scroll on enter focus if the annotation is already visible

* timeline: optionnaly display relation types (from preferences)

* accumulatorpopup: add 'scrollable' parameter

* RAZ URL stack on packageactivate/packageclose

* editaccumulator: Apply / Close on the right HS

* compact view for relations

* editaccumulator: option to automatically edit new annotations in it

* typed_related_in / typed_related_out

* nosferatu: fix panel_details UTBV : outgoingRelations/type ?

* edit relations through annotation context menu

* EditAccumulator : only annotations et relations, not queries/views

* Create a simple SVG editor (rectangle and ellipse) and integrate it in Advene

* Windows/gtk has a problem with threads. Solve using the recipe given in:

* timeline: refresh problem when opening in its own window

* Timeline: create annotations with mouse cursor on the annotation type. When we start typing, create an annotation with the right content. On annotation validation, update the end time.

* implement get_rate/set_rate actions

* Transcribe: automatically put timestamp mark when beginning to type (after a timeout)

* timeline: add a "Display tooltip" toggle

* editaccumulator: add icon for embedding

* timeline: remove annotation resizing by DND

* New popup: navigation popup (description, message, duration, URL)

* EditRelationPopup�: display snapshot in members widgets

* popup menu: escape underline characters in menuitems

* nosferatu: provide an example query (full text search on panels)

* merger: diff content window should resize & use fixed font

* azp format: store essential information (title, statistics) in a
  simple file (statistics.xml) for fast access and use it for preview

* get_filename: use extension filter

* implement .apl (advene package list) file format (cf .m3u)

* make parsed a Content method rather than a global method

* bookmarks: associate actions to timestamp, for instance "When reaching 124, go to a4.fragment.begin"

* InteractiveQuery: propose other output modes

* interactivequery: if annotation list, open in an editaccumulator

* sort views in dyn/static + alphabetic order + annotation in time order: make a script

* GUI: add volume slider

* timeline: popup action: center and zoom on annotation

* Menu Edit/Create elements

* Edit/Find annotation (by content)

* internal rule to loop over a specific annotation + convenient shortcut

* 'auto-import' metadata attribute for packages, to specify a default importing package

* view "TableOfContents", drag and drop from the navigation history or
  timeline, to create entry points with snapshot in the video.

* use cherrypy as webserver ?? cf

* Rewrite webserver using Twisted (and maybe use it also for ECAEngine) [Cf cherrypy above]

* Reorganize webserver code [Cf cherrypy above]

* offer possibility to enter the address of a stream as a youtube/googlevideo/dailymotion URL

* check that imagecache is coherent when set_default_media

* transcription: use source=TALES instead of model, to be able to transcript query results.

* create a new view content type:
  application/x-advene-adhoc-view to store parameters for adhoc

* tags: define a "tag bag" from where you can drag and drop tags to annotations
* session list: when loading .apl, check the we do not overwrite existing unsaved packages

* Search results: option "Highlight results"

* GenericContent: provide default name when saving content (based on id, if available)

* Importer: fix automatic filter selection (get_importer) esp. for XML
   files (use DTD)

* Importer GUI : button "Select a specific importer"

* Importer: pass callback method to implement progress bar (float, message)

* evaluator/display_info: if expr is multiline, analyse only the line where the cursor stands.

* drag and drop: generalize popup menu on drop (timeline...)

* timeline: create relation: propose types as submenu of the context menu

* Saut de ligne dans transcription: ajouter une option explicite [predefined options with 1 "User defined"]

* find: option 'ignore case'

* merge functionality: use author/date information to determine if the
  annotation/element was completely updated or created

* imagecache: if the image is stored on disk, use a Storage proxy to get data directly from disk instead of  memory (the OS will handle memory caching)

* tags: define a "tag_color" method that returns a color depending on present tags

* IRI importer: handle <views> tags

* timeline: add a striped colored background

* DND in timeline: change displayed bitmap according to action

* Create a TimeBookmark structure in the controller, to trigger time
   events. Basetime can be movie time or clock time. Should have 2
   parameters (clear_on_stbv_change, clear_on_position_change)

* store event history + context (media, position) and save it as a package

* Store the navigation history as a package with viewed sequences and
occurring events (but base timeline is then application time instead
of movie time)

* add parameters to TimeLine view (displayed annotation types, zoom)

* Upgrade to simpletal 4.1

* Convert importers to plugin architecture

* Move last notepad to the west of video display.

* interactive view result: put in east (as table) + offer options to open new views

* timeline: zoom level combo box in the toolbar + buttons zoom in/out + remove slider

* default adhoc: mv urlstack to west, popups to east + create fareast area (whole height)

* viewbook: add a Close button to labels (like firefox)

* timeline: move Displayed types to toolbar, move New type button to bottom of legend layout (italic)

* allow to save a title for parametered views and display it in the viewbook widget tab

* viewbook widget: add possibility to reparent widget to its own toplevel popup (detach to popup) and back to viewbook. Context menu or DND from a tab to a viewbook. Cf

* top toolbar: search entry a la googlebar + advanced search options + link to expert search

* zoom change: keep centered on position

* table view to present annotations (result of query) + button refresh / option auto-refresh
* interactivequery: new output view: sortable table: id, begin, end, duration, content, type

* treeview: subclass Views branch (static, dynamic, adhoc)

* timeline: add a type_color metadata to annotation types, and allow to edit it with the color picker.

* define a set of colors and use it when creating new annotation
  types. Pb: application-global or view-local?

* implement ColorPicker, that could be used to set a colour (either dnd in the "color" metadata field, or DND directly on the annotation type widget)

* Import GUI: when no import filter is present, add a "No valid import filter" label to the combobox

** Make the package a .zip file, with a MANIFEST, data.xml and
resources/ directory

* gstreamer: cf tutorial

* XML schema/relaxng:
Datatype reference:

* Timeline: popup menu for transtyping - do not display (or gray) move annotation if it has relations

* timeline: Do not update zoom level immediately.

* Edit element: expand Content frame if there is content in relations

* table view: export selection to .csv format 

* Timeline Zoom: center on active annotation if present

* View edition widget: if view applies on a package, add a button "Apply and preview"

* EditAccumulator: close widget when deleting annoation

* gui.widget: define TagButton

* Navigation history: button "Bookmark current time"

* EditAccumulator: on package close/activate, close all opened annotations

* timeline: if the annotation has focus, shortcut to display the context menu

* Tagbag: new pref "Update with new tags"

* importer: use palette for annotation type creation

* When stopping the video, call update_position so that the current position resets to 0

* GUI for player volume: flash-like (button + vertical slider) or only mute button

* transcription: add Find capability

* Timeline: add a small close button for quick edit

* Navigation history: do not add if the user pressed FFWD/RWD

* gstreamer: insert videoscale component (ximagesink) - option to rescale at a given size. gstreamer bug. Workaround by snapshot-size specification

* adhoc views: change signature (parameters as tuple rather than content)

* adhoc views: default parameters for all adhoc views

* save adhoc view dialog: use the title/id dialog

* convert adhoc-view parsing to ElementTree API

* all: change import sre to import re (+uses)

* timeline: store position and zoom level in arguments

* Initialize ET._namespace_map once in a core module

* timeadjustment: in text entry, validate when losing focus

* Implement perspective as in eclipse (save views layout)
* Define builtin conditions (common ones: annotation of type X,
  annotation has a relation...) to be presented. GUI building: specify TALES expressions? (package/annotationTypes ?)

* package: if uri is a dir, then try to treat it as an expanded zip package

* zippackage: convert Manifest parsing to ElementTree API

* Implement package auto-save

* timeline: when zooming with ctrl+scroll, keep centered on cursor position

* timeline: double click in background -> goto

* put the final exception handler result into a file, to record crashes and allow the user to send them

* DND annotation type to viewbook -> transcription view

* When activating the loop button, do not go to the annotation if current position in fragment

* Bug in default parameters for transcription

* Ctrl-TAB in edit window for annotations => play/pause

* left click on annotation -> display a short popup menu (go to..., quick edit) ? Or option to choose quick edit or goto on double clic

* timeadjustment: if compact, make snapshots smaller

* Transcribe: shortcut to play the current segment?? Cf control-pageup/down

* viewbook: DND of an annotation-type -> menu: transcription, browse, timeline

* autocompletion of words in transcribe widget and other components (content edition...). Cf /usr/share/scribes/plugins/WordCompletionGUI: WordIndexer (indexes views and annotations content sorted by type, with mimetype =~ text/*, updated on startup and *EditEnd) + WordCompleter.

* controller: convert PackageListHandler to ElementTree

** timeline: Option to put status bar below the timeline

* DND of annoation type to viewbook: add "Open timeline"

* When copying an annotation by DND, add focus to the new one (to allow quick edition)

* Integrate completion on note-taking view

* transcription: on editing representation in preferences, no update occurs

* gui.widget: use drag_source_set_icon

* error log -> win32 fichier

* Timeline: when update position, desactivate annotations

* Pb in launcher button for quicksearch, update tooltip (closure related)

 * new app: montage, which takes a package and generates a montage based on annotations. Cf

* notebook view: allow to reattach by DND on label

* IRI converter: convert views to their own annotation types

* Allow to reattach detached adhoc views

* TALESEntry: allow to predefine some values with titles. 

* timeline: replace annotation tooltips by a dedicated static widget.

* timeline: legend widget - make all annotation type buttons the same width

* SVG editor shapewidget: import SVG (parse SVG to object

* Montage: highlight of all montage's annotations

* montage: DND of an annotation into the montage -> copy + delete

* annotation widget: shortcut 'h' to un/highlight

* montage: do not move position if not needed

* montage: highlight current annotation when playing (or better, display time mark)

* notion of slave view: add montage and visualisation icons in
   timeline. DND them will create slave views, that are linked to the
   timeline view. THe montage zoom is in sync with the timeline
   zoom. If the master view is closed, saved views are closed too.

* Generic renaming facility for adhoc views

* edit.elements: automatic update on ElementEditEnd

* transcribe: better feedback on non-valid timestamp mark

** timeline: pb with legend refresh when opening a saved view

* Open file does not work in view editor

* interactive result: display the entry at the top to relaunch the
   search easily

* interactive result: create new annotations from the result

* EditAttributesForm: add new type 'advene' which will trigger

* timeline: reorder annotation by DND in legend background

* display bookmarks in timeline (convert to annotations?)

* annotationdisplay: display screenshot

* DND of a type to a type: propose to copy/move all annotations

* Colors in treeview

* edit.elements: remove Find buttons in non-expert mode

* sticky loop: automatic loop on annotation goto

* timeline: simple click on annotation -> goto

* timeline: add HPane with viewbook for annotation display only at right.

* timeline: hover an annotation-type -> highlight other types from the
   same schema

* DND of a type to a type: propose to copy annotations with filter (query)

* Relation: when no valid relation type, propose to create a new one
   in the popup

* Checkbox in front of annotationtypes to limit playing to these
   annotations => multiple STBV

* quicksearch sources: add tags

* edit.elements.annotation: access relation

* .azp as default format

* On MacOS X, store preferences in ~/Library/Preferences/Advene

* mpeg7 import filter. mpeg-7 compatibility: check /

* Allow to activate multiple dynamic views (checkbox list)

* transcription: center on activated annotation

* current annotation full display

** feature: dynamic view to visualize all annotations of the same type/a group -> bout-a-bout - bout-a-bout component (store annotation ids). Ability to save the result.

* interface a 2 niveaux (base/expert) pour la plupart des menus (STBV ...)

* accumulator: stack from left to right, most current on the leftmost side.

* Automatically save preferences

* type restiction: go to the first annotation

* timeline: annotation inspector - fix dimension

* Automatic annotation numerotation (for shots)

* Allow to add comments to bookmarks

* timeline: toggle "No goto on click"

* popup for annotations: Related annotations / Outgoing / Type / Annotation

* timeline: save goto-no-click setting

* TALES editor: directly display string values, and use ${} syntax for
   tales expression. On-the-fly conversion when storing.

* edit/rules: EditAction/build_parameter_widget: populate TALESEntry(predefined)

* edit.elements.annotation: validate upon navigating to next/prev

* Fields containing defaults should come up selected, so users can replace the default contents with new material quickly and easily.

* timeline: bug in DND in background - bad type guess

* importer Gui: deactivate convert button once launched

* timeline: When creating an anntoation with enter on the type, make
   Escape delete the relation

* createQuery: add author= parameter

* timeline: when DNDing an annotation on the same type, allow to move
   (since relations are valid)

* standard workspace: does not work on mac

* views.browser: in non-expert mode, limit available choices (schemas,
   annotation types, etc) -> views.finder

* timeline: double-click -> edit popup

* transcribe: notify UpdateModel on export

* transcribe: double click to insert marks

* transcribe: automatic scroll for marks

* transcribe: center on current time

* transcribe: display arrows in marks

* transcribe: use tags in conjunction with marks so that text can be greyed out when ignored for instance.

* timeline: goto on single click in background (button release)

* pb with annotation DND on win32

* transcribe: use GenericColorButton for marks so that color works on

* timeline: multiple selection (shift-click + DND)

* transcribe: toolbar toggle to deactivate automatic insertion delay

* template: prefix admin views with _

* Select multiple annotations in the timeline ?

* Shortcut "Split annotation at current player position"

* timeline: save pane position

* New action: Pronounce (with flite on linux [but needs alsa patch], MacOS X API for mac)

** Check slider value update

* gui.popup: add appropriate action (open in webbrowser, activate,
   open in workspace) for views

* timeline: display time marks in a separate layout

** ensure that timestamps are always displayed

** timeline: select a region to fit to window (cf goocanvas)

* video widget: black background + expand for video + minimal size to
   prevent resize artifacts

* finder: implement visualisation components for views, queries, resources, relations

* edit.tales: option to reveal tales expressions

* gui.edit.rules: add context parameter in EditCondition (query,
   rule...) to generate appropriate predefined values

* transcription: name the view with the annotation type

* quick-edit on annotation: preserve annotation inspector

* note taking: implement save_view

* quicksearch: multiple words -> and. Use "foo bar"  for whitespace in
   word. Support +word -word syntax.

* win32: check AT DND on view, Ann. DND to montage

* IRI export view 

* better export framework (cf model/tal/context, def interpret)

* finder: viewcolumn -> DND of Open in GUI button

* timeline: Unselect all in popup menu for timeline bg

* note-taking: text search

* Interactive search: in non-expert mode, do not display "Return" 

* Interactive search: and/or support for conditions

* search result: unhide context menu actions

* note-taking: propose options (empty ann.) on export dialog

* taking note/transcription: highlight searched word

* finder: shortcuts -> left/right change column focus

* finder: add title widget for leaf widgets

* Resources of -> Set of resources

* Quicksearch button: add a "Down button" image to popup menu OR make
   the left-click a popup menu with Search + Options

* Annotation-type tooltip: count number of annotations

* Save view on interactive query -> should save the Query, not the view

* Timeline: in search result display, limit restrict playing to
   displayed annotations and/or selected annotations

* View DND: if existing saved views, display a popup with them.

* fix initial display for annotationdisplay

** On package loading, remove already used static colors from the palette

* imagecache generator: extract 1 image every second

* interactiveresult: replace hbox.buttons by a toolbar (so that it
   resizes gracefully)

* rename rules.elements.Query to SimpleQuery to avoid nameclash with advene.model.query.Query
* Finder Query button "Try to apply query on package/annotations/first annotations"

* Allow to save the query from the interactiveresult view

* Define a application/x-advene-quicksearch query object

* Montage: add an AnnotationDisplay slave view

* IRI export: replace video extension with .flv -> they should provide
   a means to specify the video if not present

* transcription: propose to choose the source type or a saved view
   from the view itself -> cf DND menu when opening view

* mac themes:

* Search/replace in selection (context menu) or in interactiveresult ?

* close interactiveresult view on package load

* think about pytho
Results 1 - 1 of 1
Help - FTP Sites List - Software Dir.
Search over 15 billion files
© 1997-2017