def __init__(self):
     """Constructor
     """
     BaseModeLogic.__init__(self)
     
     # view modes
     self._modes = {ois.KC_V: flash_modes.FlashDefaultViewMode(self)}
     self.switchMode(ois.KC_V)
     
     
     self.gui = render_engine._gui
     self.x, self.y = render_engine._ogreRenderWindow.getWidth(),render_engine._ogreRenderWindow.getHeight()
     self.panel = False
     self.isRoot = False
     
     self.playing = False        
     self.material = None
     self.swfFile = None
     self.mat_size = [1024, 1024]
     self.coord_mult = [1.0, 1.0]
     self.coord_offset = [0, 0]
     
     
     self.rectAttached = False
     self.listenersRegistered = False
     
     # creating rectangle (surface)
     self.rect_corners = [-1.0, 1.0, 1.0, -1.0]
     self.rect = None
     self._createRect()

 def _setSheet(self, _sheet):
     """Sets sheet for a logic
     """
     BaseModeLogic._setSheet(self, _sheet)
     
     _sheet.eventRootChanged = self._onRootChanged
     _sheet.eventUpdate = self._onUpdate
     
     
     # getting data from content and save to temporary file
     import os
     import suit.core.sc_utils as sc_utils
     
     _addr = _sheet._getScAddr()
     if _addr is None:   return
     
     kernel = Kernel.getSingleton()
     session = kernel.session()
     fmt = sc_utils.getContentFormat(session, _addr)
     assert fmt is not None
     file_name = "%s.%s" %(str(_addr.this), session.get_idtf(fmt).lower())
     
     # saving data to file
     _cont = session.get_content_const(_addr)
     assert _cont is not None
     _cont_data = _cont.convertToCont()
     data = _cont.get_data(_cont_data.d.size)
     
     path = os.path.join(kernel.cache_path, 'video')
     out_file = os.path.join(path, file_name)
     file(out_file, "wb").write(data)
     
     ogre.ResourceGroupManager.getSingleton().initialiseResourceGroup("video")
     self.setVideo(file_name)

    def _setSheet(self, _sheet):
        BaseModeLogic._setSheet(self, _sheet)
        
        _sheet.eventRootChanged = self._onRoot
        _sheet.eventContentUpdate = self._onContentUpdate
        
        # trying to get data for showing
        import suit.core.sc_utils as sc_utils
        session = core.Kernel.session()
        _addr = _sheet._getScAddr()   
        _fmt = sc_utils.getContentFormat(session, _addr)     
  
        assert _fmt is not None
        
        _cont = session.get_content_const(_addr)
        assert _cont is not None
        
        _cont_data = _cont.convertToCont()
        self.file_addr = _cont_data
        
        _type = session.get_idtf(_fmt).lower()
        global count
        count += 1
        
