def actions(self):
actionDefault = QtGui.QAction(
QtGui.QIcon(":/images/resources/layout_blue.png"),
"Load Default", self.mainwindow)
actionRestorePref = QtGui.QAction(
QtGui.QIcon(":/images/resources/layout_green.png"),
"Load Prefered", self.mainwindow)
actionSetPref = QtGui.QAction(
QtGui.QIcon(":/images/resources/layout_red.png"),
"Save Prefered", self.mainwindow)
QtCore.QObject.connect(actionDefault,
QtCore.SIGNAL('triggered(bool)'),
self.mainwindow.defaultSettings)
QtCore.QObject.connect(actionRestorePref,
QtCore.SIGNAL('triggered(bool)'),
self.mainwindow.preferedSettings)
QtCore.QObject.connect(
actionSetPref, QtCore.SIGNAL('triggered(bool)'),
self.mainwindow.registerPreferedSettings)
_actions = [["Help", "Window Layout", actionDefault, 1],
["Help", "Window Layout", actionRestorePref, 1],
["Help", "Window Layout", actionSetPref, 1]]
return _actions
def actions(self):
minilab = QtGui.QAction(
QtGui.QIcon(":/images/resources/openalealogo.png"),
"MiniLab", self.mainwindow)
lab3d = QtGui.QAction(
QtGui.QIcon(":/images/resources/openalealogo.png"),
"3DLab", self.mainwindow)
plantlab = QtGui.QAction(
QtGui.QIcon(":/images/resources/openalealogo.png"),
"PlantLab", self.mainwindow)
tissuelab = QtGui.QAction(
QtGui.QIcon(":/images/resources/openalealogo.png"),
"TissueLab", self.mainwindow)
QtCore.QObject.connect(minilab,
QtCore.SIGNAL('triggered(bool)'),
self.mainwindow._mini)
QtCore.QObject.connect(lab3d, QtCore.SIGNAL('triggered(bool)'),
self.mainwindow._lab3d)
QtCore.QObject.connect(plantlab,
QtCore.SIGNAL('triggered(bool)'),
self.mainwindow._plant)
QtCore.QObject.connect(tissuelab,
QtCore.SIGNAL('triggered(bool)'),
self.mainwindow._tissue)
_actions = [["Extension", "Select an Extension", minilab, 0],
["Extension", "Select an Extension", lab3d, 0],
["Extension", "Select an Extension", plantlab, 0],
["Extension", "Select an Extension", tissuelab, 0]]
return None
class DataFactoryManager(AbstractDataFactoryManager):
data_created = QtCore.Signal(object)
data_property_set_request = QtCore.Signal(object, str, object)
def __init__(self):
AbstractDataFactoryManager.__init__(self)
self.__mimeMap = {}
def gather_items(self, refresh=False):
items = AbstractDataFactoryManager.gather_items(self, refresh)
if refresh:
self.__mimeMap.clear()
for datatype in items.itervalues():
if not datatype.started:
datatype._start_0()
if datatype is None or not datatype.supports_open():
continue
fmts = datatype.opened_mimetypes
for fmt in fmts:
self.__mimeMap.setdefault(fmt, set()).add(datatype)
return items
def get_handlers_for_mimedata(self, formats):
datatypes = self.gather_items()
handlers = set() # for unicity
for fm in formats:
fmt_datatypes = self.__mimeMap.get(fm)
if fmt_datatypes is not None:
handlers.update(fmt_datatypes)
return list(handlers)
def __init__(self, session=None, controller=None, parent=None):
super(HelpWidget, self).__init__(parent=parent)
self.setAccessibleName("HelpWidget")
actionHelpOpenAlea = QtGui.QAction(
QtGui.QIcon(":/images/resources/openalealogo.png"),
"OpenAlea WebSite", self)
actionHelpGForge = QtGui.QAction(
QtGui.QIcon(":/images/resources/git.png"), "Submit Issues", self)
actionHelpTasks = QtGui.QAction(
QtGui.QIcon(":/images/resources/gforge.png"), "See Tasks", self)
actionEditPref = QtGui.QAction(
QtGui.QIcon(":/images/resources/node.png"), "Preferences", self)
self.connect(actionHelpOpenAlea, QtCore.SIGNAL('triggered(bool)'),
self.openWebsiteOpenalea)
self.connect(actionHelpGForge, QtCore.SIGNAL('triggered(bool)'),
self.openOALabIssues)
self.connect(actionHelpTasks, QtCore.SIGNAL('triggered(bool)'),
self.openOALabTasks)
actionEditPref.triggered.connect(self.open_preferences)
self._actions = [
["Help", "Website", actionHelpOpenAlea, 0],
["Help", "Website", actionHelpGForge, 0],
["Help", "Settings", actionEditPref, 0],
]
self.setText(default_text)
register_helper(self)
def mimeData(self, modelIndexes):
item = self.itemFromIndex(modelIndexes[0])
mimeData = QtGui.QStandardItemModel.mimeData(self, modelIndexes)
(pkg_id, factory_id, mimetype) = self.get_item_info(item)
# -- marshall package and factory to the data stream, needed later --
itemData = QtCore.QByteArray()
dataStream = QtCore.QDataStream(itemData, QtCore.QIODevice.WriteOnly)
dataStream.writeString(pkg_id)
dataStream.writeString(factory_id)
mimeData.setData(mimetype, itemData)
# -- build an url --
factory = PackageManager()[pkg_id][factory_id]
if isinstance(factory, DataFactory):
url = QtCore.QUrl.fromLocalFile(factory.get_pkg_data().repr)
else:
query = ["fac="+factory_id]
ftname = type(factory).__name__
query.append("ft="+ftname)
query = reduce(lambda x,y:"&".join((x,y)), query)
url = QtCore.QUrl("oa://local/"+pkg_id+"?"+query)
mimeData.setUrls([url])
return mimeData
def startDrag(self, supportedActions):
item = self.currentIndex()
itemData = QtCore.QByteArray()
dataStream = QtCore.QDataStream(itemData, QtCore.QIODevice.WriteOnly)
pixmap = QtGui.QPixmap(":/icons/ccmime.png")
l = self.model().datapool.keys()
l.sort()
name = l[item.row()]
dataStream.writeSting(name)
mimeData = QtCore.QMimeData()
mimeData.setData("openalea/data_instance", itemData)
linecode = cli.get_datapool_code(name)
mimeData.setText(linecode)
drag = QtGui.QDrag(self)
drag.setMimeData(mimeData)
drag.setHotSpot(QtCore.QPoint(pixmap.width()/2, pixmap.height()/2))
drag.setPixmap(pixmap)
drag.start(QtCore.Qt.MoveAction)
def mouseDoubleClickEvent(self,event):
if event.modifiers() == QtCore.Qt.NoModifier:
if event.button() == QtCore.Qt.LeftButton:
self.select(event.pos())
selection = self.selectedName()
if selection == -1:
npoint = self.pointOnEditionPlane(event.pos())
res = self.pointsConstraints.addPointEvent(npoint,self.curveAccessor)
if res:
index,npoint = res
self.curveAccessor.insertPoint(index,npoint)
self.emit(QtCore.SIGNAL('valueChanged()'))
elif event.button() == QtCore.Qt.RightButton:
self.select(event.pos())
selection = self.selectedName()
if selection != -1 :
self.curveAccessor.delPoint(selection)
self.emit(QtCore.SIGNAL('valueChanged()'))
self.createControlPointsRep()
self.updateGL()
elif event.modifiers() == QtCore.Qt.ShiftModifier:
self.select(event.pos())
selection = self.selectedName()
if selection != -1 :
self.curveAccessor.delPoint(selection)
self.emit(QtCore.SIGNAL('valueChanged()'))
self.createControlPointsRep()
self.updateGL()
else:
QGLViewer.mouseDoubleClickEvent(self,event)
def __init__(self, rect, parent=None):
QtGui.QGraphicsRectItem.__init__(self, rect, parent)
self.__resizing = False
self.__handlePoly = QtGui.QPolygonF([
QtCore.QPointF(0, -self.__handleSize),
QtCore.QPointF(0, 0),
QtCore.QPointF(-self.__handleSize, 0)
])
self.setFlag(QtGui.QGraphicsItem.ItemStacksBehindParent)
# -- handle --
self.__handlePos = QtCore.QPointF(0, 0)
# -- header --
self.__headerContentRect = None
self.__headerRect = None
# -- color --
self.__color = None
self.__darkerColor = None
self.__shadowColor = None
self.setColor(self.__defaultColor.darker(110))
# -- optionnal cosmetics --
if safeEffects:
fx = QtGui.QGraphicsDropShadowEffect()
fx.setOffset(2, 2)
fx.setBlurRadius(5)
self.setGraphicsEffect(fx)
def __init__(self, parent=None, session=None):
super(SearchWidget, self).__init__(parent)
self._editor = parent
self.hiden = True
self.setMinimumSize(100, 100)
self.setWindowTitle("Search")
self.actionSearch = QtGui.QAction("Search Next", self)
self.actionBackSearch = QtGui.QAction("Search Previous", self)
self.actionReplace = QtGui.QAction("Replace All", self)
self.lineEdit = QtGui.QLineEdit()
self.lineEditReplace = QtGui.QLineEdit()
self.textSearch = QtGui.QLabel("Search :")
self.textReplaceBy = QtGui.QLabel("Replace by :")
self.btnNext = QtGui.QToolButton()
self.btnPrev = QtGui.QToolButton()
self.btnReplace = QtGui.QToolButton()
self.btnReplace.setMinimumSize(100, 40)
self.btnNext.setMinimumSize(100, 40)
self.btnPrev.setMinimumSize(100, 40)
self.btnReplace.setDefaultAction(self.actionReplace)
self.btnPrev.setDefaultAction(self.actionBackSearch)
self.btnNext.setDefaultAction(self.actionSearch)
self.caseBtn = QtGui.QCheckBox("Match Case")
self.wholeBtn = QtGui.QCheckBox(
"Whole Word (Disabled if case sensitive)")
QtCore.QObject.connect(self.actionBackSearch,
QtCore.SIGNAL('triggered(bool)'),
self.searchBack)
QtCore.QObject.connect(self.actionSearch,
QtCore.SIGNAL('triggered(bool)'), self.search)
QtCore.QObject.connect(self.actionReplace,
QtCore.SIGNAL('triggered(bool)'),
self.replaceall)
QtCore.QObject.connect(self.lineEdit, QtCore.SIGNAL('returnPressed()'),
self.search)
layout = QtGui.QGridLayout()
layout.setAlignment(QtCore.Qt.AlignLeft)
layout.addWidget(self.textSearch, 0, 0)
layout.addWidget(self.lineEdit, 0, 1, 1, 2)
layout.addWidget(self.textReplaceBy, 1, 0)
layout.addWidget(self.lineEditReplace, 1, 1, 1, 2)
layout.addWidget(self.caseBtn, 2, 0)
layout.addWidget(self.wholeBtn, 2, 1)
layout.addWidget(self.btnReplace, 3, 0)
layout.addWidget(self.btnPrev, 3, 1)
layout.addWidget(self.btnNext, 3, 2)
self.setLayout(layout)
def startDrag(self, supportedActions):
index = self.getIndex()
item = self.getItem()
data = self._model.projectdata(index)
if data is None:
return
category, name = data
# Check item in src
# TODO move this part in dragEnterEvent with mimetype
obj = self._model._project.get(category, name)
if category in ['src', 'model']:
# Read file and parse model to get inputs, outputs, doc that may be
# useful once dropped.
obj.read()
text = item.text()
# name_without_ext = ".".join(text.split(".")[:-1])
name_without_ext = text
name_without_space = "_".join(name_without_ext.split())
for sym in ["-", "+", "*", "/", "\"", "."]:
name_without_space = "_".join(name_without_space.split(sym))
python_call_string = '%s = Model("%s")' % (name_without_space,
name_without_ext)
icon = item.icon()
pixmap = icon.pixmap(20, 20)
itemData = QtCore.QByteArray()
dataStream = QtCore.QDataStream(itemData,
QtCore.QIODevice.WriteOnly)
model_id = name_without_ext
dataStream.writeString(str(python_call_string))
dataStream.writeString(str(model_id))
mimeData = QtCore.QMimeData()
mimeData.setText(python_call_string)
mimeData.setData("openalealab/model", itemData)
drag = QtGui.QDrag(self)
drag.setMimeData(mimeData)
drag.setHotSpot(
QtCore.QPoint(pixmap.width() / 2,
pixmap.height() / 2))
drag.setPixmap(pixmap)
drag.start(QtCore.Qt.CopyAction)
elif category == 'data':
p = '%s/%r' % (category, str(obj.filename))
mimetype, mimedata = encode(obj, mimetype='openalealab/data')
qmime_data = QtCore.QMimeData()
qmime_data.setData(mimetype, mimedata)
qmime_data.setText(p)
drag = QtGui.QDrag(self)
drag.setMimeData(qmime_data)
drag.start()
def __updateStatus(self, i=None):
if not i is None and i >= 0:
if int(i) < int(len(self.view.objects)):
if self.view.objects[i][0].managePrimitive():
self.emit(QtCore.SIGNAL('valueChanged(bool)'), True)
else:
self.emit(QtCore.SIGNAL('valueChanged(bool)'), False)
else:
self.emit(QtCore.SIGNAL('valueChanged(bool)'), False)
else:
self.emit(QtCore.SIGNAL('valueChanged(bool)'), False)
def setupUi(self, MainWindow):
MainWindow.setObjectName("MainWindow")
MainWindow.resize(576, 522)
sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Minimum,
QtGui.QSizePolicy.Minimum)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
MainWindow.sizePolicy().hasHeightForWidth())
MainWindow.setSizePolicy(sizePolicy)
MainWindow.setMinimumSize(QtCore.QSize(100, 150))
self.im_view = QtGui.QWidget(MainWindow)
self.im_view.setMinimumSize(QtCore.QSize(50, 50))
self.im_view.setObjectName("im_view")
self.horizontalLayout = QtGui.QHBoxLayout(self.im_view)
self.horizontalLayout.setObjectName("horizontalLayout")
MainWindow.setCentralWidget(self.im_view)
self.statusbar = QtGui.QStatusBar(MainWindow)
self.statusbar.setObjectName("statusbar")
MainWindow.setStatusBar(self.statusbar)
self.toolbar = QtGui.QToolBar(MainWindow)
self.toolbar.setObjectName("toolbar")
MainWindow.addToolBar(QtCore.Qt.TopToolBarArea, self.toolbar)
self.action_close = QtGui.QAction(MainWindow)
icon = QtGui.QIcon()
icon.addPixmap(QtGui.QPixmap(":/image/close.png"), QtGui.QIcon.Normal,
QtGui.QIcon.Off)
self.action_close.setIcon(icon)
self.action_close.setObjectName("action_close")
self.action_snapshot = QtGui.QAction(MainWindow)
icon1 = QtGui.QIcon()
icon1.addPixmap(QtGui.QPixmap(":/image/snapshot.png"),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.action_snapshot.setIcon(icon1)
self.action_snapshot.setObjectName("action_snapshot")
self.action_rotate_left = QtGui.QAction(MainWindow)
icon2 = QtGui.QIcon()
icon2.addPixmap(QtGui.QPixmap(":/image/rotate_left.png"),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.action_rotate_left.setIcon(icon2)
self.action_rotate_left.setObjectName("action_rotate_left")
self.action_rotate_right = QtGui.QAction(MainWindow)
icon3 = QtGui.QIcon()
icon3.addPixmap(QtGui.QPixmap(":/image/rotate_right.png"),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.action_rotate_right.setIcon(icon3)
self.action_rotate_right.setObjectName("action_rotate_right")
self.toolbar.addAction(self.action_close)
self.toolbar.addAction(self.action_snapshot)
self.toolbar.addAction(self.action_rotate_left)
self.toolbar.addAction(self.action_rotate_right)
self.retranslateUi(MainWindow)
QtCore.QMetaObject.connectSlotsByName(MainWindow)
def get_selection_center(self, selection=None):
""" """
items = None
if selection: items = selection
else: items = self.get_selected_items()
l = len(items)
if (l == 0): return QtCore.QPointF(30, 30)
sx = sum((i.pos().x() for i in items))
sy = sum((i.pos().y() for i in items))
return QtCore.QPointF(float(sx) / l, float(sy) / l)
def __init__(self, node, parent):
QtGui.QDialog.__init__(self, parent)
NodeWidget.__init__(self, node)
self.gridlayout = QtGui.QGridLayout(self)
self.gridlayout.setContentsMargins(3, 3, 3, 3)
self.gridlayout.setSpacing(5)
self.package_lineedit_label = QtGui.QLabel('1. Set the package', self)
self.gridlayout.addWidget(self.package_lineedit_label, 0, 0)
self.package_lineedit = QtGui.QLineEdit(self)
self.gridlayout.addWidget(self.package_lineedit, 0, 1, 1, 3)
self.connect(self.package_lineedit, QtCore.SIGNAL("textChanged()"),
self.package_changed)
self.datadir_lineedit = QtGui.QLineEdit(self)
self.datadir_lineedit.setReadOnly(True)
self.gridlayout.addWidget(self.datadir_lineedit, 1, 1, 1, 3)
self.metadata_textedit = QtGui.QTextEdit('', self)
self.metadata_textedit.setReadOnly(True)
self.metadata_textedit.setTextInteractionFlags(
QtCore.Qt.TextBrowserInteraction)
self.gridlayout.addWidget(self.metadata_textedit, 2, 1, 1, 3)
self.glob_lineedit_label = QtGui.QLabel(
'2.Filter the data: (e.g., *.dat)', self)
self.gridlayout.addWidget(self.glob_lineedit_label, 3, 0)
self.glob_lineedit = QtGui.QLineEdit(self)
self.gridlayout.addWidget(self.glob_lineedit, 3, 1, 1, 2)
self.connect(self.glob_lineedit, QtCore.SIGNAL("textChanged()"),
self.glob_changed)
self.filenames_combobox_label = QtGui.QLabel(
'3. Select the data file:', self)
self.gridlayout.addWidget(self.filenames_combobox_label, 4, 0)
self.filenames_combobox = QtGui.QComboBox(self)
self.connect(self.filenames_combobox, QtCore.SIGNAL("activated()"),
self.filename_changed)
self.gridlayout.addWidget(self.filenames_combobox, 4, 1, 1, 3)
self.setWindowTitle("SharedDatabrowser")
self.setGeometry(250, 200, 350, 550)
self.updating = False
self.notify(node, ("input_modified", 0))
self.notify(node, ("caption_modified", node.get_caption()))
def mouseMoveEvent(self, event):
if self.__resizing:
delta = event.pos() - event.lastPos()
bottomRight = self.boundingRect().bottomRight() + delta
newRect = QtCore.QRectF(0., 0., bottomRight.x(), bottomRight.y())
if newRect.contains(
self.__headerContentRect.adjusted(0, 0, 0,
self.__handleSize)):
self.setRect(newRect)
self.__headerRect = QtCore.QRectF(
0., 0., bottomRight.x(), self.__headerContentRect.height())
self.__moveHandleBottomRightTo(newRect.bottomRight())
else:
QtGui.QGraphicsRectItem.mouseMoveEvent(self, event)
class ProjectManager(QtCore.QObject):
__metaclass__ = make_metaclass((ProxySingleton, ),
(QtCore.pyqtWrapperType, ))
active_project_changed = QtCore.Signal(Project, Project)
data_added = QtCore.Signal(object, object)
mimeformat = "application/secondnature-project-data-id"
def __init__(self):
QtCore.QObject.__init__(self)
self.__activeProject = None
def new_active_project(self, name):
proj = Project(name)
return self.set_active_project(proj)
def has_active_project(self):
return self.__activeProject is not None
def set_active_project(self, project):
if self.has_active_project() and self.get_active_project().is_modified(
):
return False # raise something
old = self.__activeProject
self.__activeProject = project
self.__activeProject.data_added.connect(self.data_added)
self.active_project_changed.emit(self.__activeProject, old)
return True
def get_active_project(self):
return self.__activeProject
def close_active_project(self):
if self.__activeProject:
self.__activeProject.close()
self.__activeProject = None
def save_active_project(self, filepath):
self.__activeProject.save_to(filepath)
def add_data_to_active_project(self, data):
if data and data.registerable and self.__activeProject:
self.__activeProject.add_data(data)
def set_property_to_active_project(self, data, key, value):
if data and self.__activeProject:
self.__activeProject.set_data_property(data, key, value)
def monitor_file(self, filename):
""" Enable file monitoring """
try:
# TODO : Try to remove qt dependencie here
from openalea.vpltk.qt import QtCore
self.watch = QtCore.QFileSystemWatcher()
QtCore.QCoreApplication.instance().connect(
self.watch, QtCore.SIGNAL("fileChanged(const QString&)"),
self.changed)
self.watch.addPath(filename)
except:
print "File monitoring is not available"
class QFloatSlider(QtGui.QSlider):
floatValueChanged = QtCore.Signal(float)
def __init__(self, orientation=QtCore.Qt.Horizontal):
QtGui.QSlider.__init__(self, orientation)
self.connect(self, QtCore.SIGNAL('valueChanged(int)'), self.notifyValueChanged)
self.slider_step = 0.1
self.floatValue = 0.0
def notifyValueChanged(self, value):
self.floatValue = value * self.slider_step
self.floatValueChanged.emit(self.floatValue)
def setFloatValue(self, value):
self.floatValue = value
self.setValue(round(value / self.slider_step))
# self.floatValueChanged.emit(self.floatValue)
# self.setValue(int(float(value)/self.slider_step))
def value(self):
return self.floatValue
def setStep(self, step):
self.slider_step = step
def createSelectionManipulator(self):
""" ensure that the selection manipulator is existing and valid """
if not self.selectionManipulator:
self.selectionManipulator = SelectionManipulator()
QtCore.QObject.connect(self.selectionManipulator,
QtCore.SIGNAL("valueChanged()"),
self.__propagate_valuechanged__)
def defaultSettings(self):
"""
Restore default settings (geometry and window state)
"""
settings = QtCore.QSettings("OpenAlea", "OpenAleaLab")
self.restoreGeometry(settings.value("defaultGeometry"))
self.restoreState(settings.value("defaultWindowState"))
def registerPreferedSettings(self):
"""
Register current settings as preferd settings
"""
settings = QtCore.QSettings("OpenAlea", "OpenAleaLab")
settings.setValue("preferedGeometry", self.saveGeometry())
settings.setValue("preferedWindowState", self.saveState())
class AbstractSource(QtCore.QObject):
__metaclass__ = make_metaclass((ProxySingleton, ),
(QtCore.pyqtWrapperType, ))
# -- EXTENSION POINT SOURCES API ATTRIBUTES --
__concrete_manager__ = None
__key__ = "name"
# -- SIGNALS --
item_list_changed = QtCore.Signal(object, dict)
# -- PROPERTIES --
name = property(lambda x: x.__name)
valid = property(lambda x: x.is_valid())
def __init__(self):
QtCore.QObject.__init__(self)
self.__name = self.__class__.__name__
mgrCls = self.__concrete_manager__
if mgrCls is not None:
mgrCls()._add_source(self)
#################
# EXTENSION API #
#################
def is_valid(self):
raise NotImplementedError
def gather_items(self):
raise NotImplementedError
def get_items(self):
raise NotImplementedError
def __init__(self, node, parent, parameter_str, interface):
"""Constructor
:Parameters:
- `node` (Node) - node that own the widget
- `parent` (QWidget) - parent widget
- `parameter_str` (str) - the parameter key the widget is associated to
- `interface` (Ismth) - instance of interface object
"""
QtGui.QMainWindow.__init__(self, parent)
IInterfaceWidget.__init__(self, node, parent, parameter_str, interface)
self.setMinimumSize(100, 50)
#ui
self._lab = ScalableLabel()
self.setCentralWidget(self._lab)
self._bot_toolbar = QtGui.QToolBar("slider")
self._img_slider = QtGui.QSlider(QtCore.Qt.Horizontal)
self._img_slider.setEnabled(False)
QtCore.QObject.connect(self._img_slider,
QtCore.SIGNAL("valueChanged(int)"),
self.slice_changed)
self._bot_toolbar.addWidget(self._img_slider)
self.addToolBar(QtCore.Qt.BottomToolBarArea, self._bot_toolbar)
self._bot_toolbar.hide()
#update
self.notify(node, ("input_modified", self.param_str))
def __init__(self,
parent=None,
scene=None,
statefilename='.temp_scene.xml',
shareWidget=None):
QGLViewer.__init__(self, parent, shareWidget)
self.set_bg_white()
# set the scene
if scene == None:
scene = self.defaultScene()
self.scene = scene
# set some parameters
self.setAxisIsDrawn(False) # show axis
self.setGridIsDrawn(True) # show grid
orientation = Quaternion(0.475117, 0.472505, 0.524479, 0.525286)
position = Vec(2.91287, -0.0109797, 0.659613)
self.camera().setPosition(position)
self.camera().setOrientation(orientation)
self.camera().setSceneRadius(1) # Size of vectors x,y,z
# connection
self.connect(self, QtCore.SIGNAL("drawNeeded()"), self.draw)
self.orientation_initiale = self.camera().orientation()
self.position_initiale = self.camera().position()
# Block "*.xml" save
self.setStateFileName("")
# Disable Quit in clicking on 'Escape'
# Set "show_axis" instead of "kill_application"
self.setShortcut(0, QtCore.Qt.Key_Escape)
def __init__(self, node, parent):
LPyWindow.__init__(self, parent)
NodeWidget.__init__(self, node)
QtCore.QObject.connect(self.codeeditor,
QtCore.SIGNAL('textChanged()'),
self.updateNode)
class ColormapRectangle(QColormapBar, AbstractQtControlWidget):
valueChanged = QtCore.Signal(dict)
def __init__(self):
QColormapBar.__init__(self)
self.setAutoFillBackground(True)
AbstractQtControlWidget.__init__(self)
self.setMinimumHeight(40)
self.value_changed_signal = self.valueChanged
def reset(self,
value=dict(name='grey',
color_points=dict([(0.0, (0.0, 0.0, 0.0)),
(1.0, (1.0, 1.0, 1.0))])),
**kwargs):
self.setValue(value)
def read(self, control):
self.reset(control.value)
def apply(self, control):
AbstractQtControlWidget.apply(self, control)
class IntRangeSimpleSlider(QSpanSlider, AbstractIntRangeWidget):
valueChanged = QtCore.Signal(tuple)
def __init__(self):
QSpanSlider.__init__(self)
AbstractIntRangeWidget.__init__(self)
self.spanChanged.connect(self.notify_value_changed)
self.value_changed_signal = self.valueChanged
def reset(self, value=(0, 255), minimum=0, maximum=255, **kwargs):
if minimum is not None:
self.setMinimum(minimum)
if maximum is not None:
self.setMaximum(maximum)
self.setSpan(value[0], value[1])
def apply(self, control):
AbstractQtControlWidget.apply(self, control)
control.interface.min = self.minimum()
control.interface.max = self.maximum()
control.value = self.value()
def notify_value_changed(self, lower_value, upper_value):
self.valueChanged.emit((lower_value, upper_value))
def setValue(self, value):
self.setSpan(value[0], value[1])
def value(self, interface=None):
return (self.lowerValue(), self.upperValue())
class IntRangeSpinBoxes(QtGui.QWidget, AbstractIntRangeWidget):
valueChanged = QtCore.Signal(tuple)
def __init__(self):
QtGui.QWidget.__init__(self)
self.start_spinbox = QtGui.QSpinBox()
self.end_spinbox = QtGui.QSpinBox()
# Fill background to avoid to see text or widget behind
self.setAutoFillBackground(True)
AbstractIntRangeWidget.__init__(self)
self.start_spinbox.setMinimumHeight(18)
self.end_spinbox.setMinimumHeight(18)
self.start_spinbox.valueChanged.connect(self.end_spinbox.setMinimum)
self.end_spinbox.valueChanged.connect(self.start_spinbox.setMaximum)
self.start_spinbox.valueChanged.connect(
self.notify_start_value_changed)
self.end_spinbox.valueChanged.connect(self.notify_end_value_changed)
layout = QtGui.QHBoxLayout(self)
layout.setContentsMargins(0, 0, 0, 0)
layout.addWidget(self.start_spinbox)
layout.addWidget(self.end_spinbox)
self.value_changed_signal = self.valueChanged
def reset(self, value=(0, 255), minimum=None, maximum=None, **kwargs):
if minimum is not None:
self.start_spinbox.setMinimum(minimum)
if maximum is not None:
self.end_spinbox.setMaximum(maximum)
self.start_spinbox.setMaximum(value[1])
self.end_spinbox.setMinimum(value[0])
self.setValue(value)
def apply(self, control):
AbstractQtControlWidget.apply(self, control)
control.interface.min = self.start_spinbox.minimum()
control.interface.max = self.end_spinbox.maximum()
def value(self, interface=None):
return (self.start_spinbox.value(), self.end_spinbox.value())
def setValue(self, value):
self.start_spinbox.setValue(value[0])
self.start_spinbox.setMaximum(value[1])
self.end_spinbox.setValue(value[1])
self.end_spinbox.setMinimum(value[0])
def notify_start_value_changed(self, value):
self.valueChanged.emit((value, self.end_spinbox.value()))
def notify_end_value_changed(self, value):
self.valueChanged.emit((self.start_spinbox.value(), value))
class QColormapBar(QtGui.QWidget):
valueChanged = QtCore.Signal(dict)
def __init__(self, orientation=QtCore.Qt.Horizontal):
QtGui.QWidget.__init__(self)
self.color_points = {}
self.colormap_name = ""
self.colormap_painter = PainterColormap()
self.orientation = orientation
def setValue(self, value):
self.color_points = value['color_points']
self.colormap_name = value['name']
self.valueChanged.emit(dict(color_points=self.color_points, name=self.colormap_name))
self.update()
def value(self):
return dict(color_points=self.color_points, name=self.colormap_name)
def setOrientation(self, orientation):
self.orientation = orientation
def paintEvent(self, event):
painter = QtGui.QPainter(self)
rectangle = event.rect()
self.colormap_painter.paint_data(self.value(), painter, rectangle, orientation=self.orientation)
class PluginSelector(WelcomePage):
pluginSelected = QtCore.Signal(object)
def __init__(self, category, parent=None):
WelcomePage.__init__(self, parent=parent)
self._actions = {}
self._sorted_actions = []
for plugin_class in plugins(category):
action = QtGui.QAction(obj_icon(plugin_class), alias(plugin_class),
self)
action.triggered.connect(self._on_action_triggered)
self._actions[action] = plugin_class
self._sorted_actions.append(action)
self.set_actions(self._sorted_actions)
def _on_action_triggered(self):
plugin_class = self._actions[self.sender()]
self.plugin_class = plugin_class
self.pluginSelected.emit(plugin_class)
def resize(self, *args, **kwargs):
WelcomePage.resize(self, *args, **kwargs)
self.set_actions(self._sorted_actions)
def qCleanupResources():
QtCore.qUnregisterResourceData(0x01, qt_resource_struct, qt_resource_name, qt_resource_data)
def qInitResources():
QtCore.qRegisterResourceData(0x01, qt_resource_struct, qt_resource_name, qt_resource_data)
