Merge lp:~nico-inattendu/luciole/bp-kdenlive-export into lp:luciole/0.8

[NicoInattendu]

=== modified file 'lucioLib/gui/luciole_export_tool_window.py'
--- lucioLib/gui/luciole_export_tool_window.py	2010-01-04 17:42:18 +0000
+++ lucioLib/gui/luciole_export_tool_window.py	2010-01-04 17:42:19 +0000
@@ -1,10 +1,10 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 # -*- Mode: Python -*-
-# vi:si:ai:et:sw=4:sts=4:ts=4
-#
-#
-# Copyright Nicolas Bertrand ([e-mail]), 2009
+# vim:si:ai:et:sw=4:sts=4:ts=4
+#
+#
+# Copyright Nicolas Bertrand ([e-mail]), 2010
 #
 # This file is part of Luciole.
 #
@@ -31,12 +31,15 @@
 import gtk 
 import os.path
 
-from .. import lucioExport as LEF
-from ..lucioExport import lcl_export_pitivi as LEP
+from ..lcl_export import lcl_export_cinelerra as LEC
+from ..lcl_export import lcl_export_pitivi as LEP
+from ..lcl_export import lcl_export_kdenlive as LEK
 
 import dialog as G_DIALOG
 
-BASE_DIR = './'
+# TODO : base dir. should be provided by luciole . Not computed here
+BASE_DIR = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+TEMPLATE_DIR =  os.path.join(BASE_DIR,'templates')
 
 class SimpleBuilderApp(gtk.Builder):
     def __init__(self):
@@ -44,32 +47,57 @@
         gtk.Builder.__init__(self)
 
 
-
-
 class dialog_export_file(SimpleBuilderApp):
-
-    
-	def __init__(self, path="export_file.glade", root="dialog_export_file", domain="", form=None, project=None, **kwargs):
+    
+    EXPORTERS = {
+                'cinelerra' : { 
+                    'ext' : '.xml',
+                    'template' : os.path.join(TEMPLATE_DIR, "cinelerra_template.xml"),
+                    'func' :  LEC.lcl_export_cinelerra
+                    },
+                'pitivi': { 
+                    'ext' : '.xptv',
+                    'template' : os.path.join(TEMPLATE_DIR,"pitivi_template.xptv"),
+                    'func' :   LEP.lcl_export_pitivi
+                    },
+                'kdenlive' : { 
+                    'ext' : '.kdenlive',
+                    'template' : os.path.join(TEMPLATE_DIR,"kdenlive_template.kdenlive"),
+                    'func' :   LEK.lcl_export_kdenlive
+                    },
+                'openshot' : {
+                    'ext' : '.osp',
+                    'template' : os.path.join(TEMPLATE_DIR,"openshot_template"),
+                    'func' : None
+                    },
+                }
+
+    
+    def __init__(self, path="export_file.glade", root="dialog_export_file", domain="", form=None, project=None, **kwargs):
+        """ init dialog_export_file class : Manage the export tool window 
+            path : the path to the glade file to use
+            root : main window name
+            domain : i18n TBD / Not used
+            form : TBD / Not used
+            project : luciole project data
+
+
+        """ 
 		
-        # set export template dir
-        self.TEMPLATE_DIR =  os.path.join(BASE_DIR,'templates')
-        self.templates = dict()
         self.project=project
-        self.templates = {
-                    "cinelerra" : os.path.join(self.TEMPLATE_DIR, "cinelerra_template.xml") ,
-                    "pitivi" : os.path.join(self.TEMPLATE_DIR, "pitivi_template.xptv") ,
-                    "kdenlive" : os.path.join(self.TEMPLATE_DIR, "kdenlive_template") ,
-                    "openshot" : os.path.join(self.TEMPLATE_DIR, "openshot_template") }
-            
+        
+        #
+        # initialize window
+        #
         SimpleBuilderApp.__init__(self)
         self.add_from_file(os.path.join(self.GLADE_DIR,path))
         self.connect_signals(self)
-
         self.window = self.get_object(root)
+        
+        
         # Default Export type
         self.export_type = "cinelerra"
-        self.extension=".xml"
-        self.BASE_DIR = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
         #
         # widgets configuration
         #
@@ -79,124 +107,120 @@
         initial_folder = os.path.expandvars('$HOME')  
         self._filechooser = self.get_object("filechooserbutton1")
         self._filechooser.set_current_folder(initial_folder)
-        
+       
+        # Status bar initialization
         self._status_bar_widget = self.get_object("statusbar1")
-        #self._status_bar_widget_cid = self._status_bar_widget.get_context_id()
         self._status_bar_widget_cid = 1
         msg = _("Select an application and a file name name for export")
         self._status_bar_widget.push(self._status_bar_widget_cid,msg)
-
+        
+        # show window
         self.window.show()
+
+        #
+        # SIGNAL methods
+        #
+    
     def on_dialog_export_file_destroy(self, widget, data=None):
+        """ Signal destroy : close window """
         self.window.destroy()
 
     def on_dialog_export_file_close(self, widget, data=None):
+        """ Signal close window : close window """
         self.window.destroy()
 
-    def on_dialog_export_file_response(self, widget, data=None):
-        pass
-    
     
     def on_filechooserbutton1_file_set(self, widget, data=None):
+        """ Signal filechooser : get filename """
         self.export_folder = widget.get_filename()
 
 
     def on_radio_cine_toggled(self, widget, data=None):
+        """ Signal cinelerra button toggled : set the export type 
+            and update filename window """
         self.export_type ="cinelerra"
-        self.extension=".xml"
-
+        self.__update_fn_ext()
 
     def on_radio_kdenlive_toggled(self, widget, data=None):
+        """ Signal kdenlive button toggled : set the export type 
+            and update filename window """
         self.export_type ="kdenlive"
+        self.__update_fn_ext()
+
     
     def on_radio_pitivi_toggled(self, widget, data=None):
+        """ Signal pitivi button toggled : set the export type 
+            and update filename window """
         self.export_type ="pitivi"
-        self.extension=".xptv"
+        self.__update_fn_ext()
 
     def on_radio_openshot_toggled(self, widget, data=None):
+        """ Signal openshot button toggled : set the export type 
+            and update filename window """
         self.export_type ="openshot"
-       
-    def on_entry_fn_activate(self, widget, data=None):
-        print __file__,"DEBUG : on_entry_fn_activate",data
-        self.filename = "filename"
-   
-
-    def make_export(self) :
+        self.__update_fn_ext()
+
+    def __update_fn_ext(self) :
+        """ update filename entry with the correct extension """
+        (filename, extension)=os.path.splitext(self._fn_widget.get_text())
+        if extension != self.EXPORTERS[self.export_type]['ext'] :
+             self._fn_widget.set_text(filename+self.EXPORTERS[self.export_type]['ext'] )
+    
+
+    def __make_export(self) :
+        """ Render export, according export type, folder, and filename"""
+        
+        # clear status bar 
         self._status_bar_widget.pop(self._status_bar_widget_cid)
         
-        #get filename form entry object
-        (self.filename, self.extension)=os.path.splitext(self._fn_widget.get_text())
+        # get filename from entry object
+        (self.filename, __extension)=os.path.splitext(self._fn_widget.get_text())
 
         # get folder
         self.export_folder = self._filechooser.get_filename()
 
-        self.full_export_path = os.path.join(self.export_folder,self.filename+self.extension)
-        print __file__," DEBUG :", self.full_export_path
-        
-        ForceExport = True     # by default overide of export filename is allowed
-
+        # correct extension if needed
+        if __extension != self.EXPORTERS[self.export_type]['ext'] :
+            __extension =  self.EXPORTERS[self.export_type]['ext']
+            self._fn_widget.set_text(self.filename+__extension )
+
+
+        self.full_export_path = os.path.join(self.export_folder,self.filename+__extension)
+        
+        ForceExport = True     # by default override of export filename is allowed
+        
+        # display a message to allow overwrite or not
         if  os.path.exists(self.full_export_path):
             # add message display 
             msg =_("File %s already exists. Replace file ?") % self.full_export_path
             ForceExport = G_DIALOG.Dialog.QuestionMessage(self.window,msg)
+
         
-
         if ForceExport == True :
-            if self.export_type == "cinelerra" :
-                if self.extension == ".xml" :
-                    self.make_export_cinelerra()
-                else :
-                    msg = _("Not a valid extenstion. Should be .xml")
-                    self._status_bar_widget.push(self._status_bar_widget_cid,msg)
-            elif self.export_type == "pitivi" :
-                if self.extension == ".xptv" :
-                    self.make_export_pitivi()
-                else :
-                    msg = _("Not a valide extenstion. Should be .xptv")
-                    self._status_bar_widget.push(self._status_bar_widget_cid,msg)
-            else :
-                print "Nothing  (yet !) to export"
+            # launch export according retrieved data 
+            X = self.EXPORTERS[self.export_type]['func'](
+                lcl_project = self.project,
+                template= self.EXPORTERS[self.export_type]['template'],
+                export_file = self.full_export_path
+                )
+            X.generate()
+        
+            msg = _("Export Done")
+            self._status_bar_widget.push(self._status_bar_widget_cid,msg)
     
-    def make_export_cinelerra(self):
-
-        X = LEF.luciole_export_tool_cinelerra(
-                lcl_project = self.project,
-                template= self.templates["cinelerra"],
-                export_file = self.full_export_path)
-        X.generate()
-        
-        msg = _("Export Done")
-        self._status_bar_widget.push(self._status_bar_widget_cid,msg)
-
-    def make_export_pitivi(self):
-        X = LEP.lcl_export_pitivi(
-                lcl_project = self.project,
-                template= self.templates["pitivi"],
-                export_file = self.full_export_path)
-        X.generate()
-        
-        msg = _("Export Done")
-        self._status_bar_widget.push(self._status_bar_widget_cid,msg)
-        
         
     def run(self) :
+        """ main function in window, wait for an action of the user"""
         exit_loop = False
         while (exit_loop == False) : 
-            response = self.window.run() #wait for a reponse
+            response = self.window.run() #wait for a response
             if response == 2 :
                 # export button
-                self.make_export()
+                self.__make_export()
             else :
                 # exit
                 exit_loop = True
         
+        #exit export window
         self.window.destroy()
 
-def main():
-
-    frmExportVideo1 = dialog_export_file()
-    
-	frmExportVideo1.run() 
-
-if __name__ == "__main__":
-	main()

=== modified file 'lucioLib/gui/luciole_export_window.py'
--- lucioLib/gui/luciole_export_window.py	2009-11-23 06:28:27 +0000
+++ lucioLib/gui/luciole_export_window.py	2010-01-04 17:42:19 +0000
@@ -29,7 +29,7 @@
 from gettext import gettext as _
 
 import dialog as G_DIALOG
-from .. import lucioExport
+from ..lcl_export import lcl_export_video as LEXP
 
 class luciole_export_window(object) :
     """ This class manages the window used for video export"""
@@ -124,7 +124,7 @@
         self._progressbar.set_text('')
         
         # create an export object : Need the poroject tmp dir and widget to interact with 
-        expObj = lucioExport.luciole_export(os.path.join(project_data['project_dir'],project_data['tmp_dir']), self)
+        expObj = LEXP.lcl_export_video(os.path.join(project_data['project_dir'],project_data['tmp_dir']), self)
         
         # create export_data dictionnary who goes to collect data needed for export tools
         export_data = {}
@@ -155,7 +155,7 @@
                 # get image list from chrono/montage
                 #
                 
-                export_data['image_input']= lucioExport.IMAGE_LIST      # export data is type IMAGE_LIST
+                export_data['image_input']= LEXP.IMAGE_LIST      # export data is type IMAGE_LIST
                 
                 # Verify that a video name is entered and correct
                 l_pattern = re.compile(r'^\w+$') 
@@ -176,13 +176,13 @@
                 # get the type of export requested form the combobox
                 comboVal = self._combobox.get_active()
                 if comboVal == 0 :
-                    exportType= lucioExport.EXPORT_DV
+                    exportType= LEXP.EXPORT_DV
                 elif comboVal == 1 :
                     #export do dvd  
-                    exportType= lucioExport.EXPORT_DVD
+                    exportType= LEXP.EXPORT_DVD
                 elif comboVal == 2 :
                     #export do xvid
-                    exportType= lucioExport.EXPORT_XVID
+                    exportType= LEXP.EXPORT_XVID
                 else :
                     print _('unknown video export command')
                     exportType=None
@@ -193,7 +193,7 @@
                 ForceExport = False     # by default overide of export filename is not allowed
                 (ResExport, videopath) = expObj.export(export_data , False)
                 
-                if (ResExport == lucioExport.ERR_FILE_EXIST) :
+                if (ResExport == LEXP.ERR_FILE_EXIST) :
                     # Launch Dialog window to ask if export file can be overide
                     msg =_("File %s already exists. Replace file ?") % videopath
                     ForceExport = G_DIALOG.Dialog.QuestionMessage(self._dialog,msg)

=== added directory 'lucioLib/lcl_export'
=== added file 'lucioLib/lcl_export/__init__.py'
--- lucioLib/lcl_export/__init__.py	1970-01-01 00:00:00 +0000
+++ lucioLib/lcl_export/__init__.py	2010-01-04 17:42:19 +0000
@@ -0,0 +1,24 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# -*- Mode: Python -*-
+# vi:si:ai:et:sw=4:sts=4:ts=4
+#
+#
+# Copyright Nicolas Bertrand ([e-mail]), 2009
+#
+# This file is part of Luciole.
+#
+#    Luciole is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    Luciole is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with Luciole.  If not, see <http://www.gnu.org/licenses/>.
+#
+#

