class plotScroller:
def update_val(self, proc):
d=str(self.scl.value())
self.v.setText(d)
if proc != None:
proc(self.scl.value())
def __init__(self, master, text, geo, proc=None, lim=(0,100,1)):
self.scl=QScrollBar(Qt.Horizontal, master)
self.scl.resize(geo[2]-50,geo[3])
self.scl.move(geo[0]+50,geo[1])
self.scl.setMinimum(lim[0])
self.scl.setMaximum(lim[1])
self.scl.setSingleStep(lim[2])
self.scl.valueChanged.connect(lambda: self.update_val(proc))
q=QLabel(master)
q.move(geo[0],geo[1]+10)
q.resize(50,20)
q.setText(text)
self.v=QLabel(master)
self.v.move(geo[2]+10,geo[1]+10)
self.v.resize(50,20)
self.v.setText(str(self.scl.value()))
def setValue(self, v):
self.scl.setValue(v)
class Example(QWidget):
def __init__(self):
super(Example, self).__init__()
# vbox = QVBoxLayout(self)
hbox = QHBoxLayout()
# self.l1 = QLabel("Drag scrollbar sliders to change color")
# self.l1.setFont(QFont("Arial", 16))
# hbox.addWidget(self.l1)
self.s1 = QScrollBar()
self.s1.setMaximum(255)
# self.s1.sliderMoved.connect(self.sliderval)
# self.s2 = QScrollBar()
# self.s2.setMaximum(255)
# self.s2.sliderMoved.connect(self.sliderval)
# self.s3 = QScrollBar()
# self.s3.setMaximum(255)
# self.s3.sliderMoved.connect(self.sliderval)
hbox.addWidget(self.s1)
# hbox.addWidget(self.s2)
# hbox.addWidget(self.s3)
self.setLayout(hbox)
self.setGeometry(300, 300, 300, 200)
self.setWindowTitle('QSplitter demo')
class SlidersGroup(QGroupBox):
valueChanged = pyqtSignal(int)
def __init__(self, orientation, title, parent=None):
super(SlidersGroup, self).__init__(title, parent)
self.slider = QSlider(orientation)
self.slider.setFocusPolicy(Qt.StrongFocus)
self.slider.setTickPosition(QSlider.TicksBothSides)
self.slider.setTickInterval(10)
self.slider.setSingleStep(1)
self.scrollBar = QScrollBar(orientation)
self.scrollBar.setFocusPolicy(Qt.StrongFocus)
self.dial = QDial()
self.dial.setFocusPolicy(Qt.StrongFocus)
self.slider.valueChanged.connect(self.scrollBar.setValue)
self.scrollBar.valueChanged.connect(self.dial.setValue)
self.dial.valueChanged.connect(self.slider.setValue)
self.dial.valueChanged.connect(self.valueChanged)
if orientation == Qt.Horizontal:
direction = QBoxLayout.TopToBottom
else:
direction = QBoxLayout.LeftToRight
slidersLayout = QBoxLayout(direction)
slidersLayout.addWidget(self.slider)
slidersLayout.addWidget(self.scrollBar)
slidersLayout.addWidget(self.dial)
self.setLayout(slidersLayout)
def setValue(self, value):
self.slider.setValue(value)
def setMinimum(self, value):
self.slider.setMinimum(value)
self.scrollBar.setMinimum(value)
self.dial.setMinimum(value)
def setMaximum(self, value):
self.slider.setMaximum(value)
self.scrollBar.setMaximum(value)
self.dial.setMaximum(value)
def invertAppearance(self, invert):
self.slider.setInvertedAppearance(invert)
self.scrollBar.setInvertedAppearance(invert)
self.dial.setInvertedAppearance(invert)
def invertKeyBindings(self, invert):
self.slider.setInvertedControls(invert)
self.scrollBar.setInvertedControls(invert)
self.dial.setInvertedControls(invert)
class SlidersGroup(QGroupBox):
valueChanged = pyqtSignal(int)
def __init__(self, orientation, title, parent=None):
super(SlidersGroup, self).__init__(title, parent)
self.slider = QSlider(orientation)
self.slider.setFocusPolicy(Qt.StrongFocus)
self.slider.setTickPosition(QSlider.TicksBothSides)
self.slider.setTickInterval(10)
self.slider.setSingleStep(1)
self.scrollBar = QScrollBar(orientation)
self.scrollBar.setFocusPolicy(Qt.StrongFocus)
self.dial = QDial()
self.dial.setFocusPolicy(Qt.StrongFocus)
self.slider.valueChanged.connect(self.scrollBar.setValue)
self.scrollBar.valueChanged.connect(self.dial.setValue)
self.dial.valueChanged.connect(self.slider.setValue)
self.dial.valueChanged.connect(self.valueChanged)
if orientation == Qt.Horizontal:
direction = QBoxLayout.TopToBottom
else:
direction = QBoxLayout.LeftToRight
slidersLayout = QBoxLayout(direction)
slidersLayout.addWidget(self.slider)
slidersLayout.addWidget(self.scrollBar)
slidersLayout.addWidget(self.dial)
self.setLayout(slidersLayout)
def setValue(self, value):
self.slider.setValue(value)
def setMinimum(self, value):
self.slider.setMinimum(value)
self.scrollBar.setMinimum(value)
self.dial.setMinimum(value)
def setMaximum(self, value):
self.slider.setMaximum(value)
self.scrollBar.setMaximum(value)
self.dial.setMaximum(value)
def invertAppearance(self, invert):
self.slider.setInvertedAppearance(invert)
self.scrollBar.setInvertedAppearance(invert)
self.dial.setInvertedAppearance(invert)
def invertKeyBindings(self, invert):
self.slider.setInvertedControls(invert)
self.scrollBar.setInvertedControls(invert)
self.dial.setInvertedControls(invert)
def scroll_bar(self):
"""
Creates a scroll bar set to the size of the projects list
:return: QScrollBar Object
"""
s_bar = QScrollBar(Qt.Horizontal)
s_bar.setMaximum(len(self.project_list) - 4)
s_bar.sliderMoved.connect(self.slider_val)
s_bar.valueChanged.connect(self.slider_val)
return s_bar
def scroll_bar(self):
"""
Creates a QScrollBar set to the size of the figshare objects list.
Returns:
s_bar (QScrollBar): Scroll bar used to move through the list of Figsahre objects.
"""
s_bar = QScrollBar(Qt.Horizontal)
s_bar.setMaximum(len(self.object_list) - 4)
s_bar.sliderMoved.connect(self.slider_val)
s_bar.valueChanged.connect(self.slider_val)
return s_bar
def __init__(self, parent=None):
super().__init__(parent)
self.resize(640, 240)
self.setWindowTitle("Cocktailmixer Hardware Emulator")
layout = QGridLayout(self)
encoder_label = QLabel()
emergency_stop_label = QLabel()
scale_label = QLabel()
encoder_up_button = QPushButton()
encoder_down_button = QPushButton()
encoder_click_button = QPushButton()
emergency_stop_button = QPushButton()
scale_scroller = QScrollBar(Qt.Horizontal)
scale_scroller.setMaximum(100)
scale_value = QLabel()
encoder_label.setText("Encoder")
emergency_stop_label.setText("Emergency Stop")
encoder_up_button.setText("scroll up")
encoder_down_button.setText("scroll down")
encoder_click_button.setText("select")
emergency_stop_button.setText("STOP")
scale_label.setText("Scale Value")
scale_value.setText(str(0))
layout.addWidget(encoder_label, 0, 0)
layout.addWidget(emergency_stop_label, 0, 1)
layout.addWidget(scale_label, 0, 2)
layout.addWidget(encoder_up_button, 1, 0)
layout.addWidget(encoder_down_button, 2, 0)
layout.addWidget(encoder_click_button, 3, 0)
layout.addWidget(emergency_stop_button, 1, 1)
layout.addWidget(scale_scroller, 1, 2)
layout.addWidget(scale_value, 2, 2)
encoder_up_button.clicked.connect(lambda: self.encoder_update.emit(1))
encoder_down_button.clicked.connect(
lambda: self.encoder_update.emit(-1))
encoder_click_button.clicked.connect(self.encoder_click)
emergency_stop_button.clicked.connect(self.emergency_stop)
scale_scroller.valueChanged.connect(
lambda: self.scale_update.emit(scale_scroller.value()))
scale_scroller.valueChanged.connect(
lambda: scale_value.setText(str(scale_scroller.value())))
class ScrollBar(QWidget):
def __init__(self, parent=None):
super(ScrollBar, self).__init__(parent)
self.setGeometry(300, 300, 300, 200)
self.setWindowTitle('ScrollBar')
self.lbl = QLabel('Slide scrollbar to change color')
self.lbl.setFont(QFont('Arial', 16))
self.scrollbar1 = QScrollBar()
self.scrollbar1.setMaximum(255)
self.scrollbar1.sliderMoved.connect(self.slider_val)
self.scrollbar2 = QScrollBar()
self.scrollbar2.setMaximum(255)
self.scrollbar2.sliderMoved.connect(self.slider_val)
self.scrollbar3 = QScrollBar()
self.scrollbar3.setMaximum(255)
self.scrollbar3.sliderMoved.connect(self.slider_val)
layout = QHBoxLayout()
layout.addWidget(self.lbl)
layout.addWidget(self.scrollbar1)
layout.addWidget(self.scrollbar2)
layout.addWidget(self.scrollbar3)
self.setLayout(layout)
def slider_val(self):
print(self.scrollbar1.value(), self.scrollbar2.value(), self.scrollbar3.value())
palette = QPalette()
color = QColor(self.scrollbar1.value(), self.scrollbar2.value(), self.scrollbar3.value(), 50)
palette.setColor(QPalette.Foreground, color)
self.lbl.setPalette(palette)
class ScrollBarDemo(QWidget):
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
self.setGeometry(300, 300, 300, 300)
self.label = QLabel("通过滚动条改变字体颜色")
hlayout = QHBoxLayout()
hlayout.addWidget(self.label)
self.scrollbar1 = QScrollBar()
self.scrollbar1.setMaximum(255)
self.scrollbar1.sliderMoved.connect(self.sliderMoved)
self.scrollbar2 = QScrollBar()
self.scrollbar2.setMaximum(255)
self.scrollbar2.sliderMoved.connect(self.sliderMoved)
self.scrollbar3 = QScrollBar()
self.scrollbar3.setMaximum(255)
self.scrollbar3.sliderMoved.connect(self.sliderMoved)
self.scrollbar4 = QScrollBar()
self.scrollbar4.setMaximum(255)
self.scrollbar4.sliderMoved.connect(self.sliderMoved1)
hlayout.addWidget(self.scrollbar1)
hlayout.addWidget(self.scrollbar2)
hlayout.addWidget(self.scrollbar3)
hlayout.addWidget(self.scrollbar4)
self.setLayout(hlayout)
self.y = self.label.pos().y()
def sliderMoved(self):
print(self.scrollbar1.value(), self.scrollbar2.value(),
self.scrollbar3.value())
palette = QPalette()
color = QColor(self.scrollbar1.value(), self.scrollbar2.value(),
self.scrollbar3.value(), 255)
palette.setColor(QPalette.Foreground, color)
self.label.setPalette(palette)
def sliderMoved1(self):
self.label.move(self.label.x(), self.y + self.scrollbar4.value())
class Demo(QWidget):
def __init__(self):
super(Demo,self).__init__()
self.label = QLabel(self)
self.label.setPixmap(QPixmap('image.jpg'))
# setScaledContents(True)方法可以让图片随着QLabel控件大小变化而变化，即自适应；
self.label.setScaledContents(True)
# 实例化一个QScrollArea控件，调用setWidget()方法将QLabel滚动区域中的控件。
self.scroll_area = QScrollArea(self)
self.scroll_area.setWidget(self.label)
self.scroll_area.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.scrollbar = QScrollBar(Qt.Horizontal, self) # 3
self.scrollbar.setMaximum(self.scroll_area.horizontalScrollBar().maximum())
self.bigger_btn = QPushButton('Zoom in', self) # 4
self.smaller_btn = QPushButton('Zoom out', self)
self.bigger_btn.clicked.connect(self.bigger_func) # 5
self.smaller_btn.clicked.connect(self.smaller_func)
self.scrollbar.valueChanged.connect(self.sync_func)
self.h_layout = QHBoxLayout()
self.h_layout.addWidget(self.bigger_btn)
self.h_layout.addWidget(self.smaller_btn)
self.v_layout = QVBoxLayout()
self.v_layout.addWidget(self.scroll_area)
self.v_layout.addWidget(self.scrollbar)
self.v_layout.addLayout(self.h_layout)
self.setLayout(self.v_layout)
def bigger_func(self):
self.label.resize(self.label.width() * 1.2, self.label.height() * 1.2)
self.scrollbar.setMaximum(self.scroll_area.horizontalScrollBar().maximum())
def smaller_func(self):
self.label.resize(self.label.width() * 0.8, self.label.height() * 0.8)
self.scrollbar.setMaximum(self.scroll_area.horizontalScrollBar().maximum())
def sync_func(self):
self.scroll_area.horizontalScrollBar().setValue(self.scrollbar.value())
class QConnectionView(QWidget):
def __init__(self, parent=None):
'''Initialization of the QMatrixView.
Arguments
---------
parent : QWidget
The parent argument is sent to the QWidget constructor.
'''
super().__init__(parent)
self._inputScrollBar = QScrollBar(Qt.Vertical)
self._inputScrollBar.setFocusPolicy(Qt.StrongFocus)
self._inputScrollBar.setMaximum(0)
self._inputScrollBar.setValue(0)
self._connections = QConnectionDisplay()
self._outputScrollBar = QScrollBar(Qt.Vertical)
self._outputScrollBar.setFocusPolicy(Qt.StrongFocus)
self._outputScrollBar.setMaximum(0)
self._outputScrollBar.setValue(0)
layout = QHBoxLayout()
layout.addWidget(self._inputScrollBar)
layout.addWidget(self._connections)
layout.addWidget(self._outputScrollBar)
self.setLayout(layout)
self._inputScrollBar.valueChanged.connect(
self._connections.setInputOffset)
def setActivation(self, input: np.ndarray, output: np.ndarray) -> None:
self._connections.setActivation(input, output)
self._inputScrollBar.setMaximum(
max(
self._connections.getInputHeight() -
self._connections.height(), 0))
self._inputScrollBar.setValue(self._connections.getInputOffset())
self._inputScrollBar.setPageStep(self._connections.height())
class MainUi(QMainWindow):
obj_num = 0
container = {}
def __init__(self, info):
super(MainUi, self).__init__()
self.icon = [ico for ico in info]
self.column = len(self.icon)
self.num = 10 # 界面头部展示模块数量
self.init_ui()
def init_ui(self):
self.setWindowIcon(QIcon('index.ico'))
self.setWindowTitle("工具")
self.resize(960, 600)
self.statusBar().show()
self._center()
self.main_widget = QWidget() # 创建窗口主部件
self.main_layout = QGridLayout() # 创建主部件的网格布局
self.main_widget.setLayout(self.main_layout) # 设置窗口主部件布局为网格布局
# 创建上侧部件
self.up_widget = QWidget()
self.up_widget.setObjectName('up_widget')
self.up_widget.setFixedHeight(80)
self.up_layout = QGridLayout()
self.up_widget.setLayout(self.up_layout)
# 创建滚动条
self.slide = QScrollBar(True)
self.slide.setObjectName('slide_roll_bar')
self.slide.setFixedHeight(const.SLIDE_HEIGHT)
self.slide.setMaximum(self.column)
self.slide.setMinimum(self.num)
self.slide.valueChanged.connect(self._value_change)
# 创建日志记录
# ************************************************##
name = "Analysis"
self.notice_btn = QPushButton(name)
self.notice_btn.setObjectName(name)
self.container["selectedNoticeName"] = name
self.notice_btn.setFixedSize(const.NOTICE_WIDTH, const.BTN_HEIGHT)
self.notice_btn.clicked.connect(self._clicked)
self.notice_close_btn = QPushButton("✘")
self.notice_close_btn.setObjectName("close_btn")
self.notice_close_btn.setFixedSize(30, 30)
self.notice_close_btn.setStyleSheet(
"""#close_btn{
background:red;
border:none;
margin-bottom: 20px;
margin-left: 20px;
}
#close_btn:hover{
background:white;
}
"""
)
self.notice_btn.setStyleSheet("""
#Analysis:hover#close_btn {
background:red;
}
""")
self.close_layout = QGridLayout()
self.close_layout.addWidget(self.notice_close_btn)
self.close_layout.setAlignment(Qt.AlignAbsolute|Qt.AlignRight)
self.close_layout.setSpacing(0)
self.notice_btn.setLayout(self.close_layout)
# self.notice_btn.set(self.notice_close_btn)
# ************************************************##
# 创建中侧部件
self.mid_widget = QWidget()
self.mid_widget.setObjectName('mid_widget')
# self.mid_widget.setFixedHeight(400)
self.mid_layout = QGridLayout()
self.mid_widget.setLayout(self.mid_layout)
# 创建下侧部件
self.down_widget = QWidget()
self.down_widget.setObjectName('down_widget')
self.down_widget.setFixedHeight(60)
self.down_layout = QGridLayout()
self.down_widget.setLayout(self.down_layout)
self.main_layout.addWidget(self.up_widget, 0, 0, 1, self.column)
self.main_layout.addWidget(self.slide, 1, 0, 1, self.column)
self.main_layout.addWidget(self.notice_btn, 2, 0, 1, 1)
self.main_layout.addWidget(self.mid_widget, 3, 1, 1, self.column - 1)
self.main_layout.addWidget(self.down_widget, 4, self.column - 1, 1, 1)
self.setCentralWidget(self.main_widget)
# 生成analysis
analysis = Analysis(self, name)
self.container[name] = {"noticeName": name, "modelObj": analysis, "index": self.obj_num}
self.container["selectedModelName"] = name
# 创建头部（head）
self.head_widget = QWidget()
self.head_layout = QGridLayout()
self.head_widget.setLayout(self.head_layout)
self.load_model_ico(0, self.num) if self.num < self.column else self.load_model_ico(0, self.column)
self.up_layout.addWidget(self.head_widget, 0, 0, 0, 0)
# 创建中部
# 创建尾部 按钮
self.tail_btn = QPushButton("Execute")
self.tail_btn.setObjectName('execute')
self.tail_btn.setFixedSize(const.TAIL_HEIGHT, const.BTN_HEIGHT)
self.tail_btn.clicked.connect(self.run)
self.down_layout.addWidget(self.tail_btn, 0, 0, 0, 0)
self.down_layout.setAlignment(Qt.AlignRight)
# 展示进度条
self.progressBar = QProgressBar()
self.progressBar.setFixedHeight(10)
self.progressBar.setMaximum(const.HUNDRED)
label = QLabel()
label.setText("运行进度：")
self.statusBar().addPermanentWidget(label)
self.statusBar().addPermanentWidget(self.progressBar)
self.main_layout.setSpacing(const.ZERO)
set_style(self)
# self.setWindowFlag(Qt.FramelessWindowHint) # 隐藏边框
# self.setWindowOpacity(0.9) # 设置窗口透明度
# self.setAttribute(Qt.WA_TranslucentBackground) # 设置窗口背景透明
def run(self):
mode_name = self.container.get("selectedModelName", "")
mode_info = self.container.get(mode_name, {})
mode = mode_info.get("modelObj")
if not mode:
print("error %s" % mode)
return
try:
mode.run()
except:
self.set_progress()
traceback.print_exc()
def set_progress(self):
self.tail_btn.setEnabled(True)
def load_model_ico(self, start, end):
for i in range(start, end):
self.tool_btn = QToolButton()
self.tool_btn.setText(f"{self.icon[i]}") # 设置按钮文本
self.tool_btn.setObjectName(f"{self.icon[i]}") # 设置按钮文本
self.tool_btn.setFixedSize(85, 52)
# self.tool_btn.setFixedHeight(85)
self.tool_btn.setIcon(qtawesome.icon(f'fa.{self.icon[i]}', color='white')) # 设置按钮图标
self.tool_btn.setIconSize(QSize(const.ICO_SIZE, const.ICO_SIZE)) # 设置图标大小
self.tool_btn.setToolButtonStyle(Qt.ToolButtonTextUnderIcon)
self.tool_btn.clicked.connect(self._clicked)
self.head_layout.addWidget(self.tool_btn, 0, i, 1, 1)
def info_btn(self, name):
notice_btn = QPushButton(name)
notice_btn.setObjectName(f"{name}_{self.obj_num}")
notice_btn.setFixedSize(const.NOTICE_WIDTH, const.BTN_HEIGHT)
self.container[name]["noticeName"] = f"{name}_{self.obj_num}"
notice_btn.clicked.connect(self._clicked)
self.main_layout.addWidget(notice_btn, 2, self.obj_num, 1, 1)
def _clicked(self):
model_name = self.sender().text()
if model_name == self.container.get("selectedModelName"):
self.show_widget(model_name)
return # message.info()
self.statusBar().showMessage(f'Current Value is {model_name}')
model_info = self.container.get(model_name, {})
if not model_info:
mode = None
try:
mode = ObjFactory.create(self, model_name)
except:
traceback.print_exc()
# return # message.info()
if mode is None:
set_mid_widget_background_style(self.mid_widget, False)
self.show_widget(model_name)
print("failed")
return # message.info()
model_info["modelObj"] = mode
self.obj_num += 1
model_info["index"] = self.obj_num
self.container[model_name] = model_info
self.info_btn(model_name)
self.show_widget(model_name)
self.show()
@staticmethod
def del_layout(layout):
for i in range(layout.count()):
layout.itemAt(i).widget().deleteLater()
def show_widget(self, curr_mode_name):
previous_name = self.container.get("selectedModelName")
if previous_name is not None:
index = self.container.get(previous_name).get("index")
if index is not None:
self.mid_layout.itemAt(index).widget().close()
index = self.container.get(curr_mode_name, {}).get("index")
if index is None:
set_ico_style(self.head_widget, curr_mode_name)
self.show_notice_widget(curr_mode_name)
return
self.mid_layout.itemAt(index).widget().show()
self.show_notice_widget(curr_mode_name)
set_mid_widget_background_style(self.mid_widget)
set_ico_style(self.head_widget, curr_mode_name)
self.container["selectedModelName"] = curr_mode_name
print(f"当前Container：{self.container}")
print(f"当前选中模块：{curr_mode_name}")
def show_notice_widget(self, model_name):
curr_notice_name = self.container.get(model_name, {}).get("noticeName", "failed-model")
args = []
for key, item in self.container.items():
if not isinstance(item, dict):
continue
elif key == model_name:
continue
else:
args.append(item.get("noticeName"))
args.append(curr_notice_name)
set_notice_style(self.main_widget, tuple(args))
self.container["selectedNoticeName"] = curr_notice_name
def _value_change(self):
value = self.slide.value()
start = value - self.num
self.statusBar().showMessage(f'Current Value is {value}')
self.del_layout(self.head_layout)
self.load_model_ico(start, value)
def paintEvent(self, event):
# 设置背景颜色
painter = QPainter(self)
background_color = QColor()
background_color.setNamedColor('#006CAB')
painter.setBrush(background_color)
painter.drawRect(self.rect())
def _center(self):
# 窗口居中
screen = QDesktopWidget().screenGeometry()
size = self.geometry()
self.move((screen.width() - size.width()) / 2,
(screen.height() - size.height()) / 2)
class _s_CentralWidget(QWidget):
###############################################################################
# CentralWidget SIGNALS
###############################################################################
"""
splitterCentralRotated()
"""
splitterCentralRotated = pyqtSignal()
###############################################################################
def __init__(self, parent=None):
super(_s_CentralWidget, self).__init__(parent)
self.parent = parent
#This variables are used to save the splitter sizes before hide
self._splitterMainSizes = None
self._splitterAreaSizes = None
self.lateralPanel = None
hbox = QHBoxLayout(self)
hbox.setContentsMargins(0, 0, 0, 0)
hbox.setSpacing(0)
#Create Splitters to divide the UI in: MainPanel, Explorer, Misc
self._splitterArea = QSplitter(Qt.Horizontal)
self._splitterMain = QSplitter(Qt.Vertical)
#Create scrollbar for follow mode
self.scrollBar = QScrollBar(Qt.Vertical, self)
self.scrollBar.setFixedWidth(20)
self.scrollBar.setToolTip('Follow Mode: Scroll the Editors together')
self.scrollBar.hide()
self.scrollBar.valueChanged[int].connect(self.move_follow_scrolls)
#Add to Main Layout
hbox.addWidget(self.scrollBar)
hbox.addWidget(self._splitterArea)
def insert_central_container(self, container):
self.mainContainer = container
self._splitterMain.insertWidget(0, container)
def insert_lateral_container(self, container):
self.lateralPanel = LateralPanel(container)
self._splitterArea.insertWidget(0, self.lateralPanel)
def insert_bottom_container(self, container):
self.misc = container
self._splitterMain.insertWidget(1, container)
def showEvent(self, event):
#Show Event
QWidget.showEvent(self, event)
#Avoid recalculate the panel sizes if they are already loaded
if self._splitterArea.count() == 2:
return
#Rearrange widgets on Window
self._splitterArea.insertWidget(0, self._splitterMain)
if not event.spontaneous():
self.change_misc_visibility()
if bin(settings.UI_LAYOUT)[-1] == '1':
self.splitter_central_rotate()
if bin(settings.UI_LAYOUT >> 1)[-1] == '1':
self.splitter_misc_rotate()
if bin(settings.UI_LAYOUT >> 2)[-1] == '1':
self.splitter_central_orientation()
qsettings = QSettings(resources.SETTINGS_PATH, QSettings.IniFormat)
#Lists of sizes as list of QVariant- heightList = [QVariant, QVariant]
heightList = list(qsettings.value("window/central/mainSize",
[(self.height() / 3) * 2, self.height() / 3]))
widthList = list(qsettings.value("window/central/areaSize",
[(self.width() / 6) * 5, self.width() / 6]))
self._splitterMainSizes = [int(heightList[0]), int(heightList[1])]
self._splitterAreaSizes = [int(widthList[0]), int(widthList[1])]
#Set the sizes to splitters
#self._splitterMain.setSizes(self._splitterMainSizes)
self._splitterMain.setSizes(self._splitterMainSizes)
self._splitterArea.setSizes(self._splitterAreaSizes)
self.misc.setVisible(
qsettings.value("window/show_misc", False, type=bool))
def change_misc_visibility(self, on_start=False):
if self.misc.isVisible():
self._splitterMainSizes = self._splitterMain.sizes()
self.misc.hide()
widget = self.mainContainer.get_actual_widget()
if widget:
widget.setFocus()
else:
self.misc.show()
self.misc.gain_focus()
def change_main_visibility(self):
if self.mainContainer.isVisible():
self.mainContainer.hide()
else:
self.mainContainer.show()
def change_explorer_visibility(self, force_hide=False):
if self.lateralPanel.isVisible() or force_hide:
self._splitterAreaSizes = self._splitterArea.sizes()
self.lateralPanel.hide()
else:
self.lateralPanel.show()
def splitter_central_rotate(self):
w1, w2 = self._splitterArea.widget(0), self._splitterArea.widget(1)
self._splitterArea.insertWidget(0, w2)
self._splitterArea.insertWidget(1, w1)
self.splitterCentralRotated.emit()
def splitter_central_orientation(self):
if self._splitterArea.orientation() == Qt.Horizontal:
self._splitterArea.setOrientation(Qt.Vertical)
else:
self._splitterArea.setOrientation(Qt.Horizontal)
def splitter_misc_rotate(self):
w1, w2 = self._splitterMain.widget(0), self._splitterMain.widget(1)
self._splitterMain.insertWidget(0, w2)
self._splitterMain.insertWidget(1, w1)
def splitter_misc_orientation(self):
if self._splitterMain.orientation() == Qt.Horizontal:
self._splitterMain.setOrientation(Qt.Vertical)
else:
self._splitterMain.setOrientation(Qt.Horizontal)
def get_area_sizes(self):
if self.lateralPanel.isVisible():
self._splitterAreaSizes = self._splitterArea.sizes()
return self._splitterAreaSizes
def get_main_sizes(self):
if self.misc.isVisible():
self._splitterMainSizes = self._splitterMain.sizes()
return self._splitterMainSizes
def enable_follow_mode_scrollbar(self, val):
if val:
editorWidget = self.mainContainer.get_actual_editor()
maxScroll = editorWidget.verticalScrollBar().maximum()
position = editorWidget.verticalScrollBar().value()
self.scrollBar.setMaximum(maxScroll)
self.scrollBar.setValue(position)
self.scrollBar.setVisible(val)
def move_follow_scrolls(self, val):
widget = self.mainContainer._tabMain.currentWidget()
diff = widget._sidebarWidget.highest_line - val
s1 = self.mainContainer._tabMain.currentWidget().verticalScrollBar()
s2 = self.mainContainer._tabSecondary.\
currentWidget().verticalScrollBar()
s1.setValue(val)
s2.setValue(val + diff)
class OrpheusLibrarySearch(QWidget):
def __init__(self):
super().__init__()
self.initUI()
self.populateList()
def initUI(self):
#palette = QPalette()
#palette.setColor(QPalette.Background, QColor('#383C4A'))
#palette.setColor(QPalette.WindowText, QColor('#C1C1C1'))
#self.setPalette(palette)
self.setMaximumSize(492, 653)
self.setMinimumSize(492, 653)
le = QLineEdit(self)
le.textChanged[str].connect(self.onChanged)
le.returnPressed.connect(self.onActivation)
le.setClearButtonEnabled(True)
le.setPlaceholderText('Start typing to search...')
self.lw = QListWidget()
self.visibleLw = QListWidget()
#palette.setColor(QPalette.Base, QColor('#383C4A'))
#self.visibleLw.setPalette(palette)
self.visibleLw.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.visibleLw.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.visibleLw.itemActivated.connect(self.onActivation)
self.scrollBar = QScrollBar()
self.visibleLw.verticalScrollBar().valueChanged.connect(self.scrollBar.setValue)
self.scrollBar.valueChanged.connect(self.visibleLw.verticalScrollBar().setValue)
vbox = QVBoxLayout()
vbox.setSpacing(3)
#vbox.setContentsMargins(3, 3, 3, 3)
vbox.setContentsMargins(0, 4, 0, 0)
vbox.addWidget(le)
hbox = QHBoxLayout()
hbox.setSpacing(0)
#hbox.setContentsMargins(0, 0, 0, 0)
hbox.addWidget(self.visibleLw)
hbox.addWidget(self.scrollBar)
vbox.addLayout(hbox)
self.setLayout(vbox)
self.setWindowTitle('Music Library')
icon = QIcon.fromTheme('musique')
self.setWindowIcon(icon)
def populateList(self):
self.client = MPDClient()
self.client.connect('localhost', 6600)
self.playlistinfo = self.client.playlistinfo()
self.client.disconnect()
self.playlist = []
#backgroundColor = QColor('#383C4A')
#foregroundColor = QColor('#C1C1C1')
for i in self.playlistinfo:
row = ''
if 'album' in i:
row = row + i['album'] + ' - '
if 'title' in i:
if isinstance(i['title'], str):
row = row + i['title']
else:
row = row + i['title'][0]
if 'artist' in i:
row = row + ' - ' + i['artist']
self.playlist.append(row)
#newRow = QListWidgetItem(row)
#newRow.setBackground(backgroundColor)
#newRow.setForeground(foregroundColor)
#self.lw.addItem(newRow)
self.visibleLw.addItems(self.playlist)
self.visibleLw.setCurrentRow(0)
def get_matches(self, pattern):
self.visibleLw.clear()
pattern = '.*' + pattern.replace(' ', '.*').lower()
regexp = re.compile(pattern)
for i in self.playlist:
if regexp.match(i.lower()):
self.visibleLw.addItem(i)
def formatScrollBar(self):
self.scrollBar.setMaximum(self.visibleLw.verticalScrollBar().maximum())
self.scrollBar.setPageStep(self.visibleLw.verticalScrollBar().pageStep())
def onChanged(self, text):
self.get_matches(text)
self.visibleLw.setCurrentRow(0)
self.scrollBar.setMaximum(self.visibleLw.verticalScrollBar().maximum())
if self.visibleLw.verticalScrollBar().maximum() == 0:
self.scrollBar.setVisible(False)
else:
self.scrollBar.setVisible(True)
def onActivation(self):
selected_song = self.visibleLw.currentItem().text()
for i in range(0, len(self.playlist)):
if selected_song == self.playlist[i]:
self.client.connect('localhost', 6600)
self.client.play(i)
self.client.disconnect()
def keyPressEvent(self, e):
if e.key() == Qt.Key_Down:
self.visibleLw.setFocus()
elif e.key() == Qt.Key_Escape:
self.close()
class BitsWidget(QWidget):
def __init__(self, offset, bit_size, row_width, grid_width, grid_height,
bit_border_threshold) -> None:
super().__init__()
self._app = App()
self._offset = offset
self._bit_size = bit_size
self._row_width = row_width
self._grid_width = grid_width
self._grid_h_offset = 0
self._grid_height = grid_height
self._grid_v_offset = 0
self._one_color = Qt.blue
self._zero_color = Qt.white
self._color_table = [
QColor(self._zero_color).rgb(),
QColor(self._one_color).rgb(),
]
self._bit_border_threshold = bit_border_threshold
self._easter_egg = 0
self._painting = False
self._bits_area = QWidget()
self._h_scrollbar = QScrollBar(orientation=Qt.Horizontal)
self._h_scrollbar.setMinimum(0)
self._h_scrollbar.valueChanged.connect(self._on_scrollbar_change)
self._h_scrollbar.hide()
self._v_scrollbar = QScrollBar(orientation=Qt.Vertical)
self._v_scrollbar.setMinimum(0)
self._v_scrollbar.valueChanged.connect(self._on_scrollbar_change)
self._v_scrollbar.hide()
inner_layout = QVBoxLayout()
inner_layout.setContentsMargins(0, 0, 0, 0)
inner_layout.setSpacing(0)
inner_layout.addWidget(self._bits_area, stretch=1)
inner_layout.addWidget(self._h_scrollbar)
inner_widget = QWidget()
inner_widget.setLayout(inner_layout)
outer_layout = QHBoxLayout()
outer_layout.setContentsMargins(0, 0, 0, 0)
outer_layout.setSpacing(0)
outer_layout.addWidget(inner_widget, stretch=1)
outer_layout.addWidget(self._v_scrollbar)
self.setLayout(outer_layout)
@property
def offset(self) -> int:
return self._offset
@offset.setter
def offset(self, new_offset):
self._offset = new_offset
@property
def bit_size(self) -> int:
return self._bit_size
@bit_size.setter
def bit_size(self, size: int):
self._bit_size = size
@property
def row_width(self) -> int:
return self._row_width
@row_width.setter
def row_width(self, width: int):
self._row_width = width
@property
def grid_width(self) -> int:
return self._grid_width
@grid_width.setter
def grid_width(self, size: int):
self._grid_width = size
@property
def grid_h_offset(self) -> int:
return self._grid_h_offset
@grid_h_offset.setter
def grid_h_offset(self, offset: int):
self._grid_h_offset = offset
@property
def grid_height(self) -> int:
return self._grid_height
@grid_height.setter
def grid_height(self, size: int):
self._grid_height = size
@property
def grid_v_offset(self) -> int:
return self._grid_v_offset
@grid_v_offset.setter
def grid_v_offset(self, offset: int):
self._grid_v_offset = offset
@property
def _bits_area_width(self):
return self._bits_area.width()
@property
def _bits_area_height(self):
return self._bits_area.height()
@property
def _num_rows(self):
return ceil((self._app.num_bits - self._offset) / self._row_width)
def set_bit_border_threshold(self, threshold):
self._bit_border_threshold = threshold
def load_file(self, filename, max_bytes):
self._app.load_file(filename, max_bytes)
def paintEvent(self, a0: QPaintEvent) -> None:
super().paintEvent(a0)
if not self._app.num_bits:
return
self._painting = True
self._set_scrollbars()
self._paint_bits()
self._draw_grid()
self._painting = False
def _paint_bits(self):
visible_columns = self._bits_area_width // self._bit_size
visible_rows = self._bits_area_height // self._bit_size
bitmap = self._app.create_bitmap(
self._offset,
self._row_width,
self._h_scrollbar.value(),
self._v_scrollbar.value(),
visible_rows,
visible_columns,
)
pixmap = self._create_pixmap(bitmap.data, bitmap.width,
bitmap.bytes_per_row)
painter = QPainter(self)
painter.drawPixmap(0, 0, pixmap)
self._draw_bit_separators(painter, pixmap.width(), pixmap.height())
self._draw_last_row_of_bits(painter, bitmap.remainder, pixmap)
painter.end()
def _draw_bit_separators(self, painter: QPainter, right, bottom):
if self._bit_size <= self._bit_border_threshold:
return
painter.setPen(QPen(Qt.black, 1))
self._draw_h_grid(painter, right, bottom, 1, 0)
self._draw_v_grid(painter, right, bottom, 1, 0)
def _draw_last_row_of_bits(self, painter, last_row_of_bits, pixmap):
painter.setPen(
QPen(
Qt.black if self._bit_size > self._bit_border_threshold else
Qt.transparent,
1,
Qt.SolidLine,
))
for i, b in enumerate(last_row_of_bits):
self._draw_bit(painter, i, pixmap.height() // self._bit_size, b)
def _draw_bit(self, painter: QPainter, x, y, bit):
painter.setBrush(
QBrush(self._one_color if bit else self._zero_color,
Qt.SolidPattern))
painter.drawRect(x * self._bit_size, y * self._bit_size,
self._bit_size, self._bit_size)
def _draw_grid(self):
if not self._grid_width and not self._grid_height:
return
if not self._num_rows:
return
painter = QPainter(self)
painter.setPen(QPen(Qt.red, 1, Qt.SolidLine))
right = min(
(self._row_width - self._h_scrollbar.value()) * self._bit_size,
self._bits_area_width,
)
bottom = min(
(self._num_rows - self._v_scrollbar.value()) * self._bit_size,
self._bits_area_height,
)
self._draw_h_grid(
painter,
right,
bottom,
self._grid_width,
self._grid_h_offset - self._h_scrollbar.value(),
)
self._draw_v_grid(
painter,
right,
bottom,
self._grid_height,
self._grid_v_offset - self._v_scrollbar.value(),
)
def _create_pixmap(self, data: bytes, width, bytes_per_row: int):
height = len(data) // bytes_per_row
image = QImage(data, width, height, bytes_per_row, QImage.Format_Mono)
image.setColorTable(self._color_table)
return QPixmap.fromImage(image).scaled(width * self._bit_size,
height * self._bit_size)
def _draw_h_grid(self, painter, right, bottom, grid_width, grid_offset):
if not grid_width:
return
start_offset = grid_offset % grid_width
start = start_offset * self._bit_size
for x in range(start, right + 1, grid_width * self._bit_size):
painter.drawLine(x, 0, x, bottom)
def _draw_v_grid(self, painter, right, bottom, grid_height, grid_offset):
if not grid_height:
return
start_offset = grid_offset % grid_height
start = start_offset * self._bit_size
for y in range(start, bottom + 1, grid_height * self._bit_size):
painter.drawLine(0, y, right, y)
def _set_scrollbars(self):
self._set_h_scrollbar()
v_visibility_changed = self._set_v_scrollbar()
if v_visibility_changed:
h_visibility_changed = self._set_h_scrollbar()
if h_visibility_changed:
self._set_v_scrollbar()
def _set_h_scrollbar(self):
h_scroll_max = self._calc_h_scrollbar_max()
was_visible = self._h_scrollbar.isVisible()
if h_scroll_max > 0:
self._h_scrollbar.setMaximum(h_scroll_max)
self._h_scrollbar.show()
return not was_visible
else:
self._h_scrollbar.setValue(0)
self._h_scrollbar.hide()
return was_visible
def _set_v_scrollbar(self):
v_scroll_max = self._calc_v_scrollbar_max()
was_visible = self._v_scrollbar.isVisible()
if v_scroll_max > 0:
self._v_scrollbar.setMaximum(v_scroll_max)
self._v_scrollbar.show()
return not was_visible
else:
self._v_scrollbar.setValue(0)
self._v_scrollbar.hide()
return was_visible
def _calc_h_scrollbar_max(self):
return self._row_width - (self._bits_area_width // self.bit_size)
def _calc_v_scrollbar_max(self):
visible_rows = self._bits_area_height // self.bit_size
return self._num_rows - visible_rows
def wheelEvent(self, event: QWheelEvent) -> None:
y_delta = event.angleDelta().y()
if y_delta:
notches = ceil(y_delta / 120)
self._v_scrollbar.setValue(self._v_scrollbar.value() - notches)
x_delta = event.angleDelta().x()
if x_delta:
notches = ceil(x_delta / 120)
self._h_scrollbar.setValue(self._h_scrollbar.value() - notches)
def mousePressEvent(self, a0: QMouseEvent) -> None:
if (a0.x() <= self._bit_size and a0.y() <= self._bit_size
and self._easter_egg < 9):
self._easter_egg += 1
elif (self._bit_size <= a0.x() <= self._bit_size * 2
and self._bit_size <= a0.y() <= self._bit_size * 2
and 9 <= self._easter_egg < 12):
self._easter_egg += 1
elif (self._bit_size * 2 <= a0.x() <= self._bit_size * 3
and self._bit_size * 2 <= a0.y() <= self._bit_size * 3
and self._easter_egg == 12):
tmp = self._one_color
self._one_color = self._zero_color
self._zero_color = tmp
self._color_table = [self._color_table[1], self._color_table[0]]
self._easter_egg = 0
else:
self._easter_egg = 0
def _on_scrollbar_change(self):
if not self._painting:
self.repaint()
class MainUi(QMainWindow):
def __init__(self):
super(MainUi, self).__init__()
self.icon = [
'forward', 'sellsy', 'film', 'home', 'download', 'heart',
'comment', 'star', 'question', 'music', 'pause', 'backward'
]
self.column = len(self.icon)
self.num = 10 # 界面头部展示模块数量
self.row = 5
self.init_ui()
def init_ui(self):
self.setWindowIcon(QIcon('./img/index.ico'))
self.setWindowTitle("工具")
# self.setFixedSize(960, 700)
self.resize(960, 700)
# self._center()
self.main_widget = QWidget() # 创建窗口主部件
self.main_layout = QGridLayout() # 创建主部件的网格布局
self.main_widget.setLayout(self.main_layout) # 设置窗口主部件布局为网格布局
# 创建上侧部件
self.up_widget = QWidget()
self.up_widget.setObjectName('up_widget')
self.up_widget.setFixedHeight(80)
self.up_layout = QGridLayout()
self.up_widget.setLayout(self.up_layout)
# 创建滚动条
self.slide = QScrollBar(True)
self.slide.setObjectName('slide_roll_bar')
self.slide.setMaximum(self.column)
self.slide.setMinimum(self.num)
self.slide.valueChanged.connect(self._value_change)
# 创建中侧部件
self.mid_widget = QWidget()
self.mid_widget.setObjectName('mid_widget')
self.mid_layout = QGridLayout()
self.mid_widget.setLayout(self.mid_layout)
# 创建下侧部件
self.down_widget = QWidget()
self.down_widget.setObjectName('down_widget')
self.down_layout = QGridLayout()
self.down_widget.setLayout(self.down_layout)
self.main_layout.addWidget(self.up_widget, 0, 0, 1, self.column)
self.main_layout.addWidget(self.slide, 1, 0, 1, self.column)
self.main_layout.addWidget(self.mid_widget, 2, 2, 1, self.column - 2)
self.main_layout.addWidget(self.down_widget, 3, self.column - 1,
self.row, 1)
self.setCentralWidget(self.main_widget)
# 创建头部（head）
self.head_widget = QWidget()
self.head_layout = QGridLayout()
self.head_widget.setLayout(self.head_layout)
self.load_model_ico(
0, self.num) if self.num < self.column else self.load_model_ico(
0, self.column)
self.up_layout.addWidget(self.head_widget, 0, 0, 0, 0)
# 创建中部（middle）
self.middle_widget = QWidget()
self.middle_layout = QGridLayout()
self.middle_widget.setLayout(self.middle_layout)
for i in range(self.row):
self.middle_icon = QLabel(chr(0xf002) + f'目录_{i}:')
self.middle_icon.setFont(qtawesome.font('fa', 12))
self.middle_input = QLineEdit()
# self.middle_input.setPlaceholderText("请选择文件...")
self.middle_input.setObjectName(f'middle_input_{i}')
self.middle_btn = QPushButton(
qtawesome.icon('fa.film', color='green'), "选择文件")
self.middle_btn.setObjectName(f'middle_btn_{i}')
self.middle_btn.clicked.connect(self.open_dir)
self.middle_layout.addWidget(self.middle_icon, i, 0, 1, 1)
self.middle_layout.addWidget(self.middle_input, i, 1, 1,
self.row - 1)
self.middle_layout.addWidget(self.middle_btn, i, self.row, 1, 1)
self.mid_layout.addWidget(self.middle_widget, 0, 0, 1, 1)
# 创建尾部
self.tail_widget = QWidget()
self.tail_layout = QGridLayout()
self.tail_widget.setLayout(self.tail_layout)
self.tail_btn = QPushButton(
qtawesome.icon('fa.download', color='green'), "运行")
self.tail_layout.addWidget(self.tail_btn, 0, 9, 1, 1)
self.down_layout.addWidget(self.tail_widget, 0, 0, 0, 0)
self.set_style()
self.main_layout.setSpacing(0)
# self.setWindowFlag(Qt.FramelessWindowHint) # 隐藏边框
# self.setWindowOpacity(0.9) # 设置窗口透明度
# self.setAttribute(Qt.WA_TranslucentBackground) # 设置窗口背景透明
def open_dir(self):
response = QFileDialog.getOpenFileName()
if isinstance(response, tuple):
file_path = response[0]
if not os.path.exists(file_path):
return
self.middle_widget.sender().previousInFocusChain().setText(
file_path)
def _value_change(self):
value = self.slide.value()
start = value - self.num
self.statusBar().showMessage(f'Current Value is {value}')
for i in range(self.head_layout.count()):
self.head_layout.itemAt(i).widget().deleteLater()
self.load_model_ico(start, value)
def load_model_ico(self, start, end):
for i in range(start, end):
self.tool_btn = QToolButton()
self.tool_btn.setText(f"{self.icon[i]}") # 设置按钮文本
self.tool_btn.setObjectName(f"{self.icon[i]}") # 设置按钮文本
self.tool_btn.setFixedSize(80, 50)
self.tool_btn.setIcon(
qtawesome.icon(f'fa.{self.icon[i]}', color='white')) # 设置按钮图标
self.tool_btn.setIconSize(QSize(30, 30)) # 设置图标大小
self.tool_btn.setToolButtonStyle(Qt.ToolButtonTextUnderIcon)
self.tool_btn.clicked.connect(self._clicked)
self.head_layout.addWidget(self.tool_btn, 0, i)
def _clicked(self):
text = self.sender().text()
self.statusBar().showMessage(f'Current Value is {text}')
self.change_style(text)
def change_style(self, text):
self.head_widget.setStyleSheet("""
QToolButton{border:none;}
QToolButton:hover{border-bottom:2px solid #F76677;}
#%s{border:2px dotted black;}
""" % text)
def set_style(self):
self.up_widget.setStyleSheet("""
#up_widget{background:gray;}
""")
self.mid_widget.setStyleSheet("""
#mid_widget{
background:white;
border-top-left-radius: 5px;
border-bottom-left-radius: 5px;
}
""")
self.down_widget.setStyleSheet("""
#down_widget{background:darkGray;}
""")
self.head_widget.setStyleSheet("""
QToolButton{
border:none;
}
QToolButton:hover{border-bottom:2px solid #F76677;}
""")
self.middle_widget.setStyleSheet("""
QLineEdit{
border:1px solid gray;
/*border-radius:10px;*/
padding:5px 2px;
}
QPushButton{
border:none;
border-right:1px gray;
border-radius:10px;
width:40%;
padding:5px 2px;
}
QPushButton:hover{
color:red;font-weight: bold;
}
QLabel{
padding:0 0 0 100%;
}
""")
self.tail_widget.setStyleSheet("""
QPushButton{
border:none;
border-right:1px gray;
border-radius:10px;
padding:5px 2px;
}
QPushButton:hover{
color:red;font-weight: bold;
}
""")
def paintEvent(self, event):
# 设置背景颜色
painter = QPainter(self)
background_color = QColor()
background_color.setNamedColor('darkGray')
painter.setBrush(background_color)
painter.drawRect(self.rect())
class ScrollBar(QWidget):
""" 定义一个可以变换样式的滚动条 """
def __init__(self, externalScrollBar=None, parent=None):
super().__init__(parent)
self.externalScrollBar = externalScrollBar
# 实例化两个滚动条
self.minScrollBar = QScrollBar(Qt.Vertical, self)
self.maxScrollBar = QScrollBar(Qt.Vertical, self)
# 实例化一个控制滚动条显示的计时器
self.timer = QTimer(self)
# 初始化
self.initWidget()
self.associateScrollBar()
self.setQss()
def initWidget(self):
""" 初始化小部件 """
self.setFixedWidth(20)
self.minScrollBar.move(15, 0)
self.maxScrollBar.hide()
self.timer.setInterval(2000)
self.timer.timeout.connect(self.showMinScrollBar)
self.setAttribute(Qt.WA_TranslucentBackground)
# 分配ID
self.setObjectName('father')
self.minScrollBar.setObjectName('minScrollBar')
self.maxScrollBar.setObjectName('maxScrollBar')
def adjustSrollBarHeight(self):
""" 根据父级窗口的高度调整滚动条高度 """
if self.parent():
self.minScrollBar.setFixedHeight(self.parent().height() - 153)
self.maxScrollBar.setFixedHeight(self.parent().height() - 153)
def enterEvent(self, e: QEnterEvent):
""" 鼠标进入界面时显示大滚动条并停止秒表 """
self.maxScrollBar.show()
self.minScrollBar.hide()
self.timer.stop()
def leaveEvent(self, e):
""" 鼠标离开打开秒表 """
self.timer.start()
def showMinScrollBar(self):
""" 定时溢出时隐藏大滚动条 """
self.timer.stop()
self.maxScrollBar.hide()
self.minScrollBar.show()
def setQss(self):
""" 设置层叠样式 """
with open(r'resource\css\my_scrollBar.qss', encoding='utf-8') as f:
self.setStyleSheet(f.read())
def associateScrollBar(self):
""" 关联滚动条 """
if self.externalScrollBar:
# 设置最大值
self.minScrollBar.setMaximum(self.externalScrollBar.maximum())
self.maxScrollBar.setMaximum(self.externalScrollBar.maximum())
# 关联滚动条
self.externalScrollBar.valueChanged.connect(
lambda: self.minScrollBar.setValue(self.externalScrollBar.
value()))
self.minScrollBar.valueChanged.connect(self.__minScrollBarChanged)
self.maxScrollBar.valueChanged.connect(
lambda: self.minScrollBar.setValue(self.maxScrollBar.value()))
def __minScrollBarChanged(self):
""" minScrollBar改变时同时改变另外两个滚动条的值 """
self.maxScrollBar.setValue(self.minScrollBar.value())
self.externalScrollBar.setValue(self.minScrollBar.value())
class App(QWidget):
def __init__(self):
super().__init__()
self.title = 'Tomo Control'
self.left = 400
self.top = 400
self.width = 1000
self.height = 600
self.initUI()
self.img_bkg = np.array([])
self.img_tomo = np.array([])
self.img_align = np.array([])
self.img_recon = np.array([])
def initUI(self):
self.setWindowTitle(self.title)
self.setGeometry(self.left, self.top, self.width, self.height)
self.font1 = QtGui.QFont('Arial', 11, QtGui.QFont.Bold)
self.font2 = QtGui.QFont('Arial', 11, QtGui.QFont.Normal)
self.fpath = os.getcwd()
# lb_empty = QLabel()
grid = QGridLayout()
gpbox_prep = self.GP_prepare()
gpbox_recon = self.recon()
grid.addWidget(gpbox_prep, 0, 1)
grid.addWidget(gpbox_recon, 1, 1)
layout = QVBoxLayout()
layout.addLayout(grid)
layout.addWidget(QLabel())
self.setLayout(layout)
# self.resize(640,200)
def GP_prepare(self):
lb_empty = QLabel()
lb_empty2 = QLabel()
lb_empty2.setFixedWidth(30)
gpbox = QGroupBox('Load image')
gpbox.setFont(self.font1)
lb_ld = QLabel()
lb_ld.setFont(self.font2)
lb_ld.setText('Image type:')
lb_ld.setFixedWidth(100)
self.pb_ld = QPushButton('Load image stack')
self.pb_ld.setToolTip('image type: .hdf, .tiff')
self.pb_ld.setFont(self.font2)
self.pb_ld.clicked.connect(self.load_image)
self.pb_ld.setFixedWidth(150)
lb_mod = QLabel()
lb_mod.setFont(self.font2)
lb_mod.setText('Image mode:')
lb_mod.setFixedWidth(100)
file_group = QButtonGroup()
file_group.setExclusive(True)
self.rd_hdf = QRadioButton('hdf')
self.rd_hdf.setChecked(True)
self.rd_tif = QRadioButton('tif')
file_group.addButton(self.rd_hdf)
file_group.addButton(self.rd_tif)
type_group = QButtonGroup()
type_group.setExclusive(True)
self.rd_absp = QRadioButton('Absorption')
self.rd_absp.setFont(self.font2)
self.rd_absp.setChecked(True)
self.rd_flrc = QRadioButton('Fluorescence')
self.rd_flrc.setFont(self.font2)
type_group.addButton(self.rd_absp)
type_group.addButton(self.rd_flrc)
lb_fp = QLabel()
lb_fp.setFont(self.font2)
lb_fp.setText('Image loaded: ')
lb_fp.setFixedWidth(100)
self.lb_ip = QLabel()
self.lb_ip.setFont(self.font2)
hbox1 = QHBoxLayout()
hbox1.addWidget(lb_ld)
hbox1.addWidget(self.rd_hdf)
hbox1.addWidget(self.rd_tif)
hbox1.addWidget(lb_empty2)
hbox1.addWidget(self.pb_ld)
hbox1.addWidget(lb_empty2)
hbox1.addWidget(self.lb_ip)
hbox1.setAlignment(QtCore.Qt.AlignLeft)
hbox2 = QHBoxLayout()
hbox2.addWidget(lb_mod)
hbox2.addWidget(self.rd_absp)
hbox2.addWidget(self.rd_flrc)
hbox2.addWidget(lb_empty)
hbox2.setAlignment(QtCore.Qt.AlignLeft)
vbox = QVBoxLayout()
vbox.addLayout(hbox1)
vbox.addLayout(hbox2)
vbox.setAlignment(QtCore.Qt.AlignLeft)
gpbox.setLayout(vbox)
return gpbox
def recon(self):
lb_empty = QLabel()
lb_empty2 = QLabel()
lb_empty2.setFixedWidth(30)
gpbox = QGroupBox('Tomo reconstruction')
gpbox.setFont(self.font1)
self.canvas1 = MyCanvas()
self.canvas2 = MyCanvas()
pb_rmbg = QPushButton('Remove Bkg')
pb_rmbg.setFont(self.font2)
pb_rmbg.clicked.connect(self.rm_bkg)
pb_rmbg.setFixedWidth(150)
pb_align = QPushButton('Align image')
pb_align.setFont(self.font2)
pb_align.clicked.connect(self.align_img)
pb_align.setFixedWidth(150)
self.sl1 = QScrollBar(QtCore.Qt.Horizontal)
self.sl1.setMaximum(0)
self.sl1.setMinimum(0)
# self.sl1.hide()
self.sl1.valueChanged.connect(lambda: self.sliderval('left'))
self.sl2 = QScrollBar(QtCore.Qt.Horizontal)
self.sl2.setMaximum(0)
self.sl2.setMinimum(0)
# self.sl2.hide()
self.sl2.valueChanged.connect(lambda: self.sliderval('right'))
self.cb1 = QComboBox()
self.cb1.setFont(self.font2)
self.cb1.addItem('Raw image')
self.cb1.addItem('Background')
self.cb1.addItem('Aligned')
self.cb1.addItem('Reconstructed')
self.cb2 = QComboBox()
self.cb2.setFont(self.font2)
self.cb2.addItem('Raw image')
self.cb2.addItem('Background')
self.cb2.addItem('Aligned')
self.cb2.addItem('Reconstructed')
pb_sh1 = QPushButton('Update')
pb_sh1.setToolTip('update left image')
pb_sh1.setFont(self.font2)
pb_sh1.clicked.connect(lambda: self.update_canvas_img('left'))
pb_sh1.setFixedWidth(150)
pb_sh2 = QPushButton('Update')
pb_sh2.setToolTip('update right image')
pb_sh2.setFont(self.font2)
pb_sh2.clicked.connect(lambda: self.update_canvas_img('right'))
pb_sh2.setFixedWidth(150)
hbox = QHBoxLayout()
vbox_pb = QVBoxLayout()
vbox_pb.addWidget(pb_rmbg)
vbox_pb.addWidget(pb_align)
vbox_pb.addWidget(lb_empty)
vbox_pb.setAlignment(QtCore.Qt.AlignTop)
hbox_can_l = QHBoxLayout()
hbox_can_l.addWidget(self.cb1)
hbox_can_l.addWidget(pb_sh1)
hbox_can_r = QHBoxLayout()
hbox_can_r.addWidget(self.cb2)
hbox_can_r.addWidget(pb_sh2)
vbox_can1 = QVBoxLayout()
vbox_can1.addWidget(self.canvas1)
vbox_can1.addWidget(self.sl1)
vbox_can1.addLayout(hbox_can_l)
vbox_can1.setAlignment(QtCore.Qt.AlignLeft)
vbox_can2 = QVBoxLayout()
vbox_can2.addWidget(self.canvas2)
vbox_can2.addWidget(self.sl2)
vbox_can2.addLayout(hbox_can_r)
vbox_can2.setAlignment(QtCore.Qt.AlignLeft)
hbox.addLayout(vbox_pb)
hbox.addLayout(vbox_can1)
hbox.addWidget(lb_empty2)
hbox.addLayout(vbox_can2)
hbox.setAlignment(QtCore.Qt.AlignLeft)
gpbox.setLayout(hbox)
return gpbox
def load_image(self):
options = QFileDialog.Option()
options |= QFileDialog.DontUseNativeDialog
if self.rd_hdf.isChecked() == True: file_type = 'hdf files (*.h5)'
else: file_type = 'tiff files (*.tif)'
fn, _ = QFileDialog.getOpenFileName(tomo,
"QFileDialog.getOpenFileName()",
"",
file_type,
options=options)
self.img_bkg = np.array([])
self.img_tomo = np.array([])
self.img_align = np.array([])
self.img_recon = np.array([])
if fn:
print(fn)
fn_relative = fn.split('/')[-1]
self.lb_ip.setText('{} loaded'.format(fn_relative))
if self.rd_hdf.isChecked() == True: # read hdf file
f = h5py.File(fn, 'r')
try:
self.img_tomo = np.array(f['img_tomo'])
except:
self.img_tomo = np.zeros([1, 100, 100])
print('bkg image not exist')
try:
self.img_bkg = np.array(f['img_bkg_raw'])
except:
self.img_bkg = np.zeros([self.img_tomo.shape])
print('tomo image not exist')
f.close()
else: # read tiff file
self.img_tomo = np.array(io.imread(fn))
if self.img_tomo.shape[0] > 0:
print('total images: ' + str(self.img_tomo.shape[0]))
# self.sl1.show()
# test_img = self.img_tomo[0]
# self.canvas1.update_img_one(test_img)
# self.show_image(test_img)
# def show_image(self, test_img):
# ax = self.figure.add_subplot(111)
# ax.clear()
# ax.imshow(test_img)
# self.canvas.draw()
# def show_image(self, test_img):
# colormap = []
## for i in range(255):
## colormap.append(QtGui.qRgb(i,i,i))
# w, h = test_img.shape
#
# pp = QtGui.QImage(test_img.data, h,w, QtGui.QImage.Format_RGB32)
## if (max(pp.width(), pp.height()) > 600)
## pixmap = QtGui.QPixmap(pp.scaled(pp.width()/2, pp.height()/2))
## else:
# pixmap = QtGui.QPixmap(pp)
# self.lb_pic.setPixmap(pixmap)
def sliderval(self, slide_type):
if slide_type == 'left':
canvas = self.canvas1
img_index = self.sl1.value()
else:
canvas = self.canvas2
img_index = self.sl2.value()
img = canvas.img_stack[img_index]
img = np.array(img)
# self.show_image(img)
canvas.update_img_one(img)
def rm_bkg(self):
pass
def align_img(self):
pass
def update_canvas_img(self, canv):
if canv == 'left':
canvas = self.canvas1
slide = self.sl1
index = self.cb1.currentIndex()
print(str(1) + ' ' + str(index))
else:
canvas = self.canvas2
slide = self.sl2
index = self.cb2.currentIndex()
print(str(2) + ' ' + str(index))
if index == 0:
canvas.img_stack = self.img_tomo
canvas.update_img_stack()
slide.setMaximum(max(self.img_tomo.shape[0] - 1, 0))
elif index == 1:
canvas.img_stack = self.img_bkg
canvas.update_img_stack()
slide.setMaximum(max(self.img_bkg.shape[0] - 1, 0))
elif index == 2:
canvas.img_stack = self.img_align
canvas.update_img_stack()
slide.setMaximum(max(self.img_align.shape[0] - 1, 0))
else:
canvas.img_stack = self.img_recon
canvas.update_img_stack()
slide.setMaximum(max(self.img_recon.shape[0] - 1, 0))
class dicomImage2DdisplayWidget(QWidget):
addSeedsSignal = pyqtSignal(bool)
def __init__(self, **kwargs):
super(dicomImage2DdisplayWidget, self).__init__()
self._face = kwargs.get('face', 0)
self._datas = kwargs.get('datas', 0)
self._Spacing = kwargs.get('spacing', None)
self._low_hu = kwargs.get("low_hu", -1150)
self._high_hu = kwargs.get("high_hu", 3250)
self._axis = 0
#===============Seeds information============================
self.seedsColors = []
self.baseImageSize = 512
self.regionDrawMod = 0
self.drawLayer = []
#===============Regioin draw tool parmeter===================
self.drawPanterbegin = QPoint()
self.drawPanterEnd = QPoint()
self.posX = 0
self.posY = 0
#===============Init UI======================================
self.initUI()
def initUI(self):
self.setGeometry(0, 0, self.baseImageSize, self.baseImageSize)
self.viewLayout = None
self.imLable = QLabel(self)
self.imLable.setScaledContents(True)
self.imData = None
self.topLable = QLabel(self)
self.downLable = QLabel(self)
self.imLable.resize(self.width(), self.height())
self.initDicomParameter()
pass
def initDicomParameter(self):
#============================SetDataParameter===========================
self._color_table = [qRgb(i, i, i) for i in range(64)]
self.datas = self._datas.copy()
self.faceWindowV = self.faceWindowH = max(self.datas.shape)
#============================ChangeFaceSize=============================
self.xSpacing, self.ySpacing, self.zSpacing = self._Spacing
#============================OperationMod===============================
self.OperationMod = 0
self.facePlane = ['mainFaceplane', 'leftFaceplane', 'frontFaceplane']
self.idxSlice = 100
self.currentFace = self.facePlane[self._face]
#============================RegionGrowingParameter=====================
self.PosXY = [150, 75]
# self.seedList = [(self.PosXY[0], self.PosXY[1])]
self.seedList = []
self.seedSelectNum = 0
self.LowAndUpper = [10, 3000]
self.regionArea = []
self.regionDrawSize = 5
self.idxSlicelimt = self.datas.shape[0]
# print(self.datas.shape[0])
#=======================================================================
self.initOperationButton()
self.initDisplayfacePlane()
self.choiceOpreationMod()
pass
def initOperationButton(self):
self.facePlanes = QComboBox(self)
self.facePlanes.addItem(self.facePlane[0])
self.facePlanes.addItem(self.facePlane[1])
self.facePlanes.addItem(self.facePlane[2])
self.facePlanes.setCurrentIndex(self._face)
# self.facePlanes.activated[str].connect(self.faceItem_Choice)
self.facePlanes.currentTextChanged.connect(self.faceItem_Choice)
self.facePlanes.keyPressEvent = self.customComboxKeyEvent
self.facePlanes.move((self.width() - self.facePlanes.width()), 0)
#==================================Active keyBoard event without combobox=======================
# shorcut = QShortcut(QKeySequence(Qt.Key_F), self.facePlanes, activated=self.useforTestKeyEvent)
#===============================================================================================
#================================== Contrul region seed up and low range =======================
regionWide = QRangeSlider(self)
regionWide.setMax(255)
regionWide.setMin(0)
regionWide.setStart(150)
regionWide.setEnd(255)
regionWide.setRange(0, 255)
regionWide.setDrawValues(True)
regionWide.setBackgroundStyle('background: qlineargradient(x1:0, y1:0, x2:0, y2:1, stop:0 #222, stop:1 #333);')
regionWide.handle.setStyleSheet('background: qlineargradient(x1:0, y1:0, x2:0, y2:1, stop:0 #8EE5EE, stop:1 #393);')
regionWide.startValueChanged.connect(self.rangeSliderStartVolue)
regionWide.endValueChanged.connect(self.rangeSliderEndVolue)
#===============================================================================================
self.modCombox = QComboBox(self)
self.modCombox.addItem('Normal')
self.modCombox.addItem('Region')
self.modCombox.setCurrentIndex(self.OperationMod)
# self.modCombox.activated[str].connect(self.mod_Choice)
self.modCombox.currentTextChanged.connect(self.mod_Choice)
self.modCombox.keyPressEvent = self.customComboxKeyEvent
self.modCombox.move((self.width() - self.facePlanes.width() - self.modCombox.width()), 0)
self.layerScrollBar = QScrollBar(Qt.Horizontal, self)
self.layerScrollBar.setGeometry(0, 0, 128, 5)
self.layerScrollBar.setMinimum(0)
self.layerScrollBar.setMaximum(min(self.datas.shape))
self.layerScrollBar.setValue(0)
self.layerScrollBar.sliderMoved.connect(self.selectLayer)
self.BaseBoxLayout = QBoxLayout(QBoxLayout.TopToBottom)
self.BaseBoxLayout.addWidget(self.layerScrollBar, 0)
self.BaseBoxLayout.addWidget(regionWide, 1)
self.BaseBoxLayout.setAlignment(Qt.AlignTop)
self.secondBoxLayout = QBoxLayout(QBoxLayout.LeftToRight)
self.secondBoxLayout.addLayout(self.BaseBoxLayout)
self.secondBoxLayout.addWidget(self.modCombox)
self.secondBoxLayout.addWidget(self.facePlanes)
self.secondBoxLayout.setAlignment(Qt.AlignTop)
self.groupbox = QGroupBox(self)
self.groupbox.setGeometry(28, -64, 512, 64)
self.groupbox.setLayout(self.secondBoxLayout)
self.showButton = QPushButton(self)
self.showButton.setGeometry(0, 0, 16, 16)
self.showButton.clicked.connect(self.playAnimation)
self.initAnimation()
pass
def setGroup_pos(self, apos):
self.groupbox.move(apos.x(), apos.y())
pass
def setSeedsColor(self, lists):
# self.seedList.clear()
# self.seedsColors.clear()
# for i in range(0, len(colorList)):
# self.seedsColors.append(colorList[i][0])
# self.seedList.append(colorList[i][1])
self.seedsColors.append(lists[0])
self.seedList.append(lists[1])
print('seedList:', self.seedList)
pass
def selectSeedinList(self, num):
# tmpS = self.seedList[num]
# tmpC = self.seedsColors[num]
self.seedSelectNum = num
# print(self.seedsColors)
# print(self.seedList)
# print('number is :', num)
# print(tmpC, tmpS)
pass
def removeSeedinList(self, num):
self.seedList.remove(self.seedList[num])
self.choiceDisplayMod()
pass
def rangeSliderStartVolue(self, event):
self.LowAndUpper[0] = event
self.choiceDisplayMod()
pass
def rangeSliderEndVolue(self, event):
self.LowAndUpper[1] = event
self.choiceDisplayMod()
pass
def viewSeedinList(self, event):
if event[0] == True:
print('Open eye is:', event[1])
elif event[0] == False:
print('Close eye is:', event[1])
else:
print('viewSeedinList error.....')
pass
def initAnimation(self):
self.isBoardshow = False
xAxis = self.groupbox.pos().x()
yAxis = self.groupbox.height()
self.groupBoxAnim = QPropertyAnimation(self, b'pos')
self.groupBoxAnim.setDuration(200)
self.groupBoxAnim.setStartValue(QPointF(xAxis, -yAxis))
# self.anim.setKeyValueAt(0.5, QPointF(0, 10))
# self.anim.setKeyValueAt(0.8, QPointF(0, 80))
self.groupBoxAnim.setEndValue(QPointF(xAxis, 0))
self.reverGroupBoxAnim = QPropertyAnimation(self, b'pos')
self.reverGroupBoxAnim.setDuration(200)
self.reverGroupBoxAnim.setStartValue(QPointF(xAxis, 0))
self.reverGroupBoxAnim.setEndValue(QPointF(xAxis, -yAxis))
pass
def playAnimation(self):
print('-----PlayAnimation-----')
if self.isBoardshow == False:
self.reverGroupBoxAnim.stop()
self.groupBoxAnim.start()
self.isBoardshow = True
elif self.isBoardshow == True:
self.groupBoxAnim.stop()
self.reverGroupBoxAnim.start()
self.isBoardshow = False
pass
pos = pyqtProperty(QPointF, fset=setGroup_pos)
def selectLayer(self, event):
self.idxSlice = self.layerScrollBar.value()
self.choiceDisplayMod()
pass
def sliderval(self):
self._low_hu = self.lowHusBar.value()
self._high_hu = self.heighHusBar.value()
self.choiceDisplayMod()
pass
def mod_Choice(self, event):
if event == 'Normal':
self.OperationMod = 0
elif event == 'Region':
self.OperationMod = 1
self.choiceOpreationMod()
pass
def initDisplayfacePlane(self):
if self._face == 0:
self.topfaceView()
elif self._face == 1:
self.leftfaceView()
elif self._face == 2:
self.frontfaceView()
pass
def faceItem_Choice(self, faceEvent):
if faceEvent == self.facePlane[0]:
self.topfaceView()
self.currentFace = self.facePlane[0]
print('main view')
elif faceEvent == self.facePlane[1]:
self.leftfaceView()
self.currentFace = self.facePlane[1]
print('left view')
elif faceEvent == self.facePlane[2]:
self.frontfaceView()
self.currentFace = self.facePlane[2]
print('front view')
self.choiceOpreationMod()
self.getResizeEvent(self.width(), self.height())
pass
#==========================MakeSureDisplayMod=============================
def choiceDisplayMod(self):
if self.OperationMod == 0:
self.drawNomralArea()
elif self.OperationMod == 1:
self.drawGrowingArea()
pass
#=========================================================================
def choiceOpreationMod(self):
if self.OperationMod == 0:
self.imLable.mouseMoveEvent = self.normalModMouseMoveEvent
elif self.OperationMod == 1:
self.imLable.mouseMoveEvent = self.regionModMouseMoveEvent
self.imLable.mousePressEvent = self.regionModMousePressEvent
self.imLable.mouseReleaseEvent = self.regionModMouseReleasedEvent
self.imLable.wheelEvent = self.regionGrowingWheelEvent
self.choiceDisplayMod()
pass
def topfaceView(self):
self.datas = self._datas.copy()
self.idxSlicelimt = self.datas.shape[0]
self.faceWindowH = self.faceWindowV = self.width()
tmpPalete = QPalette()
tmpPalete.setColor(QPalette.Background, QColor(0, 0, 0))
self.setPalette(tmpPalete)
#=======================Init drawLayer===================
self.drawLayer = np.full(self.datas.shape, 0)
print('topfaceView:', self.drawLayer.shape)
pass
def leftfaceView(self):
self.datas = self._datas.copy()
self.datas = np.rot90(self.datas, -1)
self.datas = np.rot90(self.datas, axes=(0, 2))
self.idxSlicelimt = self.datas.shape[0]
self.setScaleSize(max(self.datas.shape), min(self.datas.shape))
tmpPalete = QPalette()
tmpPalete.setColor(QPalette.Background, QColor(0, 0, 0))
self.setPalette(tmpPalete)
#=======================Init drawLayer===================
self.drawLayer = np.full(self.datas.shape, 0)
print('leftfaceView:', self.drawLayer.shape)
pass
def frontfaceView(self):
self.datas = self._datas.copy()
self.datas = np.rot90(self.datas, -1)
self.idxSlicelimt = self.datas.shape[0]
width = self.datas.shape[0]
height = self.datas.shape[1]
depth = self.datas.shape[2]
self.setScaleSize(max(width, height, depth), min(width, height, depth))
tmpPalete = QPalette()
tmpPalete.setColor(QPalette.Background, QColor(0, 0, 0))
self.setPalette(tmpPalete)
#=======================Init drawLayer===================
self.drawLayer = np.full(self.datas.shape, 0)
print('frontfaceView:', self.drawLayer.shape)
pass
def drawNomralArea(self):
self.idxSlice = np.clip(self.idxSlice, 0, self.idxSlicelimt -1)
self.imData = self.datas[self.idxSlice]
self.displayDicomImage()
pass
def drawGrowingArea(self):
self.imgOriginal = SimpleITK.GetImageFromArray(self.datas[self.idxSlice])
self.imgWhiteMatter = SimpleITK.ConnectedThreshold(image1=self.imgOriginal,
seedList=self.seedList,
lower=self.LowAndUpper[0],
upper=self.LowAndUpper[1],
replaceValue=1,
)
self.regionArea = SimpleITK.GetArrayFromImage(self.imgWhiteMatter)
#================if use draw or eraser====================
if np.sum(self.drawLayer[self.idxSlice] != 0) != 0:
self.regionDrawLayerCombinEvent()
self.drawGrowingAreaContour()
pass
def drawGrowingAreaContour(self):
foreColorvalue = 1
self.imgWhiteMatter = SimpleITK.GetImageFromArray(self.regionArea)
self.imgWhiteMatterNoHoles = SimpleITK.VotingBinaryHoleFilling(image1=self.imgWhiteMatter,
radius=[2] * 3,
majorityThreshold=50,
backgroundValue=0,
foregroundValue=foreColorvalue)
regionContour = SimpleITK.LabelContour(self.imgWhiteMatterNoHoles)
# tmpWmatter = self.imgWhiteMatter
# regionContour = tmpWmatter | regionContour
tmpImage = SimpleITK.LabelOverlay(self.imgOriginal, regionContour)
regionContourArray = SimpleITK.GetArrayFromImage(tmpImage)
self.imData = regionContourArray
self.displayDicomImage()
pass
#==============================Key board event ============================================
def customComboxKeyEvent(self, event):
print('ComboxKeyEvent')
pass
def useforTestKeyEvent(self):
print('just test combobox key event')
# self.displayDicomImage()
pass
#==============================Use for display dicom image=================================
def displayDicomImage(self):
if self.imData is not None:
raw_data = self.imData
shape = self.imData.shape
# maxNum = max(shape)
# minNum = min(shape)
raw_data[raw_data < 0] = 0
raw_data[raw_data > 255] = 255
if len(shape) >= 3:
data = raw_data
#=================用于调节对比度的方法=======================
# data = (raw_data - self._low_hu) / self.window_width * 256
# print('---------Update3d--------')
#===========================================================
data = data.astype(np.int8)
tmpImage = QImage(data, shape[1], shape[0], shape[1] * shape[2], QImage.Format_RGB888)
pixmap = QPixmap.fromImage(tmpImage)
# pixmap = pixmap.scaled(self.faceWindowH , self.faceWindowV )
# pixmap = pixmap.scaled(self.xSpacing, self.zSpacing)
# pixmap = pixmap.scaled(1024, 128)
self.imLable.setPixmap(pixmap)
elif len(shape) < 3:
data = raw_data
# data = (raw_data - self._low_hu) / self.window_width * 256
# print('---------Update2d---------')
data = data.astype(np.int8)
tmpImage = QImage(data, shape[1], shape[0], QImage.Format_Grayscale8)
tmpImage.setColorTable(self._color_table)
pixmap = QPixmap.fromImage(tmpImage)
# pixmap = pixmap.scaled(self.faceWindowH, self.faceWindowV)
# pixmap = pixmap.scaled(self.xSpacing, self.zSpacing)
# pixmap = pixmap.scaled(1024, 128)
self.imLable.setPixmap(pixmap)
pass
def normalModMouseMoveEvent(self, event):
if event.buttons() == Qt.LeftButton:
xAxis = event.pos().x()
yAxis = event.pos().y()
self.choiceDisplayMod()
pass
#=============================Region draw layer operation==========================================
def regionDrawLayerEvent(self, x, y, value):
self.regionArea[y - self.regionDrawSize:y + self.regionDrawSize, x - self.regionDrawSize:x + self.regionDrawSize] = value
self.drawLayer[self.idxSlice] = self.regionArea
pass
def regionDrawLayerCombinEvent(self):
self.regionArea = self.drawLayer[self.idxSlice].astype(np.uint8)
pass
#=============================Region mod mouse Press and released event============================
def regionModMousePressEvent(self, event):
if event.buttons() == Qt.LeftButton and self.regionDrawMod != 0:
xAxis = event.pos().x()
yAxis = event.pos().y()
if xAxis >= 0 and yAxis >= 0:
tmpX = math.floor(xAxis * (self.baseImageSize / self.imLable.width()))
tmpY = math.floor(yAxis * (self.baseImageSize / self.imLable.height()))
if self.regionDrawMod == 1:
self.regionDrawLayerEvent(tmpX, tmpY, 1)
elif self.regionDrawMod == 2:
self.regionDrawLayerEvent(tmpX, tmpY, 0)
self.drawGrowingAreaContour()
pass
def regionModMouseReleasedEvent(self, Event):
if Event.buttons() == Qt.RightButton:
print('Right button released')
pass
#==================================================================================================
#=====================================Region mod mouse move event==================================
def regionModMouseMoveEvent(self, event):
self.posX = event.pos().x()
self.posY = event.pos().y()
if event.buttons() == Qt.LeftButton and self.regionDrawMod == 0:
if self.regionDrawMod == 0:
xAxis = event.pos().x()
yAxis = event.pos().y()
if xAxis >= 0 and yAxis >= 0:
self.PosXY[0] = math.floor(xAxis * (self.baseImageSize / self.imLable.width()))
self.PosXY[1] = math.floor(yAxis * (self.baseImageSize / self.imLable.height()))
self.seedList[self.seedSelectNum] = (self.PosXY[0], self.PosXY[1])
else:
print('Region Mod has Nagtive number')
elif event.buttons() == Qt.LeftButton and self.regionDrawMod != 0:
xAxis = event.pos().x()
yAxis = event.pos().y()
if xAxis >= 0 and yAxis >= 0:
tmpX = math.floor(xAxis * (self.baseImageSize / self.imLable.width()))
tmpY = math.floor(yAxis * (self.baseImageSize / self.imLable.height()))
if self.regionDrawMod == 1:
self.regionDrawLayerEvent(tmpX, tmpY, 1)
elif self.regionDrawMod == 2:
self.regionDrawLayerEvent(tmpX, tmpY, 0)
else:
print('regionModMouseMoveEvent regionDrawMod error......')
return
self.drawGrowingAreaContour()
return
else:
print('regionModMouseMoveEvent error......')
self.choiceDisplayMod()
pass
#=================================SetWindowSizeEvent==========================================
def setScaleSize(self, maxnum, minnum):
self.faceWindowH = maxnum
self.faceWindowV = minnum * (max(self.xSpacing, self.ySpacing, self.zSpacing) / min(self.xSpacing, self.ySpacing, self.zSpacing))
pass
def getResizeEvent(self, sizeX, sizeY):
if self.currentFace == self.facePlane[0]:
tmpSize = min(sizeX, sizeY)
self.imLable.resize(tmpSize, tmpSize)
elif self.currentFace == self.facePlane[1]:
#==================Resize Lable===================
self.setScaleSize(min(sizeX, sizeY), min(sizeX, sizeY) * (min(self.datas.shape)/max(self.datas.shape)))
self.imLable.resize(self.faceWindowH, self.faceWindowV)
elif self.currentFace == self.facePlane[2]:
self.setScaleSize(min(sizeX, sizeY), min(sizeX, sizeY) * (min(self.datas.shape) / max(self.datas.shape)))
self.imLable.resize(self.faceWindowH, self.faceWindowV)
#==================Move Lable=====================
maxPosY = max(sizeY, self.imLable.height())
minPoxY = min(sizeY, self.imLable.height())
tmpPosX = np.clip((sizeX - sizeY), 0, max(sizeX, sizeY)) / 2
tmpPosY = (maxPosY - minPoxY) / 2
self.imLable.move(tmpPosX, tmpPosY)
pass
#===========================mousewheelEvent==================================
def regionGrowingWheelEvent(self, event):
angle = event.angleDelta() / 8
angleX = angle.x()
angleY = angle.y()
if angleY > 0:
self.regionDrawSize -= 1
elif angleY < 0:
self.regionDrawSize += 1
pass
#==========================RegionDrawMod=====================
def setRegionDrawMod(self, event):
if event == 0:
self.regionDrawMod = 0
elif event == 1:
self.regionDrawMod = 1
elif event == 2:
self.regionDrawMod = 2
else:
print('setRegionDrawMod error....')
pass
#====================Use for paint or eraser====================
def paintEvent(self, QPaintEvent):
pen1 = QPen(Qt.blue, 1)
q = QPainter(self)
q.setPen(pen1)
q.drawRect(self.posX - 25, self.posY - 25, 50, 50)
# print('paintEvent')
pass
@property
def window_width(self):
return self._high_hu - self._low_hu
#=======================================================================================================================
# pathDicom = "D:/Dicomfile/MT_07/"
# idxSlice = 50
# reader = SimpleITK.ImageSeriesReader()
# filenamesDICOM = reader.GetGDCMSeriesFileNames(pathDicom)
#
# reader.SetFileNames(filenamesDICOM)
# imgOriginals = reader.Execute()
# datas = SimpleITK.GetArrayFromImage(imgOriginals)
# Spacing = imgOriginals.GetSpacing()
#
# if __name__ == '__main__':
# app = QApplication(sys.argv)
# win = dicomImage2DdisplayWidget(face=0, datas= datas, spacing=Spacing)
# win.show()
# sys.exit(app.exec_())
class DollWidget(QWidget):
def __init__(self, usbcom=None, target='0.0.0.0', port=0, name='Uno_Doll'):
super(DollWidget, self).__init__()
self.name = name
self.usbcom = usbcom
self.target = target
self.port = port
self.initUI()
def setName(self, name):
self.name = name
def setValue(self, value):
self.timeline.setValue(value)
self.eyebrowLine.setValue(value)
self.eyeLine.setValue(value)
self.earLine.setValue(value)
self.mouseLine.setValue(value)
def setSlider(self, value):
if value > 0.8 * self.relativeMaximum:
self.relativeMaximum = 1.2 * self.relativeMaximum
self.slider.setValue(int(100 * value / self.relativeMaximum))
def initUI(self):
self.mode = 0
self.time = 0
self.eyebrowEmotion = open('eyebrow.dqbe', 'w+')
self.eyebrowEmotion.seek(0)
self.eyeEmotion = open('eye.dqbe', 'w+')
self.eyeEmotion.seek(0)
self.earEmotion = open('ear.dqbe', 'w+')
self.earEmotion.seek(0)
self.mouseEmotion = open('mouse.dqbe', 'w+')
self.mouseEmotion.seek(0)
self.file = open('emoji.dqpe', 'a+')
self.file.seek(0)
'''mode 1 as play. mode 2 as record. mode 3 as stop. mode 4 as save.'''
self.thisDoll = QCheckBox(self.name, self)
self.eyebrow = QCheckBox('eyebrow', self)
self.eye = QCheckBox('eye', self)
self.ear = QCheckBox('ear', self)
self.mouse = QCheckBox('mouse', self)
self.playBtn = QPushButton('Play', self)
self.recordBtn = QPushButton('Record', self)
self.stopBtn = QPushButton('Stop', self)
self.saveBtn = QPushButton('Save', self)
self.timeline = TimeLine(scale=True)
self.eyebrowLine = TimeLine(scale=False,
emotionPool=self.eyebrowEmotion,
types='eyebrow')
self.eyeLine = TimeLine(scale=False,
emotionPool=self.eyeEmotion,
types='eye')
self.earLine = TimeLine(scale=False,
emotionPool=self.earEmotion,
types='ear')
self.mouseLine = TimeLine(scale=False,
emotionPool=self.mouseEmotion,
types='mouse')
self.slider = QScrollBar(Qt.Horizontal)
self.slider.setMinimum(0)
self.slider.setMaximum(100)
self.relativeMaximum = 15
self.slider.setValue(0)
self.slider.valueChanged.connect(self.valueChange)
self.playBtn.clicked.connect(self.handlePlayBtn)
self.stopBtn.clicked.connect(self.handleStopBtn)
self.recordBtn.clicked.connect(self.handleRecordBtn)
self.saveBtn.clicked.connect(self.handleSaveBtn)
self.thisDoll.stateChanged.connect(
lambda: self.handleCheck(self.thisDoll))
dollcmd.setComPort(self.usbcom)
#UI
layout = QGridLayout(self)
layout.addWidget(self.playBtn, 0, 0, 1, 1)
layout.addWidget(self.recordBtn, 0, 1, 1, 1)
layout.addWidget(self.stopBtn, 0, 2, 1, 1)
layout.addWidget(self.saveBtn, 0, 3, 1, 1)
layout.addWidget(self.thisDoll, 1, 0, 1, 1)
layout.addWidget(self.eyebrow, 2, 1, 1, 1)
layout.addWidget(self.eye, 3, 1, 1, 1)
layout.addWidget(self.ear, 4, 1, 1, 1)
layout.addWidget(self.mouse, 5, 1, 1, 1)
scroll = QScrollArea()
scroll.setWidgetResizable(True)
self.scrollContent = QWidget(scroll)
scrollLayout = QVBoxLayout(self.scrollContent)
self.scrollContent.setLayout(scrollLayout)
scrollLayout.addWidget(self.timeline)
scrollLayout.addWidget(self.eyebrowLine)
scrollLayout.addWidget(self.eyeLine)
scrollLayout.addWidget(self.earLine)
scrollLayout.addWidget(self.mouseLine)
scroll.setWidget(self.scrollContent)
layout.addWidget(self.slider, 0, 4, 1, 7)
layout.addWidget(self.scrollContent, 1, 4, 5, 7)
self.show()
def valueChange(self):
s = self.slider.value()
value = (s * self.relativeMaximum * 0.01)
self.setValue(value)
if self.mode != 1 and self.mode != 2 and self.mode != 4:
self.time = value * 20
def handleCheck(self, this):
if this.isChecked():
state = Qt.Checked
else:
state = Qt.Unchecked
self.eye.setCheckState(state)
self.eyebrow.setCheckState(state)
self.ear.setCheckState(state)
self.mouse.setCheckState(state)
def handlePlayBtn(self):
self.mode = 1
self.handleIO()
def handleStopBtn(self):
self.mode = 3
def handleRecordBtn(self):
self.mode = 2
self.handleIO()
def handleSaveBtn(self):
self.mode = 4
self.handleIO()
'''
eyebrow and eye
jd1[0] 1023 = left, 0 = right
jd1[1] 1023 = up. , 0 = down
ear
1023. = up, 0 = down
'''
def handleIO(self):
if self.mode == 1:
data = self.file.readline()
#dollcmd.sendUDP()
self.time += 1
self.setValue(self.time * 0.05)
self.setSlider(self.time * 0.05)
QTimer.singleShot(50, self.handleIO)
if self.mode == 2:
data = dollcmd.handleIOData()
self.file.write(data)
#dollcmd.sendUDP(data)
if '\n' in data:
self.eyebrowEmotion.seek(self.time * 12)
self.eyeEmotion.seek(self.time * 12)
self.earEmotion.seek(self.time * 12)
self.mouseEmotion.seek(self.time * 12)
lists = data.replace('\n', '').split(',')
#ear
if int(lists[0]) > 512: i = 0
else: i = 1
i *= 3
if int(lists[1]) > 512: i += 0
else: i += 1
self.earEmotion.write('{}@{}\n'.format(
str(self.time).zfill(8), str(i)))
#ear
#eyebrow
if int(lists[2]) > 682: i = 0
elif int(lists[2]) > 341: i = 1
else: i = 2
i *= 3
if int(lists[3]) > 682: i += 0
elif int(lists[3]) > 341: i += 1
else: i += 2
self.eyebrowEmotion.write('{}@{}\n'.format(
str(self.time).zfill(8), str(i)))
#eyebrow
#eye
if int(lists[6]) > 682: i = 0
elif int(lists[6]) > 341: i = 1
else: i = 2
i *= 3
if int(lists[7]) > 682: i += 0
elif int(lists[7]) > 341: i += 1
else: i += 2
self.eyeEmotion.write('{}@{}\n'.format(
str(self.time).zfill(8), str(i)))
#eye
#mouse
if int(lists[10]) > 682: i = 0
elif int(lists[10]) > 341: i = 1
else: i = 2
i *= 3
if int(lists[11]) > 682: i += 0
elif int(lists[11]) > 341: i += 1
else: i += 2
self.mouseEmotion.write('{}@{}\n'.format(
str(self.time).zfill(8), str(i)))
#mouse
self.time += 1
self.setValue(self.time * 0.05)
self.setSlider(self.time * 0.05)
QTimer.singleShot(50, self.handleIO)
if self.mode == 3:
pass
if self.mode == 4:
pass
def mousePressEvent(self, event):
pass
def mouseMoveEvent(self, event):
pass
class EditorMapComponent:
current = None
def __init__(self, tabbed=True, parent=None):
EditorMapComponent.current = self
self.workspace = Workspace()
self.gc_state = GraphicContextState()
if tabbed:
self.tab_widget = QTabWidget(parent)
self.widget = QWidget(self.tab_widget)
self.tab_widget.addTab(self.widget, "A Label")
else:
self.tab_widget = None
self.widget = QWidget(parent)
self.layout = QGridLayout(self.widget)
self.layout.setContentsMargins(0, 0, 0, 0)
self.layout.setHorizontalSpacing(0)
self.layout.setVerticalSpacing(0)
self.scroll_horz = QScrollBar(Qt.Horizontal)
self.scroll_vert = QScrollBar(Qt.Vertical)
self.editormap_widget = EditorMapWidget(self, None)
self.scroll_horz.valueChanged.connect(self.move_to_x)
self.scroll_vert.valueChanged.connect(self.move_to_y)
self.layout.addWidget(self.editormap_widget, 0, 0)
self.layout.addWidget(self.scroll_horz, 1, 0)
self.layout.addWidget(self.scroll_vert, 0, 1)
self.sig_drop = Signal()
self.editormap_widget.sig_drop.connect(self.on_drop)
def on_drop(self, data, pos):
"""sends (brush, pos)"""
brush_id = pickle.loads(data)
brush = ObjectSelector.current.get_brush(brush_id)
return self.sig_drop(brush, pos)
def get_workspace(self):
return self.workspace
def grab_mouse(self):
self.editormap_widget.grabMouse()
def release_mouse(self):
self.editormap_widget.releaseMouse()
# ifdef GRUMBEL
# void
# EditorMapComponentImpl::on_key_down(const CL_InputEvent& event)
# {
# if (event.id >= 0 && event.id < 256)
# {
# Rect rect = parent.get_position()
# key_bindings[event.id](CL_Mouse::get_x() - rect.left,
# CL_Mouse::get_y() - rect.top)
# }
# if (event.repeat_count == 0)
# {
# Rect rect = parent.get_position()
# CL_InputEvent ev2 = event
# ev2.mouse_pos = Point(CL_Mouse::get_x() - rect.left,
# CL_Mouse::get_y() - rect.top)
# workspace.key_down(InputEvent(ev2))
# }
# }
# void
# EditorMapComponentImpl::on_key_up(const CL_InputEvent& event)
# {
# Rect rect = parent.get_position()
# CL_InputEvent ev2 = event
# ev2.mouse_pos = Point(CL_Mouse::get_x() - rect.left,
# CL_Mouse::get_y() - rect.top)
# workspace.key_up(InputEvent(ev2))
# }
# void
# EditorMapComponentImpl::draw ()
# {
# if (workspace.get_map().is_null()) return
# Display::push_cliprect(parent.get_screen_rect())
# Display::push_modelview()
# Display::add_translate(parent.get_screen_x(), parent.get_screen_y())
# // Update scrollbars (FIXME: move me to function)
# scrollbar_v.set_range(0, workspace.get_map().get_bounding_rect().height)
# scrollbar_v.set_pagesize(parent.height/gc_state.get_zoom())
# scrollbar_v.set_pos(gc_state.get_pos().y)
# scrollbar_h.set_range(0, workspace.get_map().get_bounding_rect().width)
# scrollbar_h.set_pagesize(parent.width/gc_state.get_zoom())
# scrollbar_h.set_pos(gc_state.get_pos().x)
# gc_state.push()
# {
# GraphicContext gc(gc_state, CL_Display::get_current_window().get_gc())
# workspace.draw(gc)
# }
# gc_state.pop()
# Display::pop_modelview()
# Display::pop_cliprect()
# }
# endif
def screen2world(self, pos):
return self.gc_state.screen2world(pos)
def set_zoom(self, z):
self.gc_state.set_zoom(z)
self.editormap_widget.repaint()
self.update_scrollbars()
def zoom_out(self, pos):
self.gc_state.set_zoom(self.gc_state.get_zoom() / 1.25,
Pointf(pos.x, pos.y))
self.editormap_widget.repaint()
self.update_scrollbars()
def zoom_in(self, pos):
self.gc_state.set_zoom(self.gc_state.get_zoom() * 1.25,
Pointf(pos.x, pos.y))
self.editormap_widget.repaint()
self.update_scrollbars()
def zoom_to(self, rect):
self.gc_state.zoom_to(rect)
self.editormap_widget.repaint()
self.update_scrollbars()
def get_clip_rect(self):
return self.gc_state.get_clip_rect()
def move_to(self, x, y):
self.gc_state.set_pos(Pointf(x, y))
self.editormap_widget.repaint()
self.update_scrollbars()
def move_to_x(self, x):
self.gc_state.set_pos(Pointf(x, self.gc_state.get_pos().y))
self.editormap_widget.repaint()
self.update_scrollbars()
def move_to_y(self, y):
self.gc_state.set_pos(Pointf(self.gc_state.get_pos().x, y))
self.editormap_widget.repaint()
self.update_scrollbars()
def sig_on_key(self, keyseq_str):
key_sequence = QKeySequence(keyseq_str)
if key_sequence.isEmpty():
raise RuntimeError("invalid key binding: '%s'" % keyseq_str)
shortcut = QShortcut(key_sequence, self.editormap_widget)
signal = Signal()
def on_key(*args):
pos = self.editormap_widget.mapFromGlobal(QCursor.pos())
# pos = self.gc_state.screen2world(Point.from_qt(pos))
signal(pos.x(), pos.y())
shortcut.activated.connect(on_key)
return signal
def get_gc_state(self):
return self.gc_state
def get_widget(self):
return self.tab_widget or self.widget
def update_scrollbars(self):
rect = self.workspace.get_map().get_bounding_rect()
border = 128
self.scroll_horz.setMinimum(rect.left - border)
self.scroll_horz.setMaximum(rect.right + border)
self.scroll_horz.setPageStep(self.editormap_widget.width())
self.scroll_horz.setSliderPosition(int(self.gc_state.get_pos().x))
self.scroll_vert.setMinimum(rect.top - border)
self.scroll_vert.setMaximum(rect.bottom + border)
self.scroll_vert.setPageStep(self.editormap_widget.height())
self.scroll_vert.setSliderPosition(int(self.gc_state.get_pos().y))
def set_sector_tab_label(self, index, text):
self.tab_widget.setTabText(index, "Sector \"%s\"" % text)
def reset_scrollbar(self, scrollbar_preview: QScrollBar):
scrollbar_preview.setValue(self.sprite_preview_model.selected_sprite)
if self.sprite_preview_model.sprites is not None:
scrollbar_preview.setMaximum(
len(self.sprite_preview_model.sprites) - 1)
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")
group1.setCheckable(True)
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")
group2.setCheckable(True)
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")
group3.setCheckable(True)
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)
class Example(QMainWindow):
def __init__(self):
super().__init__()
self.background = QWidget(self)
self.background.setGeometry(30, 20, 609, 321)
self.background.setAutoFillBackground(True)
p = self.background.palette()
p.setColor(self.background.backgroundRole(), Qt.cyan)
self.background.setPalette(p)
loadUi("untitled.ui", self)
self.initUI()
def initUI(self):
self.resize(1200, 650)
self.move(300, 200)
self.setWindowTitle('Map Editor v0.1')
self.setWindowIcon(QIcon('web.png'))
self.actualTexture = 0
self.mapInfo = numpy.zeros(
4, dtype=int
) # Wielkość X mapy, wielkość Y mapy, pozycja X portalu, pozycja Y portalu
self.mtiles = {}
self.mtilesHp = {}
self.mpickups = {}
self.mtraps = {}
self.menemies = {}
self.playerPos = {}
# MENU
self.flipButton.hide()
self.hpLabel.hide()
self.hpEditor.hide()
self.armorLabel.hide()
self.armorEditor.hide()
self.mhpl.hide() # max hp label
self.marl.hide() # max armor label
self.mhpe.hide() # max hp editor
self.mare.hide() # max armor editor
self.hpEditor.valueChanged.connect(self.setMaxParameters)
self.armorEditor.valueChanged.connect(self.setMaxParameters)
self.playerInfo = numpy.zeros(6, dtype=int)
# scrolle do przewijania mapy
self.scrollX = QScrollBar(Qt.Horizontal, self)
self.scrollX.setGeometry(30, 341, 609, 16)
self.scrollY = QScrollBar(Qt.Vertical, self)
self.scrollY.setGeometry(638, 20, 16, 320)
self.scrollX.valueChanged.connect(self.prepareMap)
self.scrollY.valueChanged.connect(self.prepareMap)
self.checkButton.clicked.connect(self.checkInfo)
self.button = 1
self.tiles = [
self.tile1, self.tile2, self.tile3, self.tile4, self.tile5,
self.tile6, self.tile7, self.tile8, self.tile9, self.tile10,
self.tile11, self.tile12, self.tile13, self.tile14, self.tile15,
self.tile16, self.tile17, self.tile18, self.tile19, self.tile20,
self.tile21, self.tile22, self.tile23, self.tile24, self.tile25,
self.tile26, self.tile27, self.tile28, self.tile29, self.tile30,
self.tile31, self.tile32, self.tile33, self.tile34, self.tile35,
self.tile36, self.tile37, self.tile38, self.tile39, self.tile40,
self.tile41, self.tile42, self.tile43, self.tile44, self.tile45,
self.tile46, self.tile47, self.tile48, self.tile49, self.tile50,
self.tile51, self.tile52, self.tile53, self.tile54, self.tile55,
self.tile56, self.tile57, self.tile58, self.tile59, self.tile60,
self.tile61, self.tile62, self.tile63, self.tile64, self.tile65,
self.tile66, self.tile67, self.tile68, self.tile69, self.tile70,
self.tile71, self.tile72, self.tile73, self.tile74, self.tile75,
self.tile76, self.tile77, self.tile78, self.tile79, self.tile80,
self.tile81, self.tile82, self.tile83, self.tile84, self.tile85,
self.tile86, self.tile87, self.tile88, self.tile89, self.tile90,
self.tile91, self.tile92, self.tile93, self.tile94, self.tile95,
self.tile96, self.tile97, self.tile98, self.tile99, self.tile100,
self.tile101, self.tile102, self.tile103, self.tile104,
self.tile105, self.tile106, self.tile107, self.tile108,
self.tile109, self.tile110, self.tile111, self.tile112,
self.tile113, self.tile114, self.tile115, self.tile116,
self.tile117, self.tile118, self.tile119, self.tile120,
self.tile121, self.tile122, self.tile123, self.tile124,
self.tile125, self.tile126, self.tile127, self.tile128,
self.tile129, self.tile130, self.tile131, self.tile132,
self.tile133, self.tile134, self.tile135, self.tile136,
self.tile137, self.tile138, self.tile139, self.tile140,
self.tile141, self.tile142, self.tile143, self.tile144,
self.tile145, self.tile146, self.tile147, self.tile148,
self.tile149, self.tile150, self.tile151, self.tile152,
self.tile153, self.tile154, self.tile155, self.tile156,
self.tile157, self.tile158, self.tile159, self.tile160,
self.tile161, self.tile162, self.tile163, self.tile164,
self.tile165, self.tile166, self.tile167, self.tile168,
self.tile169, self.tile170, self.tile171, self.tile172,
self.tile173, self.tile174, self.tile175, self.tile176,
self.tile177, self.tile178, self.tile179, self.tile180,
self.tile181, self.tile182, self.tile183, self.tile184,
self.tile185, self.tile186, self.tile187, self.tile188,
self.tile189, self.tile190
]
self.enemies = [
self.enemy1, self.enemy2, self.enemy3, self.enemy4, self.enemy5,
self.enemy6, self.enemy7, self.enemy8, self.enemy9, self.enemy10,
self.enemy11, self.enemy12, self.enemy13, self.enemy14,
self.enemy15, self.enemy16, self.enemy17, self.enemy18,
self.enemy19, self.enemy20, self.enemy21, self.enemy22,
self.enemy23, self.enemy24, self.enemy25, self.enemy26,
self.enemy27, self.enemy28, self.enemy29, self.enemy30,
self.enemy31, self.enemy32, self.enemy33, self.enemy34,
self.enemy35, self.enemy36, self.enemy37, self.enemy38,
self.enemy39, self.enemy40, self.enemy41, self.enemy42,
self.enemy43, self.enemy44, self.enemy45, self.enemy46,
self.enemy47, self.enemy48, self.enemy49, self.enemy50,
self.enemy51, self.enemy52, self.enemy53, self.enemy54,
self.enemy55, self.enemy56, self.enemy57, self.enemy58,
self.enemy59, self.enemy60, self.enemy61, self.enemy62,
self.enemy63, self.enemy64, self.enemy65, self.enemy66,
self.enemy67, self.enemy68, self.enemy69, self.enemy70,
self.enemy71, self.enemy72, self.enemy73, self.enemy74,
self.enemy75, self.enemy76, self.enemy77, self.enemy78,
self.enemy79, self.enemy80, self.enemy81, self.enemy82,
self.enemy83, self.enemy84, self.enemy85, self.enemy86,
self.enemy87, self.enemy88, self.enemy89, self.enemy90,
self.enemy91, self.enemy92, self.enemy93, self.enemy94,
self.enemy95, self.enemy96, self.enemy97, self.enemy98,
self.enemy99, self.enemy100, self.enemy101, self.enemy102,
self.enemy103, self.enemy104, self.enemy105, self.enemy106,
self.enemy107, self.enemy108, self.enemy109, self.enemy110,
self.enemy111, self.enemy112, self.enemy113, self.enemy114,
self.enemy115, self.enemy116, self.enemy117, self.enemy118,
self.enemy119, self.enemy120, self.enemy121, self.enemy122,
self.enemy123, self.enemy124, self.enemy125, self.enemy126,
self.enemy127, self.enemy128, self.enemy129, self.enemy130,
self.enemy131, self.enemy132, self.enemy133, self.enemy134,
self.enemy135, self.enemy136, self.enemy137, self.enemy138,
self.enemy139, self.enemy140, self.enemy141, self.enemy142,
self.enemy143, self.enemy144, self.enemy145, self.enemy146,
self.enemy147, self.enemy148, self.enemy149, self.enemy150,
self.enemy151, self.enemy152, self.enemy153, self.enemy154,
self.enemy155, self.enemy156, self.enemy157, self.enemy158,
self.enemy159, self.enemy160, self.enemy161, self.enemy162,
self.enemy163, self.enemy164, self.enemy165, self.enemy166,
self.enemy167, self.enemy168, self.enemy169, self.enemy170,
self.enemy171, self.enemy172, self.enemy173, self.enemy174,
self.enemy175, self.enemy176, self.enemy177, self.enemy178,
self.enemy179, self.enemy180, self.enemy181, self.enemy182,
self.enemy183, self.enemy184, self.enemy185, self.enemy186,
self.enemy187, self.enemy188, self.enemy189, self.enemy190
]
self.pickups = [
self.pickup1, self.pickup2, self.pickup3, self.pickup4,
self.pickup5, self.pickup6, self.pickup7, self.pickup8,
self.pickup9, self.pickup10, self.pickup11, self.pickup12,
self.pickup13, self.pickup14, self.pickup15, self.pickup16,
self.pickup17, self.pickup18, self.pickup19, self.pickup20,
self.pickup21, self.pickup22, self.pickup23, self.pickup24,
self.pickup25, self.pickup26, self.pickup27, self.pickup28,
self.pickup29, self.pickup30, self.pickup31, self.pickup32,
self.pickup33, self.pickup34, self.pickup35, self.pickup36,
self.pickup37, self.pickup38, self.pickup39, self.pickup40,
self.pickup41, self.pickup42, self.pickup43, self.pickup44,
self.pickup45, self.pickup46, self.pickup47, self.pickup48,
self.pickup49, self.pickup50, self.pickup51, self.pickup52,
self.pickup53, self.pickup54, self.pickup55, self.pickup56,
self.pickup57, self.pickup58, self.pickup59, self.pickup60,
self.pickup61, self.pickup62, self.pickup63, self.pickup64,
self.pickup65, self.pickup66, self.pickup67, self.pickup68,
self.pickup69, self.pickup70, self.pickup71, self.pickup72,
self.pickup73, self.pickup74, self.pickup75, self.pickup76,
self.pickup77, self.pickup78, self.pickup79, self.pickup80,
self.pickup81, self.pickup82, self.pickup83, self.pickup84,
self.pickup85, self.pickup86, self.pickup87, self.pickup88,
self.pickup89, self.pickup90, self.pickup91, self.pickup92,
self.pickup93, self.pickup94, self.pickup95, self.pickup96,
self.pickup97, self.pickup98, self.pickup99, self.pickup100,
self.pickup101, self.pickup102, self.pickup103, self.pickup104,
self.pickup105, self.pickup106, self.pickup107, self.pickup108,
self.pickup109, self.pickup110, self.pickup111, self.pickup112,
self.pickup113, self.pickup114, self.pickup115, self.pickup116,
self.pickup117, self.pickup118, self.pickup119, self.pickup120,
self.pickup121, self.pickup122, self.pickup123, self.pickup124,
self.pickup125, self.pickup126, self.pickup127, self.pickup128,
self.pickup129, self.pickup130, self.pickup131, self.pickup132,
self.pickup133, self.pickup134, self.pickup135, self.pickup136,
self.pickup137, self.pickup138, self.pickup139, self.pickup140,
self.pickup141, self.pickup142, self.pickup143, self.pickup144,
self.pickup145, self.pickup146, self.pickup147, self.pickup148,
self.pickup149, self.pickup150, self.pickup151, self.pickup152,
self.pickup153, self.pickup154, self.pickup155, self.pickup156,
self.pickup157, self.pickup158, self.pickup159, self.pickup160,
self.pickup161, self.pickup162, self.pickup163, self.pickup164,
self.pickup165, self.pickup166, self.pickup167, self.pickup168,
self.pickup169, self.pickup170, self.pickup171, self.pickup172,
self.pickup173, self.pickup174, self.pickup175, self.pickup176,
self.pickup177, self.pickup178, self.pickup179, self.pickup180,
self.pickup181, self.pickup182, self.pickup183, self.pickup184,
self.pickup185, self.pickup186, self.pickup187, self.pickup188,
self.pickup189, self.pickup190
]
self.traps = [
self.trap1, self.trap2, self.trap3, self.trap4, self.trap5,
self.trap6, self.trap7, self.trap8, self.trap9, self.trap10,
self.trap11, self.trap12, self.trap13, self.trap14, self.trap15,
self.trap16, self.trap17, self.trap18, self.trap19, self.trap20,
self.trap21, self.trap22, self.trap23, self.trap24, self.trap25,
self.trap26, self.trap27, self.trap28, self.trap29, self.trap30,
self.trap31, self.trap32, self.trap33, self.trap34, self.trap35,
self.trap36, self.trap37, self.trap38, self.trap39, self.trap40,
self.trap41, self.trap42, self.trap43, self.trap44, self.trap45,
self.trap46, self.trap47, self.trap48, self.trap49, self.trap50,
self.trap51, self.trap52, self.trap53, self.trap54, self.trap55,
self.trap56, self.trap57, self.trap58, self.trap59, self.trap60,
self.trap61, self.trap62, self.trap63, self.trap64, self.trap65,
self.trap66, self.trap67, self.trap68, self.trap69, self.trap70,
self.trap71, self.trap72, self.trap73, self.trap74, self.trap75,
self.trap76, self.trap77, self.trap78, self.trap79, self.trap80,
self.trap81, self.trap82, self.trap83, self.trap84, self.trap85,
self.trap86, self.trap87, self.trap88, self.trap89, self.trap90,
self.trap91, self.trap92, self.trap93, self.trap94, self.trap95,
self.trap96, self.trap97, self.trap98, self.trap99, self.trap100,
self.trap101, self.trap102, self.trap103, self.trap104,
self.trap105, self.trap106, self.trap107, self.trap108,
self.trap109, self.trap110, self.trap111, self.trap112,
self.trap113, self.trap114, self.trap115, self.trap116,
self.trap117, self.trap118, self.trap119, self.trap120,
self.trap121, self.trap122, self.trap123, self.trap124,
self.trap125, self.trap126, self.trap127, self.trap128,
self.trap129, self.trap130, self.trap131, self.trap132,
self.trap133, self.trap134, self.trap135, self.trap136,
self.trap137, self.trap138, self.trap139, self.trap140,
self.trap141, self.trap142, self.trap143, self.trap144,
self.trap145, self.trap146, self.trap147, self.trap148,
self.trap149, self.trap150, self.trap151, self.trap152,
self.trap153, self.trap154, self.trap155, self.trap156,
self.trap157, self.trap158, self.trap159, self.trap160,
self.trap161, self.trap162, self.trap163, self.trap164,
self.trap165, self.trap166, self.trap167, self.trap168,
self.trap169, self.trap170, self.trap171, self.trap172,
self.trap173, self.trap174, self.trap175, self.trap176,
self.trap177, self.trap178, self.trap179, self.trap180,
self.trap181, self.trap182, self.trap183, self.trap184,
self.trap185, self.trap186, self.trap187, self.trap188,
self.trap189, self.trap190
]
self.names = [
"Brick", "Box", "AK", "Pistol", "Rock", "Shield", "Heart", "Dog",
"Soldier", "Spikes", "Shooter", "Shooter", "Shooter", "Shooter",
"Player", "Portal"
]
self.pixmaps = [
"./textures/blank.png", "./textures/brick.png",
"./textures/box.png", "./textures/ak.png", "./textures/pistol.png",
"./textures/rock.png", "./textures/armor.png",
"./textures/heart.png", "./textures/dog.png",
"./textures/enemy.png", "./textures/spikes.png",
"./textures/shooter1.png", "./textures/shooter2.png",
"./textures/shooter3.png", "./textures/shooter4.png",
"./textures/spawn.png", "./textures/portal.png"
]
self.bpixmaps = [
"./textures/brick.png", "./textures/box.png", "./textures/ak.png",
"./textures/pistol.png", "./textures/rock.png",
"./textures/armor.png", "./textures/heart.png",
"./textures/dog.png", "./textures/enemy.png",
"./textures/spikes.png", "./textures/shooter1.png",
"./textures/shooter2.png", "./textures/shooter3.png",
"./textures/shooter4.png", "./textures/player.png",
"./textures/portal.png"
]
# obrót shootera
self.flip = 0
self.shooterFlip = [
"./textures/shooter1.png", "./textures/shooter2.png",
"./textures/shooter3.png", "./textures/shooter4.png"
]
self.flipButton.clicked.connect(self.changeShooterFlip)
self.buttons = [
self.l1, self.l2, self.l3, self.l4, self.l5, self.l6, self.l7,
self.l8, self.l9, self.l10, self.l11, self.spawnpointButton,
self.endMapButton
]
self.l8.setIconSize(QSize(64, 64))
self.l9.setIconSize(QSize(64, 64))
self.confirmSizeButton.clicked.connect(self.makeArray)
self.saveButton.clicked.connect(self.save)
for button, pixmap, i in zip(self.buttons, self.bpixmaps,
range(1,
len(self.buttons) + 1)):
if i < 12:
button.setIcon(QIcon(QPixmap(pixmap)))
button.setIconSize(QSize(32, 32))
if i > 8:
button.setIconSize(QSize(64, 64))
button.clicked.connect(partial(self.makeMenu, i))
else:
button.clicked.connect(partial(self.makeMenu, i + 3))
self.makeArray()
self.show()
def changeShooterFlip(self):
self.flip = (self.flip + 1) % 4
self.makeMenu(11 + self.flip)
def makeMenu(self, i):
print(i)
self.infoLabel.setText('')
self.actualTexture = i
self.nameLabel.setText(self.names[i - 1])
self.podglad.setPixmap(QPixmap(self.pixmaps[i]))
self.hpLabel.hide()
self.hpEditor.hide()
self.flipButton.hide()
self.armorLabel.hide()
self.armorEditor.hide()
self.mhpl.hide()
self.marl.hide()
self.mhpe.hide()
self.mare.hide()
if i == 2:
self.hpLabel.show()
self.hpEditor.show()
if i == 11:
self.flip = 0
if 11 <= i < 15:
self.flipButton.show()
if i == 8 or i == 9:
self.hpLabel.show()
self.hpEditor.show()
self.armorLabel.show()
self.armorEditor.show()
if i == 15:
self.hpLabel.show()
self.hpEditor.show()
self.armorLabel.show()
self.armorEditor.show()
self.mhpl.show()
self.marl.show()
self.mhpe.show()
self.mare.show()
def setMaxParameters(self):
self.mare.setMinimum(self.armorEditor.value())
self.mhpe.setMinimum(self.hpEditor.value())
def makeArray(self):
allOk = 0
sizeX = self.sizeX.toPlainText()
sizeY = self.sizeY.toPlainText()
try:
self.mapInfo[0] = (int)(sizeX)
self.mapInfo[1] = (int)(sizeY)
allOk = 1
except ValueError:
msg = QMessageBox(self)
msg.setIcon(QMessageBox.Information)
msg.setWindowTitle("Information")
msg.setText("Entered data must be numbers!")
msg.show()
if allOk:
if self.mapInfo[0] >= 19 and self.mapInfo[1] >= 10:
self.mtiles = numpy.zeros((self.mapInfo[0], self.mapInfo[1]),
dtype=int)
self.mtilesHp = numpy.zeros((self.mapInfo[0], self.mapInfo[1]),
dtype=int)
self.mpickups = numpy.zeros((self.mapInfo[0], self.mapInfo[1]),
dtype=int)
self.mtraps = numpy.zeros((self.mapInfo[0], self.mapInfo[1]),
dtype=int)
self.menemies = numpy.zeros((self.mapInfo[0], self.mapInfo[1]),
dtype=int)
self.playerPos = numpy.zeros(
(self.mapInfo[0], self.mapInfo[1]), dtype=int)
self.scrollX.setMaximum(self.mapInfo[0] - 19)
self.scrollY.setMaximum(self.mapInfo[1] - 10)
msg = QMessageBox(self)
msg.setIcon(QMessageBox.Information)
msg.setWindowTitle("Information")
msg.setText("Current dimensions: " + sizeX + "x" + sizeY)
msg.show()
self.prepareMap()
else:
msg = QMessageBox(self)
msg.setIcon(QMessageBox.Information)
msg.setWindowTitle("Information")
msg.setText("Dimensions must be >= 19x10")
msg.show()
def prepareMap(self):
for i in range(19):
for j in range(10):
self.tiles[19 * j + i].setPixmap(
QPixmap(self.pixmaps[self.mtiles[i + self.scrollX.value()][
j + self.scrollY.value()]]))
self.pickups[19 * j + i].setPixmap(
QPixmap(self.pixmaps[self.mpickups[
i + self.scrollX.value()][j + self.scrollY.value()]]))
self.traps[19 * j + i].setPixmap(
QPixmap(self.pixmaps[self.mtraps[i + self.scrollX.value()][
j + self.scrollY.value()]]))
pom = self.menemies[i + self.scrollX.value()][
j + self.scrollY.value()] / 100
self.enemies[19 * j + i].setPixmap(
QPixmap(self.pixmaps[int(pom)]).scaled(
32, 32, Qt.KeepAspectRatio))
if self.playerPos[i + self.scrollX.value()][
j + self.scrollY.value()] > 0:
self.enemies[19 * j + i].setPixmap(
QPixmap(self.pixmaps[self.playerPos[
i + self.scrollX.value()][j +
self.scrollY.value()]]))
def mouseMoveEvent(self, event):
self.addItem(event)
def save(self):
if self.mapInfo[2] == 0 and self.mapInfo[3] == 0:
msg = QMessageBox(self)
msg.setIcon(QMessageBox.Information)
msg.setWindowTitle("Information")
msg.setText("Set portal(end of the map)!")
msg.show()
elif self.playerInfo[3] == 0:
msg = QMessageBox(self)
msg.setIcon(QMessageBox.Information)
msg.setWindowTitle("Information")
msg.setText("Set spawnpoint!")
msg.show()
else:
path = QInputDialog.getText(self, "Save map",
"Please input map name:")
if path[1]:
if not os.path.exists("./levels/" + path[0]):
os.makedirs("./levels/" + path[0])
text = " ".join(str(x) for x in self.mtiles)
text = text.translate({ord('['): ''})
text = text.translate({ord(']'): ''})
text = re.sub('0', '00', text).strip()
text = re.sub('1', '01', text).strip()
text = re.sub('2', '02', text).strip()
text = text.replace(" ", " ")
text = text.replace(" ", " ")
text = text.replace(" ", " ")
text = text.replace(" ", " ")
text = text.replace(" ", " ")
text = text.replace("\n", "")
self.saveFile("./levels/" + path[0] + "/map.map", text)
text = " ".join(str(x) for x in self.mtilesHp)
text = text.translate({ord('['): ''})
text = text.translate({ord(']'): ''})
text = text.replace(" ", " ")
text = text.replace(" ", " ")
text = text.replace(" ", " ")
text = text.replace(" ", " ")
text = text.replace(" ", " ")
text = text.replace("\n", "")
self.saveFile("./levels/" + path[0] + "/map.hp", text)
text = " ".join(str(x) for x in self.mtraps)
text = text.translate({ord('['): ''})
text = text.translate({ord(']'): ''})
text = re.sub('10', '1', text).strip()
text = re.sub('11', '2', text).strip()
text = re.sub('12', '3', text).strip()
text = re.sub('13', '4', text).strip()
text = re.sub('14', '5', text).strip()
text = text.replace(" ", " ")
text = text.replace(" ", " ")
text = text.replace(" ", " ")
text = text.replace(" ", " ")
text = text.replace(" ", " ")
text = text.replace("\n", "")
self.saveFile("./levels/" + path[0] + "/map.trap", text)
text = " ".join(str(x) for x in self.mpickups)
text = text.translate({ord('['): ''})
text = text.translate({ord(']'): ''})
text = re.sub('7', '1', text).strip()
text = re.sub('6', '2', text).strip()
text = re.sub('3', '7', text).strip()
text = re.sub('5', '3', text).strip()
text = re.sub('7', '5', text).strip()
text = text.replace(" ", " ")
text = text.replace(" ", " ")
text = text.replace(" ", " ")
text = text.replace(" ", " ")
text = text.replace(" ", " ")
text = text.replace("\n", "")
self.saveFile("./levels/" + path[0] + "/map.pck", text)
text = " ".join(str(x) for x in self.menemies)
#text = re.sub('0', '000', text).strip()
text = re.sub(' ', ' ', text).strip()
text = re.sub(' ', ' ', text).strip()
text = text.translate({ord('['): ''})
text = text.translate({ord(']'): ''})
text = text.replace(" ", " ")
text = text.replace(" ", " ")
text = text.replace(" ", " ")
text = text.replace(" ", " ")
text = text.replace(" ", " ")
text = text.replace("\n", "")
self.saveFile("./levels/" + path[0] + "/map.enm", text)
text = " ".join(str(x) for x in self.playerInfo)
text = text.replace(" ", " ")
text = text.replace(" ", " ")
text = text.replace(" ", " ")
text = text.replace(" ", " ")
text = text.replace(" ", " ")
text = text.replace("\n", "")
self.saveFile("./levels/" + path[0] + "/player.info", text)
text = " ".join(str(x) for x in self.mapInfo)
text = text.translate({ord('['): ''})
text = text.translate({ord(']'): ''})
text = text.replace(" ", " ")
text = text.replace(" ", " ")
text = text.replace(" ", " ")
text = text.replace(" ", " ")
text = text.replace(" ", " ")
text = text.replace("\n", "")
self.saveFile("./levels/" + path[0] + "/map.info", text)
msg = QMessageBox(self)
msg.setIcon(QMessageBox.Information)
msg.setWindowTitle("Information")
msg.setText("Map created successfully!")
msg.show()
else:
msg = QMessageBox(self)
msg.setIcon(QMessageBox.Information)
msg.setWindowTitle("Information")
msg.setText("A map with this name exists!")
msg.show()
def saveFile(self, fileName, text):
f = open(fileName, "a")
f.write(text)
def mousePressEvent(self, event):
if event.button() == 1:
self.button = 1
else:
self.button = 0
self.addItem(event)
def addItem(self, event):
for i in range(19):
for j in range(10):
if (i + 1) * 32 + 30 >= event.x() >= i * 32 + 30 and (
j + 1) * 32 + 20 >= event.y() >= j * 32 + 20:
if (self.button):
if 3 > self.actualTexture > 0:
self.mtiles[i + self.scrollX.value()][
j + self.scrollY.value()] = self.actualTexture
if self.actualTexture == 2:
pom = self.hpEditor.value() / 100.0
self.mtilesHp[i + self.scrollX.value()][
j + self.scrollY.value()] = int(pom)
if 8 > self.actualTexture > 2:
self.mpickups[i + self.scrollX.value()][
j + self.scrollY.value()] = self.actualTexture
if 10 > self.actualTexture > 7:
self.menemies[i + self.scrollX.value(
)][j + self.scrollY.value(
)] = 100 * self.actualTexture + self.hpEditor.value(
) / 10 + self.armorEditor.value() / 100
if self.playerPos[i + self.scrollX.value()][
j + self.scrollY.value()] != 0:
self.playerPos[i + self.scrollX.value()][
j + self.scrollY.value()] = 0
self.playerInfo = numpy.zeros(6, dtype=int)
if 15 > self.actualTexture > 9:
self.mtraps[i + self.scrollX.value()][
j + self.scrollY.value()] = self.actualTexture
if self.actualTexture == 15:
self.playerPos[self.playerInfo[0]][
self.playerInfo[1]] = 0
self.playerInfo[0] = i + self.scrollX.value()
self.playerInfo[1] = j + self.scrollY.value()
self.playerInfo[2] = self.hpEditor.value() / 100
self.playerInfo[3] = self.mhpe.value() / 100
self.playerInfo[4] = self.armorEditor.value() / 100
self.playerInfo[5] = self.mare.value() / 100
self.playerPos[self.playerInfo[0]][
self.playerInfo[1]] = 0
self.playerPos[i + self.scrollX.value()][
j + self.scrollY.value()] = self.actualTexture
self.menemies[i + self.scrollX.value()][
j + self.scrollY.value()] = 0
self.prepareMap()
if self.actualTexture == 16:
self.playerPos[self.mapInfo[2]][
self.mapInfo[3]] = 0
self.mapInfo[2] = i + self.scrollX.value()
self.mapInfo[3] = j + self.scrollY.value()
self.playerPos[i + self.scrollX.value()][
j + self.scrollY.value()] = self.actualTexture
self.menemies[i + self.scrollX.value()][
j + self.scrollY.value()] = 0
self.prepareMap()
if self.actualTexture == 0:
if (self.playerPos[i + self.scrollX.value()][
j + self.scrollY.value()]) != 0:
text = "HP: " + str(
self.playerInfo[2] *
100) + " Max HP: " + str(
self.playerInfo[3] *
100) + "\nArmor: " + str(
self.playerInfo[4] *
100) + " Max Armor: " + str(
self.playerInfo[5] * 100)
self.infoLabel.setText(text)
if (self.mtilesHp[i + self.scrollX.value()][
j + self.scrollY.value()]) != 0:
text = "HP: " + str(
self.mtilesHp[i + self.scrollX.value()][
j + self.scrollY.value()] * 100)
self.infoLabel.setText(text)
if (self.menemies[i + self.scrollX.value()][
j + self.scrollY.value()]) != 0:
pom = str(
self.menemies[i + self.scrollX.value()][
j + self.scrollY.value()])
text = "HP: " + str(
int(pom[1]) * 100) + "\nArmor: " + str(
int(pom[2]) * 100)
self.infoLabel.setText(text)
else:
self.mtiles[i + self.scrollX.value()][
j + self.scrollY.value()] = 0
self.mpickups[i + self.scrollX.value()][
j + self.scrollY.value()] = 0
self.mtraps[i + self.scrollX.value()][
j + self.scrollY.value()] = 0
self.menemies[i + self.scrollX.value()][
j + self.scrollY.value()] = 0
if self.playerPos[i + self.scrollX.value()][
j + self.scrollY.value()] != 0:
self.playerPos[i + self.scrollX.value()][
j + self.scrollY.value()] = 0
self.playerInfo = numpy.zeros(6, dtype=int)
self.prepareMap()
self.update()
def checkInfo(self):
self.makeMenu(0)
class ControlEventsGraph(ControlBase, QWidget):
"""
Timeline events editor
"""
def __init__(self, label="", default=0, min=0, max=100, **kwargs):
"""
:param label:
:param default:
:param min:
:param max:
:param kwargs:
"""
QWidget.__init__(self)
ControlBase.__init__(self, label, default, **kwargs)
self.add_popup_menu_option('Export to CSV', self.__export)
def init_form(self):
vlayout = QVBoxLayout()
if conf.PYFORMS_USE_QT5:
vlayout.setContentsMargins(0,0,0,0)
else:
vlayout.setMargin(0)
self.setLayout(vlayout)
self._scroll = QScrollBar(QtCore.Qt.Horizontal)
scrollarea = QScrollArea()
scrollarea.setMinimumHeight(140)
scrollarea.setWidgetResizable(True)
self._events_widget = EventsWidget(scroll=self._scroll)
scrollarea.setWidget(self._events_widget)
self._scroll.actionTriggered.connect(self.__scroll_changed)
vlayout.addWidget(scrollarea) # The timeline widget
vlayout.addWidget(self._scroll) # Add scroll
self._scroll.setMaximum(0)
self._scroll.setSliderPosition(0)
##########################################################################
#### HELPERS/PUBLIC FUNCTIONS ############################################
##########################################################################
def add_track(self, title=None):
"""
:param title:
"""
self._events_widget.add_track(title)
def add_event(self, begin, end, title='', track=0, color='#FFFF00'):
"""
:param begin:
:param end:
:param title:
:param track:
:param color:
:return:
"""
return self._events_widget.add_event(begin, end, title, track, color)
##########################################################################
#### EVENTS ##############################################################
##########################################################################
def __scroll_changed(self, change): self.repaint()
def get_export_filename(self): return "untitled.csv"
def __export(self):
"""Export annotations to a file."""
filename = QFileDialog.getSaveFileName(parent=self,
caption="Export annotations file",
directory=self.get_export_filename(),
filter="CSV Files (*.csv)",
options=QFileDialog.DontUseNativeDialog)
if filename != '':
self.export_csv(filename)
def export_csv(self, filename):
"""
Export annotations to a file.
:param str filename: filename to open
"""
with open(filename, 'wb') as csvfile:
spamwriter = csv.writer(csvfile, dialect='excel')
self._events_widget.export_csv(spamwriter)
def repaint(self):
"""
"""
self._events_widget.repaint()
##########################################################################
#### PROPERTIES ##########################################################
##########################################################################
"""
Overwrite the changed event from the ControlBase
"""
@property
def changed_event(self): return self._events_widget._pointer.moveEvent
@changed_event.setter
def changed_event(self, value): self._events_widget._pointer.moveEvent = value
@property
def value(self): return self._events_widget.position
@value.setter
def value(self, value): self._events_widget.position = value
@property
def form(self): return self
@property
def tracks(self): return self._events_widget.tracks
@property
def tracks_height(self): return self._events_widget.tracks_height
@tracks_height.setter
def tracks_height(self, value): self._events_widget.tracks_height = value
@property
def scale(self): return self._events_widget.scale
@scale.setter
def scale(self, value): self._events_widget.scale = value
class CentralWidget(QWidget):
repaintChartsEvent = QtCore.pyqtSignal()
def __init__(self, window):
super().__init__()
self.windowWidget = window
self.repaintChartsEvent.connect(self.init_charts)
grid = QVBoxLayout()
self.setLayout(grid)
self.fft = False
self.windowWidget.sample_size_select.activated.connect(self.on_sample_size_changed)
def toggle_fft(self, state):
self.fft = bool(state)
self.init_charts()
def clear_widget(self):
for i in reversed(range(self.layout().count())):
self.layout().itemAt(i).widget().setParent(None)
self.charts = []
self.chart_descriptions = []
def init_charts(self):
self.clear_widget()
self.current_sample = 0
self.chart_scroll = QScrollBar(Qt.Horizontal)
self.chart_scroll.valueChanged.connect(self.on_slider_changed)
self.chart_area_scroll = QScrollArea(self)
self.chart_area_scroll.setWidgetResizable(True)
self.layout().addWidget(self.chart_area_scroll)
self.chart_area_scroll_widget = QWidget()
self.chart_area_scroll.setWidget(self.chart_area_scroll_widget)
self.chart_area_scroll_widget.setLayout(QVBoxLayout())
for tembrFile in self.windowWidget.files:
self.add_chart(tembrFile)
self.windowWidget.setGeometry(200, 40, 1200, 500 * len(self.charts))
self.layout().addWidget(self.chart_scroll)
def on_slider_changed(self, e):
self.current_sample = e
self.update_chart_points()
self.update_chart_description()
def on_sample_size_changed(self, i):
for file in self.windowWidget.files:
file.current_sample_size = 2 ** (i + 8)
self.init_charts()
def add_chart(self, tembrFile: TembrFile):
series = QLineSeries()
series.setName(tembrFile.name)
# series.setUseOpenGL(True)
if self.fft:
series.append(tembrFile.fft(self.current_sample))
y_range=None
else:
series.append(tembrFile.get_qpoints_sample(self.current_sample))
y_range=(tembrFile.min, tembrFile.max)
self.charts.append(MyQtChart.MyChartView(series, "Chart", "Time", "Value", minimumSize=QSize(1200, 300), y_range=y_range,
allowZoom=True, allowPan=True, niceNumbers=True, showPoints=False))
self.chart_descriptions.append(QLabel())
self.chart_area_scroll_widget.layout().addWidget(self.chart_descriptions[-1])
self.chart_area_scroll_widget.layout().addWidget(self.charts[-1])
self.chart_scroll.setMaximum(tembrFile.sample_count - 1)
self.windowWidget.sample_size_select.setCurrentIndex(math.log2(tembrFile.current_sample_size) - 8)
self.update_chart_description()
def update_chart_points(self):
for chart, file in zip(self.charts, self.windowWidget.files):
first_serie = chart.chart().series()[0]
if self.fft:
first_serie.replace(file.fft(self.current_sample))
else:
first_serie.replace(file.get_qpoints_sample(self.current_sample))
chart.update_range(first_serie)
def update_chart_description(self):
for descr, file in zip(self.chart_descriptions, self.windowWidget.files):
rms, amplitude = file.rms(self.current_sample), file.amplitude(self.current_sample)
sample = file.get_points_sample(self.current_sample)
descr.setText("Мин: %f, Макс: %f, СКЗ: %f, Амплитуда: %f, Пик фактор: %f" % (min(sample), max(sample), rms, amplitude, amplitude / rms))
class MainWindow(MainWindowBase, MainWindowUI):
VIDEOS = ('front_video_file', 'eyes_video_file')
def __init__(self, manager, parent=None):
MainWindowBase.__init__(self, parent)
self.manager = manager
self.current_segment = None
self.current_video = 0
self.nav_hide_empty = True
self.setupUi(self)
self.setupConnections()
def setupUi(self, parent):
MainWindowUI.setupUi(self, parent)
# content area
layout = QHBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
self.content.setLayout(layout)
# add video widget
self.contentWidget = VideoWidget()
self.content.layout().addWidget(self.contentWidget)
self.prev_code = 'def f(img):\n return img'
self.te_code = PyCodeEdit()
self.te_code.setPlainText(self.prev_code)
self.content.layout().addWidget(self.te_code)
# footer area
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
self.footer.setLayout(layout)
self.bar_index = QScrollBar(Qt.Horizontal)
self.bar_index.setFocusPolicy(Qt.WheelFocus)
self.bar_index.setMinimum(0)
self.bar_index.setSingleStep(1)
self.bar_index.valueChanged.connect(self.indexChanged)
layout.addWidget(self.bar_index)
self.info = QLabel()
layout.addWidget(self.info)
# construct navigation tree
self.refreshNavigation()
# design the view
self.treeView.header().hide() # hide header
self.treeView.expandToDepth(0) # expand first level
def setupConnections(self):
# shortcuts
self.sc_next = QShortcut(QKeySequence("Right"), self)
self.sc_next.activated.connect(self.nextImage)
self.sc_prev = QShortcut(QKeySequence("Left"), self)
self.sc_prev.activated.connect(self.prevImage)
self.treeView.doubleClicked.connect(self.navigation_doubleClicked)
self.pb_video_toggle.clicked.connect(self.toggleVideo)
self.pb_hide_toggle.clicked.connect(self.toggleHideEmpty)
def toggleVideo(self):
self.current_video = (self.current_video + 1) % len(MainWindow.VIDEOS)
self.setSegment(self.current_segment)
def toggleHideEmpty(self):
self.nav_hide_empty = not self.nav_hide_empty
self.refreshNavigation()
def refreshNavigation(self):
items = []
for project_id in self.manager.getProjectNames():
project = self.manager.getProject(project_id)
p_node = NavigationNode(project.info['Name'])
p_node.obj_data = project
items.append(p_node)
for r_id in sorted(p_node.obj_data.getRecordingNames()):
print(r_id)
recording = p_node.obj_data.getRecording(r_id)
print(recording)
if recording:
r_node = NavigationNode(r_id)
r_node.obj_data = recording
p_node.addChild(r_node)
for segment_id in r_node.obj_data.getSegmentIDs():
s_node = NavigationNode(segment_id)
s_node.obj_data = r_node.obj_data.getSegment(
segment_id)
r_node.addChild(s_node)
self.treeView.setSelectionBehavior(QAbstractItemView.SelectRows)
self.treeView.setUniformRowHeights(True)
self.treeView.setModel(NavigationModel(items))
def navigation_doubleClicked(self, _):
item = self.treeView.selectedIndexes()[0]
obj = item.internalPointer().obj_data
if hasattr(obj, 'segments') and obj.segments_data:
obj = obj.segments_data[0]
if hasattr(obj, 'eyes_video_file'):
self.setSegment(obj)
def applyCode(self):
code = self.te_code.toPlainText()
if self.prev_code != code:
try:
exec(code, globals(), locals())
self.contentWidget.onImage = locals()['f']
except Exception as e:
print(e)
def prevImage(self):
self.bar_index.setValue(self.bar_index.value() - 1)
def nextImage(self):
self.bar_index.setValue(self.bar_index.value() + 1)
def setVideo(self, path):
self.contentWidget.openVideo(path)
self.bar_index.setMaximum(self.contentWidget.video.length)
def indexChanged(self, value):
self.applyCode()
video = self.contentWidget.video
video.pos_frame = value
self.contentWidget.updateImage()
info_msg = []
info_msg.append('FPS: %s' % video.fps)
info_msg.append('Frame: %d / %d (%.4f)' %
(video.pos_frame + 1, video.length, video.pos_msec))
self.info.setText('\n'.join(info_msg))
def setSegment(self, segment):
try:
self.current_segment = segment
self.setVideo(
getattr(self.current_segment,
MainWindow.VIDEOS[self.current_video]))
self.bar_index.setValue(0)
self.indexChanged(0)
except:
pass
class VanillaWindow(QMainWindow):
SHIFT = 100
MAX_BRUSH_SIZE = 500
TOOLBAR_HEIGHT = 791
TOOLBAR_WIDTH = 389
BUTTON_SIZE = 64
MENU_BAR_HEIGHT = 30
BUTTON_SHIFT = 20
MINIMUM_CANVAS_LEFT_SHIFT = 250
def __init__(self):
super().__init__()
self.to_draw_canvas = False
self.to_draw_line = False
self.to_draw_rectangle = False
self.to_draw_triangle = False
self.to_draw_ellipse = False
self.to_draw_selection = False
self.cursor_on_canvas = False
self.shape_start = None
self.selection_left = 0
self.selection_right = 0
self.selection_up = 0
self.selection_down = 0
self.selection_width = 0
self.selection_height = 0
self.mouse_pressed = False
self.picture_name = None
self.canvas = Canvas()
self.button_images = {}
self.buttons = {}
self.layer_tables = []
self.init_ui()
def init_ui(self):
self.setWindowTitle('Vanilla')
self.setWindowIcon(QIcon('images/icon.png'))
self.showMaximized()
self.setStyleSheet('QMainWindow{background: Gray;}'
'QMenuBar::item:selected{background: #202020;}'
'QMenu::item:disabled{color: #505050;}'
'QToolTip{background : black; font-size: 16px; color: white; '
'border: black solid 1px}')
self.setMouseTracking(True)
self.create_menu_bar()
self.color_picker = QPushButton('', self)
color_picker_height = 100
self.color_picker.setGeometry(50, self.TOOLBAR_HEIGHT + self.MENU_BAR_HEIGHT - color_picker_height - 50,
100, color_picker_height)
red = Canvas().current_color.r
green = Canvas().current_color.g
blue = Canvas().current_color.b
self.color_picker.setStyleSheet(f'background: Color({red}, {green}, {blue})')
self.color_picker.clicked.connect(self.pick_color)
self.color_picker.show()
self.size_slider = QSlider(Qt.Horizontal, self)
slider_height = 20
self.size_slider.setGeometry(10, self.color_picker.y() - slider_height - 60, 145, slider_height)
self.size_slider.setMinimum(1)
self.size_slider.setMaximum(self.MAX_BRUSH_SIZE)
self.size_slider.valueChanged[int].connect(self.size_changed)
self.size_slider.show()
validator = QIntValidator(1, self.MAX_BRUSH_SIZE)
self.size_edit = QLineEdit('1', self)
self.size_edit.setGeometry(self.size_slider.x() + self.size_slider.width() + 5, self.size_slider.y(), 35, 20)
self.size_edit.setFont(QFont('Arial', 10))
self.size_edit.setAlignment(Qt.AlignCenter)
self.size_edit.setValidator(validator)
self.size_edit.textChanged[str].connect(self.size_edited)
self.size_edit.show()
self.size_label = QLabel('Brush Size:', self)
self.size_label.setFont(QFont('Arial', 16))
self.size_label.setStyleSheet('color: lightGray;')
self.size_label.setGeometry(self.size_slider.x(), self.size_slider.y() - self.size_slider.height() - 10,
self.size_slider.width() + self.size_edit.width() + 5, 30)
self.size_label.show()
self.create_buttons()
width = QDesktopWidget().width()
height = QDesktopWidget().height() - 64
size = 20
self.layer_button_left = width - 220
self.add_layer_button = QPushButton('Add Layer', self)
self.add_layer_button.setGeometry(self.layer_button_left + 24, self.TOOLBAR_HEIGHT - 15, 150, 30)
self.add_layer_button.clicked.connect(self.add_layer)
self.add_layer_button.setFont(QFont('Arial', 14))
self.add_layer_button.show()
self.layers_label = QLabel('Layers', self)
self.layers_label.setFont(QFont('Arial', 20))
self.layers_label.setStyleSheet('color: lightGray;')
self.layers_label.setGeometry(self.layer_button_left, 25, 197, 60)
self.layers_label.setAlignment(Qt.AlignCenter)
self.layers_label.show()
self.vertical_scrollbar = QScrollBar(self)
self.vertical_scrollbar.setGeometry(width - size, 0, size, height - size)
self.vertical_scrollbar.valueChanged[int].connect(self.vertical_scrollbar_value_changed)
self.horizontal_scrollbar = QScrollBar(Qt.Horizontal, self)
self.horizontal_scrollbar.setGeometry(0, height - size, width - size, size)
self.horizontal_scrollbar.valueChanged[int].connect(self.horizontal_scrollbar_value_changed)
self.show()
def create_buttons(self):
left = 25
brush_button = self.create_button(left, self.MENU_BAR_HEIGHT + 20, 'Brush', 'B', self.brush_button_clicked)
self.buttons[Tools.BRUSH] = brush_button
right = brush_button.x() + brush_button.width() + self.BUTTON_SHIFT
eraser_button = self.create_button(right, brush_button.y(), 'Eraser', 'E', self.eraser_button_clicked)
self.buttons[Tools.ERASER] = eraser_button
fill_button = self.create_button(left, self.get_button_shift(brush_button), 'Fill', 'F',
self.fill_button_pressed)
self.buttons[Tools.FILL] = fill_button
selection_button = self.create_button(right, fill_button.y(), 'Selection', 'S', self.selection_button_clicked)
self.buttons[Tools.SELECTION] = selection_button
line_button = self.create_button(left, self.get_button_shift(fill_button), 'Line', 'L',
self.line_button_clicked)
self.buttons[Tools.LINE] = line_button
rectangle_button = self.create_button(right, line_button.y(), 'Rectangle', 'R', self.rectangle_button_clicked)
self.buttons[Tools.SQUARE] = rectangle_button
ellipse_button = self.create_button(left, self.get_button_shift(line_button), 'Ellipse', 'C',
self.ellipse_button_clicked)
self.buttons[Tools.CIRCLE] = ellipse_button
triangle_button = self.create_button(right, ellipse_button.y(), 'Triangle', 'T', self.triangle_button_clicked)
self.buttons[Tools.TRIANGLE] = triangle_button
right_turn_button = self.create_button(left, self.get_button_shift(ellipse_button), 'Turn Right', 'Ctrl+R',
self.turn_selection_right)
left_turn_button = self.create_button(right, right_turn_button.y(), 'Turn Left', 'Ctrl+L',
self.turn_selection_left)
flip_horizontally_button = self.create_button(left, self.get_button_shift(right_turn_button),
'Flip Horizontally', 'Ctrl+H', self.flip_horizontally)
flip_vertically_button = self.create_button(right, flip_horizontally_button.y(), 'Flip Vertically', 'Ctrl+F',
self.flip_vertically)
def create_menu_bar(self):
self.menu_bar = self.menuBar()
self.menu_bar.setStyleSheet('selection-background-color: #202020; background: #393939; color: lightGray;')
file_menu = self.menu_bar.addMenu('&File')
new_action = QAction('&New', self)
new_action.setShortcut('Ctrl+N')
new_action.triggered.connect(self.ask_size)
file_menu.addAction(new_action)
open_action = QAction('&Open', self)
open_action.setShortcut('Ctrl+O')
open_action.triggered.connect(self.open)
file_menu.addAction(open_action)
file_menu.addSeparator()
self.save_action = QAction('&Save', self)
self.save_action.setShortcut('Ctrl+S')
self.save_action.triggered.connect(self.save)
self.save_action.setDisabled(True)
file_menu.addAction(self.save_action)
self.save_as_action = QAction('Save as', self)
self.save_as_action.setShortcut('Ctrl+Shift+S')
self.save_as_action.triggered.connect(self.save_as)
self.save_as_action.setDisabled(True)
file_menu.addAction(self.save_as_action)
image_menu = self.menu_bar.addMenu('&Image')
self.greyscale_action = QAction('Greyscale', self)
self.greyscale_action.setShortcut('Ctrl+G')
self.greyscale_action.triggered.connect(self.change_greyscale)
self.greyscale_action.setDisabled(True)
image_menu.addAction(self.greyscale_action)
self.brightness_action = QAction('Brightness', self)
self.brightness_action.setShortcut('Ctrl+B')
self.brightness_action.triggered.connect(self.brightness)
self.brightness_action.setDisabled(True)
image_menu.addAction(self.brightness_action)
selection_menu = self.menu_bar.addMenu('&Selection')
self.deselect_action = QAction('Deselect', self)
self.deselect_action.setShortcut('Ctrl+D')
self.deselect_action.triggered.connect(self.deselect)
self.deselect_action.setDisabled(True)
selection_menu.addAction(self.deselect_action)
self.select_all_action = QAction('Select All', self)
self.select_all_action.setShortcut('Ctrl+A')
self.select_all_action.triggered.connect(self.select_all)
self.select_all_action.setDisabled(True)
selection_menu.addAction(self.select_all_action)
selection_menu.addSeparator()
self.delete_selection_action = QAction('Delete', self)
self.delete_selection_action.setShortcut('Delete')
self.delete_selection_action.triggered.connect(self.delete_in_selection)
self.delete_selection_action.setDisabled(True)
selection_menu.addAction(self.delete_selection_action)
def create_button(self, x, y, image, shortcut='', action=lambda: None):
button = QPushButton('', self)
button.setGeometry(x, y, self.BUTTON_SIZE, self.BUTTON_SIZE)
button.setStyleSheet('background: transparent;')
button.setShortcut(shortcut)
button.setToolTip(f'{image} ({shortcut})')
button.clicked.connect(action)
self.button_images[button] = QImage(f'images/{image}.png')
button.show()
return button
def flip(self, flip_function):
if not self.canvas.selection_is_on:
return
flip_function()
self.to_draw_selection = False
self.update_canvas()
self.update()
def flip_horizontally(self):
self.flip(self.canvas.flip_horizontally)
def flip_vertically(self):
self.flip(self.canvas.flip_vertically)
def get_button_shift(self, upper_button):
return upper_button.y() + upper_button.height() + self.BUTTON_SHIFT
def turn_selection_right(self):
self.turn_selection(self.canvas.turn_selection_right)
def turn_selection_left(self):
self.turn_selection(self.canvas.turn_selection_left)
def turn_selection(self, turn_function):
if not self.canvas.selection_is_on:
return
turn_function()
self.to_draw_selection = False
self.update_canvas()
self.update()
def create_layer_button(self, x, y, layer_number):
button = QPushButton('', self)
button.setGeometry(x, y, 187, 100)
button.setStyleSheet('background: transparent;')
button.clicked.connect(lambda: self.change_layer(layer_number))
button.show()
return button
def change_layer(self, number):
self.canvas.change_layer(number)
self.update_color_button()
self.update()
def delete_layer(self, layer_table):
self.canvas.delete_layer(layer_table.layer)
self.layer_tables.remove(layer_table)
self.update_canvas()
self.update_layers_buttons()
if len(self.canvas.layers) == 5:
self.add_layer_button.setDisabled(False)
self.update()
def update_layers_buttons(self):
for table in self.layer_tables:
table.close()
self.layer_tables = []
x = self.layer_button_left + 5
for i in range(len(self.canvas.layers)):
layer = self.canvas.layers[i]
btn = self.create_layer_button(x, 90 + i * 105, i)
self.layer_tables.append(LayerTable(x, 90 + i * 105, layer, btn, self))
def add_layer(self):
self.canvas.add_layer()
if len(self.canvas.layers) == 6:
self.add_layer_button.setDisabled(True)
self.update_layers_buttons()
self.update()
def eraser_button_clicked(self):
self.canvas.choose_eraser()
self.update()
def brush_button_clicked(self):
self.canvas.choose_brush()
self.update()
def line_button_clicked(self):
self.canvas.choose_line()
self.update()
def rectangle_button_clicked(self):
self.canvas.choose_rectangle()
self.update()
def triangle_button_clicked(self):
self.canvas.choose_triangle()
self.update()
def ellipse_button_clicked(self):
self.canvas.choose_ellipse()
self.update()
def fill_button_pressed(self):
self.canvas.choose_fill()
self.update()
def selection_button_clicked(self):
self.canvas.choose_selection()
self.update()
def horizontal_scrollbar_value_changed(self, value):
self.update()
def vertical_scrollbar_value_changed(self, value):
self.update()
def change_greyscale(self):
if self.canvas.active_layer.greyscale:
self.canvas.turn_greyscale_off()
else:
self.canvas.turn_greyscale_on()
self.update_canvas()
self.update_color_button()
self.update()
def deselect(self):
self.canvas.deselect()
self.deselect_action.setDisabled(True)
self.delete_selection_action.setDisabled(True)
self.to_draw_selection = False
self.update()
def select_all(self):
self.canvas.deselect()
self.shape_start = 0, 0
self.cursor_position = self.canvas.width - 1, self.canvas.height - 1
self.update_selection_position()
self.canvas.select(*self.shape_start, *self.cursor_position)
self.to_draw_selection = True
self.deselect_action.setDisabled(False)
self.delete_selection_action.setDisabled(False)
self.update()
def change_brightness(self, brightness):
self.canvas.change_brightness(brightness)
self.update_canvas()
self.update()
def brightness(self):
success, brightness = BrightnessDialog.get_brightness(self, self.canvas.active_layer.brightness)
if success:
self.change_brightness(brightness)
def delete_in_selection(self):
if not self.canvas.selection_is_on:
return
self.canvas.delete_selection()
self.update_canvas()
self.update()
@property
def canvas_left_side(self):
return self.canvas_left_edge - self.horizontal_scrollbar.value()
@property
def canvas_upper_side(self):
return self.canvas_upper_edge - self.vertical_scrollbar.value()
def size_edited(self, size):
if size == '':
value = 1
else:
value = int(size)
if value == 0:
self.size_edit.setText('1')
else:
self.size_slider.setValue(value)
def size_changed(self, value):
if value == 0:
self.canvas.brush_size = 1
else:
self.canvas.brush_size = value
if self.to_draw_canvas:
self.change_cursor()
self.size_edit.setText(f'{self.canvas.brush_size}')
def pick_color(self):
color = QColorDialog.getColor()
if color.isValid():
self.canvas.change_color(color.red(), color.green(), color.blue(), color.alpha())
self.update_color_button()
def update_color_button(self):
cur_color = self.canvas.current_color
color = QColor(cur_color.r, cur_color.g, cur_color.b)
self.color_picker.setStyleSheet(f'background: {color.name()}')
def ask_size(self):
success, width, height = SizeDialog.get_size(self)
if success:
self.create_canvas(width, height)
def create_canvas(self, width, height):
old_canvas = self.canvas
self.canvas = Canvas(width, height)
self.canvas.current_color_rgb = old_canvas.current_color_rgb
self.canvas.brush_size = old_canvas.brush_size
self.canvas.current_tool = old_canvas.current_tool
max_size = self.height() - self.SHIFT * 2
proportion = width / height
if proportion > 1:
self.canvas_width = max_size
self.canvas_height = max_size / proportion
else:
self.canvas_width = max_size * proportion
self.canvas_height = max_size
self.pixel_size = self.canvas_width / self.canvas.width
self.canvas_left_edge = (self.width() - self.canvas_width) / 2
self.canvas_upper_edge = (self.height() - self.canvas_height) / 2
self.canvas_as_image = self.convert_to_image()
self.to_draw_canvas = True
self.enable_actions()
self.update_layers_buttons()
def enable_actions(self):
self.save_action.setDisabled(False)
self.save_as_action.setDisabled(False)
self.greyscale_action.setDisabled(False)
self.brightness_action.setDisabled(False)
self.select_all_action.setDisabled(False)
def convert_to_image(self):
image = QImage(self.canvas.width, self.canvas.height, QImage.Format_ARGB32)
x = 0
y = 0
for layer in self.canvas.layers:
for column in layer.pixels:
for pixel in column:
image.setPixelColor(x, y, QColor(pixel.r, pixel.g, pixel.b, pixel.a))
y += 1
x += 1
y = 0
return image
def open(self):
load_file_name = QFileDialog.getOpenFileName(self, 'Chose Image File', '',
'PNG Files (*.png);;JPG Files (*.jpg);;BMP Files (*.bmp)')[0]
if load_file_name == '':
return False
self.picture_name = load_file_name
image = QImage(load_file_name)
self.create_canvas(image.width(), image.height())
for x in range(self.canvas.width):
for y in range(self.canvas.height):
color = image.pixelColor(x, y)
self.canvas.pixels[x][y] = Color(color.red(), color.green(), color.blue(), color.alpha())
self.update_canvas()
self.to_draw_canvas = True
self.update()
def save(self):
if self.picture_name is None:
self.save_as()
else:
self.canvas_as_image.save(self.picture_name)
def save_as(self):
name = QFileDialog.getSaveFileName(self, 'Save', '',
'PNG Files (*.png);;JPG Files (*.jpg);;BMP Files (*.bmp)')[0]
if name == '':
return False
self.picture_name = name
self.save()
def change_cursor(self):
if self.canvas.current_tool == Tools.BRUSH:
self.setCursor(self.get_brush_cursor())
elif self.canvas.current_tool == Tools.ERASER:
self.setCursor(self.get_eraser_cursor())
elif self.canvas.current_tool == Tools.FILL:
self.setCursor(self.get_fill_cursor())
def get_brush_cursor(self):
size = (2 * self.canvas.brush_size - 1) * self.pixel_size
cursor = QPixmap(size, size)
cursor.fill(Qt.transparent)
painter = QPainter()
painter.begin(cursor)
painter.setPen(QColor(self.canvas.current_color.r, self.canvas.current_color.g, self.canvas.current_color.b))
painter.drawEllipse(0, 0, size - 1, size - 1)
painter.drawLine(size / 2, size / 4, size / 2, size / 4 * 3)
painter.drawLine(size / 4, size / 2, size / 4 * 3, size / 2)
painter.end()
return QCursor(cursor)
def get_eraser_cursor(self):
size = (2 * self.canvas.brush_size - 1) * self.pixel_size
cursor = QPixmap(size, size)
cursor.fill(Qt.transparent)
painter = QPainter()
painter.begin(cursor)
painter.setBrush(QBrush(QColor(255, 255, 255)))
painter.drawEllipse(0, 0, size - 1, size - 1)
painter.end()
return QCursor(cursor)
def get_fill_cursor(self):
fill = QImage('images/FillCursor.png')
cursor = QPixmap(fill.width(), fill.height())
cursor.fill(Qt.transparent)
painter = QPainter()
painter.begin(cursor)
painter.setBrush(QColor(self.canvas.current_color.r, self.canvas.current_color.g, self.canvas.current_color.b))
painter.drawRect(10, 10, 10, 4)
painter.drawImage(0, 0, fill)
painter.end()
return QCursor(cursor)
def mouseMoveEvent(self, event):
if not self.to_draw_canvas:
return
x = math.floor((event.pos().x() - self.canvas_left_side) / self.pixel_size)
y = math.floor((event.pos().y() - self.canvas_upper_side) / self.pixel_size)
if 0 <= x < self.canvas.width and 0 <= y < self.canvas.height:
self.cursor_position = (x, y)
self.change_cursor()
self.cursor_on_canvas = True
else:
if not self.mouse_pressed:
self.shape_start = None
self.cursor_on_canvas = False
self.setCursor(Qt.ArrowCursor)
if self.mouse_pressed:
self.move_tools()
self.update_canvas()
self.update()
def move_tools(self):
if self.canvas.current_tool in [Tools.BRUSH, Tools.ERASER]:
self.canvas.paint(*self.cursor_position)
if self.cursor_on_canvas and self.canvas.current_tool == Tools.SELECTION:
self.update_selection_position()
def update_canvas(self):
if not self.to_draw_canvas:
return
while len(self.canvas.changed_pixels) > 0:
x, y = self.canvas.changed_pixels.pop()
layer = len(self.canvas.layers) - 1
pixel = self.canvas.get_pixel(x, y, layer)
while layer > 0 and pixel.a == 0:
layer -= 1
pixel = self.canvas.get_pixel(x, y, layer)
self.canvas_as_image.setPixelColor(x, y, QColor(pixel.r, pixel.g, pixel.b, pixel.a))
def mousePressEvent(self, event):
if self.cursor_on_canvas and event.button() == Qt.LeftButton:
self.mouse_pressed = True
self.press_tools()
def press_tools(self):
if self.canvas.current_tool in [Tools.LINE, Tools.SQUARE, Tools.TRIANGLE, Tools.CIRCLE, Tools.SELECTION]:
self.shape_start = self.cursor_position
if self.canvas.current_tool in [Tools.BRUSH, Tools.ERASER]:
self.canvas.paint(*self.cursor_position)
elif self.canvas.current_tool == Tools.LINE:
self.to_draw_line = True
elif self.canvas.current_tool == Tools.SQUARE:
self.to_draw_rectangle = True
elif self.canvas.current_tool == Tools.TRIANGLE:
self.to_draw_triangle = True
elif self.canvas.current_tool == Tools.CIRCLE:
self.to_draw_ellipse = True
elif self.canvas.current_tool == Tools.FILL:
self.canvas.fill(*self.cursor_position)
elif self.canvas.current_tool == Tools.SELECTION:
self.deselect()
self.deselect_action.setDisabled(False)
self.delete_selection_action.setDisabled(False)
self.to_draw_selection = True
def mouseReleaseEvent(self, event):
if event.button() == Qt.LeftButton and self.to_draw_canvas:
self.release_tools()
self.update_canvas()
self.update()
self.mouse_pressed = False
def release_tools(self):
if self.shape_start is None:
return
if self.canvas.current_tool == Tools.SELECTION:
self.canvas.select(*self.shape_start, *self.cursor_position)
if self.canvas.current_tool == Tools.LINE:
self.to_draw_line = False
self.canvas.draw_line(*self.shape_start, *self.cursor_position)
elif self.canvas.current_tool == Tools.SQUARE:
self.to_draw_rectangle = False
self.canvas.draw_rectangle(*self.shape_start, *self.cursor_position)
elif self.canvas.current_tool == Tools.TRIANGLE:
self.to_draw_triangle = False
self.canvas.draw_triangle(*self.shape_start, *self.cursor_position)
elif self.canvas.current_tool == Tools.CIRCLE:
self.to_draw_ellipse = False
self.canvas.draw_ellipse(*self.shape_start, *self.cursor_position)
def wheelEvent(self, event):
if not self.to_draw_canvas:
return
delta = event.angleDelta().y() / 120
old_width = self.canvas_width
old_height = self.canvas_height
if self.canvas.width * (self.pixel_size + delta) > 0 and self.canvas.height * (self.pixel_size + delta) > 0:
self.pixel_size += delta
self.canvas_width = self.canvas.width * self.pixel_size
self.canvas_height = self.canvas.height * self.pixel_size
self.canvas_left_edge += (old_width - self.canvas_width) / 2
self.canvas_upper_edge += (old_height - self.canvas_height) / 2
self.change_cursor()
self.update()
if self.canvas_left_edge < self.MINIMUM_CANVAS_LEFT_SHIFT:
max = self.MINIMUM_CANVAS_LEFT_SHIFT - self.canvas_left_edge
self.horizontal_scrollbar.setMaximum(max)
self.horizontal_scrollbar.setMinimum(-max)
self.horizontal_scrollbar.show()
else:
self.horizontal_scrollbar.hide()
if self.canvas_upper_edge < self.MENU_BAR_HEIGHT:
max = self.MENU_BAR_HEIGHT - self.canvas_upper_edge
self.vertical_scrollbar.setMinimum(-max)
self.vertical_scrollbar.setMaximum(max)
self.vertical_scrollbar.show()
else:
self.vertical_scrollbar.hide()
def paintEvent(self, event):
painter = QPainter()
painter.begin(self)
if self.to_draw_canvas:
self.draw_pixels(painter)
painter.setPen(QColor(self.canvas.current_color.r, self.canvas.current_color.g, self.canvas.current_color.b))
if self.to_draw_line:
self.draw_line(painter)
if self.to_draw_rectangle:
self.draw_rectangle(painter)
if self.to_draw_triangle:
self.draw_triangle(painter)
if self.to_draw_ellipse:
self.draw_ellipse(painter)
if self.to_draw_selection:
self.draw_selection(painter)
self.draw_edges(painter)
self.draw_layers(painter)
painter.drawImage(0, self.menu_bar.height(), QImage('images/ToolBar.png'))
self.highlight_current_button(painter)
self.draw_buttons(painter)
painter.end()
def draw_layers(self, painter):
painter.drawImage(self.width() - self.TOOLBAR_WIDTH, self.menu_bar.height(), QImage('images/LayersBar.png'))
self.draw_current_layer(painter)
for table in self.layer_tables:
table.draw(painter)
def highlight_current_button(self, painter):
painter.setBrush(QColor(255, 255, 255))
painter.setPen(Qt.transparent)
button = self.buttons[self.canvas.current_tool]
painter.drawRect(button.x(), button.y(), self.BUTTON_SIZE, self.BUTTON_SIZE)
def get_start_end_position(self):
start_x, start_y = self.shape_start
end_x, end_y = self.cursor_position
start_x = start_x * self.pixel_size + self.canvas_left_side + self.pixel_size / 2
start_y = start_y * self.pixel_size + self.canvas_upper_side + self.pixel_size / 2
end_x = end_x * self.pixel_size + self.canvas_left_side + self.pixel_size / 2
end_y = end_y * self.pixel_size + self.canvas_upper_side + self.pixel_size / 2
return start_x, start_y, end_x, end_y
def draw_line(self, painter):
start_x, start_y, end_x, end_y = self.get_start_end_position()
painter.drawLine(start_x, start_y, end_x, end_y)
def draw_rectangle(self, painter):
start_x, start_y, end_x, end_y = self.get_start_end_position()
left = min(start_x, end_x)
up = min(start_y, end_y)
painter.drawRect(left, up, abs(end_x - start_x), abs(end_y - start_y))
def draw_triangle(self, painter):
start_x, start_y, end_x, end_y = self.get_start_end_position()
left = min(start_x, end_x)
right = max(start_x, end_x)
up = min(start_y, end_y)
down = max(start_y, end_y)
width = right - left
left_up = left + width // 2
right_up = left_up + (width % 2)
painter.drawLine(left_up, up, left, down)
painter.drawLine(right_up, up, right, down)
painter.drawLine(left, down, right, down)
def draw_ellipse(self, painter):
start_x, start_y, end_x, end_y = self.get_start_end_position()
left = min(start_x, end_x)
up = min(start_y, end_y)
painter.drawEllipse(left, up, abs(end_x - start_x), abs(end_y - start_y))
def update_selection_position(self):
start_x = self.shape_start[0] * self.pixel_size + self.canvas_left_side
start_y = self.shape_start[1] * self.pixel_size + self.canvas_upper_side
end_x = self.cursor_position[0] * self.pixel_size + self.canvas_left_side
end_y = self.cursor_position[1] * self.pixel_size + self.canvas_upper_side
self.selection_left = min(start_x, end_x)
self.selection_right = max(start_x, end_x) + self.pixel_size
self.selection_up = min(start_y, end_y)
self.selection_down = max(start_y, end_y) + self.pixel_size
self.selection_width = abs(self.cursor_position[0] - self.shape_start[0]) + 1
self.selection_height = abs(self.cursor_position[1] - self.shape_start[1]) + 1
def draw_selection(self, painter):
width = self.pixel_size / 4
black_pen = QPen(QColor(0, 0, 0))
black_pen.setWidth(3)
white_pen = QPen(QColor(255, 255, 255))
white_pen.setWidth(3)
painter.setPen(black_pen)
for x in range(self.selection_width):
painter.drawLine(self.selection_left + x * self.pixel_size,
self.selection_up, self.selection_left + x * self.pixel_size + width, self.selection_up)
painter.drawLine(self.selection_left + x * self.pixel_size,
self.selection_down, self.selection_left + x * self.pixel_size + width, self.selection_down)
painter.setPen(white_pen)
painter.drawLine(self.selection_left + x * self.pixel_size + width,
self.selection_up, self.selection_left + x * self.pixel_size + width * 3, self.selection_up)
painter.drawLine(self.selection_left + x * self.pixel_size + width,
self.selection_down, self.selection_left + x * self.pixel_size + width * 3, self.selection_down)
painter.setPen(black_pen)
painter.drawLine(self.selection_left + x * self.pixel_size + width * 3,
self.selection_up, self.selection_left + x * self.pixel_size + width * 4, self.selection_up)
painter.drawLine(self.selection_left + x * self.pixel_size + width * 3,
self.selection_down, self.selection_left + x * self.pixel_size + width * 4, self.selection_down)
for y in range(self.selection_height):
painter.drawLine(self.selection_left, self.selection_up + y * self.pixel_size,
self.selection_left, self.selection_up + y * self.pixel_size + width)
painter.drawLine(self.selection_right, self.selection_up + y * self.pixel_size,
self.selection_right, self.selection_up + y * self.pixel_size + width)
painter.setPen(white_pen)
painter.drawLine(self.selection_left, self.selection_up + y * self.pixel_size + width,
self.selection_left, self.selection_up + y * self.pixel_size + width * 3)
painter.drawLine(self.selection_right, self.selection_up + y * self.pixel_size + width,
self.selection_right, self.selection_up + y * self.pixel_size + width * 3)
painter.setPen(black_pen)
painter.drawLine(self.selection_left, self.selection_up + y * self.pixel_size + width * 3,
self.selection_left, self.selection_up + y * self.pixel_size + width * 4)
painter.drawLine(self.selection_right, self.selection_up + y * self.pixel_size + width * 3,
self.selection_right, self.selection_up + y * self.pixel_size + width * 4)
def draw_pixels(self, painter):
painter.drawImage(self.canvas_left_side, self.canvas_upper_side,
self.canvas_as_image.scaled(self.canvas_width, self.canvas_height))
painter.setBrush(Qt.transparent)
black_pen = QPen(QColor(0, 0, 0))
black_pen.setWidth(3)
painter.setPen(black_pen)
painter.drawRect(self.canvas_left_side, self.canvas_upper_side, self.canvas_width, self.canvas_height)
painter.setPen(Qt.black)
self.draw_grid(painter)
def draw_grid(self, painter):
if self.pixel_size > 10:
for i in range(self.canvas.width + 1):
x = self.canvas_left_side + i * self.pixel_size
painter.drawLine(x, self.canvas_upper_side,
x, self.canvas_upper_side + self.canvas_height)
for i in range(self.canvas.height + 1):
y = self.canvas_upper_side + i * self.pixel_size
painter.drawLine(self.canvas_left_side, y,
self.canvas_left_side + self.canvas_width, y)
def draw_edges(self, painter):
painter.setPen(Qt.transparent)
painter.setBrush(QColor('#393939'))
painter.drawRect(self.vertical_scrollbar.x(), self.vertical_scrollbar.y(),
self.vertical_scrollbar.width(),
self.vertical_scrollbar.height() + self.horizontal_scrollbar.height() + 1)
painter.drawRect(self.horizontal_scrollbar.x(), self.horizontal_scrollbar.y(),
self.horizontal_scrollbar.width(), self.horizontal_scrollbar.height() + 1)
def draw_current_layer(self, painter):
if not self.to_draw_canvas:
return
painter.setBrush(Qt.white)
table = self.layer_tables[self.canvas.current_layer]
painter.drawRect(table.x - 1, table.y - 1, LayerTable.WIDTH + 2, LayerTable.HEIGHT + 2)
def draw_buttons(self, painter):
painter.setPen(Qt.transparent)
painter.setBrush(QColor(self.canvas.current_color.r, self.canvas.current_color.g,
self.canvas.current_color.b))
for button, image in self.button_images.items():
painter.drawRect(button.x() + 3, button.y() + 3, self.BUTTON_SIZE - 6, self.BUTTON_SIZE - 6)
painter.drawImage(button.x(), button.y(), image.scaled(self.BUTTON_SIZE, self.BUTTON_SIZE))
class GraphViewer(QWidget):
def __init__(self, parent):
super().__init__(parent)
self._y = 0
self._width = 1
self._height = 1
self.dot = Digraph(format='svg', strict=True)
self._declared_count = 1
self._declared = dict()
self._renderer = QSvgRenderer(self.dot.pipe(), self)
self.scrollbar = QScrollBar(self.parent())
self.scrollbar.setRange(0, 0)
self.parent().wheelEvent = self.wheelEvent
def wheelEvent(self, event):
if event.x() > self.getScrollWidth():
return
if event.y() > self._height:
return
self.scrollbar.wheelEvent(event)
def add(self, data):
# is variable
if data in self._declared.keys():
return self._declared[data]
if data.is_variable:
name = data.name
self._declared[data] = name
self.dot.node(name)
if data.toward is not None:
toward = self.add(data.toward)
self.dot.edge(toward, name)
return name
# is constant
if data.is_constant:
name = data.symbol
self._declared[data] = name
self.dot.node(name)
return name
# is operator
if data.is_operator:
name = '[%d] %s' % (self._declared_count, data.name)
self._declared_count += 1
self._declared[data] = name
self.dot.node(name)
args = [data.sub, data.obj, data.step]
if data.args is not None:
args += data.args
args = [arg for arg in args if arg is not None]
for arg in args:
arg = self.add(arg)
self.dot.edge(arg, name)
return name
def paintEvent(self, event):
self._width = self.width()
self._height = self.height()
self.scrollbar.setGeometry(self.getScrollWidth(), 0, 20, self._height)
self.resize(self._renderer.defaultSize())
painter = QPainter(self)
painter.restore()
drawRect = QRectF(self.rect())
if self.scrollbar.maximum() == 0:
draw_y = 0
else:
draw_y = drawRect.height() - self._height
draw_y *= self.scrollbar.value() / self.scrollbar.maximum()
drawRect.setY(-draw_y)
drawRect.setHeight(drawRect.y() + drawRect.height())
self._renderer.render(painter, drawRect)
def flush(self):
self._renderer = QSvgRenderer(self.dot.pipe())
max_h = self._renderer.defaultSize().height() / self._height
if max_h <= 1:
max_h = 0
max_h = int(self.delta() * max_h)
self.scrollbar.setMaximum(max_h)
def clear(self):
self._declared_count = 1
self._declared = dict()
self.dot.clear()
def getScrollWidth(self):
return self._width - 20
def delta(self):
return 3.14
class ObjMotorWidgetUI(QWidget):
# waveforms_generated = pyqtSignal(object, object, list, int)
# SignalForContourScanning = pyqtSignal(int, int, int, np.ndarray, np.ndarray)
# MessageBack = pyqtSignal(str)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
# os.chdir('./')# Set directory to current folder.
self.setFont(QFont("Arial"))
# self.setMinimumSize(1350,900)
self.setWindowTitle("ObjMotorWidget")
self.layout = QGridLayout(self)
self.connect_status = False
#**************************************************************************************************************************************
#--------------------------------------------------------------------------------------------------------------------------------------
#-----------------------------------------------------------GUI for Objective Motor----------------------------------------------------
#--------------------------------------------------------------------------------------------------------------------------------------
#**************************************************************************************************************************************
# Movement based on relative positions.
self.ObjMotorcontrolContainer = QGroupBox("Objective motor control")
self.ObjMotorcontrolContainer.setStyleSheet("QGroupBox {\
font: bold;\
border: 1px solid silver;\
border-radius: 6px;\
margin-top: 12px;\
color:Navy; \
background-color: #FFFAFA}\
QGroupBox::title{subcontrol-origin: margin;\
left: 7px;\
padding: 5px 5px 5px 5px;}")
self.ObjMotorcontrolLayout = QGridLayout()
self.ObjMotor_connect = StylishQT.connectButton()
self.ObjMotor_connect.setFixedWidth(70)
self.ObjMotorcontrolLayout.addWidget(self.ObjMotor_connect, 0, 0)
self.ObjMotor_connect.clicked.connect(lambda: self.ConnectMotor())
self.ObjMotor_connect.setGraphicsEffect(QGraphicsDropShadowEffect(blurRadius=3, xOffset=2, yOffset=2))
self.ObjMotor_disconnect = StylishQT.disconnectButton()
self.ObjMotor_disconnect.setFixedWidth(70)
self.ObjMotor_disconnect.setGraphicsEffect(QGraphicsDropShadowEffect(blurRadius=3, xOffset=2, yOffset=2))
self.ObjMotorcontrolLayout.addWidget(self.ObjMotor_disconnect, 0, 1)
self.ObjMotor_disconnect.clicked.connect(lambda: self.DisconnectMotor())
self.ObjMotor_disconnect.setEnabled(False)
self.ObjMotor_upwards = QPushButton("↑")
self.ObjMotor_upwards.setStyleSheet("QPushButton {color:white;background-color: teal; border-style: outset;border-radius: 10px;border-width: 2px;font: bold 14px;padding: 6px}"
"QPushButton:pressed {color:red;background-color: white; border-style: outset;border-radius: 10px;border-width: 2px;font: bold 14px;padding: 6px}"
"QPushButton:hover:!pressed {color:gray;background-color: teal; border-style: outset;border-radius: 10px;border-width: 2px;font: bold 14px;padding: 6px}")
self.ObjMotorcontrolLayout.addWidget(self.ObjMotor_upwards, 2, 2)
self.ObjMotor_upwards.clicked.connect(lambda: self.MovingMotorThread("Motor_move_upwards"))
# self.ObjMotor_upwards.setShortcut('w')
self.ObjMotor_down = QPushButton("↓")
self.ObjMotor_down.setStyleSheet("QPushButton {color:white;background-color: teal; border-style: outset;border-radius: 10px;border-width: 2px;font: bold 14px;padding: 6px}"
"QPushButton:pressed {color:red;background-color: white; border-style: outset;border-radius: 10px;border-width: 2px;font: bold 14px;padding: 6px}"
"QPushButton:hover:!pressed {color:gray;background-color: teal; border-style: outset;border-radius: 10px;border-width: 2px;font: bold 14px;padding: 6px}")
self.ObjMotorcontrolLayout.addWidget(self.ObjMotor_down, 3, 2)
self.ObjMotor_down.clicked.connect(lambda: self.MovingMotorThread("Motor_move_downwards"))
# self.stage_down.setShortcut('s')
self.ObjMotor_target = QDoubleSpinBox(self)
self.ObjMotor_target.setMinimum(-10000)
self.ObjMotor_target.setMaximum(10000)
self.ObjMotor_target.setDecimals(6)
# self.ObjMotor_target.setValue(3.45)
self.ObjMotor_target.setSingleStep(0.001)
self.ObjMotorcontrolLayout.addWidget(self.ObjMotor_target, 1, 1)
self.ObjMotorcontrolLayout.addWidget(QLabel("Target:"), 1, 0)
self.ObjMotor_current_pos_Label = QLabel("Current position: ")
self.ObjMotorcontrolLayout.addWidget(self.ObjMotor_current_pos_Label, 2, 0, 1, 2)
self.ObjMotor_goto = QPushButton()
self.ObjMotor_goto.setIcon(QIcon('./Icons/move_coord.png'))
self.ObjMotor_goto.setToolTip("Move to absolute position")
self.ObjMotor_goto.setStyleSheet("QPushButton {color:white;background-color: #CCFFFF;}"
"QPushButton:hover:!pressed {color:white;background-color: #FFE5CC;}")
self.ObjMotor_goto.setFixedWidth(35)
self.ObjMotor_goto.setFixedHeight(35)
self.ObjMotorcontrolLayout.addWidget(self.ObjMotor_goto, 1, 2)
self.ObjMotor_goto.clicked.connect(lambda: self.MovingMotorThread("Motor_move_target"))
self.ObjMotor_step = QDoubleSpinBox(self)
self.ObjMotor_step.setMinimum(-10000)
self.ObjMotor_step.setMaximum(10000)
self.ObjMotor_step.setDecimals(6)
self.ObjMotor_step.setValue(0.003)
self.ObjMotor_step.setSingleStep(0.001)
self.ObjMotorcontrolLayout.addWidget(self.ObjMotor_step, 3, 1)
self.ObjMotorcontrolLayout.addWidget(QLabel("Step: "), 3, 0)
self.FocusSlider = QScrollBar(Qt.Horizontal)
self.FocusSlider.setMinimum(2500000)
self.FocusSlider.setMaximum(4500000)
# self.FocusSlider.setTickPosition(QSlider.TicksBothSides)
# self.FocusSlider.setTickInterval(1000000)
self.FocusSlider.setStyleSheet('color:white; background: lightblue')
self.FocusSlider.setSingleStep(10000)
# self.line640 = QLineEdit(self)
# self.line640.setFixedWidth(60)
# self.FocusSlider.sliderReleased.connect(lambda:self.updatelinevalue(640))
self.FocusSlider.valueChanged.connect(lambda:self.MovingMotorThread("Motor_move_slider"))
self.FocusSlider.setTracking(False)
# self.line640.returnPressed.connect(lambda:self.updatesider(640))
self.ObjMotorcontrolLayout.addWidget(self.FocusSlider, 4, 0, 1, 3)
self.ObjMotorcontrolContainer.setLayout(self.ObjMotorcontrolLayout)
self.ObjMotorcontrolContainer.setMaximumHeight(300)
self.layout.addWidget(self.ObjMotorcontrolContainer, 4, 0)
#**************************************************************************************************************************************
#--------------------------------------------------------------------------------------------------------------------------------------
#-----------------------------------------------------------Fucs for Motor movement----------------------------------------------------
#--------------------------------------------------------------------------------------------------------------------------------------
#**************************************************************************************************************************************
def ConnectMotor(self):
self.ObjMotorcontrolContainer.setEnabled(False)
self.ObjMotor_disconnect.setEnabled(True)
self.ObjMotor_connect.setEnabled(False)
self.device_instance = ConnectObj_Thread()
self.device_instance.start()
self.device_instance.finished.connect(self.getmotorhandle)
def getmotorhandle(self):
self.pi_device_instance = self.device_instance.getInstance()
print('Objective motor connected.')
self.connect_status = True
# self.normalOutputWritten('Objective motor connected.'+'\n')
self.ObjCurrentPos = self.pi_device_instance.pidevice.qPOS(self.pi_device_instance.pidevice.axes)
self.ObjMotor_current_pos_Label.setText("Current position: {:.4f}".format(self.ObjCurrentPos['1'])) # Axis here is a string.
self.ObjMotor_target.setValue(self.ObjCurrentPos['1'])
decimal_places = len(str(self.ObjCurrentPos['1']).split('.')[1])
print(int(self.ObjCurrentPos['1']*(10**decimal_places)))
self.FocusSlider.setValue(int(self.ObjCurrentPos['1']*(10**6)))
self.ObjMotorcontrolContainer.setEnabled(True)
def MovingMotorThread(self, target):
if target == "Motor_move_target":
MoveMotorThread = threading.Thread(target = self.MoveMotor, args=('Target',))
MoveMotorThread.start()
elif target == "Motor_move_upwards":
MoveMotorThread = threading.Thread(target = self.MoveMotor, args=('UP',))
MoveMotorThread.start()
elif target == "Motor_move_downwards":
MoveMotorThread = threading.Thread(target = self.MoveMotor, args=('DOWN',))
MoveMotorThread.start()
elif target == "Motor_move_slider":
MoveMotorThread = threading.Thread(target = self.MoveMotor, args=('Slider',))
MoveMotorThread.start()
def MoveMotor(self, direction):
if direction == "Target":
pos = PIMotor.move(self.pi_device_instance.pidevice, self.ObjMotor_target.value())
elif direction == "UP":
self.MotorStep = self.ObjMotor_step.value()
pos = PIMotor.move(self.pi_device_instance.pidevice, (self.ObjCurrentPos['1'] + self.MotorStep))
elif direction == "DOWN":
self.MotorStep = self.ObjMotor_step.value()
pos = PIMotor.move(self.pi_device_instance.pidevice, (self.ObjCurrentPos['1'] - self.MotorStep))
elif direction == "Slider":
pos = PIMotor.move(self.pi_device_instance.pidevice, self.FocusSlider.value()/1000000)
self.ObjCurrentPos = self.pi_device_instance.pidevice.qPOS(self.pi_device_instance.pidevice.axes)
self.ObjMotor_current_pos_Label.setText("Current position: {:.4f}".format(self.ObjCurrentPos['1'])) # Axis here is a string.
self.ObjMotor_target.setValue(self.ObjCurrentPos['1'])
# decimal_places = len(str(self.ObjCurrentPos['1']).split('.')[1])
self.FocusSlider.setValue(int(self.ObjCurrentPos['1']*(10**6)))
def DisconnectMotor(self):
self.ObjMotor_connect.setEnabled(True)
self.ObjMotor_disconnect.setEnabled(False)
PIMotor.CloseMotorConnection(self.pi_device_instance.pidevice)
print('Disconnected')
self.connect_status = False
# self.normalOutputWritten('Objective motor disconnected.'+'\n')
def closeEvent(self, event):
# ## Because the software combines both PyQt and PyQtGraph, using the
# ## closeEvent() from PyQt will cause a segmentation fault. Calling
# ## also the exit() from PyQtGraph solves this problem.
# pg.exit()
if self.connect_status == True:
self.DisconnectMotor()
QtWidgets.QApplication.quit()
event.accept()
class CarlaRackW(QFrame, HostWidgetMeta):
#class CarlaRackW(QFrame, HostWidgetMeta, metaclass=PyQtMetaClass):
def __init__(self, parent, host, doSetup = True):
QFrame.__init__(self, parent)
self.host = host
if False:
# kdevelop likes this :)
host = CarlaHostMeta()
self.host = host
# -------------------------------------------------------------
self.fLayout = QHBoxLayout(self)
self.fLayout.setContentsMargins(0, 0, 0, 0)
self.fLayout.setSpacing(0)
self.setLayout(self.fLayout)
self.fPadLeft = QLabel(self)
self.fPadLeft.setFixedWidth(25)
self.fPadLeft.setObjectName("PadLeft")
self.fPadLeft.setText("")
self.fPadRight = QLabel(self)
self.fPadRight.setFixedWidth(25)
self.fPadRight.setObjectName("PadRight")
self.fPadRight.setText("")
self.fRack = CarlaRackList(self, host)
self.fRack.setObjectName("CarlaRackList")
self.fRack.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.fRack.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.fRack.currentRowChanged.connect(self.slot_currentRowChanged)
sb = self.fRack.verticalScrollBar()
self.fScrollBar = QScrollBar(Qt.Vertical, self)
self.fScrollBar.setMinimum(sb.minimum())
self.fScrollBar.setMaximum(sb.maximum())
self.fScrollBar.setValue(sb.value())
#sb.actionTriggered.connect(self.fScrollBar.triggerAction)
#sb.sliderMoved.connect(self.fScrollBar.)
#sb.sliderPressed.connect(self.fScrollBar.)
#sb.sliderReleased.connect(self.fScrollBar.)
sb.rangeChanged.connect(self.fScrollBar.setRange)
sb.valueChanged.connect(self.fScrollBar.setValue)
self.fScrollBar.rangeChanged.connect(sb.setRange)
self.fScrollBar.valueChanged.connect(sb.setValue)
self.fLayout.addWidget(self.fPadLeft)
self.fLayout.addWidget(self.fRack)
self.fLayout.addWidget(self.fPadRight)
self.fLayout.addWidget(self.fScrollBar)
# -------------------------------------------------------------
# Internal stuff
self.fParent = parent
self.fPluginCount = 0
self.fPluginList = []
self.fCurrentRow = -1
self.fLastSelectedItem = None
# -------------------------------------------------------------
# Set-up GUI stuff
#app = QApplication.instance()
#pal1 = app.palette().base().color()
#pal2 = app.palette().button().color()
#col1 = "stop:0 rgb(%i, %i, %i)" % (pal1.red(), pal1.green(), pal1.blue())
#col2 = "stop:1 rgb(%i, %i, %i)" % (pal2.red(), pal2.green(), pal2.blue())
self.setStyleSheet("""
QLabel#PadLeft {
background-image: url(:/bitmaps/rack_padding_left.png);
background-repeat: repeat-y;
}
QLabel#PadRight {
background-image: url(:/bitmaps/rack_padding_right.png);
background-repeat: repeat-y;
}
CarlaRackList#CarlaRackList {
background-color: black;
}
""")
# -------------------------------------------------------------
# Connect actions to functions
host.PluginAddedCallback.connect(self.slot_handlePluginAddedCallback)
host.PluginRemovedCallback.connect(self.slot_handlePluginRemovedCallback)
host.ReloadAllCallback.connect(self.slot_handleReloadAllCallback)
if not doSetup: return
parent.ui.menu_Canvas.hide()
parent.ui.act_plugins_enable.triggered.connect(self.slot_pluginsEnable)
parent.ui.act_plugins_disable.triggered.connect(self.slot_pluginsDisable)
parent.ui.act_plugins_volume100.triggered.connect(self.slot_pluginsVolume100)
parent.ui.act_plugins_mute.triggered.connect(self.slot_pluginsMute)
parent.ui.act_plugins_wet100.triggered.connect(self.slot_pluginsWet100)
parent.ui.act_plugins_bypass.triggered.connect(self.slot_pluginsBypass)
parent.ui.act_plugins_center.triggered.connect(self.slot_pluginsCenter)
parent.ui.act_plugins_panic.triggered.connect(self.slot_pluginsDisable)
parent.ui.act_settings_configure.triggered.connect(self.slot_configureCarla)
# -----------------------------------------------------------------
@pyqtSlot(int, str)
def slot_handlePluginAddedCallback(self, pluginId, pluginName):
pitem = CarlaRackItem(self.fRack, pluginId, self.fParent.getSavedSettings()[CARLA_KEY_MAIN_USE_CUSTOM_SKINS])
self.fPluginList.append(pitem)
self.fPluginCount += 1
if not self.fParent.isProjectLoading():
pitem.getWidget().setActive(True, True, True)
@pyqtSlot(int)
def slot_handlePluginRemovedCallback(self, pluginId):
pitem = self.getPluginItem(pluginId)
self.fPluginCount -= 1
self.fPluginList.pop(pluginId)
self.fRack.takeItem(pluginId)
if pitem is not None:
pitem.closeEditDialog()
del pitem
# push all plugins 1 slot back
for i in range(pluginId, self.fPluginCount):
pitem = self.fPluginList[i]
pitem.setPluginId(i)
# -----------------------------------------------------------------
# HostWidgetMeta methods
def removeAllPlugins(self):
while self.fRack.takeItem(0):
pass
for pitem in self.fPluginList:
if pitem is None:
break
pitem.closeEditDialog()
del pitem
self.fPluginCount = 0
self.fPluginList = []
def engineStarted(self):
pass
def engineStopped(self):
pass
def idleFast(self):
for pitem in self.fPluginList:
if pitem is None:
break
pitem.getWidget().idleFast()
def idleSlow(self):
for pitem in self.fPluginList:
if pitem is None:
break
pitem.getWidget().idleSlow()
def projectLoadingStarted(self):
self.fRack.setEnabled(False)
def projectLoadingFinished(self):
self.fRack.setEnabled(True)
def saveSettings(self, settings):
pass
def showEditDialog(self, pluginId):
dialog = self.getPluginEditDialog(pluginId)
if dialog is None:
return
dialog.show()
# -----------------------------------------------------------------
@pyqtSlot()
def slot_pluginsEnable(self):
if not self.host.is_engine_running():
return
for pitem in self.fPluginList:
if pitem is None:
break
pitem.getWidget().setActive(True, True, True)
@pyqtSlot()
def slot_pluginsDisable(self):
if not self.host.is_engine_running():
return
for pitem in self.fPluginList:
if pitem is None:
break
pitem.getWidget().setActive(False, True, True)
@pyqtSlot()
def slot_pluginsVolume100(self):
if not self.host.is_engine_running():
return
for pitem in self.fPluginList:
if pitem is None:
break
pitem.getWidget().setInternalParameter(PLUGIN_CAN_VOLUME, 1.0)
@pyqtSlot()
def slot_pluginsMute(self):
if not self.host.is_engine_running():
return
for pitem in self.fPluginList:
if pitem is None:
break
pitem.getWidget().setInternalParameter(PLUGIN_CAN_VOLUME, 0.0)
@pyqtSlot()
def slot_pluginsWet100(self):
if not self.host.is_engine_running():
return
for pitem in self.fPluginList:
if pitem is None:
break
pitem.getWidget().setInternalParameter(PLUGIN_CAN_DRYWET, 1.0)
@pyqtSlot()
def slot_pluginsBypass(self):
if not self.host.is_engine_running():
return
for pitem in self.fPluginList:
if pitem is None:
break
pitem.getWidget().setInternalParameter(PLUGIN_CAN_DRYWET, 0.0)
@pyqtSlot()
def slot_pluginsCenter(self):
if not self.host.is_engine_running():
return
for pitem in self.fPluginList:
if pitem is None:
break
pitem.getWidget().setInternalParameter(PARAMETER_BALANCE_LEFT, -1.0)
pitem.getWidget().setInternalParameter(PARAMETER_BALANCE_RIGHT, 1.0)
pitem.getWidget().setInternalParameter(PARAMETER_PANNING, 0.0)
# -----------------------------------------------------------------
@pyqtSlot()
def slot_configureCarla(self):
dialog = CarlaSettingsW(self, self.host, False, False)
if not dialog.exec_():
return
self.fParent.loadSettings(False)
# -----------------------------------------------------------------
@pyqtSlot(int)
def slot_handleReloadAllCallback(self, pluginId):
if pluginId >= self.fPluginCount:
return
pitem = self.fPluginList[pluginId]
if pitem is None:
return
self.fRack.setCurrentRow(-1)
self.fCurrentRow = -1
self.fLastSelectedItem = None
pitem.recreateWidget()
# -----------------------------------------------------------------
@pyqtSlot(int)
def slot_currentRowChanged(self, row):
self.fCurrentRow = row
if self.fLastSelectedItem is not None:
self.fLastSelectedItem.setSelected(False)
if row < 0 or row >= self.fPluginCount or self.fPluginList[row] is None:
self.fLastSelectedItem = None
return
pitem = self.fPluginList[row]
pitem.getWidget().setSelected(True)
self.fLastSelectedItem = pitem.getWidget()
# -----------------------------------------------------------------
def getPluginItem(self, pluginId):
if pluginId >= self.fPluginCount:
return None
pitem = self.fPluginList[pluginId]
if pitem is None:
return None
if False:
pitem = CarlaRackItem(self, 0, False)
return pitem
def getPluginEditDialog(self, pluginId):
if pluginId >= self.fPluginCount:
return None
pitem = self.fPluginList[pluginId]
if pitem is None:
return None
if False:
pitem = CarlaRackItem(self, 0, False)
return pitem.getEditDialog()
def getPluginSlotWidget(self, pluginId):
if pluginId >= self.fPluginCount:
return None
pitem = self.fPluginList[pluginId]
if pitem is None:
return None
if False:
pitem = CarlaRackItem(self, 0, False)
return pitem.getWidget()
