CustomQGraphicsView.py .. module:: CustomQGraphicsView :platform: Unix, Windows, Mac OS X :synopsis: A Custom QGraphicsView module to allow focus input events like mouse clicks and panning and zooming .. moduleauthor:: Nick Conway on 2011-01-17. Copyright (c) 2010 . All rights reserved. """ from cadnano2.cadnano import app from cadnano2.views import styles import cadnano2.util as util # import Qt stuff into the module namespace with PySide, PyQt4 independence util.qtWrapImport('QtCore', globals(), ['Qt', 'QTimer', 'pyqtSignal', 'QTimeLine']) util.qtWrapImport('QtGui', globals(), ['QGuiApplication', 'QPaintEngine']) util.qtWrapImport('QtWidgets', globals(), ['QGraphicsView', 'QGraphicsScene']) # for OpenGL mode try: # from OpenGL import GL from PyQt6.QtWidgets import QOpenGLWidget except ImportError: GL = False GL = False class CustomQGraphicsView(QGraphicsView): """
#!/usr/bin/env python # encoding: utf-8 import cadnano2.util as util from cadnano2.views import styles from cadnano2.model.enum import StrandType # import Qt stuff into the module namespace with PySide, PyQt4 independence util.qtWrapImport('QtCore', globals(), ['QPointF', 'QRectF', 'Qt']) util.qtWrapImport('QtGui', globals(), [ 'QBrush', 'QFont', 'QFontMetrics', 'QPainterPath', 'QPolygonF', 'QPen', 'QUndoCommand' ]) util.qtWrapImport( 'QtWidgets', globals(), ['QGraphicsPathItem', 'QGraphicsRectItem', 'QGraphicsSimpleTextItem']) # construct paths for breakpoint handles def _hashMarkGen(path, p1, p2, p3): path.moveTo(p1) path.lineTo(p2) path.lineTo(p3) # end # create hash marks QPainterPaths only once _ppRect = QRectF(0, 0, styles.PATH_BASE_WIDTH, styles.PATH_BASE_WIDTH) _pathCenter = QPointF(styles.PATH_BASE_WIDTH / 2,\
#!/usr/bin/env python # encoding: utf-8 from math import floor from cadnano2.controllers.itemcontrollers.strand.stranditemcontroller import StrandItemController from .endpointitem import EndpointItem from cadnano2.views import styles from .xoveritem import XoverItem from .decorators.insertionitem import InsertionItem import cadnano2.views.pathview.pathselection as pathselection import cadnano2.util as util # import Qt stuff into the module namespace with PySide, PyQt4 independence util.qtWrapImport('QtCore', globals(), ['pyqtSignal', 'QObject', 'Qt', 'QRectF']) util.qtWrapImport('QtGui', globals(), ['QBrush', 'QColor', 'QFont', 'QFontMetricsF', 'QPen']) util.qtWrapImport('QtWidgets', globals(), [ 'QGraphicsLineItem', 'QGraphicsPathItem', 'QGraphicsItem', 'QGraphicsSimpleTextItem', 'QGraphicsRectItem' ]) _baseWidth = styles.PATH_BASE_WIDTH _defaultRect = QRectF(0, 0, _baseWidth, _baseWidth) _noPen = QPen(Qt.PenStyle.NoPen) class StrandItem(QGraphicsLineItem): _filterName = "strand"
import cadnano2.util as util # import Qt stuff into the module namespace with PySide, PyQt4 independence util.qtWrapImport('QtCore', globals(), ['pyqtSignal', 'QObject']) util.qtWrapImport('QtGui', globals(), ['QActionGroup']) class SliceToolManager(QObject): """Manages interactions between the slice widgets/UI and the model.""" def __init__(self, win): """ We store mainWindow because a controller's got to have references to both the layer above (UI) and the layer below (model) """ super(SliceToolManager, self).__init__() self._window = win self._connectWindowSignalsToSelf() ### SIGNALS ### activeSliceSetToFirstIndexSignal = pyqtSignal() activeSliceSetToLastIndexSignal = pyqtSignal() activePartRenumber = pyqtSignal() ### SLOTS ### def activeSliceFirstSlot(self): """ Use a signal to notify the ActiveSliceHandle to move. A signal is used because the SliceToolManager must be instantiated first, and the ActiveSliceHandle can later subscribe. """ part = self._window.selectedPart() if part != None:
#!/usr/bin/env python # encoding: utf-8 from operator import attrgetter import cadnano2.util as util from array import array # import Qt stuff into the module namespace with PySide, PyQt4 independence util.qtWrapImport('QtCore', globals(), ['QObject', 'Qt']) util.qtWrapImport('QtGui', globals(), ['QUndoStack', 'QUndoCommand']) class Decorator(object): """ Decorators do not affect an applied sequence """ def __init__(self, index): if self.__class__ == Decorator: e = "Decorator should be subclassed." raise NotImplementedError(e) self._index = idex self._dType = None self._privateSequence = None # end def def privateLength(self): """ This is the length of a sequence that is immutable by the strand """ return length(self._privateSequence)
from cadnano2.controllers.viewrootcontroller import ViewRootController from .partitem import PartItem import cadnano2.util as util util.qtWrapImport('QtCore', globals(), ['pyqtSignal', 'QObject']) util.qtWrapImport('QtWidgets', globals(), ['QGraphicsRectItem']) class SliceRootItem(QGraphicsRectItem): """ PathRootItem is the root item in the PathView. It gets added directly to the pathscene by DocumentWindow. It receives two signals (partAddedSignal and selectedPartChangedSignal) via its ViewRootController. PathRootItem must instantiate its own controller to receive signals from the model. """ def __init__(self, rect, parent, window, document): super(SliceRootItem, self).__init__(rect, parent) self._window = window self._document = document self._controller = ViewRootController(self, document) self._instanceItems = {} ### SIGNALS ### ### SLOTS ### def partAddedSlot(self, sender, modelPart): """ Receives notification from the model that a part has been added. Views that subclass AbstractView should override this method. """
from .abstractpathtool import AbstractPathTool import cadnano2.util as util util.qtWrapImport('QtCore', globals(), []) util.qtWrapImport('QtGui', globals(), []) class SelectTool(AbstractPathTool): """ SelectTool is the default tool. It allows editing of breakpoints (by clicking and dragging) and toggling of crossovers. """ def __init__(self, controller): super(SelectTool, self).__init__(controller) def __repr__(self): return "selectTool" # first letter should be lowercase
from math import floor from .abstractpathtool import AbstractPathTool from cadnano2.views import styles import cadnano2.util as util # import Qt stuff into the module namespace with PySide, PyQt4 independence util.qtWrapImport('QtCore', globals(), ['Qt', 'QEvent', 'QPointF', 'QRectF']) util.qtWrapImport('QtGui', globals(), [ 'QBrush', 'QColor', 'QFont', 'QFontMetrics', 'QPainterPath', 'QPolygonF', 'QPen' ]) util.qtWrapImport('QtWidgets', globals(), [ 'QGraphicsItem', 'QGraphicsLineItem', 'QGraphicsPathItem', 'QGraphicsRectItem', 'QGraphicsSimpleTextItem' ]) _baseWidth = styles.PATH_BASE_WIDTH _pencilcolor = styles.redstroke _defaultRect = QRectF(0, 0, _baseWidth, _baseWidth) _noPen = QPen(Qt.PenStyle.NoPen) class PencilTool(AbstractPathTool): """ docstring for PencilTool """ def __init__(self, controller): super(PencilTool, self).__init__(controller) self._tempXover = ForcedXoverItem(self, None, None) self._tempStrandItem = ForcedStrandItem(self, None) self._tempStrandItem.hide()
import re from .abstractpathtool import AbstractPathTool from cadnano2.data.dnasequences import sequences from cadnano2.ui.dialogs.ui_addseq import Ui_AddSeqDialog from cadnano2.views import styles import cadnano2.util as util util.qtWrapImport('QtCore', globals(), [ 'Qt', 'QObject', 'QPointF', 'QRegularExpression', 'QSignalMapper', 'pyqtSignal', 'pyqtSlot' ]) util.qtWrapImport('QtGui', globals(), [ 'QBrush', 'QColor', 'QFont', 'QPen', 'QSyntaxHighlighter', 'QTextCharFormat' ]) util.qtWrapImport('QtWidgets', globals(), [ 'QDialog', 'QDialogButtonBox', 'QRadioButton', ]) dnapattern = QRegularExpression("([^ACGTacgt]+)") class DNAHighlighter(QSyntaxHighlighter): def __init__(self, parent): QSyntaxHighlighter.__init__(self, parent) self.parent = parent self.format = QTextCharFormat() self.format.setBackground(QBrush(styles.INVALID_DNA_COLOR)) if styles.UNDERLINE_INVALID_DNA:
import io import os from ..cadnano import app from ..model.document import Document from ..model.io.decoder import decode from ..model.io.encoder import encode from ..views.documentwindow import DocumentWindow from ..views import styles import cadnano2.util as util util.qtWrapImport('QtCore', globals(), ['QDir', 'QFileInfo', 'QRect', 'QSettings', 'QSize', 'Qt']) util.qtWrapImport('QtGui', globals(), ['QIcon', 'QKeySequence', 'QPainter']) util.qtWrapImport('QtWidgets', globals(), [ 'QApplication', 'QDialog', 'QDockWidget', 'QFileDialog', 'QGraphicsItem', 'QMainWindow', 'QMessageBox', 'QStyleOptionGraphicsItem' ]) util.qtWrapImport('QtSvg', globals(), ['QSvgGenerator']) class DocumentController(): """ Connects UI buttons to their corresponding actions in the model. """ ### INIT METHODS ### def __init__(self): """docstring for __init__""" # initialize variables self._document = Document() self._document.setController(self) self._activePart = None
from cadnano2.views import styles import cadnano2.util as util util.qtWrapImport('QtCore', globals(), ['QRectF', 'Qt']) util.qtWrapImport('QtGui', globals(), ['QBrush', 'QFont']) util.qtWrapImport('QtWidgets', globals(), ['QColorDialog', 'QGraphicsItem', 'QGraphicsSimpleTextItem']) _font = QFont(styles.thefont, 12, QFont.Weight.Bold) class ColorPanel(QGraphicsItem): _scafColors = styles.scafColors _stapColors = styles.stapColors _pen = Qt.PenStyle.NoPen def __init__(self, parent=None): super(ColorPanel, self).__init__(parent) self.rect = QRectF(0, 0, 30, 30) self.setFlag(QGraphicsItem.GraphicsItemFlag.ItemIgnoresTransformations) self.colordialog = QColorDialog() # self.colordialog.setOption(QColorDialog.DontUseNativeDialog) self._scafColorIndex = -1 # init on -1, painttool will cycle to 0 self._stapColorIndex = -1 # init on -1, painttool will cycle to 0 self._scafColor = self._scafColors[self._scafColorIndex] self._stapColor = self._stapColors[self._stapColorIndex] self._scafBrush = QBrush(self._scafColor) self._stapBrush = QBrush(self._stapColor) self._initLabel() self.hide()
import maya.OpenMayaMPx as OpenMayaMPx import maya.cmds as cmds import maya.OpenMayaUI as OpenMayaUI import maya.mel as mel import sip sys.path.insert(0, os.environ['CADNANO_PATH']) # cmds.flushUndo() # cmds.undoInfo(state=False) import cadnano2.views.solidview.mayaHotKeys as mayaHotKeys import cadnano2.views.solidview.mayaUI as mayaUI import cadnano2.util as util util.qtFrameworkList = ['PyQt'] # necessary to overide defaults util.qtWrapImport('QtGui', globals(), ['qApp', 'QDockWidget', 'QSizePolicy']) util.qtWrapImport('QtCore', globals(), ['Qt', 'QObject']) kPluginName = "spCadNano" gCadNanoButton = None gCadNanoToolbar = None fMayaExitingCB = None gCadNanoApp = None gIconPath = (os.environ['CADNANO_PATH'] + "/ui/mainwindow/images/cadnano2-app-icon_shelf.png") # command
from cadnano2.controllers.itemcontrollers.partitemcontroller import PartItemController from .emptyhelixitem import EmptyHelixItem from .virtualhelixitem import VirtualHelixItem from .activesliceitem import ActiveSliceItem from cadnano2.views import styles import cadnano2.util as util # import Qt stuff into the module namespace with PySide, PyQt4 independence util.qtWrapImport( 'QtCore', globals(), ['QRectF', 'QPointF', 'QEvent', 'Qt', 'pyqtSignal', 'pyqtSlot', 'QObject']) util.qtWrapImport('QtGui', globals(), ['QBrush', 'QPainterPath', 'QPen']) util.qtWrapImport('QtWidgets', globals(), ['QGraphicsItem', 'QGraphicsEllipseItem']) _radius = styles.SLICE_HELIX_RADIUS _defaultRect = QRectF(0, 0, 2 * _radius, 2 * _radius) highlightWidth = styles.SLICE_HELIX_MOD_HILIGHT_WIDTH delta = (highlightWidth - styles.SLICE_HELIX_STROKE_WIDTH) / 2. _hoverRect = _defaultRect.adjusted(-delta, -delta, delta, delta) _modPen = QPen(styles.bluestroke, highlightWidth) class PartItem(QGraphicsItem): _radius = styles.SLICE_HELIX_RADIUS def __init__(self, modelPart, parent=None): """ Parent should be either a SliceRootItem, or an AssemblyItem. Invariant: keys in _emptyhelixhash = range(_nrows) x range(_ncols) where x is the cartesian product.
#!/usr/bin/env python # encoding: utf-8 from math import floor from cadnano2.controllers.itemcontrollers.virtualhelixitemcontroller import VirtualHelixItemController from cadnano2.model.enum import StrandType from .strand.stranditem import StrandItem from cadnano2.views import styles from .virtualhelixhandleitem import VirtualHelixHandleItem import cadnano2.util as util # import Qt stuff into the module namespace with PySide, PyQt4 independence util.qtWrapImport('QtCore', globals(), ['pyqtSignal', 'QObject', 'Qt', 'QRectF']) util.qtWrapImport('QtGui', globals(), ['QBrush', 'QPainterPath', 'QPen', 'QBrush', 'QColor']) util.qtWrapImport('QtWidgets', globals(), ['QGraphicsItem', 'QGraphicsPathItem', 'QGraphicsRectItem']) _baseWidth = styles.PATH_BASE_WIDTH # _gridPen = QPen(styles.minorgridstroke, styles.MINOR_GRID_STROKE_WIDTH) # _gridPen.setCosmetic(True) class VirtualHelixItem(QGraphicsPathItem): """VirtualHelixItem for PathView""" findChild = util.findChild # for debug def __init__(self, partItem, modelVirtualHelix, viewroot, activeTool): super(VirtualHelixItem, self).__init__(partItem.proxy()) self._partItem = partItem self._modelVirtualHelix = modelVirtualHelix
#!/usr/bin/env python # encoding: utf-8 import cadnano2.util as util util.qtWrapImport('QtGui', globals(), ['QGraphicsPathItem']) class AbstractDecoratorItem(QGraphicsPathItem): def __init__(self, parent): """The parent should be a VirtualHelixItem.""" if self.__class__ == AbstractDecoratorItem: e = "AbstractDecoratorItem should be subclassed." raise NotImplementedError(e) super(AbstractDecoratorItem, self).__init__(parent) self._strand = None self._oligo = None ### SIGNALS ### ### SLOTS ### def strandResizedSlot(self): """docstring for strandResizedSlot""" pass def sequenceAddedSlot(self, oligo): """docstring for sequenceAddedSlot""" pass def decoratorRemovedSlot(self, oligo): """docstring for sequenceClearedSlot""" pass
import json from .legacydecoder import import_legacy_dict from cadnano2.ui.dialogs.ui_latticetype import Ui_LatticeType import cadnano2.util as util import cadnano2.cadnano as cadnano if cadnano.app().isGui(): # headless: from cadnano2.ui.dialogs.ui_latticetype import Ui_LatticeType util.qtWrapImport('QtWidgets', globals(), ['QDialog', 'QDialogButtonBox']) def decode(document, string): if cadnano.app().isGui(): # from ui.dialogs.ui_latticetype import Ui_LatticeType # util.qtWrapImport('QtGui', globals(), ['QDialog', 'QDialogButtonBox']) dialog = QDialog() dialogLT = Ui_LatticeType() # reusing this dialog, should rename dialogLT.setupUi(dialog) # try: # try to do it fast # try: # import cjson # packageObject = cjson.decode(string) # except: # fall back to if cjson not available or on decode error # packageObject = json.loads(string) # except ValueError: # dialogLT.label.setText("Error decoding JSON object.") # dialogLT.buttonBox.setStandardButtons(QDialogButtonBox.Ok) # dialog.exec() # return packageObject = json.loads(string)
from .abstractpathtool import AbstractPathTool from cadnano2.views import styles import cadnano2.util as util util.qtWrapImport('QtCore', globals(), ['QPointF', 'QRectF', 'Qt']) util.qtWrapImport('QtGui', globals(), ['QBrush', 'QFont', 'QPainterPath', 'QPen', 'QPolygonF']) util.qtWrapImport('QtWidgets', globals(), ['QGraphicsItem']) _bw = styles.PATH_BASE_WIDTH _pen = QPen(styles.redstroke, 1) _rect = QRectF(0, 0, _bw, _bw) _pathArrowLeft = QPainterPath() _l3poly = QPolygonF() _l3poly.append(QPointF(_bw, 0)) _l3poly.append(QPointF(0.25 * _bw, 0.5 * _bw)) _l3poly.append(QPointF(_bw, _bw)) _pathArrowLeft.addPolygon(_l3poly) _pathArrowRight = QPainterPath() _r3poly = QPolygonF() # right-hand 3' arr _r3poly.append(QPointF(0, 0)) _r3poly.append(QPointF(0.75 * _bw, 0.5 * _bw)) _r3poly.append(QPointF(0, _bw)) _pathArrowRight.addPolygon(_r3poly) class BreakTool(AbstractPathTool): """ docstring for BreakTool """ def __init__(self, controller): super(BreakTool, self).__init__(controller)
import cadnano2.util as util util.qtWrapImport('QtCore', globals(), ['QObject', 'pyqtSignal', 'Qt']) util.qtWrapImport('QtWidgets', globals(), ['QGraphicsObject']) util.qtWrapImport('QtSvg', globals(), ['QSvgRenderer']) class SVGButton(QGraphicsObject): def __init__(self, fname, parent=None): super(SVGButton, self).__init__(parent) self.svg = QSvgRenderer(fname) def paint(self, painter, options, widget): self.svg.render(painter, self.boundingRect()) def boundingRect(self): return self.svg.viewBoxF() clicked = pyqtSignal() def mousePressEvent(self, event): self.clicked.emit()
Created by Simon Breslav on 2011-10-05. """ from controllers.mayacontrollers.mayaObjectManager import Mom from cadnano2.controllers.itemcontrollers.strand.stranditemcontroller \ import StrandItemController from cadnano2.model.enum import StrandType from cadnano2.model.enum import LatticeType from cadnano2.cadnano import app import maya.OpenMayaUI as mui import maya.OpenMaya as mo import maya.cmds as cmds import cadnano2.util as util util.qtWrapImport('QtCore', globals(), ['pyqtSignal', 'pyqtSlot', \ 'QObject', 'Qt']) util.qtWrapImport('QtGui', globals(), ['QColor']) class StrandItem(object): """ StrandItem is the visual representation of the strand in the 3D SolidView. For this visual representation, StrandItem creates HalfCylinderHelixNode Node inside of Maya, so while the StrandItem itself does not get drawn in any way, it is the object that communicates with Maya Nodes associated with a given strand. """ def __init__(self, mID, modelStrand, virtualHelixItem): """ The parent should be a VirtualHelixItem. Initialize function creates the Maya Node for the strand, and setups
#!/usr/bin/env python # encoding: utf-8 import cadnano2.util as util import copy from .strand import Strand # import Qt stuff into the module namespace with PySide, PyQt4 independence util.qtWrapImport('QtCore', globals(), ['pyqtSignal', 'QObject']) util.qtWrapImport('QtGui', globals(), ['QUndoCommand']) class Oligo(QObject): """ Oligo is a group of Strands that are connected via 5' and/or 3' connections. It corresponds to the physical DNA strand, and is thus used tracking and storing properties that are common to a single strand, such as its color. Commands that affect Strands (e.g. create, remove, merge, split) are also responsible for updating the affected Oligos. """ def __init__(self, part, color=None): super(Oligo, self).__init__(part) self._part = part self._strand5p = None self._length = 0 self._isLoop = False self._color = color if color else "#0066cc" # end def
""" styles.py Created by Shawn on 2010-06-15. """ import cadnano2.util as util # import Qt stuff into the module namespace with PySide, PyQt4 independence util.qtWrapImport('QtGui', globals(), ['QColor', 'QFont', 'QFontMetricsF']) # Slice Sizing SLICE_HELIX_RADIUS = 15 SLICE_HELIX_STROKE_WIDTH = 0.5 SLICE_HELIX_HILIGHT_WIDTH = 2.5 SLICE_HELIX_MOD_HILIGHT_WIDTH = 1 HONEYCOMB_PART_MAXROWS = 30 HONEYCOMB_PART_MAXCOLS = 32 HONEYCOMB_PART_MAXSTEPS = 2 SQUARE_PART_MAXROWS = 50 SQUARE_PART_MAXCOLS = 50 SQUARE_PART_MAXSTEPS = 2 # Slice Colors bluefill = QColor(153, 204, 255) # 99ccff bluestroke = QColor(0, 102, 204) # 0066cc bluishstroke = QColor(0, 182, 250) # orangefill = QColor(255, 204, 153) # ffcc99 orangestroke = QColor(204, 102, 51) # cc6633 lightorangefill = QColor(255, 234, 183) lightorangestroke = QColor(234, 132, 81) grayfill = QColor(238, 238, 238) # eeeeee (was a1a1a1)
from ..ui.dialogs.ui_preferences import Ui_Preferences from ..views import styles import cadnano2.util as util from .. import cadnano import os.path, zipfile, shutil, platform, subprocess, tempfile, errno util.qtWrapImport('QtCore', globals(), ['QObject', 'QSettings', 'pyqtSlot', 'Qt']) util.qtWrapImport('QtWidgets', globals(), [ 'QWidget', 'QDialogButtonBox', 'QTableWidgetItem', 'QFileDialog', 'QMessageBox' ]) class Preferences(object): """docstring for Preferences""" def __init__(self): self.qs = QSettings() self.uiPrefs = Ui_Preferences() self.widget = QWidget() self.uiPrefs.setupUi(self.widget) self.readPreferences() self.widget.addAction(self.uiPrefs.actionClose) self.uiPrefs.actionClose.triggered.connect(self.hideDialog) self.uiPrefs.honeycombRowsSpinBox.valueChanged.connect( self.setHoneycombRows) self.uiPrefs.honeycombColsSpinBox.valueChanged.connect( self.setHoneycombCols) self.uiPrefs.honeycombStepsSpinBox.valueChanged.connect( self.setHoneycombSteps) self.uiPrefs.squareRowsSpinBox.valueChanged.connect(self.setSquareRows) self.uiPrefs.squareColsSpinBox.valueChanged.connect(self.setSquareCols)
from cadnano2.cadnano import app from .pathview.colorpanel import ColorPanel from .pathview.tools.pathtoolmanager import PathToolManager from .sliceview.slicerootitem import SliceRootItem from .pathview.pathrootitem import PathRootItem from .sliceview.tools.slicetoolmanager import SliceToolManager import cadnano2.ui.mainwindow.ui_mainwindow as ui_mainwindow import cadnano2.util as util util.qtWrapImport('QtCore', globals(), [ 'pyqtSignal', 'Qt', 'QFileInfo', 'QPoint', 'QSettings', 'QSize', ]) util.qtWrapImport('QtGui', globals(), ['QAction', 'QPaintEngine']) util.qtWrapImport('QtWidgets', globals(), [ 'QApplication', 'QGraphicsObject', 'QGraphicsScene', 'QGraphicsView', 'QGraphicsItem', 'QGraphicsRectItem', 'QMainWindow', 'QWidget', ]) # for OpenGL mode
""" config Created by Jonathan deWerd on 2012-01-19. """ import cadnano2.util as util import cadnano2.cadnano as cadnano from . import autobreakconfig_ui from . import autobreak util.qtWrapImport('QtGui', globals(), ['QKeySequence']) util.qtWrapImport('QtCore', globals(), ['Qt']) util.qtWrapImport('QtWidgets', globals(), ['QDialog', 'QDialogButtonBox']) class AutobreakConfig(QDialog, autobreakconfig_ui.Ui_Dialog): def __init__(self, parent, handler): QDialog.__init__(self, parent, Qt.WindowType.Sheet) self.setupUi(self) self.handler = handler fb = self.buttonBox.button(QDialogButtonBox.Cancel) fb.setShortcut(QKeySequence(Qt.CTRL | Qt.Key.Key_R)) def keyPressEvent(self, e): return QDialog.keyPressEvent(self, e) def closeDialog(self): self.close() def accept(self): part = self.handler.doc.controller().activePart() if part != None: settings = {\
""" pathselection.py Created by Nick on 2011-06-27. """ from cadnano2.views import styles from math import floor import cadnano2.util as util # import Qt stuff into the module namespace with PySide, PyQt4 independence util.qtWrapImport('QtCore', globals(), ['Qt', 'QPointF', 'QEvent', 'QRectF']) util.qtWrapImport('QtGui', globals(), ['QPen', 'QBrush', 'QColor', 'QPainterPath']) util.qtWrapImport( 'QtWidgets', globals(), [ # 'qApp', 'QGraphicsItem', 'QGraphicsItemGroup', 'QGraphicsPathItem' ]) class SelectionItemGroup(QGraphicsItemGroup): """ SelectionItemGroup """ def __init__(self, boxtype, constraint='y', parent=None): super(SelectionItemGroup, self).__init__(parent) self._viewroot = parent self.setFiltersChildEvents(True)
#!/usr/bin/env python # encoding: utf-8 import cadnano2.util as util from cadnano2.views import styles # import Qt stuff into the module namespace with PySide, PyQt4 independence util.qtWrapImport('QtCore', globals(), ['QPointF', 'QRectF', 'Qt']) util.qtWrapImport('QtGui', globals(), ['QBrush', 'QColor', 'QFont', 'QFontMetricsF', 'QPainterPath', 'QPen', 'QTextCursor', 'QTransform']) util.qtWrapImport('QtWidgets', globals(), ['QGraphicsItem', 'QGraphicsPathItem', 'QGraphicsRectItem', 'QGraphicsTextItem', 'QLabel', ]) _baseWidth = _bw = styles.PATH_BASE_WIDTH _halfbaseWidth = _hbw = _baseWidth / 2 _offset1 = _baseWidth / 4 _defaultRect = QRectF(0, 0, _bw, _bw) _bpen = QPen(styles.bluestroke, styles.INSERTWIDTH) _rpen = QPen(styles.redstroke, styles.SKIPWIDTH) _noPen = QPen(Qt.PenStyle.NoPen)
""" activeslicehandle.py Created by Shawn on 2011-02-05. """ from cadnano2.controllers.itemcontrollers.activesliceitemcontroller import ActiveSliceItemController import cadnano2.util as util # import Qt stuff into the module namespace with PySide, PyQt4 independence util.qtWrapImport('QtCore', globals(), ['QPointF', 'QRectF', 'Qt', 'QObject',\ 'pyqtSignal', 'pyqtSlot', 'QEvent']) util.qtWrapImport('QtGui', globals(), ['QBrush', 'QFont', 'QPen', 'QDrag', 'QUndoCommand']) util.qtWrapImport( 'QtWidgets', globals(), ['QGraphicsItem', 'QGraphicsRectItem', 'QGraphicsSimpleTextItem']) class ActiveSliceItem(QGraphicsRectItem): """ActiveSliceItem for the Slice View""" def __init__(self, partItem, activeBaseIndex): super(ActiveSliceItem, self).__init__(partItem) self._partItem = partItem self._controller = ActiveSliceItemController(self, partItem.part()) self.setFlag(QGraphicsItem.GraphicsItemFlag.ItemHasNoContents) # end def ### SLOTS ### def strandChangedSlot(self, sender, vh): if vh == None:
from cadnano2.views import styles from cadnano2.model.enum import StrandType import cadnano2.util as util # import Qt stuff into the module namespace with PySide, PyQt4 independence util.qtWrapImport('QtCore', globals(), ['QPointF', 'QRectF', 'Qt']) util.qtWrapImport('QtGui', globals(), ['QBrush', 'QFont', 'QPen']) util.qtWrapImport('QtWidgets', globals(), ['QGraphicsItem', 'QGraphicsItemGroup', 'QGraphicsObject']) _bw = styles.PATH_BASE_WIDTH _toolRect = QRectF(0, 0, _bw, _bw) # protected not private _rect = QRectF(-styles.PATH_BASE_HL_STROKE_WIDTH, -styles.PATH_BASE_HL_STROKE_WIDTH, _bw + 2 * styles.PATH_BASE_HL_STROKE_WIDTH, _bw + 2 * styles.PATH_BASE_HL_STROKE_WIDTH) _pen = QPen(styles.redstroke, styles.PATH_BASE_HL_STROKE_WIDTH) _brush = QBrush(Qt.BrushStyle.NoBrush) # There's a bug where C++ will free orphaned graphics items out from # under pyqt. To avoid this, "_mother" adopts orphaned graphics items. _mother = QGraphicsItemGroup() class AbstractPathTool(QGraphicsObject): """Abstract base class to be subclassed by all other pathview tools.""" def __init__(self, controller, parent=None): super(AbstractPathTool, self).__init__(parent) self._controller = controller self._window = controller.window self._active = False
""" pathhelixhandle.py Created by Shawn on 2011-02-05. """ from cadnano2.views import styles import cadnano2.util as util # import Qt stuff into the module namespace with PySide, PyQt4 independence util.qtWrapImport('QtCore', globals(), ['QPointF', 'QRectF', 'Qt']) util.qtWrapImport( 'QtGui', globals(), ['QBrush', 'QFont', 'QPen', 'QDrag', 'QTransform', 'QUndoCommand']) util.qtWrapImport('QtWidgets', globals(), [ 'QGraphicsEllipseItem', 'QGraphicsItem', 'QGraphicsSimpleTextItem', 'QGraphicsTextItem', 'QStyle' ]) _radius = styles.VIRTUALHELIXHANDLEITEM_RADIUS _rect = QRectF(0, 0, 2*_radius + styles.VIRTUALHELIXHANDLEITEM_STROKE_WIDTH,\ 2*_radius + styles.VIRTUALHELIXHANDLEITEM_STROKE_WIDTH) _defBrush = QBrush(styles.grayfill) _defPen = QPen(styles.graystroke, styles.VIRTUALHELIXHANDLEITEM_STROKE_WIDTH) _hovBrush = QBrush(styles.bluefill) _hovPen = QPen(styles.bluestroke, styles.VIRTUALHELIXHANDLEITEM_STROKE_WIDTH) _useBrush = QBrush(styles.orangefill) _usePen = QPen(styles.orangestroke, styles.VIRTUALHELIXHANDLEITEM_STROKE_WIDTH) _font = styles.VIRTUALHELIXHANDLEITEM_FONT class VirtualHelixHandleItem(QGraphicsEllipseItem): """docstring for VirtualHelixHandleItem"""
# encoding: utf-8 from collections import defaultdict from math import ceil from .activesliceitem import ActiveSliceItem from cadnano2.controllers.itemcontrollers.partitemcontroller import PartItemController from .prexoveritem import PreXoverItem from .strand.xoveritem import XoverNode3 from cadnano2.ui.mainwindow.svgbutton import SVGButton from cadnano2.views import styles from .virtualhelixitem import VirtualHelixItem import cadnano2.util as util from cadnano2.cadnano import app # import Qt stuff into the module namespace with PySide, PyQt4 independence util.qtWrapImport('QtCore', globals(), ['QDir', 'QPointF', 'QRectF', 'Qt']) util.qtWrapImport('QtGui', globals(), ['QBrush', 'QPen']) util.qtWrapImport('QtWidgets', globals(), [ 'QGraphicsPathItem', 'QGraphicsItem', 'QGraphicsRectItem', 'QInputDialog' ]) _baseWidth = _bw = styles.PATH_BASE_WIDTH _defaultRect = QRectF(0, 0, _baseWidth, _baseWidth) _modPen = QPen(styles.bluestroke) class ProxyParentItem(QGraphicsRectItem): """an invisible container that allows one to play with Z-ordering""" findChild = util.findChild # for debug