=== added file 'lucioLib/lcl_export/lcl_export_cinelerra.py'
--- lucioLib/lcl_export/lcl_export_cinelerra.py	1970-01-01 00:00:00 +0000
+++ lucioLib/lcl_export/lcl_export_cinelerra.py	2010-01-04 17:42:19 +0000
@@ -0,0 +1,114 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# -*- Mode: Python -*-
+# vi:si:ai:et:sw=4:sts=4:ts=4
+#
+#
+# Copyright Nicolas Bertrand ([e-mail]), 2010
+#
+# This file is part of Luciole.
+#
+#    Luciole is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    Luciole is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with Luciole.  If not, see <http://www.gnu.org/licenses/>.
+#
+#
+
+# for i18n
+from gettext import gettext as _
+
+import os.path
+
+import lcl_export_tool_base as LETBASE
+
+
+class lcl_export_cinelerra (LETBASE.luciole_export_tool):
+    """
+    class to export luciole project in cinelerra format 
+    """
+
+    """ ATTRIBUTES
+    N/A
+    """
+
+    def __init__(self,  lcl_project = "./luciole_project.xml", template="./template.xml", export_file = "./export.xml"):
+        """
+        initialization of class  lcl_export_cinelerra
+
+        @param object lcl_project : Luciole project or file
+        @param string template : Path to template
+        @param string export_file : Path to export_file
+        """
+        super(lcl_export_cinelerra, self).__init__(lcl_project,template,export_file )
+
+    def _gen_ressources(self):
+        """
+        ressource is called asset in cinelerra template 
+        """
+        resources_tag = self._template_xml.find("//ASSETS")
+        resource_elem_tpl =  self._template_xml.find("//ASSET")
+
+        for image in self._lcl_project_data['resources_images'] :
+            # build image_path 
+            image_p = os.path.join(self._lcl_project_data['image_path'], image)
+            # create a resource element --> i.e an ASSET element
+            new_element = self._template_xml.SubElement(resources_tag,"ASSET",{"SRC":image_p})
+            # copy subelement ASSET template tag in new element
+            for elem_tpl in resource_elem_tpl.getchildren() :
+                new_element.append(elem_tpl)
+        
+        #remove template tag
+        resources_tag.remove(resource_elem_tpl)
+    
+    def _gen_timeline(self):
+        """
+        generate timeline 
+        """
+        (timeline_tag, timeline_item_tpl) = self.__get_timeline_tags()
+        for image in self._lcl_project_data['timelines_images'] :
+            # build image_path 
+            image_p = os.path.join(self._lcl_project_data['image_path'], image)
+            
+            # create New EDIT element per image 
+            for frame in range(self._lcl_project_data['fpi']):
+                framerate = str(self._lcl_project_data['fpi'])
+                new_element = self._template_xml.SubElement(timeline_tag,"EDIT",{"STARTSOURCE":"0","CHANNEL":"0", "LENGTH":"1"})
+                # create FILE subElement of EDIT
+                self._template_xml.SubElement(new_element,"FILE",{"SRC":image_p})
+        
+        # remove EDIT template tag 
+        timeline_tag.remove(timeline_item_tpl)
+            
+    #
+    # class PRIVATE methods
+    #    
+    def __get_timeline_tags(self) :
+        """
+           in cinelerra timeline tags is TRACK with type video, and EDITS/EDIT tag
+        """
+        video_track = None
+        tracks = self._template_xml.findall("//TRACK")
+        for track in tracks :
+            if track.get("TYPE") == "VIDEO" :
+                # video track is found
+                video_track = track
+                break
+        # get EDIT tag
+        return ( video_track.find("EDITS"), video_track.find("EDITS/EDIT"))
+
+
+  
+
+if __name__ == '__main__' :
+    X = lcl_export_cinelerra( lcl_project = "/home/nico/temp/testLuciole/luciole_project_isight/luciole_project_isight.xml",template="./cinelerra_template.xml",export_file = "./cine_export.xml" ) 
+    X.generate()
+    

=== added file 'lucioLib/lcl_export/lcl_export_kdenlive.py'
--- lucioLib/lcl_export/lcl_export_kdenlive.py	1970-01-01 00:00:00 +0000
+++ lucioLib/lcl_export/lcl_export_kdenlive.py	2010-01-04 17:42:19 +0000
@@ -0,0 +1,289 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# -*- Mode: Python -*-
+# vim:si:ai:et:sw=4:sts=4:ts=4
+#
+#
+# Copyright Nicolas Bertrand ([e-mail]), 2010
+#
+# This file is part of Luciole.
+#
+#    Luciole is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    Luciole is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with Luciole.  If not, see <http://www.gnu.org/licenses/>.
+#
+#
+
+# for i18n
+from gettext import gettext as _
+
+import os.path
+import subprocess as SP
+import os
+import stat
+
+import lcl_export_tool_base as LETBASE
+
+from .. import luciole_constants as LCONST
+
+class lcl_export_kdenlive (LETBASE.luciole_export_tool):
+    """
+    class to export luciole project in cinelerra format 
+    kdenlive files are xml files based on MLT framework
+
+    """
+
+    """ ATTRIBUTES
+    @___element_id : Xml tag id for kdenlive export file
+    @__list_id_producer : List of kdenlive producer tag's id
+    @__total_duration : Total duration, in frame, or movie in timeline
+
+    """
+    
+    """ CONSTANTS
+    """
+    __PRODUCER_AUDIO_MAX = "0"
+    __PRODUCER_VIDEO_MAX = "0"
+    __PRODUCER_CHANNELS = "0"
+    __PRODUCER_DEFAULT_AUDIO = "0"
+    __PRODUCER_FRAME_SIZE = str(LCONST.VIDEO_PAL_RES[0])+"x"+ str(LCONST.VIDEO_PAL_RES[1])
+    __PRODUCER_FREQUENCY = "0"
+    __PRODUCER_IN = "0"
+    __PRODUCER_ASPECT_RATIO = "1.000000"
+    __PRODUCER_TYPE ="5"
+    __PRODUCER_DEFAULT_VIDEO = "0"
+    __PRODUCER_POS = 4
+    __PLAYLIST_ID = "lcl_track" 
+
+    __META_HOMEDIR = os.path.expandvars('$HOME')
+    __META_PROJECFOLDER = os.path.join(os.path.expandvars('$HOME'),"kdenlive")
+    __META_PROJECT_NAME =  "Submission from luciole"
+
+
+
+
+    def __init__(self,  lcl_project = "./luciole_project.xml", template="templates/kdenlive_template.kdenlive", export_file = "./export.xptv"):
+        """
+        initialization of class  lcl_export_kdenlive
+
+        @param object lcl_project : luciole project or file 
+        @param string template : Path to template
+        @param string export_file : Path to export_file
+        @return  :
+        @author
+        """
+        super(lcl_export_kdenlive, self).__init__(lcl_project,template,export_file )
+
+        self.__element_id = 1
+        self.__list_id_producer = []
+        self.__total_duration = 0
+
+    def _gen_meta(self):
+        """
+        generate meta information for kdenlive file
+        """
+        mlt_tag =  self._template_xml.getroot() 
+        mlt_tag.attrib["root"] = self.__META_HOMEDIR
+        mlt_tag.attrib["title"] = self.__META_PROJECT_NAME
+        kdenlivedoc = self._template_xml.find("//kdenlivedoc")
+        kdenlivedoc.attrib["projectfolder"] = self.__META_PROJECFOLDER
+
+    def _gen_ressources(self):
+        """
+        resources is called <kdenlive_producer> and is stored in <kdenlive_doc> 
+        """
+        resources_tag = self._template_xml.find("//kdenlivedoc")
+
+        duration =  self.__calc_duration( self._lcl_project_data['fpi'])
+        for image in self._lcl_project_data['resources_images'] :
+            # build image_path 
+            image_p = os.path.join(self._lcl_project_data['image_path'], image)
+            # create a resource element --> i.e a kdenlive_producer element
+
+            new_element = self._template_xml.SubElement(resources_tag,"kdenlive_producer",
+                    {"audio_max":       self.__PRODUCER_AUDIO_MAX,
+                     "channels" :       self.__PRODUCER_CHANNELS,
+                     "duration" :       str(duration),
+                     "default_audio" :  self.__PRODUCER_DEFAULT_AUDIO,
+                     "video_max" :      self.__PRODUCER_VIDEO_MAX,
+                     "frame_size" :     self.__PRODUCER_FRAME_SIZE,
+                     "frequency" :      self.__PRODUCER_FREQUENCY,
+                     "in" :             self.__PRODUCER_IN,
+                     "file_size" :      self.__calc_file_size(image_p),
+                     "aspect_ratio" :   self.__PRODUCER_ASPECT_RATIO,
+                     "out" :            str(duration-1),
+                     "file_hash" :      self.__calc_file_hash(image_p),      
+                     "type" :           self.__PRODUCER_TYPE,
+                     "id" :             self.__new_element_id(),
+                     "name" :           image,
+                     "default_video" :  self.__PRODUCER_DEFAULT_VIDEO,
+                     "resource" :      image_p,
+                     })
+            
+    def _gen_timeline(self):
+        """
+        The timeline in kdenlive is divided in 3 steps : the <producer> tag, the <playlist>, and <tractor>
+        """
+        self.__gen_producer()
+        self.__gen_playlist()
+        self.__gen_tractor()
+
+
+    #
+    # class PRIVATE methods
+    #
+
+    def __new_element_id(self):
+        """ generates an element id """
+        element_id = self.__element_id
+        self.__element_id += 1
+        return str(element_id)
+
+    def __calc_file_hash(self,file) :
+        """ compute the md5sum of a file.
+        These function needs robustness in cas on non success of md5sum command"""
+        output =SP.Popen(["md5sum",file], stdout=SP.PIPE).communicate()[0]
+        # output is a srting who looks like : hash_code   file
+        # return only the hashcode
+        return output.split()[0]
+
+    def __calc_file_size(self,file) : 
+        """ compute the file size """
+        fsz = os.stat(file)[stat.ST_SIZE]
+        return str(fsz)
+     
+    def __calc_duration(self,fpi) : 
+        """ kdenlive does not support ressource with duration less then 3 frames ...."""
+        fr = int(fpi)
+        if fr < 3 : fr =3 
+        return fr
+            
+    def __get_timeline_video_tags(self) :
+        """
+           in pitivi timeline tag is <timeline>
+           video is on <track>/<stream> with typepitivi.stream.VideoStream,        """    
+        video_track = None
+        tracks = self._template_xml.findall("//track")
+        for track in tracks:
+            stream = track.find("stream")
+            if stream.attrib["type"] == self.STREAM_TYPE :
+                video_track = track
+                break
+        return video_track
+
+
+    def __find_black_track(self) :
+        """ get back track play list. return the entry element """
+        pl_found = None
+        for pl in self._template_xml.findall("//playlist") :
+            if pl.attrib["id"] == "black_track" :
+                pl_found = pl
+                break
+        return pl_found.find("entry")
+
+    def __find_kdenlive_producer_id(self,image) :
+        """ find the id of a <kdenlive_producer> tag """
+        kd_producer_tags = self._template_xml.findall("//kdenlive_producer")
+        id_found  = None
+        for kd_producer_tag in kd_producer_tags :
+            if kd_producer_tag.attrib['name'] == image :
+                id_found = kd_producer_tag.attrib['id']
+        # raise error if id not found
+        return id_found
+
+    def __gen_proprety_tag(self,producer_tag,name,text) :
+        """ generate property tag """
+        prop_tag = self._template_xml.SubElement(producer_tag,"property",{
+                                        "name":name})
+        prop_tag.text = text
+        
+
+    def __gen_producer_properties(self,producer_tag, image_p) :
+        """ properties of producer tag. Dirty generation. """
+        self.__gen_proprety_tag(producer_tag,"mlt_type","producer")
+        self.__gen_proprety_tag(producer_tag,"aspect_ratio","1")
+        self.__gen_proprety_tag(producer_tag,"length","15000")
+        self.__gen_proprety_tag(producer_tag,"eof","pause")
+        self.__gen_proprety_tag(producer_tag,"resource",image_p)
+        self.__gen_proprety_tag(producer_tag,"ttl","25")
+        self.__gen_proprety_tag(producer_tag,"progressive","1")
+        self.__gen_proprety_tag(producer_tag,"mlt_service","pixbuf")
+
+
+    def __gen_producer(self) : 
+        """ <producer> tag have attributes and property subtag.
+            Producer tag is a son of <mlt> tag """        
+        mlt_tag =  self._template_xml.getroot()
+        producer_pos = self.__PRODUCER_POS
+
+        duration = str(self._lcl_project_data['fpi'])
+        # loop on luciole project timeline images
+        for (index,image) in enumerate(self._lcl_project_data['timelines_images']) :
+            id_kd_producer = self.__find_kdenlive_producer_id(image)
+            if id_kd_producer != None :
+                # create the tag 
+                producer_tag= self._template_xml.Element("producer")
+                producer_tag.set("in",self.__PRODUCER_IN)
+                producer_tag.set("out",duration)
+                producer_tag.set("id",id_kd_producer)
+                mlt_tag.insert(producer_pos,producer_tag)
+
+                # create <property> tags
+                image_p = os.path.join(self._lcl_project_data['image_path'], image)
+                self.__gen_producer_properties(producer_tag, image_p)
+                
+                # remember the id for playlist generation
+                self.__list_id_producer.append(id_kd_producer)
+
+                #increment position for next element
+                producer_pos += 1
+
+    def __gen_playlist_entry(self,pl_tag,out,producer) :
+        """ playlist entry tag"""
+        self._template_xml.SubElement(pl_tag,"entry",{
+                                        "in":self.__PRODUCER_IN,
+                                        "out":out,
+                                        "producer":producer})
+
+
+    def __gen_playlist(self) :
+        """ generate playlist """
+        mlt_tag =  self._template_xml.getroot()
+        
+        # get playlist tag
+        playlists_tag =  self._template_xml.findall("//playlist")
+        playlist_tag = None
+        for tag in playlists_tag :
+            if tag.attrib["id"]  == self.__PLAYLIST_ID :
+                playlist_tag = tag
+        # generate entry tag and compute duration of all timeline 
+        if playlist_tag != None :
+            # compute duration
+            duration = int(self._lcl_project_data['fpi']) 
+        
+            for id_p  in self.__list_id_producer :
+                self.__gen_playlist_entry(playlist_tag,str(duration),id_p)
+                self.__total_duration += duration
+        
+            self.__total_duration =  self.__total_duration -1         
+
+    def __gen_tractor(self) :
+        """ modify tractor tag""" 
+        tractor_tag = self._template_xml.find("tractor")
+        tractor_tag.attrib['out'] = str(self.__total_duration)
+        
+        #update duration in black_track playlist
+        pl_entry=self.__find_black_track()
+        pl_entry.attrib["out"] = str(self.__total_duration)
+
+
+    