#        import os, pm.pm
#        self.imageName = os.path.join(env.res_tmp_dir, "%s.jpg" % str(_addr.this))
#        pm.pm.saveContentToFile(self.imageName + "%d.jpg" % count, _cont)

        
#        file(self.imageName + "_", "wb").write(_cont.get_data(_cont_data.d.size))
        
        """data = _cont.get_data(_cont_data.d.size)

    def _onRootChanged(self, isRoot):
        """Root changed event
        """
        global prev_background
        global prev_back_visible
        BaseModeLogic._onRootChanged(self, isRoot)
        if isRoot:
            render_engine.setMode(render_engine.Mode_Perspective)            
            self.prev_cam_pos = render_engine._ogreCameraNode.getPosition()
            self.prev_cam_dir = render_engine._ogreCameraNode.getOrientation()
            prev_background = render_engine._ogreViewport.getBackgroundColour()
            render_engine._ogreViewport.setBackgroundColour(ogre.ColourValue(0, 0, 0)) 
#            space_panel.activate(self._getSheet().getChilds())
            prev_back_visible = render_engine.SceneManager.isBackVisible()
            if prev_back_visible:
                render_engine.SceneManager.hideBack()
        else:
            render_engine.setMode(render_engine.Mode_Isometric)
            render_engine._ogreCameraNode.setPosition(self.prev_cam_pos)
            render_engine._ogreCameraNode.setOrientation(self.prev_cam_dir)
            render_engine._ogreViewport.setBackgroundColour(prev_background)
#            space_panel.deactivate()
            space_window.deactivate()
            
            if prev_back_visible:
                render_engine.SceneManager.showBack()
        self.is_root = isRoot                

    def __init__(self):
        """Constructor
        """
        BaseModeLogic.__init__(self)
        #ogre.FrameListener.__init__(self)
        self.gui = render_engine._gui
        self.x, self.y = render_engine._ogreRenderWindow.getWidth(), render_engine._ogreRenderWindow.getHeight()
        self.panel = False
        self.wpanel = None
        self.isRoot = False
        #self.kernel.ogreRoot.addFrameListener(self)
        # video player
        self.videoPlayer = None
        self.videoFile = ""
        self.materialName = None
        self.playing = False
        self.runTime = 0
        self.needUpdateMaterial = True
        
        # attach flags
#        self.listenerRegistered = False
        self.rectAttached = False
        
        # creating rectangle (surface)
        self.rect = ogre.Rectangle2D(True)
        self.rect.setCorners(-1.0, 1.0, 1.0, -1.0)
        self.rect.setRenderQueueGroup(ogre.RENDER_QUEUE_8)
        self.rect.setBoundingBox(ogre.AxisAlignedBox(ogre.Vector3(-100000.0, -100000.0, -100000.0), ogre.Vector3(100000.0, 100000.0, 100000.0)))

 def __init__(self):
     BaseModeLogic.__init__(self)
     
     self._old_color_back = None
     
     import ogre.io.OIS as ois
     self.appendMode(ois.KC_V, chem_modes.ChemistryViewMode(self))
     self.switchMode(ois.KC_V)

    def _setSheet(self, _sheet):
        """Sets sheet that controls by this logic
        """
        BaseModeLogic._setSheet(self, _sheet)

        _sheet.eventContentUpdate = self._onContentUpdate

        self.createTextureAndMaterialNames()

    def __init__(self):
        BaseModeLogic.__init__(self)
        
        # view modes
        self._modes = {}
        self.mode = None

        self.is_root = False    # flag for root mode, need to store there for grow speed up

 def _setSheet(self, _sheet):
     BaseModeLogic._setSheet(self, _sheet)
     
     _sheet.eventRootChanged = self._onRootChanged
     _sheet.eventContentUpdate = self._onContentUpdate
     
     import suit.core.layout.LayoutGroupForceDirected as layout
     _sheet.setLayoutGroup(layout.LayoutGroupForceSimple())

 def _setSheet(self, _sheet):
     BaseModeLogic._setSheet(self, _sheet)
     
     _sheet.eventRootChanged = self._onRootChanged
     _sheet.eventUpdate = self._onUpdate
     _sheet.eventObjectUnderMouse = self._getObjectsUnderMouse
     _sheet.eventContentUpdate = self._onContentUpdate
     _sheet.eventHaveChild = self._haveChild

 def _setSheet(self, _sheet):
     BaseModeLogic._setSheet(self, _sheet)
     
     _sheet.eventRootChanged = self._onRoot
             
     self._createFieldFromContent()                
     self._createMaterial()
     self.rect.setMaterial(self.getMaterialName())
     self._redraw()

 def _setSheet(self, _sheet):
     # process event to viewer
     self._viewer._setSheet(_sheet)
     
     BaseModeLogic._setSheet(self, _sheet)
     
     #subscribe events
     _sheet.eventRootChanged = self._onRootChanged
     _sheet.eventUpdate = self._onUpdate

 def _setSheet(self, _sheet):
     """Notification on sheet changed
     
     @param _sheet: new sheet controlled by logic
     @type _sheet: objects.ObjectSheet 
     """
     self._viewer._setSheet(_sheet)
     BaseModeLogic._setSheet(self, _sheet)
     
     _sheet.eventRootChanged = self._onRootChanged

    def __init__(self):
        """constructor
        """
        
        BaseModeLogic.__init__(self)
        # view modes
#        self.appendMode(ois.KC_X, FlyMode(self))
#        self._active_mode = self._modes[ois.KC_X]
        self.appendMode(ois.KC_S, SpaceViewMode(self))
        self.switchMode(ois.KC_S)
        self.is_root = False

 def __init__(self):
     """Constructor
     """
     BaseModeLogic.__init__(self)
     
     # addr of viewed set
     self.view_set_addr = None
     
     # view modes
     self.appendMode(ois.KC_V, scg_modes.SCgViewMode(self))
     self.switchMode(ois.KC_V)

 def _onRootChanged(self, _isRoot):
     """Root state changed event
     @param _isRoot: new root state
     @type _isRoot: bool  
     """
     BaseModeLogic._onRootChanged(self, _isRoot)
     
     if _isRoot:
         render_engine.SceneManager.setBackMaterial("Back/Lime")
     else:
         render_engine.SceneManager.setDefaultBackMaterial()  

 def __del__(self):
     """Destructor
     """
     
     self._destroyControl()
     
     if self.rectAttached:
         self.sceneNodeChilds.detachObject(self.rect)
         
     self.destroyPanel()
     BaseModeLogic.__del__(self)        

 def delete(self):
     """Deletion message
     """
     BaseModeLogic.delete(self)
     
     if self.sceneNodeRect is not None:
         render_engine.SceneManager.destroySceneNode(self.sceneNodeRect)
     
     if self.material is not None:   self._destroyMaterial()
     if self.texture is not None:    self._destroyTexture()
     
     self._destroyRect()

    def __init__(self, _viewer = None):
        BaseModeLogic.__init__(self)
        
        if not _viewer:
            self._viewer = ChemistryViewer()
        else:
            raise RuntimeError("Chemistry editor doesn't support existing viewers for now")
        
        self.mergeModes(self._viewer)

        import ogre.io.OIS as ois
        self.appendMode(ois.KC_E, chem_modes.ChemistryEditMode(self))
        self.switchMode(ois.KC_E)

 def __init__(self):        
     '''
     Constructor
     '''
     BaseModeLogic.__init__(self)
     
     # texture object 
     self.texture = None
     self.imageName = None
     self.sceneNodeRect = render_engine.SceneManager.createSceneNode()
     
     self.rect = None
     self._createRect()