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