=== added file 'lucioLib/lcl_export/lcl_export_pitivi.py'
--- lucioLib/lcl_export/lcl_export_pitivi.py	1970-01-01 00:00:00 +0000
+++ lucioLib/lcl_export/lcl_export_pitivi.py	2010-01-04 17:42:19 +0000
@@ -0,0 +1,199 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# -*- Mode: Python -*-
+# vim:si:ai:et:sw=4:sts=4:ts=4
+#
+#
+# Copyright Nicolas Bertrand ([e-mail]), 2010
+#
+# This file is part of Luciole.
+#
+#    Luciole is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    Luciole is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with Luciole.  If not, see <http://www.gnu.org/licenses/>.
+#
+#
+
+# for i18n
+from gettext import gettext as _
+
+import os.path
+
+import lcl_export_tool_base as LETBASE
+
+
+class lcl_export_pitivi (LETBASE.luciole_export_tool):
+    """
+    class to export luciole project in pitivi format 
+
+    """
+
+    """ ATTRIBUTES
+    @__element_id    : Xml tag id for pitivi export file
+     
+    """
+    
+    """ CONSTANTS
+    """
+    # hard coded value in pitivi template
+    __SOURCE_DURATION ="18446744073709551615"
+    # pitivi type
+    __SOURCE_TYPE = "pitivi.factories.file.PictureFileSourceFactory"
+    
+    __STREAM_CAPS = "video/x-raw-yuv, format=(fourcc)I420, width=(int)720, height=(int)576, framerate=(fraction)0/1"
+    __STREAM_NAME = "src0"
+    __STREAM_TYPE = "pitivi.stream.VideoStream"
+
+    __BASE_DURATION_NS = 1000000000
+
+    __TIMELINE_TYPE = "pitivi.timeline.track.SourceTrackObject"
+    __TIMELINE_IN_POINT = "(gint64)0"
+    __TIMELINE_PRIORITY = "(int)0"
+
+
+
+    def __init__(self,  lcl_project = "./luciole_project.xml", template="./pitivi_template.xptv", export_file = "./export.xptv"):
+        """
+        initialization of class  lcl_export_pitivi
+
+        @param object lcl_project : luciole project or file 
+        @param string template : Path to template
+        @param string export_file : Path to export_file
+        """
+        super(lcl_export_pitivi, self).__init__(lcl_project,template,export_file )
+        
+        
+        #
+        # Attributes init.
+        #
+        self.__element_id = 0
+
+    def _gen_ressources(self):
+        """
+        heritage method   
+        resources is called sources in pitivi 
+        """
+        resources_tag = self._template_xml.find("//sources")
+
+        for image in self._lcl_project_data['resources_images'] :
+            # build image_path 
+            image_p = os.path.join(self._lcl_project_data['image_path'], image)
+            image_p = "file://"+image_p
+            # create a resource element --> i.e a source element
+            new_element = self._template_xml.SubElement(resources_tag,"source",
+                    {"filename":image_p,
+                     "type":self.__SOURCE_TYPE,
+                     "duration":self.__SOURCE_DURATION,
+                     "id":self.__new_element_id(),
+                     "default_duration":self.__calc_duration(int(self._lcl_project_data['fpi']))
+                     })
+            
+            # create <output-stream> and <stream> sub element 
+            new_output_stream = self._template_xml.SubElement(new_element,"output-streams")
+            new_stream = self._template_xml.SubElement(new_output_stream,"stream",
+                    {"caps":self.__STREAM_CAPS,
+                     "name":self.__STREAM_NAME,
+                     "id":self.__new_element_id(),
+                     "type":self.__STREAM_TYPE
+                     })
+            
+    def _gen_timeline(self):
+        """
+        heritage method   
+        generate timeline :
+        in pitivi each image is a track object with ref to <ourrce>
+
+        """
+        # get video track on timeline
+        video_track = self.__get_timeline_video_tags() 
+        
+        # create <track-objects> for each resource 
+        track_objects = video_track.find('track-objects')
+        
+        # loop on luciole project timeline images
+        for (index,image) in enumerate(self._lcl_project_data['timelines_images']) :
+            
+            # compute duration and start point
+            track_duration = int( self.__calc_duration(int(self._lcl_project_data['fpi'])))
+            start_point = index * int(track_duration)
+            
+            
+            # create a track_object
+            new_track_object = self._template_xml.SubElement(track_objects,"track-object",
+                    { "id":self.__new_element_id(),
+                        "type": self.__TIMELINE_TYPE,
+                        "duration" :self.__convert_to_gint64(track_duration),
+                        "media_duration" : self.__convert_to_gint64(track_duration),
+                        "start": self.__convert_to_gint64(start_point),
+                        "in_point": self.__TIMELINE_IN_POINT,
+                        "priority": self.__TIMELINE_PRIORITY
+                        })
+            
+            # get and create ref tags with sources 
+            (factory_id, stream_id) = self.__find_track_id(image)
+            self._template_xml.SubElement(new_track_object,"factory-ref", { "id":factory_id})
+            self._template_xml.SubElement(new_track_object,"stream-ref", { "id":stream_id})
+
+
+    #
+    # class PRIVATE methods
+    #
+    def __new_element_id(self):
+        """ generates an element id """
+        element_id = self.__element_id
+        self.__element_id += 1
+        return str(element_id)
+
+    def __calc_duration(self,fpi) :
+        """ compute duration in pitivi format. 
+            Input is the fpi : number of frame per image
+        """
+        duration = (1.0/fpi)*self.__BASE_DURATION_NS
+        # use of str and int : int for a rounded value and str for string in element tree
+        return str(int(duration))
+
+    def __get_timeline_video_tags(self) :
+        """
+           in pitivi timeline tag is <timeline>
+           video is on <track>/<stream> with typepitivi.stream.VideoStream
+        """
+        video_track = None
+        tracks = self._template_xml.findall("//track")
+        for track in tracks:
+            stream = track.find("stream")
+            if stream.attrib["type"] == self.__STREAM_TYPE :
+                video_track = track
+                break
+        return video_track
+
+    def __convert_to_gint64(self,value) :
+        """ convert to gint64 format. Only str conversion"""
+        return "(gint64)"+str(value)
+
+    def __find_track_id(self,image) :
+        """ find image ids for pitivi according image name """
+        sources = self._template_xml.findall("//source")
+        (source_id, stream_id) = (None,None)
+        for source in sources :
+            filename  = source.attrib["filename"]
+            filename = filename.split('/')[-1]
+            if filename == image :
+                # get source id
+                source_id = source.attrib['id']
+                # find stream id
+                stream_id = source.find('output-streams/stream').attrib['id']
+                break
+        return (source_id, stream_id)
+
+
+
+    

=== added file 'lucioLib/lcl_export/lcl_export_tool_base.py'
--- lucioLib/lcl_export/lcl_export_tool_base.py	1970-01-01 00:00:00 +0000
+++ lucioLib/lcl_export/lcl_export_tool_base.py	2010-01-04 17:42:19 +0000
@@ -0,0 +1,203 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# -*- Mode: Python -*-
+# vim:si:ai:et:sw=4:sts=4:ts=4
+#
+#
+# Copyright Nicolas Bertrand ([e-mail]), 2010
+#
+# This file is part of Luciole.
+#
+#    Luciole is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    Luciole is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with Luciole.  If not, see <http://www.gnu.org/licenses/>.
+#
+#
+"""
+lcl_export_tool_base.py
+Base export to tool definition and class
+
+"""
+# for i18n
+from gettext import gettext as _
+
+import os.path
+from .. import luciole_et as LE
+from .. import luciole_exceptions as LEXCEP
+from .. import luciole_project as LPROJECT
+
+class luciole_export_tool(object) :
+    """
+    Base class for export to tool
+    """
+    
+    
+    """ ATTRIBUTES
+    @_export_file        : Path to file to export
+    @_template           : Path to template
+    @_lcl_project        : The luciole project a file or a dict
+    @_lcl_project_data   : luciole project data dictionary filled with ecport data 
+    @_export_template    : File to update with export data
+    @_template_xml       : the export template loaded as xml file
+    """
+    
+
+
+    def __init__(self,  lcl_project = "./luciole_project.xml", template="./template.xml", export_file = "./export.xml"):
+        """
+        @param lcl_project      : luciole project  
+        @param template         : Path to template
+        @param export_file      : Path to export_file
+        """
+        #
+        # Atributes init
+        #
+        self._lcl_project = lcl_project
+        self._template = template
+        self._export_file = export_file
+        self._lcl_project_data = {}
+        self._lcl_project_data['resources_images'] = []
+        self._lcl_project_data['timelines_images'] = []
+
+        self._export_template = None
+        self._template_xml = None
+        
+        if (type(lcl_project) == str) : 
+            # test file type
+            if os.path.exists(lcl_project) :
+                #filetype exits load it
+                self.__load_lcl_file()
+            else :
+                #Raise Error
+                excep_message = "%s is ot a file",lcl_project
+                raise LEXCEP.LucioException,excep_message            
+        elif (type(lcl_project) == LPROJECT.project_dico) :
+            # input is a dictionary
+            self.__load_lcl_dict()
+        else :
+            # template does not exists : raise an exception
+            excep_message = "Invalid projetc type nor file nor luciole_project"
+            raise LEXCEP.LucioException,excep_message            
+        
+        #
+        # Test template
+        #
+        if os.path.exists(self._template) :
+            self._load_template()
+        else :
+            # template does not exists : raise an exception
+            excep_message = " Template file %s does not exist"%self._template
+            raise LEXCEP.LucioException,excep_message            
+
+            
+
+
+    def generate(self):
+        """
+         
+
+        @return  :
+        @author
+        """
+        self._gen_meta()
+        self._gen_ressources()
+        self._gen_timeline()
+        self.__write_export_file()
+
+    def _load_template(self):
+        """
+         
+
+        @return  :
+        @author
+        """
+
+        self._template_xml = LE.lcl_et(self._template)
+
+    def _gen_ressources(self):
+        """
+         generate date for resources
+
+        @return  :
+        @author
+        """
+        pass
+
+    def _gen_timeline(self):
+        """
+         Generate data for timeline
+
+        @return  :
+        @author
+        """
+        pass
+
+    def _gen_meta(self) :
+        """
+         Generate meta information for project
+
+        @return  :
+        @author
+        """
+        pass
+
+
+
+    def __load_lcl_file(self):
+        """
+         Load a Luciole project from a file dictionary
+
+        @return  :
+        @author
+        """
+        try :
+            _lcl_project_xml = LE.lcl_et(self._lcl_project)
+        except :
+            pass
+        else :
+            self._lcl_project_data['image_path'] = os.path.join(_lcl_project_xml.findtext("metas/projectPath").strip() , 
+                                                        _lcl_project_xml.findtext("metas/rush_dir").strip() )
+            self._lcl_project_data['fpi'] = int(_lcl_project_xml.findtext("metas/fpi").strip())
+            
+            # get resources images from project capture data
+            list_image = _lcl_project_xml.find("captureData").getiterator('image')
+            [ self._lcl_project_data['resources_images'].append(image.text.strip())  for image in list_image]
+            
+            # get timelines images from project chrono data
+            list_image = _lcl_project_xml.find("chronoData").getiterator('image')
+            [self._lcl_project_data['timelines_images'].append(image.text.strip())  for image in list_image]
+            
+
+    def __load_lcl_dict(self):
+        """
+         Load a Luciole project from a dictionary
+
+        @return  :
+        @author
+        """
+        
+        self._lcl_project_data['image_path'] = os.path.join(self._lcl_project['project_dir'], self._lcl_project['rush_dir'])
+        self._lcl_project_data['fpi'] = int(self._lcl_project['fpi'])
+        self._lcl_project_data['resources_images'] = self._lcl_project['capture_images']
+        self._lcl_project_data['timelines_images'] = self._lcl_project['chrono_images']
+
+
+    def __write_export_file(self):
+        """
+         
+
+        @return  :
+        @author
+        """
+        self._template_xml.write(self._export_file)
+
+   

