def get_oligos_with_color(color):
"""
Returns the set of oligos that has color <color>.
"""
if isinstance(color, basestring):
util.qtWrapImport('QtCore', globals(), ['QString'])
if color[0] != "#" and len(color) == 6:
# Probably forgot to add '#' in #ff00ff:
color = '#'+color
color = QString(color.lower()) # colors should be lower-case
return set(oligo for oligo in get_all_oligos() if oligo.color() == color)
def get_oligos_with_color(color):
"""
Returns the set of oligos that has color <color>.
"""
if isinstance(color, basestring):
util.qtWrapImport('QtCore', globals(), ['QString'])
if color[0] != "#" and len(color) == 6:
# Probably forgot to add '#' in #ff00ff:
color = '#' + color
color = QString(color.lower()) # colors should be lower-case
return set(oligo for oligo in get_all_oligos() if oligo.color() == color)
def set_oligos_color(color, enableRedo=True):
"""
Sets the color of all selected oligos to <color>.
"""
if isinstance(color, basestring):
util.qtWrapImport('QtCore', globals(), ['QString'])
# PySide uses standard str as QString, but that should not be a problem.
color = QString(color)
selectedOs = get_selected_oligos()
if enableRedo:
# If A LOT of oligos are selected, this could add considerable overhead.
# (There will be one undo command in the undo stack for EACH oligo.)
for oligo in selectedOs:
oligo.applyColor(color)
else:
for oligo in selectedOs:
oligo.setColor(color) # setColor does not emit the
oligo.oligoAppearanceChangedSignal(oligo)
def set_oligos_color(color, enableRedo=True):
"""
Sets the color of all selected oligos to <color>.
"""
if isinstance(color, basestring):
util.qtWrapImport('QtCore', globals(), ['QString'])
# PySide uses standard str as QString, but that should not be a problem.
color = QString(color)
selectedOs = get_selected_oligos()
if enableRedo:
# If A LOT of oligos are selected, this could add considerable overhead.
# (There will be one undo command in the undo stack for EACH oligo.)
for oligo in selectedOs:
oligo.applyColor(color)
else:
for oligo in selectedOs:
oligo.setColor(color) # setColor does not emit the
oligo.oligoAppearanceChangedSignal(oligo)
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 cadnano import app
from views import styles
import util
# import Qt stuff into the module namespace with PySide, PyQt4 independence
util.qtWrapImport('QtCore', globals(),
['Qt', 'QTimer', 'pyqtSignal', 'QTimeLine'])
util.qtWrapImport(
'QtGui', globals(),
['QGraphicsView', 'QGraphicsScene', 'qApp', 'QPen', 'QPaintEngine'])
# for OpenGL mode
try:
from PyQt4.QtGui import QWidget
from OpenGL import GL
from PyQt4.QtOpenGL import QGLWidget, QGLFormat, QGL
except:
GL = False
GL = False
import os
from cadnano import app
from .selecttool import SelectTool
from .penciltool import PencilTool
from .breaktool import BreakTool
from .erasetool import EraseTool
from .insertiontool import InsertionTool
from .skiptool import SkipTool
from .painttool import PaintTool
from .addseqtool import AddSeqTool
import util
# import Qt stuff into the module namespace with PySide, PyQt4 independence
util.qtWrapImport('QtCore', globals(), ['QObject', 'pyqtSignal'])
util.qtWrapImport('QtWidgets', globals(), [ 'QActionGroup'])
class PathToolManager(QObject):
"""
Manages the interactions between Path widgets / UI elements and the model.
"""
def __init__(self, win):
super(PathToolManager, self).__init__()
self.window = win
self._activeTool = None
self._activePart = None
self.selectTool = SelectTool(self)
self.pencilTool = PencilTool(self)
self.breakTool = BreakTool(self)
self.eraseTool = EraseTool(self)
self.insertionTool = InsertionTool(self)
# encoding: utf-8
from collections import defaultdict
from math import ceil
from .activesliceitem import ActiveSliceItem
from controllers.itemcontrollers.partitemcontroller import PartItemController
from .prexoveritem import PreXoverItem
from .strand.xoveritem import XoverNode3
from ui.mainwindow.svgbutton import SVGButton
from views import styles
from .virtualhelixitem import VirtualHelixItem
import util
from cadnano import app
# import Qt stuff into the module namespace with PySide, PyQt4 independence
util.qtWrapImport('QtCore', globals(), ['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
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
# http://www.opensource.org/licenses/mit-license.php
from parts.honeycombpart import HoneycombPart
from parts.squarepart import SquarePart
from parts.part import Part
from strand import Strand
from operator import itemgetter
import util, cadnano
util.qtWrapImport('QtCore', globals(), ['pyqtSignal', 'QObject'])
util.qtWrapImport('QtGui', globals(), ['QUndoCommand', 'QUndoStack'])
class Document(QObject):
"""
The Document class is the root of the model. It has two main purposes:
1. Serve as the parent all Part objects within the model.
2. Track all sub-model actions on its undoStack.
"""
def __init__(self):
super(Document, self).__init__()
self._undoStack = QUndoStack()
self._parts = []
self._assemblies = []
self._controller = None
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
# http://www.opensource.org/licenses/mit-license.php
"""
base.py
Created by Shawn Douglas on 2011-02-08.
"""
from .enum import StrandType
from random import Random
from views import styles
prng = Random()
import util
# import Qt stuff into the module namespace with PySide, PyQt4 independence
util.qtWrapImport('QtGui', globals(), [ 'QColor'])
class Base(object):
"""
A POD class that lives in the private API of virtualhelix.
(Why not put it inside VirtualHelix? Because it's already quite crowded)
Provides information about which bases are connected to which other bases.
"""
def __init__(self, vhelix, strandtype, index):
super(Base, self).__init__()
self._5pBase = None
self._3pBase = None
self._color = None
self._vhelix = vhelix
self._strandtype = strandtype
self._n = index
# THE SOFTWARE.
#
# http://www.opensource.org/licenses/mit-license.php
from 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 ui.mainwindow.ui_mainwindow as ui_mainwindow
import util
util.qtWrapImport('QtCore', globals(), ['pyqtSignal', 'Qt', 'QFileInfo',
'QPoint', 'QSettings', 'QSize',
'QString'])
util.qtWrapImport('QtGui', globals(), ['QAction', 'QApplication',
'QGraphicsObject', 'QGraphicsScene',
'QGraphicsView', 'QMainWindow',
'QGraphicsItem', 'QGraphicsRectItem',
'QWidget', 'QPaintEngine'])
# for OpenGL mode
try:
from OpenGL import GL
except:
GL = False
GL = False
class DocumentWindow(QMainWindow, ui_mainwindow.Ui_MainWindow):
# http://www.opensource.org/licenses/mit-license.php
"""
virtualhelixitem.py
Created by Shawn on 2010-06-15.
"""
from views import styles
from model.virtualhelix import VirtualHelix
from model.enum import Parity, StrandType
from controllers.itemcontrollers.virtualhelixitemcontroller import VirtualHelixItemController
import util
# import Qt stuff into the module namespace with PySide, PyQt4 independence
util.qtWrapImport('QtCore', globals(), ['Qt', 'QEvent', 'QString', 'QRectF',\
'QPointF'])
util.qtWrapImport('QtGui', globals(), ['QGraphicsEllipseItem', 'QGraphicsItem',\
'QGraphicsSimpleTextItem', 'QBrush', 'QPen', \
'QPainterPath', 'QPolygonF', 'QGraphicsLineItem', 'QColor'])
class VirtualHelixItem(QGraphicsEllipseItem):
"""
The VirtualHelixItem is an individual circle that gets drawn in the SliceView
as a child of the PartItem. Taken as a group, many SliceHelix
instances make up the crossection of the DNAPart. Clicking on a SliceHelix
adds a VirtualHelix to the DNAPart. The SliceHelix then changes appearence
and paints its corresponding VirtualHelix number.
"""
# set up default, hover, and active drawing styles
_useBrush = QBrush(styles.orangefill)
_usePen = QPen(styles.orangestroke, styles.SLICE_HELIX_STROKE_WIDTH)
import math
import re
from cadnano import app
from model.enum import StrandType
from views import styles
import util
try:
from OpenGL import GL
except:
GL = False
GL = False
# import Qt stuff into the module namespace with PySide, PyQt4 independence
util.qtWrapImport('QtCore', globals(), ['QPointF', 'QRectF', 'Qt'])
util.qtWrapImport('QtGui', globals(), ['QBrush', 'QFont', 'QGraphicsItem',\
'QGraphicsSimpleTextItem', 'QPen',\
'QGraphicsTextItem', 'QDrag', \
'QUndoCommand', 'QGraphicsEllipseItem',\
'QTransform', 'QStyle'])
# strand addition stores some meta information in the UndoCommand's text
_strand_re = re.compile("\((\d+),(\d+)\)\.0\^(\d+)")
class EmptyHelixItem(QGraphicsEllipseItem):
"""docstring for EmptyHelixItem"""
# set up default, hover, and active drawing styles
_defaultBrush = QBrush(styles.grayfill)
_defaultPen = QPen(styles.graystroke, styles.SLICE_HELIX_STROKE_WIDTH)
_hoverBrush = QBrush(styles.bluefill)
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 views.solidview.mayaHotKeys as mayaHotKeys
import views.solidview.mayaUI as mayaUI
import 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")
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
# http://www.opensource.org/licenses/mit-license.php
import re
from abstractpathtool import AbstractPathTool
from model.enum import StrandType
from data.dnasequences import sequences
from ui.dialogs.ui_addseq import Ui_AddSeqDialog
from views import styles
import util
util.qtWrapImport('QtGui', globals(), ['QBrush','QColor', 'QDialog', \
'QDialogButtonBox', 'QFont', 'QPen', \
'QRadioButton', 'QSyntaxHighlighter', \
'QTextCharFormat'])
util.qtWrapImport('QtCore', globals(), ['Qt', 'QObject', 'QPointF', \
'QRegExp', \
'QString', 'QSignalMapper', \
'pyqtSignal', 'pyqtSlot'])
dnapattern = QRegExp("[^ACGTacgt]")
class DNAHighlighter(QSyntaxHighlighter):
def __init__(self, parent):
QSyntaxHighlighter.__init__(self, parent)
self.parent = parent
self.format = QTextCharFormat()
self.format.setForeground(QBrush(styles.INVALID_DNA_COLOR))
if styles.UNDERLINE_INVALID_DNA:
# -*- coding: utf-8 -*-
# Form implementation generated from reading ui file 'mainwindow.ui'
#
# Created: Tue Jul 5 15:37:53 2011
# by: PyQt4 UI code generator 4.8.3
#
# WARNING! All changes made in this file will be lost!
import util
util.qtWrapImport(None, globals(), ["QtCore", "QtGui"])
try:
_fromUtf8 = QtCore.QString.fromUtf8
except AttributeError:
_fromUtf8 = lambda s: s
class Ui_MainWindow(object):
def setupUi(self, MainWindow):
MainWindow.setObjectName(_fromUtf8("MainWindow"))
MainWindow.resize(1100, 800)
MainWindow.setContextMenuPolicy(QtCore.Qt.NoContextMenu)
MainWindow.setStatusTip(_fromUtf8(""))
MainWindow.setIconSize(QtCore.QSize(32, 32))
MainWindow.setDockNestingEnabled(True)
MainWindow.setDockOptions(
QtGui.QMainWindow.AllowNestedDocks | QtGui.QMainWindow.AllowTabbedDocks | QtGui.QMainWindow.AnimatedDocks
)
self.centralwidget = QtGui.QWidget(MainWindow)
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
# http://www.opensource.org/licenses/mit-license.php
import bisect
# from PyQt4.QtCore import QAbstractItemModel, QModelIndex, Qt, QByteArray, QString, QStringList, QVariant
# from PyQt4.QtCore import QXmlStreamReader, QXmlStreamWriter
import util
# import Qt stuff into the module namespace with PySide, PyQt4 independence
util.qtWrapImport('QtCore', globals(), ['QAbstractItemModel', 'QModelIndex', \
'Qt', 'QByteArray', 'QString', \
'QStringList', 'QVariant', \
'QXmlStreamReader', \
'QXmlStreamWriter'])
NODETAG = "node"
NAMETAG = "NAMETAG"
OBJ_ID = "objectid"
INST_ID = "instanceid"
KEY, NODE = range(2)
NAME,HIDDEN,LOCKED = range(3)
class Node(object):
"""
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
# http://www.opensource.org/licenses/mit-license.php
import json
from exceptions import ImportError
from legacydecoder import import_legacy_dict
from ui.dialogs.ui_latticetype import Ui_LatticeType
import util, cadnano
if cadnano.app().isGui():#headless:
from ui.dialogs.ui_latticetype import Ui_LatticeType
util.qtWrapImport('QtGui', 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
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
# http://www.opensource.org/licenses/mit-license.php
from exceptions import ImportError
from controllers.viewrootcontroller import ViewRootController
from partitem import PartItem
import util
util.qtWrapImport('QtCore', globals(), ['pyqtSignal', 'QObject'])
util.qtWrapImport('QtGui', 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
#
# http://www.opensource.org/licenses/mit-license.php
"""
assembly.py
Created by Nick Conway on 2011-01-19.
"""
from collections import defaultdict
from idbank import IdBank
# from PyQt4.QtCore import QObject
import util
# import Qt stuff into the module namespace with PySide, PyQt4 independence
util.qtWrapImport('QtCore', globals(), ['QObject'])
class Assembly(QObject):
"""
"""
def __init__(self, parent=None):
super(Assembly,self).__init__()
"""
this is gonna be a list of non-specific attributes for an assembly
self.object_instances = defaultdict(list) # default dictionary as a list?
"""
self.parent = parent # or parent hash?
self.node_type = "assembly"
self.color = 0
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
# http://www.opensource.org/licenses/mit-license.php
from math import floor
from controllers.itemcontrollers.virtualhelixitemcontroller import VirtualHelixItemController
from model.enum import StrandType
from strand.stranditem import StrandItem
from views import styles
from virtualhelixhandleitem import VirtualHelixHandleItem
import 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', 'QGraphicsItem', \
'QGraphicsPathItem', 'QGraphicsRectItem', \
'QPainterPath', 'QPen', 'QBrush', 'QColor'])
_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
"""
activeslicehandle.py
Created by Shawn on 2011-02-05.
"""
# from exceptions import IndexError
from math import floor
from controllers.itemcontrollers.activesliceitemcontroller import ActiveSliceItemController
from views import styles
import 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'])
util.qtWrapImport('QtWidgets', globals(), [
'QGraphicsItem', 'QGraphicsSimpleTextItem', 'QGraphicsRectItem',
'QUndoCommand'
])
_baseWidth = styles.PATH_BASE_WIDTH
_brush = QBrush(styles.activeslicehandlefill)
_labelbrush = QBrush(styles.orangestroke)
_pen = QPen(styles.activeslicehandlestroke,\
styles.SLICE_HANDLE_STROKE_WIDTH)
_font = QFont(styles.thefont, 12, QFont.Bold)
class ActiveSliceItem(QGraphicsRectItem):
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
# http://www.opensource.org/licenses/mit-license.php
"""
config
Created by Jonathan deWerd on 2012-01-19.
"""
import util, cadnano
import autobreakconfig_ui
import autobreak
util.qtWrapImport('QtGui', globals(), ['QDialog', 'QKeySequence', 'QDialogButtonBox'])
util.qtWrapImport('QtCore', globals(), ['Qt'])
class AutobreakConfig(QDialog, autobreakconfig_ui.Ui_Dialog):
def __init__(self, parent, handler):
QDialog.__init__(self, parent, Qt.Sheet)
self.setupUi(self)
self.handler = handler
fb = self.buttonBox.button(QDialogButtonBox.Cancel)
fb.setShortcut(QKeySequence(Qt.CTRL | Qt.Key_R ))
def keyPressEvent(self, e):
return QDialog.keyPressEvent(self, e)
def closeDialog(self):
self.close()
# THE SOFTWARE.
#
# http://www.opensource.org/licenses/mit-license.php
"""
recorder.py
Created by Shawn on 2011-06-30.
"""
import os
import glob
from cadnano import app
from model.enum import LatticeType
import util
util.qtWrapImport("QtCore", globals(), ["Qt", "QPoint", "QPointF", "QEvent", "pyqtSlot"])
class TestRecorder(object):
"""
TestRecorder can be used to auto-generate functional tests based on
user input.
It is currently set up for specific workflow, which assumes the first
step is creating a part, followed by mousePress, mouseMove, and
mouseRelease events in the slice and path views.
INSTRUCTIONS:
To record a new test, call "python main.py -r" from the cadnano2
root directory. The resulting test will be saved in two places:
#!/usr/bin/env python
# encoding: utf-8
import 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('QtWidgets', 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
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
# http://www.opensource.org/licenses/mit-license.php
import util
import sys
from abstractpathtool import AbstractPathTool
util.qtWrapImport('QtCore', globals(), ['Qt', 'QPointF'])
util.qtWrapImport('QtGui', globals(), ['QGraphicsItem', 'QBrush', 'QFont',
'QGraphicsSimpleTextItem', 'QPen',
'QPolygonF', 'QPainterPath'])
class BreakTool(AbstractPathTool):
"""
BreakTool is the default tool. It allows editing of breakpoints
(by clicking and dragging) and toggling of crossovers.
"""
# And we actually use those PartGraphicsItem events
mouseMovePartGraphicsItemUnused = False
mouseReleasePartGraphicsItemUnused = False
mousePressPartGraphicsItemUnused = False
logger = None
import re
from .abstractpathtool import AbstractPathTool
from data.dnasequences import sequences
from ui.dialogs.ui_addseq import Ui_AddSeqDialog
from views import styles
import util
util.qtWrapImport('QtCore', globals(), [
'Qt', 'QObject', 'QPointF', 'QRegExp', 'QSignalMapper', 'pyqtSignal',
'pyqtSlot'
])
util.qtWrapImport('QtGui', globals(), [
'QBrush', 'QColor', 'QFont', 'QPen', 'QSyntaxHighlighter',
'QTextCharFormat'
])
util.qtWrapImport('QtWidgets', globals(), [
'QDialog',
'QDialogButtonBox',
'QRadioButton',
])
dnapattern = QRegExp("[^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:
Created by Simon Breslav on 2011-10-05.
"""
from controllers.mayacontrollers.mayaObjectManager import Mom
from controllers.itemcontrollers.strand.stranditemcontroller \
import StrandItemController
from model.enum import StrandType
from model.enum import LatticeType
from cadnano import app
import maya.OpenMayaUI as mui
import maya.OpenMaya as mo
import maya.cmds as cmds
import 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
from views import styles
from model.enum import EndType, LatticeType, StrandType
from model.virtualhelix import VirtualHelix
from weakref import ref
from handles.pathhelixhandle import PathHelixHandle
from handles.loophandle import LoopItem, SkipItem
from handles.precrossoverhandle import PreCrossoverHandle
from math import floor, pi, ceil
from cadnano import app
from itertools import product
from ui.svgbutton import SVGButton
import util
# import Qt stuff into the module namespace with PySide, PyQt4 independence
util.qtWrapImport('QtCore', globals(), ['Qt', 'QRect', 'QLine', 'QRectF',\
'QPointF', 'QPoint', 'pyqtSlot',\
'QEvent', 'SLOT'])
util.qtWrapImport('QtGui', globals(), ['QBrush', 'QColor', 'QFont',\
'QGraphicsObject', 'QFontMetricsF',\
'QGraphicsSimpleTextItem',\
'QPainter', 'QPainterPath', 'QPen',\
'QDrag', 'QPolygonF', 'QUndoCommand',
'QInputDialog', 'QGraphicsItem'])
baseWidth = styles.PATH_BASE_WIDTH
ppL5 = QPainterPath() # Left 5' PainterPath
ppR5 = QPainterPath() # Right 5' PainterPath
ppL3 = QPainterPath() # Left 3' PainterPath
ppR3 = QPainterPath() # Right 3' PainterPath
# set up ppL5 (left 5' blue square)
ppL5.addRect(0.25 * baseWidth, 0.125 * baseWidth,\
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
# http://www.opensource.org/licenses/mit-license.php
from collections import defaultdict
from model.document import Document
from model.enum import LatticeType, StrandType
from model.parts.honeycombpart import HoneycombPart
from model.parts.squarepart import SquarePart
from model.virtualhelix import VirtualHelix
from views import styles
import util, cadnano
# import Qt stuff into the module namespace with PySide, PyQt4 independence
util.qtWrapImport('QtGui', globals(), ['QColor'])
if cadnano.app().isGui():
from ui.dialogs.ui_latticetype import Ui_LatticeType
util.qtWrapImport('QtGui', globals(), ['QDialog', 'QDialogButtonBox'])
NODETAG = "node"
NAME = "name"
OBJ_ID = "objectid"
INST_ID = "instanceid"
DONE = "done"
CHECKED = "check"
LOCKED = "locked"
VHELIX = "vhelix"
NUM = "num"
COL = "col"
#!/usr/bin/env python
# encoding: utf-8
import util
from views import styles
from 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'])
util.qtWrapImport('QtWidgets', globals(), [
'QGraphicsPathItem', 'QGraphicsRectItem', 'QGraphicsSimpleTextItem',
'QUndoCommand'
])
# 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,\
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
# http://www.opensource.org/licenses/mit-license.php
"""
selecttool
Created by Shawn Douglas on 2011-06-21.
"""
from abstractpathtool import AbstractPathTool
import util
util.qtWrapImport('QtGui', globals(), ['QPen', 'QColor', 'QInputDialog'])
util.qtWrapImport('QtCore', globals(), ['Qt', 'QPointF', 'SLOT', 'pyqtSlot'])
from model.enum import StrandType
from data.dnasequences import sequences
class AddSeqTool(AbstractPathTool):
def __init__(self, controller, parent=None):
AbstractPathTool.__init__(self, controller, parent)
def mousePressPathHelix(self, pathHelix, event):
strandType, idx = self.baseAtPoint(pathHelix, event.pos())
dialog = QInputDialog(self.window())
dialog.setWindowFlags(Qt.Dialog | Qt.Sheet)
dialog.setWindowModality(Qt.WindowModal)
dialog.setLabelText('Choose the sequence to be applied from 5\' to 3\' in the\n oligo you clicked on by name, or enter a sequence by hand:')
dialog.setWindowTitle('Choose Sequence')
import json
from .legacydecoder import import_legacy_dict
from ui.dialogs.ui_latticetype import Ui_LatticeType
import util, cadnano
if cadnano.app().isGui(): # headless:
from 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)
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
# http://www.opensource.org/licenses/mit-license.php
"""
part
Created by Jonathan deWerd on 2011-01-26.
"""
from exceptions import NotImplementedError
from cadnano import app
import util
# import Qt stuff into the module namespace with PySide, PyQt4 independence
util.qtWrapImport('QtCore', globals(), ['pyqtSignal', 'QObject'])
class Part(QObject):
# this is for removing a part from scenes
partRemoved = pyqtSignal()
def __init__(self, id, *args, **kargs):
super(Part, self).__init__()
app().p = self
def document(self):
return self._document
def _setDocument(self, newDoc):
"Should only be called by Document"
self._document = newDoc
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
# http://www.opensource.org/licenses/mit-license.php
"""
cadnanoqt
Created by Jonathan deWerd on 2012-01-11.
"""
import util, sys, os
import cadnano
from code import interact
util.qtWrapImport('QtGui', globals(), ['qApp', 'QApplication', 'QIcon',\
'QUndoGroup'])
util.qtWrapImport('QtCore', globals(), ['QObject', 'QCoreApplication', 'Qt',\
'QEventLoop', 'pyqtSignal'])
class CadnanoQt(QObject):
dontAskAndJustDiscardUnsavedChanges = False
shouldPerformBoilerplateStartupScript = False
documentWasCreatedSignal = pyqtSignal(object) # doc
documentWindowWasCreatedSignal = pyqtSignal(object, object) # doc, window
def __init__(self, argv):
self.argv = argv
if QCoreApplication.instance() == None:
self.qApp = QApplication(argv)
assert (QCoreApplication.instance() != None)
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
# http://www.opensource.org/licenses/mit-license.php
import 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 ###
# from model.strands.normalstrand import NormalStrand
# from model.strands.xoverstrand import XoverStrand3, XoverStrand5
from controllers.mayacontrollers.mayaObjectManager import Mom
from controllers.itemcontrollers.virtualhelixitemcontroller import VirtualHelixItemController
import maya.OpenMayaUI as mui
import maya.OpenMaya as mo
import maya.cmds as cmds
import util
from .stranditem import StrandItem
# import Qt stuff into the module namespace with PySide, PyQt4 independence
util.qtWrapImport("QtCore", globals(), ["pyqtSignal", "pyqtSlot", "QObject"])
util.qtWrapImport("QtGui", globals(), ["QColor"])
class VirtualHelixItem(object):
"""
VirtualHelixItem is the container for StrandItems for is the Maya 3D View,
it does not get visualized in any way right now.
"""
baseWidth = styles.PATH_BASE_WIDTH
def __init__(self, partItem, modelVirtualHelix, x, y):
"""
Initialize member variables.
Setup VirtualHelixItemController, that takes care of all the
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
# http://www.opensource.org/licenses/mit-license.php
import sys
from abstractpathtool import AbstractPathTool
import 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
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
# http://www.opensource.org/licenses/mit-license.php
# from model.enum import StrandType
from views import styles
from model.enum import StrandType
import util
# import Qt stuff into the module namespace with PySide, PyQt4 independence
util.qtWrapImport('QtCore', globals(), ['QPointF', 'QRectF', 'Qt'])
util.qtWrapImport('QtGui', globals(), [ 'QGraphicsItem', 'QGraphicsItemGroup', \
'QBrush', 'QFont', 'QPen', \
'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.NoBrush)
# There's a bug where C++ will free orphaned graphics items out from
# under pyqt. To avoid this, "_mother" adopts orphaned graphics items.
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
# http://www.opensource.org/licenses/mit-license.php
import util
util.qtWrapImport('QtCore', globals(), ['QObject', 'pyqtSignal', 'Qt'])
util.qtWrapImport('QtGui', 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()
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
# http://www.opensource.org/licenses/mit-license.php
"""
recordinggraphicsitem.py
Created by Shawn on 2011-07-01.
"""
import util
util.qtWrapImport('QtCore', globals(), ['Qt', 'QEvent', 'QString', 'QRectF'])
util.qtWrapImport('QtGui', globals(), ['QGraphicsItem', 'QGraphicsObject'])
class SceneType:
Slice = 0
Path = 1
class RecordableQGraphicsItem(object):
"""QGraphicsItems that need to report actions to the test recorder
via sceneEvent should also inherit from this class."""
def __init__(self, controller, sceneType):
"""docstring for __init__"""
print "init RecordableQGraphicsItem"
self.controller = controller
self.sceneType = sceneType
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
# http://www.opensource.org/licenses/mit-license.php
import sys
from abstractpathtool import AbstractPathTool
import util
util.qtWrapImport('QtCore', globals(), [])
util.qtWrapImport('QtGui', globals(), [])
class PaintTool(AbstractPathTool):
"""
Handles visibility and color cycling for the paint tool.
"""
def __init__(self, controller):
super(PaintTool, self).__init__(controller)
self._isMacrod = False
def __repr__(self):
return "paintTool" # first letter should be lowercase
def setActive(self, willBeActive):
import re
import os
import inspect
from collections import deque
try:
import readline
import rlcompleter
except ImportError:
readline = None
## CADNANO MODULE imports ##
import cadnano
import util
util.qtWrapImport('QtGui', globals(), ['QTransform'])
util.qtWrapImport(
'QtCore', globals(),
['QPropertyAnimation', 'pyqtProperty', 'QObject', 'QEasingCurve'])
## SETTINGS ##
#### Constants / settings for API functions #####
ANIMATE_DURATION_MSEC = 500
ANIMATE_ENABLED_DEFAULT = True
# PySide QEasingCurve is NOT instantiated with an integer, but takes a QtCore.Type instance.
ANIMATE_EASINGCURVE = QEasingCurve.Linear # This should work for both PyQt4 and PySide and is also more readable.
# http://qt-project.org/doc/qt-4.8/qeasingcurve.html
#
# http://www.opensource.org/licenses/mit-license.php
"""
virtualhelixitem.py
Created by Shawn on 2010-06-15.
"""
from views import styles
from model.virtualhelix import VirtualHelix
from model.enum import Parity, StrandType
from controllers.itemcontrollers.virtualhelixitemcontroller import VirtualHelixItemController
import util
# import Qt stuff into the module namespace with PySide, PyQt4 independence
util.qtWrapImport('QtCore', globals(), ['Qt', 'QEvent', 'QString', 'QRectF',\
'QPointF'])
util.qtWrapImport('QtGui', globals(), ['QGraphicsEllipseItem', 'QGraphicsItem',\
'QGraphicsSimpleTextItem', 'QBrush', 'QPen'])
class VirtualHelixItem(QGraphicsEllipseItem):
"""
The VirtualHelixItem is an individual circle that gets drawn in the SliceView
as a child of the PartItem. Taken as a group, many SliceHelix
instances make up the crossection of the DNAPart. Clicking on a SliceHelix
adds a VirtualHelix to the DNAPart. The SliceHelix then changes appearence
and paints its corresponding VirtualHelix number.
"""
# set up default, hover, and active drawing styles
_useBrush = QBrush(styles.orangefill)
_usePen = QPen(styles.orangestroke, styles.SLICE_HELIX_STROKE_WIDTH)
from controllers.itemcontrollers.partitemcontroller import PartItemController
from .emptyhelixitem import EmptyHelixItem
from .virtualhelixitem import VirtualHelixItem
from .activesliceitem import ActiveSliceItem
from views import styles
import 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)
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
# http://www.opensource.org/licenses/mit-license.php
from views import styles
import util
util.qtWrapImport('QtCore', globals(), ['QRectF', 'Qt'])
util.qtWrapImport('QtGui', globals(), ['QBrush', 'QColorDialog', 'QFont',
'QGraphicsItem',
'QGraphicsSimpleTextItem'])
_font = QFont(styles.thefont, 12, QFont.Bold)
class ColorPanel(QGraphicsItem):
_scafColors = styles.scafColors
_stapColors = styles.stapColors
_pen = Qt.NoPen
def __init__(self, parent=None):
super(ColorPanel, self).__init__(parent)
self.rect = QRectF(0, 0, 30, 30)
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
# http://www.opensource.org/licenses/mit-license.php
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 util
util.qtWrapImport('QtCore', globals(), ['QDir', 'QFileInfo', 'QRect',
'QString', 'QStringList', 'QSettings',
'QSize', 'Qt'])
util.qtWrapImport('QtGui', globals(), ['QApplication', 'QDialog',
'QDockWidget', 'QFileDialog',
'QKeySequence', 'QGraphicsItem',
'QMainWindow',
'QMessageBox', 'QPainter', 'QIcon',
'QStyleOptionGraphicsItem'])
util.qtWrapImport('QtSvg', globals(), ['QSvgGenerator'])
class DocumentController():
"""
Connects UI buttons to their corresponding actions in the model.
"""
### INIT METHODS ###
def __init__(self):
from math import floor
from .abstractpathtool import AbstractPathTool
from views import styles
import 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.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()
from .autobreakconfig import AutobreakConfig
import cadnano, util
util.qtWrapImport('QtGui', globals(), ['QAction', 'QIcon', 'QPixmap'])
class AutobreakHandler(object):
def __init__(self, document, window):
self.doc, self.win = document, window
icon10 = QIcon()
icon10.addPixmap(QPixmap(":/pathtools/autobreak"), QIcon.Mode.Normal,
QIcon.State.Off)
self.actionAutoBreak = QAction(window)
self.actionAutoBreak.setIcon(icon10)
self.actionAutoBreak.setText('AutoBreak')
self.actionAutoBreak.setToolTip(
"Click this button to generate a default set of staples.")
self.actionAutoBreak.setObjectName("actionAutoBreak")
self.actionAutoBreak.triggered.connect(self.actionAutobreakSlot)
self.win.menuPlugins.addAction(self.actionAutoBreak)
# add to main tool bar
self.win.topToolBar.insertAction(self.win.actionFiltersLabel,
self.actionAutoBreak)
self.win.topToolBar.insertSeparator(self.win.actionFiltersLabel)
self.configDialog = None
def actionAutobreakSlot(self):
"""Only show the dialog if staple strands exist."""
part = self.doc.controller().activePart()
if part != None: # is there a part?
for o in list(part.oligos()):
if o.isStaple(): # is there a staple oligo?
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
# http://www.opensource.org/licenses/mit-license.php
from exceptions import NotImplementedError
from math import floor
from views import styles
import views.pathview.pathselection as pathselection
import util
# import Qt stuff into the module namespace with PySide, PyQt4 independence
util.qtWrapImport('QtCore', globals(),
['pyqtSignal', 'QObject', 'QPointF', 'QRectF', 'Qt'])
util.qtWrapImport('QtGui', globals(), ['QGraphicsPathItem', 'QPen', \
'QGraphicsItem', 'QPainterPath', \
'QPolygonF', 'QGraphicsRectItem', \
'QBrush', 'QColor'])
_baseWidth = styles.PATH_BASE_WIDTH
ppL5 = QPainterPath() # Left 5' PainterPath
ppR5 = QPainterPath() # Right 5' PainterPath
ppL3 = QPainterPath() # Left 3' PainterPath
ppR3 = QPainterPath() # Right 3' PainterPath
pp53 = QPainterPath() # Left 5', Right 3' PainterPath
pp35 = QPainterPath() # Left 5', Right 3' PainterPath
# set up ppL5 (left 5' blue square)
ppL5.addRect(0.25 * _baseWidth, 0.125 * _baseWidth, 0.75 * _baseWidth,
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
# http://www.opensource.org/licenses/mit-license.php
from ui.dialogs.ui_preferences import Ui_Preferences
from views import styles
import util
import cadnano
import os.path, zipfile, shutil, platform, subprocess, tempfile, errno
util.qtWrapImport('QtCore', globals(), ['QObject', 'QSettings', 'pyqtSlot', 'Qt'])
util.qtWrapImport('QtGui', globals(), ['QWidget', 'QDialogButtonBox',\
'QTableWidgetItem', 'QFileDialog',\
'QMessageBox'])
class Preferences(object):
"""
Preferences class used to:
1) Create a preferences Qt widget, self.uiPrefs, which is bound to another new parent, self.widget.
2) Read settings and set up event bindings (So changes in UI status is linked to the settings store).
"""
def __init__(self):
self.qs = QSettings()
self.uiPrefs = Ui_Preferences()
self.widget = QWidget()
self.uiPrefs.setupUi(self.widget)
import 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()
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
# http://www.opensource.org/licenses/mit-license.php
from abstractpathtool import AbstractPathTool
from views import styles
import util
util.qtWrapImport('QtCore', globals(), ['QPointF', 'QRectF', 'Qt'])
util.qtWrapImport(
'QtGui', globals(),
['QGraphicsItem', 'QBrush', 'QFont', 'QPainterPath', 'QPen', 'QPolygonF'])
_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
# http://www.opensource.org/licenses/mit-license.php
"""
document.py
Created by Jonathan deWerd on 2011-01-26.
"""
import json
from views import styles
from .dnahoneycombpart import DNAHoneycombPart
from .dnasquarepart import DNASquarePart
from .enum import LatticeType
import util
# import Qt stuff into the module namespace with PySide, PyQt4 independence
util.qtWrapImport('QtCore', globals(), ['pyqtSignal', 'QObject'])
util.qtWrapImport('QtGui', globals(), [ 'QUndoCommand'])
class Document(QObject):
def __init__(self, incompleteArchivedDict=None):
super(Document, self).__init__()
self._parts = []
self._selectedPart = None
self._controller = None
def fsck(self):
for p in self._parts:
p.fsck()
def controller(self):
return self._controller
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
# http://www.opensource.org/licenses/mit-license.php
"""
config
Created by Jonathan deWerd on 2012-01-19.
"""
import util, cadnano
import autobreakconfig_ui
import autobreak
util.qtWrapImport('QtGui', globals(),
['QDialog', 'QKeySequence', 'QDialogButtonBox'])
util.qtWrapImport('QtCore', globals(), ['Qt'])
class AutobreakConfig(QDialog, autobreakconfig_ui.Ui_Dialog):
def __init__(self, parent, handler):
QDialog.__init__(self, parent, Qt.Sheet)
self.setupUi(self)
self.handler = handler
fb = self.buttonBox.button(QDialogButtonBox.Cancel)
fb.setShortcut(QKeySequence(Qt.CTRL | Qt.Key_R))
def keyPressEvent(self, e):
return QDialog.keyPressEvent(self, e)
def closeDialog(self):
from views import styles
import 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.Bold)
class ColorPanel(QGraphicsItem):
_scafColors = styles.scafColors
_stapColors = styles.stapColors
_pen = Qt.NoPen
def __init__(self, parent=None):
super(ColorPanel, self).__init__(parent)
self.rect = QRectF(0, 0, 30, 30)
self.setFlag(QGraphicsItem.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()
def _initLabel(self):
#
# http://www.opensource.org/licenses/mit-license.php
"""
activeslicehandle.py
Created by Shawn on 2011-02-05.
"""
from exceptions import IndexError
from math import floor
from controllers.itemcontrollers.activesliceitemcontroller import ActiveSliceItemController
from views import styles
import 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', 'QGraphicsItem',\
'QGraphicsSimpleTextItem', 'QPen',\
'QDrag', 'QUndoCommand', 'QGraphicsRectItem'])
_baseWidth = styles.PATH_BASE_WIDTH
_brush = QBrush(styles.activeslicehandlefill)
_labelbrush = QBrush(styles.orangestroke)
_pen = QPen(styles.activeslicehandlestroke,\
styles.SLICE_HANDLE_STROKE_WIDTH)
_font = QFont(styles.thefont, 12, QFont.Bold)
class ActiveSliceItem(QGraphicsRectItem):
"""ActiveSliceItem for the Path View"""
