path: root/cad/src/ne1_ui/cursors.py

# Copyright 2004-2007 Nanorex, Inc.  See LICENSE file for details.
"""
cursors.py - load all the custom cursors needed by NE1

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

mark 060427 - loadCursors() moved from MWsemantics.py.

To do: (Mark)
- Find and replace all uses of self.o.setCursor(QCursor(Qt.ArrowCursor)) with
self.o.setCursor(win.ArrowCursor)).
- Replace all bitmap cursors with color PNG cursors.
"""

from PyQt4.Qt import QCursor, QBitmap, Qt, QPainter, QApplication
import os, sys

from utilities.icon_utilities import getCursorPixmap

def showWaitCursor(on_or_off):
    """
    Show the wait cursor or revert to the prior cursor if the current cursor
    is the wait cursor.

    For on_or_off True, set the main window waitcursor.
    For on_or_off False, revert to the prior cursor.

    [It might be necessary to always call it in matched pairs,
     I don't know [bruce 050401].]
    """
    if on_or_off:
        QApplication.setOverrideCursor( QCursor(Qt.WaitCursor) )
    else:
        QApplication.restoreOverrideCursor() # Restore the cursor
    return

def loadCursors(w):
    """
    This routine is called once to load all the custom cursors needed by NE1.
    """

    filePath = os.path.dirname(os.path.abspath(sys.argv[0]))

    # Pencil symbols.
    w.addSymbol = QCursor(getCursorPixmap("symbols/PlusSign.png"), 0, 0)
    w.subtractSymbol = QCursor(getCursorPixmap("symbols/MinusSign.png"), 0, 0)

    # Selection lock symbol
    w.selectionLockSymbol = \
     QCursor(getCursorPixmap("symbols/SelectionLock.png"), 0, 0)

    # Pencil symbols.
    horizontalSymbol = \
        QCursor(getCursorPixmap("symbols/HorizontalSnap.png"), 0, 0)
    verticalSymbol = \
        QCursor(getCursorPixmap("symbols/VerticalSnap.png"), 0, 0)

    # Pencil cursors
    w.colorPencilCursor = QCursor(getCursorPixmap("Pencil.png"), 0, 0)

    w.pencilHorizontalSnapCursor = \
        createCompositeCursor(w.colorPencilCursor, horizontalSymbol,
                              offsetX = 22, offsetY = 22)
    w.pencilVerticalSnapCursor = \
        createCompositeCursor(w.colorPencilCursor, verticalSymbol,
                              offsetX = 22, offsetY = 22)

    # Select Chunks cursors
    w.SelectArrowCursor = \
     QCursor(getCursorPixmap("SelectArrowCursor.png"), 0, 0)
    w.SelectArrowAddCursor = \
     createCompositeCursor(w.SelectArrowCursor, w.addSymbol,
                           offsetX = 12, offsetY = 0)
    w.SelectArrowSubtractCursor = \
     createCompositeCursor(w.SelectArrowCursor, w.subtractSymbol,
                           offsetX = 12, offsetY = 0)

    # Build Atoms - normal cursors
    w.SelectAtomsCursor = \
     QCursor(getCursorPixmap("SelectAtomsCursor.png"), 0, 0)

    w.SelectAtomsAddCursor = \
     createCompositeCursor(w.SelectAtomsCursor, w.addSymbol,
                           offsetX = 12, offsetY = 0)
    w.SelectAtomsSubtractCursor = \
     createCompositeCursor(w.SelectAtomsCursor, w.subtractSymbol,
                           offsetX = 12, offsetY = 0)
    w.DeleteCursor = \
     QCursor(getCursorPixmap("DeleteCursor.png"), 0, 0)

    # Build Atoms - Atom Selection Filter cursors
    w.SelectAtomsFilterCursor = \
     QCursor(getCursorPixmap("SelectAtomsFilterCursor.png"), 0, 0)

    w.SelectAtomsAddFilterCursor = \
     createCompositeCursor(w.SelectAtomsFilterCursor, w.addSymbol,
                           offsetX = 12, offsetY = 0)
    w.SelectAtomsSubtractFilterCursor = \
     createCompositeCursor(w.SelectAtomsFilterCursor, w.subtractSymbol,
                           offsetX = 12, offsetY = 0)

    w.DeleteAtomsFilterCursor = \
     QCursor(getCursorPixmap("DeleteAtomsFilterCursor.png"), 0, 0)

    # Build Atoms - Bond Tool cursors with no modkey pressed
    w.BondToolCursor = []
    w.BondToolCursor.append(QCursor(getCursorPixmap("SelectAtomsCursor.png"), 0, 0))
    w.BondToolCursor.append(QCursor(getCursorPixmap("Bond1ToolCursor.png"), 0, 0))
    w.BondToolCursor.append(QCursor(getCursorPixmap("Bond2ToolCursor.png"), 0, 0))
    w.BondToolCursor.append(QCursor(getCursorPixmap("Bond3ToolCursor.png"), 0, 0))
    w.BondToolCursor.append(QCursor(getCursorPixmap("BondAToolCursor.png"), 0, 0))
    w.BondToolCursor.append(QCursor(getCursorPixmap("BondGToolCursor.png"), 0, 0))
    w.BondToolCursor.append(QCursor(getCursorPixmap("CutBondCursor.png"), 0, 0))

    # Build Atoms - Bond Tool cursors with Shift modkey pressed
    w.BondToolAddCursor = []
    for cursor in w.BondToolCursor:
        w.BondToolAddCursor.append(
            createCompositeCursor(cursor, w.addSymbol,
                                  offsetX = 12, offsetY = 0))

    # Build Atoms - Bond Tool cursors with Control/Cmd modkey pressed
    w.BondToolSubtractCursor = []
    for cursor in w.BondToolCursor:
        w.BondToolSubtractCursor.append(
            createCompositeCursor(cursor, w.subtractSymbol,
                                  offsetX = 12, offsetY = 0))

    # Translate selection cursors
    w.TranslateSelectionCursor = \
     QCursor(getCursorPixmap("TranslateSelectionCursor.png"), 0, 0)
    w.TranslateSelectionAddCursor = \
     createCompositeCursor(w.TranslateSelectionCursor, w.addSymbol,
                           offsetX = 12, offsetY = 0)
    w.TranslateSelectionSubtractCursor = \
     createCompositeCursor(w.TranslateSelectionCursor, w.subtractSymbol,
                           offsetX = 12, offsetY = 0)

    # Rotate selection cursors
    w.RotateSelectionCursor = \
     QCursor(getCursorPixmap("RotateSelectionCursor.png"), 0, 0)

    w.RotateSelectionAddCursor = \
     createCompositeCursor(w.RotateSelectionCursor, w.addSymbol,
                           offsetX = 12, offsetY = 0)
    w.RotateSelectionSubtractCursor = \
     createCompositeCursor(w.RotateSelectionCursor, w.subtractSymbol,
                           offsetX = 12, offsetY = 0)

    # Axis translation/rotation cursor
    w.AxisTranslateRotateSelectionCursor = \
     QCursor(getCursorPixmap("AxisTranslateRotateSelectionCursor.png"), 0, 0)

    # Build Crystal cursors
    w.CookieCursor = QCursor(getCursorPixmap("Pencil.png"), 0, 0)
    w.CookieAddCursor = \
     createCompositeCursor(w.colorPencilCursor, w.addSymbol, \
                           offsetX = 12, offsetY = 0)
    w.CookieSubtractCursor = \
     createCompositeCursor(w.colorPencilCursor, w.subtractSymbol, \
                           offsetX = 12, offsetY = 0)

    # View Zoom, Pan, Rotate cursors

    # The zoom cursor(s). One is for a dark background, the other for a light bg.
    # See GLPane.setCursor() for more details about this list.
    w.ZoomCursor = []
    _cursor = QCursor(getCursorPixmap("darkbg/ZoomCursor.png"), 11, 11)
    w.ZoomCursor.append(_cursor)
    _cursor = QCursor(getCursorPixmap("litebg/ZoomCursor.png"), 11, 11)
    w.ZoomCursor.append(_cursor)

    w.ZoomInOutCursor = []
    _cursor = QCursor(getCursorPixmap("darkbg/ZoomCursor.png"), 11, 11)
    w.ZoomInOutCursor.append(_cursor)
    _cursor = QCursor(getCursorPixmap("litebg/ZoomCursor.png"), 11, 11)
    w.ZoomInOutCursor.append(_cursor)

    w.PanViewCursor = QCursor(getCursorPixmap("PanViewCursor.png"), 0, 0)
    w.RotateViewCursor = QCursor(getCursorPixmap("RotateViewCursor.png"), 0, 0)

    # Miscellaneous cursors
    w.RotateZCursor = QCursor(getCursorPixmap("RotateZCursor.png"), 0, 0)
    w.ZoomPovCursor = QCursor(getCursorPixmap("ZoomPovCursor.png"), -1, -1)
    w.ArrowWaitCursor = QCursor(getCursorPixmap("ArrowWaitCursor.png"), 0, 0)
    w.ArrowCursor = QCursor(Qt.ArrowCursor) #bruce 070627

    # Confirmation corner cursors [loaded by bruce 070626 from files committed by mark]
    w._confcorner_OKCursor = \
     QCursor(getCursorPixmap("OKCursor.png"), 0, 0)
    w.confcorner_TransientDoneCursor = \
     QCursor(getCursorPixmap("TransientDoneCursor.png"), 0, 0)
    w._confcorner_CancelCursor = \
     QCursor(getCursorPixmap("CancelCursor.png"), 0, 0)

    # Some Build Dna mode cursors
    w.rotateAboutCentralAxisCursor = \
     QCursor(getCursorPixmap("Rotate_About_Central_Axis.png"), 0, 0)
    w.translateAlongCentralAxisCursor = \
     QCursor(getCursorPixmap("Translate_Along_Central_Axis.png"), 0, 0)

    #Rotate about a point cursors
    w.rotateAboutPointCursor = \
     QCursor(getCursorPixmap("RotateAboutPointCursor.png"), 0, 0)

    w.rotateAboutPointHorizontalSnapCursor = \
        createCompositeCursor(w.rotateAboutPointCursor, horizontalSymbol,
                              offsetX = 22, offsetY = 22)
    w.rotateAboutPointVerticalSnapCursor = \
        createCompositeCursor(w.rotateAboutPointCursor, verticalSymbol,
                              offsetX = 22, offsetY = 22)

    #Add a segment to a list of segments to be resized (in Multiple_DnaSegments
    #command)
    w.addSegmentToResizeSegmentListCursor = \
     QCursor(getCursorPixmap("AddSegment_To_ResizeSegmentListCursor.png"), 0, 0)
    w.removeSegmentFromResizeSegmentListCursor = \
     QCursor(getCursorPixmap("RemoveSegment_From_ResizeSegmentList_Cursor.png"), 0, 0)

    w.specifyPlaneCursor = \
     QCursor(getCursorPixmap("SpecifyPlaneCursor.png"), 0, 0)

    w.clickToJoinStrandsCursor = QCursor(getCursorPixmap(
        "ClickToJoinStrands_Cursor.png"), 0, 0)

    return # from loadCursors