=== added file 'lucioLib/lcl_export/lcl_export_video.py'
--- lucioLib/lcl_export/lcl_export_video.py	1970-01-01 00:00:00 +0000
+++ lucioLib/lcl_export/lcl_export_video.py	2010-01-04 17:42:19 +0000
@@ -0,0 +1,656 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# -*- Mode: Python -*-
+# vim:si:ai:et:sw=4:sts=4:ts=4
+#
+#
+# Copyright Nicolas Bertrand ([e-mail]), 2009
+#
+# This file is part of Luciole.
+#
+#    Luciole is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    Luciole is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with Luciole.  If not, see <http://www.gnu.org/licenses/>.
+#
+#
+
+import subprocess as SP
+import os
+import os.path
+import dircache
+import fnmatch
+import string
+import tempfile
+import dircache
+import re
+
+from .. import luciole_tools as MT
+from .. import luciole_exceptions as LEXCEP
+
+import gobject
+import threading
+import Queue
+import time
+
+# for i18n
+from gettext import gettext as _
+
+
+import os
+import signal
+
+(IMAGE_LIST,IMAGE_DIR)=range(2)
+ERR_FILE_EXIST = 1
+(EXPORT_DV,EXPORT_DVD,EXPORT_XVID) = range(3)
+
+# Mencoder commands for export , according export type
+dictPal= { 
+    #EXPORT_DV : "-vf scale=720:576 -ofps 25 -ovc lavc -oac pcm",
+    EXPORT_DV : "-target pal-dv -aspect 4:3",
+    EXPORT_DVD : "-vf scale=720:576 -ofps 25 -oac pcm -ovc lavc -lavcopts vcodec=mpeg2video:vbitrate=9600:aspect=4/3", 
+    EXPORT_XVID : "-vf scale=720:576 -ofps 25 -ovc lavc -lavcopts vcodec=mpeg4:vbitrate=2000:aspect=4/3  -oac mp3lame -lameopts cbr:br=128", 
+}
+
+dictEncoder= {
+    "PAL":dictPal,
+    }
+
+
+class MyThreadConvertToYuv(threading.Thread):
+    """ Thread class for convert a sequence of image to a YUV file """
+  
+    def _get_abort(self): return self.__abort
+    def _set_abort(self, value): 
+        if value in (True,False) : self.__abort = value
+    abort = property(_get_abort, _set_abort, None, "abort thread work")
+
+
+    def __init__(self,imageInputType,imageDir,imageList,ppmtoy4m_opts,framesPerImage,tmpDir,VideoName,finish_queue,export_gui_obj):
+        """ Thread class initialisation  """
+        super(MyThreadConvertToYuv, self).__init__()
+        self.__imageInputType = imageInputType
+        self.__imageDir = imageDir
+        self.__imageList = imageList
+        self.__ppmtoy4m_opts = ppmtoy4m_opts
+        self.__framesPerImage = framesPerImage
+        self.__tmpDir = tmpDir
+        self.__VideoName = VideoName
+        self.__queue= finish_queue
+
+       
+        self._export_gui_obj = export_gui_obj
+        self._export_gui_obj.progress_bar_text = _("Pass 1/2")
+        self._export_gui_obj.progress_bar_fraction = 0
+
+        self.__abort = False # reset abort value
+
+    def _on_finish(self, file_path,abort):
+        """Callback function. Raised when conversions is finished"""
+        #preparation of next pass if no abort
+        if abort == False :
+            self._export_gui_obj.progress_bar_text = _("Pass 2/2") 
+        self._export_gui_obj.progress_bar_fraction = 0.0
+        # TBD : missing update of file path in export obj 
+        self.__abort = False # reset abort value
+        return False
+
+    def _on_progress(self, value):
+        """Callback function. used to know the conversion progress """
+        self._export_gui_obj.progress_bar_fraction = value
+        return False
+
+    def _convertToYuv(self) :
+        """ This memthod is used to convert the sequence of image in a raw
+            video in YUV4MPEG format. This method use external tools as
+            imagemagick and tools (ppmtoy4m) from mjpegtools suite."""
+        # Get first the list of image To co_nvert is depending of the type 
+    
+        if self.__imageInputType == IMAGE_DIR :
+            # input images are stored in a directory
+            imagesToConv = MT.filesInDir(self.__imageDir,"*.jpeg")
+        else :
+            # input images are in a list
+            imagesToConv =  self.__imageList
+        # copmute the number of frames to genarate = Number of images * nf of frame per image
+        nbFrames = len(imagesToConv)*self.__framesPerImage
+        self.__ppmtoy4m_opts['-n'] = str(nbFrames)      #update the numner of frames for  
+    
+        video_temp_base=os.path.join(self.__tmpDir,self.__VideoName)
+        # build  ppmtoy4m_cmd
+        ppmtoy4m_cmd = ""
+        for key,value in self.__ppmtoy4m_opts.items() :
+            mystring = " "+ key
+            if value : mystring = mystring + " "+value
+            ppmtoy4m_cmd = mystring + ppmtoy4m_cmd
+        ppmtoy4m_cmd = 'ppmtoy4m'+ppmtoy4m_cmd
+
+        # launch ppmtoy4m, this process run during all the image convesrion
+        # and receive in stdin images converted in ppm format 
+        # the ppm images are sent to this subprocess by the convert operation
+        # see p2 below 
+        fd5 = os.open(video_temp_base+".yuv",os.O_WRONLY|os.O_CREAT)
+        fd6 = os.open(video_temp_base+".log",os.O_WRONLY|os.O_CREAT)
+
+        ppm_proc = SP.Popen(ppmtoy4m_cmd, shell=True, stdin=SP.PIPE,stdout=fd5,stderr=fd6)
+        frame_cpt = 0
+        for (count_image,image) in enumerate(imagesToConv) :
+            # check abort 
+            if self.__abort == True : break
+            #loop on images to convert
+            #conversion and rezizing of cuurent image
+            imagePath = os.path.join(self.__imageDir,image)
+            montage_cmd = "montage  -type TrueColor -quality 100 -geometry 720x576  "+imagePath+ " " + video_temp_base+".jpg"
+            pMontage =SP.call(montage_cmd,shell=True)
+            convert_cmd = "convert -type TrueColor -quality 100 "+video_temp_base+".jpg " +video_temp_base+".pnm "
+            pconvert =SP.call(convert_cmd,shell=True)
+          
+            for i in range(self.__framesPerImage) :
+                # check abort 
+                if self.__abort == True : break
+                frame_cpt = frame_cpt +1
+                convert_cmd = "convert -depth 8 ppm:"+video_temp_base+".pnm -"
+                p1 = SP.Popen(convert_cmd,shell=True, stdout=ppm_proc.stdin,stderr=SP.PIPE)
+                p1.wait()
+            # progress bar update 
+            progression = ((count_image+1.0)/len(imagesToConv)) 
+            gobject.idle_add(self._on_progress,progression)
+        os.fsync(fd5)
+        os.close(fd5)
+        os.close(fd6) 
+        #return the path to yuv file
+        return video_temp_base+".yuv"
+  
+    def run(self) :
+        """ Thread start --> launch images to video conversion """
+        yuvfile_path = self._convertToYuv()
+        self.__queue.put(yuvfile_path)
+        gobject.idle_add(self._on_finish,yuvfile_path,self.__abort)
+
+
+
+class MyExportThread(threading.Thread):
+    """ Export Thread. Thread in charge to enconde video in Yuv format
+        to DV, DVD or XVID format
+    """
+  
+    def _get_abort(self): return self.__abort
+    def _set_abort(self, value): 
+        if value in (True,False) : self.__abort = value
+    abort = property(_get_abort, _set_abort, None, "abort thread work")
+  
+    def __init__(self, exportType, videoOutPath, yuv_queue, export_gui_obj) :
+        """ Init export video Thread"""
+        super(MyExportThread, self).__init__()
+        self.__abort = False
+        (self._exportType,self._videoInPath,self._videoOutPath) = (exportType,None,videoOutPath)
+        self.__queue = yuv_queue
+        self._export_gui_obj = export_gui_obj
+
+    def _on_finish(self,abort):
+        """Callback function. Raised when conversions is finished"""
+        # update gui progress bar
+        if abort == False : 
+            # Terminated normaly 
+            self._export_gui_obj.progress_bar_text = _("Export Done")
+            self._export_gui_obj.progress_bar_fraction = 1.0
+        else :
+            self._export_gui_obj.progress_bar_text = _("Export Canceled")
+            self._export_gui_obj.progress_bar_fraction = 0.0
+            self.__abort = False # reset abort
+        return False
+
+    def _on_progress(self, value):
+        """Callback function. used to know the conversion progress """
+        self._export_gui_obj.progress_bar_fraction = value
+        return False
+
+    def run(self):
+        """ Thread execution --> generate export """
+        """ Build and launch ffmpeg command. """
+        yuv_is_finished=False
+        data = None
+        while (yuv_is_finished == False) :
+            time.sleep(0.1)
+            try :
+                data=self.__queue.get(block=False)
+                yuv_is_finished=True
+            except Queue.Empty :
+                pass
+            # check abort if true leave it  
+            if self.__abort == True :
+                data = None
+                break
+        if data :
+            self._videoInPath = data
+            if self._exportType == EXPORT_DV :
+                self._ffmpeg_launcher()
+            else :
+                self._mencoder_launcher()   
+        gobject.idle_add(self._on_finish,self.__abort)
+
+    def _ffmpeg_launcher(self):
+        """ Video conversion with ffmpeg : only used for DV conversion """
+        self.__videoFormat = "PAL" # only PAL is supported 
+        self.__withSound = False        # no sound by default
+        if ( (self._exportType == EXPORT_DV)  and ( self._videoInPath ) and ( self._videoOutPath ) ) :
+            #
+            # Build ffmpeg command
+            #
+            ffmpeg_cmd = []
+            ffmpeg_cmd.append("ffmpeg")
+            # add input video name
+            ffmpeg_cmd.append('-i')
+            ffmpeg_cmd.append(self._videoInPath)
+            # add video conversion options
+            coding_command = dictEncoder["PAL"][EXPORT_DV]       
+            for ffmpeg_w in coding_command.split() : ffmpeg_cmd.append(ffmpeg_w)
+            # add output video name
+            ffmpeg_cmd.append(self._videoOutPath)
+            
+            #
+            # launch ffmpeg subprocess
+            #
+            print "[",self.__class__.__name__,"] ","command :", ffmpeg_cmd
+            sb_encoder =SP.Popen(ffmpeg_cmd,stdout=SP.PIPE,stderr=SP.PIPE)
+            
+            #
+            # check encoding process and finish
+            #
+            encode_not_finish = True
+            pulse_counter = 0
+            pulse_modulo = 20
+            while encode_not_finish == True:
+                ret_code = sb_encoder.poll()
+                if type(ret_code) == int :
+                    # encoding is finished when a code is returned
+                    encode_not_finish = False
+                if pulse_counter % pulse_modulo == 0 :
+                    # update progress bar only with pulses
+                    gobject.idle_add(self._on_progress, 2.0 )
+                pulse_counter = pulse_counter +1
+
+    def _mencoder_launcher(self) : 
+        """ Video conversion with mencoder : used for convestion in DVD and XVID format"""
+        self.__videoFormat = "PAL" # only PAL is supported
+        self.__withSound = False        # no sound by default
+        if ( (self._exportType in (EXPORT_DVD,EXPORT_XVID))  and ( self._videoInPath ) and ( self._videoOutPath ) ) :
+            #
+            # Build mencoder command
+            #
+            mencoder_cmd =[]
+            mencoder_cmd.append("mencoder")
+            # add export video options  
+            if self.__videoFormat == "PAL" :
+                coding_command = dictEncoder["PAL"][self._exportType]       
+                for mencoder_w in coding_command.split() : mencoder_cmd.append(mencoder_w)
+            #finally add the input and output :
+            mencoder_cmd.append(self._videoInPath)
+            mencoder_cmd.append('-o')
+            mencoder_cmd.append(self._videoOutPath)
+            
+            #
+            # launch mencoder command
+            #
+            print "[",self.__class__.__name__,"] ","command :", mencoder_cmd
+            sb_encoder =SP.Popen(mencoder_cmd,stdout=SP.PIPE,stderr=SP.PIPE)
+
+            #
+            # check encoding process and finish
+            #
+            encode_not_finish = True
+            res_value = 0
+            res_value_old = 0
+            while encode_not_finish == True:
+        
+                # First loop until child is finished
+                buffer = []
+                ret_code = sb_encoder.poll()
+                if type(ret_code) == int :
+                    encode_not_finish = False
+                while True:
+                    # second loop to detect a line
+                    # remark : I have no success to use readline or readlines
+                    # missing some characters
+        
+                    # mencoder display info on stdout, 
+                    # read one char to no be blocked until eof
+                    char = sb_encoder.stdout.readline(1)
+                    if not char : break
+                    else : 
+                        if char == '\r':
+                            aLine = string.join( buffer, '' )
+                            buffer = []
+                            break
+                        else:
+                            buffer.append(char)
+                #extact Frame num
+                #print aLine
+                #Exemple line : 
+                #Pos:  19.0s    475f (99%) 30.68fps Trem:   0min  65mb  A-V:0.000 [28800:0]
+                # regeexp for select percent value here : 99.
+                # value in parenthis ; with one or digits; select only the number 
+                pattern = re.compile("\(\s*([0-9]+)\%\)")
+                # get Match_object
+                # cf tuto : http://docs.python.org/howto/regex.html#regex-howto
+                re_res = pattern.search(aLine)
+                if re_res :
+                    # result is at first index of groups method
+                    # divide by 100 to have a value in range 0 .. 100
+                    res_value = re_res.groups()[0]
+                    if res_value != res_value_old :
+                        # if send message only when percentage value change
+                        # avoid sending unuseful message 
+                        gobject.idle_add(self._on_progress, float(res_value)/100.0 )
+                        res_value_old = res_value
+                        # check if abort requested 
+                        if self.__abort == True :
+                            pid = sb_encoder.pid
+                            os.kill(pid, signal.SIGTERM)
+                            time.sleep(1.0)
+                            # check if is process really dead
+                            if not isinstance(sb_encoder.poll(),int) :
+                                os.kill(pid,signal.SIGKILL)
+                            encode_not_finish = False
+            
+
+
+class lcl_export_video(object) :
+    """ Class in charge of managing exports. The class use threads for conversions"""
+
+    _exportType = (EXPORT_DV,EXPORT_DVD,EXPORT_XVID) 
+  
+    _suffixList =(".dv",".mpeg2",".avi")
+  
+    def _get_imageDir(self): return self.__imageDir
+    def _set_imageDir(self, value): self.__imageDir = value
+    def _del_imageDir(self): del self.__imageDir
+    imageDir = property(_get_imageDir, _set_imageDir, _del_imageDir, "Image's directory. ")
+
+    def _get_imageList(self): return self.__imageList
+    def _set_imageList(self, value): self.__imageList = value
+    def _del_imageList(self): del self.__imageList
+    imageList = property(_get_imageList, _set_imageList, _del_imageList, "Image's list to encode. This list should be sorted. images are encodede in list order. ")
+
+    def _get_imageInputType(self): return self.__imageInputType
+    def _set_imageInputType(self, value): 
+        if value in (IMAGE_LIST,IMAGE_DIR) :
+            self.__imageInputType = value
+        else :
+            print "[",self.__class__.__name__,"] ",value," not in correct type" 
+    def _del_imageInputType(self): del self.__imageInputType
+    imageInputType = property(_get_imageInputType, _set_imageInputType, _del_imageInputType, "Image's input type  ")
+
+    def _get_VideoName(self): return self.__VideoName
+    def _set_VideoName(self, value): self.__VideoName = value
+    def _del_VideoName(self): del self.__VideoName
+    VideoName = property(_get_VideoName, _set_VideoName, _del_VideoName, "Image's directory. ")
+
+    def _get_videoDir(self): return self.__videoDir
+    def _set_videoDir(self, value): self.__videoDir = value
+    def _del_videoDir(self): del self.__videoDir
+    videoDir = property(_get_videoDir, _set_videoDir, _del_videoDir, "Image's directory. ")
+
+    def _get_framesPerImage(self): return self.__framesPerImage
+    def _set_framesPerImage(self, value): self.__framesPerImage = value
+    def _del_framesPerImage(self): del self.__framesPerImage
+    framesPerImage = property(_get_framesPerImage, _set_framesPerImage, _del_framesPerImage, "Number of frames per image. ")
+
+    def _get_outputFPS(self): return self.__outputFPS
+    def _set_outputFPS(self, value): self.__outputFPS = value
+    def _del_outputFPS(self): del self.__outputFPS
+    outputFPS = property(_get_outputFPS, _set_outputFPS, _del_outputFPS, "Image's directory. ")
+
+    def _get_videoFormat(self): return self.__videoFormat
+    def _set_videoFormat(self, value): 
+        self.__videoFormat = value
+        #set values for PAL format
+        if self.__videoFormat == "PAL" :
+            self.__ppmtoy4m_opts['F'] = "-F 25:1"     # framerate - see man ppmtoy4m
+            self.__ppmtoy4m_opts['A'] = "-A 59:54"    # aspect ratio - see man ppmtoy4m 
+    def _del_videoFormat(self): del self.__videoFormat
+    videoFormat = property(_get_videoFormat, _set_videoFormat, _del_videoFormat, "Image's directory. ")
+
+    def _get_videoType(self): return self.__videoType
+    def _set_videoType(self, value): self.__videoType = value
+    def _del_videoType(self): del self.__videoType
+    videoType = property(_get_videoType, _set_videoType, _del_videoType, "Image's directory. ")
+
+    def _get_videoAspect(self): return self.__videoAspect
+    def _set_videoAspect(self, value): self.__videoAspect = value
+    def _del_videoAspect(self): del self.__videoAspect
+    videoAspect = property(_get_videoAspect, _set_videoAspect, _del_videoAspect, "Image's directory. ")
+
+    def _get_withSound(self): return self.__withSound
+    def _set_withSound(self, value): self.__withSound = value
+    def _del_withSound(self): del self.__withSound
+    withSound = property(_get_withSound, _set_withSound, _del_withSound, "Image's directory. ")
+  
+    def _get_export_on_progress(self):
+        """ export status is knowed by the status of the last expôpt thread """
+        if self._t_encoder  and self._t_encoder.isAlive() == True :
+            self._export_on_progress = True
+        else :
+            self._export_on_progress = False
+        return self._export_on_progress
+    export_on_progress = property(_get_export_on_progress, None, None, "export status")
+
+
+
+    def __init__(self,tmp_dir, export_gui_obj):
+        """Init of class"""
+        self.__tmpDir = os.path.join(tmp_dir,"export") 
+        self._cleanTmpDir()
+    
+        self.__imageList = list() # input image list
+        self.__imageInputType = IMAGE_LIST    # image type input is imageList by default
+
+        self.__VideoName = "export"
+        self.__outputFPS = "25"
+        self.__videoFormat = "PAL"
+        self.__videoType = "DV"
+        self.__videoAspect ="4/3"
+
+        # set ppmtoy4m options
+        self.__ppmtoy4m_opts=dict()
+        self.__ppmtoy4m_opts['-F'] = "25:1"      # framerate - see man ppmtoy4m
+        self.__ppmtoy4m_opts['-A'] = "59:54"     # aspectRatio - see man ppmtoy4m
+        self.__ppmtoy4m_opts['-S'] = "420mpeg2"  # subsamplimg chroma mode  - see man ppmtoy4m
+        self.__ppmtoy4m_opts['-I'] = "p"         # interlacing mode,progressive, non-interlaced  - see man ppmtoy4m
+        self.__ppmtoy4m_opts['-n'] = "0"       # total output frames  - see man ppmtoy4m
+        self.__ppmtoy4m_opts['-v'] = "2"       # verbosity  - see man ppmtoy4m
+ 
+        self.__framesPerImage=10           # default value for frame Per image
+    
+        self.__withSound = False        # no sound by default
+    
+        self._export_on_progress = False   # export progression
+        self._t_yuv = None
+        self._t_encoder = None
+        self._videopath = None
+        self.__imageDir = None
+        if self.__videoFormat == "PAL":
+            self.__videoRes=(720,576)
+        # export gui obj    
+        self._export_gui_obj = export_gui_obj
+
+
+  
+    def export(self, export_data ,forceExport=False) :
+        """ Export function 
+            exportData is a dict with the following items :
+            'image_input' = type of image put list or dir (IMAGE_LIST,IMAGE_DIR)
+            'image_list' = List of image to convert, each element is an absolute path yo the image
+                or
+            'image_dir' = dir with all the images to impot : Not implemented
+            'export_dir' = the directory where the video will be exported
+            'video_name' = the export video name wihout extension
+            'export_type' = the type of export (EXPORT_DV,EXPORT_DVD,EXPORT_XVID)
+            'fpi' = the frame rate
+            """
+
+        
+        (VideoExsists,videopath) = self._IsVideoExists(export_data)
+        if (    ( VideoExsists == False) or (forceExport == True) 
+                and 
+                ( videopath != None ) ) : 
+            # check tmp dir is clean
+            self._cleanTmpDir()
+            self._export_on_progress = True
+
+            # initiate queue for comunication between yuv converter and export converter
+            self._dataQueue=Queue.Queue()
+            self._ResQueue=Queue.Queue()
+
+            #
+            # Check input parameters
+            #
+            print " DEBUG : export - ",export_data
+            export_is_valid = False
+            if export_data.has_key('image_input') :
+                self.__imageInputType = export_data['image_input']
+                export_is_valid = True
+
+            # check type of input validity
+            if( 
+                    (export_is_valid == True ) 
+                and 
+                    ( 
+                    (
+                    export_data.has_key('image_list') 
+                    and
+                    export_data['image_input'] == IMAGE_LIST
+                    )
+                or 
+                    (
+                    export_data.has_key('image_dir') 
+                    and
+                    ( export_data['image_input'] == IMAGE_DIR )
+            ) )) :
+                
+                if export_data.has_key('image_list') : self.__imageList = export_data['image_list']
+                if export_data.has_key('image_dir') : self.__imageList = export_data['image_dir']
+                export_is_valid = True
+            else :
+                export_is_valid = False
+
+            if  (export_is_valid == True) and (export_data.has_key('fpi')) :
+                self.__framesPerImage = int(export_data['fpi'])
+                export_is_valid = True
+            else :
+                export_is_valid = False
+
+            if  (export_is_valid == True) and (export_data.has_key('video_name')) :
+                self.__VideoName = export_data['video_name']
+                export_is_valid = True
+            else :
+                export_is_valid = False
+
+            if (export_is_valid == True) and os.path.exists(videopath) :
+                try :
+                    os.remove(videopath) 
+                except OSError,err :
+                    print _('Unable to erase'),err.filename
+                    print err.strerror
+                    videopath = None  
+                    export_is_valid = False 
+
+
+            if export_is_valid == True :
+                # start yuv converter sub process
+                self._t_yuv = MyThreadConvertToYuv(self.__imageInputType,self.__imageDir,self.__imageList,self.__ppmtoy4m_opts,self.__framesPerImage,self.__tmpDir,self.__VideoName,self._dataQueue, self._export_gui_obj)
+                self._t_yuv.start()
+                # start video export encoder subprocess
+                self._videopath = videopath
+                self._t_encoder = MyExportThread(export_data['export_type'], self._videopath, self._dataQueue, self._export_gui_obj)
+                self._t_encoder.start()
+            else :
+                return (0,videopath)
+    
+        if ( VideoExsists == True ) :
+            return (ERR_FILE_EXIST,videopath)
+        else :
+            return (0,videopath)
+
+    def cancel_export(self):
+        """ Cancel export """
+        if self._export_on_progress == True :
+            # kill the eport Threads
+            if self._t_yuv.isAlive() : self._t_yuv.abort= True 
+            if self._t_encoder.isAlive() : self._t_encoder.abort= True 
+            #check if process remains 
+            while ( self._t_yuv.isAlive() or self._t_encoder.isAlive() ) : 
+                time.sleep(0.1)
+            # clean temporary files  
+            self._cleanTmpDir()
+            try :
+                os.remove(self._videopath ) 
+                print self._videopath ," is removed"
+            except OSError,err :
+                print "Impossible d effacer ",err.filename
+                print err.strerror
+ 
+
+
+    ################################################################################ 
+    # private methods
+    ################################################################################ 
+    def _cleanTmpDir(self) :
+        """ Clean or create  tmp dir if needed"""
+        if not os.path.exists(self.__tmpDir) :
+            #create it
+            try :
+                os.makedirs(self.__tmpDir)
+            except OSError,err :
+                print "Impossible de creer le repertoire export"
+                print err.strerror
+                self.__tmpDir = "/tmp"
+        else :
+            # directory exist, clean it
+            list = dircache.listdir( self.__tmpDir)
+            for file in list :
+                filePath = os.path.join(self.__tmpDir,file)
+                try :
+                    os.remove(filePath) 
+                    print filePath ," is removed"
+                except OSError,err :
+                    print "Impossible d effacer ",err.filename
+                    print err.strerror
+     
+    def _IsVideoExists(self,export_data):
+        """ test if a video path exists """
+        exists = False
+        video_path = None
+        # check export type 
+        if export_data.has_key('export_type') and export_data['export_type'] in self._exportType :
+            suffix = self._suffixList[export_data['export_type']]
+            # check export video name
+            if export_data.has_key('video_name') :
+                video_name = export_data['video_name']+suffix
+                
+                # check export dir 
+                if not os.path.exists(export_data['export_dir']) :
+                    #create it
+                    try :
+                        MT.mkdirs(export_data['export_dir'])
+                    except LEXCEP.LucioException , err :
+                        # to robustify : Error handling
+                        print err
+                        return (exists, video_path)
+                video_path = os.path.join(export_data['export_dir'], video_name)
+                
+                # check if video path exists
+                if os.path.exists(video_path) : 
+                    exists = True
+        return (exists,video_path)
+
+
+

