def set_viewport(self, size, raise_if_empty=False):
"""
Set viewport size.
If size is "full" viewport size is detected automatically.
If can also be "<width>x<height>".
.. note::
This will update all JS geometry variables, but window resize event
is delivered asynchronously and so ``window.resize`` will not be
invoked until control is yielded to the event loop.
"""
if size == 'full':
size = self.web_page.mainFrame().contentsSize()
self.logger.log("Contents size: %s" % size, min_level=2)
if size.isEmpty():
if raise_if_empty:
raise RuntimeError("Cannot detect viewport size")
else:
size = defaults.VIEWPORT_SIZE
self.logger.log("Viewport is empty, falling back to: %s" %
size)
if not isinstance(size, QSize):
validate_size_str(size)
w, h = map(int, size.split('x'))
size = QSize(w, h)
self.web_page.setViewportSize(size)
self._force_relayout()
w, h = int(size.width()), int(size.height())
self.logger.log("viewport size is set to %sx%s" % (w, h), min_level=2)
return w, h
def _get_icon_rect(self, opt, text_rect):
"""Get a QRect for the icon to draw.
Args:
opt: QStyleOptionTab
text_rect: The QRect for the text.
Return:
A QRect.
"""
icon_size = opt.iconSize
if not icon_size.isValid():
icon_extent = self.pixelMetric(QStyle.PM_SmallIconSize)
icon_size = QSize(icon_extent, icon_extent)
icon_mode = (QIcon.Normal if opt.state & QStyle.State_Enabled
else QIcon.Disabled)
icon_state = (QIcon.On if opt.state & QStyle.State_Selected
else QIcon.Off)
# reserve space for favicon when tab bar is vertical (issue #1968)
position = config.val.tabs.position
if (position in [QTabWidget.East, QTabWidget.West] and
config.val.tabs.favicons.show):
tab_icon_size = icon_size
else:
actual_size = opt.icon.actualSize(icon_size, icon_mode, icon_state)
tab_icon_size = QSize(
min(actual_size.width(), icon_size.width()),
min(actual_size.height(), icon_size.height()))
icon_top = text_rect.center().y() + 1 - tab_icon_size.height() / 2
icon_rect = QRect(QPoint(text_rect.left(), icon_top), tab_icon_size)
icon_rect = self._style.visualRect(opt.direction, opt.rect, icon_rect)
return icon_rect
def get_favicon(self):
u"""
Get favicon for the site.
This is called when the site_url can’t be loaded or when that
page doesn’t contain a link tag with rel set to icon (the new
way of doing site icons.)
"""
if self.site_icon:
return
if not with_pyqt:
self.site_icon = None
return
ico_url = urllib.parse.urljoin(self.icon_url, "/favicon.ico")
ico_request = urllib.request.Request(ico_url)
if self.user_agent:
ico_request.add_header('User-agent', self.user_agent)
ico_response = urllib.request.urlopen(ico_request)
if 200 != ico_response.code:
self.site_icon = None
return
self.site_icon = QImage.fromData(ico_response.read())
max_size = QSize(self.max_icon_size, self.max_icon_size)
ico_size = self.site_icon.size()
if ico_size.width() > max_size.width() \
or ico_size.height() > max_size.height():
self.site_icon = self.site_icon.scaled(
max_size, Qt.KeepAspectRatio, Qt.SmoothTransformation)
def renderToTexture(self, levelOfDetail = 1.0):
# Determine the fbo size we will need.
size = (self.sceneRect().size() * levelOfDetail).toSize()
fboSize = nextPowerOfTwo(size)
if fboSize.isEmpty():
fboSize = QSize(16, 16)
# Create or re-create the fbo.
if self.fbo is None or self.fbo.size() != fboSize:
#del self.fbo
self.fbo = QGLFramebufferObject(fboSize, self.format)
if not self.fbo.isValid():
#del self.fbo
self.fbo = None
return 0
self.dirty = True
# Return the previous texture contents if the scene hasn't changed.
if self.fbo is not None and not self.dirty:
return self.fbo.texture()
# Render the scene into the fbo, scaling the QPainter's view
# transform up to the power-of-two fbo size.
painter = QPainter(self.fbo)
painter.setWindow(0, 0, size.width(), size.height())
painter.setViewport(0, 0, fboSize.width(), fboSize.height())
self.render(painter)
painter.end()
self.dirty = False
return self.fbo.texture()
def calculate_relative_position(parent_rect: QtCore.QRect, own_size: QtCore.QSize,
constraint: RelativeLayoutConstraint):
"""
Calculates the position of the element, given its size, the position and size of the parent and a relative layout
constraint. The position is the position of the parent plus the weighted size of the parent, the weighted size of
the element and an offset. The weights and the offset are given by the constraint for each direction.
:param parent_rect: parent coordinates and size as rectangle
:param own_size: size of the element (width and height)
:param constraint: relative layout constraint to apply
:return: tuple of recommended x and y positions of the element
"""
"""
Returns the left, upper corner of an object if the parent rectangle (QRect) is given and our own size (QSize)
and a relative layout constraint (see RelativeLayoutConstraint).
"""
x = (parent_rect.x()
+ constraint.x[0] * parent_rect.width()
+ constraint.x[1] * own_size.width()
+ constraint.x[2])
y = (parent_rect.y()
+ constraint.y[0] * parent_rect.height()
+ constraint.y[1] * own_size.height()
+ constraint.y[2])
return x, y
def minimumTabSizeHint(self, index):
"""Set the minimum tab size to indicator/icon/... text.
Args:
index: The index of the tab to get a size hint for.
Return:
A QSize.
"""
icon = self.tabIcon(index)
padding_count = 2
if icon.isNull():
icon_size = QSize(0, 0)
else:
extent = self.style().pixelMetric(QStyle.PM_TabBarIconSize, None,
self)
icon_size = icon.actualSize(QSize(extent, extent))
padding_count += 1
indicator_width = config.get('tabs', 'indicator-width')
if indicator_width != 0:
indicator_width += config.get('tabs', 'indicator-space')
padding_width = self.style().pixelMetric(PM_TabBarPadding, None, self)
height = self.fontMetrics().height()
width = (self.fontMetrics().width('\u2026') +
icon_size.width() + padding_count * padding_width +
indicator_width)
return QSize(width, height)
def minimumTabSizeHint(self, index):
"""Set the minimum tab size to indicator/icon/... text.
Args:
index: The index of the tab to get a size hint for.
Return:
A QSize.
"""
icon = self.tabIcon(index)
padding = config.get('tabs', 'padding')
padding_h = padding.left + padding.right
padding_v = padding.top + padding.bottom
if icon.isNull():
icon_size = QSize(0, 0)
else:
extent = self.style().pixelMetric(QStyle.PM_TabBarIconSize, None,
self)
icon_size = icon.actualSize(QSize(extent, extent))
padding_h += self.style().pixelMetric(
PixelMetrics.icon_padding, None, self)
indicator_width = config.get('tabs', 'indicator-width')
height = self.fontMetrics().height() + padding_v
width = (self.fontMetrics().width('\u2026') + icon_size.width() +
padding_h + indicator_width)
return QSize(width, height)
def __init__(self, text, align=LEFT, userCode=0, parent=None, type=SIDEBAR):
super(TextButton, self).__init__(parent)
# Prevent a circular import.
from menumanager import MenuManager
self._menu_manager = MenuManager.instance()
self.menuString = text
self.buttonLabel = text
self.alignment = align
self.buttonType = type
self.userCode = userCode
self.scanAnim = None
self.bgOn = None
self.bgOff = None
self.bgHighlight = None
self.bgDisabled = None
self.state = TextButton.OFF
self.setAcceptHoverEvents(True)
self.setCursor(Qt.PointingHandCursor)
# Calculate the button size.
if type in (TextButton.SIDEBAR, TextButton.PANEL):
self.logicalSize = QSize(TextButton.BUTTON_WIDTH, TextButton.BUTTON_HEIGHT)
else:
self.logicalSize = QSize(int((TextButton.BUTTON_WIDTH / 2.0) - 5), int(TextButton.BUTTON_HEIGHT * 1.5))
self._prepared = False
def minimumTabSizeHint(self, index):
"""Override minimumTabSizeHint because we want no hard minimum.
There are two problems with having a hard minimum tab size:
- When expanding is True, the window will expand without stopping
on some window managers.
- We don't want the main window to get bigger with many tabs. If
nothing else helps, we *do* want the tabs to get smaller instead
of enforcing a minimum window size.
Args:
index: The index of the tab to get a sizehint for.
Return:
A QSize.
"""
icon = self.tabIcon(index)
padding_count = 0
if not icon.isNull():
extent = self.style().pixelMetric(QStyle.PM_TabBarIconSize, None,
self)
icon_size = icon.actualSize(QSize(extent, extent))
padding_count += 1
else:
icon_size = QSize(0, 0)
padding_width = self.style().pixelMetric(PM_TabBarPadding, None, self)
height = self.fontMetrics().height()
width = (self.fontMetrics().size(0, '\u2026').width() +
icon_size.width() + padding_count * padding_width)
return QSize(width, height)
def sizeHint(self):
hint = QLabel.sizeHint(self)
if self.maximum_size_hint != None:
hint = QSize(max(hint.width(), self.maximum_size_hint.width()),
max(hint.height(), self.maximum_size_hint.height()))
self.maximum_size_hint = hint
return hint
def minimumSize(self):
# Return the largest "minimum size" of the items
size = QSize()
for item in self.items:
size = size.expandedTo(item.minimumSize())
margin, _, _, _ = self.getContentsMargins()
size += QSize(2 * margin, 2 * margin)
# self._logger.debug('size {} {}'.format(size.width(), size.height()))
return size
def minimumSize(self):
size = QSize()
for item in self.itemList:
size = size.expandedTo(item.minimumSize())
margin, _, _, _ = self.getContentsMargins()
size += QSize(2 * margin, 2 * margin)
return size
def _get_icon_rect(self, opt, text_rect):
"""Get a QRect for the icon to draw.
Args:
opt: QStyleOptionTab
text_rect: The QRect for the text.
Return:
A QRect.
"""
icon_size = opt.iconSize
if not icon_size.isValid():
icon_extent = self.pixelMetric(QStyle.PM_SmallIconSize)
icon_size = QSize(icon_extent, icon_extent)
icon_mode = (QIcon.Normal if opt.state & QStyle.State_Enabled
else QIcon.Disabled)
icon_state = (QIcon.On if opt.state & QStyle.State_Selected
else QIcon.Off)
tab_icon_size = opt.icon.actualSize(icon_size, icon_mode, icon_state)
tab_icon_size = QSize(min(tab_icon_size.width(), icon_size.width()),
min(tab_icon_size.height(), icon_size.height()))
icon_rect = QRect(text_rect.left(),
text_rect.center().y() - tab_icon_size.height() / 2,
tab_icon_size.width(), tab_icon_size.height())
icon_rect = self._style.visualRect(opt.direction, opt.rect, icon_rect)
qtutils.ensure_valid(icon_rect)
return icon_rect
def __init__(self, parent = None):
super().__init__(parent)
self.mMouseAnchorPoint = QPoint()
self.mOffset = QPoint()
self.mOldSize = QSize()
self.mDragging = False
self.mOffsetBounds = QRect()
self.mScale = 0.0
self.mNewSize = QSize()
self.mOrigOffset = QPoint()
self.setMinimumSize(20, 20)
self.setOldSize(QSize(1, 1))
class FeatureTableWidgetHHeader(QTableWidgetItem):
sub_trans = str.maketrans('0123456789', '₀₁₂₃₄₅₆₇₈₉')
def __init__(self, column, sigma=None, window_size=3.5):
QTableWidgetItem.__init__(self)
# init
# ------------------------------------------------
self.column = column
self.sigma = sigma
self.window_size = window_size
self.pixmapSize = QSize(61, 61)
self.setNameAndBrush(self.sigma)
@property
def brushSize(self):
if self.sigma is None:
return 0
else:
return int(3.0 * self.sigma + 0.5) + 1
def setNameAndBrush(self, sigma, color=Qt.black):
self.sigma = sigma
self.setText(f'σ{self.column}'.translate(self.sub_trans))
if self.sigma is not None:
total_window = (1 + 2 * int(self.sigma * self.window_size + 0.5))
self.setToolTip(f'sigma = {sigma:.1f} pixels, window diameter = {total_window:.1f}')
font = QFont()
font.setPointSize(10)
# font.setBold(True)
self.setFont(font)
self.setForeground(color)
pixmap = QPixmap(self.pixmapSize)
pixmap.fill(Qt.transparent)
painter = QPainter()
painter.begin(pixmap)
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setPen(color)
brush = QBrush(color)
painter.setBrush(brush)
painter.drawEllipse(QRect(old_div(self.pixmapSize.width(), 2) - old_div(self.brushSize, 2),
old_div(self.pixmapSize.height(), 2) - old_div(self.brushSize, 2),
self.brushSize, self.brushSize))
painter.end()
self.setIcon(QIcon(pixmap))
self.setTextAlignment(Qt.AlignVCenter)
def setIconAndTextColor(self, color):
self.setNameAndBrush(self.sigma, color)
def __init__(self, name, x, y, width, height):
super().__init__(Layer.TileLayerType, name, x, y, width, height)
self.mMaxTileSize = QSize(0, 0)
self.mGrid = QVector()
for i in range(width * height):
self.mGrid.append(Cell())
self.mOffsetMargins = QMargins()
def __init__(self, parent=None):
super(QWidget, self).__init__(parent)
self.m_iconSize = QSize(64, 64)
self.m_scene = QGraphicsScene()
self.m_ui = Ui_Form()
self.m_ui.setupUi(self)
self.m_ui.easingCurvePicker.setIconSize(self.m_iconSize)
self.m_ui.easingCurvePicker.setMinimumHeight(self.m_iconSize.height() + 50)
self.m_ui.buttonGroup.setId(self.m_ui.lineRadio, 0)
self.m_ui.buttonGroup.setId(self.m_ui.circleRadio, 1)
dummy = QEasingCurve()
self.m_ui.periodSpinBox.setValue(dummy.period())
self.m_ui.amplitudeSpinBox.setValue(dummy.amplitude())
self.m_ui.overshootSpinBox.setValue(dummy.overshoot())
self.m_ui.easingCurvePicker.currentRowChanged.connect(self.curveChanged)
self.m_ui.buttonGroup.buttonClicked[int].connect(self.pathChanged)
self.m_ui.periodSpinBox.valueChanged.connect(self.periodChanged)
self.m_ui.amplitudeSpinBox.valueChanged.connect(self.amplitudeChanged)
self.m_ui.overshootSpinBox.valueChanged.connect(self.overshootChanged)
self.createCurveIcons()
pix = QPixmap(':/images/qt-logo.png')
self.m_item = PixmapItem(pix)
self.m_scene.addItem(self.m_item.pixmap_item)
self.m_ui.graphicsView.setScene(self.m_scene)
self.m_anim = Animation(self.m_item, b'pos')
self.m_anim.setEasingCurve(QEasingCurve.OutBounce)
self.m_ui.easingCurvePicker.setCurrentRow(int(QEasingCurve.OutBounce))
self.startAnimation()
def calculate_size(self):
"""Determine size by calculating the space of the visible items"""
visible_items = min(self.model().rowCount(), self.MAX_VISIBLE_ITEMS)
first_visible_row = self.verticalScrollBar().value()
option = self.viewOptions()
size_hint = QSize()
for index in range(visible_items):
tmp_size = self.itemDelegate().sizeHint(
option, self.model().index(index + first_visible_row, 0))
if size_hint.width() < tmp_size.width():
size_hint = tmp_size
height = size_hint.height()
height *= visible_items
size_hint.setHeight(height)
return size_hint
def maybe_get_icon(self):
u"""
Get icon for the site as a QImage if we haven’t already.
Get the site icon, either the 'rel="icon"' or the favicon, for
the web page at url or passed in as page_html and store it as
a QImage. This function can be called repeatedly and loads the
icon only once.
"""
if self.site_icon:
return
if not with_pyqt:
self.site_icon = None
return
page_request = urllib.request.Request(self.icon_url)
if self.user_agent:
page_request.add_header('User-agent', self.user_agent)
page_response = urllib.request.urlopen(page_request)
if 200 != page_response.code:
self.get_favicon()
return
page_soup = soup(page_response, 'html.parser')
try:
icon_url = page_soup.find(
name='link', attrs={'rel': 'icon'})['href']
except (TypeError, KeyError):
self.get_favicon()
return
# The url may be absolute or relative.
if not urllib.parse.urlsplit(icon_url).netloc:
icon_url = urllib.parse.urljoin(
self.url, urllib.parse.quote(icon_url.encode('utf-8')))
icon_request = urllib.request.Request(icon_url)
if self.user_agent:
icon_request.add_header('User-agent', self.user_agent)
icon_response = urllib.request.urlopen(icon_request)
if 200 != icon_response.code:
self.site_icon = None
return
self.site_icon = QImage.fromData(icon_response.read())
max_size = QSize(self.max_icon_size, self.max_icon_size)
icon_size = self.site_icon.size()
if icon_size.width() > max_size.width() \
or icon_size.height() > max_size.height():
self.site_icon = self.site_icon.scaled(
max_size, Qt.KeepAspectRatio, Qt.SmoothTransformation)
def maxSize(self):
size = QSize()
for variation in self.d.variations:
size.setWidth(max(size.width(), variation.map.width()))
size.setHeight(max(size.height(), variation.map.height()))
return size
def __init__(self, parent):
super().__init__(parent)
self.setFocusPolicy(Qt.NoFocus)
self.setBackgroundRole(QPalette.Window)
self.setFrameShape(QFrame.NoFrame)
self.setBackgroundBrush(QBrush(Qt.NoBrush))
self._scene = QGraphicsScene(self)
self.setScene(self._scene)
self._keys = {}
self._midi_to_key = {}
for octave in range(2, 7):
for idx, note in enumerate(['C', 'D', 'E', 'F', 'G', 'A', 'B']):
pitch_name = '%s%d' % (note, octave)
key = PianoKey(
parent,
140 * octave + 20 * idx,
pitch_name,
PianoKey.WHITE)
self._keys[pitch_name] = key
self._midi_to_key[music.NOTE_TO_MIDI[pitch_name]] = key
self._scene.addItem(key)
for idx, note in enumerate(['C#', 'D#', '', 'F#', 'G#', 'A#', '']):
if not note:
continue
pitch_name = '%s%d' % (note, octave)
key = PianoKey(
parent,
140 * octave + 20 * idx + 10,
pitch_name,
PianoKey.BLACK)
self._keys[pitch_name] = key
self._midi_to_key[music.NOTE_TO_MIDI[pitch_name]] = key
self._scene.addItem(key)
size = self._scene.sceneRect().size()
size = QSize(int(math.ceil(size.width())) + 1,
int(math.ceil(size.height())) + 10)
self.setMinimumSize(size)
self.setMaximumSize(size)
def __init__(self, column, sigma=None, window_size=3.5):
QTableWidgetItem.__init__(self)
# init
# ------------------------------------------------
self.column = column
self.sigma = sigma
self.window_size = window_size
self.pixmapSize = QSize(61, 61)
self.setNameAndBrush(self.sigma)
def __init__(self):
super(AbstractLayout, self).__init__()
self._pages = []
self._size = QSize()
self._margin = 4
self._spacing = 8
self._scale = 1.0
self._scaleChanged = False
self._dpi = (72, 72)
def maybe_get_icon(self):
if self.site_icon:
return
if not with_pyqt:
self.site_icon = None
return
try:
icon_data = self.get_data_from_url(self.full_icon_url)
except:
AudioDownloader.maybe_get_icon(self)
else:
self.site_icon = QImage.fromData(icon_data)
max_size = QSize(self.max_icon_size, self.max_icon_size)
ico_size = self.site_icon.size()
if ico_size.width() > max_size.width() \
or ico_size.height() > max_size.height():
self.site_icon = self.site_icon.scaled(
max_size, Qt.KeepAspectRatio, Qt.SmoothTransformation)
def calculateSize(self, sizeType):
totalSize = QSize()
for wrapper in self.list:
position = wrapper.position
itemSize = QSize()
if sizeType == self.MinimumSize:
itemSize = wrapper.item.minimumSize()
else: # sizeType == self.SizeHint
itemSize = wrapper.item.sizeHint()
if position in (self.North, self.South, self.Center):
totalSize.setHeight(totalSize.height() + itemSize.height())
if position in (self.West, self.East, self.Center):
totalSize.setWidth(totalSize.width() + itemSize.width())
return totalSize
class ResizeMap(QUndoCommand):
def __init__(self, mapDocument, size):
super().__init__(QCoreApplication.translate("Undo Commands", "Resize Map"))
self.mMapDocument = mapDocument
self.mSize = QSize(size)
def undo(self):
self.swapSize()
def redo(self):
self.swapSize()
def swapSize(self):
map = self.mMapDocument.map()
oldSize = QSize(map.width(), map.height())
map.setWidth(self.mSize.width())
map.setHeight(self.mSize.height())
self.mSize = oldSize
self.mMapDocument.emitMapChanged()
def __init__(self, sigma, window_size, name=None):
QTableWidgetItem.__init__(self)
# init
# ------------------------------------------------
self.sigma = sigma
self.window_size = window_size
self.pixmapSize = QSize(61, 61)
if not name:
self.setNameAndBrush(self.sigma)
else:
self.setText(name)
def mapSize(self):
p = RenderParams(self.map())
# The map size is the same regardless of which indexes are shifted.
if (p.staggerX):
size = QSize(self.map().width() * p.columnWidth + p.sideOffsetX,
self.map().height() * (p.tileHeight + p.sideLengthY))
if (self.map().width() > 1):
size.setHeight(size.height() + p.rowHeight)
return size
else:
size = QSize(self.map().width() * (p.tileWidth + p.sideLengthX),
self.map().height() * p.rowHeight + p.sideOffsetY)
if (self.map().height() > 1):
size.setWidth(size.width() + p.columnWidth)
return size
def __init__(self, parent=None):
"""
Constructor
@param parent reference to the parent widget (QWidget)
"""
super(IconEditorGrid, self).__init__(parent)
self.setAttribute(Qt.WA_StaticContents)
self.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
self.__curColor = Qt.black
self.__zoom = 12
self.__curTool = self.Pencil
self.__startPos = QPoint()
self.__endPos = QPoint()
self.__dirty = False
self.__selecting = False
self.__selRect = QRect()
self.__isPasting = False
self.__clipboardSize = QSize()
self.__pasteRect = QRect()
self.__undoStack = QUndoStack(self)
self.__currentUndoCmd = None
self.__image = QImage(32, 32, QImage.Format_ARGB32)
self.__image.fill(qRgba(0, 0, 0, 0))
self.__markImage = QImage(self.__image)
self.__markImage.fill(self.NoMarkColor.rgba())
self.__compositingMode = QPainter.CompositionMode_SourceOver
self.__lastPos = (-1, -1)
self.__gridEnabled = True
self.__selectionAvailable = False
self.__initCursors()
self.__initUndoTexts()
self.setMouseTracking(True)
self.__undoStack.canRedoChanged.connect(self.canRedoChanged)
self.__undoStack.canUndoChanged.connect(self.canUndoChanged)
self.__undoStack.cleanChanged.connect(self.__cleanChanged)
self.imageChanged.connect(self.__updatePreviewPixmap)
QApplication.clipboard().dataChanged.connect(self.__checkClipboard)
self.__checkClipboard()
def __init__(self, parent=None):
super(NGL_SeekBar, self).__init__(parent)
self._max = 100
self._min = 0
self._level = 50
self._orientation = Qt.Horizontal
self._show_progress = True
self._slider_size = QSize(8,8)
self._slider_color = QColor(Qt.blue)
self._eventsEnabled = True
self.setGeometry(50, 50, 150, 15)
self.setStyleSheet('color: rgb(64, 128, 64);')
self.update()
class Settings(object):
l = logging.getLogger('Settings')
def __init__(self, fileName='shadow.ini'):
self.fileName = fileName
self.tzIdx = 0
self.mainWindowSize = QSize(1200, 700)
self.mainWindowPos = QPoint(240, 200)
def load(self):
self.l.debug('Loading local settings from {}'.format(self.fileName))
config = configparser.ConfigParser()
config.read(self.fileName)
if config.has_section('common'):
commonSettings = config['common']
self.tzIdx = int(commonSettings.get('tz', 0))
# load main window position and size
if config.has_section('mainWindow'):
windowSettings = config['mainWindow']
# read position
pos = windowSettings.get(
'pos', '{},{}'.format(self.mainWindowPos.x(),
self.mainWindowPos.y())).split(',')
self.mainWindowPos = QPoint(int(pos[0]), int(pos[1]))
# read size
size = windowSettings.get(
'size',
'{},{}'.format(self.mainWindowSize.width(),
self.mainWindowSize.height())).split(',')
self.mainWindowSize = QSize(int(size[0]), int(size[1]))
def dump(self, channel):
self.l.debug('Saving local settings ...')
config = configparser.ConfigParser()
config.add_section('common')
config.set('common', 'tz', str(self.tzIdx))
config.add_section('mainWindow')
config.set(
'mainWindow', 'pos', '{},{}'.format(self.mainWindowPos.x(),
self.mainWindowPos.y()))
config.set(
'mainWindow', 'size', '{},{}'.format(self.mainWindowSize.width(),
self.mainWindowSize.height()))
config.write(channel)
def save(self):
with open(self.fileName, 'w') as configfile:
self.dump(configfile)
def setMainWindowPos(self, pos):
self.mainWindowPos = pos
def setMainWindowSize(self, size):
self.mainWindowSize = size
def getMainWindowPos(self):
return self.mainWindowPos
def getMainWindowSize(self):
return self.mainWindowSize
def getTzIndex(self):
return self.tzIdx
def setTzIdx(self, idx):
self.tzIdx = idx
def loadAvatar(self, fileName):
self.avatar.load(fileName)
self.avatar = self.avatar.scaled(QSize(128, 58))
def test_size_hint(self, container):
assert container.sizeHint() == QSize(23, 42)
def thumbnails(self) -> dict:
return {'INDEX': QSize(100, 70), 'TIMELINE': QSize(105, 60)}
def sizeHint(self) -> QSize:
# return QSize(500, sum(map(lambda x: x.sizeHint().height(), self._item_list)))
return QSize(
500, sum(map(lambda x: x.sizeHint().height(), self._item_list)))
def minimumSizeHint(self):
"""Set the minimum height to the text height plus some padding."""
padding = config.get('ui', 'statusbar-padding')
width = super().minimumSizeHint().width()
height = self.fontMetrics().height() + padding.top + padding.bottom
return QSize(width, height)
def __init__(self, debug, parent=None):
"""Constructor for CrashDialog.
Args:
debug: Whether --debug was given.
"""
super().__init__(parent)
# We don't set WA_DeleteOnClose here as on an exception, we'll get
# closed anyways, and it only could have unintended side-effects.
self._crash_info = []
self._btn_box = None
self._btn_report = None
self._btn_cancel = None
self._lbl = None
self._paste_text = None
self.setWindowTitle("Whoops!")
self.resize(QSize(640, 600))
self._vbox = QVBoxLayout(self)
self._paste_client = pastebin.PastebinClient(self)
self._pypi_client = autoupdate.PyPIVersionClient(self)
self._init_text()
contact = QLabel(
"I'd like to be able to follow up with you, to keep "
"you posted on the status of this crash and get more "
"information if I need it - how can I contact you?",
wordWrap=True)
self._vbox.addWidget(contact)
self._contact = QTextEdit(tabChangesFocus=True, acceptRichText=False)
try:
state = objreg.get('state-config')
try:
self._contact.setPlainText(state['general']['contact-info'])
except KeyError:
self._contact.setPlaceholderText("Mail or IRC nickname")
except Exception:
log.misc.exception("Failed to get contact information!")
self._contact.setPlaceholderText("Mail or IRC nickname")
self._vbox.addWidget(self._contact, 2)
info = QLabel("What were you doing when this crash/bug happened?")
self._vbox.addWidget(info)
self._info = QTextEdit(tabChangesFocus=True, acceptRichText=False)
self._info.setPlaceholderText("- Opened http://www.example.com/\n"
"- Switched tabs\n"
"- etc...")
self._vbox.addWidget(self._info, 5)
self._vbox.addSpacing(15)
self._debug_log = QTextEdit(tabChangesFocus=True,
acceptRichText=False,
lineWrapMode=QTextEdit.NoWrap)
self._debug_log.hide()
info = QLabel(
"<i>You can edit the log below to remove sensitive "
"information.</i>",
wordWrap=True)
info.hide()
self._fold = miscwidgets.DetailFold("Show log", self)
self._fold.toggled.connect(self._debug_log.setVisible)
self._fold.toggled.connect(info.setVisible)
if debug:
self._fold.toggle()
self._vbox.addWidget(self._fold)
self._vbox.addWidget(info)
self._vbox.addWidget(self._debug_log, 10)
self._vbox.addSpacing(15)
self._init_checkboxes()
self._init_info_text()
self._init_buttons()
def _setupUi(self):
self.setWindowTitle(tr("Schedule Info"))
self.resize(469, 416)
self.setModal(True)
self.verticalLayout_2 = QVBoxLayout(self)
self.tabWidget = QTabWidget(self)
self.tab = QWidget()
self.formLayout = QFormLayout(self.tab)
self.formLayout.setFieldGrowthPolicy(QFormLayout.ExpandingFieldsGrow)
self.label_2 = QLabel(tr("Start Date:"))
self.formLayout.setWidget(0, QFormLayout.LabelRole, self.label_2)
self.startDateEdit = DateEdit(self.tab)
self.startDateEdit.setMaximumSize(QSize(120, 16777215))
self.formLayout.setWidget(0, QFormLayout.FieldRole, self.startDateEdit)
self.label_7 = QLabel(tr("Repeat Type:"))
self.formLayout.setWidget(1, QFormLayout.LabelRole, self.label_7)
self.repeatTypeComboBoxView = QComboBox(self.tab)
self.formLayout.setWidget(1, QFormLayout.FieldRole,
self.repeatTypeComboBoxView)
self.label_8 = QLabel(tr("Every:"))
self.formLayout.setWidget(2, QFormLayout.LabelRole, self.label_8)
self.horizontalLayout_2 = QHBoxLayout()
self.repeatEverySpinBox = QSpinBox(self.tab)
self.repeatEverySpinBox.setMinimum(1)
self.horizontalLayout_2.addWidget(self.repeatEverySpinBox)
self.repeatEveryDescLabel = QLabel(self.tab)
self.horizontalLayout_2.addWidget(self.repeatEveryDescLabel)
self.formLayout.setLayout(2, QFormLayout.FieldRole,
self.horizontalLayout_2)
self.label_9 = QLabel(tr("Stop Date:"))
self.formLayout.setWidget(3, QFormLayout.LabelRole, self.label_9)
self.stopDateEdit = DateEdit(self.tab, is_clearable=True)
self.stopDateEdit.setMaximumSize(QSize(120, 16777215))
self.formLayout.setWidget(3, QFormLayout.FieldRole, self.stopDateEdit)
self.label_3 = QLabel(tr("Description:"))
self.formLayout.setWidget(4, QFormLayout.LabelRole, self.label_3)
self.descriptionEdit = DescriptionEdit(self.model.completable_edit,
self.tab)
self.formLayout.setWidget(4, QFormLayout.FieldRole,
self.descriptionEdit)
self.label_4 = QLabel(tr("Payee:"))
self.formLayout.setWidget(5, QFormLayout.LabelRole, self.label_4)
self.payeeEdit = PayeeEdit(self.model.completable_edit, self.tab)
self.formLayout.setWidget(5, QFormLayout.FieldRole, self.payeeEdit)
self.label_5 = QLabel(tr("Check #:"))
self.formLayout.setWidget(6, QFormLayout.LabelRole, self.label_5)
self.checkNoEdit = QLineEdit(self.tab)
self.checkNoEdit.setMaximumSize(QSize(120, 16777215))
self.formLayout.setWidget(6, QFormLayout.FieldRole, self.checkNoEdit)
self.amountLabel = QLabel(tr("Transfers:"))
self.formLayout.setWidget(7, QFormLayout.LabelRole, self.amountLabel)
self.splitTableView = TableView(self.tab)
self.splitTableView.setMinimumSize(QSize(355, 0))
self.splitTableView.setAcceptDrops(True)
self.splitTableView.setDragEnabled(True)
self.splitTableView.setDragDropOverwriteMode(False)
self.splitTableView.setDragDropMode(QAbstractItemView.InternalMove)
self.splitTableView.setSelectionBehavior(QAbstractItemView.SelectRows)
self.splitTableView.horizontalHeader().setDefaultSectionSize(40)
self.splitTableView.verticalHeader().setVisible(False)
self.splitTableView.verticalHeader().setDefaultSectionSize(18)
self.formLayout.setWidget(7, QFormLayout.FieldRole,
self.splitTableView)
self.widget = QWidget(self.tab)
sizePolicy = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.widget.sizePolicy().hasHeightForWidth())
self.widget.setSizePolicy(sizePolicy)
self.horizontalLayout_6 = QHBoxLayout(self.widget)
self.horizontalLayout_6.setContentsMargins(0, 0, 0, 0)
spacerItem = QSpacerItem(40, 20, QSizePolicy.Expanding,
QSizePolicy.Minimum)
self.horizontalLayout_6.addItem(spacerItem)
self.addSplitButton = QPushButton(self.widget)
icon = QIcon()
icon.addPixmap(QPixmap(':/plus_8'), QIcon.Normal, QIcon.Off)
self.addSplitButton.setIcon(icon)
self.horizontalLayout_6.addWidget(self.addSplitButton)
self.removeSplitButton = QPushButton(self.widget)
icon1 = QIcon()
icon1.addPixmap(QPixmap(':/minus_8'), QIcon.Normal, QIcon.Off)
self.removeSplitButton.setIcon(icon1)
self.horizontalLayout_6.addWidget(self.removeSplitButton)
self.formLayout.setWidget(8, QFormLayout.FieldRole, self.widget)
self.tabWidget.addTab(self.tab, tr("Info"))
self.tab_3 = QWidget()
self.horizontalLayout_5 = QHBoxLayout(self.tab_3)
self.notesEdit = QPlainTextEdit(self.tab_3)
self.horizontalLayout_5.addWidget(self.notesEdit)
self.tabWidget.addTab(self.tab_3, tr("Notes"))
self.verticalLayout_2.addWidget(self.tabWidget)
self.buttonBox = QDialogButtonBox(self)
self.buttonBox.setOrientation(Qt.Horizontal)
self.buttonBox.setStandardButtons(QDialogButtonBox.Cancel
| QDialogButtonBox.Save)
self.verticalLayout_2.addWidget(self.buttonBox)
self.label_2.setBuddy(self.startDateEdit)
self.label_7.setBuddy(self.repeatTypeComboBoxView)
self.label_3.setBuddy(self.descriptionEdit)
self.label_4.setBuddy(self.payeeEdit)
self.label_5.setBuddy(self.checkNoEdit)
self.tabWidget.setCurrentIndex(0)
def Button(parent=None):
btn = PathButton(parent)
btn.setIsDownColor(QColor())
btn.setFocusPolicy(Qt.NoFocus)
btn.setSize(QSize(26, 26))
return btn
def minimumSizeHint(self):
return QSize(1, self.fontMetrics().height())
def newConfigurationBox(self,info,iconName,title,alternative_type):
hbox=QHBoxLayout()
hbox.setContentsMargins(0,0,0,0)
hbox.setSpacing(0)
icon=QLabel()
box_image=self.core.rsrc_dir+iconName
#pixmap=QtGui.QPixmap(box_image).scaled(70,70)
pixmap=QPixmap(box_image)
icon.setPixmap(pixmap)
icon.setAlignment(Qt.AlignCenter|Qt.AlignVCenter)
icon.setMinimumSize(90,100)
icon.setMaximumSize(90,100)
icon.current=False
icon.alternative_type=alternative_type
hbox.addWidget(icon)
name=QLabel()
name.setText(title)
name.setAlignment(Qt.AlignLeft|Qt.AlignVCenter)
if self.count<self.num_separators:
name.setStyleSheet("font:10pt;border:3px solid silver;border-top:0px;border-right:0px;border-left:0px;margin-top:0px;")
else:
name.setStyleSheet("font:10pt")
name.current=False
name.alternative_type=alternative_type
hbox.addWidget(name,-1)
try:
default=QLabel()
for item in info:
if info[item]["default"]:
text=item
except:
text=""
default.setText(text)
default.setAlignment(Qt.AlignRight|Qt.AlignVCenter)
if self.count<self.num_separators:
default.setStyleSheet("font:10pt;padding:15px;border:3px solid silver;border-top:0px;border-right:0px;border-left:0px;margin-top:0px;")
else:
default.setStyleSheet("font:10pt;padding:15px")
default.setMinimumHeight(100)
default.setMaximumHeight(100)
default.current=True
default.alternative_type=alternative_type
hbox.addWidget(default)
menu =QMenu()
for item in info:
action = menu.addAction(item)
action.triggered.connect(lambda chk, item=item: self.itemClicked(item,info[item]["cmd"],alternative_type))
pushbutton =QToolButton()
icn=QIcon.fromTheme(os.path.join(settings.ICONS_THEME,"editor.svg"))
pushbutton.setIcon(icn)
pushbutton.setIconSize(QSize(16,16))
pushbutton.setToolTip(_("Click to select an option"))
pushbutton.clicked.connect(lambda:self.buttonPress(alternative_type))
pushbutton.current=False
pushbutton.alternative_type=alternative_type
pushbutton.setPopupMode(QToolButton.InstantPopup)
pushbutton.setStyleSheet("margin-right:15px")
pushbutton.setMaximumSize(40,30)
self.setMenu(menu,alternative_type)
hbox.addWidget(pushbutton)
self.boxConfigurations.addLayout(hbox)
def __init__(self):
"""Initial configuration."""
super().__init__()
# GLOBAL VARIABLES
# graph variables
self.graph = Graph()
self.selected_node = None
self.vertex_positions = []
self.selected_vertex = None
# offset of the mouse from the position of the currently dragged node
self.mouse_drag_offset = None
# position of the mouse; is updated when the mouse moves
self.mouse_x = -1
self.mouse_y = -1
# variables for visualizing the graph
self.node_radius = 20
self.weight_rectangle_size = self.node_radius / 3
self.arrowhead_size = 4
self.arrow_separation = pi / 7
self.selected_color = Qt.red
self.regular_node_color = Qt.white
self.regular_vertex_weight_color = Qt.black
# limit the displayed length of labels for each node
self.node_label_limit = 10
# UI variables
self.font_family = "Times New Roman"
self.font_size = 18
self.layout_margins = 8
self.layout_item_spacing = 2 * self.layout_margins
# canvas positioning - scale and translation
self.scale = 1
self.scale_coefficient = 1.1 # by how much the scale changes on scroll
self.translation = [0, 0]
# angle (in degrees) by which all of the nodes rotate
self.node_rotation_angle = 15
# TIMERS
# runs the simulation 60 times a second (1000/60 ~= 16ms)
self.simulation_timer = QTimer(
interval=16, timeout=self.perform_simulation_iteration)
# WIDGETS
self.canvas = QFrame(self, minimumSize=QSize(0, 400))
self.canvas_size = None
self.canvas.resizeEvent = self.adjust_canvas_translation
# toggles between directed/undirected graphs
self.directed_toggle_button = QPushButton(
text="undirected", clicked=self.toggle_directed_graph)
# for showing the labels of the nodes
self.labels_checkbox = QCheckBox(text="labels")
# sets, whether the graph is weighted or not
self.weighted_checkbox = QCheckBox(text="weighted",
clicked=self.set_weighted_graph)
# enables/disables forces (True by default - they're fun!)
self.forces_checkbox = QCheckBox(text="forces", checked=True)
# input of the labels and vertex weights
self.input_line_edit = QLineEdit(
enabled=self.labels_checkbox.isChecked(),
textChanged=self.input_line_edit_changed)
# displays information about the app
self.about_button = QPushButton(text="?",
clicked=self.show_help,
sizePolicy=QSizePolicy(
QSizePolicy.Fixed,
QSizePolicy.Fixed))
# imports/exports the current graph
self.import_graph_button = QPushButton(text="import",
clicked=self.import_graph)
self.export_graph_button = QPushButton(text="export",
clicked=self.export_graph)
# WIDGET LAYOUT
self.main_v_layout = QVBoxLayout(self, margin=0)
self.main_v_layout.addWidget(self.canvas)
self.option_h_layout = QHBoxLayout(self, margin=self.layout_margins)
self.option_h_layout.addWidget(self.directed_toggle_button)
self.option_h_layout.addSpacing(self.layout_item_spacing)
self.option_h_layout.addWidget(self.weighted_checkbox)
self.option_h_layout.addSpacing(self.layout_item_spacing)
self.option_h_layout.addWidget(self.labels_checkbox)
self.option_h_layout.addSpacing(self.layout_item_spacing)
self.option_h_layout.addWidget(self.forces_checkbox)
self.option_h_layout.addSpacing(self.layout_item_spacing)
self.option_h_layout.addWidget(self.input_line_edit)
self.io_h_layout = QHBoxLayout(self, margin=self.layout_margins)
self.io_h_layout.addWidget(self.import_graph_button)
self.io_h_layout.addSpacing(self.layout_item_spacing)
self.io_h_layout.addWidget(self.export_graph_button)
self.io_h_layout.addSpacing(self.layout_item_spacing)
self.io_h_layout.addWidget(self.about_button)
self.main_v_layout.addLayout(self.option_h_layout)
self.main_v_layout.addSpacing(-self.layout_margins)
self.main_v_layout.addLayout(self.io_h_layout)
self.setLayout(self.main_v_layout)
# WINDOW SETTINGS
self.setWindowTitle('Graph Visualizer')
self.setFont(QFont(self.font_family, self.font_size))
self.setWindowIcon(QIcon("icon.ico"))
self.show()
# start the simulation
self.simulation_timer.start()
def _set_icon_size(self):
"""Set the tab bar favicon size."""
size = self.fontMetrics().height() - 2
size = int(size * config.val.tabs.favicons.scale)
self.setIconSize(QSize(size, size))
def __init__(self, font, parent=None):
super().__init__(parent)
self.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Preferred)
self._font = font
self._glyph = None
self._shouldEditLastName = False
glyphGroup = GroupBox(self)
glyphGroup.setTitle(self.tr("Glyph"))
glyphLayout = QGridLayout()
zeroWidth = self.fontMetrics().width('0')
columnOneWidth = zeroWidth * (5 + 2 * platformSpecific.widen())
nameLabel = RLabel(self.tr("Name"), self)
self.nameEdit = QLineEdit(self)
self.nameEdit.editingFinished.connect(self.writeGlyphName)
unicodesLabel = RLabel(self.tr("Unicode"), self)
self.unicodesEdit = QLineEdit(self)
self.unicodesEdit.editingFinished.connect(self.writeUnicodes)
unicodesRegExp = QRegularExpression(
"(|([a-fA-F0-9]{4,6})( ([a-fA-F0-9]{4,6}))*)")
unicodesValidator = QRegularExpressionValidator(unicodesRegExp, self)
self.unicodesEdit.setValidator(unicodesValidator)
widthLabel = RLabel(self.tr("Width"), self)
self.widthEdit = NumberBox(self)
self.widthEdit.setMaximumWidth(columnOneWidth)
self.widthEdit.editingFinished.connect(self.writeWidth)
leftMarginLabel = RLabel(self.tr("Left"), self)
self.leftMarginEdit = NumberBox(self)
self.leftMarginEdit.setMaximumWidth(columnOneWidth)
self.leftMarginEdit.editingFinished.connect(self.writeLeftMargin)
rightMarginLabel = RLabel(self.tr("Right"), self)
self.rightMarginEdit = NumberBox(self)
self.rightMarginEdit.setMaximumWidth(columnOneWidth)
self.rightMarginEdit.editingFinished.connect(self.writeRightMargin)
markColorLabel = RLabel(self.tr("Flag"), self)
self.markColorWidget = ColorVignette(self)
self.markColorWidget.colorChanged.connect(self.writeMarkColor)
self.markColorWidget.setMaximumWidth(columnOneWidth)
line = 0
glyphLayout.addWidget(nameLabel, line, 0)
glyphLayout.addWidget(self.nameEdit, line, 1, 1, 3)
line += 1
glyphLayout.addWidget(unicodesLabel, line, 0)
glyphLayout.addWidget(self.unicodesEdit, line, 1, 1, 3)
line += 1
glyphLayout.addWidget(widthLabel, line, 0)
glyphLayout.addWidget(self.widthEdit, line, 1)
line += 1
glyphLayout.addWidget(leftMarginLabel, line, 0)
glyphLayout.addWidget(self.leftMarginEdit, line, 1)
glyphLayout.addWidget(rightMarginLabel, line, 2)
glyphLayout.addWidget(self.rightMarginEdit, line, 3)
line += 1
glyphLayout.addWidget(markColorLabel, line, 0)
glyphLayout.addWidget(self.markColorWidget, line, 1)
glyphLayout.setSpacing(8)
glyphGroup.setChildLayout(glyphLayout)
transformGroup = GroupBox(self)
transformGroup.setTitle(self.tr("Transform"))
transformLayout = QGridLayout()
columnTwoWidth = zeroWidth * (8 + 2 * platformSpecific.widen())
self.alignmentWidget = GlyphAlignmentWidget(self)
self.alignmentWidget.setAlignment(4)
# TODO: should this be implemented for partial selection?
invScaleButton = Button(self)
invScaleButton.setDrawingCommands(icons.dc_invscale())
invScaleButton.setToolTip(self.tr("Scale down selection"))
invScaleButton.clicked.connect(self.scale)
invScaleButton.setProperty("inverted", True)
self.scaleXEdit = SpinBox(self)
self.scaleXEdit.setMaximumWidth(columnTwoWidth)
self.scaleXEdit.setSuffix("%")
self.scaleXEdit.setMaximum(500)
self.scaleXEdit.setMinimum(-500)
self.scaleXEdit.setValue(2)
scaleButton = Button(self)
scaleButton.setDrawingCommands(icons.dc_scale())
scaleButton.setToolTip(self.tr("Scale up selection"))
scaleButton.clicked.connect(self.scale)
self.scaleYEdit = SpinBox(self)
self.scaleYEdit.setMaximumWidth(columnTwoWidth)
self.scaleYEdit.setSuffix("%")
self.scaleYEdit.setMaximum(500)
self.scaleYEdit.setMinimum(-500)
self.scaleYEdit.setValue(2)
rotateButton = Button(self)
rotateButton.setDrawingCommands(icons.dc_rotate())
rotateButton.setToolTip(self.tr("Rotate selection counter-clockwise"))
rotateButton.clicked.connect(self.rotate)
self.rotateEdit = SpinBox(self)
self.rotateEdit.setMaximumWidth(columnTwoWidth)
self.rotateEdit.setSuffix("º")
# XXX: calling stepDown() from zero shows 359.999
self.rotateEdit.setMaximum(359.999)
self.rotateEdit.setValue(40)
self.rotateEdit.setWrapping(True)
invRotateButton = Button(self)
invRotateButton.setDrawingCommands(icons.dc_invrotate())
invRotateButton.setToolTip(self.tr("Rotate selection clockwise"))
invRotateButton.clicked.connect(self.rotate)
invRotateButton.setProperty("inverted", True)
invSkewButton = Button(self)
invSkewButton.setDrawingCommands(icons.dc_invskew())
invSkewButton.setToolTip(self.tr("Skew selection counter-clockwise"))
invSkewButton.clicked.connect(self.skew)
invSkewButton.setProperty("inverted", True)
self.skewEdit = SpinBox(self)
self.skewEdit.setMaximumWidth(columnTwoWidth)
self.skewEdit.setSuffix("º")
self.skewEdit.setMaximum(100)
self.skewEdit.setValue(6)
self.skewEdit.setWrapping(True)
skewButton = Button(self)
skewButton.setDrawingCommands(icons.dc_skew())
skewButton.setToolTip(self.tr("Skew selection clockwise"))
skewButton.clicked.connect(self.skew)
snapButton = Button(self)
snapButton.setDrawingCommands(icons.dc_snap())
snapButton.setToolTip(self.tr("Snap selection to precision"))
snapButton.clicked.connect(self.snap)
self.snapEdit = SpinBox(self)
self.snapEdit.setMaximumWidth(columnTwoWidth)
self.snapEdit.setValue(1)
unionButton = Button(self)
unionButton.setDrawingCommands(icons.dc_union())
unionButton.setToolTip(self.tr("Remove selection overlap"))
unionButton.clicked.connect(self.removeOverlap)
subtractButton = Button(self)
subtractButton.setDrawingCommands(icons.dc_subtract())
subtractButton.setToolTip(self.tr("Subtract selected or top contour"))
subtractButton.clicked.connect(self.subtract)
intersectButton = Button(self)
intersectButton.setDrawingCommands(icons.dc_intersect())
intersectButton.setToolTip(
self.tr("Intersect selected or top contour"))
intersectButton.clicked.connect(self.intersect)
xorButton = Button(self)
xorButton.setDrawingCommands(icons.dc_xor())
xorButton.setToolTip(self.tr("Xor selected or top contour"))
xorButton.clicked.connect(self.xor)
hMirrorButton = Button()
hMirrorButton.setDrawingCommands(icons.dc_hmirror())
hMirrorButton.setToolTip(self.tr("Mirror selection horizontally"))
hMirrorButton.clicked.connect(self.hMirror)
vMirrorButton = Button()
vMirrorButton.setDrawingCommands(icons.dc_vmirror())
vMirrorButton.setToolTip(self.tr("Mirror selection vertically"))
vMirrorButton.clicked.connect(self.vMirror)
alignHLeftButton = Button(self)
alignHLeftButton.setDrawingCommands(icons.dc_alignhleft())
alignHLeftButton.setToolTip(self.tr("Push selection left"))
alignHLeftButton.clicked.connect(self.alignHLeft)
alignHCenterButton = Button(self)
alignHCenterButton.setDrawingCommands(icons.dc_alignhcenter())
alignHCenterButton.setToolTip(
self.tr("Push selection to horizontal center"))
alignHCenterButton.clicked.connect(self.alignHCenter)
alignHRightButton = Button(self)
alignHRightButton.setDrawingCommands(icons.dc_alignhright())
alignHRightButton.setToolTip(self.tr("Push selection right"))
alignHRightButton.clicked.connect(self.alignHRight)
alignVTopButton = Button(self)
alignVTopButton.setDrawingCommands(icons.dc_alignvtop())
alignVTopButton.setToolTip(self.tr("Push selection top"))
alignVTopButton.clicked.connect(self.alignVTop)
alignVCenterButton = Button(self)
alignVCenterButton.setDrawingCommands(icons.dc_alignvcenter())
alignVCenterButton.setToolTip(
self.tr("Push selection to vertical center"))
alignVCenterButton.clicked.connect(self.alignVCenter)
alignVBottomButton = Button(self)
alignVBottomButton.setDrawingCommands(icons.dc_alignvbottom())
alignVBottomButton.setToolTip(self.tr("Push selection bottom"))
alignVBottomButton.clicked.connect(self.alignVBottom)
buttonsLayout = QGridLayout()
buttonsLayout.setSpacing(0)
line = 0
buttonsLayout.addWidget(unionButton, line, 0)
buttonsLayout.addWidget(subtractButton, line, 1)
buttonsLayout.addWidget(intersectButton, line, 2)
buttonsLayout.addWidget(xorButton, line, 3)
buttonsLayout.addWidget(hMirrorButton, line, 4)
buttonsLayout.addWidget(vMirrorButton, line, 5)
line += 1
buttonsLayout.addWidget(alignHLeftButton, line, 0)
buttonsLayout.addWidget(alignHCenterButton, line, 1)
buttonsLayout.addWidget(alignHRightButton, line, 2)
buttonsLayout.addWidget(alignVTopButton, line, 3)
buttonsLayout.addWidget(alignVCenterButton, line, 4)
buttonsLayout.addWidget(alignVBottomButton, line, 5)
line = 0
transformLayout.addWidget(self.alignmentWidget, line, 1)
line += 1
transformLayout.addWidget(invScaleButton, line, 0)
transformLayout.addWidget(self.scaleXEdit, line, 1)
transformLayout.addWidget(scaleButton, line, 2)
line += 1
transformLayout.addWidget(self.scaleYEdit, line, 1)
line += 1
transformLayout.addWidget(rotateButton, line, 0)
transformLayout.addWidget(self.rotateEdit, line, 1)
transformLayout.addWidget(invRotateButton, line, 2)
line += 1
transformLayout.addWidget(invSkewButton, line, 0)
transformLayout.addWidget(self.skewEdit, line, 1)
transformLayout.addWidget(skewButton, line, 2)
line += 1
transformLayout.addWidget(snapButton, line, 0)
transformLayout.addWidget(self.snapEdit, line, 1)
line += 1
transformLayout.addLayout(buttonsLayout, line, 0, 1, 3)
transformLayout.setSpacing(4)
transformGroup.setChildLayout(transformLayout)
layersGroup = GroupBox(self)
layersGroup.setTitle(self.tr("Layers"))
layersLayout = QGridLayout()
self.layerSetView = ListView(self)
# QListView has no proper sizeHint by default
self.layerSetView.sizeHint = lambda: QSize(150, 150)
self.layerSetView.setDragEnabled(True)
# HACK: we need this to setup headers and signals
self.layerSetView.setList([[None, None, None]])
hdr = self.layerSetView.header()
hdr.setMinimumSectionSize(20)
hdr.setStretchLastSection(False)
hdr.setSectionResizeMode(QHeaderView.Fixed)
hdr.setSectionResizeMode(1, QHeaderView.Stretch)
hdr.resizeSection(0, 20)
hdr.resizeSection(2, 34)
self.layerSetView.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.layerSetView.dataDropped.connect(self.writeLayerOrder)
self.layerSetView.valueChanged.connect(self.writeLayerAttribute)
layerAddButton = Button(self)
layerAddButton.setDrawingCommands(icons.dc_plus())
layerAddButton.setToolTip(self.tr("Add a layer"))
layerAddButton.clicked.connect(self.addLayer)
layerRemoveButton = Button(self)
layerRemoveButton.setDrawingCommands(icons.dc_minus())
layerRemoveButton.setToolTip(self.tr("Remove selected layer"))
layerRemoveButton.clicked.connect(self.removeLayer)
layerDownButton = Button(self)
layerDownButton.setDrawingCommands(icons.dc_down())
layerDownButton.setToolTip(self.tr("Lower selected layer"))
layerDownButton.clicked.connect(lambda: self.layerOffset(1))
layerUpButton = Button(self)
layerUpButton.setDrawingCommands(icons.dc_up())
layerUpButton.setToolTip(self.tr("Raise selected layer"))
layerUpButton.clicked.connect(lambda: self.layerOffset(-1))
spacer = QWidget()
spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
layersLayout.setSpacing(0)
line = 0
layersLayout.addWidget(self.layerSetView, line, 0, 1, 5)
line += 1
layersLayout.addWidget(layerAddButton, line, 0)
layersLayout.addWidget(layerRemoveButton, line, 1)
layersLayout.addWidget(spacer, line, 2)
layersLayout.addWidget(layerDownButton, line, 3)
layersLayout.addWidget(layerUpButton, line, 4)
layersGroup.setChildLayout(layersLayout)
mainLayout = QVBoxLayout()
mainLayout.addWidget(glyphGroup)
mainLayout.addWidget(transformGroup)
mainLayout.addWidget(layersGroup)
mainLayout.addWidget(FillWidget())
mainLayout.setContentsMargins(0, 0, 0, 0)
mainLayout.setSpacing(2)
self.setLayout(mainLayout)
self._updateLayerAttributes()
self._subscribeToFont(self._font)
# re-export signal
self.activeLayerModified = self.layerSetView.selectionChanged_
def initField(self):
self.timer = QBasicTimer()
self.setFocusPolicy(Qt.StrongFocus)
self.setMinimumSize(QSize(240, 240))
self.setMaximumSize(QSize(240, 240))
def sizeHint(self):
self.ensurePolished()
return QSize(20, 20)
def __init__(self, serial_com):
QMainWindow.__init__(self)
self.setMaximumSize(QSize(400, 600))
self.setMinimumSize(QSize(400, 600))
self.setWindowTitle("COM")
self.addressMyDist = ["1", "0"]
self.transmit_counter = 0
self.serial_com = serial_com
self.fromLabel = QLabel(self)
self.fromLabel.setText('From:')
self.fromLabel.move(20, 400)
self.line = QTextEdit(self)
self.line.move(20, 0)
self.line.resize(355, 120)
self.pybutton = QPushButton('Send', self)
self.pybutton.clicked.connect(self.clickMethod)
self.pybutton.resize(355, 32)
self.pybutton.move(20, 120)
self.pybutton.setEnabled(False)
self.recieveLabel = QLabel(self)
self.recieveLabel.setText("R: 0")
self.recieveLabel.move(20, 300)
self.transmitLabel = QLabel(self)
self.transmitLabel.setText("T: 0")
self.transmitLabel.move(20, 340)
self.setDestAddressLabel = QLabel(self)
self.setDestAddressLabel.setText("Destination address: ")
self.setDestAddressLabel.move(60, 300)
self.setDestAddress = QComboBox(self)
self.setDestAddress.move(200, 300)
self.setDestAddress.addItems(
["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B"])
self.setDestAddress.currentIndexChanged.connect(
self.selectionChangeDestAddress)
self.setMyAddressLabel = QLabel(self)
self.setMyAddressLabel.setText("My address: ")
self.setMyAddressLabel.move(60, 340)
self.setMyAddress = QComboBox(self)
self.setMyAddress.move(200, 340)
self.setMyAddress.addItems(
["1", "0", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B"])
self.setMyAddress.currentIndexChanged.connect(
self.selectionChangeMyAddress)
self.errorLabel = QLabel(self)
self.errorLabel.setText("")
self.errorLabel.move(20, 460)
self.errorLabel.setStyleSheet('color: red')
self.xonLabel = QLabel(self)
self.xonLabel.setText("XOFF on reciever")
self.xonLabel.move(150, 370)
self.output = QTextEdit(self)
self.output.move(20, 200)
self.output.setReadOnly(True)
self.output.resize(355, 100)
self.comInput = QComboBox(self)
self.comInput.move(20, 430)
self.comInput.addItems([
"---", "COM1", "COM2", "COM3", "COM4", "COM5", "COM6", "COM7",
"COM8", "COM9"
])
self.comInput.currentIndexChanged.connect(self.selectionChangeInput)
self.comState = QComboBox(self)
self.comState.move(150, 430)
self.comState.addItems(["Close port", "Open port"])
self.comState.currentIndexChanged.connect(self.selectionChangeState)
self.inboxLabel = QLabel(self)
self.inboxLabel.setText('All inboxes:')
self.inboxLabel.move(20, 170)
self.xon = QPushButton("send XON", self)
self.xon.clicked.connect(self.xonEnable)
self.xon.move(20, 370)
self.debugState = QTextEdit(self)
self.debugState.move(20, 490)
self.debugState.setReadOnly(True)
self.debugState.resize(355, 70)
def init_buttons(self):
"""
Инициализация кнопок
"""
# кнопка загрузки изображения
btn = QPushButton(self)
btn.setText(' Открыть')
btn.setIcon(QIcon(self._upload_img_icon_path))
btn.setIconSize(QSize(20, 20))
btn.clicked.connect(self.image_uploaded)
self._upload_img_button = btn
# кнопка старта алгоритма
start_btn = QPushButton(self)
start_btn.setDisabled(True)
start_btn.setIcon(QIcon(self._start_icon_path))
start_btn.setIconSize(QSize(20, 20))
start_btn.setText(' Найти')
start_btn.clicked.connect(self.start_btn_pressed)
self._start_button = start_btn
# кнопки выбранных фишек
self._chosen_chips_buttons = []
for i in range(7):
btn = QPushButton(self)
btn.setObjectName("chosen_letters")
btn.setDisabled(True)
self._chosen_chips_buttons.append(btn)
# расчет кол-ва разновидностей фишек
# со звездочкой 33, без нее 32
if self._asterisk_active:
self._chips_varieties = 33
else:
self._chips_varieties = 32
# кнопки с фишками-буквами
self._letters_buttons = []
self._letters_on_buttons = []
for i in range(self._chips_varieties):
if i == 32:
letter_on_button = '*'
else:
letter_on_button = chr(1072 + i)
self._letters_on_buttons.append(letter_on_button)
btn = QPushButton(self)
btn.setObjectName("letters")
btn.setText(self._letters_on_buttons[i].upper())
btn.setDisabled(True)
btn.clicked.connect(self.letter_btn_pressed)
self._letters_buttons.append(btn)
# пустые кнопки в конце клавиатуры
for i in range(36 - self._chips_varieties):
btn = QPushButton(self)
btn.setObjectName("letters")
btn.setDisabled(True)
self._empty_buttons.append(btn)
# кнопка сброса счетчика
drop_button = QPushButton(self)
drop_button.setDisabled(True)
drop_button.setIcon(QIcon(self._drop_img_icon_path))
drop_button.setIconSize(QSize(20, 20))
drop_button.setObjectName("drop")
drop_button.clicked.connect(self.drop_btn_pressed)
self._drop_button = drop_button
def sizeHint(self):
return QSize(1270, 800)
def __init__(self, fileName='shadow.ini'):
self.fileName = fileName
self.tzIdx = 0
self.mainWindowSize = QSize(1200, 700)
self.mainWindowPos = QPoint(240, 200)
def sizeHint(self):
return QSize(23, 42)
def mousePressEvent(self, event):
"""
:type event: QMouseEvent
:param event:
:return:
"""
if GetImageHeight() == 0:
return
if event.button() == Qt.LeftButton:
self.snapped = True
self.pressPos = self.dragPos = event.pos()
self.tapTimer.stop()
self.tapTimer.start(100, self)
if (not vut.IsPointOnScreen(event.x(), event.y(), self.surface)):
self.UpdateSurface()
return
# point drawer
if self.gt is not None and self._interaction.pointDrawer:
Longitude, Latitude, Altitude = vut.GetPointCommonCoords(
event, self.surface)
pointIndex = len(self.drawPtPos) + 1
AddDrawPointOnMap(pointIndex, Longitude, Latitude, Altitude)
self.drawPtPos.append([Longitude, Latitude, Altitude])
# polygon drawer
if self.gt is not None and self._interaction.polygonDrawer:
Longitude, Latitude, Altitude = vut.GetPointCommonCoords(
event, self.surface)
self.poly_RubberBand.addPoint(QgsPointXY(Longitude, Latitude))
self.poly_coordinates.extend(QgsPointXY(Longitude, Latitude))
self.drawPolygon.append([Longitude, Latitude, Altitude])
# line drawer
if self.gt is not None and self._interaction.lineDrawer:
Longitude, Latitude, Altitude = vut.GetPointCommonCoords(
event, self.surface)
self.drawLines.append([Longitude, Latitude, Altitude])
AddDrawLineOnMap(self.drawLines)
if self._interaction.objectTracking:
self.origin = event.pos()
self.Tracking_RubberBand.setGeometry(
QRect(self.origin, QSize()))
self.Tracking_RubberBand.show()
if self._interaction.censure:
self.origin = event.pos()
self.Censure_RubberBand.setGeometry(QRect(
self.origin, QSize()))
self.Censure_RubberBand.show()
# Ruler drawer
if self.gt is not None and self._interaction.ruler:
Longitude, Latitude, Altitude = vut.GetPointCommonCoords(
event, self.surface)
self.drawRuler.append([Longitude, Latitude, Altitude])
# if not called, the paint event is not triggered.
self.UpdateSurface()
def resize(dim):
size = (QSize(dim, 666) if splitter.orientation() == Qt.Horizontal
else QSize(666, dim))
splitter.resize(size)
if splitter.size() != size:
pytest.skip("Resizing window failed")
def minimumSizeHint(self):
return QSize(800, 600)
def sizeHint(self):
return QSize(400, 400)
def setupTab1(self, tab1):
"""Basic widgets for preview panel"""
scrollContainer = QVBoxLayout()
scrollArea = QScrollArea()
scrollArea.setWidgetResizable(True)
mainWidget = QWidget()
layout = QVBoxLayout()
mainWidget.setLayout(layout)
mainWidget.setMinimumSize(QSize(420, 800))
scrollArea.setWidget(mainWidget)
scrollContainer.addWidget(scrollArea)
tab1.setLayout(scrollContainer)
# Label TextBox
group1 = QGroupBox("Text")
group1layout = QHBoxLayout()
group1.setLayout(group1layout)
layout.addWidget(group1)
layoutCol1 = QFormLayout()
layoutCol2 = QFormLayout()
group1layout.addLayout(layoutCol1)
group1layout.addLayout(layoutCol2)
label1 = QLabel(self.tr("User Name(&Id):"))
text1 = QLineEdit("default")
label1.setBuddy(text1)
label2 = QLabel(self.tr("data 1:"))
text2 = QLineEdit()
text2.setPlaceholderText(self.tr("input"))
lebel3 = QLabel(self.tr("<b>Pasword</b>:"))
text3 = QLineEdit("******")
text3.setEchoMode(QLineEdit.Password)
label4 = QLabel(self.tr("link label:"))
label5 = QLabel(
self.
tr("<a href='https://github.com/hustlei/'>github.com/hustlei</a>"))
label5.setOpenExternalLinks(True)
label6 = QLabel(self.tr("icon label:"))
label7 = QLabel("icon")
label7.setPixmap(QPixmap(":appres.img/book_address.png"))
layoutCol1.addRow(label1, text1)
layoutCol1.addRow(label2, text2)
layoutCol1.addRow(lebel3, text3)
layoutCol1.addRow(label4, label5)
layoutCol1.addRow(label6, label7)
text4 = QLineEdit()
text4.setInputMask("0000-00-00")
text5 = QLineEdit()
text5.setInputMask("HH:HH:HH:HH:HH:HH;_")
text6 = QLineEdit()
text6.setInputMask("XXXXXX")
text7 = QLineEdit()
validator1 = QDoubleValidator()
validator1.setRange(0, 100)
validator1.setDecimals(2)
text7.setValidator(validator1)
text8 = QLineEdit()
validator2 = QRegExpValidator()
reg = QRegExp("[a-zA-Z0-9]+$")
validator2.setRegExp(reg)
text8.setValidator(validator2)
layoutCol2.addRow(self.tr("Date Mask:"), text4)
layoutCol2.addRow(self.tr("Mac Mask"), text5)
layoutCol2.addRow(self.tr("String Mask"), text6)
layoutCol2.addRow(self.tr("Double Validate:"), text7)
layoutCol2.addRow(self.tr("Regexp Validate:"), text8)
text9 = QLineEdit()
text9.setPlaceholderText("input email")
text9.setToolTip("please input a email address.")
model = QStandardItemModel(0, 1, self)
completer = QCompleter(model, self)
text9.setCompleter(completer)
def textch(texts):
if "@" in texts:
return
strList = [
"@163.com", "@qq.com", "@gmail.com", "@hotmail.com", "@126.com"
]
model.removeRows(0, model.rowCount())
for i in strList:
model.insertRow(0)
model.setData(model.index(0, 0), texts + i)
text9.textChanged.connect(textch)
text10 = QLineEdit("ReadOnly")
text10.setReadOnly(True)
layoutCol1.addRow(self.tr("auto complete:"), text9)
layoutCol2.addRow("Readonly:", text10)
# Button
group2 = QGroupBox("Button")
group2layout = QVBoxLayout()
group2.setLayout(group2layout)
layout.addWidget(group2)
layoutRow1 = QHBoxLayout()
layoutRow2 = QHBoxLayout()
group2layout.addLayout(layoutRow1)
group2layout.addLayout(layoutRow2)
btn1 = QPushButton("Button")
btn2 = QPushButton("IconBtn")
btn2.setIcon(QIcon(":appres.img/yes.png"))
btn3 = QPushButton("Disabled")
btn3.setEnabled(False)
btn4 = QPushButton("Default")
btn4.setDefault(True)
btn5 = QPushButton("Switch")
btn5.setCheckable(True)
btn6 = QToolButton()
# btn6.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
btn6.setText("ToolButton")
btn6.setPopupMode(QToolButton.MenuButtonPopup)
m = QMenu()
m.addAction("action1")
m.addAction("action2")
m.addAction("action3")
btn6.setMenu(m)
btn7 = QCommandLinkButton("LinkBtn")
layoutRow1.addWidget(btn1)
layoutRow1.addWidget(btn2)
layoutRow1.addWidget(btn3)
layoutRow1.addWidget(btn4)
layoutRow2.addWidget(btn5)
layoutRow2.addWidget(btn6)
layoutRow2.addWidget(btn7)
# Checkable Item
group3 = QGroupBox("Checkable")
group3Layout = QVBoxLayout()
layoutRow1 = QHBoxLayout()
layoutRow2 = QHBoxLayout()
group3Layout.addLayout(layoutRow1)
group3Layout.addLayout(layoutRow2)
group3.setLayout(group3Layout)
layout.addWidget(group3)
group3.setCheckable(True)
ch1 = QRadioButton("Radio")
ch2 = QRadioButton("Iconradio")
ch2.setIcon(QIcon(":appres.img/Flag_blueHS.png"))
ch3 = QRadioButton("Iconradio")
ch3.setIcon(QIcon(":appres.img/Flag_greenHS.png"))
ch4 = QRadioButton("Disable")
ch4.setEnabled(False)
ch5 = QCheckBox("CheckBox")
ch6 = QCheckBox("CheckBox")
ch6.setIcon(QIcon(":appres.img/Flag_blueHS.png"))
ch7 = QCheckBox("TriState")
ch7.setTristate(True)
ch7.setCheckState(Qt.PartiallyChecked)
ch8 = QCheckBox("Disable")
ch8.setEnabled(False)
layoutRow1.addWidget(ch1)
layoutRow1.addWidget(ch2)
layoutRow1.addWidget(ch3)
layoutRow1.addWidget(ch4)
layoutRow2.addWidget(ch5)
layoutRow2.addWidget(ch6)
layoutRow2.addWidget(ch7)
layoutRow2.addWidget(ch8)
# Selecting Input
group4 = QGroupBox("Selectable")
group4Layout = QVBoxLayout()
layoutRow1 = QHBoxLayout()
group4Layout.addLayout(layoutRow1)
group4.setLayout(group4Layout)
layout.addWidget(group4)
s1 = QSpinBox()
s1.setValue(50)
s2 = QDoubleSpinBox()
s2.setRange(0, 1)
s2.setValue(0.5)
s3 = QComboBox()
s3.addItems(["aaa", "bbb", "ccc"])
s3.setEditable(True)
s3.setCurrentIndex(2)
s4 = QComboBox()
s4.addItems(["aaa", "bbb", "ccc"])
layoutRow1.addWidget(s1)
layoutRow1.addWidget(s2)
layoutRow1.addWidget(s3)
layoutRow1.addWidget(s4)
# TextEdit
group5 = QGroupBox("TextEdit")
group5Layout = QVBoxLayout()
group5.setLayout(group5Layout)
layout.addWidget(group5)
group5Layout.addWidget(
QTextEdit(
self.
tr("If you do not leave me, I will be by your side until the end."
)))
layout.addStretch(1)
def minimumSizeHint(self):
"""Return a sensible size."""
return QSize(8, 8)
def sizeHint(self):
return QSize(self.editor.lineNumberAreaWidth(), 0)
def setupTab2(self, tab2):
"""Special widgets for preview panel"""
scrollContainer = QVBoxLayout()
scrollArea = QScrollArea()
scrollArea.setWidgetResizable(True)
mainWidget = QWidget()
layout = QVBoxLayout()
mainWidget.setLayout(layout)
mainWidget.setMinimumSize(QSize(420, 800))
scrollArea.setWidget(mainWidget)
scrollContainer.addWidget(scrollArea)
tab2.setLayout(scrollContainer)
# Dialog
group0 = QGroupBox("Dialog")
group1Layout = QVBoxLayout()
layoutRow1 = QHBoxLayout()
layoutRow2 = QHBoxLayout()
group1Layout.addLayout(layoutRow1)
group1Layout.addLayout(layoutRow2)
group0.setLayout(group1Layout)
layout.addWidget(group0)
b1 = QPushButton(self.tr("Info"))
b1.clicked.connect(lambda: QMessageBox.information(
self, "Info", self.tr("This is a message."), QMessageBox.Ok,
QMessageBox.Ok))
b2 = QPushButton(self.tr("Question"))
b2.clicked.connect(lambda: QMessageBox.question(
self, "question", self.tr("Are you sure?"), QMessageBox.No |
QMessageBox.Yes, QMessageBox.Yes))
b3 = QPushButton(self.tr("Warning"))
b3.clicked.connect(lambda: QMessageBox.warning(
self, "warning", self.tr("This is a warning."), QMessageBox.No |
QMessageBox.Yes, QMessageBox.Yes))
b4 = QPushButton(self.tr("Error"))
b4.clicked.connect(lambda: QMessageBox.critical(
self, "error", self.tr("It's a error."), QMessageBox.No |
QMessageBox.Yes, QMessageBox.Yes))
b5 = QPushButton(self.tr("About"))
b5.clicked.connect(lambda: QMessageBox.about(
self, "about", self.tr("About this software")))
b6 = QPushButton(self.tr("Input")) # ,"输入对话框"))
b6.clicked.connect(lambda: QInputDialog.getInt(
self, self.tr("input"), self.tr("please input int")))
b6.clicked.connect(lambda: QInputDialog.getDouble(
self, self.tr("input"), self.tr("please input float")))
b6.clicked.connect(lambda: QInputDialog.getItem(
self, self.tr("input"), self.tr("please select"), ["aaa", "bbb"]))
b7 = QPushButton(self.tr("Color")) # ,"颜色对话框"))
b7.clicked.connect(lambda: QColorDialog.getColor())
b8 = QPushButton(self.tr("Font")) # ,"字体对话框"))
b8.clicked.connect(lambda: QFontDialog.getFont())
b9 = QPushButton(self.tr("OpenFile")) # ,"打开对话框"))
b9.clicked.connect(lambda: QFileDialog.getOpenFileName(
self, "open", "", "Text(*.txt *.text)"))
b10 = QPushButton(self.tr("SaveFile")) # ,"保存对话框"))
b10.clicked.connect(lambda: QFileDialog.getSaveFileName())
layoutRow1.addWidget(b1)
layoutRow1.addWidget(b2)
layoutRow1.addWidget(b3)
layoutRow1.addWidget(b4)
layoutRow1.addWidget(b5)
layoutRow2.addWidget(b6)
layoutRow2.addWidget(b7)
layoutRow2.addWidget(b8)
layoutRow2.addWidget(b9)
layoutRow2.addWidget(b10)
# DateTime
group1 = QGroupBox("DateTime")
group1Layout = QHBoxLayout()
layoutRow1 = QVBoxLayout()
layoutRow2 = QVBoxLayout()
group1Layout.addLayout(layoutRow1)
group1Layout.addLayout(layoutRow2)
group1.setLayout(group1Layout)
layout.addWidget(group1)
group1.setMaximumHeight(240)
dt1 = QDateEdit()
dt1.setDate(QDate.currentDate())
dt2 = QTimeEdit()
dt2.setTime(QTime.currentTime())
dt3 = QDateTimeEdit()
dt3.setDateTime(QDateTime.currentDateTime())
dt4 = QDateTimeEdit()
dt4.setCalendarPopup(True)
dt5 = QCalendarWidget()
dt5.setMaximumSize(QSize(250, 240))
layoutRow1.addWidget(dt1)
layoutRow1.addWidget(dt2)
layoutRow1.addWidget(dt3)
layoutRow1.addWidget(dt4)
layoutRow2.addWidget(dt5)
# Slider
group2 = QGroupBox("Sliders")
group2Layout = QVBoxLayout()
layoutRow1 = QHBoxLayout()
layoutRow2 = QHBoxLayout()
group2Layout.addLayout(layoutRow1)
group2Layout.addLayout(layoutRow2)
group2.setLayout(group2Layout)
layout.addWidget(group2)
slider = QSlider()
slider.setOrientation(Qt.Horizontal)
slider.setMaximum(100)
progress = QProgressBar()
slider.valueChanged.connect(progress.setValue)
slider.setValue(50)
scroll1 = QScrollBar()
scroll2 = QScrollBar()
scroll3 = QScrollBar()
scroll1.setMaximum(255)
scroll2.setMaximum(255)
scroll3.setMaximum(255)
scroll1.setOrientation(Qt.Horizontal)
scroll2.setOrientation(Qt.Horizontal)
scroll3.setOrientation(Qt.Horizontal)
c = QLabel(self.tr("Slide to change color")) # , "拖动滑块改变颜色"))
c.setAutoFillBackground(True)
c.setAlignment(Qt.AlignCenter)
# c.setStyleSheet("border:1px solid gray;")
c.setStyleSheet("background:rgba(0,0,0,100);")
def clr():
# clr=QColor(scroll1.getValue(),scroll2.getValue(),scroll3.getValue(),100)
# p=QPalette()
# p.setColor(QPalette.Background,clr)
# c.setPalette(p)
c.setStyleSheet("background: rgba({},{},{},100);".format(
scroll1.value(), scroll2.value(), scroll3.value()))
scroll1.valueChanged.connect(clr)
scroll2.valueChanged.connect(clr)
scroll3.valueChanged.connect(clr)
scroll1.setValue(128)
layoutRow1.addWidget(slider)
layoutRow1.addWidget(progress)
layCol1 = QVBoxLayout()
layCol1.addWidget(scroll1)
layCol1.addWidget(scroll2)
layCol1.addWidget(scroll3)
layoutRow2.addLayout(layCol1)
layoutRow2.addWidget(c)
# Meter
group3 = QGroupBox("Meters")
layRow = QHBoxLayout()
group3.setLayout(layRow)
layout.addWidget(group3)
dial1 = QDial()
dial2 = QDial()
dial2.setNotchesVisible(True)
dial1.valueChanged.connect(dial2.setValue)
layRow.addWidget(dial1)
layRow.addWidget(dial2)
layout.addStretch(1)
def set_font(self):
"""Set the tab bar font."""
self.setFont(config.get('fonts', 'tabbar'))
size = self.fontMetrics().height() - 2
self.setIconSize(QSize(size, size))
