path: root/cad/src/commands/PlaneProperties/Plane_EditCommand.py

# Copyright 2007-2008 Nanorex, Inc.  See LICENSE file for details. 
"""
Plane_EditCommand.py

@author: Ninad
@copyright: 2007-2008 Nanorex, Inc.  See LICENSE file for details.
@version: $Id$

History:
ninad 20070606: Created.
ninad 2007-10-05: Refactored, Also renamed PlaneGenerator to Plane_EditCommand
                  while refactoring the old GeometryGeneratorBaseClass
ninad 2007-12-26: Changes to make Plane_EditCommand a command on command stack

Summer 2008: Urmi and Piotr added code to support image display and grid display
             within Plane objects.

@TODO 2008-04-15:
Note that Plane_EditCommand was originally implemented before the command 
sequencer was operational. This class and its Property Manager has some methods 
that need cleanup to matchup with the command/commandsequencer API. 
e.g. in its PM, the method update_props_if_needed_before_closing need to be 
revised because there is any easy way now, to know which command is currently 
active.Also a general clanup is due -- Ninad

TODO 2008-09-09
Refactor update ui related code. e.g. see self.command_will_exit() -- 
self.struct.updatecosmeticProps() should go inside a command_update method. 
[-- Ninad]

"""

from utilities.Log import greenmsg
from command_support.EditCommand import EditCommand
from commands.PlaneProperties.PlanePropertyManager import PlanePropertyManager
from model.Plane import Plane
from commands.SelectAtoms.SelectAtoms_GraphicsMode import SelectAtoms_GraphicsMode
from utilities.Comparison import same_vals
from utilities.debug import print_compact_stack