=== removed directory 'lucioLib/lucioExport'
=== removed file 'lucioLib/lucioExport/__init__.py'
--- lucioLib/lucioExport/__init__.py	2009-12-03 08:11:32 +0000
+++ lucioLib/lucioExport/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,26 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-# -*- Mode: Python -*-
-# vi:si:ai:et:sw=4:sts=4:ts=4
-#
-#
-# Copyright Nicolas Bertrand ([e-mail]), 2009
-#
-# This file is part of Luciole.
-#
-#    Luciole is free software: you can redistribute it and/or modify
-#    it under the terms of the GNU General Public License as published by
-#    the Free Software Foundation, either version 3 of the License, or
-#    (at your option) any later version.
-#
-#    Luciole is distributed in the hope that it will be useful,
-#    but WITHOUT ANY WARRANTY; without even the implied warranty of
-#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#    GNU General Public License for more details.
-#
-#    You should have received a copy of the GNU General Public License
-#    along with Luciole.  If not, see <http://www.gnu.org/licenses/>.
-#
-#
-from luciole_export import *
-from luciole_export_tool import *

=== removed file 'lucioLib/lucioExport/lcl_export_pitivi.py'
--- lucioLib/lucioExport/lcl_export_pitivi.py	2010-01-04 17:42:19 +0000
+++ lucioLib/lucioExport/lcl_export_pitivi.py	1970-01-01 00:00:00 +0000
@@ -1,217 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-# -*- Mode: Python -*-
-# vim:si:ai:et:sw=4:sts=4:ts=4
-#
-#
-# Copyright Nicolas Bertrand ([e-mail]), 2009
-#
-# This file is part of Luciole.
-#
-#    Luciole is free software: you can redistribute it and/or modify
-#    it under the terms of the GNU General Public License as published by
-#    the Free Software Foundation, either version 3 of the License, or
-#    (at your option) any later version.
-#
-#    Luciole is distributed in the hope that it will be useful,
-#    but WITHOUT ANY WARRANTY; without even the implied warranty of
-#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#    GNU General Public License for more details.
-#
-#    You should have received a copy of the GNU General Public License
-#    along with Luciole.  If not, see <http://www.gnu.org/licenses/>.
-#
-#
-
-# for i18n
-from gettext import gettext as _
-
-import os.path
-
-import lcl_export_tool_base as LETBASE
-
-from .. import luciole_et as LE
-from .. import luciole_exceptions as LEXCEP
-from .. import luciole_project as LPROJECT 
-
-class lcl_export_pitivi (LETBASE.luciole_export_tool):
-
-    """
-     
-
-    :version:
-    :author:
-    """
-
-    """ ATTRIBUTES
-
-     
-
-    _export_template  (private)
-
-    """
-    
-    """ CONSTANTS
-    """
-    # hard coded value in pitivi tamplate
-    SOURCE_DURATION ="18446744073709551615"
-    # pitivi type
-    SOURCE_TYPE = "pitivi.factories.file.PictureFileSourceFactory"
-    
-    STREAM_CAPS = "video/x-raw-yuv, format=(fourcc)I420, width=(int)720, height=(int)576, framerate=(fraction)0/1"
-    STREAM_NAME = "src0"
-    STREAM_TYPE = "pitivi.stream.VideoStream"
-
-    BASE_DURATION_NS = 1000000000
-
-    TIMELINE_TYPE = "pitivi.timeline.track.SourceTrackObject"
-    TIMELINE_IN_POINT = "(gint64)0"
-    TIMELINE_PRIORITY = "(int)0"
-
-
-
-    def __init__(self,  lcl_project = "./luciole_project.xml", template="./pitivi_template.xptv", export_file = "./export.xptv"):
-        """
-         
-
-        @param object lcl_project : luciole project or file 
-        @param string template : Path to template
-        @param string export_file : Path to export_file
-        @return  :
-        @author
-        """
-        super(lcl_export_pitivi, self).__init__(lcl_project,template,export_file )
-        
-        self._element_id = 0
-        self._stream_id = 1
-    
-    def _new_element_id(self):
-        """ generates an element id """
-        element_id = self._element_id
-        self._element_id += 1
-        return str(element_id)
-
-    def _new_stream_id(self):
-        """ generates an element id """
-        stream_id = self._stream_id
-        self._stream_id += 1
-        return str(stream_id)
-
-
-    def _calc_duration(self,fpi) :
-        """ compute duration in pitivi format. 
-            Input is the fpi : number of frame per image
-        """
-        duration = (1.0/fpi)*self.BASE_DURATION_NS
-        # use of str and int : int for a rounded value and str for string in element tree
-        return str(int(duration))
-
-
-    def _load_template(self):
-        """
-        """
-        self._template_xml = LE.lcl_et(self.template)
-        
-
-    def _gen_ressources(self):
-        """
-        ressources is called sources in pitivi 
-        """
-        resources_tag = self._template_xml.find("//sources")
-
-        for image in self._lcl_project_data['resources_images'] :
-            # build image_path 
-            image_p = os.path.join(self._lcl_project_data['image_path'], image)
-            image_p = "file://"+image_p
-            # create a resouce element --> i.e a source element
-            new_element = self._template_xml.SubElement(resources_tag,"source",
-                    {"filename":image_p,
-                     "type":self.SOURCE_TYPE,
-                     "duration":self.SOURCE_DURATION,
-                     "id":self._new_element_id(),
-                     "default_duration":self._calc_duration(int(self._lcl_project_data['fpi']))
-                     })
-            
-            # create <output-stream> and <stream> sub element 
-            new_output_stream = self._template_xml.SubElement(new_element,"output-streams")
-            new_stream = self._template_xml.SubElement(new_output_stream,"stream",
-                    {"caps":self.STREAM_CAPS,
-                     "name":self.STREAM_NAME,
-                     "id":self._new_element_id(),
-                     "type":self.STREAM_TYPE
-                     })
-            
-    
-    def __get_timeline_video_tags(self) :
-        """
-           in pitivi timeline tag is <timeline>
-           video is on <track>/<stream> with typepitivi.stream.VideoStream,        """
-        
-        
-        video_track = None
-        tracks = self._template_xml.findall("//track")
-        for track in tracks:
-            stream = track.find("stream")
-            if stream.attrib["type"] == self.STREAM_TYPE :
-                video_track = track
-                break
-        return video_track
-
-    def __convert_to_gint64(self,value) :
-        return "(gint64)"+str(value)
-
-    def __find_track_id(self,image) :
-        """ find image ids for pitivi avcorrding image name """
-        sources = self._template_xml.findall("//source")
-        (source_id, stream_id) = (None,None)
-        for source in sources :
-            filename  = source.attrib["filename"]
-            filename = filename.split('/')[-1]
-            if filename == image :
-                # get source id
-                source_id = source.attrib['id']
-                # find stream id
-                stream_id = source.find('output-streams/stream').attrib['id']
-                break
-                
-        return (source_id, stream_id)
-
-
-
-    def _gen_timeline(self):
-        """
-        generate timeline :
-        in pitivi each image is a track object with ref to <ourrce>
-
-        """
-        # get video track on timeline
-        video_track = self.__get_timeline_video_tags() 
-        
-        # create <track-objects> for each resource 
-        track_objects = video_track.find('track-objects')
-        
-        # loop on luciiole project timeline images
-        for (index,image) in enumerate(self._lcl_project_data['timelines_images']) :
-            
-            # compute duration and start point
-            track_duration = int( self._calc_duration(int(self._lcl_project_data['fpi'])))
-            start_point = index * int(track_duration)
-            
-            
-            # create a track_object
-            new_track_object = self._template_xml.SubElement(track_objects,"track-object",
-                    { "id":self._new_element_id(),
-                        "type": self.TIMELINE_TYPE,
-                        "duration" :self.__convert_to_gint64(track_duration),
-                        "media_duration" : self.__convert_to_gint64(track_duration),
-                        "start": self.__convert_to_gint64(start_point),
-                        "in_point": self.TIMELINE_IN_POINT,
-                        "priority": self.TIMELINE_PRIORITY
-                        })
-            
-            # get and create ref tags with sources 
-            (factory_id, stream_id) = self.__find_track_id(image)
-            self._template_xml.SubElement(new_track_object,"factory-ref", { "id":factory_id})
-            self._template_xml.SubElement(new_track_object,"stream-ref", { "id":stream_id})
-
-    