def createCompositeCursor(cursor, overlayCursor,
                          hotX = None, hotY = None,
                          offsetX = 0, offsetY = 0):
    """
    Returns a composite 32x32 cursor using two other cursors.

    This is useful for creating composite cursor images from two (or more)
    cursors.

    For example, the pencil cursor includes a horizontal and vertical
    symbol when drawing a horizontal or vertical line. This function can
    be used to create these cursors without having to create each one by hand.
    The payoff is when the developer/artist wants to change the base cursor
    image (i.e. the pencil cursor) without having to redraw and save all the
    other versions of the cursor in the set.

    @param cursor: The main cursor.
    @type  cursor: QCursor

    @param overlayCursor: The cursor to overlay on top of I{cursor}.
    @type  overlayCursor: QCursor

    @param hotX: The X coordinate of the hotspot. If none is given, the
                 hotspot of I{cursor} is used.
    @type  hotX: int

    @param hotY: The Y coordinate of the hotspot. If none is given, the
                 hotspot of I{cursor} is used.
    @type  hotY: int

    @param offsetX: The X offset in which to draw the overlay cursor onto
                    I{cursor}. The default is 0.
    @type  offsetX: int

    @param offsetY: The Y offset in which to draw the overlay cursor onto
                    I{cursor}. The default is 0.
    @type  offsetY: int

    @return: The composite cursor.
    @rtype:  QCursor

    @note: It would be easy and useful to allow overlayCursor to be a QPixmap.
           I'll add this when it becomes helpful. --Mark 2008-03-06.
    """
    # Method:
    # 1. Get cursor's pixmap and create a painter from it.
    # 2. Get the pixmap from the overlay cursor and draw it onto the
    #    cursor pixmap to create the composite pixmap.
    # 3. Create and return a new QCursor from the composite pixmap.
    # Mark 2008-03-05

    assert isinstance(cursor, QCursor)
    assert isinstance(overlayCursor, QCursor)

    if hotX is None:
        hotX = cursor.hotSpot().x()
    if hotY is None:
        hotY = cursor.hotSpot().y()
    pixmap = cursor.pixmap()
    overlayPixmap = overlayCursor.pixmap()
    painter = QPainter(pixmap)
    painter.drawPixmap(offsetX, offsetY, overlayPixmap)
    painter.end()
    return QCursor(pixmap, hotX, hotY)