def build_dark_palette():
darkPalette = QPalette()
window = QColor(50, 52, 55)
text = QColor(200, 200, 200)
disabledText = text.darker(170)
base = window.darker(150)
button = window.lighter(115)
highlight = QColor(42, 130, 218)
dark = window.darker(170)
darkPalette.setColor(QPalette.Window, window)
darkPalette.setColor(QPalette.WindowText, text)
darkPalette.setColor(QPalette.Disabled, QPalette.WindowText, disabledText)
darkPalette.setColor(QPalette.Base, base)
darkPalette.setColor(QPalette.AlternateBase, QColor(46, 47, 48))
darkPalette.setColor(QPalette.ToolTipBase, base)
darkPalette.setColor(QPalette.ToolTipText, text)
darkPalette.setColor(QPalette.Text, text)
darkPalette.setColor(QPalette.Disabled, QPalette.Text, disabledText)
darkPalette.setColor(QPalette.Button, button)
darkPalette.setColor(QPalette.ButtonText, text)
darkPalette.setColor(QPalette.Disabled, QPalette.ButtonText, disabledText)
darkPalette.setColor(QPalette.Mid, button.lighter(120))
darkPalette.setColor(QPalette.Highlight, highlight)
darkPalette.setColor(QPalette.Disabled, QPalette.Highlight,
QColor(80, 80, 80))
darkPalette.setColor(QPalette.HighlightedText, Qt.white)
darkPalette.setColor(QPalette.Disabled, QPalette.HighlightedText,
QColor(127, 127, 127))
darkPalette.setColor(QPalette.Shadow, Qt.black)
darkPalette.setColor(QPalette.Link, highlight.lighter(130))
return darkPalette
def paint(self, painter, option, c: QColor, w: int, h: int, bounding_rect,
theme: str, widget):
painter.setRenderHint(QPainter.Antialiasing)
brush = QBrush(QColor(100, 100, 100, 150)) # QBrush(QColor('#3B9CD9'))
painter.setBrush(brush)
if self.ni.parent_node.design_style == 'extended':
if theme == 'dark std':
self.draw_dark_extended_background(painter, c, w, h,
bounding_rect)
elif theme == 'dark tron':
self.draw_tron_extended_background(painter, c, w, h,
bounding_rect)
elif theme == 'ghostly':
self.draw_ghostly_extended_background(painter, c, w, h,
bounding_rect)
elif theme == 'blender':
self.draw_blender_extended_background(painter, c, w, h,
bounding_rect)
elif self.ni.parent_node.design_style == 'minimalistic':
if theme == 'dark std':
self.draw_dark_minimalistic(painter, c, w, h, bounding_rect)
elif theme == 'dark tron':
if option.state & QStyle.State_MouseOver: # use special dark background color when mouse hovers
self.draw_tron_minimalistic(painter,
10,
c,
w,
h,
background_color=c.darker())
else:
self.draw_tron_minimalistic(painter, 10, c, w, h)
elif theme == 'ghostly':
if option.state & QStyle.State_MouseOver: # use special dark background color when mouse hovers
self.draw_ghostly_minimalistic(painter,
15,
c,
w,
h,
background_color=c.darker())
else:
self.draw_ghostly_minimalistic(painter, 15, c, w, h)
elif theme == 'blender':
self.draw_blender_minimalistic(painter, 20, c, w, h,
bounding_rect)
def __init__(self, *args, button_text="", button_slot=None, **kwargs):
super().__init__(*args, **kwargs)
button = QPushButton(button_text, self)
self.layout().addWidget(button)
button.clicked.connect(button_slot)
button.clicked.connect(self.start_self_destruction)
# Style button: We try hard to programmatically find good contrasting colors
label_bg_color = QColor(self._background_color)
base_hue = label_bg_color.hsvHueF()
saturation = label_bg_color.hsvSaturationF()
bg_color = color_from_index(1,
2,
base_hue=base_hue,
saturation=saturation)
pressed_bg_color = bg_color.darker(110)
hover_bg_color = bg_color.lighter(110)
border_color = QColor("#F0F0F0")
pressed_border_color = border_color.darker(110)
ss = (
"QPushButton{"
f"background-color: {bg_color.name()}; color: #0F0F0F; "
f"border: 2px solid {border_color.name()}; border-style: groove; border-radius: 4px;}}"
f"QPushButton:hover{{background-color: {hover_bg_color.name()};}}"
f"QPushButton:pressed{{background-color: {pressed_bg_color.name()};"
f"border: 2px solid {pressed_border_color.name()};}}")
button.setStyleSheet(ss)
font = QFont()
font.setBold(True)
button.setFont(font)
def _update_person_list_view(self, person_list, view):
view.clear()
# logger.debug("Updating %d persons on view %s", len(person_list), str(view))
for person in person_list:
view.add_human_by_pos(person.person_id,
(person.pos.x, person.pos.y))
color = QColor(person.color)
darker_factor = 100 + int(person.detection_delta_time() / 200)
color = color.darker(darker_factor)
# logger.debug("setting color %s darker factor %d"%(color.name(), darker_factor))
view.set_human_color(person.person_id, color)
def __init__(self, qmlEngine, parent=None):
"""Palette constructor.
Args:
qmlEngine (QQmlApplicationEngine)
"""
super(Palette, self).__init__(parent)
self.qmlEngine = qmlEngine
darkPalette = QPalette()
window = QColor(50, 52, 55)
text = QColor(200, 200, 200)
disabledText = text.darker(170)
base = window.darker(150)
button = window.lighter(115)
highlight = QColor(42, 130, 218)
dark = window.darker(170)
darkPalette.setColor(QPalette.Window, window)
darkPalette.setColor(QPalette.WindowText, text)
darkPalette.setColor(QPalette.Disabled, QPalette.WindowText, disabledText)
darkPalette.setColor(QPalette.Base, base)
darkPalette.setColor(QPalette.AlternateBase, QColor(46, 47, 48))
darkPalette.setColor(QPalette.ToolTipBase, base)
darkPalette.setColor(QPalette.ToolTipText, text)
darkPalette.setColor(QPalette.Text, text)
darkPalette.setColor(QPalette.Disabled, QPalette.Text, disabledText)
darkPalette.setColor(QPalette.Button, button)
darkPalette.setColor(QPalette.ButtonText, text)
darkPalette.setColor(QPalette.Disabled, QPalette.ButtonText, disabledText)
darkPalette.setColor(QPalette.Mid, button.lighter(120))
darkPalette.setColor(QPalette.Highlight, highlight)
darkPalette.setColor(QPalette.Disabled, QPalette.Highlight, QColor(80, 80, 80))
darkPalette.setColor(QPalette.HighlightedText, Qt.white)
darkPalette.setColor(QPalette.Disabled, QPalette.HighlightedText, QColor(127, 127, 127))
darkPalette.setColor(QPalette.Shadow, Qt.black)
darkPalette.setColor(QPalette.Link, highlight.lighter(130))
self.darkPalette = darkPalette
self.defaultPalette = QApplication.instance().palette()
self.togglePalette()
def paint_NI(design_style, painter, option, c: QColor, w: int, h: int,
bounding_rect, title_rect):
painter.setRenderHint(QPainter.Antialiasing)
if design_style == 'extended':
NIPainter_Ghostly.draw_NI_extended_background(
painter, c, w, h, bounding_rect, title_rect)
elif design_style == 'minimalistic':
if option.state & QStyle.State_MouseOver: # use special dark background color when mouse hovers
NIPainter_Ghostly.draw_NI_minimalistic(
painter, c, w, h, background_color=c.darker())
else:
NIPainter_Ghostly.draw_NI_minimalistic(painter, c, w, h)
def drawSquare(self, painter, x, y, shape):
'''draws a square of a shape'''
colorTable = [
0x000000, 0xCC6666, 0x66CC66, 0x6666CC, 0xCCCC66, 0xCC66CC,
0x66CCCC, 0xDAAA00
]
color = QColor(colorTable[shape])
painter.fillRect(x + 1, y + 1,
self.squareWidth() - 2,
self.squareHeight() - 2, color)
painter.setPen(color.lighter())
painter.drawLine(x, y + self.squareHeight() - 1, x, y)
painter.drawLine(x, y, x + self.squareWidth() - 1, y)
painter.setPen(color.darker())
painter.drawLine(x + 1, y + self.squareHeight() - 1,
x + self.squareWidth() - 1,
y + self.squareHeight() - 1)
painter.drawLine(x + self.squareWidth() - 1,
y + self.squareHeight() - 1,
x + self.squareWidth() - 1, y + 1)
class DesignGraphicsScene(CustomGraphicsScene):
"""A scene for the Design view.
Mainly, it handles drag and drop events of ProjectItemDragMixin sources.
"""
def __init__(self, parent, toolbox):
"""
Args:
parent (QObject): scene's parent object
toolbox (ToolboxUI): reference to the main window
"""
super().__init__(parent)
self._toolbox = toolbox
self.item_shadow = None
self._last_selected_items = set()
# Set background attributes
settings = toolbox.qsettings()
self.bg_choice = settings.value("appSettings/bgChoice",
defaultValue="solid")
bg_color = settings.value("appSettings/bgColor", defaultValue="false")
self.bg_color = QColor("#f5f5f5") if bg_color == "false" else bg_color
self.bg_origin = None
self.link_drawer = LinkDrawer(toolbox)
self.link_drawer.hide()
self.connect_signals()
def mouseMoveEvent(self, event):
"""Moves link drawer."""
if self.link_drawer.isVisible():
self.link_drawer.tip = event.scenePos()
self.link_drawer.update_geometry()
event.setButtons(
Qt.NoButton
) # this is so super().mouseMoveEvent sends hover events to connector buttons
super().mouseMoveEvent(event)
def mousePressEvent(self, event):
"""Puts link drawer to sleep and log message if it looks like the user doesn't know what they're doing."""
was_drawing = self.link_drawer.isVisible()
super().mousePressEvent(event)
if was_drawing and self.link_drawer.isVisible():
self.link_drawer.sleep()
if event.button() == Qt.LeftButton:
self.emit_connection_failed()
def mouseReleaseEvent(self, event):
"""Makes link if drawer is released over a valid connector button."""
super().mouseReleaseEvent(event)
if not self.link_drawer.isVisible(
) or self.link_drawer.src_connector.isUnderMouse():
return
if self.link_drawer.dst_connector is None:
self.link_drawer.sleep()
self.emit_connection_failed()
return
self.link_drawer.add_link()
def emit_connection_failed(self):
self._toolbox.msg_warning.emit(
"Unable to make connection. Try landing the connection onto a valid connector button."
)
def keyPressEvent(self, event):
"""Puts link drawer to sleep if user presses ESC."""
super().keyPressEvent(event)
if self.link_drawer.isVisible() and event.key() == Qt.Key_Escape:
self.link_drawer.sleep()
def connect_signals(self):
"""Connect scene signals."""
self.selectionChanged.connect(self.handle_selection_changed)
def project_item_icons(self):
return [
item for item in self.items() if isinstance(item, ProjectItemIcon)
]
@Slot()
def handle_selection_changed(self):
"""Synchronizes selection with the project tree."""
selected_items = set(self.selectedItems())
if self._last_selected_items == selected_items:
return
self._last_selected_items = selected_items
project_item_icons = []
links = []
for item in self.selectedItems():
if isinstance(item, ProjectItemIcon):
project_item_icons.append(item)
elif isinstance(item, Link):
links.append(item)
# Set active project item, active link, and executed item in toolbox
active_project_item = (self._toolbox.project_item_model.get_item(
project_item_icons[0].name()).project_item
if len(project_item_icons) == 1 else None)
active_link = links[0] if len(links) == 1 else None
self._toolbox.refresh_active_elements(active_project_item, active_link)
# Sync selection with project tree view
selected_item_names = {icon.name() for icon in project_item_icons}
self._toolbox.sync_item_selection_with_scene = False
for ind in self._toolbox.project_item_model.leaf_indexes():
item_name = self._toolbox.project_item_model.item(ind).name
cmd = QItemSelectionModel.Select if item_name in selected_item_names else QItemSelectionModel.Deselect
self._toolbox.ui.treeView_project.selectionModel().select(ind, cmd)
self._toolbox.sync_item_selection_with_scene = True
# Make last item selected the current index in project tree view
if project_item_icons:
last_ind = self._toolbox.project_item_model.find_item(
project_item_icons[-1].name())
self._toolbox.ui.treeView_project.selectionModel().setCurrentIndex(
last_ind, QItemSelectionModel.NoUpdate)
def set_bg_color(self, color):
"""Change background color when this is changed in Settings.
Args:
color (QColor): Background color
"""
self.bg_color = color
def set_bg_choice(self, bg_choice):
"""Set background choice when this is changed in Settings.
Args:
bg (str): "grid", "tree", or "solid"
"""
self.bg_choice = bg_choice
@staticmethod
def _is_project_item_drag(source):
"""Checks whether or not source corresponds to a project item being dragged into the scene.
"""
return isinstance(source, ProjectItemDragMixin)
def dragLeaveEvent(self, event):
"""Accept event."""
event.accept()
def dragEnterEvent(self, event):
"""Accept event. Then call the super class method
only if drag source is not a ProjectItemDragMixin."""
event.accept()
source = event.source()
if not self._is_project_item_drag(source):
super().dragEnterEvent(event)
def dragMoveEvent(self, event):
"""Accept event. Then call the super class method
only if drag source is not a ProjectItemDragMixin."""
event.accept()
source = event.source()
if not self._is_project_item_drag(source):
super().dragMoveEvent(event)
def dropEvent(self, event):
"""Only accept drops when the source is an instance of ProjectItemDragMixin.
Capture text from event's mimedata and show the appropriate 'Add Item form.'
"""
source = event.source()
if not self._is_project_item_drag(source):
super().dropEvent(event)
return
if not self._toolbox.project():
self._toolbox.msg.emit("Please open or create a project first")
event.ignore()
return
event.acceptProposedAction()
item_type, spec = event.mimeData().text().split(",")
pos = event.scenePos()
x = pos.x()
y = pos.y()
factory = self._toolbox.item_factories[item_type]
self.item_shadow = factory.make_icon(self._toolbox)
self.item_shadow.finalize("", x, y)
self.addItem(self.item_shadow)
self._toolbox.show_add_project_item_form(item_type, x, y, spec=spec)
def event(self, event):
"""Accepts GraphicsSceneHelp events without doing anything, to not interfere with our usage of
QToolTip.showText in graphics_items.ExclamationIcon.
"""
if event.type() == QEvent.GraphicsSceneHelp:
event.accept()
return True
return super().event(event)
def drawBackground(self, painter, rect):
"""Reimplemented method to make a custom background.
Args:
painter (QPainter): Painter that is used to paint background
rect (QRectF): The exposed (viewport) rectangle in scene coordinates
"""
if self.bg_origin is None:
self.bg_origin = rect.center()
{
"solid": self._draw_solid_bg,
"grid": self._draw_grid_bg,
"tree": self._draw_tree_bg
}.get(self.bg_choice, self._draw_solid_bg)(painter, rect)
def _draw_solid_bg(self, painter, rect):
"""Draws solid bg."""
painter.fillRect(rect, QBrush(self.bg_color))
def _draw_grid_bg(self, painter, rect):
"""Draws grid bg."""
step = round(ProjectItemIcon.ITEM_EXTENT / 3) # Grid step
painter.setPen(QPen(self.bg_color))
delta = rect.topLeft() - self.bg_origin
x_start = round(delta.x() / step)
y_start = round(delta.y() / step)
x_stop = x_start + round(rect.width() / step) + 1
y_stop = y_start + round(rect.height() / step) + 1
for i in range(x_start, x_stop):
x = step * i
painter.drawLine(x, rect.top(), x, rect.bottom())
for j in range(y_start, y_stop):
y = step * j
painter.drawLine(rect.left(), y, rect.right(), y)
painter.setPen(QPen(self.bg_color.darker(110)))
painter.drawLine(self.bg_origin.x(), rect.top(), self.bg_origin.x(),
rect.bottom())
painter.drawLine(rect.left(), self.bg_origin.y(), rect.right(),
self.bg_origin.y())
def _draw_tree_bg(self, painter, rect):
"""Draws 'tree of life' bg."""
painter.setPen(QPen(self.bg_color))
radius = ProjectItemIcon.ITEM_EXTENT
dx = math.sin(math.pi / 3) * radius
dy = math.cos(math.pi / 3) * radius
delta = rect.topLeft() - self.bg_origin
x_start = round(delta.x() / dx)
y_start = round(delta.y() / radius)
x_stop = x_start + round(rect.width() / dx) + 1
y_stop = y_start + round(rect.height() / radius) + 1
for i in range(x_start, x_stop):
ref = QPointF(i * dx, (i & 1) * dy)
for j in range(y_start, y_stop):
painter.drawEllipse(ref + QPointF(0, j * radius), radius,
radius)
painter.setPen(QPen(self.bg_color.darker(110)))
painter.drawEllipse(self.bg_origin, 2 * radius, 2 * radius)
font.setPointSize(fontsize)
fontinfo = QFontInfo(font)
print("Selected font family:", fontinfo.family())
print("Point size:", fontinfo.pointSize())
app.setFont(font)
# Apollo color palette
app.setStyle("Fusion")
palette = app.palette()
basecolor = QColor("#888b8d")
textcolor = QColor("#fff")
palette.setColor(QPalette.WindowText, textcolor)
palette.setColor(QPalette.Button, basecolor)
#palette.setColor(QPalette.ButtonText, textcolor)
palette.setColor(QPalette.Light, basecolor.lighter(150))
palette.setColor(QPalette.Dark, basecolor.darker(150))
palette.setColor(QPalette.Mid, basecolor)
palette.setColor(QPalette.Text, basecolor.darker(250))
#palette.setColor(QPalette.BrightText, textcolor)
palette.setColor(QPalette.Base, basecolor.lighter(150))
palette.setColor(QPalette.Window, basecolor)
app.setPalette(palette)
if sys.platform == "darwin":
app.setStyleSheet(
f"QLabel {{ font-size: 12px; font-family: {fontfamily}; }}")
window = MainWindow(None)
window.show()
app.exec_()