=== removed file 'lucioLib/lucioExport/lcl_export_tool_base.py'
--- lucioLib/lucioExport/lcl_export_tool_base.py	2010-01-04 17:42:19 +0000
+++ lucioLib/lucioExport/lcl_export_tool_base.py	1970-01-01 00:00:00 +0000
@@ -1,188 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-# -*- Mode: Python -*-
-# vim:si:ai:et:sw=4:sts=4:ts=4
-#
-#
-# Copyright Nicolas Bertrand ([e-mail]), 2009
-#
-# This file is part of Luciole.
-#
-#    Luciole is free software: you can redistribute it and/or modify
-#    it under the terms of the GNU General Public License as published by
-#    the Free Software Foundation, either version 3 of the License, or
-#    (at your option) any later version.
-#
-#    Luciole is distributed in the hope that it will be useful,
-#    but WITHOUT ANY WARRANTY; without even the implied warranty of
-#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#    GNU General Public License for more details.
-#
-#    You should have received a copy of the GNU General Public License
-#    along with Luciole.  If not, see <http://www.gnu.org/licenses/>.
-#
-#
-
-# for i18n
-from gettext import gettext as _
-
-import os.path
-from .. import luciole_et as LE
-
-from .. import luciole_exceptions as LEXCEP
-from .. import luciole_project as LPROJECT 
-class luciole_export_tool(object) :
-    """
-    :version:
-    :author:
-    """
-    
-    
-    """
-    ATTRIBUTES
-    export_file         : Path to file to export
-    template            : Path to template
-    lcl_project         : The luciole project a file or a dict
-    _lcl_project_data   : 
-    _export_template    : File to update with export data
-    _template_xml       : 
-    """
-    
-
-
-    def __init__(self,  lcl_project = "./luciole_project.xml", template="./template.xml", export_file = "./export.xml"):
-        """
-        @param lcl_project      : Type de projet 
-        @param template         : Path to template
-        @param export_file      : Path to export_file
-        """
-        #
-        # Atributes init
-        #
-        self.lcl_project = lcl_project
-        self.template = template
-        self.export_file = export_file
-        self._lcl_project_data = {}
-        self._lcl_project_data['resources_images'] = []
-        self._lcl_project_data['timelines_images'] = []
-
-        self._export_template = None
-        self._template_xml = None
-        
-        if (type(lcl_project) == str) : 
-            # test file type
-            if os.path.exists(lcl_project) :
-                #filetype exits load it
-                self.__load_lcl_file()
-            else :
-                #Raise Error
-                excep_message = "%s is ot a file",lcl_project
-                raise LEXCEP.LucioException,excep_message            
-        elif (type(lcl_project) == LPROJECT.project_dico) :
-            # input is a dictionary
-            self.__load_lcl_dict()
-        else :
-            # template does not exists : raise an exception
-            excep_message = "Invalid projetc type nor file nor luciole_project"
-            raise LEXCEP.LucioException,excep_message            
-        
-        #
-        # Test template
-        #
-        if os.path.exists(self.template) :
-            self._load_template()
-        else :
-            # template does not exists : raise an exception
-            excep_message = " Template file %s does not exist"%self.template
-            raise LEXCEP.LucioException,excep_message            
-
-            
-
-
-    def generate(self):
-        """
-         
-
-        @return  :
-        @author
-        """
-        self._gen_ressources()
-        self._gen_timeline()
-        self.__write_export_file()
-
-    def _load_template(self):
-        """
-         
-
-        @return  :
-        @author
-        """
-        pass
-
-    def _gen_ressources(self):
-        """
-         generate date for resources
-
-        @return  :
-        @author
-        """
-        pass
-
-    def _gen_timeline(self):
-        """
-         Generate data for timeline
-
-        @return  :
-        @author
-        """
-        pass
-
-    def __load_lcl_file(self):
-        """
-         Load a Luciole project from a file dictionary
-
-        @return  :
-        @author
-        """
-        try :
-            _lcl_project_xml = LE.lcl_et(self.lcl_project)
-        except :
-            pass
-        else :
-            self._lcl_project_data['image_path'] = os.path.join(_lcl_project_xml.findtext("metas/projectPath").strip() , 
-                                                        _lcl_project_xml.findtext("metas/rush_dir").strip() )
-            self._lcl_project_data['fpi'] = int(_lcl_project_xml.findtext("metas/fpi").strip())
-            
-            # get resources images from project capture data
-            list_image = _lcl_project_xml.find("captureData").getiterator('image')
-            [ self._lcl_project_data['resources_images'].append(image.text.strip())  for image in list_image]
-            
-            # get timelines images from project chrono data
-            list_image = _lcl_project_xml.find("chronoData").getiterator('image')
-            [self._lcl_project_data['timelines_images'].append(image.text.strip())  for image in list_image]
-            
-
-    def __load_lcl_dict(self):
-        """
-         Load a Luciole project from a dictionary
-
-        @return  :
-        @author
-        """
-        
-        self._lcl_project_data['image_path'] = os.path.join(self.lcl_project['project_dir'], self.lcl_project['rush_dir'])
-        self._lcl_project_data['fpi'] = int(self.lcl_project['fpi'])
-        self._lcl_project_data['resources_images'] = self.lcl_project['capture_images']
-        self._lcl_project_data['timelines_images'] = self.lcl_project['chrono_images']
-
-
-    def __write_export_file(self):
-        """
-         
-
-        @return  :
-        @author
-        """
-        self._template_xml.write(self.export_file)
-
-   

