Merge lp:~nico-inattendu/luciole/luciole-with-sound into lp:luciole

[NicoInattendu]

Finally a merge of luciole with sound !
New features :
- Sound track can be added. Only wav files accepted
- Timeline management with Pitivi. implies huge changes of luciole
- Webcam detection improved. No more use of HAL replaced by udev
- Webcam definition / framerates / videotypes can now be selected
- Acquisition can now be made in full webcam definition or PAL definition

Know problems :
- Mixer features does not work
- Acqusisition from DV cam should be implemented ( urgent ! ). try with udev ?
- Only export to file is implemented with sound
- assistant page webcam when back/ rewind action the cam detection appears twice ...
- i18n with gettext to improve
- code cleaning needed (remove unused files and classes)
- GUI tuning needed : in particular the aspect ratio of viewer window
- Problems of display when no acquisition is set ( digicam mode)

For packaging :
- need to include all Pitivi files
- review files to include
- review files for i18n
- add-dependency to python-udev , and check gstreamer package depdendencies ( bad-plugins, etc ...)

=== added file 'Examples_launch.txt'
--- Examples_launch.txt	1970-01-01 00:00:00 +0000
+++ Examples_launch.txt	2011-02-28 13:21:06 +0000
@@ -0,0 +1,5 @@
+PITIVI_DEBUG=2,*action*:4,*ctrlp*:4 bin/luciole
+
+PITIVI_DEBUG=2,*webcam*:4,*tester:4* PYTHONPATH=".:$PYTHONPATH" python test/test_project_etree.py 
+
+

=== added file 'WebcamProps.py'
--- WebcamProps.py	1970-01-01 00:00:00 +0000
+++ WebcamProps.py	2011-02-28 13:21:06 +0000
@@ -0,0 +1,390 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# -*- Mode: Python -*-
+# vim:si:ai:et:sw=4:sts=4:ts=4
+
+import gst
+
+from pitivi.log.loggable import Loggable
+from pitivi.signalinterface import Signallable
+
+from luciole.media.lgst.webcam_caps import WebcamCaps
+
+class WebcamProps(Loggable, Signallable):
+    
+    __signals__ = {
+            'caps-selected' : ['caps'],
+            }
+
+    BEST_RATIO = (720.0/576.0) 
+    BEST_VIDEOTYPES = ['video/x-raw-yuv', 'video/x-raw-rgb']
+    BEST_YUV_FORMATS = [gst.Fourcc('I420'), gst.Fourcc('YUY2')]
+    
+    VIDEOTYPE_PROPS = [
+            'red_mask', 
+            'blue_mask',
+            'green_mask',
+            'bpp', 
+            'depth',
+            'format'
+            ]
+        
+
+    FIELDS_TYPE = {
+            'width' : 'int' , 
+            'height' : 'int' , 
+            'framerate' : 'fraction' ,
+            'definition' : 'definition',       
+            'videotype' : 'videotype',
+            'red_mask' : 'int' , 
+            'blue_mask' : 'int' ,
+            'green_mask'  : 'int' ,
+            'bpp' :'int', 
+            'depth' :'int',
+            'format': 'fourcc',
+            }
+    
+    
+    
+    def __init__(self, widget) :
+        Loggable.__init__(self)
+        Signallable.__init__(self)
+
+        self.widget = widget
+        self._filter_caps = gst.caps_new_any()
+        self._webcam_caps = gst.caps_new_any()
+        self._selected_props = {}
+        self._selected_videotype = ""
+        
+        self.PROPS_WITH_BEST_VALUE = {
+            'format' : self.get_best_yuv_format,
+            'definition' : self.get_best_definition,
+            'videotype' : self.get_best_videotype,
+            }
+        
+        self._active_videotype_props = []
+        self._active_common_props = []
+
+
+    def prepare(self, caps) :
+        # store caps for webcam        
+        self._webcam_caps = WebcamCaps(caps)
+       
+
+        self.widget.connect('prop-changed', self._prop_changed_cb)
+        
+        # first show definition
+        self.manage_prop('definition', None)
+        
+        
+
+    def get_best_value(self, prop, prop_values) :
+        _best = None        
+        if prop in self.PROPS_WITH_BEST_VALUE :
+            _best = self.PROPS_WITH_BEST_VALUE[prop](prop_values) 
+        else :
+            _best = prop_values[0] 
+            self.info('No best value algorithm for %s. Fist value taken %s',
+                prop,  _best)
+        return _best
+        
+    def get_best_definition(self, definitions) :
+        """ algorithms who search first for best ratios,
+            then for higher width        
+        """
+        _def_dict = {}
+        # Write algotithm 
+        _def_dict['width'] = definitions[-1]['width']
+        _def_dict['height'] = definitions[-1]['height']
+        return _def_dict                    
+    
+    def get_best_videotype(self, videotypes) :
+        """ parse  BEST_VIDEOTYPES list in preference order.
+            if videotype not in BEST_VIDEOTYPES return the first 
+            videotype in input list
+         """       
+        _best_vtype = None        
+        for _vtype in self.BEST_VIDEOTYPES :
+            if _vtype in videotypes :
+                _best_vtype = _vtype
+                break
+        if _best_vtype == None :
+            _best_vtype = videotypes[0]
+            self.warning( ("No best video type founds. selelcted %s."
+                         "First in list") ) \
+                        % _best_vtype
+        return _best_vtype  
+    
+    def get_best_yuv_format(self, yuv_formats) :
+        """ parse  BEST_YUV_FORMAT list in preference order.
+            if videotype not in BEST_YUV_FORMAT return the first 
+            videotype in input list
+         """       
+        _best  = None        
+        self.debug('avlb values : "%s', yuv_formats)
+        for _format in self.BEST_YUV_FORMATS :
+            if _format in yuv_formats :
+                _best  = _format
+                break
+        if _best == None :
+            _best = yuv_formats[0]
+            print _best
+            self.warning("No best yuv format found. selelcted %s. First in list", _best)
+        self.debug("Best yuv fomat is %s",_best )
+        return _best    
+    
+    def get_best_framerate(self, framerates) :
+        """ take a framerate on the middle. 
+            Not too high, not too low
+        """
+        _len = len(framerates)
+        _best = _len/2
+        return _best
+              
+    
+        
+    def _prop2str_single(self, name, value) :
+        _prop_str = ""
+        if self.FIELDS_TYPE[name] == 'fourcc' :
+            _prop_str = "%s" % value.fourcc
+        elif self.FIELDS_TYPE[name] == 'fraction' :
+            _prop_str = "%s/%s" % (value.num, value.denom)
+        elif self.FIELDS_TYPE[name] == 'definition' :
+            _prop_str = "%sx%s" % (value['width'], value['height'])
+        else :
+            _prop_str = "%s" % (value)
+        return _prop_str
+
+    def _prop2str(self, prop_name, values) :
+        _prop_out = None
+        if isinstance(values, list) :
+            _prop_out = [ self._prop2str_single(prop_name, _val) \
+                        for _val in values ]
+        else :
+            _prop_out =  self._prop2str_single(prop_name, values)
+        return _prop_out
+
+        return _prop_out
+
+
+    def _str2def(self, string) :      
+        if string is not None : 
+            _list = string.split('x')
+            _def_dict = {
+                'width' : _list[0],
+                'height' : _list[1]
+                }
+            return _def_dict
+        else :
+            self.error('Impossible to understand/interpret %s'%string)
+            return None
+        
+    
+    def set_prop_widget(self, prop, prop_values , active_value, wdg_type = 'combo' ) :
+        self.widget.set_prop(prop, prop_values , wdg_type  )
+        
+        # TODO : manage signal connect        
+        
+        self.debug("Active value for %s is %s", prop, active_value)        
+        self.widget.set_active_prop(prop, active_value)    
+        
+    def set_framerates_widget(self, framerates, best_framerate ) :
+        pass
+
+    
+    def _prop_changed_cb(self, widget, prop, value) :
+        if prop == 'definition' :
+            self._definition_changed_cb(value)
+        elif prop == 'videotype' :
+            self._videotype_changed_cb(value)
+        elif prop  == 'framerate' :
+            self._framerate_changed_cb(value)
+        elif prop in self.VIDEOTYPE_PROPS :
+            self._videotype_prop_changed_cb(prop, value)
+
+            
+
+
+    def _definition_changed_cb(self, str_definition) : 
+        """ definition changed cb :
+            _ store definition
+            _ look  videotype
+             
+        """  
+        _selected_def = self._str2def(str_definition)
+        self._selected_props.update(_selected_def)
+                
+        self._filter_caps = \
+            self._webcam_caps.get_caps_from_definition( _selected_def)
+        
+        # when defintion changed clear videotype ( if exists)
+        self._clear_videotype()
+        self._clear_framerate()
+
+        #now look for videotypes
+        self.manage_prop('videotype', self._filter_caps)
+
+    def _videotype_changed_cb(self, videotype) :
+        self._selected_videotype =  videotype
+        self.debug("RX videotype-changed : %s", self._selected_videotype)
+        
+        _caps = self._make_caps(self._selected_videotype, self._selected_props)
+        self._filter_caps = self._webcam_caps.intersect(_caps)
+        _size = self._filter_caps.get_size()         
+        self.debug(" %s selected caps :%s",
+                _size,
+                self._filter_caps ,
+                )
+        if _size == 0 :
+            self.error("No caps found for tpl %s ", _caps)
+            return
+        self._clear_videotype_props()
+        self._clear_framerate()
+        if _size == 1 :
+            # no more selection of props needed
+            # request for available framerates according definition
+            _is_single = self.manage_prop('framerate', self._filter_caps)
+            if _is_single == True :
+                self._check_single_caps(self._filter_caps)
+   
+
+        else :
+            # more than one struct in caps
+            if self._selected_videotype == 'video/x-raw-yuv' :
+                self.manage_prop('format', self._filter_caps)
+            
+            if self._selected_videotype == 'video/x-raw-rgb' :
+                self.manage_prop('red_mask', self._filter_caps)
+        
+    def _videotype_prop_changed_cb(self, prop, value) :
+        
+        self.debug("RX prop %s changed = %s", prop, value)
+        self._selected_props[prop] = value
+        
+        self._clear_framerate()
+        
+        _caps = self._make_caps(self._selected_videotype, self._selected_props)
+        self._filter_caps = self._webcam_caps.intersect(_caps)
+        
+        _size = self._filter_caps.get_size()         
+        self.debug(" %s selected caps :%s",
+                _size,
+                self._filter_caps ,
+                )
+        
+        
+        if _size == 0 :
+            self.error("No caps found for tpl %s ", _caps)
+            return
+        if _size > 1 :
+            self.warning(" Now what we do ???. What prop to select ? take the fitst_srtuct")
+            _single_caps = gst.Caps(self._filter_caps[0])
+            self._filter_caps = _single_caps
+
+        # no more selection of props needed
+        # request for available framerates according definition
+        _is_single = self.manage_prop('framerate', self._filter_caps)
+        if _is_single == True :
+            self._check_single_caps(self._filter_caps)
+   
+
+    def _framerate_changed_cb(self, value) :
+        self.debug("RX framerate changed = %s (%s)", value, type(value))
+        if isinstance(value, float) : 
+            value = gst.Fraction(value)
+            value = "%s/%s"%(int(value.num), int(value.denom))
+            print value 
+        self._selected_props['framerate'] = value
+
+        _caps = self._make_caps(self._selected_videotype, self._selected_props)
+        self._filter_caps = self._webcam_caps.intersect(_caps)
+        
+        self._filter_caps.get_size()         
+        self.debug(" %s selected caps :%s",
+                self._filter_caps.get_size(),
+                self._filter_caps ,
+                )
+        # check if a single caps is set
+        self._check_single_caps(self._filter_caps)
+    
+
+    def _check_single_caps(self, caps) :
+        if caps.get_size() == 1 \
+                and\
+                caps.is_fixed() == True :
+            self.debug("Hourra ! . caps %s can be applied to webcam", caps )
+            self.emit('caps-selected', caps)  
+
+
+
+    def manage_prop(self, prop_name, caps) :
+        """ generic manage of a prop """
+        _is_single_value = False  
+        is_range, _prop_values = \
+            self._webcam_caps.get_prop_values(prop_name , caps)
+        self.debug("%s = %s",prop_name, _prop_values)
+        if len(_prop_values) > 1 or is_range == True :
+            if is_range == False : 
+                _best  = self.get_best_value(prop_name, _prop_values)
+                _prop_values = self._prop2str(prop_name, _prop_values)
+                _best = self._prop2str(prop_name, _best)
+                self.set_prop_widget(prop_name, _prop_values , _best)
+            else :
+                _best = _prop_values[0]
+                self.set_prop_widget(prop_name, _prop_values , _best, 'range')
+
+        else :
+            self.info("Only one value %s for %s",_prop_values,prop_name )
+            _is_single_value = True  
+        if prop_name in self.VIDEOTYPE_PROPS and _is_single_value == False :
+            self._active_videotype_props.append(prop_name)
+
+        return _is_single_value
+
+    
+    def _clear_videotype(self) :
+        self._clear_videotype_props()
+        _prop = 'videotype'
+        if self._selected_videotype != "" :
+            self.widget.remove_prop(_prop)
+            self._selected_videotype = ""
+
+    def _clear_videotype_props(self) :
+        while self._active_videotype_props != [] :
+            _prop = self._active_videotype_props.pop()
+            self.widget.remove_prop(_prop)
+            del self._selected_props[_prop]
+        
+    def _clear_framerate(self) :
+        _prop = 'framerate'
+        if _prop in self._selected_props :
+            self.widget.remove_prop(_prop)
+            del self._selected_props[_prop]
+    
+    def clear_all(self) :
+        self.widget.remove_all_props()
+        self._selected_props.clear()
+        self._active_videotype_props = []
+        self._selected_videotype = ""
+
+        try : 
+            self.widget.disconnect_by_function(self._prop_changed_cb)
+        except :
+            self.warning('Impossible to disconnect')
+            pass
+    
+    def _make_caps(self, mediatype, fields) :
+        _caps_str = ""
+        for _key, _value in fields.iteritems() :
+            _caps_str = "%s, %s=(%s)%s" % ( \
+                    _caps_str,
+                    _key,
+                    self.FIELDS_TYPE[_key],
+                    _value
+                    )
+        
+        _caps_str = "%s %s" % (mediatype, _caps_str) 
+        _caps = gst.Caps(_caps_str)
+        self.debug(" Caps created : %s", _caps.to_string())
+        return _caps
+    

=== modified file 'luciole/base/options.py'
--- luciole/base/options.py	2010-09-01 09:29:58 +0000
+++ luciole/base/options.py	2011-02-28 13:21:06 +0000
@@ -34,7 +34,7 @@
 
 # local application/library specific imports
 
