def flags(self, index):
"""Override Qt method"""
if not index.isValid():
return Qt.ItemIsEnabled
column = index.column()
if column in [0, 1, 2, 3]:
return Qt.ItemFlags(Qt.ItemIsEnabled)
else:
return Qt.ItemFlags(Qt.NoItemFlags)
def flags(self, index):
"""Override Qt method"""
if not index.isValid():
return Qt.ItemIsEnabled
column = index.column()
if column in [0]:
return Qt.ItemFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable
| Qt.ItemIsUserCheckable | Qt.ItemIsEditable)
else:
return Qt.ItemFlags(Qt.ItemIsEnabled)
def flags(index):
"""Override Qt method."""
column = index.column()
if index.isValid():
if column in [C.COL_START, C.COL_END]:
return Qt.ItemFlags(Qt.ItemIsEnabled)
else:
return Qt.ItemFlags(Qt.ItemIsEnabled)
else:
return Qt.ItemFlags(Qt.ItemIsEnabled)
def flags(self, index):
"""Override Qt method"""
column = index.column()
if index.isValid():
if column in [C.COL_START, C.COL_END]:
# return Qt.ItemFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
return Qt.ItemFlags(Qt.ItemIsEnabled)
else:
# return Qt.ItemFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
return Qt.ItemFlags(Qt.ItemIsEnabled)
else:
return Qt.ItemFlags(Qt.ItemIsEnabled)
def movePoint(self, handle, pos, modifiers=Qt.KeyboardModifier(), finish=True, coords="parent"):
super(BetterRectROI, self).movePoint(handle, pos, modifiers, finish, coords)
self.width = self.handle["pos"].x() * self.size().x()
self.height = self.handle["pos"].y() * self.size().y()
self.handleChanged()
def __init__(self,
reserved: Iterable[str] = None,
parent=None,
window_flags=Qt.WindowFlags()):
super(MetadataDialog, self).__init__(parent, window_flags)
self.reserved = set(reserved or [])
self.parameter_tree = pt.ParameterTree(showHeader=False)
self.parameter_tree.setParameters(self.parameter, showTop=False)
calibrate_button = QPushButton("&Acquire")
self.buttons = QDialogButtonBox(Qt.Horizontal)
# Add calibration button that accepts the dialog (closes with 1 status)
self.buttons.addButton(calibrate_button, QDialogButtonBox.AcceptRole)
# Add a cancel button that will reject the dialog (closes with 0 status)
self.buttons.addButton(QDialogButtonBox.Cancel)
self.buttons.rejected.connect(self.reject)
self.buttons.accepted.connect(self.accept)
outer_layout = QVBoxLayout()
outer_layout.addWidget(self.parameter_tree)
outer_layout.addWidget(self.buttons)
outer_layout.setSpacing(0)
outer_layout.setContentsMargins(0, 0, 0, 0)
self.setLayout(outer_layout)
def flags(self, index):
"""Override Qt method"""
row = index.row()
ui_name, name, state = self.row(row)
if name in self.read_only:
return Qt.NoItemFlags
if not index.isValid():
return Qt.ItemIsEnabled
column = index.column()
if column in [0]:
return Qt.ItemFlags(int(Qt.ItemIsEnabled | Qt.ItemIsSelectable |
Qt.ItemIsUserCheckable |
Qt.ItemIsEditable))
else:
return Qt.ItemFlags(Qt.ItemIsEnabled)
def editorEvent(
self,
event: QtCore.QEvent,
model: QtCore.QAbstractItemModel,
option: QStyleOptionViewItem,
index: QtCore.QModelIndex,
) -> bool:
"""Called when an event has occured in the editor.
This can be used to customize how the delegate handles mouse/key events
"""
if (event.type() == event.MouseButtonRelease
and event.button() == Qt.RightButton):
self.show_context_menu(index, model, event.globalPos(),
option.widget)
# if the user clicks quickly on the visibility checkbox, we *don't*
# want it to be interpreted as a double-click. We want the visibilty
# to simply be toggled.
if event.type() == event.MouseButtonDblClick:
self.initStyleOption(option, index)
style = option.widget.style()
check_rect = style.subElementRect(
style.SE_ItemViewItemCheckIndicator, option, option.widget)
if check_rect.contains(event.pos()):
cur_state = index.data(Qt.CheckStateRole)
if model.flags(index) & Qt.ItemIsUserTristate:
state = Qt.CheckState((cur_state + 1) % 3)
else:
state = Qt.Unchecked if cur_state else Qt.Checked
return model.setData(index, state, Qt.CheckStateRole)
# refer all other events to the QStyledItemDelegate
return super().editorEvent(event, model, option, index)
def mouseMoveEvent(self, event):
"""Override Qt method"""
if event.buttons() == Qt.MouseButtons(Qt.LeftButton) and \
(event.pos() - self.__drag_start_pos).manhattanLength() > \
QApplication.startDragDistance():
drag = QDrag(self)
mimeData = QMimeData()
# Converting id's to long to avoid an OverflowError with PySide
if PY2:
ancestor_id = long(id(self.ancestor))
parent_widget_id = long(id(self.parentWidget()))
self_id = long(id(self))
else:
ancestor_id = id(self.ancestor)
parent_widget_id = id(self.parentWidget())
self_id = id(self)
mimeData.setData("parent-id", QByteArray.number(ancestor_id))
mimeData.setData("tabwidget-id",
QByteArray.number(parent_widget_id))
mimeData.setData("tabbar-id", QByteArray.number(self_id))
mimeData.setData(
"source-index",
QByteArray.number(self.tabAt(self.__drag_start_pos)))
drag.setMimeData(mimeData)
drag.exec_()
QTabBar.mouseMoveEvent(self, event)
def test_construct(qtbot):
"""
Test the construction of the widget.
Expectations:
Default values are correctly assigned.
Parameters
----------
qtbot : fixture
Window for widget testing
"""
pydm_slider = PyDMSlider()
qtbot.addWidget(pydm_slider)
assert pydm_slider.alarmSensitiveContent is True
assert pydm_slider.alarmSensitiveBorder is False
assert pydm_slider._show_limit_labels is True
assert pydm_slider._show_value_label is True
assert pydm_slider._user_defined_limits is False
assert pydm_slider._needs_limit_info is True
assert pydm_slider._minimum is None
assert pydm_slider._maximum is None
assert pydm_slider._user_minimum == -10.0
assert pydm_slider._user_maximum == 10.0
assert pydm_slider._num_steps == 101
assert pydm_slider.orientation == Qt.Horizontal
assert pydm_slider.isEnabled() is False
assert type(pydm_slider.low_lim_label) == QLabel
assert pydm_slider.low_lim_label.sizePolicy() == QSizePolicy(
QSizePolicy.Maximum, QSizePolicy.Fixed)
assert pydm_slider.low_lim_label.alignment() == Qt.Alignment(
Qt.AlignLeft | Qt.AlignTrailing | Qt.AlignVCenter)
assert type(pydm_slider.high_lim_label) == QLabel
assert pydm_slider.high_lim_label.sizePolicy() == QSizePolicy(
QSizePolicy.Maximum, QSizePolicy.Fixed)
assert pydm_slider.high_lim_label.alignment() == Qt.Alignment(
Qt.AlignRight | Qt.AlignTrailing | Qt.AlignVCenter)
assert type(pydm_slider._slider) == QSlider
assert pydm_slider._slider.orientation() == Qt.Orientation(Qt.Horizontal)
assert pydm_slider._slider_position_to_value_map is None
assert pydm_slider._mute_internal_slider_changes is False
assert pydm_slider._orientation == Qt.Horizontal
def mightRender(self, text):
"""
Test if a string can be rendered by this text engine
:param str text: Text to be tested
:return: True, if it can be rendered
"""
return PYSIDE2 or Qt.mightBeRichText(text)
def __init__(self):
self.isDirty = True
self.maxColumns = 0
self.numRows = 0
self.numColumns = 0
self.expanding = Qt.Orientations()
self.itemSizeHints = []
self.itemList = []
def flags(self, index):
"""Override to make cells editable."""
if not index.isValid():
return Qt.ItemIsEnabled
if index.column() in (2, ):
return Qt.ItemFlags(
QAbstractTableModel.flags(self, index) | Qt.ItemIsEditable)
return QAbstractTableModel.flags(self, index)
def flags(self, index):
"""Set editable flag"""
if not index.isValid():
return Qt.ItemIsEnabled
flags = QAbstractTableModel.flags(self, index)
if not self.readonly:
flags |= Qt.ItemIsEditable
return Qt.ItemFlags(flags)
def movePoint(self,
handle,
pos,
modifiers=Qt.KeyboardModifier(),
finish=True,
coords="parent"):
super(LineROI, self).movePoint(handle, pos, modifiers, finish, coords)
self._update_state()
self.handleChanged()
def mightRender(self, text):
"""
Test if a string can be rendered by this text engine
:param str text: Text to be tested
:return: True, if it can be rendered
"""
try:
return Qt.mightBeRichText(text)
except AttributeError:
return True
def anchor(self, widget, left=True, right=True, top=True, bottom=True):
'''anchor the widget. Depending on the anchors, widget will be left-,
right-, center-aligned or stretched.
'''
align = {
(False, False): Qt.AlignHCenter,
(True, False): Qt.AlignLeft,
(False, True): Qt.AlignRight,
(True, True): Qt.Alignment()
}[(left, right)]
widget.parent().layout().setAlignment(widget, align)
def mouseDoubleClickEvent(self, event):
"""Override Qt method to trigger the tab name editor."""
if self.rename_tabs is True and \
event.buttons() == Qt.MouseButtons(Qt.LeftButton):
# Tab index
index = self.tabAt(event.pos())
if index >= 0:
# Tab is valid, call tab name editor
self.tab_name_editor.edit_tab(index)
else:
# Event is not interesting, raise to parent
QTabBar.mouseDoubleClickEvent(self, event)
def flags(self, index):
result = super(LayerArtistModel, self).flags(index)
if index.isValid() and index.row() < len(self.artists):
art = self.artists[index.row()]
if art.enabled:
result = (result | Qt.ItemIsEditable | Qt.ItemIsDragEnabled
| Qt.ItemIsUserCheckable)
else:
result = int(result & Qt.ItemIsUserCheckable) ^ int(result)
else: # only drop between rows, where index isn't valid
result = result | Qt.ItemIsDropEnabled
return Qt.ItemFlags(int(result))
def movePoint(self, handle, pos, modifiers=Qt.KeyboardModifier(), finish=True, coords='parent'):
super(ArcROI, self).movePoint(handle, pos, modifiers, finish, coords)
# Set internal parameters
if handle in [self.innerhandle, self.outerhandle]:
self.innerradius = self.innerhandle.pos().length()
self.outerradius = self.outerhandle.pos().length()
self.thetacenter = self.outerhandle.pos().angle(Point(1, 0))
elif handle is self.widthhandle:
self.thetawidth = 2 * self.widthhandle.pos().angle(self.innerhandle.pos())
self.handleChanged()
def createEditor(
self,
parent: QWidget,
option: QStyleOptionViewItem,
index: QtCore.QModelIndex,
) -> QWidget:
"""User has double clicked on layer name."""
# necessary for geometry, otherwise editor takes up full width.
self.get_layer_icon(option, index)
editor = super().createEditor(parent, option, index)
# make sure editor has same alignment as the display name
editor.setAlignment(Qt.Alignment(index.data(Qt.TextAlignmentRole)))
return editor
def editSettings(self, settingValues, mDialog):
"""
Edit the settings window. This method will edit all the provided
settings and set them to their correcponding value.
Args:
settingValues (dict(str:str)): setting name and value to be set
"""
QTest.mouseClick(self.drill.settings, Qt.LeftButton)
sw = self.drill.children()[-1]
form = sw.formLayout
widgets = dict()
for i in range(0, sw.formLayout.rowCount()):
label = form.itemAt(i, QFormLayout.LabelRole).widget().text()
widget = form.itemAt(i, QFormLayout.FieldRole).widget()
widgets[label] = widget
for name,value in settingValues.items():
if name in widgets:
if isinstance(widgets[name], QLineEdit):
QTest.mouseClick(widgets[name], Qt.LeftButton)
QTest.mouseDClick(widgets[name], Qt.LeftButton)
widgets[name].clear()
QTest.keyClicks(widgets[name], value)
QTest.keyClick(widgets[name], Qt.Key_Tab)
elif isinstance(widgets[name], QComboBox):
v = widgets[name].view()
m = widgets[name].model()
for i in range(m.rowCount()):
index = m.index(i, 0)
text = index.data(Qt.DisplayRole)
if text == name:
v.scrollTo(index)
pos = index.center()
Qt.mouseClick(v.viewport(), Qt.LeftButton, 0, pos)
break
QTest.mouseClick(sw.okButton, Qt.LeftButton)
def setRenderFlags(self, renderFlags):
"""
Change the render flags
The default setting is `Qt.AlignCenter`
:param int renderFlags: Bitwise OR of the flags used like in `QPainter.drawText()`
.. seealso::
:py:meth:`renderFlags()`,
:py:meth:`qwt.text.QwtTextEngine.draw()`
"""
renderFlags = Qt.AlignmentFlag(renderFlags)
if renderFlags != self.__data.renderFlags:
self.__data.renderFlags = renderFlags
self.__layoutCache.invalidate()
def initScale(self, align):
"""
Initialize the scale
:param int align: Alignment
"""
self.__data = QwtScaleWidget_PrivateData()
self.__data.layoutFlags = 0
if align == QwtScaleDraw.RightScale:
self.__data.layoutFlags |= self.TitleInverted
self.__data.borderDist = [0, 0]
self.__data.minBorderDist = [0, 0]
self.__data.margin = 4
self.__data.titleOffset = 0
self.__data.spacing = 2
self.__data.scaleDraw = QwtScaleDraw()
self.__data.scaleDraw.setAlignment(align)
self.__data.scaleDraw.setLength(10)
self.__data.scaleDraw.setScaleDiv(QwtLinearScaleEngine().divideScale(
0.0, 100.0, 10, 5))
self.__data.colorBar.colorMap = QwtLinearColorMap()
self.__data.colorBar.isEnabled = False
self.__data.colorBar.width = 10
flags = Qt.AlignmentFlag(Qt.AlignHCenter | Qt.TextExpandTabs
| Qt.TextWordWrap)
self.__data.title.setRenderFlags(flags)
self.__data.title.setFont(self.font())
policy = QSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Fixed)
if self.__data.scaleDraw.orientation() == Qt.Vertical:
policy.transpose()
self.setSizePolicy(policy)
self.setAttribute(Qt.WA_WState_OwnSizePolicy, False)
def mouseMoveEvent(self, event):
"""Override Qt method"""
if event.buttons() == Qt.MouseButtons(Qt.LeftButton) and \
(event.pos() - self.__drag_start_pos).manhattanLength() > \
QApplication.startDragDistance():
drag = QDrag(self)
mimeData = QMimeData()
ancestor_id = to_text_string(id(self.ancestor))
parent_widget_id = to_text_string(id(self.parentWidget()))
self_id = to_text_string(id(self))
source_index = to_text_string(self.tabAt(self.__drag_start_pos))
mimeData.setData("parent-id", to_binary_string(ancestor_id))
mimeData.setData("tabwidget-id",
to_binary_string(parent_widget_id))
mimeData.setData("tabbar-id", to_binary_string(self_id))
mimeData.setData("source-index", to_binary_string(source_index))
drag.setMimeData(mimeData)
drag.exec_()
QTabBar.mouseMoveEvent(self, event)
def flags(self, index):
"""Qt Override."""
if not index.isValid():
return Qt.ItemIsEnabled
return Qt.ItemFlags(QAbstractTableModel.flags(self, index))
def flags(self, index):
"""Set editable flag"""
if not index.isValid():
return Qt.ItemIsEnabled
return Qt.ItemFlags(
QAbstractTableModel.flags(self, index) | Qt.ItemIsEditable)
def expandingDirections(self):
return Qt.Orientations(0)
def flags(self, index):
"""Set flags"""
if index.column() == 0:
return Qt.ItemIsEnabled | Qt.ItemIsSelectable
return Qt.ItemFlags(
QAbstractTableModel.flags(self, index) | Qt.ItemIsEditable)
def drawLabel(self, painter, canvasRect, pos):
"""
Align and draw the text label of the marker
:param QPainter painter: Painter
:param QRectF canvasRect: Contents rectangle of the canvas in painter coordinates
:param QPointF pos: Position of the marker, translated into widget coordinates
.. seealso::
:py:meth:`drawLabel()`,
:py:meth:`qwt.symbol.QwtSymbol.drawSymbol()`
"""
if self.__data.label.isEmpty():
return
align = Qt.Alignment(self.__data.labelAlignment)
alignPos = QPointF(pos)
symbolOff = QSizeF(0, 0)
if self.__data.style == QwtPlotMarker.VLine:
# In VLine-style the y-position is pointless and
# the alignment flags are relative to the canvas
if bool(self.__data.labelAlignment & Qt.AlignTop):
alignPos.setY(canvasRect.top())
align &= ~Qt.AlignTop
align |= Qt.AlignBottom
elif bool(self.__data.labelAlignment & Qt.AlignBottom):
# In HLine-style the x-position is pointless and
# the alignment flags are relative to the canvas
alignPos.setY(canvasRect.bottom() - 1)
align &= ~Qt.AlignBottom
align |= Qt.AlignTop
else:
alignPos.setY(canvasRect.center().y())
elif self.__data.style == QwtPlotMarker.HLine:
if bool(self.__data.labelAlignment & Qt.AlignLeft):
alignPos.setX(canvasRect.left())
align &= ~Qt.AlignLeft
align |= Qt.AlignRight
elif bool(self.__data.labelAlignment & Qt.AlignRight):
alignPos.setX(canvasRect.right() - 1)
align &= ~Qt.AlignRight
align |= Qt.AlignLeft
else:
alignPos.setX(canvasRect.center().x())
else:
if self.__data.symbol and self.__data.symbol.style(
) != QwtSymbol.NoSymbol:
symbolOff = self.__data.symbol.size() + QSizeF(1, 1)
symbolOff /= 2
pw2 = self.__data.pen.widthF() / 2.0
if pw2 == 0.0:
pw2 = 0.5
spacing = self.__data.spacing
xOff = max([pw2, symbolOff.width()])
yOff = max([pw2, symbolOff.height()])
textSize = self.__data.label.textSize(painter.font())
if align & Qt.AlignLeft:
alignPos.setX(alignPos.x() - (xOff + spacing))
if self.__data.labelOrientation == Qt.Vertical:
alignPos.setX(alignPos.x() - textSize.height())
else:
alignPos.setX(alignPos.x() - textSize.width())
elif align & Qt.AlignRight:
alignPos.setX(alignPos.x() + xOff + spacing)
else:
if self.__data.labelOrientation == Qt.Vertical:
alignPos.setX(alignPos.x() - textSize.height() / 2)
else:
alignPos.setX(alignPos.x() - textSize.width() / 2)
if align & Qt.AlignTop:
alignPos.setY(alignPos.y() - (yOff + spacing))
if self.__data.labelOrientation != Qt.Vertical:
alignPos.setY(alignPos.y() - textSize.height())
elif align & Qt.AlignBottom:
alignPos.setY(alignPos.y() + yOff + spacing)
if self.__data.labelOrientation == Qt.Vertical:
alignPos.setY(alignPos.y() + textSize.width())
else:
if self.__data.labelOrientation == Qt.Vertical:
alignPos.setY(alignPos.y() + textSize.width() / 2)
else:
alignPos.setY(alignPos.y() - textSize.height() / 2)
painter.translate(alignPos.x(), alignPos.y())
if self.__data.labelOrientation == Qt.Vertical:
painter.rotate(-90.0)
textRect = QRectF(0, 0, textSize.width(), textSize.height())
self.__data.label.draw(painter, textRect)