=== removed file 'lucioLib/lucioExport/luciole_export.py'
--- lucioLib/lucioExport/luciole_export.py	2009-11-23 06:28:27 +0000
+++ lucioLib/lucioExport/luciole_export.py	1970-01-01 00:00:00 +0000
@@ -1,656 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-# -*- Mode: Python -*-
-# vi:si:ai:et:sw=4:sts=4:ts=4
-#
-#
-# Copyright Nicolas Bertrand ([e-mail]), 2009
-#
-# This file is part of Luciole.
-#
-#    Luciole is free software: you can redistribute it and/or modify
-#    it under the terms of the GNU General Public License as published by
-#    the Free Software Foundation, either version 3 of the License, or
-#    (at your option) any later version.
-#
-#    Luciole is distributed in the hope that it will be useful,
-#    but WITHOUT ANY WARRANTY; without even the implied warranty of
-#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#    GNU General Public License for more details.
-#
-#    You should have received a copy of the GNU General Public License
-#    along with Luciole.  If not, see <http://www.gnu.org/licenses/>.
-#
-#
-
-import subprocess as SP
-import os
-import os.path
-import dircache
-import fnmatch
-import string
-import tempfile
-import dircache
-import re
-
-from .. import luciole_tools as MT
-from .. import luciole_exceptions as LEXCEP
-
-import gobject
-import threading
-import Queue
-import time
-
-# for i18n
-from gettext import gettext as _
-
-
-import os
-import signal
-
-(IMAGE_LIST,IMAGE_DIR)=range(2)
-ERR_FILE_EXIST = 1
-(EXPORT_DV,EXPORT_DVD,EXPORT_XVID) = range(3)
-
-# Mencoder commands for export , according export type
-dictPal= { 
-    #EXPORT_DV : "-vf scale=720:576 -ofps 25 -ovc lavc -oac pcm",
-    EXPORT_DV : "-target pal-dv -aspect 4:3",
-    EXPORT_DVD : "-vf scale=720:576 -ofps 25 -oac pcm -ovc lavc -lavcopts vcodec=mpeg2video:vbitrate=9600:aspect=4/3", 
-    EXPORT_XVID : "-vf scale=720:576 -ofps 25 -ovc lavc -lavcopts vcodec=mpeg4:vbitrate=2000:aspect=4/3  -oac mp3lame -lameopts cbr:br=128", 
-}
-
-dictEncoder= {
-    "PAL":dictPal,
-    }
-
-
-class MyThreadConvertToYuv(threading.Thread):
-    """ Thread class for convert a sequence of image to a YUV file """
-  
-    def _get_abort(self): return self.__abort
-    def _set_abort(self, value): 
-        if value in (True,False) : self.__abort = value
-    abort = property(_get_abort, _set_abort, None, "abort thread work")
-
-
-    def __init__(self,imageInputType,imageDir,imageList,ppmtoy4m_opts,framesPerImage,tmpDir,VideoName,finish_queue,export_gui_obj):
-        """ Thread class initialisation  """
-        super(MyThreadConvertToYuv, self).__init__()
-        self.__imageInputType = imageInputType
-        self.__imageDir = imageDir
-        self.__imageList = imageList
-        self.__ppmtoy4m_opts = ppmtoy4m_opts
-        self.__framesPerImage = framesPerImage
-        self.__tmpDir = tmpDir
-        self.__VideoName = VideoName
-        self.__queue= finish_queue
-
-       
-        self._export_gui_obj = export_gui_obj
-        self._export_gui_obj.progress_bar_text = _("Pass 1/2")
-        self._export_gui_obj.progress_bar_fraction = 0
-
-        self.__abort = False # reset abort value
-
-    def _on_finish(self, file_path,abort):
-        """Callback function. Raised when conversions is finished"""
-        #preparation of next pass if no abort
-        if abort == False :
-            self._export_gui_obj.progress_bar_text = _("Pass 2/2") 
-        self._export_gui_obj.progress_bar_fraction = 0.0
-        # TBD : missing update of file path in export obj 
-        self.__abort = False # reset abort value
-        return False
-
-    def _on_progress(self, value):
-        """Callback function. used to know the conversion progress """
-        self._export_gui_obj.progress_bar_fraction = value
-        return False
-
-    def _convertToYuv(self) :
-        """ This memthod is used to convert the sequence of image in a raw
-            video in YUV4MPEG format. This method use external tools as
-            imagemagick and tools (ppmtoy4m) from mjpegtools suite."""
-        # Get first the list of image To co_nvert is depending of the type 
-    
-        if self.__imageInputType == IMAGE_DIR :
-            # input images are stored in a directory
-            imagesToConv = MT.filesInDir(self.__imageDir,"*.jpeg")
-        else :
-            # input images are in a list
-            imagesToConv =  self.__imageList
-        # copmute the number of frames to genarate = Number of images * nf of frame per image
-        nbFrames = len(imagesToConv)*self.__framesPerImage
-        self.__ppmtoy4m_opts['-n'] = str(nbFrames)      #update the numner of frames for  
-    
-        video_temp_base=os.path.join(self.__tmpDir,self.__VideoName)
-        # build  ppmtoy4m_cmd
-        ppmtoy4m_cmd = ""
-        for key,value in self.__ppmtoy4m_opts.items() :
-            mystring = " "+ key
-            if value : mystring = mystring + " "+value
-            ppmtoy4m_cmd = mystring + ppmtoy4m_cmd
-        ppmtoy4m_cmd = 'ppmtoy4m'+ppmtoy4m_cmd
-
-        # launch ppmtoy4m, this process run during all the image convesrion
-        # and receive in stdin images converted in ppm format 
-        # the ppm images are sent to this subprocess by the convert operation
-        # see p2 below 
-        fd5 = os.open(video_temp_base+".yuv",os.O_WRONLY|os.O_CREAT)
-        fd6 = os.open(video_temp_base+".log",os.O_WRONLY|os.O_CREAT)
-
-        ppm_proc = SP.Popen(ppmtoy4m_cmd, shell=True, stdin=SP.PIPE,stdout=fd5,stderr=fd6)
-        frame_cpt = 0
-        for (count_image,image) in enumerate(imagesToConv) :
-            # check abort 
-            if self.__abort == True : break
-            #loop on images to convert
-            #conversion and rezizing of cuurent image
-            imagePath = os.path.join(self.__imageDir,image)
-            montage_cmd = "montage  -type TrueColor -quality 100 -geometry 720x576  "+imagePath+ " " + video_temp_base+".jpg"
-            pMontage =SP.call(montage_cmd,shell=True)
-            convert_cmd = "convert -type TrueColor -quality 100 "+video_temp_base+".jpg " +video_temp_base+".pnm "
-            pconvert =SP.call(convert_cmd,shell=True)
-          
-            for i in range(self.__framesPerImage) :
-                # check abort 
-                if self.__abort == True : break
-                frame_cpt = frame_cpt +1
-                convert_cmd = "convert -depth 8 ppm:"+video_temp_base+".pnm -"
-                p1 = SP.Popen(convert_cmd,shell=True, stdout=ppm_proc.stdin,stderr=SP.PIPE)
-                p1.wait()
-            # progress bar update 
-            progression = ((count_image+1.0)/len(imagesToConv)) 
-            gobject.idle_add(self._on_progress,progression)
-        os.fsync(fd5)
-        os.close(fd5)
-        os.close(fd6) 
-        #return the path to yuv file
-        return video_temp_base+".yuv"
-  
-    def run(self) :
-        """ Thread start --> launch images to video conversion """
-        yuvfile_path = self._convertToYuv()
-        self.__queue.put(yuvfile_path)
-        gobject.idle_add(self._on_finish,yuvfile_path,self.__abort)
-
-
-
-class MyExportThread(threading.Thread):
-    """ Export Thread. Thread in charge to enconde video in Yuv format
-        to DV, DVD or XVID format
-    """
-  
-    def _get_abort(self): return self.__abort
-    def _set_abort(self, value): 
-        if value in (True,False) : self.__abort = value
-    abort = property(_get_abort, _set_abort, None, "abort thread work")
-  
-    def __init__(self, exportType, videoOutPath, yuv_queue, export_gui_obj) :
-        """ Init export video Thread"""
-        super(MyExportThread, self).__init__()
-        self.__abort = False
-        (self._exportType,self._videoInPath,self._videoOutPath) = (exportType,None,videoOutPath)
-        self.__queue = yuv_queue
-        self._export_gui_obj = export_gui_obj
-
-    def _on_finish(self,abort):
-        """Callback function. Raised when conversions is finished"""
-        # update gui progress bar
-        if abort == False : 
-            # Terminated normaly 
-            self._export_gui_obj.progress_bar_text = _("Export Done")
-            self._export_gui_obj.progress_bar_fraction = 1.0
-        else :
-            self._export_gui_obj.progress_bar_text = _("Export Canceled")
-            self._export_gui_obj.progress_bar_fraction = 0.0
-            self.__abort = False # reset abort
-        return False
-
-    def _on_progress(self, value):
-        """Callback function. used to know the conversion progress """
-        self._export_gui_obj.progress_bar_fraction = value
-        return False
-
-    def run(self):
-        """ Thread execution --> generate export """
-        """ Build and launch ffmpeg command. """
-        yuv_is_finished=False
-        data = None
-        while (yuv_is_finished == False) :
-            time.sleep(0.1)
-            try :
-                data=self.__queue.get(block=False)
-                yuv_is_finished=True
-            except Queue.Empty :
-                pass
-            # check abort if true leave it  
-            if self.__abort == True :
-                data = None
-                break
-        if data :
-            self._videoInPath = data
-            if self._exportType == EXPORT_DV :
-                self._ffmpeg_launcher()
-            else :
-                self._mencoder_launcher()   
-        gobject.idle_add(self._on_finish,self.__abort)
-
-    def _ffmpeg_launcher(self):
-        """ Video conversion with ffmpeg : only used for DV conversion """
-        self.__videoFormat = "PAL" # only PAL is supported 
-        self.__withSound = False        # no sound by default
-        if ( (self._exportType == EXPORT_DV)  and ( self._videoInPath ) and ( self._videoOutPath ) ) :
-            #
-            # Build ffmpeg command
-            #
-            ffmpeg_cmd = []
-            ffmpeg_cmd.append("ffmpeg")
-            # add input video name
-            ffmpeg_cmd.append('-i')
-            ffmpeg_cmd.append(self._videoInPath)
-            # add video conversion options
-            coding_command = dictEncoder["PAL"][EXPORT_DV]       
-            for ffmpeg_w in coding_command.split() : ffmpeg_cmd.append(ffmpeg_w)
-            # add output video name
-            ffmpeg_cmd.append(self._videoOutPath)
-            
-            #
-            # launch ffmpeg subprocess
-            #
-            print "[",self.__class__.__name__,"] ","command :", ffmpeg_cmd
-            sb_encoder =SP.Popen(ffmpeg_cmd,stdout=SP.PIPE,stderr=SP.PIPE)
-            
-            #
-            # check encoding process and finish
-            #
-            encode_not_finish = True
-            pulse_counter = 0
-            pulse_modulo = 20
-            while encode_not_finish == True:
-                ret_code = sb_encoder.poll()
-                if type(ret_code) == int :
-                    # encoding is finished when a code is returned
-                    encode_not_finish = False
-                if pulse_counter % pulse_modulo == 0 :
-                    # update progress bar only with pulses
-                    gobject.idle_add(self._on_progress, 2.0 )
-                pulse_counter = pulse_counter +1
-
-    def _mencoder_launcher(self) : 
-        """ Video conversion with mencoder : used for convestion in DVD and XVID format"""
-        self.__videoFormat = "PAL" # only PAL is supported
-        self.__withSound = False        # no sound by default
-        if ( (self._exportType in (EXPORT_DVD,EXPORT_XVID))  and ( self._videoInPath ) and ( self._videoOutPath ) ) :
-            #
-            # Build mencoder command
-            #
-            mencoder_cmd =[]
-            mencoder_cmd.append("mencoder")
-            # add export video options  
-            if self.__videoFormat == "PAL" :
-                coding_command = dictEncoder["PAL"][self._exportType]       
-                for mencoder_w in coding_command.split() : mencoder_cmd.append(mencoder_w)
-            #finally add the input and output :
-            mencoder_cmd.append(self._videoInPath)
-            mencoder_cmd.append('-o')
-            mencoder_cmd.append(self._videoOutPath)
-            
-            #
-            # launch mencoder command
-            #
-            print "[",self.__class__.__name__,"] ","command :", mencoder_cmd
-            sb_encoder =SP.Popen(mencoder_cmd,stdout=SP.PIPE,stderr=SP.PIPE)
-
-            #
-            # check encoding process and finish
-            #
-            encode_not_finish = True
-            res_value = 0
-            res_value_old = 0
-            while encode_not_finish == True:
-        
-                # First loop until child is finished
-                buffer = []
-                ret_code = sb_encoder.poll()
-                if type(ret_code) == int :
-                    encode_not_finish = False
-                while True:
-                    # second loop to detect a line
-                    # remark : I have no success to use readline or readlines
-                    # missing some characters
-        
-                    # mencoder display info on stdout, 
-                    # read one char to no be blocked until eof
-                    char = sb_encoder.stdout.readline(1)
-                    if not char : break
-                    else : 
-                        if char == '\r':
-                            aLine = string.join( buffer, '' )
-                            buffer = []
-                            break
-                        else:
-                            buffer.append(char)
-                #extact Frame num
-                #print aLine
-                #Exemple line : 
-                #Pos:  19.0s    475f (99%) 30.68fps Trem:   0min  65mb  A-V:0.000 [28800:0]
-                # regeexp for select percent value here : 99.
-                # value in parenthis ; with one or digits; select only the number 
-                pattern = re.compile("\(\s*([0-9]+)\%\)")
-                # get Match_object
-                # cf tuto : http://docs.python.org/howto/regex.html#regex-howto
-                re_res = pattern.search(aLine)
-                if re_res :
-                    # result is at first index of groups method
-                    # divide by 100 to have a value in range 0 .. 100
-                    res_value = re_res.groups()[0]
-                    if res_value != res_value_old :
-                        # if send message only when percentage value change
-                        # avoid sending unuseful message 
-                        gobject.idle_add(self._on_progress, float(res_value)/100.0 )
-                        res_value_old = res_value
-                        # check if abort requested 
-                        if self.__abort == True :
-                            pid = sb_encoder.pid
-                            os.kill(pid, signal.SIGTERM)
-                            time.sleep(1.0)
-                            # check if is process really dead
-                            if not isinstance(sb_encoder.poll(),int) :
-                                os.kill(pid,signal.SIGKILL)
-                            encode_not_finish = False
-            
-
-
-class luciole_export(object) :
-    """ Class in charge of managing exports. The class use threads for conversions"""
-
-    _exportType = (EXPORT_DV,EXPORT_DVD,EXPORT_XVID) 
-  
-    _suffixList =(".dv",".mpeg2",".avi")
-  
-    def _get_imageDir(self): return self.__imageDir
-    def _set_imageDir(self, value): self.__imageDir = value
-    def _del_imageDir(self): del self.__imageDir
-    imageDir = property(_get_imageDir, _set_imageDir, _del_imageDir, "Image's directory. ")
-
-    def _get_imageList(self): return self.__imageList
-    def _set_imageList(self, value): self.__imageList = value
-    def _del_imageList(self): del self.__imageList
-    imageList = property(_get_imageList, _set_imageList, _del_imageList, "Image's list to encode. This list should be sorted. images are encodede in list order. ")
-
-    def _get_imageInputType(self): return self.__imageInputType
-    def _set_imageInputType(self, value): 
-        if value in (IMAGE_LIST,IMAGE_DIR) :
-            self.__imageInputType = value
-        else :
-            print "[",self.__class__.__name__,"] ",value," not in correct type" 
-    def _del_imageInputType(self): del self.__imageInputType
-    imageInputType = property(_get_imageInputType, _set_imageInputType, _del_imageInputType, "Image's input type  ")
-
-    def _get_VideoName(self): return self.__VideoName
-    def _set_VideoName(self, value): self.__VideoName = value
-    def _del_VideoName(self): del self.__VideoName
-    VideoName = property(_get_VideoName, _set_VideoName, _del_VideoName, "Image's directory. ")
-
-    def _get_videoDir(self): return self.__videoDir
-    def _set_videoDir(self, value): self.__videoDir = value
-    def _del_videoDir(self): del self.__videoDir
-    videoDir = property(_get_videoDir, _set_videoDir, _del_videoDir, "Image's directory. ")
-
-    def _get_framesPerImage(self): return self.__framesPerImage
-    def _set_framesPerImage(self, value): self.__framesPerImage = value
-    def _del_framesPerImage(self): del self.__framesPerImage
-    framesPerImage = property(_get_framesPerImage, _set_framesPerImage, _del_framesPerImage, "Number of frames per image. ")
-
-    def _get_outputFPS(self): return self.__outputFPS
-    def _set_outputFPS(self, value): self.__outputFPS = value
-    def _del_outputFPS(self): del self.__outputFPS
-    outputFPS = property(_get_outputFPS, _set_outputFPS, _del_outputFPS, "Image's directory. ")
-
-    def _get_videoFormat(self): return self.__videoFormat
-    def _set_videoFormat(self, value): 
-        self.__videoFormat = value
-        #set values for PAL format
-        if self.__videoFormat == "PAL" :
-            self.__ppmtoy4m_opts['F'] = "-F 25:1"     # framerate - see man ppmtoy4m
-            self.__ppmtoy4m_opts['A'] = "-A 59:54"    # aspect ratio - see man ppmtoy4m 
-    def _del_videoFormat(self): del self.__videoFormat
-    videoFormat = property(_get_videoFormat, _set_videoFormat, _del_videoFormat, "Image's directory. ")
-
-    def _get_videoType(self): return self.__videoType
-    def _set_videoType(self, value): self.__videoType = value
-    def _del_videoType(self): del self.__videoType
-    videoType = property(_get_videoType, _set_videoType, _del_videoType, "Image's directory. ")
-
-    def _get_videoAspect(self): return self.__videoAspect
-    def _set_videoAspect(self, value): self.__videoAspect = value
-    def _del_videoAspect(self): del self.__videoAspect
-    videoAspect = property(_get_videoAspect, _set_videoAspect, _del_videoAspect, "Image's directory. ")
-
-    def _get_withSound(self): return self.__withSound
-    def _set_withSound(self, value): self.__withSound = value
-    def _del_withSound(self): del self.__withSound
-    withSound = property(_get_withSound, _set_withSound, _del_withSound, "Image's directory. ")
-  
-    def _get_export_on_progress(self):
-        """ export status is knowed by the status of the last expôpt thread """
-        if self._t_encoder  and self._t_encoder.isAlive() == True :
-            self._export_on_progress = True
-        else :
-            self._export_on_progress = False
-        return self._export_on_progress
-    export_on_progress = property(_get_export_on_progress, None, None, "export status")
-
-
-
-    def __init__(self,tmp_dir, export_gui_obj):
-        """Init of class"""
-        self.__tmpDir = os.path.join(tmp_dir,"export") 
-        self._cleanTmpDir()
-    
-        self.__imageList = list() # input image list
-        self.__imageInputType = IMAGE_LIST    # image type input is imageList by default
-
-        self.__VideoName = "export"
-        self.__outputFPS = "25"
-        self.__videoFormat = "PAL"
-        self.__videoType = "DV"
-        self.__videoAspect ="4/3"
-
-        # set ppmtoy4m options
-        self.__ppmtoy4m_opts=dict()
-        self.__ppmtoy4m_opts['-F'] = "25:1"      # framerate - see man ppmtoy4m
-        self.__ppmtoy4m_opts['-A'] = "59:54"     # aspectRatio - see man ppmtoy4m
-        self.__ppmtoy4m_opts['-S'] = "420mpeg2"  # subsamplimg chroma mode  - see man ppmtoy4m
-        self.__ppmtoy4m_opts['-I'] = "p"         # interlacing mode,progressive, non-interlaced  - see man ppmtoy4m
-        self.__ppmtoy4m_opts['-n'] = "0"       # total output frames  - see man ppmtoy4m
-        self.__ppmtoy4m_opts['-v'] = "2"       # verbosity  - see man ppmtoy4m
- 
-        self.__framesPerImage=10           # default value for frame Per image
-    
-        self.__withSound = False        # no sound by default
-    
-        self._export_on_progress = False   # export progression
-        self._t_yuv = None
-        self._t_encoder = None
-        self._videopath = None
-        self.__imageDir = None
-        if self.__videoFormat == "PAL":
-            self.__videoRes=(720,576)
-        # export gui obj    
-        self._export_gui_obj = export_gui_obj
-
-
-  
-    def export(self, export_data ,forceExport=False) :
-        """ Export function 
-            exportData is a dict with the following items :
-            'image_input' = type of image put list or dir (IMAGE_LIST,IMAGE_DIR)
-            'image_list' = List of image to convert, each element is an absolute path yo the image
-                or
-            'image_dir' = dir with all the images to impot : Not implemented
-            'export_dir' = the directory where the video will be exported
-            'video_name' = the export video name wihout extension
-            'export_type' = the type of export (EXPORT_DV,EXPORT_DVD,EXPORT_XVID)
-            'fpi' = the frame rate
-            """
-
-        
-        (VideoExsists,videopath) = self._IsVideoExists(export_data)
-        if (    ( VideoExsists == False) or (forceExport == True) 
-                and 
-                ( videopath != None ) ) : 
-            # check tmp dir is clean
-            self._cleanTmpDir()
-            self._export_on_progress = True
-
-            # initiate queue for comunication between yuv converter and export converter
-            self._dataQueue=Queue.Queue()
-            self._ResQueue=Queue.Queue()
-
-            #
-            # Check input parameters
-            #
-            print " DEBUG : export - ",export_data
-            export_is_valid = False
-            if export_data.has_key('image_input') :
-                self.__imageInputType = export_data['image_input']
-                export_is_valid = True
-
-            # check type of input validity
-            if( 
-                    (export_is_valid == True ) 
-                and 
-                    ( 
-                    (
-                    export_data.has_key('image_list') 
-                    and
-                    export_data['image_input'] == IMAGE_LIST
-                    )
-                or 
-                    (
-                    export_data.has_key('image_dir') 
-                    and
-                    ( export_data['image_input'] == IMAGE_DIR )
-            ) )) :
-                
-                if export_data.has_key('image_list') : self.__imageList = export_data['image_list']
-                if export_data.has_key('image_dir') : self.__imageList = export_data['image_dir']
-                export_is_valid = True
-            else :
-                export_is_valid = False
-
-            if  (export_is_valid == True) and (export_data.has_key('fpi')) :
-                self.__framesPerImage = int(export_data['fpi'])
-                export_is_valid = True
-            else :
-                export_is_valid = False
-
-            if  (export_is_valid == True) and (export_data.has_key('video_name')) :
-                self.__VideoName = export_data['video_name']
-                export_is_valid = True
-            else :
-                export_is_valid = False
-
-            if (export_is_valid == True) and os.path.exists(videopath) :
-                try :
-                    os.remove(videopath) 
-                except OSError,err :
-                    print _('Unable to erase'),err.filename
-                    print err.strerror
-                    videopath = None  
-                    export_is_valid = False 
-
-
-            if export_is_valid == True :
-                # start yuv converter sub process
-                self._t_yuv = MyThreadConvertToYuv(self.__imageInputType,self.__imageDir,self.__imageList,self.__ppmtoy4m_opts,self.__framesPerImage,self.__tmpDir,self.__VideoName,self._dataQueue, self._export_gui_obj)
-                self._t_yuv.start()
-                # start video export encoder subprocess
-                self._videopath = videopath
-                self._t_encoder = MyExportThread(export_data['export_type'], self._videopath, self._dataQueue, self._export_gui_obj)
-                self._t_encoder.start()
-            else :
-                return (0,videopath)
-    
-        if ( VideoExsists == True ) :
-            return (ERR_FILE_EXIST,videopath)
-        else :
-            return (0,videopath)
-
-    def cancel_export(self):
-        """ Cancel export """
-        if self._export_on_progress == True :
-            # kill the eport Threads
-            if self._t_yuv.isAlive() : self._t_yuv.abort= True 
-            if self._t_encoder.isAlive() : self._t_encoder.abort= True 
-            #check if process remains 
-            while ( self._t_yuv.isAlive() or self._t_encoder.isAlive() ) : 
-                time.sleep(0.1)
-            # clean temporary files  
-            self._cleanTmpDir()
-            try :
-                os.remove(self._videopath ) 
-                print self._videopath ," is removed"
-            except OSError,err :
-                print "Impossible d effacer ",err.filename
-                print err.strerror
- 
-
-
-    ################################################################################ 
-    # private methods
-    ################################################################################ 
-    def _cleanTmpDir(self) :
-        """ Clean or create  tmp dir if needed"""
-        if not os.path.exists(self.__tmpDir) :
-            #create it
-            try :
-                os.makedirs(self.__tmpDir)
-            except OSError,err :
-                print "Impossible de creer le repertoire export"
-                print err.strerror
-                self.__tmpDir = "/tmp"
-        else :
-            # directory exist, clean it
-            list = dircache.listdir( self.__tmpDir)
-            for file in list :
-                filePath = os.path.join(self.__tmpDir,file)
-                try :
-                    os.remove(filePath) 
-                    print filePath ," is removed"
-                except OSError,err :
-                    print "Impossible d effacer ",err.filename
-                    print err.strerror
-     
-    def _IsVideoExists(self,export_data):
-        """ test if a video path exists """
-        exists = False
-        video_path = None
-        # check export type 
-        if export_data.has_key('export_type') and export_data['export_type'] in self._exportType :
-            suffix = self._suffixList[export_data['export_type']]
-            # check export video name
-            if export_data.has_key('video_name') :
-                video_name = export_data['video_name']+suffix
-                
-                # check export dir 
-                if not os.path.exists(export_data['export_dir']) :
-                    #create it
-                    try :
-                        MT.mkdirs(export_data['export_dir'])
-                    except LEXCEP.LucioException , err :
-                        # to robustify : Error handling
-                        print err
-                        return (exists, video_path)
-                video_path = os.path.join(export_data['export_dir'], video_name)
-                
-                # check if video path exists
-                if os.path.exists(video_path) : 
-                    exists = True
-        return (exists,video_path)
-
-
-

