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

# Copyright 2004-2007 Nanorex, Inc.  See LICENSE file for details.
"""
$Id$

TODO:
- Does the parentWidget for the DnaFlyout always needs to be a propertyManager
  The parentWidget is the propertyManager object of the currentCommand on the
  commandSequencer. What if the currentCommand doesn't have a PM but it wants
  its own commandToolbar?  Use the mainWindow as its parentWidget?
- The implementation may change after Command Manager (Command toolbar) code
  cleanup. The implementation as of 2007-12-20 is an attempt to define
  flyouttoolbar object in the 'Command.
"""

import foundation.env as env
from PyQt4 import QtCore, QtGui
from PyQt4.Qt import Qt
from PyQt4.Qt import SIGNAL
from utilities.icon_utilities import geticon
from utilities.Log import greenmsg
from ne1_ui.NE1_QWidgetAction import NE1_QWidgetAction
from ne1_ui.toolbars.Ui_AbstractFlyout import Ui_AbstractFlyout

_superclass = Ui_AbstractFlyout
class DnaFlyout(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.buildDnaAction

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

    def getFlyoutActionList(self):
        """
        Returns a tuple that contains lists of actions used to create
        the flyout toolbar.
        Called by CommandToolbar._createFlyoutToolBar().
        @return: params: A tuple that contains 3 lists:
        (subControlAreaActionList, commandActionLists, allActionsList)
        """
        #'allActionsList' returns all actions in the flyout toolbar
        #including the subcontrolArea actions.
        allActionsList = []


        #Action List for  subcontrol Area buttons.
        subControlAreaActionList = []
        subControlAreaActionList.append(self.exitModeAction)
        separator = QtGui.QAction(self.parentWidget)
        separator.setSeparator(True)
        subControlAreaActionList.append(separator)
        subControlAreaActionList.append(self.dnaDuplexAction)
        subControlAreaActionList.append(self.breakStrandAction)
        subControlAreaActionList.append(self.joinStrandsAction)
        subControlAreaActionList.append(self.makeCrossoversAction)
        subControlAreaActionList.append(self.convertDnaAction)
        subControlAreaActionList.append(self.orderDnaAction)
        subControlAreaActionList.append(self.editDnaDisplayStyleAction)

        allActionsList.extend(subControlAreaActionList)

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

        params = (subControlAreaActionList, commandActionLists, allActionsList)

        return params

    def _createActions(self, parentWidget):
        """
        Overrides superclass method
        """

        _superclass._createActions(self, parentWidget)

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

        self.dnaDuplexAction = NE1_QWidgetAction(self.subControlActionGroup,
                                                 win = self.win)
        self.dnaDuplexAction.setText("Insert DNA")
        self.dnaDuplexAction.setCheckable(True)
        self.dnaDuplexAction.setIcon(
            geticon("ui/actions/Command Toolbar/BuildDna/InsertDna.png"))

        self.breakStrandAction = NE1_QWidgetAction(self.subControlActionGroup,
                                                   win = self.win)
        self.breakStrandAction.setText("Break Strand")
        self.breakStrandAction.setCheckable(True)
        self.breakStrandAction.setIcon(
            geticon("ui/actions/Command Toolbar/BuildDna/BreakStrand.png"))

        self.joinStrandsAction = NE1_QWidgetAction(self.subControlActionGroup,
                                                   win = self.win)
        self.joinStrandsAction.setText("Join Strands")
        self.joinStrandsAction.setCheckable(True)
        self.joinStrandsAction.setIcon(
            geticon("ui/actions/Command Toolbar/BuildDna/JoinStrands.png"))

        self.makeCrossoversAction = NE1_QWidgetAction(self.subControlActionGroup,
                                                      win = self.win)
        self.makeCrossoversAction.setText("Crossovers")
        self.makeCrossoversAction.setCheckable(True)
        self.makeCrossoversAction.setIcon(
            geticon("ui/actions/Command Toolbar/BuildDna/MakeCrossovers.png"))

        self.dnaOrigamiAction = NE1_QWidgetAction(self.subControlActionGroup,
                                                  win = self.win)
        self.dnaOrigamiAction.setText("Origami")
        self.dnaOrigamiAction.setIcon(
            geticon("ui/actions/Tools/Build Structures/DNA_Origami.png"))

        self.convertDnaAction = NE1_QWidgetAction(self.subControlActionGroup,
                                                      win = self.win)
        self.convertDnaAction.setText("Convert")
        self.convertDnaAction.setIcon(
            geticon("ui/actions/Command Toolbar/BuildDna/ConvertDna.png"))

        self.orderDnaAction = NE1_QWidgetAction(self.subControlActionGroup,
                                                win = self.win)
        self.orderDnaAction.setText("Order DNA")
        self.orderDnaAction.setIcon(
            geticon("ui/actions/Command Toolbar/BuildDna/OrderDna.png"))

        self.editDnaDisplayStyleAction = NE1_QWidgetAction(self.subControlActionGroup,
                                                           win = self.win)
        self.editDnaDisplayStyleAction.setText("Edit Style")
        self.editDnaDisplayStyleAction.setCheckable(True)
        self.editDnaDisplayStyleAction.setIcon(
            geticon("ui/actions/Command Toolbar/BuildDna/EditDnaDisplayStyle.png"))

        # Add the actions.
        self.subControlActionGroup.addAction(self.dnaDuplexAction)
        self.subControlActionGroup.addAction(self.breakStrandAction)
        self.subControlActionGroup.addAction(self.joinStrandsAction)
        self.subControlActionGroup.addAction(self.makeCrossoversAction)
        self.subControlActionGroup.addAction(self.editDnaDisplayStyleAction)

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

    def _addToolTipText(self):
        """
        Add 'Tool tip' help text for all actions on toolbar.
        """
        from ne1_ui.ToolTipText_for_CommandToolbars import toolTipTextForDnaCommandToolbar
        toolTipTextForDnaCommandToolbar(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

        _superclass.connect_or_disconnect_signals(self,
                                                  isConnect)

        change_connect(self.dnaDuplexAction,
                             SIGNAL("triggered(bool)"),
                             self.activateInsertDna_EditCommand)

        change_connect(self.breakStrandAction,
                             SIGNAL("triggered(bool)"),
                             self.activateBreakStrands_Command)

        change_connect(self.joinStrandsAction,
                             SIGNAL("triggered(bool)"),
                             self.activateJoinStrands_Command)

        change_connect(self.makeCrossoversAction,
                             SIGNAL("triggered(bool)"),
                             self.activateMakeCrossovers_Command)

        change_connect(self.dnaOrigamiAction,
                             SIGNAL("triggered()"),
                             self.activateDnaOrigamiEditCommand)

        change_connect(self.convertDnaAction,
                             SIGNAL("triggered()"),
                             self.convertDnaCommand)



        if 1: # the new way, with the "DNA Order" PM.
            change_connect(self.orderDnaAction,
                                 SIGNAL("triggered(bool)"),
                                 self.activateOrderDna_Command)
        else: # the old way (without the PM)
            change_connect(self.orderDnaAction,
                                 SIGNAL("triggered()"),
                                 self.orderDnaCommand)

        change_connect(self.editDnaDisplayStyleAction,
                             SIGNAL("triggered(bool)"),
                             self.activateDisplayStyle_Command)

    def ORIGINAL_activateFlyoutToolbar(self): #Unused as of 2008-08-13 (and onwards)
        #This method can be removed in the near future. Testing has not discovered
        #any new bugs after Ui_DnaFlyout was inherited from Ui_AbstractFlyout.
        """
        Updates the flyout toolbar with the actions this class provides.
        """
        if self._isActive:
            return

        self._isActive = True

        #Temporary workaround for bug 2600 .
        #until the Command Toolbar code is revised
        #When DnaFlyout toolbar is activated, it should switch to (check) the
        #'Build Button' in the control area. So that the DnaFlyout
        #actions are visible in the flyout area of the command toolbar.
        #-- Ninad 2008-01-21.
        #UPDATE 2008-04-12: There is a better fix available (see bug 2801)
        #That fix is likely to unnecessiate the following -- but not tested
        #well. After more testing, the following line of code can be removed
        #@see: CommandToolbar.check_controlAreaButton_containing_action -- Ninad

        self.win.commandToolbar.cmdButtonGroup.button(0).setChecked(True)
        #Now update the command toolbar (flyout area)
        self.win.commandToolbar.updateCommandToolbar(self.win.buildDnaAction,
                                                     self)
        #self.win.commandToolbar._setControlButtonMenu_in_flyoutToolbar(
                    #self.cmdButtonGroup.checkedId())
        self.exitDnaAction.setChecked(True)


        self.connect_or_disconnect_signals(True)



    def activateInsertDna_EditCommand(self, isChecked):
        """
        Slot for B{Duplex} action.
        """

        self.win.insertDna(isChecked)

        #IMPORTANT:
        #For a QAction, the method
        #setChecked does NOT emmit the 'triggered' SIGNAL. So
        #we can call self.breakStrandAction.setChecked without invoking its
        #slot method!
        #Otherwise we would have needed to block the signal when action is
        #emitted ..example we would have called something like :
        #'if self._block_dnaDuplexAction_event: return' at the beginning of this
        #method. Why we didn't use QAction group -- We need these actions to be
        # a) exclusive as well as
        #(b) 'toggle-able' (e.g. if you click on a checked action , it should
        #uncheck)
        #QActionGroup achieves (a) but can't do (b)

        #Uncheck all the actions except the dna duplex action
        #in the flyout toolbar (subcontrol area)
        for action in self.subControlActionGroup.actions():
            if action is not self.dnaDuplexAction and action.isChecked():
                action.setChecked(False)

    def activateBreakStrands_Command(self, isChecked):
        """
        Call the method that enters BreakStrands_Command.
        (After entering the command) Also make sure that
        all the other actions on the DnaFlyout toolbar are unchecked AND
        the BreakStrands Action is checked.
        """

        self.win.enterBreakStrandCommand(isChecked)

        #Uncheck all the actions except the break strands action
        #in the flyout toolbar (subcontrol area)
        for action in self.subControlActionGroup.actions():
            if action is not self.breakStrandAction and action.isChecked():
                action.setChecked(False)

    def activateJoinStrands_Command(self, isChecked):
        """
        Call the method that enters JoinStrands_Command. (After entering the
        command) Also make sure that all the other actions on the DnaFlyout
        toolbar are unchecked AND the JoinStrands Action is checked.
        """
        self.win.enterJoinStrandsCommand(isChecked)

        #Uncheck all the actions except the join strands action
        #in the flyout toolbar (subcontrol area)
        for action in self.subControlActionGroup.actions():
            if action is not self.joinStrandsAction and action.isChecked():
                action.setChecked(False)
            elif action is self.joinStrandsAction and not action.isChecked():
                pass
                #action.setChecked(True)

    def activateMakeCrossovers_Command(self, isChecked):
        """
        Call the method that enters JoinStrands_Command. (After entering the
        command) Also make sure that all the other actions on the DnaFlyout
        toolbar are unchecked AND the JoinStrands Action is checked.
        """
        self.win.enterMakeCrossoversCommand(isChecked)

        #Uncheck all the actions except the join strands action
        #in the flyout toolbar (subcontrol area)
        for action in self.subControlActionGroup.actions():
            if action is not self.makeCrossoversAction and action.isChecked():
                action.setChecked(False)
            elif action is self.makeCrossoversAction and not action.isChecked():
                pass
                #action.setChecked(True)

    def activateDnaOrigamiEditCommand(self):
        """
        Slot for B{Origami} action.
        """
        msg1 = greenmsg("DNA Origami: ")
        msg2 = "Not implemented yet."
        final_msg = msg1 + msg2
        env.history.message(final_msg)


    def convertDnaCommand(self):
        """
        Slot for B{Convert DNA} action.
        """
        cs = self.win.commandSequencer
        cs.userEnterCommand('CONVERT_DNA')
        return

    def orderDnaCommand(self):
        """
        Slot for B{Order DNA} action.
        @see: MWSemantics.orderDna
        """
        self.win.orderDna()
        return

    def activateOrderDna_Command(self, isChecked):
        """
        Call the method that enters OrderDna_Command.
        (After entering the command) Also make sure that
        all the other actions on the DnaFlyout toolbar are unchecked AND
        the DisplayStyle Action is checked.
        """

        self.win.enterOrderDnaCommand(isChecked)

        #Uncheck all the actions except the Order DNA action
        #in the flyout toolbar (subcontrol area)
        for action in self.subControlActionGroup.actions():
            if action is not self.editDnaDisplayStyleAction and action.isChecked():
                action.setChecked(False)

    def activateDisplayStyle_Command(self, isChecked):
        """
        Call the method that enters DisplayStyle_Command.
        (After entering the command) Also make sure that
        all the other actions on the DnaFlyout toolbar are unchecked AND
        the DisplayStyle Action is checked.
        """

        self.win.enterDnaDisplayStyleCommand(isChecked)

        #Uncheck all the actions except the (DNA) display style action
        #in the flyout toolbar (subcontrol area)
        for action in self.subControlActionGroup.actions():
            if action is not self.editDnaDisplayStyleAction and action.isChecked():
                action.setChecked(False)


    def resetStateOfActions(self):
        """
        See superclass for more documentation.

        Resets the state of actions in the flyout toolbar.
        It unchecks all the actions EXCEPT the ExitModeAction. This is called
        while resuming a command.

        This is called while resuming a command.

        Example: If Insert > Dna command is exited and 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: AbstractFlyout.resetStateOfActions()
        @see: baseCommand.command_update_flyout() which calls this method.
        """
        #Uncheck all the actions in the flyout toolbar (subcontrol area)
        for action in self.subControlActionGroup.actions():
            if action.isChecked():
                action.setChecked(False)