path: root/cad/src/PM/PM_WidgetGrid.py

# Copyright 2007 Nanorex, Inc.  See LICENSE file for details.
"""
PM_WidgetGrid.py

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

History:

ninad 2007-08-14: Created.
"""


from PyQt4.Qt import QSizePolicy
from PyQt4.Qt import QSpacerItem
from PyQt4.Qt import QSize
from PyQt4.Qt import QLabel
from PyQt4.Qt import QToolButton
from PyQt4.Qt import QPushButton

from utilities.debug import print_compact_traceback
from utilities.icon_utilities import geticon

from PM.PM_GroupBox import PM_GroupBox


class PM_WidgetGrid( PM_GroupBox ):
    """
    The B{PM_WidgetGrid} provides a convenient way to create different
    types of widgets (such as ToolButtons, Labels, PushButtons etc) and
    arrange them in the grid layout of a B{PM_Groupbox}

    @see: B{Ui_MovePropertyManager} that uses B{PM_ToolButtonRow}, to create
    custom widgets (toolbuttons) arranged in a grid layout.

    """

    def __init__(self,
                 parentWidget,
                 title     = '',
                 widgetList = [],
                 alignment = None,
                 label = '',
                 labelColumn = 0,
                 spanWidth   = True
                 ):


        """
        Appends a PM_WidgetGrid (a group box widget) to the bottom of
        I{parentWidget},the Property Manager Group box.

        @param parentWidget: The parent group box containing this widget.
        @type  parentWidget: PM_GroupBox

        @param title: The group box title.
        @type  title: str

        @param widgetList: A list of I{widget info lists}. There is one widget
                           info list for each widget in the grid. The widget
                           info list contains custom information about the
                           widget but the following items are always present:
                           - First Item       : Widget Type (str),
                           - Second Last Item : Column (int),
                           - Last Item        : Row (int).
        @type  widgetList: list

        @param alignment:  The alignment of the widget row in the parent
                           groupbox. Based on its value,spacer items is added
                           to the grid layout of the parent groupbox.
        @type  alignment:  str

        @param label:      The label for the widget row. .
        @type  label:      str

        @param labelColumn: The column in the parentWidget's grid layout to
                            which this widget's label will be added.
                            The labelColum can only be E{0} or E{1}
        @type  labelColumn: int

        @param spanWidth: If True, the widget and its label will span the width
                         of the group box. Its label will appear directly above
                         the widget (unless the label is empty) and is left
                         justified.
        @type  spanWidth: bool (default False)


        """


        self.label = label
        self.labelColumn = labelColumn
        self.spanWidth = spanWidth

        if label: # Create this widget's QLabel.
            self.labelWidget = QLabel()
            self.labelWidget.setText(label)

        PM_GroupBox.__init__(self, parentWidget, title)

        # These are needed to properly maintain the height of the grid if
        # all labels in a row are hidden via hide().
        self.vBoxLayout.setMargin(0)
        self.vBoxLayout.setSpacing(0)

        self.gridLayout.setMargin(0)
        self.gridLayout.setSpacing(0)

        self.parentWidget = parentWidget
        self.widgetList   = widgetList

        self.alignment = alignment

        self.loadWidgets()

    def loadWidgets(self):
        """
        Creates the widgets (or spacers) in a grid layout of a B{PM_GroupBox}
        Then adds this group box to the grid layout of the I{parentWidget},
        which is again a B{PM_GroupBox} object.
        """

        for widgetInfo in self.widgetList:
            widgetInfoList = self.getWidgetInfoList(widgetInfo)
            widgetParams = list(widgetInfoList[0:-2])

            widgetOrSpacer = self._createWidgetUsingParameters(widgetParams)

            column  = widgetInfoList[-2]
            row     = widgetInfoList[-1]


            if widgetOrSpacer.__class__.__name__  ==  QSpacerItem.__name__:
                self.gridLayout.addItem( widgetOrSpacer,
                                       row,
                                       column,
                                       1,
                                       1 )
            else:
                self.gridLayout.addWidget( widgetOrSpacer,
                                           row,
                                           column,
                                           1,
                                           1 )


        self.parentWidget.addPmWidget(self)

    def getWidgetInfoList(self, widgetInfo):
        """
        Returns the widget information provided by the user.
        Subclasses should override this method if they need to provide
        custom information (e.g. a fixed value for row) .
        @param  widgetInfo: A list containing the widget information
        @type   widgetInfo: list

        @return: A list containing custom widget information.
                This can be same as I{widgetInfo} or can be modified further.
        @rtype: list
        @see:   B{PM_ToolButtonRow.getWidgetInfoList}

        """

        widgetInfoList = list(widgetInfo)
        return widgetInfoList


    def _createWidgetUsingParameters(self, widgetParams):
        """
        Returns a widget based on the I{widgetType}

        Subclasses can override this method.

        @param widgetParams: A list containing widget's parameters.
        @type  widgetParams: list

        @see: L{PM_ToolButtonGrid._createWidgetUsingParameters} which overrides
              this method.

        """
        widgetParams = list(widgetParams)

        widgetType = str(widgetParams[0])


        if widgetType[0:3] == "PM_":
            #The given widget is already defined using a class in PM_Module
            #so simply use the specified object
            #@see:Ui_BuildCrystal_PropertyManager._loadLayerPropertiesGroupBox
            #      for an example on how it is used.
            widget = widgetParams[1]
            return widget

        if widgetType == QToolButton.__name__:
            widget = self._createToolButton(widgetParams)
        elif widgetType == QPushButton.__name__:
            widget = self._createPushButton(widgetParams)
        elif widgetType == QLabel.__name__:
            widget = self._createLabel(widgetParams)
        elif widgetType == QSpacerItem.__name__:
            widget = self._createSpacer(widgetParams)
        else:
            msg1 = "Error, unknown/unsupported widget type. "
            msg2 = "Widget Grid can not be created"
            print_compact_traceback(msg1 + msg2)
            widget = None

        return widget

    def _createToolButton(self, widgetParams):
        """
        Returns a tool button created using the custom parameters.

        @param widgetParams: A list containing tool button parameters.
        @type  widgetParams: list

        @see: L{self._createWidgetUsingParameters} where this method is called.
        """

        buttonSize = QSize(32, 32) #@ FOR TEST ONLY

        buttonParams = list(widgetParams)
        buttonId       = buttonParams[1]
        buttonText     = buttonParams[2]
        buttonIconPath = buttonParams[3]
        buttonToolTip  = buttonParams[4]
        buttonShortcut = buttonParams[5]

        button = QToolButton(self)
        button.setText(buttonText)
        if buttonIconPath:
            buttonIcon = geticon(buttonIconPath)
            if not buttonIcon.isNull():
                button.setIcon(buttonIcon)
                button.setIconSize(QSize(22, 22))
        button.setToolTip(buttonToolTip)
        if buttonShortcut:
            button.setShortcut(buttonShortcut)

        button.setFixedSize(buttonSize) #@ Currently fixed to 32 x 32.
        button.setCheckable(True)
        return button


    def _createLabel(self, widgetParams):
        """
        Returns a label created using the custom parameters.

        @param widgetParams: A list containing label parameters.
        @type  widgetParams: list

        @see: L{self._createWidgetUsingParameters} where this method is called.
        """

        labelParams = list(widgetParams)
        labelText   = labelParams[1]
        label = QLabel(self)
        label.setText(labelText)
        return label

    def _createSpacer(self, widgetParams):
        """
        Returns a QSpacerItem created using the custom parameters.

        @param widgetParams: A list containing spacer parameters.
        @type  widgetParams: list

        @see: L{self._createWidgetUsingParameters} where this method is called.
        """
        spacerParams = list(widgetParams)
        spacerWidth = spacerParams[1]
        spacerHeight = spacerParams[2]

        spacer = QSpacerItem(spacerWidth,
                             spacerHeight,
                             QSizePolicy.MinimumExpanding,
                             QSizePolicy.Minimum
                         )
        return spacer




    # ==== Helper methods to add widgets/ spacers to the Grid Layout =====
    # NOTE:  Following helper methods ARE NOT used as of 2007-08-16. These will
    # be deleted or modified when a new HBoxLayout is introduced to the Groupbox
    #-- Ninad 2007-08-16

    def addWidgetToParentGridLayout(self):
        """
        Adds this widget (groupbox) to the parent widget's grid layout.
        ( The parent widget should be a groupbox)
        Example: If user specifies this widget's alignment as 'Center' then
        it adds Left spacer, this widget and the right spacer to the
        parentWidget's grid layout, in the current row.
        This method also increments the row number of the parentWidget's grid
        layout.
        @see: L{self.loadWidgets} which calls this method

        """

        row = self.parentWidget.getRowCount()
        column = 0

        #Add Left spacer to the parentWidget's layout
        if self.alignment and self.alignment != 'Left':
            self._addAlignmentSpacer(row, column)
            column += 1

        #Add the widget to the parentWidget's layout
        self.parentWidget.gridLayout.addWidget(self, row, column, 1, 1)

        #Add Right spacer to the parentWidget's layout
        if self.alignment and self.alignment != 'Right':
            self._addAlignmentSpacer(row, column + 1)

        #Increment the parent widget's row count
        self.parentWidget.incrementRowCount()

    def _addAlignmentSpacer(self, rowNumber, columnNumber):
        """
        Adds a alignment spacer to the parent widget's grid layout which also
        contain this classes widget.
        @see: L{self.addWidgetToParentGridLayout} for an example on how it is
              used.
        """
        row = rowNumber
        column = columnNumber
        spacer = QSpacerItem(10, 5, QSizePolicy.Expanding, QSizePolicy.Minimum)

        self.parentWidget.gridLayout.addItem( spacer, row, column, 1, 1 )