def subTimeOut(self):
fontColor = self.previewSubtitle.fontColor
fontSize = (self.previewSubtitle.fontSize + 5) / 2.5
fontBold = self.previewSubtitle.bold
fontItalic = self.previewSubtitle.italic
fontShadowOffset = self.previewSubtitle.shadowOffset
for _, srtTextItem in self.srtTextItemDict.items():
srtTextItem.setDefaultTextColor(fontColor)
font = QFont()
font.setFamily("微软雅黑")
font.setPointSize(fontSize)
font.setBold(fontBold)
font.setItalic(fontItalic)
srtTextItem.setFont(font)
srtTextShadow = QGraphicsDropShadowEffect()
srtTextShadow.setOffset(fontShadowOffset)
srtTextItem.setGraphicsEffect(srtTextShadow)
try:
selected = self.subtitle.selectionModel().selection().indexes()
for x, i in enumerate(selected):
if self.subtitle.item(i.row(), x):
txt = self.subtitle.item(i.row(), x).text()
if txt:
self.srtTextItemDict[x].setPlainText('#%s：' % (x + 1) + txt)
txtSize = self.srtTextItemDict[x].boundingRect().size()
posY = self.playerWidget.size().height() - txtSize.height() * (x + 1)
posX = (self.playerWidget.size().width() - txtSize.width()) / 2
self.srtTextItemDict[x].setPos(posX, posY)
else:
self.srtTextItemDict[x].setPlainText('')
else:
self.srtTextItemDict[x].setPlainText('')
except:
pass
def css_button(qtwindow, button, color=None, shadow=True):
''' apply style to a button widget '''
# default bg color is gray 80
if color == 'red':
bg_color = 'rgb(160, 20, 20)' # red/white
tx_color = 'rgb(255, 255, 255)'
elif color == 'disabled':
bg_color = 'rgb(80, 80, 80)' # gray/gray
tx_color = 'rgb(180, 180, 180)'
elif color == 'blue':
bg_color = 'rgb(46, 134, 193)' # blue arcane/white
tx_color = 'rgb(230, 230, 230)'
else:
bg_color = 'rgb(80, 80, 80)' # gray
tx_color = 'rgb(230, 230, 230)'
css = "border-radius:3px;color:{};background:{};font-size:12px;font-family:Segoe UI;".format(
tx_color, bg_color)
button.setStyleSheet(css)
if shadow:
shadow = QGraphicsDropShadowEffect(qtwindow)
shadow.setBlurRadius(6)
shadow.setOffset(4)
shadow.setColor(QColor(20, 20, 20, 200))
button.setGraphicsEffect(shadow)
def overlay_text(
self,
message: str,
color: int,
size: int,
x: int,
y: int,
timeout: int,
font_name: str,
centered: bool,
shadow: bool,
):
gfx = QGraphicsTextItem(message)
gfx.setDefaultTextColor(decode_color(color))
font = QFont(font_name, min(50, size))
font.setStyleHint(QFont.SansSerif)
gfx.setFont(font)
if shadow:
effect = QGraphicsDropShadowEffect(gfx)
effect.setBlurRadius(0)
effect.setColor(Qt.GlobalColor.black)
effect.setOffset(1, 1)
gfx.setGraphicsEffect(effect)
if centered:
# The provided x, y is at the center of the text
bound = gfx.boundingRect()
gfx.setPos(x - (bound.width() / 2), y - (bound.height() / 2))
else:
gfx.setPos(x, y)
self._finalize_gfx(gfx, timeout)
def activate(self):
"""Adds items to scene and setup graphics effect.
Called in the constructor and when re-adding the item to the project in the context of undo/redo.
"""
scene = self._toolbox.ui.graphicsView.scene()
scene.addItem(self)
shadow_effect = QGraphicsDropShadowEffect()
shadow_effect.setOffset(1)
shadow_effect.setEnabled(False)
self.setGraphicsEffect(shadow_effect)
def __init__(self, toolbox, x, y, w, h, project_item, icon_file,
icon_color, background_color):
"""Base class for project item icons drawn in Design View.
Args:
toolbox (ToolBoxUI): QMainWindow instance
x (float): Icon x coordinate
y (float): Icon y coordinate
w (float): Icon width
h (float): Icon height
project_item (ProjectItem): Item
icon_file (str): Path to icon resource
icon_color (QColor): Icon's color
background_color (QColor): Background color
"""
super().__init__()
self._toolbox = toolbox
self._project_item = project_item
self._moved_on_scene = False
self.renderer = QSvgRenderer()
self.svg_item = QGraphicsSvgItem()
self.colorizer = QGraphicsColorizeEffect()
self.setRect(QRectF(x, y, w, h)) # Set ellipse coordinates and size
self.text_font_size = 10 # point size
# Make item name graphics item.
name = project_item.name if project_item else ""
self.name_item = QGraphicsSimpleTextItem(name)
shadow_effect = QGraphicsDropShadowEffect()
shadow_effect.setOffset(1)
shadow_effect.setEnabled(False)
self.setGraphicsEffect(shadow_effect)
self.set_name_attributes() # Set font, size, position, etc.
# Make connector buttons
self.connectors = dict(
bottom=ConnectorButton(self, toolbox, position="bottom"),
left=ConnectorButton(self, toolbox, position="left"),
right=ConnectorButton(self, toolbox, position="right"),
)
# Make exclamation and rank icons
self.exclamation_icon = ExclamationIcon(self)
self.rank_icon = RankIcon(self)
# Group the drawn items together by setting the background rectangle as the parent of other QGraphicsItems
# NOTE: setting the parent item moves the items as one!
self.name_item.setParentItem(self)
for conn in self.connectors.values():
conn.setParentItem(self)
self.svg_item.setParentItem(self)
self.exclamation_icon.setParentItem(self)
self.rank_icon.setParentItem(self)
brush = QBrush(background_color)
self._setup(brush, icon_file, icon_color)
# Add items to scene
scene = self._toolbox.ui.graphicsView.scene()
scene.addItem(self)
def __init__(self, text: str, object_name: str = "blue"):
super().__init__(text)
self.setCursor(Qt.PointingHandCursor)
if object_name:
self.setObjectName(object_name)
effect = QGraphicsDropShadowEffect(self)
effect.setColor(QColor(0, 0, 0, 0.25 * 255))
effect.setOffset(2, 4)
effect.setBlurRadius(4)
self.setGraphicsEffect(effect)
def add_window_drop_shadow() -> None:
"""Adds a drop-shadow behind the window"""
if self.__use_shadow:
self.layout().setMargin(self.__style.window.SHADOW_RADIUS_PX)
drop_shadow_effect = QGraphicsDropShadowEffect(self)
drop_shadow_effect.setEnabled(True)
drop_shadow_effect.setBlurRadius(
self.__style.window.SHADOW_RADIUS_PX)
color = QColor(self.__style.window.SHADOW_COLOR_RGB)
color.setAlpha(self.__style.window.SHADOW_OPACITY_HEX)
drop_shadow_effect.setColor(color)
drop_shadow_effect.setOffset(0)
self.setGraphicsEffect(drop_shadow_effect)
def __init__(self, toolbox, icon_file, icon_color, background_color):
"""
Args:
toolbox (ToolboxUI): QMainWindow instance
icon_file (str): Path to icon resource
icon_color (QColor): Icon's color
background_color (QColor): Background color
"""
super().__init__()
self._toolbox = toolbox
self.icon_file = icon_file
self._moved_on_scene = False
self.previous_pos = QPointF()
self.current_pos = QPointF()
self.icon_group = {self}
self.renderer = QSvgRenderer()
self.svg_item = QGraphicsSvgItem(self)
self.colorizer = QGraphicsColorizeEffect()
self.setRect(
QRectF(-self.ITEM_EXTENT / 2, -self.ITEM_EXTENT / 2,
self.ITEM_EXTENT, self.ITEM_EXTENT))
self.text_font_size = 10 # point size
# Make item name graphics item.
self._name = ""
self.name_item = QGraphicsSimpleTextItem(self._name, self)
self.set_name_attributes() # Set font, size, position, etc.
# Make connector buttons
self.connectors = dict(
bottom=ConnectorButton(self, toolbox, position="bottom"),
left=ConnectorButton(self, toolbox, position="left"),
right=ConnectorButton(self, toolbox, position="right"),
)
# Make exclamation and rank icons
self.exclamation_icon = ExclamationIcon(self)
self.execution_icon = ExecutionIcon(self)
self.rank_icon = RankIcon(self)
brush = QBrush(background_color)
self._setup(brush, icon_file, icon_color)
shadow_effect = QGraphicsDropShadowEffect()
shadow_effect.setOffset(1)
shadow_effect.setEnabled(False)
self.setGraphicsEffect(shadow_effect)
def set_shadow(QtWindow, button):
shadow = QGraphicsDropShadowEffect(QtWindow)
shadow.setBlurRadius(6)
shadow.setOffset(3)
shadow.setColor(QColor(0, 0, 0, 160))
button.setGraphicsEffect(shadow)
class Central(QFrame):
'''Initializes, styles, and connects the various classes'''
def __init__(self):
super().__init__()
# Objects
self.overallLayout = QVBoxLayout(self)
self.contentLayout = QHBoxLayout()
self.dropShadow = QGraphicsDropShadowEffect(self)
self.boxManager = BoxManager.BoxManager()
self.topBar = TopBar.TopBar()
self.selectorArea = QFrame()
self.selectorLayout = QVBoxLayout(self.selectorArea)
self.folderArea = QFrame()
self.folderLayout = QHBoxLayout(self.folderArea)
self.folderList = FolderList.FolderList()
self.folderBar = ScrollBar.ScrollBar(self.folderList)
self.canvas = Canvas.Canvas(self.boxManager)
self.imageArea = QFrame()
self.imageList = ImageList.ImageList()
self.imageLayout = QHBoxLayout(self.imageArea)
self.imageBar = ScrollBar.ScrollBar(self.imageList)
# Styling
self.setStyleSheet('Central { background: transparent; }')
self.overallLayout.setMargin(20)
self.overallLayout.setSpacing(0)
self.dropShadow.setOffset(QPointF(0,4))
self.dropShadow.setColor(QColor(0,0,0,100))
self.dropShadow.setBlurRadius(10)
self.setGraphicsEffect(self.dropShadow)
self.contentLayout.setAlignment(Qt.AlignCenter)
self.contentLayout.setMargin(0)
self.contentLayout.setSpacing(0)
self.selectorLayout.setMargin(0)
self.selectorLayout.setSpacing(0)
self.folderLayout.setMargin(0)
self.folderLayout.setSpacing(0)
self.imageLayout.setMargin(0)
self.imageLayout.setSpacing(0)
self.folderList.setVerticalScrollBar(self.folderBar)
self.imageList.setVerticalScrollBar(self.imageBar)
self.selectorArea.setMaximumWidth(400)
self.selectorArea.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
# Layout
self.folderLayout.addWidget(self.folderList)
self.folderLayout.addSpacerItem(QSpacerItem(-7, 0))
self.folderLayout.addWidget(self.folderBar)
self.imageLayout.addWidget(self.imageList)
self.imageLayout.addSpacerItem(QSpacerItem(-7, 0))
self.imageLayout.addWidget(self.imageBar)
self.selectorLayout.addWidget(self.folderArea, 15)
self.selectorLayout.addWidget(self.imageArea, 85)
self.contentLayout.addWidget(self.selectorArea, 30)
self.contentLayout.addWidget(self.canvas, 70)
self.overallLayout.addLayout(self.contentLayout)
self.overallLayout.insertWidget(0, self.topBar)
# Connections
self.folderList.selectedFolderChanged.connect(self.handleSelectedFolderChanged)
self.imageList.selectedImageChanged.connect(self.handleSelectedImageChanged)
def handleSelectedFolderChanged(self, folder):
self.imageList.populate(folder)
self.canvas.changeImage(None)
self.canvas.setMessage('Switching Folders - {}'.format(folder.data(role=Qt.DisplayRole)))
self.topBar.setSelectedFolder(str(folder.data(role=Qt.UserRole+1)))
self.topBar.setSelectedImage('')
def handleSelectedImageChanged(self, image):
self.canvas.changeImage(image)
self.canvas.setMessage('Switching Images - {}'.format(image.data(role=Qt.DisplayRole)))
self.topBar.setSelectedImage(str(image.data(role=Qt.DisplayRole)))
class StyleWindow(QWidget):
def __init__(self, parent=None):
"""
基于QWidget的窗口，作为一些窗口的基类，提供一些基础的属性
background_color_: 背景色， 目前只支持单色
border_width_: 边框宽度， 为0表示没有边框
border_color_:
opacity_: 窗口透明度
shadow_on_: 是否开启阴影
shadow_color_:
shadow_blur_: 阴影半径
border_radius_: 四个角的弧度
分别设置4个角的radius
left_top_border_radius:
left_bottom_border_radius_:
right_top_border_radius_:
right_bottom_border_radius_
"""
QWidget.__init__(self, parent)
self._border_width = 0
self._border_indicator_width = 5
self._mouse_left_button_pressed = False
self._rt_pre_geometry = self.geometry()
self._mouse_move_pre_pos = QPoint()
self._background_color = Qt.white
self._border_color = Qt.transparent
self._border_width = 0
self._border_radius = 0
self._opacity = 1.0
self._shadow = None
self._main_v_layout_ = None
self._cursor_calc_type = MousePosition.CenterPos
# border
self._left_top_border_radius = 0
self._left_bottom_border_radius = 0
self._right_top_border_radius = 0
self._right_bottom_border_radius = 0
self._enabled_drag = False
self.setMouseTracking(True)
# self.setAttribute(Qt.WA_TranslucentBackground)
self._init_default_layout()
def paint_style_widget(self, painter):
style_opt = QStyleOption()
style_opt.init(self)
self.style().drawPrimitive(QStyle.PE_Widget, style_opt, painter)
def paintEvent(self, event):
""" paintEvent(self, event:PySide2.QtGui.QPaintEvent) """
painter = QPainter(self)
self.paint_border_background(painter)
def border_width(self):
return self._border_width
def set_border_width(self, width):
self._border_width = parse_pix_width(width)
if self._main_v_layout_ is not None:
self._main_v_layout_.setContentsMargins(self._border_width,
self._border_width,
self._border_width,
self._border_width)
border_width_ = Property(str, fget=border_width, fset=set_border_width)
def border_indicator_width(self):
return self._border_indicator_width
def set_border_indicator_width(self, width):
self._border_indicator_width = parse_pix_width(width)
border_indicator_width_ = Property(str,
fget=border_indicator_width,
fset=set_border_indicator_width)
def mouseMoveEvent(self, event):
""" mouseMoveEvent(self, event:PySide2.QtGui.QMouseEvent) """
if self._enabled_drag:
if self.isMaximized() is not True and self.isFullScreen(
) is not True:
self._set_cursor_shape(
self._calc_cursor_pos(event.pos(),
self._calc_cursor_col(event.pos())))
if self._mouse_left_button_pressed and MousePosition.CenterPos != self._cursor_calc_type:
self._drag_resize()
super(StyleWindow, self).mouseMoveEvent(event)
def _set_cursor_shape(self, pos):
"""setCurSorShape(self, pos:StyleWindow.MousePosition)"""
cursor_shape = Qt.ArrowCursor
if MousePosition.TopLeftPos == pos or MousePosition.BottomRightPos == pos:
cursor_shape = Qt.SizeFDiagCursor
elif MousePosition.LeftPos == pos or MousePosition.RightPos == pos:
cursor_shape = Qt.SizeHorCursor
elif MousePosition.BottomLeftPos == pos or MousePosition.TopRightPos == pos:
cursor_shape = Qt.SizeBDiagCursor
elif MousePosition.BottomPos == pos or MousePosition.TopPos == pos:
cursor_shape = Qt.SizeVerCursor
self.setCursor(cursor_shape)
def _calc_cursor_col(self, pt):
"""calCursorCol(self, pt:PySide2.QtCore.QPoint)"""
res = 3
x = pt.x()
if x < self.border_indicator_width():
res = 1
elif x < self.width() - self.border_indicator_width():
res = 2
return res
def _calc_cursor_pos(self, pt, bit):
"""calCursorCol(self, pt:PySide2.QtCore.QPoint, bit)"""
result = bit
y = pt.y()
if y < self.border_indicator_width():
result += 10
elif y > self.height() - self.border_indicator_width():
result += 30
else:
result += 20
return result
def mousePressEvent(self, event):
""" mousePressEvent(self, event:PySide2.QtGui.QMouseEvent) """
if self._enabled_drag:
self.set_calc_mouse_type(
self._calc_cursor_pos(event.pos(),
self._calc_cursor_col(event.pos())))
if Qt.LeftButton == event.button(
) and MousePosition.CenterPos != self._cursor_calc_type:
self._mouse_left_button_pressed = True
self._rt_pre_geometry = self.geometry()
self._mouse_move_pre_pos = event.globalPos()
super(StyleWindow, self).mousePressEvent(event)
def mouseReleaseEvent(self, event):
""" mousePressEvent(self, event:PySide2.QtGui.QMouseEvent) """
self._mouse_left_button_pressed = False
QApplication.restoreOverrideCursor()
super(StyleWindow, self).mouseReleaseEvent(event)
def _drag_resize(self):
mouse_cur_pos = QCursor.pos()
move_pos = mouse_cur_pos - self._mouse_move_pre_pos
after_resize_geometry = self._rt_pre_geometry
if MousePosition.TopLeftPos == self._cursor_calc_type:
after_resize_geometry.setTopLeft(self._rt_pre_geometry.topLeft() +
move_pos)
elif MousePosition.LeftPos == self._cursor_calc_type:
after_resize_geometry.setLeft(self._rt_pre_geometry.left() +
move_pos.x())
elif MousePosition.BottomLeftPos == self._cursor_calc_type:
after_resize_geometry.setBottomLeft(
self._rt_pre_geometry.bottomLeft() + move_pos)
elif MousePosition.BottomPos == self._cursor_calc_type:
after_resize_geometry.setBottom(self._rt_pre_geometry.bottom() +
move_pos.y())
elif MousePosition.BottomRightPos == self._cursor_calc_type:
after_resize_geometry.setBottomRight(
self._rt_pre_geometry.bottomRight() + move_pos)
elif MousePosition.RightPos == self._cursor_calc_type:
after_resize_geometry.setRight(self._rt_pre_geometry.right() +
move_pos.x())
elif MousePosition.TopRightPos == self._cursor_calc_type:
after_resize_geometry.setTopRight(
self._rt_pre_geometry.topRight() + move_pos)
elif MousePosition.TopPos == self._cursor_calc_type:
after_resize_geometry.setTop(self._rt_pre_geometry.top() +
move_pos.y())
self.setGeometry(after_resize_geometry)
self._mouse_move_pre_pos = mouse_cur_pos
self._rt_pre_geometry = after_resize_geometry
def background_color(self):
return self._background_color
def set_background_color(self, clr):
self._background_color = clr
background_color_ = Property(QColor,
fget=background_color,
fset=set_background_color)
def border_color(self):
return self._border_color
def set_border_color(self, clr):
self._border_color = clr
border_color_ = Property(QColor, fget=border_color, fset=set_border_color)
def border_radius(self):
return self._border_radius
def set_border_radius(self, radius):
self._border_radius = parse_pix_width(radius)
border_radius_ = Property(str, fget=border_radius, fset=set_border_radius)
def paint_border_background(self, painter):
"""paint_border_background(self, painter:PySide2.QtGui.QPainter)"""
painter.save()
pen = QPen()
pen.setColor(self.border_color())
pen.setWidth(self.border_width())
painter.setPen(pen)
brush = QBrush(self.background_color())
painter.setBrush(brush)
painter.setOpacity(self.opacity())
# painter.setRenderHint(QPainter.Antialiasing)
rc = self.rect()
paint_path = QPainterPath()
# adjust shadow
if self._shadow is not None:
rc.adjust(self.shadow_blur(), self.shadow_blur(),
-self.shadow_blur(), -self.shadow_blur())
# self._calc_background_path(rc, paint_path)
if self._calc_background_path(rc, paint_path):
painter.setRenderHint(QPainter.Antialiasing)
if self.border_width() > 0:
painter.drawPath(paint_path)
else:
painter.fillPath(paint_path, brush)
painter.restore()
def set_opacity(self, opacity):
self._opacity = opacity
def opacity(self) -> float:
return self._opacity
opacity_ = Property(float, fget=opacity, fset=set_opacity)
def resizeEvent(self, event):
super(StyleWindow, self).resizeEvent(event)
# self.setGeometry(5, 5, self.width() - 5, self.height() - 5)
def set_shadow(self, on):
if on:
self._shadow = QGraphicsDropShadowEffect(self)
self._shadow.setOffset(0.0, 0.0)
self._shadow.color()
self.setGraphicsEffect(self._shadow)
self.setGeometry(5, 5, self.width() - 5, self.height() - 5)
def shadow(self):
return self._shadow
shadow_on_ = Property(bool, fget=shadow, fset=set_shadow)
def shadow_color(self):
if self._shadow is not None:
return self._shadow.color()
def set_shadow_color(self, color):
if self._shadow is not None:
self._shadow.setColor(color)
shadow_color_ = Property(QColor, fget=shadow_color, fset=set_shadow_color)
def shadow_blur(self):
if self._shadow is not None:
return self._shadow.blurRadius()
return 0
def set_shadow_blur(self, pix_blur):
if self._shadow is not None:
blur = parse_pix_width(pix_blur)
self._shadow.setBlurRadius(blur)
self.set_border_indicator_width(blur +
self.border_indicator_width())
if self._main_v_layout_ is not None:
self._main_v_layout_.setContentsMargins(
blur + self.border_width(), blur + self.border_width(),
blur - 1 + self.border_width(), blur + self.border_width())
shadow_blur_ = Property(str, fget=shadow_blur, fset=set_shadow_blur)
def _init_default_layout(self):
"""setting a default QVBoxLayout"""
self._main_v_layout_ = QVBoxLayout(self)
self._main_v_layout_.setContentsMargins(0, 0, 0, 0)
self.setLayout(self._main_v_layout_)
def set_left_top_border_radius(self, radius):
self._left_top_border_radius = parse_pix_width(radius)
def left_top_border_radius(self):
if self._left_top_border_radius:
return self._left_top_border_radius
return self.border_radius()
left_top_border_radius_ = Property(str,
fget=left_top_border_radius,
fset=set_left_top_border_radius)
def set_left_bottom_border_radius(self, radius):
self._left_bottom_border_radius = parse_pix_width(radius)
def left_bottom_border_radius(self):
if self._left_bottom_border_radius:
return self._left_bottom_border_radius
return self.border_radius()
left_bottom_border_radius_ = Property(str,
fget=left_bottom_border_radius,
fset=set_left_bottom_border_radius)
def set_right_top_border_radius(self, radius):
self._right_top_border_radius = parse_pix_width(radius)
def right_top_border_radius(self):
if self._right_top_border_radius:
return self._right_top_border_radius
return self.border_radius()
right_top_border_radius_ = Property(str,
fget=right_top_border_radius,
fset=set_right_top_border_radius)
def set_right_bottom_border_radius(self, radius):
self._right_bottom_border_radius = parse_pix_width(radius)
def right_bottom_border_radius(self):
if self._right_bottom_border_radius:
return self._right_bottom_border_radius
return self.border_radius()
right_bottom_border_radius_ = Property(str,
fget=right_bottom_border_radius,
fset=set_right_bottom_border_radius)
def _calc_background_path(self, rc, painter_path):
render_hint = False
if self.border_radius():
painter_path.addRoundedRect(rc, self.border_radius(),
self.border_radius())
render_hint = True
else:
if self.left_top_border_radius() or self.left_bottom_border_radius() \
or self.right_top_border_radius() or self.right_bottom_border_radius():
# add radius
render_hint = True
radius_angle = 90.0
rotate_angle = 90.0
painter_path.moveTo(rc.left(), rc.top())
painter_path.arcTo(rc.left(), rc.top(),
self.left_top_border_radius(),
self.left_top_border_radius(), rotate_angle,
radius_angle)
painter_path.lineTo(
rc.left(),
rc.bottom() - self.left_bottom_border_radius() / 2)
painter_path.arcTo(rc.left(),
rc.bottom() - self.left_bottom_border_radius(),
self.left_bottom_border_radius(),
self.left_bottom_border_radius(),
rotate_angle * 2, radius_angle)
painter_path.lineTo(
rc.right() - self.right_bottom_border_radius() / 2,
rc.bottom())
painter_path.arcTo(rc.right() - self.right_bottom_border_radius(),
rc.bottom() - self.right_bottom_border_radius(),
self.right_bottom_border_radius(),
self.right_bottom_border_radius(),
rotate_angle * 3, radius_angle)
painter_path.lineTo(rc.right(),
rc.top() - self.right_top_border_radius() / 2)
painter_path.arcTo(rc.right() - self.right_top_border_radius(),
rc.top(), self.right_top_border_radius(),
self.right_top_border_radius(),
rotate_angle * 4 % rotate_angle, radius_angle)
painter_path.lineTo(rc.left() + self.left_top_border_radius() / 2,
rc.top())
return render_hint
def set_layout(self, layout):
if self._main_v_layout_ is not None:
self._main_v_layout_.addLayout(layout)
@property
def mouse_drag_enabled(self):
return self._enabled_drag
@mouse_drag_enabled.setter
def mouse_drag_enabled(self, drag):
self._enabled_drag = drag
def _mouse_drag_is_center_type(self):
if self._cursor_calc_type == MousePosition.CenterPos:
return True
return False
def set_calc_mouse_type(self, mouse_type: MousePosition):
self._cursor_calc_type = mouse_type
class PreferencesGUI(App):
'''
Main class for the Preferences Window
'''
keys = list()
finished = Signal()
def __init__(self, appctxt, windowInst):
super().__init__()
self.appctxt = appctxt
self.initUI(windowInst)
# self.windowInst.setWindowFlags(QtCore.Qt.WindowTitleHint | QtCore.Qt.FramelessWindowHint)
# self.windowInst.setAttribute(QtCore.Qt.WA_DeleteOnClose)
self.settings = QSettings(self.COMPANY_NAME, self.APPLICATION_NAME)
self.receiversInst = Receivers(self.ui)
self.receiversInst.confirmSignal.connect(self.handleExit)
self.connectReceivers()
self.guiHelper = GuiHelper()
self.loadKeys()
self.loadSettings()
def terminate(self):
self.storeSettings()
del self.settings
def initUI(self, windowInst):
# self.app = QtWidgets.QApplication(sys.argv)
self.ui = Ui_PreferencesDialog()
self.ui.windowInst = windowInst
self.ui.windowInst.hide()
self.ui.setupUi(self.ui.windowInst)
windowInst.setAttribute(Qt.WA_TranslucentBackground)
self.backgroundEffect = QGraphicsDropShadowEffect(windowInst)
self.backgroundEffect.setBlurRadius(30)
self.backgroundEffect.setOffset(0, 0)
self.backgroundEffect.setEnabled(True)
self.ui.centralwidget.setGraphicsEffect(self.backgroundEffect)
self.ui.comboBoxAutosaveMode.addItem("Don't Autosave")
self.ui.comboBoxAutosaveMode.addItem("5 min Autosave")
self.ui.comboBoxAutosaveMode.addItem("10 min Autosave")
self.ui.comboBoxAutosaveMode.addItem("15 min Autosave")
self.ui.comboBoxAutosaveMode.addItem("20 min Autosave")
self.ui.comboBoxThemeSelect.addItem("Dark Theme")
self.ui.comboBoxThemeSelect.addItem("Light Theme")
# self.ui.comboBoxThemeSelect.addItem("Ambient Theme")
def run(self):
'''
Starts the Preferences Window
'''
self.loadSettings()
self.ui.windowInst.show()
@Slot(bool)
def handleExit(self, confirmed):
if confirmed:
self.storeLooseEntries()
self.storeSettings()
print('Settings saved')
else:
self.loadSettings()
print('Settings discarded')
self.finished.emit()
def connectReceivers(self):
'''
Connects all the buttons to the right receivers
'''
self.ui.radioButtonAffectsPDF.clicked.connect(
self.receiversInst.setRadioButtonAffectsPDF)
self.ui.comboBoxThemeSelect.currentIndexChanged.connect(
self.receiversInst.setComboBoxThemeSelect)
self.ui.radioButtonSmoothLines.clicked.connect(
self.receiversInst.setradioButtonSmoothLines)
self.ui.radioButtonSaveOnExit.clicked.connect(
self.receiversInst.setRadioButtonSaveOnExit)
self.ui.comboBoxAutosaveMode.currentIndexChanged.connect(
self.receiversInst.setComboBoxAutosaveMode)
self.ui.pushButtonOk.clicked.connect(
lambda: self.receiversInst.confirmReceiver())
self.ui.pushButtonCancel.clicked.connect(
lambda: self.receiversInst.rejectReceiver())
self.receiversInst.confirmSignal.connect(self.onClose)
def loadKeys(self):
'''
Load the preferences keys
'''
scriptPath = os.path.dirname(os.path.abspath(__file__)) + '\\'
# absKeysFilePath = os.path.normpath(scriptPath + KEYSFILEPATH)
absKeysFilePath = self.appctxt.get_resource('preferences.keys')
keysFileContent = readFile(absKeysFilePath)
for key in keysFileContent['lines']:
self.keys.append(key.replace('\n', ''))
def storeSettings(self):
'''
Store the settings from the gui to the local dict and then to the settings instance
'''
for key in self.keys:
self.settings.setValue(key, str(Preferences.data[key]))
self.settings.sync()
def storeLooseEntries(self):
'''
Saves all entries, which have been entered without explicit confirmation
'''
Preferences.updateKeyValue(
"radioButtonAffectsPDF",
str(self.ui.radioButtonAffectsPDF.isChecked()))
Preferences.updateKeyValue(
"comboBoxThemeSelect",
str(self.ui.comboBoxThemeSelect.currentIndex()))
Preferences.updateKeyValue(
"radioButtonSmoothLines",
str(self.ui.radioButtonSmoothLines.isChecked()))
Preferences.updateKeyValue(
"radioButtonUsePenAsDefault",
str(self.ui.radioButtonSmoothLines.isChecked()))
Preferences.updateKeyValue(
"radioButtonSaveOnExit",
int(self.ui.radioButtonSaveOnExit.isChecked()))
Preferences.updateKeyValue(
"comboBoxAutosaveMode",
int(self.ui.comboBoxAutosaveMode.currentIndex()))
Preferences.updateKeyValue(
"radioButtonNoInteractionWhileEditing",
str(self.ui.radioButtonNoInteractionWhileEditing.isChecked()))
@Slot(bool)
def onClose(self, store):
if store:
self.saveSettings()
else:
self.discardSettings()
def saveSettings(self):
self.storeLooseEntries()
self.storeSettings()
def discardSettings(self):
self.loadSettings()
def loadSettings(self):
'''
Load the settings from the settings instance to the local dict
'''
for key in self.keys:
Preferences.updateKeyValue(
key, self.settings.value(key, defaultValue=None, type=str))
self.ensureValidData()
self.ui.radioButtonAffectsPDF.setChecked(
toBool(Preferences.data["radioButtonAffectsPDF"]))
self.ui.comboBoxThemeSelect.setCurrentIndex(
int(Preferences.data["comboBoxThemeSelect"]))
self.receiversInst.setComboBoxThemeSelect(
int(Preferences.data["comboBoxThemeSelect"]))
self.ui.radioButtonUsePenAsDefault.setChecked(
toBool(Preferences.data["radioButtonUsePenAsDefault"]))
self.ui.radioButtonSmoothLines.setChecked(
toBool(Preferences.data["radioButtonSmoothLines"]))
self.ui.radioButtonSaveOnExit.setChecked(
toBool(Preferences.data["radioButtonSaveOnExit"]))
self.ui.comboBoxAutosaveMode.setCurrentIndex(
int(Preferences.data["comboBoxAutosaveMode"]))
self.ui.radioButtonNoInteractionWhileEditing.setChecked(
toBool(Preferences.data["radioButtonNoInteractionWhileEditing"]))
def ensureValidData(self):
# Apply all default preferences if necessary
if Preferences.data['radioButtonAffectsPDF'] == "":
Preferences.updateKeyValue('radioButtonAffectsPDF', str(True))
if Preferences.data['comboBoxThemeSelect'] == "":
Preferences.updateKeyValue('comboBoxThemeSelect', 1)
if Preferences.data['radioButtonSmoothLines'] == "":
Preferences.updateKeyValue('radioButtonSmoothLines', str(True))
if Preferences.data['radioButtonUsePenAsDefault'] == "":
Preferences.updateKeyValue('radioButtonUsePenAsDefault', str(True))
if Preferences.data['comboBoxDrawingMode'] == "":
Preferences.updateKeyValue('comboBoxDrawingMode', 0)
if Preferences.data['radioButtonSaveOnExit'] == "":
Preferences.updateKeyValue('radioButtonSaveOnExit', str(True))
if Preferences.data['comboBoxAutosaveMode'] == "":
Preferences.updateKeyValue('comboBoxAutosaveMode', 0)
if Preferences.data['radioButtonNoInteractionWhileEditing'] == "":
Preferences.updateKeyValue('radioButtonNoInteractionWhileEditing',
str(True))
if Preferences.data['textSize'] == "":
Preferences.updateKeyValue('textSize', "('0', '0', '0')")
if Preferences.data['markerSize'] == "":
Preferences.updateKeyValue('markerSize', "70")
if Preferences.data['markerColor'] == "":
Preferences.updateKeyValue('markerColor', "('0', '0', '0')")
if Preferences.data['freehandSize'] == "":
Preferences.updateKeyValue('freehandSize', "70")
if Preferences.data['freehandColor'] == "":
Preferences.updateKeyValue('freehandColor', "('0', '0', '0')")
if Preferences.data['formSize'] == "":
Preferences.updateKeyValue('formSize', "70")
if Preferences.data['formColor'] == "":
Preferences.updateKeyValue('formColor', "('0', '0', '0')")
