def remove_opacity_stop_at_position(self, n):
if len(self._opacity) > 1:
message = {"opacity": self._opacity[n][1], "location": self._opacity[n][0]}
messenger.publish("opacity_removed", message)
del self._opacity[n]
self.update()
def add_layer(self):
# Add layer just below 'New Layer' button
position = self.layout.count() - 1
messenger.publish("layer_added", {"index": position})
name = "Layer " + str(self.layer_count)
self.layer_count += 1
self.layout.insertWidget(1, LayerView(name), alignment=Qt.AlignCenter)
def onChanged(self, text):
if text != self.combo_text:
messenger.publish("layer_gui_type_changed", {
"value": text,
"elem": self.layer_view
})
self.combo_text = text
def initUI(self, name):
self.setMinimumSize(240, 40)
self.setMaximumWidth(300)
self.font = QFont()
self.font.setFamily("Arial")
self.font.setPointSize(14)
layout = QHBoxLayout()
self.setLayout(layout)
layout.setContentsMargins(0, 0, 0, 0)
# Add toggle visibility button
self.toggle_visible = QPushButton()
self.checked = True
self.toggle_visible.setFlat(True)
self.visible_icon = QIcon("resources/visible.png")
self.toggle_visible.setIcon(self.visible_icon)
self.toggle_visible.setMaximumWidth(18)
self.toggle_visible.clicked.connect(self.visibility_toggled)
self.toggle_visible.setStyleSheet(
"background-color: rgb(205, 205, 205);")
layout.addWidget(self.toggle_visible)
# Add layer name
label = QLabel(name)
label.setFont(self.font)
layout.addWidget(label)
# Add layer order buttons button
arrow_buttons = ArrowButtons()
arrow_buttons.arrow_up_callback = self.arrow_up_pressed
arrow_buttons.arrow_down_callback = self.arrow_down_pressed
layout.addWidget(arrow_buttons)
# Add settings button
settingsIcon = QIcon("resources/settings.png")
settings = QPushButton()
settings.setIcon(settingsIcon)
settings.setMaximumWidth(30)
settings.setStyleSheet("background-color: white; shadow: none")
settings.clicked.connect(lambda: self.settings_windows.show())
layout.addWidget(settings)
# Add delete button
delIcon = QIcon("resources/delete.png")
delete = QPushButton()
delete.clicked.connect(
lambda: messenger.publish("delete_gui_clicked", {"elem": self}))
delete.setIcon(delIcon)
delete.setMaximumWidth(30)
delete.setStyleSheet("background-color: white; shadow: none")
layout.addWidget(delete)
# Setup behavior when layer is clicked
selected_action = lambda event: messenger.publish(
"layer_gui_selected", {"elem": self})
self.mouseReleaseEvent = selected_action
selected_action(None)
def choose_interior_color(self):
dlg = QtWidgets.QColorDialog(self)
dlg.setCurrentColor(QtGui.QColor(self.interior_color))
if dlg.exec_():
self.interior_color = dlg.currentColor().name()
message = {"color": self.interior_color}
messenger.publish("interior_color_changed", message)
def remove_gradient_stop_at_position(self, n):
if len(self._gradient) > 1:
message = {"color": self._gradient[n][1], "location": self._gradient[n][0]}
messenger.publish("color_removed", message)
del self._gradient[n]
self.gradientChanged.emit()
self.update()
def layer_selected(self, event):
if self.selected_layer:
self.selected_layer.setStyleSheet("background-color: white")
event["elem"].setStyleSheet("background-color: rgb(205, 205, 205)")
self.selected_layer = event["elem"]
layer_index = self.gui_index_to_fractal_index(event["elem"])
messenger.publish("selected_layer_changed", {"index": layer_index})
def submit(self):
self.original_value = self.value
opacity_list = self.gradient_gui._opacity
for location, opacity, window in opacity_list:
if window is self.parent_window:
messenger.publish("opacity_gui_changed", {"location": location, "value": self.value})
self.parent_window.hide()
def change_opacity(self, event):
changed = False
for i in range(len(self._opacity)):
if self._opacity[i][0] == event["location"]:
self._opacity[i] = (self._opacity[i][0], event["value"], self._opacity[i][2])
changed = True
if changed:
messenger.publish("opacity_changed", event)
def setColorAtPosition(self, n, color):
if n < len(self._gradient):
stop, _ = self._gradient[n]
self._gradient[n] = stop, color
message = {"color": self._gradient[n][1], "location": self._gradient[n][0]}
messenger.publish("color_changed", message)
self.gradientChanged.emit()
self.update()
def visibility_toggled(self):
self.checked = not self.checked
icon = self.visible_icon if self.checked else QIcon()
self.toggle_visible.setIcon(icon)
if self.checked:
self.toggle_visible.setStyleSheet('border:none')
else:
self.toggle_visible.setStyleSheet('border:black')
messenger.publish("layer_gui_toggled", {
"value": self.checked,
"elem": self
})
def mouseReleaseEvent(self, e):
if self._drag_position is not None:
message = {"color": self._gradient[self._drag_position][1],
"location": self._gradient[self._drag_position][0],
"old_location" : self._old_position}
messenger.publish("color_moved", message)
if self._opacity_drag_position is not None:
message = {"opacity": self._opacity[self._opacity_drag_position][1],
"location": self._opacity[self._opacity_drag_position][0],
"old_location" : self._opacity_old_position}
messenger.publish("opacity_moved", message)
self._drag_position = None
self._opacity_drag_position = None
self._sort_gradient()
self._sort_opacity()
def layer_moved(self, event):
layer_index = self.gui_index_to_fractal_index(event["elem"])
gui_index = self.layout.indexOf(event["elem"])
# Ignore bad values
if (layer_index is 0 and event["value"] is "down") or (
layer_index is self.layout.count() - 2
and event["value"] is "up"):
return
self.layout.removeWidget(event["elem"])
new_index = gui_index - 1 if event["value"] is "up" else gui_index + 1
self.layout.insertWidget(new_index, event["elem"])
messenger.publish("layer_moved", {
"value": event["value"],
"index": layer_index
})
def add_opacity_stop(self, stop):
# Stop is a value 0...1, find the point to insert this stop
# in the list.
assert 0.0 <= stop <= 1.0
index = -1
for n, g in enumerate(self._opacity):
if g[0] > stop:
# Insert before this entry, with specified or next color.
self._opacity.insert(n, (stop, OPACITY_DEFAULT, OpacitySliderWindow(self)))
index = n
break
if index == -1:
# Insert at end of list
index = len(self._gradient) - 1
self._opacity.append((stop, OPACITY_DEFAULT, OpacitySliderWindow(self)))
message = {"opacity" : self._opacity[index][1], "location": self._opacity[index][0]}
messenger.publish("opacity_added", message)
self.update()
def add_gradient_stop(self, stop, color=None):
# Stop is a value 0...1, find the point to insert this stop
# in the list.
assert 0.0 <= stop <= 1.0
index = -1
for n, g in enumerate(self._gradient):
if g[0] > stop:
# Insert before this entry, with specified or next color.
self._gradient.insert(n, (stop, color or '#ffffff'))
index = n
break
if index == -1:
# Insert at end of list
index = len(self._gradient)
self._gradient.append((stop, color or '#ffffff'))
self._constrain_gradient()
message = {"color" : self._gradient[index][1], "location": self._gradient[index][0]}
messenger.publish("color_added", message)
self.gradientChanged.emit()
self.update()
def keyPressEvent(self, e):
messenger.publish("key_pressed", {"event": e})
def layer_type_changed(self, event):
layer_index = self.gui_index_to_fractal_index(event["elem"])
messenger.publish("layer_type_changed", {
"index": layer_index,
"value": event["value"]
})
def remove_layer(self, event):
layer_index = self.gui_index_to_fractal_index(event["elem"])
if event["elem"] is self.selected_layer:
self.selected_layer = None
event["elem"].deleteLater()
messenger.publish("layer_removed", {"index": layer_index})
def forward_layer_toggle_event(self, event):
event["index"] = self.gui_index_to_fractal_index(event["elem"])
del event["elem"]
messenger.publish("layer_toggled", event)
def wheelEvent(self, event):
messenger.publish("mouse_wheel_moved", {"event": event})
def arrow_down_pressed(self):
messenger.publish("layer_gui_moved", {"value": "down", "elem": self})