_superclass = EditCommand
class Plane_EditCommand(EditCommand):
    """
    The Plane_EditCommand class  provides an editCommand Object.
    The editCommand, depending on what client code needs it to do, may create 
    a new plane or it may be used for an existing plane. 
    """
    #@NOTE: self.struct is the Plane object
    
    PM_class = PlanePropertyManager
    
    GraphicsMode_class = SelectAtoms_GraphicsMode

    cmd = greenmsg("Plane: ")
    #
    prefix = '' # Not used by jigs.
    # All jigs like rotary and linear motors already created their
    # name, so do not (re)create it (in GeneratorBaseClass) from the prefix.
    create_name_from_prefix = False 
    #See Command.anyCommand for details about the following flags

    command_should_resume_prevMode = True
    command_has_its_own_PM = True
        # When <command_should_resume_prevMode> and <command_has_its_own_PM>
        # are both set to True (like here), want_confirmation_corner_type()
        # will determine that the confirmation corner should include the
        # Transient-Done image, which is sometimes OK and sometimes not OK.
        # This is what bug 2701 is about (assigned to me). I will talk to Ninad
        # and Bruce about fixing this (after Rattlesnake). 
        # --Mark 2008-03-24

    commandName = 'REFERENCE_PLANE'
    featurename = "Reference Plane"
    from utilities.constants import CL_EDIT_GENERIC
    command_level = CL_EDIT_GENERIC
    
    #see self.command_update_internal_state() 
    _previous_display_params = None

        
    def command_will_exit(self):
        #Following call doesn't update the struct with steps similar to 
        #ones in bug 2699. Instead calling struct.updateCosmeticProps directly
        #Note 2008-09-09: this code was copied from the former self.restore_gui. 
        #This needs to do inside an update method. 
        if self.hasValidStructure():            
            self.struct.updateCosmeticProps() 
            
        _superclass.command_will_exit(self)
        
    def _getStructureType(self):
        """
        Subclasses override this method to define their own structure type. 
        Returns the type of the structure this command supports. 
        This is used in isinstance test. 
        @see: EditCommand._getStructureType() (overridden here)
        """
        return Plane

    
    def placePlaneParallelToScreen(self):
        """
        Orient this plane such that it is placed parallel to the screen
        """
        self.struct.placePlaneParallelToScreen()


    def placePlaneThroughAtoms(self):
        """
        Orient this plane such that its center is same as the common center of 
        three or more selected atoms.
        """
        self.struct.placePlaneThroughAtoms()
        #NOTE: This log message can be used to either display a history message 
        #if using NE1 UI or for consol print when command is executed via 
        #command prompt. Its upto the client to use this message. This, 
        #however needs a global updater that will clear previous log message 
        #from this object, in order to avoid errors. (if in some cases, the 
        #logMessage is not there, client could accidentaly use garbage 
        #logMessage hanging out from some previous execution) 
        #This is subject to revision. May not be needed after once Logging 
        #facility (see Log.py) is fully implemented -- Ninad 20070921
        self.logMessage = self.cmd + self.struct.logMessage

    def placePlaneOffsetToAnother(self):
        """
        Orient the plane such that it is parallel to a selected plane , with an
        offset.
        """
        self.struct.placePlaneOffsetToAnother()
        self.logMessage = self.cmd + self.struct.logMessage


    ##=========== Structure Generator like interface ======##
    
    def _gatherParameters(self):
        """
        Return all the parameters from the Plane Property Manager.
        """
        width, height, gridColor, gridLineType, gridXSpacing, gridYSpacing, \
             originLocation,  displayLabelStyle = self.propMgr.getParameters()
    
        atmList =  self.win.assy.selatoms_list()
        
        #Do not change the plane placement here. ONLY do it when user explicitely
        #selects an option from the radio button list. This avoids bug 2949
        #but a side effect of this fix is that if user has already changed a 
        #radio button option , then makes some changes -- then the current placement
        #option won't have any effect. 
        ##self.propMgr.changePlanePlacement(
            ##self.propMgr.pmPlacementOptions.checkedId())        
        
        if self.struct:            
            ctr     =  self.struct.center 
            imagePath = self.struct.imagePath    
        else:
            ctr = None
            imagePath = ''
   
        
        return (width, height, ctr, atmList, imagePath, 
                gridColor, gridLineType, gridXSpacing, 
                gridYSpacing, originLocation, displayLabelStyle)
        
    def _createStructure(self):
        """
        Create a Plane object. (The model object which this edit controller 
        creates) 
        """
        assert not self.struct
               
        self.win.assy.part.ensure_toplevel_group()        
        struct = Plane(self.win, self)
        self.win.assy.place_new_geometry(struct)

        return struct


    def _modifyStructure(self, params):
        """
        Modifies the structure (Plane) using the provided params.
        @param params: The parameters used as an input to modify the structure
                       (Plane created using this Plane_EditCommand) 
        @type  params: tuple
        """
        assert self.struct
        assert params 
        assert len(params) == 11           
        width, height, center_junk, atmList_junk, imagePath, \
             gridColor, gridLineType, gridXSpacing, \
             gridYSpacing,  originLocation, displayLabelStyle = params
      
        self.struct.width   =  width        
        self.struct.height  =  height 
        self.struct.imagePath = imagePath
        self.struct.gridColor = gridColor
        self.struct.gridLineType = gridLineType
        self.struct.gridXSpacing = gridXSpacing
        self.struct.gridYSpacing = gridYSpacing        
        self.struct.originLocation = originLocation
        self.struct.displayLabelStyle = displayLabelStyle
                
        self.win.win_update() # Update model tree
        self.win.assy.changed()        

    ##=====================================##
    
    def command_update_internal_state(self):
        """
        Extends the superclass method.
        This method should replace model_changed() eventually. This method 
        calss self.model_changed at the moment.  
        @see:baseCommand.command_update_internal_state() for documentation
        
        @see: PlanePropertyManager._update_UI_do_updates()
        @see: PlanePropertyManager.update_spinboxes()
        @see: Plane.resizeGeometry()        
        """   
        
        if not self.propMgr:
            print_compact_stack("bug: self.propMgr not defined when"\
                "Plane_EditCommand.command_update_internal_state called."\
                "Returning.")
            return
        
        #check first if the plane object exists first
        if not self.hasValidStructure():
            return       
        
        #NOTE: The following ensures that the image path and other display 
        #prams are properly updated in the plane. Perhaps its better done using 
        #env.prefs? Revising this code to fix bugs in resizing because
        #of the self._modifyStructure call. See also original code in 
        #Revision 12982  -- Ninad 2008-09-19
                
        currentDisplayParams = self.propMgr.getCurrrentDisplayParams()
                
        if same_vals(currentDisplayParams, self._previous_display_params):
            return
        
        self._previous_display_params = currentDisplayParams
        
        params = self._gatherParameters()
        self._modifyStructure(params)
        
    def runCommand(self):
        """
        Overrides superclass method. 
        Run this edit command. This method is called when user invokes 
        Insert > Plane command (to create a new plane object) . In addition 
        to creating the Plane object and Property manager, this also updates
        the property manager values with the ones for the new Plane object. 
        
        @see: MWSemantics.createPlane() which calls this while inserting a 
        new Plane
        @see: self.editStructure()
        @see: PlanePropertyManager.setParameters()
        @see: self._updatePropMgrParams()
        @TODO: The code that updates the PropMgr params etc needs to be in the 
        EditCommand API method/
        
        """
        _superclass.runCommand(self)
        if self.hasValidStructure():             
            self._updatePropMgrParams()
            #Store the previous parameters. Important to set it after you 
            #set attrs in the propMgr. 
            #self.previousParams is used in self._previewStructure and 
            #self._finalizeStructure to check if self.struct changed.
            self.previousParams = self._gatherParameters()
        
    def editStructure(self, struct = None):
        """
        """
        _superclass.editStructure(self, struct)        
        if self.hasValidStructure():             
            self._updatePropMgrParams()

            #Store the previous parameters. Important to set it after you 
            #set attrs in the propMgr. 
            #self.previousParams is used in self._previewStructure and 
            #self._finalizeStructure to check if self.struct changed.
            self.previousParams = self._gatherParameters()
            
            
    def _updatePropMgrParams(self):
        """
        Subclasses may override this method. 
        Update some property manager parameters with the parameters of
        self.struct (which is being edited)
        @see: self.editStructure()
        """             
        
        params_for_propMgr = (self.struct.width, 
                              self.struct.height, 
                              self.struct.gridColor, 
                              self.struct.gridLineType, 
                              self.struct.gridXSpacing,
                              self.struct.gridYSpacing,
                              self.struct.originLocation,
                              self.struct.displayLabelStyle
                              )
        
        
        #TODO 2008-03-25: better to get all parameters from self.struct and
        #set it in propMgr?  This will mostly work but some params used in 
        #PM are not required by structy and vice versa. (e.g. struct.name)
      
        self.propMgr.setParameters(params_for_propMgr)