=== removed file 'lucioLib/lucioExport/luciole_export_tool.py'
--- lucioLib/lucioExport/luciole_export_tool.py	2009-12-03 08:11:32 +0000
+++ lucioLib/lucioExport/luciole_export_tool.py	1970-01-01 00:00:00 +0000
@@ -1,281 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-# -*- Mode: Python -*-
-# vi:si:ai:et:sw=4:sts=4:ts=4
-#
-#
-# Copyright Nicolas Bertrand ([e-mail]), 2009
-#
-# This file is part of Luciole.
-#
-#    Luciole is free software: you can redistribute it and/or modify
-#    it under the terms of the GNU General Public License as published by
-#    the Free Software Foundation, either version 3 of the License, or
-#    (at your option) any later version.
-#
-#    Luciole is distributed in the hope that it will be useful,
-#    but WITHOUT ANY WARRANTY; without even the implied warranty of
-#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#    GNU General Public License for more details.
-#
-#    You should have received a copy of the GNU General Public License
-#    along with Luciole.  If not, see <http://www.gnu.org/licenses/>.
-#
-#
-
-# for i18n
-from gettext import gettext as _
-
-import os.path
-from .. import luciole_et as LE
-
-from .. import luciole_exceptions as LEXCEP
-from .. import luciole_project as LPROJECT 
-class luciole_export_tool(object) :
-    """
-    :version:
-    :author:
-    """
-    
-    
-    """
-    ATTRIBUTES
-    export_file         : Path to file to export
-    template            : Path to template
-    lcl_project         : The luciole project a file or a dict
-    _lcl_project_data   : 
-    _export_template    : File to update with export data
-    _template_xml       : 
-    """
-    
-
-
-    def __init__(self,  lcl_project = "./luciole_project.xml", template="./template.xml", export_file = "./export.xml"):
-        """
-        @param lcl_project      : Type de projet 
-        @param template         : Path to template
-        @param export_file      : Path to export_file
-        """
-        #
-        # Atributes init
-        #
-        self.lcl_project = lcl_project
-        self.template = template
-        self.export_file = export_file
-        self._lcl_project_data = {}
-        self._lcl_project_data['resources_images'] = []
-        self._lcl_project_data['timelines_images'] = []
-
-        self._export_template = None
-        self._template_xml = None
-        
-        if (type(lcl_project) == str) : 
-            # test file type
-            if os.path.exists(lcl_project) :
-                #filetype exits load it
-                self.__load_lcl_file()
-            else :
-                #Raise Error
-                excep_message = "%s is ot a file",lcl_project
-                raise LEXCEP.LucioException,excep_message            
-        elif (type(lcl_project) == LPROJECT.project_dico) :
-            # input is a dictionary
-            self.__load_lcl_dict()
-        else :
-            # template does not exists : raise an exception
-            excep_message = "Invalid projetc type nor file nor luciole_project"
-            raise LEXCEP.LucioException,excep_message            
-        
-        #
-        # Test template
-        #
-        if os.path.exists(self.template) :
-            self._load_template()
-        else :
-            # template does not exists : raise an exception
-            excep_message = " Template file %s does not exist"%self.template
-            raise LEXCEP.LucioException,excep_message            
-
-            
-
-
-    def generate(self):
-        """
-         
-
-        @return  :
-        @author
-        """
-        self._gen_ressources()
-        self._gen_timeline()
-        self.__write_export_file()
-
-    def _load_template(self):
-        """
-         
-
-        @return  :
-        @author
-        """
-        pass
-
-    def _gen_ressources(self):
-        """
-         generate date for resources
-
-        @return  :
-        @author
-        """
-        pass
-
-    def _gen_timeline(self):
-        """
-         Generate data for timeline
-
-        @return  :
-        @author
-        """
-        pass
-
-    def __load_lcl_file(self):
-        """
-         Load a Luciole project from a file dictionary
-
-        @return  :
-        @author
-        """
-        try :
-            _lcl_project_xml = LE.lcl_et(self.lcl_project)
-        except :
-            pass
-        else :
-            self._lcl_project_data['image_path'] = os.path.join(_lcl_project_xml.findtext("metas/projectPath").strip() , 
-                                                        _lcl_project_xml.findtext("metas/rush_dir").strip() )
-            self._lcl_project_data['fpi'] = int(_lcl_project_xml.findtext("metas/fpi").strip())
-            
-            # get resources images from project capture data
-            list_image = _lcl_project_xml.find("captureData").getiterator('image')
-            [ self._lcl_project_data['resources_images'].append(image.text.strip())  for image in list_image]
-            
-            # get timelines images from project chrono data
-            list_image = _lcl_project_xml.find("chronoData").getiterator('image')
-            [self._lcl_project_data['timelines_images'].append(image.text.strip())  for image in list_image]
-            
-
-    def __load_lcl_dict(self):
-        """
-         Load a Luciole project from a dictionary
-
-        @return  :
-        @author
-        """
-        
-        self._lcl_project_data['image_path'] = os.path.join(self.lcl_project['project_dir'], self.lcl_project['rush_dir'])
-        self._lcl_project_data['fpi'] = int(self.lcl_project['fpi'])
-        self._lcl_project_data['resources_images'] = self.lcl_project['capture_images']
-        self._lcl_project_data['timelines_images'] = self.lcl_project['chrono_images']
-
-
-    def __write_export_file(self):
-        """
-         
-
-        @return  :
-        @author
-        """
-        self._template_xml.write(self.export_file)
-
-class luciole_export_tool_cinelerra (luciole_export_tool):
-
-    """
-     
-
-    :version:
-    :author:
-    """
-
-    """ ATTRIBUTES
-
-     
-
-    _export_template  (private)
-
-    """
-
-    def __init__(self,  lcl_project = "./luciole_project.xml", template="./template.xml", export_file = "./export.xml"):
-        """
-         
-
-        @param luciole_export_tool lcl_project_type : type of luciole project : "file" or "project"
-        @param object lcl_project : Type de projet
-        @param string template : Path to template
-        @param string export_file : Path to export_file
-        @return  :
-        @author
-        """
-        super(luciole_export_tool_cinelerra, self).__init__(lcl_project,template,export_file )
-
-    def _load_template(self):
-        """
-        """
-        self._template_xml = LE.lcl_et(self.template)
-        
-
-    def _gen_ressources(self):
-        """
-        ressource is called asset in cinelerra template 
-        """
-        resources_tag = self._template_xml.find("//ASSETS")
-        resource_elem_tpl =  self._template_xml.find("//ASSET")
-
-        for image in self._lcl_project_data['resources_images'] :
-            # build image_path 
-            image_p = os.path.join(self._lcl_project_data['image_path'], image)
-            # create a resouce element --> i.e an ASSET element
-            new_element = self._template_xml.SubElement(resources_tag,"ASSET",{"SRC":image_p})
-            # copy subelement od ASSET template tag in new element
-            for elem_tpl in resource_elem_tpl.getchildren() :
-                new_element.append(elem_tpl)
-        
-        #remove template tag
-        resources_tag.remove(resource_elem_tpl)
-            
-    
-    def __get_timeline_tags(self) :
-        """
-           in cinelerra timeline tags is TRACK with type video, and EDITS/EDIT tag
-        """
-        video_track = None
-        tracks = self._template_xml.findall("//TRACK")
-        for track in tracks :
-            if track.get("TYPE") == "VIDEO" :
-                # video tak is found
-                video_track = track
-                break
-        # get EDIT tag
-        return ( video_track.find("EDITS"), video_track.find("EDITS/EDIT"))
-
-
-    def _gen_timeline(self):
-        """
-        generate timeline 
-        """
-        (timeline_tag, timeline_item_tpl) = self.__get_timeline_tags()
-        for image in self._lcl_project_data['timelines_images'] :
-            # build image_path 
-            image_p = os.path.join(self._lcl_project_data['image_path'], image)
-            
-            # create New EDIT element per image 
-            for frame in range(self._lcl_project_data['fpi']):
-                framerate = str(self._lcl_project_data['fpi'])
-                new_element = self._template_xml.SubElement(timeline_tag,"EDIT",{"STARTSOURCE":"0","CHANNEL":"0", "LENGTH":"1"})
-                # create FILE subElement of EDIT
-                self._template_xml.SubElement(new_element,"FILE",{"SRC":image_p})
-        
-        # remove EDIT template tag 
-        timeline_tag.remove(timeline_item_tpl)
-
-if __name__ == '__main__' :
-    X = luciole_export_tool_cinelerra( lcl_project = "/home/nico/temp/testLuciole/luciole_project_isight/luciole_project_isight.xml",template="./cinelerra_template.xml",export_file = "./cine_export.xml" ) 
-    X.generate()
-    

=== modified file 'lucioLib/luciole_et.py'
--- lucioLib/luciole_et.py	2010-01-04 17:42:18 +0000
+++ lucioLib/luciole_et.py	2010-01-04 17:42:19 +0000
@@ -64,12 +64,21 @@
     def findall(self,match) :
         return self.xml_obj.findall(match)
 
+    def Element(self, tag) :
+        return ET.Element(tag)
+
     def SubElement(self,parent,tag,attrib={}) :
         return ET.SubElement(parent,tag,attrib)
 
+    def insert(self,index,element) :
+        return self.xml_obj.insert(index,element)
+
     def tostring(self,element) :
         return ET.tostring(element)
 
+    def getroot(self) :
+        return self.xml_obj.getroot()
+
     def write(self,file) :
         indent(self.xml_obj.getroot())
         return self.xml_obj.write(file,"UTF-8")

=== added file 'templates/kdenlive_template.kdenlive'
--- templates/kdenlive_template.kdenlive	1970-01-01 00:00:00 +0000
+++ templates/kdenlive_template.kdenlive	2010-01-04 17:42:19 +0000
@@ -0,0 +1,46 @@
+<?xml version='1.0' encoding='utf-8'?>
+<mlt title="Anonymous Submission" root="" >
+ <producer in="0" out="14999" id="black" >
+  <property name="mlt_type" >producer</property>
+  <property name="aspect_ratio" >0.000000</property>
+  <property name="length" >15000</property>
+  <property name="eof" >pause</property>
+  <property name="resource" >black</property>
+  <property name="mlt_service" >colour</property>
+ </producer>
+ <!-- update out value with total duration -->
+ <playlist id="black_track" >
+  <entry in="0" out="" producer="black" />
+ </playlist>
+ <playlist id="playlist1" />
+ <playlist id="playlist2" />
+ <!-- generate producer tags here -->
+ 
+ <playlist id="lcl_track" >
+	 <!-- generate entry tags here -->
+ </playlist>
+
+ <!-- modify "out" value with number of frame in project -->
+ <tractor title="Anonymous Submission" global_feed="1" in="0" out="2" id="maintractor" >
+  <track producer="black_track" />
+  <track hide="video" producer="playlist1" />
+  <track hide="video" producer="playlist2" />
+  <track producer="lcl_track" />
+  </tractor>
+  <!-- Update projectfolder tag with kdenlivepath -->
+ <kdenlivedoc profile="dv_pal" kdenliveversion="0.7.5" version="0.84" projectfolder="" >
+  <documentproperties zonein="0" zoneout="100" zoom="1" verticalzoom="1" position="0" />
+  <profileinfo width="720" display_aspect_den="3" frame_rate_den="1" description="DV/DVD PAL" height="576" frame_rate_num="25" display_aspect_num="4" progressive="0" sample_aspect_num="16" sample_aspect_den="15" />
+  <tracksinfo>
+   <trackinfo blind="1" mute="0" locked="0" type="audio" />
+   <trackinfo blind="1" mute="0" locked="0" type="audio" />
+   <trackinfo blind="0" mute="0" locked="0" />
+  </tracksinfo>
+  <!--  generate kdenlive_producer tag example : 
+	  <kdenlive_producer audio_max="0" channels="0" duration="10" default_audio="0" video_max="0" frame_size="720x576" frequency="0" in="0" file_size="46448" aspect_ratio="1.000000" out="10" file_hash="fc820ac310b557ad08df64a52a06e635" type="5" id="1" name="rush_00000.jpeg" default_video="0" resource="/home/nico/temp/testLuciole/luciole_project_isight/rush/rush_00000.jpeg" />
+ -->
+ 
+  <markers/>
+  <groups/>
+ </kdenlivedoc>
+</mlt>

=== modified file 'ui/export_file.glade'
--- ui/export_file.glade	2009-12-03 08:11:32 +0000
+++ ui/export_file.glade	2010-01-04 17:42:19 +0000
@@ -4,11 +4,13 @@
   <!-- interface-naming-policy project-wide -->
   <object class="GtkDialog" id="dialog_export_file">
     <property name="border_width">5</property>
+    <property name="title" translatable="yes">Tool Exporter</property>
+    <property name="icon">../images/luciole.png</property>
+    <property name="icon_name">luciole</property>
     <property name="type_hint">normal</property>
     <property name="has_separator">False</property>
     <signal name="destroy" handler="on_dialog_export_file_destroy"/>
     <signal name="close" handler="on_dialog_export_file_close"/>
-    <signal name="response" handler="on_dialog_export_file_response"/>
     <child internal-child="vbox">
       <object class="GtkVBox" id="dialog-vbox1">
         <property name="visible">True</property>
@@ -48,6 +50,7 @@
                     <property name="visible">True</property>
                     <property name="can_focus">True</property>
                     <property name="receives_default">False</property>
+                    <property name="tooltip_text" translatable="yes">Export to cinelerra</property>
                     <property name="active">True</property>
                     <property name="draw_indicator">True</property>
                     <signal name="toggled" handler="on_radio_cine_toggled"/>
@@ -59,6 +62,7 @@
                     <property name="visible">True</property>
                     <property name="can_focus">True</property>
                     <property name="receives_default">False</property>
+                    <property name="tooltip_text" translatable="yes">Export to Kdenlive</property>
                     <property name="draw_indicator">True</property>
                     <property name="group">radio_cine</property>
                     <signal name="toggled" handler="on_radio_kdenlive_toggled"/>
@@ -74,6 +78,7 @@
                     <property name="visible">True</property>
                     <property name="can_focus">True</property>
                     <property name="receives_default">False</property>
+                    <property name="tooltip_text" translatable="yes">Export to pitivi</property>
                     <property name="draw_indicator">True</property>
                     <property name="group">radio_cine</property>
                     <signal name="toggled" handler="on_radio_pitivi_toggled"/>
@@ -87,8 +92,11 @@
                   <object class="GtkRadioButton" id="radio_openshot">
                     <property name="label" translatable="yes">Openshot</property>
                     <property name="visible">True</property>
-                    <property name="can_focus">True</property>
+                    <property name="sensitive">False</property>
+                    <property name="can_focus">False</property>
                     <property name="receives_default">False</property>
+                    <property name="tooltip_text" translatable="yes">Coming soon</property>
+                    <property name="inconsistent">True</property>
                     <property name="draw_indicator">True</property>
                     <property name="group">radio_cine</property>
                     <signal name="toggled" handler="on_radio_openshot_toggled"/>