path: root/cad/src/ne1_ui/toolbars/Ui_BuildAtomsFlyout.py

# Copyright 2008 Nanorex, Inc.  See LICENSE file for details.
"""

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

History:
- 2008-07-29 created. Moved related code from BuildAtoms_Command to this new class
NOTE THAT THIS CLASS IS NOT YET USED ANYWHERE. As of 2008-07-29,
BuildAtoms_Command continues to use its own methods to update the flyout toolbar
Eventually this class will be used to do that part.


TODO:

- This may be revised heavily during the command toolbar cleanup project.
The current class refactors the related code from class BuildAtoms_Command

@Note: The class name is BuildAtomsFlyout -- this provides the flyout toolbar
for class BuildAtoms_Command

"""
from ne1_ui.NE1_QWidgetAction import NE1_QWidgetAction
from PyQt4.Qt import SIGNAL
from PyQt4.Qt import QAction
from PyQt4.Qt import QActionGroup


from utilities.icon_utilities import geticon

from ne1_ui.toolbars.Ui_AbstractFlyout import Ui_AbstractFlyout
from utilities.debug import print_compact_stack

_superclass = Ui_AbstractFlyout

class BuildAtomsFlyout(Ui_AbstractFlyout):

    def _action_in_controlArea_to_show_this_flyout(self):
        """
        Required action in the 'Control Area' as a reference for this
        flyout toolbar. See superclass method for documentation and todo note.
        """
        return self.win.toolsDepositAtomAction


    def _getExitActionText(self):
        """
        Overrides superclass method.
        @see: self._createActions()
        """
        return "Exit Atoms"


    def getFlyoutActionList(self):
        """
        Returns a tuple that contains mode spcific actionlists in the
        added in the flyout toolbar of the mode.
        CommandToolbar._createFlyoutToolBar method calls this
        @return: params: A tuple that contains 3 lists:
        (subControlAreaActionList, commandActionLists, allActionsList)
        """

        #ninad070330 This implementation may change in future.

        #'allActionsList' returns all actions in the flyout toolbar
        #including the subcontrolArea actions.
        allActionsList = []
        #Action List for  subcontrol Area buttons.
        #For now this list is just used to set a different palette to thisaction
        #buttons in the toolbar
        subControlAreaActionList =[]


        #Append subcontrol area actions to  subControlAreaActionList
        #The 'Exit button' althought in the subcontrol area, would
        #look as if its in the Control area because of the different color
        #palette
        #and the separator after it. This is intentional.
        subControlAreaActionList.append(self.exitModeAction)
        separator1 = QAction(self.win)
        separator1.setSeparator(True)
        subControlAreaActionList.append(separator1)

        subControlAreaActionList.append(self.atomsToolAction)
        subControlAreaActionList.append(self.bondsToolAction)
        separator = QAction(self.win)
        separator.setSeparator(True)
        subControlAreaActionList.append(separator)

        #Also add the subcontrol Area actions to the 'allActionsList'
        for a in subControlAreaActionList:
            allActionsList.append(a)
        ##actionlist.append(self.win.modifyAdjustSelAction)
        ##actionlist.append(self.win.modifyAdjustAllAction)

        #Ninad 070330:
        #Command Actions : These are the actual actions that will respond the
        #a button pressed in the 'subControlArea (if present).
        #Each Subcontrol area button can have its own 'command list'
        #The subcontrol area buuton and its command list form a 'key:value pair
        #in a python dictionary object
        #In Build mode, as of 070330 we have 3 subcontrol area buttons
        #(or 'actions)'
        commandActionLists = []

        #Append empty 'lists' in 'commandActionLists equal to the
        #number of actions in subControlArea
        for i in range(len(subControlAreaActionList)):
            lst = []
            commandActionLists.append(lst)

        #Command list for the subcontrol area button 'Atoms Tool'
        #For others, this list will remain empty for now -- ninad070330
        depositAtomsCmdLst = []
        depositAtomsCmdLst.append(self.win.modifyHydrogenateAction)
        depositAtomsCmdLst.append(self.win.modifyDehydrogenateAction)
        depositAtomsCmdLst.append(self.win.modifyPassivateAction)
        separatorAfterPassivate = QAction(self.win)
        separatorAfterPassivate.setSeparator(True)
        depositAtomsCmdLst.append(separatorAfterPassivate)
        depositAtomsCmdLst.append(self.transmuteAtomsAction)
        separatorAfterTransmute = QAction(self.win)
        separatorAfterTransmute.setSeparator(True)
        depositAtomsCmdLst.append(separatorAfterTransmute)
        depositAtomsCmdLst.append(self.win.modifyDeleteBondsAction)
        depositAtomsCmdLst.append(self.win.modifySeparateAction)
        depositAtomsCmdLst.append(self.win.makeChunkFromSelectedAtomsAction)

        commandActionLists[2].extend(depositAtomsCmdLst)

        ##for action in self.win.buildToolsMenu.actions():
            ##commandActionLists[2].append(action)

        # Command list for the subcontrol area button 'Bonds Tool'
        # For others, this list will remain empty for now -- ninad070405
        bondsToolCmdLst = []
        bondsToolCmdLst.append(self.bond1Action)
        bondsToolCmdLst.append(self.bond2Action)
        bondsToolCmdLst.append(self.bond3Action)
        bondsToolCmdLst.append(self.bondaAction)
        bondsToolCmdLst.append(self.bondgAction)
        bondsToolCmdLst.append(self.cutBondsAction)
        commandActionLists[3].extend(bondsToolCmdLst)

        params = (subControlAreaActionList, commandActionLists, allActionsList)

        return params


    def _createActions(self, parentWidget):
        """
        Define flyout toolbar actions for this mode.
        """
        #@NOTE: In Build mode, some of the actions defined in this method are also
        #used in Build Atoms PM. (e.g. bond actions) So probably better to rename
        #it as _init_modeActions. Not doing that change in mmkit code cleanup
        #commit(other modes still implement a method by same name)-ninad20070717

        _superclass._createActions(self, parentWidget)

        # The subControlActionGroup is the parent of all flyout QActions.
        self.subControlActionGroup = QActionGroup(parentWidget)
            # Shouldn't the parent be self.win?
            # Isn't parentWidget = BuildAtomsPropertyManager.
            # Ask Bruce about this. --Mark 2008-12-07.

        self.subControlActionGroup.setExclusive(True)

        #Following Actions are added in the Flyout toolbar.
        #Defining them outside that method as those are being used
        #by the subclasses of deposit mode (testmode.py as of 070410) -- ninad

        self.atomsToolAction = \
            NE1_QWidgetAction(self.subControlActionGroup, win = self.win)
        self.atomsToolAction.setText("Atoms Tool")
        self.atomsToolAction.setIcon(geticon(
            "ui/actions/Command Toolbar/BuildAtoms/AtomsTool.png"))
        self.atomsToolAction.setCheckable(True)
        self.atomsToolAction.setChecked(True)
        self.atomsToolAction.setObjectName('ACTION_ATOMS_TOOL')


        self.bondsToolAction = \
            NE1_QWidgetAction(self.subControlActionGroup, win = self.win)
        self.bondsToolAction.setText("Bonds Tool")
        self.bondsToolAction.setIcon(geticon(
            "ui/actions/Command Toolbar/BuildAtoms/BondsTool.png"))
        self.bondsToolAction.setCheckable(True)
        self.bondsToolAction.setObjectName('ACTION_BOND_TOOL')


        self.subControlActionGroup.addAction(self.atomsToolAction)
        self.subControlActionGroup.addAction(self.bondsToolAction)

        self.transmuteAtomsAction = \
            NE1_QWidgetAction(self.subControlActionGroup, win = self.win)
        self.transmuteAtomsAction.setText("Transmute Atoms")
        self.transmuteAtomsAction.setIcon(geticon(
            "ui/actions/Command Toolbar/BuildAtoms/TransmuteAtoms.png"))
        self.transmuteAtomsAction.setCheckable(False)


        self._createBondToolActions(parentWidget)

    def _createBondToolActions(self, parentWidget):
        """
        Create the actions to be included in flyout toolbar , when the 'bonds
        tool' is active. Note that the object names of these action will be
        be used to find the Bond Tool type to which each action corresponds to.

        @see: self._createActions() where this is called.
        """
        self.bondToolsActionGroup = QActionGroup(parentWidget)
        self.bondToolsActionGroup.setExclusive(True)

        self.bond1Action = \
            NE1_QWidgetAction(self.bondToolsActionGroup, win = self.win)
        self.bond1Action.setText("Single")
        self.bond1Action.setIcon(geticon("ui/actions/Command Toolbar/BuildAtoms/SingleBond.png"))
        self.bond1Action.setObjectName('ACTION_SINGLE_BOND_TOOL')

        self.bond2Action = \
            NE1_QWidgetAction(self.bondToolsActionGroup, win = self.win)
        self.bond2Action.setText("Double")
        self.bond2Action.setIcon(geticon("ui/actions/Command Toolbar/BuildAtoms/DoubleBond.png"))
        self.bond2Action.setObjectName('ACTION_DOUBLE_BOND_TOOL')

        self.bond3Action = \
            NE1_QWidgetAction(self.bondToolsActionGroup, win = self.win)
        self.bond3Action.setText("Triple")
        self.bond3Action.setIcon(geticon("ui/actions/Command Toolbar/BuildAtoms/TripleBond.png"))
        self.bond3Action.setObjectName('ACTION_TRIPLE_BOND_TOOL')

        self.bondaAction = \
            NE1_QWidgetAction(self.bondToolsActionGroup, win = self.win)
        self.bondaAction.setText("Aromatic")
        self.bondaAction.setIcon(geticon("ui/actions/Command Toolbar/BuildAtoms/AromaticBond.png"))
        self.bondaAction.setObjectName('ACTION_AROMATIC_BOND_TOOL')

        self.bondgAction = \
            NE1_QWidgetAction(self.bondToolsActionGroup, win = self.win)
        self.bondgAction.setText("Graphitic")
        self.bondgAction.setIcon(geticon("ui/actions/Command Toolbar/BuildAtoms/GraphiticBond.png"))
        self.bondgAction.setObjectName('ACTION_GRAPHITIC_BOND_TOOL')

        self.cutBondsAction = \
            NE1_QWidgetAction(self.bondToolsActionGroup, win = self.win)
        self.cutBondsAction.setText("Cut Bonds")
        self.cutBondsAction.setIcon(geticon("ui/actions/Command Toolbar/BuildAtoms/CutBonds.png"))
        self.cutBondsAction.setObjectName('ACTION_DELETE_BOND_TOOL')

        for action in [self.bond1Action,
                       self.bond2Action,
                       self.bond3Action,
                       self.bondaAction,
                       self.bondgAction,
                       self.cutBondsAction
                       ]:
            self.bondToolsActionGroup.addAction(action)
            action.setCheckable(True)

        return

    def _addWhatsThisText(self):
        """
        Add 'What's This' help text for all actions on toolbar.
        """
        from ne1_ui.WhatsThisText_for_CommandToolbars import whatsThisTextForAtomsCommandToolbar
        whatsThisTextForAtomsCommandToolbar(self)
        return

    def _addToolTipText(self):
        """
        Add 'Tool tip' help text for all actions on toolbar.
        """
        from ne1_ui.ToolTipText_for_CommandToolbars import toolTipTextForAtomsCommandToolbar
        toolTipTextForAtomsCommandToolbar(self)
        return


    def connect_or_disconnect_signals(self, isConnect):
        """
        Connect or disconnect widget signals sent to their slot methods.
        This can be overridden in subclasses. By default it does nothing.
        @param isConnect: If True the widget will send the signals to the slot
                          method.
        @type  isConnect: boolean

        @see: self.activateFlyoutToolbar, self.deActivateFlyoutToolbar
        """
        if isConnect:
            change_connect = self.win.connect
        else:
            change_connect = self.win.disconnect

        #Ui_AbstractFlyout connects the self.exitmodeAction, so call it first.
        _superclass.connect_or_disconnect_signals(self, isConnect)

        #Atom , Bond Tools Groupbox
        change_connect(self.bondToolsActionGroup,
                       SIGNAL("triggered(QAction *)"),
                       self.command.changeBondTool)

        change_connect(self.transmuteAtomsAction,
                        SIGNAL("triggered()"),self.command.transmutePressed)

        change_connect(self.subControlActionGroup,
                       SIGNAL("triggered(QAction *)"),
                       self.updateCommandToolbar)

        change_connect(self.bondsToolAction,
                       SIGNAL("triggered()"),
                       self._activateBondsTool)

        change_connect(self.atomsToolAction,
                       SIGNAL("triggered()"),
                       self._activateAtomsTool)


    def get_cursor_id_for_active_tool(self):
        """
        Provides a cursor id (int) for updating cursor in graphics mode,
        based on the checked action in its flyout toolbar. (i.e. based on the
        active tool)
        @see: BuildAtoms_GraphicsMode.update_cursor_for_no_MB_selection_filter_disabled
        """
        if self.atomsToolAction.isChecked():
            cursor_id = 0
        elif self.bond1Action.isChecked():
            cursor_id = 1
        elif self.bond2Action.isChecked():
            cursor_id = 2
        elif self.bond3Action.isChecked():
            cursor_id = 3
        elif self.bondaAction.isChecked():
            cursor_id = 4
        elif self.bondgAction.isChecked():
            cursor_id = 5
        elif self.cutBondsAction.isChecked():
            cursor_id = 6
        else:
            cursor_id = 0

        return cursor_id


    def _activateAtomsTool(self):
        """
        Activate the atoms tool of the Build Atoms mode
        hide only the Atoms Tools groupbox in the Build Atoms Property manager
        and show all others the others.
        """
        self.command.activateAtomsTool()


    def _activateBondsTool(self):
        """
        Activate the bond tool of the Build Atoms mode
        Show only the Bond Tools groupbox in the Build Atoms Property manager
        and hide the others.
        @see:self._convert_bonds_bet_selected_atoms()
        """
        self.command.activateBondsTool()


    def getBondToolActions(self):
        return self.bondToolsActionGroup.actions()

    def getCheckedBondToolAction(self):
        return self.bondToolsActionGroup.checkedAction()

    def resetStateOfActions(self):
        """
        Default implementation does nothing. Overridden in subclasses.

        R Resets the state of actions in the flyout toolbar.
        Generally, it unchecks all the actions except the ExitModeAction.
        This is called while resuming a command.


        Example: if exits is in Insert > Dna command,
        the Build > Dna command is resumed. When this happens, program needs to
        make sure that the Insert > dna button in the flyout is unchecked.
        It is done by using this method.

        @see: self.deActivateFlyoutToolbar()
        @see: self.activateBreakStrands_Command()

        @see: baseCommand.command_update_flyout() which calls this method.
        @see: BuildAtoms_Command.command_update_state()
        @see: BuildAtoms_Command.activateAtomsTool()
        """
        self.atomsToolAction.setChecked(True)
        ##self.bondsToolAction.setChecked(False)
        for action in self.bondToolsActionGroup.actions():
            action.setChecked(False)