-def options_parser() :
+def options_parser(args) :
     """ parse application options """
     option_list = [
         make_option("-f", "--file",
@@ -50,6 +50,5 @@
 
     usage = "usage: %prog [options] "
     parser = OptionParser(option_list=option_list, usage=usage)
-    (options, args2) = parser.parse_args()
-    return options
+    return parser.parse_args(args)
 

=== modified file 'luciole/conf.py'
--- luciole/conf.py	2010-09-06 05:04:33 +0000
+++ luciole/conf.py	2011-02-28 13:21:06 +0000
@@ -37,13 +37,14 @@
 # related third party imports
 import gtk
 
+from pitivi.log.loggable import Loggable
 
 # local application/library specific imports
 import luciole.base.exceptions as LEXCEP
 import luciole.base.tools as LT
 import luciole.constants as LCONST
 import luciole.base.lcl_et as LE
-
+import luciole.gui.constants as GUI_CONST
 
 class RecentPjtMngr(object):
     """ Manage recent projects, display
@@ -114,7 +115,9 @@
         """ Callback on menu activation. open selected project """
         try :
             # respect strucuture or emit signals 
-            self.__cbs['open-project'](self, {'path':project})
+            # TODO : emit open-project signal
+            #self.__cbs['open-project'](self, {'path':project})
+            pass
         except LEXCEP.LucioException, _err :
             _msg = _("Project %s no more exist"%project)
             self.__gui_window.error_message(_msg)
@@ -122,12 +125,11 @@
 
 
 
-class LucioleConf(object):
+class LucioleConf(Loggable):
     """ Manage the configuration file of luciole """    
     
     __USER_LUCIOLE_DIR = ".luciole"
     __CONF_FILE_NAME = "lucioleConf.xml"
-    __ORIGINAL_DIR = "templates"
     __THEME_DIR = LCONST.THEMES_DIR
 
     def __get_conf_options(self):
@@ -148,8 +150,7 @@
             - if conf file does not exist in user dir create it
             - parse xml conf file
         """
-        
-        self.logger = logging.getLogger('luciole')
+        Loggable.__init__(self)
         self._home_dir = os.path.expandvars('$HOME')
         self._option_dict = dict()
         self._option_dict["LastProjects"] = list()
@@ -165,7 +166,7 @@
         else :
             try :
                 # copy file to local dir
-                self._copy_conf_file(os.path.join(self.__ORIGINAL_DIR,
+                self._copy_conf_file(os.path.join(LCONST.TEMPLATE_DIR,
                                                 self.__CONF_FILE_NAME))
                 # and parse it 
                 self._parse_conf_file()
@@ -232,18 +233,27 @@
     
     def load_theme(self) :
         """ Load a gtk theme """
-        self.logger.debug('Entering theme load')
+        self.debug('Entering theme load')
         if self._option_dict.has_key('Theme') :
             l_path = os.path.join(self.__THEME_DIR, self._option_dict['Theme'])
             if os.path.exists(l_path) :
                 gtk.rc_parse(l_path)
+                self.debug('Theme %s loaded', l_path)
+                # load specidic icons
+                factory = gtk.IconFactory()
+                for _stock in GUI_CONST.STOCKS :
+                    gtk.stock_add([GUI_CONST.STOCK_ACQUISITION_ITEM])
+                    iconset = gtk.IconSet()
+                    factory.add(_stock, iconset)
+                factory.add_default()
+
             else :
                 msg =  _('Theme %s does not exist'%l_path)
-                self.logger.info(msg) 
+                self.info(msg) 
         else : 
             msg =  _('Impossible to load theme')
-            self.logger.info(msg) 
-        self.logger.debug('Exiting theme load')
+            self.info(msg) 
+        self.debug('Exiting theme load')
 
     #
     # Private methods

=== modified file 'luciole/constants.py'
--- luciole/constants.py	2010-09-01 06:11:33 +0000
+++ luciole/constants.py	2011-02-28 13:21:06 +0000
@@ -31,7 +31,9 @@
 import os.path
 
 # related third party imports
-# N/A
+import pygst
+pygst.require('0.10')
+import gst
 
 # local application/library specific imports
 # N/A
@@ -93,8 +95,9 @@
 ########################################
 # IMAGE FORMATS
 ########################################
-THUMB_RATIO         =   4       # ration normal/thumbnail. 
-                                # To set size ot thumbnail images in treeview.
+# Thumb width displayed in treeviews, the height is calcuated in app
+# according image ratio
+THUMB_WIDTH         =   120      
 # clor in rgb format muliply by 255 each level to go in gtk.gdk.Color format
 THUMB_COLOR_RATIO = 256
 THUMB_TEXT_COLOR    =   (
@@ -106,7 +109,6 @@
 THUMB_TEXT_FAMILY   =   'sans'              # font family
 
 
-ALPHA_DEFAULT = 0.4 # default alpha value used for mixer
 
 ############################################
 # PROGRAM_PATH 
@@ -117,9 +119,47 @@
 TEMPLATE_DIR = os.path.join(BASE_DIR, 'data/templates')
 IMAGE_DIR = os.path.join(BASE_DIR, 'data', 'images')
 LOCALE_DIR = os.path.join(BASE_DIR, 'po')
+SOUNDS_DIR = os.path.join(BASE_DIR, 'data', 'sounds')
+
 ###############################################
 # For GLADE
 ###############################################
 MAIN_GLADE_FILE = "luciole.glade"
 MAIN_GLADE_FILE_PATH = os.path.join(UI_DIR, MAIN_GLADE_FILE)
+MAIN_WINDOW_NAME = 'window1'
+
+
+
+ACQ_MODE_GLADE_FILE = "acquisition_mode.glade"
+ACQ_MODE_GLADE_PATH = os.path.join(UI_DIR, ACQ_MODE_GLADE_FILE)
+
+NO_PROJECT_MODE_GLADE_FILE = "no_project_mode.glade"
+NO_PROJECT_MODE_GLADE_PATH = os.path.join(UI_DIR, NO_PROJECT_MODE_GLADE_FILE)
+
+VIEWER_GLADE_FILE = "viewer.ui"
+VIEWER_GLADE_PATH = os.path.join(UI_DIR, VIEWER_GLADE_FILE)
+
+
+MODE_MAIN_WINDOW = 'window_main'
+
+
+###############################################
+# GST constants
+###############################################
+CLOCK_TIME_NONE = gst.CLOCK_TIME_NONE
+
+###############################################
+# SOUNDS_FILE
+###############################################
+SOUND_SNAPSHOT_FILE = 'camera.ogg'
+SOUND_SNAPSHOT_PATH = os.path.join(SOUNDS_DIR, SOUND_SNAPSHOT_FILE)
+
+SOUND_TRACK_NAME = 'sound_track.wav'
+#################################################
+# For mixer
+################################################
+IMAGE2MIX_NAME = 'ToMix.jpeg'
+DEFAULT_IMAGE2MIX = os.path.join(IMAGE_DIR,'white.jpg')
+DEFAULT_ALPHA_IMAGE = 0.5
+DEFAULT_ALPHA_STREAM = 1.0
 

=== added file 'luciole/ctrl/base.py'
--- luciole/ctrl/base.py	1970-01-01 00:00:00 +0000
+++ luciole/ctrl/base.py	2011-02-28 13:21:06 +0000
@@ -0,0 +1,105 @@
+# -*- Mode: Python -*-
+# vim:si:ai:et:sw=4:sts=4:ts=4
+#
+#
+# Copyright Nicolas Bertrand ([e-mail]), 2009-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/>.
+#
+#
+"""
+ctrl_base.py :
+    Base class for ctrl class
+"""
+# standard library imports
+
+# related third party imports
+from pitivi.signalinterface import Signallable
+from pitivi.log.loggable import Loggable
+# local application/library specific imports
+
+
+class ProjectMode(Signallable, Loggable) :
+    """ Base class """
+    __signals__ = {}
+    
+    def __init__(self, ctrl_project,  mode_type = None) :
+        Signallable.__init__(self)
+        Loggable.__init__(self)
+        self.mode_type = mode_type
+        self.ctrl_project = ctrl_project
+        self.gui =  ctrl_project.gui
+        self._viewer = None
+        
+        self.project = None
+        self._pipeline = None
+
+        self.connect_to_project()
+
+    def set_viewer(self, viewer) :
+        """ set the gui viewer """
+        self._viewer = viewer
+
+    def connect_to_project(self) :
+        """ conecto project controller """
+        self.debug('Connect to project')
+        self.ctrl_project.connect('project-loaded', self.project_loaded_cb)
+        self.ctrl_project.connect('project-closed', self.project_closed_cb)
+    
+    def project_loaded_cb(self, project_ctrl, project) :
+        """ project-loaded callback """
+        self.debug('RX project-loaded')
+        self.prepare(project)
+
+    def project_closed_cb(self, project_ctrl) :
+        """ project-closed callback """
+        self.debug('RX project-closed')
+        self.release()
+
+    def connect_to_gui(self, gui) :
+        """ Meta function.
+        connect to gui signals """
+        self.debug('Connect to gui')
+        
+
+    def active_viewer(self) :
+        """ Meta function.
+            active displays associted to mode """
+        pass
+    
+    def prepare(self, project) :
+        """ Meta function.
+            prepare the mode """
+        
+        self.debug("project : %s", project)
+        self.project = project
+        if project == None :
+            self.error('No project to prepare')
+        else :
+            self.project = project
+
+
+    def release(self) : 
+        """ Meta function
+        release """
+        self.debug('Release')
+        self._viewer.setPipeline(None)
+        pass
+        
+
+        
+
+

=== modified file 'luciole/ctrl/constants.py'
--- luciole/ctrl/constants.py	2010-04-06 13:57:15 +0000
+++ luciole/ctrl/constants.py	2011-02-28 13:21:06 +0000
@@ -43,7 +43,8 @@
     "move-down-chrono",
     "move-to-chrono",
     "move-up-chrono",
-    "open-project",
+#    "open-project",
+    "play-query-position",
     "play-video",
     "quit-app",
     "save-as-project",

=== modified file 'luciole/ctrl/ctrl.py'
--- luciole/ctrl/ctrl.py	2010-09-03 12:44:41 +0000
+++ luciole/ctrl/ctrl.py	2011-02-28 13:21:06 +0000
@@ -28,13 +28,15 @@
 """
 # standard library imports
 import sys
+import os
+import os.path
 import locale
 import gettext
 _ = gettext.gettext
 
 # related third party imports
 import gobject
-import os.path
+from pitivi.log import log
 
 # local application/library specific imports
 import luciole.base.app_logging as LOGGING
@@ -52,6 +54,8 @@
 #####
 
 
+
+
 class LucioleController(object):
     """ 
     Main luciole controller
@@ -59,7 +63,12 @@
 
     def __init__(self, args) :
         """ Controller initialisation.
+        
         Is the main appication intialisation """
+        # init logging as early as possible so we can log startup code
+        enable_color = os.environ.get('PITIVI_DEBUG_NO_COLOR', '0') in ('', '0')
+        log.init('PITIVI_DEBUG', enable_color)
+        
         #
         # init attributes
         #
@@ -91,7 +100,7 @@
 
 
         # load recent projects
-        _cbs = {'open-project' : self.on_open_project}
+        _cbs = None
         _recent_mnger = self.__configurer.init_recent_manager(
                                    self.__gui.file_recent_menu,
                                    self.__gui.windows,
@@ -103,7 +112,7 @@
 
         
         # start project controller
-        self.__project = \
+        self._project = \
                 CTRL_PROJECT.ProjectController(self.__gui,_recent_mnger ,_cbs)
         
         _cbs = {
@@ -120,7 +129,12 @@
 
         # conncet gui signals after the controller initialisation
         self.__gui.connect_gui_signals()
-        
+        # Connect GUI with app
+        self.__gui.connect_to_app_ctrl(self)
+       
+        # TODO : load timeline
+        #TMLN.Timeline()
+
     def __connect_signals(self):
         """ connect controller signals """
         self.ctrl_signals = gobject.GObject()
@@ -152,42 +166,42 @@
     def on_change_framerate(self,  *args) :
         """ Request of framerate(fpi) change """
         _args = self.__extract_signal_args(args) 
-        self.__project.change_framerate(_args['framerate']) 
+        self._project.change_framerate(_args['framerate']) 
         
     def on_change_project(self, *args) :
         """ Request for prohect change """
         _args = self.__extract_signal_args(args)
         for _key, _value in _args.iteritems() :
-            self.__project.change_project(_key, _value)
+            self._project.change_project(_key, _value)
         
     def on_close_project(self, *args ) :
         """ Request for project close  """
         _args = self.__extract_signal_args(args) 
         # test if project exists
-        if self.__project.mode == CTRL_CONST.PROJECT_LOADED :
+        if self._project.mode == CTRL_CONST.PROJECT_LOADED :
             # check if project is modified 
-            if self.__project.data['is_modified'] :
+            if self._project.data['is_modified'] :
                 # ask for save it before close
                 _res = self.__gui.windows.\
                     question_message(_('Save Project before closing'))
                 if _res : 
-                    self.__project.save()
+                    self._project.save()
                 
         # set viewer in default mode 
         self._viewer.mode = self._viewer.DEFAULT
         
         # clear project controller 
-        self.__project.mode = CTRL_CONST.NO_PROJECT
+        self._project.mode = CTRL_CONST.NO_PROJECT
         
         # display close message 
-        _msg = _('Project %s is closed' % self.__project.data['project_name'])
+        _msg = _('Project %s is closed' % self._project.data['project_name'])
         self.__gui.status_bar.display_message(_msg)
 
 
     def on_create_project(self, *args) :
         """ Request new project """
         _args = self.__extract_signal_args(args) 
-        self.__project.new()
+        self._project.new()
 
 
     def on_delete_capture(self, *args) :
@@ -248,7 +262,7 @@
         """ Request display project properties """
         _args = self.__extract_signal_args(args) 
         # test if project exists
-        if self.__project.mode == CTRL_CONST.PROJECT_LOADED :
+        if self._project.mode == CTRL_CONST.PROJECT_LOADED :
             # go in default mode before dispalying window
             # due to webcam detection and avoid confilcts with acquisition
             self._viewer.mode = self._viewer.DEFAULT
@@ -262,30 +276,30 @@
             # launch project poperties window
             _cbs = \
             {'change-project-properties' : self.on_change_project_properties} 
-            self.__gui.windows.project_properties(self.__project.data, _cbs) 
+            self.__gui.windows.project_properties(self._project.data, _cbs) 
 
 
     def on_export_to_tool(self, *args) :
         """ Request export to tool  """
         _args = self.__extract_signal_args(args) 
         # test if project exists
-        if self.__project.mode == CTRL_CONST.PROJECT_LOADED :
-            self.__gui.windows.export_tool(self.__project.data)
+        if self._project.mode == CTRL_CONST.PROJECT_LOADED :
+            self.__gui.windows.export_tool(self._project.data)
 
 
     def on_export_to_video(self, *args) :
         """ Request export to video  """
         _args = self.__extract_signal_args(args) 
         # test if project exists
-        if self.__project.mode == CTRL_CONST.PROJECT_LOADED :
-            self.__gui.windows.export_video(self.__project.data)
+        if self._project.mode == CTRL_CONST.PROJECT_LOADED :
+            self.__gui.windows.export_video(self._project.data)
 
 
     def on_import_image(self, *args) :
         """ Request image import """
         _args = self.__extract_signal_args(args) 
         # check if project exists
-        if self.__project.mode == CTRL_CONST.PROJECT_LOADED :
+        if self._project.mode == CTRL_CONST.PROJECT_LOADED :
             # open filename chooser dialog    
             _filenames = self.__gui.windows.import_dialog()
             
@@ -293,7 +307,7 @@
                 _cbs = { 'done-import' : self.on_done_import}
                 # start import controller
                 CTRL_IMPORT.ImportController(_filenames, 
-                                            self.__project.data, 
+                                            self._project.data, 
                                             self.__rusher,
                                             self.__gui.status_bar,
                                             _cbs)
@@ -307,7 +321,7 @@
     def on_move_down_chrono(self, *args) :
         """ request to move down an image """
         _args = self.__extract_signal_args(args) 
-        if self.__project.mode == CTRL_CONST.PROJECT_LOADED :
+        if self._project.mode == CTRL_CONST.PROJECT_LOADED :
             self.__gui.treeviews[LCONST.CHRONO].move_down()
 
 
@@ -326,40 +340,35 @@
     def on_move_up_chrono(self, *args) :
         """ request to move up an image """
         _args = self.__extract_signal_args(args) 
-        if self.__project.mode == CTRL_CONST.PROJECT_LOADED :
+        if self._project.mode == CTRL_CONST.PROJECT_LOADED :
             self.__gui.treeviews[LCONST.CHRONO].move_up()
 
 
-    def on_open_project(self, *args  ) :
-        """ Request open project """
+
+
+
+    def on_play_query_position(self, *args) :
+        """ Query for player position """
         _args = self.__extract_signal_args(args) 
-        if 'path' in _args :
-            if _args['path'] :
-                # path is givan as param
-                _path = _args['path']
-            else :
-                # launch open project window
-                _path = self.__gui.windows.open_project()
-        try :
-            self.__project.open(_path)
-        except LEXCEP.LucioException, _err_msg :
-            _msg = _("Project load impossible\n%s" % _err_msg)
-            self.__gui.windows.error_message( _msg)
+        (_position, _duration) = self._viewer.play_query_position()
+        if _args['cb'] :
+            # callback call to gui 
+            _args['cb'](_position, _duration)
 
 
     def on_play_video(self, *args) :
         """ Play video request """
         _args = self.__extract_signal_args(args) 
         # test if project exists
-        if self.__project.mode == CTRL_CONST.PROJECT_LOADED :
+        if self._project.mode == CTRL_CONST.PROJECT_LOADED :
             try :
-                self._viewer.init_video_player(self.__project.data)
+                self._viewer.init_video_player(self._project.data)
             except  LEXCEP.LucioException, _err_msg :
                 raise LEXCEP.LucioException, _err_msg
             else :
                 self._viewer.mode = self._viewer.PLAYER
                 try :
-                    self._viewer.play_video(self.__project.data)
+                    self._viewer.play_video(self._project.data)
                 except  LEXCEP.LucioException, _err_msg :
                     raise LEXCEP.LucioException, _err_msg
         else :
@@ -371,15 +380,15 @@
     def on_quit_app(self, *args) :
         """ Request quit application """
         _args = self.__extract_signal_args(args) 
-        if self.__project.mode == CTRL_CONST.PROJECT_LOADED and \
-                self.__project.data['is_modified'] :
+        if self._project.mode == CTRL_CONST.PROJECT_LOADED and \
+                self._project.data['is_modified'] :
             _msg = _('Project modified. Save project before exit ?')
             _res = self.__gui.windows.question_message(_msg)
             # if response is not a bool : cancel clicked
             if isinstance(_res, bool) :
                 if _res :
                     # if True save project before exit
-                    self.__project.save()
+                    self._project.save()
                 GUI_CTRL.GuiController.quit()
         else :
             GUI_CTRL.GuiController.quit()
@@ -387,45 +396,45 @@
     def on_save_as_project(self, *args) :
         """  save as project request """
         _args = self.__extract_signal_args(args) 
-        if self.__project.mode == CTRL_CONST.PROJECT_LOADED :
+        if self._project.mode == CTRL_CONST.PROJECT_LOADED :
             _dir = self.__gui.windows.dir_chooser()
             if _dir != None :
                 # set viewer in default mode due to project reload
                 self._viewer.mode = self._viewer.DEFAULT
                 try : 
-                    self.__project.save_as(_dir) 
+                    self._project.save_as(_dir) 
                 except LEXCEP.LucioException, _err_msg :
                     _msg = _('Impossible to save as project : %s' % _err_msg)
                     self.__gui.windows.error_message(_msg)
                 else :
                     _msg = _('Project saved as %s' % \
-                            self.__project.data['project_name'])
+                            self._project.data['project_name'])
                     self.__gui.status_bar.display_message(_msg)
 
 
     def on_save_project(self, *args) :
         """ save project request """
         _args = self.__extract_signal_args(args) 
-        if self.__project.mode == CTRL_CONST.PROJECT_LOADED :
+        if self._project.mode == CTRL_CONST.PROJECT_LOADED :
             try : 
-                self.__project.save() 
+                self._project.save() 
             except LEXCEP.LucioException, _err_msg :
                 _msg = _('Impossible to save project : %s' % _err_msg)
                 self.__gui.windows.error_message(_msg)
             else :
                 _msg = _('Project %s saved' % \
-                        self.__project.data['project_name'])
+                        self._project.data['project_name'])
                 self.__gui.status_bar.display_message(_msg)
                 # update project name on Main bar
-                self.__gui.set_program_bar(self.__project.data['project_name'],
-                                        self.__project.data['is_modified'])
+                self.__gui.set_program_bar(self._project.data['project_name'],
+                                        self._project.data['is_modified'])
 
 
     def on_start_acquisition(self, *args ) :
         """Request for starting acqusisition """
         _args = self.__extract_signal_args(args) 
         # check if a project is loaded
-        if self.__project.mode == CTRL_CONST.PROJECT_LOADED :
+        if self._project.mode == CTRL_CONST.PROJECT_LOADED :
             self._viewer.mode = self._viewer.ACQUIRER
                        
             # change control widget in acquisition mode
@@ -441,7 +450,7 @@
         """ Request mixer start """
         _args = self.__extract_signal_args(args) 
          # check if a project is loaded
-        if self.__project.mode == CTRL_CONST.PROJECT_LOADED :
+        if self._project.mode == CTRL_CONST.PROJECT_LOADED :
             # switch to viewer with acqusisition and mixer
             self._viewer.mode = self._viewer.ACQUIRER_WITH_MIXER
             # change control widget in no acquisition mode
@@ -462,7 +471,7 @@
         """ Request to stop acquistion  """
         _args = self.__extract_signal_args(args) 
         # check if a project is loaded
-        if self.__project.mode == CTRL_CONST.PROJECT_LOADED :
+        if self._project.mode == CTRL_CONST.PROJECT_LOADED :
             # switch to viewer default
             self._viewer.mode = self._viewer.DEFAULT 
             # change control widget in no acquisition mode
@@ -478,7 +487,7 @@
         """ Request mixer stop """
         _args = self.__extract_signal_args(args) 
          # check if a project is loaded
-        if self.__project.mode == CTRL_CONST.PROJECT_LOADED :
+        if self._project.mode == CTRL_CONST.PROJECT_LOADED :
             # switch to viewer with acqusisition and mixer
             self._viewer.mode = self._viewer.ACQUIRER
             # change control widget in no acquisition mode
@@ -507,7 +516,7 @@
     def on_take_snapshot(self, *args) :
         """ take image snapshot request  """
         _args = self.__extract_signal_args(args) 
-        if self.__project.mode == CTRL_CONST.PROJECT_LOADED :
+        if self._project.mode == CTRL_CONST.PROJECT_LOADED :
             self._viewer.take_snapshot()
         else :
             # robustness
@@ -558,10 +567,8 @@
         if self.__options.filename \
         and os.path.exists(self.__options.filename):
             # emit open project signal
-            self.ctrl_signals.emit(
-                        "open-project",
-                        {'path' : self.__options.filename}
-                        )
+            self.__gui.emit(
+                        "open-project", self.__options.filename)
 
         GUI_CTRL.GuiController.main_loop()
         GUI_CTRL.GuiController.threads_leave()
@@ -572,32 +579,32 @@
     def on_done_rush(self, rusher) :
         """ callback : when tush images are loaded """
         if rusher != None \
-        and self.__project.mode == CTRL_CONST.PROJECT_LOADED :
+        and self._project.mode == CTRL_CONST.PROJECT_LOADED :
             # load treeviews
             # prepare data
             _app_data = {}
-            _app_data['capture_images'] = self.__project.data['capture_images']
-            _app_data['chrono_images'] = self.__project.data['chrono_images']
+            _app_data['capture_images'] = self._project.data['capture_images']
+            _app_data['chrono_images'] = self._project.data['chrono_images']
             _app_data['rush'] = rusher
 
             self.__gui.load_treeviews(_app_data) 
              
             # init acquisition 
-            self._viewer.init_acquisition(self.__project.data)                 
+            self._viewer.init_acquisition(self._project.data)                 
             
             
             #  update fpi on gui and show it
-            self.__gui.update_framerate(int(self.__project.data['fpi']))
+            self.__gui.update_framerate(int(self._project.data['fpi']))
             
             # show project  acquisition widgets
             self.__gui.control_widget.mode = GUI_CONST.ACQUISTION_INACTIVE 
 
             # update project name on Main bar
-            self.__gui.set_program_bar(self.__project.data['project_name'],
-                                        self.__project.data['is_modified'])
+            self.__gui.set_program_bar(self._project.data['project_name'],
+                                        self._project.data['is_modified'])
             
             # finish project load (project aspect)
-            self.__project.finish_project_load()
+            self._project.finish_project_load()
 
             # store rusher
             self.__rusher = rusher
@@ -609,7 +616,7 @@
         callback : image snapshot is done.
         Now image can be processed into project
         """
-        self.__project.append_snapshot(self.__rusher, self._viewer.acquirer)
+        self._project.append_snapshot(self.__rusher, self._viewer.acquirer)
         
     def on_done_preferences(self , modified_options) :
         """ callback : preferences modified fome diaog """
@@ -632,17 +639,17 @@
         # Test if webcam data change key
         if key == 'webcam_data':
             # make a local copy of webcam_data
-            webcam_dict = self.__project.data['webcam_data']
+            webcam_dict = self._project.data['webcam_data']
             #test if webcam dict key exists
             if webcam_dict.has_key(key_webcam) :
                 # update webcam key and call project change
                 webcam_dict[key_webcam] = data
-                self.__project.change_project('webcam_data', webcam_dict)
+                self._project.change_project('webcam_data', webcam_dict)
 
     def on_done_import(self, image_objs = [] ) :
         """ callback : image import (rush generation) is done """
         if image_objs != [] :
-            self.__project.change_project(  'rush_images',
+            self._project.change_project(  'rush_images',
                                             self.__rusher.dump_image_name())
             # Not to be done in thread : interacts with gui
             for _image_obj in image_objs :

=== added file 'luciole/ctrl/ctrl_acq.py'
--- luciole/ctrl/ctrl_acq.py	1970-01-01 00:00:00 +0000
+++ luciole/ctrl/ctrl_acq.py	2011-02-28 13:21:06 +0000
@@ -0,0 +1,634 @@
+#!/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-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/>.
+#
+#
+"""
+ctrl_acq.py :
+    manages acquisition
+"""
+# standard library imports
+import os.path
+
+# related third party imports
+import gst
+from pitivi.signalinterface import Signallable
+from pitivi.log.loggable import Loggable
+from pitivi.signalgroup import SignalGroup
+from pitivi.action import ViewAction
+from pitivi.pipeline import Pipeline
+
+# local application/library specific imports
+from luciole.media.lgst.webcam_factory import WebcamSourceFactory
+import luciole.constants as LCONST
+import luciole.base.exceptions as LEXCEP
+import luciole.base.tools as LT
+import luciole.media.image as LI
+
+from luciole.ctrl.base import ProjectMode
+
+class ProjectModeAcquisition(ProjectMode) :
+    MODES = (   "INVALID",
+                "NO_ACQUISITION",
+                "ACQUISITION",
+                "ACQUISITION_WITH_MIXER",
+                )
+
+    __signals__ = {
+                    'acquirer-ready' : [],
+                    'acquirer-error' : ['msg'],
+                    'acquisition-started' : ['with_mixer'],
+                    'acquisition-stopped' : [],
+                    'snapshot-on-progress' : [],
+                    'snapshot-taken' : ['rush_image'],
+                }
+
+    def __init__(self, ctrl_project) :
+        self._mode ="INVALID"
+        ProjectMode.__init__(self, ctrl_project, "ACQUISITION") 
+        self.gui_signals = SignalGroup()
+    
+    def prepare(self, project) :
+        """ prepare acquistion """
+        ProjectMode.prepare(self, project)
+        # prepare acqusisition
+        _project = project.props
+        if _project != None :
+            if _project['hardtype'] == LCONST.WEBCAM :
+                # create webcam source
+                _capture_path = os.path.join(
+                        _project['project_dir'], 
+                        LCONST.ACQUIRED_IMAGE_NAME)
+                self.debug ("Image capture path : %s", _capture_path)
+                self._source_factory = \
+                        WebcamSourceFactory(capture_path = _capture_path,
+                                            with_mixer = False)
+
+                self.debug(' webcam filter : %s',self.project.props['webcam_data']) 
+                self._set_webcam_params(
+                        self.project.props['webcam_data'],
+                        self._source_factory)
+                
+                # set video resize/scale mode (or not)
+                if _project['resize'] == 'yes' :
+                    self._source_factory.with_scale = True
+                else :
+                    self._source_factory.with_scale = False
+
+                self._connect_to_factory(self._source_factory, _capture_path )
+                
+                # create pipeline and resource
+                self._pipeline = Pipeline()
+                self._view_action = ViewAction()
+                self._view_action.addProducers(self._source_factory)
+                
+                self._mode = "NO_ACQUISITION"
+                self.debug('emit acquirer-ready, Webcam factory : %s, pipeline : %s',
+                        self._source_factory, self._pipeline )
+                self.emit('acquirer-ready')
+
+
+    def release(self) :
+        ProjectMode.release(self)
+        self.debug('releasing acquisition')
+        self._disconnect_from_factory(self._source_factory)
+        self._mode = "INVALID"
+        self._pipeline.release()
+        self._pipeline = None
+        self._source_factory = None
+        self._view_action = None
+
+    def active_viewer(self) :
+        if self._viewer :
+            self._viewer.setPipeline(None)
+            self._viewer.hideSlider()
+            self.debug('active viewer - Pipeline : %s, action %s', 
+                self._pipeline,
+                self._view_action)
+            self._viewer.setAction(self._view_action)
+            self._viewer.setPipeline(self._pipeline, "ACQUISITION")
+        else :
+            self.error("No viewer set")
+        
+
+    def start(self, with_mixer = False) :
+        """ start acquisition """
+        # check if image view mode
+        # in that case restart acquisition mode
+        if self.ctrl_project.mode == 'IMAGE_VIEW' :
+            self.ctrl_project.acquistion_mode()
+            return
+
+        if self._mode == "NO_ACQUISITION" :
+            if with_mixer == True :
+                self._source_factory.active_mixer(True)
+                self._mode = "ACQUISITION_WITH_MIXER"
+            else :
+                #self._source_factory.active_mixer(False)
+                self._mode = "ACQUISITION"
+                
+            self._pipeline.play()
+            self.debug('send acquisition-started - mode : %s',self._mode )
+            self.emit('acquisition-started', with_mixer)
+
+
+        else :
+            self.error("Cannot start acquisition. Controller in incorrect mode (%s)", 
+            self._mode)
+    
+    def stop(self) :
+        """ stop acquisition """
+        self.debug('stop acquisition - mode  %s', self._mode)
+        if self._mode in ("ACQUISITION", "ACQUISITION_WITH_MIXER") :
+            if self._mode == "ACQUISITION_WITH_MIXER" :
+                pass
+                #self.acquirer.deactive_onion_skin()
+            self._pipeline.stop()
+            self._mode = "NO_ACQUISITION"
+            self.debug('emit acquisition-stopped')
+            self.emit('acquisition-stopped')
+        else :
+            self.error(
+            "Cannot stop acquistion. Controller in incorrect mode (%s)", 
+            self._mode)
+   
+
+    def do_snapshot(self) :
+        if self._mode in ("ACQUISITION", "ACQUISITION_WITH_MIXER") :
+            self._source_factory.capture()
+
+        else :
+            self.error(
+            "Cannot take snapshot. Controller in incorrect mode (%s)", 
+            self._mode)
+
+    def active_mixer(self, is_active) :
+        # check with current mixer status 
+        self.debug('active_mixer : %s', is_active)
+        if self.project.props['is-mixer-active'] == is_active :
+            self.info('No mixer status to change')
+            return
+        
+        
+
+        # stop pipeline,  deactivate producer and remove old webcam factory 
+        self._pipeline.stop()
+        self._view_action.deactivate()
+        self._view_action.removeProducers(self._source_factory)
+        
+        # create new webcam factory
+        _capture_path = os.path.join(
+                        self.project.props['project_dir'], 
+                        LCONST.ACQUIRED_IMAGE_NAME)
+        self.debug ("Image capture path : %s", _capture_path)
+
+        self._source_factory =  WebcamSourceFactory(
+                                capture_path = _capture_path, 
+                                with_mixer = is_active,
+                                image2mix = self.project.props['image2mix'] )
+        # set video resize/scale mode (or not)
+        if self.project.props['resize'] == 'yes' :
+            self._source_factory.with_scale = True
+        else :
+            self._source_factory.with_scale = False
+
+
+        # add producer 
+        self._view_action.addProducers(self._source_factory)
+        # activate it --> regeneration of pipeline bins
+        self._view_action.activate()
+        # set image alpha if webcam active 
+        if is_active == True :
+            self._source_factory.alpha_value = self.project.props['alpha']
+        
+            self.debug(' image to mix is %s with alpha = %s',
+                self._source_factory.image2mix,
+                self._source_factory.alpha_value)
+
+        # start acquisition
+        self._pipeline.play()
+        
+        self.project.props['is-mixer-active'] = is_active
+        
+    def _connect_to_factory(self, factory, _capture_path) :
+        factory.connect("image-capture-done", self._image_capture_done_cb, _capture_path )
+    
+    def _disconnect_from_factory(self, factory) :
+        factory.disconnect_by_function(self._image_capture_done_cb)
+
+    def _image_capture_done_cb( self, factory, _capture_path) :
+        self.debug('RX image-capture-done')
+        _rush_image = self._process_snapshot(_capture_path)
+        self.debug('emit snapshot-taken : %s', _rush_image.name)
+        self.emit('snapshot-taken', _rush_image)
+
+    def _process_snapshot(self, capture_path) :
+         # get acquired image name
+        _acq_image = capture_path
+
+        # build temp impage path
+        _temp_dir = os.path.join(self.project.props['project_dir'], 'tmp')
+        # copy name
+        _ac_image_temp = os.path.join(_temp_dir, _acq_image)
+        # resized copy name
+        _ac_image_temp_rz = \
+            os.path.join(_temp_dir, LCONST.ACQUIRED_IMAGE_NAME_RZ)
+
+        # build rush image name
+        _basename = LCONST.RUSH_FILENAME_TPL % self.project.rush.rush_index
+        _rush_image = \
+            os.path.join(self.project.props['project_dir'],
+                        self.project.props['rush_dir'],
+                        _basename)
+
+        try :  
+            # 1. move image acquired image to tmp dir
+            LT.movef(_acq_image, _ac_image_temp)
+            # 2. resize image result is in _ac_image_temp_rz
+            if self.project.props['resize'] == 'yes' :
+                _rz_obj = LI.ImageResize(_ac_image_temp, _ac_image_temp_rz )
+                _rz_obj.convert()
+            else :
+                _ac_image_temp_rz = _ac_image_temp
+            
+            # 3. move resized image to rush dire 
+            LT.movef(_ac_image_temp_rz, _rush_image)
+        
+        except LEXCEP.LucioException, _err_msg :
+            self.error(_err_msg)
+        else :
+            self.debug("create rush image : %s", _basename) 
+            # 4. append image to rush list
+            _rush_image = self.project.rush.append(_basename)
+            
+            # always update the image 2 mix, even if mixer is not active
+            # used to memorize the last capture 
+            #self.acquirer.Image2Mix = _rush_image.path
+            
+            # project modified
+            self.project.props['rush_images'].append(_basename)
+            self.project.props['capture_images'].append(_basename)
+
+            self.ctrl_project.is_modified = True
+            
+            self.debug("capture post-treatemnt done ") 
+            return _rush_image
+
+    def _set_webcam_params(self, webcam_props, factory) :
+        """ 
+        set webcam parameters according project propperties
+        """
+        #retrieve params value
+        _wcam_params = {
+            'wcam_driver': {
+                'element': webcam_props['v4ldriver'] ,
+                'properties' : {
+                    'device':webcam_props['device-file'],
+                    },
+                },
+            
+            'wcam_filter' : {
+                'media_type' :gst.Caps(webcam_props['caps']),
+                },
+            }
+
+        # set params on factory
+        factory.webcam_params =  _wcam_params
+        self.debug(" webcam params set : %s", factory.webcam_params)
+        
+
+        
+
+
+
+# TODO : suppress CtrlAcq
+
+class CtrlAcq(Signallable, Loggable) :
+    MODES = (   "INVALID",
+                "NO_ACQUISITION",
+                "ACQUISITION",
+                "ACQUISITION_WITH_MIXER",
+                )
+
+    
+    __signals__ = {
+                    'acquirer-ready' : ['acquirer'],
+                    'acquirer-error' : ['msg'],
+                    'acquisition-started' : ['with_mixer'],
+                    'acquisition-stopped' : [],
+                    'snapshot-on-progress' : [],
+                    'snapshot-taken' : ['rush_image'],
+                }
+
+
+    def __init__(self, ctrl_project) :
+        """ initialize the acquirer   """
+        Signallable.__init__(self)
+        Loggable.__init__(self)
+        self.ctrl_project = ctrl_project
+        
+        self.acquirer = None
+        self.project = None
+        self._mode = "INVALID"
+        
+        # signal connections 
+        self._connect_to_project(self.ctrl_project)
+        
+        self.gui_signals = SignalGroup()   
+        
+        self.debug('CtrlAcq intialized : %s %s',self.ctrl_project, ctrl_project  )
+
+   
+    def init_acquirer(self, project) :
+        self.debug("Init acquirer")
+        _project = project.props
+        if _project != None :
+            # Create acquisition object
+            _acq_obj = None     
+            # remark;  acquisition object for webcam and dv cam
+            if _project['hardtype'] == LCONST.WEBCAM :
+                # init webcam factory 
+                self.factory = WebcamSourceFactory()
+                self.debug('Webcam factory : %s', self.factory )
+                self.pipeline = PTV_PPLN.Pipeline()
+                self.view_action = ViewAction()
+                self.view_action.addProducers(self.factory)
+                
+                self.viewer = self.ctrl_project.gui._get_drawarea()
+                self.viewer.hideSlider()
+                self.viewer.setPipeline(None)
+                self.viewer.setAction(self.view_action)
+                self.viewer.setPipeline(self.pipeline, "ACQUISITION")
+                #self.viewer.play()
+                # just for debug 
+                _acq_obj =self.pipeline
+
+ 
+
+            elif _project['hardtype'] == LCONST.DVCAM :
+                # default acquisition load i.e. DVCAM
+                _acq_obj =  LACQ.Acquisition(
+                                    self._get_drawarea(self.ctrl_project.gui),
+                                    False,
+                                    _project['hardtype'],
+                                    project_dir = _project['project_dir'],
+                                    cb_error = self._on_error_acqusition,
+                                    cb_capture_done = self._on_done_snaphot)
+            else :
+                # Nothing to do
+                self.emit('acquirer-error', 'No valid acquirer found' )
+        if _acq_obj != None :
+            self._mode = "NO_ACQUISITION"
+            # for mixer initialisation set image to mix with the last image 
+            # of the capture view. only if capture image is not empty
+            if len(_project['capture_images'] ) > 0 :
+                _last_image_path = \
+                    os.path.join(   _project['project_dir'],
+                                    _project['rush_dir'],
+                                    _project['capture_images'][-1])
+                if os.path.exists(_last_image_path) : 
+                    _acq_obj.Image2Mix = _last_image_path
+            
+            self.emit('acquirer-ready', _acq_obj )
+        self.acquirer = _acq_obj
+
+    
+    def start_acquisition(self) :
+        if self._mode == "NO_ACQUISITION" :
+            self.pipeline.play()
+            self._mode = "ACQUISITION"
+            self.emit('acquisition-started', False)
+        else :
+            self.error(
+            "Cannot start acquisition. Controller in incorrect mode (%s)", 
+            self._mode)
+    
+    def stop_acquisition(self) :
+        if self._mode in ("ACQUISITION", "ACQUISITION_WITH_MIXER") :
+            if self._mode == "ACQUISITION_WITH_MIXER" :
+                pass
+                #self.acquirer.deactive_onion_skin()
+            self.pipeline.stop()
+            
+            self._mode = "NO_ACQUISITION"
+            self.debug('emit acquisition-stopped')
+            self.emit('acquisition-stopped')
+        else :
+            self.error(
+            "Cannot stop acquistion. Controller in incorrect mode (%s)", 
+            self._mode)
+
+    def active_mixer(self) :
+        if self._mode == "ACQUISITION" :
+            # the active onion skin stop the acquistion
+            self.acquirer.active_onion_skin()
+            # so start acqusition
+            self.acquirer.start_acqusition()
+
+            self._mode = "ACQUISITION_WITH_MIXER"
+            self.emit('acquisition-started', True)
+        else :
+            self.error(
+            "Cannot active mixer. Controller in incorrect mode (%s)", 
+            self._mode)
+
+
+    def deactive_mixer(self) :
+        if self._mode == "ACQUISITION_WITH_MIXER" :
+            # deactivate onion skin stop the acquistion
+            self.acquirer.deactive_onion_skin()
+            # so start acqusition
+            self.acquirer.start_acqusition()
+
+            self._mode = "ACQUISITION"
+            self.emit('acquisition-started', False)
+        else :
+            self.error(
+            "Cannot deactive mixer. Controller in incorrect mode (%s)", 
+            self._mode)
+    
+    def take_snapshot(self) :
+        if self._mode in ("ACQUISITION", "ACQUISITION_WITH_MIXER") :
+            if self.acquirer.is_streaming_active == True :
+                
+                self.debug('emit snapshot-on-progress')
+                self.emit('snapshot-on-progress')
+                self.acquirer.capture_image()
+
+
+
+    def release(self) :
+        # ensure acquisition stop
+        self.debug('Enterin release in mode=%s', self._mode)
+        if self._mode in ("ACQUISITION","ACQUISITION_WITH_MIXER") :
+            self.debug('Force acquistion stop : %s',  self._mode)
+            self.stop_acquisition()
+        else :
+            self.debug('Bad state  : %s',  self._mode)
+        self.acquirer.release()
+
+        #self._disconnect_from_project(self.ctrl_project)
+        #self._disconnect_from_gui(self.ctrl_project.gui)
+        #self.gui_signals.disconnectAll()
+
+    def _connect_to_project(self, ctrl_project) :
+        ctrl_project.connect('project-loaded', self._project_loaded_cb)
+        ctrl_project.connect('project-closed', self._project_closed_cb)
+    """
+    def _disconnect_from_project(self, ctrl_project) :
+        ctrl_project.disconnect_by_function(self._project_loaded_cb)
+        ctrl_project.disconnect_by_function(self._project_closed_cb)
+    """    
+    def _project_closed_cb(self, project_ctrl) :
+        self.debug('RX project-closed')
+        self.release()
+
+
+    def _project_loaded_cb(self, project_ctrl, project) :
+        self.debug('RX project-loaded')
+        self.init_acquirer(project)
+        self._connect_to_gui(self.ctrl_project.gui)
+        self.pipeline.play()
+        self.project = project
+
+    """" 
+    def _connect_to_gui(self, gui) :
+        # connection GUI to ctrl_acq 
+        gui.connect('start-acqusition', self._start_acq_cb) 
+        gui.connect('stop-acqusition', self._stop_acq_cb)
+        gui.connect('take-snapshot', self._take_snapshot_cb)
+        gui.connect('active-mixer', self._active_mixer_cb)
+        gui.connect('deactive-mixer', self._deactive_mixer_cb)
+        
+        # connection ctrl_acq to gui
+        gui._project_mode.connect_to_ctrl('ACQUISITION', self)
+    """
+    
+    def _connect_to_gui(self, gui) :
+        self.gui_signals.connect(
+            gui, "start-acqusition", None, self._start_acq_cb)
+        self.gui_signals.connect(
+            gui, "stop-acqusition", None, self._stop_acq_cb)
+        self.gui_signals.connect(
+            gui, "take-snapshot", None, self._take_snapshot_cb)
+        self.gui_signals.connect(
+            gui, "active-mixer", None, self._active_mixer_cb)
+        self.gui_signals.connect(
+            gui, "deactive-mixer", None, self._deactive_mixer_cb)
+        
+        # connection ctrl_acq to gui
+        gui._project_mode.connect_to_ctrl('ACQUISITION', self)
+
+
+    def _disconnect_from_gui(self,gui) :
+        # dicconnection GUI to ctrl_acq 
+        gui.disconnect_by_function(self._start_acq_cb) 
+        gui.disconnect_by_function(self._stop_acq_cb)
+        gui.disconnect_by_function(self._take_snapshot_cb)
+        gui.disconnect_by_function(self._active_mixer_cb)
+        gui.disconnect_by_function(self._deactive_mixer_cb)
+
+
+    def _start_acq_cb(self, gui) :
+        if self.ctrl_project.mode == 'ACQUISITION' :
+            self.start_acquisition()
+            
+    def _stop_acq_cb(self, gui) :
+        if self.ctrl_project.mode == 'ACQUISITION' :
+            self.stop_acquisition()
+
+    def _take_snapshot_cb(self, gui) :
+        if self.ctrl_project.mode == 'ACQUISITION' :
+            self.take_snapshot()        
+
+    def _active_mixer_cb(self, gui) :
+        self.active_mixer()
+    
+    def _deactive_mixer_cb(self, gui) :
+        self.deactive_mixer()
+
+    def _on_error_acqusition(self, message) :
+        """
+        callback error 
+        propagate it to main controller.
+        """
+        print " acqusistion error\n ", message
+        self.emit('acquirer-error', message)
+
+    def _on_done_snaphot(self, *unsued) :
+        """ 
+        callback when snaphot done.
+        """ 
+        _rush_image = self._process_snapshot()
+        self.debug('emit snapshot-taken : %s', _rush_image.name)
+        self.emit('snapshot-taken', _rush_image)
+
+    def _process_snapshot(self) :
+         # get acquired image name
+        _acq_image = self.acquirer.image2save
+
+        # build temp impage path
+        _temp_dir = os.path.join(self.project.props['project_dir'], 'tmp')
+        # copy name
+        _ac_image_temp = os.path.join(_temp_dir, _acq_image)
+        # resized copy name
+        _ac_image_temp_rz = \
+            os.path.join(_temp_dir, LCONST.ACQUIRED_IMAGE_NAME_RZ)
+
+        # build rush image name
+        _basename = LCONST.RUSH_FILENAME_TPL % self.project.rush.rush_index
+        _rush_image = \
+            os.path.join(self.project.props['project_dir'],
+                        self.project.props['rush_dir'],
+                        _basename)
+
+        try :  
+            # 1. move image acquired image to tmp dir
+            LT.movef(_acq_image, _ac_image_temp)
+
+            # 2. resize image result is in _ac_image_temp_rz
+            _rz_obj = LI.ImageResize(_ac_image_temp, _ac_image_temp_rz )
+            _rz_obj.convert()
+            
+            # 3. move resized image to rush dire 
+            LT.movef(_ac_image_temp_rz, _rush_image)
+        
+        except LEXCEP.LucioException, _err_msg :
+            self.error(_err_msg)
+        else : 
+            # 4. append image to rush list
+            _rush_image = self.project.rush.append(_basename)
+            
+            # always update the image 2 mix, even if mixer is not active
+            # used to memorize the last capture 
+            self.acquirer.Image2Mix = _rush_image.path
+            
+            # project modified
+            self.ctrl_project.is_modified = True
+            
+            return _rush_image
+
+    def _get_drawarea(self, gui) :
+        _da =  gui._get_drawarea()
+        self.debug(" Drawarea used : %s", _da)
+        return _da
+

=== added file 'luciole/ctrl/ctrl_app.py'
--- luciole/ctrl/ctrl_app.py	1970-01-01 00:00:00 +0000
+++ luciole/ctrl/ctrl_app.py	2011-02-28 13:21:06 +0000
@@ -0,0 +1,1050 @@
+#!/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-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/>.
+#
+#
+"""
+ctrl.py :
+   Main application controller
+"""
+# standard library imports
+import sys
+import os
+import os.path
+import locale
+import gettext
+_ = gettext.gettext
+
+# related third party imports
+import gobject
+from pitivi.log import log
+
+from pitivi.signalinterface import Signallable
+from pitivi.log.loggable import Loggable
+from pitivi.log import log
+
+# local application/library specific imports
+import luciole.base.app_logging as LOGGING
+import luciole.base.exceptions as LEXCEP
+import luciole.base.options as OPTIONS
+import luciole.conf as LCONF
+import luciole.constants as LCONST
+import luciole.ctrl.constants as CTRL_CONST
+import luciole.ctrl.import_image as CTRL_IMPORT
+import luciole.ctrl.ctrl_project as CTRL_PROJECT
+import luciole.gui.constants as GUI_CONST
+import luciole.gui.main_window as GUI_MAIN
+import luciole.gui.gui_ctrl as GUI_CTRL
+import luciole.info as INFO 
+import luciole.media.lgst.play_sound as LSOUND
+#####
+
+
+
+class CtrlAppGui(Signallable, Loggable) :
+    """ Interface between gui and App"""
+           
+    def __init__(self, app) :
+        Signallable.__init__(self)
+        Loggable.__init__(self)
+        self.app = app
+        self.project_ctrl = self.app.project_ctrl
+        self.gui = self.app.gui
+        self._connect_gui_and_project()
+
+    def _connect_gui_and_project(self) :
+        
+        # application high level actions 
+        self.gui.gui_actions.connect('open-project', self._open_project_cb)
+        self.gui.gui_actions.connect('new-project', self._new_project_cb)
+        self.gui.gui_actions.connect('quit-app', self._quit_cb) 
+        
+        # Project level actions  
+        self.gui.gui_actions.connect('save-project', self._save_project_cb) 
+        self.gui.gui_actions.connect('save-as-project', self._save_as_project_cb) 
+        self.gui.gui_actions.connect('close-project', self._close_project_cb) 
+        self.gui.gui_actions.connect('acquisition-mode', self._acq_mode_cb) 
+        self.gui.gui_actions.connect('timeline-mode', self._timeline_mode_cb) 
+        self.gui.gui_actions.connect('import-sound', self._import_sound_cb) 
+        self.gui.gui_actions.connect('image-view', self._image_view_cb) 
+        self.gui.gui_actions.connect('import-images', self._import_images_cb) 
+        self.gui.gui_actions.connect('show-project-properties', self._show_project_properties_cb) 
+
+
+        # Acqusition actions
+        self.gui.gui_actions.connect('start-acquistion', self._start_acq_cb) 
+        self.gui.gui_actions.connect('stop-acquistion', self._stop_acq_cb) 
+        self.gui.gui_actions.connect('take-snapshot', self._take_snapshot_cb)
+        self.gui.gui_actions.connect('active-mixer', self._active_mixer_cb)
+        
+        # Timeline actions
+        self.gui.gui_actions.connect('change-timeline-order', self._change_timeline_order_cb) 
+        self.gui.gui_actions.connect('insert-image-on-timeline', self._insert_image_on_timeline_cb) 
+        self.gui.gui_actions.connect('remove-image-on-timeline', self._remove_image_on_timeline_cb) 
+        self.gui.gui_actions.connect('active-sound', self._active_sound_cb) 
+        self.gui.gui_actions.connect('deactive-sound', self._deactive_sound_cb) 
+        self.gui.gui_actions.connect('sound-stop-with-video', self._sound_stop_with_video_cb) 
+        self.gui.gui_actions.connect('change-framerate', self._change_framerate_cb) 
+        
+
+
+
+    #
+    #  application high level callbacks 
+    #
+    
+    def _open_project_cb(self, gui, path) :
+        self.debug('RX close-project signal')
+        self.project_ctrl.open(path)
+    
+    def _new_project_cb(self, gui ) :
+        self.debug('RX new-project signal' )
+        self.project_ctrl.new_project()
+
+
+    def _quit_cb(self, gui): 
+        self.app.quit()
+        return True
+    #
+    # Project level callbacks 
+    #
+    def _save_project_cb(self, gui) :
+        self.debug('RX save-project signal')
+        self.project_ctrl.save()
+
+    def _save_as_project_cb(self, gui, path) :
+        self.debug('RX save-as-project signal')
+        self.project_ctrl.save(path)
+
+
+    def _close_project_cb(self, gui) :
+        self.debug('RX close-project signal')
+        self.project_ctrl.close()
+
+        
+    def _acq_mode_cb(self, gui) :
+        self.debug('RX acquisition-mode signal')
+        self.project_ctrl.acquisition_mode()
+
+    def _timeline_mode_cb(self, gui) :
+        self.debug('RX timeline-mode signal')
+        self.project_ctrl.timleline_mode()
+    
+    def _import_sound_cb(self, gui, path) :
+        self.debug('RX import-sound signal : %s', path)
+        self.project_ctrl.ctrl_tmln.add_sound_track(path)
+    
+    def _image_view_cb(self, gui, origin, image_name, position = 0) :
+        self.debug('RX image-view signal : origin %s image %s', origin, image_name)
+        self.project_ctrl.img_vw_mode(origin, image_name, position)
+    
+    def _import_images_cb(self, gui, paths) :
+        self.debug('RX import-images signal : %s',paths  )
+        self.project_ctrl.import_images(paths)
+    
+    def _show_project_properties_cb(self, gui) :
+        """ show project properties callback """
+        self.debug('RX show-project-properties' )
+        self.project_ctrl.show_project_properties()
+
+
+
+    #
+    # Acqusition callbacks
+    # 
+
+    def _start_acq_cb(self, gui) :
+        self.debug(' RX start-acquistion signal')
+        self.project_ctrl.ctrl_acq.start()
+    
+    def _stop_acq_cb(self, gui) :
+        self.debug(' RX stop-acquistion signal')
+        self.project_ctrl.ctrl_acq.stop()
+    
+    def _take_snapshot_cb(self, gui) :
+        self.debug('RX take-snapshot signal')
+        self.project_ctrl.ctrl_acq.do_snapshot()
+
+    def _active_mixer_cb(self, gui, is_active) :
+        self.debug('RX active-mixer signal : %s', is_active)
+        self.project_ctrl.ctrl_acq.active_mixer(is_active)
+
+    #
+    # Timeline callbacks
+    # 
+    def _change_timeline_order_cb(self, gui, objs, target):
+        self.debug('RX change-timeline-order signal - objs %s target %s', objs, target)
+        self.project_ctrl.ctrl_tmln.change_order(objs, target)
+
+    def _insert_image_on_timeline_cb(self, gui, objs, target):
+        self.debug('RX insert-image-on-timeline signal - objs %s target %s', objs, target)
+        self.project_ctrl.ctrl_tmln.insert(objs, target)
+
+    def _remove_image_on_timeline_cb(self, gui, objs):
+        self.debug('RX remove-image-on-timeline signal - objs %s', objs)
+        self.project_ctrl.ctrl_tmln.remove(objs)
+
+    def _active_sound_cb(self, gui) :
+        self.debug('RX active-sound signal') 
+        self.project_ctrl.ctrl_tmln.add_sound_track_to_timeline()
+
+    def _deactive_sound_cb(self, gui) :
+        self.debug('RX deactive-sound signal')
+        self.project_ctrl.ctrl_tmln.remove_sound_track_from_timeline()
+
+    def _sound_stop_with_video_cb(self, gui, is_stop) :
+        self.debug('RX sound-stop-with-video, is_stop %s', is_stop)
+        self.project_ctrl.ctrl_tmln.stop_sound_with_video(is_stop) 
+    
+    def _change_framerate_cb(self, gui, fpi) :
+        self.debug('RXchange-framerate, fpi %s', fpi)
+        self.project_ctrl.set_framerate(fpi)
+
+class CtrlApp(Signallable, Loggable) :
+    # CONSTANTS
+    MODES = ("INIT", "RUN", "QUIT")
+
+    def __init__(self) :
+        """ 
+        Controller initialisation.
+        Is the main appication intialisation 
+        """
+        # initialize threads
+        gobject.threads_init() 
+        
+        Loggable.__init__(self)
+        
+        self.mode = "INIT"
+        # init logging as early as possible so we can log startup code
+        enable_color = os.environ.get('PITIVI_DEBUG_NO_COLOR', '0') in ('', '0')
+        log.init('PITIVI_DEBUG', enable_color)
+
+        self.mainloop = gobject.MainLoop()
+        
+        # initializes i18n
+        self._init_i18n()
+        
+        # load configuration : ie. saved user options
+        self.configuration = LCONF.LucioleConf()
+        #  load GUI theme i.e parse rc file
+        self.configuration.load_theme()
+        
+                
+        
+
+    def run(self, args) :
+        
+        # TODO : seems no more needed : check
+        import gtk.gdk
+        gtk.gdk.threads_enter()
+        
+        
+        # intializes options :
+        (_options, _args) = OPTIONS.options_parser(args)
+        
+        # initialize sound player i.e from snapshot sound
+        self.soundplayer = LSOUND.SoundPlayer(LCONST.SOUND_SNAPSHOT_PATH)
+        
+        # start Project controller
+        self.project_ctrl = CTRL_PROJECT.CtrlProject()
+
+        # start GUI
+        self.gui = GUI_MAIN.LucioleMainWindow(self)
+        
+
+        # connect project controller with GUI
+        self.project_ctrl.connect_to_gui(self.gui)
+        
+        self.connect_to_project(self.project_ctrl)       
+        
+        self.gui_interface = CtrlAppGui(self)
+
+        # load a project ?
+        if _options.filename \
+            and os.path.exists(_options.filename):
+            self.project_ctrl.open(_options.filename)
+        else :
+            self.project_ctrl.no_project_mode()
+        self.mode = "RUN"
+
+        
+
+        self.mainloop.run()
+
+        # TODO : seems no more needed : check
+        import gtk.gdk
+        gtk.gdk.threads_leave()
+    
+    def quit(self) :
+        self.mainloop.quit()
+
+    def _init_i18n(self) :
+        """ intialize locales """
+        _locale_path = LCONST.LOCALE_DIR
+
+        # Init the list of languages to support
+        _langs = []
+        #Check the default locale
+        _lc, _encoding = locale.getdefaultlocale()
+        if (_lc):
+            #If we have a default, it's the first in the list
+            _langs = [_lc]
+        # Now lets get all of the supported languages on the system
+        _language = os.environ.get('LANGUAGE', None)
+        _msg = "language : " , _language
+        self.debug(_msg)
+        if (_language):
+            # langage comes back something like en_CA:en_US:en_GB:en
+            # on linuxy systems, on Win32 it's nothing, so we need to
+            # split it up into a list
+            _langs += _language.split(":")
+        # Now add on to the back of the list the translations that we
+        # know that we have, our defaults"""
+        _langs += ["en_US"]
+        
+        # Now langs is a list of all of the languages that we are going
+        # to try to use.  First we check the default, then what the system
+        # told us, and finally the 'known' list
+        _msg = "locale path", _locale_path
+        self.debug(_msg)
+        
+        GUI_CTRL.GuiController.init_18n(_locale_path)
+        #import gtk.glade
+        #gtk.glade.bindtextdomain(LCONST.APP_NAME, _locale_path)
+        #gtk.glade.textdomain(LCONST.APP_NAME)
+
+        gettext.bindtextdomain(LCONST.APP_NAME, _locale_path)
+        gettext.textdomain(LCONST.APP_NAME)
+        
+        # Get the language to use
+        _lang = gettext.translation(LCONST.APP_NAME, _locale_path
+            , languages=_langs, fallback = True)
+        # Install the language, map _() (which we marked our
+        # strings to translate with) to self.lang.gettext() which will
+        # translate them."""
+        global _
+        _ = _lang.gettext
+
+    def connect_to_project(self, project_ctrl) :
+        project_ctrl.connect('project-loaded', self._project_loaded_cb)
+        project_ctrl.connect('project-closed', self._project_closed_cb)
+        project_ctrl.connect('quit', self._quit_cb)
+
+    def disconnect_from_project(self, project_ctrl) :
+        project_ctrl.disconnect_by_function(self._project_loaded_cb)
+        project_ctrl.disconnect_by_function(self._project_closed_cb)
+    
+    def _project_loaded_cb(self, project_ctrl, project) :
+        self.soundplayer.connect_to_app(project_ctrl)
+
+    def _project_closed_cb(self, project_ctrl) :
+        pass
+        #self.soundplayer.disconnect_from_app(project_ctrl)
+    
+    def _quit_cb(self, project) :
+        self.quit()
+
+class LucioleController(object):
+    """ 
+    Main luciole controller
+    """
+
+    def __init__(self, args) :
+        """ Controller initialisation.
+        
+        Is the main appication intialisation """
+        # init logging as early as possible so we can log startup code
+        enable_color = os.environ.get('PITIVI_DEBUG_NO_COLOR', '0') in ('', '0')
+        log.init('PITIVI_DEBUG', enable_color)
+        
+        #
+        # init attributes
+        #
+        self.ctrl_signals = None
+        self.__rusher = None
+
+        # parse program options 
+        self.__options = OPTIONS.options_parser()
+        
+        # init logging
+        self.logger = LOGGING.init_logging(
+                            self.__options.is_verbose, 
+                            log_to_file = self.__options.is_logfile
+                            )
+        self.logger.info("Starting luciole")
+        
+        # Init i18n 
+        self.__init_i18n()
+        
+        # load configuration : ie. saved user options
+        self.__configurer = LCONF.LucioleConf()
+        #  load GUI theme
+        self.__configurer.load_theme()
+        # create controller signals
+        self.__connect_signals()
+        # initialize gui and BTW threads        
+        self.__gui = GUI_CTRL.GuiController(self.ctrl_signals)
+        
+
+
+        # load recent projects
+        _cbs = None
+        _recent_mnger = self.__configurer.init_recent_manager(
+                                   self.__gui.file_recent_menu,
+                                   self.__gui.windows,
+                                   _cbs)
+        
+        # prepare callbacks for Project controller
+        _cbs = { 'done-rush' : self.on_done_rush,
+                'close-project' : self.on_close_project }
+
+        
+        # start project controller
+        self._project = \
+                CTRL_PROJECT.ProjectController(self.__gui,_recent_mnger ,_cbs)
+        
+        _cbs = {
+                'on-done-snapshot' : self.on_done_snapshot,
+                'on-error':self.on_error
+                }
+        self._viewer = CTRL_VIEWER.Viewer(self.__gui, _cbs)
+        
+        # display capture trash if option is set
+        if  self.__configurer.conf_options['CaptureTrashDisplay'] == 'yes' :
+            self.__gui.capture_trash = True
+
+
+
+        # conncet gui signals after the controller initialisation
+        self.__gui.connect_gui_signals()
+        # Connect GUI with app
+        self.__gui.connect_to_app_ctrl(self)
+       
+        # TODO : load timeline
+        #TMLN.Timeline()
+
+    def __connect_signals(self):
+        """ connect controller signals """
+        self.ctrl_signals = gobject.GObject()
+        for _signal in CTRL_CONST.CTRL_SIGNALS :
+            
+            # declare signal
+            gobject.signal_new(_signal, self.ctrl_signals,
+                       gobject.SIGNAL_RUN_LAST,
+                       gobject.TYPE_NONE,
+                       (gobject.TYPE_PYOBJECT,))
+
+            # Build signal callback function name from signal name 
+            # example : signal "change-alpha-mixer" 
+            #           have callback self.on_change_alpha_mixer 
+            _cb = 'self.on_' + _signal.replace('-', '_')
+            # connect signal
+            self.ctrl_signals.connect(_signal, eval(_cb))
+            
+
+    def on_change_alpha_mixer(self, *args) :
+        """ Request change mixer alpha value """
+        _args = self.__extract_signal_args(args) 
+        try :
+            self._viewer.change_mixer_alpha(_args['alpha'])
+        except  LEXCEP.LucioException, _err_msg :
+            raise LEXCEP.LucioException, _err_msg
+
+
+    def on_change_framerate(self,  *args) :
+        """ Request of framerate(fpi) change """
+        _args = self.__extract_signal_args(args) 
+        self._project.change_framerate(_args['framerate']) 
+        
+    def on_change_project(self, *args) :
+        """ Request for prohect change """
+        _args = self.__extract_signal_args(args)
+        for _key, _value in _args.iteritems() :
+            self._project.change_project(_key, _value)
+        
+    def on_close_project(self, *args ) :
+        """ Request for project close  """
+        _args = self.__extract_signal_args(args) 
+        # test if project exists
+        if self._project.mode == CTRL_CONST.PROJECT_LOADED :
+            # check if project is modified 
+            if self._project.data['is_modified'] :
+                # ask for save it before close
+                _res = self.__gui.windows.\
+                    question_message(_('Save Project before closing'))
+                if _res : 
+                    self._project.save()
+                
+        # set viewer in default mode 
+        self._viewer.mode = self._viewer.DEFAULT
+        
+        # clear project controller 
+        self._project.mode = CTRL_CONST.NO_PROJECT
+        
+        # display close message 
+        _msg = _('Project %s is closed' % self._project.data['project_name'])
+        self.__gui.status_bar.display_message(_msg)
+
+
+    def on_create_project(self, *args) :
+        """ Request new project """
+        _args = self.__extract_signal_args(args) 
+        self._project.new()
+
+
+    def on_delete_capture(self, *args) :
+        """ Request delete on capture """
+        _args = self.__extract_signal_args(args) 
+        # remove on treeview
+        self.__gui.treeviews[LCONST.CAPTURE].remove()
+        
+        # The image selected for delete is displayed before delete
+        # so after go in default mode to nom more display the deleted image
+        self._viewer.mode = self._viewer.DEFAULT
+        
+        # change control widget in no acquisition mode
+        if self.__gui.control_widget.mode in\
+                ( GUI_CONST.ACQUISITION_ACTIVE,
+                GUI_CONST.ACQUISITION_ACTIVE_WITH_MIXER) :
+            self.__gui.control_widget.mode = GUI_CONST.ACQUISTION_INACTIVE
+
+
+    def on_delete_chrono(self, *args) :
+        """ Request delete on capture """
+        _args = self.__extract_signal_args(args) 
+        # remove on treeview
+        self.__gui.treeviews[LCONST.CHRONO].remove()
+        
+        # The image selected for delete is displayed before delete
+        # so after go in default mode to nom more display the deleted image
+        self._viewer.mode = self._viewer.DEFAULT
+
+        # change control widget in no acquisition mode
+        if self.__gui.control_widget.mode in \
+                ( GUI_CONST.ACQUISITION_ACTIVE,
+                GUI_CONST.ACQUISITION_ACTIVE_WITH_MIXER) :
+            self.__gui.control_widget.mode = GUI_CONST.ACQUISTION_INACTIVE
+
+
+    def on_display_about(self, *args) :
+        """ request display about """
+        _args = self.__extract_signal_args(args) 
+        # compute version
+        __version = "\n %s (%s)" % (INFO.VERSION, INFO.REVNO)
+        # display window
+        self.__gui.windows.about(__version)
+
+
+    def on_display_luciole_preferences(self, *args) :
+        """ Request display of application preferences """
+        _args = self.__extract_signal_args(args) 
+        _cbs = {'done-preferences' : self.on_done_preferences} 
+        self.__gui.windows.preferences(  self.__configurer.conf_options,
+                                        _cbs)
+                                        
+                                        
+        
+
+
+    def on_display_project_properties(self, *args) :
+        """ Request display project properties """
+        _args = self.__extract_signal_args(args) 
+        # test if project exists
+        if self._project.mode == CTRL_CONST.PROJECT_LOADED :
+            # go in default mode before dispalying window
+            # due to webcam detection and avoid confilcts with acquisition
+            self._viewer.mode = self._viewer.DEFAULT
+            
+            # change control widget in no acquisition mode
+            self.__gui.control_widget.mode = GUI_CONST.ACQUISTION_INACTIVE
+
+            # display message 
+            self.__gui.status_bar.display_message(_('No Acquistion'))
+            
+            # launch project poperties window
+            _cbs = \
+            {'change-project-properties' : self.on_change_project_properties} 
+            self.__gui.windows.project_properties(self._project.data, _cbs) 
+
+
+    def on_export_to_tool(self, *args) :
+        """ Request export to tool  """
+        _args = self.__extract_signal_args(args) 
+        # test if project exists
+        if self._project.mode == CTRL_CONST.PROJECT_LOADED :
+            self.__gui.windows.export_tool(self._project.data)
+
+
+    def on_export_to_video(self, *args) :
+        """ Request export to video  """
+        _args = self.__extract_signal_args(args) 
+        # test if project exists
+        if self._project.mode == CTRL_CONST.PROJECT_LOADED :
+            self.__gui.windows.export_video(self._project.data)
+
+
+    def on_import_image(self, *args) :
+        """ Request image import """
+        _args = self.__extract_signal_args(args) 
+        # check if project exists
+        if self._project.mode == CTRL_CONST.PROJECT_LOADED :
+            # open filename chooser dialog    
+            _filenames = self.__gui.windows.import_dialog()
+            
+            if _filenames != [] :
+                _cbs = { 'done-import' : self.on_done_import}
+                # start import controller
+                CTRL_IMPORT.ImportController(_filenames, 
+                                            self._project.data, 
+                                            self.__rusher,
+                                            self.__gui.status_bar,
+                                            _cbs)
+            else :
+                _msg = _("No files or valid files choosen for image import.")
+                self.__gui.windows.error_message( _msg)
+        else :
+            _msg = _("Impossible to import images when no project are loaded.")
+            self.__gui.windows.error_message( _msg)
+ 
+    def on_move_down_chrono(self, *args) :
+        """ request to move down an image """
+        _args = self.__extract_signal_args(args) 
+        if self._project.mode == CTRL_CONST.PROJECT_LOADED :
+            self.__gui.treeviews[LCONST.CHRONO].move_down()
+
+
+    def on_move_to_chrono(self, *args) :
+        """  request for move imge from capture to chrono"""
+        _args = self.__extract_signal_args(args) 
+        # get images to move from capture widget
+        _images_name = self.__gui.treeviews[LCONST.CAPTURE].images_to_move()
+        # append this images in chrono widget
+        _images_obj = \
+            [ self.__rusher.get_image(_image) for _image in _images_name ]
+        for _image in _images_obj :
+            self.__gui.treeviews[LCONST.CHRONO].append_image(_image)
+ 
+
+    def on_move_up_chrono(self, *args) :
+        """ request to move up an image """
+        _args = self.__extract_signal_args(args) 
+        if self._project.mode == CTRL_CONST.PROJECT_LOADED :
+            self.__gui.treeviews[LCONST.CHRONO].move_up()
+
+
+
+
+
+    def on_play_query_position(self, *args) :
+        """ Query for player position """
+        _args = self.__extract_signal_args(args) 
+        (_position, _duration) = self._viewer.play_query_position()
+        if _args['cb'] :
+            # callback call to gui 
+            _args['cb'](_position, _duration)
+
+
+    def on_play_video(self, *args) :
+        """ Play video request """
+        _args = self.__extract_signal_args(args) 
+        # test if project exists
+        if self._project.mode == CTRL_CONST.PROJECT_LOADED :
+            try :
+                self._viewer.init_video_player(self._project.data)
+            except  LEXCEP.LucioException, _err_msg :
+                raise LEXCEP.LucioException, _err_msg
+            else :
+                self._viewer.mode = self._viewer.PLAYER
+                try :
+                    self._viewer.play_video(self._project.data)
+                except  LEXCEP.LucioException, _err_msg :
+                    raise LEXCEP.LucioException, _err_msg
+        else :
+            # send error message
+            msg =  _("Can not play animation : No project loaded")
+            self.__gui.windows.error_message( msg)
+
+
+    def on_quit_app(self, *args) :
+        """ Request quit application """
+        _args = self.__extract_signal_args(args) 
+        if self._project.mode == CTRL_CONST.PROJECT_LOADED and \
+                self._project.data['is_modified'] :
+            _msg = _('Project modified. Save project before exit ?')
+            _res = self.__gui.windows.question_message(_msg)
+            # if response is not a bool : cancel clicked
+            if isinstance(_res, bool) :
+                if _res :
+                    # if True save project before exit
+                    self._project.save()
+                GUI_CTRL.GuiController.quit()
+        else :
+            GUI_CTRL.GuiController.quit()
+
+    def on_save_as_project(self, *args) :
+        """  save as project request """
+        _args = self.__extract_signal_args(args) 
+        if self._project.mode == CTRL_CONST.PROJECT_LOADED :
+            _dir = self.__gui.windows.dir_chooser()
+            if _dir != None :
+                # set viewer in default mode due to project reload
+                self._viewer.mode = self._viewer.DEFAULT
+                try : 
+                    self._project.save_as(_dir) 
+                except LEXCEP.LucioException, _err_msg :
+                    _msg = _('Impossible to save as project : %s' % _err_msg)
+                    self.__gui.windows.error_message(_msg)
+                else :
+                    _msg = _('Project saved as %s' % \
+                            self._project.data['project_name'])
+                    self.__gui.status_bar.display_message(_msg)
+
+
+    def on_save_project(self, *args) :
+        """ save project request """
+        _args = self.__extract_signal_args(args) 
+        if self._project.mode == CTRL_CONST.PROJECT_LOADED :
+            try : 
+                self._project.save() 
+            except LEXCEP.LucioException, _err_msg :
+                _msg = _('Impossible to save project : %s' % _err_msg)
+                self.__gui.windows.error_message(_msg)
+            else :
+                _msg = _('Project %s saved' % \
+                        self._project.data['project_name'])
+                self.__gui.status_bar.display_message(_msg)
+                # update project name on Main bar
+                self.__gui.set_program_bar(self._project.data['project_name'],
+                                        self._project.data['is_modified'])
+
+
+    def on_start_acquisition(self, *args ) :
+        """Request for starting acqusisition """
+        _args = self.__extract_signal_args(args) 
+        # check if a project is loaded
+        if self._project.mode == CTRL_CONST.PROJECT_LOADED :
+            self._viewer.mode = self._viewer.ACQUIRER
+                       
+            # change control widget in acquisition mode
+            self.__gui.control_widget.mode = GUI_CONST.ACQUISITION_ACTIVE
+
+        else :
+            _msg = \
+                _(' Can not start acquisition when no project are loaded.')
+            self.__gui.windows.error_message(_msg)
+
+
+    def on_start_mixer(self, *args) :
+        """ Request mixer start """
+        _args = self.__extract_signal_args(args) 
+         # check if a project is loaded
+        if self._project.mode == CTRL_CONST.PROJECT_LOADED :
+            # switch to viewer with acqusisition and mixer
+            self._viewer.mode = self._viewer.ACQUIRER_WITH_MIXER
+            # change control widget in no acquisition mode
+            self.__gui.control_widget.mode = \
+                    GUI_CONST.ACQUISITION_ACTIVE_WITH_MIXER
+
+            # display message 
+            self.__gui.status_bar.display_message(_('Acquiring with mixer'))
+        else :
+            # robustness
+            _msg = \
+                _('No project are loaded.')
+            self.__gui.windows.error_message(_msg)
+
+
+
+    def on_stop_acquisition(self, *args) :
+        """ Request to stop acquistion  """
+        _args = self.__extract_signal_args(args) 
+        # check if a project is loaded
+        if self._project.mode == CTRL_CONST.PROJECT_LOADED :
+            # switch to viewer default
+            self._viewer.mode = self._viewer.DEFAULT 
+            # change control widget in no acquisition mode
+            self.__gui.control_widget.mode = GUI_CONST.ACQUISTION_INACTIVE
+
+        else :
+            # robustness
+            _msg = \
+                _('No project are loaded.')
+            self.__gui.windows.error_message(_msg)
+
+    def on_stop_mixer(self, *args) :
+        """ Request mixer stop """
+        _args = self.__extract_signal_args(args) 
+         # check if a project is loaded
+        if self._project.mode == CTRL_CONST.PROJECT_LOADED :
+            # switch to viewer with acqusisition and mixer
+            self._viewer.mode = self._viewer.ACQUIRER
+            # change control widget in no acquisition mode
+            self.__gui.control_widget.mode = \
+                    GUI_CONST.ACQUISITION_ACTIVE
+
+            # display message 
+            self.__gui.status_bar.display_message(_('Acquiring'))
+        else :
+            # robustness
+            _msg = \
+                _('No project are loaded.')
+            self.__gui.windows.error_message(_msg)
+
+    def on_stop_video(self, *args) :
+        """ Stop video request  """
+        _args = self.__extract_signal_args(args) 
+        try :
+            self._viewer.stop_video()
+        except  LEXCEP.LucioException, _err_msg :
+            raise LEXCEP.LucioException, _err_msg
+        else :
+            self._viewer.mode = self._viewer.DEFAULT
+
+
+    def on_take_snapshot(self, *args) :
+        """ take image snapshot request  """
+        _args = self.__extract_signal_args(args) 
+        if self._project.mode == CTRL_CONST.PROJECT_LOADED :
+            self._viewer.take_snapshot()
+        else :
+            # robustness
+            _msg = \
+                _('No project are loaded.')
+            self.__gui.windows.error_message(_msg)
+
+            _msg = \
+                _('No project are loaded.')
+            self.__gui.windows.error_message(_msg)
+
+
+    def on_view_image(self, *args) :
+        """ 
+        request image view/display :
+        Mix image with stream if viewer mode is acquirer with mixer 
+        """
+        _args = self.__extract_signal_args(args) 
+        #if mode is player does not allow image view
+        if self._viewer.mode == self._viewer.PLAYER :
+            pass
+        
+        # if mode is acquirer with mixer and image is from capture treeview :
+        # mix image with acqusisition stream
+        elif self._viewer.mode == self._viewer.ACQUIRER_WITH_MIXER \
+        and _args['tv_type'] ==  LCONST.CAPTURE :
+            self._viewer.mix_image_in_stream(_args['image'])
+        
+        # on other cases view image
+        else :
+            self._viewer.mode = self._viewer.IMAGER
+            self._viewer.view_image(_args['image'])
+            
+            #change control widget in no acquisition mode
+            if self.__gui.control_widget.mode in \
+                    ( GUI_CONST.ACQUISITION_ACTIVE,
+                    GUI_CONST.ACQUISITION_ACTIVE_WITH_MIXER) :
+                self.__gui.control_widget.mode = GUI_CONST.ACQUISTION_INACTIVE
+
+
+    def run(self) :
+        """ main program ininite loop """
+        # TODO : 
+        GUI_CTRL.GuiController.threads_enter()
+        # before starting main loop check for 
+        # options given to application
+        
+        # load a project ? 
+        if self.__options.filename \
+        and os.path.exists(self.__options.filename):
+            # emit open project signal
+            self.__gui.emit(
+                        "open-project", self.__options.filename)
+
+        GUI_CTRL.GuiController.main_loop()
+        GUI_CTRL.GuiController.threads_leave()
+        self.logger.info("Leaving luciole")
+    #
+    #   Callbacks from controller
+    #
+    def on_done_rush(self, rusher) :
+        """ callback : when tush images are loaded """
+        if rusher != None \
+        and self._project.mode == CTRL_CONST.PROJECT_LOADED :
+            # load treeviews
+            # prepare data
+            _app_data = {}
+            _app_data['capture_images'] = self._project.data['capture_images']
+            _app_data['chrono_images'] = self._project.data['chrono_images']
+            _app_data['rush'] = rusher
+
+            self.__gui.load_treeviews(_app_data) 
+             
+            # init acquisition 
+            self._viewer.init_acquisition(self._project.data)                 
+            
+            
+            #  update fpi on gui and show it
+            self.__gui.update_framerate(int(self._project.data['fpi']))
+            
+            # show project  acquisition widgets
+            self.__gui.control_widget.mode = GUI_CONST.ACQUISTION_INACTIVE 
+
+            # update project name on Main bar
+            self.__gui.set_program_bar(self._project.data['project_name'],
+                                        self._project.data['is_modified'])
+            
+            # finish project load (project aspect)
+            self._project.finish_project_load()
+
+            # store rusher
+            self.__rusher = rusher
+   
+ 
+
+    def on_done_snapshot(self) :
+        """
+        callback : image snapshot is done.
+        Now image can be processed into project
+        """
+        self._project.append_snapshot(self.__rusher, self._viewer.acquirer)
+        
+    def on_done_preferences(self , modified_options) :
+        """ callback : preferences modified fome diaog """
+        # update prefernces
+        (_capture_trash, _ask_restart) = \
+            self.__configurer.update_preferences(modified_options)
+        
+        # check if gui update is needed
+        if isinstance(_capture_trash, bool) :
+            self.__gui.capture_trash = _capture_trash
+
+        if isinstance(_ask_restart, bool) and _ask_restart == True :
+            _msg = \
+                _('Please restart Luciole to take into account the new theme ')
+            self.__gui.status_bar.display_message(_msg)
+
+    def on_change_project_properties(self, key, key_webcam= None, data =None) :
+        """ callback project change from properties window """
+        # webcam_data field of project dictionaty is a dictionaty
+        # Test if webcam data change key
+        if key == 'webcam_data':
+            # make a local copy of webcam_data
+            webcam_dict = self._project.data['webcam_data']
+            #test if webcam dict key exists
+            if webcam_dict.has_key(key_webcam) :
+                # update webcam key and call project change
+                webcam_dict[key_webcam] = data
+                self._project.change_project('webcam_data', webcam_dict)
+
+    def on_done_import(self, image_objs = [] ) :
+        """ callback : image import (rush generation) is done """
+        if image_objs != [] :
+            self._project.change_project(  'rush_images',
+                                            self.__rusher.dump_image_name())
+            # Not to be done in thread : interacts with gui
+            for _image_obj in image_objs :
+                self.__gui.append_capture(_image_obj)  
+   
+
+    
+    #
+    # Error calbacks 
+    #
+    def on_error(self, err_type, message) :
+        """ Main error callback  """
+        _msg = _("error type : %s.  %s" % (err_type, message))
+        # Display error on log window
+        self.logger.info(_msg)
+    #
+    # private methods
+    #
+    def __init_i18n(self) :
+        """ intialize locales """
+        _locale_path = LCONST.LOCALE_DIR
+
+        # Init the list of languages to support
+        _langs = []
+        #Check the default locale
+        _lc, _encoding = locale.getdefaultlocale()
+        if (_lc):
+            #If we have a default, it's the first in the list
+            _langs = [_lc]
+        # Now lets get all of the supported languages on the system
+        _language = os.environ.get('LANGUAGE', None)
+        _msg = "language : " , _language
+        self.logger.debug(_msg)
+        if (_language):
+            # langage comes back something like en_CA:en_US:en_GB:en
+            # on linuxy systems, on Win32 it's nothing, so we need to
+            # split it up into a list
+            _langs += _language.split(":")
+        # Now add on to the back of the list the translations that we
+        # know that we have, our defaults"""
+        _langs += ["en_US"]
+        
+        # Now langs is a list of all of the languages that we are going
+        # to try to use.  First we check the default, then what the system
+        # told us, and finally the 'known' list
+        _msg = "locale path", _locale_path
+        self.logger.debug(_msg)
+        
+        GUI_CTRL.GuiController.init_18n(_locale_path)
+        #import gtk.glade
+        #gtk.glade.bindtextdomain(LCONST.APP_NAME, _locale_path)
+        #gtk.glade.textdomain(LCONST.APP_NAME)
+
+        gettext.bindtextdomain(LCONST.APP_NAME, _locale_path)
+        gettext.textdomain(LCONST.APP_NAME)
+        
+        # Get the language to use
+        _lang = gettext.translation(LCONST.APP_NAME, _locale_path
+            , languages=_langs, fallback = True)
+        # Install the language, map _() (which we marked our
+        # strings to translate with) to self.lang.gettext() which will
+        # translate them."""
+        global _
+        _ = _lang.gettext
+
+
+
+    #
+    # static_method
+    #
+    @staticmethod
+    def __extract_signal_args(args) :
+        """ 
+        extract the signals arguments :
+        arfs is a tuple
+        The first argument is the emitter object ( gobject)
+        the second argument is a dict with all the parameter given 
+        to signal.
+        
+        The function returns the paramter dictionary
+        """
+        return args[1]
+            
+
+if __name__ == '__main__' :
+    X = LucioleController(sys.argv)
+    X.run() 
+    
+
+

=== added file 'luciole/ctrl/ctrl_img_vw.py'
--- luciole/ctrl/ctrl_img_vw.py	1970-01-01 00:00:00 +0000
+++ luciole/ctrl/ctrl_img_vw.py	2011-02-28 13:21:06 +0000
@@ -0,0 +1,82 @@
+# -*- Mode: Python -*-
+# vim:si:ai:et:sw=4:sts=4:ts=4
+#
+#
+# Copyright Nicolas Bertrand ([e-mail]), 2009-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/>.
+#
+#
+"""
+ctrl_img_vw.py :
+    manage image viewer
+"""
+# standard library imports
+
+# related third party imports
+
+from pitivi.action import ViewAction
+from pitivi.pipeline import Pipeline
+
+# local application/library specific imports
+from luciole.ctrl.base import ProjectMode
+
+
+class ProjectModeImgVw(ProjectMode) :
+    """ Base class """
+    __signals__ = {}
+    
+    def __init__(self, ctrl_project,  mode_type = None) :
+        ProjectMode.__init__(self, ctrl_project, "IMAGE_VIEW") 
+
+  
+       
+
+           
+
+        
+    def prepare(self, project) :
+        """ prepare image viewer """
+        ProjectMode.prepare(self, project)
+        
+
+    def release(self) : 
+        """ Meta function
+        release """
+        ProjectMode.release(self)
+
+        
+    def active_viewer(self, factory) :
+        self._pipeline = Pipeline()
+        self._view_action = ViewAction()
+
+        self.debug(" factory to play :%s", factory)
+        self._view_action.addProducers(factory)
+        if self._viewer :
+            self._viewer.setPipeline(None, 'IMAGE_VIEW')
+            self._viewer.hideSlider()
+       
+            self._viewer.setAction(self._view_action)
+            self._viewer.setPipeline(self._pipeline, 'IMAGE_VIEW')
+            self._pipeline.play()
+    
+    def stop(self) :
+
+            self._pipeline.stop()
+
+        
+
+

=== added file 'luciole/ctrl/ctrl_no_project.py'
--- luciole/ctrl/ctrl_no_project.py	1970-01-01 00:00:00 +0000
+++ luciole/ctrl/ctrl_no_project.py	2011-02-28 13:21:06 +0000
@@ -0,0 +1,60 @@
+#!/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-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/>.
+#
+#
+"""
+ctrl_no_project.py :
+    manages no project loaded mode
+"""
+# standard library imports
+# N/A
+
+# related third party imports
+from pitivi.signalgroup import SignalGroup
+
+# local application/library specific imports
+from luciole.ctrl.base import ProjectMode
+
+class ProjectModeNoProject(ProjectMode) :
+    __signals__ = {
+                }
+
+    def __init__(self, ctrl_project) :
+        ProjectMode.__init__(self, ctrl_project, "NO_PROJECT") 
+        self.gui_signals = SignalGroup()
+    
+    def prepare(self, project) :
+        """ Nothing to prepare """
+        pass
+
+    def release(self) :
+        ProjectMode.release(self)
+
+    def active_viewer(self) :
+        if self._viewer :
+            self._viewer.setPipeline(None, "NO_PROJECT")
+        else :
+            self.error("No viewer set")
+        
+
+ 

=== renamed file 'luciole/ctrl/project_ctrl.py' => 'luciole/ctrl/ctrl_project.py'
--- luciole/ctrl/project_ctrl.py	2010-09-07 06:27:09 +0000
+++ luciole/ctrl/ctrl_project.py	2011-02-28 13:21:06 +0000
@@ -22,7 +22,7 @@
 #
 #
 """
-project_ctrl.py :
+ctrl_project.py :
    Manage interactions with a luciole Project 
 """
 
@@ -31,325 +31,537 @@
 from gettext import gettext as _
 
 # related third party imports
-# N/A
+from pitivi.signalinterface import Signallable
+from pitivi.log.loggable import Loggable
+
 
 # local application/library specific imports
 import luciole.base.exceptions as LEXCEP
 import luciole.base.tools as LT
 import luciole.constants as LCONST
 import luciole.ctrl.constants as CTRL_CONST
+import luciole.ctrl.ctrl_acq as CTRL_ACQ
 import luciole.ctrl.ctrl_base as CTRL_BASE
+import luciole.ctrl.ctrl_timeline as CTRL_TMLN
+import luciole.ctrl.ctrl_no_project as CTRL_NO_PROJECT
+import luciole.ctrl.ctrl_img_vw as CTRL_IMG_VW
 import luciole.ctrl.load_rush as LRUSH
 import luciole.gui.constants as GUI_CONST
 import luciole.media.image as LI
-import luciole.project.project as LPF
+import luciole.project.project_etree as LPF
+
+from luciole.gui.windows.assistant_new_project import AssistantNewProject
+from luciole.gui.windows.dialog_project_properties import ProjectProperties
+from luciole.ctrl.import_image import ImportController
 
 # NULL tuple constant defined for compat with gobject signals on ctrl.py file
 _NULL_TUPLE = None, None
 
-class ProjectController(CTRL_BASE.CtrlBase) :
-    """ 
-    Class to manage luciole project 
-    SubClass of controller
-    """
-    #
-    # CONSTANTS 
-    #
-    __MODES = (CTRL_CONST.NO_PROJECT, CTRL_CONST.PROJECT_LOADED)
-
-    def __get_data(self):
-        """ getter for is_project"""
-        return self.__data
-    data = property(  __get_data,
-                            None,
-                            None,
-                            """Retrieve project data """
-                            )   
-
-    def __get_mode(self):
-        """ getter for project controller mode """
-        return self.__mode
-    def __set_mode(self, mode) :
-        """ setter for project controller mode """
-        # change mode only on transition
-        if mode in self.__MODES and mode != self.__mode :
-            self.__mode_call[mode]()
-    mode = property(	__get_mode, __set_mode, None,
-						""" Project controller mode """)
-
-    def __init__(self, gui, recent_mnger, cbs):
-        """ 
-            ctrl_cbs: dictionary of main main controller callbacks
-        """
-        CTRL_BASE.CtrlBase.__init__(self) 
-        self.__data = None
-        self.__mode = CTRL_CONST.NO_PROJECT
-         # init mode 
-        self.__mode_call = {
-            CTRL_CONST.NO_PROJECT : \
-                self.__set_mode_no_project,
-             CTRL_CONST.PROJECT_LOADED : \
-                self.__set_mode_project_loaded,
-                }
-
-        self.__gui = gui
-        self.__gui_windows = gui.windows
-        self.__cbs = cbs
-        self.__recent_mngr = recent_mnger
-        
-        self.__pjt_file = LPF.ProjectToFile()
-
-    def new(self) :
-        """ create a new project """
-        # if project exist : close it
-        if self.__data != None :
-            # (None, None) params for compat with gobject signal
-            self.__cbs['close-project'](None, None)
-        # launch New project assitant window
-        self.__gui_windows.new_project_assistant(self._cb_new_project) 
-
+class Project(object) :
+    
+    
+    def __init__(self) :
+        self.parser = LPF.ProjectToFile()
+        self.props = LPF.ProjectDico()
+        self.timeline = None
+        self.rush = None
+        self.acquirer = None
+    
+       
+    def save(self, path) :
+        _project_path  = None 
+        if path is not None :
+            try :
+                _project_path = self.parser.save_as(path , self.props)
+            except LEXCEP.LucioException, _err_msg :
+                raise LEXCEP.LucioException, _err_msg
+        else :
+            try :
+                _project_path = self.parser.save(self.props)
+            except LEXCEP.LucioException, _err_msg :
+                raise LEXCEP.LucioException, _err_msg
+        return _project_path
+    
+    def set_non_pjt_dpdt_props(self) :
+        # init props not managed by porject in file
+        self.props['is_modified'] = False 
+        self.props['is-mixer-active'] = False
+        self.props['image2mix'] = None
+        self.props['alpha'] = LCONST.DEFAULT_ALPHA_IMAGE
+
+class CtrlProject(Signallable, Loggable) :
+    
+    # CONSTANTS
+    MODES = ("NO_PROJECT", "ACQUISITION", "TIMELINE", "IMAGE_VIEW", "EXPORT")
+    PROJECT_LOADED_MODES = ("ACQUISITION", "TIMELINE", "IMAGE_VIEW", "EXPORT")
+    
+
+
+    __signals__ = {
+            "project-loaded": ["project"],
+            "project-closing" : ["project"],
+            "project-closed" : [],
+            'project-modified' : ["is_modified"],
+            'project-mode-changed' : ["mode"],
+            'quit' : [],
+            'import-image-done' : ['images'], 
+            }
+    
+    def _get_mode(self) :
+        """ mode getter """
+        return self._mode
+    mode = property(_get_mode,
+                    None,
+                    None,
+                    """ project mode """)
+    
+
+    def _get_is_modified(self):
+        """ is_modified getter """
+        return self.project.props['is_modified']
+
+    def _set_is_modified(self, is_modified = True)  :
+        """ is_modified getter """
+        if isinstance(is_modified, bool)\
+                and\
+                is_modified != self.project.props['is_modified'] :
+            self.project.props['is_modified'] = is_modified
+            self.debug('emit signal project-modified : is_modified = %s',
+                    is_modified)
+            self.emit('project-modified', is_modified)
+
+    is_modified = property(_get_is_modified,
+                    _set_is_modified,
+                    None,
+                    """ is_modified project property """)
+
+
+    def __init__(self) :
+        Signallable.__init__(self)
+        Loggable.__init__(self)
+        
+        self._mode = None
+        self.gui = None
+        self.project = Project()
+
+        self.ctrl_acq = CTRL_ACQ.ProjectModeAcquisition(self)
+        self.ctrl_tmln = CTRL_TMLN.ProjectModeTimeline(self)
+        self.ctrl_no_project = CTRL_NO_PROJECT.ProjectModeNoProject(self)
+        self.ctrl_img_vw = CTRL_IMG_VW.ProjectModeImgVw(self)
+        
+        self._connect_to_acq(self.ctrl_acq)
+        self._connect_to_timeline(self.ctrl_tmln)
+
+
+    def connect_to_gui(self, gui) :
+        self.gui = gui
+        
+        self.ctrl_acq.set_viewer(gui.drawarea)
+        self.ctrl_tmln.set_viewer(gui.drawarea)
+        self.ctrl_no_project.set_viewer(gui.drawarea)
+        self.ctrl_img_vw.set_viewer(gui.drawarea)
+    
+    def no_project_mode(self) :
+        self.debug('No project mode')
+        
+        if self._mode == 'ACQUISITION' :
+            self.ctrl_acq.stop()
+
+        if self._mode != 'NO_PROJECT' :
+            self._mode = 'NO_PROJECT'
+            self.ctrl_no_project.active_viewer()
+        else :
+            self.warning("impossible to switch to No Project mode (%s)",
+                    self._mode )
+
+
+     
+
+    def acquisition_mode(self, force = False) :
+        """ activate acquisition mode """
+        self.debug('Acquisition mode')
+        if self._mode in self.PROJECT_LOADED_MODES \
+            and self._mode != 'ACQUISITION'  :
+            self._mode = 'ACQUISITION'
+            #force = True 
+            if force == True :
+                self.debug('switch to acquisition mode forced')
+                # force prepare for pipelline configuration
+                # the _acquirer_ready_cb will call acquisition_mode
+                # when aquirer(pipeline) is ready
+                self.ctrl_acq.release()
+                self.ctrl_acq.prepare(self.project)
+                return
+
+            self.ctrl_acq.active_viewer()
+            self.ctrl_acq.start()
+            self.debug('Emit project-mode-changed : %s'%self._mode)
+            self.emit('project-mode-changed',self._mode)
+
+        else :
+            self.warning("impossible to switch to acquisition mode (%s)",
+                    self._mode )
+    
+    def timleline_mode(self) :
+        """ activate timeline mode """
+        if self._mode == 'ACQUISITION' :
+            self.ctrl_acq.stop()
+        
+        if self._mode in self.PROJECT_LOADED_MODES \
+            and self._mode != 'TIMELINE'  :
+
+            self._mode = 'TIMELINE'
+            self.ctrl_tmln.active_viewer()
+            self.debug('Emit project-mode-changed : %s'%self._mode)
+            self.emit('project-mode-changed',self._mode)
+        else :
+            self.warning("impossible to switch to timeline mode")
+    
+
+    def img_vw_mode(self, origin, image_name, position = 0) :
+        if self._mode in self.PROJECT_LOADED_MODES : 
+            if self._mode == 'ACQUISITION' :
+                self.ctrl_acq.stop()
+
+            if self._mode == 'TIMELINE' and origin == LCONST.CHRONO :
+                self.ctrl_tmln.go_to_position(position)
+                # TODO : implemnt better then return here
+                return
+
+            if self._mode == 'IMAGE_VIEW' :
+                self.ctrl_img_vw.stop()
+
+             
+            _factory = self.ctrl_tmln._get_factory(image_name)
+            self.ctrl_img_vw.active_viewer(_factory)
+            self._mode = 'IMAGE_VIEW'
+     
     def open(self, project_path = None) :
         """ open an existing project """
-        # no project path open a Dialog
+        # no project path  : leave
         if project_path == None :
-            _path =  self.__gui_windows.open_project()
-        else :
-            _path = project_path
+            return
+        self.debug("Starting project load of %s", project_path)
 
         # if a project is loaded close it
-        if self.__data != None :
+        if self._mode != 'NO_PROJECT' :
             # (None, None) params for compat with gobject signal
-            self.__cbs['close-project'](None, None)
-        
-        # check if a path entered ( from gui)
-        if _path != None :
-            try :
-                (_is_valid, self.__data) =self.__pjt_file.open(_path)
-            except LEXCEP.LucioException, _err_msg :
-                # Transmit error to controller: not stop application
-                raise LEXCEP.LucioException, _err_msg
-            else :
-                if not _is_valid :
-                    _msg = _(" Webcam data not valid in project.\
-                            Please restart webcam detection")
-                    self.__gui_windows.error_message( _msg)
-            
-                # load project in application
-                self.__load_project_in_app()
-
-
-            
-    def save_as(self, dir_path) :
-        """ save as current project """
-       
-        # project saved and self.__data updated
-        try :
-            self.__pjt_file.save_as(dir_path , self.__data)
-        except LEXCEP.LucioException, _err_msg :
-            raise LEXCEP.LucioException, _err_msg
-        else :
-            self.__data['is_modified'] = False
-            # saved project needs now to be reloaded
-            # close it 
-            self.__set_mode_no_project()
-            # reload project
-
-            self.__set_mode_project_loaded()
-            self.__load_project_in_app()
-
-
-    def save(self) :
-        """ save current project """
-        try :
-            self.__pjt_file.save(self.__data)
-        except LEXCEP.LucioException, _err_msg :
-            raise LEXCEP.LucioException, _err_msg
-        else :
-            self.__data['is_modified'] = False
-
-
-
-
-
-    def append_snapshot(self, rusher, acquirer) :
-        """ move acquired  image to rush dir : 
-            1. move image to tmp dir.
-            2. resize it.
-            3. move it to rush image dir """
-        # get acquired image name
-        l_acq_image = acquirer.image2save
-
-        # build temp impage path
-        l_temp_dir = os.path.join(self.__data['project_dir'], 'tmp')
-        # copy name
-        l_ac_image_temp = os.path.join(l_temp_dir, LCONST.ACQUIRED_IMAGE_NAME)
-        # resized copy name
-        l_ac_image_temp_rz = \
-            os.path.join(l_temp_dir,LCONST.ACQUIRED_IMAGE_NAME_RZ)
-
-        # build rush image name
-        l_basename = LCONST.RUSH_FILENAME_TPL % rusher.rush_index
-        l_rush_image = \
-            os.path.join(self.__data['project_dir'], self.__data['rush_dir'])
-        l_rush_image = os.path.join(l_rush_image, l_basename)
-
-        try :  
-            # 1. move image acquired image to tmp dir
-            LT.movef(l_acq_image, l_ac_image_temp)
-
-            # 2. resize image result is in l_ac_image_temp_rz
-            l_rz_obj = LI.ImageResize(l_ac_image_temp, l_ac_image_temp_rz )
-            l_rz_obj.convert()
-            
-            # 3. move resized image to rush dire 
-            LT.movef(l_ac_image_temp_rz, l_rush_image)
-        
-        except LEXCEP.LucioException, _err_msg :
-            raise LEXCEP.LucioException, _err_msg
-        else : 
-            # 4. append image to rush list
-            rusher.append(l_basename)
-            # indicate project change (rush list)
-            self.__change_project('rush_images', rusher.dump_image_name())
-
-             
-            # 5. append image object to capture list
-            l_rush_image = rusher.get_image(l_basename)
-            # 6. always update the image 2 mix, even if mixer is not active
-            # used to memorize the last capture 
-            acquirer.Image2Mix = l_rush_image.path 
-            
-            #7 append capture to treeview
-            self.__gui.append_capture(l_rush_image)  
-
-    def change_framerate(self, fpi) :
-        """ change framerate """
-        # update framerate only if project exist
-        if self.__data and isinstance(fpi, int): 
-            self.__change_project('fpi', str(fpi))
-   
-    def change_project(self, project_key, data) :
-        """ Change project : External mathod """
-        self.__change_project(project_key, data)
-
-    def finish_project_load(self) :
+            # TODO : manage close project
+            #self.__cbs['close-project'](None, None)
+            pass
+        
+        self.project = Project()
+        try :
+            (_is_valid, self.project.props) = \
+                    self.project.parser.open(project_path)
+        except LEXCEP.LucioException, _err_msg :
+            # Transmit error to controller: not stop application
+            self.error(_err_msg)
+            # TODO : manage exceptions
+            raise LEXCEP.LucioException, _err_msg
+        else :
+            if not _is_valid :
+                _msg = _(" Webcam data not valid in project.\
+                        Please restart webcam detection")
+                self.gui.windows.error_message( _msg)
+            
+            # initiate project load
+            self._start_project_load()
+    
+    def new_project(self ) :
+        """ new project creation """
+        if self._mode != 'NO_PROJECT' :
+            # close current project
+            self.close()
+            
+        _ass = AssistantNewProject(self._new_project_cb)
+        
+        # TODO : fot test purpose only
+        import os.path
+        import shutil
+        PROJECT_NAME = 'test_luciole'
+        PROJECT_PATH = '/home/nico/temp/testLuciole'
+        
+        _p_path = os.path.join(PROJECT_PATH, PROJECT_NAME)
+        if os.path.exists(_p_path) :
+            # delete folder
+            self.debug('Deleting folder %s', _p_path)
+            shutil.rmtree(_p_path)
+
+        # set on assistant project name
+        _ass._pg1.entry_project_name.set_text(PROJECT_NAME)
+        # set a folder
+        _ass._pg1._file_chooser.set_current_folder(PROJECT_PATH)
+
+        
+        
+    def _new_project_cb(self, project_data) :
         """ 
-            Method called to finsih project load.
+        new project callback : 
+        signal generated by new project assistant
         """
-        # add project loaded to recent manager
-        self.__recent_mngr.add_project(os.path.join(
-                                self.__data['project_dir'],
-                                self.__data['xml_filename'] )
-                                )
-        
-        # Set project as not modified
-        self.__data['is_modified'] =  False        
-    #
-    # def callbacks
-    #
-    def _cb_new_project(self, project_data) :
-        """ callback when new project assistant is done """
-        # 1. copy data in a project_dico object
-        project_dico_data = LPF.ProjectDico() 
-        for _key  in project_data.keys() :
-            project_dico_data[_key] = project_data[_key]
-
-        # 2. create project ( folder structure ,etc ...)
-        # mising raise exception in case of create failure 
+        self.debug(" create project with %s", project_data)
+        if project_data is None :
+            self.error('No data to load')
+            return
+        # create project on disk
+        self.project = Project()
         try :
-            self.__pjt_file.create(project_dico_data)
+            _path = self.project.parser.create(project_data)
         except LEXCEP.LucioException, _err :
             raise LEXCEP.LucioException, _err
-        else :
-            self.__data = project_dico_data
-        
-            # 3. load created project in application
-            self.__load_project_in_app()
-
-
-
-    #
-    # Private methods
-    #
-    def __set_mode_no_project(self): 
-        """ No project mode """
-        
-        #
-        # clear gui 
-        #
-        # clear treeviews 
-        self.__gui.clear_treeviews()
-        
-        # set control widget in open_Load mode 
-        self.__gui.control_widget.mode = GUI_CONST.LOAD_OR_CREATE
-
-        # clear program bar
-        self.__gui.set_program_bar('', False)
-        
-        
-        self.__mode = CTRL_CONST.NO_PROJECT
-
-    def __set_mode_project_loaded(self): 
-        """project loaded mode """
-        self.__mode = CTRL_CONST.PROJECT_LOADED
-
-    def __save(self) :
-        """ private method for save """
+        
+        self.debug(" created project on disk : %s", _path)
+        # load project on luciole
+        self.open(_path)
+
+            
+    def close(self) :
+        """ close current project """
+        if self._mode in self.PROJECT_LOADED_MODES :
+            if self.project.props['is_modified'] == True :
+                if (self.emit('project-closing', self.project) == True) :
+                    self.save()
+            
+            self.debug(" Closing current project ")
+            self.release()
+            self.no_project_mode()
+            self.debug('emit signal project-closed')
+            self.emit('project-closed')
+            self.project = None
+    
+    def save(self, dir_path = None ) :
+        if self._mode not in self.PROJECT_LOADED_MODES :
+            self.error('invalid mode for save : %s'%self._mode)
+            return
+        if dir_path and not os.path.exists(dir_path) :
+            self.error('Path %s exists. Impossible to save project', dir_path)
+            return
+        self.debug("%s",dir_path)  
+        try :
+            _project_path = self.project.save(dir_path)
+        except LEXCEP.LucioException, _err_msg :
+            self.error('%s', _err_msg)
+        else : 
+            self.debug('Project saved in %s', _project_path)
+            self.is_modified = False
+            if dir_path is not None and _project_path is not None  :
+                # reload project is corretcly saved
+                self.close()
+                self.debug('Opening project with path %s',_project_path)
+                self.open(_project_path)
+    
+    def set_framerate(self, fpi, force = False) :
+        if self._mode != "TIMELINE" and force == False :
+            self.info('update of fpi only availabe in TIMELINE mode')
+            return
+        if int(self.project.props['fpi']) != fpi :
+            self.project.props['fpi'] = str(fpi)
+            self.is_modified = True
+            # update timeline 
+            self.ctrl_tmln.update_image_duration(fpi)
+        
+
+
+    def new(self, project_data = None) :
+        
+        # create new project
+
+        if  project_data :
+            # TODO case with assistant
+            pass
+
+
+
+    def release(self) :
+
+        # release signals between aquirer and project
+        if self.project.props['hardtype'] in \
+                (LCONST.FAKE, LCONST.DVCAM, LCONST.WEBCAM ) : 
+            #self._disconnect_from_acq(self.ctrl_acq)
+            pass
+
+        # release signals between timeline and project
+        # self._disconnect_from_timeline(self.ctrl_tmln)
+        
+        # disconnect from gui
+        # TODO : Analyse when to be done on close project or quit ?
+        #self.disconnect_from_gui(self.gui)
+
+
+    def import_images(self, paths) :
+        if self._mode not in self.PROJECT_LOADED_MODES :
+            self.error('invalid mode for import: %s'%self._mode)
+            return
+
+        if paths != [] :
+            self.debug('Starting image importer for %s',paths)
+            importer =  ImportController(   paths,
+                                        self.project.props,
+                                        self.project.rush,
+                                        self.gui.status_bar
+                                        )
+            importer.connect('import-image-done', self._import_img_done_cb)
+        else :
+            self.info('No image to import')
+    
+
+    def  _import_img_done_cb(self, imager, images) :
+        """ import-image-done callback """
+        self.debug("RX import-image-done : %s", images)
+        if images != [] :
+            self.emit('import-image-done', images)
+            
+            # update project 
+            # get image names
+            _names = [ _img.name for _img in images]
+            self.project.props['rush_images'].extend(_names)
+            self.project.props['capture_images'].extend(_names)
+            self.is_modified = True
+        else :
+            self.warning('No image imported')
+    
+    def show_project_properties(self) :
+        """ show project properties 
+            webcam setup can be modified. So before displaying window all 
+            pipelines and associated stuff should be stopped 
+        """
+        if self._mode not in self.PROJECT_LOADED_MODES :
+            self.error('invalid mode for import: %s'%self._mode)
+            return
+        self.debug('%s',self.project.props)
+        self._old_mode = self._mode
+        if self._mode == 'ACQUISITION' :
+            # switch to TIMELINE to free the webcam
+            self.timleline_mode()
+
+        
+        _properties = ProjectProperties(self.gui.main_window, 
+                self.project.props)
+        _properties.connect('project-changed', self._project_modified_cb)
+        _properties.run()
+
+    def  _project_modified_cb(self, dialog, project_data) :
+        """ callback for modified data from project properties dialog """
+        self.is_modified = True
+        if self._old_mode == 'ACQUISITION' :
+            # go back to acqusition mode
+            self.acquisition_mode(True)
+            self._old_mode = None
+
+
+
+    def _start_project_load(self) :
+        
+        
+        # start rusher controller
+        _rush_ctrl = LRUSH.ControllerLoadRush(   self.project,
+                                    self.gui.status_bar )
+        self._connect_to_rush(_rush_ctrl)
+        
+        # start acquirer controller
+        if self.project.props['hardtype'] in \
+            (LCONST.FAKE, LCONST.DVCAM, LCONST.WEBCAM ) :  
+            # start acquisition controller
+            #self.acq_ctrl = CTRL_ACQ.CtrlAcq(self)
+            self.debug('Acquirer Object loaded %s', self.ctrl_acq)
+        else :
+            # No acquisition (only import and timeline)
+            self._mode = "TIMELINE"
+
+        # start timeline controller
+        #self.ctrl_tmln = CTRL_TMLN.CtrlTimeline(self)
+
+
+    def _connect_to_rush(self, rush_ctrl) :
+        rush_ctrl.connect('rush-loaded', self._rush_load_finish_cb)
+
+    def _disconnect_from_rush(self, rush_ctrl) :
+        rush_ctrl.disconnect_by_function( self._rush_load_finish_cb)
+
+    def _rush_load_finish_cb(self, rush_ctrl, rush_obj) :
+        self.debug(" Rush Load Finish :%s ", rush_obj.dump_image_name() )
+        if rush_obj != None : 
+            self._terminate_project_load(rush_obj)
+        # Load rush is done only one time at load so disconnect it
+        self._disconnect_from_rush(rush_ctrl)
+    
+    def _terminate_project_load(self, rush_obj) :
+        self.project.rush = rush_obj
+        
+        # set project as not modified as it is just loaded
+        self.project.set_non_pjt_dpdt_props()
+        
+        # set path for image to mix
+        self.project.props['image2mix'] =\
+                os.path.join(
+                        self.project.props['project_dir'],
+                        LCONST.IMAGE2MIX_NAME
+                        )
+
+        # if a capture image exist ,
+        # mix with last one by copying it in 'image2mix'
+        
+        if self.project.props['capture_images'] != []:  
+            self.debug(' image 2 copy %s', 
+                    self.project.props['capture_images'][-1])
+            self._copy_to_image2mix(
+                    self.project.props['capture_images'][-1])             
+
+        self.debug("emit project-loaded : %s " , self.project) 
+        self.emit('project-loaded', self.project )
+    
+    def _connect_to_acq(self , ctrl_acq) :
+        ctrl_acq.connect('acquirer-ready', self._acquirer_ready_cb)
+        ctrl_acq.connect('acquirer-error', self._acquirer_error_cb)
+
+    def  _disconnect_from_acq(self , ctrl_acq) :
+        ctrl_acq.disconnect_by_function( self._acquirer_ready_cb)
+        ctrl_acq.disconnect_by_function( self._acquirer_error_cb)
+
+
+    def _acquirer_ready_cb(self, ctrl_acq ) :
+        self.debug('RX acquirer-ready signal')
+        # TODO : work around on mode
+        # FIXME : set to image to force transtion to acquisition mode
+        # default mode when project is started
+        self._mode = 'IMAGE_VIEW'
+        self.acquisition_mode()
+
+
+
+    def _acquirer_error_cb(self, ctrl_acq, msg) :
+        self.error(msg)
+    
+    def _connect_to_timeline(self, ctrl_tmln) :
+        ctrl_tmln.connect('timeline-loaded', self._timeline_loaded_cb)
+        
+    def _disconnect_from_timeline(self, ctrl_tmln) :
+        ctrl_tmln.disconnect_from_project(self)
+        ctrl_tmln.disconnect_by_function(self._timeline_loaded_cb)
+
+    def _timeline_loaded_cb(self, ctrl_tmln): 
         pass
-
-    def __load_project_in_app(self) :
-        """ load project data in luciole :
-            1. Load rusher
-            2. when rusher done a callback is generated. 
-                handled in main controller. Main controller
-                load the acquistion object, and display
-                project in gui
-        """
-        if self.__data != None :
-            # set modified attibute 
-            self.__data['is_modified'] = False
-            
-            # set set mode as PROJECT LOADED
-            self.__mode = CTRL_CONST.PROJECT_LOADED
-            
-            self.logger.\
-                debug("-----------------------------------------------------")
-            self.logger.debug("Luciole_controller project info: ")
-            self.logger.\
-                debug("-----------------------------------------------------")
-            for _key, _value in self.__data.iteritems() :
-                self.logger.debug("**%s** : %s "%(_key, _value))
-            self.logger.\
-                debug("-----------------------------------------------------")
-
-            # Initilaisation of rush obj is threaded because its take a while
-            # (generation of images pixbufs)
-            # When rush load is finish : __on_rush_finish is called 
-            LRUSH.ControllerLoadRush(   self.__data,
-                                        self.__gui.status_bar, 
-                                        self.__cbs['done-rush'])
-
-
-    def __change_project(self, project_key, data) :
-        """ function called to update the current project """
-        if self.__data != None :
-            # is key exist ?
-            if self.__data.has_key(project_key) :
-                # update only on change
-                if self.__data[project_key] != data :
-                    self.__data[project_key] = data
-                    self.__data['is_modified'] = True
-                    self.__gui.set_program_bar( self.__data['project_name'], 
-                                                self.__data['is_modified'])
-            else :
-                #raise Error/Exception 
-                _err_msg =  "key %s not in project " % project_key 
-                raise LEXCEP.LucioException, _err_msg
+        #self.project.timeline = timeline
+    
+    
+    def _copy_to_image2mix(self, image_name) :
+        
+        _source = os.path.join(     self.project.props['project_dir'],
+                                        self.project.props['rush_dir'],
+                                        image_name)
+        try :    
+            LT.copyf(_source, self.project.props['image2mix'])  
+        except LEXCEP.LucioException, err :
+            self.error('impossible to copy %s in %s -- %s ',
+                    _source,
+                    self.project.props['image2mix'],
+                    err)
         else :
-            # raise Error/Exception 
-            _err_msg = " Project not loaded "
-            raise LEXCEP.LucioException, _err_msg
- 
+            self.debug(' copied %s in %s',
+                    _source,
+                    self.project.props['image2mix'])
+
 
 
 

=== added file 'luciole/ctrl/ctrl_timeline.py'
--- luciole/ctrl/ctrl_timeline.py	1970-01-01 00:00:00 +0000
+++ luciole/ctrl/ctrl_timeline.py	2011-02-28 13:21:06 +0000
@@ -0,0 +1,953 @@
+#!/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-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/>.
+#
+#
+"""
+ctrl_acq.py :
+    manages acquisition
+"""
+# standard library imports
+import os.path
+import urllib
+import gettext
+_ = gettext.gettext
+
+# related third party imports
+import gst
+import copy
+import gobject
+
+from pitivi.signalgroup import SignalGroup
+from pitivi.pipeline import Pipeline
+from pitivi.action import ViewAction
+from pitivi.timeline.timeline import Timeline, TimelineObject, TimelineError
+
+from pitivi.factories.timeline import TimelineSourceFactory
+
+from pitivi.stream import AudioStream, VideoStream
+from pitivi.settings import GlobalSettings
+from pitivi.settings import ExportSettings
+from pitivi.sourcelist import SourceList
+from pitivi.timeline.track import Track, SourceTrackObject
+
+from pitivi.utils import Seeker, getNextObject
+# local application/library specific imports
+from luciole.ctrl.base import ProjectMode
+import luciole.base.tools as LT
+import luciole.constants as LCONST
+import luciole.base.exceptions as LEXCEP
+
+class LucioleTimeline(Timeline) :
+    DEFAULT_DURATION = 1 * gst.SECOND
+
+    def __init__(self) :
+        Timeline.__init__(self)
+        # TODO : Temporary usage of GlobalSettings
+        self.settings = GlobalSettings()
+        self.default_duration = self.DEFAULT_DURATION
+        
+    def change_order(self, images_list, position_dest) :
+        self.info("order changed move images %s at position %s", 
+                images_list, 
+                position_dest)
+        
+        _tl_objects_to_move = [self.video_objects[_elem[0]] for _elem in images_list]
+        self.debug( " Objs to move :%s", [ obj.factory.name for obj in _tl_objects_to_move])
+
+        if position_dest[0] < len(self.video_objects ) :
+            # Move images inside sequence
+            _tl_obj_dest = self.video_objects[position_dest[0]]
+        
+            for tl_obj  in _tl_objects_to_move :
+
+                self.info(" Moving image %s (position %s) before %s (position : %s)",\
+                    tl_obj.factory.name,
+                    self.video_objects.index(tl_obj),
+                    _tl_obj_dest.factory.name,
+                    self.video_objects.index(_tl_obj_dest))
+
+                _tl_obj_tmp = self._move_timeline_object(tl_obj,_tl_obj_dest)
+                _tl_obj_dest = \
+                    self.video_objects\
+                    [self.video_objects.index(_tl_obj_tmp) + 1]
+        
+        else :
+            # move images at the end of sequnce
+            for tl_obj  in _tl_objects_to_move :
+                self.info(" Moving image %s (position %s) at end of sequence",\
+                    tl_obj.factory.name,
+                    self.video_objects.index(tl_obj) )
+                self._move_at_end(tl_obj)
+        
+       
+    def insert_factories(self, factories, position_dest) :
+        self.info("images to insert %s at position %s", 
+                factories, position_dest)
+        
+        if position_dest[0] < len(self.video_objects ) :
+            self._insert_factories_at_position( position_dest[0], factories)
+        else :
+            for _factory in factories :
+                # TODO : verify if append merhod usage is correct. regarding 
+                # _insert_factories_at_position method (i.e. tl_obj creation and
+                # disable/enable timeleine methods) 
+                self._append_obj(_factory)
+        
+        
+
+    
+    def remove_images(self, images_list) :
+        self.info("images to remove on timeline %s", images_list)
+        _tl_objs_to_remove = \
+                [self.video_objects[_elem[0]] for _elem in images_list]
+        
+        for tl_obj in _tl_objs_to_remove :
+            self._remove_object(tl_obj)
+        
+         
+  
+
+    
+    def create_timeline_object(self, factory) :
+        
+        _stream_map = self._getSourceFactoryStreamMap(factory)
+        _timeline_object = TimelineObject(factory)
+        for stream, track in _stream_map.iteritems():
+            track_object = SourceTrackObject(factory, stream)
+            track.addTrackObject(track_object)
+            self.info("Stream: %s, Track: %s, Track duration: %d", str(stream),
+                       str(track), track.duration)
+
+            _timeline_object.addTrackObject(track_object)
+        _timeline_object.start = 0
+        return _timeline_object
+
+
+
+
+    
+    def add_sound_track(self, audio_factory, duration, is_video_duration = True,   audio_offset = 0,) :
+        # TODO : only a offset of 0 is vlaid. with ofsset !=0 --> pieleine error
+        audio_offset = 0
+        # TODO : undestand better disable/ Enable updates.
+        # the usage od disable/enable avoid a fade transition at start ?
+        _vtrack = self._get_video_track()
+        self.debug('Video track duration %s, ', _vtrack.duration)
+        if is_video_duration :
+            _duration = _vtrack.duration
+        else :
+            _duration = duration
+      
+        self.debug('Sound track %s, duration %s, audio offest %s', 
+                audio_factory.name, _duration, audio_offset)
+        
+        #self.disableUpdates() 
+        _tl_obj = self.create_timeline_object(audio_factory)
+        _tl_obj.start = audio_offset
+        _tl_obj.duration = _duration
+        self.debug('timeline object duration = %s', _tl_obj.duration)
+        self.addTimelineObject( _tl_obj)
+        #self.enableUpdates()
+        return _tl_obj
+    
+    def remove_sound_track(self, factory) :
+        # remove factory from timeline
+        self.removeFactory(factory)
+        # update duration
+        _vtrack = self._get_video_track()
+        if _vtrack.duration != self.duration :
+            self.duration = _vtrack.duration
+
+
+
+            
+
+
+        
+
+
+    def update_timeline_duration(self, duration, sound_stop_with_video = True ) :
+        
+        
+        # copy objects for vaoiding update problems
+        _video_objs = copy.copy(self.video_objects)
+        self.debug('New duration %s image to update %s', duration, [ _obj.factory.name for _obj in _video_objs ] )
+        
+        _old_duration = _video_objs[0].duration
+        # check type of image duration update
+        # if duration update increase, start update by the last image 
+        #    in timeline (right to left order)
+        # if duration update decrease, start update fu the first image
+        #    in timeline (left to riht order )
+        
+        _reverse = False
+        if duration > _old_duration :
+            # new duration > old duration
+            # start update of images in reverse order
+            _start = (len(_video_objs) -1) * duration 
+            _video_objs.reverse()
+            _reverse = True
+        else :
+            # new duration < old duration
+            _start = 0
+
+        for _obj in _video_objs :
+             
+            self.debug('Before Update %s : start %s duration %s, factory duration %s', 
+                    _obj.factory.name,
+                    _obj.start,
+                    _obj.duration,
+                    _obj.factory.duration)
+               
+            _obj.setDuration(duration, True)
+            _obj.setStart(_start, True) 
+            if _reverse == True :
+                _start = _start - duration
+            else :
+                _start = _start + duration
+            
+            self.debug('Updated %s : start %s duration %s ', 
+                    _obj.factory.name,
+                    _obj._getStart(),
+                    _obj._getDuration())
+        
+        _total_duration = len(_video_objs) * duration 
+        self.debug(' Total duration %s', _total_duration)
+        if sound_stop_with_video == True :
+            _obj = self._get_audio_object()
+            #TODO ; check case of audio track duration < images duration
+            if _obj is not None : 
+                _obj.setDuration(_total_duration, True, True)
+                self.debug('NEW audio %s track duration %s factory duration %s',_obj, _obj.duration, _obj.factory.duration)
+        self.debug('NEW timeline duration %s', self.duration )
+
+    
+    def _move_timeline_object(self, tl_src, tl_dest) :
+        _idx_src = self.video_objects.index(tl_src)
+        _idx_dest = self.video_objects.index(tl_dest)
+        # select objects to shift on timeline 
+        if _idx_src < _idx_dest :
+            _objs_to_move = self.video_objects[_idx_src+1:_idx_dest]
+            _duration = -1 * tl_src.duration
+            #set start duration of src before dest
+            tl_src.start = self.video_objects[_idx_dest -1].start
+        else :
+            _objs_to_move = self.video_objects[_idx_dest:_idx_src]
+            _duration = 1 * tl_src.duration
+            #set start duration at  dest
+            tl_src.start = self.video_objects[_idx_dest].start
+
+        # shift objects to move
+        self._shift_object(_objs_to_move, _duration)
+
+        return tl_src 
+    
+    def _move_at_end(self, tl_src):
+
+        # get objecs to move 
+        _objs_to_move = self._getVideoObjsAfter(tl_src)
+
+        # set last postion fo tl_src
+        tl_src.start = self.video_objects[-1].start
+        
+        # shift back the objects to move
+        _duration = -1*tl_src.duration
+        self._shift_object(_objs_to_move, _duration)
+     
+    def _move_object(self, pos_src, pos_dest) :
+ 
+        if pos_src == pos_dest :
+            # nothing to move
+            return
+        _pos_dest = self.video_objects[pos_dest].start
+        _obj_src = self.video_objects[pos_src]
+        # select objects to move
+        if pos_src > pos_dest :
+            _objs_to_move = self.video_objects[pos_dest:pos_src]
+            _duration = 1 * _obj_src.duration
+        else :
+            _objs_to_move = self.video_objects[pos_src+1:pos_dest+1]
+            _duration = -1 * _obj_src.duration
+        # shift objects to move
+        self._shift_object(_objs_to_move, _duration)
+        
+        # move object at despoistion
+        _obj_src.start = _pos_dest
+    
+    def _get_track_objects(self, objs, track) :
+        track_objs = []
+        for _obj in objs :
+            if track == _obj.track_objects[0].track :
+                track_objs.append(_obj)
+
+        return track_objs
+
+
+
+
+
+    def _insert_factories_at_position(self, position, factories_to_insert) :
+        # TODO : undestand better disable/ Enable updates.
+        # the usage od disable/enable avoid a fade transition between images: Why ?
+        self.disableUpdates() 
+        _timeline_objects = []
+        _position_obj = self.video_objects[position]
+        self.debug( "_position_obj :%s", _position_obj.factory.name)
+        _objs_after = self._getVideoObjsAfter(_position_obj) 
+        _objs_after.insert(0, _position_obj)
+        
+        _dur = _position_obj.start
+        
+        for _factory in factories_to_insert :
+            _timeline_obect = self.create_timeline_object(_factory)
+            _timeline_objects.append(_timeline_obect)
+        
+        _insert_duration = self._calc_objs_duration(_timeline_objects)
+        self._shift_object(_objs_after, _insert_duration)
+        
+        for  _tl_obj in _timeline_objects :
+            _tl_obj.start =  _dur
+            _dur += _tl_obj.duration
+            self.addTimelineObject( _tl_obj)
+        
+        self.enableUpdates()
+  
+    def _calc_objs_duration(self, objs_to_insert) :
+        _duration = 0
+        for _obj in objs_to_insert :
+            _duration += _obj.duration
+        self.info("shift duration = %s", _duration)
+        return _duration
+        
+    def _shift_object(self, timeline_objects, duration) :
+        for _obj in timeline_objects :
+            self.debug("%s", _obj.factory.name)
+            _obj.start += duration
+        self.info ( "%s timeline objects shifted from %s"%(len(timeline_objects), duration))
+
+    def _append_obj(self, factory):
+    
+        timeline_object = self.addSourceFactory(factory)
+        self.info("appended  %s"%timeline_object)
+        return timeline_object
+    
+    def _remove_object(self, tl_obj) :
+        _objs_after = self._getVideoObjsAfter(tl_obj)
+        _duration = -1* tl_obj.duration
+        self.debug("obj to remove %s ", tl_obj)  
+        _vtrack = self._get_video_track()
+        _vtrack.removeTrackObject(tl_obj)
+        
+        # update start point of objects after deleted one
+        self._shift_object(_objs_after, _duration)
+
+   
+    def _get_video_track(self) :
+        for track in self.tracks:
+            if isinstance(track.stream, VideoStream) :
+                return track
+
+    def _get_audio_track(self):
+        for track in self.tracks:
+            if isinstance(track.stream, AudioStream) :
+                return track
+
+    
+    def _get_video_track_objects(self) :
+        _vtrack = self._get_video_track()
+        
+        _res = _vtrack.track_objects
+        #self.debug("Video Track objects : %s", 
+        #        [ obj.factory.name for obj in _res])
+
+        return _res
+    video_objects = property(_get_video_track_objects)
+
+    def _get_audio_object(self) :
+        _audio_obj = []
+        _res = None
+        for _obj in self.timeline_objects :
+            if isinstance(_obj.track_objects[0].stream, AudioStream) :
+                _audio_obj.append(_obj)
+
+        if len(_audio_obj) > 1 :
+            raise TimelineError(" More then one audio stream in timeline")
+        elif len(_audio_obj) == 1 :
+            _res = _audio_obj[0]
+            
+
+        return _res
+    audio_object = property(_get_audio_object)
+
+
+    def _getVideoObjsAfter(self, timeline_object) :
+        """ 
+        get video objects after timeline objects 
+        This function retrieves objects only from video track
+        """
+        objects = []
+        priority= None
+        if timeline_object in self.video_objects :
+            _res = getNextObject(timeline_object, self.video_objects, priority) 
+            while _res is not None :
+                objects.append(_res)
+                _res = getNextObject(_res, self.video_objects, priority) 
+        else :
+            self.error('timeline_object %s not in video_track', 
+                timeline_object.factory.name)  
+        
+        self.debug(" video objs after %s : %s", 
+                timeline_object.factory.name,
+                [ obj.factory.name for obj in objects])
+        return objects
+
+    def _get_image_sequence(self) :
+        _list = [ _obj.factory.name for _obj in  self.video_objects] 
+        return _list
+            
+  
+
+
+class ProjectModeTimeline(ProjectMode):
+    __signals__ = {
+            'timeline-loaded' : ['timeline'] ,
+            'sound-props-changed' : ['active', 'stop_with_video'],
+            }
+    
+    _25_FPS = (1 * gst.SECOND)/25
+
+    def __init__(self, ctrl_project) :
+        ProjectMode.__init__(self, ctrl_project, "TIMELINE") 
+        
+        self.acq_signals = SignalGroup()
+        self.timeline_signals =  SignalGroup()
+        self.debug('ProjectModeTimeline initialized ')
+        self._is_stop_sound_with_video = False
+        
+        # prepare connection to acquisiton mode
+        self._connect_to_ctrl_acq(self.ctrl_project.ctrl_acq)
+
+    def prepare(self, project) :
+        ProjectMode.prepare(self, project)
+        
+        # prepare sources 
+        self.sources = SourceList()
+        self.sources.connect("source-added", self._sourceAddedCb)
+        self.sources.connect("source-removed", self._sourceRemovedCb)
+        self.uris = []
+
+        
+
+        # prepare timeline
+        self.timeline = LucioleTimeline()
+        self._timeline_factory = TimelineSourceFactory(self.timeline)
+        
+        # prepare pipeline and resource 
+        self._pipeline = Pipeline()
+        # TODO : connect to pipeline signals ?
+        #self._pipeline.connect('eos', self._eos_cb)
+
+        self._view_action = ViewAction()
+        self._view_action.addProducers(self._timeline_factory)
+        self._pipeline.addAction(self._view_action)
+        # why seeker ? 
+        self.seeker = Seeker(80)
+        
+        #
+        # initialize video settings
+        #
+        settings = self.getAutoSettings()
+        self._videocaps = settings.getVideoCaps()
+
+        # fill timeline with audio and video track
+        video = VideoStream(gst.Caps(settings.getVideoCaps()))
+        track = Track(video)
+        self.timeline.addTrack(track)
+        audio = AudioStream(gst.Caps(settings.getAudioCaps()))
+        track = Track(audio)
+        self.timeline.addTrack(track)
+
+        
+        self._load_timeline(self.project)
+        
+        self.debug("Prepare Timeline : %s", self.timeline )
+        
+            
+    def release(self) :
+        self._mode = "INVALID"
+        self._pipeline.release()
+        self._pipeline = None
+        del self._timeline_factory
+        del self.timeline
+        self._view_action = None
+
+
+
+    def active_viewer(self) :
+        if self._viewer :
+            self.debug(" Timeline :%s, timeline duration :%s ", self.timeline, self.timeline.duration)
+        
+            self._viewer.setPipeline(None)
+            self._viewer.showSlider()
+            self._viewer.setAction(self._view_action)
+            self._viewer.setPipeline(self._pipeline, "TIMELINE")
+            
+            # chnage pipeline status to activate it ( seek, duration)
+            self._pipeline.pause()
+            self.debug("Pipeline state : %s", self._pipeline.getState())
+            self._viewer.prepare_viewer(self.timeline.duration)
+            # FIXME : hack to make the gtk.HScale seek slider UI behave properly
+            #self._viewer._durationChangedCb(None, self.timeline.duration) 
+            self.debug("actual sequence %s", [_obj.factory.name for _obj in self.timeline.video_objects])
+        
+        else :
+            self.error("No viewer defined")
+    
+    def change_order(self, images, target) :
+        self.debug('images : %s , target :%s', images, target)
+        self.timeline.change_order(images, target)
+        # update project
+        self._update_project()
+        
+    def insert(self, images, target) :
+        self.debug('images : %s , target :%s', images, target)
+        # get factories from source
+        _factories = [ self._get_factory(_elem) for _elem in images ]
+        # insert factories on timeline
+        self.timeline.insert_factories(_factories, target)
+        # update project
+        self._update_project()
+
+    def remove(self, images) :
+        self.debug('images : %s'  , images)
+        self.timeline.remove_images(images)
+ 
+        # update project
+        self._update_project()
+
+    def _update_project(self) :
+        """ update project properties according image sequence """ 
+        _img_seq = self.timeline._get_image_sequence()
+        self.info('Image sequence : %s', _img_seq)
+        # update project according image sequence
+        self.project.props['chrono_images'] =_img_seq
+        self.ctrl_project.is_modified = True
+
+
+    def add_sound_track(self, path) :
+        """ add a sound track to timeline """
+        if os.path.splitext(path)[1] != '.wav' :
+            _msg = _('Invalid sound file : %s. Only wav files allowed.' % path)
+            self.error(_msg)
+            self.ctrl_project.gui.status_bar.display_message(_msg)
+            return
+        
+        self.debug('Add sound track : %s', path )
+        # check if a sound track is avlbl, if yes remove it
+        _dest_path = os.path.join(   self.project.props['project_dir'],
+                                LCONST.SOUND_TRACK_NAME)
+
+        # first remove current sound track from timeline and sources
+        self._remove_sound_track(True)
+             
+
+        
+        
+        try :
+            LT.copyf(path, _dest_path) 
+        except LEXCEP.LucioException, err:
+            self.error(err)
+        else :
+            self.AddSources([_dest_path])
+            self.ctrl_project.is_modified = True
+            self.project.props['sound']['name'] = LCONST.SOUND_TRACK_NAME
+            self._update_sound_props(self.project.props, active='no')
+            _msg = _('Sound track %s loaded in project'% path )
+            self.info(_msg)
+            self.ctrl_project.gui.status_bar.display_message(_msg)
+
+
+    
+    def go_to_position(self, position) :
+        
+        self._viewer.seek(position*self.default_duration)
+    
+    def update_image_duration(self , fpi ) :
+        self.default_duration =   self._25_FPS * fpi
+        # upadte image factory duration
+        for _factory in self.sources.getSources() :
+            if _factory.name == LCONST.SOUND_TRACK_NAME :
+                # dont update sound track duration
+                continue
+            _factory.duration =  self.default_duration
+            self.debug('Updated duration (%s) of factory %s',
+                    _factory.duration,
+                    _factory.name)
+
+        
+        self.timeline.update_timeline_duration(self.default_duration, self._is_stop_sound_with_video)
+        
+       
+
+    def _remove_sound_track(self, force = True) :
+        """ 
+        if force = True --> rm from timeline and source list
+        if force = False --> rm from timeline only
+        """
+        _factory = self._get_factory(LCONST.SOUND_TRACK_NAME)
+        if _factory is None :
+            # nothing to suppress
+            self.debug('No factory to suppress')
+            return
+
+        if self.project.props['sound']['active'] == 'yes' :
+            self.timeline.remove_sound_track(_factory)
+            # disconnect callback who updates audio duration regarding
+            # video duration
+            try :
+                self.timeline.disconnect_by_function(self._video_track_added)
+            except :
+                #TODO : what we do ?
+                pass
+        if force == True :
+            self.sources.removeUri(_factory.uri)
+        
+        self._is_stop_sound_with_video = False
+
+                    
+            
+    
+    def add_sound_track_to_timeline(self) :
+        _factory = self._get_factory(LCONST.SOUND_TRACK_NAME)
+        if _factory : 
+            self.debug('Sound Factory %s, %r , duration %s', 
+                    _factory.name, 
+                    _factory, 
+                    _factory.duration)
+            self._is_stop_sound_with_video = False
+
+            _tl_obj = self.timeline.add_sound_track(
+                    _factory,
+                    _factory.duration,
+                    self._is_stop_sound_with_video,
+                    0)
+            self.timeline.connect('timeline-object-added', self._video_track_added, _tl_obj)
+            self.debug('Timeline duration : %s', self.timeline.duration)
+            self.debug('Pipeline duration : %s', self._pipeline.getDuration())
+        else :
+            self.warning ("Sound factory does not exists")
+        
+        self._update_sound_props(self.project.props, 
+                                active ='yes',
+                                stop_with_video = 'no' 
+                                )
+
+
+    
+    
+    def remove_sound_track_from_timeline(self) :
+        _factory = self._get_factory(LCONST.SOUND_TRACK_NAME)
+        if _factory :
+            self.debug('remove Sound Factory %s from timeline', _factory.name)
+            self.timeline.removeFactory(_factory)
+            self.timeline.disconnect_by_function(self._video_track_added)
+        else :
+            self.info('No sound track to remove')
+        
+        self._update_sound_props(self.project.props, active ='no')
+
+    
+    
+    def _video_track_added(self, timeline , timeline_object , audio_object) :
+        if timeline_object.track_objects[0] in timeline.video_objects :
+            # a video object is added
+            _vtrack = timeline._get_video_track()
+            self.debug('video track duration %s , object added %s , audio_object duration :%s ',
+            _vtrack.duration, timeline_object.factory.name, audio_object.duration)
+            
+            if _vtrack.duration >  audio_object.duration :
+                audio_object.duration = _vtrack.duration
+                self.debug ('Audio object duration updated')
+        else :
+            self.info('timeline _object %s not a video track', timeline_object.factory.name)
+    
+    def  stop_sound_with_video(self, is_stop = True) :
+        self._is_stop_sound_with_video = is_stop
+        # check if audio_track yet in timeline
+        try :
+            _obj = self.timeline.audio_object
+        except TimelineError, err :
+            self.error('Timeline error : %s',err)
+        else :
+            self.debug("Update duration")
+            if _obj :
+                if self._is_stop_sound_with_video :
+                    _vtrack = self.timeline._get_video_track()
+                    _duration = _vtrack.duration
+                    _stop_with_video = 'yes'
+
+                else :
+                    self.debug('Set audio track duration')
+                    _factory = self._get_factory(LCONST.SOUND_TRACK_NAME)
+                    _duration = _factory.duration
+                    _stop_with_video = 'no'
+                
+                self._update_sound_props(self.project.props, 
+                                    stop_with_video = _stop_with_video)
+                _obj.duration = _duration
+                self.debug("timeline duration %s", self.timeline.duration)
+        
+
+
+    def _connect_to_ctrl_acq(self, ctrl_acq) : 
+        self.debug(" Connecting to ProjectModeAcquisition ")
+        self.acq_signals.connect(
+                ctrl_acq,'snapshot-taken', None,  self._snapshot_taken_cb)
+
+    
+    def _snapshot_taken_cb(self, ctrl_acq, rush_image) :
+        self.debug('RX signal snapshot-taken : %s', rush_image.name)
+        #TODO : set the correct duration
+        self.AddSources([rush_image.path] ) 
+    
+    def _load_timeline(self, project) :
+        _project = project.props
+        self.debug('rush images to load : %s', _project['capture_images'] ) 
+        _sources = \
+            [ os.path.join( _project['project_dir'], 
+                            _project['rush_dir'], 
+                            _image) \
+                    for _image in _project['capture_images'] ]
+        _image_duration = self._25_FPS *  int(_project['fpi'])
+        uris = ["file://" + urllib.quote(os.path.abspath(path))\
+                for path in _sources]
+        
+        # check if sound track active
+        if _project['sound']['active'] == 'yes' :
+            # check if sound track really present
+            _sound_track =  os.path.join(
+                                _project['project_dir'], 
+                                LCONST.SOUND_TRACK_NAME)
+            if os.path.exists(_sound_track) :
+                _uri =  "file://" + urllib.quote(os.path.abspath(_sound_track))
+                uris.append(_uri)
+            else :
+                self.error(
+                    'Sound track active but no sound file present (%s)' %
+                     _sound_track)
+
+        # discover the factories
+        closure = {"rediscovered": 0}
+        discoverer = self.sources.discoverer
+        discoverer.connect("discovery-done", self._discovererDiscoveryDoneCb,
+                _project, _image_duration, uris, closure)
+        discoverer.connect("discovery-error", self._discovererDiscoveryErrorCb,
+                _project, _image_duration, uris, closure)
+         
+        # start discoverer
+
+        self.sources.addUris(uris)
+        self.default_duration = _image_duration
+
+    
+    def _finishLoadingProject(self, project, duration) :
+        _start = 0 
+        self.debug ('project %s', project)
+        for _image in project['chrono_images'] :
+            _factory = self._get_factory(_image)
+            _factory.default_duration = duration
+            _tl_obj = self.timeline.create_timeline_object(_factory)
+            _tl_obj.start = _start
+            _tl_obj.duration = duration
+            _start += duration
+            self.timeline.addTimelineObject( _tl_obj)
+        if  project['sound']['active'] == 'yes' :
+            _factory = self._get_factory(LCONST.SOUND_TRACK_NAME)
+            if _factory : 
+                
+                self.debug('Sound Factory %s, %r , duration %s', 
+                        _factory.name, 
+                        _factory, 
+                        _factory.duration)
+                self._is_stop_sound_with_video = False
+                if project['sound']['stop_with_video'] == 'yes' :
+                    self._is_stop_sound_with_video = True
+                _tl_obj = self.timeline.add_sound_track(
+                        _factory,
+                        _factory.duration,
+                        self._is_stop_sound_with_video,
+                        0)
+                self.timeline.connect('timeline-object-added', self._video_track_added, _tl_obj)
+        # force emit of project sound props
+        self._update_sound_props(
+                project = project, 
+                active = project['sound']['active'],                
+                stop_with_video =  project['sound']['stop_with_video'])
+
+
+        self.debug('Emit timeline-loaded')
+        self.emit('timeline-loaded')
+    
+
+       
+    def _update_sound_props(self, project, active = None, stop_with_video = None) :
+        _is_modified = False
+        _is_active = None
+        _is_stop_with_video = None
+        if project is None :
+            self.error("No project defined") 
+            return
+        
+        if active is not None :
+            if active not in ('yes','no') :
+                self.error('invalid value for prop active (%s)',
+                        active)
+                return
+            if active != project['sound']['active'] :
+                project['sound']['active'] = active
+                _is_modified = True
+            
+            if active == 'yes' :
+                _is_active = True
+            else :
+                _is_active = False
+        if stop_with_video :
+            if stop_with_video not in ('yes','no') :
+                self.error('invalid value for prop active (%s)', 
+                        stop_with_video)
+                return
+
+            if stop_with_video != project['sound']['stop_with_video'] :
+                project['sound']['stop_with_video'] = stop_with_video
+                _is_modified = True
+            if stop_with_video == 'yes' :
+                _is_stop_with_video = True
+            else :
+                _is_stop_with_video = False
+
+        self.debug('sound is_active :%s is_stop_with_video : %s, project %s',
+            active,
+            stop_with_video,
+            project['sound'] )
+        
+        if _is_modified == True :
+            self.ctrl_project.is_modified = True
+        
+        if  _is_stop_with_video is not None \
+            or \
+            _is_active is not None :   
+            self.debug('Emit sound-props-changed : active %s stop_with_video %s',
+                   _is_active, _is_stop_with_video  )
+            self.emit('sound-props-changed', _is_active, _is_stop_with_video)
+
+
+    
+    # Sources associated functions 
+    #
+    def AddSources(self, file_list) :
+
+        uris = ["file://" + urllib.quote(os.path.abspath(path))\
+                for path in file_list]
+        self.uris = uris 
+        self.debug("Sources to add %s", uris) 
+        # add uris
+        self.sources.addUris(uris)
+
+    def _discovererDiscoveryDoneCb(self, discoverer, uri, factory,
+            project , duration, uris, closure):
+        self.debug("discovery done for %s",factory.name)
+        if factory.uri not in uris:
+            # someone else is using discoverer, this signal isn't for us
+            return
+        
+        # update duration of image factory
+        if factory.name != LCONST.SOUND_TRACK_NAME :
+            factory.duration = self.default_duration
+
+
+        if factory not in self.sources.getSources() :
+            self.debug("Factory duration :%s", factory.duration)
+            self.sources.addFactory(factory)
+        
+        closure["rediscovered"] += 1
+        if closure["rediscovered"] == len(uris):
+            self._finishLoadingProject(project, duration)
+
+    def _discovererDiscoveryErrorCb(self, discoverer, uri, factory,
+            project, duration, uris, closure):
+        self.warning('Impossible to load %s'%uri)
+    
+    def _get_factory(self, image_name) :
+        _factory = None
+        for _source in self.sources.getSources() :
+            if _source.name == image_name :
+                _factory = _source
+                break
+        if _factory == None :
+            self.error("No factory found for %s", image_name)
+        return _factory
+
+    def _sourceAddedCb(self, sourcelist, factory):
+        #self.info("source added to timeline : %s %s"%(sourcelist, factory))
+        factory.setFilterCaps(self._videocaps)
+        factory.default_duration = self.default_duration
+        #        #timeline_object = self.timeline.addSourceFactory(factory)
+        #self.info("Object %s starts at %s", factory.name, timeline_object.start)
+        self.debug("RX source-added Source %s added -- %s", factory.name, factory)
+
+    def _sourceRemovedCb(self, sourcelist, uri, factory):
+        self.timeline.removeFactory(factory)
+        self.info('Source %s removed call back'%uri) 
+        # TODO : emit source-removed ? 
+        #self.emit('source-removed', uri, factory)
+
+    def getAutoSettings(self):
+        """
+        Computes and returns smart settings for the project.
+        If the project only has one source, it will be that source's settings.
+        If it has more than one, it will return the largest setting that suits
+        all contained sources.
+        """
+        settings = ExportSettings()
+        if not self.timeline:
+            self.warning\
+            ("project doesn't have a timeline, returning default settings")
+            return settings
+
+        # FIXME: this is ugly, but rendering for now assumes at most one audio
+        # and one video tracks
+        have_audio = have_video = False
+        for track in self.timeline.tracks:
+            if isinstance(track.stream, VideoStream) and track.duration != 0:
+                have_video = True
+            elif isinstance(track.stream, AudioStream) and track.duration != 0:
+                have_audio = True
+
+        if not have_audio:
+            settings.aencoder = None
+
+        if not have_video:
+            settings.vencoder = None
+
+        return settings
+

=== modified file 'luciole/ctrl/import_image.py'
--- luciole/ctrl/import_image.py	2010-09-04 15:17:48 +0000
+++ luciole/ctrl/import_image.py	2011-02-28 13:21:06 +0000
@@ -36,6 +36,9 @@
 # N/A
 import gobject
 
+from pitivi.signalinterface import Signallable
+from pitivi.log.loggable import Loggable
+
 # local application/library specific imports
 import luciole.base.exceptions as LEXCEP
 import luciole.base.tools as LT
@@ -62,6 +65,7 @@
         """ run thread """
         # create rush list object
         _image_objs = []
+        
         for (_index, _filename) in enumerate(self.__filenames) :
             # copy image to rush folder and resize it
             try : 
@@ -116,8 +120,11 @@
             LT.copyf(p_image_path, _ac_image_temp)
 
             # 2. resize image result is in _ac_image_temp_rz
-            _rz_obj = LI.ImageResize(_ac_image_temp, _ac_image_temp_rz )
-            _rz_obj.convert()
+            if self.__pjt_data['resize'] == 'yes' :
+                _rz_obj = LI.ImageResize(_ac_image_temp, _ac_image_temp_rz )
+                _rz_obj.convert()
+            else :
+                _ac_image_temp_rz = _ac_image_temp
             
             # 3. move resized image to rush dire 
             LT.movef(_ac_image_temp_rz, _rush_image)
@@ -127,7 +134,7 @@
         return _basename
  
 
-class ImportController(object):
+class ImportController(Signallable, Loggable):
     """ This class is used to manage the import of image in project .
         The class use a Thread for importing images (it can takes) long.
         The thread and this class communicate via a queue.
@@ -135,17 +142,21 @@
         The queue is checked cyclicly via a gobject timer
     """
     _TIMEOUT = 50        # 50 ms timer
-
-    def __init__(self, filenames, project_data, rusher, status_bar, cbs ) : 
+    __signals__ = {
+                    'import-image-done' : ['image_name'],
+                    }
+    def __init__(self, filenames, project_data, rusher, status_bar) : 
         """ Init Thread, init gobject timer and clear progressbar """
+        Signallable.__init__(self)
+        Loggable.__init__(self)
         self.__filenames = filenames
         self.__pjt_data = project_data
         self.__rusher = rusher
         self.__status_bar = status_bar
-        self.__cbs = cbs
 
         
         # initialize thread
+        self.debug('Starting thread')
         self.queue = Queue.Queue()
         self.t_rush = ImportThread(self.__filenames, 
                                     self.__pjt_data,
@@ -176,11 +187,15 @@
             pass
         else :
             if _qmsg.has_key('progression') : 
+                
+                self.debug(' on progress')
                 self._progress_bar_on_progress(_qmsg['progression'])
             if _qmsg.has_key('finish') :
                 # finisg project load ( Non threaded section )
-                self.__cbs['done-import'](_qmsg['finish'])
-                
+                self.debug('emit import-image-done : %s',_qmsg['finish'])
+                self.emit('import-image-done',  _qmsg['finish'])
+
+
                 #update as finsih staus/progress bard
                 self._progress_bar_complete()
                 # stop the timer
@@ -198,6 +213,7 @@
         _msg = _('All images imported')
         # use of idle_add because gui update not in the same thread
         self.__status_bar.stop(_msg)
+        
 
     def _progress_bar_on_progress(self, ratio = None):
         """ indicate that import  is going on """

=== modified file 'luciole/ctrl/load_rush.py'
--- luciole/ctrl/load_rush.py	2010-09-04 15:17:48 +0000
+++ luciole/ctrl/load_rush.py	2011-02-28 13:21:06 +0000
@@ -35,6 +35,7 @@
 
 # related third party imports
 import gobject
+from pitivi.signalinterface import Signallable
 
 # local application/library specific imports
 import luciole.media.image as LI
@@ -80,24 +81,27 @@
         self.queue.put(_qmsg, block=False)
 
 
-class ControllerLoadRush(object):
+class ControllerLoadRush(Signallable):
     """ This class is used to manage the load of a project in application.
         The class use a Thread for launch rush object init. (it can takes) long.
         The thread and this class communicate vai a queue. Information on queue are progression and finish.
         The queue is checked cyclicly via a gobject timer
     """
     _TIMEOUT = 10        # 10 ms timer
+    
+    __signals__ = {
+            "rush-loaded" : ["rush_obj"],
+            }
 
-    def __init__(self, project, status_bar, cb_on_finish)  : 
+    def __init__(self, project, status_bar)  : 
         """ Init Thread, init gobject timer and clear progressbar """
-        self.project = project
-        self._cb_on_finish = cb_on_finish 
-
+        Signallable.__init__(self)
+        self.project = project.props
         self.__status_bar = status_bar
         
         # initialize thread
         self.queue = Queue.Queue()
-        self.t_rush = RushLoaderThread(project, self.queue)
+        self.t_rush = RushLoaderThread(self.project, self.queue)
         
         #clear progressbar
         self._progress_bar_clear()
@@ -144,6 +148,7 @@
 
     def _progress_bar_complete(self):
         """ Progress bar full : Project loaded  """
+        # TODO : This message should not displayed here
         _msg = _( 'Project %s is loaded')%self.project['project_name'] 
         # use of idle_add because gui update not in the same thread
         self.__status_bar.stop(_msg)
@@ -157,7 +162,7 @@
     def _on_rush_finish(self, rush_obj):
         """ Finish the load after rush generation """
         # call back to indicate finish at controller
-        self._cb_on_finish(rush_obj)
+        self.emit("rush-loaded",rush_obj )
     
     
 

=== modified file 'luciole/ctrl/viewer_ctrl.py'
--- luciole/ctrl/viewer_ctrl.py	2010-09-06 09:00:55 +0000
+++ luciole/ctrl/viewer_ctrl.py	2011-02-28 13:21:06 +0000
@@ -225,7 +225,14 @@
             # send error message
             _msg =  _("Can not play animation : No image on montage view ")
             self.__gui.window.error_message(_msg)
-
+    
+    def play_query_position(self) : 
+        """ query position """
+        _position =  LCONST.CLOCK_TIME_NONE
+        _duration =  LCONST.CLOCK_TIME_NONE
+        if self.__mode == self.PLAYER :
+            (_position, _duration) = self.__lucio_player.query_postion()
+        return (_position, _duration)
 
     def play_video(self, app_data) :
         """ play a video  from chrono images """

=== added file 'luciole/data/images/white.jpg'
Binary files luciole/data/images/white.jpg	1970-01-01 00:00:00 +0000 and luciole/data/images/white.jpg	2011-02-28 13:21:06 +0000 differ
=== modified file 'luciole/data/templates/project_template.xml'
--- luciole/data/templates/project_template.xml	2010-03-30 07:18:34 +0000
+++ luciole/data/templates/project_template.xml	2011-02-28 13:21:06 +0000
@@ -3,7 +3,8 @@
   <metas>