class MDIHistory(QWidget, _HalWidgetBase):
def __init__(self, parent=None):
super(MDIHistory, self).__init__(parent)
self.setMinimumSize(QSize(300, 200))
self.setWindowTitle("PyQt5 editor test example")
lay = QVBoxLayout()
lay.setContentsMargins(0,0,0,0)
self.setLayout(lay)
self.list = QListView()
self.list.setEditTriggers(QListView.NoEditTriggers)
self.list.activated.connect(self.activated)
self.list.setAlternatingRowColors(True)
self.list.selectionChanged = self.selectionChanged
self.model = QStandardItemModel(self.list)
self.MDILine = MDILine()
self.MDILine.soft_keyboard = False
self.MDILine.line_up = self.line_up
self.MDILine.line_down = self.line_down
# add widgets
lay.addWidget(self.list)
lay.addWidget(self.MDILine)
self.reload()
def _hal_init(self):
STATUS.connect('state-off', lambda w: self.setEnabled(False))
STATUS.connect('state-estop', lambda w: self.setEnabled(False))
STATUS.connect('interp-idle', lambda w: self.setEnabled(STATUS.machine_is_on()
and (STATUS.is_all_homed()
or INFO.NO_HOME_REQUIRED)))
STATUS.connect('interp-run', lambda w: self.setEnabled(not STATUS.is_auto_mode()))
STATUS.connect('all-homed', lambda w: self.setEnabled(STATUS.machine_is_on()))
def reload(self, w=None ):
print 'RELOAD'
try:
fp = os.path.expanduser(INFO.MDI_HISTORY_PATH)
with open(fp,'r') as inputfile:
for line in inputfile:
line = line.rstrip('\n')
item = QStandardItem(line)
self.model.appendRow(item)
self.list.setModel(self.model)
self.list.scrollToBottom()
except Exception as e:
print e
LOG.error('File path is not valid: {}]n,()'.format(fp),e)
def line_up(self):
print 'up'
def line_down(self):
print 'down'
def selectionChanged(self,old, new):
cmd = self.getSelected()
self.MDILine.setText(cmd)
def getSelected(self):
selected_indexes = self.list.selectedIndexes()
selected_rows = [item.row() for item in selected_indexes]
# iterates each selected row in descending order
for selected_row in sorted(selected_rows, reverse=True):
text = self.model.item(selected_row).text()
return text
def activated(self):
cmd = self.getSelected()
self.MDILine.setText(cmd)
self.MDILine.submit()
item = QStandardItem(cmd)
self.model.appendRow(item)
self.list.update()
#########################################################################
# This is how designer can interact with our widget properties.
# designer will show the pyqtProperty properties in the editor
# it will use the get set and reset calls to do those actions
#########################################################################
def set_soft_keyboard(self, data):
self.MDILine.soft_keyboard = data
def get_soft_keyboard(self):
return self.MDILine.soft_keyboard
def reset_soft_keyboard(self):
self.MDILine.soft_keyboard = False
# designer will show these properties in this order:
soft_keyboard_option = pyqtProperty(bool, get_soft_keyboard, set_soft_keyboard, reset_soft_keyboard)
def __init__(self):
QWidget.__init__(self, flags=Qt.Widget)
self.setWindowTitle("ItemView QListView")
self.setFixedWidth(210)
self.setFixedHeight(100)
fruits = [
{
"name": "banana",
"color": "yellow",
"bg_color": "yellow"
},
{
"name": "apple",
"color": "red",
"bg_color": "red"
},
{
"name": "pear",
"color": "green",
"bg_color": "gray"
},
]
view = QListView(self)
view.setEditTriggers(QAbstractItemView.DoubleClicked)
model = UserModel(fruits)
view.setModel(model)
class MainForm(QDialog):
def __init__(self, parent=None):
super(MainForm, self).__init__(parent)
self.model = BarGraphModel()
self.barGraphView = BarGraphView()
self.barGraphView.setModel(self.model)
self.listView = QListView()
self.listView.setModel(self.model)
self.listView.setItemDelegate(BarGraphDelegate(0, 1000, self))
self.listView.setMaximumWidth(100)
self.listView.setEditTriggers(QListView.DoubleClicked|
QListView.EditKeyPressed)
layout = QHBoxLayout()
layout.addWidget(self.listView)
layout.addWidget(self.barGraphView, 1)
self.setLayout(layout)
self.setWindowTitle("Bar Grapher")
QTimer.singleShot(0, self.initialLoad)
def initialLoad(self):
# Generate fake data
count = 20
self.model.insertRows(0, count - 1)
for row in range(count):
value = random.randint(1, 150)
color = QColor(random.randint(0, 255), random.randint(0, 255),
random.randint(0, 255))
index = self.model.index(row)
self.model.setData(index, value)
self.model.setData(index, QVariant(color), Qt.UserRole)
def __init__(self):
QWidget.__init__(self, flags=Qt.Widget)
self.setWindowTitle("ItemView QListView")
self.setFixedWidth(210)
self.setFixedHeight(100)
fruits = [
{
"name": "Mail",
"icon": "assets/mail.png"
},
{
"name": "Calender",
"icon": "assets/calender.png"
},
{
"name": "Network",
"icon": "assets/network.png"
},
]
view = QListView(self)
view.setAlternatingRowColors(True)
view.setEditTriggers(QAbstractItemView.DoubleClicked)
model = UserModel(fruits)
view.setModel(model)
class Window(QWidget):
def __init__(self, *args, **kwargs):
super(Window, self).__init__(*args, **kwargs)
self.resize(600, 400)
layout = QVBoxLayout(self)
self.listView = QListView(self)
self.listView.setEditTriggers(QListView.NoEditTriggers)
layout.addWidget(self.listView)
layout.addWidget(QPushButton('恢复默认顺序', self, clicked=self.restoreSort))
layout.addWidget(QPushButton('唐', self, clicked=self.sortByClassify))
layout.addWidget(QPushButton('宋', self, clicked=self.sortByClassify))
layout.addWidget(QPushButton('元', self, clicked=self.sortByClassify))
layout.addWidget(QPushButton('明', self, clicked=self.sortByClassify))
layout.addWidget(QPushButton('清', self, clicked=self.sortByClassify))
self._initItems()
def restoreSort(self):
# 恢复默认排序
self.fmodel.setSortRole(IdRole) # 必须设置排序角色为ID
self.fmodel.sort(0) # 排序第一列按照ID升序
def sortByClassify(self):
self.fmodel.setSortIndex(NameDict.get(
self.sender().text(), ['', 100])[1])
# self.restoreSort()
self.fmodel.setSortRole(IdRole)
# 按照给定的分类排序（这里注意还要按照把给定分类的放在最前面）
self.fmodel.setSortRole(ClassifyRole)
self.fmodel.sort(0)
def _initItems(self):
# 初始化Items
self.dmodel = QStandardItemModel(self.listView)
self.fmodel = SortFilterProxyModel(self.listView)
self.fmodel.setSourceModel(self.dmodel)
self.listView.setModel(self.fmodel)
keys = list(NameDict.keys())
print(keys) # ['清', '元', '唐', '明', '宋']
classifies = [v[1] for v in NameDict.values()]
for i in range(5):
# 添加5个100, 用于模拟没有分类, 排序的时候就显示在最后面
classifies.append(100)
print(classifies) # [4, 2, 0, 3, 1, 100, 100, 100, 100, 100]
# 生成50个Item
for i in range(50):
# name = keys[i % 4] # 随机取一个朝代
item = QStandardItem()
# 设置ID角色
item.setData(i, IdRole)
# 设置分类角色
c = choice(classifies)
item.setData(c, ClassifyRole)
# 设置显示内容
item.setText('Name: {}\t\tId: {}\t\tClassify: {}'.format(
IndexDict.get(c, '其它'), i, c))
self.dmodel.appendRow(item)
class Browser():
def __init__(self, app):
self.listViewModel = QStandardItemModel()
self.app = app
self.listView = QListView(app)
self.listView.move(15, 145)
self.listView.setFixedSize(app.width - 30, app.height - 190)
self.listView.setModel(self.listViewModel)
self.listView.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.listView.doubleClicked.connect(self.processItem)
self.listView.keyPressEvent = self.keyPressEvent
self.listView.selectionModel().selectionChanged.connect(
self.selectionChanged)
def populate(self, entries):
self.listViewModel.clear()
for entry in entries:
item = QStandardItem(
QIcon('icons/' + (
'file.png' if entry['type'] == 'file' else 'folder.png')),
entry['name'])
item.setData(entry)
self.listViewModel.appendRow(item)
def processItem(self):
if self.item.data()['type'] == 'dir':
self.app.navigateDown(self.selectedItem())
else:
self.app.extract()
def keyPressEvent(self, event):
super(QListView, self.listView).keyPressEvent(event)
if event.key() == Qt.Key_Return:
self.processItem()
def deselect(self):
self.item = None
self.app.disableFileActions()
def selectedItem(self):
return self.item.text() if self.item else None
def selectionChanged(self, selected, deselected):
if len(selected.indexes()):
modelIndex = selected.indexes()[0]
self.item = modelIndex.model().item(modelIndex.row())
self.app.enableFileActions()
else:
self.deselect()
def create_QListView(ui, qle=None):
ql = QListView(ui)
ql.setEditTriggers(QAbstractItemView.NoEditTriggers)
ql.setSelectionMode(QAbstractItemView.ExtendedSelection)
ql.setDefaultDropAction(Qt.TargetMoveAction)
ql.setDragDropMode(QAbstractItemView.InternalMove);
ql.setMinimumHeight(80)
ql.clicked.connect(lambda: slot_qlv_check_list(ui, ql))
if qle is not None:
ql.doubleClicked.connect(lambda: slot_qlv_double_click(ui, ql, qle))
return ql
class DatabaseWidget(QSplitter):
def __init__(self):
super().__init__()
self.setOrientation(Qt.Vertical)
self.create_ui()
def create_ui(self):
top = QWidget()
box = QVBoxLayout()
top.setLayout(box)
box.addWidget(label('<strong>Stored regions</strong>'))
self.listview = QListView()
self.listview.setModel(DatabaseModel(db))
self.listview.selectionModel().selectionChanged.connect(self.selection_changed)
self.listview.doubleClicked.connect(self.list_double_clicked)
self.listview.setEditTriggers(QListView.EditKeyPressed | QListView.SelectedClicked)
box.addWidget(self.listview)
self.addWidget(top)
self.poly = PolyWidget()
self.addWidget(self.poly)
def unselect(self):
selection_model = self.listview.selectionModel()
selection_model.select(QModelIndex(), QItemSelectionModel.SelectCurrent)
def select(self, row):
selection_model = self.listview.selectionModel()
index = self.listview.model().index(row, 0, QModelIndex())
selection_model.select(index, QItemSelectionModel.SelectCurrent)
def selection_changed(self, selected, deselected):
try:
index = selected.indexes()[0]
except IndexError:
main_widget.set_selected()
self.poly.show()
return
poly = db[index.row()]
main_widget.set_selected(poly.lfid)
self.poly.show(poly)
def list_double_clicked(self, item):
main_widget.focus(db[item.row()].lfid)
class ListTab(QWidget):
def __init__(self, data_manager, parent=None):
super(ListTab, self).__init__(parent)
self.data_manager = data_manager
self.layout = QVBoxLayout()
self.form_layout = QFormLayout()
self.grid_layout = QGridLayout()
self.package_label = QListView()
self.package_label.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.model = QStandardItemModel(self.package_label)
self.grid_layout.addWidget(self.package_label, 0, 0, 0, 0)
def configure_layout(self):
self.layout.addLayout(self.form_layout)
self.layout.addLayout(self.grid_layout)
self.setLayout(self.layout)
def create_button(self, text, listener=None):
new_button = QPushButton(text)
new_button.setFixedWidth(new_button.sizeHint().width())
if listener:
new_button.clicked.connect(listener)
return new_button
def add_form_element(self, text, widget=None):
self.form_layout.addRow(text, QLabel("") if widget is None else widget)
def select_all(self):
self.change_state(Qt.Checked)
def unselect_all(self):
self.change_state(Qt.Unchecked)
def change_state(self, state):
for index in range(self.model.rowCount()):
item = self.model.item(index)
item.setCheckState(state)
def add_select_buttons(self):
select_all_button = self.create_button("Select all", self.select_all)
unselect_all_button = self.create_button("Unselect all", self.unselect_all)
self.add_form_element("", select_all_button)
self.add_form_element("", unselect_all_button)
def __init__(self, parent, plugins_available):
QWidget.__init__(self, parent)
main_layout = QVBoxLayout()
label = QLabel("Tilastolaskimen valinta")
main_layout.addWidget(label)
calculator_list_view = QListView()
model = QStandardItemModel(calculator_list_view)
for plugin_name in plugins_available:
print(plugin_name)
item = QStandardItem(plugin_name)
model.appendRow(item)
calculator_list_view.setModel(model)
calculator_list_view.clicked.connect(self.on_item_changed)
main_layout.addWidget(calculator_list_view)
calculator_list_view.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.setLayout(main_layout)
class Demo(QWidget):
def __init__(self):
super(Demo, self).__init__()
self.item_list = ['item %s' % i for i in range(11)] # 1
self.model_1 = QStringListModel(self)
self.model_1.setStringList(self.item_list)
self.model_2 = QStringListModel(self) # 2
self.listview_1 = QListView(self) # 3
self.listview_1.setModel(self.model_1)
self.listview_1.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.listview_1.doubleClicked.connect(
lambda: self.change_func(self.listview_1))
self.listview_2 = QListView(self) # 4
self.listview_2.setModel(self.model_2)
self.listview_2.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.listview_2.doubleClicked.connect(
lambda: self.change_func(self.listview_2))
self.pic_label = QLabel(self) # 5
self.pic_label.setPixmap(QPixmap('arrow.png'))
self.h_layout = QHBoxLayout()
self.h_layout.addWidget(self.listview_1)
self.h_layout.addWidget(self.pic_label)
self.h_layout.addWidget(self.listview_2)
self.setLayout(self.h_layout)
def change_func(self, listview):
if listview == self.listview_1: # 6
self.model_2.insertRows(self.model_2.rowCount(), 1)
data = self.listview_1.currentIndex().data()
index = self.model_2.index(self.model_2.rowCount() - 1)
self.model_2.setData(index, data)
else: # 7
self.model_2.removeRows(self.listview_2.currentIndex().row(), 1)
class ShowListWindow(QMainWindow):
def __init__(self,
app_context: ApplicationContext,
flashcard_manager: FlashcardManager,
card_list: CardList,
parent=None):
super(ShowListWindow, self).__init__(parent)
self.app_context = app_context
self.flashcard_manager = flashcard_manager
self.card_list = card_list
self.setFixedSize(600, 400)
self.setWindowTitle(self.card_list.name + " - TangoCards")
main_widget = QWidget()
main_widget.setProperty("cssClass", "background")
main_layout = QVBoxLayout()
learn_button = QPushButton("Frag mich ab!")
learn_button.clicked.connect(self.on_click_learn)
main_layout.addWidget(learn_button)
self.card_list_model = QStringListModel(
self.card_list.get_card_name_list())
self.cards_list_component = QListView()
self.cards_list_component.setModel(self.card_list_model)
self.cards_list_component.setEditTriggers(
QAbstractItemView.NoEditTriggers)
main_layout.addWidget(self.cards_list_component)
tool_buttons_widget = QWidget()
tool_buttons_layout = QHBoxLayout()
tool_buttons_widget.setLayout(tool_buttons_layout)
add_button = QPushButton("Hinzufügen")
add_button.clicked.connect(self.on_click_add)
delete_button = QPushButton("Löschen")
delete_button.clicked.connect(self.on_click_delete)
tool_buttons_layout.addWidget(add_button)
tool_buttons_layout.addWidget(delete_button)
main_layout.addWidget(tool_buttons_widget)
main_widget.setLayout(main_layout)
self.setCentralWidget(main_widget)
def update_list(self):
self.card_list_model = QStringListModel(
self.card_list.get_card_name_list())
self.cards_list_component.setModel(self.card_list_model)
self.cards_list_component.repaint()
def on_click_add(self):
word_text, ok1 = QInputDialog.getText(self, 'Karte hinzufügen',
'Wort:')
if not ok1:
return
if word_text is None or len(word_text) < 2:
msg = QMessageBox()
msg.setIcon(QMessageBox.Warning)
msg.setText("Der Text ist leer oder zu kurz!")
msg.exec_()
return
if self.card_list.get_card(word_text) is not None:
msg = QMessageBox()
msg.setIcon(QMessageBox.Warning)
msg.setText("Wort ist bereits in der Lernkartei!")
msg.exec_()
return
solution_text, ok2 = QInputDialog.getText(self, 'Karte hinzufügen',
'Lösung:')
if not ok2:
return
if solution_text is None or len(word_text) < 2:
msg = QMessageBox()
msg.setIcon(QMessageBox.Warning)
msg.setText("Der Text ist leer oder zu kurz!")
msg.exec_()
return
self.card_list.add_card(word_text, solution_text)
self.flashcard_manager.save_list(self.card_list)
self.update_list()
def on_click_learn(self):
if len(self.card_list.cards) < 1:
msg = QMessageBox()
msg.setIcon(QMessageBox.Warning)
msg.setText("Du musst erst Lernkarten hinzufügen!")
msg.exec_()
return
window = LearnWindow(self.app_context,
self.flashcard_manager,
self.card_list,
parent=self.parent())
self.hide()
window.show()
def on_click_delete(self):
if len(self.cards_list_component.selectedIndexes()) < 1:
return
word_text = self.cards_list_component.selectedIndexes()[0].data()
card = self.card_list.get_card(word_text)
if card is not None:
self.card_list.remove_card(card)
self.flashcard_manager.save_list(self.card_list)
self.update_list()
class RepositoryTab(QWidget):
def __init__(self, data_manager, parent=None):
super(RepositoryTab, self).__init__(parent)
self.data_manager = data_manager
# initialize widgets
self.repo_box = QComboBox()
self.delete_button = QPushButton("Delete")
self.package_label = QListView()
self.package_label.setEditTriggers(QAbstractItemView.NoEditTriggers)
# place widget in the layout
layout = QGridLayout()
layout.addWidget(self.repo_box, 0, 0, 1, 1)
layout.addWidget(self.delete_button, 0, 1, 1, 1)
layout.addWidget(self.package_label, 1, 1, 2, 1)
self.setLayout(layout)
# initialize data
self.model = QStandardItemModel(self.package_label)
self.repo_dictionary = {}
# controllers
self.load_repository()
self.repo_box.currentIndexChanged.connect(self.update_list)
self.delete_button.clicked.connect(self.remove_package)
def load_repository(self):
repos = self.data_manager.client.do_get('/repos')
repo_list = []
for repo in repos:
repo_list.append(repo["Name"])
for repo in sorted(repo_list):
self.repo_box.addItem(repo)
self.repo_box.update()
self.update_list()
def update_list(self):
self.model.removeRows(0, self.model.rowCount())
current_repo = self.repo_box.currentText()
if current_repo == "":
return
if current_repo not in self.repo_dictionary.keys():
self.repo_dictionary[current_repo] = sorted(
Publish._get_packages(self.data_manager.get_client(), "repos",
current_repo))
if self.repo_dictionary[current_repo]:
for package in self.repo_dictionary[current_repo]:
item = QStandardItem(package)
item.setCheckable(True)
item.setCheckState(Qt.Unchecked)
self.model.appendRow(item)
self.package_label.setModel(self.model)
def remove_package(self):
package_list = []
repo_name = self.repo_box.currentText()
self.repo_dictionary[repo_name] = []
for index in range(self.model.rowCount()):
current_item = self.model.item(index)
if current_item and current_item.checkState() != 0:
package_list.append(current_item.text())
else:
self.repo_dictionary[repo_name].append(current_item.text())
print(package_list)
self.data_manager.get_client().do_delete(
'/repos/%s/packages' % repo_name,
data={'PackageRefs': package_list})
self.update_list()
# TODO: disable buttons if no packages...
def reload_component(self):
return
class MDIHistory(QWidget, _HalWidgetBase):
def __init__(self, parent=None):
super(MDIHistory, self).__init__(parent)
self.setMinimumSize(QSize(200, 150))
self.setWindowTitle("PyQt5 editor test example")
lay = QVBoxLayout()
lay.setContentsMargins(0, 0, 0, 0)
self.setLayout(lay)
self.list = QListView()
self.list.setEditTriggers(QListView.NoEditTriggers)
self.list.activated.connect(self.activated)
self.list.setAlternatingRowColors(True)
self.list.selectionChanged = self.selectionChanged
self.model = QStandardItemModel(self.list)
self.MDILine = MDILine()
self.MDILine.soft_keyboard = False
self.MDILine.line_up = self.line_up
self.MDILine.line_down = self.line_down
STATUS.connect('mdi-history-changed', self.reload)
# add widgets
lay.addWidget(self.list)
lay.addWidget(self.MDILine)
self.fp = os.path.expanduser(INFO.MDI_HISTORY_PATH)
try:
open(self.fp, 'r')
except:
open(self.fp, 'a+')
LOG.debug('MDI History file created: {}'.format(self.fp))
self.reload()
self.select_row('last')
def _hal_init(self):
STATUS.connect('state-off', lambda w: self.setEnabled(False))
STATUS.connect('state-estop', lambda w: self.setEnabled(False))
STATUS.connect(
'interp-idle', lambda w: self.setEnabled(STATUS.machine_is_on(
) and (STATUS.is_all_homed() or INFO.NO_HOME_REQUIRED)))
STATUS.connect('interp-run',
lambda w: self.setEnabled(not STATUS.is_auto_mode()))
STATUS.connect('all-homed',
lambda w: self.setEnabled(STATUS.machine_is_on()))
def reload(self, w=None):
self.model.clear()
try:
with open(self.fp, 'r') as inputfile:
for line in inputfile:
line = line.rstrip('\n')
item = QStandardItem(line)
self.model.appendRow(item)
self.list.setModel(self.model)
self.list.scrollToBottom()
if self.MDILine.hasFocus():
self.select_row('last')
except:
LOG.debug('File path is not valid: {}'.format(fp))
def selectionChanged(self, old, new):
cmd = self.getSelected()
self.MDILine.setText(cmd)
selectionModel = self.list.selectionModel()
if selectionModel.hasSelection():
self.row = selectionModel.currentIndex().row()
def getSelected(self):
selected_indexes = self.list.selectedIndexes()
selected_rows = [item.row() for item in selected_indexes]
# iterates each selected row in descending order
for selected_row in sorted(selected_rows, reverse=True):
text = self.model.item(selected_row).text()
return text
def activated(self):
cmd = self.getSelected()
self.MDILine.setText(cmd)
self.MDILine.submit()
self.select_row('down')
def run_command(self):
self.MDILine.submit()
self.select_row('last')
def select_row(self, style):
style = style.lower()
selectionModel = self.list.selectionModel()
parent = QModelIndex()
self.rows = self.model.rowCount(parent) - 1
if style == 'last':
self.row = self.rows
print 'last =', self.row
elif style == 'up':
if self.row > 0:
self.row -= 1
else:
self.row = 0
elif style == 'down':
if self.row < self.rows:
self.row += 1
else:
self.row = self.rows
else:
return
top = self.model.index(self.row, 0, parent)
bottom = self.model.index(self.row, 0, parent)
selectionModel.setCurrentIndex(
top, QItemSelectionModel.Select | QItemSelectionModel.Rows)
selection = QItemSelection(top, top)
selectionModel.clearSelection()
selectionModel.select(selection, QItemSelectionModel.Select)
def line_up(self):
self.select_row('up')
def line_down(self):
self.select_row('down')
#########################################################################
# This is how designer can interact with our widget properties.
# designer will show the pyqtProperty properties in the editor
# it will use the get set and reset calls to do those actions
#########################################################################
def set_soft_keyboard(self, data):
self.MDILine.soft_keyboard = data
def get_soft_keyboard(self):
return self.MDILine.soft_keyboard
def reset_soft_keyboard(self):
self.MDILine.soft_keyboard = False
# designer will show these properties in this order:
soft_keyboard_option = pyqtProperty(bool, get_soft_keyboard,
set_soft_keyboard, reset_soft_keyboard)
def __init__(self, *args, **kwargs):
super(KwWorkFontDialog, self).__init__(*args, **kwargs)
#fontIds = []
#for font_fname in free_font_path_generator():
# fontIds = QFontDatabase.addApplicationFont(font_fname)
#QFontDatabase.removeAllApplicationFonts()
fontFreeFilterChecker = QCheckBox(u'Вільні')
fontNoFreeFilterChecker = QCheckBox(u'Невільні')
fontRating5FilterChecker = QCheckBox(u'Найкращі')
fontRating4FilterChecker = QCheckBox(u'Добрі')
fontRating3FilterChecker = QCheckBox(u'Задовільні')
fontUseStrict_FilterChecker = QCheckBox(u'Діловодство, наука')
fontUseWriting_FilterChecker = QCheckBox(u'Рукопис')
fontUseFantasy_FilterChecker = QCheckBox(u'Декорації, реклама')
fontFamilyListView = QListView()
fontFamilyListView.setMinimumWidth(250)
#fontFamilyModel = QStringListModel([str(fontDatabase.sty)])
fontStyleListView = QListView()
fontStyleListView.setFixedWidth(150)
fontSizeListView = QListView()
fontSizeListView.setFixedWidth(60)
fontSizeModel = QStringListModel([
str(v) for v in (6, 7, 8, 9, 10, 11, 12, 14, 16, 18, 20, 22, 24,
26, 28, 36, 48, 72)
])
fontSizeListView.setModel(fontSizeModel)
fontSizeListView.setEditTriggers(QAbstractItemView.NoEditTriggers)
fontSampleWidget = QLabel(u'ІіЇїРр')
fontSampleWidget.setFrameStyle(QFrame.StyledPanel | QFrame.Sunken)
fontSampleWidget.setStyleSheet(r'''QLabel {
font: normal normal 72pt "Consolas";
padding: 3px;
qproperty-alignment: AlignCenter;
color: black;
background-color: white;
}''')
sampleGroup = QGroupBox(u'Зразок:')
sampleLayout = QHBoxLayout(sampleGroup)
sampleLayout.addWidget(fontSampleWidget)
fontFilterLayout = QHBoxLayout()
fontAccessFilterGroup = QGroupBox(u'Доступність:')
fontAccessFilterLayout = QVBoxLayout(fontAccessFilterGroup)
fontAccessFilterLayout.addWidget(fontFreeFilterChecker)
fontAccessFilterLayout.addWidget(fontNoFreeFilterChecker)
fontAccessFilterLayout.addStretch()
fontFilterLayout.addWidget(fontAccessFilterGroup)
fontUseFilterGroup = QGroupBox(u'Призначення:')
fontUseFilterLayout = QVBoxLayout(fontUseFilterGroup)
fontUseFilterLayout.addWidget(fontUseStrict_FilterChecker)
fontUseFilterLayout.addWidget(fontUseWriting_FilterChecker)
fontUseFilterLayout.addWidget(fontUseFantasy_FilterChecker)
fontFilterLayout.addWidget(fontUseFilterGroup)
fontRatingFilterGroup = QGroupBox(u'Оцінка:')
fontRatingFilterLayout = QVBoxLayout(fontRatingFilterGroup)
fontRatingFilterLayout.addWidget(fontRating5FilterChecker)
fontRatingFilterLayout.addWidget(fontRating4FilterChecker)
fontRatingFilterLayout.addWidget(fontRating3FilterChecker)
fontFilterLayout.addWidget(fontRatingFilterGroup)
fontLayout = QGridLayout()
familyLayout = QVBoxLayout()
familyLayout.setSpacing(3)
familyLayout.addWidget(QLabel(u'Шрифт:'))
familyLayout.addWidget(fontFamilyListView)
fontLayout.addLayout(familyLayout, 0, 0)
styleLayout = QVBoxLayout()
styleLayout.setSpacing(3)
styleLayout.addWidget(QLabel(u'Стиль:'))
styleLayout.addWidget(fontStyleListView)
fontLayout.addLayout(styleLayout, 0, 1)
sizeLayout = QVBoxLayout()
sizeLayout.setSpacing(3)
sizeLayout.addWidget(QLabel(u'Розмір:'))
sizeLayout.addWidget(fontSizeListView)
fontLayout.addLayout(sizeLayout, 0, 2)
fontLayout.addWidget(sampleGroup, 1, 0, 1, 3)
bbox = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
layout = QVBoxLayout(self)
testButton = QPushButton(u'Тестова: відкрити шрифт')
testButton.clicked.connect(lambda: QFontDialog.getFont())
layout.addWidget(testButton)
layout.addLayout(fontFilterLayout)
layout.addLayout(fontLayout)
layout.addSpacing(5)
layout.addWidget(bbox)
self.setWindowTitle(u'Вибір шрифта')
self.setWindowFlags(self.windowFlags()
^ Qt.WindowContextHelpButtonHint)
# Налаштування.
fontMaxPointSize = fontSizeListView.font()
# print(QFontDatabase.families())
fontMaxPointSize.setPointSize(72)
fm = QFontMetrics(fontMaxPointSize)
fontSampleWidget.setMinimumHeight(
fm.size(Qt.TextSingleLine
| Qt.TextShowMnemonic, u'Їр').height())
fontSizeListView.setCurrentIndex(
fontSizeModel.match(fontSizeModel.index(0, 0), Qt.DisplayRole,
fontSizeListView.font().pointSize())[0])
fontFreeFilterChecker.setChecked(True)
fontUseStrict_FilterChecker.setChecked(True)
fontRating5FilterChecker.setChecked(True)
fontRating4FilterChecker.setChecked(True)
class DesktopIconWidget(QFrame):
def __init__(self, parent):
QFrame.__init__(self, parent)
self.setFrameStyle(QFrame.Box | QFrame.Sunken)
self.setStyleSheet("QListView{background:transparent;}")
self.listView = QListView(self)
self.setLayout(QHBoxLayout())
self.layout().setContentsMargins(0, 0, 0, 0)
self.layout().addWidget(self.listView)
self.listView.setContextMenuPolicy(Qt.CustomContextMenu)
self.listView.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.listView.setMovement(QListView.Snap)
self.listView.setFlow(QListView.LeftToRight)
self.listView.setResizeMode(QListView.Adjust)
self.listView.setGridSize(QSize(self.logicalDpiX() / 96 * 70,
self.logicalDpiY() / 96 * 70))
self.listView.setViewMode(QListView.IconMode)
self.quickDesktopModel = QuickDesktopModel(self.window().platform.databaseFile)
self.listView.setModel(self.quickDesktopModel)
self.createActions()
self.makeConnections()
def createActions(self):
self.actionCreateComputer = QAction(self.tr("我的电脑(&C)"), self)
self.actionCreateDocuments = QAction(self.tr("我的文档(&D)"), self)
self.actionCreateMusic = QAction(self.tr("我的音乐(&M)"), self)
self.actionCreatePictures = QAction(self.tr("我的图片(&P)"), self)
self.actionCreateShortcut = QAction(self.tr("创建快捷方式(&C)"), self)
self.actionCreateShortcut.setIcon(QIcon(":/images/new.png"))
self.actionCreateBookmark = QAction(self.tr("创建网络链接(&B)"), self)
self.actionCreateBookmark.setIcon(QIcon(":/images/insert-link.png"))
self.actionRemoveShortcut = QAction(self.tr("删除快捷方式(&R)"), self)
self.actionRemoveShortcut.setIcon(QIcon(":/images/delete.png"))
self.actionRenameShortcut = QAction(self.tr("重命名(&N)"), self)
self.actionRenameShortcut.setIcon(QIcon(":/images/edit-rename.png"))
self.actionEditShortcut = QAction(self.tr("编辑快捷方式(&E)"), self)
self.actionEditShortcut.setIcon(QIcon(":/images/edit.png"))
def makeConnections(self):
self.listView.customContextMenuRequested.connect(self.onQuickDesktopContextMenuRequest)
self.listView.activated.connect(self.runQuickDesktopShortcut)
self.actionCreateComputer.triggered.connect(self.createComputerShortcut)
self.actionCreateDocuments.triggered.connect(self.createDocumentsShortcut)
self.actionCreateMusic.triggered.connect(self.createMusicShortcut)
self.actionCreatePictures.triggered.connect(self.createPicturesShortcut)
self.actionCreateShortcut.triggered.connect(self.createShortcut)
self.actionCreateBookmark.triggered.connect(self.createBookmark)
self.actionEditShortcut.triggered.connect(self.editShortcut)
self.actionRemoveShortcut.triggered.connect(self.removeShortcut)
self.actionRenameShortcut.triggered.connect(self.renameShortcut)
def onQuickDesktopContextMenuRequest(self, pos):
index = self.listView.indexAt(pos)
self.listView.setCurrentIndex(index)
menu = QMenu()
menu.addAction(self.actionCreateShortcut)
menu.addAction(self.actionCreateBookmark)
menu2 = menu.addMenu(self.tr("创建特殊快捷方式(&S)"))
if os.name == "nt":
menu2.addAction(self.actionCreateComputer)
menu2.addAction(self.actionCreateDocuments)
menu2.addAction(self.actionCreatePictures)
menu2.addAction(self.actionCreateMusic)
if index.isValid():
menu.addAction(self.actionRemoveShortcut)
if not self.quickDesktopModel.isSpecialShortcut(index):
menu.addAction(self.actionEditShortcut)
menu.addAction(self.actionRenameShortcut)
try:
getattr(menu, "exec")(QCursor.pos())
except AttributeError:
getattr(menu, "exec_")(QCursor.pos())
def createShortcut(self):
d = ShortcutDialog(self)
if self.window().runDialog(d.create) == QDialog.Accepted:
shortcut = d.getResult()
shortcut["id"] = str(uuid.uuid4())
self.quickDesktopModel.addShortcut(shortcut)
d.deleteLater()
def createBookmark(self):
d = BookmarkDialog(self)
if self.window().runDialog(d.create) == QDialog.Accepted:
shortcut = {
"id": str(uuid.uuid4()),
"icon": "",
"openwith": "",
"dir": "",
}
shortcut.update(d.getResult())
self.quickDesktopModel.addShortcut(shortcut)
d.deleteLater()
def createComputerShortcut(self):
shortcut = {
"id": str(uuid.uuid4()),
"name": self.tr("我的电脑"),
"path": COMPUTER_PATH,
"icon": "",
"dir": "",
"openwith": "",
}
self.quickDesktopModel.addShortcut(shortcut)
def createDocumentsShortcut(self):
shortcut = {
"id": str(uuid.uuid4()),
"name": self.tr("我的文档"),
"path": DOCUMENTS_PATH,
"icon": "",
"dir": "",
"openwith": "",
}
self.quickDesktopModel.addShortcut(shortcut)
def createPicturesShortcut(self):
shortcut = {
"id": str(uuid.uuid4()),
"name": self.tr("图片收藏"),
"path": PICTURES_PATH,
"icon": "",
"dir": "",
"openwith": "",
}
self.quickDesktopModel.addShortcut(shortcut)
def createMusicShortcut(self):
shortcut = {
"id": str(uuid.uuid4()),
"name": self.tr("我的音乐"),
"path": MUSIC_PATH,
"icon": "",
"dir": "",
"openwith": "",
}
self.quickDesktopModel.addShortcut(shortcut)
def renameShortcut(self):
self.listView.edit(self.listView.currentIndex())
def removeShortcut(self):
self.quickDesktopModel.removeShortcut(self.listView.currentIndex())
def editShortcut(self):
index = self.listView.currentIndex()
if not index.isValid():
return
shortcut = self.quickDesktopModel.shortcutAt(index)
url = QUrl.fromUserInput(shortcut["path"])
if not url.isValid():
return
if url.scheme() == "special":
QMessageBox.information(self, self.tr("编辑快捷方式"), self.tr("不能编辑特殊图标。"))
return
elif url.scheme() == "file":
d = ShortcutDialog(self)
else:
d = BookmarkDialog(self)
if self.window().runDialog(d.edit, shortcut) == QDialog.Accepted:
shortcut.update(d.getResult())
self.quickDesktopModel.updateShortcut(shortcut, index)
d.deleteLater()
def runQuickDesktopShortcut(self):
index = self.listView.currentIndex()
if not index.isValid():
return
if not self.quickDesktopModel.runShortcut(index):
QMessageBox.information(self, self.tr("快捷面板"), \
self.tr("不能运行快捷方式。请检查文件是否存在或者程序是否正确。"))
else:
self.window().close()
class Read_Cheat_Sheet(QWidget):
def __init__(self, font, size_policy, base_directory):
super().__init__()
self.setWindowIcon(QIcon('BEI_Logo.png'))
self.setWindowTitle('Cheat Sheet Reading')
self.font = font
self.size_policy = size_policy
self.base_directory = base_directory
self.setup()
def setup(self):
'''Setup the cheat sheet viewing
'''
self.display = QTextEdit(self)
self.display.setFont(self.font)
self.display.setSizePolicy(self.size_policy, self.size_policy)
self.display.setReadOnly(True)
self.options = QListView(self)
self.options.setFont(self.font)
self.options.setSizePolicy(self.size_policy, self.size_policy)
# self.options.setReadOnly(True)
self.options.setEditTriggers(QAbstractItemView.NoEditTriggers)
layout = QHBoxLayout(self)
layout.addWidget(self.options)
layout.addWidget(self.display)
self.setLayout(layout)
#get the different topics from cheat_sheet_topics.txt
c = open(
os.path.join(os.path.join(self.base_directory, 'Cheat_Sheets'),
'Topics.txt'), 'r')
c_data = c.readlines()
c.close()
if len(c_data) == 0:
replay = QMessageBox.information(
self, 'No Cheat Sheets', 'There are currently no cheat sheets',
QMessageBox.Ok)
if replay == QMessageBox.Ok:
self.close()
else:
self.topics = []
for i in c_data:
self.topics.append(i.replace('\n', ''))
self.entry = QStandardItemModel()
self.options.setModel(self.entry)
self.options.doubleClicked[QModelIndex].connect(self.openFile)
for tex in self.topics:
self.entry.appendRow(QStandardItem(tex))
self.show()
def openFile(self, index):
item = self.entry.itemFromIndex(index)
text = str(item.text()).replace(' ', '_')
#open the text file associated with the clicked item
u = open(
os.path.join(os.path.join(self.base_directory, 'Cheat_Sheets'),
'{}.txt'.format(text)), 'r')
data = u.readlines()
u.close()
combi = ''
for i in data:
combi += i
self.display.setText(combi)
class PackagePromotion(QWidget):
def __init__(self, data_manager, parent=None):
super(PackagePromotion, self).__init__(parent)
self.data_manager = data_manager
# initialize widgets
self.component_box = QComboBox()
self.component_label = QLabel("Component")
self.source_publish_box = QComboBox()
self.source_publish_label = QLabel("Source")
self.target_publish_box = QComboBox()
self.target_publish_label = QLabel("Target")
self.publish_button = QPushButton("Promote")
self.package_label = QListView()
self.package_label.setEditTriggers(QAbstractItemView.NoEditTriggers)
# place widget in the layout
layout = QGridLayout()
layout.addWidget(self.source_publish_box, 0, 0, 1, 1)
layout.addWidget(self.component_box, 0, 1, 1, 1)
layout.addWidget(self.target_publish_box, 0, 2, 1, 1)
layout.addWidget(self.package_label, 1, 1, 2, 1)
layout.addWidget(self.publish_button, 1, 2, 1, 1)
self.setLayout(layout)
# initialize data
self.model = QStandardItemModel(self.package_label)
self.fill_publish_box()
self.recreate_package_box()
# controllers
self.source_publish_box.currentIndexChanged.connect(self.update_snapshot_box)
self.component_box.currentIndexChanged.connect(self.recreate_package_box)
self.publish_button.clicked.connect(self.update_publish)
def load_snapshot(self, name):
return Publish.get_packages(self.data_manager.get_client(), "snapshots", name)
def update_publish_old(self):
target_publish = self.data_manager.get_publish(self.target_publish_box.currentText())
target_publish.load()
package_list = set()
# find a better way to get packages
for index in reversed(range(self.model.rowCount())):
current_item = self.model.item(index)
if current_item and current_item.checkState() != 0:
package_list.add(current_item.text())
component = self.component_box.currentText()
old_snapshot_name = target_publish.components[component][0]
new_snapshot_name = DataManager.generate_snapshot_name(old_snapshot_name)
old_packages = target_publish._get_packages(self.data_manager.get_client(), "snapshots", old_snapshot_name)
for package in old_packages:
package_list.add(package)
target_publish.create_snapshots_from_packages(list(package_list), new_snapshot_name, 'Snapshot created from GUI for component {}'.format(component))
target_publish.replace_snapshot(component, new_snapshot_name)
target_publish.do_publish(recreate=False, merge_snapshots=False)
def update_publish(self):
target_publish_name = self.target_publish_box.currentText()
component = self.component_box.currentText()
package_list = []
for index in reversed(range(self.model.rowCount())):
currentItem = self.model.item(index)
if currentItem and currentItem.checkState() != 0:
package_list.append(currentItem.text())
wait_dialog = WaitDialog(target_publish_name, self.data_manager, self, component=component,
package_list=package_list, merge=True)
def fill_publish_box(self):
self.source_publish_box.clear()
self.target_publish_box.clear()
publishes = self.data_manager.get_publish_list()
for publish in publishes:
self.source_publish_box.addItem(publish)
self.target_publish_box.addItem(publish)
self.source_publish_box.update()
self.target_publish_box.update()
# update snapshot box
if len(publishes) > 0:
self.update_snapshot_box()
def update_snapshot_box(self):
name = self.source_publish_box.currentText()
current_publish = self.data_manager.get_publish(name)
current_publish.load()
self.component_box.clear()
for component in sorted(list(current_publish.components.keys())):
self.component_box.addItem(component)
self.component_box.update()
def recreate_package_box(self):
self.model.removeRows(0, self.model.rowCount())
component = self.component_box.currentText()
publish = self.source_publish_box.currentText()
# empty sometimes?
if not component:
return
packages = self.data_manager.get_package_from_publish_component(publish, component)
for package in packages:
item = QStandardItem(package)
item.setCheckable(True)
item.setCheckState(Qt.Checked)
self.model.appendRow(item)
self.package_label.setModel(self.model)
def reload_component(self):
if len(self.data_manager.get_publish_list()) > 0:
self.update_snapshot_box()
class OperacaoLogistica(QDialog):
#TODO: Acertar formatação na listagem de items por SIMAFIC
def __init__(self, parent=None):
super().__init__(parent)
self.setWindowFlags(Qt.WindowMinMaxButtonsHint
| Qt.WindowCloseButtonHint)
self.setWindowTitle('Operação Logística')
self.setMinimumSize(QSize(h_size, v_size))
self.setWindowIcon(QIcon(main_icon))
verticalSpacer = QSpacerItem(40, 20, QSizePolicy.Minimum,
QSizePolicy.Expanding)
#Pedido Input Field
self.proxy_list_result_id = QSortFilterProxyModel()
self.numero_pedido = QLineEdit(self)
self.numero_pedido.setPlaceholderText("Insira o Número do Pedido")
self.numero_pedido.textChanged.connect(
lambda wildcard: self.proxy_list_result_id.setFilterWildcard(
wildcard))
#Voltar Btn
self.voltar_btn = QPushButton(self)
#self.voltar_btn.setStyleSheet('background-color: rgb(0,0,255); color: #fff')
self.voltar_btn.setText('Voltar')
self.voltar_btn.clicked.connect(self.goMainWindow)
self.close()
#Adicionar Cores no StyleSheet
colors = ['##393318', ' ##fff']
self.pedidos = services.get_all_pedidos()
self.item_result = None
self.item_escolhido = None
self.id_pedido_list = QListView()
self.simafics_do_id = QListWidget()
#self.simafics_do_id.setHidden(True)
self.createPedidoIdList()
self.id_pedido_list.clicked.connect(
lambda id_pedido: self.createListaSimafics(id_pedido))
self.simafics_do_id.itemDoubleClicked.connect(
lambda pedido: self.simaficSelecionado(pedido))
self.pedidos_label = QLabel()
self.pedidos_label.setBuddy(self.id_pedido_list)
self.simafic_label = QLabel()
self.simafic_label.setBuddy(self.simafics_do_id)
self.itensTree = PedidoItensTree()
self.treeItensTV = QTreeView()
self.treeItensTV.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.treeItensTV.setAlternatingRowColors(True)
self.treeItensTV.setRootIsDecorated(True)
self.treeItensTV.doubleClicked.connect(self.simaficSelecionado)
self.treeItensTV.setColumnHidden(8, True)
if len(self.pedidos) <= 0:
self.pedidos_label.setText(
"É necessário adicionar um pedido na tela de cadastro.")
self.pedidos_label.setStyleSheet("QLabel { color: red; }")
else:
self.pedidos_label.setText("Listagem de Pedidos:")
self.pedidos_label.setStyleSheet("QLabel { color: black; }")
self.simafic_label.setText(
"Selecione um pedido para ver a listagem de Itens por SIMAFIC:"
)
self.simafic_label.setStyleSheet("QLabel { color: red; }")
layout = QGridLayout()
layout.setColumnStretch(0, 1)
layout.setColumnStretch(1, 4)
layout.addWidget(self.numero_pedido, 0, 0)
layout.addWidget(self.voltar_btn, 0, 1)
layout.addWidget(self.pedidos_label, 1, 0)
layout.addWidget(self.simafic_label, 1, 1)
layout.addWidget(self.id_pedido_list, 2, 0)
layout.addWidget(self.treeItensTV, 2, 1)
#layout.addWidget(self.simafics_do_id, 2,1)
self.setLayout(layout)
def createPedidoIdList(self):
print('def createPedidoIdList(self):')
onlyids = set()
pedidosbyid = []
pedidosCompletos = []
self.proxy_list_result_id = QSortFilterProxyModel()
for obj in self.pedidos:
if obj.id_pedido not in onlyids:
pedidosbyid.append(obj)
onlyids.add(obj.id_pedido)
self.pedidoId_model = QStringListModel(onlyids, self)
self.proxy_list_result_id.setSourceModel(self.pedidoId_model)
self.id_pedido_list.setModel(self.proxy_list_result_id)
self.id_pedido_list.setAlternatingRowColors(True)
self.id_pedido_list.setEditTriggers(QAbstractItemView.NoEditTriggers)
def createListaSimafics(self, id_pedido):
pedido = id_pedido.data()
self.pedidosModel = self.itensTree.createPedidosModel(self.itensTree)
self.treeItensTV.setModel(self.pedidosModel)
print('def listaSimafics(self, id_pedido): {id_pedido}'.format(
id_pedido=pedido))
self.item_result = None
self.item_result = [x for x in self.pedidos if x.id_pedido == pedido]
self.simafics_do_id.clear()
self.pedidosModel.beginResetModel
self.pedidosModel.modelReset
self.pedidosModel.endResetModel
for idx, item in enumerate(self.item_result):
print(item)
self.itensTree.addItens(
self.pedidosModel, item.cod_simafic, item.desc,
item.qty_scanneada, item.qty_total, item.nome_responsavel,
item.id_caixa, item.time_updated.strftime("%d/%m/%y %H:%M:%S"),
item.id_pedido, item)
self.simafic_label.setText(
"Listagem de Itens do pedido {} por SIMAFIC:".format(pedido))
self.simafic_label.setStyleSheet("QLabel { color: black; }")
#self.simafics_do_id.setHidden(False)
def simaficSelecionado(self, item):
print(item.column(), item.row())
simafic_escolhido = self.treeItensTV.model().index(item.row(),
0).data()
id_pedido = self.treeItensTV.model().index(item.row(), 7).data()
self.item_escolhido = [
x for x in self.item_result
if x.cod_simafic == simafic_escolhido and x.id_pedido == id_pedido
]
self.cams = ItemScanner(self.item_escolhido[0])
self.cams.show()
self.close()
def goMainWindow(self):
self.cams = mainView
self.cams.show()
self.close()
def goScan(self):
self.cams = ItemScanner("Eu sou o Pedido", "Eu sou o Simafic",
"Eu sou a Descrição", "300")
self.cams.show()
self.close()
class ImageInpainting(QWidget):
PREVIEW_CLIP_WIDTH = 200
PREVIEW_MASK_WIDTH = 200
PREVIEW_CLIP_MASK_WIDTH = 200
PREVIEW_EDGE_WIDTH = 200
PREVIEW_RESULT_WIDTH = 450
INFO_READY = 'Info : READY'
INFO_PROCESS = 'Info : PROCESSING......'
INFO_FINSH = 'Info : ACCOMPLISHMENT !'
def __init__(self, parent=None):
super(ImageInpainting, self).__init__(parent=parent)
self.parent = parent
self.image_clip_data = None
self.image_mask_data = None
self.image_clip_mask_data = None
self.image_edge_data = None
self.image_result_data = None
self.item_name_to_clip_image_info = {
} # (clip image, clip_pos_size, left_up_pos, size)
self.item_name_to_mask_image_info = {} # (mask image)
self.item_name_to_result_image_info = {} # (edge image, result image)
self.current_item_name = 'image 1'
self.edge_model = None
self.inpaint_model = None
self.config = None
self.btn_start = QPushButton('Start Process !', self)
self.btn_start.clicked.connect(self.on_clicked_start)
self.btn_show = QPushButton('Show Final Image !', self)
self.btn_show.clicked.connect(self.on_clicked_show)
self.thread_inpainting = InpaintingThread(self)
# label
ft1, ft2 = QFont(), QFont()
ft1.setPointSize(15)
ft2.setPointSize(20)
self.label_clip = QLabel('Origin image')
self.label_mask = QLabel('Mask image')
self.label_clip_mask = QLabel('Origin image with mask')
self.label_edge = QLabel('generated edge image')
self.label_result = QLabel('Result')
self.label_result.setFont(ft1)
self.label_info = QLabel(self.INFO_READY)
self.label_info.setFont(ft2)
# image
self.label_image_clip = QLabel('image clip')
self.label_image_mask = QLabel('image mask')
self.label_image_clip_mask = QLabel('image clip mask')
self.label_image_edge = QLabel('image edge')
self.label_image_result = QLabel('image mask')
# listview
self.label_listview = QLabel('Select Image')
self.model_image_clip = QStringListModel(self)
self.model_image_clip.setStringList(
self.item_name_to_clip_image_info.keys())
self.listview_image_clip = QListView(self)
self.listview_image_clip.setModel(self.model_image_clip)
self.listview_image_clip.setEditTriggers(
QAbstractItemView.NoEditTriggers)
self.listview_image_clip.doubleClicked.connect(
lambda: self.on_clicked_listview_item(self.listview_image_clip))
self.vbox_layout1 = QVBoxLayout()
self.vbox_layout1.addWidget(self.label_clip, alignment=Qt.AlignBottom)
self.vbox_layout1.addWidget(self.label_image_clip)
self.vbox_layout1.addWidget(self.label_mask, alignment=Qt.AlignBottom)
self.vbox_layout1.addWidget(self.label_image_mask)
self.vbox_layout2 = QVBoxLayout()
self.vbox_layout2.addWidget(self.label_clip_mask,
alignment=Qt.AlignBottom)
self.vbox_layout2.addWidget(self.label_image_clip_mask)
self.vbox_layout2.addWidget(self.label_edge, alignment=Qt.AlignBottom)
self.vbox_layout2.addWidget(self.label_image_edge)
self.vbox_layout3 = QVBoxLayout()
self.vbox_layout3.addWidget(self.label_result)
self.vbox_layout3.addWidget(self.label_image_result)
self.vbox_layout3.addWidget(self.label_info)
self.hbox_layout1 = QHBoxLayout()
self.hbox_layout1.addLayout(self.vbox_layout1)
self.hbox_layout1.addLayout(self.vbox_layout2)
self.vbox_layout4 = QVBoxLayout()
self.vbox_layout4.addLayout(self.hbox_layout1)
self.vbox_layout4.addWidget(self.label_listview)
self.vbox_layout4.addWidget(self.listview_image_clip)
self.grid_layout = QGridLayout()
self.grid_layout.addWidget(self.btn_start, 0, 0, 1, 3)
self.grid_layout.addWidget(self.btn_show, 0, 4, 1, 3)
self.grid_layout.addLayout(self.vbox_layout4, 1, 0, 9, 6)
self.grid_layout.addLayout(self.vbox_layout3, 1, 6, 9, 9,
Qt.AlignCenter)
self.setLayout(self.grid_layout)
def set_image(self, item_name_to_clip_image_info,
item_name_to_mask_image_info):
self.item_name_to_clip_image_info = item_name_to_clip_image_info
self.item_name_to_mask_image_info = item_name_to_mask_image_info
self.model_image_clip.setStringList(
self.item_name_to_clip_image_info.keys())
for item_name, image_info in self.item_name_to_clip_image_info.items():
image_clip_data = image_info[0]
self.item_name_to_result_image_info[item_name] = \
(np.zeros(image_clip_data.shape, np.uint8), np.copy(image_clip_data))
self.set_current_draw('image 1')
def set_current_draw(self, item_name):
from image_inpainting_demo import set_label_image
self.current_item_name = item_name
# clip image
self.image_clip_data = self.item_name_to_clip_image_info[
self.current_item_name][0]
set_label_image(self.label_image_clip, self.PREVIEW_CLIP_WIDTH,
self.image_clip_data)
# mask image
self.image_mask_data = self.item_name_to_mask_image_info[
self.current_item_name][0]
set_label_image(self.label_image_mask, self.PREVIEW_MASK_WIDTH,
self.image_mask_data)
# clip mask image
color = (255, 255, 255)
self.image_clip_mask_data = np.copy(
(self.image_mask_data / 255 * color) +
((1 - self.image_mask_data / 255) * self.image_clip_data))
self.image_clip_mask_data = np.array(self.image_clip_mask_data,
np.uint8)
set_label_image(self.label_image_clip_mask,
self.PREVIEW_CLIP_MASK_WIDTH,
self.image_clip_mask_data)
# edge image
self.image_edge_data = self.item_name_to_result_image_info[item_name][
0]
set_label_image(self.label_image_edge, self.PREVIEW_EDGE_WIDTH,
self.image_edge_data)
# result image
self.image_result_data = self.item_name_to_result_image_info[
item_name][1]
set_label_image(self.label_image_result, self.PREVIEW_RESULT_WIDTH,
self.image_result_data)
self.parent.setTabEnabled(3, True)
self.label_info.setText(self.INFO_READY)
def on_clicked_start(self):
print('on_click_start')
self.btn_start.setEnabled(False)
self.btn_show.setEnabled(False)
self.parent.setTabEnabled(0, False)
self.parent.setTabEnabled(1, False)
self.parent.setTabEnabled(2, False)
self.label_info.setText(self.INFO_PROCESS)
self.thread_inpainting.start()
def on_clicked_show(self):
row_image_data = np.copy(self.parent.file_explorer.image_selected_data)
row_img = Image.fromarray(row_image_data)
for item_name in self.item_name_to_clip_image_info.keys():
image_result_data = self.item_name_to_result_image_info[item_name][
1]
clip_pos_size = self.item_name_to_clip_image_info[item_name][1]
paste_pos_size = clip_pos_size
x, y, width, height = paste_pos_size
result_img = Image.fromarray(image_result_data)
row_img.paste(result_img, (x, y, x + width, y + height))
row_img.show('inpainted image')
def on_clicked_listview_item(self, listview):
data = listview.currentIndex().data()
self.set_current_draw(data)
def image_inpainting(self):
from shutil import copyfile
from image_inpainting_demo import set_label_image
from src.models import EdgeModel
from src.models import InpaintingModel
from config import Config
mode = 2 # test
if not self.config:
cfg_path = '.././checkpoints'
config_path = os.path.join(cfg_path, 'config.yml')
# create checkpoints path if does't exist
if not os.path.exists(cfg_path):
os.makedirs(cfg_path)
# copy config template if does't exist
if not os.path.exists(config_path):
copyfile('./config.yml.example', config_path)
# load config file
self.config = Config(config_path)
self.config.MODE = mode
# cuda visble devices
os.environ['CUDA_VISIBLE_DEVICES'] = ','.join(
str(e) for e in self.config.GPU)
# init device
if torch.cuda.is_available():
self.config.DEVICE = torch.device("cuda")
torch.backends.cudnn.benchmark = True # cudnn auto-tuner
else:
self.config.DEVICE = torch.device("cpu")
# set cv2 running threads to 1 (prevents deadlocks with pytorch dataloader)
cv2.setNumThreads(0)
# initialize random seed
torch.manual_seed(self.config.SEED)
torch.cuda.manual_seed_all(self.config.SEED)
np.random.seed(self.config.SEED)
random.seed(self.config.SEED)
if not self.edge_model and not self.inpaint_model:
self.edge_model = EdgeModel(self.config).to(self.config.DEVICE)
self.inpaint_model = InpaintingModel(self.config).to(
self.config.DEVICE)
# load model
self.edge_model.load()
self.inpaint_model.load()
# init edge connect
self.edge_model.eval()
self.inpaint_model.eval()
# load dataset
image_clip_data_list = []
image_mask_data_list = []
item_name_list = []
for item_name in self.item_name_to_clip_image_info.keys():
item_name_list.append(item_name)
image_clip_data_list.append(
self.item_name_to_clip_image_info[item_name][0])
image_mask_data_list.append(
self.item_name_to_mask_image_info[item_name][0])
test_dataset = ImageDataset(self.config,
image_clip_data_list, [],
image_mask_data_list,
augment=False,
training=False)
# start testing
print('start testing...')
test_loader = DataLoader(dataset=test_dataset, batch_size=1)
def to_cuda(*args):
return (item.to(self.config.DEVICE)
if hasattr(item, 'to') else item for item in args)
for index, items in enumerate(test_loader):
ori_shapes, images, images_gray, edges, masks = to_cuda(*items)
edges = self.edge_model(images_gray, edges, masks).detach()
outputs = self.inpaint_model(images, edges, masks)
outputs_merged = (outputs * masks) + (images * (1 - masks))
# output edge img
image_edge_data = self._get_image_data_from_tensor(
edges, ori_shapes)
# output result img
image_result_data = self._get_image_data_from_tensor(
outputs_merged, ori_shapes)
# save to image info
item_name = item_name_list[index]
self.item_name_to_result_image_info[item_name] = (
image_edge_data, image_result_data)
print('End test....')
self.set_current_draw(self.current_item_name)
self.btn_start.setEnabled(True)
self.btn_show.setEnabled(True)
self.parent.setTabEnabled(0, True)
self.parent.setTabEnabled(1, True)
self.parent.setTabEnabled(2, True)
self.label_info.setText(self.INFO_FINSH)
def _get_image_data_from_tensor(self, gpu_data, ori_shapes):
# postprocess
outputs_merged = gpu_data * 255.0
outputs_merged = outputs_merged.permute(0, 2, 3, 1)
output = outputs_merged.int()
output = output[0]
# output result img
ori_shapes = [t.item() for t in ori_shapes]
image = output.cpu().numpy().astype(np.uint8)
image = image.squeeze()
image_data = utils.resize(image, ori_shapes[0], ori_shapes[1], False)
return image_data
class LocationView(QWidget):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
# TODO load this from the data layer
self.name = "Your Home" # the name of the shown location
self.ppl = []
self.push_alt_views = []
self.push_actions = []
self.push_ctl = []
nrof_actions = 3
nrof_controls = 2
# create widgets
self.site_view = QScalingNoticeBoard(parent=self)
self.person_interact = PersonInteraction(self)
self.people_list = QListView(self)
self.calendar_notes_lbl = QLabel(self)
self.person_site_lbl = QLabel(self)
# create layout
grid = QGridLayout(self)
grid.setRowStretch(0, 2)
grid.setColumnStretch(0, 1)
grid.setColumnStretch(1, 7)
grid.setColumnStretch(2, 2)
grid.addWidget(self.site_view, 0, 0, 1, 2)
grid.addWidget(self.people_list, 0, 2, 1, 1)
hbox2 = QHBoxLayout()
for _ in range(nrof_actions):
pushbtn = QPushButton(self)
hbox2.addWidget(pushbtn)
self.push_actions.append(pushbtn)
grid.addLayout(hbox2, 1, 0, 1, 1)
grid.addWidget(self.calendar_notes_lbl, 1, 1, 1, 1)
hbox3 = QHBoxLayout()
hbox3.addWidget(self.person_site_lbl, 2, Qt.AlignLeft)
for _ in range(nrof_controls):
pushbtn = QPushButton(self)
hbox3.addWidget(pushbtn)
self.push_ctl.append(pushbtn)
grid.addLayout(hbox3, 1, 2, 1, 1)
self.setLayout(grid)
# configure widgets
self.setContentsMargins(0, 0, 0, 0)
self.person_site_lbl.setObjectName("text") # use text style
self.calendar_notes_lbl.setObjectName("text")
self.calendar_notes_lbl.setAlignment(Qt.AlignCenter)
maximized = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
maximized.setHorizontalStretch(0)
maximized.setVerticalStretch(0)
self.setSizePolicy(maximized)
# self.site_view.setScaledContents(True)
model = QStringListModel()
# model.setStringList(self.forenames)
self.people_list.setModel(model)
self.people_list.setStyleSheet(style.people_list_style)
self.people_list.setEditTriggers(QListView.NoEditTriggers)
self.people_list.setProperty("showDropIndicator", False)
self.people_list.setDefaultDropAction(Qt.IgnoreAction)
selectionModel = QItemSelectionModel(model)
self.people_list.setSelectionModel(selectionModel)
self.setImage(world.locationImage(self.name))
# TODO: location buttons belong to a location
btn_size = (100, 35)
for text, pos in world.locationButtons(self.name):
pushbtn = QPushButton(self.site_view)
pushbtn.setGeometry(*pos, *btn_size)
pushbtn.setText(text)
pushbtn.setToolTip(text)
notice = self.site_view.addNotice(pushbtn)
notice.setFixedGeometry(True)
self.push_alt_views.append(pushbtn)
self.retranslateUi()
# connect signals
self.push_alt_views[0].clicked.connect(
self.parent().toggle_school_management)
selectionModel.selectionChanged.connect(self.on_selectionChanged)
self.site_view.show()
def addPerson(self, person):
self.ppl.append(person)
self.people_list.model().setStringList(self.forenames)
def removePerson(self, person):
pass # TODO
def setImage(self, path):
self.site_view.setPixmap(QPixmap(str(path)))
def retranslateUi(self):
tra = QApplication.translate
ctxt = "LocationView"
self.person_site_lbl.setText(tra(ctxt, "Oliver Klozoff | Lubriscity"))
self.calendar_notes_lbl.setText(
tra(ctxt, "No calendar notes for today"))
self.push_actions[0].setText(tra(ctxt, "Smartphone"))
self.push_actions[1].setText(tra(ctxt, "Inventory"))
self.push_actions[2].setText(tra(ctxt, "Map"))
self.push_ctl[0].setText(tra(ctxt, "Settings"))
self.push_ctl[1].setText(tra(ctxt, "Debug"))
btnnames = [data[0] for data in world.locationButtons(self.name)]
for btn, text in zip(self.push_alt_views, btnnames):
btn.setText(tra(ctxt, text))
@property
def forenames(self):
return [p.forename for p in self.ppl]
@pyqtSlot(QItemSelection, QItemSelection)
def on_selectionChanged(self, selected, deselected):
# TODO: implement blur
# self.site_view.toggle_blur()
# self.person_interact.setVisible(True)
self.person_interact.exec()
class CollectData(QWidget):
def __init__(self):
super().__init__()
self.init_variable()
self.init_img()
self.init_ui()
self.show()
'''
def paintEvent(self, QPaintEvent):
painter = QPainter(self)
painter.setPen(QColor(166,66,250))
painter.begin(self)
painter.draw()
painter.end()
'''
def init_img(self):
self.qlabel = myLabel(self)
img = cv2.imread('data/test.png') # 打开图片
self.qlabel.img = img.copy()
self.qlabel.img_current = img.copy()
self.qlabel.update_img()
def init_variable(self):
self.label = 0
self.transformation_type = 0
self.total_img_number = 0
self.current_img_index = 0
self.folder_path = r"data"
self.jump_img_index = -1
self.img_list = []
self.img_name_list = []
self.whether_to_crop = 0
def init_ui(self):
self.setGeometry(200, 200, 1000, 800)
self.setWindowTitle('数据标注')
self.qlabel.setGeometry(QRect(30, 30, 640, 480))
self.init_buttons()
for file_name in os.listdir(self.folder_path + '/'):
img = cv2.imread(self.folder_path + '/' + file_name)
if img is None:
continue
self.img_list.append(img)
self.img_name_list.append(os.path.splitext(file_name)[0])
#QMessageBox.information(self, 'complete', '图片加载完毕')
self.total_img_number = len(self.img_list)
self.current_img_index = 1
self.refresh_img()
self.update_list()
def init_buttons(self):
self.previous_img_button = QPushButton("上一张图片", self)
self.next_img_button = QPushButton("下一张图片", self)
self.save_message_button = QPushButton("保存当前图片信息", self)
self.show_message_button = QPushButton("显示当前图片信息", self)
self.open_folder_button = QPushButton("打开文件夹", self)
self.add_border_button = QPushButton("保存当前框", self)
self.delete_border_button = QPushButton("删除选中框", self)
self.img_folder_text = QLineEdit('data', self)
self.goto_chosen_img_button = QPushButton("跳转图片", self)
self.jump_img_text = QLineEdit('', self)
self.show_index_message = QLabel(self)
self.crop_message_box = QCheckBox('裁剪所选图片', self)
self.img_folder_text.selectAll()
self.img_folder_text.setFocus()
self.previous_img_button.setGeometry(30, 530, 150, 40)
self.next_img_button.setGeometry(200, 530, 150, 40)
self.save_message_button.setGeometry(370, 530, 150, 40)
self.show_message_button.setGeometry(540, 530, 150, 40)
self.img_folder_text.setGeometry(30, 590, 660, 40)
self.open_folder_button.setGeometry(710, 590, 150, 40)
self.jump_img_text.setGeometry(30, 650, 150, 40)
self.goto_chosen_img_button.setGeometry(200, 650, 150, 40)
self.show_index_message.setGeometry(30, 710, 300, 40)
self.crop_message_box.setGeometry(30, 750, 150, 40)
self.add_border_button.setGeometry(710, 380, 150, 40)
self.delete_border_button.setGeometry(710, 440, 150, 40)
self.previous_img_button.clicked.connect(self.previous_img)
self.next_img_button.clicked.connect(self.next_img)
self.save_message_button.clicked.connect(self.save_message)
self.show_message_button.clicked.connect(self.show_message)
self.open_folder_button.clicked.connect(self.open_folder)
self.add_border_button.clicked.connect(self.save_current_border)
self.delete_border_button.clicked.connect(self.delete_border)
self.goto_chosen_img_button.clicked.connect(self.goto_chosen_img)
self.crop_message_box.stateChanged.connect(self.crop_message)
self.label_combo = QComboBox(self)
for i in range(len(LABEL_LIST)):
self.label_combo.addItem(LABEL_LIST[i])
self.label_combo.move(900, 30)
self.label_combo.activated[str].connect(self.label_on_activated)
self.listview = QListView(self)
self.listview.setGeometry(710, 30, 150, 320)
self.listview.doubleClicked.connect(self.list_clicked)
self.listview.setEditTriggers(QListView.NoEditTriggers)
def crop_message(self):
self.whether_to_crop = self.crop_message_box.checkState()
def previous_img(self):
if self.current_img_index == 1:
QMessageBox.information(self, 'warning', '已经是第一张啦')
return
self.current_img_index -= 1
self.refresh_img()
def next_img(self):
if self.current_img_index == self.total_img_number:
QMessageBox.information(self, 'warning', '已经是最后一张啦')
return
self.current_img_index += 1
self.refresh_img()
def show_message(self):
if len(self.qlabel.rectangle_label) > 0:
reply = QMessageBox.question(self, '确认', '当前有未保存信息，是否继续？',
QMessageBox.Yes | QMessageBox.No,
QMessageBox.No)
if reply == QMessageBox.No:
return
self.qlabel.rectangle_label.clear()
if os.path.isfile(self.folder_path + '/' +
self.img_name_list[self.current_img_index - 1] +
'.csv') == False:
QMessageBox.information(self, 'warning', '当前图片无信息')
return
message = pd.read_csv(self.folder_path + '/' +
self.img_name_list[self.current_img_index - 1] +
'.csv',
sep=',',
header=None)
message = np.array(message.T)
message = message.astype(int)
for i in range(len(message)):
self.qlabel.rectangle_label.append(
Rectangle(message[i][1], message[i][2], message[i][3],
message[i][4], True, message[i][0]))
self.update_list()
self.refresh_img()
QMessageBox.information(self, 'complete', '信息加载完毕')
def open_folder(self):
self.folder_path = self.img_folder_text.text()
if os.path.isdir(self.folder_path) == False:
QMessageBox.information(self, 'warning', '文件夹路径非法')
return
self.img_list.clear()
self.img_name_list.clear()
for file_name in os.listdir(self.folder_path + '/'):
img = cv2.imread(self.folder_path + '/' + file_name)
if img is None:
continue
self.img_list.append(img)
self.img_name_list.append(os.path.splitext(file_name)[0])
QMessageBox.information(self, 'complete', '图片加载完毕')
self.total_img_number = len(self.img_list)
self.current_img_index = 1
self.refresh_img()
def goto_chosen_img(self):
if self.jump_img_text.text().isdigit() == False:
QMessageBox.information(self, 'warning', '请输入合法的数字')
return
if int(self.jump_img_text.text()) <= 0 or int(
self.jump_img_text.text()) > self.total_img_number:
QMessageBox.information(self, 'warning', '请输入合法的数字')
return
self.current_img_index = int(self.jump_img_text.text())
self.refresh_img()
def refresh_img(self):
img = self.img_list[self.current_img_index - 1]
self.qlabel.img = img.copy()
self.qlabel.update_qlabel_img()
self.qlabel.update_img()
self.show_index_message.setText('一共' + str(self.total_img_number) +
'张图片,当前第' +
str(self.current_img_index) + '张图片')
def label_on_activated(self):
self.label = self.label_combo.currentIndex()
def update_list(self):
slm = QStringListModel()
string_list = []
for i in range(len(self.qlabel.rectangle_label)):
string_list.append(
LABEL_LIST[self.qlabel.rectangle_label[i].label])
slm.setStringList(string_list)
self.listview.setModel(slm)
def list_clicked(self, qModelIndex):
if self.qlabel.rectangle_label[
qModelIndex.row()].whether_display == True:
self.qlabel.rectangle_label[
qModelIndex.row()].whether_display = False
else:
self.qlabel.rectangle_label[
qModelIndex.row()].whether_display = True
self.qlabel.update_qlabel_img()
self.qlabel.update_img()
def save_current_border(self):
self.qlabel.save_current_border(self.label)
self.qlabel.update_qlabel_img()
self.qlabel.update_img()
self.update_list()
def label_clicked(self):
sender = self.sender()
if sender == self.label_button:
self.label = self.label_button.checkedId()
def save_message(self):
if self.save_current_angle() == False:
return
self.qlabel.rectangle_label.clear()
self.update_list()
self.refresh_img()
def save_current_angle(self):
save_data = []
for i in range(5):
save_data.append([])
if len(self.qlabel.rectangle_label) > 0:
if os.path.isfile(self.folder_path + '/' +
self.img_name_list[self.current_img_index - 1] +
'.csv'):
reply = QMessageBox.question(self, '确认', '是否覆盖当前图片已保存信息？',
QMessageBox.Yes | QMessageBox.No,
QMessageBox.No)
if reply == QMessageBox.No:
return False
for i in range(len(self.qlabel.rectangle_label)):
save_data[0].append(self.qlabel.rectangle_label[i].label)
save_data[1].append(self.qlabel.rectangle_label[i].x0)
save_data[2].append(self.qlabel.rectangle_label[i].x1)
save_data[3].append(self.qlabel.rectangle_label[i].y0)
save_data[4].append(self.qlabel.rectangle_label[i].y1)
if os.path.exists('crop_img/') == False:
os.makedirs('crop_img/')
h, w, channel = self.qlabel.img.shape
img_after_crop = self.qlabel.img[
self.qlabel.rectangle_label[i].y0 * h // self.qlabel.
qlabel_width:self.qlabel.rectangle_label[i].y1 * h //
self.qlabel.qlabel_width,
self.qlabel.rectangle_label[i].x0 * w // self.qlabel.
qlabel_length:self.qlabel.rectangle_label[i].x1 * w //
self.qlabel.qlabel_length]
if self.whether_to_crop == 1:
cv2.imwrite(
'crop_img/' +
self.img_name_list[self.current_img_index - 1] + '_' +
str(i) + '.jpg', img_after_crop)
if np.shape(np.array(save_data)) != (5, 0):
np.savetxt(self.folder_path + '/' +
self.img_name_list[self.current_img_index - 1] +
'.csv',
np.array(save_data),
delimiter=',')
def delete_border(self):
if self.listview.currentIndex().row() > -1:
self.qlabel.delete_border(self.listview.currentIndex().row())
self.qlabel.update_qlabel_img()
self.qlabel.update_img()
self.update_list()
else:
QMessageBox.information(self, 'warning', '请先选中一行')
class MDIHistory(QWidget, _HalWidgetBase):
def __init__(self, parent=None):
super(MDIHistory, self).__init__(parent)
self.setMinimumSize(QSize(300, 200))
self.setWindowTitle("PyQt5 editor test example")
lay = QVBoxLayout()
lay.setContentsMargins(0, 0, 0, 0)
self.setLayout(lay)
self.list = QListView()
self.list.setEditTriggers(QListView.NoEditTriggers)
self.list.activated.connect(self.activated)
self.list.setAlternatingRowColors(True)
self.list.selectionChanged = self.selectionChanged
self.model = QStandardItemModel(self.list)
self.MDILine = MDILine()
self.MDILine.soft_keyboard = False
self.MDILine.line_up = self.line_up
self.MDILine.line_down = self.line_down
# add widgets
lay.addWidget(self.list)
lay.addWidget(self.MDILine)
self.reload()
def _hal_init(self):
STATUS.connect('state-off', lambda w: self.setEnabled(False))
STATUS.connect('state-estop', lambda w: self.setEnabled(False))
STATUS.connect(
'interp-idle', lambda w: self.setEnabled(STATUS.machine_is_on(
) and (STATUS.is_all_homed() or INFO.NO_HOME_REQUIRED)))
STATUS.connect('interp-run',
lambda w: self.setEnabled(not STATUS.is_auto_mode()))
STATUS.connect('all-homed',
lambda w: self.setEnabled(STATUS.machine_is_on()))
def reload(self, w=None):
print 'RELOAD'
try:
fp = os.path.expanduser(INFO.MDI_HISTORY_PATH)
with open(fp, 'r') as inputfile:
for line in inputfile:
line = line.rstrip('\n')
item = QStandardItem(line)
self.model.appendRow(item)
self.list.setModel(self.model)
self.list.scrollToBottom()
except Exception as e:
print e
LOG.error('File path is not valid: {}]n,()'.format(fp), e)
def line_up(self):
print 'up'
def line_down(self):
print 'down'
def selectionChanged(self, old, new):
cmd = self.getSelected()
self.MDILine.setText(cmd)
def getSelected(self):
selected_indexes = self.list.selectedIndexes()
selected_rows = [item.row() for item in selected_indexes]
# iterates each selected row in descending order
for selected_row in sorted(selected_rows, reverse=True):
text = self.model.item(selected_row).text()
return text
def activated(self):
cmd = self.getSelected()
self.MDILine.setText(cmd)
self.MDILine.submit()
item = QStandardItem(cmd)
self.model.appendRow(item)
self.list.update()
#########################################################################
# This is how designer can interact with our widget properties.
# designer will show the pyqtProperty properties in the editor
# it will use the get set and reset calls to do those actions
#########################################################################
def set_soft_keyboard(self, data):
self.MDILine.soft_keyboard = data
def get_soft_keyboard(self):
return self.MDILine.soft_keyboard
def reset_soft_keyboard(self):
self.MDILine.soft_keyboard = False
# designer will show these properties in this order:
soft_keyboard_option = pyqtProperty(bool, get_soft_keyboard,
set_soft_keyboard, reset_soft_keyboard)
class FontViewWidget(QWidget):
def __init__(self, statusBar, config, *args, **kwargs):
super(FontViewWidget, self).__init__(*args, **kwargs)
self.statusBar = statusBar
layout = QVBoxLayout(self)
self.retButton = QToolButton(self)
self.retButton.setIconSize(QSize(60, 60))
self.retButton.setToolButtonStyle(Qt.ToolButtonTextUnderIcon)
self.retButton.setMinimumSize(200, 100)
self.retButton.setMaximumSize(200, 100)
layout.addWidget(self.retButton)
# 过滤输入框
layout.addWidget(
QLineEdit(self, textChanged=self.doFilter,
placeholderText='过滤...'))
# Material Font
self.listView = QListView(self)
self.listView.setMouseTracking(True)
self.listView.setViewMode(QListView.IconMode)
self.listView.setMovement(QListView.Static)
self.listView.setFlow(QListView.LeftToRight)
self.listView.setWrapping(True)
self.listView.setEditTriggers(QListView.NoEditTriggers)
self.listView.setResizeMode(QListView.Adjust)
self.listView.doubleClicked.connect(self.onDoubleClicked)
self.listView.entered.connect(self.onEntered)
self.dmodel = QStandardItemModel(self.listView)
self.fmodel = QSortFilterProxyModel(self.listView)
self.fmodel.setSourceModel(self.dmodel)
self.fmodel.setFilterRole(Qt.ToolTipRole)
self.listView.setModel(self.fmodel)
layout.addWidget(self.listView)
# 字体加载器
loader = config[0]
# 添加Item
fontMap = json.loads(open(config[1],
'rb').read().decode(encoding='utf_8',
errors='ignore'),
encoding='utf_8')
for name, _ in fontMap.items():
item = QStandardItem(loader.icon(name), '')
item.setData(name, Qt.ToolTipRole)
item.setData(name, Qt.StatusTipRole)
item.setTextAlignment(Qt.AlignCenter)
item.setFlags(item.flags())
self.dmodel.appendRow(item)
def doFilter(self, _):
self.fmodel.setFilterRegExp(self.sender().text())
def onEntered(self, index):
index = self.fmodel.mapToSource(index)
text = index.data(Qt.ToolTipRole)
if text:
self.retButton.setText(text)
self.retButton.setIcon(self.dmodel.itemFromIndex(index).icon())
def onDoubleClicked(self, index):
index = self.fmodel.mapToSource(index)
text = index.data(Qt.ToolTipRole)
if text:
QApplication.clipboard().setText(text)
self.statusBar.showMessage('已复制: %s' % text)
class UploadDialog(QDialog):
"""文件上传对话框"""
new_infos = pyqtSignal(object)
def __init__(self):
super().__init__()
self.cwd = os.getcwd()
self.selected = []
self.max_len = 400
self.initUI()
self.set_size()
self.setStyleSheet(dialog_qss_style)
def set_values(self, folder_name):
self.setWindowTitle("上传文件至 ➩ " + str(folder_name))
def initUI(self):
self.setWindowTitle("上传文件")
self.setWindowIcon(QIcon("./icon/upload.ico"))
self.logo = QLabel()
self.logo.setPixmap(QPixmap("./icon/logo3.gif"))
self.logo.setStyleSheet("background-color:rgb(0,153,255);")
self.logo.setAlignment(Qt.AlignCenter)
# btn 1
self.btn_chooseDir = QPushButton("选择文件夹", self)
self.btn_chooseDir.setObjectName("btn_chooseDir")
self.btn_chooseDir.setObjectName("btn_chooseDir")
self.btn_chooseDir.setIcon(QIcon("./icon/folder.gif"))
# btn 2
self.btn_chooseMutiFile = QPushButton("选择多文件", self)
self.btn_chooseDir.setObjectName("btn_chooseMutiFile")
self.btn_chooseMutiFile.setObjectName("btn_chooseMutiFile")
self.btn_chooseMutiFile.setIcon(QIcon("./icon/file.ico"))
# btn 3
self.btn_deleteSelect = QPushButton("删除", self)
self.btn_deleteSelect.setObjectName("btn_deleteSelect")
self.btn_deleteSelect.setIcon(QIcon("./icon/delete.ico"))
# 列表
self.list_view = QListView(self)
self.list_view.setViewMode(QListView.ListMode)
self.slm = QStandardItem()
self.model = QStandardItemModel()
self.list_view.setModel(self.model)
self.model.removeRows(0, self.model.rowCount()) # 清除旧的选择
self.list_view.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.list_view.setSelectionBehavior(QAbstractItemView.SelectRows)
self.list_view.setSelectionMode(QAbstractItemView.ExtendedSelection)
self.buttonBox = QDialogButtonBox()
self.buttonBox.setOrientation(Qt.Horizontal)
self.buttonBox.setStandardButtons(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
grid = QGridLayout()
grid.setSpacing(10)
grid.addWidget(self.logo, 1, 0, 1, 3)
grid.addWidget(self.btn_chooseDir, 2, 0)
grid.addWidget(self.btn_chooseMutiFile, 2, 2)
grid.addWidget(self.list_view, 3, 0, 2, 3)
grid.addWidget(self.btn_deleteSelect, 5, 0)
grid.addWidget(self.buttonBox, 5, 1, 1, 2)
self.setLayout(grid)
self.setMinimumWidth(350)
# 设置信号
self.btn_chooseDir.clicked.connect(self.slot_btn_chooseDir)
self.btn_chooseMutiFile.clicked.connect(self.slot_btn_chooseMutiFile)
self.btn_deleteSelect.clicked.connect(self.slot_btn_deleteSelect)
self.buttonBox.accepted.connect(self.slot_btn_ok)
self.buttonBox.accepted.connect(self.accept)
self.buttonBox.rejected.connect(self.clear_old)
self.buttonBox.rejected.connect(self.reject)
def set_size(self):
rows = self.model.rowCount()
for i in range(rows):
m_len = int(len(self.model.item(i, 0).text()) * 4)
if m_len > self.max_len:
self.max_len = m_len
rows = 10 if rows >= 10 else rows # 限制最大高度
self.resize(self.max_len, 250 + rows * 28)
def clear_old(self):
self.selected = []
self.model.removeRows(0, self.model.rowCount())
self.set_size()
def slot_btn_ok(self):
if self.selected:
self.new_infos.emit(self.selected)
self.clear_old()
def slot_btn_deleteSelect(self):
_indexes = self.list_view.selectionModel().selection().indexes()
if not _indexes:
return
indexes = []
for i in _indexes: # 获取所选行号
indexes.append(i.row())
indexes = set(indexes)
for i in sorted(indexes, reverse=True):
self.selected.remove(self.model.item(i, 0).text())
self.model.removeRow(i)
self.set_size()
def slot_btn_chooseDir(self):
dir_choose = QFileDialog.getExistingDirectory(self, "选择文件夹",
self.cwd) # 起始路径
if dir_choose == "":
return
if dir_choose not in self.selected:
self.selected.append(dir_choose)
self.model.appendRow(
QStandardItem(QIcon("./icon/folder.gif"), dir_choose))
self.set_size()
def slot_btn_chooseMutiFile(self):
files, _ = QFileDialog.getOpenFileNames(self, "选择多文件", self.cwd,
"All Files (*)")
if len(files) == 0:
return
for _file in files:
if _file not in self.selected:
self.selected.append(_file)
self.model.appendRow(
QStandardItem(QIcon("./icon/file.ico"), _file))
self.set_size()
class MatchViewGroup(QGroupBox):
def __init__(self, ui_template):
super(MatchViewGroup, self).__init__()
"""
Import settings
"""
self.ui_template = ui_template
self.settings = import_settings()
self.current_match = Match()
self.setTitle('Match View')
"""
Layout
"""
self.grid_layout = QGridLayout()
self.setLayout(self.grid_layout)
self.grid_layout.setColumnStretch(1, 1)
self.grid_layout.setColumnStretch(2, 1)
self.grid_layout.setColumnStretch(3, 1)
self.grid_layout.setRowStretch(1, 1)
"""
Rounds list
"""
self.rounds_list = QListView()
self.rounds_list_model = QStandardItemModel()
self.rounds_list.setModel(self.rounds_list_model)
self.rounds_list.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.grid_layout.addWidget(self.rounds_list, 0, 0, 2, 1)
"""
End game state info
"""
self.end_game_state_info_group = QGroupBox()
self.end_game_state_info_layout = QVBoxLayout()
self.end_game_state_info_group.setLayout(
self.end_game_state_info_layout)
self.end_game_state_info_group.setTitle('Results')
self.grid_layout.addWidget(self.end_game_state_info_group, 2, 0, 2, 1)
# Results
self.match_seed_label = QLabel()
self.end_game_state_info_layout.addWidget(self.match_seed_label)
self.match_winner_label = QLabel()
self.end_game_state_info_layout.addWidget(self.match_winner_label)
self.player_A_results_label = QLabel()
self.end_game_state_info_layout.addWidget(self.player_A_results_label)
self.player_B_results_label = QLabel()
self.end_game_state_info_layout.addWidget(self.player_B_results_label)
self.referee_messages_label = QLabel()
self.referee_messages_label.setText('Referee Messages')
self.end_game_state_info_layout.addWidget(self.referee_messages_label)
self.referee_messages_text = QTextBrowser()
self.end_game_state_info_layout.addWidget(self.referee_messages_text)
# Map view
self.map_view = QGraphicsView()
self.map_scene = QGraphicsScene()
self.map_view.setScene(self.map_scene)
self.grid_layout.addWidget(self.map_view, 1, 1, 2, 2)
# Add groups and field labels to the match view
self.groups = {}
self.populate_fields(self.ui_template, self.grid_layout)
def populate_fields(self, template, layout, i=0):
groups = template['groups']
for group_ in groups:
group = QGroupBox()
group.setTitle(group_['title'])
layout_ = QGridLayout()
layout_.setSpacing(0)
group.setLayout(layout_)
self.groups[group_['name']] = group
coordinates = [i, 0]
span = [1, 1]
if 'row' in group_ and 'col' in group_:
coordinates = [group_['row'], group_['col']]
if 'colSpan' in group_ or 'rowSpan' in group_:
span = [group_.get('rowSpan', 1), group_.get('colSpan', 1)]
layout.addWidget(group, *coordinates, *span)
group.fields = {}
if 'fields' in group_:
for index, field_ in enumerate(group_['fields']):
if field_['name'] == 'worm':
field = QLabel()
field.setPixmap(QPixmap(field_['resource']))
layout_.addWidget(field, index - 1, 0)
else:
field_label = QLabel()
field_label.setText(field_['label'])
field = QLabel()
if field_['label'] != '':
group.fields[field_['name']] = field
layout_.addWidget(field_label, index, 0)
layout_.addWidget(field, index, 1)
else:
group.fields[field_['name']] = field
layout_.addWidget(field, index, 1)
if 'groups' in group_:
self.populate_fields(group_, layout_, index + 1)
def match_selected(self, *args):
match = args[0].indexes()[0].data()
match_logs_directory = self.settings.value('match_logs_directory')
directory = os.path.join(match_logs_directory, match)
self.map_scene.clear()
if os.path.isdir(directory):
self.load_match(directory)
def round_selected(self, *args):
index_array = args[0].indexes()
if len(index_array):
index = index_array[0]
self.current_match.set_current_round(index.data())
self.update_fields()
self.draw_map()
def draw_map(self):
cells = self.current_match.current_round.state['map']
self.map_scene.clear()
self.map_scene.setSceneRect(
0, 0, self.current_match.state['mapSize'] * PIXEL_SIZE,
self.current_match.state['mapSize'] * PIXEL_SIZE)
for row in cells:
for cell in row:
pic = QPixmap(IMAGE[cell['type']])
item = self.map_scene.addPixmap(
pic.scaled(PIXEL_SIZE, PIXEL_SIZE))
item.setPos(cell['x'] * PIXEL_SIZE, cell['y'] * PIXEL_SIZE)
if 'occupier' in cell:
if cell['occupier']['playerId'] == 1:
pic = QPixmap(':resources/icons/map/wormA.png')
else:
pic = QPixmap(':resources/icons/map/wormB.png')
item = self.map_scene.addPixmap(
pic.scaled(PIXEL_SIZE, PIXEL_SIZE))
item.setPos(cell['x'] * PIXEL_SIZE, cell['y'] * PIXEL_SIZE)
health_label = QLabel()
font = QFont()
font.setBold(True)
health_label.setFont(font)
health_label.setText(
str(cell['occupier']['id']) + ' - ' +
str(cell['occupier']['health']))
item = self.map_scene.addWidget(health_label)
item.setPos((cell['x'] - 0.5) * PIXEL_SIZE,
(cell['y'] - 1) * PIXEL_SIZE)
if 'powerup' in cell:
pic = QPixmap(IMAGE[cell['powerup']['type']])
item = self.map_scene.addPixmap(
pic.scaled(PIXEL_SIZE, PIXEL_SIZE))
item.setPos(cell['x'] * PIXEL_SIZE, cell['y'] * PIXEL_SIZE)
def load_match(self, directory):
self.current_match = Match(directory)
self.list_rounds()
self.update_end_game_state()
self.rounds_list.setCurrentIndex(self.rounds_list_model.index(0, 0))
def update_end_game_state(self):
results = self.current_match.end_game_state
self.match_seed_label.setText(results['seed'])
self.match_winner_label.setText(results['winner'])
self.player_A_results_label.setText(results['playerA'])
self.player_B_results_label.setText(results['playerB'])
self.referee_messages_text.setText(results['referee'])
def list_rounds(self):
match_directory = self.current_match.match_directory
model = self.rounds_list_model
model.clear()
rounds = [
round_ for round_ in os.listdir(match_directory) if
'Round' in round_ and os.path.isdir(os.path.join(match_directory))
]
for round_ in rounds:
item = QStandardItem(round_)
model.appendRow(item)
def update_fields(self):
for group_key, group in self.groups.items():
if group_key == 'match_info_group':
state = self.current_match.state
self.update_labels(group, state)
if 'player_A_move_info' in group_key:
temp = [
value for key, value in
self.current_match.current_round.player_command.items()
if 'A -' in key
]
self.update_labels(group, temp[0])
if 'player_B_move_info' in group_key:
temp = [
value for key, value in
self.current_match.current_round.player_command.items()
if 'B -' in key
]
self.update_labels(group, temp[0])
if group_key == 'player_A_info_group':
temp = [
value for key, value in
self.current_match.current_round.state.items()
if 'A - ' in key
]
self.update_labels(group, temp[0])
if group_key == 'player_B_info_group':
temp = [
value for key, value in
self.current_match.current_round.state.items()
if 'B - ' in key
]
self.update_labels(group, temp[0])
if group_key == 'player_A_worms_info_group':
players = [player for player in self.current_match.players]
self.populate_worms_info(group, players[0])
if group_key == 'player_B_worms_info_group':
self.populate_worms_info(group, players[1])
@staticmethod
def update_labels(group, state):
for field_key, field in group.fields.items():
field.setText(str(state[field_key]))
if field_key == 'colour':
field.setIcon()
def populate_worms_info(self, group, player):
# Clears the layout before re-adding worms info
for i in reversed(range(group.layout().count())):
group.layout().itemAt(i).widget().setParent(None)
worms = self.current_match.current_round.state[player]['worms']
for worm in worms:
wormGroup = QGroupBox()
wormGroup_layout = QGridLayout()
wormGroup_layout.setSpacing(0)
wormGroup.setLayout(wormGroup_layout)
group.layout().addWidget(wormGroup)
for index, (key, value) in enumerate(worm.items()):
label_ = QLabel()
label_.setText(key + ': ')
label = QLabel()
label.setText(str(value))
wormGroup_layout.addWidget(label_, index, 0)
wormGroup_layout.addWidget(label, index, 1)
class Viewer(QMainWindow):
loaded_spectrum = {}
count_rates = {}
plotted_spectrum = []
e_plot = []
e_calibration = []
mini = 0
maxi = 14
plotted_tracking = []
not_plotted_tracking = []
def __init__(self):
super().__init__()
self.size_policy = QSizePolicy.Expanding
self.font = QFont()
self.font.setPointSize(12)
self.setWindowTitle('Calibrated Spectrum Viewer')
self.menu()
self.geometry()
self.showMaximized()
self.show()
def menu(self):
self.menuFile = self.menuBar().addMenu('&File')
self.load_new = QAction('&Load New Spectrum')
self.load_new.triggered.connect(self.new_spectrum)
self.load_new.setShortcut('Ctrl+O')
self.load_new.setToolTip('Load a new calibrated spectrum')
self.save_figure = QAction('&Save Spectrum Image')
self.save_figure.triggered.connect(self.save_fig)
self.save_figure.setShortcut('Ctrl+Shift+S')
self.save_spec = QAction('&Save Spe File')
self.save_spec.triggered.connect(self.spe)
self.save_spec.setShortcut('Ctrl+S')
self.menuFile.addActions(
[self.load_new, self.save_figure, self.save_spec])
self.menuEdit = self.menuBar().addMenu('&Edit')
self.calibrate_spectrum = QAction('&Calibrate Spectrum')
self.calibrate_spectrum.triggered.connect(self.spectrum_calibrate)
self.calibrate_spectrum.setShortcut('Ctrl+G')
self.calibrate_spectrum.setToolTip('Calibrate a raw spectrum')
self.menuEdit.addActions([self.calibrate_spectrum])
self.change_zoom = QAction('&Change Zoom Location')
self.change_zoom.triggered.connect(self.zoom_change)
self.change_zoom.setShortcut('Ctrl+Z')
self.change_zoom.setToolTip('Change the initial zoom on the spectrum')
self.menuView = self.menuBar().addMenu('&View Spectrum Data')
self.view_energies = QAction('&View Energies')
self.view_energies.setToolTip('Add Vertical Energy Lines')
self.view_energies.triggered.connect(self.vert_lines)
self.view_calibration_energies = QAction('&Calibration Energies')
self.view_calibration_energies.triggered.connect(self.calib_lines)
self.view_countrate = QAction('&Count Rates')
self.view_countrate.triggered.connect(self.rate_tracking)
self.roi_uncertainty = QAction('&ROI Uncertainties')
self.roi_uncertainty.triggered.connect(self.roi_count_rate_uncertainty)
self.res_action = QAction('&Energy Resolution')
self.res_action.triggered.connect(self.find_peaks)
self.menuView.addActions([
self.view_energies, self.change_zoom,
self.view_calibration_energies, self.view_countrate,
self.roi_uncertainty, self.res_action
])
self.menuList = self.menuBar().addMenu('&List Mode Data Analysis')
self.timing_window = QAction('&View Time Decay')
self.timing_window.triggered.connect(self.time_display)
self.list_mode = QAction('&Analyze List Mode Data')
self.list_mode.triggered.connect(self.list_moder)
self.detection_probability = QAction('&Detection Probability')
self.detection_probability.triggered.connect(self.detec_prob)
self.dieaway = QAction('&Analyze Die Away')
self.dieaway.triggered.connect(self.bck_die_away)
self.video = QAction('&Save Probability Videos')
self.video.triggered.connect(self.save_detec_videos)
self.view_probs = QAction('&View Detection Probability')
self.view_probs.triggered.connect(self.view_probabilities)
self.menuList.addActions([
self.timing_window, self.list_mode, self.detection_probability,
self.dieaway, self.video, self.view_probs
])
def geometry(self):
self.open_ = QDockWidget('Loaded Spectrums')
#initialize the widget to be used for loading the spectrum
self.open_spectrum = QListView(self)
self.open_spectrum.setFont(self.font)
self.open_spectrum.setSizePolicy(self.size_policy, self.size_policy)
self.open_spectrum.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.loader = QStandardItemModel()
self.open_spectrum.setModel(self.loader)
self.open_spectrum.doubleClicked[QModelIndex].connect(self.update_add)
self.open_.setWidget(self.open_spectrum)
self.addDockWidget(Qt.LeftDockWidgetArea, self.open_)
#initialize the widget to remove a spectrum from the plotter
self.close_ = QDockWidget('Plotted Spectrum')
self.close_spectrum = QListView(self)
self.close_spectrum.setFont(self.font)
self.close_spectrum.setSizePolicy(self.size_policy, self.size_policy)
self.close_spectrum.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.unloader = QStandardItemModel()
self.close_spectrum.setModel(self.unloader)
self.close_spectrum.doubleClicked[QModelIndex].connect(
self.update_close)
self.close_.setWidget(self.close_spectrum)
self.addDockWidget(Qt.RightDockWidgetArea, self.close_)
#add the plot window
self.plot_window = QWidget()
layout = QVBoxLayout()
self.figure = Figure()
self._canvas = FigureCanvas(self.figure)
self.toolbar = NavigationToolbar(self._canvas, self)
layout.addWidget(self.toolbar)
layout.addWidget(self._canvas)
self.plot_window.setLayout(layout)
self.setCentralWidget(self.plot_window)
self.static_ax = self._canvas.figure.subplots()
self.static_ax.set_yscale('log')
self.static_ax.set_xlim(0, 14)
self.static_ax.set_xlabel('Energy [MeV]')
self.static_ax.set_ylabel('Count Rate [cps]')
self.figure.tight_layout()
def new_spectrum(self):
self.vals = New()
self.vals.add.clicked.connect(self.new_getter)
def new_getter(self):
self.vals.add_spectrum()
counts = self.vals.counts
calibr = self.vals.calibration
legend = self.vals.legend.text()
accum_time = self.vals.accum_time
self.count_rates[legend] = self.vals.count_rate
self.loaded_spectrum[legend] = [calibr, counts, accum_time]
self.loader.appendRow(QStandardItem(legend))
self.not_plotted_tracking.append(legend)
def vert_lines(self):
self.widget = QWidget()
self.widget.setWindowTitle('Add Energies')
current_lines = ''
for i in range(len(self.e_plot)):
if i != 0:
current_lines += ',{}'.format(self.e_plot[i])
else:
current_lines += '{}'.format(self.e_plot[i])
self.line = QLineEdit(self)
self.line.setFont(self.font)
self.line.setSizePolicy(self.size_policy, self.size_policy)
self.line.setToolTip('Enter energies in MeV, seperated by commas')
self.line.setText(current_lines)
self.line_label = QLabel('Energies:', self)
self.line_label.setFont(self.font)
self.line_label.setSizePolicy(self.size_policy, self.size_policy)
self.add = QPushButton('Update')
self.add.setFont(self.font)
self.add.setSizePolicy(self.size_policy, self.size_policy)
self.add.clicked.connect(self.add_lines)
layout = QGridLayout()
layout.addWidget(self.line_label, 0, 0)
layout.addWidget(self.line, 0, 1)
layout.addWidget(self.add, 1, 0, 1, 2)
self.widget.setLayout(layout)
self.widget.show()
def calib_lines(self):
self.widget1 = QWidget()
self.widget1.setWindowTitle('Add Energies')
current_lines = ''
for i in range(len(self.e_calibration)):
if i != 0:
current_lines += ',{}'.format(self.e_calibration[i])
else:
current_lines += '{}'.format(self.e_calibration[i])
self.line1 = QLineEdit(self)
self.line1.setFont(self.font)
self.line1.setSizePolicy(self.size_policy, self.size_policy)
self.line1.setToolTip(
'Enter energies in MeV used for calibration, seperated by commas')
self.line1.setText(current_lines)
self.line_label1 = QLabel('Energies:', self)
self.line_label1.setFont(self.font)
self.line_label1.setSizePolicy(self.size_policy, self.size_policy)
self.add1 = QPushButton('Update')
self.add1.setFont(self.font)
self.add1.setSizePolicy(self.size_policy, self.size_policy)
self.add1.clicked.connect(self.add_cal_lines)
layout = QGridLayout()
layout.addWidget(self.line_label1, 0, 0)
layout.addWidget(self.line1, 0, 1)
layout.addWidget(self.add1, 1, 0, 1, 2)
self.widget1.setLayout(layout)
self.widget1.show()
def add_lines(self):
text = self.line.text().split(sep=',')
try:
self.e_plot = [float(i) for i in text]
except:
self.e_plot = []
self.widget.close()
self.replot()
def add_cal_lines(self):
text = self.line1.text().split(sep=',')
try:
self.e_calibration = [float(i) for i in text]
except:
self.e_calibration = []
self.widget1.close()
self.replot()
def zoom_change(self):
self.change_zoomed = QWidget()
min_label = QLabel('Min:[MeV]', self)
min_label.setFont(self.font)
min_label.setSizePolicy(self.size_policy, self.size_policy)
max_label = QLabel('Max:[MeV]', self)
max_label.setFont(self.font)
max_label.setSizePolicy(self.size_policy, self.size_policy)
self.min_ = QLineEdit(self)
self.min_.setFont(self.font)
self.min_.setSizePolicy(self.size_policy, self.size_policy)
self.min_.setText(str(self.mini))
self.max_ = QLineEdit(self)
self.max_.setFont(self.font)
self.max_.setSizePolicy(self.size_policy, self.size_policy)
self.max_.setText(str(self.maxi))
self.add_ = QPushButton('Update')
self.add_.setFont(self.font)
self.add_.setSizePolicy(self.size_policy, self.size_policy)
self.add_.clicked.connect(self.zoomed_update)
layout = QGridLayout()
layout.addWidget(min_label, 0, 0)
layout.addWidget(self.min_, 0, 1)
layout.addWidget(max_label, 1, 0)
layout.addWidget(self.max_, 1, 1)
layout.addWidget(self.add_, 2, 0, 1, 2)
self.change_zoomed.setLayout(layout)
self.change_zoomed.show()
def zoomed_update(self):
self.mini = float(self.min_.text())
self.maxi = float(self.max_.text())
self.change_zoomed.close()
self.replot()
def update_add(self, index):
item = self.loader.itemFromIndex(index)
val = item.text()
self.plotted_spectrum.append(val)
#add the item selected to the plotted side
self.plotted_tracking.append(val)
self.unloader.appendRow(QStandardItem(val))
#remove all the values from the add plot
self.loader.removeRows(0, self.loader.rowCount())
#remove the values clicked from the not plotted list
self.not_plotted_tracking.remove(val)
#add the remaining items back to the options
for i in self.not_plotted_tracking:
self.loader.appendRow(QStandardItem(i))
self.replot()
def update_close(self, index):
item = self.unloader.itemFromIndex(index)
val = item.text()
self.plotted_spectrum.remove(val)
#add the value to the not plotted side
self.not_plotted_tracking.append(val)
self.loader.appendRow(QStandardItem(val))
#remove all the values from the unloading side
self.unloader.removeRows(0, self.unloader.rowCount())
#remove the value from the tracking list
self.plotted_tracking.remove(val)
#put the items back into the unloader
for i in self.plotted_tracking:
self.unloader.appendRow(QStandardItem(i))
self.replot()
def replot(self):
self.static_ax.clear()
self.mouse_tracking()
self.static_ax.set_yscale('log')
self.static_ax.set_xlim(self.mini, self.maxi)
self.static_ax.set_xlabel('Energy [MeV]')
self.static_ax.set_ylabel('Count Rate [cps]')
current = list(self.static_ax.get_xticks())
for i in self.e_plot:
current.append(i)
self.static_ax.axvline(i, color='r', linestyle='--', linewidth=0.8)
for i in self.e_calibration:
current.append(i)
self.static_ax.axvline(i, color='k', linestyle='-', linewidth=1)
for i in self.plotted_spectrum:
spec = self.loaded_spectrum[i]
self.static_ax.plot(spec[0],
spec[1],
label='{}, Accum Time: {}s'.format(i, spec[2]))
current = [round(float(k), 2) for k in current]
self.static_ax.set_xticks(current)
self.static_ax.set_xticklabels(current, rotation=90)
self.static_ax.legend(prop={'size': 18})
# self.static_ax.tick_params(labelsize=18)
self._canvas.draw()
self.figure.tight_layout()
def save_fig(self):
options = 'Portable Network Graphics (*.png);;'
options_ = 'Joint Photographic Experts Group(*.jpg)'
options = options + options_
file_name, ok = QFileDialog.getSaveFileName(self,
'Spectrum Image Save', "",
options)
if file_name and ok:
self.figure.savefig(file_name, dpi=600, figsize=(10, 10))
def spectrum_calibrate(self):
'''Launch a calibration window
'''
self.calibrator = Window()
def rate_tracking(self):
'''Show the count rate for all the loaded spectrum
'''
self.rater = QWidget()
self.rater.setWindowTitle('Count Rates')
editor = QTextEdit()
editor.setFont(self.font)
editor.setReadOnly(True)
editor.setSizePolicy(self.size_policy, self.size_policy)
for i in list(self.count_rates.keys()):
editor.append('{}: {:,.2f}cps'.format(i, self.count_rates[i]))
layout = QVBoxLayout()
layout.addWidget(editor)
self.rater.setLayout(layout)
self.rater.show()
def mouse_tracking(self):
self.txt = self.static_ax.text(0.85,
0.6,
"",
transform=self.static_ax.transAxes)
self.figure.canvas.mpl_connect('motion_notify_event', self.mouse_move)
def mouse_move(self, event):
if not event.inaxes:
return
self.txt.set_text('Energy: {:,.3f} MeV'.format(event.xdata))
self._canvas.draw()
def roi_display(self):
'''Determine the number of counts
in a specified ROI and display them
'''
self.change_roi = QWidget()
min_label = QLabel('Min:[MeV]', self)
min_label.setFont(self.font)
min_label.setSizePolicy(self.size_policy, self.size_policy)
max_label = QLabel('Max:[MeV]', self)
max_label.setFont(self.font)
max_label.setSizePolicy(self.size_policy, self.size_policy)
self.min_roi = QLineEdit(self)
self.min_roi.setFont(self.font)
self.min_roi.setSizePolicy(self.size_policy, self.size_policy)
self.max_roi = QLineEdit(self)
self.max_roi.setFont(self.font)
self.max_roi.setSizePolicy(self.size_policy, self.size_policy)
self.add_roi = QPushButton('Update')
self.add_roi.setFont(self.font)
self.add_roi.setSizePolicy(self.size_policy, self.size_policy)
self.add_roi.clicked.connect(self.roi_update)
layout = QGridLayout()
layout.addWidget(min_label, 0, 0)
layout.addWidget(self.min_roi, 0, 1)
layout.addWidget(max_label, 1, 0)
layout.addWidget(self.max_roi, 1, 1)
layout.addWidget(self.add_roi, 2, 0, 1, 2)
self.change_roi.setLayout(layout)
self.change_roi.show()
def roi_update(self):
self.change_roi.close()
roi_counts = {}
for i in self.plotted_spectrum:
calibration = self.loaded_spectrum[i]
ma = 0
mi = len(calibration[0])
for j in range(len(calibration[0])):
if calibration[0][j] <= float(self.max_roi.text()):
ma = j
if calibration[0][j] <= float(self.min_roi.text()):
# print(calibration[0][j])
mi = j
# print(mi,ma)
roi_counts[i] = self.loaded_spectrum[i][1][mi:ma]
# scale the rois by the accumulation time and determine the sum of the
# area using np
roi = {}
for i in list(roi_counts.keys()):
timer = float(self.loaded_spectrum[i][2])
scale = 0
for j in range(len(roi_counts[i])):
scale += roi_counts[i][j] #*timer
roi[i] = scale
self.roi_counts = roi
if self.display == False:
self.uncertain()
if self.display:
self.display_roi = QWidget()
self.display_roi.setWindowTitle('ROI counts')
rois = QTextEdit()
rois.setFont(self.font)
rois.setSizePolicy(self.size_policy, self.size_policy)
for i in list(roi.keys()):
rois.append('{}: {:.4f} cps'.format(i, roi[i]))
layout = QVBoxLayout()
layout.addWidget(rois)
self.display_roi.setLayout(layout)
self.display_roi.show()
self.display = True
def spe(self):
'''Save the selected file out to an spe file format, even though the
calibration will likely not be correct
'''
items = self.loaded_spectrum.keys()
text, ok = QInputDialog.getItem(self, 'Save Spectrum', 'Saving:',
items, 0, False)
if ok and text:
name = QFileDialog.getSaveFileName(self, 'Spe File Name', '',
'IAEA (*.spe)')
if name != " ":
try:
Save_Spe(self.loaded_spectrum[text], text, name)
except:
pass
def time_display(self):
self.di = Time_Window()
def list_moder(self):
self.lm = List_Mode_Viewer()
def roi_count_rate_uncertainty(self):
'''Calculate the std of the ROI count rates-- will
eventaully have the ability to indicate which loaded spectrum
are desired'''
self.display = False
self.roi_display()
# self.display=True
def uncertain(self):
# now to select the foreground and background spectrum:
foreground, ok = QInputDialog.getItem(self, 'Foreground',
'Select Foreground',
self.roi_counts.keys(), 0, False)
background, ok2 = QInputDialog.getItem(self, 'Background',
'Select Background',
self.roi_counts.keys(), 0,
False)
if ok and ok2:
#get the count rates from both of them
uncer = net_std(self.roi_counts[foreground],
self.roi_counts[background])
u = uncer.calculate_uncertainties()
net_cr = self.roi_counts[foreground] - self.roi_counts[background]
self.uncertainty_display(u, net_cr, foreground, background)
def uncertainty_display(self, net_uncer, net_count_rate, foreground,
background):
self.rateu = QWidget()
self.rateu.setWindowTitle('Count Rates')
editor = QTextEdit()
editor.setFont(self.font)
editor.setReadOnly(True)
editor.setSizePolicy(self.size_policy, self.size_policy)
fore_cps = self.roi_counts[foreground]
back_cps = self.roi_counts[background]
editorappd = [
'Foreground: {}: {:.3f} +\- {:.3f} cps'.format(
foreground, fore_cps,
fore_cps**0.5), 'Background: {}: {:.3f} +\- {:.3f} cps'.format(
background, back_cps, back_cps**0.5),
'Net: {:.3f} +\- {:.3f} cps'.format(net_count_rate, net_uncer)
]
for i in editorappd:
editor.append(i)
layout = QVBoxLayout()
layout.addWidget(editor)
self.rateu.setLayout(layout)
self.rateu.show()
def bck_die_away(self):
#get the file
file_name, ok = QFileDialog.getOpenFileName(
self, 'Background Die Away List Mode File', "",
'Comma Seperated File (*.csv);;Text File (*.txt)')
num_bins, ok2 = QInputDialog.getInt(self, 'Enter number of bins',
'Bins:', 300, 0, 10000)
if file_name != '' and ok and ok2:
cts, time = bkg(file_name, num_bins).process_data()
io = max(cts[1::])
index = (np.abs(cts - io / 2)).argmin()
t_12 = time[index]
lambd = np.log(2) / t_12
fit = [io * np.exp(-lambd * i) for i in time]
plt.plot(time[1::], cts[1::], '*')
# plt.plot(time[1::],fit[1::])
plt.ylabel('Count Rate (cps)')
plt.xlabel('Time (s)')
plt.show()
f = open('Back_Die_Away.csv', 'w')
f.write('Time,Counts\n')
for i in range(len(cts)):
f.write('{:.5f},{:.5f}\n'.format(cts[i], time[i]))
f.close()
def detec_prob(self):
#get the foreground and background file names and info
#get the file
file_nameb, ok = QFileDialog.getOpenFileName(
self, 'Background List Mode File', "",
'Comma Seperated File (*.csv);;Text File (*.txt)')
file_namef, ok2 = QFileDialog.getOpenFileName(
self, 'Foreground List Mode File', "",
'Comma Seperated File (*.csv);;Text File (*.txt)')
if ok and ok2:
num, ok3 = QInputDialog.getInt(self, 'Detection Probability',
'Percentage:', 99, 0, 100)
if ok3:
evals = np.linspace(0, 1800, 181)
detection_probability = DT(file_namef, file_nameb, evals)
probs = detection_probability.probs
probs = [i * 100 for i in probs]
#need to parse through the probabilities and find the first
#real data point that doesn't represent a statistical anamoly
#set a lower threshold to start counting at
threshold = 90 #if the probability drops below this
s_index = 0
for i in range(len(probs)):
if probs[i] <= threshold:
s_index = i
break
probs = probs[s_index::]
evals = evals[s_index::]
time_detect = np.interp(num, probs, evals)
plt.figure(1)
plt.plot(evals, probs, '*')
plt.axvline(
time_detect,
label='Time to {}% detection probability: {:.2f}s'.format(
num, time_detect))
plt.xlabel('Time(s)')
plt.ylabel('Probability (%)')
plt.legend()
# print(probs)
plt.show()
#save the raw data out
fore_sums = detection_probability.f_sums[s_index::]
back_sums = detection_probability.b_sums[s_index::]
analysis_times = detection_probability.a_times[s_index::]
raw_name, ok3 = QFileDialog.getSaveFileName(
self, 'Raw Data Save File Name', "",
'Comma Seperated File (*.csv);;Text File (*.txt)')
if ok3:
f = open(raw_name, 'w')
for i in range(len(fore_sums)):
f.write('{},{},{:.4f},{:.4f}\n'.format(
fore_sums[i], back_sums[i], analysis_times[i],
probs[i]))
f.close()
def save_detec_videos(self):
file_nameb, ok = QFileDialog.getOpenFileName(
self, 'Raw Data File', "",
'Comma Seperated File (*.csv);;Text File (*.txt)')
file_nameg, ok1 = QFileDialog.getSaveFileName(self, 'Curve Save File',
"", 'Multimeda (*.mp4)')
file_namep, ok2 = QFileDialog.getSaveFileName(self,
'Probability Save File',
"", 'Multimeda (*.mp4)')
if ok and ok1 and ok2:
Movie = movie(file_nameb, file_nameg, file_namep)
Movie.save_gaussian()
Movie.save_probability()
def find_peaks(self):
#first get all the plotted spectrum names
loaded_spectrum = self.plotted_spectrum
selection, ok = QInputDialog.getItem(self, 'Energy Resolution',
'Selection', loaded_spectrum, 0,
False)
if ok:
x = self.loaded_spectrum[selection][1]
y = self.loaded_spectrum[selection][0]
#then let the user select which one to pick
#then get the counts to analyze
peaks, properties = signal.find_peaks(x, width=3, distance=2)
e_res = []
widths = properties['widths'] #the fwhm of the peak
left = properties['left_ips'] #left point of the fwhm
right = properties['right_ips'] #right point of the fwhm
sigma = [i / (2 * np.sqrt(2 * np.log(2)))
for i in widths] #standard deviation
left_sig = []
right_sig = []
#recalculate the peak location based on the average fo the left and right fwhm
for i in range(len(peaks)):
avg = (left[i] + right[i]) / 2
peaks[i] = avg
left_sig.append(avg - 4 * sigma[i])
right_sig.append(avg + 4 * sigma[i])
e_res.append(widths[i] / avg * 100)
plt.plot(y, x)
plt.yscale('log')
_, y_max = plt.gca().get_ylim()
y_max = y_max - .5 * y_max
for i in range(len(peaks)):
plt.axvline(y[int(peaks[i])],
linestyle='--',
color='m',
linewidth=1)
v = y[int(peaks[i])] + 0.005 * y[int(peaks[i])]
plt.annotate('{:.2f}%'.format(e_res[i]),
xy=(v, y_max),
rotation='vertical',
color='m')
# plt.axvspan(y[int(left_sig[2])],y[int(right_sig[2])],facecolor='g',alpha=0.5)
plt.show()
return peaks, e_res
def view_probabilities(self):
self.view = Plotter()
def __init__(self):
super(SoundpacksTab, self).__init__()
self.tab_disabled = False
self.qnam = QNetworkAccessManager()
self.http_reply = None
self.download_http_reply = None
self.current_repo_info = None
self.soundpacks = []
self.soundpacks_model = None
self.installing_new_soundpack = False
self.downloading_new_soundpack = False
self.extracting_new_soundpack = False
self.close_after_install = False
self.game_dir = None
self.soundpacks_dir = None
layout = QVBoxLayout()
top_part = QWidget()
tp_layout = QHBoxLayout()
tp_layout.setContentsMargins(0, 0, 0, 0)
self.tp_layout = tp_layout
installed_gb = QGroupBox()
tp_layout.addWidget(installed_gb)
self.installed_gb = installed_gb
installed_gb_layout = QVBoxLayout()
installed_gb.setLayout(installed_gb_layout)
self.installed_gb_layout = installed_gb_layout
installed_lv = QListView()
installed_lv.clicked.connect(self.installed_clicked)
installed_lv.setEditTriggers(QAbstractItemView.NoEditTriggers)
installed_gb_layout.addWidget(installed_lv)
self.installed_lv = installed_lv
installed_buttons = QWidget()
ib_layout = QHBoxLayout()
installed_buttons.setLayout(ib_layout)
ib_layout.setContentsMargins(0, 0, 0, 0)
self.ib_layout = ib_layout
self.installed_buttons = installed_buttons
installed_gb_layout.addWidget(installed_buttons)
disable_existing_button = QPushButton()
disable_existing_button.clicked.connect(self.disable_existing)
disable_existing_button.setEnabled(False)
ib_layout.addWidget(disable_existing_button)
self.disable_existing_button = disable_existing_button
delete_existing_button = QPushButton()
delete_existing_button.clicked.connect(self.delete_existing)
delete_existing_button.setEnabled(False)
ib_layout.addWidget(delete_existing_button)
self.delete_existing_button = delete_existing_button
repository_gb = QGroupBox()
tp_layout.addWidget(repository_gb)
self.repository_gb = repository_gb
repository_gb_layout = QVBoxLayout()
repository_gb.setLayout(repository_gb_layout)
self.repository_gb_layout = repository_gb_layout
repository_lv = QListView()
repository_lv.clicked.connect(self.repository_clicked)
repository_lv.setEditTriggers(QAbstractItemView.NoEditTriggers)
repository_gb_layout.addWidget(repository_lv)
self.repository_lv = repository_lv
suggest_new_label = QLabel()
suggest_new_label.setOpenExternalLinks(True)
repository_gb_layout.addWidget(suggest_new_label)
self.suggest_new_label = suggest_new_label
install_new_button = QPushButton()
install_new_button.clicked.connect(self.install_new)
install_new_button.setEnabled(False)
repository_gb_layout.addWidget(install_new_button)
self.install_new_button = install_new_button
top_part.setLayout(tp_layout)
layout.addWidget(top_part)
self.top_part = top_part
details_gb = QGroupBox()
layout.addWidget(details_gb)
self.details_gb = details_gb
details_gb_layout = QGridLayout()
viewname_label = QLabel()
details_gb_layout.addWidget(viewname_label, 0, 0, Qt.AlignRight)
self.viewname_label = viewname_label
viewname_le = QLineEdit()
viewname_le.setReadOnly(True)
details_gb_layout.addWidget(viewname_le, 0, 1)
self.viewname_le = viewname_le
name_label = QLabel()
details_gb_layout.addWidget(name_label, 1, 0, Qt.AlignRight)
self.name_label = name_label
name_le = QLineEdit()
name_le.setReadOnly(True)
details_gb_layout.addWidget(name_le, 1, 1)
self.name_le = name_le
path_label = QLabel()
details_gb_layout.addWidget(path_label, 2, 0, Qt.AlignRight)
self.path_label = path_label
path_le = QLineEdit()
path_le.setReadOnly(True)
details_gb_layout.addWidget(path_le, 2, 1)
self.path_le = path_le
size_label = QLabel()
details_gb_layout.addWidget(size_label, 3, 0, Qt.AlignRight)
self.size_label = size_label
size_le = QLineEdit()
size_le.setReadOnly(True)
details_gb_layout.addWidget(size_le, 3, 1)
self.size_le = size_le
homepage_label = QLabel()
details_gb_layout.addWidget(homepage_label, 4, 0, Qt.AlignRight)
self.homepage_label = homepage_label
homepage_tb = QTextBrowser()
homepage_tb.setReadOnly(True)
homepage_tb.setOpenExternalLinks(True)
homepage_tb.setMaximumHeight(23)
homepage_tb.setLineWrapMode(QTextEdit.NoWrap)
homepage_tb.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
details_gb_layout.addWidget(homepage_tb, 4, 1)
self.homepage_tb = homepage_tb
details_gb.setLayout(details_gb_layout)
self.details_gb_layout = details_gb_layout
self.setLayout(layout)
self.load_repository()
self.set_text()
class SnapshotTab(QWidget):
def __init__(self, dataManager, parent=None):
self.dataManager = dataManager
super(SnapshotTab, self).__init__(parent)
# initialize widgets
self.component_box = QComboBox()
self.publish_box = QComboBox()
self.publish_button = QPushButton("Publish")
self.reload_button = QPushButton("Reload")
self.package_label = QListView()
self.package_label.setEditTriggers(QAbstractItemView.NoEditTriggers)
# place widget in the layout
layout = QGridLayout()
layout.addWidget(self.publish_box, 0, 0, 1, 1)
layout.addWidget(self.component_box, 0, 1, 1, 1)
layout.addWidget(self.publish_button, 0, 2, 1, 1)
layout.addWidget(self.package_label, 1, 1, 2, 1)
layout.addWidget(self.reload_button, 1, 2, 1, 1)
self.setLayout(layout)
# initialize data
self.model = QStandardItemModel(self.package_label)
self.fill_publish_box()
self.recreate_package_box()
# controllers
self.publish_box.currentIndexChanged.connect(self.update_snapshot_box)
self.component_box.currentIndexChanged.connect(self.recreate_package_box)
self.publish_button.clicked.connect(self.update_publish)
def update_publish(self):
publish_name = self.publish_box.currentText()
package_list = []
for index in reversed(range(self.model.rowCount())):
currentItem = self.model.item(index)
if currentItem and currentItem.checkState() != 0:
package_list.append(currentItem.text())
# TODO: create function for snapshot name?
component = self.component_box.currentText()
waitDialog = WaitDialog(publish_name, self.dataManager, self, component=component, package_list=package_list)
def fill_publish_box(self):
self.publish_box.clear()
publishes = self.dataManager.get_publish_list()
for publish in publishes:
self.publish_box.addItem(publish)
if len(publishes) > 0:
self.publish_box.update()
self.update_snapshot_box()
def update_snapshot_box(self):
name = self.publish_box.currentText()
current_publish = self.dataManager.get_publish(name)
self.component_box.clear()
for component in sorted(list(current_publish.components.keys())):
self.component_box.addItem(component)
self.component_box.update()
def recreate_package_box(self):
self.model.removeRows(0, self.model.rowCount())
component = self.component_box.currentText()
current_publish = self.publish_box.currentText()
# empty sometimes?
if not component:
return
packages = self.dataManager.get_package_from_publish_component(current_publish, component)
for package in packages:
item = QStandardItem(package)
item.setCheckable(True)
item.setCheckState(Qt.Checked)
self.model.appendRow(item)
self.package_label.setModel(self.model)
def reload_component(self):
if len(self.dataManager.get_publish_list()) > 0:
self.update_snapshot_box()
self.recreate_package_box()
class VistaListaPrenotazioniAdmin(QWidget):
def __init__(self, data_inizio=None, parent=None):
super(VistaListaPrenotazioniAdmin, self).__init__(parent)
self.controllore_lista_prenotazioni = ControlloreListaPrenotazioni()
self.data_inizio = data_inizio
self.v_layout = QVBoxLayout()
self.font = QFont("Arial", 15, 15, True)
#Se non è stata passata alcuna data di inizio visualizza tutte le prenotazioni, altrimenti visualizza le prenotazioni
#che iniziano in quella data
if data_inizio is not None:
self.label_prenotazioni_by_data = QLabel("Arrivi del giorno " + data_inizio.strftime("%d/%m/%Y") + ":")
else:
self.label_prenotazioni_by_data = QLabel("Tutte le prenotazioni: ")
self.label_prenotazioni_by_data.setStyleSheet("font: 20pt \"Papyrus\";""color: rgb(0,0,255);")
self.label_prenotazioni_by_data.setAlignment(Qt.AlignCenter)
self.v_layout.addWidget(self.label_prenotazioni_by_data)
self.v_layout.addSpacing(15)
self.lista_prenotazioni = QListView()
self.aggiorna_dati_prenotazioni()
self.v_layout.addWidget(self.lista_prenotazioni)
self.bottone_dettagli_prenotaizone = QPushButton("Dettagli prenotazione")
self.bottone_dettagli_prenotaizone.setFont(self.font)
self.bottone_dettagli_prenotaizone.setStyleSheet("background-color: rgb(170,180,255);")
self.bottone_dettagli_prenotaizone.clicked.connect(self.dettagli_prenotazione)
self.shortcut_open = QShortcut(QKeySequence('Return'), self)
self.shortcut_open.activated.connect(self.dettagli_prenotazione)
self.v_layout.addWidget(self.bottone_dettagli_prenotaizone)
self.v_layout.addSpacing(15)
#Se è stata passata una data di inizio, verrà creato nella finestra un piccolo sommario della situazione del
#resort in quella data
if data_inizio is not None:
self.label_stato_resort = QLabel("Sommario prenotazioni:")
self.label_stato_resort.setAlignment(Qt.AlignCenter)
self.label_stato_resort.setStyleSheet("font: 18pt \"Papyrus\";""color: rgb(0,0,255);")
self.v_layout.addWidget(self.label_stato_resort)
self.lista_stato_resort = QListView()
self.get_stato_resort(data_inizio)
self.lista_stato_resort.setAlternatingRowColors(True)
self.lista_stato_resort.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.v_layout.addWidget(self.lista_stato_resort)
self.setLayout(self.v_layout)
self.resize(900, 800)
self.setWindowTitle("Lista Prenotazioni")
#Ottiene i dati delle prenotazioni e li mette nella lista visualizzata
def aggiorna_dati_prenotazioni(self):
self.modello_lista_prenotazioni = QStandardItemModel()
for prenotazione in self.controllore_lista_prenotazioni.get_lista_prenotazioni():
if self.data_inizio == prenotazione.data_inizio:
item = QStandardItem()
item.setText("Prenotazione del " + prenotazione.data_inizio.strftime("%d/%m/%Y")
+ " - " + prenotazione.data_fine.strftime("%d/%m/%Y") + " effettuata da " + prenotazione.email_cliente)
item.setEditable(False)
item.setFont(self.font)
self.modello_lista_prenotazioni.appendRow(item)
elif self.data_inizio is None:
item = QStandardItem()
item.setText("Prenotazione del " + prenotazione.data_inizio.strftime("%d/%m/%Y")
+ " - " + prenotazione.data_fine.strftime("%d/%m/%Y") + " effettuata da " + prenotazione.email_cliente)
item.setEditable(False)
item.setFont(self.font)
self.modello_lista_prenotazioni.appendRow(item)
self.lista_prenotazioni.setModel(self.modello_lista_prenotazioni)
#Visualizza i dettagli della prenotazione selezionata, se non ne è stata selezionata alcuna mostra un messaggio di errore
def dettagli_prenotazione(self):
try:
indice = self.lista_prenotazioni.selectedIndexes()[0].row()
if self.data_inizio is not None:
lista_prenotazioni_filtrata = []
for prenotazione in self.controllore_lista_prenotazioni.get_lista_prenotazioni():
if prenotazione.data_inizio == self.data_inizio:
lista_prenotazioni_filtrata.append(prenotazione)
da_visualizzare = lista_prenotazioni_filtrata[indice]
else:
da_visualizzare = self.controllore_lista_prenotazioni.get_lista_prenotazioni()[indice]
except:
QMessageBox.critical(self, "Errore", "Seleziona la prenotazione da visualizzare", QMessageBox.Ok, QMessageBox.Ok)
return
self.vista_prenotazione = VistaPrenotazione(ControllorePrenotazione(da_visualizzare))
self.vista_prenotazione.show()
#Crea il sommario dello stato del reort nella data passata come argomento
def get_stato_resort(self, data_controllo_stato):
self.modello_stato_resort = QStandardItemModel()
#Inizializza il numero di posti occupati dei serivizi disponibili a 0
numero_suite_occupate = 0
numero_stanze_doppie_occupate = 0
numero_stanze_familiari_occupate = 0
numero_bungalow_occupati = 0
numero_mezzi_elettrici_occupati = 0
numero_prenotazioni_centro_benessere = 0
for prenotazione in self.controllore_lista_prenotazioni.get_lista_prenotazioni():
#Controlla se la data del sommario ricade tra l'inizio e la fine di ogni prenotazione
if data_controllo_stato >= prenotazione.data_inizio and data_controllo_stato <= prenotazione.data_fine:
#Se il controllo dà esito positivo, viene aggiunto un posto occupato al servizio di alloggio scelto nella prenotazione
if prenotazione.servizio_alloggio == Servizio("Suite", "Alloggio", 235):
numero_suite_occupate = numero_suite_occupate + 1
if prenotazione.servizio_alloggio == Servizio("Camera doppia", "Alloggio", 80):
numero_stanze_doppie_occupate = numero_stanze_doppie_occupate + 1
if prenotazione.servizio_alloggio == Servizio("Camera famigliare", "Alloggio", 125):
numero_stanze_familiari_occupate = numero_stanze_familiari_occupate + 1
if prenotazione.servizio_alloggio == Servizio("Bungalow", "Alloggio", 150):
numero_bungalow_occupati = numero_bungalow_occupati + 1
#Se il controllo dà esito positivo, viene aggiunto un numero di posti occupati al servizio aggiuntivo
# pari al numero di persone della prenotazione
for servizio_aggiuntivo in prenotazione.servizi_aggiuntivi:
if servizio_aggiuntivo == Servizio("Noleggio mezzi elettrici", "Servizi aggiuntivi", 30):
numero_mezzi_elettrici_occupati = numero_mezzi_elettrici_occupati + prenotazione.numero_persone
if servizio_aggiuntivo == Servizio("Centro benessere", "Servizi aggiuntivi", 50):
numero_prenotazioni_centro_benessere = numero_prenotazioni_centro_benessere + prenotazione.numero_persone
#I dati vengono aggiunti alla lista del sommario tramite degli item
item_suite = QStandardItem()
item_suite.setFont(self.font)
item_suite.setEditable(False)
item_suite.setText("Suite occupate: " + str(numero_suite_occupate))
self.modello_stato_resort.appendRow(item_suite)
item_camere_doppie = QStandardItem()
item_camere_doppie.setFont(self.font)
item_camere_doppie.setEditable(False)
item_camere_doppie.setText("Camere doppie occupate: " + str(numero_stanze_doppie_occupate))
self.modello_stato_resort.appendRow(item_camere_doppie)
item_camere_famigliari = QStandardItem()
item_camere_famigliari.setFont(self.font)
item_camere_famigliari.setEditable(False)
item_camere_famigliari.setText("Camere famigliari occupate: " + str(numero_stanze_doppie_occupate))
self.modello_stato_resort.appendRow(item_camere_famigliari)
item_bungalow = QStandardItem()
item_bungalow.setFont(self.font)
item_bungalow.setEditable(False)
item_bungalow.setText("Bungalow occupati: " + str(numero_bungalow_occupati))
self.modello_stato_resort.appendRow(item_bungalow)
item_vuoto = QStandardItem()
item_vuoto.setEditable(False)
self.modello_stato_resort.appendRow(item_vuoto)
item_mezzi_elettrici = QStandardItem()
item_mezzi_elettrici.setFont(self.font)
item_mezzi_elettrici.setEditable(False)
item_mezzi_elettrici.setText("Numero mezzi elettrici noleggiati: " + str(numero_mezzi_elettrici_occupati))
self.modello_stato_resort.appendRow(item_mezzi_elettrici)
item_centro_benessere = QStandardItem()
item_centro_benessere.setFont(self.font)
item_centro_benessere.setEditable(False)
item_centro_benessere.setText("Numero prenotazioni centro benessere: " + str(numero_prenotazioni_centro_benessere))
self.modello_stato_resort.appendRow(item_centro_benessere)
self.lista_stato_resort.setModel(self.modello_stato_resort)
class MDIHistory(QWidget, _HalWidgetBase):
def __init__(self, parent=None):
super(MDIHistory, self).__init__(parent)
self.setMinimumSize(QSize(200, 150))
self.setWindowTitle("PyQt5 editor test example")
lay = QVBoxLayout()
lay.setContentsMargins(0,0,0,0)
self.setLayout(lay)
self.list = QListView()
self.list.setEditTriggers(QListView.NoEditTriggers)
self.list.activated.connect(self.activated)
self.list.setAlternatingRowColors(True)
self.list.selectionChanged = self.selectionChanged
self.model = QStandardItemModel(self.list)
self.MDILine = MDILine()
self.MDILine.soft_keyboard = False
self.MDILine.line_up = self.line_up
self.MDILine.line_down = self.line_down
STATUS.connect('reload-mdi-history', self.reload)
# add widgets
lay.addWidget(self.list)
lay.addWidget(self.MDILine)
self.fp = os.path.expanduser(INFO.MDI_HISTORY_PATH)
try:
open(self.fp, 'r')
except:
open(self.fp, 'a+')
LOG.debug('MDI History file created: {}'.format(self.fp))
self.reload()
self.select_row('last')
def _hal_init(self):
STATUS.connect('state-off', lambda w: self.setEnabled(False))
STATUS.connect('state-estop', lambda w: self.setEnabled(False))
STATUS.connect('interp-idle', lambda w: self.setEnabled(STATUS.machine_is_on()
and (STATUS.is_all_homed()
or INFO.NO_HOME_REQUIRED)))
STATUS.connect('interp-run', lambda w: self.setEnabled(not STATUS.is_auto_mode()))
STATUS.connect('all-homed', lambda w: self.setEnabled(STATUS.machine_is_on()))
def reload(self, w=None ):
self.model.clear()
try:
with open(self.fp,'r') as inputfile:
for line in inputfile:
line = line.rstrip('\n')
item = QStandardItem(line)
self.model.appendRow(item)
self.list.setModel(self.model)
self.list.scrollToBottom()
if self.MDILine.hasFocus():
self.select_row('last')
except:
LOG.debug('File path is not valid: {}'.format(fp))
def selectionChanged(self,old, new):
cmd = self.getSelected()
self.MDILine.setText(cmd)
selectionModel = self.list.selectionModel()
if selectionModel.hasSelection():
self.row = selectionModel.currentIndex().row()
def getSelected(self):
selected_indexes = self.list.selectedIndexes()
selected_rows = [item.row() for item in selected_indexes]
# iterates each selected row in descending order
for selected_row in sorted(selected_rows, reverse=True):
text = self.model.item(selected_row).text()
return text
def activated(self):
cmd = self.getSelected()
self.MDILine.setText(cmd)
self.MDILine.submit()
self.select_row('down')
def select_row(self, style):
selectionModel = self.list.selectionModel()
parent = QModelIndex()
self.rows = self.model.rowCount(parent) - 1
if style == 'last':
self.row = self.rows
elif style == 'up':
if self.row > 0:
self.row -= 1
else:
self.row = self.rows
elif style == 'down':
if self.row < self.rows:
self.row += 1
else:
self.row = 0
else:
return
top = self.model.index(self.row, 0, parent)
bottom = self.model.index(self.row, 0, parent)
selectionModel.setCurrentIndex(top, QItemSelectionModel.Select | QItemSelectionModel.Rows)
selection = QItemSelection(top, top)
selectionModel.clearSelection()
selectionModel.select(selection, QItemSelectionModel.Select)
def line_up(self):
self.select_row('up')
def line_down(self):
self.select_row('down')
#########################################################################
# This is how designer can interact with our widget properties.
# designer will show the pyqtProperty properties in the editor
# it will use the get set and reset calls to do those actions
#########################################################################
def set_soft_keyboard(self, data):
self.MDILine.soft_keyboard = data
def get_soft_keyboard(self):
return self.MDILine.soft_keyboard
def reset_soft_keyboard(self):
self.MDILine.soft_keyboard = False
# designer will show these properties in this order:
soft_keyboard_option = pyqtProperty(bool, get_soft_keyboard, set_soft_keyboard, reset_soft_keyboard)
class Chat(QWidget):
msg_signal = pyqtSignal(dict)
after_close = None
chats = []
cur_chat = None
def __init__(self, parent=None):
super().__init__(parent)
self.msg_signal.connect(self.fill_msg)
MsgWorker().do_recv_msg = self.do_recv_msg
self.setWindowTitle('')
self.op_bar = QFrame(self)
self.op_bar.setStyleSheet('background-color:rgb(255, 255, 255);')
self.send_bar = QFrame(self)
self.send_bar.setStyleSheet('background-color:rgb(255, 255, 255);')
self.rcTxt = QTextBrowser(self)
self.rcTxt.setStyleSheet('background-color:rgb(255, 255, 255);')
self.sdTxt = QTextEdit(self)
self.sdTxt.setStyleSheet('background-color:rgb(255, 255, 255);')
self.btn = QPushButton("发送", self.send_bar)
self.btn.clicked.connect(self.send)
self.lv = QListView(self)
self.lv.setViewMode(QListView.ListMode)
self.lv.setIconSize(QSize(30, 30))
self.lv.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.lv.setResizeMode(QListView.Adjust)
self.lv_model = QStandardItemModel()
self.lv.setModel(self.lv_model)
self.lv.clicked.connect(self.lv_clicked)
self.lv.move(0, 0)
w, h = 600, 400
self.resize(800, 600)
def resizeEvent(self, evt):
self.after_resize(evt.size().width(), evt.size().height())
def after_resize(self, w, h):
lv_width = 200
sdTxt_height = 120
bar_height = 30
self.op_bar.move(200, h - sdTxt_height - bar_height * 2)
self.op_bar.resize(w - lv_width, bar_height)
self.send_bar.move(200, h - bar_height)
self.send_bar.resize(w - lv_width, bar_height)
self.lv.resize(lv_width, h)
self.rcTxt.move(lv_width, 0)
self.rcTxt.resize(w - lv_width, h - sdTxt_height - bar_height * 2)
self.sdTxt.move(lv_width, h - sdTxt_height - bar_height)
self.sdTxt.resize(w - lv_width, sdTxt_height)
def lv_clicked(self, model_index):
cur_chat = self.chats[model_index.row()]
if cur_chat['mode'] == 'user':
self.setWindowTitle(cur_chat['data'].nick_name)
def refresh_cur_chat(self):
if self.cur_chat['mode'] == 'user':
self.setWindowTitle(self.cur_chat['data'].nick_name)
def get_in_chat_index(self, chat):
if chat['mode'] == 'user':
name = chat['data'].name
match = lambda x: x['mode'] == 'user' and x['data'].name == name
for i in range(len(self.chats)):
if match(self.chats[i]):
return i
return -1
def chat_to(self, chat):
i = self.get_in_chat_index(chat)
if i == -1:
if chat['mode'] == 'user':
self.lv_model.appendRow(
QStandardItem(QIcon("./client/image/man.png"),
chat['data'].nick_name))
self.chats.append(chat)
self.cur_chat = chat
i = len(self.chats) - 1
else:
self.cur_chat = self.chats[i]
self.refresh_cur_chat()
self.lv.setCurrentIndex(self.lv_model.index(i, 0))
def fill_msg(self, data):
ufrom = data['from']
uto = data['to']
val = data['val']
ufrom_nickname = ufrom
try:
self.rcTxt.setPlainText(self.rcTxt.toPlainText() + '%s:%s\n' %
(ufrom_nickname, val))
except Exception as ex:
print(ex)
def do_recv_msg(self, data):
self.msg_signal.emit(data)
def send(self):
# val = self.sdTxt.toHtml()
val = self.sdTxt.toPlainText()
if self.cur_chat['mode'] == 'user':
MsgWorker().send_msg(
msg_lib.build_chat_msg(MsgWorker().user_info.name,
self.cur_chat['data'].name, val))
# self.rcTxt.setHtml(self.rcTxt.toHtml()+'\n我:%s'%val)
self.rcTxt.setPlainText(self.rcTxt.toPlainText() + '我:%s\n' % val)
self.sdTxt.setPlainText('')
def closeEvent(self, event):
self.chats.clear()
if self.after_close:
self.after_close()
Note2B = QTextEdit()
Note2B.setTabChangesFocus(True)
NotesLayout.addWidget(Note2B)
CreateButton = QPushButton('Save')
CreateButton.clicked.connect(lambda: on_click(0))
NotesLayout.addWidget(CreateButton)
ClearButton = QPushButton('Clear')
ClearButton.clicked.connect(lambda: on_click(1))
NotesLayout.addWidget(ClearButton)
List = QWidget()
List.setObjectName("List")
ListLayout = QGridLayout(List)
NotesListTable = QListView()
NotesListTable.setEditTriggers(QListView.NoEditTriggers)
NotesListTable.setModel(model)
NotesListTable.clicked.connect(lambda: on_select(1))
ListLayout.addWidget(NotesListTable)
NotePreview = QTextBrowser()
ListLayout.addWidget(NotePreview)
EditButton = QPushButton('Edit')
EditButton.clicked.connect(lambda: on_click(2))
ListLayout.addWidget(EditButton)
DeleteButton = QPushButton('Move to Trash')
DeleteButton.clicked.connect(lambda: on_click(3))
ListLayout.addWidget(DeleteButton)
Editor = QWidget()
Editor.setObjectName("Editor")
