def __drawTrackLines(self, painter, start, end): # Draw only from pixel start to end painter.setPen(QtCore.Qt.DashLine) painter.setOpacity(0.3) # Draw horizontal lines # for track in range(0, self.numberoftracks + 1): # y = (track * 34) + 18 # painter.drawLine(start, y, end, y) for i, track in enumerate(self._tracks): track.draw(painter, start, end, i) # Draw vertical lines for x in range(start - (start % 100), end, 100): painter.drawLine(x, 20, x, self.height()) string = "{0}".format(int(round(x / self._scale))) boundtext = painter.boundingRect(QtCore.QRectF(), string) painter.drawText(x - boundtext.width() / 2, 15, string) if self._video_fps: string = "{0}".format( int(round((x / self._scale) * (1000.0 / self._video_fps)))) boundtext = painter.boundingRect(QtCore.QRectF(), string) painter.drawText(x - boundtext.width() / 2, 30, string) painter.setOpacity(1.0) for index, track in enumerate(self._tracks): track.drawLabels(painter, index)
def __draw_track_lines(self, painter, start, end): """ Draw the track lines. :param QPainter painter: Qt QPainter object. :param int start: Initial X coordinate pixel to paint. :param int end: Final X coordinate pixel to paint. """ # Draw only from pixel start to end painter.setPen(QtCore.Qt.DashLine) painter.setOpacity(0.3) for i, track in enumerate(self._tracks): track.draw(painter, start, end) # Draw vertical lines for x in range(start - (start % 100), end, 100): painter.drawLine(x, self.TOPTRACK_HEIGHT, x, self.height()) string = "{0}".format(int(round(x / self._scale))) boundtext = painter.boundingRect(QtCore.QRectF(), string) painter.drawText(x - boundtext.width() / 2, 15, string) if self._video_fps: string = "{0}".format( int(round((x / self._scale) * (1000.0 / self._video_fps)))) boundtext = painter.boundingRect(QtCore.QRectF(), string) painter.drawText(x - boundtext.width() / 2, 30, string) painter.setOpacity(1.0)
def write_image(cls, filename, scene): # export via svg to temp file then print that # NOTE: can't use NamedTemporaryFile with delete = True # (see https://bugs.python.org/issue14243) fd, tmpname = tempfile.mkstemp(suffix=".svg") os.close(fd) try: SvgFormat.write_image(tmpname, scene) with open(tmpname, "rb") as f: svgcontents = f.read() finally: os.unlink(tmpname) svgrend = QtSvg.QSvgRenderer(QtCore.QByteArray(svgcontents)) vbox = svgrend.viewBox() if not vbox.isValid(): size = svgrend.defaultSize() else: size = vbox.size() writer = QtGui.QPdfWriter(filename) writer.setPageSizeMM(QtCore.QSizeF(size) * 0.282) painter = QtGui.QPainter(writer) svgrend.render(painter) painter.end() del svgrend del painter
def __QWheelEvent_angleDelta(self): """ Qt5 compatible QWheelEvent.angleDelta Return the delta as an x or y axis aligned QPoint vector """ if self.orientation() == __QtCore.Qt.Horizontal: return __QtCore.QPoint(self.delta(), 0) else: return __QtCore.QPoint(0, self.delta())
def paintEvent(self, e): # call the base implementation to paint normal interface QWidget.paintEvent(self, e); draw = QPainter(); draw.begin(self) h = self.height() - 1 diff = (self._higher - self._lower) * self.scale try: self._step = float(self.width()) / float(diff) except ZeroDivisionError: self._step = 0 x_start = (self._minVal - self._lower) * self._step * self.scale x_end = (self._maxVal - self._lower) * self._step * self.scale draw.setOpacity(1.0) draw.setBrush(QtCore.Qt.NoBrush) draw.setPen(QColor(200, 200, 255)) for i in range( int(self.width()/5), int(self.width()-self.width()/5) + 1, int(self.width()/5) ): draw.drawLine(i, 0, i, h) draw.setBrush(QColor(238, 238, 238)) draw.setPen(QColor(238, 238, 238)) draw.drawRoundedRect(0, 2, self.width(), h - 4, 3, 3) draw.setBrush(QColor(33, 133, 208)) draw.setPen(QColor(33, 133, 208)) draw.drawRoundedRect(int(round(x_start)), 2, int(round(x_end - x_start)), h - 4, 3, 3) # draw.setOpacity(1.0) draw.setFont(QFont('Decorative', 8)) draw.setPen(QColor(80, 80, 80)) str(self._maxVal) if self._use_float else str(int(round(self._maxVal))) boundtext = draw.boundingRect(QtCore.QRectF(), str(self._higher) if self._use_float else str(int(round(self._higher)))) draw.drawText(self.width() - boundtext.width(), 14, str(self._higher) if self._use_float else str(int(round(self._higher)))) draw.drawText(0, 14, str(self._lower) if self._use_float else str(int(round(self._lower)))) draw.setPen(QColor(255, 255, 255)) boundtext = draw.boundingRect(QtCore.QRectF(), str(self._minVal) if self._use_float else str(int(round(self._minVal)))) draw.drawText(x_start + 2, 14, str(self._minVal) if self._use_float else str(int(round(self._minVal)))) boundtext = draw.boundingRect(QtCore.QRectF(), str(self._maxVal) if self._use_float else str(int(round(self._maxVal)))) draw.drawText(x_end - boundtext.width(), 14, str(self._maxVal) if self._use_float else str(int(round(self._maxVal)))) draw.end()
def createAttributePixmap(char, background=Qt.black, color=Qt.white): """ Create a QIcon with a given character. The icon is 13 pixels high and wide. :param char: The character that is printed in the icon :type char: str :param background: the background color (default: black) :type background: QColor :param color: the character color (default: white) :type color: QColor :rtype: QIcon """ icon = QtGui.QIcon() for size in (13, 16, 18, 20, 22, 24, 28, 32, 64): pixmap = QtGui.QPixmap(size, size) pixmap.fill(Qt.transparent) painter = QtGui.QPainter() painter.begin(pixmap) painter.setRenderHints(painter.Antialiasing | painter.TextAntialiasing | painter.SmoothPixmapTransform) painter.setPen(background) painter.setBrush(background) margin = 1 + size // 16 text_margin = size // 20 rect = QtCore.QRectF(margin, margin, size - 2 * margin, size - 2 * margin) painter.drawRoundedRect(rect, 30.0, 30.0, Qt.RelativeSize) painter.setPen(color) font = painter.font() # type: QtGui.QFont font.setPixelSize(size - 2 * margin - 2 * text_margin) painter.setFont(font) painter.drawText(rect, Qt.AlignCenter, char) painter.end() icon.addPixmap(pixmap) return icon
def _get_buffer(size, filename): buffer = QtSvg.QSvgGenerator() buffer.setResolution( int(QApplication.primaryScreen().logicalDotsPerInch())) buffer.setFileName(filename) buffer.setViewBox(QtCore.QRectF(0, 0, size.width(), size.height())) return buffer
class EmulatorModeServer(QtNetwork.QLocalServer): signal_data_received = QtCore.pyqtSignal(object) _SOCKET_TIMEOUT = 2000 def __init__(self): super().__init__() self.setSocketOptions(QtNetwork.QLocalServer.WorldAccessOption) self.newConnection.connect(self._handleConnection) def listen(self): if not super().listen(Emulator.GUI_PLUGIN_SERVER_NAME): raise RuntimeError( f'Could not start server: {Emulator.GUI_PLUGIN_SERVER_NAME}') def close(self): super().close() self.removeServer(self.fullServerName()) def _handleConnection(self): socket = self.nextPendingConnection() if socket is not None: data = None if socket.waitForReadyRead(self._SOCKET_TIMEOUT): data = socket.readAll().data().decode('utf-8') logger.debug(f'Read data from emulator: {data}') socket.disconnectFromServer() socket.deleteLater() if data is not None: self.signal_data_received.emit(data) logger.debug('Data emitted.')
def init_form(self): # Get the current path of the file rootPath = os.path.dirname(__file__) # Load the UI for the self instance uic.loadUi(os.path.join(rootPath, "video.ui"), self) # Define the icon for the Play button self.videoPlay.setIcon(conf.PYFORMS_ICON_VIDEOPLAYER_PAUSE_PLAY) self._videoWidget = VideoGLWidget() self._videoWidget._control = self self.videoLayout.addWidget(self._videoWidget) self.videoPlay.clicked.connect(self.videoPlay_clicked) self.videoFrames.valueChanged.connect(self.videoFrames_valueChanged) self.videoProgress.valueChanged.connect( self.videoProgress_valueChanged) self.videoProgress.sliderReleased.connect( self.videoProgress_sliderReleased) self._timer = QtCore.QTimer(self) self._timer.timeout.connect(self.update_frame) self.form.horizontalSlider.valueChanged.connect(self.__rotateZ) self.form.verticalSlider.valueChanged.connect(self.__rotateX) self._currentFrame = None self.view_in_3D = False
def setSelection(self, selection): """ Set the model item selection. Parameters ---------- selection : QtCore.QItemSelection Item selection. """ if self.values_view.selectionModel() is not None: indices = selection.indexes() pind = defaultdict(list) for index in indices: parent = index.parent() if parent.isValid(): if parent == self.__model.index(parent.row(), parent.column()): pind[parent.row()].append( QtCore.QPersistentModelIndex(index)) else: warnings.warn("Die Die Die") else: # top level index pass self.__selections = pind self.__restoreSelection()
def __init__(self, master, enableDragDrop=False, dragDropCallback=None, dataValidityCallback=None, sizeHint=None, *args): """ :param master: the master widget :type master: OWWidget or OWComponent :param enableDragDrop: flag telling whether drag and drop is enabled :type enableDragDrop: bool :param dragDropCallback: callback for the end of drop event :type dragDropCallback: function :param dataValidityCallback: callback that accepts or ignores dragEnter and dragMove events :type dataValidityCallback: function with one argument (event) :param sizeHint: size hint :type sizeHint: QSize :param args: optional arguments for the inherited constructor """ self.master = master super().__init__(*args) self.drop_callback = dragDropCallback self.valid_data_callback = dataValidityCallback if not sizeHint: self.size_hint = QtCore.QSize(150, 100) else: self.size_hint = sizeHint if enableDragDrop: self.setDragEnabled(True) self.setAcceptDrops(True) self.setDropIndicatorShown(True)
def _get_buffer(size, filename): buffer = QtGui.QPdfWriter(filename) dpi = QApplication.desktop().logicalDpiX() buffer.setResolution(dpi) buffer.setPageMargins(QMarginsF(0, 0, 0, 0)) buffer.setPageSizeMM(QtCore.QSizeF(size.width(), size.height()) / dpi * 25.4) return buffer
def __storeSelection(self, groupind, indices): # Store current values selection for the current group groupind = self.__currentIndex indices = [ QtCore.QPersistentModelIndex(ind) for ind in self.values_view.selectedIndexes() ] self.__selections[groupind] = indices
def currentGroupSelection(self): """ Return the item selection for the current group only. """ if self.values_view.selectionModel() is not None: return self.values_view.selectionModel().selection() else: return QtCore.QItemSelection()
def sizeHint(self, option, index): options = QStyleOptionViewItem(option) self.initStyleOption(options, index) doc = QtGui.QTextDocument() doc.setHtml(options.text) doc.setTextWidth(options.rect.width()) return QtCore.QSize(doc.idealWidth(), doc.size().height())
def __QWheelEvent_pixelDelta(self): """ Qt5 compatible QWheelEvent.pixelDelta Always return a null QPoint. This is acceptable and compatible with the API (i.e. the pixelDelta is only supported on platforms where high resolution is available). """ return __QtCore.QPoint()
def value(self, value): ControlBase.value.fset(self, value) model = QFileSystemModel(parent=None) self._form.setModel(model) model.setRootPath(QtCore.QDir.currentPath()) self._form.setRootIndex(model.setRootPath(value)) self._form.setIconSize(QtCore.QSize(32, 32))
def _get_target(scene, painter, buffer, source): try: brush = scene.backgroundBrush() if brush.style() == QtCore.Qt.NoBrush: brush = QtGui.QBrush(scene.palette().color(QtGui.QPalette.Base)) except AttributeError: # not a QGraphicsView/Scene brush = QtGui.QBrush(QtCore.Qt.white) painter.fillRect(buffer.rect(), brush) return QtCore.QRectF(0, 0, source.width(), source.height())
def _get_buffer(size, filename): buffer = QtGui.QPdfWriter(filename) dpi = int(QApplication.primaryScreen().logicalDotsPerInch()) buffer.setResolution(dpi) buffer.setPageMargins(QMarginsF(0, 0, 0, 0)) pagesize = QtCore.QSizeF(size.width(), size.height()) / dpi * 25.4 buffer.setPageSize( QtGui.QPageSize(pagesize, QtGui.QPageSize.Millimeter)) return buffer
def paintEvent(self, e): """ :param e: :return: """ self._is_painting = True super(EventsWidget, self).paintEvent(e) painter = QPainter() painter.begin(self) painter.setRenderHint(QPainter.Antialiasing) painter.setFont(QFont('Decorative', 8)) slider_pos = self._scroll.sliderPosition() start = slider_pos * self._scale end = start + self.width() * self._scale for i, track in enumerate(self._tracks): if self._break_draw: break track.draw_events(painter, start, end, track_index=i, left_shift=-self._scroll.sliderPosition(), scale=self._scale) # Draw only from pixel start to end painter.setPen(QtCore.Qt.DashLine) painter.setOpacity(0.3) # print('Draw', start, end, self._scale, self._scroll.sliderPosition(), self.width()) # Draw vertical lines for x in range(start - (start % (100 * self._scale)), end, 100 * self._scale): x2draw = (x - slider_pos * self._scale) // self._scale painter.drawLine(x2draw, 20, x2draw, self.height()) string = str(x) boundtext = painter.boundingRect(QtCore.QRectF(), string) painter.drawText(x2draw - boundtext.width() / 2, 15, string) for index, track in enumerate(self._tracks): top = self.which_top(index) # print(top) painter.drawLine(0, top, self.width(), top) painter.drawText(10, top + 15, track.title) painter.setOpacity(1.0) self._pointer.draw(painter, left_shift=-slider_pos, scale=self._scale) # Draw the time pointer painter.end() self._break_draw = False self._is_painting = False
def draw(self, painter, showvalues=False): """ :param painter: :param showvalues: :return: """ painter.setPen(QColor(0, 255, 0)) painter.setBrush(QColor(0, 255, 0)) painter.drawLine( self.xposition, 8, self.xposition, self._parent.height()) painter.drawEllipse(QtCore.QPoint(self.xposition, 8), 5, 5) painter.drawText(self.xposition + 8, 8 + 4, str(self._position))
def draw(self, painter, left_shift=0, scale=1): """ :param painter: :param left_shift: :param scale: :return: """ x = self.position / scale + left_shift painter.setPen(QColor(0, 255, 0)) painter.setBrush(QColor(0, 255, 0)) painter.drawLine(x, 8, x, self._parent.height()) painter.drawEllipse(QtCore.QPoint(x, 8), 5, 5) painter.drawText(x + 8, 8 + 4, str(self.position))
def __restoreSelection(self): # Restore previous selection for root (if available) assert self.__model is not None groupind = self.__currentIndex root = self.__model.index(groupind, 0) sel = self.__selections.get(groupind, []) indices = [ self.__model.index(pind.row(), pind.column(), root) for pind in sel if pind.isValid() and pind.parent() == root ] selection = QtCore.QItemSelection() for ind in indices: selection.select(ind, ind) self.values_view.selectionModel().select( selection, QtCore.QItemSelectionModel.ClearAndSelect)
def selection(self): """ Return the item selection. Returns ------- selection : QtCore.QItemSelection """ selection = QtCore.QItemSelection() if self.__model is None: return selection for pind in chain(*self.__selections.values()): ind = self.__model.index(pind.row(), pind.column(), pind.parent()) if ind.isValid(): selection.select(ind, ind) return selection
def itemselection(modelindexlist): """ Return an QtCore.QItemSelection from QModelIndex list Parameters ---------- modelindexlist : list of QtCore.QModelIndex Selected model indices. Returns ------- selection : QtCore.QItemSelection """ selection = QtCore.QItemSelection() for index in modelindexlist: selection.select(index, index) return selection
def paint(self, painter, option, index): painter.save() self.drawBackground(painter, option, index) ratio = index.data(TableBarItem.BarRole) if isinstance(ratio, float): if math.isnan(ratio): ratio = None color = None if ratio is not None: if self.color_schema is not None: class_ = index.data(TableClassValueRole) if isinstance(class_, Orange.data.Value) and \ class_.variable.is_discrete and \ not math.isnan(class_): color = self.color_schema[int(class_)] else: color = index.data(self.BarColorRole) if color is None: color = self.color rect = option.rect if ratio is not None: pw = 5 hmargin = 3 + pw / 2 # + half pen width for the round line cap vmargin = 1 textoffset = pw + vmargin * 2 baseline = rect.bottom() - textoffset / 2 width = (rect.width() - 2 * hmargin) * ratio painter.save() painter.setRenderHint(QtGui.QPainter.Antialiasing) painter.setPen(QtGui.QPen(QtGui.QBrush(color), pw, Qt.SolidLine, Qt.RoundCap)) line = QtCore.QLineF( rect.left() + hmargin, baseline, rect.left() + hmargin + width, baseline ) painter.drawLine(line) painter.restore() text_rect = rect.adjusted(0, 0, 0, -textoffset) else: text_rect = rect text = str(index.data(Qt.DisplayRole)) self.drawDisplay(painter, option, text_rect, text) painter.restore()
def __init__(self, *args, **kwargs): global games_json super().__init__("NSScreenshotMaker") self._tmpinputfolder = tempfile.mkdtemp() self._settingsbutton = ControlButton("⚙️") self._settingsbutton.value = self.openSettings self._runbutton = ControlButton("Go!") self._runbutton.value = self.go self._combo = ControlCombo( helptext="The game the Switch will think the screenshot is from") self.gameslist = games_json for k in self.gameslist: self._combo.add_item(k, self.gameslist[k]) self._combo.add_item("Custom", "Custom") self._combolabel = ControlLabel( "Game ID", helptext="The game the Switch will think the screenshot is from") self._imagelist = ControlFilesTree() self._imagelist._form.setDragEnabled(True) self._imagelist._form.setAcceptDrops(True) self._imagelist._form.setDropIndicatorShown(True) self._imagelist._form.dropEvent = self.dropEvent model = QFileSystemModel(parent=None) model.setReadOnly(False) self._imagelist._form.setModel(model) model.setRootPath(QtCore.QDir.currentPath()) self._imagelist._form.setRootIndex( model.setRootPath(self._tmpinputfolder)) self._imagelist._form.setIconSize(QtCore.QSize(32, 32)) self.formset = [("_combolabel", "_combo", "_settingsbutton"), "_imagelist", "_runbutton"] self._firstrunpanel = ControlDockWidget() self._firstrunpanel.hide() self._firstrunwin = FirstRun() if not os.path.isfile( appdirs.AppDirs("NSScreenshotMaker", "").user_data_dir + "/settings.json"): self._firstrunwin.parent = self self._firstrunpanel.value = self._firstrunwin self._firstrunpanel.show() self._firstrunwin.show() self._settingspanel = ControlDockWidget() self._settingspanel.hide() self._settingswin = SettingsWindow()
def drawDistBar(painter, rect, distribution, colortable): """ Parameters ---------- painter : QtGui.QPainter rect : QtCore.QRect distribution : numpy.ndarray colortable : List[QtGui.QColor] """ # assert numpy.isclose(numpy.sum(distribution), 1.0) # assert numpy.all(distribution >= 0) painter.save() painter.translate(rect.topLeft()) for dvalue, color in zip(distribution, colortable): if dvalue and numpy.isfinite(dvalue): painter.setBrush(color) width = rect.width() * dvalue painter.drawRoundedRect(QtCore.QRectF(0, 0, width, rect.height()), 1, 2) painter.translate(width, 0.0) painter.restore()
def _get_target(scene, painter, buffer, source): return QtCore.QRectF(0, 0, source.width(), source.height())
def _get_buffer(size, filename): buffer = QtSvg.QSvgGenerator() buffer.setFileName(filename) buffer.setSize(QtCore.QSize(int(size.width()), int(size.height()))) return buffer