def setFormatter(self, formatter): """Set the formatter object to be used to display data from the model :param TextFormatter formatter: Formatter to use """ if formatter is self.__formatter: return if qt.qVersion() > "4.6": self.beginResetModel() if self.__formatter is not None: self.__formatter.formatChanged.disconnect(self.__formatChanged) self.__formatter = formatter self.__editFormatter = TextFormatter(formatter) self.__editFormatter.setUseQuoteForText(False) if self.__formatter is not None: self.__formatter.formatChanged.connect(self.__formatChanged) if qt.qVersion() > "4.6": self.endResetModel() else: self.reset()
def mouseReleaseEvent(self, event): point1 = self.pos() deltax = point1.x() - self._point0.x() deltay = point1.y() - self._point0.y() self.moveBy(-deltax, -deltay) parent = self.parentItem() # deduce scale from rectangle if (qt.qVersion() < "5.0") or self.keepRatio: scalex = self._newRect.rect().width() / self._w scaley = scalex else: scalex = self._newRect.rect().width() / self._w scaley = self._newRect.rect().height() / self._h if qt.qVersion() < "5.0": parent.scale(scalex, scaley) else: # apply the scale to the previous transformation matrix previousTransform = parent.transform() parent.setTransform( previousTransform.scale(scalex, scaley)) self.scene().removeItem(self._newRect) self._newRect = None qt.QGraphicsRectItem.mouseReleaseEvent(self, event)
def setArrayData(self, data): """Set the data array and the viewing perspective. You can set ``copy=False`` if you need more performances, when dealing with a large numpy array. In this case, a simple reference to the data is used to access the data, rather than a copy of the array. .. warning:: Any change to the data model will affect your original data array, when using a reference rather than a copy.. :param data: 1D numpy array, or any object that can be converted to a numpy array using ``numpy.array(data)`` (e.g. a nested sequence). """ if qt.qVersion() > "4.6": self.beginResetModel() self.__data = data if isinstance(data, numpy.ndarray): self.__is_array = True elif silx.io.is_dataset(data) and data.shape != tuple(): self.__is_array = True else: self.__is_array = False self.__fields = [] if data is not None: if data.dtype.fields is not None: fields = sorted(data.dtype.fields.items(), key=lambda e: e[1][1]) for name, (dtype, _index) in fields: if dtype.shape != tuple(): keys = itertools.product( *[range(x) for x in dtype.shape]) for key in keys: label = "%s%s" % (name, list(key)) array_key = (name, key) self.__fields.append((label, array_key)) else: self.__fields.append((name, (name, ))) else: self.__fields = None if qt.qVersion() > "4.6": self.endResetModel() else: self.reset()
def setData1(self): if qt.qVersion() > "4.6": self.beginResetModel() else: self.reset() content = {} content[0, 0] = ("title", True, (1, 3)) content[0, 1] = ("a", True, (2, 1)) content[1, 1] = ("b", False, (1, 2)) content[1, 2] = ("c", False, (1, 1)) content[2, 2] = ("d", False, (1, 1)) self.__content = content if qt.qVersion() > "4.6": self.endResetModel()
def configure(self, parsed_options): """Configure the TestOptions class from the command line arguments and the environment variables """ if not parsed_options.gui: self.WITH_QT_TEST = False self.WITH_QT_TEST_REASON = "Skipped by command line" elif os.environ.get('WITH_QT_TEST', 'True') == 'False': self.WITH_QT_TEST = False self.WITH_QT_TEST_REASON = "Skipped by WITH_QT_TEST env var" elif sys.platform.startswith('linux') and not os.environ.get('DISPLAY', ''): self.WITH_QT_TEST = False self.WITH_QT_TEST_REASON = "DISPLAY env variable not set" if not parsed_options.opencl or os.environ.get('SILX_OPENCL', 'True') == 'False': self.WITH_OPENCL_TEST = False # That's an easy way to skip OpenCL tests # It disable the use of OpenCL on the full silx project os.environ['SILX_OPENCL'] = "False" if not parsed_options.opengl: self.WITH_GL_TEST = False self.WITH_GL_TEST_REASON = "Skipped by command line" elif os.environ.get('WITH_GL_TEST', 'True') == 'False': self.WITH_GL_TEST = False self.WITH_GL_TEST_REASON = "Skipped by WITH_GL_TEST env var" if parsed_options.low_mem or os.environ.get('SILX_TEST_LOW_MEM', 'True') == 'False': self.TEST_LOW_MEM = True if self.WITH_QT_TEST: from silx.gui import qt if sys.platform == "win32" and qt.qVersion() == "5.9.2": self.SKIP_TEST_FOR_ISSUE_936 = True
def setData(self, data): """Set the h5py-like object exposed by the model :param data: A h5py-like object. It can be a `h5py.Dataset`, a `h5py.File`, a `h5py.Group`. It also can be a, `silx.gui.hdf5.H5Node` which is needed to display some local path information. """ model = self.model() model.setObject(data) header = self.horizontalHeader() if qt.qVersion() < "5.0": setResizeMode = header.setResizeMode else: setResizeMode = header.setSectionResizeMode setResizeMode(0, qt.QHeaderView.Fixed) setResizeMode(1, qt.QHeaderView.ResizeToContents) setResizeMode(2, qt.QHeaderView.Stretch) setResizeMode(3, qt.QHeaderView.ResizeToContents) setResizeMode(4, qt.QHeaderView.ResizeToContents) header.setStretchLastSection(False) for row in range(model.rowCount()): for column in range(model.columnCount()): index = model.index(row, column) if (index.isValid() and index.data( HierarchicalTableView.HierarchicalTableModel.IsHeaderRole) is False): self.openPersistentEditor(index)
def mousePressEvent(self, event): if self._newRect is not None: self._newRect = None self._point0 = self.pos() parent = self.parentItem() scene = self.scene() # following line prevents dragging along the previously selected # item when resizing another one scene.clearSelection() rect = parent.boundingRect() self._x = rect.x() self._y = rect.y() self._w = rect.width() self._h = rect.height() self._ratio = self._w / self._h if qt.qVersion() < "5.0": self._newRect = qt.QGraphicsRectItem(parent, scene) else: self._newRect = qt.QGraphicsRectItem(parent) self._newRect.setRect(qt.QRectF(self._x, self._y, self._w, self._h)) qt.QGraphicsRectItem.mousePressEvent(self, event)
def __init__(self, parent=None): """Constructor""" qt.QTreeView.__init__(self, parent=None) self.__model = _Model(self) self.__model.setColumnCount(4) self.__model.setHorizontalHeaderLabels(["Name", "Dataset", "Type", "Shape"]) self.setModel(self.__model) self.setItemDelegateForColumn(1, _HashDropZones(self)) self.__model.sigNxdataUpdated.connect(self.__nxdataUpdate) self.__model.rowsAboutToBeRemoved.connect(self.__rowsAboutToBeRemoved) self.__model.rowsAboutToBeInserted.connect(self.__rowsAboutToBeInserted) header = self.header() if qt.qVersion() < "5.0": setResizeMode = header.setResizeMode else: setResizeMode = header.setSectionResizeMode setResizeMode(0, qt.QHeaderView.ResizeToContents) setResizeMode(1, qt.QHeaderView.Stretch) setResizeMode(2, qt.QHeaderView.ResizeToContents) setResizeMode(3, qt.QHeaderView.ResizeToContents) self.setSelectionMode(qt.QAbstractItemView.SingleSelection) self.setDropIndicatorShown(True) self.setDragDropOverwriteMode(True) self.setDragEnabled(True) self.viewport().setAcceptDrops(True) self.setContextMenuPolicy(qt.Qt.CustomContextMenu) self.customContextMenuRequested[qt.QPoint].connect(self.__executeContextMenu)
def setArrayData(self, data): """Set the data array and the viewing perspective. You can set ``copy=False`` if you need more performances, when dealing with a large numpy array. In this case, a simple reference to the data is used to access the data, rather than a copy of the array. .. warning:: Any change to the data model will affect your original data array, when using a reference rather than a copy.. :param data: 1D numpy array, or any object that can be converted to a numpy array using ``numpy.array(data)`` (e.g. a nested sequence). """ if qt.qVersion() > "4.6": self.beginResetModel() self.__data = data if isinstance(data, numpy.ndarray): self.__is_array = True elif silx.io.is_dataset(data) and data.shape != tuple(): self.__is_array = True else: self.__is_array = False self.__fields = [] if data is not None: if data.dtype.fields is not None: fields = sorted(data.dtype.fields.items(), key=lambda e: e[1][1]) for name, (dtype, _index) in fields: if dtype.shape != tuple(): keys = itertools.product(*[range(x) for x in dtype.shape]) for key in keys: label = "%s%s" % (name, list(key)) array_key = (name, key) self.__fields.append((label, array_key)) else: self.__fields.append((name, (name,))) else: self.__fields = None if qt.qVersion() > "4.6": self.endResetModel() else: self.reset()
def configure(self, parsed_options=None): """Configure the TestOptions class from the command line arguments and the environment variables """ if parsed_options is not None and not parsed_options.gui: self.WITH_QT_TEST = False self.WITH_QT_TEST_REASON = "Skipped by command line" elif os.environ.get('WITH_QT_TEST', 'True') == 'False': self.WITH_QT_TEST = False self.WITH_QT_TEST_REASON = "Skipped by WITH_QT_TEST env var" elif sys.platform.startswith('linux') and not os.environ.get('DISPLAY', ''): self.WITH_QT_TEST = False self.WITH_QT_TEST_REASON = "DISPLAY env variable not set" if parsed_options is not None and not parsed_options.opencl: self.WITH_OPENCL_TEST_REASON = "Skipped by command line" self.WITH_OPENCL_TEST = False elif os.environ.get('SILX_OPENCL', 'True') == 'False': self.WITH_OPENCL_TEST_REASON = "Skipped by SILX_OPENCL env var" self.WITH_OPENCL_TEST = False if not self.WITH_OPENCL_TEST: # That's an easy way to skip OpenCL tests # It disable the use of OpenCL on the full silx project os.environ['SILX_OPENCL'] = "False" if parsed_options is not None and not parsed_options.opengl: self.WITH_GL_TEST = False self.WITH_GL_TEST_REASON = "Skipped by command line" elif os.environ.get('WITH_GL_TEST', 'True') == 'False': self.WITH_GL_TEST = False self.WITH_GL_TEST_REASON = "Skipped by WITH_GL_TEST env var" elif sys.platform.startswith('linux') and not os.environ.get('DISPLAY', ''): self.WITH_GL_TEST = False self.WITH_GL_TEST_REASON = "DISPLAY env variable not set" else: try: import OpenGL except ImportError: self.WITH_GL_TEST = False self.WITH_GL_TEST_REASON = "OpenGL package not available" if parsed_options is not None and parsed_options.low_mem: self.TEST_LOW_MEM = True self.TEST_LOW_MEM_REASON = "Skipped by command line" elif os.environ.get('SILX_TEST_LOW_MEM', 'True') == 'False': self.TEST_LOW_MEM = True self.TEST_LOW_MEM_REASON = "Skipped by SILX_TEST_LOW_MEM env var" if self.WITH_QT_TEST: try: from silx.gui import qt except ImportError: self.WITH_QT_TEST = False self.WITH_QT_TEST_REASON = "Qt is not installed" else: if sys.platform == "win32" and qt.qVersion() == "5.9.2": self.SKIP_TEST_FOR_ISSUE_936 = True
def setFrameAxes(self, row_axis, col_axis): """Set the perspective by specifying the two axes parallel to the frame to be visualised. The complementary approach of defining the orthogonal axes can be used with :meth:`setPerspective`. :param int row_axis: Index (0-based) of the first dimension used as a frame axis :param int col_axis: Index (0-based) of the 2nd dimension used as a frame axis :raise: IndexError if axes are invalid """ if row_axis > col_axis: _logger.warning("The dimension of the row axis must be lower " + "than the dimension of the column axis. Swapping.") row_axis, col_axis = min(row_axis, col_axis), max(row_axis, col_axis) n_dimensions = len(self._array.shape) if n_dimensions < 3: _logger.warning( "Frame axes cannot be changed for 1D and 2D arrays") return perspective = tuple(set(range(0, n_dimensions)) - {row_axis, col_axis}) if len(perspective) != n_dimensions - 2 or\ min(perspective) < 0 or max(perspective) >= n_dimensions: raise IndexError("Invalid perspective " + str(perspective) + " for %d-D array " % n_dimensions + "with shape " + str(self._array.shape)) if qt.qVersion() > "4.6": self.beginResetModel() else: self.reset() self._perspective = perspective # reset index self._index = [0 for _i in range(n_dimensions - 2)] if qt.qVersion() > "4.6": self.endResetModel()
def setFrameAxes(self, row_axis, col_axis): """Set the perspective by specifying the two axes parallel to the frame to be visualised. The complementary approach of defining the orthogonal axes can be used with :meth:`setPerspective`. :param int row_axis: Index (0-based) of the first dimension used as a frame axis :param int col_axis: Index (0-based) of the 2nd dimension used as a frame axis :raise: IndexError if axes are invalid """ if row_axis > col_axis: _logger.warning("The dimension of the row axis must be lower " + "than the dimension of the column axis. Swapping.") row_axis, col_axis = min(row_axis, col_axis), max(row_axis, col_axis) n_dimensions = len(self._array.shape) if n_dimensions < 3: _logger.warning( "Frame axes cannot be changed for 1D and 2D arrays") return perspective = tuple(set(range(0, n_dimensions)) - {row_axis, col_axis}) if len(perspective) != n_dimensions - 2 or\ min(perspective) < 0 or max(perspective) >= n_dimensions: raise IndexError( "Invalid perspective " + str(perspective) + " for %d-D array " % n_dimensions + "with shape " + str(self._array.shape)) if qt.qVersion() > "4.6": self.beginResetModel() else: self.reset() self._perspective = perspective # reset index self._index = [0 for _i in range(n_dimensions - 2)] if qt.qVersion() > "4.6": self.endResetModel()
def __updateColumnConstraints(self): header = self.horizontalHeader() if qt.qVersion() < "5.0": setResizeMode = header.setResizeMode else: setResizeMode = header.setSectionResizeMode setResizeMode(0, qt.QHeaderView.Stretch) setResizeMode(1, qt.QHeaderView.ResizeToContents) setResizeMode(2, qt.QHeaderView.ResizeToContents) setResizeMode(3, qt.QHeaderView.Fixed)
def setData(self, data): widget = self.getWidget() widget.model().setObject(data) header = widget.horizontalHeader() if qt.qVersion() < "5.0": setResizeMode = header.setResizeMode else: setResizeMode = header.setSectionResizeMode setResizeMode(0, qt.QHeaderView.Fixed) setResizeMode(1, qt.QHeaderView.Stretch) header.setStretchLastSection(True)
def setFrameIndex(self, index): """Set the active slice index. This method is only relevant to arrays with at least 3 dimensions. :param index: Index of the active slice in the array. In the general n-D case, this is a sequence of :math:`n - 2` indices where the slice intersects the respective orthogonal axes. :raise IndexError: If any index in the index sequence is out of bound on its respective axis. """ shape = self._array.shape if len(shape) < 3: # index is ignored return if qt.qVersion() > "4.6": self.beginResetModel() else: self.reset() if len(shape) == 3: len_ = shape[self._perspective[0]] # accept integers as index in the case of 3-D arrays if not hasattr(index, "__len__"): self._index = [index] else: self._index = index if not 0 <= self._index[0] < len_: raise ValueError("Index must be a positive integer " + "lower than %d" % len_) else: # general n-D case for i_, idx in enumerate(index): if not 0 <= idx < shape[self._perspective[i_]]: raise IndexError("Invalid index %d " % idx + "not in range 0-%d" % (shape[i_] - 1)) self._index = index if qt.qVersion() > "4.6": self.endResetModel()
def setArrayData(self, data): """Set the data array. :param data: A numpy object or a dataset. """ if qt.qVersion() > "4.6": self.beginResetModel() self.__connector = None self.__data = data if self.__data is not None: if silx.io.utils.is_dataset(self.__data): data = data[()] elif isinstance(self.__data, numpy.ndarray): data = data[()] self.__connector = _VoidConnector(data) if qt.qVersion() > "4.6": self.endResetModel() else: self.reset()
def setObject(self, h5pyObject): """Set the h5py-like object exposed by the model :param h5pyObject: A h5py-like object. It can be a `h5py.Dataset`, a `h5py.File`, a `h5py.Group`. It also can be a, `silx.gui.hdf5.H5Node` which is needed to display some local path information. """ if qt.qVersion() > "4.6": self.beginResetModel() if h5pyObject is None or self.isSupportedObject(h5pyObject): self.__obj = h5pyObject else: _logger.warning("Object class %s unsupported. Object ignored.", type(h5pyObject)) self.__initProperties() if qt.qVersion() > "4.6": self.endResetModel() else: self.reset()
def __fixHeader(self): """Update the view according to the state of the auto-resize""" header = self.horizontalHeader() if qt.qVersion() < "5.0": setResizeMode = header.setResizeMode else: setResizeMode = header.setSectionResizeMode header.setDefaultSectionSize(30) header.setStretchLastSection(True) for i in range(0x10): setResizeMode(i, qt.QHeaderView.Fixed) setResizeMode(0x10, qt.QHeaderView.Stretch)
def testAvoidRestoreRegression_Version1(self): version = qt.qVersion().split(".")[0] if version == "4": state = self.STATE_VERSION1_QT4 elif version == "5": state = self.STATE_VERSION1_QT5 else: self.skipTest("Resource not available") state = qt.QByteArray(state) dialog = self.createDialog() result = dialog.restoreState(state) self.assertTrue(result)
def __updateText(self): """Update the content of the dialog according to the settings.""" import silx._version message = """<table> <tr><td width="50%" align="center" valign="middle"> <img src="{silx_image_path}" width="100" /> </td><td width="50%" align="center" valign="middle"> <b>{application_name}</b> <br /> <br />{silx_version} <br /> <br /><a href="{project_url}">Upstream project on GitHub</a> </td></tr> </table> <dl> <dt><b>Silx version</b></dt><dd>{silx_version}</dd> <dt><b>Qt version</b></dt><dd>{qt_version}</dd> <dt><b>Qt binding</b></dt><dd>{qt_binding}</dd> <dt><b>Python version</b></dt><dd>{python_version}</dd> <dt><b>Optional libraries</b></dt><dd>{optional_lib}</dd> </dl> <p> Copyright (C) <a href="{esrf_url}">European Synchrotron Radiation Facility</a> </p> """ optional_lib = [] optional_lib.append( self.__formatOptionalLibraries("FabIO", fabio is not None)) optional_lib.append( self.__formatOptionalLibraries("H5py", h5py is not None)) optional_lib.append( self.__formatOptionalLibraries("hdf5plugin", hdf5plugin is not None)) # Access to the logo in SVG or PNG logo = icons.getQFile("../logo/silx") info = dict(application_name=self.__applicationName, esrf_url="http://www.esrf.eu", project_url="https://github.com/silx-kit/silx", silx_version=silx._version.version, qt_binding=qt.BINDING, qt_version=qt.qVersion(), python_version=sys.version.replace("\n", "<br />"), optional_lib="<br />".join(optional_lib), silx_image_path=logo.fileName()) self.__label.setText(message.format(**info)) self.__updateSize()
def mouseReleaseEvent(self, event): point1 = self.pos() deltax = point1.x() - self._point0.x() deltay = point1.y() - self._point0.y() self.moveBy(-deltax, -deltay) parent = self.parentItem() # deduce scale from rectangle if (qt.qVersion() < "5.0") or self.keepRatio: scalex = self._newRect.rect().width() / self._w scaley = scalex else: scalex = self._newRect.rect().width() / self._w scaley = self._newRect.rect().height() / self._h if qt.qVersion() < "5.0": parent.scale(scalex, scaley) else: # the correct equivalent would be: # rectItem.setTransform(qt.QTransform.fromScale(scalex, scaley)) parent.setScale(scalex) self.scene().removeItem(self._newRect) self._newRect = None qt.QGraphicsRectItem.mouseReleaseEvent(self, event)
def __sourceChanged(self): self.setCheckable(self.__source.isCheckable()) self.setEnabled(self.__source.isEnabled()) self.setFont(self.__source.font()) self.setIcon(self.__source.icon()) self.setIconText(self.__source.iconText()) self.setIconVisibleInMenu(self.__source.isIconVisibleInMenu()) self.setMenuRole(self.__source.menuRole()) self.setShortcut(self.__source.shortcut()) self.setShortcutContext(self.__source.shortcutContext()) if LooseVersion(qt.qVersion()) >= LooseVersion("5.10"): self.setShortcutVisibleInContextMenu(self.__source.isShortcutVisibleInContextMenu()) self.setStatusTip(self.__source.statusTip()) self.setText(self.__source.text()) self.setToolTip(self.__source.toolTip()) self.setVisible(self.__source.isVisible()) self.setWhatsThis(self.__source.whatsThis())
def __rowsAboutToBeRemoved(self, parentIndex, start, end): """Called when an item was removed from the model.""" items = [] model = self.model() for index in range(start, end): qindex = model.index(index, 0, parent=parentIndex) item = self.__model.itemFromIndex(qindex) if isinstance(item, _NxDataItem): items.append(item) for item in items: self.sigNxdataItemRemoved.emit(item) if qt.qVersion()[0:2] == "5.": # FIXME: workaround for https://github.com/silx-kit/silx/issues/1919 # Uses of ResizeToContents looks to break nice update of cells with Qt5 # This patch make the view blinking self.repaint()
def setData(self, data): """Set the h5py-like object exposed by the model :param h5pyObject: A h5py-like object. It can be a `h5py.Dataset`, a `h5py.File`, a `h5py.Group`. It also can be a, `silx.gui.hdf5.H5Node` which is needed to display some local path information. """ self.model().setObject(data) header = self.horizontalHeader() if qt.qVersion() < "5.0": setResizeMode = header.setResizeMode else: setResizeMode = header.setSectionResizeMode setResizeMode(0, qt.QHeaderView.Fixed) setResizeMode(1, qt.QHeaderView.Stretch) header.setStretchLastSection(True)
def __sourceChanged(self): self.setCheckable(self.__source.isCheckable()) self.setEnabled(self.__source.isEnabled()) self.setFont(self.__source.font()) self.setIcon(self.__source.icon()) self.setIconText(self.__source.iconText()) self.setIconVisibleInMenu(self.__source.isIconVisibleInMenu()) self.setMenuRole(self.__source.menuRole()) self.setShortcut(self.__source.shortcut()) self.setShortcutContext(self.__source.shortcutContext()) if LooseVersion(qt.qVersion()) >= LooseVersion("5.10"): self.setShortcutVisibleInContextMenu( self.__source.isShortcutVisibleInContextMenu()) self.setStatusTip(self.__source.statusTip()) self.setText(self.__source.text()) self.setToolTip(self.__source.toolTip()) self.setVisible(self.__source.isVisible()) self.setWhatsThis(self.__source.whatsThis())
def __init__(self, parent=None): super(OpenClDeviceDialog, self).__init__(parent) filename = get_ui_file("opencl-device-dialog.ui") qt.loadUi(filename, self) self.__availableIds = {} model = self.__createModel() self._deviceView.setModel(model) self._deviceView.setSelectionMode(qt.QAbstractItemView.SingleSelection) self._deviceView.setSelectionBehavior(qt.QAbstractItemView.SelectRows) header = self._deviceView.horizontalHeader() if qt.qVersion() < "5.0": header.setClickable(True) header.setMovable(True) header.setSectionResizeMode = self.setResizeMode else: header.setSectionsClickable(True) header.setSectionsMovable(True) header.setStretchLastSection(False) header.setSectionResizeMode(0, qt.QHeaderView.Stretch) header.setSectionResizeMode(1, qt.QHeaderView.Interactive) header.setSectionResizeMode(2, qt.QHeaderView.ResizeToContents) header.setSectionResizeMode(3, qt.QHeaderView.ResizeToContents) header.setSectionResizeMode(4, qt.QHeaderView.ResizeToContents) self._buttonBox.accepted.connect(self.accept) self._buttonBox.rejected.connect(self.reject) self._group = qt.QButtonGroup(self) self._group.setExclusive(True) self._group.addButton(self._anyDeviceButton) self._group.addButton(self._anyGpuButton) self._group.addButton(self._anyCpuButton) self._group.addButton(self._availableButton) self._group.addButton(self._customButton) self._group.buttonClicked.connect(self.__modeChanged) self._anyDeviceButton.setChecked(True) self.__modeChanged() if pyopencl is None: self._availableButton.setEnabled(False) self._availableButton.setToolTip( "PyOpenCL have to be installed to display available devices.")
def __init__(self, parent=None, model=None): super(TreeView, self).__init__(parent) # WARNING : had to set this as a queued connection, otherwise # there was a crash after the slot was called (conflict with # __setHiddenNodes probably) # TODO : investigate self.expanded.connect(self.__expanded, Qt.Qt.QueuedConnection) self.collapsed.connect(self.__collapsed) if int(Qt.qVersion().split('.')[0]) <= 4: self.header().setResizeMode(Qt.QHeaderView.ResizeToContents) else: self.header().setSectionResizeMode(Qt.QHeaderView.ResizeToContents) self.__showUniqueGroup = False self.__userRoot = False # self.setSelectionBehavior(Qt.QAbstractItemView.SelectRows) if model: self.setModel(model)
def setData(self, data): """Set the h5py-like object exposed by the model :param data: A h5py-like object. It can be a `h5py.Dataset`, a `h5py.File`, a `h5py.Group`. It also can be a, `silx.gui.hdf5.H5Node` which is needed to display some local path information. """ self.model().setObject(data) header = self.horizontalHeader() if qt.qVersion() < "5.0": setResizeMode = header.setResizeMode else: setResizeMode = header.setSectionResizeMode setResizeMode(0, qt.QHeaderView.Fixed) setResizeMode(1, qt.QHeaderView.ResizeToContents) setResizeMode(2, qt.QHeaderView.Stretch) setResizeMode(3, qt.QHeaderView.ResizeToContents) setResizeMode(4, qt.QHeaderView.ResizeToContents) header.setStretchLastSection(False)
def __init__(self, parent=None, scene=None, keepratio=True): if qt.qVersion() < '5.0': qt.QGraphicsRectItem.__init__(self, parent, scene) else: qt.QGraphicsRectItem.__init__(self, parent) rect = parent.boundingRect() x = rect.x() y = rect.y() w = rect.width() h = rect.height() self._newRect = None self.keepRatio = keepratio self.setRect(qt.QRectF(x + w - 40, y + h - 40, 40, 40)) self.setAcceptHoverEvents(True) pen = qt.QPen() color = qt.QColor(qt.Qt.white) color.setAlpha(0) pen.setColor(color) pen.setStyle(qt.Qt.NoPen) self.setPen(pen) self.setBrush(color) self.setFlag(self.ItemIsMovable, True) self.show()
def configure(self, parsed_options): """Configure the TestOptions class from the command line arguments and the environment variables """ if not parsed_options.gui: self.WITH_QT_TEST = False self.WITH_QT_TEST_REASON = "Skipped by command line" elif os.environ.get('WITH_QT_TEST', 'True') == 'False': self.WITH_QT_TEST = False self.WITH_QT_TEST_REASON = "Skipped by WITH_QT_TEST env var" elif sys.platform.startswith('linux') and not os.environ.get( 'DISPLAY', ''): self.WITH_QT_TEST = False self.WITH_QT_TEST_REASON = "DISPLAY env variable not set" if not parsed_options.opencl or os.environ.get('SILX_OPENCL', 'True') == 'False': self.WITH_OPENCL_TEST = False # That's an easy way to skip OpenCL tests # It disable the use of OpenCL on the full silx project os.environ['SILX_OPENCL'] = "False" if not parsed_options.opengl: self.WITH_GL_TEST = False self.WITH_GL_TEST_REASON = "Skipped by command line" elif os.environ.get('WITH_GL_TEST', 'True') == 'False': self.WITH_GL_TEST = False self.WITH_GL_TEST_REASON = "Skipped by WITH_GL_TEST env var" if parsed_options.low_mem or os.environ.get('SILX_TEST_LOW_MEM', 'True') == 'False': self.TEST_LOW_MEM = True if self.WITH_QT_TEST: from silx.gui import qt if sys.platform == "win32" and qt.qVersion() == "5.9.2": self.SKIP_TEST_FOR_ISSUE_936 = True
def mousePressEvent(self, event): if self._newRect is not None: self._newRect = None self._point0 = self.pos() parent = self.parentItem() scene = self.scene() # following line prevents dragging along the previously selected # item when resizing another one scene.clearSelection() rect = parent.rect() self._x = rect.x() self._y = rect.y() self._w = rect.width() self._h = rect.height() self._ratio = self._w / self._h if qt.qVersion() < "5.0": self._newRect = qt.QGraphicsRectItem(parent, scene) else: self._newRect = qt.QGraphicsRectItem(parent) self._newRect.setRect(qt.QRectF(self._x, self._y, self._w, self._h)) qt.QGraphicsRectItem.mousePressEvent(self, event)
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN # THE SOFTWARE. # # ###########################################################################*/ from __future__ import absolute_import __authors__ = ["D. Naudet"] __license__ = "MIT" __date__ = "15/09/2016" import sys from silx.gui import qt as Qt print('Using Qt {0}'.format(Qt.qVersion())) from .XsocsGui import XsocsGui from .process.MergeWidget import MergeWidget from .process.QSpaceWidget import QSpaceWidget def merge_window(*args, **kwargs): app = Qt.QApplication(sys.argv) app.setQuitOnLastWindowClosed(True) mw = MergeWidget(*args, **kwargs) mw.show() app.exec_() def conversion_window(*args, **kwargs):
# 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. # # ######################################################################### */ """Collection of widgets used to build :class:`silx.gui.fit.FitWidget.FitWidget`""" from collections import OrderedDict from silx.gui import qt from silx.gui.fit.Parameters import Parameters QTVERSION = qt.qVersion() __authors__ = ["V.A. Sole", "P. Knobel"] __license__ = "MIT" __date__ = "13/10/2016" class FitActionsButtons(qt.QWidget): """Widget with 3 ``QPushButton``: The buttons can be accessed as public attributes:: - ``EstimateButton`` - ``StartFitButton`` - ``DismissButton``
def addPixmap(self, pixmap, title=None, comment=None, commentPosition=None): """Add a pixmap to the print preview scene :param QPixmap pixmap: Pixmap to be added to the scene :param str title: Title shown above (centered) the pixmap :param str comment: Comment displayed below the pixmap :param commentPosition: "CENTER" or "LEFT" """ if self._toBeCleared: self._clearAll() self.ensurePrinterIsSet() if self.printer is None: _logger.error("printer is not set, cannot add pixmap to page") return if title is None: title = ' ' * 88 if comment is None: comment = ' ' * 88 if commentPosition is None: commentPosition = "CENTER" if qt.qVersion() < "5.0": rectItem = qt.QGraphicsRectItem(self.page, self.scene) else: rectItem = qt.QGraphicsRectItem(self.page) rectItem.setRect(qt.QRectF(1, 1, pixmap.width(), pixmap.height())) pen = rectItem.pen() color = qt.QColor(qt.Qt.red) color.setAlpha(1) pen.setColor(color) rectItem.setPen(pen) rectItem.setZValue(1) rectItem.setFlag(qt.QGraphicsItem.ItemIsSelectable, True) rectItem.setFlag(qt.QGraphicsItem.ItemIsMovable, True) rectItem.setFlag(qt.QGraphicsItem.ItemIsFocusable, False) rectItemResizeRect = _GraphicsResizeRectItem(rectItem, self.scene) rectItemResizeRect.setZValue(2) if qt.qVersion() < "5.0": pixmapItem = qt.QGraphicsPixmapItem(rectItem, self.scene) else: pixmapItem = qt.QGraphicsPixmapItem(rectItem) pixmapItem.setPixmap(pixmap) pixmapItem.setZValue(0) # I add the title if qt.qVersion() < "5.0": textItem = qt.QGraphicsTextItem(title, rectItem, self.scene) else: textItem = qt.QGraphicsTextItem(title, rectItem) textItem.setTextInteractionFlags(qt.Qt.TextEditorInteraction) offset = 0.5 * textItem.boundingRect().width() textItem.moveBy(0.5 * pixmap.width() - offset, -20) textItem.setZValue(2) # I add the comment if qt.qVersion() < "5.0": commentItem = qt.QGraphicsTextItem(comment, rectItem, self.scene) else: commentItem = qt.QGraphicsTextItem(comment, rectItem) commentItem.setTextInteractionFlags(qt.Qt.TextEditorInteraction) offset = 0.5 * commentItem.boundingRect().width() if commentPosition.upper() == "LEFT": x = 1 else: x = 0.5 * pixmap.width() - offset commentItem.moveBy(x, pixmap.height() + 20) commentItem.setZValue(2) rectItem.moveBy(20, 40)
def __updateText(self): """Update the content of the dialog according to the settings.""" import silx._version message = """<table> <tr><td width="50%" align="center" valign="middle"> <img src="{silx_image_path}" width="100" /> </td><td width="50%" align="center" valign="middle"> <b>{application_name}</b> <br /> <br />{silx_version} <br /> <br /><a href="{project_url}">Upstream project on GitHub</a> </td></tr> </table> <dl> <dt><b>Silx version</b></dt><dd>{silx_version}</dd> <dt><b>Qt version</b></dt><dd>{qt_version}</dd> <dt><b>Qt binding</b></dt><dd>{qt_binding}</dd> <dt><b>Python version</b></dt><dd>{python_version}</dd> <dt><b>Optional libraries</b></dt><dd>{optional_lib}</dd> </dl> <p> Copyright (C) <a href="{esrf_url}">European Synchrotron Radiation Facility</a> </p> """ optionals = [] optionals.append( self.__formatOptionalLibraries("H5py", "h5py" in sys.modules)) optionals.append( self.__formatOptionalLibraries("FabIO", "fabio" in sys.modules)) try: import h5py.version if h5py.version.hdf5_version_tuple >= (1, 10, 2): # Previous versions only return True if the filter was first used # to decode a dataset import h5py.h5z FILTER_LZ4 = 32004 FILTER_BITSHUFFLE = 32008 filters = [ ("HDF5 LZ4 filter", FILTER_LZ4), ("HDF5 Bitshuffle filter", FILTER_BITSHUFFLE), ] for name, filterId in filters: isAvailable = h5py.h5z.filter_avail(filterId) optionals.append( self.__formatOptionalFilters(name, isAvailable)) else: optionals.append( self.__formatOptionalLibraries("hdf5plugin", "hdf5plugin" in sys.modules)) except ImportError: pass # Access to the logo in SVG or PNG logo = icons.getQFile("silx:" + os.path.join("gui", "logo", "silx")) info = dict(application_name=self.__applicationName, esrf_url="http://www.esrf.eu", project_url="https://github.com/silx-kit/silx", silx_version=silx._version.version, qt_binding=qt.BINDING, qt_version=qt.qVersion(), python_version=sys.version.replace("\n", "<br />"), optional_lib="<br />".join(optionals), silx_image_path=logo.fileName()) self.__label.setText(message.format(**info)) self.__updateSize()
def addSvgItem(self, item, title=None, comment=None, commentPosition=None, viewBox=None): """Add a SVG item to the scene. :param QSvgRenderer item: SVG item to be added to the scene. :param str title: Title shown above (centered) the SVG item. :param str comment: Comment displayed below the SVG item. :param str commentPosition: "CENTER" or "LEFT" :param QRectF viewBox: Bounding box for the item on the print page (xOffset, yOffset, width, height). If None, use original item size. """ if not qt.HAS_SVG: raise RuntimeError("Missing QtSvg library.") if not isinstance(item, qt.QSvgRenderer): raise TypeError("addSvgItem: QSvgRenderer expected") if self._toBeCleared: self._clearAll() self.ensurePrinterIsSet() if self.printer is None: _logger.error("printer is not set, cannot add SvgItem to page") return if title is None: title = 50 * ' ' if comment is None: comment = 80 * ' ' if commentPosition is None: commentPosition = "CENTER" if viewBox is None: if hasattr(item, "_viewBox"): # PyMca compatibility: viewbox attached to item viewBox = item._viewBox else: # try the original item viewbox viewBox = item.viewBoxF() svgItem = _GraphicsSvgRectItem(viewBox, self.page) svgItem.setSvgRenderer(item) svgItem.setCacheMode(qt.QGraphicsItem.NoCache) svgItem.setZValue(0) svgItem.setFlag(qt.QGraphicsItem.ItemIsSelectable, True) svgItem.setFlag(qt.QGraphicsItem.ItemIsMovable, True) svgItem.setFlag(qt.QGraphicsItem.ItemIsFocusable, False) rectItemResizeRect = _GraphicsResizeRectItem(svgItem, self.scene) rectItemResizeRect.setZValue(2) self._svgItems.append(item) if qt.qVersion() < '5.0': textItem = qt.QGraphicsTextItem(title, svgItem, self.scene) else: textItem = qt.QGraphicsTextItem(title, svgItem) textItem.setTextInteractionFlags(qt.Qt.TextEditorInteraction) title_offset = 0.5 * textItem.boundingRect().width() textItem.setZValue(1) textItem.setFlag(qt.QGraphicsItem.ItemIsMovable, True) dummyComment = 80 * "1" if qt.qVersion() < '5.0': commentItem = qt.QGraphicsTextItem(dummyComment, svgItem, self.scene) else: commentItem = qt.QGraphicsTextItem(dummyComment, svgItem) commentItem.setTextInteractionFlags(qt.Qt.TextEditorInteraction) scaleCalculationRect = qt.QRectF(commentItem.boundingRect()) scale = svgItem.boundingRect().width() / scaleCalculationRect.width() comment_offset = 0.5 * commentItem.boundingRect().width() if commentPosition.upper() == "LEFT": x = 1 else: x = 0.5 * svgItem.boundingRect().width() - comment_offset * scale # fixme: centering commentItem.moveBy(svgItem.boundingRect().x() + x, svgItem.boundingRect().y() + svgItem.boundingRect().height()) commentItem.setPlainText(comment) commentItem.setZValue(1) commentItem.setFlag(qt.QGraphicsItem.ItemIsMovable, True) if qt.qVersion() < "5.0": commentItem.scale(scale, scale) else: # the correct equivalent would be: # rectItem.setTransform(qt.QTransform.fromScale(scalex, scaley)) commentItem.setScale(scale) textItem.moveBy(svgItem.boundingRect().x() + 0.5 * svgItem.boundingRect().width() - title_offset * scale, svgItem.boundingRect().y()) if qt.qVersion() < "5.0": textItem.scale(scale, scale) else: # the correct equivalent would be: # rectItem.setTransform(qt.QTransform.fromScale(scalex, scaley)) textItem.setScale(scale)
def setPerspective(self, perspective): """Set the perspective by defining a sequence listing all axes orthogonal to the frame or 2-D slice to be visualized. Alternatively, you can use :meth:`setFrameAxes` for the complementary approach of specifying the two axes parallel to the frame. In the 1-D or 2-D case, this parameter is irrelevant. In the 3-D case, if the unit vectors describing your axes are :math:`\vec{x}, \vec{y}, \vec{z}`, a perspective of 0 means you slices are parallel to :math:`\vec{y}\vec{z}`, 1 means they are parallel to :math:`\vec{x}\vec{z}` and 2 means they are parallel to :math:`\vec{x}\vec{y}`. In the n-D case, this parameter is a sequence of :math:`n-2` axes numbers. For instance if you want to display 2-D frames whose axes are the second and third dimensions of a 5-D array, set the perspective to ``(0, 3, 4)``. :param perspective: Sequence of dimensions/axes orthogonal to the frames. :raise: IndexError if any value in perspective is higher than the number of dimensions minus one (first dimension is 0), or if the number of values is different from the number of dimensions minus two. """ n_dimensions = len(self._array.shape) if n_dimensions < 3: _logger.warning("perspective is not relevant for 1D and 2D arrays") return if not hasattr(perspective, "__len__"): # we can tolerate an integer for 3-D array if n_dimensions == 3: perspective = [perspective] else: raise ValueError("perspective must be a sequence of integers") # ensure unicity of dimensions in perspective perspective = tuple(set(perspective)) if len(perspective) != n_dimensions - 2 or\ min(perspective) < 0 or max(perspective) >= n_dimensions: raise IndexError("Invalid perspective " + str(perspective) + " for %d-D array " % n_dimensions + "with shape " + str(self._array.shape)) if qt.qVersion() > "4.6": self.beginResetModel() else: self.reset() self._perspective = perspective # reset index self._index = [0 for _i in range(n_dimensions - 2)] if qt.qVersion() > "4.6": self.endResetModel()
def __init__(self, parent=None): super(DetectorSelectorDrop, self).__init__(parent) qt.loadUi(pyFAI.utils.get_ui_file("detector-selection-drop.ui"), self) self.__detector = None self.__dialogState = None model = self.__createManufacturerModel() self._manufacturerList.setModel(model) selection = self._manufacturerList.selectionModel() selection.selectionChanged.connect(self.__manufacturerChanged) model = AllDetectorModel(self) modelFilter = DetectorFilter(self) modelFilter.setSourceModel(model) self._detectorView.setModel(modelFilter) self._detectorView.setSelectionMode(qt.QAbstractItemView.SingleSelection) self._detectorView.setSelectionBehavior(qt.QAbstractItemView.SelectRows) self._detectorView.setSelectionBehavior(qt.QAbstractItemView.SelectRows) self._detectorView.setWordWrap(False) header = self._detectorView.horizontalHeader() # Manufacturer first self.MANUFACTURER_COLUMN = 1 header.moveSection(self.MANUFACTURER_COLUMN, 0) if qt.qVersion() < "5.0": header.setSectionResizeMode = self.setResizeMode header.setSectionResizeMode(0, qt.QHeaderView.ResizeToContents) header.setSectionResizeMode(1, qt.QHeaderView.ResizeToContents) header.setStretchLastSection(True) selection = self._detectorView.selectionModel() selection.selectionChanged.connect(self.__modelChanged) self._detectorView.doubleClicked.connect(self.__selectAndAccept) customModel = qt.QStandardItemModel(self) item = qt.QStandardItem("From file") item.setData("FILE", role=self._CustomDetectorRole) customModel.appendRow(item) item = qt.QStandardItem("Manual definition") item.setData("MANUAL", role=self._CustomDetectorRole) customModel.appendRow(item) self._customList.setModel(customModel) self._customList.setFixedHeight(self._customList.sizeHintForRow(0) * 2) selection = self._customList.selectionModel() selection.selectionChanged.connect(self.__customSelectionChanged) self.__splineFile = DataModel() self._splineFile.setModel(self.__splineFile) self._splineLoader.clicked.connect(self.loadSplineFile) self.__splineFile.changed.connect(self.__splineFileChanged) self._splineError.setVisible(False) self.__descriptionFile = DataModel() self.__descriptionFile.changed.connect(self.__descriptionFileChanged) self._fileSelection.setModel(self.__descriptionFile) self._fileLoader.clicked.connect(self.__loadDetectorFormFile) self._fileResult.setVisible(False) self._fileError.setVisible(False) self._splinePanel.setVisible(False) validator = validators.IntegerAndEmptyValidator() validator.setBottom(0) self._detectorWidth.setValidator(validator) self._detectorHeight.setValidator(validator) self.__detectorWidth = DataModel() self.__detectorHeight = DataModel() self.__pixelWidth = DataModel() self.__pixelHeight = DataModel() self._detectorWidth.setModel(self.__detectorWidth) self._detectorHeight.setModel(self.__detectorHeight) self._pixelWidth.setModel(self.__pixelWidth) self._pixelHeight.setModel(self.__pixelHeight) self._customResult.setVisible(False) self._customError.setVisible(False) self.__detectorWidth.changed.connect(self.__customDetectorChanged) self.__detectorHeight.changed.connect(self.__customDetectorChanged) self.__pixelWidth.changed.connect(self.__customDetectorChanged) self.__pixelHeight.changed.connect(self.__customDetectorChanged) self.__customDetector = None # By default select all the manufacturers self.__selectAllRegistreredDetector()
def setArrayData(self, data, copy=True, perspective=None, editable=False): """Set the data array and the viewing perspective. You can set ``copy=False`` if you need more performances, when dealing with a large numpy array. In this case, a simple reference to the data is used to access the data, rather than a copy of the array. .. warning:: Any change to the data model will affect your original data array, when using a reference rather than a copy.. :param data: n-dimensional numpy array, or any object that can be converted to a numpy array using ``numpy.array(data)`` (e.g. a nested sequence). :param bool copy: If *True* (default), a copy of the array is stored and the original array is not modified if the table is edited. If *False*, then the behavior depends on the data type: if possible (if the original array is a proper numpy array) a reference to the original array is used. :param perspective: See documentation of :meth:`setPerspective`. If None, the default perspective is the list of the first ``n-2`` dimensions, to view frames parallel to the last two axes. :param bool editable: Flag to enable editing data. Default *False*. """ if qt.qVersion() > "4.6": self.beginResetModel() else: self.reset() if data is None: # empty array self._array = numpy.array([]) elif copy: # copy requested (default) self._array = numpy.array(data, copy=True) if hasattr(data, "dtype"): # Avoid to lose the monkey-patched h5py dtype self._array.dtype = data.dtype elif not _is_array(data): raise TypeError("data is not a proper array. Try setting" + " copy=True to convert it into a numpy array" + " (this will cause the data to be copied!)") # # copy not requested, but necessary # _logger.warning( # "data is not an array-like object. " + # "Data must be copied.") # self._array = numpy.array(data, copy=True) else: # Copy explicitly disabled & data implements required attributes. # We can use a reference. self._array = data # reset colors to None if new data shape is inconsistent valid_color_shapes = (self._array.shape + (3, ), self._array.shape + (4, )) if self._bgcolors is not None: if self._bgcolors.shape not in valid_color_shapes: self._bgcolors = None if self._fgcolors is not None: if self._fgcolors.shape not in valid_color_shapes: self._fgcolors = None self.setEditable(editable) self._index = [0 for _i in range((len(self._array.shape) - 2))] self._perspective = tuple(perspective) if perspective is not None else\ tuple(range(0, len(self._array.shape) - 2)) if qt.qVersion() > "4.6": self.endResetModel()
def setPerspective(self, perspective): """Set the perspective by defining a sequence listing all axes orthogonal to the frame or 2-D slice to be visualized. Alternatively, you can use :meth:`setFrameAxes` for the complementary approach of specifying the two axes parallel to the frame. In the 1-D or 2-D case, this parameter is irrelevant. In the 3-D case, if the unit vectors describing your axes are :math:`\vec{x}, \vec{y}, \vec{z}`, a perspective of 0 means you slices are parallel to :math:`\vec{y}\vec{z}`, 1 means they are parallel to :math:`\vec{x}\vec{z}` and 2 means they are parallel to :math:`\vec{x}\vec{y}`. In the n-D case, this parameter is a sequence of :math:`n-2` axes numbers. For instance if you want to display 2-D frames whose axes are the second and third dimensions of a 5-D array, set the perspective to ``(0, 3, 4)``. :param perspective: Sequence of dimensions/axes orthogonal to the frames. :raise: IndexError if any value in perspective is higher than the number of dimensions minus one (first dimension is 0), or if the number of values is different from the number of dimensions minus two. """ n_dimensions = len(self._array.shape) if n_dimensions < 3: _logger.warning( "perspective is not relevant for 1D and 2D arrays") return if not hasattr(perspective, "__len__"): # we can tolerate an integer for 3-D array if n_dimensions == 3: perspective = [perspective] else: raise ValueError("perspective must be a sequence of integers") # ensure unicity of dimensions in perspective perspective = tuple(set(perspective)) if len(perspective) != n_dimensions - 2 or\ min(perspective) < 0 or max(perspective) >= n_dimensions: raise IndexError( "Invalid perspective " + str(perspective) + " for %d-D array " % n_dimensions + "with shape " + str(self._array.shape)) if qt.qVersion() > "4.6": self.beginResetModel() else: self.reset() self._perspective = perspective # reset index self._index = [0 for _i in range(n_dimensions - 2)] if qt.qVersion() > "4.6": self.endResetModel()
def setArrayData(self, data, copy=True, perspective=None, editable=False): """Set the data array and the viewing perspective. You can set ``copy=False`` if you need more performances, when dealing with a large numpy array. In this case, a simple reference to the data is used to access the data, rather than a copy of the array. .. warning:: Any change to the data model will affect your original data array, when using a reference rather than a copy.. :param data: n-dimensional numpy array, or any object that can be converted to a numpy array using ``numpy.array(data)`` (e.g. a nested sequence). :param bool copy: If *True* (default), a copy of the array is stored and the original array is not modified if the table is edited. If *False*, then the behavior depends on the data type: if possible (if the original array is a proper numpy array) a reference to the original array is used. :param perspective: See documentation of :meth:`setPerspective`. If None, the default perspective is the list of the first ``n-2`` dimensions, to view frames parallel to the last two axes. :param bool editable: Flag to enable editing data. Default *False*. """ if qt.qVersion() > "4.6": self.beginResetModel() else: self.reset() if data is None: # empty array self._array = numpy.array([]) elif copy: # copy requested (default) self._array = numpy.array(data, copy=True) if hasattr(data, "dtype"): # Avoid to lose the monkey-patched h5py dtype self._array.dtype = data.dtype elif not _is_array(data): raise TypeError("data is not a proper array. Try setting" + " copy=True to convert it into a numpy array" + " (this will cause the data to be copied!)") # # copy not requested, but necessary # _logger.warning( # "data is not an array-like object. " + # "Data must be copied.") # self._array = numpy.array(data, copy=True) else: # Copy explicitly disabled & data implements required attributes. # We can use a reference. self._array = data # reset colors to None if new data shape is inconsistent valid_color_shapes = (self._array.shape + (3,), self._array.shape + (4,)) if self._bgcolors is not None: if self._bgcolors.shape not in valid_color_shapes: self._bgcolors = None if self._fgcolors is not None: if self._fgcolors.shape not in valid_color_shapes: self._fgcolors = None self.setEditable(editable) self._index = [0 for _i in range((len(self._array.shape) - 2))] self._perspective = tuple(perspective) if perspective is not None else\ tuple(range(0, len(self._array.shape) - 2)) if qt.qVersion() > "4.6": self.endResetModel()
def __rowsAboutToBeInserted(self, parentIndex, start, end): if qt.qVersion()[0:2] == "5.": # FIXME: workaround for https://github.com/silx-kit/silx/issues/1919 # Uses of ResizeToContents looks to break nice update of cells with Qt5 # This patch make the view blinking self.repaint()
self.assertEqual(tableItems['coords min'].text(), '0, 2') self.assertEqual(tableItems['max'].text(), '90') self.assertEqual(tableItems['coords max'].text(), '50, 69') self.assertEqual(tableItems['delta'].text(), '85') class TestEmptyStatsWidget(TestCaseQt): def test(self): widget = StatsWidget.StatsWidget() widget.show() self.qWaitForWindowExposed(widget) # skip unit test for pyqt4 because there is some unrealised widget without # apparent reason @unittest.skipIf(qt.qVersion().split('.')[0] == '4', reason='PyQt4 not tested') class TestLineWidget(TestCaseQt): """Some test for the StatsLineWidget.""" def setUp(self): TestCaseQt.setUp(self) mystats = statshandler.StatsHandler( ((stats.StatMin(), statshandler.StatFormatter()), )) self.plot = Plot1D() self.plot.show() x = range(20) y = range(20) self.plot.addCurve(x, y, legend='curve0') y = range(12, 32) self.plot.addCurve(x, y, legend='curve1')
__date__ = "15/02/2017" import logging import sys import traceback import warnings from silx.math.fit import fittheories from silx.math.fit import fitmanager, functions from silx.gui import qt from .FitWidgets import (FitActionsButtons, FitStatusLines, FitConfigWidget, ParametersTab) from .FitConfig import getFitConfigDialog from .BackgroundWidget import getBgDialog, BackgroundDialog QTVERSION = qt.qVersion() DEBUG = 0 _logger = logging.getLogger(__name__) __authors__ = ["V.A. Sole", "P. Knobel"] __license__ = "MIT" __date__ = "30/11/2016" class FitWidget(qt.QWidget): """This widget can be used to configure, run and display results of a fitting process. The standard steps for using this widget is to initialize it, then load the data to be fitted.
def __updateText(self): """Update the content of the dialog according to the settings.""" import silx._version message = """<table> <tr><td width="50%" align="center" valign="middle"> <img src="{silx_image_path}" width="100" /> </td><td width="50%" align="center" valign="middle"> <b>{application_name}</b> <br /> <br />{silx_version} <br /> <br /><a href="{project_url}">Upstream project on GitHub</a> </td></tr> </table> <dl> <dt><b>Silx version</b></dt><dd>{silx_version}</dd> <dt><b>Qt version</b></dt><dd>{qt_version}</dd> <dt><b>Qt binding</b></dt><dd>{qt_binding}</dd> <dt><b>Python version</b></dt><dd>{python_version}</dd> <dt><b>Optional libraries</b></dt><dd>{optional_lib}</dd> </dl> <p> Copyright (C) <a href="{esrf_url}">European Synchrotron Radiation Facility</a> </p> """ optionals = [] optionals.append(self.__formatOptionalLibraries("H5py", "h5py" in sys.modules)) optionals.append(self.__formatOptionalLibraries("FabIO", "fabio" in sys.modules)) try: import h5py.version if h5py.version.hdf5_version_tuple >= (1, 10, 2): # Previous versions only return True if the filter was first used # to decode a dataset import h5py.h5z FILTER_LZ4 = 32004 FILTER_BITSHUFFLE = 32008 filters = [ ("HDF5 LZ4 filter", FILTER_LZ4), ("HDF5 Bitshuffle filter", FILTER_BITSHUFFLE), ] for name, filterId in filters: isAvailable = h5py.h5z.filter_avail(filterId) optionals.append(self.__formatOptionalFilters(name, isAvailable)) else: optionals.append(self.__formatOptionalLibraries("hdf5plugin", "hdf5plugin" in sys.modules)) except ImportError: pass # Access to the logo in SVG or PNG logo = icons.getQFile("../logo/silx") info = dict( application_name=self.__applicationName, esrf_url="http://www.esrf.eu", project_url="https://github.com/silx-kit/silx", silx_version=silx._version.version, qt_binding=qt.BINDING, qt_version=qt.qVersion(), python_version=sys.version.replace("\n", "<br />"), optional_lib="<br />".join(optionals), silx_image_path=logo.fileName() ) self.__label.setText(message.format(**info)) self.__updateSize()